schain Commit - r664:9aee9f7a8e3e · Jicamarca Repository

Version 2.1.3: ...

Miguel Valdez -

r664:9aee9f7a8e3e

parent child

Context file:

r664:9aee9f7a8e3e

Collapse all files

schainpy/VERSION +8 -1

             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
-            -jroplot_heispectra.py: SpectraHeisScope was not showing the right channel
+.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.
  No newline at end of file

schainpy/__init__.py +1 -1

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

schainpy/controller.py +2 -3

             '''
             Created on September , 2012
             @author:
             '''
-            from xml.etree.ElementTree import Element, SubElement
+            from xml.etree.ElementTree import ElementTree, Element, SubElement, tostring
-            from xml.etree import ElementTree as ET
             from xml.dom import minidom
             from model import *
             try:
                 from gevent import sleep
             except:
                 from time import sleep
             import ast
             def prettify(elem):
                 """Return a pretty-printed XML string for the Element.
                 """
-                rough_string = ET.tostring(elem, 'utf-8')
+                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
                     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
                     return finalSts
                 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):
                     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 run(self):
                     print
                     print "*"*50
                     print "   Starting SIGNAL CHAIN PROCESSING  "
                     print "*"*50
                     print
                     keyList = self.procUnitConfObjDict.keys()
                     keyList.sort()
                     while(True):
                         finalSts = 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
                         #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"
                 def start(self, filename):
                     self.writeXml(filename)
                     self.readXml(filename)
                     self.createObjects()
                     self.connectObjects()
                     self.run()
             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/gui/viewcontroller/basicwindow.py +20 -24

             # -*- coding: utf-8 -*-
             """
             Module implementing MainWindow.
             #+++++++++++++GUI V1++++++++++++++#
             @author: AlexanderValdezPortocarrero ñ_ñ
             """
             import os, sys, time
             import datetime
             import numpy
             import Queue
             from collections import OrderedDict
             from os.path import  expanduser
             from time import sleep
             # from gevent import sleep
             import ast
             from PyQt4.QtGui           import QMainWindow
             from PyQt4.QtCore          import pyqtSignature
             from PyQt4.QtCore          import pyqtSignal
             from PyQt4                 import QtCore
             from PyQt4                 import QtGui
             # from PyQt4.QtCore          import QThread
             # from PyQt4.QtCore          import QObject, SIGNAL
             from schainpy.gui.viewer.ui_unitprocess import Ui_UnitProcess
             from schainpy.gui.viewer.ui_ftp      import Ui_Ftp
             from schainpy.gui.viewer.ui_mainwindow  import Ui_BasicWindow
             from schainpy.controller_api import ControllerThread
             from schainpy.controller  import Project
             from propertiesViewModel  import TreeModel, PropertyBuffer
             from parametersModel import ProjectParms
             from schainpy.gui.figures import tools
             FIGURES_PATH = tools.get_path()
             TEMPORAL_FILE = ".temp.xml"
             def isRadarFile(file):
                 try:
                     year = int(file[1:5])
                     doy = int(file[5:8])
                     set = int(file[8:11])
                 except:
                     return 0
                 return 1
             def isRadarPath(path):
                 try:
                     year = int(path[1:5])
                     doy = int(path[5:8])
                 except:
                     return 0
                 return 1
             def isInt(value):
                 try:
                     int(value)
                 except:
                     return 0
                 return 1
             def isFloat(value):
                 try:
                     float(value)
                 except:
                     return 0
                 return 1
             def isList(value):
                 x = ast.literal_eval(value)
                 if type(x) in (tuple, list):
                     return 1
                 return 0
             class BasicWindow(QMainWindow, Ui_BasicWindow):
                 """
                 """
                 def __init__(self, parent=None):
                     """
                     """
                     QMainWindow.__init__(self, parent)
                     self.setupUi(self)
                     self.__puObjDict = {}
                     self.__itemTreeDict = {}
                     self.readUnitConfObjList = []
                     self.operObjList = []
                     self.projecObjView = None
                     self.idProject = 0
                     # self.idImag = 0
                     self.idImagscope = 0
                     self.idImagspectra = 0
                     self.idImagcross = 0
                     self.idImagrti = 0
                     self.idImagcoherence = 0
                     self.idImagpower = 0
                     self.idImagrtinoise = 0
                     self.idImagspectraHeis = 0
                     self.idImagrtiHeis = 0
                     self.dataPath = None
                     self.online = 0
                     self.walk = 0
                     self.create = False
                     self.selectedItemTree = None
                     self.controllerThread = None
             #         self.commCtrlPThread = None
             #         self.create_figure()
                     self.temporalFTP = ftpBuffer()
                     self.projectProperCaracteristica = []
                     self.projectProperPrincipal = []
                     self.projectProperDescripcion = []
                     self.volProperCaracteristica = []
                     self.volProperPrincipal = []
                     self.volProperDescripcion = []
                     self.specProperCaracteristica = []
                     self.specProperPrincipal = []
                     self.specProperDescripcion = []
                     self.specHeisProperCaracteristica = []
                     self.specHeisProperPrincipal = []
                     self.specHeisProperDescripcion = []
                     # self.pathWorkSpace = './'
                     self.__projectObjDict = {}
                     self.__operationObjDict = {}
                     self.__puLocalFolder2FTP = {}
                     self.__enable = False
             #         self.create_comm()
                     self.create_updating_timer()
                     self.setGUIStatus()
                 @pyqtSignature("")
                 def on_actionOpen_triggered(self):
                     """
                     Slot documentation goes here.
                     """
                     self.openProject()
                 @pyqtSignature("")
                 def on_actionCreate_triggered(self):
                     """
                     Slot documentation goes here.
                     """
                     self.setInputsProject_View()
                     self.create = True
                 @pyqtSignature("")
                 def on_actionSave_triggered(self):
                     """
                     Slot documentation goes here.
                     """
                     self.saveProject()
                 @pyqtSignature("")
                 def on_actionClose_triggered(self):
                     """
                     Slot documentation goes here.
                     """
                     self.close()
                 @pyqtSignature("")
                 def on_actionStart_triggered(self):
                     """
                     """
                     self.playProject()
                 @pyqtSignature("")
                 def on_actionPause_triggered(self):
                     """
                     """
                     self.pauseProject()
                 @pyqtSignature("")
                 def on_actionStop_triggered(self):
                     """
                     """
                     self.stopProject()
                 @pyqtSignature("")
                 def on_actionAbout_triggered(self):
                     """
                     """
                     self.aboutEvent()
                 @pyqtSignature("")
                 def on_actionFTP_triggered(self):
                     """
                     """
                     self.configFTPWindowObj = Ftp(self)
                     if not self.temporalFTP.create:
                         self.temporalFTP.setwithoutconfiguration()
                     self.configFTPWindowObj.setParmsfromTemporal(self.temporalFTP.server,
                                                                  self.temporalFTP.remotefolder,
                                                                  self.temporalFTP.username,
                                                                  self.temporalFTP.password,
                                                                  self.temporalFTP.ftp_wei,
                                                                  self.temporalFTP.exp_code,
                                                                  self.temporalFTP.sub_exp_code,
                                                                  self.temporalFTP.plot_pos)
                     self.configFTPWindowObj.show()
                     self.configFTPWindowObj.closed.connect(self.createFTPConfig)
                 def createFTPConfig(self):
                     if not self.configFTPWindowObj.create:
                         self.console.clear()
                         self.console.append("There is no FTP configuration")
                         return
                     self.console.append("Push Ok in Spectra view to Add FTP Configuration")
                     server, remotefolder, username, password, ftp_wei, exp_code, sub_exp_code, plot_pos = self.configFTPWindowObj.getParmsFromFtpWindow()
                     self.temporalFTP.save(server=server,
                                           remotefolder=remotefolder,
                                           username=username,
                                           password=password,
                                           ftp_wei=ftp_wei,
                                           exp_code=exp_code,
                                           sub_exp_code=sub_exp_code,
                                           plot_pos=plot_pos)
                 @pyqtSignature("")
                 def on_actionOpenToolbar_triggered(self):
                     """
                     Slot documentation goes here.
                     """
                     self.openProject()
                 @pyqtSignature("")
                 def on_actionCreateToolbar_triggered(self):
                     """
                     Slot documentation goes here.
                     """
                     self.setInputsProject_View()
                     self.create = True
                 @pyqtSignature("")
                 def on_actionAddPU_triggered(self):
                     if len(self.__projectObjDict) == 0:
                         outputstr = "First Create a Project then add Processing Unit"
                         self.console.clear()
                         self.console.append(outputstr)
                         return 0
                     else:
                        self.addPUWindow()
                        self.console.clear()
                        self.console.append("Please, Choose the type of Processing Unit")
                        self.console.append("If your Datatype is rawdata, you will start with processing unit Type Voltage")
                        self.console.append("If your Datatype is pdata, you will choose between processing unit Type Spectra or Correlation")
                        self.console.append("If your Datatype is fits, you will start with processing unit Type SpectraHeis")
                 @pyqtSignature("")
                 def on_actionSaveToolbar_triggered(self):
                     """
                     Slot documentation goes here.
                     """
                     self.saveProject()
                 @pyqtSignature("")
                 def on_actionStarToolbar_triggered(self):
                     """
                     Slot documentation goes here.
                     """
                     self.playProject()
                 @pyqtSignature("")
                 def on_actionPauseToolbar_triggered(self):
                     self.pauseProject()
                 @pyqtSignature("")
                 def on_actionStopToolbar_triggered(self):
                     """
                     Slot documentation goes here.
                     """
                     self.stopProject()
                 @pyqtSignature("int")
                 def on_proComReadMode_activated(self, index):
                     """
                     SELECCION DEL MODO DE LECTURA ON=1, OFF=0
                     """
                     if index == 0:
                        self.online = 0
                        self.proDelay.setText("0")
                        self.proSet.setText("")
                        self.proSet.setEnabled(False)
                        self.proDelay.setEnabled(False)
                     elif index == 1:
                         self.online = 1
                         self.proSet.setText("")
                         self.proDelay.setText("5")
                         self.proSet.setEnabled(True)
                         self.proDelay.setEnabled(True)
                 @pyqtSignature("int")
                 def on_proComDataType_activated(self, index):
                     """
                     Voltage or Spectra
                     """
                     self.labelSet.show()
                     self.proSet.show()
                     self.labExpLabel.show()
                     self.proExpLabel.show()
                     self.labelIPPKm.hide()
                     self.proIPPKm.hide()
                     if index == 0:
                         extension = '.r'
                     elif index == 1:
                         extension = '.pdata'
                     elif index == 2:
                         extension = '.fits'
                     elif index == 3:
                         extension = '.hdf5'
                         self.labelIPPKm.show()
                         self.proIPPKm.show()
                         self.labelSet.hide()
                         self.proSet.hide()
                         self.labExpLabel.hide()
                         self.proExpLabel.hide()
                     self.proDataType.setText(extension)
                 @pyqtSignature("int")
                 def on_proComWalk_activated(self, index):
                     """
                     """
                     if index == 0:
                        self.walk = 0
                     elif index == 1:
                         self.walk = 1
                 @pyqtSignature("")
                 def on_proToolPath_clicked(self):
                     """
                     Choose your path
                     """
                     current_dpath = './'
                     if self.dataPath:
                         current_dpath = self.dataPath
                     datapath = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', current_dpath, QtGui.QFileDialog.ShowDirsOnly))
                     #If it was canceled
                     if not datapath:
                         return
                     #If any change was done
                     if datapath == self.dataPath:
                         return
                     self.proDataPath.setText(datapath)
                     self.actionStart.setEnabled(False)
                     self.actionStarToolbar.setEnabled(False)
                     self.proOk.setEnabled(False)
                     self.proComStartDate.clear()
                     self.proComEndDate.clear()
                     if not os.path.exists(datapath):
                         self.console.clear()
                         self.console.append("Write a valid path")
                         return
                     self.dataPath = datapath
                     self.console.clear()
                     self.console.append("Select the read mode and press 'load button'")
                 @pyqtSignature("")
                 def on_proLoadButton_clicked(self):
                     self.console.clear()
             #         if not self.getSelectedProjectObj():
             #             self.console.append("Please select a project before load files")
             #             return
                     parameter_list = self.checkInputsProject()
                     if not parameter_list[0]:
                         return
                     parms_ok, project_name, datatype, ext, data_path, read_mode, delay, walk, set, expLabel = parameter_list
                     if read_mode == "Offline":
                         self.proComStartDate.clear()
                         self.proComEndDate.clear()
                         self.proComStartDate.setEnabled(True)
                         self.proComEndDate.setEnabled(True)
                         self.proStartTime.setEnabled(True)
                         self.proEndTime.setEnabled(True)
                         self.frame_2.setEnabled(True)
                     if read_mode == "Online":
                         self.proComStartDate.addItem("1960/01/30")
                         self.proComEndDate.addItem("2018/12/31")
                         self.proComStartDate.setEnabled(False)
                         self.proComEndDate.setEnabled(False)
                         self.proStartTime.setEnabled(False)
                         self.proEndTime.setEnabled(False)
                         self.frame_2.setEnabled(True)
                     self.loadDays(data_path, ext, walk, expLabel)
                 @pyqtSignature("int")
                 def on_proComStartDate_activated(self, index):
                     """
                     SELECCION DEL RANGO DE FECHAS -START DATE
                     """
                     stopIndex = self.proComEndDate.count() - self.proComEndDate.currentIndex() - 1
                     self.proComEndDate.clear()
                     for i in self.dateList[index:]:
                         self.proComEndDate.addItem(i)
                     if self.proComEndDate.count() - stopIndex - 1 >= 0:
                         self.proComEndDate.setCurrentIndex(self.proComEndDate.count() - stopIndex - 1)
                     else:
                         self.proComEndDate.setCurrentIndex(self.proComEndDate.count() - 1)
                 @pyqtSignature("int")
                 def on_proComEndDate_activated(self, index):
                     """
                     SELECCION DEL RANGO DE FECHAS-END DATE
                     """
                     pass
                 @pyqtSignature("")
                 def on_proOk_clicked(self):
                     """
                     Añade al Obj XML de Projecto, name,datatype,date,time,readmode,wait,etc, crea el readUnitProcess del archivo xml.
                     Prepara la configuración del diágrama del Arbol del treeView numero 2
                     """
                     self.actionStart.setEnabled(False)
                     self.actionStarToolbar.setEnabled(False)
                     self.console.clear()
                     if self.create:
                         projectId = self.__getNewProjectId()
                         if not projectId:
                             return 0
                         projectObjView = self.createProjectView(projectId)
                         if not projectObjView:
                             return 0
                         self.create = False
                         readUnitObj = self.createReadUnitView(projectObjView)
                         if not readUnitObj:
                             return 0
                     else:
                         projectObjView = self.updateProjectView()
                         if not projectObjView:
                             return 0
                         projectId = projectObjView.getId()
                         idReadUnit = projectObjView.getReadUnitId()
                         readUnitObj = self.updateReadUnitView(projectObjView, idReadUnit)
                         if not readUnitObj:
                             return 0
                         self.__itemTreeDict[projectId].setText(projectObjView.name)
                     # Project Properties
                     self.refreshProjectProperties(projectObjView)
                     # Disable tabProject after finish the creation
                     self.actionStart.setEnabled(True)
                     self.actionStarToolbar.setEnabled(True)
                     self.console.clear()
                     self.console.append("The project parameters were validated")
                     return 1
                 @pyqtSignature("")
                 def on_proClear_clicked(self):
                     self.console.clear()
                 @pyqtSignature("int")
                 def on_volOpCebChannels_stateChanged(self, p0):
                     """
                     Check Box habilita operaciones de Selecci�n de Canales
                     """
                     if  p0 == 2:
                         self.volOpComChannels.setEnabled(True)
                         self.volOpChannel.setEnabled(True)
                     if  p0 == 0:
                         self.volOpComChannels.setEnabled(False)
                         self.volOpChannel.setEnabled(False)
                         self.volOpChannel.clear()
                 @pyqtSignature("int")
                 def on_volOpCebHeights_stateChanged(self, p0):
                     """
                     Check Box habilita operaciones de Selecci�n de Alturas
                     """
                     if  p0 == 2:
                         self.volOpHeights.setEnabled(True)
                         self.volOpComHeights.setEnabled(True)
                     if  p0 == 0:
                         self.volOpHeights.setEnabled(False)
                         self.volOpHeights.clear()
                         self.volOpComHeights.setEnabled(False)
                 @pyqtSignature("int")
                 def on_volOpCebFilter_stateChanged(self, p0):
                      """
                      Name='Decoder', optype='other'
                      """
                      if  p0 == 2:
                         self.volOpFilter.setEnabled(True)
                      if  p0 == 0:
                         self.volOpFilter.setEnabled(False)
                         self.volOpFilter.clear()
                 @pyqtSignature("int")
                 def on_volOpCebProfile_stateChanged(self, p0):
                     """
                     Check Box habilita ingreso  del rango de Perfiles
                     """
                     if  p0 == 2:
                         self.volOpComProfile.setEnabled(True)
                         self.volOpProfile.setEnabled(True)
                     if  p0 == 0:
                         self.volOpComProfile.setEnabled(False)
                         self.volOpProfile.setEnabled(False)
                         self.volOpProfile.clear()
                 @pyqtSignature("int")
                 def on_volOpComProfile_activated(self, index):
                     """
                     Check Box habilita ingreso  del rango de Perfiles
                     """
                     #Profile List
                     if  index == 0:
                         self.volOpProfile.setToolTip('List of selected profiles. Example: 0, 1, 2, 3, 4, 5, 6, 7')
                     #Profile Range
                     if  index == 1:
                         self.volOpProfile.setToolTip('Minimum and maximum profile index. Example: 0, 7')
                     #Profile Range List
                     if index == 2:
                         self.volOpProfile.setToolTip('List of profile ranges. Example: (0, 7), (12, 19), (100, 200)')
                 @pyqtSignature("int")
                 def on_volOpCebDecodification_stateChanged(self, p0):
                     """
                     Check Box habilita
                     """
                     if  p0 == 2:
                         self.volOpComCode.setEnabled(True)
                         self.volOpComMode.setEnabled(True)
                     if  p0 == 0:
                         self.volOpComCode.setEnabled(False)
                         self.volOpComMode.setEnabled(False)
                 @pyqtSignature("int")
                 def on_volOpComCode_activated(self, index):
                     """
                     Check Box habilita ingreso
                     """
                     if  index == 13:
                         self.volOpCode.setEnabled(True)
                     else:
                         self.volOpCode.setEnabled(False)
                         if index == 0:
                             code = ''
                             self.volOpCode.setText(str(code))
                             return
                         if index == 1:
                             code = '(1,1,-1)'
                             nCode = '1'
                             nBaud = '3'
                         if index == 2:
                             code = '(1,1,-1,1)'
                             nCode = '1'
                             nBaud = '4'
                         if index == 3:
                             code = '(1,1,1,-1,1)'
                             nCode = '1'
                             nBaud = '5'
                         if index == 4:
                             code = '(1,1,1,-1,-1,1,-1)'
                             nCode = '1'
                             nBaud = '7'
                         if index == 5:
                             code = '(1,1,1,-1,-1,-1,1,-1,-1,1,-1)'
                             nCode = '1'
                             nBaud = '11'
                         if index == 6:
                             code = '(1,1,1,1,1,-1,-1,1,1,-1,1,-1,1)'
                             nCode = '1'
                             nBaud = '13'
                         if index == 7:
                             code = '(1,1,-1,-1,-1,1)'
                             nCode = '2'
                             nBaud = '3'
                         if index == 8:
                             code = '(1,1,-1,1,-1,-1,1,-1)'
                             nCode = '2'
                             nBaud = '4'
                         if index == 9:
                             code = '(1,1,1,-1,1,-1,-1,-1,1,-1)'
                             nCode = '2'
                             nBaud = '5'
                         if index == 10:
                             code = '(1,1,1,-1,-1,1,-1,-1,-1,-1,1,1,-1,1)'
                             nCode = '2'
                             nBaud = '7'
                         if index == 11:
                             code = '(1,1,1,-1,-1,-1,1,-1,-1,1,-1,-1 ,-1 ,-1 ,1 ,1,1,-1 ,1 ,1 ,-1 ,1)'
                             nCode = '2'
                             nBaud = '11'
                         if index == 12:
                             code = '(1,1,1,1,1,-1,-1,1,1,-1,1,-1,1,-1,-1,-1,-1,-1,1,1,-1,-1,1,-1,1,-1)'
                             nCode = '2'
                             nBaud = '13'
                         code = ast.literal_eval(code)
                         nCode = int(nCode)
                         nBaud = int(nBaud)
                         code = numpy.asarray(code).reshape((nCode, nBaud)).tolist()
                         self.volOpCode.setText(str(code))
                 @pyqtSignature("int")
                 def on_volOpCebFlip_stateChanged(self, p0):
                     """
                     Check Box habilita ingresode del numero de Integraciones a realizar
                     """
                     if  p0 == 2:
                         self.volOpFlip.setEnabled(True)
                     if  p0 == 0:
                         self.volOpFlip.setEnabled(False)
                         self.volOpFlip.clear()
                 @pyqtSignature("int")
                 def on_volOpCebCohInt_stateChanged(self, p0):
                     """
                     Check Box habilita ingresode del numero de Integraciones a realizar
                     """
                     if  p0 == 2:
                         self.volOpCohInt.setEnabled(True)
                     if  p0 == 0:
                         self.volOpCohInt.setEnabled(False)
                         self.volOpCohInt.clear()
                 @pyqtSignature("int")
                 def on_volOpCebRadarfrequency_stateChanged(self, p0):
                     """
                     Check Box habilita ingresode del numero de Integraciones a realizar
                     """
                     if  p0 == 2:
                         self.volOpRadarfrequency.setEnabled(True)
                     if  p0 == 0:
                         self.volOpRadarfrequency.clear()
                         self.volOpRadarfrequency.setEnabled(False)
                 @pyqtSignature("")
                 def on_volOutputToolPath_clicked(self):
                     dirOutPath = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly))
                     self.volOutputPath.setText(dirOutPath)
                 @pyqtSignature("")
                 def on_specOutputToolPath_clicked(self):
                     dirOutPath = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly))
                     self.specOutputPath.setText(dirOutPath)
                 @pyqtSignature("")
                 def on_specHeisOutputToolPath_clicked(self):
                     dirOutPath = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly))
                     self.specHeisOutputPath.setText(dirOutPath)
                 @pyqtSignature("")
                 def on_specHeisOutputMetadaToolPath_clicked(self):
                     filename = str(QtGui.QFileDialog.getOpenFileName(self, "Open text file", self.pathWorkSpace, self.tr("Text Files (*.xml)")))
                     self.specHeisOutputMetada.setText(filename)
                 @pyqtSignature("")
                 def on_volOpOk_clicked(self):
                     """
                     BUSCA EN LA LISTA DE OPERACIONES DEL TIPO VOLTAJE Y LES A�ADE EL PARAMETRO ADECUADO ESPERANDO LA ACEPTACION DEL USUARIO
                     PARA AGREGARLO AL ARCHIVO DE CONFIGURACION XML
                     """
                     checkPath = False
                     self.actionSaveToolbar.setEnabled(False)
                     self.actionStarToolbar.setEnabled(False)
                     self.console.clear()
                     self.console.append("Checking input parameters ...")
                     puObj = self.getSelectedItemObj()
                     puObj.removeOperations()
                     if self.volOpCebRadarfrequency.isChecked():
                         value = str(self.volOpRadarfrequency.text())
                         format = 'float'
                         name_operation = 'setRadarFrequency'
                         name_parameter = 'frequency'
                         if not value == "":
                             try:
                                 radarfreq = float(self.volOpRadarfrequency.text())*1e6
                             except:
                                 self.console.clear()
                                 self.console.append("Invalid value '%s' for Radar Frequency" %value)
                                 return 0
                             opObj = puObj.addOperation(name=name_operation)
                             if not opObj.addParameter(name=name_parameter, value=radarfreq, format=format):
                                 self.console.append("Invalid value '%s' for %s" %(value,name_parameter))
                                 return 0
                     if self.volOpCebChannels.isChecked():
                         value = str(self.volOpChannel.text())
                         if value == "":
                             print "Please fill channel list"
                             return 0
                         format = 'intlist'
                         if self.volOpComChannels.currentIndex() == 0:
                             name_operation = "selectChannels"
                             name_parameter = 'channelList'
                         else:
                             name_operation = "selectChannelsByIndex"
                             name_parameter = 'channelIndexList'
                         opObj = puObj.addOperation(name=name_operation)
                         if not opObj.addParameter(name=name_parameter, value=value, format=format):
                             self.console.append("Invalid value '%s' for %s" %(value,name_parameter))
                             return 0
                     if self.volOpCebHeights.isChecked():
                        value = str(self.volOpHeights.text())
                        if value == "":
                             print "Please fill height range"
                             return 0
                        valueList = value.split(',')
                        format = 'float'
                        if  self.volOpComHeights.currentIndex() == 0:
                            name_operation = 'selectHeights'
                            name_parameter1 = 'minHei'
                            name_parameter2 = 'maxHei'
                        else:
                            name_operation = 'selectHeightsByIndex'
                            name_parameter1 = 'minIndex'
                            name_parameter2 = 'maxIndex'
                        opObj = puObj.addOperation(name=name_operation)
                        opObj.addParameter(name=name_parameter1, value=valueList[0], format=format)
                        opObj.addParameter(name=name_parameter2, value=valueList[1], format=format)
                     if self.volOpCebFilter.isChecked():
                        value = str(self.volOpFilter.text())
                        if value == "":
                             print "Please fill filter value"
                             return 0
                        format = 'int'
                        name_operation = 'filterByHeights'
                        name_parameter = 'window'
                        opObj = puObj.addOperation(name=name_operation)
                        if not opObj.addParameter(name=name_parameter, value=value, format=format):
                             self.console.append("Invalid value '%s' for %s" %(value,name_parameter))
                             return 0
                     if self.volOpCebProfile.isChecked():
                         value = str(self.volOpProfile.text())
                         if value == "":
                             print "Please fill profile value"
                             return 0
                         format = 'intlist'
                         optype = 'other'
                         name_operation = 'ProfileSelector'
                         if self.volOpComProfile.currentIndex() == 0:
                             name_parameter = 'profileList'
                         if self.volOpComProfile.currentIndex() == 1:
                             name_parameter = 'profileRangeList'
                         if self.volOpComProfile.currentIndex() == 2:
                             name_parameter = 'rangeList'
                         opObj = puObj.addOperation(name='ProfileSelector', optype='other')
                         if not opObj.addParameter(name=name_parameter, value=value, format=format):
                             self.console.append("Invalid value '%s' for %s" %(value,name_parameter))
                             return 0
                     if self.volOpCebDecodification.isChecked():
                         name_operation = 'Decoder'
                         opObj = puObj.addOperation(name=name_operation, optype='other')
                         #User defined
                         nBaud = None
                         nCode = None
                         code = str(self.volOpCode.text())
                         try:
                             code_tmp = ast.literal_eval(code)
                         except:
                             code_tmp = []
                         if len(code_tmp) > 0:
                             if type(code_tmp) not in (tuple, list):
                                 self.console.append("Please write a right value for Code (Exmaple: [1,1,-1], [1,-1,1])")
                                 return 0
                             if len(code_tmp) > 1 and type(code_tmp[0]) in (tuple, list): #[ [1,-1,1], [1,1,-1] ]
                                 nBaud = len(code_tmp[0])
                                 nCode = len(code_tmp)
                             elif len(code_tmp) == 1 and type(code_tmp[0]) in (tuple, list): #[ [1,-1,1] ]
                                 nBaud = len(code_tmp[0])
                                 nCode = 1
                             elif type(code_tmp[0]) in (int, float): #[1,-1,1]  or (1,-1,1)
                                 nBaud = len(code_tmp)
                                 nCode = 1
                             else:
                                 self.console.append("Please write a right value for Code (Exmaple: [1,1,-1], [1,-1,1])")
                                 return 0
                             if not nBaud or not nCode:
                                 self.console.append("Please write a right value for Code")
                                 return 0
                             code = code.replace("(", "")
                             code = code.replace(")", "")
                             code = code.replace("[", "")
                             code = code.replace("]", "")
                             if not opObj.addParameter(name='code', value=code, format='intlist'):
                                 self.console.append("Please write a right value for Code")
                                 return 0
                             if not opObj.addParameter(name='nCode', value=nCode, format='int'):
                                 self.console.append("Please write a right value for Code")
                                 return 0
                             if not opObj.addParameter(name='nBaud', value=nBaud, format='int'):
                                 self.console.append("Please write a right value for Code")
                                 return 0
                         name_parameter = 'mode'
                         format = 'int'
                         value = str(self.volOpComMode.currentIndex())
                         if not opObj.addParameter(name=name_parameter, value=value, format=format):
                             self.console.append("Invalid value '%s' for '%s'" %(value,name_parameter))
                             return 0
                     if self.volOpCebFlip.isChecked():
                         name_operation = 'deFlip'
                         optype = 'self'
                         opObj = puObj.addOperation(name=name_operation, optype=optype)
                         name_parameter = 'channelList'
                         format = 'intlist'
                         value = str(self.volOpFlip.text())
                         if value != "":
                             if not opObj.addParameter(name=name_parameter, value=value, format=format):
                                 self.console.append("Invalid value '%s' for '%s'" %(value,name_parameter))
                                 return 0
                     if self.volOpCebCohInt.isChecked():
                         name_operation = 'CohInt'
                         optype = 'other'
                         value = str(self.volOpCohInt.text())
                         if value == "":
                             print "Please fill number of coherent integrations"
                             return 0
                         name_parameter = 'n'
                         format = 'float'
                         opObj = puObj.addOperation(name=name_operation, optype=optype)
                         if not opObj.addParameter(name=name_parameter, value=value, format=format):
                             self.console.append("Invalid value '%s' for '%s'" %(value,name_parameter))
                             return 0
                     if self.volGraphCebshow.isChecked():
                         name_operation = 'Scope'
                         optype = 'other'
                         name_parameter = 'type'
                         value = 'Scope'
                         if self.idImagscope == 0:
                             self.idImagscope = 100
                         else:
                             self.idImagscope = self.idImagscope + 1
                         name_parameter1 = 'id'
                         value1 = int(self.idImagscope)
                         format1 = 'int'
                         format = 'str'
                         opObj = puObj.addOperation(name=name_operation, optype=optype)
             #             opObj.addParameter(name=name_parameter, value=value, format=format)
                         opObj.addParameter(name=name_parameter1, value=opObj.id, format=format1)
                         channelList = str(self.volGraphChannelList.text()).replace(" ","")
                         xvalue = str(self.volGraphfreqrange.text()).replace(" ","")
                         yvalue = str(self.volGraphHeightrange.text()).replace(" ","")
                         if channelList:
                             opObj.addParameter(name='channelList', value=channelList, format='intlist')
                         if xvalue:
                             xvalueList = xvalue.split(',')
                             try:
                                value0 = float(xvalueList[0])
                                value1 = float(xvalueList[1])
                             except:
                                 return 0
                             opObj.addParameter(name='xmin', value=value0, format='float')
                             opObj.addParameter(name='xmax', value=value1, format='float')
                         if not yvalue == "":
                            yvalueList = yvalue.split(",")
                            try:
                                value0 = int(yvalueList[0])
                                value1 = int(yvalueList[1])
                            except:
                                 return 0
                            opObj.addParameter(name='ymin', value=value0, format='int')
                            opObj.addParameter(name='ymax', value=value1, format='int')
                         if self.volGraphCebSave.isChecked():
                             checkPath = True
                             opObj.addParameter(name='save', value='1', format='int')
                             opObj.addParameter(name='figpath', value=str(self.volGraphPath.text()), format='str')
                             value = str(self.volGraphPrefix.text()).replace(" ","")
                             if value:
                                opObj.addParameter(name='figfile', value=value, format='str')
                     localfolder = None
                     if checkPath:
                         localfolder = str(self.volGraphPath.text())
                         if localfolder == '':
                             self.console.clear()
                             self.console.append("Graphic path should be defined")
                             return 0
                     # if something happend
                     parms_ok, output_path, blocksperfile, profilesperblock = self.checkInputsPUSave(datatype='Voltage')
                     if parms_ok:
                         name_operation = 'VoltageWriter'
                         optype = 'other'
                         name_parameter1 = 'path'
                         name_parameter2 = 'blocksPerFile'
                         name_parameter3 = 'profilesPerBlock'
                         value1 = output_path
                         value2 = blocksperfile
                         value3 = profilesperblock
                         format = "int"
                         opObj = puObj.addOperation(name=name_operation, optype=optype)
                         opObj.addParameter(name=name_parameter1, value=value1)
                         opObj.addParameter(name=name_parameter2, value=value2, format=format)
                         opObj.addParameter(name=name_parameter3, value=value3, format=format)
                     self.console.clear()
                     try:
                         self.refreshPUProperties(puObj)
                     except:
                         self.console.append("An error reading input parameters was found ...Check them!")
                         return 0
                     self.console.append("Save your project and press Play button to start signal processing")
                     self.actionSaveToolbar.setEnabled(True)
                     self.actionStarToolbar.setEnabled(True)
                     return 1
                 """
                 Voltage Graph
                 """
                 @pyqtSignature("int")
                 def on_volGraphCebSave_stateChanged(self, p0):
                     """
                     Check Box habilita ingresode del numero de Integraciones a realizar
                     """
                     if  p0 == 2:
                         self.volGraphPath.setEnabled(True)
                         self.volGraphPrefix.setEnabled(True)
                         self.volGraphToolPath.setEnabled(True)
                     if  p0 == 0:
                         self.volGraphPath.setEnabled(False)
                         self.volGraphPrefix.setEnabled(False)
                         self.volGraphToolPath.setEnabled(False)
                 @pyqtSignature("")
                 def on_volGraphToolPath_clicked(self):
                     """
                     Donde se guardan los DATOS
                     """
                     save_path = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly))
                     self.volGraphPath.setText(save_path)
                     if not os.path.exists(save_path):
                         self.console.clear()
                         self.console.append("Set a valid path")
                         self.volGraphOk.setEnabled(False)
                         return
                 @pyqtSignature("int")
                 def on_volGraphCebshow_stateChanged(self, p0):
                     """
                     Check Box habilita ingresode del numero de Integraciones a realizar
                     """
                     if p0 == 0:
                        self.volGraphChannelList.setEnabled(False)
                        self.volGraphfreqrange.setEnabled(False)
                        self.volGraphHeightrange.setEnabled(False)
                     if p0 == 2:
                        self.volGraphChannelList.setEnabled(True)
                        self.volGraphfreqrange.setEnabled(True)
                        self.volGraphHeightrange.setEnabled(True)
                 """
                 Spectra operation
                 """
                 @pyqtSignature("int")
                 def on_specOpCebRadarfrequency_stateChanged(self, p0):
                     """
                     Check Box habilita ingresode del numero de Integraciones a realizar
                     """
                     if  p0 == 2:
                         self.specOpRadarfrequency.setEnabled(True)
                     if  p0 == 0:
                         self.specOpRadarfrequency.clear()
                         self.specOpRadarfrequency.setEnabled(False)
                 @pyqtSignature("int")
                 def on_specOpCebCrossSpectra_stateChanged(self, p0):
                     """
                     Habilita la opcion de a�adir el par�metro CrossSpectra a la Unidad de Procesamiento .
                     """
                     if  p0 == 2:
                       #  self.specOpnFFTpoints.setEnabled(True)
                         self.specOppairsList.setEnabled(True)
                     if  p0 == 0:
                       #  self.specOpnFFTpoints.setEnabled(False)
                         self.specOppairsList.setEnabled(False)
                 @pyqtSignature("int")
                 def on_specOpCebChannel_stateChanged(self, p0):
                     """
                     Habilita la opcion de a�adir el par�metro numero de Canales a la Unidad de Procesamiento .
                     """
                     if  p0 == 2:
                         self.specOpChannel.setEnabled(True)
                         self.specOpComChannel.setEnabled(True)
                     if  p0 == 0:
                         self.specOpChannel.setEnabled(False)
                         self.specOpComChannel.setEnabled(False)
                 @pyqtSignature("int")
                 def on_specOpCebHeights_stateChanged(self, p0):
                     """
                     Habilita la opcion de a�adir el par�metro de alturas a la Unidad de Procesamiento .
                     """
                     if  p0 == 2:
                         self.specOpComHeights.setEnabled(True)
                         self.specOpHeights.setEnabled(True)
                     if  p0 == 0:
                         self.specOpComHeights.setEnabled(False)
                         self.specOpHeights.setEnabled(False)
                 @pyqtSignature("int")
                 def on_specOpCebIncoherent_stateChanged(self, p0):
                     """
                     Habilita la opcion de a�adir el par�metro integraciones incoherentes a la Unidad de Procesamiento .
                     """
                     if  p0 == 2:
                         self.specOpIncoherent.setEnabled(True)
                     if  p0 == 0:
                         self.specOpIncoherent.setEnabled(False)
                 @pyqtSignature("int")
                 def on_specOpCebRemoveDC_stateChanged(self, p0):
                     """
                     Habilita la opcion de a�adir el par�metro remover DC a la Unidad de Procesamiento .
                     """
                     if  p0 == 2:
                         self.specOpComRemoveDC.setEnabled(True)
                     if  p0 == 0:
                         self.specOpComRemoveDC.setEnabled(False)
                 @pyqtSignature("int")
                 def on_specOpCebgetNoise_stateChanged(self, p0):
                     """
                     Habilita la opcion de a�adir la estimacion de ruido a la Unidad de Procesamiento .
                     """
                     if  p0 == 2:
                         self.specOpgetNoise.setEnabled(True)
                     if  p0 == 0:
                         self.specOpgetNoise.setEnabled(False)
                 @pyqtSignature("")
                 def on_specOpOk_clicked(self):
                     """
                     AÑADE OPERACION SPECTRA
                     """
                     addFTP = False
                     checkPath = False
                     self.actionSaveToolbar.setEnabled(False)
                     self.actionStarToolbar.setEnabled(False)
                     self.console.clear()
                     self.console.append("Checking input parameters ...")
                     projectObj = self.getSelectedProjectObj()
                     if not projectObj:
                         self.console.append("Please select a project before update it")
                         return
                     puObj = self.getSelectedItemObj()
                     puObj.removeOperations()
                     if self.specOpCebRadarfrequency.isChecked():
                         value = str(self.specOpRadarfrequency.text())
                         format = 'float'
                         name_operation = 'setRadarFrequency'
                         name_parameter = 'frequency'
                         if not isFloat(value):
                             self.console.clear()
                             self.console.append("Invalid value '%s' for '%s'" %(value, name_parameter))
                             return 0
                         radarfreq = float(value)*1e6
                         opObj = puObj.addOperation(name=name_operation)
                         opObj.addParameter(name=name_parameter, value=radarfreq, format=format)
                     inputId = puObj.getInputId()
                     inputPuObj = projectObj.getProcUnitObj(inputId)
                     if inputPuObj.datatype == 'Voltage' or inputPuObj.datatype == 'USRP':
                         value = str(self.specOpnFFTpoints.text())
                         if not isInt(value):
                             self.console.append("Invalid value '%s' for '%s'" %(value, 'nFFTPoints'))
                             return 0
                         puObj.addParameter(name='nFFTPoints', value=value, format='int')
                         value = str(self.specOpProfiles.text())
                         if not isInt(value):
                             self.console.append("Please write a value on Profiles field")
                         else:
                             puObj.addParameter(name='nProfiles', value=value, format='int')
                         value = str(self.specOpippFactor.text())
                         if not isInt(value):
                             self.console.append("Please write a value on IppFactor field")
                         else:
                             puObj.addParameter(name='ippFactor' , value=value , format='int')
                     if self.specOpCebCrossSpectra.isChecked():
                         name_parameter = 'pairsList'
                         format = 'pairslist'
                         value = str(self.specOppairsList.text())
                         if value == "":
                             print "Please fill the pairs list field"
                             return 0
                         if not opObj.addParameter(name=name_parameter, value=value, format=format):
                             self.console.append("Invalid value '%s' for '%s'" %(value,name_parameter))
                             return 0
                     if self.specOpCebHeights.isChecked():
                         value = str(self.specOpHeights.text())
                         if value == "":
                             self.console.append("Empty value for '%s'" %(value, "Height range"))
                             return 0
                         valueList = value.split(',')
                         format = 'float'
                         value0 = valueList[0]
                         value1 = valueList[1]
                         if not isFloat(value0) or not isFloat(value1):
                             self.console.append("Invalid value '%s' for '%s'" %(value, "Height range"))
                             return 0
                         if self.specOpComHeights.currentIndex() == 0:
                             name_operation = 'selectHeights'
                             name_parameter1 = 'minHei'
                             name_parameter2 = 'maxHei'
                         else:
                             name_operation = 'selectHeightsByIndex'
                             name_parameter1 = 'minIndex'
                             name_parameter2 = 'maxIndex'
                         opObj = puObj.addOperation(name=name_operation)
                         opObj.addParameter(name=name_parameter1, value=value0, format=format)
                         opObj.addParameter(name=name_parameter2, value=value1, format=format)
                     if self.specOpCebChannel.isChecked():
                         if self.specOpComChannel.currentIndex() == 0:
                             name_operation = "selectChannels"
                             name_parameter = 'channelList'
                         else:
                             name_operation = "selectChannelsByIndex"
                             name_parameter = 'channelIndexList'
                         format = 'intlist'
                         value = str(self.specOpChannel.text())
                         if value == "":
                             print "Please fill channel list"
                             return 0
                         if not isList(value):
                             self.console.append("Invalid value '%s' for '%s'" %(value, name_parameter))
                             return 0
                         opObj = puObj.addOperation(name=name_operation)
                         opObj.addParameter(name=name_parameter, value=value, format=format)
                     if self.specOpCebIncoherent.isChecked():
                         name_operation = 'IncohInt'
                         optype = 'other'
                         if self.specOpCobIncInt.currentIndex() == 0:
                             name_parameter = 'timeInterval'
                             format = 'float'
                         else:
                             name_parameter = 'n'
                             format = 'float'
                         value = str(self.specOpIncoherent.text())
                         if value == "":
                             print "Please fill Incoherent integration value"
                             return 0
                         if not isFloat(value):
                             self.console.append("Invalid value '%s' for '%s'" %(value, name_parameter))
                             return 0
                         opObj = puObj.addOperation(name=name_operation, optype=optype)
                         opObj.addParameter(name=name_parameter, value=value, format=format)
                     if self.specOpCebRemoveDC.isChecked():
                         name_operation = 'removeDC'
                         name_parameter = 'mode'
                         format = 'int'
                         if self.specOpComRemoveDC.currentIndex() == 0:
                             value = 1
                         else:
                             value = 2
                         opObj = puObj.addOperation(name=name_operation)
                         opObj.addParameter(name=name_parameter, value=value, format=format)
                     if self.specOpCebRemoveInt.isChecked():
                         name_operation = 'removeInterference'
                         opObj = puObj.addOperation(name=name_operation)
                     if self.specOpCebgetNoise.isChecked():
                         value = str(self.specOpgetNoise.text())
                         valueList = value.split(',')
                         format = 'float'
                         name_operation = "getNoise"
                         opObj = puObj.addOperation(name=name_operation)
                         if not value == '':
                            valueList = value.split(',')
                            length = len(valueList)
                            if length == 1:
                                try:
                                    value1 = float(valueList[0])
                                except:
                                    self.console.clear()
                                    self.console.append("Please Write  correct parameter Get Noise")
                                    return 0
                                name1 = 'minHei'
                                opObj.addParameter(name=name1, value=value1, format=format)
                            elif length == 2:
                                try:
                                    value1 = float(valueList[0])
                                    value2 = float(valueList[1])
                                except:
                                    self.console.clear()
                                    self.console.append("Please Write  corrects parameter Get Noise")
                                    return 0
                                name1 = 'minHei'
                                name2 = 'maxHei'
                                opObj.addParameter(name=name1, value=value1, format=format)
                                opObj.addParameter(name=name2, value=value2, format=format)
                            elif length == 3:
                                try:
                                    value1 = float(valueList[0])
                                    value2 = float(valueList[1])
                                    value3 = float(valueList[2])
                                except:
                                    self.console.clear()
                                    self.console.append("Please Write  corrects parameter Get Noise")
                                    return 0
                                name1 = 'minHei'
                                name2 = 'maxHei'
                                name3 = 'minVel'
                                opObj.addParameter(name=name1, value=value1, format=format)
                                opObj.addParameter(name=name2, value=value2, format=format)
                                opObj.addParameter(name=name3, value=value3, format=format)
                            elif length == 4:
                                try:
                                    value1 = float(valueList[0])
                                    value2 = float(valueList[1])
                                    value3 = float(valueList[2])
                                    value4 = float(valueList[3])
                                except:
                                    self.console.clear()
                                    self.console.append("Please Write  corrects parameter Get Noise")
                                    return 0
                                name1 = 'minHei'
                                name2 = 'maxHei'
                                name3 = 'minVel'
                                name4 = 'maxVel'
                                opObj.addParameter(name=name1, value=value1, format=format)
                                opObj.addParameter(name=name2, value=value2, format=format)
                                opObj.addParameter(name=name3, value=value3, format=format)
                                opObj.addParameter(name=name4, value=value4, format=format)
                            elif length > 4:
                                self.console.clear()
                                self.console.append("Get Noise Operation only accepts  4 parameters")
                                return 0
                     channelList = str(self.specGgraphChannelList.text()).replace(" ","")
                     vel_range = str(self.specGgraphFreq.text()).replace(" ","")
                     hei_range = str(self.specGgraphHeight.text()).replace(" ","")
                     db_range = str(self.specGgraphDbsrange.text()).replace(" ","")
                     trange = str(self.specGgraphTminTmax.text()).replace(" ","")
                     magrange = str(self.specGgraphmagnitud.text()).replace(" ","")
                     phaserange = str(self.specGgraphPhase.text()).replace(" ","")
             #         timerange = str(self.specGgraphTimeRange.text()).replace(" ","")
                     figpath = str(self.specGraphPath.text())
                     figfile = str(self.specGraphPrefix.text()).replace(" ","")
                     try:
                         wrperiod = int(str(self.specGgraphftpratio.text()).replace(" ",""))
                     except:
                         wrperiod = None
                     #-----Spectra Plot-----
                     if self.specGraphCebSpectraplot.isChecked():
                         opObj = puObj.addOperation(name='SpectraPlot', optype='other')
                         opObj.addParameter(name='id', value=opObj.id, format='int')
                         if not channelList == '':
                             if not isList(channelList):
                                 self.console.append("Invalid channelList")
                                 return 0
                             opObj.addParameter(name='channelList', value=channelList, format='intlist')
                         if not vel_range == '':
                            xvalueList = vel_range.split(',')
                            try:
                                value1 = float(xvalueList[0])
                                value2 = float(xvalueList[1])
                            except:
                                self.console.clear()
                                self.console.append("Invalid velocity/frequency range")
                                return 0
                            opObj.addParameter(name='xmin', value=value1, format='float')
                            opObj.addParameter(name='xmax', value=value2, format='float')
                         if not hei_range == '':
                           yvalueList = hei_range.split(",")
                           try:
                                value1 = float(yvalueList[0])
                                value2 = float(yvalueList[1])
                           except:
                               self.console.clear()
                               self.console.append("Invalid height range")
                               return 0
                           opObj.addParameter(name='ymin', value=value1, format='float')
                           opObj.addParameter(name='ymax', value=value2, format='float')
                         if not db_range == '':
                             zvalueList = db_range.split(",")
                             try:
                                value1 = float(zvalueList[0])
                                value2 = float(zvalueList[1])
                             except:
                                self.console.clear()
                                self.console.append("Invalid db range")
                                return 0
                             opObj.addParameter(name='zmin', value=value1, format='float')
                             opObj.addParameter(name='zmax', value=value2, format='float')
                         if self.specGraphSaveSpectra.isChecked():
                             checkPath = True
                             opObj.addParameter(name='save', value=1 , format='bool')
                             opObj.addParameter(name='figpath', value=figpath, format='str')
                             if figfile:
                                 opObj.addParameter(name='figfile', value=figfile, format='str')
                             if wrperiod:
                                 opObj.addParameter(name='wr_period', value=wrperiod,format='int')
                         if self.specGraphftpSpectra.isChecked():
                            opObj.addParameter(name='ftp', value='1', format='int')
                            self.addFTPConf2Operation(puObj, opObj)
                            addFTP = True
                     if self.specGraphCebCrossSpectraplot.isChecked():
                         opObj = puObj.addOperation(name='CrossSpectraPlot', optype='other')
             #             opObj.addParameter(name='power_cmap', value='jet', format='str')
             #             opObj.addParameter(name='coherence_cmap', value='jet', format='str')
             #             opObj.addParameter(name='phase_cmap', value='RdBu_r', format='str')
                         opObj.addParameter(name='id', value=opObj.id, format='int')
                         if not vel_range == '':
                             xvalueList = vel_range.split(',')
                             try:
                                 value1 = float(xvalueList[0])
                                 value2 = float(xvalueList[1])
                             except:
                                 self.console.clear()
                                 self.console.append("Invalid velocity/frequency range")
                                 return 0
                             opObj.addParameter(name='xmin', value=value1, format='float')
                             opObj.addParameter(name='xmax', value=value2, format='float')
                         if not hei_range == '':
                             yvalueList = hei_range.split(",")
                             try:
                                  value1 = float(yvalueList[0])
                                  value2 = float(yvalueList[1])
                             except:
                                 self.console.clear()
                                 self.console.append("Invalid height range")
                                 return 0
                             opObj.addParameter(name='ymin', value=value1, format='float')
                             opObj.addParameter(name='ymax', value=value2, format='float')
                         if not db_range == '':
                             zvalueList = db_range.split(",")
                             try:
                                 value1 = float(zvalueList[0])
                                 value2 = float(zvalueList[1])
                             except:
                                 self.console.clear()
                                 self.console.append("Invalid db range")
                                 return 0
                             opObj.addParameter(name='zmin', value=value1, format='float')
                             opObj.addParameter(name='zmax', value=value2, format='float')
                         if not magrange == '':
                             zvalueList = magrange.split(",")
                             try:
                                 value1 = float(zvalueList[0])
                                 value2 = float(zvalueList[1])
                             except:
                                 self.console.clear()
                                 self.console.append("Invalid magnitude range")
                                 return 0
                             opObj.addParameter(name='coh_min', value=value1, format='float')
                             opObj.addParameter(name='coh_max', value=value2, format='float')
                         if not phaserange == '':
                             zvalueList = phaserange.split(",")
                             try:
                                 value1 = float(zvalueList[0])
                                 value2 = float(zvalueList[1])
                             except:
                                 self.console.clear()
                                 self.console.append("Invalid phase range")
                                 return 0
                             opObj.addParameter(name='phase_min', value=value1, format='float')
                             opObj.addParameter(name='phase_max', value=value2, format='float')
                         if self.specGraphSaveCross.isChecked():
                             checkPath = True
                             opObj.addParameter(name='save', value='1', format='bool')
                             opObj.addParameter(name='figpath', value=figpath, format='str')
                             if figfile:
                                opObj.addParameter(name='figfile', value=figfile, format='str')
                             if wrperiod:
                                 opObj.addParameter(name='wr_period', value=wrperiod,format='int')
                         if self.specGraphftpCross.isChecked():
                            opObj.addParameter(name='ftp', value='1', format='int')
                            self.addFTPConf2Operation(puObj, opObj)
                            addFTP = True
                     if self.specGraphCebRTIplot.isChecked():
                         opObj = puObj.addOperation(name='RTIPlot', optype='other')
                         opObj.addParameter(name='id', value=opObj.id, format='int')
                         if not channelList == '':
                             if not isList(channelList):
                                 self.console.append("Invalid channelList")
                                 return 0
                             opObj.addParameter(name='channelList', value=channelList, format='intlist')
                         if not trange == '':
                             xvalueList = trange.split(',')
                             try:
                                 value1 = float(xvalueList[0])
                                 value2 = float(xvalueList[1])
                             except:
                                 self.console.clear()
                                 self.console.append("Invalid time range")
                                 return 0
                             opObj.addParameter(name='xmin', value=value1, format='float')
                             opObj.addParameter(name='xmax', value=value2, format='float')
             #             if not timerange == '':
             #                 try:
             #                     timerange = float(timerange)
             #                 except:
             #                     self.console.clear()
             #                     self.console.append("Invalid time range")
             #                     return 0
             #
             #                 opObj.addParameter(name='timerange', value=timerange, format='float')
                         if not hei_range == '':
                             yvalueList = hei_range.split(",")
                             try:
                                 value1 = float(yvalueList[0])
                                 value2 = float(yvalueList[1])
                             except:
                                 self.console.clear()
                                 self.console.append("Invalid height range")
                                 return 0
                             opObj.addParameter(name='ymin', value=value1, format='float')
                             opObj.addParameter(name='ymax', value=value2, format='float')
                         if not db_range == '':
                             zvalueList = db_range.split(",")
                             try:
                                 value1 = float(zvalueList[0])
                                 value2 = float(zvalueList[1])
                             except:
                                 self.console.clear()
                                 self.console.append("Invalid db range")
                                 return 0
                             opObj.addParameter(name='zmin', value=value1, format='float')
                             opObj.addParameter(name='zmax', value=value2, format='float')
                         if self.specGraphSaveRTIplot.isChecked():
                             checkPath = True
                             opObj.addParameter(name='save', value='1', format='bool')
                             opObj.addParameter(name='figpath', value=figpath, format='str')
                             if figfile:
                                opObj.addParameter(name='figfile', value=value, format='str')
                             if wrperiod:
                                 opObj.addParameter(name='wr_period', value=wrperiod,format='int')
                         if self.specGraphftpRTIplot.isChecked():
                            opObj.addParameter(name='ftp', value='1', format='int')
                            self.addFTPConf2Operation(puObj, opObj)
                            addFTP = True
                     if self.specGraphCebCoherencmap.isChecked():
                         opObj = puObj.addOperation(name='CoherenceMap', optype='other')
             #             opObj.addParameter(name=name_parameter, value=value, format=format)
                         # opObj.addParameter(name='coherence_cmap', value='jet', format='str')
                         # opObj.addParameter(name='phase_cmap', value='RdBu_r', format='str')
                         opObj.addParameter(name='id', value=opObj.id, format='int')
             #             if not timerange == '':
             #                 try:
             #                     timerange = int(timerange)
             #                 except:
             #                     self.console.clear()
             #                     self.console.append("Invalid time range")
             #                     return 0
             #
             #                 opObj.addParameter(name='timerange', value=timerange, format='int')
                         if not trange == '':
                             xvalueList = trange.split(',')
                             try:
                                 value1 = float(xvalueList[0])
                                 value2 = float(xvalueList[1])
                             except:
                                 self.console.clear()
                                 self.console.append("Invalid time range")
                                 return 0
                             opObj.addParameter(name='xmin', value=value1, format='float')
                             opObj.addParameter(name='xmax', value=value2, format='float')
                         if not hei_range == '':
                             yvalueList = hei_range.split(",")
                             try:
                                 value1 = float(yvalueList[0])
                                 value2 = float(yvalueList[1])
                             except:
                                 self.console.clear()
                                 self.console.append("Invalid height range")
                                 return 0
                             opObj.addParameter(name='ymin', value=value1, format='float')
                             opObj.addParameter(name='ymax', value=value2, format='float')
                         if not magrange == '':
                             zvalueList = magrange.split(",")
                             try:
                                 value1 = float(zvalueList[0])
                                 value2 = float(zvalueList[1])
                             except:
                                 self.console.clear()
                                 self.console.append("Invalid magnitude range")
                                 return 0
                             opObj.addParameter(name='zmin', value=value1, format='float')
                             opObj.addParameter(name='zmax', value=value2, format='float')
                         if not phaserange == '':
                             zvalueList = phaserange.split(",")
                             try:
                                 value1 = float(zvalueList[0])
                                 value2 = float(zvalueList[1])
                             except:
                                 self.console.clear()
                                 self.console.append("Invalid phase range")
                                 return 0
                             opObj.addParameter(name='phase_min', value=value1, format='float')
                             opObj.addParameter(name='phase_max', value=value2, format='float')
                         if self.specGraphSaveCoherencemap.isChecked():
                             checkPath = True
                             opObj.addParameter(name='save', value='1', format='bool')
                             opObj.addParameter(name='figpath', value=figpath, format='str')
                             if figfile:
                                opObj.addParameter(name='figfile', value=value, format='str')
                             if wrperiod:
                                 opObj.addParameter(name='wr_period', value=wrperiod,format='int')
                         if self.specGraphftpCoherencemap.isChecked():
                            opObj.addParameter(name='ftp', value='1', format='int')
                            self.addFTPConf2Operation(puObj, opObj)
                            addFTP = True
                     if self.specGraphPowerprofile.isChecked():
                        opObj = puObj.addOperation(name='PowerProfilePlot', optype='other')
                        opObj.addParameter(name='id', value=opObj.id, format='int')
                        if not channelList == '':
                            if not isList(channelList):
                                 self.console.append("Invalid channelList")
                                 return 0
                            opObj.addParameter(name='channelList', value=channelList, format='intlist')
                        if not db_range == '':
                            xvalueList = db_range.split(',')
                            try:
                                 value1 = float(xvalueList[0])
                                 value2 = float(xvalueList[1])
                            except:
                                 self.console.clear()
                                 self.console.append("Invalid db range")
                                 return 0
                            opObj.addParameter(name='xmin', value=value1, format='float')
                            opObj.addParameter(name='xmax', value=value2, format='float')
                        if not hei_range == '':
                             yvalueList = hei_range.split(",")
                             try:
                                  value1 = float(yvalueList[0])
                                  value2 = float(yvalueList[1])
                             except:
                                  self.console.clear()
                                  self.console.append("Invalid height range")
                                  return 0
                             opObj.addParameter(name='ymin', value=value1, format='float')
                             opObj.addParameter(name='ymax', value=value2, format='float')
                        if self.specGraphSavePowerprofile.isChecked():
                             checkPath = True
                             opObj.addParameter(name='save', value='1', format='bool')
                             opObj.addParameter(name='figpath', value=figpath, format='str')
                             if figfile:
                                opObj.addParameter(name='figfile', value=value, format='str')
                             if wrperiod:
                                 opObj.addParameter(name='wr_period', value=wrperiod,format='int')
                        if self.specGraphftpPowerprofile.isChecked():
                           opObj.addParameter(name='ftp', value='1', format='int')
                           self.addFTPConf2Operation(puObj, opObj)
                           addFTP = True
                        # rti noise
                     if self.specGraphCebRTInoise.isChecked():
                         opObj = puObj.addOperation(name='Noise', optype='other')
                         opObj.addParameter(name='id', value=opObj.id, format='int')
                         if not channelList == '':
                             if not isList(channelList):
                                 self.console.append("Invalid channelList")
                                 return 0
                             opObj.addParameter(name='channelList', value=channelList, format='intlist')
             #             if not timerange == '':
             #                 try:
             #                     timerange = float(timerange)
             #                 except:
             #                     self.console.clear()
             #                     self.console.append("Invalid time range")
             #                     return 0
             #
             #                 opObj.addParameter(name='timerange', value=timerange, format='float')
                         if not trange == '':
                             xvalueList = trange.split(',')
                             try:
                                 value1 = float(xvalueList[0])
                                 value2 = float(xvalueList[1])
                             except:
                                 self.console.clear()
                                 self.console.append("Invalid time range")
                                 return 0
                             opObj.addParameter(name='xmin', value=value1, format='float')
                             opObj.addParameter(name='xmax', value=value2, format='float')
                         if not db_range == '':
                             yvalueList = db_range.split(",")
                             try:
                                 value1 = float(yvalueList[0])
                                 value2 = float(yvalueList[1])
                             except:
                                 self.console.clear()
                                 self.console.append("Invalid db range")
                                 return 0
                             opObj.addParameter(name='ymin', value=value1, format='float')
                             opObj.addParameter(name='ymax', value=value2, format='float')
                         if self.specGraphSaveRTInoise.isChecked():
                             checkPath = True
                             opObj.addParameter(name='save', value='1', format='bool')
                             opObj.addParameter(name='figpath', value=figpath, format='str')
                             if figfile:
                                opObj.addParameter(name='figfile', value=value, format='str')
                             if wrperiod:
                                 opObj.addParameter(name='wr_period', value=wrperiod,format='int')
                         # test_ftp
                         if self.specGraphftpRTInoise.isChecked():
                            opObj.addParameter(name='ftp', value='1', format='int')
                            self.addFTPConf2Operation(puObj, opObj)
                            addFTP = True
                     if checkPath:
                         if not figpath:
                             self.console.clear()
                             self.console.append("Graphic path should be defined")
                             return 0
                     if addFTP and not figpath:
                             self.console.clear()
                             self.console.append("You have to save the plots before sending them to FTP Server")
                             return 0
             #      if something happend
                     parms_ok, output_path, blocksperfile, profilesperblock = self.checkInputsPUSave(datatype='Spectra')
                     if parms_ok:
                         opObj = puObj.addOperation(name='SpectraWriter', optype='other')
                         opObj.addParameter(name='path', value=output_path)
                         opObj.addParameter(name='blocksPerFile', value=blocksperfile, format='int')
                     self.console.clear()
                     try:
                         self.refreshPUProperties(puObj)
                     except:
                         self.console.append("An error reading input parameters was found ... Check them!")
                         return 0
                     self.console.append("Save your project and press Play button to start signal processing")
                     self.actionSaveToolbar.setEnabled(True)
                     self.actionStarToolbar.setEnabled(True)
                     return 1
                 """
                 Spectra  Graph
                 """
                 @pyqtSignature("int")
                 def on_specGraphCebSpectraplot_stateChanged(self, p0):
                     self.__checkSpecGraphFilters()
                 @pyqtSignature("int")
                 def on_specGraphCebCrossSpectraplot_stateChanged(self, p0):
                     self.__checkSpecGraphFilters()
                 @pyqtSignature("int")
                 def on_specGraphCebRTIplot_stateChanged(self, p0):
                     self.__checkSpecGraphFilters()
                 @pyqtSignature("int")
                 def on_specGraphCebRTInoise_stateChanged(self, p0):
                     self.__checkSpecGraphFilters()
                 @pyqtSignature("int")
                 def on_specGraphCebCoherencmap_stateChanged(self, p0):
                     self.__checkSpecGraphFilters()
                 @pyqtSignature("int")
                 def on_specGraphPowerprofile_stateChanged(self, p0):
                     self.__checkSpecGraphFilters()
                 @pyqtSignature("int")
                 def on_specGraphPhase_stateChanged(self, p0):
                     self.__checkSpecGraphFilters()
                 @pyqtSignature("int")
                 def on_specGraphSaveSpectra_stateChanged(self, p0):
                     """
                     """
                     self.__checkSpecGraphSaving()
                 @pyqtSignature("int")
                 def on_specGraphSaveCross_stateChanged(self, p0):
                     self.__checkSpecGraphSaving()
                 @pyqtSignature("int")
                 def on_specGraphSaveRTIplot_stateChanged(self, p0):
                     self.__checkSpecGraphSaving()
                 @pyqtSignature("int")
                 def on_specGraphSaveRTInoise_stateChanged(self, p0):
                     self.__checkSpecGraphSaving()
                 @pyqtSignature("int")
                 def on_specGraphSaveCoherencemap_stateChanged(self, p0):
                     self.__checkSpecGraphSaving()
                 @pyqtSignature("int")
                 def on_specGraphSavePowerprofile_stateChanged(self, p0):
                     self.__checkSpecGraphSaving()
                 @pyqtSignature("int")
                 def on_specGraphftpSpectra_stateChanged(self, p0):
                     """
                     """
                     self.__checkSpecGraphFTP()
                 @pyqtSignature("int")
                 def on_specGraphftpCross_stateChanged(self, p0):
                     self.__checkSpecGraphFTP()
                 @pyqtSignature("int")
                 def on_specGraphftpRTIplot_stateChanged(self, p0):
                     self.__checkSpecGraphFTP()
                 @pyqtSignature("int")
                 def on_specGraphftpRTInoise_stateChanged(self, p0):
                     self.__checkSpecGraphFTP()
                 @pyqtSignature("int")
                 def on_specGraphftpCoherencemap_stateChanged(self, p0):
                     self.__checkSpecGraphFTP()
                 @pyqtSignature("int")
                 def on_specGraphftpPowerprofile_stateChanged(self, p0):
                     self.__checkSpecGraphFTP()
                 @pyqtSignature("")
                 def on_specGraphToolPath_clicked(self):
                     """
                     """
                     save_path = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly))
                     self.specGraphPath.setText(save_path)
                     if not os.path.exists(save_path):
                         self.console.clear()
                         self.console.append("Write a valid path")
                         return
                 @pyqtSignature("")
                 def on_specGraphClear_clicked(self):
                     return
                 @pyqtSignature("")
                 def on_specHeisGraphToolPath_clicked(self):
                     """
                     """
                     save_path = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly))
                     self.specHeisGraphPath.setText(save_path)
                     if not os.path.exists(save_path):
                         self.console.clear()
                         self.console.append("Write a valid path")
                         return
                 @pyqtSignature("int")
                 def on_specHeisOpCebIncoherent_stateChanged(self, p0):
                     """
                     Habilita la opcion de a�adir el par�metro integraciones incoherentes a la Unidad de Procesamiento .
                     """
                     if  p0 == 2:
                         self.specHeisOpIncoherent.setEnabled(True)
                         self.specHeisOpCobIncInt.setEnabled(True)
                     if  p0 == 0:
                         self.specHeisOpIncoherent.setEnabled(False)
                         self.specHeisOpCobIncInt.setEnabled(False)
                 @pyqtSignature("")
                 def on_specHeisOpOk_clicked(self):
                     """
                     AÑADE OPERACION SPECTRAHEIS
                     """
                     addFTP = False
                     checkPath = False
                     self.actionSaveToolbar.setEnabled(False)
                     self.actionStarToolbar.setEnabled(False)
                     self.console.clear()
                     self.console.append("Checking input parameters ...")
                     puObj = self.getSelectedItemObj()
                     puObj.removeOperations()
                     if self.specHeisOpCebIncoherent.isChecked():
                         value = str(self.specHeisOpIncoherent.text())
                         name_operation = 'IncohInt4SpectraHeis'
                         optype = 'other'
                         name_parameter = 'timeInterval'
                         format = 'float'
                         if self.specOpCobIncInt.currentIndex() == 0:
                             name_parameter = 'timeInterval'
                             format = 'float'
                         if not isFloat(value):
                             self.console.append("Invalid value '%s' for '%s'" %(value, name_parameter))
                             return 0
                         opObj = puObj.addOperation(name=name_operation, optype=optype)
                         if not opObj.addParameter(name=name_parameter, value=value, format=format):
                             self.console.append("Invalid value '%s' for '%s'" %(value, name_parameter))
                             return 0
                     channelList = str(self.specHeisGgraphChannelList.text())
                     freq_range = str(self.specHeisGgraphXminXmax.text())
                     power_range = str(self.specHeisGgraphYminYmax.text())
                     time_range = str(self.specHeisGgraphTminTmax.text())
                     timerange = str(self.specHeisGgraphTimeRange.text())
                     # ---- Spectra Plot-----
                     if self.specHeisGraphCebSpectraplot.isChecked():
                         name_operation = 'SpectraHeisScope'
                         optype = 'other'
                         opObj = puObj.addOperation(name=name_operation, optype=optype)
                         name_parameter = 'id'
                         format = 'int'
                         value = opObj.id
                         if not opObj.addParameter(name=name_parameter, value=value, format=format):
                             self.console.append("Invalid value '%s' for '%s'" %(value, name_parameter))
                             return 0
                         if not (channelList == ''):
                            name_parameter = 'channelList'
                            format = 'intlist'
                            if not isList(channelList):
                                self.console.append("Invalid value '%s' for '%s'" %(channelList, name_parameter))
                                return 0
                            opObj.addParameter(name=name_parameter, value=channelList, format=format)
                         if not freq_range == '':
                             xvalueList = freq_range.split(',')
                             if len(xvalueList) != 2:
                                 self.console.append("Invalid value '%s' for '%s'" %(freq_range, "xrange"))
                                 return 0
                             value1 = xvalueList[0]
                             value2 = xvalueList[1]
                             if not isFloat(value1) or not isFloat(value2):
                                 self.console.append("Invalid value '%s' for '%s'" %(freq_range, "xrange"))
                                 return 0
                             name1 = 'xmin'
                             name2 = 'xmax'
                             format = 'float'
                             opObj.addParameter(name=name1, value=value1, format=format)
                             opObj.addParameter(name=name2, value=value2, format=format)
                         #------specHeisGgraphYmin-Ymax---
                         if not power_range == '':
                             yvalueList = power_range.split(",")
                             if len(yvalueList) != 2:
                                 self.console.append("Invalid value '%s' for '%s'" %(power_range, "xrange"))
                                 return 0
                             value1 = yvalueList[0]
                             value2 = yvalueList[1]
                             if not isFloat(value1) or not isFloat(value2):
                                 self.console.append("Invalid value '%s' for '%s'" %(power_range, "yrange"))
                                 return 0
                             name1 = 'ymin'
                             name2 = 'ymax'
                             format = 'float'
                             opObj.addParameter(name=name1, value=value1, format=format)
                             opObj.addParameter(name=name2, value=value2, format=format)
                         if self.specHeisGraphSaveSpectra.isChecked():
                             checkPath = True
                             name_parameter1 = 'save'
                             name_parameter2 = 'figpath'
                             name_parameter3 = 'figfile'
                             value1 = '1'
                             value2 = str(self.specHeisGraphPath.text())
                             value3 = str(self.specHeisGraphPrefix.text())
                             format1 = 'bool'
                             format2 = 'str'
                             opObj.addParameter(name=name_parameter1, value=value1 , format=format1)
                             opObj.addParameter(name=name_parameter2, value=value2, format=format2)
                             if not value3 == "":
                                try:
                                    value3 = str(self.specHeisGraphPrefix.text())
                                except:
                                    self.console.clear()
                                    self.console.append("Please Write prefix")
                                    return 0
                                opObj.addParameter(name='figfile', value=str(self.specHeisGraphPrefix.text()), format='str')
                          #   opObj.addParameter(name=name_parameter3, value=value3, format=format2)
                          #   opObj.addParameter(name='wr_period', value='5',format='int')
                         if self.specHeisGraphftpSpectra.isChecked():
                            opObj.addParameter(name='ftp', value='1', format='int')
                            self.addFTPConf2Operation(puObj, opObj)
                            addFTP = True
                     if self.specHeisGraphCebRTIplot.isChecked():
                         name_operation = 'RTIfromSpectraHeis'
                         optype = 'other'
                         name_parameter = 'id'
                         format = 'int'
                         opObj = puObj.addOperation(name=name_operation, optype=optype)
                         value = opObj.id
                         opObj.addParameter(name=name_parameter, value=value, format=format)
                         if not channelList == '':
                             opObj.addParameter(name='channelList', value=channelList, format='intlist')
                         if not time_range == '':
                             xvalueList = time_range.split(',')
                             try:
                                 value = float(xvalueList[0])
                                 value = float(xvalueList[1])
                             except:
                                     return 0
                             format = 'float'
                             opObj.addParameter(name='xmin', value=xvalueList[0], format=format)
                             opObj.addParameter(name='xmax', value=xvalueList[1], format=format)
                         if not timerange == '':
                             format = 'int'
                             try:
                                 timerange = int(timerange)
                             except:
                                 return 0
                             opObj.addParameter(name='timerange', value=timerange, format=format)
                         if not power_range == '':
                             yvalueList = power_range.split(",")
                             try:
                                 value = float(yvalueList[0])
                                 value = float(yvalueList[1])
                             except:
                                 return 0
                             format = 'float'
                             opObj.addParameter(name='ymin', value=yvalueList[0], format=format)
                             opObj.addParameter(name='ymax', value=yvalueList[1], format=format)
                         if self.specHeisGraphSaveRTIplot.isChecked():
                             checkPath = True
                             opObj.addParameter(name='save', value='1', format='bool')
                             opObj.addParameter(name='figpath', value=str(self.specHeisGraphPath.text()), format='str')
                             value = str(self.specHeisGraphPrefix.text())
                             if not value == "":
                                try:
                                    value = str(self.specHeisGraphPrefix.text())
                                except:
                                     self.console.clear()
                                     self.console.append("Please Write prefix")
                                     return 0
                                opObj.addParameter(name='figfile', value=value, format='str')
                         # test_ftp
                         if self.specHeisGraphftpRTIplot.isChecked():
                            opObj.addParameter(name='ftp', value='1', format='int')
                            self.addFTPConf2Operation(puObj, opObj)
                            addFTP = True
                     localfolder = None
                     if checkPath:
                         localfolder = str(self.specHeisGraphPath.text())
                         if localfolder == '':
                             self.console.clear()
                             self.console.append("Graphic path should be defined")
                             return 0
                     if addFTP and not localfolder:
                         self.console.clear()
                         self.console.append("You should save plots before send them to FTP Server")
                         return 0
                     # if something happened
