From 30b3788062caa2ef22f45fc023bb564b1273c72e 2017-04-24 17:08:51 From: jespinoza Date: 2017-04-24 17:08:51 Subject: [PATCH] add multiSchain (@jchavez) --- diff --git a/schainpy/controller.py b/schainpy/controller.py index 7cf11b6..445a2a4 100644 --- a/schainpy/controller.py +++ b/schainpy/controller.py @@ -7,6 +7,8 @@ import sys import ast import datetime import traceback +from multiprocessing import Process, Queue, cpu_count + import schainpy import schainpy.admin @@ -23,6 +25,51 @@ def prettify(elem): reparsed = minidom.parseString(rough_string) return reparsed.toprettyxml(indent=" ") +def multiSchain(child, nProcess=cpu_count(), startDate=None, endDate=None): + skip = 0 + cursor = 0 + nFiles = None + processes = [] + + dt1 = datetime.datetime.strptime(startDate, '%Y/%m/%d') + dt2 = datetime.datetime.strptime(endDate, '%Y/%m/%d') + days = (dt2 - dt1).days + print days + for day in range(days+1): + skip = 0 + cursor = 0 + q = Queue() + processes = [] + dt = (dt1 + datetime.timedelta(day)).strftime('%Y/%m/%d') + firstProcess = Process(target=child, args=(cursor, skip, q, dt)) + firstProcess.start() + nFiles = q.get() + firstProcess.terminate() + skip = int(math.ceil(nFiles/nProcess)) + try: + while True: + processes.append(Process(target=child, args=(cursor, skip, q, dt))) + processes[cursor].start() + if nFiles < cursor*skip: + break + cursor += 1 + except KeyboardInterrupt: + for process in processes: + process.terminate() + process.join() + for process in processes: + process.join() + #process.terminate() + sleep(3) + + try: + while True: + pass + except KeyboardInterrupt: + for process in processes: + process.terminate() + process.join() + class ParameterConf(): id = None @@ -51,6 +98,9 @@ class ParameterConf(): return self.__formated_value + if format == 'obj': + return value + if format == 'str': self.__formated_value = str(value) return self.__formated_value @@ -171,7 +221,10 @@ class ParameterConf(): self.id = str(id) self.name = name - self.value = str(value) + if format == 'obj': + self.value = value + else: + self.value = str(value) self.format = str.lower(format) self.getValue() @@ -698,7 +751,7 @@ class ReadUnitConf(ProcUnitConf): return self.ELEMENTNAME - def setup(self, id, name, datatype, path, startDate="", endDate="", startTime="", endTime="", parentId=None, **kwargs): + def setup(self, id, name, datatype, path, startDate="", endDate="", startTime="", endTime="", parentId=None, queue=None, **kwargs): #Compatible with old signal chain version if datatype==None and name==None: @@ -725,7 +778,7 @@ class ReadUnitConf(ProcUnitConf): self.inputId = '0' self.parentId = parentId - + self.queue = queue self.addRunOperation(**kwargs) def update(self, datatype, path, startDate, endDate, startTime, endTime, parentId=None, name=None, **kwargs): diff --git a/schainpy/model/graphics/jroplot_data.py b/schainpy/model/graphics/jroplot_data.py index 2ef13ed..518a445 100644 --- a/schainpy/model/graphics/jroplot_data.py +++ b/schainpy/model/graphics/jroplot_data.py @@ -84,7 +84,8 @@ class PlotData(Operation, Process): print 'plotting...{}'.format(self.CODE) self.plot() - self.figure.suptitle('{} {}'.format(self.title, self.CODE.upper())) + self.figure.suptitle('{} {} - Date:{}'.format(self.title, self.CODE.upper(), + datetime.datetime.utcfromtimestamp(self.max_time).strftime('%y/%m/%d %H:%M:%S'))) if self.save: figname = os.path.join(self.save, '{}_{}.png'.format(self.CODE, @@ -234,17 +235,17 @@ class PlotSpectraData(PlotData): ax.ax_profile.set_ylim(self.ymin, self.ymax) ax.ax_profile.set_xlabel('dB') ax.ax_profile.grid(b=True, axis='x') + ax.plot_noise = ax.ax_profile.plot(numpy.repeat(self.data['noise'][self.max_time][n], len(y)), y, + color="k", linestyle="dashed", lw=2)[0] [tick.set_visible(False) for tick in ax.ax_profile.get_yticklabels()] - noise = 10*numpy.log10(self.data['rti'][self.max_time][n]/self.dataOut.normFactor) - ax.ax_profile.vlines(noise, self.ymin, self.ymax, colors="k", linestyle="dashed", lw=2) else: ax.plot.set_array(z[n].T.ravel()) - ax.set_title('{} {}'.format(self.titles[n], - datetime.datetime.utcfromtimestamp(self.max_time).strftime('%y/%m/%d %H:%M:%S')), - size=8) if self.showprofile: ax.plot_profile.set_data(self.data['rti'][self.max_time][n], y) + ax.plot_noise.set_data(numpy.repeat(self.data['noise'][self.max_time][n], len(y)), y) + ax.set_title('{} - Noise: {:.2f} dB'.format(self.titles[n], self.data['noise'][self.max_time][n]), + size=8) class PlotRTIData(PlotData): diff --git a/schainpy/model/io/jroIO_base.py b/schainpy/model/io/jroIO_base.py index e31f158..c753eb3 100644 --- a/schainpy/model/io/jroIO_base.py +++ b/schainpy/model/io/jroIO_base.py @@ -17,7 +17,7 @@ try: from gevent import sleep except: from time import sleep - + from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader from schainpy.model.data.jroheaderIO import get_dtype_index, get_numpy_dtype, get_procflag_dtype, get_dtype_width @@ -27,11 +27,11 @@ def isNumber(cad): """ Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero. - Excepciones: + 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 @@ -45,271 +45,271 @@ def isNumber(cad): def isFileInEpoch(filename, startUTSeconds, endUTSeconds): """ Esta funcion determina si un archivo de datos se encuentra o no dentro del rango de fecha especificado. - + Inputs: filename : nombre completo del archivo de datos en formato Jicamarca (.r) - + startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en segundos contados desde 01/01/1970. endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en segundos contados desde 01/01/1970. - + Return: Boolean : Retorna True si el archivo de datos contiene datos en el rango de fecha especificado, de lo contrario retorna False. - + Excepciones: Si el archivo no existe o no puede ser abierto Si la cabecera no puede ser leida. - + """ basicHeaderObj = BasicHeader(LOCALTIME) - + try: fp = open(filename,'rb') except IOError: print "The file %s can't be opened" %(filename) return 0 - + sts = basicHeaderObj.read(fp) fp.close() - + if not(sts): print "Skipping the file %s because it has not a valid header" %(filename) return 0 - + if not ((startUTSeconds <= basicHeaderObj.utc) and (endUTSeconds > basicHeaderObj.utc)): return 0 - + return 1 def isTimeInRange(thisTime, startTime, endTime): - + if endTime >= startTime: if (thisTime < startTime) or (thisTime > endTime): return 0 - + return 1 else: if (thisTime < startTime) and (thisTime > endTime): return 0 - + return 1 - + def isFileInTimeRange(filename, startDate, endDate, startTime, endTime): """ Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado. - + Inputs: filename : nombre completo del archivo de datos en formato Jicamarca (.r) - + startDate : fecha inicial del rango seleccionado en formato datetime.date - + endDate : fecha final del rango seleccionado en formato datetime.date - + startTime : tiempo inicial del rango seleccionado en formato datetime.time - + endTime : tiempo final del rango seleccionado en formato datetime.time - + Return: Boolean : Retorna True si el archivo de datos contiene datos en el rango de fecha especificado, de lo contrario retorna False. - + Excepciones: Si el archivo no existe o no puede ser abierto Si la cabecera no puede ser leida. - + """ - - + + try: fp = open(filename,'rb') except IOError: print "The file %s can't be opened" %(filename) return None - + firstBasicHeaderObj = BasicHeader(LOCALTIME) systemHeaderObj = SystemHeader() radarControllerHeaderObj = RadarControllerHeader() processingHeaderObj = ProcessingHeader() - + lastBasicHeaderObj = BasicHeader(LOCALTIME) - + sts = firstBasicHeaderObj.read(fp) - + if not(sts): print "[Reading] Skipping the file %s because it has not a valid header" %(filename) return None - + if not systemHeaderObj.read(fp): return None - + if not radarControllerHeaderObj.read(fp): return None - + if not processingHeaderObj.read(fp): return None - + filesize = os.path.getsize(filename) - + offset = processingHeaderObj.blockSize + 24 #header size - + if filesize <= offset: print "[Reading] %s: This file has not enough data" %filename return None - + fp.seek(-offset, 2) - + sts = lastBasicHeaderObj.read(fp) - + fp.close() - + thisDatetime = lastBasicHeaderObj.datatime thisTime_last_block = thisDatetime.time() - + thisDatetime = firstBasicHeaderObj.datatime thisDate = thisDatetime.date() thisTime_first_block = thisDatetime.time() - + #General case # o>>>>>>>>>>>>>><<<<<<<<<<<<<= startTime: if (thisTime_last_block < startTime) or (thisTime_first_block > endTime): return None - + return thisDatetime - + #If endTime < startTime then endTime belongs to the next day - - + + #<<<<<<<<<<>>>>>>>>>> #-----------o----------------------------o----------- # endTime startTime - + if (thisDate == startDate) and (thisTime_last_block < startTime): return None - + if (thisDate == endDate) and (thisTime_first_block > endTime): return None - + if (thisTime_last_block < startTime) and (thisTime_first_block > endTime): return None - + return thisDatetime def isFolderInDateRange(folder, startDate=None, endDate=None): """ Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado. - + Inputs: folder : nombre completo del directorio. Su formato deberia ser "/path_root/?YYYYDDD" - + siendo: YYYY : Anio (ejemplo 2015) DDD : Dia del anio (ejemplo 305) - + startDate : fecha inicial del rango seleccionado en formato datetime.date - + endDate : fecha final del rango seleccionado en formato datetime.date - + Return: Boolean : Retorna True si el archivo de datos contiene datos en el rango de fecha especificado, de lo contrario retorna False. Excepciones: Si el directorio no tiene el formato adecuado """ - + basename = os.path.basename(folder) - + if not isRadarFolder(basename): print "The folder %s has not the rigth format" %folder return 0 - + if startDate and endDate: thisDate = getDateFromRadarFolder(basename) - + if thisDate < startDate: return 0 - + if thisDate > endDate: return 0 - + return 1 def isFileInDateRange(filename, startDate=None, endDate=None): """ Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado. - + Inputs: filename : nombre completo del archivo de datos en formato Jicamarca (.r) - + Su formato deberia ser "?YYYYDDDsss" - + siendo: YYYY : Anio (ejemplo 2015) DDD : Dia del anio (ejemplo 305) sss : set - + startDate : fecha inicial del rango seleccionado en formato datetime.date - + endDate : fecha final del rango seleccionado en formato datetime.date - + Return: Boolean : Retorna True si el archivo de datos contiene datos en el rango de fecha especificado, de lo contrario retorna False. Excepciones: Si el archivo no tiene el formato adecuado """ - + basename = os.path.basename(filename) - + if not isRadarFile(basename): print "The filename %s has not the rigth format" %filename return 0 - + if startDate and endDate: thisDate = getDateFromRadarFile(basename) - + if thisDate < startDate: return 0 - + if thisDate > endDate: return 0 - + return 1 def getFileFromSet(path, ext, set): validFilelist = [] fileList = os.listdir(path) - + # 0 1234 567 89A BCDE # H YYYY DDD SSS .ext - + for thisFile in fileList: try: year = int(thisFile[1:5]) doy = int(thisFile[5:8]) except: continue - + if (os.path.splitext(thisFile)[-1].lower() != ext.lower()): continue - + validFilelist.append(thisFile) myfile = fnmatch.filter(validFilelist,'*%4.4d%3.3d%3.3d*'%(year,doy,set)) - + if len(myfile)!= 0: return myfile[0] else: filename = '*%4.4d%3.3d%3.3d%s'%(year,doy,set,ext.lower()) print 'the filename %s does not exist'%filename print '...going to the last file: ' - + if validFilelist: validFilelist = sorted( validFilelist, key=str.lower ) return validFilelist[-1] @@ -319,37 +319,37 @@ def getFileFromSet(path, ext, set): def getlastFileFromPath(path, ext): """ Depura el fileList dejando solo los que cumplan el formato de "PYYYYDDDSSS.ext" - al final de la depuracion devuelve el ultimo file de la lista que quedo. - - Input: + al final de la depuracion devuelve el ultimo file de la lista que quedo. + + Input: fileList : lista conteniendo todos los files (sin path) que componen una determinada carpeta - ext : extension de los files contenidos en una carpeta - + ext : extension de los files contenidos en una carpeta + Return: El ultimo file de una determinada carpeta, no se considera el path. """ validFilelist = [] fileList = os.listdir(path) - + # 0 1234 567 89A BCDE # H YYYY DDD SSS .ext - + for thisFile in fileList: - + year = thisFile[1:5] if not isNumber(year): continue - + doy = thisFile[5:8] if not isNumber(doy): continue - + year = int(year) doy = int(doy) - + if (os.path.splitext(thisFile)[-1].lower() != ext.lower()): continue - + validFilelist.append(thisFile) if validFilelist: @@ -363,10 +363,10 @@ def checkForRealPath(path, foldercounter, year, doy, set, ext): Por ser Linux Case Sensitive entonces checkForRealPath encuentra el nombre correcto de un path, Prueba por varias combinaciones de nombres entre mayusculas y minusculas para determinar el path exacto de un determinado file. - + Example : nombre correcto del file es .../.../D2009307/P2009307367.ext - + Entonces la funcion prueba con las siguientes combinaciones .../.../y2009307367.ext .../.../Y2009307367.ext @@ -374,17 +374,17 @@ def checkForRealPath(path, foldercounter, year, doy, set, ext): .../.../x2009307/Y2009307367.ext .../.../X2009307/y2009307367.ext .../.../X2009307/Y2009307367.ext - siendo para este caso, la ultima combinacion de letras, identica al file buscado - + siendo para este caso, la ultima combinacion de letras, identica al file buscado + Return: - Si encuentra la cobinacion adecuada devuelve el path completo y el nombre del file - caso contrario devuelve None como path y el la ultima combinacion de nombre en mayusculas - para el filename + Si encuentra la cobinacion adecuada devuelve el path completo y el nombre del file + caso contrario devuelve None como path y el la ultima combinacion de nombre en mayusculas + para el filename """ fullfilename = None find_flag = False filename = None - + prefixDirList = [None,'d','D'] if ext.lower() == ".r": #voltage prefixFileList = ['d','D'] @@ -392,20 +392,20 @@ def checkForRealPath(path, foldercounter, year, doy, set, ext): prefixFileList = ['p','P'] else: return None, filename - - #barrido por las combinaciones posibles + + #barrido por las combinaciones posibles for prefixDir in prefixDirList: thispath = path if prefixDir != None: #formo el nombre del directorio xYYYYDDD (x=d o x=D) if foldercounter == 0: - thispath = os.path.join(path, "%s%04d%03d" % ( prefixDir, year, doy )) + thispath = os.path.join(path, "%s%04d%03d" % ( prefixDir, year, doy )) else: thispath = os.path.join(path, "%s%04d%03d_%02d" % ( prefixDir, year, doy , foldercounter)) for prefixFile in prefixFileList: #barrido por las dos combinaciones posibles de "D" filename = "%s%04d%03d%03d%s" % ( prefixFile, year, doy, set, ext ) #formo el nombre del file xYYYYDDDSSS.ext fullfilename = os.path.join( thispath, filename ) #formo el path completo - + if os.path.exists( fullfilename ): #verifico que exista find_flag = True break @@ -423,7 +423,7 @@ def isRadarFolder(folder): doy = int(folder[5:8]) except: return 0 - + return 1 def isRadarFile(file): @@ -433,7 +433,7 @@ def isRadarFile(file): set = int(file[8:11]) except: return 0 - + return 1 def getDateFromRadarFile(file): @@ -456,138 +456,138 @@ def getDateFromRadarFolder(folder): thisDate = datetime.date(year, 1, 1) + datetime.timedelta(doy-1) return thisDate - + class JRODataIO: - + c = 3E8 - + isConfig = False - + basicHeaderObj = None - + systemHeaderObj = None - + radarControllerHeaderObj = None - + processingHeaderObj = None - + dtype = None - + pathList = [] - + filenameList = [] - + filename = None - + ext = None - + flagIsNewFile = 1 - + flagDiscontinuousBlock = 0 - + flagIsNewBlock = 0 - + fp = None - + firstHeaderSize = 0 - + basicHeaderSize = 24 - + versionFile = 1103 - + fileSize = None - + # ippSeconds = None - + fileSizeByHeader = None - + fileIndex = None - + profileIndex = None - + blockIndex = None - + nTotalBlocks = None - + maxTimeStep = 30 - + lastUTTime = None - + datablock = None - + dataOut = None - + blocksize = None - + getByBlock = False - + def __init__(self): - + raise NotImplementedError - + def run(self): - + raise NotImplementedError def getDtypeWidth(self): - + dtype_index = get_dtype_index(self.dtype) dtype_width = get_dtype_width(dtype_index) - + return dtype_width - + class JRODataReader(JRODataIO): - - + + online = 0 - + realtime = 0 - + nReadBlocks = 0 - + delay = 10 #number of seconds waiting a new file - + nTries = 3 #quantity tries - + nFiles = 3 #number of files for searching - + path = None - + foldercounter = 0 - + flagNoMoreFiles = 0 - + datetimeList = [] - + __isFirstTimeOnline = 1 - + __printInfo = True - + profileIndex = None - + nTxs = 1 - + txIndex = None - + #Added-------------------- - + selBlocksize = None - + selBlocktime = None - - + + def __init__(self): - + """ This class is used to find data files - + Example: reader = JRODataReader() fileList = reader.findDataFiles() - + """ pass - + def createObjByDefault(self): """ @@ -596,7 +596,7 @@ class JRODataReader(JRODataIO): raise NotImplementedError def getBlockDimension(self): - + raise NotImplementedError def __searchFilesOffLine(self, @@ -608,76 +608,93 @@ class JRODataReader(JRODataIO): set=None, expLabel='', ext='.r', + queue=None, + cursor=None, + skip=None, walk=True): - + self.filenameList = [] self.datetimeList = [] - + pathList = [] - + dateList, pathList = self.findDatafiles(path, startDate, endDate, expLabel, ext, walk, include_path=True) - + if dateList == []: # print "[Reading] Date range selected invalid [%s - %s]: No *%s files in %s)" %(startDate, endDate, ext, path) return None, None - + if len(dateList) > 1: print "[Reading] Data found for date range [%s - %s]: total days = %d" %(startDate, endDate, len(dateList)) else: print "[Reading] Data found for date range [%s - %s]: date = %s" %(startDate, endDate, dateList[0]) - + filenameList = [] datetimeList = [] - + for thisPath in pathList: # thisPath = pathList[pathDict[file]] - + fileList = glob.glob1(thisPath, "*%s" %ext) fileList.sort() - - for file in fileList: - + + skippedFileList = [] + + if cursor is not None and skip is not None: + # if cursor*skip > len(fileList): + if skip == 0: + if queue is not None: + queue.put(len(fileList)) + skippedFileList = [] + else: + skippedFileList = fileList[cursor*skip: cursor*skip + skip] + + else: + skippedFileList = fileList + + for file in skippedFileList: + filename = os.path.join(thisPath,file) - + if not isFileInDateRange(filename, startDate, endDate): continue - + thisDatetime = isFileInTimeRange(filename, startDate, endDate, startTime, endTime) - + if not(thisDatetime): continue - + filenameList.append(filename) datetimeList.append(thisDatetime) - + if not(filenameList): print "[Reading] Time range selected invalid [%s - %s]: No *%s files in %s)" %(startTime, endTime, ext, path) return None, None - + print "[Reading] %d file(s) was(were) found in time range: %s - %s" %(len(filenameList), startTime, endTime) print - + for i in range(len(filenameList)): print "[Reading] %s -> [%s]" %(filenameList[i], datetimeList[i].ctime()) self.filenameList = filenameList self.datetimeList = datetimeList - + return pathList, filenameList def __searchFilesOnLine(self, path, expLabel = "", ext = None, walk=True, set=None): - + """ Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y devuelve el archivo encontrado ademas de otros datos. - - Input: + + Input: path : carpeta donde estan contenidos los files que contiene data - + expLabel : Nombre del subexperimento (subfolder) - + ext : extension de los files - + walk : Si es habilitado no realiza busquedas dentro de los ubdirectorios (doypath) Return: @@ -686,14 +703,14 @@ class JRODataReader(JRODataIO): year : el anho doy : el numero de dia del anho set : el set del archivo - - + + """ if not os.path.isdir(path): return None, None, None, None, None, None - + dirList = [] - + if not walk: fullpath = path foldercounter = 0 @@ -704,19 +721,19 @@ class JRODataReader(JRODataIO): continue if not isRadarFolder(thisPath): continue - + dirList.append(thisPath) - + if not(dirList): return None, None, None, None, None, None - + dirList = sorted( dirList, key=str.lower ) - + doypath = dirList[-1] foldercounter = int(doypath.split('_')[1]) if len(doypath.split('_'))>1 else 0 fullpath = os.path.join(path, doypath, expLabel) - - + + print "[Reading] %s folder was found: " %(fullpath ) if set == None: @@ -726,20 +743,20 @@ class JRODataReader(JRODataIO): if not(filename): return None, None, None, None, None, None - + print "[Reading] %s file was found" %(filename) - + if not(self.__verifyFile(os.path.join(fullpath, filename))): return None, None, None, None, None, None year = int( filename[1:5] ) doy = int( filename[5:8] ) - set = int( filename[8:11] ) - + set = int( filename[8:11] ) + return fullpath, foldercounter, filename, year, doy, set - + def __setNextFileOffline(self): - + idFile = self.fileIndex while (True): @@ -772,9 +789,9 @@ class JRODataReader(JRODataIO): """ Busca el siguiente file que tenga suficiente data para ser leida, dentro de un folder especifico, si no encuentra un file valido espera un tiempo determinado y luego busca en los posibles n files - siguientes. - - Affected: + siguientes. + + Affected: self.flagIsNewFile self.filename self.fileSize @@ -782,23 +799,23 @@ class JRODataReader(JRODataIO): self.set self.flagNoMoreFiles - Return: + Return: 0 : si luego de una busqueda del siguiente file valido este no pudo ser encontrado 1 : si el file fue abierto con exito y esta listo a ser leido - - Excepciones: + + Excepciones: Si un determinado file no puede ser abierto """ nFiles = 0 - fileOk_flag = False + fileOk_flag = False firstTime_flag = True self.set += 1 - + if self.set > 999: self.set = 0 - self.foldercounter += 1 - + self.foldercounter += 1 + #busca el 1er file disponible fullfilename, filename = checkForRealPath( self.path, self.foldercounter, self.year, self.doy, self.set, self.ext ) if fullfilename: @@ -806,27 +823,27 @@ class JRODataReader(JRODataIO): fileOk_flag = True #si no encuentra un file entonces espera y vuelve a buscar - if not(fileOk_flag): + if not(fileOk_flag): for nFiles in range(self.nFiles+1): #busco en los siguientes self.nFiles+1 files posibles - if firstTime_flag: #si es la 1era vez entonces hace el for self.nTries veces + if firstTime_flag: #si es la 1era vez entonces hace el for self.nTries veces tries = self.nTries else: tries = 1 #si no es la 1era vez entonces solo lo hace una vez - - for nTries in range( tries ): + + for nTries in range( tries ): if firstTime_flag: - print "\t[Reading] Waiting %0.2f sec for the next file: \"%s\" , try %03d ..." % ( self.delay, filename, nTries+1 ) + print "\t[Reading] Waiting %0.2f sec for the next file: \"%s\" , try %03d ..." % ( self.delay, filename, nTries+1 ) sleep( self.delay ) else: print "\t[Reading] Searching the next \"%s%04d%03d%03d%s\" file ..." % (self.optchar, self.year, self.doy, self.set, self.ext) - + fullfilename, filename = checkForRealPath( self.path, self.foldercounter, self.year, self.doy, self.set, self.ext ) if fullfilename: if self.__verifyFile(fullfilename): fileOk_flag = True break - + if fileOk_flag: break @@ -834,7 +851,7 @@ class JRODataReader(JRODataIO): print "\t[Reading] Skipping the file \"%s\" due to this file doesn't exist" % filename self.set += 1 - + if nFiles == (self.nFiles-1): #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta self.set = 0 self.doy += 1 @@ -844,7 +861,7 @@ class JRODataReader(JRODataIO): self.fileSize = os.path.getsize( fullfilename ) self.filename = fullfilename self.flagIsNewFile = 1 - if self.fp != None: self.fp.close() + if self.fp != None: self.fp.close() self.fp = open(fullfilename, 'rb') self.flagNoMoreFiles = 0 # print '[Reading] Setting the file: %s' % fullfilename @@ -857,7 +874,7 @@ class JRODataReader(JRODataIO): # print '[Reading] No more files to read' return fileOk_flag - + def setNextFile(self): if self.fp != None: self.fp.close() @@ -872,29 +889,29 @@ class JRODataReader(JRODataIO): return 0 print '[Reading] Setting the file: %s' % self.filename - + self.__readFirstHeader() self.nReadBlocks = 0 return 1 def __waitNewBlock(self): """ - Return 1 si se encontro un nuevo bloque de datos, 0 de otra forma. - + 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.processingHeaderObj.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 ) @@ -905,99 +922,99 @@ class JRODataReader(JRODataIO): if ( currentSize >= neededSize ): self.basicHeaderObj.read(self.fp) return 1 - + if self.fileSize == self.fileSizeByHeader: # self.flagEoF = True return 0 - + print "[Reading] Waiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1) sleep( self.delay ) - - - return 0 + + + return 0 def waitDataBlock(self,pointer_location): - + currentPointer = pointer_location - + 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 ): return 1 - + print "[Reading] Waiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1) sleep( self.delay ) - + return 0 def __jumpToLastBlock(self): - + if not(self.__isFirstTimeOnline): return - + csize = self.fileSize - self.fp.tell() blocksize = self.processingHeaderObj.blockSize - + #salta el primer bloque de datos if csize > self.processingHeaderObj.blockSize: self.fp.seek(self.fp.tell() + blocksize) else: return - + csize = self.fileSize - self.fp.tell() neededsize = self.processingHeaderObj.blockSize + self.basicHeaderSize while True: - + if self.fp.tell() 0: # self.fp.seek(self.fp.tell() + factor*neededsize) - + self.flagIsNewFile = 0 self.__isFirstTimeOnline = 0 def __setNewBlock(self): - + if self.fp == None: return 0 - + # if self.online: # self.__jumpToLastBlock() - + if self.flagIsNewFile: self.lastUTTime = self.basicHeaderObj.utc return 1 - + if self.realtime: self.flagDiscontinuousBlock = 1 if not(self.setNextFile()): return 0 else: return 1 - + currentSize = self.fileSize - self.fp.tell() neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize - + if (currentSize >= neededSize): self.basicHeaderObj.read(self.fp) self.lastUTTime = self.basicHeaderObj.utc return 1 - + if self.__waitNewBlock(): self.lastUTTime = self.basicHeaderObj.utc return 1 @@ -1007,7 +1024,7 @@ class JRODataReader(JRODataIO): deltaTime = self.basicHeaderObj.utc - self.lastUTTime # self.lastUTTime = self.basicHeaderObj.utc - + self.flagDiscontinuousBlock = 0 if deltaTime > self.maxTimeStep: @@ -1016,33 +1033,33 @@ class JRODataReader(JRODataIO): return 1 def readNextBlock(self): - + #Skip block out of startTime and endTime while True: if not(self.__setNewBlock()): return 0 - + if not(self.readBlock()): return 0 - + self.getBasicHeader() - + if not isTimeInRange(self.dataOut.datatime.time(), self.startTime, self.endTime): - + print "[Reading] Block No. %d/%d -> %s [Skipping]" %(self.nReadBlocks, self.processingHeaderObj.dataBlocksPerFile, self.dataOut.datatime.ctime()) continue - + break - + print "[Reading] Block No. %d/%d -> %s" %(self.nReadBlocks, self.processingHeaderObj.dataBlocksPerFile, self.dataOut.datatime.ctime()) return 1 def __readFirstHeader(self): - + self.basicHeaderObj.read(self.fp) self.systemHeaderObj.read(self.fp) self.radarControllerHeaderObj.read(self.fp) @@ -1072,20 +1089,20 @@ class JRODataReader(JRODataIO): # self.dataOut.channelList = numpy.arange(self.systemHeaderObj.numChannels) # self.dataOut.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels) self.getBlockDimension() - + def __verifyFile(self, filename, msgFlag=True): - + msg = None - + try: fp = open(filename, 'rb') except IOError: - + if msgFlag: print "[Reading] File %s can't be opened" % (filename) - + return False - + currentPosition = fp.tell() neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize @@ -1094,32 +1111,32 @@ class JRODataReader(JRODataIO): systemHeaderObj = SystemHeader() radarControllerHeaderObj = RadarControllerHeader() processingHeaderObj = ProcessingHeader() - + if not( basicHeaderObj.read(fp) ): fp.close() return False - + if not( systemHeaderObj.read(fp) ): fp.close() return False - + if not( radarControllerHeaderObj.read(fp) ): fp.close() return False - + if not( processingHeaderObj.read(fp) ): fp.close() return False - + neededSize = processingHeaderObj.blockSize + basicHeaderObj.size else: msg = "[Reading] Skipping the file %s due to it hasn't enough data" %filename fp.close() - + fileSize = os.path.getsize(filename) currentSize = fileSize - currentPosition - + if currentSize < neededSize: if msgFlag and (msg != None): print msg @@ -1128,97 +1145,97 @@ class JRODataReader(JRODataIO): return True def findDatafiles(self, path, startDate=None, endDate=None, expLabel='', ext='.r', walk=True, include_path=False): - + path_empty = True - + dateList = [] pathList = [] - + multi_path = path.split(',') - + if not walk: - + for single_path in multi_path: - + if not os.path.isdir(single_path): continue - + fileList = glob.glob1(single_path, "*"+ext) - + if not fileList: continue - + path_empty = False - + fileList.sort() - + for thisFile in fileList: - + if not os.path.isfile(os.path.join(single_path, thisFile)): continue - + if not isRadarFile(thisFile): continue - + if not isFileInDateRange(thisFile, startDate, endDate): continue - + thisDate = getDateFromRadarFile(thisFile) - + if thisDate in dateList: continue - + dateList.append(thisDate) pathList.append(single_path) - + else: for single_path in multi_path: - + if not os.path.isdir(single_path): continue - + dirList = [] - + for thisPath in os.listdir(single_path): - + if not os.path.isdir(os.path.join(single_path,thisPath)): continue - + if not isRadarFolder(thisPath): continue - + if not isFolderInDateRange(thisPath, startDate, endDate): continue - + dirList.append(thisPath) - + if not dirList: continue - + dirList.sort() - + for thisDir in dirList: - + datapath = os.path.join(single_path, thisDir, expLabel) fileList = glob.glob1(datapath, "*"+ext) - + if not fileList: continue - + path_empty = False - + thisDate = getDateFromRadarFolder(thisDir) - + pathList.append(datapath) dateList.append(thisDate) - + dateList.sort() - + if walk: pattern_path = os.path.join(multi_path[0], "[dYYYYDDD]", expLabel) else: pattern_path = multi_path[0] - + if path_empty: print "[Reading] No *%s files in %s for %s to %s" %(ext, pattern_path, startDate, endDate) else: @@ -1227,18 +1244,18 @@ class JRODataReader(JRODataIO): if include_path: return dateList, pathList - + return dateList - + def setup(self, path=None, - startDate=None, - endDate=None, - startTime=datetime.time(0,0,0), - endTime=datetime.time(23,59,59), - set=None, - expLabel = "", - ext = None, + startDate=None, + endDate=None, + startTime=datetime.time(0,0,0), + endTime=datetime.time(23,59,59), + set=None, + expLabel = "", + ext = None, online = False, delay = 60, walk = True, @@ -1246,7 +1263,10 @@ class JRODataReader(JRODataIO): nTxs = 1, realtime=False, blocksize=None, - blocktime=None): + blocktime=None, + queue=None, + skip=None, + cursor=None): if path == None: raise ValueError, "[Reading] The path is not valid" @@ -1255,54 +1275,55 @@ class JRODataReader(JRODataIO): ext = self.ext if online: - print "[Reading] Searching files in online mode..." - + print "[Reading] Searching files in online mode..." + for nTries in range( self.nTries ): fullpath, foldercounter, file, year, doy, set = self.__searchFilesOnLine(path=path, expLabel=expLabel, ext=ext, walk=walk, set=set) - + if fullpath: break - + print '[Reading] Waiting %0.2f sec for an valid file in %s: try %02d ...' % (self.delay, path, nTries+1) sleep( self.delay ) - + if not(fullpath): print "[Reading] There 'isn't any valid file in %s" % path return - + self.year = year self.doy = doy self.set = set - 1 self.path = path self.foldercounter = foldercounter last_set = None - + else: print "[Reading] 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) - + walk=walk, cursor=cursor, + skip=skip, queue=queue) + if not(pathList): # print "[Reading] No *%s files in %s (%s - %s)"%(ext, path, # datetime.datetime.combine(startDate,startTime).ctime(), # datetime.datetime.combine(endDate,endTime).ctime()) - + # sys.exit(-1) - + self.fileIndex = -1 self.pathList = [] self.filenameList = [] return - + self.fileIndex = -1 self.pathList = pathList self.filenameList = filenameList file_name = os.path.basename(filenameList[-1]) basename, ext = os.path.splitext(file_name) last_set = int(basename[-3:]) - + self.online = online self.realtime = realtime self.delay = delay @@ -1312,12 +1333,12 @@ class JRODataReader(JRODataIO): self.nTxs = nTxs self.startTime = startTime self.endTime = endTime - + #Added----------------- self.selBlocksize = blocksize self.selBlocktime = blocktime - - + + if not(self.setNextFile()): if (startDate!=None) and (endDate!=None): print "[Reading] No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime()) @@ -1325,116 +1346,116 @@ class JRODataReader(JRODataIO): print "[Reading] No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime()) else: print "[Reading] No files" - + self.fileIndex = -1 self.pathList = [] self.filenameList = [] return # self.getBasicHeader() - + if last_set != None: self.dataOut.last_block = last_set * self.processingHeaderObj.dataBlocksPerFile + self.basicHeaderObj.dataBlock return def getBasicHeader(self): - + self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000. + self.profileIndex * self.radarControllerHeaderObj.ippSeconds - + self.dataOut.flagDiscontinuousBlock = self.flagDiscontinuousBlock - + self.dataOut.timeZone = self.basicHeaderObj.timeZone - + self.dataOut.dstFlag = self.basicHeaderObj.dstFlag - + self.dataOut.errorCount = self.basicHeaderObj.errorCount - + self.dataOut.useLocalTime = self.basicHeaderObj.useLocalTime - + self.dataOut.ippSeconds = self.radarControllerHeaderObj.ippSeconds/self.nTxs - + # self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock*self.nTxs - - + + def getFirstHeader(self): - + raise NotImplementedError - + def getData(self): - + raise NotImplementedError def hasNotDataInBuffer(self): - + raise NotImplementedError def readBlock(self): - + raise NotImplementedError - + def isEndProcess(self): - + return self.flagNoMoreFiles - + def printReadBlocks(self): - + print "[Reading] Number of read blocks per file %04d" %self.nReadBlocks - + def printTotalBlocks(self): - + print "[Reading] Number of read blocks %04d" %self.nTotalBlocks def printNumberOfBlock(self): - + if self.flagIsNewBlock: print "[Reading] Block No. %d/%d -> %s" %(self.nReadBlocks, self.processingHeaderObj.dataBlocksPerFile, self.dataOut.datatime.ctime()) def printInfo(self): - + if self.__printInfo == False: return - + self.basicHeaderObj.printInfo() self.systemHeaderObj.printInfo() self.radarControllerHeaderObj.printInfo() self.processingHeaderObj.printInfo() - + self.__printInfo = False - - + + def run(self, **kwargs): - + if not(self.isConfig): - + # self.dataOut = dataOut self.setup(**kwargs) self.isConfig = True - + self.getData() class JRODataWriter(JRODataIO): - """ + """ Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura - de los datos siempre se realiza por bloques. + de los datos siempre se realiza por bloques. """ - + blockIndex = 0 - + path = None - + setFile = None - + profilesPerBlock = None - + blocksPerFile = None - + nWriteBlocks = 0 - + fileDate = None - + def __init__(self, dataOut=None): raise NotImplementedError @@ -1446,7 +1467,7 @@ class JRODataWriter(JRODataIO): def setBlockDimension(self): raise NotImplementedError - + def writeBlock(self): raise NotImplementedError @@ -1454,140 +1475,140 @@ class JRODataWriter(JRODataIO): def putData(self): raise NotImplementedError - + def getProcessFlags(self): - + processFlags = 0 - + dtype_index = get_dtype_index(self.dtype) procflag_dtype = get_procflag_dtype(dtype_index) - + processFlags += procflag_dtype - + if self.dataOut.flagDecodeData: processFlags += PROCFLAG.DECODE_DATA - + if self.dataOut.flagDeflipData: processFlags += PROCFLAG.DEFLIP_DATA - + if self.dataOut.code is not None: processFlags += PROCFLAG.DEFINE_PROCESS_CODE - + if self.dataOut.nCohInt > 1: processFlags += PROCFLAG.COHERENT_INTEGRATION - + if self.dataOut.type == "Spectra": if self.dataOut.nIncohInt > 1: processFlags += PROCFLAG.INCOHERENT_INTEGRATION - + if self.dataOut.data_dc is not None: processFlags += PROCFLAG.SAVE_CHANNELS_DC - + if self.dataOut.flagShiftFFT: processFlags += PROCFLAG.SHIFT_FFT_DATA - + return processFlags - + def setBasicHeader(self): - + self.basicHeaderObj.size = self.basicHeaderSize #bytes self.basicHeaderObj.version = self.versionFile self.basicHeaderObj.dataBlock = self.nTotalBlocks - + utc = numpy.floor(self.dataOut.utctime) milisecond = (self.dataOut.utctime - utc)* 1000.0 - + self.basicHeaderObj.utc = utc self.basicHeaderObj.miliSecond = milisecond self.basicHeaderObj.timeZone = self.dataOut.timeZone self.basicHeaderObj.dstFlag = self.dataOut.dstFlag self.basicHeaderObj.errorCount = self.dataOut.errorCount - + def setFirstHeader(self): """ Obtiene una copia del First Header - + Affected: - + self.basicHeaderObj self.systemHeaderObj self.radarControllerHeaderObj self.processingHeaderObj self. - + Return: None """ - + raise NotImplementedError - + def __writeFirstHeader(self): """ Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader) - + Affected: __dataType - + Return: None """ - + # CALCULAR PARAMETROS - + sizeLongHeader = self.systemHeaderObj.size + self.radarControllerHeaderObj.size + self.processingHeaderObj.size self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader - + self.basicHeaderObj.write(self.fp) self.systemHeaderObj.write(self.fp) self.radarControllerHeaderObj.write(self.fp) self.processingHeaderObj.write(self.fp) - + def __setNewBlock(self): """ Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header - + Return: 0 : si no pudo escribir nada 1 : Si escribio el Basic el First Header - """ + """ if self.fp == None: self.setNextFile() - + if self.flagIsNewFile: return 1 - + if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile: self.basicHeaderObj.write(self.fp) return 1 - + if not( self.setNextFile() ): return 0 - + return 1 def writeNextBlock(self): """ Selecciona el bloque siguiente de datos y los escribe en un file - - Return: - 0 : Si no hizo pudo escribir el bloque de datos + + Return: + 0 : Si no hizo pudo escribir el bloque de datos 1 : Si no pudo escribir el bloque de datos """ if not( self.__setNewBlock() ): return 0 - + self.writeBlock() - + print "[Writing] Block No. %d/%d" %(self.blockIndex, self.processingHeaderObj.dataBlocksPerFile) - - return 1 + + return 1 def setNextFile(self): - """ + """ Determina el siguiente file que sera escrito - Affected: + Affected: self.filename self.subfolder self.fp @@ -1600,16 +1621,16 @@ class JRODataWriter(JRODataIO): """ ext = self.ext path = self.path - + if self.fp != None: self.fp.close() - + timeTuple = time.localtime( self.dataOut.utctime) subfolder = 'd%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday) fullpath = os.path.join( path, subfolder ) setFile = self.setFile - + if not( os.path.exists(fullpath) ): os.mkdir(fullpath) setFile = -1 #inicializo mi contador de seteo @@ -1623,49 +1644,49 @@ class JRODataWriter(JRODataIO): # x YYYY DDD SSS .ext if isNumber( filen[8:11] ): setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file - else: + else: setFile = -1 else: setFile = -1 #inicializo mi contador de seteo - + setFile += 1 - + #If this is a new day it resets some values if self.dataOut.datatime.date() > self.fileDate: setFile = 0 self.nTotalBlocks = 0 - + filen = '%s%4.4d%3.3d%3.3d%s' % (self.optchar, timeTuple.tm_year, timeTuple.tm_yday, setFile, ext ) filename = os.path.join( path, subfolder, filen ) fp = open( filename,'wb' ) - + self.blockIndex = 0 - - #guardando atributos + + #guardando atributos self.filename = filename self.subfolder = subfolder self.fp = fp self.setFile = setFile self.flagIsNewFile = 1 self.fileDate = self.dataOut.datatime.date() - + self.setFirstHeader() - + print '[Writing] Opening file: %s'%self.filename - + self.__writeFirstHeader() - + return 1 - + def setup(self, dataOut, path, blocksPerFile, profilesPerBlock=64, set=None, ext=None, datatype=4): """ - Setea el tipo de formato en la cual sera guardada la data y escribe el First Header - + Setea el tipo de formato en la cual sera guardada la data y escribe el First Header + Inputs: path : directory where data will be saved - profilesPerBlock : number of profiles per block + profilesPerBlock : number of profiles per block set : initial file set datatype : An integer number that defines data type: 0 : int8 (1 byte) @@ -1674,50 +1695,49 @@ class JRODataWriter(JRODataIO): 3 : int64 (8 bytes) 4 : float32 (4 bytes) 5 : double64 (8 bytes) - + Return: 0 : Si no realizo un buen seteo - 1 : Si realizo un buen seteo + 1 : Si realizo un buen seteo """ - + if ext == None: ext = self.ext - + self.ext = ext.lower() - + self.path = path - + if set is None: self.setFile = -1 else: self.setFile = set - 1 - + self.blocksPerFile = blocksPerFile - + self.profilesPerBlock = profilesPerBlock - + self.dataOut = dataOut self.fileDate = self.dataOut.datatime.date() #By default self.dtype = self.dataOut.dtype - + if datatype is not None: self.dtype = get_numpy_dtype(datatype) - + if not(self.setNextFile()): print "[Writing] There isn't a next file" return 0 - + self.setBlockDimension() - + return 1 - + def run(self, dataOut, **kwargs): - + if not(self.isConfig): - + self.setup(dataOut, **kwargs) self.isConfig = True - - self.putData() + self.putData() diff --git a/schainpy/model/utils/jroutils_publish.py b/schainpy/model/utils/jroutils_publish.py index 7cf665a..e47fd2f 100644 --- a/schainpy/model/utils/jroutils_publish.py +++ b/schainpy/model/utils/jroutils_publish.py @@ -279,7 +279,7 @@ class ReceiverData(ProcessingUnit, Process): self.data['times'] = [] for plottype in self.plottypes: self.data[plottype] = {} - + self.data['noise'] = {} self.isConfig = True def event_monitor(self, monitor): @@ -325,8 +325,8 @@ class ReceiverData(ProcessingUnit, Process): if plottype == 'spc': z = self.dataOut.data_spc/self.dataOut.normFactor - zdB = 10*numpy.log10(z) - self.data[plottype] = zdB + self.data[plottype] = 10*numpy.log10(z) + self.data['noise'][t] = 10*numpy.log10(self.dataOut.getNoise()/self.dataOut.normFactor) if plottype == 'rti': self.data[plottype][t] = self.dataOut.getPower() if plottype == 'snr': diff --git a/schainpy/scripts/PPD.py b/schainpy/scripts/PPD.py new file mode 100644 index 0000000..805ee04 --- /dev/null +++ b/schainpy/scripts/PPD.py @@ -0,0 +1,82 @@ +import argparse + +from schainpy.controller import Project, multiSchain + +desc = "HF_EXAMPLE" + +def fiber(cursor, skip, q, dt): + + controllerObj = Project() + + controllerObj.setup(id='191', name='test01', description=desc) + + readUnitConfObj = controllerObj.addReadUnit(datatype='SpectraReader', + path='/data/workspace/data/julia/', + startDate=dt, + endDate=dt, + startTime="00:00:00", + endTime="23:59:59", + online=0, + #set=1426485881, + delay=10, + walk=1, + queue=q, + cursor=cursor, + skip=skip, + #timezone=-5*3600 + ) + + # #opObj11 = readUnitConfObj.addOperation(name='printNumberOfBlock') + # + procUnitConfObj2 = controllerObj.addProcUnit(datatype='Spectra', inputId=readUnitConfObj.getId()) + # opObj11 = procUnitConfObj2.addParameter(name='pairsList', value='(0,1)', format='pairslist') + # + # procUnitConfObj2 = controllerObj.addProcUnit(datatype='ParametersProc', inputId=readUnitConfObj.getId()) + + # opObj11 = procUnitConfObj2.addOperation(name='SpectralMoments', optype='other') + + # + # opObj11 = procUnitConfObj1.addOperation(name='SpectraPlot', optype='other') + # opObj11.addParameter(name='id', value='1000', format='int') + # opObj11.addParameter(name='wintitle', value='HF_Jicamarca_Spc', format='str') + # opObj11.addParameter(name='channelList', value='0', format='intlist') + # opObj11.addParameter(name='zmin', value='-120', format='float') + # opObj11.addParameter(name='zmax', value='-70', format='float') + # opObj11.addParameter(name='save', value='1', format='int') + # opObj11.addParameter(name='figpath', value=figpath, format='str') + + # opObj11 = procUnitConfObj1.addOperation(name='RTIPlot', optype='other') + # opObj11.addParameter(name='id', value='2000', format='int') + # opObj11.addParameter(name='wintitle', value='HF_Jicamarca', format='str') + # opObj11.addParameter(name='showprofile', value='0', format='int') + # opObj11.addParameter(name='channelList', value='0', format='intlist') + # # opObj11.addParameter(name='xmin', value='0', format='float') + # opObj11.addParameter(name='xmin', value='0', format='float') + # opObj11.addParameter(name='xmax', value='24', format='float') + # + # opObj11.addParameter(name='zmin', value='-110', format='float') + # opObj11.addParameter(name='zmax', value='-70', format='float') + # opObj11.addParameter(name='save', value='0', format='int') + # opObj11.addParameter(name='figpath', value='/tmp/', format='str') + + opObj12 = procUnitConfObj2.addOperation(name='PublishData', optype='other') + opObj12.addParameter(name='zeromq', value=1, format='int') + + # print "Escribiendo el archivo XML" + # controllerObj.writeXml(filename) + # print "Leyendo el archivo XML" + # controllerObj.readXml(filename) + + controllerObj.createObjects() + controllerObj.connectObjects() + + # timeit.timeit('controllerObj.run()', number=2) + + controllerObj.run() + + +if __name__ == '__main__': + parser = argparse.ArgumentParser(description='Set number of parallel processes') + parser.add_argument('--nProcess', default=2, type=int) + args = parser.parse_args() + multiSchain(fiber, nProcess=args.nProcess, startDate='2016/08/19', endDate='2016/08/20')