schain Commit - r1352:55100ef75825 · Jicamarca Repository

update test

avaldez -

r1352:55100ef75825

parent child

Context file:

r1352:55100ef75825

schainpy/model/io/jroIO_param.py +1 -1

             import os
             import time
             import datetime
             import numpy
             import h5py
             import schainpy.admin
             from schainpy.model.data.jrodata import *
             from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation, MPDecorator
             from schainpy.model.io.jroIO_base import *
             from schainpy.utils import log
             class HDFReader(Reader, ProcessingUnit):
                 """Processing unit to read HDF5 format files
                 This unit reads HDF5 files created with `HDFWriter` operation contains
                 by default two groups Data and Metadata all variables would be saved as `dataOut`
                 attributes.
                 It is possible to read any HDF5 file by given the structure in the `description`
                 parameter, also you can add extra values to metadata with the parameter `extras`.
                 Parameters:
                 -----------
                 path : str
                     Path where files are located.
                 startDate : date
                     Start date of the files
                 endDate : list
                     End date of the files
                 startTime : time
                     Start time of the files
                 endTime : time
                     End time of the files
                 description : dict, optional
                     Dictionary with the description of the HDF5 file
                 extras : dict, optional
                     Dictionary with extra metadata to be be added to `dataOut`
                 Examples
                 --------
                 desc = {
                     'Data': {
                         'data_output': ['u', 'v', 'w'],
                         'utctime': 'timestamps',
                     }  ,
                     'Metadata': {
                         'heightList': 'heights'
                     }
                 }
                 desc = {
                     'Data': {
                         'data_output': 'winds',
                         'utctime': 'timestamps'
                     },
                     'Metadata': {
                         'heightList': 'heights'
                     }
                 }
                 extras = {
                     'timeZone': 300
                 }
                 reader = project.addReadUnit(
                     name='HDFReader',
                     path='/path/to/files',
                     startDate='2019/01/01',
                     endDate='2019/01/31',
                     startTime='00:00:00',
                     endTime='23:59:59',
                     # description=json.dumps(desc),
                     # extras=json.dumps(extras),
                     )
                 """
                 __attrs__ = ['path', 'startDate', 'endDate', 'startTime', 'endTime', 'description', 'extras']
                 def __init__(self):
                     ProcessingUnit.__init__(self)
                     self.dataOut = Parameters()
                     self.ext = ".hdf5"
                     self.optchar = "D"
                     self.meta = {}
                     self.data = {}
                     self.open_file = h5py.File
                     self.open_mode = 'r'
                     self.description = {}
                     self.extras = {}
                     self.filefmt = "*%Y%j***"
                     self.folderfmt = "*%Y%j"
                 def setup(self, **kwargs):
                     self.set_kwargs(**kwargs)
                     if not self.ext.startswith('.'):
                         self.ext = '.{}'.format(self.ext)
                     if self.online:
                         log.log("Searching files in online mode...", self.name)
                         for nTries in range(self.nTries):
                             fullpath = self.searchFilesOnLine(self.path, self.startDate,
                                 self.endDate, self.expLabel, self.ext, self.walk,
                                 self.filefmt, self.folderfmt)
                             try:
                                 fullpath = next(fullpath)
                             except:
                                 fullpath = None
                             if fullpath:
                                 break
                             log.warning(
                                 'Waiting {} sec for a valid file in {}: try {} ...'.format(
                                     self.delay, self.path, nTries + 1),
                                 self.name)
                             time.sleep(self.delay)
                         if not(fullpath):
                             raise schainpy.admin.SchainError(
                                 'There isn\'t any valid file in {}'.format(self.path))
                         pathname, filename = os.path.split(fullpath)
                         self.year = int(filename[1:5])
                         self.doy = int(filename[5:8])
                         self.set = int(filename[8:11]) - 1
                     else:
                         log.log("Searching files in {}".format(self.path), self.name)
                         self.filenameList = self.searchFilesOffLine(self.path, self.startDate,
                             self.endDate, self.expLabel, self.ext, self.walk, self.filefmt, self.folderfmt)
                     self.setNextFile()
                     return
                 def readFirstHeader(self):
                     '''Read metadata and data'''
                     self.__readMetadata()
                     self.__readData()
                     self.__setBlockList()
                     if 'type' in self.meta:
                         self.dataOut = eval(self.meta['type'])()
                     for attr in self.meta:
                         setattr(self.dataOut, attr, self.meta[attr])
                     self.blockIndex = 0
                     return
                 def __setBlockList(self):
                     '''
                     Selects the data within the times defined
                     self.fp
                     self.startTime
                     self.endTime
                     self.blockList
                     self.blocksPerFile
                     '''
                     startTime = self.startTime
                     endTime = self.endTime
                     thisUtcTime = self.data['utctime']
                     self.interval = numpy.min(thisUtcTime[1:] - thisUtcTime[:-1])
                     thisDatetime = datetime.datetime.utcfromtimestamp(thisUtcTime[0])
                     thisDate = thisDatetime.date()
                     thisTime = thisDatetime.time()
                     startUtcTime = (datetime.datetime.combine(thisDate, startTime) - datetime.datetime(1970, 1, 1)).total_seconds()
                     endUtcTime = (datetime.datetime.combine(thisDate, endTime) - datetime.datetime(1970, 1, 1)).total_seconds()
                     ind = numpy.where(numpy.logical_and(thisUtcTime >= startUtcTime, thisUtcTime < endUtcTime))[0]
                     self.blockList = ind
                     self.blocksPerFile = len(ind)
                     return
                 def __readMetadata(self):
                     '''
                     Reads Metadata
                     '''
                     meta = {}
                     desc = {
                         'Data': {
-                            'dataPP_POW': 'Data/dataPP_POW/table00',
+                            'dataPP_POW': 'Data/dataPP_POW/channel00',
                             'utctime':'Data/utctime'
                         },
                         'Metadata': {
                             'azimuth' :'Metadata/azimuth',
                             'heightList' :'Metadata/heightList',
                             'flagDataAsBlock':'Metadata/flagDataAsBlock'
                         }
                     }
                     self.description = desc
                     if self.description:
                         for key, value in self.description['Metadata'].items():
                             try:
                                 meta[key] = self.fp[value].value
                             except:
                                 meta[key] = self.fp[value][()]
                     else:
                         grp = self.fp['Metadata']
                         for name in grp:
                             meta[name] = grp[name].value
                     if self.extras:
                         for key, value in self.extras.items():
                             meta[key] = value
                     self.meta = meta
                     return
                 def __readData(self):
                     data = {}
                     if self.description:
                         for key, value in self.description['Data'].items():
                             if isinstance(value, str):
                                 if isinstance(self.fp[value], h5py.Dataset):
                                     try:
                                         data[key] = self.fp[value].value
                                     except:
                                         ndim= self.fp[value][()].ndim
                                         if ndim==2:
                                             data[key] = numpy.swapaxes(self.fp[value][()],0,1)
                                         if ndim==1:
                                             data[key] = self.fp[value][()]
                                 elif isinstance(self.fp[value], h5py.Group):
                                     array = []
                                     for ch in self.fp[value]:
                                         array.append(self.fp[value][ch].value)
                                     data[key] = numpy.array(array)
                             elif isinstance(value, list):
                                 array = []
                                 for ch in value:
                                     array.append(self.fp[ch].value)
                                 data[key] = numpy.array(array)
                     else:
                         grp = self.fp['Data']
                         for name in grp:
                             if isinstance(grp[name], h5py.Dataset):
                                 array = grp[name].value
                             elif isinstance(grp[name], h5py.Group):
                                 array = []
                                 for ch in grp[name]:
                                     array.append(grp[name][ch].value)
                                 array = numpy.array(array)
                             else:
                                 log.warning('Unknown type: {}'.format(name))
                             if name in self.description:
                                 key = self.description[name]
                             else:
                                 key = name
                             data[key] = array
                     self.data = data
                     return
                 def getData(self):
                     for attr in self.data:
                         if self.data[attr].ndim == 1:
                             setattr(self.dataOut, attr, self.data[attr][self.blockIndex])
                         else:
                             setattr(self.dataOut, attr, self.data[attr][:, self.blockIndex])
                     self.dataOut.flagNoData = False
                     self.blockIndex += 1
                     log.log("Block No. {}/{} -> {}".format(
                         self.blockIndex,
                         self.blocksPerFile,
                         self.dataOut.datatime.ctime()), self.name)
                     return
                 def run(self, **kwargs):
                     if not(self.isConfig):
                         self.setup(**kwargs)
                         self.isConfig = True
                     if self.blockIndex == self.blocksPerFile:
                         self.setNextFile()
                     self.getData()
                     return
             @MPDecorator
             class HDFWriter(Operation):
                 """Operation to write HDF5 files.
                 The HDF5 file contains by default two groups Data and Metadata where
                 you can save any `dataOut` attribute specified by `dataList` and `metadataList`
                 parameters, data attributes are normaly time dependent where the metadata
                 are not.
                 It is possible to customize the structure of the HDF5 file with the
                 optional description parameter see the examples.
                 Parameters:
                 -----------
                 path : str
                     Path where files will be saved.
                 blocksPerFile : int
                     Number of blocks per file
                 metadataList : list
                     List of the dataOut attributes that will be saved as metadata
                 dataList : int
                     List of the dataOut attributes that will be saved as data
                 setType : bool
                     If True the name of the files corresponds to the timestamp of the data
                 description : dict, optional
                     Dictionary with the desired description of the HDF5 file
                 Examples
                 --------
                 desc = {
                     'data_output': {'winds': ['z', 'w', 'v']},
                     'utctime': 'timestamps',
                     'heightList': 'heights'
                 }
                 desc = {
                     'data_output': ['z', 'w', 'v'],
                     'utctime': 'timestamps',
                     'heightList': 'heights'
                 }
                 desc = {
                     'Data': {
                         'data_output': 'winds',
                         'utctime': 'timestamps'
                     },
                     'Metadata': {
                         'heightList': 'heights'
                     }
                 }
                 writer = proc_unit.addOperation(name='HDFWriter')
                 writer.addParameter(name='path', value='/path/to/file')
                 writer.addParameter(name='blocksPerFile', value='32')
                 writer.addParameter(name='metadataList', value='heightList,timeZone')
                 writer.addParameter(name='dataList',value='data_output,utctime')
                 # writer.addParameter(name='description',value=json.dumps(desc))
                 """
                 ext = ".hdf5"
                 optchar = "D"
                 filename = None
                 path = None
                 setFile = None
                 fp = None
                 firsttime = True
                 #Configurations
                 blocksPerFile = None
                 blockIndex = None
                 dataOut = None
                 #Data Arrays
                 dataList = None
                 metadataList = None
                 currentDay = None
                 lastTime = None
                 def __init__(self):
                     Operation.__init__(self)
                     return
                 def setup(self, path=None, blocksPerFile=10, metadataList=None, dataList=None, setType=None, description=None):
                     self.path = path
                     self.blocksPerFile = blocksPerFile
                     self.metadataList = metadataList
                     self.dataList = [s.strip() for s in dataList]
                     self.setType = setType
                     self.description = description
                     if self.metadataList is None:
                         self.metadataList = self.dataOut.metadata_list
                     tableList = []
                     dsList = []
                     for i in range(len(self.dataList)):
                         dsDict = {}
                         if hasattr(self.dataOut, self.dataList[i]):
                             dataAux = getattr(self.dataOut, self.dataList[i])
                             dsDict['variable'] = self.dataList[i]
                         else:
                             log.warning('Attribute {} not found in dataOut', self.name)
                             continue
                         if dataAux is None:
                             continue
                         elif isinstance(dataAux, (int, float, numpy.integer, numpy.float)):
                             dsDict['nDim'] = 0
                         else:
                             dsDict['nDim'] = len(dataAux.shape)
                             dsDict['shape'] = dataAux.shape
                             dsDict['dsNumber'] = dataAux.shape[0]
                             dsDict['dtype'] = dataAux.dtype
                         dsList.append(dsDict)
                     self.dsList = dsList
                     self.currentDay = self.dataOut.datatime.date()
                 def timeFlag(self):
                     currentTime = self.dataOut.utctime
                     timeTuple = time.localtime(currentTime)
                     dataDay = timeTuple.tm_yday
                     if self.lastTime is None:
                         self.lastTime = currentTime
                         self.currentDay = dataDay
                         return False
                     timeDiff = currentTime - self.lastTime
                     #Si el dia es diferente o si la diferencia entre un dato y otro supera la hora
                     if dataDay != self.currentDay:
                         self.currentDay = dataDay
                         return True
                     elif timeDiff > 3*60*60:
                         self.lastTime = currentTime
                         return True
                     else:
                         self.lastTime = currentTime
                         return False
                 def run(self, dataOut, path, blocksPerFile=10, metadataList=None,
                         dataList=[], setType=None, description={}):
                     self.dataOut = dataOut
                     if not(self.isConfig):
                         self.setup(path=path, blocksPerFile=blocksPerFile,
                                    metadataList=metadataList, dataList=dataList,
                                    setType=setType, description=description)
                         self.isConfig = True
                         self.setNextFile()
                     self.putData()
                     return
                 def setNextFile(self):
                     ext = self.ext
                     path = self.path
                     setFile = self.setFile
                     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 os.path.exists(fullpath):
                         filesList = os.listdir(fullpath)
                         filesList = [k for k in filesList if k.startswith(self.optchar)]
                         if len( filesList ) > 0:
                             filesList = sorted(filesList, key=str.lower)
                             filen = filesList[-1]
                             # el filename debera tener el siguiente formato
                             # 0 1234 567 89A BCDE (hex)
                             # 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:
                                 setFile = -1
                         else:
                             setFile = -1 #inicializo mi contador de seteo
                     else:
                         os.makedirs(fullpath)
                         setFile = -1 #inicializo mi contador de seteo
                     if self.setType is None:
                         setFile += 1
                         file = '%s%4.4d%3.3d%03d%s' % (self.optchar,
                                                        timeTuple.tm_year,
                                                        timeTuple.tm_yday,
                                                        setFile,
                                                        ext )
                     else:
                         setFile = timeTuple.tm_hour*60+timeTuple.tm_min
                         file = '%s%4.4d%3.3d%04d%s' % (self.optchar,
                                                        timeTuple.tm_year,
                                                        timeTuple.tm_yday,
                                                        setFile,
                                                        ext )
                     self.filename = os.path.join( path, subfolder, file )
                     #Setting HDF5 File
                     self.fp = h5py.File(self.filename, 'w')
                     #write metadata
                     self.writeMetadata(self.fp)
                     #Write data
                     self.writeData(self.fp)
                 def getLabel(self, name, x=None):
                     if x is None:
                         if 'Data' in self.description:
                             data = self.description['Data']
                             if 'Metadata' in self.description:
                                 data.update(self.description['Metadata'])
                         else:
                             data = self.description
                         if name in data:
                             if isinstance(data[name], str):
                                 return data[name]
                             elif isinstance(data[name], list):
                                 return None
                             elif isinstance(data[name], dict):
                                 for key, value in data[name].items():
                                     return key
                         return name
                     else:
                         if 'Metadata' in self.description:
                             meta = self.description['Metadata']
                         else:
                             meta = self.description
                         if name in meta:
                             if isinstance(meta[name], list):
                                 return meta[name][x]
                             elif isinstance(meta[name], dict):
                                 for key, value in meta[name].items():
                                     return value[x]
                         if 'cspc' in name:
                             return 'pair{:02d}'.format(x)
                         else:
                             return 'channel{:02d}'.format(x)
                 def writeMetadata(self, fp):
                     if self.description:
                         if 'Metadata' in self.description:
                             grp = fp.create_group('Metadata')
                         else:
                             grp = fp
                     else:
                         grp = fp.create_group('Metadata')
                     for i in range(len(self.metadataList)):
                         if not hasattr(self.dataOut, self.metadataList[i]):
                             log.warning('Metadata: `{}` not found'.format(self.metadataList[i]), self.name)
                             continue
                         value = getattr(self.dataOut, self.metadataList[i])
                         if isinstance(value, bool):
                             if value is True:
                                 value = 1
                             else:
                                 value = 0
                         grp.create_dataset(self.getLabel(self.metadataList[i]), data=value)
                     return
                 def writeData(self, fp):
                     if self.description:
                         if 'Data' in self.description:
                             grp = fp.create_group('Data')
                         else:
                             grp = fp
                     else:
                         grp = fp.create_group('Data')
                     dtsets = []
                     data = []
                     for dsInfo in self.dsList:
                         if dsInfo['nDim'] == 0:
                             ds = grp.create_dataset(
                                 self.getLabel(dsInfo['variable']),
                                 (self.blocksPerFile, ),
                                 chunks=True,
                                 dtype=numpy.float64)
                             dtsets.append(ds)
                             data.append((dsInfo['variable'], -1))
                         else:
                             label = self.getLabel(dsInfo['variable'])
                             if label is not None:
                                 sgrp = grp.create_group(label)
                             else:
                                 sgrp = grp
                             for i in range(dsInfo['dsNumber']):
                                 ds = sgrp.create_dataset(
                                     self.getLabel(dsInfo['variable'], i),
                                     (self.blocksPerFile, ) + dsInfo['shape'][1:],
                                     chunks=True,
                                     dtype=dsInfo['dtype'])
                                 dtsets.append(ds)
                                 data.append((dsInfo['variable'], i))
                     fp.flush()
                     log.log('Creating file: {}'.format(fp.filename), self.name)
                     self.ds = dtsets
                     self.data = data
                     self.firsttime = True
                     self.blockIndex = 0
                     return
                 def putData(self):
                     if (self.blockIndex == self.blocksPerFile) or self.timeFlag():
                         self.closeFile()
                         self.setNextFile()
                     for i, ds in enumerate(self.ds):
                         attr, ch = self.data[i]
                         if ch == -1:
                             ds[self.blockIndex] = getattr(self.dataOut, attr)
                         else:
                             ds[self.blockIndex] = getattr(self.dataOut, attr)[ch]
                     self.fp.flush()
                     self.blockIndex += 1
                     log.log('Block No. {}/{}'.format(self.blockIndex, self.blocksPerFile), self.name)
                     return
                 def closeFile(self):
                     if self.blockIndex != self.blocksPerFile:
                         for ds in self.ds:
                             ds.resize(self.blockIndex, axis=0)
                     if self.fp:
                         self.fp.flush()
                         self.fp.close()
                 def close(self):
                     self.closeFile()