-                    parms_ok, output_path, blocksperfile, metada = self.checkInputsPUSave(datatype='SpectraHeis')
+                    parms_ok, output_path, blocksperfile, metadata_file = self.checkInputsPUSave(datatype='SpectraHeis')
                     if parms_ok:
                         name_operation = 'FitsWriter'
                         optype = 'other'
                         name_parameter1 = 'path'
                         name_parameter2 = 'dataBlocksPerFile'
                         name_parameter3 = 'metadatafile'
                         value1 = output_path
                         value2 = blocksperfile
-                        value3 = metada
+                        value3 = metadata_file
                         format2 = "int"
                         format3 = "str"
                         opObj = puObj.addOperation(name=name_operation, optype=optype)
                         opObj.addParameter(name=name_parameter1, value=value1)
-                        opObj.addParameter(name=name_parameter2, value=value2, format=format2)
-                        opObj.addParameter(name=name_parameter3, value=value3, format=format3)
+                        if blocksperfile:
+                            opObj.addParameter(name=name_parameter2, value=value2, format=format2)
+                        if metadata_file:
+                            opObj.addParameter(name=name_parameter3, value=value3, format=format3)
                     self.console.clear()
                     try:
                         self.refreshPUProperties(puObj)
                     except:
                         self.console.append("An error reading input parameters was found ... Check them!")
                         return 0
                     self.console.append("Save your project and press Play button to start signal processing")
                     self.actionSaveToolbar.setEnabled(True)
                     self.actionStarToolbar.setEnabled(True)
                     return 1
                 @pyqtSignature("int")
                 def on_specHeisGraphCebSpectraplot_stateChanged(self, p0):
                     if  p0 == 2:
                         self.specHeisGgraphChannelList.setEnabled(True)
                         self.specHeisGgraphXminXmax.setEnabled(True)
                         self.specHeisGgraphYminYmax.setEnabled(True)
                     if  p0 == 0:
                         self.specHeisGgraphXminXmax.setEnabled(False)
                         self.specHeisGgraphYminYmax.setEnabled(False)
                 @pyqtSignature("int")
                 def on_specHeisGraphCebRTIplot_stateChanged(self, p0):
                     if  p0 == 2:
                         self.specHeisGgraphChannelList.setEnabled(True)
                         self.specHeisGgraphTminTmax.setEnabled(True)
                         self.specHeisGgraphYminYmax.setEnabled(True)
                         self.specHeisGgraphTimeRange.setEnabled(True)
                     if  p0 == 0:
                         self.specHeisGgraphTminTmax.setEnabled(False)
                         self.specHeisGgraphYminYmax.setEnabled(False)
                         self.specHeisGgraphTimeRange.setEnabled(False)
                 @pyqtSignature("int")
                 def on_specHeisGraphSaveSpectra_stateChanged(self, p0):
                     """
                     """
                     if  p0 == 2:
                         self.specHeisGraphPath.setEnabled(True)
                         self.specHeisGraphPrefix.setEnabled(True)
                         self.specHeisGraphToolPath.setEnabled(True)
                     if  p0 == 0:
                         self.specHeisGraphPath.setEnabled(False)
                         self.specHeisGraphPrefix.setEnabled(False)
                         self.specHeisGraphToolPath.setEnabled(False)
                 @pyqtSignature("int")
                 def on_specHeisGraphSaveRTIplot_stateChanged(self, p0):
                     if  p0 == 2:
                         self.specHeisGraphPath.setEnabled(True)
                         self.specHeisGraphPrefix.setEnabled(True)
                         self.specHeisGraphToolPath.setEnabled(True)
                 @pyqtSignature("int")
                 def on_specHeisGraphftpSpectra_stateChanged(self, p0):
                     """
                     """
                     if  p0 == 2:
                         self.specHeisGgraphftpratio.setEnabled(True)
                     if  p0 == 0:
                         self.specHeisGgraphftpratio.setEnabled(False)
                 @pyqtSignature("int")
                 def on_specHeisGraphftpRTIplot_stateChanged(self, p0):
                     if  p0 == 2:
                         self.specHeisGgraphftpratio.setEnabled(True)
                 @pyqtSignature("")
                 def on_specHeisGraphClear_clicked(self):
                     pass
                 def __checkSpecGraphSaving(self):
                     enable = False
                     if self.specGraphSaveSpectra.checkState():
                         enable = True
                     if self.specGraphSaveCross.checkState():
                         enable = True
                     if self.specGraphSaveRTIplot.checkState():
                         enable = True
                     if self.specGraphSaveCoherencemap.checkState():
                         enable = True
                     if self.specGraphSavePowerprofile.checkState():
                         enable = True
                     if self.specGraphSaveRTInoise.checkState():
                         enable = True
                     self.specGraphPath.setEnabled(enable)
                     self.specGraphPrefix.setEnabled(enable)
                     self.specGraphToolPath.setEnabled(enable)
                     self.specGgraphftpratio.setEnabled(enable)
                 def __checkSpecGraphFTP(self):
                     enable = False
                     if self.specGraphftpSpectra.checkState():
                         enable = True
                     if self.specGraphftpCross.checkState():
                         enable = True
                     if self.specGraphftpRTIplot.checkState():
                         enable = True
                     if self.specGraphftpCoherencemap.checkState():
                         enable = True
                     if self.specGraphftpPowerprofile.checkState():
                         enable = True
                     if self.specGraphftpRTInoise.checkState():
                         enable = True
             #         self.specGgraphftpratio.setEnabled(enable)
                 def __checkSpecGraphFilters(self):
                     freq = False
                     height = False
                     db = False
                     time = False
                     magnitud = False
                     phase = False
                     channelList = False
                     if self.specGraphCebSpectraplot.checkState():
                         freq = True
                         height = True
                         db = True
                         channelList = True
                     if self.specGraphCebCrossSpectraplot.checkState():
                         freq = True
                         height = True
                         db = True
                         magnitud = True
                         phase = True
                     if self.specGraphCebRTIplot.checkState():
                         height = True
                         db = True
                         time = True
                         channelList = True
                     if self.specGraphCebCoherencmap.checkState():
                         height = True
                         time = True
                         magnitud = True
                         phase = True
                     if self.specGraphPowerprofile.checkState():
                         height = True
                         db = True
                         channelList = True
                     if self.specGraphCebRTInoise.checkState():
                         db = True
                         time = True
                         channelList = True
                     self.specGgraphFreq.setEnabled(freq)
                     self.specGgraphHeight.setEnabled(height)
                     self.specGgraphDbsrange.setEnabled(db)
                     self.specGgraphTminTmax.setEnabled(time)
                     self.specGgraphmagnitud.setEnabled(magnitud)
                     self.specGgraphPhase.setEnabled(phase)
                     self.specGgraphChannelList.setEnabled(channelList)
                 def __getParmsFromProjectWindow(self):
                     """
                     Check Inputs Project:
                     - project_name
                     - datatype
                     - ext
                     - data_path
                     - readmode
                     - delay
                     - set
                     - walk
                     """
                     parms_ok = True
                     project_name = str(self.proName.text())
                     if project_name == '' or project_name == None:
                         outputstr = "Enter a project Name"
                         self.console.append(outputstr)
                         parms_ok = False
                         project_name = None
                     description = str(self.proDescription.toPlainText())
                     datatype = str(self.proComDataType.currentText())
                     ext = str(self.proDataType.text())
                     dpath = str(self.proDataPath.text())
                     if dpath == '':
                         outputstr = 'Datapath is empty'
                         self.console.append(outputstr)
                         parms_ok = False
                         dpath = None
                     if dpath != None:
                         if not os.path.isdir(dpath):
                             outputstr = 'Datapath (%s) does not exist' % dpath
                             self.console.append(outputstr)
                             parms_ok = False
                             dpath = None
                     online = int(self.proComReadMode.currentIndex())
                     delay = None
                     if online==1:
                         try:
                             delay = int(str(self.proDelay.text()))
                         except:
                             outputstr = 'Delay value (%s) must be a integer number' %str(self.proDelay.text())
                             self.console.append(outputstr)
                             parms_ok = False
                     set = None
                     value = str(self.proSet.text())
                     try:
                         set = int(value)
                     except:
                         pass
                     ippKm = None
                     value = str(self.proIPPKm.text())
                     try:
                         ippKm = float(value)
                     except:
                         if datatype=="USRP":
                             outputstr = 'IPP value "%s" must be a float number' % str(self.proIPPKm.text())
                             self.console.append(outputstr)
                             parms_ok = False
                     walk = int(self.proComWalk.currentIndex())
                     expLabel = str(self.proExpLabel.text())
                     startDate = str(self.proComStartDate.currentText())
                     endDate = str(self.proComEndDate.currentText())
             #         startDateList = startDate.split("/")
             #         endDateList = endDate.split("/")
             #
             #         startDate = datetime.date(int(startDateList[0]), int(startDateList[1]), int(startDateList[2]))
             #         endDate = datetime.date(int(endDateList[0]), int(endDateList[1]), int(endDateList[2]))
                     startTime = self.proStartTime.time()
                     endTime = self.proEndTime.time()
                     startTime = str(startTime.toString("H:m:s"))
                     endTime = str(endTime.toString("H:m:s"))
                     projectParms = ProjectParms()
                     projectParms.name = project_name
                     projectParms.description = description
                     projectParms.datatype = datatype
                     projectParms.ext = ext
                     projectParms.dpath = dpath
                     projectParms.online = online
                     projectParms.startDate = startDate
                     projectParms.endDate = endDate
                     projectParms.startTime = startTime
                     projectParms.endTime = endTime
                     projectParms.delay = delay
                     projectParms.walk = walk
                     projectParms.expLabel = expLabel
                     projectParms.set = set
                     projectParms.ippKm = ippKm
                     projectParms.parmsOk = parms_ok
                     return projectParms
                 def __getParmsFromProjectObj(self, projectObjView):
                     parms_ok = True
                     project_name, description = projectObjView.name, projectObjView.description
                     readUnitObj = projectObjView.getReadUnitObj()
                     datatype = readUnitObj.datatype
                     operationObj = readUnitObj.getOperationObj(name='run')
                     dpath = operationObj.getParameterValue(parameterName='path')
                     startDate = operationObj.getParameterValue(parameterName='startDate')
                     endDate = operationObj.getParameterValue(parameterName='endDate')
                     startDate = startDate.strftime("%Y/%m/%d")
                     endDate = endDate.strftime("%Y/%m/%d")
                     startTime = operationObj.getParameterValue(parameterName='startTime')
                     endTime = operationObj.getParameterValue(parameterName='endTime')
                     startTime = startTime.strftime("%H:%M:%S")
                     endTime = endTime.strftime("%H:%M:%S")
                     online = 0
                     try:
                         online = operationObj.getParameterValue(parameterName='online')
                     except:
                         pass
                     delay = ''
                     try:
                         delay = operationObj.getParameterValue(parameterName='delay')
                     except:
                         pass
                     walk = 0
                     try:
                         walk = operationObj.getParameterValue(parameterName='walk')
                     except:
                         pass
                     set = ''
                     try:
                         set = operationObj.getParameterValue(parameterName='set')
                     except:
                         pass
                     expLabel = ''
                     try:
                         expLabel = operationObj.getParameterValue(parameterName='expLabel')
                     except:
                         pass
                     ippKm = ''
                     if datatype.lower() == 'usrp':
                         try:
                             ippKm = operationObj.getParameterValue(parameterName='ippKm')
                         except:
                             pass
                     projectParms = ProjectParms()
                     projectParms.name = project_name
                     projectParms.description = description
                     projectParms.datatype = datatype
                     projectParms.ext = None
                     projectParms.dpath = dpath
                     projectParms.online = online
                     projectParms.startDate = startDate
                     projectParms.endDate = endDate
                     projectParms.startTime = startTime
                     projectParms.endTime = endTime
                     projectParms.delay=delay
                     projectParms.walk=walk
                     projectParms.set=set
                     projectParms.ippKm=ippKm
                     projectParms.expLabel = expLabel
                     projectParms.parmsOk=parms_ok
                     return projectParms
                 def refreshProjectWindow(self, projectObjView):
                     projectParms = self.__getParmsFromProjectObj(projectObjView)
                     index = projectParms.getDatatypeIndex()
                     self.proName.setText(projectParms.name)
                     self.proDescription.clear()
                     self.proDescription.append(projectParms.description)
                     self.on_proComDataType_activated(index=index)
                     self.proDataPath.setText(projectParms.dpath)
                     self.proComDataType.setCurrentIndex(index)
                     self.proComReadMode.setCurrentIndex(projectParms.online)
                     self.proDelay.setText(str(projectParms.delay))
                     self.proSet.setText(str(projectParms.set))
                     self.proIPPKm.setText(str(projectParms.ippKm))
                     self.proComWalk.setCurrentIndex(projectParms.walk)
                     self.proExpLabel.setText(str(projectParms.expLabel).strip())
                     dateList = self.loadDays(data_path = projectParms.dpath,
                                              ext = projectParms.getExt(),
                                              walk = projectParms.walk,
                                              expLabel = projectParms.expLabel)
                     try:
                         startDateIndex = dateList.index(projectParms.startDate)
                     except:
                         startDateIndex = 0
                     try:
                         endDateIndex = dateList.index(projectParms.endDate)
                     except:
                         endDateIndex = int(self.proComEndDate.count()-1)
                     self.proComStartDate.setCurrentIndex(startDateIndex)
                     self.proComEndDate.setCurrentIndex(endDateIndex)
                     startlist = projectParms.startTime.split(":")
                     endlist = projectParms.endTime.split(":")
                     self.time.setHMS(int(startlist[0]), int(startlist[1]), int(startlist[2]))
                     self.proStartTime.setTime(self.time)
                     self.time.setHMS(int(endlist[0]), int(endlist[1]), int(endlist[2]))
                     self.proEndTime.setTime(self.time)
                 def __refreshVoltageWindow(self, puObj):
                     opObj = puObj.getOperationObj(name='setRadarFrequency')
                     if opObj == None:
                         self.volOpRadarfrequency.clear()
                         self.volOpCebRadarfrequency.setCheckState(0)
                     else:
                         value = opObj.getParameterValue(parameterName='frequency')
                         value = str(float(value)/1e6)
                         self.volOpRadarfrequency.setText(value)
                         self.volOpRadarfrequency.setEnabled(True)
                         self.volOpCebRadarfrequency.setCheckState(QtCore.Qt.Checked)
                     opObj = puObj.getOperationObj(name="selectChannels")
                     if opObj == None:
                         opObj = puObj.getOperationObj(name="selectChannelsByIndex")
                     if opObj == None:
                         self.volOpChannel.clear()
                         self.volOpCebChannels.setCheckState(0)
                     else:
                         channelEnabled = False
                         try:
                             value = opObj.getParameterValue(parameterName='channelList')
                             value = str(value)[1:-1]
                             channelEnabled = True
                             channelMode = 0
                         except:
                             pass
                         try:
                             value = opObj.getParameterValue(parameterName='channelIndexList')
                             value = str(value)[1:-1]
                             channelEnabled = True
                             channelMode = 1
                         except:
                             pass
                         if channelEnabled:
                             self.volOpChannel.setText(value)
                             self.volOpChannel.setEnabled(True)
                             self.volOpCebChannels.setCheckState(QtCore.Qt.Checked)
                             self.volOpComChannels.setCurrentIndex(channelMode)
                     opObj = puObj.getOperationObj(name="selectHeights")
                     if opObj == None:
                         self.volOpHeights.clear()
                         self.volOpCebHeights.setCheckState(0)
                     else:
                        value1 = int(opObj.getParameterValue(parameterName='minHei'))
                        value1 = str(value1)
                        value2 = int(opObj.getParameterValue(parameterName='maxHei'))
                        value2 = str(value2)
                        value = value1 + "," + value2
                        self.volOpHeights.setText(value)
                        self.volOpHeights.setEnabled(True)
                        self.volOpCebHeights.setCheckState(QtCore.Qt.Checked)
                     opObj = puObj.getOperationObj(name="filterByHeights")
                     if opObj == None:
                         self.volOpFilter.clear()
                         self.volOpCebFilter.setCheckState(0)
                     else:
                         value = opObj.getParameterValue(parameterName='window')
                         value = str(value)
                         self.volOpFilter.setText(value)
                         self.volOpFilter.setEnabled(True)
                         self.volOpCebFilter.setCheckState(QtCore.Qt.Checked)
                     opObj = puObj.getOperationObj(name="ProfileSelector")
                     if opObj == None:
                         self.volOpProfile.clear()
                         self.volOpCebProfile.setCheckState(0)
                     else:
                        for parmObj in opObj.getParameterObjList():
                             if parmObj.name == "profileList":
                                 value = parmObj.getValue()
                                 value = str(value)[1:-1]
                                 self.volOpProfile.setText(value)
                                 self.volOpProfile.setEnabled(True)
                                 self.volOpCebProfile.setCheckState(QtCore.Qt.Checked)
                                 self.volOpComProfile.setCurrentIndex(0)
                             if parmObj.name == "profileRangeList":
                                 value = parmObj.getValue()
                                 value = str(value)[1:-1]
                                 self.volOpProfile.setText(value)
                                 self.volOpProfile.setEnabled(True)
                                 self.volOpCebProfile.setCheckState(QtCore.Qt.Checked)
                                 self.volOpComProfile.setCurrentIndex(1)
                             if parmObj.name == "rangeList":
                                 value = parmObj.getValue()
                                 value = str(value)[1:-1]
                                 self.volOpProfile.setText(value)
                                 self.volOpProfile.setEnabled(True)
                                 self.volOpCebProfile.setCheckState(QtCore.Qt.Checked)
                                 self.volOpComProfile.setCurrentIndex(2)
                     opObj = puObj.getOperationObj(name="Decoder")
                     self.volOpCode.setText("")
                     if opObj == None:
                         self.volOpCebDecodification.setCheckState(0)
                     else:
                         self.volOpCebDecodification.setCheckState(QtCore.Qt.Checked)
                         parmObj = opObj.getParameterObj('code')
                         if parmObj == None:
                             self.volOpComCode.setCurrentIndex(0)
                         else:
                             parmObj1 = opObj.getParameterObj('nCode')
                             parmObj2 = opObj.getParameterObj('nBaud')
                             if parmObj1 == None or parmObj2 == None:
                                 self.volOpComCode.setCurrentIndex(0)
                             else:
                                 code = ast.literal_eval(str(parmObj.getValue()))
                                 nCode = parmObj1.getValue()
                                 nBaud = parmObj2.getValue()
                                 code = numpy.asarray(code).reshape((nCode, nBaud)).tolist()
                                 #User defined by default
                                 self.volOpComCode.setCurrentIndex(13)
                                 self.volOpCode.setText(str(code))
                                 if nCode == 1:
                                     if nBaud == 3:
                                        self.volOpComCode.setCurrentIndex(1)
                                     if nBaud == 4:
                                         self.volOpComCode.setCurrentIndex(2)
                                     if nBaud == 5:
                                         self.volOpComCode.setCurrentIndex(3)
                                     if nBaud == 7:
                                         self.volOpComCode.setCurrentIndex(4)
                                     if nBaud == 11:
                                         self.volOpComCode.setCurrentIndex(5)
                                     if nBaud == 13:
                                         self.volOpComCode.setCurrentIndex(6)
                                 if nCode == 2:
                                     if nBaud == 3:
                                        self.volOpComCode.setCurrentIndex(7)
                                     if nBaud == 4:
                                         self.volOpComCode.setCurrentIndex(8)
                                     if nBaud == 5:
                                         self.volOpComCode.setCurrentIndex(9)
                                     if nBaud == 7:
                                         self.volOpComCode.setCurrentIndex(10)
                                     if nBaud == 11:
                                         self.volOpComCode.setCurrentIndex(11)
                                     if nBaud == 13:
                                         self.volOpComCode.setCurrentIndex(12)
                     opObj = puObj.getOperationObj(name="deFlip")
                     if opObj == None:
                         self.volOpFlip.clear()
                         self.volOpFlip.setEnabled(False)
                         self.volOpCebFlip.setCheckState(0)
                     else:
                         try:
                             value = opObj.getParameterValue(parameterName='channelList')
                             value = str(value)[1:-1]
                         except:
                             value = ""
                         self.volOpFlip.setText(value)
                         self.volOpFlip.setEnabled(True)
                         self.volOpCebFlip.setCheckState(QtCore.Qt.Checked)
                     opObj = puObj.getOperationObj(name="CohInt")
                     if opObj == None:
                         self.volOpCohInt.clear()
                         self.volOpCebCohInt.setCheckState(0)
                     else:
                         value = opObj.getParameterValue(parameterName='n')
                         self.volOpCohInt.setText(str(value))
                         self.volOpCohInt.setEnabled(True)
                         self.volOpCebCohInt.setCheckState(QtCore.Qt.Checked)
                     opObj = puObj.getOperationObj(name='Scope')
                     if opObj == None:
                         self.volGraphCebshow.setCheckState(0)
                     else:
                         self.volGraphCebshow.setCheckState(QtCore.Qt.Checked)
                         parmObj = opObj.getParameterObj(parameterName='channelList')
                         if parmObj == None:
                             self.volGraphChannelList.clear()
                         else:
                             value = parmObj.getValue()
                             value = str(value)
                             self.volGraphChannelList.setText(value)
                             self.volOpProfile.setEnabled(True)
                         parmObj1 = opObj.getParameterObj(parameterName='xmin')
                         parmObj2 = opObj.getParameterObj(parameterName='xmax')
                         if parmObj1 == None or parmObj2 ==None:
                             self.volGraphfreqrange.clear()
                         else:
                             value1 = parmObj1.getValue()
                             value1 = str(value1)
                             value2 = parmObj2.getValue()
                             value2 = str(value2)
                             value = value1 + "," + value2
                             self.volGraphfreqrange.setText(value)
                         parmObj1 = opObj.getParameterObj(parameterName='ymin')
                         parmObj2 = opObj.getParameterObj(parameterName='ymax')
                         if parmObj1 == None or parmObj2 ==None:
                             self.volGraphHeightrange.clear()
                         else:
                             value1 = parmObj1.getValue()
                             value1 = str(value1)
                             value2 = parmObj2.getValue()
                             value2 = str(value2)
                             value = value1 + "," + value2
                             value2 = str(value2)
                             self.volGraphHeightrange.setText(value)
                         parmObj = opObj.getParameterObj(parameterName='save')
                         if parmObj == None:
                             self.volGraphCebSave.setCheckState(QtCore.Qt.Unchecked)
                         else:
                             value = parmObj.getValue()
                             if int(value):
                                 self.volGraphCebSave.setCheckState(QtCore.Qt.Checked)
                             else:
                                 self.volGraphCebSave.setCheckState(QtCore.Qt.Unchecked)
                         parmObj = opObj.getParameterObj(parameterName='figpath')
                         if parmObj == None:
                             self.volGraphPath.clear()
                         else:
                             value = parmObj.getValue()
                             path = str(value)
                             self.volGraphPath.setText(path)
                         parmObj = opObj.getParameterObj(parameterName='figfile')
                         if parmObj == None:
                             self.volGraphPrefix.clear()
                         else:
                             value = parmObj.getValue()
                             figfile = str(value)
                             self.volGraphPrefix.setText(figfile)
                     # outputVoltageWrite
                     opObj = puObj.getOperationObj(name='VoltageWriter')
                     if opObj == None:
                         self.volOutputPath.clear()
                         self.volOutputblocksperfile.clear()
                         self.volOutputprofilesperblock.clear()
                     else:
                         parmObj = opObj.getParameterObj(parameterName='path')
                         if parmObj == None:
                             self.volOutputPath.clear()
                         else:
                             value = parmObj.getValue()
                             path = str(value)
                             self.volOutputPath.setText(path)
                         parmObj = opObj.getParameterObj(parameterName='blocksPerFile')
                         if parmObj == None:
                            self.volOutputblocksperfile.clear()
                         else:
                             value = parmObj.getValue()
                             blocksperfile = str(value)
                             self.volOutputblocksperfile.setText(blocksperfile)
                         parmObj = opObj.getParameterObj(parameterName='profilesPerBlock')
                         if parmObj == None:
                             self.volOutputprofilesperblock.clear()
                         else:
                             value = parmObj.getValue()
                             profilesPerBlock = str(value)
                             self.volOutputprofilesperblock.setText(profilesPerBlock)
                     return
                 def __refreshSpectraWindow(self, puObj):
                     inputId = puObj.getInputId()
                     inputPUObj = self.__puObjDict[inputId]
                     if inputPUObj.datatype == 'Voltage':
                         self.specOpnFFTpoints.setEnabled(True)
                         self.specOpProfiles.setEnabled(True)
                         self.specOpippFactor.setEnabled(True)
                     else:
                         self.specOpnFFTpoints.setEnabled(False)
                         self.specOpProfiles.setEnabled(False)
                         self.specOpippFactor.setEnabled(False)
                     opObj = puObj.getOperationObj(name='setRadarFrequency')
                     if opObj == None:
                         self.specOpRadarfrequency.clear()
                         self.specOpCebRadarfrequency.setCheckState(0)
                     else:
                         value = opObj.getParameterValue(parameterName='frequency')
                         value = str(float(value)/1e6)
                         self.specOpRadarfrequency.setText(value)
                         self.specOpRadarfrequency.setEnabled(True)
                         self.specOpCebRadarfrequency.setCheckState(QtCore.Qt.Checked)
                     opObj = puObj.getOperationObj(name="run")
                     if opObj == None:
                         self.specOpnFFTpoints.clear()
                         self.specOpProfiles.clear()
                         self.specOpippFactor.clear()
                     else:
                         parmObj = opObj.getParameterObj(parameterName='nFFTPoints')
                         if parmObj == None:
                             self.specOpnFFTpoints.clear()
                         else:
                             self.specOpnFFTpoints.setEnabled(True)
                             value = opObj.getParameterValue(parameterName='nFFTPoints')
                             self.specOpnFFTpoints.setText(str(value))
                         parmObj = opObj.getParameterObj(parameterName='nProfiles')
                         if parmObj == None:
                             self.specOpProfiles.clear()
                         else:
                             self.specOpProfiles.setEnabled(True)
                             value = opObj.getParameterValue(parameterName='nProfiles')
                             self.specOpProfiles.setText(str(value))
                         parmObj = opObj.getParameterObj(parameterName='ippFactor')
                         if parmObj == None:
                             self.specOpippFactor.clear()
                         else:
                             self.specOpippFactor.setEnabled(True)
                             value = opObj.getParameterValue(parameterName='ippFactor')
                             self.specOpippFactor.setText(str(value))
                     opObj = puObj.getOperationObj(name="run")
                     if opObj == None:
                         self.specOppairsList.clear()
                         self.specOpCebCrossSpectra.setCheckState(0)
                     else:
                         parmObj = opObj.getParameterObj(parameterName='pairsList')
                         if parmObj == None:
                             self.specOppairsList.clear()
                             self.specOpCebCrossSpectra.setCheckState(0)
                         else:
                             value = opObj.getParameterValue(parameterName='pairsList')
                             value = str(value)[1:-1]
                             self.specOppairsList.setText(str(value))
                             self.specOppairsList.setEnabled(True)
                             self.specOpCebCrossSpectra.setCheckState(QtCore.Qt.Checked)
                     opObj = puObj.getOperationObj(name="selectChannels")
                     if opObj == None:
                         opObj = puObj.getOperationObj(name="selectChannelsByIndex")
                     if opObj == None:
                         self.specOpChannel.clear()
                         self.specOpCebChannel.setCheckState(0)
                     else:
                         channelEnabled = False
                         try:
                             value = opObj.getParameterValue(parameterName='channelList')
                             value = str(value)[1:-1]
                             channelEnabled = True
                             channelMode = 0
                         except:
                             pass
                         try:
                             value = opObj.getParameterValue(parameterName='channelIndexList')
                             value = str(value)[1:-1]
                             channelEnabled = True
                             channelMode = 1
                         except:
                             pass
                         if channelEnabled:
                             self.specOpChannel.setText(value)
                             self.specOpChannel.setEnabled(True)
                             self.specOpCebChannel.setCheckState(QtCore.Qt.Checked)
                             self.specOpComChannel.setCurrentIndex(channelMode)
                     opObj = puObj.getOperationObj(name="selectHeights")
                     if opObj == None:
                         self.specOpHeights.clear()
                         self.specOpCebHeights.setCheckState(0)
                     else:
                        value1 = int(opObj.getParameterValue(parameterName='minHei'))
                        value1 = str(value1)
                        value2 = int(opObj.getParameterValue(parameterName='maxHei'))
                        value2 = str(value2)
                        value = value1 + "," + value2
                        self.specOpHeights.setText(value)
                        self.specOpHeights.setEnabled(True)
                        self.specOpCebHeights.setCheckState(QtCore.Qt.Checked)
                     opObj = puObj.getOperationObj(name="IncohInt")
                     if opObj == None:
                         self.specOpIncoherent.clear()
                         self.specOpCebIncoherent.setCheckState(0)
                     else:
                         for parmObj in opObj.getParameterObjList():
                            if parmObj.name == 'timeInterval':
                                value = opObj.getParameterValue(parameterName='timeInterval')
                                value = float(value)
                                self.specOpIncoherent.setText(str(value))
                                self.specOpIncoherent.setEnabled(True)
                                self.specOpCebIncoherent.setCheckState(QtCore.Qt.Checked)
                                self.specOpCobIncInt.setCurrentIndex(0)
                            if parmObj.name == 'n':
                                value = opObj.getParameterValue(parameterName='n')
                                value = float(value)
                                self.specOpIncoherent.setText(str(value))
                                self.specOpIncoherent.setEnabled(True)
                                self.specOpCebIncoherent.setCheckState(QtCore.Qt.Checked)
                                self.specOpCobIncInt.setCurrentIndex(1)
                     opObj = puObj.getOperationObj(name="removeDC")
                     if opObj == None:
                         self.specOpCebRemoveDC.setCheckState(0)
                     else:
                         self.specOpCebRemoveDC.setCheckState(QtCore.Qt.Checked)
                         value = opObj.getParameterValue(parameterName='mode')
                         if value == 1:
                             self.specOpComRemoveDC.setCurrentIndex(0)
                         elif value == 2:
                             self.specOpComRemoveDC.setCurrentIndex(1)
                     opObj = puObj.getOperationObj(name="removeInterference")
                     if opObj == None:
                         self.specOpCebRemoveInt.setCheckState(0)
                     else:
                         self.specOpCebRemoveInt.setCheckState(QtCore.Qt.Checked)
                     opObj = puObj.getOperationObj(name='getNoise')
                     if opObj == None:
                         self.specOpCebgetNoise.setCheckState(0)
                         self.specOpgetNoise.clear()
                     else:
                         self.specOpCebgetNoise.setCheckState(QtCore.Qt.Checked)
                         parmObj = opObj.getParameterObj(parameterName='minHei')
                         if parmObj == None:
                             self.specOpgetNoise.clear()
                             value1 = None
                         else:
                             value1 = opObj.getParameterValue(parameterName='minHei')
                             value1 = str(value1)
                             parmObj = opObj.getParameterObj(parameterName='maxHei')
                             if parmObj == None:
                                 value2 = None
                                 value = value1
                                 self.specOpgetNoise.setText(value)
                                 self.specOpgetNoise.setEnabled(True)
                             else:
                                 value2 = opObj.getParameterValue(parameterName='maxHei')
                                 value2 = str(value2)
                                 parmObj = opObj.getParameterObj(parameterName='minVel')
                                 if parmObj == None:
                                     value3 = None
                                     value = value1 + "," + value2
                                     self.specOpgetNoise.setText(value)
                                     self.specOpgetNoise.setEnabled(True)
                                 else:
                                     value3 = opObj.getParameterValue(parameterName='minVel')
                                     value3 = str(value3)
                                     parmObj = opObj.getParameterObj(parameterName='maxVel')
                                     if parmObj == None:
                                         value4 = None
                                         value = value1 + "," + value2 + "," + value3
                                         self.specOpgetNoise.setText(value)
                                         self.specOpgetNoise.setEnabled(True)
                                     else:
                                         value4 = opObj.getParameterValue(parameterName='maxVel')
                                         value4 = str(value4)
                                         value = value1 + "," + value2 + "," + value3 + ',' + value4
                                         self.specOpgetNoise.setText(value)
                                         self.specOpgetNoise.setEnabled(True)
                     self.specGraphPath.clear()
                     self.specGraphPrefix.clear()
                     self.specGgraphFreq.clear()
                     self.specGgraphHeight.clear()
                     self.specGgraphDbsrange.clear()
                     self.specGgraphmagnitud.clear()
                     self.specGgraphPhase.clear()
                     self.specGgraphChannelList.clear()
                     self.specGgraphTminTmax.clear()
                     self.specGgraphTimeRange.clear()
                     self.specGgraphftpratio.clear()
                     opObj = puObj.getOperationObj(name='SpectraPlot')
                     if opObj == None:
                         self.specGraphCebSpectraplot.setCheckState(0)
                         self.specGraphSaveSpectra.setCheckState(0)
                         self.specGraphftpSpectra.setCheckState(0)
                     else:
                         operationSpectraPlot = "Enable"
                         self.specGraphCebSpectraplot.setCheckState(QtCore.Qt.Checked)
                         parmObj = opObj.getParameterObj(parameterName='channelList')
                         if parmObj == None:
                             self.specGgraphChannelList.clear()
                         else:
                             value = opObj.getParameterValue(parameterName='channelList')
                             channelListSpectraPlot = str(value)[1:-1]
                             self.specGgraphChannelList.setText(channelListSpectraPlot)
                             self.specGgraphChannelList.setEnabled(True)
                         parmObj = opObj.getParameterObj(parameterName='xmin')
                         if parmObj == None:
                             self.specGgraphFreq.clear()
                         else:
                             value1 = opObj.getParameterValue(parameterName='xmin')
                             value1 = str(value1)
                             value2 = opObj.getParameterValue(parameterName='xmax')
                             value2 = str(value2)
                             value = value1 + "," + value2
                             self.specGgraphFreq.setText(value)
                             self.specGgraphFreq.setEnabled(True)
                         parmObj = opObj.getParameterObj(parameterName='ymin')
                         if parmObj == None:
                             self.specGgraphHeight.clear()
                         else:
                             value1 = opObj.getParameterValue(parameterName='ymin')
                             value1 = str(value1)
                             value2 = opObj.getParameterValue(parameterName='ymax')
                             value2 = str(value2)
                             value = value1 + "," + value2
                             self.specGgraphHeight.setText(value)
                             self.specGgraphHeight.setEnabled(True)
                         parmObj = opObj.getParameterObj(parameterName='zmin')
                         if parmObj == None:
                             self.specGgraphDbsrange.clear()
                         else:
                             value1 = opObj.getParameterValue(parameterName='zmin')
                             value1 = str(value1)
                             value2 = opObj.getParameterValue(parameterName='zmax')
                             value2 = str(value2)
                             value = value1 + "," + value2
                             self.specGgraphDbsrange.setText(value)
                             self.specGgraphDbsrange.setEnabled(True)
                         parmObj = opObj.getParameterObj(parameterName="save")
                         if parmObj == None:
                             self.specGraphSaveSpectra.setCheckState(0)
                         else:
                             self.specGraphSaveSpectra.setCheckState(QtCore.Qt.Checked)
                         parmObj = opObj.getParameterObj(parameterName="ftp")
                         if parmObj == None:
                             self.specGraphftpSpectra.setCheckState(0)
                         else:
                             self.specGraphftpSpectra.setCheckState(QtCore.Qt.Checked)
                         parmObj = opObj.getParameterObj(parameterName="figpath")
                         if parmObj:
                             value = parmObj.getValue()
                             self.specGraphPath.setText(value)
                         parmObj = opObj.getParameterObj(parameterName="wr_period")
                         if parmObj:
                             value = parmObj.getValue()
                             self.specGgraphftpratio.setText(str(value))
                     opObj = puObj.getOperationObj(name='CrossSpectraPlot')
                     if opObj == None:
                         self.specGraphCebCrossSpectraplot.setCheckState(0)
                         self.specGraphSaveCross.setCheckState(0)
                         self.specGraphftpCross.setCheckState(0)
                     else:
                         operationCrossSpectraPlot = "Enable"
                         self.specGraphCebCrossSpectraplot.setCheckState(QtCore.Qt.Checked)
                         parmObj = opObj.getParameterObj(parameterName='xmin')
                         if parmObj == None:
                             self.specGgraphFreq.clear()
                         else:
                             value1 = opObj.getParameterValue(parameterName='xmin')
                             value1 = str(value1)
                             value2 = opObj.getParameterValue(parameterName='xmax')
                             value2 = str(value2)
                             value = value1 + "," + value2
                             self.specGgraphFreq.setText(value)
                             self.specGgraphFreq.setEnabled(True)
                         parmObj = opObj.getParameterObj(parameterName='ymin')
                         if parmObj == None:
                             self.specGgraphHeight.clear()
                         else:
                             value1 = opObj.getParameterValue(parameterName='ymin')
                             value1 = str(value1)
                             value2 = opObj.getParameterValue(parameterName='ymax')
                             value2 = str(value2)
                             value = value1 + "," + value2
                             self.specGgraphHeight.setText(value)
                             self.specGgraphHeight.setEnabled(True)
                         parmObj = opObj.getParameterObj(parameterName='zmin')
                         if parmObj == None:
                             self.specGgraphDbsrange.clear()
                         else:
                             value1 = opObj.getParameterValue(parameterName='zmin')
                             value1 = str(value1)
                             value2 = opObj.getParameterValue(parameterName='zmax')
                             value2 = str(value2)
                             value = value1 + "," + value2
                             self.specGgraphDbsrange.setText(value)
                             self.specGgraphDbsrange.setEnabled(True)
                         parmObj = opObj.getParameterObj(parameterName='coh_min')
                         if parmObj == None:
                             self.specGgraphmagnitud.clear()
                         else:
                             value1 = opObj.getParameterValue(parameterName='coh_min')
                             value1 = str(value1)
                             value2 = opObj.getParameterValue(parameterName='coh_max')
                             value2 = str(value2)
                             value = value1 + "," + value2
                             self.specGgraphmagnitud.setText(value)
                             self.specGgraphmagnitud.setEnabled(True)
                         parmObj = opObj.getParameterObj(parameterName='phase_min')
                         if parmObj == None:
                             self.specGgraphPhase.clear()
                         else:
                             value1 = opObj.getParameterValue(parameterName='phase_min')
                             value1 = str(value1)
                             value2 = opObj.getParameterValue(parameterName='phase_max')
                             value2 = str(value2)
                             value = value1 + "," + value2
                             self.specGgraphPhase.setText(value)
                             self.specGgraphPhase.setEnabled(True)
                         parmObj = opObj.getParameterObj(parameterName="save")
                         if parmObj == None:
                             self.specGraphSaveCross.setCheckState(0)
                         else:
                             self.specGraphSaveCross.setCheckState(QtCore.Qt.Checked)
                         parmObj = opObj.getParameterObj(parameterName="ftp")
                         if parmObj == None:
                             self.specGraphftpCross.setCheckState(0)
                         else:
                             self.specGraphftpCross.setCheckState(QtCore.Qt.Checked)
                         parmObj = opObj.getParameterObj(parameterName="figpath")
                         if parmObj:
                             value = parmObj.getValue()
                             self.specGraphPath.setText(value)
                         parmObj = opObj.getParameterObj(parameterName="wr_period")
                         if parmObj:
                             value = parmObj.getValue()
                             self.specGgraphftpratio.setText(str(value))
                     opObj = puObj.getOperationObj(name='RTIPlot')
                     if opObj == None:
                         self.specGraphCebRTIplot.setCheckState(0)
                         self.specGraphSaveRTIplot.setCheckState(0)
                         self.specGraphftpRTIplot.setCheckState(0)
                     else:
                         self.specGraphCebRTIplot.setCheckState(QtCore.Qt.Checked)
                         parmObj = opObj.getParameterObj(parameterName='channelList')
                         if parmObj == None:
                             self.specGgraphChannelList.clear()
                         else:
                             value = opObj.getParameterValue(parameterName='channelList')
                             channelListRTIPlot = str(value)[1:-1]
                             self.specGgraphChannelList.setText(channelListRTIPlot)
                             self.specGgraphChannelList.setEnabled(True)
                         parmObj = opObj.getParameterObj(parameterName='xmin')
                         if parmObj == None:
                             self.specGgraphTminTmax.clear()
                         else:
                             value1 = opObj.getParameterValue(parameterName='xmin')
                             value1 = str(value1)
                             value2 = opObj.getParameterValue(parameterName='xmax')
                             value2 = str(value2)
                             value = value1 + "," + value2
                             self.specGgraphTminTmax.setText(value)
                             self.specGgraphTminTmax.setEnabled(True)
                         parmObj = opObj.getParameterObj(parameterName='timerange')
                         if parmObj == None:
                             self.specGgraphTimeRange.clear()
                         else:
                             value1 = opObj.getParameterValue(parameterName='timerange')
                             value1 = str(value1)
                             self.specGgraphTimeRange.setText(value1)
                             self.specGgraphTimeRange.setEnabled(True)
                         parmObj = opObj.getParameterObj(parameterName='ymin')
                         if parmObj == None:
                             self.specGgraphHeight.clear()
                         else:
                             value1 = opObj.getParameterValue(parameterName='ymin')
                             value1 = str(value1)
                             value2 = opObj.getParameterValue(parameterName='ymax')
                             value2 = str(value2)
                             value = value1 + "," + value2
                             self.specGgraphHeight.setText(value)
                             self.specGgraphHeight.setEnabled(True)
                         parmObj = opObj.getParameterObj(parameterName='zmin')
                         if parmObj == None:
                             self.specGgraphDbsrange.clear()
                         else:
                             value1 = opObj.getParameterValue(parameterName='zmin')
                             value1 = str(value1)
                             value2 = opObj.getParameterValue(parameterName='zmax')
                             value2 = str(value2)
                             value = value1 + "," + value2
                             self.specGgraphDbsrange.setText(value)
                             self.specGgraphDbsrange.setEnabled(True)
                         parmObj = opObj.getParameterObj(parameterName="save")
                         if parmObj == None:
                             self.specGraphSaveRTIplot.setCheckState(0)
                         else:
                             self.specGraphSaveRTIplot.setCheckState(QtCore.Qt.Checked)
                         parmObj = opObj.getParameterObj(parameterName="ftp")
                         if parmObj == None:
                             self.specGraphftpRTIplot.setCheckState(0)
                         else:
                             self.specGraphftpRTIplot.setCheckState(QtCore.Qt.Checked)
                         parmObj = opObj.getParameterObj(parameterName="figpath")
                         if parmObj:
                             value = parmObj.getValue()
                             self.specGraphPath.setText(value)
                         parmObj = opObj.getParameterObj(parameterName="wr_period")
                         if parmObj:
                             value = parmObj.getValue()
                             self.specGgraphftpratio.setText(str(value))
                     opObj = puObj.getOperationObj(name='CoherenceMap')
                     if opObj == None:
                         self.specGraphCebCoherencmap.setCheckState(0)
                         self.specGraphSaveCoherencemap.setCheckState(0)
                         self.specGraphftpCoherencemap.setCheckState(0)
                     else:
                         operationCoherenceMap = "Enable"
                         self.specGraphCebCoherencmap.setCheckState(QtCore.Qt.Checked)
                         parmObj = opObj.getParameterObj(parameterName='xmin')
                         if parmObj == None:
                             self.specGgraphTminTmax.clear()
                         else:
                             value1 = opObj.getParameterValue(parameterName='xmin')
                             value1 = str(value1)
                             value2 = opObj.getParameterValue(parameterName='xmax')
                             value2 = str(value2)
                             value = value1 + "," + value2
                             self.specGgraphTminTmax.setText(value)
                             self.specGgraphTminTmax.setEnabled(True)
                         parmObj = opObj.getParameterObj(parameterName='timerange')
                         if parmObj == None:
                             self.specGgraphTimeRange.clear()
                         else:
                             value1 = opObj.getParameterValue(parameterName='timerange')
                             value1 = str(value1)
                             self.specGgraphTimeRange.setText(value1)
                             self.specGgraphTimeRange.setEnabled(True)
                         parmObj = opObj.getParameterObj(parameterName='ymin')
                         if parmObj == None:
                             self.specGgraphHeight.clear()
                         else:
                             value1 = opObj.getParameterValue(parameterName='ymin')
                             value1 = str(value1)
                             value2 = opObj.getParameterValue(parameterName='ymax')
                             value2 = str(value2)
                             value = value1 + "," + value2
                             self.specGgraphHeight.setText(value)
                             self.specGgraphHeight.setEnabled(True)
                         parmObj = opObj.getParameterObj(parameterName='zmin')
                         if parmObj == None:
                             self.specGgraphmagnitud.clear()
                         else:
                             value1 = opObj.getParameterValue(parameterName='zmin')
                             value1 = str(value1)
                             value2 = opObj.getParameterValue(parameterName='zmax')
                             value2 = str(value2)
                             value = value1 + "," + value2
                             self.specGgraphmagnitud.setText(value)
                             self.specGgraphmagnitud.setEnabled(True)
                         parmObj = opObj.getParameterObj(parameterName='coh_min')
                         if parmObj == None:
                             self.specGgraphmagnitud.clear()
                         else:
                             value1 = opObj.getParameterValue(parameterName='coh_min')
                             value1 = str(value1)
                             value2 = opObj.getParameterValue(parameterName='coh_max')
                             value2 = str(value2)
                             value = value1 + "," + value2
                             self.specGgraphmagnitud.setText(value)
                             self.specGgraphmagnitud.setEnabled(True)
                         parmObj = opObj.getParameterObj(parameterName='phase_min')
                         if parmObj == None:
                             self.specGgraphPhase.clear()
                         else:
                             value1 = opObj.getParameterValue(parameterName='phase_min')
                             value1 = str(value1)
                             value2 = opObj.getParameterValue(parameterName='phase_max')
                             value2 = str(value2)
                             value = value1 + "," + value2
                             self.specGgraphPhase.setText(value)
                             self.specGgraphPhase.setEnabled(True)
                         parmObj = opObj.getParameterObj(parameterName="save")
                         if parmObj == None:
                             self.specGraphSaveCoherencemap.setCheckState(0)
                         else:
                             self.specGraphSaveCoherencemap.setCheckState(QtCore.Qt.Checked)
                         parmObj = opObj.getParameterObj(parameterName="ftp")
                         if parmObj == None:
                             self.specGraphftpCoherencemap.setCheckState(0)
                         else:
                             self.specGraphftpCoherencemap.setCheckState(QtCore.Qt.Checked)
                         parmObj = opObj.getParameterObj(parameterName="figpath")
                         if parmObj:
                             value = parmObj.getValue()
                             self.specGraphPath.setText(value)
                         parmObj = opObj.getParameterObj(parameterName="wr_period")
                         if parmObj:
                             value = parmObj.getValue()
                             self.specGgraphftpratio.setText(str(value))
                     opObj = puObj.getOperationObj(name='PowerProfilePlot')
                     if opObj == None:
                         self.specGraphPowerprofile.setCheckState(0)
                         self.specGraphSavePowerprofile.setCheckState(0)
                         self.specGraphftpPowerprofile.setCheckState(0)
                         operationPowerProfilePlot = "Disabled"
                         channelList = None
                         freq_vel = None
                         heightsrange = None
                     else:
                         operationPowerProfilePlot = "Enable"
                         self.specGraphPowerprofile.setCheckState(QtCore.Qt.Checked)
                         parmObj = opObj.getParameterObj(parameterName='xmin')
                         if parmObj == None:
                             self.specGgraphDbsrange.clear()
                         else:
                             value1 = opObj.getParameterValue(parameterName='xmin')
                             value1 = str(value1)
                             value2 = opObj.getParameterValue(parameterName='xmax')
                             value2 = str(value2)
                             value = value1 + "," + value2
                             self.specGgraphDbsrange.setText(value)
                             self.specGgraphDbsrange.setEnabled(True)
                         parmObj = opObj.getParameterObj(parameterName='ymin')
                         if parmObj == None:
                             self.specGgraphHeight.clear()
                         else:
                             value1 = opObj.getParameterValue(parameterName='ymin')
                             value1 = str(value1)
                             value2 = opObj.getParameterValue(parameterName='ymax')
                             value2 = str(value2)
                             value = value1 + "," + value2
                             self.specGgraphHeight.setText(value)
                             self.specGgraphHeight.setEnabled(True)
                         parmObj = opObj.getParameterObj(parameterName="save")
                         if parmObj == None:
                             self.specGraphSavePowerprofile.setCheckState(0)
                         else:
                             self.specGraphSavePowerprofile.setCheckState(QtCore.Qt.Checked)
                         parmObj = opObj.getParameterObj(parameterName="ftp")
                         if parmObj == None:
                             self.specGraphftpPowerprofile.setCheckState(0)
                         else:
                             self.specGraphftpPowerprofile.setCheckState(QtCore.Qt.Checked)
                         parmObj = opObj.getParameterObj(parameterName="figpath")
                         if parmObj:
                             value = parmObj.getValue()
                             self.specGraphPath.setText(value)
                         parmObj = opObj.getParameterObj(parameterName="wr_period")
                         if parmObj:
                             value = parmObj.getValue()
                             self.specGgraphftpratio.setText(str(value))
                     opObj = puObj.getOperationObj(name='Noise')
                     if opObj == None:
                         self.specGraphCebRTInoise.setCheckState(0)
                         self.specGraphSaveRTInoise.setCheckState(0)
                         self.specGraphftpRTInoise.setCheckState(0)
                     else:
                         self.specGraphCebRTInoise.setCheckState(QtCore.Qt.Checked)
                         parmObj = opObj.getParameterObj(parameterName='channelList')
                         if parmObj == None:
                                self.specGgraphChannelList.clear()
                         else:
                             value = opObj.getParameterValue(parameterName='channelList')
                             channelListRTINoise = str(value)[1:-1]
                             self.specGgraphChannelList.setText(channelListRTINoise)
                             self.specGgraphChannelList.setEnabled(True)
                         parmObj = opObj.getParameterObj(parameterName='xmin')
                         if parmObj == None:
                             self.specGgraphTminTmax.clear()
                         else:
                             value1 = opObj.getParameterValue(parameterName='xmin')
                             value1 = str(value1)
                             value2 = opObj.getParameterValue(parameterName='xmax')
                             value2 = str(value2)
                             value = value1 + "," + value2
                             self.specGgraphTminTmax.setText(value)
                             self.specGgraphTminTmax.setEnabled(True)
                         parmObj = opObj.getParameterObj(parameterName='timerange')
                         if parmObj == None:
                             self.specGgraphTimeRange.clear()
                         else:
                             value1 = opObj.getParameterValue(parameterName='timerange')
                             value1 = str(value1)
                             self.specGgraphTimeRange.setText(value1)
                             self.specGgraphTimeRange.setEnabled(True)
                         parmObj = opObj.getParameterObj(parameterName='ymin')
                         if parmObj == None:
                             self.specGgraphDbsrange.clear()
                         else:
                             value1 = opObj.getParameterValue(parameterName='ymin')
                             value1 = str(value1)
                             value2 = opObj.getParameterValue(parameterName='ymax')
                             value2 = str(value2)
                             value = value1 + "," + value2
                             self.specGgraphDbsrange.setText(value)
                             self.specGgraphDbsrange.setEnabled(True)
                         parmObj = opObj.getParameterObj(parameterName="save")
                         if parmObj == None:
                             self.specGraphSaveRTInoise.setCheckState(0)
                         else:
                             self.specGraphSaveRTInoise.setCheckState(QtCore.Qt.Checked)
                         parmObj = opObj.getParameterObj(parameterName="ftp")
                         if parmObj == None:
                             self.specGraphftpRTInoise.setCheckState(0)
                         else:
                             self.specGraphftpRTInoise.setCheckState(QtCore.Qt.Checked)
                         parmObj = opObj.getParameterObj(parameterName="figpath")
                         if parmObj:
                             value = parmObj.getValue()
                             self.specGraphPath.setText(value)
                         parmObj = opObj.getParameterObj(parameterName="wr_period")
                         if parmObj:
                             value = parmObj.getValue()
                             self.specGgraphftpratio.setText(str(value))
                     opObj = puObj.getOperationObj(name='SpectraWriter')
                     if opObj == None:
                         self.specOutputPath.clear()
                         self.specOutputblocksperfile.clear()
                     else:
                         value = opObj.getParameterObj(parameterName='path')
                         if value == None:
                             self.specOutputPath.clear()
                         else:
                             value = opObj.getParameterValue(parameterName='path')
                             path = str(value)
                             self.specOutputPath.setText(path)
                         value = opObj.getParameterObj(parameterName='blocksPerFile')
                         if value == None:
                            self.specOutputblocksperfile.clear()
                         else:
                             value = opObj.getParameterValue(parameterName='blocksPerFile')
                             blocksperfile = str(value)
                             self.specOutputblocksperfile.setText(blocksperfile)
                     return
                 def __refreshSpectraHeisWindow(self, puObj):
                     opObj = puObj.getOperationObj(name="IncohInt4SpectraHeis")
                     if opObj == None:
                         self.specHeisOpIncoherent.clear()
                         self.specHeisOpCebIncoherent.setCheckState(0)
                     else:
                         for parmObj in opObj.getParameterObjList():
                            if parmObj.name == 'timeInterval':
                                value = opObj.getParameterValue(parameterName='timeInterval')
                                value = float(value)
                                self.specHeisOpIncoherent.setText(str(value))
                                self.specHeisOpIncoherent.setEnabled(True)
                                self.specHeisOpCebIncoherent.setCheckState(QtCore.Qt.Checked)
                                self.specHeisOpCobIncInt.setCurrentIndex(0)
                     # SpectraHeis Graph
                     self.specHeisGgraphXminXmax.clear()
                     self.specHeisGgraphYminYmax.clear()
                     self.specHeisGgraphChannelList.clear()
                     self.specHeisGgraphTminTmax.clear()
                     self.specHeisGgraphTimeRange.clear()
                     self.specHeisGgraphftpratio.clear()
                     opObj = puObj.getOperationObj(name='SpectraHeisScope')
                     if opObj == None:
                         self.specHeisGraphCebSpectraplot.setCheckState(0)
                         self.specHeisGraphSaveSpectra.setCheckState(0)
                         self.specHeisGraphftpSpectra.setCheckState(0)
                     else:
                         operationSpectraHeisScope = "Enable"
                         self.specHeisGraphCebSpectraplot.setCheckState(QtCore.Qt.Checked)
                         parmObj = opObj.getParameterObj(parameterName='channelList')
                         if parmObj == None:
                             self.specHeisGgraphChannelList.clear()
                         else:
                             value = opObj.getParameterValue(parameterName='channelList')
                             channelListSpectraHeisScope = str(value)[1:-1]
                             self.specHeisGgraphChannelList.setText(channelListSpectraHeisScope)
                             self.specHeisGgraphChannelList.setEnabled(True)
                         parmObj = opObj.getParameterObj(parameterName='xmin')
                         if parmObj == None:
                             self.specHeisGgraphXminXmax.clear()
                         else:
                             value1 = opObj.getParameterValue(parameterName='xmin')
                             value1 = str(value1)
                             value2 = opObj.getParameterValue(parameterName='xmax')
                             value2 = str(value2)
                             value = value1 + "," + value2
                             self.specHeisGgraphXminXmax.setText(value)
                             self.specHeisGgraphXminXmax.setEnabled(True)
                         parmObj = opObj.getParameterObj(parameterName='ymin')
                         if parmObj == None:
                             self.specHeisGgraphYminYmax.clear()
                         else:
                             value1 = opObj.getParameterValue(parameterName='ymin')
                             value1 = str(value1)
                             value2 = opObj.getParameterValue(parameterName='ymax')
                             value2 = str(value2)
                             value = value1 + "," + value2
                             self.specHeisGgraphYminYmax.setText(value)
                             self.specHeisGgraphYminYmax.setEnabled(True)
                         parmObj = opObj.getParameterObj(parameterName="save")
                         if parmObj == None:
                             self.specHeisGraphSaveSpectra.setCheckState(0)
                         else:
                             self.specHeisGraphSaveSpectra.setCheckState(QtCore.Qt.Checked)
                         parmObj = opObj.getParameterObj(parameterName="ftp")
                         if parmObj == None:
                             self.specHeisGraphftpSpectra.setCheckState(0)
                         else:
                             self.specHeisGraphftpSpectra.setCheckState(QtCore.Qt.Checked)
                         parmObj = opObj.getParameterObj(parameterName="figpath")
                         if parmObj:
                             value = parmObj.getValue()
                             self.specHeisGraphPath.setText(value)
                         parmObj = opObj.getParameterObj(parameterName="wr_period")
                         if parmObj:
                             value = parmObj.getValue()
                             self.specHeisGgraphftpratio.setText(str(value))
                     opObj = puObj.getOperationObj(name='RTIfromSpectraHeis')
                     if opObj == None:
                         self.specHeisGraphCebRTIplot.setCheckState(0)
                         self.specHeisGraphSaveRTIplot.setCheckState(0)
                         self.specHeisGraphftpRTIplot.setCheckState(0)
                     else:
                         self.specHeisGraphCebRTIplot.setCheckState(QtCore.Qt.Checked)
                         parmObj = opObj.getParameterObj(parameterName='channelList')
                         if parmObj == None:
                             self.specHeisGgraphChannelList.clear()
                         else:
                             value = opObj.getParameterValue(parameterName='channelList')
                             channelListRTIPlot = str(value)[1:-1]
                             self.specGgraphChannelList.setText(channelListRTIPlot)
                             self.specGgraphChannelList.setEnabled(True)
                         parmObj = opObj.getParameterObj(parameterName='xmin')
                         if parmObj == None:
                             self.specHeisGgraphTminTmax.clear()
                         else:
                             value1 = opObj.getParameterValue(parameterName='xmin')
                             value1 = str(value1)
                             value2 = opObj.getParameterValue(parameterName='xmax')
                             value2 = str(value2)
                             value = value1 + "," + value2
                             self.specHeisGgraphTminTmax.setText(value)
                             self.specHeisGgraphTminTmax.setEnabled(True)
                         parmObj = opObj.getParameterObj(parameterName='timerange')
                         if parmObj == None:
                             self.specGgraphTimeRange.clear()
                         else:
                             value1 = opObj.getParameterValue(parameterName='timerange')
                             value1 = str(value1)
                             self.specHeisGgraphTimeRange.setText(value1)
                             self.specHeisGgraphTimeRange.setEnabled(True)
                         parmObj = opObj.getParameterObj(parameterName='ymin')
                         if parmObj == None:
                             self.specHeisGgraphYminYmax.clear()
                         else:
                             value1 = opObj.getParameterValue(parameterName='ymin')
                             value1 = str(value1)
                             value2 = opObj.getParameterValue(parameterName='ymax')
                             value2 = str(value2)
                             value = value1 + "," + value2
                             self.specHeisGgraphYminYmax.setText(value)
                             self.specHeisGgraphYminYmax.setEnabled(True)
                         parmObj = opObj.getParameterObj(parameterName="save")
                         if parmObj == None:
                             self.specHeisGraphSaveRTIplot.setCheckState(0)
                         else:
                             self.specHeisGraphSaveRTIplot.setCheckState(QtCore.Qt.Checked)
                         parmObj = opObj.getParameterObj(parameterName="ftp")
                         if parmObj == None:
                             self.specHeisGraphftpRTIplot.setCheckState(0)
                         else:
                             self.specHeisGraphftpRTIplot.setCheckState(QtCore.Qt.Checked)
                         parmObj = opObj.getParameterObj(parameterName="figpath")
                         if parmObj:
                             value = parmObj.getValue()
                             self.specHeisGraphPath.setText(value)
                         parmObj = opObj.getParameterObj(parameterName="wr_period")
                         if parmObj:
                             value = parmObj.getValue()
                             self.specHeisGgraphftpratio.setText(str(value))
                     # outputSpectraHeisWrite
                     opObj = puObj.getOperationObj(name='FitsWriter')
                     if opObj == None:
                         self.specHeisOutputPath.clear()
                         self.specHeisOutputblocksperfile.clear()
                         self.specHeisOutputMetada.clear()
                     else:
                         value = opObj.getParameterObj(parameterName='path')
                         if value == None:
                             self.specHeisOutputPath.clear()
                         else:
                             value = opObj.getParameterValue(parameterName='path')
                             path = str(value)
                             self.specHeisOutputPath.setText(path)
                         value = opObj.getParameterObj(parameterName='dataBlocksPerFile')
                         if value == None:
                            self.specHeisOutputblocksperfile.clear()
                         else:
                             value = opObj.getParameterValue(parameterName='dataBlocksPerFile')
                             blocksperfile = str(value)
                             self.specHeisOutputblocksperfile.setText(blocksperfile)
                         value = opObj.getParameterObj(parameterName='metadatafile')
                         if value == None:
                             self.specHeisOutputMetada.clear()
                         else:
                             value = opObj.getParameterValue(parameterName='metadatafile')
