wolfhece 2.1.112__py3-none-any.whl → 2.1.113__py3-none-any.whl

wolfhece/mar/commontools.py

@@ -10,7 +10,6 @@ Created on Mon Dec  5 09:03:34 2022
 import numpy as np
 import matplotlib.pyplot as plt
 import commontools as ct
-from mpl_toolkits.basemap import Basemap
 import xarray as xr
 import matplotlib as mpl
 import pandas as pd
@@ -47,7 +46,7 @@ def openfileh(fileloc,col):
             columns=lines.split()
             V=np.append(V,float(columns[col]))
         r=r+1
-    return(V)    
+    return(V)
 
 def isbis(year):
     if((year%4==0 and year%100!=0)or(year%4==0 and year%400==0 and year%100==0)):
@@ -63,27 +62,27 @@ def seasonalmeans(fileloc,col,start_year,end_year,mod,season):
     # T=np.zeros(end_year-start_year+1)
 
 
-    for y in range(start_year,end_year+1):   
+    for y in range(start_year,end_year+1):
         beg_summer=np.array([173,173,170]);end_summer=np.array([264,264,259])
         beg_falls=end_summer+1;end_falls=np.array([355,355,359])
         beg_winter=end_falls+1;end_winter=np.array([80,80,69])
         beg_spring=end_winter+1;end_spring=beg_summer-1
-        end_year=np.array([365,365,360]) 
-        
+        end_year=np.array([365,365,360])
+
         if(isbis(y)==1 and mod==0):
             beg_summer=beg_summer+1;end_summer=end_summer+1
             beg_falls=beg_falls+1;end_falls=end_falls+1
             beg_winter=beg_winter+1;end_winter=end_winter+1
             beg_spring=beg_spring+1;end_spring=beg_summer-1
-            end_year=end_year+1  
-        # ind=y-start_year                      
-        if season=="Summer":                        
+            end_year=end_year+1
+        # ind=y-start_year
+        if season=="Summer":
             MASK=years==y
             T=np.append(T,np.mean(var[MASK][beg_summer[mod]-1:end_summer[mod]-1]))
             # T[ind]=np.mean(var[MASK][beg_summer[mod]-1:end_summer[mod]-1])
         elif season=="Falls":
             MASK=years==y
-            T=np.append(T,np.mean(var[MASK][beg_falls[mod]-1:end_falls[mod]-1])) 
+            T=np.append(T,np.mean(var[MASK][beg_falls[mod]-1:end_falls[mod]-1]))
             # T[ind]=np.mean(var[MASK][beg_falls[mod]-1:end_falls[mod]-1])
         elif season=="Winter":
             MASK1=years==y;MASK2=years==y+1
@@ -97,7 +96,7 @@ def seasonalmeans(fileloc,col,start_year,end_year,mod,season):
             # T[ind]=np.mean(var[MASK][beg_spring[mod]-1:end_spring[mod]-1])
         elif season=="year":
             MASK=years==y
-            T=np.append(T,np.mean(var[MASK][0:end_year[mod]-1])) 
+            T=np.append(T,np.mean(var[MASK][0:end_year[mod]-1]))
             # T[ind]=np.mean(var[MASK][0:end_year[mod]-1])
     return(T)
 
@@ -109,27 +108,27 @@ def seasonalsums(fileloc,col,start_year,end_year,mod,season):
     # T=np.zeros(end_year-start_year+1)
 
 
-    for y in range(start_year,end_year+1):   
+    for y in range(start_year,end_year+1):
         beg_summer=np.array([173,173,170]);end_summer=np.array([264,264,259])
         beg_falls=end_summer+1;end_falls=np.array([355,355,359])
         beg_winter=end_falls+1;end_winter=np.array([80,80,69])
         beg_spring=end_winter+1;end_spring=beg_summer-1
-        end_year=np.array([365,365,360]) 
-        
+        end_year=np.array([365,365,360])
+
         if(isbis(y)==1 and mod==0):
             beg_summer=beg_summer+1;end_summer=end_summer+1
             beg_falls=beg_falls+1;end_falls=end_falls+1
             beg_winter=beg_winter+1;end_winter=end_winter+1
             beg_spring=beg_spring+1;end_spring=beg_summer-1
-            end_year=end_year+1  
-        # ind=y-start_year                      
-        if season=="Summer":                        
+            end_year=end_year+1
+        # ind=y-start_year
+        if season=="Summer":
             MASK=years==y
             T=np.append(T,np.sum(var[MASK][beg_summer[mod]-1:end_summer[mod]-1]))
             # T[ind]=np.mean(var[MASK][beg_summer[mod]-1:end_summer[mod]-1])
         elif season=="Falls":
             MASK=years==y
-            T=np.append(T,np.sum(var[MASK][beg_falls[mod]-1:end_falls[mod]-1])) 
+            T=np.append(T,np.sum(var[MASK][beg_falls[mod]-1:end_falls[mod]-1]))
             # T[ind]=np.mean(var[MASK][beg_falls[mod]-1:end_falls[mod]-1])
         elif season=="Winter":
             MASK1=years==y;MASK2=years==y+1
@@ -143,18 +142,18 @@ def seasonalsums(fileloc,col,start_year,end_year,mod,season):
             # T[ind]=np.mean(var[MASK][beg_spring[mod]-1:end_spring[mod]-1])
         elif season=="year":
             MASK=years==y
-            T=np.append(T,np.sum(var[MASK][0:end_year[mod]-1])) 
+            T=np.append(T,np.sum(var[MASK][0:end_year[mod]-1]))
             # T[ind]=np.mean(var[MASK][0:end_year[mod]-1])
     return(T)
 
 def text_into_matrix(model_name,scenario,mx,my,sy,ey):
     """
     This function reads precipitation
-    text files to put all of it in a 
+    text files to put all of it in a
     3D matrix of yearly precipitation
     """
     directory='/srv7_tmp1/jbrajkovic/These/TS_ppp2/'