schainpy/scripts/test_sim00011.py +1 -1

             import os,sys
             import datetime
             import time
             from schainpy.controller import Project
             #path    = '/home/alex/Downloads/hdf5_testPP2'
             #path    = '/home/alex/Downloads/hdf5_test'
             #path='/home/alex/Downloads/hdf5_wr'
-            path='/home/developer/Downloads/HDF5_WR'
+            path='/home/developer/Downloads/HDF5_WR/HDF5_064'
             figpath = path
             desc            = "Simulator Test"
             controllerObj   = Project()
             controllerObj.setup(id='10',name='Test Simulator',description=desc)
             readUnitConfObj = controllerObj.addReadUnit(datatype='HDFReader',
                                                         path=path,
                                                         startDate="2021/01/01",   #"2020/01/01",#today,
                                                         endDate= "2021/12/01",  #"2020/12/30",#today,
                                                         startTime='00:00:00',
                                                         endTime='23:59:59',
                                                         delay=0,
                                                         #set=0,
                                                         online=0,
                                                         walk=0)#1
             procUnitConfObjA = controllerObj.addProcUnit(datatype='ParametersProc',inputId=readUnitConfObj.getId())
             opObj11 = procUnitConfObjA.addOperation(name='Block360')
             opObj11.addParameter(name='n', value='10', format='int')
             opObj11= procUnitConfObjA.addOperation(name='WeatherPlot',optype='other')
             #opObj11.addParameter(name='save', value=figpath)
             #opObj11.addParameter(name='save_period', value=1)
             #opObj11 = procUnitConfObjA.addOperation(name='PowerPlot', optype='other')#PulsepairPowerPlot
             #opObj11 = procUnitConfObjA.addOperation(name='PPSignalPlot', optype='other')
             controllerObj.start()