-                            metada = str(value)
+                            metadata_file = str(value)
-                            self.specHeisOutputMetada.setText(metada)
+                            self.specHeisOutputMetada.setText(metadata_file)
                     return
                 def __refreshCorrelationWindow(self, puObj):
                     pass
                 def refreshPUWindow(self, puObj):
                     if puObj.datatype == 'Voltage':
                         self.__refreshVoltageWindow(puObj)
                     if puObj.datatype == 'Spectra':
                         self.__refreshSpectraWindow(puObj)
                     if puObj.datatype == 'SpectraHeis':
                         self.__refreshSpectraHeisWindow(puObj)
                 def refreshProjectProperties(self, projectObjView):
                     propertyBuffObj = PropertyBuffer()
                     name = projectObjView.name
                     propertyBuffObj.append("Properties", "Name", projectObjView.name),
                     propertyBuffObj.append("Properties", "Description", projectObjView.description)
                     propertyBuffObj.append("Properties", "Workspace", self.pathWorkSpace)
                     readUnitObj = projectObjView.getReadUnitObj()
                     runOperationObj = readUnitObj.getOperationObj(name='run')
                     for thisParmObj in runOperationObj.getParameterObjList():
                         propertyBuffObj.append("Reading parms", thisParmObj.name, str(thisParmObj.getValue()))
                     propertiesModel = propertyBuffObj.getPropertyModel()
                     self.treeProjectProperties.setModel(propertiesModel)
                     self.treeProjectProperties.expandAll()
                     self.treeProjectProperties.resizeColumnToContents(0)
                     self.treeProjectProperties.resizeColumnToContents(1)
                 def refreshPUProperties(self, puObjView):
                     ############ FTP CONFIG ################################
                     #Deleting FTP Conf. This processing unit have not got any
                     #FTP configuration by default
                     if puObjView.id in self.__puLocalFolder2FTP.keys():
                         self.__puLocalFolder2FTP.pop(puObjView.id)
                     ########################################################
                     propertyBuffObj = PropertyBuffer()
                     for thisOp in puObjView.getOperationObjList():
                         operationName = thisOp.name
                         if operationName == 'run':
                             operationName = 'Properties'
                         else:
                             if not thisOp.getParameterObjList():
                                 propertyBuffObj.append(operationName, '--', '--')
                                 continue
                         for thisParmObj in thisOp.getParameterObjList():
                             propertyBuffObj.append(operationName, thisParmObj.name, str(thisParmObj.getValue()))
                             ############ FTP CONFIG ################################
                             if thisParmObj.name == "ftp_wei" and thisParmObj.getValue():
                                 value = thisParmObj.getValue()
                                 self.temporalFTP.ftp_wei = value
                             if thisParmObj.name == "exp_code" and thisParmObj.getValue():
                                 value = thisParmObj.getValue()
                                 self.temporalFTP.exp_code = value
                             if thisParmObj.name == "sub_exp_code" and thisParmObj.getValue():
                                 value = thisParmObj.getValue()
                                 self.temporalFTP.sub_exp_code = value
                             if thisParmObj.name == "plot_pos" and thisParmObj.getValue():
                                 value = thisParmObj.getValue()
                                 self.temporalFTP.plot_pos = value
                             if thisParmObj.name == 'ftp' and thisParmObj.getValue():
                                 figpathObj = thisOp.getParameterObj('figpath')
                                 if figpathObj:
                                     self.__puLocalFolder2FTP[puObjView.id] = figpathObj.getValue()
                             ########################################################
                     propertiesModel = propertyBuffObj.getPropertyModel()
                     self.treeProjectProperties.setModel(propertiesModel)
                     self.treeProjectProperties.expandAll()
                     self.treeProjectProperties.resizeColumnToContents(0)
                     self.treeProjectProperties.resizeColumnToContents(1)
                 def refreshGraphicsId(self):
                     projectObj = self.getSelectedProjectObj()
                     if not projectObj:
                         return
                     for idPU, puObj in projectObj.procUnitConfObjDict.items():
                         for opObj in puObj.getOperationObjList():
                             if opObj.name not in ('Scope', 'SpectraPlot', 'CrossSpectraPlot', 'RTIPlot', 'CoherenceMap', 'PowerProfilePlot', 'Noise', 'SpectraHeisScope', 'RTIfromSpectraHeis'):
                                 continue
                             opObj.changeParameter(name='id', value=opObj.id, format='int')
                 def on_click(self, index):
                     self.selectedItemTree = self.projectExplorerModel.itemFromIndex(index)
                     projectObjView = self.getSelectedProjectObj()
                     if not projectObjView:
                         return
                     self.create = False
                     selectedObjView = self.getSelectedItemObj()
                     #A project has been selected
                     if projectObjView == selectedObjView:
                         self.refreshProjectWindow(projectObjView)
                         self.refreshProjectProperties(projectObjView)
                         self.tabProject.setEnabled(True)
                         self.tabVoltage.setEnabled(False)
                         self.tabSpectra.setEnabled(False)
                         self.tabCorrelation.setEnabled(False)
                         self.tabSpectraHeis.setEnabled(False)
                         self.tabWidgetProject.setCurrentWidget(self.tabProject)
                         return
                     #A processing unit has been selected
                     voltEnable = False
                     specEnable = False
                     corrEnable = False
                     specHeisEnable = False
                     tabSelected = self.tabProject
                     puObj = selectedObjView
                     self.refreshPUWindow(puObj)
                     self.refreshPUProperties(puObj)
                     self.showtabPUCreated(puObj.datatype)
                 def on_right_click(self, pos):
                     self.menu = QtGui.QMenu()
                     quitAction0 = self.menu.addAction("Create a New Project")
                     quitAction1 = self.menu.addAction("Create a New Processing Unit")
                     quitAction2 = self.menu.addAction("Delete Item")
                     quitAction3 = self.menu.addAction("Quit")
                     if len(self.__itemTreeDict) == 0:
                         quitAction2.setEnabled(False)
                     else:
                         quitAction2.setEnabled(True)
                     action = self.menu.exec_(self.mapToGlobal(pos))
                     if action == quitAction0:
                        self. setInputsProject_View()
                        self.create = True
                     if action == quitAction1:
                         if len(self.__projectObjDict) == 0:
                             outputstr = "You need to create a Project before adding a Processing Unit"
                             self.console.clear()
                             self.console.append(outputstr)
                             return 0
                         else:
                            self.addPUWindow()
                            self.console.clear()
                            self.console.append("Please, Choose the type of Processing Unit")
             #                self.console.append("If your Datatype is rawdata, you will start with processing unit Type Voltage")
             #                self.console.append("If your Datatype is pdata, you will choose between processing unit Type Spectra or Correlation")
             #                self.console.append("If your Datatype is fits, you will start with processing unit Type SpectraHeis")
                     if action == quitAction2:
                         index = self.selectedItemTree
                         try:
                             index.parent()
                         except:
                             self.console.append('Please first select a Project or Processing Unit')
                             return 0
                         # print index.parent(),index
                         if index.parent() == None:
                            self.projectExplorerModel.removeRow(index.row())
                         else:
                             index.parent().removeRow(index.row())
                         self.removeItemTreeFromProject()
                         self.console.clear()
                         # for i in self.projectExplorerTree.selectionModel().selection().indexes():
                         #     print i.row()
                     if action == quitAction3:
                         self.close()
                         return 0
                 def createProjectView(self, id):
             #         project_name, description, datatype, data_path, starDate, endDate, startTime, endTime, online, delay, walk, set = self.getParmsFromProjectWindow()
                     id = str(id)
                     projectParms = self.__getParmsFromProjectWindow()
                     if not projectParms.isValid():
                         return None
                     projectObjView = Project()
                     projectObjView.setup(id=id, name=projectParms.name, description=projectParms.description)
                     self.__projectObjDict[id] = projectObjView
                     self.addProject2ProjectExplorer(id=id, name=projectObjView.name)
                     return projectObjView
                 def updateProjectView(self):
             #         project_name, description, datatype, data_path, starDate, endDate, startTime, endTime, online, delay, walk, set = self.getParmsFromProjectWindow()
                     projectParms = self.__getParmsFromProjectWindow()
                     if not projectParms.isValid():
                         return None
                     projectObjView = self.getSelectedProjectObj()
                     if not projectObjView:
                         self.console.append("Please select a project before update it")
                         return None
                     projectObjView.update(name=projectParms.name, description=projectParms.description)
                     return projectObjView
                 def createReadUnitView(self, projectObjView):
             #         project_name, description, datatype, data_path, startDate, endDate, startTime, endTime, online, delay, walk, set = self.getParmsFromProjectWindow()
                     projectParms = self.__getParmsFromProjectWindow()
                     if not projectParms.isValid():
                         return None
                     if projectParms.datatype in ("Voltage", "Spectra", "Fits"):
                         readUnitConfObj = projectObjView.addReadUnit(datatype=projectParms.datatype,
                                                                         path=projectParms.dpath,
                                                                         startDate=projectParms.startDate,
                                                                         endDate=projectParms.endDate,
                                                                         startTime=projectParms.startTime,
                                                                         endTime=projectParms.endTime,
                                                                         online=projectParms.online,
                                                                         walk=projectParms.walk
                                                                         )
                         if projectParms.set:
                             readUnitConfObj.addParameter(name="set", value=projectParms.set, format="int")
                         if projectParms.delay:
                             readUnitConfObj.addParameter(name="delay", value=projectParms.delay, format="int")
                         if projectParms.expLabel:
                             readUnitConfObj.addParameter(name="expLabel", value=projectParms.expLabel)
                         readUnitConfObj.addOperation(name="printInfo")
                     if projectParms.datatype == "USRP":
                         readUnitConfObj = projectObjView.addReadUnit(datatype=projectParms.datatype,
                                                                         path=projectParms.dpath,
                                                                         startDate=projectParms.startDate,
                                                                         endDate=projectParms.endDate,
                                                                         startTime=projectParms.startTime,
                                                                         endTime=projectParms.endTime,
                                                                         online=projectParms.online,
                                                                         ippKm=projectParms.ippKm
                                                                         )
                         if projectParms.delay:
                             readUnitConfObj.addParameter(name="delay", value=projectParms.delay, format="int")
                     return readUnitConfObj
                 def updateReadUnitView(self, projectObjView, idReadUnit):
             #         project_name, description, datatype, data_path, startDate, endDate, startTime, endTime, online, delay, walk , set = self.getParmsFromProjectWindow()
                     readUnitConfObj = projectObjView.getProcUnitObj(idReadUnit)
                     projectParms = self.__getParmsFromProjectWindow()
                     if not projectParms.isValid():
                         return None
                     if projectParms.datatype in ["Voltage", "Spectra", "Fits"]:
                         readUnitConfObj.update(datatype=projectParms.datatype,
                                                 path=projectParms.dpath,
                                                 startDate=projectParms.startDate,
                                                 endDate=projectParms.endDate,
                                                 startTime=projectParms.startTime,
                                                 endTime=projectParms.endTime,
                                                 online=projectParms.online,
                                                 walk=projectParms.walk
                                                 )
                         if projectParms.set:
                             readUnitConfObj.addParameter(name="set", value=projectParms.set, format="int")
                         if projectParms.delay:
                             readUnitConfObj.addParameter(name="delay", value=projectParms.delay, format="int")
                         if projectParms.expLabel:
                             readUnitConfObj.addParameter(name="expLabel", value=projectParms.expLabel)
                         readUnitConfObj.addOperation(name="printInfo")
                     if projectParms.datatype == "USRP":
                         readUnitConfObj.update(datatype=projectParms.datatype,
                                                 path=projectParms.dpath,
                                                 startDate=projectParms.startDate,
                                                 endDate=projectParms.endDate,
                                                 startTime=projectParms.startTime,
                                                 endTime=projectParms.endTime,
                                                 online=projectParms.online,
                                                 ippKm=projectParms.ippKm
                                                 )
                         if projectParms.delay:
                             readUnitConfObj.addParameter(name="delay", value=projectParms.delay, format="int")
                     return readUnitConfObj
                 def createProcUnitView(self, projectObjView, datatype, inputId):
                     procUnitConfObj = projectObjView.addProcUnit(datatype=datatype, inputId=inputId)
                     self.__puObjDict[procUnitConfObj.getId()] = procUnitConfObj
                     return procUnitConfObj
                 def updateProcUnitView(self, id):
                     procUnitConfObj = projectObjView.getProcUnitObj(id)
                     procUnitConfObj.removeOperations()
                     return procUnitConfObj
                 def addPUWindow(self):
                     self.configUPWindowObj = UnitProcessWindow(self)
                     fatherObj = self.getSelectedItemObj()
                     try:
                         fatherObj.getElementName()
                     except:
                         self.console.append("First left click on Project or Processing Unit")
                         return 0
                     if fatherObj.getElementName() == 'Project':
                         readUnitConfObj = fatherObj.getReadUnitObj()
                         self.configUPWindowObj.dataTypeProject = str(readUnitConfObj.datatype)
                     self.configUPWindowObj.getfromWindowList.append(fatherObj)
                     self.configUPWindowObj.loadTotalList()
                     self.configUPWindowObj.show()
                     self.configUPWindowObj.closed.connect(self.createPUWindow)
                 def createPUWindow(self):
                     if not self.configUPWindowObj.create:
                         return
                     fatherObj = self.configUPWindowObj.getFromWindow
                     datatype = self.configUPWindowObj.typeofUP
                     if fatherObj.getElementName() == 'Project':
                         inputId = fatherObj.getReadUnitId()
                         projectObjView = fatherObj
                     else:
                         inputId = fatherObj.getId()
                         projectObjView = self.getSelectedProjectObj()
                     if not projectObjView:
                         return
                     puObj = self.createProcUnitView(projectObjView, datatype, inputId)
                     self.addPU2ProjectExplorer(puObj)
                     self.showtabPUCreated(datatype)
                     self.clearPUWindow(datatype)
                     self.showPUinitView()
                 def addFTPConf2Operation(self, puObj, opObj):
                     if not self.temporalFTP.create:
                         self.temporalFTP.setwithoutconfiguration()
             #         opObj.addParameter(name='server', value=self.temporalFTP.server, format='str')
             #         opObj.addParameter(name='remotefolder', value=self.temporalFTP.remotefolder, format='str')
             #         opObj.addParameter(name='username', value=self.temporalFTP.username, format='str')
             #         opObj.addParameter(name='password', value=self.temporalFTP.password, format='str')
                     if self.temporalFTP.ftp_wei:
                         opObj.addParameter(name='ftp_wei', value=int(self.temporalFTP.ftp_wei), format='int')
                     if self.temporalFTP.exp_code:
                         opObj.addParameter(name='exp_code', value=int(self.temporalFTP.exp_code), format='int')
                     if self.temporalFTP.sub_exp_code:
                         opObj.addParameter(name='sub_exp_code', value=int(self.temporalFTP.sub_exp_code), format='int')
                     if self.temporalFTP.plot_pos:
                         opObj.addParameter(name='plot_pos', value=int(self.temporalFTP.plot_pos), format='int')
             #     def __checkFTPProcUnit(self, projectObj, localfolder):
             #
             #         puId = None
             #         puObj = None
             #
             #         for thisPuId, thisPuObj in projectObj.procUnitItems():
             #
             #             if not thisPuObj.name == "SendToServer":
             #                 continue
             #
             #             opObj = thisPuObj.getOperationObj(name='run')
             #
             #             parmObj = opObj.getParameterObj('localfolder')
             #
             #             #localfolder parameter should always be set, if it is not set then ProcUnit should be removed
             #             if not parmObj:
             #                 projectObj.removeProcUnit(thisPuId)
             #                 continue
             #
             #             thisLocalfolder = parmObj.getValue()
             #
             #             if localfolder != thisLocalfolder:
             #                 continue
             #
             #             puId = thisPuId
             #             puObj = thisPuObj
             #             break
             #
             #         return puObj
                 def createFTPProcUnitView(self):
                     if not self.temporalFTP.create:
                         self.temporalFTP.setwithoutconfiguration()
                     projectObj = self.getSelectedProjectObj()
                     if not projectObj:
                         return
                     self.removeAllFTPProcUnitView(projectObj)
                     if not self.__puLocalFolder2FTP:
                         return
                     folderList = ",".join(self.__puLocalFolder2FTP.values())
                     procUnitConfObj = projectObj.addProcUnit(name="SendToServer")
                     procUnitConfObj.addParameter(name='server', value=self.temporalFTP.server, format='str')
                     procUnitConfObj.addParameter(name='username', value=self.temporalFTP.username, format='str')
                     procUnitConfObj.addParameter(name='password', value=self.temporalFTP.password, format='str')
                     procUnitConfObj.addParameter(name='localfolder', value=folderList, format='list')
                     procUnitConfObj.addParameter(name='remotefolder', value=self.temporalFTP.remotefolder, format='str')
                     procUnitConfObj.addParameter(name='ext', value=self.temporalFTP.extension, format='str')
                     procUnitConfObj.addParameter(name='period', value=self.temporalFTP.period, format='int')
                     procUnitConfObj.addParameter(name='protocol', value=self.temporalFTP.protocol, format='str')
                     procUnitConfObj.addParameter(name='ftp_wei', value=self.temporalFTP.ftp_wei, format='int')
                     procUnitConfObj.addParameter(name='exp_code', value=self.temporalFTP.exp_code, format='int')
                     procUnitConfObj.addParameter(name='sub_exp_code', value=self.temporalFTP.sub_exp_code, format='int')
                     procUnitConfObj.addParameter(name='plot_pos', value=self.temporalFTP.plot_pos, format='int')
                     self.__puObjDict[procUnitConfObj.getId()] = procUnitConfObj
                 def removeAllFTPProcUnitView(self, projectObj):
                     for thisPuId, thisPuObj in projectObj.procUnitItems():
                         if not thisPuObj.name == "SendToServer":
                             continue
                         projectObj.removeProcUnit(thisPuId)
                         if thisPuId not in self.__puObjDict.keys():
                             continue
                         self.__puObjDict.pop(thisPuId)
                 def showPUinitView(self):
                     self.propertiesModel = TreeModel()
                     self.propertiesModel.initPUVoltageView()
                     self.treeProjectProperties.setModel(self.propertiesModel)
                     self.treeProjectProperties.expandAll()
                     self.treeProjectProperties.allColumnsShowFocus()
                     self.treeProjectProperties.resizeColumnToContents(1)
                 def saveFTPFromOpObj(self, operationObj):
                     if operationObj.name != "SendByFTP":
                         return
                     server = operationObj.getParameterValue("server")
                     username = operationObj.getParameterValue("username")
                     password = operationObj.getParameterValue("password")
                     localfolder = operationObj.getParameterValue("localfolder")
                     remotefolder = operationObj.getParameterValue("remotefolder")
                     ext = operationObj.getParameterValue("ext")
                     period = operationObj.getParameterValue("period")
                     self.temporalFTP.save(server=server,
                                           remotefolder=remotefolder,
                                           username=username,
                                           password=password,
                                           localfolder=localfolder,
                                           extension=ext)
                     return
                 def saveFTPFromProcUnitObj(self, puObj):
                     opObj = puObj.getOperationObj(name="run")
                     parmObj = opObj.getParameterObj(parameterName="server")
                     if parmObj == None:
                         server = 'jro-app.igp.gob.pe'
                     else:
                         server = parmObj.getValue()
                     parmObj = opObj.getParameterObj(parameterName="remotefolder")
                     if parmObj == None:
                         remotefolder = '/home/wmaster/graficos'
                     else:
                         remotefolder = parmObj.getValue()
                     parmObj = opObj.getParameterObj(parameterName="username")
                     if parmObj == None:
                         username = 'wmaster'
                     else:
                         username = parmObj.getValue()
                     parmObj = opObj.getParameterObj(parameterName="password")
                     if parmObj == None:
                         password = 'mst2010vhf'
                     else:
                         password = parmObj.getValue()
                     parmObj = opObj.getParameterObj(parameterName="ftp_wei")
                     if parmObj == None:
                         ftp_wei = 0
                     else:
                         ftp_wei = parmObj.getValue()
                     parmObj = opObj.getParameterObj(parameterName="exp_code")
                     if parmObj == None:
                         exp_code = 0
                     else:
                         exp_code = parmObj.getValue()
                     parmObj = opObj.getParameterObj(parameterName="sub_exp_code")
                     if parmObj == None:
                         sub_exp_code = 0
                     else:
                         sub_exp_code = parmObj.getValue()
                     parmObj = opObj.getParameterObj(parameterName="plot_pos")
                     if parmObj == None:
                         plot_pos = 0
                     else:
                         plot_pos = parmObj.getValue()
                     parmObj = opObj.getParameterObj(parameterName="localfolder")
                     if parmObj == None:
                         localfolder = None
                     else:
                         localfolder = parmObj.getValue()
                     parmObj = opObj.getParameterObj(parameterName="ext")
                     if parmObj == None:
                         extension = '.png'
                     else:
                         extension = parmObj.getValue()
                     self.temporalFTP.save(server=server,
                                           remotefolder=remotefolder,
                                           username=username,
                                           password=password,
                                           ftp_wei=ftp_wei,
                                           exp_code=exp_code,
                                           sub_exp_code=sub_exp_code,
                                           plot_pos=plot_pos,
                                           localfolder=localfolder,
                                           extension=extension)
                 def addProject2ProjectExplorer(self, id, name):
                     itemTree = QtGui.QStandardItem(QtCore.QString(str(name)))
                     parentItem = self.projectExplorerModel.invisibleRootItem()
                     parentItem.appendRow(itemTree)
                     self.projectExplorerTree.setCurrentIndex(itemTree.index())
                     self.selectedItemTree = itemTree
                     self.__itemTreeDict[id] = itemTree
                 def addPU2ProjectExplorer(self, puObj):
                     id, name = puObj.id, puObj.datatype
                     itemTree = QtGui.QStandardItem(QtCore.QString(str(name)))
                     parentItem = self.selectedItemTree
                     parentItem.appendRow(itemTree)
                     self.projectExplorerTree.expandAll()
                     self.projectExplorerTree.setCurrentIndex(itemTree.index())
                     self.selectedItemTree = itemTree
                     self.__itemTreeDict[id] = itemTree
                 def addPU2PELoadXML(self, puObj):
                     id, name, inputId = puObj.id, puObj.datatype, puObj.inputId
                     itemTree = QtGui.QStandardItem(QtCore.QString(str(name)))
                     if self.__itemTreeDict.has_key(inputId):
                         parentItem = self.__itemTreeDict[inputId]
                     else:
                         #If parent is a Reader object
                         parentItem = self.__itemTreeDict[id[:-1]]
                     parentItem.appendRow(itemTree)
                     self.projectExplorerTree.expandAll()
                     parentItem = itemTree
                     self.projectExplorerTree.setCurrentIndex(parentItem.index())
                     self.__itemTreeDict[id] = itemTree
                     self.selectedItemTree = itemTree
                 def getSelectedProjectObj(self):
                     """
                     Return the current project object selected. If a processing unit is
                     actually selected this function returns associated project.
                     None if any project or processing unit is selected
                     """
                     for key in self.__itemTreeDict.keys():
                         if self.__itemTreeDict[key] != self.selectedItemTree:
                             continue
                         if self.__projectObjDict.has_key(key):
                             projectObj = self.__projectObjDict[key]
                             return projectObj
                         puObj = self.__puObjDict[key]
                         if puObj.parentId == None:
                             projectId = puObj.getId()[0]
                         else:
                             projectId = puObj.parentId
                         projectObj = self.__projectObjDict[projectId]
                         return projectObj
                     return None
                 def getSelectedItemObj(self):
                     """
                     Return the current project or processing unit object selected
                     None if any project or processing unit is selected
                     """
                     for key in self.__itemTreeDict.keys():
                         if self.__itemTreeDict[key] != self.selectedItemTree:
                             continue
                         if self.__projectObjDict.has_key(key) == True:
                             fatherObj = self.__projectObjDict[key]
                         else:
                             fatherObj = self.__puObjDict[key]
                         return fatherObj
                     return None
                 def _WarningWindow(self, text, information):
                     msgBox = QtGui.QMessageBox()
                     msgBox.setText(text)
                     msgBox.setInformativeText(information)
                     msgBox.setStandardButtons(QtGui.QMessageBox.Ok | QtGui.QMessageBox.Cancel)
                     msgBox.setDefaultButton(QtGui.QMessageBox.Ok)
                     ret = msgBox.exec_()
                     answer = False
                     if ret == QtGui.QMessageBox.Ok:
                         answer = True
                     return answer
                 def __getNewProjectId(self):
                     loadProject = False
                     for thisId in range(1,10):
                         newId = str(thisId)
                         if newId in self.__projectObjDict.keys():
                             continue
                         loadProject = True
                         projectId = newId
                         break
                     if not loadProject:
                         self.console.clear()
                         self.console.append("The maximum number of projects has been loaded, a new project can not be loaded")
                         return None
                     return projectId
                 def openProject(self):
                     self.actionStart.setEnabled(False)
                     self.actionStarToolbar.setEnabled(False)
                     self.frame_2.setEnabled(True)
                     # print self.dir
                     filename = str(QtGui.QFileDialog.getOpenFileName(self, "Open text file", self.pathWorkSpace, self.tr("Text Files (*.xml)")))
                     projectObjLoad = Project()
                     try:
                         projectObjLoad.readXml(filename)
                     except:
                         self.console.clear()
                         self.console.append("The selected xml file could not be loaded ...")
                         return 0
                     self.create = False
                     self.refreshProjectWindow(projectObjLoad)
                     self.refreshProjectProperties(projectObjLoad)
                     projectId = projectObjLoad.id
                     if projectId in self.__projectObjDict.keys():
             #             answer = self._WarningWindow("You already have a project loaded with the same Id",
             #                                             "Do you want to load the file anyway?")
             #             if not answer:
             #                 return
                         projectId = self.__getNewProjectId()
                         if not projectId:
                             return
                         projectObjLoad.updateId(projectId)
                     self.__projectObjDict[projectId] = projectObjLoad
                     self.addProject2ProjectExplorer(id=projectId, name=projectObjLoad.name)
                     self.tabWidgetProject.setEnabled(True)
                     self.tabWidgetProject.setCurrentWidget(self.tabProject)
                     # Disable tabProject after finish the creation
                     self.tabProject.setEnabled(True)
                     puObjorderList = OrderedDict(sorted(projectObjLoad.procUnitConfObjDict.items(), key=lambda x: x[0]))
                     for puId, puObj in puObjorderList.items():
                         self.__puObjDict[puId] = puObj
                         if puObj.name == "SendToServer":
                             self.saveFTPFromProcUnitObj(puObj)
                         ############## COMPATIBLE WITH OLD VERSIONS ################
                         operationObj = puObj.getOperationObj("SendByFTP")
                         if operationObj:
                             self.saveFTPFromOpObj(operationObj)
                         ############################################################
                         if puObj.inputId == '0':
                             continue
                         self.addPU2PELoadXML(puObj)
                         self.refreshPUWindow(puObj)
                         self.refreshPUProperties(puObj)
                         self.showtabPUCreated(datatype=puObj.datatype)
                     self.console.clear()
                     self.console.append("The selected xml file has been loaded successfully")
                     self.actionStart.setEnabled(True)
                     self.actionStarToolbar.setEnabled(True)
                 def create_updating_timer(self):
                     self.comm_data_timer = QtCore.QTimer(self)
                     self.comm_data_timer.timeout.connect(self.on_comm_updating_timer)
                     self.comm_data_timer.start(1000)
                 def on_comm_updating_timer(self):
                     # Verifica si algun proceso ha sido inicializado y sigue ejecutandose
                     # Si el proceso se ha parado actualizar el GUI (stopProject)
                     if not self.__enable:
                         return
                     if self.controllerThread.isFinished():
                         self.stopProject()
             #     def jobStartedFromThread(self, success):
             #
             #         self.console.clear()
             #         self.console.append("Job started")
             #
             #     def jobFinishedFromThread(self, success):
             #
             #         self.stopProject()
                 def playProject(self, ext=".xml", save=1):
                     projectObj = self.getSelectedProjectObj()
                     if not projectObj:
                         self.console.append("Please select a project before pressing PLAY button")
                         return
                     if save:
                         filename = self.saveProject()
                         if filename == None:
                             self.console.append("Process did not initialize.")
                             return
                     else:
                         filename = TEMPORAL_FILE
                         projectObj.writeXml( os.path.join(self.pathWorkSpace,filename) )
                     self.actionStart.setEnabled(False)
                     self.actionPause.setEnabled(True)
                     self.actionStop.setEnabled(True)
                     self.actionStarToolbar.setEnabled(False)
                     self.actionPauseToolbar.setEnabled(True)
                     self.actionStopToolbar.setEnabled(True)
                     self.console.append("Please Wait...")
                     self.controllerThread = ControllerThread(filename)
             #         QObject.connect( self.controllerThread, SIGNAL( "jobFinished( PyQt_PyObject )" ), self.jobFinishedFromThread )
             #         QObject.connect( self.controllerThread, SIGNAL( "jobStarted( PyQt_PyObject )" ), self.jobStartedFromThread )
                     self.console.clear()
                     self.controllerThread.start()
                     sleep(0.5)
                     self.__enable = True
                 def stopProject(self):
                     self.__enable = False
             #         self.commCtrlPThread.cmd_q.put(ProcessCommand(ProcessCommand.STOP, True))
                     self.controllerThread.stop()
                     while self.controllerThread.isRunning():
                         sleep(0.5)
                     self.actionStart.setEnabled(True)
                     self.actionPause.setEnabled(False)
                     self.actionStop.setEnabled(False)
                     self.actionStarToolbar.setEnabled(True)
                     self.actionPauseToolbar.setEnabled(False)
                     self.actionStopToolbar.setEnabled(False)
                     self.restorePauseIcon()
                 def pauseProject(self):
             #         self.commCtrlPThread.cmd_q.put(ProcessCommand(ProcessCommand.PAUSE, data=True))
                     self.controllerThread.pause()
                     self.actionStart.setEnabled(False)
                     self.actionPause.setEnabled(True)
                     self.actionStop.setEnabled(True)
                     self.actionStarToolbar.setEnabled(False)
                     self.actionPauseToolbar.setEnabled(True)
                     self.actionStopToolbar.setEnabled(True)
                 def saveProject(self, filename=None):
                     self.actionStart.setEnabled(False)
                     self.actionStarToolbar.setEnabled(False)
                     projectObj = self.getSelectedProjectObj()
                     if not projectObj:
                         if self.create:
                             self.console.append("Please press Ok before save it")
                         else:
                             self.console.append("Please select a project before save it")
                         return
                     self.refreshGraphicsId()
                     sts = True
                     selectedItemObj = self.getSelectedItemObj()
                     #A Processing Unit has been selected
                     if projectObj == selectedItemObj:
                         if not self.on_proOk_clicked():
                             return None
                     #A Processing Unit has been selected
                     if projectObj != selectedItemObj:
                         puObj = selectedItemObj
                         if puObj.name == 'VoltageProc':
                             sts = self.on_volOpOk_clicked()
                         if puObj.name == 'SpectraProc':
                             sts = self.on_specOpOk_clicked()
                         if puObj.name == 'SpectraHeisProc':
                             sts = self.on_specHeisOpOk_clicked()
                         if not sts:
                             return None
                     self.createFTPProcUnitView()
                     if not filename:
                         filename = os.path.join( str(self.pathWorkSpace), "%s%s" %(str(projectObj.name), '.xml') )
                     projectObj.writeXml(filename)
                     self.console.clear()
                     self.console.append("Project saved")
                     self.console.append("Press Play button to start data processing ...")
                     self.actionStart.setEnabled(True)
                     self.actionStarToolbar.setEnabled(True)
                     return filename
                 def removeItemTreeFromProject(self):
                     """
                     Metodo para eliminar el proyecto en el dictionario de proyectos y en el dictionario de vista de arbol
                     """
                     for key in self.__itemTreeDict.keys():
                         #Check again because an item can delete multiple items (childs)
                         if key not in self.__itemTreeDict.keys():
                             continue
                         if self.__itemTreeDict[key] != self.selectedItemTree:
                             continue
                         if self.__projectObjDict.has_key(key) == True:
                             del self.__projectObjDict[key]
                             del self.__itemTreeDict[key]
                         else:
                             puObj = self.__puObjDict[key]
                             idProjectParent = puObj.parentId
                             projectObj = self.__projectObjDict[idProjectParent]
                             del self.__puObjDict[key]
                             del self.__itemTreeDict[key]
                             del projectObj.procUnitConfObjDict[key]
                             for key in projectObj.procUnitConfObjDict.keys():
                                 if projectObj.procUnitConfObjDict[key].inputId != puObj.getId():
                                     continue
                                 del self.__puObjDict[projectObj.procUnitConfObjDict[key].getId()]
                                 del self.__itemTreeDict[projectObj.procUnitConfObjDict[key].getId()]
                                 del projectObj.procUnitConfObjDict[key]
                             # print projectObj.procUnitConfObjDict
                         # print self.__itemTreeDict,self.__projectObjDict,self.__puObjDict
                 def setInputsProject_View(self):
                     self.tabWidgetProject.setEnabled(True)
                     self.tabWidgetProject.setCurrentWidget(self.tabProject)
                     self.tabProject.setEnabled(True)
                     self.frame_2.setEnabled(False)
                     self.proName.clear()
                     self.proName.setFocus()
                     self.proName.setSelection(0, 0)
                     self.proName.setCursorPosition(0)
                     self.proDataType.setText('.r')
                     self.proDataPath.clear()
                     self.proComDataType.clear()
                     self.proComDataType.addItem("Voltage")
                     self.proComDataType.addItem("Spectra")
                     self.proComDataType.addItem("Fits")
                     self.proComDataType.addItem("USRP")
                     self.proComStartDate.clear()
                     self.proComEndDate.clear()
                     startTime = "00:00:00"
                     endTime = "23:59:59"
                     starlist = startTime.split(":")
                     endlist = endTime.split(":")
                     self.proDelay.setText("60")
                     self.proSet.setText("")
                     self.labelSet.show()
                     self.proSet.show()
                     self.labelIPPKm.hide()
                     self.proIPPKm.hide()
                     self.time.setHMS(int(starlist[0]), int(starlist[1]), int(starlist[2]))
                     self.proStartTime.setTime(self.time)
                     self.time.setHMS(int(endlist[0]), int(endlist[1]), int(endlist[2]))
                     self.proEndTime.setTime(self.time)
                     self.proDescription.clear()
                     self.proOk.setEnabled(False)
             #         self.console.append("Please, Write a name Project")
             #         self.console.append("Introduce Project Parameters")DC
             #         self.console.append("Select data type Voltage( .rawdata)  or Spectra(.pdata)")
                 def clearPUWindow(self, datatype):
                     projectObjView = self.getSelectedProjectObj()
                     if not projectObjView:
                         return
                     puObj = self.getSelectedItemObj()
                     inputId = puObj.getInputId()
                     inputPUObj = projectObjView.getProcUnitObj(inputId)
                     if datatype == 'Voltage':
                         self.volOpComChannels.setEnabled(False)
                         self.volOpComHeights.setEnabled(False)
                         self.volOpFilter.setEnabled(False)
                         self.volOpComProfile.setEnabled(False)
                         self.volOpComCode.setEnabled(False)
                         self.volOpCohInt.setEnabled(False)
                         self.volOpChannel.setEnabled(False)
                         self.volOpHeights.setEnabled(False)
                         self.volOpProfile.setEnabled(False)
                         self.volOpRadarfrequency.setEnabled(False)
                         self.volOpCebChannels.setCheckState(0)
                         self.volOpCebRadarfrequency.setCheckState(0)
                         self.volOpCebHeights.setCheckState(0)
                         self.volOpCebFilter.setCheckState(0)
                         self.volOpCebProfile.setCheckState(0)
                         self.volOpCebDecodification.setCheckState(0)
                         self.volOpCebCohInt.setCheckState(0)
                         self.volOpChannel.clear()
                         self.volOpHeights.clear()
                         self.volOpProfile.clear()
                         self.volOpFilter.clear()
                         self.volOpCohInt.clear()
                         self.volOpRadarfrequency.clear()
                     if datatype == 'Spectra':
                         if inputPUObj.datatype == 'Spectra':
                             self.specOpnFFTpoints.setEnabled(False)
                             self.specOpProfiles.setEnabled(False)
                             self.specOpippFactor.setEnabled(False)
                         else:
                             self.specOpnFFTpoints.setEnabled(True)
                             self.specOpProfiles.setEnabled(True)
                             self.specOpippFactor.setEnabled(True)
                         self.specOpCebCrossSpectra.setCheckState(0)
                         self.specOpCebChannel.setCheckState(0)
                         self.specOpCebHeights.setCheckState(0)
                         self.specOpCebIncoherent.setCheckState(0)
                         self.specOpCebRemoveDC.setCheckState(0)
                         self.specOpCebRemoveInt.setCheckState(0)
                         self.specOpCebgetNoise.setCheckState(0)
                         self.specOpCebRadarfrequency.setCheckState(0)
                         self.specOpRadarfrequency.setEnabled(False)
                         self.specOppairsList.setEnabled(False)
                         self.specOpChannel.setEnabled(False)
                         self.specOpHeights.setEnabled(False)
                         self.specOpIncoherent.setEnabled(False)
                         self.specOpgetNoise.setEnabled(False)
                         self.specOpRadarfrequency.clear()
                         self.specOpnFFTpoints.clear()
                         self.specOpProfiles.clear()
                         self.specOpippFactor.clear
                         self.specOppairsList.clear()
                         self.specOpChannel.clear()
                         self.specOpHeights.clear()
                         self.specOpIncoherent.clear()
                         self.specOpgetNoise.clear()
                         self.specGraphCebSpectraplot.setCheckState(0)
                         self.specGraphCebCrossSpectraplot.setCheckState(0)
                         self.specGraphCebRTIplot.setCheckState(0)
                         self.specGraphCebRTInoise.setCheckState(0)
                         self.specGraphCebCoherencmap.setCheckState(0)
                         self.specGraphPowerprofile.setCheckState(0)
                         self.specGraphSaveSpectra.setCheckState(0)
                         self.specGraphSaveCross.setCheckState(0)
                         self.specGraphSaveRTIplot.setCheckState(0)
                         self.specGraphSaveRTInoise.setCheckState(0)
                         self.specGraphSaveCoherencemap.setCheckState(0)
                         self.specGraphSavePowerprofile.setCheckState(0)
                         self.specGraphftpRTIplot.setCheckState(0)
                         self.specGraphftpRTInoise.setCheckState(0)
                         self.specGraphftpCoherencemap.setCheckState(0)
                         self.specGraphPath.clear()
                         self.specGraphPrefix.clear()
                         self.specGgraphftpratio.clear()
                         self.specGgraphChannelList.clear()
                         self.specGgraphFreq.clear()
                         self.specGgraphHeight.clear()
                         self.specGgraphDbsrange.clear()
                         self.specGgraphmagnitud.clear()
                         self.specGgraphTminTmax.clear()
                         self.specGgraphTimeRange.clear()
                     if datatype == 'SpectraHeis':
                         self.specHeisOpCebIncoherent.setCheckState(0)
                         self.specHeisOpIncoherent.setEnabled(False)
                         self.specHeisOpIncoherent.clear()
                         self.specHeisGraphCebSpectraplot.setCheckState(0)
                         self.specHeisGraphCebRTIplot.setCheckState(0)
                         self.specHeisGraphSaveSpectra.setCheckState(0)
                         self.specHeisGraphSaveRTIplot.setCheckState(0)
                         self.specHeisGraphftpSpectra.setCheckState(0)
                         self.specHeisGraphftpRTIplot.setCheckState(0)
                         self.specHeisGraphPath.clear()
                         self.specHeisGraphPrefix.clear()
                         self.specHeisGgraphChannelList.clear()
                         self.specHeisGgraphXminXmax.clear()
                         self.specHeisGgraphYminYmax.clear()
                         self.specHeisGgraphTminTmax.clear()
                         self.specHeisGgraphTimeRange.clear()
                         self.specHeisGgraphftpratio.clear()
                 def showtabPUCreated(self, datatype):
                     if datatype == "Voltage":
                         self.tabVoltage.setEnabled(True)
                         self.tabProject.setEnabled(False)
                         self.tabSpectra.setEnabled(False)
                         self.tabCorrelation.setEnabled(False)
                         self.tabSpectraHeis.setEnabled(False)
                         self.tabWidgetProject.setCurrentWidget(self.tabVoltage)
                     if datatype == "Spectra":
                         self.tabVoltage.setEnabled(False)
                         self.tabProject.setEnabled(False)
                         self.tabSpectra.setEnabled(True)
                         self.tabCorrelation.setEnabled(False)
                         self.tabSpectraHeis.setEnabled(False)
                         self.tabWidgetProject.setCurrentWidget(self.tabSpectra)
                     if datatype == "SpectraHeis":
                         self.tabVoltage.setEnabled(False)
                         self.tabProject.setEnabled(False)
                         self.tabSpectra.setEnabled(False)
                         self.tabCorrelation.setEnabled(False)
                         self.tabSpectraHeis.setEnabled(True)
                         self.tabWidgetProject.setCurrentWidget(self.tabSpectraHeis)
                 def checkInputsProject(self):
                     """
                     Check Inputs Project:
                     - project_name
                     - datatype
                     - ext
                     - data_path
                     - readmode
                     - delay
                     - set
                     - walk
                     """
                     parms_ok = True
                     project_name = str(self.proName.text())
                     if project_name == '' or project_name == None:
                         outputstr = "Enter the Project Name"
                         self.console.append(outputstr)
                         parms_ok = False
                         project_name = None
                     datatype = str(self.proComDataType.currentText())
                     if not(datatype in ['Voltage', 'Spectra', 'Fits', 'USRP']):
                         outputstr = 'datatype = %s, this must be either Voltage, Spectra, SpectraHeis or USRP' % datatype
                         self.console.append(outputstr)
                         parms_ok = False
                         datatype = None
                     ext = str(self.proDataType.text())
                     if not(ext in ['.r', '.pdata', '.fits', '.hdf5']):
                         outputstr = "extension files must be .r , .pdata, .fits or .hdf5"
                         self.console.append(outputstr)
                         parms_ok = False
                         ext = None
                     data_path = str(self.proDataPath.text())
                     if data_path == '':
                         outputstr = 'Datapath is empty'
                         self.console.append(outputstr)
                         parms_ok = False
                         data_path = None
                     if data_path != None:
                         if not os.path.isdir(data_path):
                             outputstr = 'Datapath:%s does not exists' % data_path
                             self.console.append(outputstr)
                             parms_ok = False
                             data_path = None
                     read_mode = str(self.proComReadMode.currentText())
                     if not(read_mode in ['Online', 'Offline']):
                         outputstr = 'Read Mode: %s, this must be either Online or Offline' % read_mode
                         self.console.append(outputstr)
                         parms_ok = False
                         read_mode = None
                     delay = None
                     if read_mode == "Online":
                         parms_ok = False
                         try:
                             delay = int(str(self.proDelay.text()))
                             parms_ok = True
                         except:
                             outputstr = 'Delay: %s, this must be a integer number' % str(self.proDelay.text())
                             self.console.append(outputstr)
                     try:
                         set = int(str(self.proSet.text()))
                     except:
                         # outputstr = 'Set: %s, this must be a integer number' % str(self.proName.text())
                         # self.console.append(outputstr)
                         # parms_ok = False
                         set = None
                     walk = int(self.proComWalk.currentIndex())
                     expLabel = str(self.proExpLabel.text())
                     return parms_ok, project_name, datatype, ext, data_path, read_mode, delay, walk, set, expLabel
                 def checkInputsPUSave(self, datatype):
                     """
                     Check Inputs Spectra Save:
                     - path
                     - blocks Per File
                     - sufix
                     - dataformat
                     """
                     parms_ok = True
                     if datatype == "Voltage":
                         output_path = str(self.volOutputPath.text())
                         blocksperfile = str(self.volOutputblocksperfile.text())
                         profilesperblock = str(self.volOutputprofilesperblock.text())
                     if datatype == "Spectra":
                         output_path = str(self.specOutputPath.text())
                         blocksperfile = str(self.specOutputblocksperfile.text())
                         profilesperblock = 0
                     if datatype == "SpectraHeis":
                         output_path = str(self.specHeisOutputPath.text())
                         blocksperfile = str(self.specHeisOutputblocksperfile.text())
