def LoadRadar(self): ''' DESCRIPTION: This method loads the radar information. _________________________________________________________________ INPUT: ''' PathRadar = '/Users/DGD042/Documents/Est_Information/SIATA/Radar/01_nc/PPIVol/' PathRadarRHI = '/Users/DGD042/Documents/Est_Information/SIATA/Radar/01_nc/RHIVol/' # --------------------- # Radar Files # --------------------- self.DateRI = self.DateI+timedelta(0,5*60*60) self.DateRE = self.DateE+timedelta(0,5*60*60) DateR = '%04i%02i/'%(self.DateRI.year,self.DateRE.month) self.PathRadar = PathRadar+DateR Files = gl.glob(PathRadar+DateR+'*.gz') if len(Files) == 0: self.ShowError('LoadRadar','Medellin','No Radar PPIVol Files Found') self.Files = gl.glob(PathRadar+DateR+'*.gz') self.RadarDates = np.array([i[-32:-32+8]+i[-32+9:-32+8+5] for i in Files]) self.RadarDatesP = DUtil.Dates_str2datetime(self.RadarDates,Date_Format='%Y%m%d%H%M') # --------------------- # Radar Files RHI # --------------------- if self.flagRHI: self.DateRIRHI = self.DateI+timedelta(0,5*60*60) self.DateRERHI = self.DateE+timedelta(0,5*60*60) DateR = '%04i%02i/'%(self.DateRIRHI.year,self.DateRERHI.month) self.PathRadarRHI = PathRadarRHI+DateR Files = gl.glob(PathRadarRHI+DateR+'*.gz') if len(Files) == 0: self.ShowError('LoadRadar','Medellin','No Radar RHIVol Files Found') self.FilesRHI = gl.glob(PathRadarRHI+DateR+'*.gz') self.RadarRHIDates = np.array([i[-32:-32+8]+i[-32+9:-32+8+5] for i in Files]) self.RadarRHIDatesP = DUtil.Dates_str2datetime(self.RadarRHIDates,Date_Format='%Y%m%d%H%M') # --------------------- # Dates # --------------------- xi = np.where(self.RadarDatesP == self.DateRI)[0] while len(xi) == 0: xi = np.where(self.RadarDatesP == self.DateRI+timedelta(0,60))[0] xf = np.where(self.RadarDatesP == self.DateRE)[0] while len(xf) == 0: xf = np.where(self.RadarDatesP == self.DateRE-timedelta(0,60))[0] self.ArchRadar = self.Files[xi:xf+1] self.RadarDates = self.RadarDates[xi:xf+1] self.RadarDatesP = DUtil.Dates_str2datetime(self.RadarDates,Date_Format='%Y%m%d%H%M') if self.flagRHI: self.ArchRadarRHI = self.FilesRHI[xi:xf+1] self.RadarRHIDates = self.RadarRHIDates[xi:xf+1] self.RadarRHIDatesP = DUtil.Dates_str2datetime(self.RadarRHIDates,Date_Format='%Y%m%d%H%M') return
def __init__(self,Dates,Date_Format=None,flagQuick=False): ''' DESCRIPTION: This class uses data from dates and converts them into datetime or string data, having all the data packed in one object. ''' # ----------------- # Error managment # ----------------- assert isinstance(Dates[0],str) or isinstance(Dates[0],datetime) or isinstance(Dates[0],date) if isinstance(Dates[0],str): self.datetime = DUtil.Dates_str2datetime(Dates,Date_Format=Date_Format,flagQuick=flagQuick) self.str = DUtil.Dates_datetime2str(self.datetime,Date_Format=None) if isinstance(Dates[0],datetime) or isinstance(Dates[0],date): self.datetime = Dates self.str = DUtil.Dates_datetime2str(Dates) return
def __init__(self,DateI,DateE,endingmat='',Var='',flagRHI=False): ''' ''' # ---------------- # Error Managment # ---------------- if not(isinstance(endingmat,str)): self.ShowError('__init__','Medellin','endingmat must be a string') # ---------------- # Paths # ---------------- # ---------------- # Constants # ---------------- self.ImgFolder = {'Medellin':'Medellin/Cases'+endingmat+'/'} Labels = ['ID','Name','Latitud','Longitud'] self.DateI = DateI self.DateE = DateE lenData = int((self.DateE-self.DateI).seconds/60) self.DatesSt = [DateI] for iEv in range(lenData): self.DatesSt.append(self.DatesSt[-1]+timedelta(0,60)) self.DatesSt = np.array(self.DatesSt) DatesStr = DUtil.Dates_datetime2str([DateI],Date_Format='%Y%m')[0] self.PathImg = 'Tesis_MscR/02_Docs/01_Tesis_Doc/Kap5/Img/Medellin/Cases_'+Var+'/'+DatesStr+'/' self.VarA = Var self.flagRHI = flagRHI # ---------------- # Load Information # ---------------- self.SC = BPL.Scatter_Gen(DataBase='Medellin', endingmat=endingmat,PathImg=self.PathImg) # --------------------- # Station information # --------------------- self.ID = self.SC.ID self.St_Info = {} for iSt,St in enumerate(self.ID): self.St_Info[St] = {} for Lab in Labels: self.St_Info[St][Lab] = self.SC.StInfo['Medellin'][Lab][iSt] self.St_Info[St]['CodesNames'] = self.SC.StInfo['Medellin']['ID'][iSt]+ ' ' + self.SC.StInfo['Medellin']['Name'][iSt] return
def CompD(Dates,V,dtm=None): ''' DESCRIPTION: This function takes a data series and fill the missing dates with nan values, It would fill the entire year. _______________________________________________________________________ INPUT: :param Dates: A list or ndarray, Data date, it must be a string vector or a date or datetime vector. :param V: A list or ndarray, Variable that wants to be filled. :param dtm: A list or ndarray, Time delta for the full data, if None it would use the timedelta from the 2 values of the original data. _______________________________________________________________________ OUTPUT: :return DateC: A ndarray, Comlete date string vector. :return VC: A ndarray, Filled data values. :return DateN: A ndarray, Complete date Python datetime vector. ''' V = np.array(V) Dates = np.array(Dates) # --------------------- # Error managment # --------------------- if isinstance(Dates[0],str) == False and isinstance(Dates[0],date) == False and isinstance(Dates[0],datetime) == False: utl.ShowError('CompD','EDSM','not expected format in dates') if len(Dates) != len(V): utl.ShowError('CompD','EDSM','Date and V are different length') if dtm != None and isinstance(dtm,timedelta) == False: utl.ShowError('CompD','EDSM','Bad dtm format') # Eliminate the errors in February if isinstance(Dates[0],str): lenDates = len(Dates) Dates2 = np.array([i[:10] for i in Dates]) for iY,Y in enumerate(range(int(Dates2[0][:4]),int(Dates2[-1][:4]))): Fi = date(Y,2,1) Ff = date(Y,3,1) Dif = (Ff-Fi).days if Dif == 28: x = np.where(Dates2 == '%s/02/29' %(Y)) Dates = np.delete(Dates,x) V = np.delete(V,x) x = np.where(Dates2 == '%s/02/30' %(Y)) Dates = np.delete(Dates,x) V = np.delete(V,x) # --------------------- # Dates Calculations # --------------------- # Original Dates if isinstance(Dates[0],str): DatesO = DUtil.Dates_str2datetime(Dates) else: DatesO = Dates if dtm == None: dtm = DatesO[1]-DatesO[0] # Complete Dates if isinstance(DatesO[0],datetime): DateI = datetime(DatesO[0].year,1,1,0,0) DateE = datetime(DatesO[-1].year,12,31,23,59) DatesN = DUtil.Dates_Comp(DateI,DateE,dtm=dtm) else: DateI = date(DatesO[0].year,1,1) DateE = date(DatesO[-1].year,12,31) DatesN = DUtil.Dates_Comp(DateI,DateE,dtm=dtm) # Filled data VC = np.empty(len(DatesN))*np.nan DatesN = np.array(DatesN) DatesO = np.array(DatesO) V = np.array(V) # x = DatesN.searchsorted(DatesO) x = np.searchsorted(DatesN,DatesO) try: VC[x] = V except ValueError: VC = np.array(['' for i in range(len(DatesN))]).astype('<U20') VC[x] = V DatesC = DUtil.Dates_datetime2str(DatesN) Results = {'DatesC':DatesC,'DatesN':DatesN,'VC':VC} return Results
def Ca_E(FechaC,V1C,dt=24,escala=1,op='mean',flagMa=False,flagDF=False,flagNaN=True): ''' DESCRIPTION: Con esta función se pretende cambiar de escala temporal los datos, agregándolos a diferentes escalas temporales, se deben insertar series completas de tiempo. Los datos faltantes deben estar como NaN. _______________________________________________________________________ INPUT: + FechaC: Fecha de los datos organizada como 'año/mes/dia - HHMM' los '/' pueden ser substituidos por cualquier caracter. Debe ser un vector string y debe tener años enteros. + V1C: Variable que se desea cambiar de escala temporal. + dt: Delta de tiempo para realizar la agregación, depende de la naturaleza de los datos. Si se necesitan datos mensuales, el valor del dt debe ser 1. + escala: Escala a la cual se quieren pasar los datos: -1: de minutal. 0: horario. 1: a diario. 2: a mensual, es necesario llevarlo primero a escala diaria. + op: Es la operación que se va a llevar a cabo para por ahora solo responde a: 'mean': para obtener el promedio. 'sum': para obtener la suma. + flagMa: Para ver si se quieren los valores máximos y mínimos. True: Para obtenerlos. False: Para no calcularos. + flagDF: Para ver si se quieren los datos faltantes por mes, solo funciona en los datos que se dan diarios. True: Para calcularlos. False: Para no calcularos. + flagNaN: Flag to know if the user wants to include the calculations with low data. _______________________________________________________________________ OUTPUT: - FechaEs: Nuevas fechas escaladas. - FechaNN: Nuevas fechas escaladas como vector fechas. - VE: Variable escalada. - VEMax: Vector de máximos. - VEMin: Vector de mínimos. ''' # Se desactivan los warnings en este codigo para que corra más rápido, los # warnings que se generaban eran por tener realizar promedios de datos NaN # no porque el código tenga un problema en los cálculos. warnings.filterwarnings('ignore') if escala > 2: utl.ShowError('EMSD','Ca_E','Todavía no se han programado estas escalas') # ------------------------------------------- # Inicialización de variables # ------------------------------------------- # Se inicializan las variables que se utilizarán FechaNN = ["" for k in range(1)] FechaEs = ["" for k in range(1)] VE = [] VEMax = [] VEMin = [] NF = [] # Porcentaje de datos faltantes NNF = [] # Porcentaje de datos no faltantes rr = 0 Oper = {'sum':np.nansum,'mean':np.nanmean} # ------------------------------------------- # Vector de fechas # ------------------------------------------- # Se toman los años yeari = int(FechaC[0][0:4]) # Año inicial yearf = int(FechaC[len(FechaC)-1][0:4]) # Año final Sep = FechaC[0][4] # Separador de la Fecha if isinstance(FechaC[0],str): DatesO = DUtil.Dates_str2datetime(FechaC) else: DatesO = FechaC # Los años se toman para generar el output de FechasEs if escala == -1: DateI = datetime(DatesO[0].year,1,1,0,0) DateE = datetime(DatesO[-1].year,12,31,23,59) dtm = timedelta(0,dt*60) FechaNN = DUtil.Dates_Comp(DateI,DateE,dtm=dtm) FechaEs = DUtil.Dates_datetime2str(FechaNN) elif escala == 0: DateI = datetime(DatesO[0].year,1,1,0,0) DateE = datetime(DatesO[-1].year,12,31,23,59) dtm = timedelta(0,60*60) FechaNN = DUtil.Dates_Comp(DateI,DateE,dtm=dtm) FechaEs = DUtil.Dates_datetime2str(FechaNN) elif escala == 1: # Para datos horarios o diarios for result in perdelta(date(int(yeari), 1, 1), date(int(yearf)+1, 1, 1), timedelta(days=1)): FR = result.strftime('%Y'+Sep+'%m'+Sep+'%d') # Fecha if escala == 0: for i in range(0,24): if rr == 0: FechaNN[0] = result if i < 10: FechaEs[rr] = FR + '-0' +str(i)+'00' else: FechaEs[rr] = FR + '-' +str(i)+'00' else: FechaNN.append(result) if i < 10: FechaEs.append(FR + '-0' +str(i)+'00') else: FechaEs.append(FR + '-' +str(i)+'00') rr += 1 # Se suman las filas elif escala == 1: if rr == 0: FechaNN[0] = result FechaEs[rr] = FR else: FechaNN.append(result) FechaEs.append(FR) rr += 1 if escala == 2: x = 0 for i in range(int(yeari),int(yearf)+1): for j in range(1,13): if i == int(yeari) and j == 1: FechaNN[0] = date(i,j,1) FechaEs[0] = FechaNN[0].strftime('%Y'+Sep+'%m') else: FechaNN.append(date(i,j,1)) FechaEs.append(FechaNN[x].strftime('%Y'+Sep+'%m')) x += 1 # ------------------------------------------- # Cálculo del escalamiento # ------------------------------------------- dtt = 0 # Contador de la diferencia if op == 'mean': if escala == 0 or escala == -1 or escala == 1: # Ciclo para realizar el agregamiento de los datos for i in range(0,len(V1C),dt): dtt = dtt + dt # Se aumenta el número de filas en el contador q = np.isnan(V1C[i:dtt]) qq = sum(q) qYes = sum(~np.isnan(V1C[i:dtt])) if (qq > dt*0.30 and flagNaN) or qYes == 0: VE.append(np.nan) if flagMa == True: VEMax.append(np.nan) VEMin.append(np.nan) else: try: VE.append(float(np.nanmean(V1C[i:dtt]))) except ValueError: VE.append(np.nan) if flagMa == True: try: VEMax.append(float(np.nanmax(V1C[i:dtt]))) except ValueError: VEMax.append(np.nan) try: VEMin.append(float(np.nanmin(V1C[i:dtt]))) except ValueError: VEMin.append(np.nan) elif op == 'sum': if escala == 0 or escala == -1 or escala == 1: # Ciclo para realizar el agregamiento de los datos for i in range(0,len(V1C),dt): dtt = dtt + dt # Se aumenta el número de filas en el contador q = np.isnan(V1C[i:dtt]) qq = sum(q) qYes = sum(~np.isnan(V1C[i:dtt])) if (qq > dt*0.30 and flagNaN) or qYes == 0: VE.append(np.nan) if flagMa == True: VEMax.append(np.nan) VEMin.append(np.nan) else: try: VE.append(float(np.nansum(V1C[i:dtt]))) except ValueError: VE.append(np.nan) if flagMa == True: try: VEMax.append(float(np.nanmax(V1C[i:dtt]))) except ValueError: VEMax.append(np.nan) try: VEMin.append(float(np.nanmin(V1C[i:dtt]))) except ValueError: VEMin.append(np.nan) if escala == 2: YearMonthData = np.array([str(i.year)+'/'+str(i.month) for i in DatesO]) YearMonth = np.array([str(date(i,j,1).year)+'/'+str(date(i,j,1).month) for i in range(int(yeari),int(yearf)+1) for j in range(1,13)]) VE = np.empty(YearMonth.shape)*np.nan VEMax = np.empty(YearMonth.shape)*np.nan VEMin = np.empty(YearMonth.shape)*np.nan NF = np.empty(YearMonth.shape)*np.nan NNF = np.empty(YearMonth.shape)*np.nan for iYM, YM in enumerate(YearMonth): x = np.where(YearMonthData == YM)[0] if len(x) != 0: q = sum(~np.isnan(V1C[x])) NF[iYM] = (q/len(x)) NNF[iYM] = (1-NF[-1]) if q >= round(len(x)*0.7,0) and flagNaN: VE[iYM] = Oper[op](V1C[x]) VEMax[iYM] = np.nanmax(V1C[x]) VEMin[iYM] = np.nanmin(V1C[x]) # ------------------------------------------- # Se dan los resultados # ------------------------------------------- if flagMa == True: if flagDF: return np.array(FechaEs), np.array(FechaNN), np.array(VE), np.array(VEMax), np.array(VEMin), np.array(NF),np.array(NNF) else: return np.array(FechaEs), np.array(FechaNN), np.array(VE), np.array(VEMax), np.array(VEMin) elif flagMa == False: if flagDF: return np.array(FechaEs), np.array(FechaNN), np.array(VE),np.array(NF),np.array(NNF) else: return np.array(FechaEs), np.array(FechaNN), np.array(VE)
def CompDC(Dates,V,DateI,DateE,dtm=None): ''' DESCRIPTION: This function completes or cut data from specific dates. _____________________________________________________________________ INPUT: :param Dates: Data date, it must be a string like this 'Year/month/day' the separator '/' could be change with any character. It must be a string vector or a date or datetime vector. :param VC: Variable. :param DateI: Initial Date in date or datetime format. :param DateE: Final Date in date or datetime format. :param dtm: Time delta for the full data, if None it would use the timedelta from the 2 values of the original data _____________________________________________________________________ OUTPUT: :return Results: A dict, Dictionary with the following results. DatesC: Complete date string vector. V1C: Filled data values. DatesN: Complete date Python datetime vector. ''' V = np.array(V) Dates = np.array(Dates) # --------------------- # Error managment # --------------------- if isinstance(Dates[0],str) == False and isinstance(Dates[0],date) == False and isinstance(Dates[0],datetime) == False: Er = utl.ShowError('CompD','EDSM','Bad format in dates') raise Er if len(Dates) != len(V): Er = utl.ShowError('CompD','EDSM','Date and V are different length') raise Er if dtm != None and isinstance(dtm,timedelta) == False: Er = utl.ShowError('CompD','EDSM','Bad dtm format') raise Er # --------------------- # Dates Calculations # --------------------- # Original Dates if isinstance(Dates[0],str): DatesO = DUtil.Dates_str2datetime(Dates) else: DatesO = Dates if dtm == None: dtm = DatesO[1]-DatesO[0] DatesN = DUtil.Dates_Comp(DateI,DateE,dtm=dtm) # ------------------------------------------- # Data Extraction # ------------------------------------------- # Filled data if isinstance(V[0],str): VC = (np.empty(len(DatesN))*np.nan).astype(str) else: VC = (np.empty(len(DatesN))*np.nan) DatesN = np.array(DatesN) DatesO = np.array(DatesO) for iF,F in enumerate(DatesO): x = np.where(DatesN == F)[0] if len(x) == 1: VC[x] = V[iF] elif len(x) > 1: VC[x[0]] = V[iF] DatesC = DUtil.Dates_datetime2str(DatesN) Results = {'DatesC':DatesC,'DatesN':DatesN,'VC':VC} return Results
def EventsSeriesGen(self,ax,DatesEv,Data,DataV,DataKeyV,DataKey=None, PathImg='',Name='',NameArch='', GraphInfo={'ylabel':['Precipitación [mm]'],'color':['b'],'label':['Precipitación']}, GraphInfoV={'color':['-.b'],'label':['Inicio del Evento']}, flagBig=False,vm={'vmax':[],'vmin':[]},Ev=0,flagV=True, flagAverage=False,dt=1,Date='',flagEvent=False): ''' DESCRIPTION: Esta función realiza los gráficos de los diferentes eventos solamente de los eventos de precipitación. _______________________________________________________________________ INPUT: :param DatesEv: A ndarray, Dates of the events. :param Data: A dict, Diccionario con las variables que se graficarán. :param DataV: A dict, Diccionario con las líneas verticales estos deben ser fechas en formato datetime. :param DataKeyV: A list, Lista con keys de los valores verticales. ''' # Se organizan las fechas if flagAverage: H = int(len(DatesEv)/2) FechaEvv = np.arange(-H,H,1) FechaEvv = FechaEvv*dt/60 else: if not(isinstance(DatesEv[0],datetime)): FechaEvv = DUtil.Dates_str2datetime(DatesEv) else: FechaEvv = DatesEv if DataKey is None: flagSeveral = False elif len(DataKey) >= 1: flagSeveral = True if len(vm['vmax']) == 0 and len(vm['vmin']) == 0: flagVm = False else: flagVm = True if flagVm: if len(vm['vmax']) >= 1 and len(vm['vmin']) >= 1: flagVmax = True flagVmin = True elif len(vm['vmax']) >= 1: flagVmax = True flagVmin = False elif len(vm['vmin']) >= 1: flagVmax = False flagVmin = True # ------------------------- # Se grafican los eventos # ------------------------- # Se grafican las dos series # fH=30 # Largo de la Figura # fV = fH*(2/3) # Ancho de la Figura lensize=17 plt.rcParams.update({'font.size': 15,'font.family': 'sans-serif'\ ,'font.sans-serif': 'Arial Narrow'\ ,'xtick.labelsize': 13,'xtick.major.size': 6,'xtick.minor.size': 4\ ,'xtick.major.width': 1,'xtick.minor.width': 1\ ,'ytick.labelsize': 15,'ytick.major.size': 12,'ytick.minor.size': 4\ ,'ytick.major.width': 1,'ytick.minor.width': 1\ ,'axes.linewidth':1\ ,'grid.alpha':0.1,'grid.linestyle':'-'}) # plt.tick_params( # axis='x', # changes apply to the x-axis # which='both', # both major and minor ticks are affected # bottom='off', # ticks along the bottom edge are off # top='off', # ticks along the top edge are off # labelbottom='off') plt.xticks(rotation=45) # f = plt.figure(figsize=DM.cm2inch(fH,fV)) # ax = host_subplot(111, axes_class=AA.Axes) ax.tick_params(axis='x',which='both',bottom='on',top='off',\ labelbottom='off',direction='out') ax.tick_params(axis='y',which='both',left='on',right='off',\ labelleft='on') ax.tick_params(axis='y',which='major',direction='inout') if flagSeveral: if len(DataKey) >= 1: DataP = Data[DataKey[0]] else: DataP = Data # Se grafica el gráfico principal ax.plot(FechaEvv,DataP,color=GraphInfo['color'][0],label=GraphInfo['label'][0]) if not(flagAverage): ax.axis["bottom"].major_ticklabels.set_rotation(30) ax.axis["bottom"].major_ticklabels.set_ha("right") ax.axis["bottom"].label.set_pad(30) ax.axis["bottom"].format_xdata = mdates.DateFormatter('%H%M') # ax.axis["bottom"].set_visible(False) # ax.axes().get_xaxis().set_visible(False) ax.axis["left"].label.set_color(color=GraphInfo['color'][0]) ax.set_ylabel(GraphInfo['ylabel'][0]) # Se escala el eje if flagVm: if (flagVmax and flagVmin) and (not(vm['vmin'][0] is None) and not(vm['vmax'][0] is None)): ax.set_ylim([vm['vmin'][0],vm['vmax'][0]]) elif flagVmax and not(vm['vmax'][0] is None): ax.set_ylim(ymax=vm['vmax'][0]) elif flagVmin and not(vm['vmin'][0] is None): ax.set_ylim(ymin=vm['vmin'][0]) yTL = ax.yaxis.get_ticklocs() # List of Ticks in y # Se grafican las líneas verticales if flagV: for ilab,lab in enumerate(DataKeyV): ax.plot([DataV[lab][0],DataV[lab][0]],[yTL[0],yTL[-1]], GraphInfoV['color'][ilab],label=GraphInfoV['label'][ilab]) # Se organizan los ejes MyL = (yTL[1]-yTL[0])/5 # minorLocatory value minorLocatory = MultipleLocator(MyL) ax.yaxis.set_minor_locator(minorLocatory) # Se realizan los demás gráficos if flagSeveral: axi = [ax.twinx() for i in range(len(DataKey)-1)] for ilab,lab in enumerate(DataKey): if ilab >= 1: axi[ilab-1].plot(FechaEvv,Data[lab],color=GraphInfo['color'][ilab], label=GraphInfo['label'][ilab]) axi[ilab-1].set_ylabel(GraphInfo['ylabel'][ilab]) if flagVm and len(vm['vmax']) > 1: if (not(vm['vmin'][ilab] is None) and not(vm['vmax'][ilab] is None)): axi[ilab-1].set_ylim([vm['vmin'][ilab],vm['vmax'][ilab]]) elif not(vm['vmax'][ilab] is None): axi[ilab-1].set_ylim(ymax=vm['vmax'][ilab]) elif not(vm['vmin'][ilab] is None): axi[ilab-1].set_ylim(ymin=vm['vmin'][ilab]) if ilab == 2: offset = 60 new_fixed_axis = axi[ilab-1].get_grid_helper().new_fixed_axis axi[ilab-1].axis["right"] = new_fixed_axis(loc="right", axes=axi[ilab-1], offset=(offset, 0)) axi[ilab-1].axis["right"].label.set_color(color=GraphInfo['color'][ilab]) elif ilab == 3: # axi[ilab-1].spines['right'].set_position(('axes',-0.25)) offset = -60 new_fixed_axis = axi[ilab-1].get_grid_helper().new_fixed_axis axi[ilab-1].axis["right"] = new_fixed_axis(loc="left", axes=axi[ilab-1], offset=(offset, 0)) axi[ilab-1].axis["right"].label.set_color(color=GraphInfo['color'][ilab]) else: offset = 0 new_fixed_axis = axi[ilab-1].get_grid_helper().new_fixed_axis axi[ilab-1].axis["right"] = new_fixed_axis(loc="right", axes=axi[ilab-1], offset=(offset, 0)) axi[ilab-1].axis["right"].label.set_color(color=GraphInfo['color'][ilab]) # Se organizan los ejes yTL = axi[ilab-1].yaxis.get_ticklocs() # List of Ticks in y MyL = (yTL[1]-yTL[0])/5 # minorLocatory value minorLocatory = MultipleLocator(MyL) axi[ilab-1].yaxis.set_minor_locator(minorLocatory) axi[ilab-1].format_xdata = mdates.DateFormatter('%H%M') ax.set_title(Name) return
def LoadData(self,Station=None,flagComplete=True,dt=1): ''' DESCRIPTION: This function loads the data of a station and compiles it in a dictionary. ___________________________________________________________________ INPUT: :param Station: A str, List with the stations that would be extracted. :param flagComplete: A boolean, flag to determine if completes the data ''' self.flagComplete = flagComplete self.Station = Station # ------------------------- # Error Managment # ------------------------- # ------------------------- # Stations # ------------------------- # ------------------------- # Parameters # ------------------------- DataBase = {'DataBaseType':'txt','deli':self.deli, 'colStr':None,'colData':None,'row_skip':1,'flagHeader':True, 'rowH':0,'row_end':0,'str_NaN':'','num_NaN':None, 'dtypeData':float} LabelsH = ['H','maxH','minH'] LabelsD = ['D','NF', 'NNF', 'maxD', 'M', 'minM', 'maxM', 'minD'] self.LabelsH = LabelsH self.LabelsD = LabelsD # ------------------------- # Verify Headers # ------------------------- # Headers Headers = np.genfromtxt(self.Arch[Station][0],dtype=str,skip_header=0,delimiter=self.deli,max_rows=1) # Verify colStr data colStr = [] LabStrNo = [] LabStrYes = [] for lab in self.LabelsStr: x = np.where(Headers == lab)[0] if len(x) > 0: colStr.append(x[0]) LabStrYes.append(lab) else: LabStrNo.append(lab) DataBase['colStr'] = tuple(colStr) # Verify colData data colData = [] LabDataNo = [] LabDataYes = [] for lab in self.LabelsData: x = np.where(Headers == lab)[0] if len(x) > 0: colData.append(x[0]) LabDataYes.append(lab) else: LabDataNo.append(lab) self.LabStrYes = LabDataYes DataBase['colData'] = tuple(colData) # ------------------------- # Extract information # ------------------------- EM = EMSD() for iar,ar in enumerate(self.Arch[Station]): try: R = EM.Open_Data(ar,DataBase=DataBase) except ValueError: print('Error document data:',ar) continue if iar == 0: Data = R else: for iLab,Lab in enumerate(LabStrYes): Data[Lab] = np.hstack((Data[Lab],R[Lab])) for iLab,Lab in enumerate(LabDataYes): try: Data[Lab] = np.hstack((Data[Lab],R[Lab])) except KeyError: Data[Lab] = np.hstack((Data[Lab],np.empty(R[LabDataYes[0]].shape)*np.nan)) # for Lab in LabStrNo: # R[Lab] = np.array(['nan' for i in len(R['Time'])]) # for Lab in LabDataNo: # R[Lab] = np.array([np.nan for i in len(R['Time'])]) # DatesS = [i[:16] for i in Data['Time']] DatesS = Data['Time'] Dates = DUtil.Dates_str2datetime(DatesS,Date_Format='%Y-%m-%d %H:%M:%S') Data.pop('Time',None) # ------------------------- # Data Completion # ------------------------- LabelsHmat = [] LabelsDmat = [] # Data in years DataC = dict() DataCC = dict() # Se llenan los datos DataH = dict() # Datos Horarios DataD = dict() # Datos Diarios self.DatesC = dict() self.DatesD = dict() # Fechas diarias for iLab,Lab in enumerate(LabDataYes): VC = DMan.CompD(Dates,Data[Lab],dtm=timedelta(0,60)) # Precipitation corrected if Lab == 'HourlyPrecipMM': VC['VC'] = VC['VC']*5/60 if iLab == 0: DatesC = VC['DatesC'] DataC[self.LabDataSave[Lab]] = VC['VC'] # Se pasa la información a cada 5 minutos DatesCC,DatesCN,DataCC[self.LabDataSave[Lab]] = DMan.Ca_E(DatesC, DataC[self.LabDataSave[Lab]],dt=dt,escala=-1, op=self.LabDataOper[Lab],flagNaN=False) # Data Eliminations if self.ElimOver[self.LabDataSave[Lab]] != None: DataCC[self.LabDataSave[Lab]][DataCC[self.LabDataSave[Lab]] > self.ElimOver[self.LabDataSave[Lab]]] = np.nan if self.ElimLow[self.LabDataSave[Lab]] != None: DataCC[self.LabDataSave[Lab]][DataCC[self.LabDataSave[Lab]] < self.ElimLow[self.LabDataSave[Lab]]] = np.nan # Se convierten los datos DatesC2, DatesNC2, VC2 = EM.Ca_EC(Date=DatesCC,V1=DataCC[self.LabDataSave[Lab]], op=self.LabDataOper1[Lab], key=None,dtm=dt,op2=self.LabDataOper2[Lab],op3=self.LabDataOper3[Lab]) for LabH in LabelsH: DataH[self.LabDataSave[Lab]+LabH] = VC2[LabH] LabelsHmat.append(self.LabDataSave[Lab]+LabH) for LabD in LabelsD: DataD[self.LabDataSave[Lab]+LabD] = VC2[LabD] LabelsDmat.append(self.LabDataSave[Lab]+LabD) self.DataH = DataH self.DataD = DataD self.DatesH = DatesC2['DateH'] self.DatesD['DatesD'] = DatesC2['DateD'] self.DatesD['DatesM'] = DatesC2['DateM'] self.DataCC = DataCC self.DatesCC = DatesCC self.DatesCN = DatesCN self.DatesNC2 = DatesNC2['DateMN'] self.LabelsHmat = LabelsHmat self.LabelsDmat = LabelsDmat return
def test_datetime2str(): Date = DUtil.Dates_datetime2str([datetime(2012, 1, 1, 0, 0)]) assert isinstance(Date[0], str)
def test_str2datetime(): Date = DUtil.Dates_str2datetime(['2012-02-01 0100'], flagQuick=True) assert isinstance(Date[0], datetime) or isinstance(Date[0], date)