schainpy/scripts/wr_integradorv2.py +2 -2

             import os,numpy,h5py
             from shutil import copyfile
             import sys,time
             def isNumber(str):
                 try:
                     float(str)
                     return True
                 except:
                     return False
             def getfirstFilefromPath(path,meta,ext):
                 validFilelist = []
                 fileList      = os.listdir(path)
                 if len(fileList)<1:
                  return None
                 # meta    1234 567 8-18 BCDE
                 # H,D,PE  YYYY DDD EPOC .ext
                 for thisFile in fileList:
                     if meta =="PE":
                         try:
                             number= int(thisFile[len(meta)+7:len(meta)+17])
                         except:
                              print("There is a file or folder with different format")
                     if meta == "D":
                         try:
                             number= int(thisFile[8:11])
                         except:
                             print("There is a file or folder with different format")
                     if not isNumber(str=number):
                         continue
                     if (os.path.splitext(thisFile)[-1].lower() != ext.lower()):
                         continue
                     validFilelist.sort()
                     validFilelist.append(thisFile)
                 if len(validFilelist)>0:
                     validFilelist = sorted(validFilelist,key=str.lower)
                     return validFilelist
                 return None
             def gettimeutcfromDirFilename(path,file):
                 dir_file= path+"/"+file
                 fp      = h5py.File(dir_file,'r')
                 epoc    = fp['Metadata'].get('utctimeInit')[()]
                 fp.close()
                 return epoc
             def getDatavaluefromDirFilename(path,file,value):
                 dir_file= path+"/"+file
                 fp      = h5py.File(dir_file,'r')
                 array    = fp['Data'].get(value)[()]
                 fp.close()
                 return array
             #·········· Velocidad de Pedestal·················
             w = input ("Ingresa velocidad de Pedestal:   ")
             w = 4
             w = float(w)
             #·········· Resolucion minimo en grados···········
             alfa = input ("Ingresa resolucion minima en grados:  ")
             alfa = 1
             alfa = float(alfa)
             #·········· IPP del Experimento ··················
             IPP  = input ("Ingresa el IPP del experimento:   ")
             IPP  = 0.0004
             IPP  = float(IPP)
             #·········· MODE ··················
             mode = input ("Ingresa el MODO del experimento T or F:   ")
             mode = "T"
             mode = str(mode)
             #·········· Tiempo en generar la resolucion min···
             #············ MCU ·· var_ang = w * (var_tiempo)···
             var_tiempo  = alfa/w
             #·········· Tiempo Equivalente en perfiles········
             #··········  var_tiempo =  IPP * ( num_perfiles )·
             num_perfiles = int(var_tiempo/IPP)
             #··········DATA PEDESTAL··························