-                        metada = str(self.specHeisOutputMetada.text())
+                        metadata_file = str(self.specHeisOutputMetada.text())
                     if output_path == '':
                         outputstr = 'Outputpath is empty'
                         self.console.append(outputstr)
                         parms_ok = False
-                        data_path = None
-                    if output_path != None:
-                        if not os.path.exists(output_path):
-                            outputstr = 'OutputPath:%s does not exists' % output_path
-                            self.console.append(outputstr)
-                            parms_ok = False
-                            output_path = None
+                    if not os.path.isdir(output_path):
+                        outputstr = 'OutputPath:%s does not exists' % output_path
+                        self.console.append(outputstr)
+                        parms_ok = False
                     try:
                         profilesperblock = int(profilesperblock)
                     except:
                         if datatype == "Voltage":
                             outputstr = 'Profilesperblock: %s, this must be a integer number' % str(self.volOutputprofilesperblock.text())
                             self.console.append(outputstr)
                             parms_ok = False
                             profilesperblock = None
                     try:
                         blocksperfile = int(blocksperfile)
                     except:
                         if datatype == "Voltage":
                             outputstr = 'Blocksperfile: %s, this must be a integer number' % str(self.volOutputblocksperfile.text())
                         elif datatype == "Spectra":
                             outputstr = 'Blocksperfile: %s, this must be a integer number' % str(self.specOutputblocksperfile.text())
                         elif datatype == "SpectraHeis":
                             outputstr = 'Blocksperfile: %s, this must be a integer number' % str(self.specHeisOutputblocksperfile.text())
                         self.console.append(outputstr)
                         parms_ok = False
                         blocksperfile = None
                     if datatype == "SpectraHeis":
