schain Commit - r1463:03ce684852b1 · Jicamarca Repository

fix en escritura y prueba de script con ploteo general

avaldezp -

r1463:03ce684852b1

parent child

Context file:

r1463:03ce684852b1

Collapse all files

schainpy/scripts/sophy_proc_test001.py created 644 +152 0

@@ -0,0 +1,152
	1	# SOPHY PROC script
	2	import os, sys, json, argparse
	3	import datetime
	4	import time
	5
	6	PATH = '/DATA_RM/DATA'
	7	# PATH = '/Users/jespinoza/workspace/data/'
	8	#PATH = '/home/roberto/DATA/data_WR_RHI/RHI'
	9	PATH = '/home/soporte/Downloads/data_WR_RHI'
	10
	11
	12	PARAM = {
	13	'P': {'name': 'dataPP_POWER', 'zmin': 35, 'zmax': 60, 'colormap': 'jet', 'label': 'Power', 'cb_label': 'dB'},
	14	'V': {'name': 'dataPP_DOP', 'zmin': -20, 'zmax': 20, 'colormap': 'seismic', 'label': 'Velocity', 'cb_label': 'm/s'},
	15	'RH': {'name': 'RhoHV_R', 'zmin': 0, 'zmax': 1, 'colormap': 'jet', 'label': 'CoeficienteCorrelacion', 'cb_label': '*'},
	16	'FD': {'name': 'PhiD_P', 'zmin': -180, 'zmax': 180, 'colormap': 'RdBu_r', 'label': 'Fase Diferencial', 'cb_label': 'º'},
	17	'ZD': {'name': 'Zdb_D', 'zmin': -20, 'zmax': 80, 'colormap': 'viridis', 'label': 'ReflectividadDiferencial', 'cb_label': 'dBz'},
	18	'Z': {'name': 'Zdb', 'zmin': -20, 'zmax': 60, 'colormap': 'viridis', 'label': 'Reflectividad', 'cb_label': 'dBz'},
	19	'W': {'name': 'Sigmav_W', 'zmin': -20, 'zmax': 60, 'colormap': 'viridis', 'label': 'AnchoEspectral', 'cb_label': 'hz'}
	20	}
	21
	22	def main(args):
	23
	24	experiment = args.experiment
	25	fp = open(os.path.join(PATH, experiment, 'experiment.conf'))
	26	conf = json.loads(fp.read())
	27
	28	ipp_km = conf['usrp_tx']['ipp']
	29	ipp = ipp_km * 2 /300000
	30	samp_rate = conf['usrp_rx']['sample_rate']
	31	axis = ['0' if x=='elevation' else '1' for x in conf['pedestal']['speed']] # AZIMUTH 1 ELEVACION 0
	32	speed_axis = conf['pedestal']['speed']
	33	steeps = conf['pedestal']['table']
	34	time_offset = args.time_offset
	35	parameters = args.parameters
	36	#start_date = experiment.split('@')[1].split('T')[0].replace('-', '/')
	37	start_date = '2022/04/22'
	38	end_date = start_date
	39	#start_time = experiment.split('@')[1].split('T')[1]
	40	start_time ='17:42:55'
	41	end_time = '23:59:59'
	42	max_index = int(samp_rateipp1e6 * args.range / 60) + int(samp_rateipp1e6 * 1.2 / 60)
	43	N = int(1/(speed_axis[0]*ipp)) # 1 GRADO DE RESOLUCION
	44	path = os.path.join(PATH, experiment, 'rawdata')
	45	path_ped = os.path.join(PATH, experiment, 'position')
	46	path_plots = os.path.join(PATH, experiment, 'plots')
	47	path_save = os.path.join(PATH, experiment, 'param')
	48
	49	dBmin = 35
	50	dBmax = 60
	51	Vmin = -20
	52	Vmax = 20
	53
	54
	55	from schainpy.controller import Project
	56
	57	project = Project()
	58	project.setup(id='1', name='Sophy', description='sophy proc')
	59
	60	reader = project.addReadUnit(datatype='DigitalRFReader',
	61	path=path,
	62	startDate=start_date,
	63	endDate=end_date,
	64	startTime=start_time,
	65	endTime=end_time,
	66	delay=0,
	67	online=0,
	68	walk=1,
	69	ippKm = ipp_km,
	70	getByBlock = 1,
	71	nProfileBlocks = N,
	72	)
	73
	74	voltage = project.addProcUnit(datatype='VoltageProc', inputId=reader.getId())
	75	op = voltage.addOperation(name='setH0')
	76	op.addParameter(name='h0', value='-1.2')
	77
	78	if args.range > 0:
	79	op = voltage.addOperation(name='selectHeights')
	80	op.addParameter(name='minIndex', value='0', format='int')
	81	op.addParameter(name='maxIndex', value=max_index, format='int')
	82
	83	op = voltage.addOperation(name='PulsePair_vRF', optype='other')
	84	op.addParameter(name='n', value=int(N), format='int')
	85
	86	proc = project.addProcUnit(datatype='ParametersProc', inputId=voltage.getId())
	87	#-----------------------new--------- variables polarimetricas---------------
	88	opObj10 = proc.addOperation(name="WeatherRadar")
	89	opObj10.addParameter(name='variableList',value='Reflectividad,ReflectividadDiferencial,CoeficienteCorrelacion,FaseDiferencial,VelocidadRadial,AnchoEspectral')
	90
	91
	92
	93	op = proc.addOperation(name='PedestalInformation')
	94	op.addParameter(name='path', value=path_ped, format='str')
	95	op.addParameter(name='interval', value='0.04', format='float')
	96	op.addParameter(name='time_offset', value=time_offset)
	97	#op.addParameter(name='axis', value=','.join(axis)) #Preguntar en pedestal si todos los elementos
	98	#de aqui son iguales, si lo fueran, que considere
	99	#el primero dato como el modo (PPI o RHI) y que ya
	100	#no pregunte por el modo porque este no cambia
	101
	102	for param in parameters:
	103	op = proc.addOperation(name='Block360_vRF4')
	104	#op.addParameter(name='axis', value=','.join(axis))
	105	op.addParameter(name='runNextOp', value=True)
	106	op.addParameter(name='attr_data', value=PARAM[param]['name'])
	107
	108	path_fig = '/AUTO{}km'.format(args.range)
	109	op = proc.addOperation(name='WeatherParamsPlot')
	110	op.addParameter(name='save', value=path_plots+path_fig, format='str')
	111	op.addParameter(name='save_period', value=-1)
	112	op.addParameter(name='show', value=args.show)
	113	op.addParameter(name='channels', value='(1,)')
	114	op.addParameter(name='zmin', value=PARAM[param]['zmin'])
	115	op.addParameter(name='zmax', value=PARAM[param]['zmax'])
	116	op.addParameter(name='attr_data', value=PARAM[param]['name'], format='str')
	117	op.addParameter(name='labels', value=[PARAM[param]['label']])
	118	op.addParameter(name='save_code', value=param)
	119	op.addParameter(name='cb_label', value=PARAM[param]['cb_label'])
	120	op.addParameter(name='colormap', value=PARAM[param]['colormap'])
	121
	122	if args.save:
	123	opObj10 = proc.addOperation(name='HDFWriter')
	124	opObj10.addParameter(name='path',value=path_save, format='str')
	125	opObj10.addParameter(name='Reset',value=True)
	126	opObj10.addParameter(name='setType',value='weather')
	127	opObj10.addParameter(name='blocksPerFile',value='1',format='int')
	128	opObj10.addParameter(name='metadataList',value='heightList,data_azi,data_ele')
	129	opObj10.addParameter(name='dataList',value=','.join([PARAM[param]['name'],'utctime']))
	130
	131	project.start()
	132
	133
	134	if __name__ == '__main__':
	135
	136	parser = argparse.ArgumentParser(description='Script to process SOPHy data.')
	137	parser.add_argument('experiment',
	138	help='Experiment name')
	139	parser.add_argument('--parameters', nargs='*', default=['P'],
	140	help='Variables to process: P, Z, V')
	141	parser.add_argument('--time_offset', default=0,
	142	help='Fix time offset')
	143	parser.add_argument('--range', default=0, type=int,
	144	help='Max range to plot')
	145	parser.add_argument('--save', action='store_true',
	146	help='Create output files')
	147	parser.add_argument('--show', action='store_true',
	148	help='Show matplotlib plot.')
	149
	150	args = parser.parse_args()
	151	print (args)
	152	main(args)

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

             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"
                     self.utcoffset = 0
                 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.utcoffset
                     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 = {}
                     if self.description:
                         for key, value in self.description['Metadata'].items():
                             meta[key] = self.fp[value][()]
                     else:
                         grp = self.fp['Metadata']
                         for name in grp:
                             meta[name] = grp[name][()]
                     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):
                                     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][()])
                                     data[key] = numpy.array(array)
                             elif isinstance(value, list):
                                 array = []
                                 for ch in value:
                                     array.append(self.fp[ch][()])
                                 data[key] = numpy.array(array)
                     else:
                         grp = self.fp['Data']
                         for name in grp:
                             if isinstance(grp[name], h5py.Dataset):
                                 array = grp[name][()]
                             elif isinstance(grp[name], h5py.Group):
                                 array = []
                                 for ch in grp[name]:
                                     array.append(grp[name][ch][()])
                                 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
                 last_Azipos = None
                 last_Elepos = None
                 mode       = None
                 #-----------------------
                 Typename = None
                 def __init__(self):
                     Operation.__init__(self)
                     return
                 def set_kwargs(self, **kwargs):
                     for key, value in kwargs.items():
                         setattr(self, key, value)
                 def set_kwargs_obj(self,obj, **kwargs):
                     for key, value in kwargs.items():
                         setattr(obj, key, value)
                 def generalFlag(self):
                     ####rint("GENERALFLAG")
                     if self.mode== "weather":
                         if self.last_Azipos == None:
                             tmp = self.dataOut.azimuth
                             ####print("ang azimuth writer",tmp)
                             self.last_Azipos = tmp
                             flag = False
                             return flag
                         ####print("ang_azimuth writer",self.dataOut.azimuth)
                         result = self.dataOut.azimuth - self.last_Azipos
                         self.last_Azipos = self.dataOut.azimuth
                         if result<0:
                             flag = True
                             return flag
                 def generalFlag_vRF(self):
                     ####rint("GENERALFLAG")
                     try:
                         self.dataOut.flagBlock360Done
                         return self.dataOut.flagBlock360Done
                     except:
                         return 0
                 def setup(self, path=None, blocksPerFile=10, metadataList=None, dataList=None, setType=None, description=None,type_data=None,**kwargs):
                     self.path = path
                     self.blocksPerFile = blocksPerFile
                     self.metadataList = metadataList
                     self.dataList = [s.strip() for s in dataList]
                     self.setType = setType
                     if self.mode == "weather":
                         self.setType = "weather"
                         self.set_kwargs(**kwargs)
                         self.set_kwargs_obj(self.dataOut,**kwargs)
                     self.description = description
                     self.type_data=type_data
                     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={},mode= None,type_data=None,Reset = False,**kwargs):
                     if Reset:
                         self.isConfig = False
                         self.closeFile()
                         self.lastTime = None
                         self.blockIndex = 0
                     self.dataOut = dataOut
                     self.mode    = mode
                     self.var = dataList[0]
                     if not(self.isConfig):
                         self.setup(path=path, blocksPerFile=blocksPerFile,
                                    metadataList=metadataList, dataList=dataList,
                                    setType=setType, description=description,type_data=type_data,**kwargs)
                         self.isConfig = True
                         self.setNextFile()
                     self.putData()
                     return
                 def setNextFile(self):
                     ###print("HELLO WORLD--------------------------------")
                     ext = self.ext
                     path = self.path
                     setFile = self.setFile
                     type_data = self.type_data
                     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
                     ###print("**************************",self.setType)
                     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 )
                     elif self.setType == "weather":
                         if self.var.lower() == 'Zdb'.lower():
                             wr_type = 'Z'
                         elif self.var.lower() == 'Zdb_D'.lower():
                             wr_type = 'D'
                         elif self.var.lower() == 'PhiD_P'.lower():
                             wr_type = 'P'
                         elif self.var.lower() == 'RhoHV_R'.lower():
                             wr_type = 'R'
                         elif self.var.lower() == 'velRadial_V'.lower():
                             wr_type = 'V'
                         elif self.var.lower() == 'Sigmav_W'.lower():
                             wr_type = 'S'
                         elif self.var.lower() == 'dataPP_POWER'.lower():
                             wr_type = 'Pow'
                         elif self.var.lower() == 'dataPP_DOP'.lower():
                             wr_type = 'Dop'
                         #Z_SOPHy_El10.0_20200505_14:02:15.h5
                         #Z_SOPHy_Az40.0_20200505_14:02:15.h5
                         if self.dataOut.flagMode == 1: #'AZI' #PPI
                             ang_type = 'El'
                             len_aux = int(self.dataOut.data_ele.shape[0]/4)
-                            mean = numpy.mean(self.dataOut.data_ele[len_aux:-len:aux])
+                            mean = numpy.mean(self.dataOut.data_ele[len_aux:-len_aux])
                             ang_    = round(mean,1)
                         elif self.dataOut.flagMode == 0: #'ELE' #RHI
                             ang_type = 'Az'
                             len_aux = int(self.dataOut.data_azi.shape[0]/4)
-                            mean = numpy.mean(self.dataOut.data_azi[len_aux:-len:aux])
+                            mean = numpy.mean(self.dataOut.data_azi[len_aux:-len_aux])
                             ang_    = round(mean,1)
                         file = '%s%s%s%2.1f%s%2.2d%2.2d%2.2d%s%2.2d%2.2d%2.2d%s' % (wr_type,
                                                        '_SOPHy_',
                                                        ang_type,
                                                        ang_,
                                                        '_',
                                                        timeTuple.tm_year,
                                                        timeTuple.tm_mon,
                                                        timeTuple.tm_mday,
                                                        '_',
                                                        timeTuple.tm_hour,
                                                        timeTuple.tm_min,
                                                        timeTuple.tm_sec,
                                                        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
                     #print("filename",self.filename)
                     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():# or self.generalFlag_vRF():
                         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()

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