-            dir_pedestal = "/home/developer/Downloads/Pedestal/P2021064"
+            dir_pedestal = "/home/developer/Downloads/Pedestal/P2021093"
             #·········· DATA ADQ······························
             if mode=="T":
-                dir_adq  = "/home/developer/Downloads/HDF5_TESTPP2/d2021064" # Time domain
+                dir_adq  = "/home/developer/Downloads/HDF5_TESTPP2V3/d2021093" # Time domain
             else:
                 dir_adq  = "/home/developer/Downloads/hdf5_test/d2021053"   # Frequency domain
             print( "Velocidad angular             :", w)
             print( "Resolucion minima en grados   :", alfa)
             print( "Numero de perfiles equivalente:", num_perfiles)
             print( "Mode                          :", mode)
             #············ First File·············
             list_pedestal = getfirstFilefromPath(path=dir_pedestal,meta="PE",ext=".hdf5")
             list_adq      = getfirstFilefromPath(path=dir_adq ,meta="D",ext=".hdf5")
             print("list_pedestal")
             #print(list_pedestal)
             print("list_adq")
             #print(list_adq)
             #sys.exit(0)
             #············ utc time ··············
             utc_pedestal= gettimeutcfromDirFilename(path=dir_pedestal,file=list_pedestal[0])
             utc_adq     = gettimeutcfromDirFilename(path=dir_adq     ,file=list_adq[0])
             print("utc_pedestal                  :",utc_pedestal)
             print("utc_adq                       :",utc_adq)
             #sys.exit(0)
             #·············Relacion:  utc_adq (+/-) var_tiempo*nro_file= utc_pedestal
             time_Interval_p   = 0.01
             n_perfiles_p      = 100 #muestras por achivo del pedestal
             if utc_adq>utc_pedestal:
                 nro_file = int((utc_adq - utc_pedestal)/(time_Interval_p*n_perfiles_p))
                 print("nro_file",nro_file)
                 ff_pedestal  = list_pedestal[nro_file]
                 print(ff_pedestal)
                 utc_pedestal = gettimeutcfromDirFilename(path=dir_pedestal,file=ff_pedestal)
                 print(utc_pedestal)
                 nro_key_p    = int((utc_adq-utc_pedestal)/time_Interval_p)
                 print(nro_key_p)
                 #sys.exit(0)
                 if utc_adq >utc_pedestal:
                     ff_pedestal  = ff_pedestal
                 else:
                     nro_file      = nro_file-1
                     ff_pedestal  = list_pedestal[nro_file]
                     utc_pedestal = gettimeutcfromDirFilename(path=dir_pedestal,file=ff_pedestal)
                 angulo       = getDatavaluefromDirFilename(path=dir_pedestal,file=ff_pedestal,value="azimuth")
                 nro_key_p    = int((utc_adq-utc_pedestal)/time_Interval_p)
                 print("nro_file                      :",nro_file)
                 print("name_file                     :",ff_pedestal)
                 print("utc_pedestal_file             :",utc_pedestal)
                 print("nro_key_p                     :",nro_key_p)
                 print("utc_pedestal_init             :",utc_pedestal+nro_key_p*time_Interval_p)
                 print("angulo_array                  :",angulo[nro_key_p])
             #4+25+25+25+21
             #while True:
             list_pedestal = getfirstFilefromPath(path=dir_pedestal,meta="PE",ext=".hdf5")
             list_adq      = getfirstFilefromPath(path=dir_adq ,meta="D",ext=".hdf5")
             nro_file       = nro_file #10
             nro_key_perfil = nro_key_p
             blocksPerFile  = 100##### aqui se cambia dependiendo de los blqoues por achivo en adq
             wr_path        = "/home/developer/Downloads/HDF5_WR/"
             # Lectura  de archivos de adquisicion para adicion de azimuth
             # factor de archivos
             #f_a_p = tiempo_file_1_adq/tiempo_file_1_ped=25/1 = 25
             tiempo_file_1_adq=25
             tiempo_file_1_ped=1
             f_a_p= int(tiempo_file_1_adq/tiempo_file_1_ped)
             for thisFile in range(len(list_adq)):
                 print("thisFileAdq",thisFile)
                 angulo_adq    = numpy.zeros(blocksPerFile)
                 tmp           = 0
                 for j in range(blocksPerFile):
                     iterador    = nro_key_perfil + f_a_p*(j-tmp)
                     #print("iterador",iterador)
                     if iterador < n_perfiles_p:
                         nro_file = nro_file
                     else:
                         nro_file = nro_file+1
                         dif      = blocksPerFile-(nro_key_perfil+f_a_p*(j-tmp-1))
                         tmp      = j
                         nro_key_perfil= f_a_p-dif
                         iterador = nro_key_perfil
                         #print(iterador)
                     print("nro_file",nro_file)
                     ff_pedestal  = list_pedestal[nro_file]
                     angulo       = getDatavaluefromDirFilename(path=dir_pedestal,file=ff_pedestal,value="azimuth")
                     angulo_adq[j]= angulo[iterador]
                 copyfile(dir_adq+"/"+list_adq[thisFile],wr_path+list_adq[thisFile])
                 fp      = h5py.File(wr_path+list_adq[thisFile],'a')
                 #grp     = fp.create_group("Pedestal")
                 grp     = fp['Metadata']
                 #sgrp    = grp.create_group('Pedestal')
                 dset    = grp.create_dataset("azimuth"  , data=angulo_adq)
                 fp.close()
                 print("Angulo",angulo_adq)
                 print("Angulo",len(angulo_adq))
                 nro_key_perfil=iterador + f_a_p
                 if nro_key_perfil<  n_perfiles_p:
                     nro_file = nro_file
                 else:
                     nro_file = nro_file+1
                     nro_key_perfil= nro_key_p

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