-                        if metada == '':
+                        if metadata_file != '':
-                            outputstr = 'Choose metada file'
+                           if not os.path.isfile(metadata_file):
-                            self.console.append(outputstr)
+                                outputstr = 'Metadata file %s does not exist' % metadata_file
-                            parms_ok = False
-                        if metada != None:
-                           if not  os.path.isfile(metada):
-                                outputstr = 'Metadata:%s does not exists' % metada
                                 self.console.append(outputstr)
                                 parms_ok = False
-                                output_path = None
                     if datatype == "Voltage":
                         return parms_ok, output_path, blocksperfile, profilesperblock
                     if datatype == "Spectra":
                         return parms_ok, output_path, blocksperfile, profilesperblock
                     if datatype == "SpectraHeis":
-                        return parms_ok, output_path, blocksperfile, metada
+                        return parms_ok, output_path, blocksperfile, metadata_file
                 def findDatafiles(self, data_path, ext, walk, expLabel=''):
                     dateList = []
                     fileList = []
                     if ext == ".r":
                         from schainpy.model.io.jroIO_base import JRODataReader
                         readerObj = JRODataReader()
                         dateList = readerObj.findDatafiles(path=data_path,
                                                            expLabel=expLabel,
                                                            ext=ext,
                                                            walk=walk)
                     if ext == ".pdata":
                         from schainpy.model.io.jroIO_base import JRODataReader
                         readerObj = JRODataReader()
                         dateList = readerObj.findDatafiles(path=data_path,
                                                            expLabel=expLabel,
                                                            ext=ext,
                                                            walk=walk)
                     if ext == ".fits":
                         from schainpy.model.io.jroIO_base import JRODataReader
                         readerObj = JRODataReader()
                         dateList = readerObj.findDatafiles(path=data_path,
                                                            expLabel=expLabel,
                                                            ext=ext,
                                                            walk=walk)
                     if ext == ".hdf5":
                         from schainpy.model.io.jroIO_usrp import USRPReader
                         readerObj = USRPReader()
                         dateList = readerObj.findDatafiles(path=data_path)
                     return dateList
                 def loadDays(self, data_path, ext, walk, expLabel=''):
                     """
                     Method to loads day
                     """
                     self.proOk.setEnabled(False)
                     self.proComStartDate.clear()
                     self.proComEndDate.clear()
                     self.dateList = []
                     if not os.path.isdir(data_path):
                         return
                     self.dataPath = data_path
                     dateList = self.findDatafiles(data_path, ext=ext, walk=walk, expLabel=expLabel)
                     if not dateList:
             #             self.console.clear()
                         if walk:
                             if expLabel:
                                 outputstr = "No files (*%s) were found on %s/DOYPATH/%s" % (ext, data_path, expLabel)
                             else:
                                 outputstr = "No files (*%s) were found on %s" % (ext, data_path)
                         else:
                             outputstr = "No files (*%s) were found on %s" % (ext, data_path)
                         self.console.append(outputstr)
                         return
                     dateStrList = []
                     for thisDate in dateList:
                         dateStr = thisDate.strftime("%Y/%m/%d")
                         self.proComStartDate.addItem(dateStr)
                         self.proComEndDate.addItem(dateStr)
                         dateStrList.append(dateStr)
                     self.proComStartDate.setCurrentIndex(0)
                     self.proComEndDate.setCurrentIndex(self.proComEndDate.count() - 1)
                     self.dateList = dateStrList
                     self.proOk.setEnabled(True)
                     self.console.clear()
                     self.console.append("Successful load")
                     return self.dateList
                 def setWorkSpaceGUI(self, pathWorkSpace=None):
                     if pathWorkSpace == None:
                         home = os.path.expanduser("~")
                         pathWorkSpace = os.path.join(home,'schain_workspace')
                     self.pathWorkSpace = pathWorkSpace
                 """
                 Comandos Usados en Console
                 """
                 def __del__(self):
                     sys.stdout = sys.__stdout__
                     sys.stderr = sys.__stderr__
                 def normalOutputWritten(self, text):
                     color_black = QtGui.QColor(0,0,0)
                     self.console.setTextColor(color_black)
                     self.console.append(text)
                 def errorOutputWritten(self, text):
                     color_red = QtGui.QColor(255,0,0)
                     color_black = QtGui.QColor(0,0,0)
                     self.console.setTextColor(color_red)
                     self.console.append(text)
                     self.console.setTextColor(color_black)
                 def setGUIStatus(self):
                     self.setWindowTitle("ROJ-Signal Chain")
                     self.setWindowIcon(QtGui.QIcon( os.path.join(FIGURES_PATH,"adn.jpg") ))
                     self.tabWidgetProject.setEnabled(False)
                     self.tabVoltage.setEnabled(False)
                     self.tabSpectra.setEnabled(False)
                     self.tabCorrelation.setEnabled(False)
                     self.frame_2.setEnabled(False)
                     self.actionCreate.setShortcut('Ctrl+N')
                     self.actionOpen.setShortcut('Ctrl+O')
                     self.actionSave.setShortcut('Ctrl+S')
                     self.actionClose.setShortcut('Ctrl+X')
                     self.actionStart.setShortcut('Ctrl+1')
                     self.actionPause.setShortcut('Ctrl+2')
                     self.actionStop.setShortcut('Ctrl+3')
                     self.actionFTP.setShortcut('Ctrl+F')
                     self.actionStart.setEnabled(False)
                     self.actionPause.setEnabled(False)
                     self.actionStop.setEnabled(False)
                     self.actionStarToolbar.setEnabled(False)
                     self.actionPauseToolbar.setEnabled(False)
                     self.actionStopToolbar.setEnabled(False)
                     self.proName.clear()
                     self.proDataPath.setText('')
                     self.console.setReadOnly(True)
                     self.console.append("Welcome to Signal Chain\nOpen a project or Create a new one")
                     self.proStartTime.setDisplayFormat("hh:mm:ss")
                     self.proDataType.setEnabled(False)
                     self.time = QtCore.QTime()
                     self.hour = 0
                     self.min = 0
                     self.sec = 0
                     self.proEndTime.setDisplayFormat("hh:mm:ss")
                     startTime = "00:00:00"
                     endTime = "23:59:59"
                     starlist = startTime.split(":")
                     endlist = endTime.split(":")
                     self.time.setHMS(int(starlist[0]), int(starlist[1]), int(starlist[2]))
                     self.proStartTime.setTime(self.time)
                     self.time.setHMS(int(endlist[0]), int(endlist[1]), int(endlist[2]))
                     self.proEndTime.setTime(self.time)
                     self.proOk.setEnabled(False)
                     # set model Project Explorer
                     self.projectExplorerModel = QtGui.QStandardItemModel()
                     self.projectExplorerModel.setHorizontalHeaderLabels(("Project Explorer",))
                     layout = QtGui.QVBoxLayout()
                     layout.addWidget(self.projectExplorerTree)
                     self.projectExplorerTree.setModel(self.projectExplorerModel)
                     self.projectExplorerTree.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
                     self.projectExplorerTree.customContextMenuRequested.connect(self.on_right_click)
                     self.projectExplorerTree.clicked.connect(self.on_click)
                     self.projectExplorerTree.expandAll()
                     # set model Project Properties
                     self.propertiesModel = TreeModel()
                     self.propertiesModel.initProjectView()
                     self.treeProjectProperties.setModel(self.propertiesModel)
                     self.treeProjectProperties.expandAll()
                     self.treeProjectProperties.allColumnsShowFocus()
                     self.treeProjectProperties.resizeColumnToContents(1)
                     # set Project
                     self.proExpLabel.setEnabled(True)
                     self.proDelay.setEnabled(False)
                     self.proSet.setEnabled(True)
                     self.proDataType.setReadOnly(True)
                      # set Operation Voltage
                     self.volOpComChannels.setEnabled(False)
                     self.volOpComHeights.setEnabled(False)
                     self.volOpFilter.setEnabled(False)
                     self.volOpComProfile.setEnabled(False)
                     self.volOpComCode.setEnabled(False)
                     self.volOpFlip.setEnabled(False)
                     self.volOpCohInt.setEnabled(False)
                     self.volOpRadarfrequency.setEnabled(False)
                     self.volOpChannel.setEnabled(False)
                     self.volOpHeights.setEnabled(False)
                     self.volOpProfile.setEnabled(False)
                     self.volOpComMode.setEnabled(False)
                     self.volGraphPath.setEnabled(False)
                     self.volGraphPrefix.setEnabled(False)
                     self.volGraphToolPath.setEnabled(False)
                     # set Graph Voltage
                     self.volGraphChannelList.setEnabled(False)
                     self.volGraphfreqrange.setEnabled(False)
                     self.volGraphHeightrange.setEnabled(False)
                     # set Operation Spectra
                     self.specOpnFFTpoints.setEnabled(False)
                     self.specOpProfiles.setEnabled(False)
                     self.specOpippFactor.setEnabled(False)
                     self.specOppairsList.setEnabled(False)
                     self.specOpComChannel.setEnabled(False)
                     self.specOpComHeights.setEnabled(False)
                     self.specOpIncoherent.setEnabled(False)
                     self.specOpgetNoise.setEnabled(False)
                     self.specOpRadarfrequency.setEnabled(False)
                     self.specOpChannel.setEnabled(False)
                     self.specOpHeights.setEnabled(False)
                     # set Graph Spectra
                     self.specGgraphChannelList.setEnabled(False)
                     self.specGgraphFreq.setEnabled(False)
                     self.specGgraphHeight.setEnabled(False)
                     self.specGgraphDbsrange.setEnabled(False)
                     self.specGgraphmagnitud.setEnabled(False)
                     self.specGgraphTminTmax.setEnabled(False)
                     self.specGgraphTimeRange.setEnabled(False)
                     self.specGraphPath.setEnabled(False)
                     self.specGraphToolPath.setEnabled(False)
                     self.specGraphPrefix.setEnabled(False)
                     self.specGgraphftpratio.setEnabled(False)
                     # set Operation SpectraHeis
                     self.specHeisOpIncoherent.setEnabled(False)
                     self.specHeisOpCobIncInt.setEnabled(False)
                     # set Graph SpectraHeis
                     self.specHeisGgraphChannelList.setEnabled(False)
                     self.specHeisGgraphXminXmax.setEnabled(False)
                     self.specHeisGgraphYminYmax.setEnabled(False)
                     self.specHeisGgraphTminTmax.setEnabled(False)
                     self.specHeisGgraphTimeRange.setEnabled(False)
                     self.specHeisGgraphftpratio.setEnabled(False)
                     self.specHeisGraphPath.setEnabled(False)
                     self.specHeisGraphPrefix.setEnabled(False)
                     self.specHeisGraphToolPath.setEnabled(False)
                     # tool tip gui
                     QtGui.QToolTip.setFont(QtGui.QFont('SansSerif', 10))
                     self.projectExplorerTree.setToolTip('Right clik to add Project or Unit Process')
                     # tool tip gui project
                     self.proComWalk.setToolTip('<b>On Files</b>:<i>Search file in format .r or pdata</i> <b>On Folders</b>:<i>Search file in a directory DYYYYDOY</i>')
                     self.proComWalk.setCurrentIndex(0)
                     # tool tip gui volOp
                     self.volOpChannel.setToolTip('Example: 1,2,3,4,5')
                     self.volOpHeights.setToolTip('Example: 90,180')
                     self.volOpFilter.setToolTip('Example: 2')
                     self.volOpProfile.setToolTip('Example:0,127')
                     self.volOpCohInt.setToolTip('Example: 128')
                     self.volOpFlip.setToolTip('ChannelList where flip will be applied. Example: 0,2,3')
                     self.volOpOk.setToolTip('If you have finished, please Ok ')
                     # tool tip gui volGraph
                     self.volGraphfreqrange.setToolTip('Height range. Example: 50,100')
                     self.volGraphHeightrange.setToolTip('Amplitude. Example: 0,10000')
                     # tool tip gui specOp
                     self.specOpnFFTpoints.setToolTip('Example: 128')
                     self.specOpProfiles.setToolTip('Example: 128')
                     self.specOpippFactor.setToolTip('Example:1.0')
                     self.specOpIncoherent.setToolTip('Example: 10')
                     self.specOpgetNoise.setToolTip('Example:20,180,30,120 (minHei,maxHei,minVel,maxVel)')
                     self.specOpChannel.setToolTip('Example: 0,1,2,3')
                     self.specOpHeights.setToolTip('Example: 90,180')
                     self.specOppairsList.setToolTip('Example: (0,1),(2,3)')
                     # tool tip gui specGraph
                     self.specGgraphChannelList.setToolTip('Example: 0,3,4')
                     self.specGgraphFreq.setToolTip('Example: -20,20')
                     self.specGgraphHeight.setToolTip('Example: 100,400')
                     self.specGgraphDbsrange.setToolTip('Example: 30,170')
                     self.specGraphPrefix.setToolTip('Example: EXPERIMENT_NAME')
                     self.specHeisOpIncoherent.setToolTip('Example: 10')
                     self.specHeisGgraphChannelList.setToolTip('Example: 0,2,3')
                     self.specHeisGgraphXminXmax.setToolTip('Example (Hz): -1000, 1000')
                     self.specHeisGgraphYminYmax.setToolTip('Example (dB): 5, 35')
                     self.specHeisGgraphTminTmax.setToolTip('Example (hours): 0, 24')
                     self.specHeisGgraphTimeRange.setToolTip('Example (hours): 8')
                     self.labelSet.show()
                     self.proSet.show()
                     self.labelIPPKm.hide()
                     self.proIPPKm.hide()
                     sys.stdout = ShowMeConsole(textWritten=self.normalOutputWritten)
             #         sys.stderr = ShowMeConsole(textWritten=self.errorOutputWritten)
             class UnitProcessWindow(QMainWindow, Ui_UnitProcess):
                 """
                 Class documentation goes here.
                 """
                 closed = pyqtSignal()
                 create = False
                 def __init__(self, parent=None):
                     """
                     Constructor
                     """
                     QMainWindow.__init__(self, parent)
                     self.setupUi(self)
                     self.getFromWindow = None
                     self.getfromWindowList = []
                     self.dataTypeProject = None
                     self.listUP = None
                 @pyqtSignature("")
                 def on_unitPokbut_clicked(self):
                     """
                     Slot documentation goes here.
                     """
                     self.create = True
                     self.getFromWindow = self.getfromWindowList[int(self.comboInputBox.currentIndex())]
                     # self.nameofUP= str(self.nameUptxt.text())
                     self.typeofUP = str(self.comboTypeBox.currentText())
                     self.close()
                 @pyqtSignature("")
                 def on_unitPcancelbut_clicked(self):
                     """
                     Slot documentation goes here.
                     """
                     self.create = False
                     self.close()
                 def loadTotalList(self):
                     self.comboInputBox.clear()
                     for i in self.getfromWindowList:
                         name = i.getElementName()
                         if name == 'Project':
                             id = i.id
                             name = i.name
                             if self.dataTypeProject == 'Voltage':
                                 self.comboTypeBox.clear()
                                 self.comboTypeBox.addItem("Voltage")
                             if self.dataTypeProject == 'Spectra':
                                 self.comboTypeBox.clear()
                                 self.comboTypeBox.addItem("Spectra")
                                 self.comboTypeBox.addItem("Correlation")
                             if self.dataTypeProject == 'Fits':
                                 self.comboTypeBox.clear()
                                 self.comboTypeBox.addItem("SpectraHeis")
                         if name == 'ProcUnit':
                            id = int(i.id) - 1
                            name = i.datatype
                            if name == 'Voltage':
                               self.comboTypeBox.clear()
                               self.comboTypeBox.addItem("Spectra")
                               self.comboTypeBox.addItem("SpectraHeis")
                               self.comboTypeBox.addItem("Correlation")
                            if name == 'Spectra':
                               self.comboTypeBox.clear()
                               self.comboTypeBox.addItem("Spectra")
                               self.comboTypeBox.addItem("SpectraHeis")
                               self.comboTypeBox.addItem("Correlation")
                            if name == 'SpectraHeis':
                               self.comboTypeBox.clear()
                               self.comboTypeBox.addItem("SpectraHeis")
                         self.comboInputBox.addItem(str(name))
                        # self.comboInputBox.addItem(str(name)+str(id))
                 def closeEvent(self, event):
                     self.closed.emit()
                     event.accept()
             class Ftp(QMainWindow, Ui_Ftp):
                 """
                 Class documentation goes here.
                 """
                 create = False
                 closed = pyqtSignal()
                 server = None
                 remotefolder = None
                 username = None
                 password = None
                 ftp_wei = None
                 exp_code = None
                 sub_exp_code = None
                 plot_pos = None
                 def __init__(self, parent=None):
                     """
                     Constructor
                     """
                     QMainWindow.__init__(self, parent)
                     self.setupUi(self)
                     self.setGUIStatus()
                 def setGUIStatus(self):
                     self.setWindowTitle("ROJ-Signal Chain")
                     self.serverFTP.setToolTip('Example: jro-app.igp.gob.pe')
                     self.folderFTP.setToolTip('Example: /home/wmaster/graficos')
                     self.usernameFTP.setToolTip('Example: myusername')
                     self.passwordFTP.setToolTip('Example: mypass ')
                     self.weightFTP.setToolTip('Example: 0')
                     self.expcodeFTP.setToolTip('Example: 0')
                     self.subexpFTP.setToolTip('Example: 0')
                     self.plotposFTP.setToolTip('Example: 0')
                 def setParmsfromTemporal(self, server, remotefolder, username, password, ftp_wei, exp_code, sub_exp_code, plot_pos):
                     self.serverFTP.setText(str(server))
                     self.folderFTP.setText(str(remotefolder))
                     self.usernameFTP.setText(str(username))
                     self.passwordFTP.setText(str(password))
                     self.weightFTP.setText(str(ftp_wei))
                     self.expcodeFTP.setText(str(exp_code))
                     self.subexpFTP.setText(str(sub_exp_code))
                     self.plotposFTP.setText(str(plot_pos))
                 def getParmsFromFtpWindow(self):
                     """
                     Return Inputs Project:
                     - server
                     - remotefolder
                     - username
                     - password
                     - ftp_wei
                     - exp_code
                     - sub_exp_code
                     - plot_pos
                     """
                     name_server_ftp = str(self.serverFTP.text())
                     if not name_server_ftp:
                         self.console.clear()
                         self.console.append("Please Write  a FTP Server")
                         return 0
                     folder_server_ftp = str(self.folderFTP.text())
                     if not folder_server_ftp:
                         self.console.clear()
                         self.console.append("Please Write  a Folder")
                         return 0
                     username_ftp = str(self.usernameFTP.text())
                     if not username_ftp:
                         self.console.clear()
                         self.console.append("Please Write  a User Name")
                         return 0
                     password_ftp = str(self.passwordFTP.text())
                     if not password_ftp:
                         self.console.clear()
                         self.console.append("Please Write  a passwordFTP")
                         return 0
                     ftp_wei = str(self.weightFTP.text())
                     if not ftp_wei == "":
                         try:
                            ftp_wei = int(self.weightFTP.text())
                         except:
                             self.console.clear()
                             self.console.append("Please Write  a ftp_wei number")
                             return 0
                     exp_code = str(self.expcodeFTP.text())
                     if not exp_code == "":
                         try:
                            exp_code = int(self.expcodeFTP.text())
                         except:
                             self.console.clear()
                             self.console.append("Please Write  a  exp_code number")
                             return 0
                     sub_exp_code = str(self.subexpFTP.text())
                     if not sub_exp_code == "":
                         try:
                            sub_exp_code = int(self.subexpFTP.text())
                         except:
                             self.console.clear()
                             self.console.append("Please Write  a  sub_exp_code number")
                             return 0
                     plot_pos = str(self.plotposFTP.text())
                     if not plot_pos == "":
                         try:
                            plot_pos = int(self.plotposFTP.text())
                         except:
                             self.console.clear()
                             self.console.append("Please Write  a  plot_pos number")
                             return 0
                     return  name_server_ftp, folder_server_ftp, username_ftp, password_ftp, ftp_wei, exp_code, sub_exp_code, plot_pos
                 @pyqtSignature("")
                 def on_ftpOkButton_clicked(self):
                     server, remotefolder, username, password, ftp_wei, exp_code, sub_exp_code, plot_pos = self.getParmsFromFtpWindow()
                     self.create = True
                     self.close()
                 @pyqtSignature("")
                 def on_ftpCancelButton_clicked(self):
                     self.create = False
                     self.close()
                 def closeEvent(self, event):
                     self.closed.emit()
                     event.accept()
             class ftpBuffer():
                 server = None
                 remotefolder = None
                 username = None
                 password = None
                 ftp_wei = None
                 exp_code = None
                 sub_exp_code = None
                 plot_pos = None
                 create = False
                 withoutconfig = False
                 createforView = False
                 localfolder = None
                 extension = None
                 period = None
                 protocol = None
                 def __init__(self):
                     self.create = False
                     self.server = None
                     self.remotefolder = None
                     self.username = None
                     self.password = None
                     self.ftp_wei = None
                     self.exp_code = None
                     self.sub_exp_code = None
                     self.plot_pos = None
                     # self.create = False
                     self.localfolder = None
                     self.extension = None
                     self.period = None
                     self.protocol = None
                 def setwithoutconfiguration(self):
                     self.create = False
                     self.server = "jro-app.igp.gob.pe"
                     self.remotefolder = "/home/wmaster/graficos"
                     self.username = "wmaster"
                     self.password = "mst2010vhf"
                     self.withoutconfig = True
                     self.localfolder = './'
                     self.extension = '.png'
                     self.period = 60
                     self.protocol = 'ftp'
                     self.createforView = True
                     if not self.ftp_wei:
                         self.ftp_wei = 0
                     if not self.exp_code:
                         self.exp_code = 0
                     if not self.sub_exp_code:
                         self.sub_exp_code = 0
                     if not self.plot_pos:
                         self.plot_pos = 0
                 def save(self, server, remotefolder, username, password, ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, localfolder='./', extension='.png', period=60, protocol='ftp'):
                     self.server = server
                     self.remotefolder = remotefolder
                     self.username = username
                     self.password = password
                     self.ftp_wei = ftp_wei
                     self.exp_code = exp_code
                     self.sub_exp_code = sub_exp_code
                     self.plot_pos = plot_pos
                     self.create = True
                     self.withoutconfig = False
                     self.createforView = True
                     self.localfolder = localfolder
                     self.extension = extension
                     self.period = period
                     self.protocol = protocol
                 def recover(self):
                     return self.server, self.remotefolder, self.username, self.password, self.ftp_wei, self.exp_code, self.sub_exp_code, self.plot_pos, self.extension, self.period, self.protocol
             class ShowMeConsole(QtCore.QObject):
                 textWritten = QtCore.pyqtSignal(str)
                 def write(self, text):
                     if text[-1] == "\n":
                         text = text[:-1]
                     self.textWritten.emit(str(text))