-    
+
     mat_ret=np.zeros([mx,my,1])
     if scenario=='ssp585':
         y1=1980;y2=2100
@@ -168,21 +167,21 @@ def text_into_matrix(model_name,scenario,mx,my,sy,ey):
             isuiv+=1
             # print('File doesn\'t exist',fn)
             continue
-        else: 
+        else:
             isuiv2+=1
-            
+
             if isuiv<=my:
                     ii=0;jj=isuiv
             else:
                     jj=int(isuiv%my)-1
                     ii=int((isuiv-jj)/my)
-          
+
             if jj==0:j=my-1;ii=ii-1
             else:jj=jj-1
             if isuiv2==1:
                 with open (fn, 'r') as f:
                     yys = [float(row[0]) for row in csv.reader(f,delimiter='\t')]
-                with open (fn, 'r') as f:    
+                with open (fn, 'r') as f:
                     pr= [float(row[2]) for row in csv.reader(f,delimiter='\t')]
             else:
                 with open (fn, 'r') as f:
@@ -197,11 +196,11 @@ def text_into_matrix(model_name,scenario,mx,my,sy,ey):
             if isuiv2%200==0:print(isuiv2, mat_ret[ii,jj,0])
             isuiv+=1
     return(mat_ret)
-    
-                    
-                
-            
-        
+
+
+
+
+
 
 
 def slidingmeans(TS,interval,std_or_mean=1):
@@ -220,10 +219,10 @@ def slidingmeans(TS,interval,std_or_mean=1):
             else:newTS[i]=np.std(TS[i-int2:i+int2])
     return(newTS)
 
-            
+
 def RGPD(vec,shape,scale,pu,teta,th):
     # print(th)
-    r=th+(scale/shape)*((vec*pu*teta)**shape-1) 
+    r=th+(scale/shape)*((vec*pu*teta)**shape-1)
     return (r)
 
 def GPD_frequency(valu,shape,scale,pu,teta,th,events_per_year):
@@ -232,7 +231,7 @@ def GPD_frequency(valu,shape,scale,pu,teta,th,events_per_year):
     return(ret_p)
 
 def RGPDI_values(vec,shape,scale,th):
-    
+
     vals=((((1-vec)**(-shape))-1)*scale)/shape+th
     return (vals)
 
@@ -240,7 +239,7 @@ def RGPD_values(vec,shape,scale):
     vals=1-(1+shape*vec/scale)**(-1/shape)
     return (vals)
 
-   
+
 def CIGPD(vec,shape,scale,pu,teta,th,varsc,varsh,cov):
     T1=(((vec*pu*teta)**shape-1)/shape)**2*varsc
     T2=((scale*(-(vec*teta*pu)**shape+shape*(vec*teta*pu)**shape*np.log(vec*teta*pu)+1)/shape**2))**2*varsh
@@ -248,7 +247,7 @@ def CIGPD(vec,shape,scale,pu,teta,th,varsc,varsh,cov):
         ((scale*(-(vec*teta*pu)**shape+shape*(vec*teta*pu)**shape*np.log(vec*teta*pu)+1)/shape**2))*cov
     CI=np.sqrt(T1+T2+T3)*1.645
     return(CI)
-            
+
 
 
 def JJ2date(day,year):
@@ -261,7 +260,7 @@ def JJ2date(day,year):
 
     for i in range(1,12):
         end_monthcum[i]=end_monthcum[i-1]+end_month[i]
-        
+
     for i in range(0,12):
         if i > 0:
             if (day<=end_monthcum[i] and day>end_monthcum[i-1]):
@@ -271,20 +270,20 @@ def JJ2date(day,year):
             if (day<=end_monthcum[i] and day>0):
                 m=monthlab[i]
                 jj=day
-    # jj+=1  
+    # jj+=1
     date=np.array([jj,m,year]);date.astype(int)
     return(date)
 
 def date2JJ(day,month,year,fn1='__',type_mod=2):
-    end_month=[31,28,31,30,31,30,31,31,30,31,30,31]    
+    end_month=[31,28,31,30,31,30,31,31,30,31,30,31]
     end_monthcum=np.zeros(12);
     if type_mod==1:
         if (ct.isbis(year)==1):end_month[1]=29
-    
+
 
     for i in range(1,12):
         end_monthcum[i]=end_monthcum[i-1]+end_month[i]
-        
+
     jj=int(end_monthcum[int(month-1)])+day
     # print(day,month,year,jj)
     return(jj)
@@ -299,6 +298,8 @@ def makebounds(mat,step):
     return(bounds)
 
 def map_belgium(ax,lons,lats):