schainpy/gui/viewer/windows/ui_spectra_heis.py +2 -2

             from PyQt4 import QtCore, QtGui
             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)
             class Ui_SpectraHeisTab(object):
                 def setupUi(self):
                     self.tabSpectraHeis = QtGui.QWidget()
                     self.tabSpectraHeis.setObjectName(_fromUtf8("tabSpectraHeis"))
                     self.gridLayout_23 = QtGui.QGridLayout(self.tabSpectraHeis)
                     self.gridLayout_23.setObjectName(_fromUtf8("gridLayout_23"))
                     self.frame_6 = QtGui.QFrame(self.tabSpectraHeis)
                     self.frame_6.setFrameShape(QtGui.QFrame.StyledPanel)
                     self.frame_6.setFrameShadow(QtGui.QFrame.Raised)
                     self.frame_6.setObjectName(_fromUtf8("frame_6"))
                     self.gridLayout_22 = QtGui.QGridLayout(self.frame_6)
                     self.gridLayout_22.setObjectName(_fromUtf8("gridLayout_22"))
                     self.specHeisGraphClear = QtGui.QPushButton(self.frame_6)
                     self.specHeisGraphClear.setObjectName(_fromUtf8("specHeisGraphClear"))
                     self.gridLayout_22.addWidget(self.specHeisGraphClear, 0, 1, 1, 1)
                     self.specHeisOpOk = QtGui.QPushButton(self.frame_6)
                     self.specHeisOpOk.setObjectName(_fromUtf8("specHeisOpOk"))
                     self.gridLayout_22.addWidget(self.specHeisOpOk, 0, 0, 1, 1)
                     self.gridLayout_23.addWidget(self.frame_6, 1, 0, 1, 1)
                     self.tabWidgetSpectraHeis = QtGui.QTabWidget(self.tabSpectraHeis)
                     self.tabWidgetSpectraHeis.setObjectName(_fromUtf8("tabWidgetSpectraHeis"))
                     self.tabopSpectraHeis = QtGui.QWidget()
                     self.tabopSpectraHeis.setObjectName(_fromUtf8("tabopSpectraHeis"))
                     self.gridLayout_21 = QtGui.QGridLayout(self.tabopSpectraHeis)
                     self.gridLayout_21.setObjectName(_fromUtf8("gridLayout_21"))
                     spacerItem21 = QtGui.QSpacerItem(40, 20, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Minimum)
                     self.gridLayout_21.addItem(spacerItem21, 0, 1, 1, 1)
                     self.specHeisOpCobIncInt = QtGui.QComboBox(self.tabopSpectraHeis)
                     self.specHeisOpCobIncInt.setObjectName(_fromUtf8("specHeisOpCobIncInt"))
                     self.specHeisOpCobIncInt.addItem(_fromUtf8(""))
                     self.gridLayout_21.addWidget(self.specHeisOpCobIncInt, 1, 0, 1, 1)
                     self.specHeisOpCebIncoherent = QtGui.QCheckBox(self.tabopSpectraHeis)
                     self.specHeisOpCebIncoherent.setObjectName(_fromUtf8("specHeisOpCebIncoherent"))
                     self.gridLayout_21.addWidget(self.specHeisOpCebIncoherent, 0, 0, 1, 1)
                     self.specHeisOpIncoherent = QtGui.QLineEdit(self.tabopSpectraHeis)
                     self.specHeisOpIncoherent.setObjectName(_fromUtf8("specHeisOpIncoherent"))
                     self.gridLayout_21.addWidget(self.specHeisOpIncoherent, 1, 1, 1, 1)
                     spacerItem22 = QtGui.QSpacerItem(20, 40, QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Expanding)
                     self.gridLayout_21.addItem(spacerItem22, 2, 0, 1, 1)
                     self.tabWidgetSpectraHeis.addTab(self.tabopSpectraHeis, _fromUtf8(""))
                     self.tabgraphSpectraHeis = QtGui.QWidget()
                     self.tabgraphSpectraHeis.setObjectName(_fromUtf8("tabgraphSpectraHeis"))
                     self.gridLayout_20 = QtGui.QGridLayout(self.tabgraphSpectraHeis)
                     self.gridLayout_20.setObjectName(_fromUtf8("gridLayout_20"))
                     self.label_54 = QtGui.QLabel(self.tabgraphSpectraHeis)
                     self.label_54.setObjectName(_fromUtf8("label_54"))
                     self.gridLayout_20.addWidget(self.label_54, 1, 0, 1, 1)
                     self.specHeisGraphToolPath = QtGui.QToolButton(self.tabgraphSpectraHeis)
                     self.specHeisGraphToolPath.setObjectName(_fromUtf8("specHeisGraphToolPath"))
                     self.gridLayout_20.addWidget(self.specHeisGraphToolPath, 0, 6, 1, 1)
                     self.specHeisGraphCebRTIplot = QtGui.QCheckBox(self.tabgraphSpectraHeis)
                     self.specHeisGraphCebRTIplot.setText(_fromUtf8(""))
                     self.specHeisGraphCebRTIplot.setObjectName(_fromUtf8("specHeisGraphCebRTIplot"))
                     self.gridLayout_20.addWidget(self.specHeisGraphCebRTIplot, 4, 2, 1, 1)
                     self.label_62 = QtGui.QLabel(self.tabgraphSpectraHeis)
                     self.label_62.setObjectName(_fromUtf8("label_62"))
                     self.gridLayout_20.addWidget(self.label_62, 7, 0, 1, 1)
                     self.label_63 = QtGui.QLabel(self.tabgraphSpectraHeis)
                     self.label_63.setObjectName(_fromUtf8("label_63"))
                     self.gridLayout_20.addWidget(self.label_63, 8, 0, 1, 1)
                     self.label_64 = QtGui.QLabel(self.tabgraphSpectraHeis)
                     self.label_64.setObjectName(_fromUtf8("label_64"))
                     self.gridLayout_20.addWidget(self.label_64, 9, 0, 1, 1)
                     self.label_65 = QtGui.QLabel(self.tabgraphSpectraHeis)
                     self.label_65.setObjectName(_fromUtf8("label_65"))
                     self.gridLayout_20.addWidget(self.label_65, 10, 0, 1, 1)
                     spacerItem23 = QtGui.QSpacerItem(134, 20, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Minimum)
                     self.gridLayout_20.addItem(spacerItem23, 11, 0, 1, 2)
                     self.specHeisGgraphftpratio = QtGui.QLineEdit(self.tabgraphSpectraHeis)
                     self.specHeisGgraphftpratio.setObjectName(_fromUtf8("specHeisGgraphftpratio"))
                     self.gridLayout_20.addWidget(self.specHeisGgraphftpratio, 10, 1, 1, 6)
                     self.specHeisGraphftpRTIplot = QtGui.QCheckBox(self.tabgraphSpectraHeis)
                     self.specHeisGraphftpRTIplot.setText(_fromUtf8(""))
                     self.specHeisGraphftpRTIplot.setObjectName(_fromUtf8("specHeisGraphftpRTIplot"))
                     self.gridLayout_20.addWidget(self.specHeisGraphftpRTIplot, 4, 6, 1, 1)
                     self.specHeisGgraphTminTmax = QtGui.QLineEdit(self.tabgraphSpectraHeis)
                     self.specHeisGgraphTminTmax.setObjectName(_fromUtf8("specHeisGgraphTminTmax"))
                     self.gridLayout_20.addWidget(self.specHeisGgraphTminTmax, 8, 1, 1, 6)
                     self.label_60 = QtGui.QLabel(self.tabgraphSpectraHeis)
                     self.label_60.setObjectName(_fromUtf8("label_60"))
                     self.gridLayout_20.addWidget(self.label_60, 5, 0, 1, 1)
                     self.label_61 = QtGui.QLabel(self.tabgraphSpectraHeis)
                     self.label_61.setObjectName(_fromUtf8("label_61"))
                     self.gridLayout_20.addWidget(self.label_61, 6, 0, 1, 1)
                     self.specHeisGraphPrefix = QtGui.QLineEdit(self.tabgraphSpectraHeis)
                     self.specHeisGraphPrefix.setObjectName(_fromUtf8("specHeisGraphPrefix"))
                     self.gridLayout_20.addWidget(self.specHeisGraphPrefix, 1, 1, 1, 6)
                     self.label_56 = QtGui.QLabel(self.tabgraphSpectraHeis)
                     self.label_56.setObjectName(_fromUtf8("label_56"))
                     self.gridLayout_20.addWidget(self.label_56, 2, 4, 1, 1)
                     self.label_57 = QtGui.QLabel(self.tabgraphSpectraHeis)
                     self.label_57.setObjectName(_fromUtf8("label_57"))
                     self.gridLayout_20.addWidget(self.label_57, 2, 6, 1, 1)
                     self.label_58 = QtGui.QLabel(self.tabgraphSpectraHeis)
                     self.label_58.setObjectName(_fromUtf8("label_58"))
                     self.gridLayout_20.addWidget(self.label_58, 3, 0, 1, 1)
                     self.specHeisGraphCebSpectraplot = QtGui.QCheckBox(self.tabgraphSpectraHeis)
                     self.specHeisGraphCebSpectraplot.setText(_fromUtf8(""))
                     self.specHeisGraphCebSpectraplot.setObjectName(_fromUtf8("specHeisGraphCebSpectraplot"))
                     self.gridLayout_20.addWidget(self.specHeisGraphCebSpectraplot, 3, 2, 1, 1)
                     self.specHeisGgraphYminYmax = QtGui.QLineEdit(self.tabgraphSpectraHeis)
                     self.specHeisGgraphYminYmax.setObjectName(_fromUtf8("specHeisGgraphYminYmax"))
                     self.gridLayout_20.addWidget(self.specHeisGgraphYminYmax, 7, 1, 1, 6)
                     self.label_53 = QtGui.QLabel(self.tabgraphSpectraHeis)
                     self.label_53.setObjectName(_fromUtf8("label_53"))
                     self.gridLayout_20.addWidget(self.label_53, 0, 0, 1, 1)
                     self.label_55 = QtGui.QLabel(self.tabgraphSpectraHeis)
                     self.label_55.setObjectName(_fromUtf8("label_55"))
                     self.gridLayout_20.addWidget(self.label_55, 2, 2, 1, 1)
                     self.specHeisGraphSaveRTIplot = QtGui.QCheckBox(self.tabgraphSpectraHeis)
                     self.specHeisGraphSaveRTIplot.setText(_fromUtf8(""))
                     self.specHeisGraphSaveRTIplot.setObjectName(_fromUtf8("specHeisGraphSaveRTIplot"))
                     self.gridLayout_20.addWidget(self.specHeisGraphSaveRTIplot, 4, 4, 1, 1)
                     spacerItem24 = QtGui.QSpacerItem(40, 20, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Minimum)
                     self.gridLayout_20.addItem(spacerItem24, 2, 3, 1, 1)
                     self.specHeisGgraphXminXmax = QtGui.QLineEdit(self.tabgraphSpectraHeis)
                     self.specHeisGgraphXminXmax.setObjectName(_fromUtf8("specHeisGgraphXminXmax"))
                     self.gridLayout_20.addWidget(self.specHeisGgraphXminXmax, 6, 1, 1, 6)
                     self.specHeisGgraphChannelList = QtGui.QLineEdit(self.tabgraphSpectraHeis)
                     self.specHeisGgraphChannelList.setObjectName(_fromUtf8("specHeisGgraphChannelList"))
                     self.gridLayout_20.addWidget(self.specHeisGgraphChannelList, 5, 1, 1, 6)
                     self.specHeisGgraphTimeRange = QtGui.QLineEdit(self.tabgraphSpectraHeis)
                     self.specHeisGgraphTimeRange.setObjectName(_fromUtf8("specHeisGgraphTimeRange"))
                     self.gridLayout_20.addWidget(self.specHeisGgraphTimeRange, 9, 1, 1, 6)
                     spacerItem25 = QtGui.QSpacerItem(106, 20, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Minimum)
                     self.gridLayout_20.addItem(spacerItem25, 11, 3, 1, 3)
                     self.specHeisGraphSaveSpectra = QtGui.QCheckBox(self.tabgraphSpectraHeis)
                     self.specHeisGraphSaveSpectra.setText(_fromUtf8(""))
                     self.specHeisGraphSaveSpectra.setObjectName(_fromUtf8("specHeisGraphSaveSpectra"))
                     self.gridLayout_20.addWidget(self.specHeisGraphSaveSpectra, 3, 4, 1, 1)
                     self.specHeisGraphftpSpectra = QtGui.QCheckBox(self.tabgraphSpectraHeis)
                     self.specHeisGraphftpSpectra.setText(_fromUtf8(""))
                     self.specHeisGraphftpSpectra.setObjectName(_fromUtf8("specHeisGraphftpSpectra"))
                     self.gridLayout_20.addWidget(self.specHeisGraphftpSpectra, 3, 6, 1, 1)
                     self.label_59 = QtGui.QLabel(self.tabgraphSpectraHeis)
                     self.label_59.setObjectName(_fromUtf8("label_59"))
                     self.gridLayout_20.addWidget(self.label_59, 4, 0, 1, 1)
                     spacerItem26 = QtGui.QSpacerItem(40, 20, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Minimum)
                     self.gridLayout_20.addItem(spacerItem26, 2, 5, 1, 1)
                     self.specHeisGraphPath = QtGui.QLineEdit(self.tabgraphSpectraHeis)
                     self.specHeisGraphPath.setObjectName(_fromUtf8("specHeisGraphPath"))
                     self.gridLayout_20.addWidget(self.specHeisGraphPath, 0, 1, 1, 5)
                     self.tabWidgetSpectraHeis.addTab(self.tabgraphSpectraHeis, _fromUtf8(""))
                     self.taboutputSpectraHeis = QtGui.QWidget()
                     self.taboutputSpectraHeis.setObjectName(_fromUtf8("taboutputSpectraHeis"))
                     self.gridLayout_19 = QtGui.QGridLayout(self.taboutputSpectraHeis)
                     self.gridLayout_19.setObjectName(_fromUtf8("gridLayout_19"))
                     self.label_67 = QtGui.QLabel(self.taboutputSpectraHeis)
                     self.label_67.setObjectName(_fromUtf8("label_67"))
                     self.gridLayout_19.addWidget(self.label_67, 1, 0, 1, 1)
                     self.label_68 = QtGui.QLabel(self.taboutputSpectraHeis)
                     self.label_68.setObjectName(_fromUtf8("label_68"))
                     self.gridLayout_19.addWidget(self.label_68, 2, 0, 1, 2)
                     self.label_66 = QtGui.QLabel(self.taboutputSpectraHeis)
                     self.label_66.setObjectName(_fromUtf8("label_66"))
                     self.gridLayout_19.addWidget(self.label_66, 0, 0, 1, 1)
                     spacerItem27 = QtGui.QSpacerItem(20, 40, QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Expanding)
                     self.gridLayout_19.addItem(spacerItem27, 4, 0, 1, 1)
                     self.specHeisOutputToolPath = QtGui.QToolButton(self.taboutputSpectraHeis)
                     self.specHeisOutputToolPath.setObjectName(_fromUtf8("specHeisOutputToolPath"))
                     self.gridLayout_19.addWidget(self.specHeisOutputToolPath, 1, 4, 1, 1)
                     self.specHeisOutputPath = QtGui.QLineEdit(self.taboutputSpectraHeis)
                     self.specHeisOutputPath.setObjectName(_fromUtf8("specHeisOutputPath"))
                     self.gridLayout_19.addWidget(self.specHeisOutputPath, 1, 3, 1, 1)
                     self.specHeisOutputComdata = QtGui.QComboBox(self.taboutputSpectraHeis)
                     self.specHeisOutputComdata.setObjectName(_fromUtf8("specHeisOutputComdata"))
                     self.specHeisOutputComdata.addItem(_fromUtf8(""))
                     self.gridLayout_19.addWidget(self.specHeisOutputComdata, 0, 3, 1, 2)
                     self.label_69 = QtGui.QLabel(self.taboutputSpectraHeis)
                     self.label_69.setObjectName(_fromUtf8("label_69"))
                     self.gridLayout_19.addWidget(self.label_69, 3, 0, 1, 2)
                     self.specHeisOutputblocksperfile = QtGui.QLineEdit(self.taboutputSpectraHeis)
                     self.specHeisOutputblocksperfile.setObjectName(_fromUtf8("specHeisOutputblocksperfile"))
                     self.gridLayout_19.addWidget(self.specHeisOutputblocksperfile, 2, 3, 1, 1)
                     self.specHeisOutputMetada = QtGui.QLineEdit(self.taboutputSpectraHeis)
                     self.specHeisOutputMetada.setObjectName(_fromUtf8("specHeisOutputMetada"))
                     self.gridLayout_19.addWidget(self.specHeisOutputMetada, 3, 3, 1, 1)
                     self.specHeisOutputMetadaToolPath = QtGui.QToolButton(self.taboutputSpectraHeis)
                     self.specHeisOutputMetadaToolPath.setObjectName(_fromUtf8("specHeisOutputMetadaToolPath"))
                     self.gridLayout_19.addWidget(self.specHeisOutputMetadaToolPath, 3, 4, 1, 1)
                     self.tabWidgetSpectraHeis.addTab(self.taboutputSpectraHeis, _fromUtf8(""))
                     self.gridLayout_23.addWidget(self.tabWidgetSpectraHeis, 0, 0, 1, 1)
                     self.tabWidgetProject.addTab(self.tabSpectraHeis, _fromUtf8(""))
                     self.tabWidgetSpectraHeis.setCurrentIndex(0)
                 def retranslateUi(self):
                     self.specHeisGraphClear.setText(_translate("MainWindow", "Clear", None))
                     self.specHeisOpOk.setText(_translate("MainWindow", "Ok", None))
                     self.specHeisOpCobIncInt.setItemText(0, _translate("MainWindow", "Time Interval", None))
                     self.specHeisOpCebIncoherent.setText(_translate("MainWindow", "Incoherent Intergration", None))
                     self.tabWidgetSpectraHeis.setTabText(self.tabWidgetSpectraHeis.indexOf(self.tabopSpectraHeis), _translate("MainWindow", "Operation", None))
                     self.label_54.setText(_translate("MainWindow", "Prefix", None))
                     self.specHeisGraphToolPath.setText(_translate("MainWindow", "...", None))
                     self.label_62.setText(_translate("MainWindow", "Intensity range (dB)", None))
                     self.label_63.setText(_translate("MainWindow", "Time range (hours):", None))
                     self.label_64.setText(_translate("MainWindow", "Time interval:", None))
                     self.label_65.setText(_translate("MainWindow", "Wr Period", None))
                     self.label_60.setText(_translate("MainWindow", "Channel List:", None))
                     self.label_61.setText(_translate("MainWindow", "Frequency range", None))
                     self.label_56.setText(_translate("MainWindow", "Save", None))
                     self.label_57.setText(_translate("MainWindow", "ftp", None))
                     self.label_58.setText(_translate("MainWindow", "Spectra Plot", None))
                     self.label_53.setText(_translate("MainWindow", "Path", None))
                     self.label_55.setText(_translate("MainWindow", "Show", None))
                     self.label_59.setText(_translate("MainWindow", "RTI Plot", None))
                     self.tabWidgetSpectraHeis.setTabText(self.tabWidgetSpectraHeis.indexOf(self.tabgraphSpectraHeis), _translate("MainWindow", "Graphics", None))
                     self.label_67.setText(_translate("MainWindow", "Path:", None))