+    from mpl_toolkits.basemap import Basemap
+
     lat_0=50.6;lon_0=4.73
     m = Basemap(width=55000,height=50000,
                 rsphere=(649328.00,665262.0),\
@@ -309,6 +310,7 @@ def map_belgium(ax,lons,lats):
     return(m)
 
 def map_belgium_J21(ax,lons,lats):
+    from mpl_toolkits.basemap import Basemap
     lat_0=50.15;lon_0=5.83
     m = Basemap(width=15000,height=18000,
                 rsphere=(649328.00,665262.0),\
@@ -320,6 +322,7 @@ def map_belgium_J21(ax,lons,lats):
 
 
 def map_Vesdre(ax,lons,lats):
+    from mpl_toolkits.basemap import Basemap
     lat_0=50.55;lon_0=5.93
     m = Basemap(width=6000,height=3800,
                 rsphere=(649328.00,665262.0),\
@@ -328,14 +331,15 @@ def map_Vesdre(ax,lons,lats):
     m.drawcountries()
     m.drawcoastlines()
     return(m)
-    
 
 
 
-    
+
+
 def map_belgium_zoom(ax,lons,lats):
+    from mpl_toolkits.basemap import Basemap
     lat_0=50.6;lon_0=4.73
-    
+
     m = Basemap(width=34000,height=30000,
                 rsphere=(649328.00,665262.0),\
                 area_thresh=1000.,projection='lcc',\
@@ -350,7 +354,8 @@ def map_belgium_zoom(ax,lons,lats):
     return(m)
 
 def map_Europe(ax,lons,lats):
-    
+    from mpl_toolkits.basemap import Basemap
+
     print(np.mean(lats))
     m = Basemap(width=6000,height=150000,
                 rsphere=(649328.00,665262.0),\
@@ -368,7 +373,7 @@ def mean_netcdf_alldomain(start_year,end_year,direct,var):
     for y in range(start_year,end_year+1):
         # print(y)
         fn=glob.glob(direct+'*'+str(y)+'**nc*')[0]
-        
+
         if y==start_year:
             matrice=np.average(np.transpose((np.array(xr.open_dataset(fn)[var]))),axis=2)
         else:
@@ -386,18 +391,19 @@ def mean_netcdf_alldomain(start_year,end_year,direct,var):
            #          for k in range(dimt):
            #              mat2add[i,j,k]=np.mean(matrice[i,j,:,k])
            # matdaily=np.append(matdaily,mat2add,axis=2)
-                    
-                    
+
+
     return(meant)
 
 def quick_map_plot(lons,lats,mat,bounds,cmap,MSK=np.zeros(0),nticks=4):
+    from mpl_toolkits.basemap import Basemap
     # filemask="/srv7_tmp1/jbrajkovic/These/EU-7.5km.nc"
     # ds_mask=xr.open_dataset(filemask)
     # mask=np.transpose(np.array(ds_mask.MASK[:,:]))
     # MSK=mask==1
     if MSK.shape[0]==0:
         MSK=np.zeros_like(mat)==0
-        
+
     lon_center=4.96
     # lon_center=np.mean(lats)
     lat_center=50.56
@@ -414,13 +420,13 @@ def quick_map_plot(lons,lats,mat,bounds,cmap,MSK=np.zeros(0),nticks=4):
     step=vmax/10.
     # bounds = bounds=np.arange(0,105,5)
     # cmap=cm.jet
-    norm = mpl.colors.BoundaryNorm(bounds, cmap.N) 
+    norm = mpl.colors.BoundaryNorm(bounds, cmap.N)
     x,y=m(lons,lats)
     # print(x,y)
     mapa=m.pcolormesh(x,y,mat,norm=norm,cmap=cmap)
     # mapa=m.contourf(x,y,mat,norm=norm,cmap=cmap)
-    # m.contour(x,y,MSK,levels=0,linewidth=3.0)  
-    
+    # m.contour(x,y,MSK,levels=0,linewidth=3.0)
+
     # ds_mask=xr.open_dataset(filemask)
     # mask=np.transpose(np.array(ds_mask.MASK[:,:]))
     # MSK=mask==1
@@ -433,7 +439,7 @@ def quick_map_plot(lons,lats,mat,bounds,cmap,MSK=np.zeros(0),nticks=4):
     #                             color='black',
     #                             arrowprops=dict(arrowstyle='Simple', color='black'),
     #                             fontsize=24,weight='bold')
-    # plt.annotate(text1, xy=(0.9, 0.1), xycoords='axes fraction',                                
+    # plt.annotate(text1, xy=(0.9, 0.1), xycoords='axes fraction',
     #                             color='black',
     #                             fontsize=24,weight='bold')
     # m.contourf(x,y,mat,norm=norm,cmap=cmap)
@@ -452,7 +458,7 @@ def quick_map_plot(lons,lats,mat,bounds,cmap,MSK=np.zeros(0),nticks=4):
     #                         ha=ps1[i],va=pos[i],color='k')
     #     else:
     #         plt.text(xv[i], yv[i]-decalage[i], cities[i],fontsize=10,
-    #                         ha=ps1[i],va=pos[i],color='k',weight='bold')            
+    #                         ha=ps1[i],va=pos[i],color='k',weight='bold')
     #     if i<=4:plt.scatter(xv[i], yv[i],marker='+',color='black',s=8)
     # for item in [fig, ax]:
     #     item.patch.set_visible(False)
@@ -463,8 +469,9 @@ def quick_map_plot(lons,lats,mat,bounds,cmap,MSK=np.zeros(0),nticks=4):
     cbar.ax.tick_params(labelsize=10)
     # cbar.set_label('Height (m)',fontsize=14,labelpad=10)
     # cbar.solids.set_edgecolor("face")
-    
+
 def quick_map_plot2(lons,lats,mat,bounds,cmap,ax):
+    from mpl_toolkits.basemap import Basemap
     lat_0=50.6;lon_0=4.73
     lon_center=lon_0
     # lon_center=np.mean(lats)
@@ -481,11 +488,11 @@ def quick_map_plot2(lons,lats,mat,bounds,cmap,ax):
     step=vmax/10.
     # bounds = bounds=np.arange(0,105,5)
     # cmap=cm.jet
-    norm = mpl.colors.BoundaryNorm(bounds, cmap.N) 
+    norm = mpl.colors.BoundaryNorm(bounds, cmap.N)
     x,y=m(lons,lats)
     mapa=m.pcolormesh(x,y,mat,norm=norm,cmap=cmap    )
     return(mapa)
-    
+
 # def get_coordinates(path_to_file):
 
 #     with fiona.open(path_to_file) as shapefile:
@@ -495,62 +502,62 @@ def quick_map_plot2(lons,lats,mat,bounds,cmap,ax):
 #             print(record)
 #     # Read the shapefile
 #     gdf = gpd.read_file(path_to_file)
-    
+
 #     # Print the first few rows of the GeoDataFrame
 #     print(gdf.head())
-    
+
 def mask_belgium(lon,lat,path_in,path_out,center_or_all=2):
-    
-    """This routine takes as arguments: 
+
+    """This routine takes as arguments:
         -The longitudes and latitudes of the netcdf (gridded)
         -a .tif file of the mask we want to create (tif must be in epsg:31370 lambbert 72)
        and creates a mask at the resolution of the input netcdf which is saved as netcdf in path_out
-       
-       L'option center_or_all precise si l'on souhaite qu'un des 4 coins des pixels chosisis soient à l'intérieur 
+
+       L'option center_or_all precise si l'on souhaite qu'un des 4 coins des pixels chosisis soient à l'intérieur
        de la zone ou si on regarde uniquement le centre.
        Si center_or_all vaut 1, on ragarde uniquement le centre et donc le masque sera plus petit
-       
+
        conseil : raster d'une résolution 100 mètres en input'
     """
-    
+
     "Projecting lon lat to Lambert"
     discheck=300000
     lb=pyproj.Proj(projparams='epsg:31370')
     xlb,ylb=lb(lon,lat)
     if center_or_all!=0:
         xlb_ur=np.zeros([xlb.shape[0],xlb.shape[1]])
-        ylb_ur=np.zeros([xlb.shape[0],xlb.shape[1]])  
-        
+        ylb_ur=np.zeros([xlb.shape[0],xlb.shape[1]])
+
         xlb_ul=np.zeros([xlb.shape[0],xlb.shape[1]])
         ylb_ul=np.zeros([xlb.shape[0],xlb.shape[1]])
-        
-      
+
+
         xlb_bl=np.zeros([xlb.shape[0],xlb.shape[1]])
         ylb_bl=np.zeros([xlb.shape[0],xlb.shape[1]])
-        
-        xlb_br=np.zeros([xlb.shape[0],xlb.shape[1]]) 
-        ylb_br=np.zeros([xlb.shape[0],xlb.shape[1]]) 
-        
+
+        xlb_br=np.zeros([xlb.shape[0],xlb.shape[1]])
+        ylb_br=np.zeros([xlb.shape[0],xlb.shape[1]])
+
         "Calcul des sommets des pixels"
-        
+
         for i in range(1,xlb.shape[0]-1):
             for j in range(1,xlb.shape[1]-1):
                 xlb_ur[i,j]=np.mean(lon[i-1:i+1,j:j+2]);ylb_ur[i,j]=np.mean(lat[i-1:i+1,j:j+2])
                 xlb_ul[i,j]=np.mean(lon[i-1:i+1,j-1:j+1]);ylb_ul[i,j]=np.mean(lat[i-1:i,j-1:j+1])
                 xlb_bl[i,j]=np.mean(lon[i:i+2,j-1:j+1]);ylb_bl[i,j]=np.mean(lat[i:i+2,j-1:j+1])
                 xlb_br[i,j]=np.mean(lon[i:i+2,j:j+2]);ylb_br[i,j]=np.mean(lat[i:i+2,j:j+2])
-                
+
         xlb_ur,ylb_ur=lb(xlb_ur,ylb_ur)
         xlb_ul,ylb_ul=lb(xlb_ul,ylb_ul)
         xlb_bl,ylb_bl=lb(xlb_bl,ylb_bl)
         xlb_br,ylb_br=lb(xlb_br,ylb_br)
-    
-        
-        
-    
+
+
+
+
     # print (ylb_ur[1:]-ylb[1:])
     "Opening the raster file"
-    
+
     im = Image.open(path_in)
     imarray = np.array(im)
 
@@ -570,11 +577,11 @@ def mask_belgium(lon,lat,path_in,path_out,center_or_all=2):
     lons=lons[imarray!=0]
     print(lats)
     MSK=np.zeros(xlb.shape)
-    
+
     print(np.max(xs),np.max(ys))
-    
+
     "Finding the pixels which are in the zone"
-    
+
     "perimetre de recherche"
     maxi_lat=np.max(lats)
     mini_lat=np.min(lats)
@@ -592,7 +599,7 @@ def mask_belgium(lon,lat,path_in,path_out,center_or_all=2):
             if abs(ylb[i,j]-maxi_lat)<disu and ylb[i,j]-maxi_lat>=0 :
                 iu=i
                 disu=abs(ylb[i,j]-maxi_lat)
-                
+
             if abs( ylb[i,j]-mini_lat)<disb and ylb[i,j]-mini_lat<=0:
                 ib=i
                 disb=abs( ylb[i,j]-mini_lat)
@@ -604,8 +611,8 @@ def mask_belgium(lon,lat,path_in,path_out,center_or_all=2):
             if abs(xlb[i,j]-maxi_lon)<disr and xlb[i,j]-maxi_lon >=0 :
                 jr=j
                 disr=abs(xlb[i,j]-maxi_lon)
-    
-    print(disu,disr,disb,disl)       
+
+    print(disu,disr,disb,disl)
     print(iu,ib,jl,jr)
     # if iu==ib or jl==jr:
     # iu=1;ib=xlb.shape[0]-1
@@ -626,7 +633,7 @@ def mask_belgium(lon,lat,path_in,path_out,center_or_all=2):
 
                 else:
                     msk_stp=lons[((abs(lons-xlb[i,j])<discheck)&(abs(lats-ylb[i,j])<discheck))]
-                    
+
                 # print(i,j)
                 # if i%10==0 and j==jl:
                 # print(i,j)
@@ -639,7 +646,7 @@ def mask_belgium(lon,lat,path_in,path_out,center_or_all=2):
 
     # MSK
     # time=[1]
-    
+
     "writing the output netcdf with the mask"
 
     coords=dict(
@@ -650,7 +657,7 @@ def mask_belgium(lon,lat,path_in,path_out,center_or_all=2):
         data=np.transpose(np.zeros([xlb.shape[0],xlb.shape[1]])),
         dims=["y","x"],
         coords=coords,
-        )    
+        )
     Mar_rain=xr.DataArray(
         data=np.transpose(MSK),
         dims=["y","x"],
@@ -665,54 +672,54 @@ def mask_belgium(lon,lat,path_in,path_out,center_or_all=2):
     MSK=[MSK==1]
     return (ylb)
         # return(coords)
-        
+
 def mask_belgiumV2(lon,lat,path_in,path_out,center_or_all=2,discheck=300000,buffer=2):
-    """This routine takes as arguments: 
+    """This routine takes as arguments:
         -The longitudes and latitudes of the netcdf (gridded)
         -a .tif file of the mask we want to create (tif must be in epsg:31370 lambbert 72)
        and creates a mask at the resolution of the input netcdf which is saved as netcdf in path_out
-       
-       L'option center_or_all precise si l'on souhaite qu'un des 4 coins des pixels chosisis soient à l'intérieur 
+
+       L'option center_or_all precise si l'on souhaite qu'un des 4 coins des pixels chosisis soient à l'intérieur
        de la zone ou si on regarde uniquement le centre.
        Si center_or_all vaut 1, on ragarde uniquement le centre et donc le masque sera plus petit
-       
+
        conseil : raster d'une résolution 100 mètres en input'
     """
-    
+
     "Projecting lon lat to Lambert"
     # discheck=300000
     print('Check distance = '+str(discheck) + 'meters')
     lb=pyproj.Proj(projparams='epsg:31370')
-   
+
     if center_or_all!=0:
         xlb_ur=np.zeros_like(lon)
         ylb_ur=np.zeros_like(lon)
-        
+
         xlb_ul=np.zeros_like(lon)
         ylb_ul=np.zeros_like(lon)
-        
-      
+
+
         xlb_bl=np.zeros_like(lon)
         ylb_bl=np.zeros_like(lon)
-        
+
         xlb_br=np.zeros_like(lon)
         ylb_br=np.zeros_like(lon)
-        
+
         "Calcul des sommets des pixels"
-        
+
         for i in range(1,lon.shape[0]-1):
             for j in range(1,lon.shape[1]-1):
                 xlb_ur[i,j]=np.mean(lon[i-1:i+1,j:j+2]);ylb_ur[i,j]=np.mean(lat[i-1:i+1,j:j+2])
                 xlb_ul[i,j]=np.mean(lon[i-1:i+1,j-1:j+1]);ylb_ul[i,j]=np.mean(lat[i-1:i,j-1:j+1])
                 xlb_bl[i,j]=np.mean(lon[i:i+2,j-1:j+1]);ylb_bl[i,j]=np.mean(lat[i:i+2,j-1:j+1])
                 xlb_br[i,j]=np.mean(lon[i:i+2,j:j+2]);ylb_br[i,j]=np.mean(lat[i:i+2,j:j+2])
-                
-       
-    
+
+
+
 
     # print (ylb_ur[1:]-ylb[1:])
     "Opening the raster file"
-    
+
     im = Image.open(path_in)
     imarray = np.array(im)
 
@@ -727,25 +734,25 @@ def mask_belgiumV2(lon,lat,path_in,path_out,center_or_all=2,discheck=300000,buff
          lons= np.array(xs)
          lats = np.array(ys)
          print('lons shape', lons.shape)
-         
+
     inProj=Proj(init='epsg:31370')
     outProj = Proj(init='epsg:4326')
 
-    lons,lats=transform(inProj,outProj,lons,lats)     
-    
+    lons,lats=transform(inProj,outProj,lons,lats)
+
     # print(ys,ylb)
     # plt.imshow(imarray);plt.colorbar()
     # plt.show()
     lats=lats[imarray>0]
     lons=lons[imarray>0]
-    
+
     print(lats)
     MSK=np.zeros(lon.shape)
-    
+
     print(np.max(xs),np.max(ys))
-    
+
     "Finding the pixels which are in the zone"
-    
+
     "perimetre de recherche"
     maxi_lat=np.max(lats)
     mini_lat=np.min(lats)
@@ -758,7 +765,7 @@ def mask_belgiumV2(lon,lat,path_in,path_out,center_or_all=2,discheck=300000,buff
     disb=disrech
     disl=disrech
     disr=disrech
-    
+
     print('lon max ',maxi_lon,mini_lon,me_lat,maxi_lat,mini_lat)
     for i in range(lon.shape[0]):
         # print(i)
@@ -766,27 +773,27 @@ def mask_belgiumV2(lon,lat,path_in,path_out,center_or_all=2,discheck=300000,buff
             if ct.dis2pix(lat[i,j], lon[i,j], maxi_lat, lon[i,j])<disu and lat[i,j]>=maxi_lat:
                 iu=i
                 disu=ct.dis2pix(lat[i,j], lon[i,j], maxi_lat, lon[i,j])
-                
-            if ct.dis2pix(lat[i,j], lon[i,j], mini_lat, lon[i,j])<disb and lat[i,j]<=mini_lat:   
+
+            if ct.dis2pix(lat[i,j], lon[i,j], mini_lat, lon[i,j])<disb and lat[i,j]<=mini_lat:
                 ib=i
                 disb=ct.dis2pix(lat[i,j], lon[i,j], mini_lat, lon[i,j])
-                
+
             if ct.dis2pix(lat[i,j], lon[i,j], me_lat, mini_lon)<disl and lon[i,j]<=mini_lon:
                 jl=j
                 disl=ct.dis2pix(lat[i,j], lon[i,j], me_lat, mini_lon)
-                
-            if ct.dis2pix(lat[i,j], lon[i,j], me_lat, maxi_lon)<disr and lon[i,j]>=maxi_lon: 
-                
+
+            if ct.dis2pix(lat[i,j], lon[i,j], me_lat, maxi_lon)<disr and lon[i,j]>=maxi_lon:
+
                 jr=j
                 disr=ct.dis2pix(lat[i,j], lon[i,j], me_lat, maxi_lon)
-    
-    print(disu,disr,disb,disl)       
+
+    print(disu,disr,disb,disl)
     print(iu,ib,jl,jr)
     print('aire latitudinale de recherche : '+"{:.0f}".format(lat[int(ib),int(jl)])+' '+"{:.0f}".format(lat[int(iu),int(jl)]))
     ide=iu-2;ifi=ib+2
     if ide<0:ide=0;
     if ifi>lon.shape[0]:ifi=lon.shape[0]
-    
+
     jde=jl-2;jfi=jr+2
     if jde<0:jde=0
     if jr>lon.shape[0]:jfi=lon.shape[1]
@@ -800,36 +807,36 @@ def mask_belgiumV2(lon,lat,path_in,path_out,center_or_all=2,discheck=300000,buff
                 # msk_stp=lons[((abs(lons-xlb_ur[i,j])<100)&(abs(lats-ylb_ur[i,j])<100))]
                 if center_or_all !=2:
                     if center_or_all==1:
-                        
-                        msk_stp=lons[((ct.dis2pix(lats, lons, lat[i,j], lon[i,j])<discheck)|  
+
+                        msk_stp=lons[((ct.dis2pix(lats, lons, lat[i,j], lon[i,j])<discheck)|
                                      ((ct.dis2pix(lats, lons, ylb_ur[i,j], xlb_ur[i,j]))<discheck)|
                                      ((ct.dis2pix(lats, lons, ylb_ul[i,j], xlb_ul[i,j]))<discheck)|
                                      (ct.dis2pix(lats, lons, ylb_bl[i,j], xlb_bl[i,j])<discheck)|
                                     ((ct.dis2pix(lats, lons, ylb_br[i,j], xlb_br[i,j]))<discheck))]
-                        
-    
+
+
                     else:
-                        msk_stp=lons[(ct.dis2pix(lats, lons, lat[i,j], lon[i,j])<discheck)] 
-    
+                        msk_stp=lons[(ct.dis2pix(lats, lons, lat[i,j], lon[i,j])<discheck)]
+
                     if np.size(msk_stp)!=0:#print('ok');
                         print(i,j)
                         MSK[i,j]=1
-    
+
                 else:
-                    dists=np.matrix([ct.dis2pix(center_pixel_lat, center_pixel_lon, lat[i,j], lon[i,j]),  
+                    dists=np.matrix([ct.dis2pix(center_pixel_lat, center_pixel_lon, lat[i,j], lon[i,j]),
                                  ct.dis2pix(center_pixel_lat, center_pixel_lon, ylb_ur[i,j], xlb_ur[i,j]),
                                  ct.dis2pix(center_pixel_lat, center_pixel_lon, ylb_ul[i,j], xlb_ul[i,j]),
                                  ct.dis2pix(center_pixel_lat, center_pixel_lon, ylb_bl[i,j], xlb_bl[i,j]),
                                  ct.dis2pix(center_pixel_lat, center_pixel_lon, ylb_br[i,j], xlb_br[i,j])])
                     min_dist=np.min(dists)
-                    
+
                     if min_dist<min_dist1:
                         min_dist1=min_dist
                         iic=i;jjc=j
     if center_or_all==2:
         MSK[iic-buffer:iic+buffer+1,jjc-buffer:jjc+buffer+1]=1
-                    
-                
+
+
     "writing the output netcdf with the mask"
 
     coords=dict(
@@ -840,7 +847,7 @@ def mask_belgiumV2(lon,lat,path_in,path_out,center_or_all=2,discheck=300000,buff
         data=np.transpose(np.zeros([lon.shape[0],lat.shape[1]])),
         dims=["y","x"],
         coords=coords,
-        )    
+        )
     Mar_rain=xr.DataArray(
         data=np.transpose(MSK),
         dims=["y","x"],
@@ -854,7 +861,7 @@ def mask_belgiumV2(lon,lat,path_in,path_out,center_or_all=2,discheck=300000,buff
     Mar_ds.to_netcdf(path_out,mode='w',format=format1)
     MSK=[MSK==1]
     return (MSK)
-        
+
 def dis2pix(lat1,lon1,lat2,lon2):
     lat1,lon1,lat2,lon2=np.deg2rad(lat1),np.deg2rad(lon1),np.deg2rad(lat2),np.deg2rad(lon2)
     dis=np.arccos(np.sin(lat1)*np.sin(lat2)+np.cos(lat1)*np.cos(lat2)*np.cos(abs(lon1-lon2)))*6371000
@@ -873,7 +880,7 @@ def grid_mean(folder,year,var,season,sum_or_mean=0,nts=24,lev=0,nf=0,fn1='__'):
     # print(fn)
     seasons_names=['SP','SU','F','W','DJF','MAM','JJA','SON']
     if season!='Y':
-        
+
         beg_seas=[81,173,265,356,335,60,152,244]
         end_seas=[172,264,355,80,59,151,243,334]
         for i in range(8):
@@ -911,7 +918,7 @@ def grid_mean(folder,year,var,season,sum_or_mean=0,nts=24,lev=0,nf=0,fn1='__'):
                             [:,:,0:es*nts+nts])
                 Ds=np.append(Ds,np.transpose(np.array(xr.open_dataset(fn1)['MBRR'])+\
                                 np.array(xr.open_dataset(fn1)['MBSF']))\
-                                [:,:,(bs-1)*nts+1:],axis=2) 
+                                [:,:,(bs-1)*nts+1:],axis=2)
                 Ds=np.average(Ds,axis=2)
     else:
         mat=np.array(xr.open_dataset(fn)[var])
@@ -937,23 +944,23 @@ def grid_mean(folder,year,var,season,sum_or_mean=0,nts=24,lev=0,nf=0,fn1='__'):
             elif season=='Y'  :
                 mat=np.transpose(mat)\
                         [:,:,:]
-         
+
             else:
                 mat=np.transpose(mat)\
                         [:,:,(bs-1)*nts+1: es*nts+nts]
-                
-            
+
+
         if sum_or_mean:
-            
+
                 Ds=np.sum(mat,axis=2)
-  
+
         else:
                 print(axis)
                 Ds=np.average(mat,axis=2)
 
-                          
+
     return(Ds)
-    
+
 def find_pix_be(lon_p,lat_p,lons,lats):
     Lb72=pyproj.Proj(projparams='epsg:31370')
     xl,yl=Lb72(lon_p,lat_p)
@@ -990,18 +997,18 @@ def find_MARs_closest_pixel(lonsm,latsm,lonsi,latsi,neighbours=1):
                         else:
                             if dis2pixels[i,j,k,l]<dists[n] and\
                                 dis2pixels[i,j,k,l]>dists[n-1]:
-                                dists[n]=dis2pixels[i,j,k,l]                            
+                                dists[n]=dis2pixels[i,j,k,l]
                                 output[i,j,n,0]=k
                                 output[i,j,n,1]=l
                                 output[i,j,n,2]=1/(dists[n]/1000)
     return(output)
-    
+
 def IPCC_cmap():
     cmap = mpl.colors.LinearSegmentedColormap.from_list("", [(84/256, 48/256, 5/256),
                                                              (245/256,245/256,245/256),
                                                              (0/256,60/256,48/256)])
     return(cmap)
-    
+
 def draw_cities(m,fs_c=14,fs_C=16):
     fs=10
     cities=np.array(['Bruxelles','Charleroi','Liège',
@@ -1024,16 +1031,16 @@ def draw_cities(m,fs_c=14,fs_C=16):
                 plt.text(xv[i], yv[i]-decalage[i], cities[i],fontsize=fs_c,
                                 ha=ps1[i],va=pos[i],color='k',weight='bold',
                                 path_effects=[pe.withStroke(linewidth=4, foreground="white")])
-                
+
             else:
                 plt.text(xv[i], yv[i]-decalage[i], cities[i],fontsize=fs_C,
-                                ha=ps1[i],va=pos[i],color='k',weight='bold')            
-            
-               
-        
+                                ha=ps1[i],va=pos[i],color='k',weight='bold')
+
+
+
 def draw_stations(m,n_id=1,fs=8):
 
-        
+
        stations_lons=[6.07960,5.912,6.228,
                             5.594,5.405,5.255,
                             4.591,4.653,4.471,
@@ -1043,7 +1050,7 @@ def draw_stations(m,n_id=1,fs=8):
                             4.539,5.470,5.072,
                             4.470,4.381,3.208,
                             2.856,2.668     ]
-        
+
        stations_lats=[50.511,50.478,50.459,
                             49.647,50.037,50.207,
                             50.094,50.226,50.478,
@@ -1053,7 +1060,7 @@ def draw_stations(m,n_id=1,fs=8):
                             51.064,51.170,51.270,
                             51.219,51.322
                             ,51.322,51.200,51.126]
-        
+
        stations_names=['Mont-Rigi','Spa','Elsenborn',
                               'Buzenol','Saint-Hubert','Humain',
                               'Dourbes','Florennes','Gosselies',
@@ -1063,7 +1070,7 @@ def draw_stations(m,n_id=1,fs=8):
                               'Sint-Katelijne','Kleine-Brogel','Retie',
                               'Deurne','Stabroek','Zeebrugge',
                               'Middelkerke','Koksijde']
-        
+
        stations_index=['06494','06490','06496',
                         '06484','06476','06472',
                         '06455','06456','06449',
@@ -1079,18 +1086,18 @@ def draw_stations(m,n_id=1,fs=8):
        # m.drawmapscale(5.5,49.2,5.5, 49)
        for i in range(np.size(stations_lons)):
                plt.text(xv[i], yv[i], te[i],fontsize=fs,
-                               color='k',weight='bold')            
-           
-    
+                               color='k',weight='bold')
+
+
 def box_plot(data, edge_color, fill_color,ax):
     bp = ax.boxplot(data, patch_artist=True)
-    
+
     for element in ['boxes', 'whiskers', 'fliers', 'means', 'medians', 'caps']:
         plt.setp(bp[element], color=edge_color)
 
     for patch in bp['boxes']:
-        patch.set(facecolor=fill_color)       
-        
+        patch.set(facecolor=fill_color)
+
     return bp
 
 
@@ -1102,7 +1109,7 @@ def endmonth(year):
     return(em)
 
 def radar_coord():
-    
+
     radar='/srv5_tmp3/RADCLIM/2021/20210714230000.radclim.accum1h.hdf'
     f = h5py.File(radar, "r")
 
@@ -1116,12 +1123,12 @@ def radar_coord():
     lr_x = ul_x + (xsize*xscale)
     lr_x = ul_x + (xsize*xscale)
     lr_y = ul_y - (ysize*yscale)
-     
+
     x=np.arange(ul_x, lr_x, xscale) + xscale/2
     y=np.arange(lr_y, ul_y, yscale) - yscale/2
-     
+
     xx,yy = np.meshgrid(x,y)
-     
+
     yy= np.flip(yy)
 
     inProj=Proj(r'+proj=lcc +lat_1=49.83333333333334 +lat_2=51.16666666666666 +lat_0=50.797815 +lon_0=4.359215833333333 +x_0=649328 +y_0=665262 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs ')
@@ -1144,7 +1151,7 @@ def RGEV(retp,nyears,loc,sca,sha):
 
 def GEV_frequency(value,loc,sca,sha):
     prob=1-np.exp(-(1-(((loc-value)*sha)/sca))**(-1/sha))
-    
+
     ret=(1/prob)
     return(ret)
 
@@ -1161,8 +1168,8 @@ def GEVCI(retp,loc,sc,sh,
     return(CI)
 
 
-    
-   
+
+
 
 def gumCI(retp,loc,sc,
           varloc,varsc,
@@ -1173,7 +1180,7 @@ def gumCI(retp,loc,sc,
     S2T=derloc**2*varloc+dersc**2*varsc+2*derloc*dersc*covlocsc
     CI=S2T**0.5*1.645
     return(CI)
-    
+
 
 def RGum(retp,nyears,loc,sca):
     prob=1/(retp)#*nyears)
@@ -1190,7 +1197,7 @@ def extreme_matrix(fn,ret_per=20,value=50,mx=80,my=50,abs_or_retour=1,ydays=365,
 
     f=open(fn,'r')
     indice_suivi=0
-    
+
     mat=np.zeros([mx,my])*float('nan')
     mv=np.array(ret_per*ydays)
     for line in f:
@@ -1216,10 +1223,10 @@ def extreme_matrix(fn,ret_per=20,value=50,mx=80,my=50,abs_or_retour=1,ydays=365,
                 th=float(columns[9])
                 varsh=float(columns[4])
                 varsc=float(columns[3])
-                cov=float(columns[5]) 
+                cov=float(columns[5])
                 pu=ne/(ydays*(end_year-start_year+1));teta=ncl/ne
-                if abs_or_retour: 
-                 
+                if abs_or_retour:
+
                     if sha==0:
                         continue
                     mat[i,j]=ct.RGPD(mv,sha,sca,pu,teta,th)
@@ -1238,7 +1245,7 @@ def extreme_matrix(fn,ret_per=20,value=50,mx=80,my=50,abs_or_retour=1,ydays=365,
                   nye=end_year-start_year+1
                   if abs_or_retour: mat[i,j]=ct.RGEV(ret_per,nye,loc,sca,sha)
                   else:mat[i,j]=ct.GEV_frequency(value[i,j],loc,sca, sha)
-               
+
             elif gpd_gev_gum==2:
                 nye=end_year-start_year+1
                 loc=float(columns[13])
@@ -1255,14 +1262,14 @@ def extreme_matrix_V2(fn,ret_per=20,value=50,mx=80,my=50,
                       gpd_gev_gum=0,unst_st=0,var_unst='MKam',y_unst=2021):
     # print('ok')
 
-   
+
     data=ct.df_from_file(fn)
     mat=np.zeros([mx,my])*float('nan')
     mv=np.array(ret_per*ydays)
-    
+
     for p in range(data.shape[0]):
     # for line in f:
-       
+
             ind_pix=data['indice'][p]
             if ind_pix<=my:
                 i=0;j=ind_pix
@@ -1274,7 +1281,7 @@ def extreme_matrix_V2(fn,ret_per=20,value=50,mx=80,my=50,
             if j==0:j=my-1;i=i-1
             else:j=j-1
             if unst_st==0:
-                
+
                 if gpd_gev_gum==0:
                     sca=data['sc'][p]
                     sha=data['sh'][p]
@@ -1285,7 +1292,7 @@ def extreme_matrix_V2(fn,ret_per=20,value=50,mx=80,my=50,
                     varsc=data['varsc'][p]
                     cov=data['cov'][p]
                     pu=ne/(ydays*(end_year-start_year+1));teta=ncl/ne
-                    if abs_or_retour: 
+                    if abs_or_retour:
                         if sha==0:
                             continue
                         mat[i,j]=ct.RGPD(mv,sha,sca,pu,teta,th)
@@ -1304,7 +1311,7 @@ def extreme_matrix_V2(fn,ret_per=20,value=50,mx=80,my=50,
                       nye=end_year-start_year+1
                       if abs_or_retour: mat[i,j]=ct.RGEV(ret_per,nye,loc,sca,sha)
                       else:mat[i,j]=ct.GEV_frequency(value[i,j],loc,sca, sha)
-                   
+
                 elif gpd_gev_gum==2:
                     nye=end_year-start_year+1
                     loc=data['GUMshape'][p]
@@ -1326,7 +1333,7 @@ def extreme_matrix_V2(fn,ret_per=20,value=50,mx=80,my=50,
                     slam=data['slam'][p]
                     th=th+(y_unst-start_year)*slam
                     sca=sca+(y_unst-start_year)*slam
-                    if abs_or_retour: 
+                    if abs_or_retour:
                         if sha==0:
                             continue
                         mat[i,j]=ct.RGPD(mv,sha,sca,pu,teta,th)
@@ -1348,19 +1355,19 @@ def extreme_matrix_V2(fn,ret_per=20,value=50,mx=80,my=50,
                        nye=end_year-start_year+1
                        if abs_or_retour: mat[i,j]=ct.RGEV(ret_per,nye,loc,sca,sha)
                        else:mat[i,j]=ct.GEV_frequency(value[i,j],loc,sca, sha)
-                    
+
                 elif gpd_gev_gum==2:
                      nye=end_year-start_year+1
                      loc=data['GUMshape'][p]
                      sca=data['GUMscale'][p]
                      if abs_or_retour: mat[i,j]=ct.RGum(ret_per,nye,loc,sca)
                      else:mat[i,j]=ct.Gum_frequency(value[i,j],loc,sca)
-                
-                
-                
-                
-            
-       
+
+
+
+
+
+
     return(mat)
 
 def find_clusters(TS1):
@@ -1380,7 +1387,7 @@ def find_clusters(TS1):
             cl_ind=t
             while suiv<r and t1<np.size(TS):
                 suiv+=1
-               
+
                 # print(t1)
                 if pd.isna(TS[t1])==False:
                     # print('ok')
@@ -1388,13 +1395,13 @@ def find_clusters(TS1):
                     if TS[t1]>cl_maxima:cl_maxima=TS[t1];cl_ind=t1
                     # print(suiv)
                 t1+=1
-            
+
             clss=np.append(clss,cl_maxima)
             indexes=np.append(indexes,cl_ind)
             # print(cls_dates.shape)
-            
+
             t=t1
-        
+
         t+=1
     return(clss,indexes)
 
@@ -1407,21 +1414,21 @@ def df_from_file(fn):
         lines=line.strip()
         lines=lines.split()
         if suiv>0:
-            
-            
+
+
             dat=lines[0]
             vappend=np.zeros([1,np.size(lines[:])])
             # dates=np.append(dates,dat[1:-1])
             for i in range(vappend.shape[1]):
                 vappend[0,i]=float(lines[i])
-                
+
             if suiv==1:
                 data=vappend
             else:
                 data=np.append(data,vappend,axis=0)
         else:
             vnames=lines
-            
+
     data=pd.DataFrame(data)
     data.columns=vnames
     return(data)