-                    self.label_68.setText(_translate("MainWindow", "Blocks  per File:", None))
+                    self.label_68.setText(_translate("MainWindow", "Blocks per file:", None))
                     self.label_66.setText(_translate("MainWindow", "Type:", None))
                     self.tabWidgetSpectraHeis.setTabText(self.tabWidgetSpectraHeis.indexOf(self.taboutputSpectraHeis), _translate("MainWindow", "Output", None))
                     self.specHeisOutputToolPath.setText(_translate("MainWindow", "...", None))
                     self.specHeisOutputComdata.setItemText(0, _translate("MainWindow", ".fits", None))
-                    self.label_69.setText(_translate("MainWindow", "Metada", None))
+                    self.label_69.setText(_translate("MainWindow", "Metadata file:", None))
                     self.specHeisOutputMetadaToolPath.setText(_translate("MainWindow", "...", None))
                     self.tabWidgetProject.setTabText(self.tabWidgetProject.indexOf(self.tabSpectraHeis), _translate("MainWindow", "SpectraHeis", None))

schainpy/model/data/jrodata.py 0 -4

             '''
             $Author: murco $
             $Id: JROData.py 173 2012-11-20 15:06:21Z murco $
             '''
             import copy
             import numpy
             import datetime
             from jroheaderIO import SystemHeader, RadarControllerHeader
             def getNumpyDtype(dataTypeCode):
                 if dataTypeCode == 0:
                     numpyDtype = numpy.dtype([('real','<i1'),('imag','<i1')])
                 elif dataTypeCode == 1:
                     numpyDtype = numpy.dtype([('real','<i2'),('imag','<i2')])
                 elif dataTypeCode == 2:
                     numpyDtype = numpy.dtype([('real','<i4'),('imag','<i4')])
                 elif dataTypeCode == 3:
                     numpyDtype = numpy.dtype([('real','<i8'),('imag','<i8')])
                 elif dataTypeCode == 4:
                     numpyDtype = numpy.dtype([('real','<f4'),('imag','<f4')])
                 elif dataTypeCode == 5:
                     numpyDtype = numpy.dtype([('real','<f8'),('imag','<f8')])
                 else:
                     raise ValueError, 'dataTypeCode was not defined'
                 return numpyDtype
             def getDataTypeCode(numpyDtype):
                 if numpyDtype == numpy.dtype([('real','<i1'),('imag','<i1')]):
                     datatype = 0
                 elif numpyDtype == numpy.dtype([('real','<i2'),('imag','<i2')]):
                     datatype = 1
                 elif numpyDtype == numpy.dtype([('real','<i4'),('imag','<i4')]):
                     datatype = 2
                 elif numpyDtype == numpy.dtype([('real','<i8'),('imag','<i8')]):
                     datatype = 3
                 elif numpyDtype == numpy.dtype([('real','<f4'),('imag','<f4')]):
                     datatype = 4
                 elif numpyDtype == numpy.dtype([('real','<f8'),('imag','<f8')]):
                     datatype = 5
                 else:
                     datatype = None
                 return datatype
             def hildebrand_sekhon(data, navg):
                 """
                 This method is for the objective determination of the noise level in Doppler spectra. This
                 implementation technique is based on the fact that the standard deviation of the spectral
                 densities is equal to the mean spectral density for white Gaussian noise
                 Inputs:
                     Data    :    heights
                     navg    :    numbers of averages
                 Return:
                     -1        :    any error
                     anoise    :    noise's level
                 """
                 sortdata = numpy.sort(data,axis=None)
                 lenOfData = len(sortdata)
                 nums_min = lenOfData/10
                 if (lenOfData/10) > 2:
                     nums_min = lenOfData/10
                 else:
                     nums_min = 2
                 sump = 0.
                 sumq = 0.
                 j = 0
                 cont = 1
                 while((cont==1)and(j<lenOfData)):
                     sump += sortdata[j]
                     sumq += sortdata[j]**2
                     if j > nums_min:
                         rtest = float(j)/(j-1) + 1.0/navg
                         if ((sumq*j) > (rtest*sump**2)):
                             j = j - 1
                             sump  = sump - sortdata[j]
                             sumq =  sumq - sortdata[j]**2
                             cont = 0
                     j += 1
                 lnoise = sump /j
                 stdv = numpy.sqrt((sumq - lnoise**2)/(j - 1))
                 return lnoise
             class Beam:
                 def __init__(self):
                     self.codeList = []
                     self.azimuthList = []
                     self.zenithList = []
             class GenericData(object):
                 flagNoData = True
                 def __init__(self):
                     raise ValueError, "This class has not been implemented"
                 def copy(self, inputObj=None):
                     if inputObj == None:
                         return copy.deepcopy(self)
                     for key in inputObj.__dict__.keys():
                         self.__dict__[key] = inputObj.__dict__[key]
                 def deepcopy(self):
                     return copy.deepcopy(self)
                 def isEmpty(self):
                     return self.flagNoData
             class JROData(GenericData):
             #    m_BasicHeader = BasicHeader()
             #    m_ProcessingHeader = ProcessingHeader()
                 systemHeaderObj = SystemHeader()
                 radarControllerHeaderObj = RadarControllerHeader()
             #    data = None
                 type = None
                 datatype = None #dtype but in string
             #     dtype = None
             #    nChannels = None
             #    nHeights = None
                 nProfiles = None
                 heightList = None
                 channelList = None
                 flagDiscontinuousBlock = False
                 useLocalTime = False
                 utctime = None
                 timeZone = None
                 dstFlag = None
                 errorCount = None
                 blocksize = None
             #     nCode = None
             #
             #     nBaud = None
             #
             #     code = None
                 flagDecodeData = False #asumo q la data no esta decodificada
                 flagDeflipData = False #asumo q la data no esta sin flip
                 flagShiftFFT = False
             #     ippSeconds = None
             #     timeInterval = None
                 nCohInt = None
             #     noise = None
                 windowOfFilter = 1
                 #Speed of ligth
                 C = 3e8
                 frequency = 49.92e6
                 realtime = False
                 beacon_heiIndexList = None
                 last_block = None
                 blocknow = None
                 azimuth = None
                 zenith = None
                 beam = Beam()
                 profileIndex = None
                 def __init__(self):
                     raise ValueError, "This class has not been implemented"
                 def getNoise(self):
                     raise ValueError, "Not implemented"
                 def getNChannels(self):
                     return len(self.channelList)
                 def getChannelIndexList(self):
                     return range(self.nChannels)
                 def getNHeights(self):
                     return len(self.heightList)
                 def getHeiRange(self, extrapoints=0):
                     heis = self.heightList
             #        deltah = self.heightList[1] - self.heightList[0]
             #
             #        heis.append(self.heightList[-1])
                     return heis
                 def getltctime(self):
                     if self.useLocalTime:
                         return self.utctime - self.timeZone*60
                     return self.utctime
                 def getDatatime(self):
                     datatimeValue = datetime.datetime.utcfromtimestamp(self.ltctime)
                     return datatimeValue
                 def getTimeRange(self):
                     datatime = []
                     datatime.append(self.ltctime)
                     datatime.append(self.ltctime + self.timeInterval+60)
                     datatime = numpy.array(datatime)
                     return datatime
                 def getFmax(self):
                     PRF = 1./(self.ippSeconds * self.nCohInt)
                     fmax = PRF/2.
                     return fmax
                 def getVmax(self):
                     _lambda = self.C/self.frequency
                     vmax = self.getFmax() * _lambda
                     return vmax
                 def get_ippSeconds(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.ippSeconds
                 def set_ippSeconds(self, ippSeconds):
                     '''
                     '''
                     self.radarControllerHeaderObj.ippSeconds = ippSeconds
                     return
                 def get_dtype(self):
                     '''
                     '''
                     return getNumpyDtype(self.datatype)
                 def set_dtype(self, numpyDtype):
                     '''
                     '''
                     self.datatype = getDataTypeCode(numpyDtype)
                 def get_code(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.code
                 def set_code(self, code):
                     '''
                     '''
                     self.radarControllerHeaderObj.code = code
                     return
                 def get_ncode(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.nCode
                 def set_ncode(self, nCode):
                     '''
                     '''
                     self.radarControllerHeaderObj.nCode = nCode
                     return
                 def get_nbaud(self):
                     '''
                     '''
                     return self.radarControllerHeaderObj.nBaud
                 def set_nbaud(self, nBaud):
                     '''
                     '''
                     self.radarControllerHeaderObj.nBaud = nBaud
                     return
             #     def getTimeInterval(self):
             #
             #         raise IOError, "This method should be implemented inside each Class"
                 nChannels = property(getNChannels, "I'm the 'nChannel' property.")
                 channelIndexList = property(getChannelIndexList, "I'm the 'channelIndexList' property.")
                 nHeights = property(getNHeights, "I'm the 'nHeights' property.")
                 #noise = property(getNoise, "I'm the 'nHeights' property.")
                 datatime = property(getDatatime, "I'm the 'datatime' property")
                 ltctime = property(getltctime, "I'm the 'ltctime' property")
                 ippSeconds = property(get_ippSeconds, set_ippSeconds)
                 dtype = property(get_dtype, set_dtype)
             #     timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
                 code = property(get_code, set_code)
                 nCode = property(get_ncode, set_ncode)
                 nBaud = property(get_nbaud, set_nbaud)
             class Voltage(JROData):
                 #data es un numpy array de 2 dmensiones (canales, alturas)
                 data = None
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.useLocalTime = True
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Voltage"
                     self.data = None
             #         self.dtype = None
             #        self.nChannels = 0
             #        self.nHeights = 0
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
             #        self.channelIndexList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
                     self.utctime = None
                     self.timeZone = None
                     self.dstFlag = None
                     self.errorCount = None
                     self.nCohInt = None
                     self.blocksize = None
                     self.flagDecodeData = False #asumo q la data no esta decodificada
                     self.flagDeflipData = False #asumo q la data no esta sin flip
                     self.flagShiftFFT = False
                     self.flagDataAsBlock = False    #Asumo que la data es leida perfil a perfil
                     self.profileIndex = 0
                 def getNoisebyHildebrand(self, channel = None):
                     """
                     Determino el nivel de ruido usando el metodo Hildebrand-Sekhon
                     Return:
                         noiselevel
                     """
                     if channel != None:
                         data = self.data[channel]
                         nChannels = 1
                     else:
                         data = self.data
                         nChannels = self.nChannels
                     noise = numpy.zeros(nChannels)
                     power = data * numpy.conjugate(data)
                     for thisChannel in range(nChannels):
                         if nChannels == 1:
                             daux = power[:].real
                         else:
                             daux = power[thisChannel,:].real
                         noise[thisChannel] = hildebrand_sekhon(daux, self.nCohInt)
                     return noise
                 def getNoise(self, type = 1, channel = None):
                     if type == 1:
                         noise = self.getNoisebyHildebrand(channel)
                     return 10*numpy.log10(noise)
                 def getPower(self, channel = None):
                     if channel != None:
                         data = self.data[channel]
                     else:
                         data = self.data
                     power = data * numpy.conjugate(data)
                     return 10*numpy.log10(power.real)
                 def getTimeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt
                     return timeInterval
                 noise = property(getNoise, "I'm the 'nHeights' property.")
                 timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
             class Spectra(JROData):
                 #data es un numpy array de 2 dmensiones (canales, perfiles, alturas)
                 data_spc = None
                 #data es un numpy array de 2 dmensiones (canales, pares, alturas)
                 data_cspc = None
                 #data es un numpy array de 2 dmensiones (canales, alturas)
                 data_dc = None
                 nFFTPoints = None
             #     nPairs = None
                 pairsList = None
                 nIncohInt = None
                 wavelength = None #Necesario para cacular el rango de velocidad desde la frecuencia
                 nCohInt = None #se requiere para determinar el valor de timeInterval
                 ippFactor = None
                 profileIndex = 0
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.useLocalTime = True
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Spectra"
             #        self.data = None
             #         self.dtype = None
             #        self.nChannels = 0
             #        self.nHeights = 0
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
             #        self.channelIndexList = None
                     self.pairsList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
                     self.utctime = None
                     self.nCohInt = None
                     self.nIncohInt = None
                     self.blocksize = None
                     self.nFFTPoints = None
                     self.wavelength = None
                     self.flagDecodeData = False #asumo q la data no esta decodificada
                     self.flagDeflipData = False #asumo q la data no esta sin flip
                     self.flagShiftFFT = False
                     self.ippFactor = 1
                     #self.noise = None
                     self.beacon_heiIndexList = []
                     self.noise_estimation = None
                 def getNoisebyHildebrand(self, xmin_index=None, xmax_index=None, ymin_index=None, ymax_index=None):
                     """
                     Determino el nivel de ruido usando el metodo Hildebrand-Sekhon
                     Return:
                         noiselevel
                     """
                     noise = numpy.zeros(self.nChannels)
                     for channel in range(self.nChannels):
                         daux = self.data_spc[channel,xmin_index:xmax_index,ymin_index:ymax_index]
                         noise[channel] = hildebrand_sekhon(daux, self.nIncohInt)
                     return noise
                 def getNoise(self, xmin_index=None, xmax_index=None, ymin_index=None, ymax_index=None):
                     if self.noise_estimation != None:
                         return self.noise_estimation #this was estimated by getNoise Operation defined in jroproc_spectra.py
                     else:
                         noise = self.getNoisebyHildebrand(xmin_index, xmax_index, ymin_index, ymax_index)
                         return noise
                 def getFreqRange(self, extrapoints=0):
                     deltafreq = self.getFmax() / (self.nFFTPoints*self.ippFactor)
                     freqrange = deltafreq*(numpy.arange(self.nFFTPoints+extrapoints)-self.nFFTPoints/2.) - deltafreq/2
                     return freqrange
                 def getVelRange(self, extrapoints=0):
                     deltav = self.getVmax() / (self.nFFTPoints*self.ippFactor)
                     velrange = deltav*(numpy.arange(self.nFFTPoints+extrapoints)-self.nFFTPoints/2.) - deltav/2
                     return velrange
                 def getNPairs(self):
                     return len(self.pairsList)
                 def getPairsIndexList(self):
                     return range(self.nPairs)
                 def getNormFactor(self):
                     pwcode = 1
                     if self.flagDecodeData:
                         pwcode = numpy.sum(self.code[0]**2)
                     #normFactor = min(self.nFFTPoints,self.nProfiles)*self.nIncohInt*self.nCohInt*pwcode*self.windowOfFilter
                     normFactor = self.nProfiles*self.nIncohInt*self.nCohInt*pwcode*self.windowOfFilter
                     return normFactor
                 def getFlagCspc(self):
                     if self.data_cspc is None:
                         return True
                     return False
                 def getFlagDc(self):
                     if self.data_dc is None:
                         return True
                     return False
                 def getTimeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt * self.nProfiles
                     return timeInterval
                 def setValue(self, value):
                     print "This property should not be initialized"
                     return
                 nPairs = property(getNPairs, setValue, "I'm the 'nPairs' property.")
                 pairsIndexList = property(getPairsIndexList, setValue, "I'm the 'pairsIndexList' property.")
                 normFactor = property(getNormFactor, setValue, "I'm the 'getNormFactor' property.")
                 flag_cspc = property(getFlagCspc, setValue)
                 flag_dc = property(getFlagDc, setValue)
                 noise = property(getNoise, setValue, "I'm the 'nHeights' property.")
                 timeInterval = property(getTimeInterval, setValue, "I'm the 'timeInterval' property")
             class SpectraHeis(Spectra):
                 data_spc = None
                 data_cspc = None
                 data_dc = None
                 nFFTPoints = None
             #     nPairs = None
                 pairsList = None
                 nCohInt = None
                 nIncohInt = None
                 def __init__(self):
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "SpectraHeis"
             #         self.dtype = None
             #        self.nChannels = 0
             #        self.nHeights = 0
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
             #        self.channelIndexList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
             #         self.nPairs = 0
                     self.utctime = None
                     self.blocksize = None
                     self.profileIndex = 0
                     self.nCohInt = 1
                     self.nIncohInt = 1
                 def getNormFactor(self):
                     pwcode = 1
                     if self.flagDecodeData:
                         pwcode = numpy.sum(self.code[0]**2)
                     normFactor = self.nIncohInt*self.nCohInt*pwcode
                     return normFactor
                 def getTimeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt
                     return timeInterval
                 normFactor = property(getNormFactor, "I'm the 'getNormFactor' property.")
                 timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
             class Fits(JROData):
                 heightList = None
                 channelList = None
                 flagNoData = True
                 flagDiscontinuousBlock = False
                 useLocalTime = False
                 utctime = None
                 timeZone = None
             #     ippSeconds = None
             #     timeInterval = None
                 nCohInt = None
                 nIncohInt = None
                 noise = None
                 windowOfFilter = 1
                 #Speed of ligth
                 C = 3e8
                 frequency = 49.92e6
                 realtime = False
                 def __init__(self):
                     self.type = "Fits"
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
             #         self.channelIndexList = None
                     self.flagNoData = True
                     self.utctime = None
                     self.nCohInt = 1
                     self.nIncohInt = 1
                     self.useLocalTime = True
                     self.profileIndex = 0
             #         self.utctime = None
             #         self.timeZone = None
             #         self.ltctime = None
             #         self.timeInterval = None
             #         self.header = None
             #         self.data_header = None
             #         self.data = None
             #         self.datatime = None
             #         self.flagNoData = False
             #         self.expName = ''
             #         self.nChannels = None
             #         self.nSamples = None
             #         self.dataBlocksPerFile = None
             #         self.comments = ''
             #
                 def getltctime(self):
                     if self.useLocalTime:
                         return self.utctime - self.timeZone*60
                     return self.utctime
                 def getDatatime(self):
                     datatime = datetime.datetime.utcfromtimestamp(self.ltctime)
                     return datatime
                 def getTimeRange(self):
                     datatime = []
                     datatime.append(self.ltctime)
                     datatime.append(self.ltctime + self.timeInterval)
                     datatime = numpy.array(datatime)
                     return datatime
                 def getHeiRange(self):
                     heis = self.heightList
                     return heis
-                def isEmpty(self):
-                    return self.flagNoData
                 def getNHeights(self):
                     return len(self.heightList)
                 def getNChannels(self):
                     return len(self.channelList)
                 def getChannelIndexList(self):
                     return range(self.nChannels)
                 def getNoise(self, type = 1):
                     #noise = numpy.zeros(self.nChannels)
                     if type == 1:
                         noise = self.getNoisebyHildebrand()
                     if type == 2:
                         noise = self.getNoisebySort()
                     if type == 3:
                         noise = self.getNoisebyWindow()
                     return noise
                 def getTimeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt
                     return timeInterval
                 datatime = property(getDatatime, "I'm the 'datatime' property")
                 nHeights = property(getNHeights, "I'm the 'nHeights' property.")
                 nChannels = property(getNChannels, "I'm the 'nChannel' property.")
                 channelIndexList = property(getChannelIndexList, "I'm the 'channelIndexList' property.")
                 noise = property(getNoise, "I'm the 'nHeights' property.")
                 ltctime = property(getltctime, "I'm the 'ltctime' property")
                 timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
             class Correlation(JROData):
                 noise = None
                 SNR = None
                 pairsAutoCorr = None    #Pairs of Autocorrelation
                 #--------------------------------------------------
                 data_corr = None
                 data_volt = None
                 lagT = None # each element value is a profileIndex
                 lagR = None # each element value is in km
                 pairsList = None
                 calculateVelocity = None
                 nPoints = None
                 nAvg = None
                 bufferSize = None
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Correlation"
                     self.data = None
                     self.dtype = None
                     self.nProfiles = None
                     self.heightList = None
                     self.channelList = None
                     self.flagNoData = True
                     self.flagDiscontinuousBlock = False
                     self.utctime = None
                     self.timeZone = None
                     self.dstFlag = None
                     self.errorCount = None
                     self.blocksize = None
                     self.flagDecodeData = False #asumo q la data no esta decodificada
                     self.flagDeflipData = False #asumo q la data no esta sin flip
                     self.pairsList = None
                     self.nPoints = None
                 def getLagTRange(self, extrapoints=0):
                     lagTRange = self.lagT
                     diff = lagTRange[1] - lagTRange[0]
                     extra = numpy.arange(1,extrapoints + 1)*diff + lagTRange[-1]
                     lagTRange = numpy.hstack((lagTRange, extra))
                     return lagTRange
                 def getLagRRange(self, extrapoints=0):
                     return self.lagR
                 def getPairsList(self):
                     return self.pairsList
                 def getCalculateVelocity(self):
                     return self.calculateVelocity
                 def getNPoints(self):
                     return self.nPoints
                 def getNAvg(self):
                     return self.nAvg
                 def getBufferSize(self):
                     return self.bufferSize
                 def getPairsAutoCorr(self):
                     pairsList = self.pairsList
                     pairsAutoCorr = numpy.zeros(self.nChannels, dtype = 'int')*numpy.nan
                     for l in range(len(pairsList)):
                         firstChannel = pairsList[l][0]
                         secondChannel = pairsList[l][1]
                         #Obteniendo pares de Autocorrelacion
                         if firstChannel == secondChannel:
                             pairsAutoCorr[firstChannel] = int(l)
                     pairsAutoCorr = pairsAutoCorr.astype(int)
                     return pairsAutoCorr
                 def getNoise(self, mode = 2):
                     indR = numpy.where(self.lagR == 0)[0][0]
                     indT = numpy.where(self.lagT == 0)[0][0]
                     jspectra0 = self.data_corr[:,:,indR,:]
                     jspectra = copy.copy(jspectra0)
                     num_chan = jspectra.shape[0]
                     num_hei = jspectra.shape[2]
                     freq_dc = jspectra.shape[1]/2
                     ind_vel = numpy.array([-2,-1,1,2]) + freq_dc
                     if ind_vel[0]<0:
                         ind_vel[range(0,1)] = ind_vel[range(0,1)] + self.num_prof
                     if mode == 1:
                         jspectra[:,freq_dc,:] = (jspectra[:,ind_vel[1],:] + jspectra[:,ind_vel[2],:])/2 #CORRECCION
                     if mode == 2:
                         vel = numpy.array([-2,-1,1,2])
                         xx = numpy.zeros([4,4])
                         for fil in range(4):
                             xx[fil,:] = vel[fil]**numpy.asarray(range(4))
                         xx_inv = numpy.linalg.inv(xx)
                         xx_aux = xx_inv[0,:]
                         for ich in range(num_chan):
                             yy = jspectra[ich,ind_vel,:]
                             jspectra[ich,freq_dc,:] = numpy.dot(xx_aux,yy)
                             junkid = jspectra[ich,freq_dc,:]<=0
                             cjunkid = sum(junkid)
                             if cjunkid.any():
                                 jspectra[ich,freq_dc,junkid.nonzero()] = (jspectra[ich,ind_vel[1],junkid] + jspectra[ich,ind_vel[2],junkid])/2
                     noise = jspectra0[:,freq_dc,:] - jspectra[:,freq_dc,:]
                     return noise
                 def getTimeInterval(self):
                     timeInterval = self.ippSeconds * self.nCohInt * self.nPoints
                     return timeInterval
                 timeInterval = property(getTimeInterval, "I'm the 'timeInterval' property")
             #     pairsList = property(getPairsList, "I'm the 'pairsList' property.")
             #     nPoints = property(getNPoints, "I'm the 'nPoints' property.")
                 calculateVelocity = property(getCalculateVelocity, "I'm the 'calculateVelocity' property.")
                 nAvg = property(getNAvg, "I'm the 'nAvg' property.")
                 bufferSize = property(getBufferSize, "I'm the 'bufferSize' property.")
             class Parameters(JROData):
                 #Information from previous data
                 inputUnit = None        #Type of data to be processed
                 operation = None        #Type of operation to parametrize
                 normFactor = None       #Normalization Factor
                 groupList = None        #List of Pairs, Groups, etc
                 #Parameters
                 data_param = None       #Parameters obtained
                 data_pre = None         #Data Pre Parametrization
                 data_SNR = None         #Signal to Noise Ratio
             #     heightRange = None      #Heights
                 abscissaList = None    #Abscissa, can be velocities, lags or time
                 noise = None            #Noise Potency
                 utctimeInit = None      #Initial UTC time
                 paramInterval = None    #Time interval to calculate Parameters in seconds
                 #Fitting
                 data_error = None       #Error of the estimation
                 constants = None
                 library = None
                 #Output signal
                 outputInterval = None     #Time interval to calculate output signal in seconds
                 data_output = None       #Out signal
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.type = "Parameters"
                 def getTimeRange1(self):
                     datatime = []
                     if self.useLocalTime:
                         time1 = self.utctimeInit - self.timeZone*60
                     else:
                         time1 = utctimeInit
             #         datatime.append(self.utctimeInit)
             #         datatime.append(self.utctimeInit + self.outputInterval)
                     datatime.append(time1)
                     datatime.append(time1 + self.outputInterval)
                     datatime = numpy.array(datatime)
                     return datatime

schainpy/model/io/__init__.py 0 -5

             '''
             $Author: murco $
             $Id: JRODataIO.py 169 2012-11-19 21:57:03Z murco $
             '''
             from jroIO_voltage import *
             from jroIO_spectra import *
             from jroIO_heispectra import *
             from jroIO_usrp import *
-            # try:
-            #     from jroIO_usrp_api import *
-            # except:
-            #     print "jroIO_usrp_api could not be imported"
             from jroIO_amisr import *
             from jroIO_HDF5 import *
             from jroIO_hf import *

schainpy/model/io/jroIO_heispectra.py +27 -31

             '''
             Created on Jul 3, 2014
             @author: roj-idl71
             '''
             import os, sys
             import time, datetime
             import numpy
             import fnmatch
             import glob
+            from time import sleep
-            try:
-                from gevent import sleep
-            except:
-                from time import sleep
             try:
                 import pyfits
-            except:
+            except ImportError, e:
-                """
+                print "Fits data cannot be used. Install pyfits module"
-                """
             from xml.etree.ElementTree import ElementTree
             from jroIO_base import isRadarFolder, isNumber
+            from schainpy.model.data.jrodata import Fits
             from schainpy.model.proc.jroproc_base import Operation, ProcessingUnit
-            class Fits:
+            class PyFits(object):
                 name=None
                 format=None
                 array =None
                 data =None
                 thdulist=None
                 prihdr=None
                 hdu=None
                 def __init__(self):
                     pass
                 def setColF(self,name,format,array):
                     self.name=name
                     self.format=format
                     self.array=array
                     a1=numpy.array([self.array],dtype=numpy.float32)
                     self.col1 = pyfits.Column(name=self.name, format=self.format, array=a1)
                     return self.col1
             #    def setColP(self,name,format,data):
             #        self.name=name
             #        self.format=format
             #        self.data=data
             #        a2=numpy.array([self.data],dtype=numpy.float32)
             #        self.col2 = pyfits.Column(name=self.name, format=self.format, array=a2)
             #        return self.col2
                 def writeData(self,name,format,data):
                     self.name=name
                     self.format=format
                     self.data=data
                     a2=numpy.array([self.data],dtype=numpy.float32)
                     self.col2 = pyfits.Column(name=self.name, format=self.format, array=a2)
                     return self.col2
                 def cFImage(self,idblock,year,month,day,hour,minute,second):
                     self.hdu= pyfits.PrimaryHDU(idblock)
                     self.hdu.header.set("Year",year)
                     self.hdu.header.set("Month",month)
                     self.hdu.header.set("Day",day)
                     self.hdu.header.set("Hour",hour)
                     self.hdu.header.set("Minute",minute)
                     self.hdu.header.set("Second",second)
                     return self.hdu
                 def Ctable(self,colList):
                     self.cols=pyfits.ColDefs(colList)
                     self.tbhdu = pyfits.new_table(self.cols)
                     return self.tbhdu
                 def CFile(self,hdu,tbhdu):
                     self.thdulist=pyfits.HDUList([hdu,tbhdu])
                 def wFile(self,filename):
                     if os.path.isfile(filename):
                         os.remove(filename)
                     self.thdulist.writeto(filename)
             class ParameterConf:
                 ELEMENTNAME = 'Parameter'
                 def __init__(self):
                     self.name = ''
                     self.value = ''
                 def readXml(self, parmElement):
                     self.name = parmElement.get('name')
                     self.value = parmElement.get('value')
                 def getElementName(self):
                     return self.ELEMENTNAME
-            class Metadata:
+            class Metadata(object):
                 def __init__(self, filename):
                     self.parmConfObjList = []
                     self.readXml(filename)
                 def readXml(self, filename):
                     self.projectElement = None
                     self.procUnitConfObjDict = {}
                     self.projectElement = ElementTree().parse(filename)
                     self.project = self.projectElement.tag
                     parmElementList = self.projectElement.getiterator(ParameterConf().getElementName())
                     for parmElement in parmElementList:
                         parmConfObj = ParameterConf()
                         parmConfObj.readXml(parmElement)
                         self.parmConfObjList.append(parmConfObj)
             class FitsWriter(Operation):
                 def __init__(self):
                     self.isConfig = False
                     self.dataBlocksPerFile = None
                     self.blockIndex = 0
                     self.flagIsNewFile = 1
                     self.fitsObj = None
                     self.optchar = 'P'
                     self.ext = '.fits'
                     self.setFile = 0
-                def setFitsHeader(self, dataOut, metadatafile):
+                def setFitsHeader(self, dataOut, metadatafile=None):
                     header_data = pyfits.PrimaryHDU()
-                    metadata4fits = Metadata(metadatafile)
+                    header_data.header['EXPNAME'] = "RADAR DATA"
-                    for parameter in metadata4fits.parmConfObjList:
+                    header_data.header['DATATYPE'] = "SPECTRA"
-                        parm_name = parameter.name
+                    header_data.header['COMMENT'] = ""
-                        parm_value = parameter.value
+                    if metadatafile:
-            #             if parm_value == 'fromdatadatetime':
+                        metadata4fits = Metadata(metadatafile)
-            #                 value = time.strftime("%b %d %Y %H:%M:%S", dataOut.datatime.timetuple())
-            #             elif parm_value == 'fromdataheights':
-            #                 value = dataOut.nHeights
-            #             elif parm_value == 'fromdatachannel':
-            #                 value = dataOut.nChannels
-            #             elif parm_value == 'fromdatasamples':
-            #                 value = dataOut.nFFTPoints
-            #             else:
-            #                 value = parm_value
-                        header_data.header[parm_name] = parm_value
+                        for parameter in metadata4fits.parmConfObjList:
+                            parm_name = parameter.name
+                            parm_value = parameter.value
+                            header_data.header[parm_name] = parm_value
                     header_data.header['DATETIME'] = time.strftime("%b %d %Y %H:%M:%S", dataOut.datatime.timetuple())
                     header_data.header['CHANNELLIST'] = str(dataOut.channelList)
                     header_data.header['NCHANNELS'] = dataOut.nChannels
                     #header_data.header['HEIGHTS'] = dataOut.heightList
                     header_data.header['NHEIGHTS'] = dataOut.nHeights
                     header_data.header['IPPSECONDS'] = dataOut.ippSeconds
                     header_data.header['NCOHINT'] = dataOut.nCohInt
                     header_data.header['NINCOHINT'] = dataOut.nIncohInt
                     header_data.header['TIMEZONE'] = dataOut.timeZone
                     header_data.header['NBLOCK'] = self.blockIndex
                     header_data.writeto(self.filename)
                     self.addExtension(dataOut.heightList,'HEIGHTLIST')
-                def setup(self, dataOut, path, dataBlocksPerFile, metadatafile):
+                def setup(self, dataOut, path, dataBlocksPerFile=100, metadatafile=None):
                     self.path = path
                     self.dataOut = dataOut
                     self.metadatafile = metadatafile
                     self.dataBlocksPerFile = dataBlocksPerFile
                 def open(self):
                     self.fitsObj = pyfits.open(self.filename, mode='update')
                 def addExtension(self, data, tagname):
                     self.open()
                     extension = pyfits.ImageHDU(data=data, name=tagname)
                     #extension.header['TAG'] = tagname
                     self.fitsObj.append(extension)
                     self.write()
                 def addData(self, data):
                     self.open()
                     extension = pyfits.ImageHDU(data=data, name=self.fitsObj[0].header['DATATYPE'])
                     extension.header['UTCTIME'] = self.dataOut.utctime
                     self.fitsObj.append(extension)
                     self.blockIndex += 1
                     self.fitsObj[0].header['NBLOCK'] = self.blockIndex
                     self.write()
                 def write(self):
                     self.fitsObj.flush(verbose=True)
                     self.fitsObj.close()
                 def setNextFile(self):
                     ext = self.ext
                     path = self.path
                     timeTuple = time.localtime( self.dataOut.utctime)
                     subfolder = 'd%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
                     fullpath = os.path.join( path, subfolder )
                     if not( os.path.exists(fullpath) ):
                         os.mkdir(fullpath)
                         self.setFile = -1 #inicializo mi contador de seteo
                     else:
                         filesList = os.listdir( fullpath )
                         if len( filesList ) > 0:
                             filesList = sorted( filesList, key=str.lower )
                             filen = filesList[-1]
                             if isNumber( filen[8:11] ):
                                 self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
                             else:
                                 self.setFile = -1
                         else:
                             self.setFile = -1 #inicializo mi contador de seteo
                     setFile = self.setFile
                     setFile += 1
                     thisFile = '%s%4.4d%3.3d%3.3d%s' % (self.optchar,
                                                     timeTuple.tm_year,
                                                     timeTuple.tm_yday,
                                                     setFile,
                                                     ext )
                     filename = os.path.join( path, subfolder, thisFile )
                     self.blockIndex = 0
                     self.filename = filename
                     self.setFile = setFile
                     self.flagIsNewFile = 1
                     print 'Writing the file: %s'%self.filename
                     self.setFitsHeader(self.dataOut, self.metadatafile)
                     return 1
                 def writeBlock(self):
                     self.addData(self.dataOut.data_spc)
                     self.flagIsNewFile = 0
                 def __setNewBlock(self):
                     if self.flagIsNewFile:
                         return 1
                     if self.blockIndex < self.dataBlocksPerFile:
                         return 1
                     if not( self.setNextFile() ):
                         return 0
                     return 1
                 def writeNextBlock(self):
                     if not( self.__setNewBlock() ):
                         return 0
                     self.writeBlock()
                     return 1
                 def putData(self):
                     if self.flagIsNewFile:
                         self.setNextFile()
                     self.writeNextBlock()
                 def run(self, dataOut, **kwargs):
                     if not(self.isConfig):
                         self.setup(dataOut, **kwargs)
                         self.isConfig = True
                     self.putData()
             class FitsReader(ProcessingUnit):
             #     __TIMEZONE = time.timezone
                 expName = None
                 datetimestr = None
                 utc = None
                 nChannels = None
                 nSamples = None
                 dataBlocksPerFile = None
                 comments = None
                 lastUTTime = None
                 header_dict = None
                 data = None
                 data_header_dict = None
                 def __init__(self):
                     self.isConfig = False
                     self.ext = '.fits'
                     self.setFile = 0
                     self.flagNoMoreFiles = 0
                     self.flagIsNewFile = 1
                     self.flagDiscontinuousBlock = None
                     self.fileIndex = None
                     self.filename = None
                     self.fileSize = None
                     self.fitsObj = None
                     self.timeZone = None
                     self.nReadBlocks = 0
                     self.nTotalBlocks = 0
                     self.dataOut = self.createObjByDefault()
                     self.maxTimeStep = 10# deberia ser definido por el usuario usando el metodo setup()
                     self.blockIndex = 1
                 def createObjByDefault(self):
                     dataObj = Fits()
                     return dataObj
                 def isFileinThisTime(self, filename, startTime, endTime, useLocalTime=False):
                     try:
                         fitsObj = pyfits.open(filename,'readonly')
                     except:
                         raise IOError, "The file %s can't be opened" %(filename)
                     header = fitsObj[0].header
                     struct_time = time.strptime(header['DATETIME'], "%b %d %Y %H:%M:%S")
                     utc = time.mktime(struct_time) - time.timezone #TIMEZONE debe ser un parametro del header FITS
                     ltc = utc
                     if useLocalTime:
                         ltc -= time.timezone
                     thisDatetime = datetime.datetime.utcfromtimestamp(ltc)
                     thisTime = thisDatetime.time()
                     if not ((startTime <= thisTime) and (endTime > thisTime)):
                         return None
                     return thisDatetime
                 def __setNextFileOnline(self):
                     raise ValueError, "No implemented"
                 def __setNextFileOffline(self):
                     idFile = self.fileIndex
                     while (True):
                         idFile += 1
                         if not(idFile < len(self.filenameList)):
                             self.flagNoMoreFiles = 1
                             print "No more Files"
                             return 0
                         filename = self.filenameList[idFile]
             #            if not(self.__verifyFile(filename)):
             #                continue
                         fileSize = os.path.getsize(filename)
                         fitsObj = pyfits.open(filename,'readonly')
                         break
                     self.flagIsNewFile = 1
                     self.fileIndex = idFile
                     self.filename = filename
                     self.fileSize = fileSize
                     self.fitsObj = fitsObj
                     self.blockIndex = 0
                     print "Setting the file: %s"%self.filename
                     return 1
                 def __setValuesFromHeader(self):
                     self.dataOut.header = self.header_dict
                     self.dataOut.expName = self.expName
-                    self.dataOut.nChannels = self.nChannels
                     self.dataOut.timeZone = self.timeZone
                     self.dataOut.dataBlocksPerFile = self.dataBlocksPerFile
                     self.dataOut.comments = self.comments
             #         self.dataOut.timeInterval = self.timeInterval
                     self.dataOut.channelList = self.channelList
                     self.dataOut.heightList = self.heightList
                     self.dataOut.nCohInt = self.nCohInt
                     self.dataOut.nIncohInt = self.nIncohInt
+                    self.dataOut.ippSeconds = self.ippSeconds
                 def readHeader(self):
                     headerObj = self.fitsObj[0]
                     self.header_dict = headerObj.header
                     if 'EXPNAME' in headerObj.header.keys():
                         self.expName = headerObj.header['EXPNAME']
                     if 'DATATYPE' in headerObj.header.keys():
                         self.dataType = headerObj.header['DATATYPE']
                     self.datetimestr = headerObj.header['DATETIME']
                     channelList = headerObj.header['CHANNELLIST']
                     channelList = channelList.split('[')
                     channelList = channelList[1].split(']')
                     channelList = channelList[0].split(',')
                     channelList = [int(ch) for ch in channelList]
                     self.channelList = channelList
                     self.nChannels = headerObj.header['NCHANNELS']
                     self.nHeights = headerObj.header['NHEIGHTS']
                     self.ippSeconds = headerObj.header['IPPSECONDS']
                     self.nCohInt = headerObj.header['NCOHINT']
                     self.nIncohInt = headerObj.header['NINCOHINT']
                     self.dataBlocksPerFile = headerObj.header['NBLOCK']
                     self.timeZone = headerObj.header['TIMEZONE']
             #         self.timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt
                     if 'COMMENT' in headerObj.header.keys():
                         self.comments = headerObj.header['COMMENT']
                     self.readHeightList()
                 def readHeightList(self):
                     self.blockIndex = self.blockIndex + 1
                     obj = self.fitsObj[self.blockIndex]
                     self.heightList = obj.data
                     self.blockIndex = self.blockIndex + 1
                 def readExtension(self):
                     obj = self.fitsObj[self.blockIndex]
                     self.heightList = obj.data
                     self.blockIndex = self.blockIndex + 1
                 def setNextFile(self):
                     if self.online:
                         newFile = self.__setNextFileOnline()
                     else:
                         newFile = self.__setNextFileOffline()
                     if not(newFile):
                         return 0
                     self.readHeader()
                     self.__setValuesFromHeader()
                     self.nReadBlocks = 0
             #         self.blockIndex = 1
                     return 1
                 def __searchFilesOffLine(self,
                                         path,
                                         startDate,
                                         endDate,
                                         startTime=datetime.time(0,0,0),
                                         endTime=datetime.time(23,59,59),
                                         set=None,
                                         expLabel='',
                                         ext='.fits',
                                         walk=True):
                     pathList = []
                     if not walk:
                         pathList.append(path)
                     else:
                         dirList = []
                         for thisPath in os.listdir(path):
                             if not os.path.isdir(os.path.join(path,thisPath)):
                                 continue
                             if not isRadarFolder(thisPath):
                                 continue
                             dirList.append(thisPath)
                         if not(dirList):
                             return None, None
                         thisDate = startDate
                         while(thisDate <= endDate):
                             year = thisDate.timetuple().tm_year
                             doy = thisDate.timetuple().tm_yday
                             matchlist = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy) + '*')
                             if len(matchlist) == 0:
                                 thisDate += datetime.timedelta(1)
                                 continue
                             for match in matchlist:
                                 pathList.append(os.path.join(path,match,expLabel))
                             thisDate += datetime.timedelta(1)
                     if pathList == []:
                         print "Any folder was found for the date range: %s-%s" %(startDate, endDate)
                         return None, None
                     print "%d folder(s) was(were) found for the date range: %s - %s" %(len(pathList), startDate, endDate)
                     filenameList = []
                     datetimeList = []
                     for i in range(len(pathList)):
                         thisPath = pathList[i]
                         fileList = glob.glob1(thisPath, "*%s" %ext)
                         fileList.sort()
                         for thisFile in fileList:
                             filename = os.path.join(thisPath,thisFile)
                             thisDatetime = self.isFileinThisTime(filename, startTime, endTime)
                             if not(thisDatetime):
                                 continue
                             filenameList.append(filename)
                             datetimeList.append(thisDatetime)
                     if not(filenameList):
                         print "Any file was found for the time range %s - %s" %(startTime, endTime)
                         return None, None
                     print "%d file(s) was(were) found for the time range: %s - %s" %(len(filenameList), startTime, endTime)
                     print
                     for i in range(len(filenameList)):
                         print "%s -> [%s]" %(filenameList[i], datetimeList[i].ctime())
                     self.filenameList = filenameList
                     self.datetimeList = datetimeList
                     return pathList, filenameList
                 def setup(self, path=None,
                             startDate=None,
                             endDate=None,
                             startTime=datetime.time(0,0,0),
                             endTime=datetime.time(23,59,59),
                             set=0,
                             expLabel = "",
                             ext = None,
                             online = False,
                             delay = 60,
                             walk = True):
                     if path == None:
                         raise ValueError, "The path is not valid"
                     if ext == None:
                         ext = self.ext
                     if not(online):
                         print "Searching files in offline mode ..."
                         pathList, filenameList = self.__searchFilesOffLine(path, startDate=startDate, endDate=endDate,
                                                                            startTime=startTime, endTime=endTime,
                                                                            set=set, expLabel=expLabel, ext=ext,
                                                                            walk=walk)
                         if not(pathList):
                             print "No *%s files into the folder %s \nfor the range: %s - %s"%(ext, path,
                                                                     datetime.datetime.combine(startDate,startTime).ctime(),
                                                                     datetime.datetime.combine(endDate,endTime).ctime())
                             sys.exit(-1)
                         self.fileIndex = -1
                         self.pathList = pathList
                         self.filenameList = filenameList
                     self.online = online
                     self.delay = delay
                     ext = ext.lower()
                     self.ext = ext
                     if not(self.setNextFile()):
                         if (startDate!=None) and (endDate!=None):
                             print "No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())
                         elif startDate != None:
                             print "No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime())
                         else:
                             print "No files"
                         sys.exit(-1)
                 def readBlock(self):
                     dataObj = self.fitsObj[self.blockIndex]
                     self.data = dataObj.data
                     self.data_header_dict = dataObj.header
                     self.utc = self.data_header_dict['UTCTIME']
                     self.flagIsNewFile = 0
                     self.blockIndex += 1
                     self.nTotalBlocks += 1
                     self.nReadBlocks += 1
                     return 1
                 def __jumpToLastBlock(self):
                     raise ValueError, "No implemented"
                 def __waitNewBlock(self):
                     """
                     Return 1 si se encontro un nuevo bloque de datos, 0 de otra forma.
                     Si el modo de lectura es OffLine siempre retorn 0
                     """
                     if not self.online:
                         return 0
                     if (self.nReadBlocks >= self.dataBlocksPerFile):
                         return 0
                     currentPointer = self.fp.tell()
                     neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
                     for nTries in range( self.nTries ):
                         self.fp.close()
                         self.fp = open( self.filename, 'rb' )
                         self.fp.seek( currentPointer )
                         self.fileSize = os.path.getsize( self.filename )
                         currentSize = self.fileSize - currentPointer
                         if ( currentSize >= neededSize ):
                             self.__rdBasicHeader()
                             return 1
                         print "\tWaiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1)
                         sleep( self.delay )
                     return 0
                 def __setNewBlock(self):
                     if self.online:
                         self.__jumpToLastBlock()
                     if self.flagIsNewFile:
                         return 1
                     self.lastUTTime = self.utc
                     if self.online:
                         if self.__waitNewBlock():
                             return 1
                     if self.nReadBlocks < self.dataBlocksPerFile:
                         return 1
                     if not(self.setNextFile()):
                         return 0
                     deltaTime = self.utc - self.lastUTTime
                     self.flagDiscontinuousBlock = 0
                     if deltaTime > self.maxTimeStep:
                         self.flagDiscontinuousBlock = 1
                     return 1
                 def readNextBlock(self):
                     if not(self.__setNewBlock()):
                         return 0
                     if not(self.readBlock()):
                         return 0
                     return 1
+                def printInfo(self):
+                    pass
                 def getData(self):
                     if self.flagNoMoreFiles:
                         self.dataOut.flagNoData = True
                         print 'Process finished'
                         return 0
                     self.flagDiscontinuousBlock = 0
                     self.flagIsNewBlock = 0
                     if not(self.readNextBlock()):
                         return 0
-                    if self.data == None:
+                    if self.data is None:
                         self.dataOut.flagNoData = True
                         return 0
                     self.dataOut.data = self.data
                     self.dataOut.data_header = self.data_header_dict
                     self.dataOut.utctime = self.utc
             #         self.dataOut.header = self.header_dict
             #         self.dataOut.expName = self.expName
             #         self.dataOut.nChannels = self.nChannels
             #         self.dataOut.timeZone = self.timeZone
             #         self.dataOut.dataBlocksPerFile = self.dataBlocksPerFile
             #         self.dataOut.comments = self.comments
             # #         self.dataOut.timeInterval = self.timeInterval
             #         self.dataOut.channelList = self.channelList
             #         self.dataOut.heightList = self.heightList
                     self.dataOut.flagNoData = False
                     return self.dataOut.data
                 def run(self, **kwargs):
                     if not(self.isConfig):
                         self.setup(**kwargs)
                         self.isConfig = True
                     self.getData()
             class SpectraHeisWriter(Operation):
             #    set = None
                 setFile = None
                 idblock = None
                 doypath = None
                 subfolder = None
                 def __init__(self):
-                    self.wrObj = Fits()
+                    self.wrObj = PyFits()
             #        self.dataOut = dataOut
                     self.nTotalBlocks=0
             #        self.set = None
                     self.setFile = None
                     self.idblock = 0
                     self.wrpath = None
                     self.doypath = None
                     self.subfolder = None
                     self.isConfig = False
                 def isNumber(str):
                     """
                     Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
                     Excepciones:
                     Si un determinado string no puede ser convertido a numero
                     Input:
                     str, string al cual se le analiza para determinar si convertible a un numero o no
                     Return:
                     True    :    si el string es uno numerico
                     False   :    no es un string numerico
                     """
                     try:
                         float( str )
                         return True
                     except:
                         return False
                 def setup(self, dataOut, wrpath):
                     if not(os.path.exists(wrpath)):
                         os.mkdir(wrpath)
                     self.wrpath = wrpath
             #        self.setFile = 0
                     self.dataOut = dataOut
                 def putData(self):
                     name= time.localtime( self.dataOut.utctime)
                     ext=".fits"
                     if self.doypath == None:
                        self.subfolder = 'F%4.4d%3.3d_%d' % (name.tm_year,name.tm_yday,time.mktime(datetime.datetime.now().timetuple()))
                        self.doypath = os.path.join( self.wrpath, self.subfolder )
                        os.mkdir(self.doypath)
                     if self.setFile == None:
             #           self.set = self.dataOut.set
                        self.setFile = 0
             #        if self.set != self.dataOut.set:
             ##            self.set = self.dataOut.set
             #            self.setFile = 0
                     #make the filename
                     thisFile = 'D%4.4d%3.3d_%3.3d%s' % (name.tm_year,name.tm_yday,self.setFile,ext)
                     filename = os.path.join(self.wrpath,self.subfolder, thisFile)
                     idblock = numpy.array([self.idblock],dtype="int64")
                     header=self.wrObj.cFImage(idblock=idblock,
                                             year=time.gmtime(self.dataOut.utctime).tm_year,
                                             month=time.gmtime(self.dataOut.utctime).tm_mon,
                                             day=time.gmtime(self.dataOut.utctime).tm_mday,
                                             hour=time.gmtime(self.dataOut.utctime).tm_hour,
                                             minute=time.gmtime(self.dataOut.utctime).tm_min,
                                             second=time.gmtime(self.dataOut.utctime).tm_sec)
                     c=3E8
                     deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
                     freq=numpy.arange(-1*self.dataOut.nHeights/2.,self.dataOut.nHeights/2.)*(c/(2*deltaHeight*1000))
                     colList = []
                     colFreq=self.wrObj.setColF(name="freq", format=str(self.dataOut.nFFTPoints)+'E', array=freq)
                     colList.append(colFreq)
                     nchannel=self.dataOut.nChannels
                     for i in range(nchannel):
                         col = self.wrObj.writeData(name="PCh"+str(i+1),
                                                      format=str(self.dataOut.nFFTPoints)+'E',
                                                       data=10*numpy.log10(self.dataOut.data_spc[i,:]))
                         colList.append(col)
                     data=self.wrObj.Ctable(colList=colList)
                     self.wrObj.CFile(header,data)
                     self.wrObj.wFile(filename)
                     #update the setFile
                     self.setFile += 1
                     self.idblock += 1
                     return 1
                 def run(self, dataOut, **kwargs):
                     if not(self.isConfig):
                         self.setup(dataOut, **kwargs)
                         self.isConfig = True
                     self.putData()

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

             import numpy
             from jroproc_base import ProcessingUnit, Operation
             from schainpy.model.data.jrodata import SpectraHeis
             class SpectraHeisProc(ProcessingUnit):
                 def __init__(self):
                     ProcessingUnit.__init__(self)
             #        self.buffer = None
             #        self.firstdatatime = None
             #        self.profIndex = 0
                     self.dataOut = SpectraHeis()
                 def __updateObjFromVoltage(self):
                     self.dataOut.timeZone = self.dataIn.timeZone
                     self.dataOut.dstFlag = self.dataIn.dstFlag
                     self.dataOut.errorCount = self.dataIn.errorCount
                     self.dataOut.useLocalTime = self.dataIn.useLocalTime
                     self.dataOut.radarControllerHeaderObj = self.dataIn.radarControllerHeaderObj.copy()#
                     self.dataOut.systemHeaderObj = self.dataIn.systemHeaderObj.copy()#
                     self.dataOut.channelList = self.dataIn.channelList
                     self.dataOut.heightList = self.dataIn.heightList
             #        self.dataOut.dtype = self.dataIn.dtype
                     self.dataOut.dtype = numpy.dtype([('real','<f4'),('imag','<f4')])
             #        self.dataOut.nHeights = self.dataIn.nHeights
             #        self.dataOut.nChannels = self.dataIn.nChannels
                     self.dataOut.nBaud = self.dataIn.nBaud
                     self.dataOut.nCode = self.dataIn.nCode
                     self.dataOut.code = self.dataIn.code
             #        self.dataOut.nProfiles = 1
             #        self.dataOut.nProfiles = self.dataOut.nFFTPoints
                     self.dataOut.nFFTPoints = self.dataIn.nHeights
             #        self.dataOut.channelIndexList = self.dataIn.channelIndexList
             #        self.dataOut.flagNoData = self.dataIn.flagNoData
                     self.dataOut.flagDiscontinuousBlock = self.dataIn.flagDiscontinuousBlock
                     self.dataOut.utctime = self.dataIn.utctime
             #        self.dataOut.utctime = self.firstdatatime
                     self.dataOut.flagDecodeData = self.dataIn.flagDecodeData #asumo q la data esta decodificada
                     self.dataOut.flagDeflipData = self.dataIn.flagDeflipData #asumo q la data esta sin flip
             #        self.dataOut.flagShiftFFT = self.dataIn.flagShiftFFT
                     self.dataOut.nCohInt = self.dataIn.nCohInt
                     self.dataOut.nIncohInt = 1
             #         self.dataOut.ippSeconds= self.dataIn.ippSeconds
                     self.dataOut.windowOfFilter = self.dataIn.windowOfFilter
             #         self.dataOut.timeInterval = self.dataIn.timeInterval*self.dataOut.nIncohInt
             #        self.dataOut.set=self.dataIn.set
             #        self.dataOut.deltaHeight=self.dataIn.deltaHeight
                 def __updateObjFromFits(self):
                     self.dataOut.utctime = self.dataIn.utctime
-                    self.dataOut.channelIndexList = self.dataIn.channelIndexList
+            #         self.dataOut.channelIndexList = self.dataIn.channelIndexList
                     self.dataOut.channelList = self.dataIn.channelList
                     self.dataOut.heightList = self.dataIn.heightList
                     self.dataOut.data_spc = self.dataIn.data
                     self.dataOut.ippSeconds = self.dataIn.ippSeconds
                     self.dataOut.nCohInt = self.dataIn.nCohInt
                     self.dataOut.nIncohInt = self.dataIn.nIncohInt
             #         self.dataOut.timeInterval = self.dataIn.timeInterval
                     self.dataOut.timeZone = self.dataIn.timeZone
                     self.dataOut.useLocalTime = True
             #         self.dataOut.
             #         self.dataOut.
                 def __getFft(self):
                     fft_volt = numpy.fft.fft(self.dataIn.data, axis=1)
                     fft_volt = numpy.fft.fftshift(fft_volt,axes=(1,))
                     spc = numpy.abs(fft_volt * numpy.conjugate(fft_volt))/(self.dataOut.nFFTPoints)
                     self.dataOut.data_spc = spc
                 def run(self):
                     self.dataOut.flagNoData = True
                     if self.dataIn.type == "Fits":
                         self.__updateObjFromFits()
                         self.dataOut.flagNoData = False
                         return
                     if self.dataIn.type == "SpectraHeis":
                         self.dataOut.copy(self.dataIn)
                         return
                     if self.dataIn.type == "Voltage":
                         self.__updateObjFromVoltage()
                         self.__getFft()
                         self.dataOut.flagNoData = False
                         return
                     raise ValueError, "The type object %s is not valid"%(self.dataIn.type)
                 def selectChannels(self, channelList):
                     channelIndexList = []
                     for channel in channelList:
                         index = self.dataOut.channelList.index(channel)
                         channelIndexList.append(index)
                     self.selectChannelsByIndex(channelIndexList)
                 def selectChannelsByIndex(self, channelIndexList):
                     """
                     Selecciona un bloque de datos en base a canales segun el channelIndexList
                     Input:
                         channelIndexList    :    lista sencilla de canales a seleccionar por ej. [2,3,7]
                     Affected:
                         self.dataOut.data
                         self.dataOut.channelIndexList
                         self.dataOut.nChannels
                         self.dataOut.m_ProcessingHeader.totalSpectra
                         self.dataOut.systemHeaderObj.numChannels
                         self.dataOut.m_ProcessingHeader.blockSize
                     Return:
                         None
                     """
                     for channelIndex in channelIndexList:
                         if channelIndex not in self.dataOut.channelIndexList:
                             print channelIndexList
                             raise ValueError, "The value %d in channelIndexList is not valid" %channelIndex
             #         nChannels = len(channelIndexList)
                     data_spc = self.dataOut.data_spc[channelIndexList,:]
                     self.dataOut.data_spc = data_spc
                     self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
                     return 1
             class IncohInt4SpectraHeis(Operation):
                 isConfig = False
                 __profIndex = 0
                 __withOverapping  = False
                 __byTime = False
                 __initime = None
                 __lastdatatime = None
                 __integrationtime = None
                 __buffer = None
                 __dataReady = False
                 n = None
                 def __init__(self):
                     Operation.__init__(self)
             #         self.isConfig = False
                 def setup(self, n=None, timeInterval=None, overlapping=False):
                     """
                     Set the parameters of the integration class.
                     Inputs:
                         n        :    Number of coherent integrations
                         timeInterval   :    Time of integration. If the parameter "n" is selected this one does not work
                         overlapping    :
                     """
                     self.__initime = None
                     self.__lastdatatime = 0
                     self.__buffer = None
                     self.__dataReady = False
                     if n == None and timeInterval == None:
                         raise ValueError, "n or timeInterval should be specified ..."
                     if n != None:
                         self.n = n
                         self.__byTime = False
                     else:
                         self.__integrationtime = timeInterval #* 60. #if (type(timeInterval)!=integer) -> change this line
                         self.n = 9999
                         self.__byTime = True
                     if overlapping:
                         self.__withOverapping = True
                         self.__buffer = None
                     else:
                         self.__withOverapping = False
                         self.__buffer = 0
                     self.__profIndex = 0
                 def putData(self, data):
                     """
                     Add a profile to the __buffer and increase in one the __profileIndex
                     """
                     if not self.__withOverapping:
                         self.__buffer += data.copy()
                         self.__profIndex += 1
                         return
                     #Overlapping data
                     nChannels, nHeis = data.shape
                     data = numpy.reshape(data, (1, nChannels, nHeis))
                     #If the buffer is empty then it takes the data value
                     if self.__buffer is None:
                         self.__buffer = data
                         self.__profIndex += 1
                         return
                     #If the buffer length is lower than n then stakcing the data value
                     if self.__profIndex < self.n:
                         self.__buffer = numpy.vstack((self.__buffer, data))
                         self.__profIndex += 1
                         return
                     #If the buffer length is equal to n then replacing the last buffer value with the data value
                     self.__buffer = numpy.roll(self.__buffer, -1, axis=0)
                     self.__buffer[self.n-1] = data
                     self.__profIndex = self.n
                     return
                 def pushData(self):
                     """
                     Return the sum of the last profiles and the profiles used in the sum.
                     Affected:
                     self.__profileIndex
                     """
                     if not self.__withOverapping:
                         data = self.__buffer
                         n = self.__profIndex
                         self.__buffer = 0
                         self.__profIndex = 0
                         return data, n
                     #Integration with Overlapping
                     data = numpy.sum(self.__buffer, axis=0)
                     n = self.__profIndex
                     return data, n
                 def byProfiles(self, data):
                     self.__dataReady = False
                     avgdata = None
             #         n = None
                     self.putData(data)
                     if self.__profIndex == self.n:
                         avgdata, n = self.pushData()
                         self.__dataReady = True
                     return avgdata
                 def byTime(self, data, datatime):
                     self.__dataReady = False
                     avgdata = None
                     n = None
                     self.putData(data)
                     if (datatime - self.__initime) >= self.__integrationtime:
                         avgdata, n = self.pushData()
                         self.n = n
                         self.__dataReady = True
                     return avgdata
                 def integrate(self, data, datatime=None):
                     if self.__initime == None:
                         self.__initime = datatime
                     if self.__byTime:
                         avgdata = self.byTime(data, datatime)
                     else:
                         avgdata = self.byProfiles(data)
                     self.__lastdatatime = datatime
                     if avgdata is None:
                         return None, None
                     avgdatatime = self.__initime
                     deltatime = datatime -self.__lastdatatime
                     if not self.__withOverapping:
                         self.__initime = datatime
                     else:
                         self.__initime += deltatime
                     return avgdata, avgdatatime
                 def run(self, dataOut, **kwargs):
                     if not self.isConfig:
                         self.setup(**kwargs)
                         self.isConfig = True
                     avgdata, avgdatatime = self.integrate(dataOut.data_spc, dataOut.utctime)
             #        dataOut.timeInterval *= n
                     dataOut.flagNoData = True
                     if self.__dataReady:
                         dataOut.data_spc = avgdata
                         dataOut.nIncohInt *= self.n
             #            dataOut.nCohInt *= self.n
                         dataOut.utctime = avgdatatime
             #             dataOut.timeInterval = dataOut.ippSeconds * dataOut.nIncohInt
             #            dataOut.timeInterval = self.__timeInterval*self.n
                         dataOut.flagNoData = False

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