def __init__(self,linkid=None, path = None, ExtraParams = None, model_uid = 604,
build_rvr = True):
'''Depending on the linkid or in the path the class starts a table
to set up a new project fro HLM model.
- linkid = number of link id to search for in the database.
- path = path to search for a WMF.SimuBasin project .nc
- ExtraParams: name of external params stored in the dataBase.
- model_uid: the id of the model at the global.
- build_rvr: if there is going to be an rvr or already exists.
Optional:
-ExtraParams: List with the names of the extra params extracted from the database'''
#Type of model to be used
self.model_uid = model_uid
#Make an action depending on each case.
if build_rvr:
if linkid is not None and path is None:
self.Table = db.SQL_Get_WatershedFromMaster(linkid, ExtraParams)
self.linkid = linkid
elif path is not None and linkid is None:
self.wmfBasin = wmf.SimuBasin(rute=path)
self.wmfBasin.GetGeo_Cell_Basics()
self.Table = cu.Transform_Basin2Asnych('/tmp/tmp.rvr',
lookup='/tmp/tmp.look',
prm='/tmp/tmp.prm')
self.build_rvr = True
else:
self.build_rvr = False
def Genera_riskvectorMap(rutaConfig, cuenca, figSZ):
''' Genera un mapa en .png con el risk_vector, esta funcion no es de uso operacional.
Por lo que necesita leer directamente el ConfigFile.'''
#Lee el archivo de configuracion
ListConfig = get_rutesList(rutaConfig)
#Lectura de rutas de salida de la imagen
ruta_out = get_ruta(ListConfig, 'ruta_map_riskvector')
#Lectura de cuenca
cu = wmf.SimuBasin(rute=cuenca, SimSlides=True)
wmf.models.slide_allocate(cu.ncells, 10)
#Mapa risk vector.
R = wmf.models.sl_riskvector #np.copy(wmf.models.sl_riskvector)
#Plot
cu.Plot_basinClean(R,
figsize=(figSZ[0], figSZ[1]),
cmap=pl.get_cmap('viridis', 3),
ruta=ruta_out)
help="Escribe archivo con coordenadas",
default=False,
type=bool)
parser.add_argument("-r",
"--record",
help="Record de lectura en el binario para graficar",
default=1,
type=int)
#lee todos los argumentos
args = parser.parse_args()
#-------------------------------------------------------------------------------------------------------
#-------------------------------------------------------------------------------------------------------
#Lectura de cuenc ay variables
cu = wmf.SimuBasin(rute=args.cuenca)
v, r = wmf.models.read_float_basin_ncol(args.storage, args.record, cu.ncells,
5)
#lectura de constantes
qmed = cu.Load_BasinVar('qmed')
horton = cu.Load_BasinVar('horton')
cauce = cu.Load_BasinVar('cauce')
#-------------------------------------------------------------------------------------------------------
#-------------------------------------------------------------------------------------------------------
#Configura rutas
if args.ruta.endswith('.png'):
ruta_texto = args.ruta[:-4] + '.txt'
ruta_plot = args.ruta
else:
ruta_texto = args.ruta + '.txt'
wmf.models.show_storage = 1
wmf.models.separate_fluxes = 1
wmf.models.dt = 300
#Set para deslizamientos
wmf.models.sl_fs = 0.5
wmf.models.sim_slides = 1
#Variables de caudales y lluvia en simulacion
Caudales = {}
Rain = wmf.read_mean_rain(args.rutaCampo[:-4] + '.hdr')
#Ejecucion del modelo
for k in Proyectos:
# Se fija que el proyecto tenga calibracion
if Proyectos[k]['calibValues'] <> None:
#Si si, comienza a cargar las cosas para la ejecuicion
if args.rutaSlides <> None:
cu = wmf.SimuBasin(rute=Proyectos[k]['cuenca'], SimSlides=True)
else:
cu = wmf.SimuBasin(rute=Proyectos[k]['cuenca'], SimSlides=False)
Caudales.update({k: {}})
posControl = wmf.models.control[wmf.models.control <> 0]
MapSlides = []
DictSlides = {}
#Itera para cada almacenamiento
for k2 in Proyectos[k]['calibValues'].keys():
#Obtiene la calibracion
Calib = Proyectos[k]['calibValues'][k2]
#Obtiene el almacenamiento
try:
#Mira si hay almacenamiento para esa calibracion
p = Proyectos[k]['storeFile'].keys().index(k2)
# obtiene las rutas del binario y del encabezado de almacenamiento
ListaFin = [i for i in Lista if i.startswith(FechaStart)]
Fechas = [
dt.datetime.strptime(i[:12], '%Y%m%d%H%M') +
dt.timedelta(minutes=int(i[-7:-4])) for i in ListaFin
]
Fechas = [i - dt.timedelta(hours=5) for i in Fechas]
#Obtiene el punto de inicio para que las imagenes sean chevres
Diferencias = [i - fecha for i in Fechas]
Segundos = np.array([i.seconds for i in Diferencias])
pos = np.argmin(Segundos)
#------------------------------------------------------------------------------
#LEE Y DETERMINA FECHAS DE ARCHIVOS CORRESPONDINTES
#------------------------------------------------------------------------------
#inicia la variable de radar y la variable cuenca
cuAMVA = wmf.SimuBasin(rute=args.cuenca)
rad = radar.radar_process()
Lprop = radar.RadProp
Lprop.insert(4, Lprop[-2])
#Trabaja sobre la lista para adicionar campos
rvec = {'media': [], 'baja': [], 'alta': []}
for c, l in enumerate(ListaFin[pos:pos + 12]):
#convierte imagen de radar en lluvia
rad.read_bin(args.ruta + l)
rad.detect_clouds(umbral=500)
rad.ref = rad.ref * rad.binario
rad.DBZ2Rain()
for k in ['media', 'baja', 'alta']:
rv = cuAMVA.Transform_Map2Basin(rad.ppt[k] / 12.0, Lprop)
rvec[k].append(rv)
"Ruta donde se guarda el pickle con el diccionario con las propiedades geomorfologicas de los tramos"
)
parser.add_argument(
"-u",
"--umbral",
help="Umbral para la generacion de red hidrica en la cuenca",
type=float,
default=30)
#lee todos los argumentos
args = parser.parse_args()
#-----------------------------------------------------------------------------------------------------
#Carga la cuenca
#-----------------------------------------------------------------------------------------------------
cu = wmf.SimuBasin(0, 0, 0, 0, rute=args.cuencaNC)
#Carga los nodos
nodos = wmf.models.control[wmf.models.control <> 0]
posicion = np.where(wmf.models.control <> 0)[1]
#Obtiene parametros en los demas lugares (nodos)
x, y = wmf.cu.basin_coordxy(cu.structure, cu.ncells)
DictParam = {}
for pos, nodo in zip(posicion, nodos):
#Calcula la cuenca y param
cu2 = wmf.Basin(x[pos], y[pos], cu.DEM, cu.DIR, umbral=args.umbral)
cu2.GetGeo_Parameters(GetPerim=False)
#Guarda los parametros
DictParam.update({str(nodo): {'Geo': cu2.GeoParameters, 'Tc': cu2.Tc}})
print 'Tiempos de concentracion calculados'
print '\n'
print '###################################### Fecha de Ejecucion: ' + dateText + ' #############################\n'
#Lee el archivo de configuracion
ruta_configuracion_1 = '/media/nicolas/Home/Jupyter/Soraya/git/Alarmas/03_modelo/Op_AMVA60m/configfile.md'
RutasList = al.get_rutesList(ruta_configuracion_1)
# Lee rutas de objetos de entrada
ruta_cuenca = al.get_ruta(RutasList, 'ruta_cuenca')
ruta_campos = al.get_ruta(RutasList, 'ruta_campos')
# Lee rutas de salida - lluvia radar
ruta_out_rain = al.get_ruta(RutasList, 'ruta_rain')
ruta_out_rain_png = al.get_ruta(RutasList, 'ruta_rain_png')
############################################## Se carga la cuenca ########################################################
cuenca = wmf.SimuBasin(rute=ruta_cuenca, SimSlides=True)
##########################################################################################################################
#||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
#||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
print '###################################### CONSULTA DE LA LLUVIA Y EXTRAPOLACION ############################\n'
#-------------------------------------------------------------------
#GENERA EL CAMPO DE LLUVIA DE LOS ULTIMOS 10MIN Y LOS PROXIMOS 60
#-------------------------------------------------------------------
# Obtiene el datetime
fecha_1 = date + dt.timedelta(hours=5) - dt.timedelta(minutes=10)
fecha_2 = date + dt.timedelta(hours=5) + dt.timedelta(minutes=60)
# Lo convierte en texto
fecha1 = fecha_1.strftime('%Y-%m-%d')
def Graph_AcumRain(fechaI,
fechaF,
cuenca,
rutaRain,
rutaFigura,
vmin=0,
vmax=100,
verbose=True):
''' Si hay lluvia en el periodo definido devuelve 1 si no 0.
Grafica si figure=True.
Siempre se debe poner la ruta de la figura.
##Falta poner ventanas mas grandes de pronostico de lluvia ya que el calentamiento con las par y CI actuales se toma unos 25 pasos.'''
#Se lee la informacion
rutebin, rutehdr = wmf.__Add_hdr_bin_2route__(rutaRain)
cu = wmf.SimuBasin(rute=cuenca)
DictRain = wmf.read_rain_struct(rutehdr)
R = DictRain[u' Record']
#Se cuadran las fechas para que casen con las de los archivos de radar.
#Se obtienen las fechas con minutos en 00 o 05.
####FechaF######
#Obtiene las fechas por dias
fecha_f = pd.to_datetime(fechaF)
fecha_f = fecha_f - pd.Timedelta(str(fecha_f.second) + ' seconds')
fecha_f = fecha_f - pd.Timedelta(str(fecha_f.microsecond) + ' microsecond')
#corrige las fechas
cont = 0
while fecha_f.minute % 5 <> 0 and cont < 10:
fecha_f = fecha_f - pd.Timedelta('1 minutes')
cont += 1
####FechaI######
#Obtiene las fechas por dias
fecha_i = pd.to_datetime(fechaI)
fecha_i = fecha_i - pd.Timedelta(str(fecha_f.second) + ' seconds')
fecha_i = fecha_i - pd.Timedelta(str(fecha_f.microsecond) + ' microsecond')
#corrige las fechas
cont = 0
while fecha_i.minute % 5 <> 0 and cont < 10:
fecha_i = fecha_i - pd.Timedelta('1 minutes')
cont += 1
#Evalua que las fechas solicitadas existan, si no para aqui y no se grafica nada - if solo sirve para ensayos.. operacionalmente no debe hacer nada.
try:
lol = R[fecha_i:fecha_f]
#Ensaya si las fechas solicitadas cuentan con campo de radar en el binario historico, si no escoge la fecha anterior a esa. Este debe existir tambien, lo ideal es que se mantenga el dt, existan campos cada 5 min.
####FechaF######
Flag = True
cont = 0
while Flag:
try:
lol = R.index.get_loc(fecha_f)
Flag = False
except:
print 'Aviso: no existe campo de lluvia para fecha_f en la serie entregada, se intenta buscar el de 5 min antes'
fecha_f = fecha_f - pd.Timedelta('5 minutes')
cont += 1
if cont > 1:
Flag = False
####FechaI######
Flag = True
cont = 0
while Flag:
try:
lol = R.index.get_loc(fecha_i)
Flag = False
except:
print 'Aviso: no existe campo de lluvia para fecha_i en la serie entregada, se intenta buscar el de 5 min antes'
fecha_i = fecha_i - pd.Timedelta('5 minutes')
cont += 1
if cont > 1:
Flag = False
#Escoge pos de campos con lluvia dentro del periodo solicitado.
pos = R[fecha_i:fecha_f].values
pos = pos[pos <> 1]
#~ #imprime el tamano de lo que esta haciendo
#~ if verbose:
#~ print fecha_f - fecha_i
#si hay barridos para graficar
if len(pos) > 0:
#-------
#Grafica
#-------
#Textos para la legenda
#~ lab = np.linspace(vmin, vmax, 4)
#~ texto = ['Bajo', 'Medio', 'Alto', 'Muy alto']
#~ labText = ['%dmm\n%s'%(i,j) for i,j in zip(lab, texto)]
#Acumula la lluvia para el periodo
Vsum = np.zeros(cu.ncells)
for i in pos:
v, r = wmf.models.read_int_basin(rutebin, i, cu.ncells)
v = v.astype(float)
v = v / 1000.0
Vsum += v
#Genera la figura
c = cu.Plot_basinClean(
Vsum,
cmap=pl.get_cmap('viridis', 10),
vmin=vmin,
vmax=vmax, #~ show_cbar=True,
#~ cbar_ticksize = 16,
#~ cbar_ticks= lab,
#~ cbar_ticklabels = labText,
#~ cbar_aspect = 17,
ruta=rutaFigura,
figsize=(10, 12),
show=False)
c[1].set_title('Mapa Lluvia de Radar Acumulada', fontsize=16)
if verbose:
print 'Aviso: Se ha producido una grafica nueva con valores diferentes de cero para ' + rutaFigura[
49:-4]
print fecha_f - fecha_i
return 1
#si no hay barridos
else:
#-------
#Grafica
#-------
Vsum = np.zeros(cu.ncells)
c = cu.Plot_basinClean(
Vsum,
cmap=pl.get_cmap('viridis', 10),
vmin=vmin,
vmax=vmax, #show_cbar=True,
#~ cbar_ticksize = 16,
#~ cbar_ticks= lab,
#~ cbar_ticklabels = labText,
#~ cbar_aspect = 17,
ruta=rutaFigura,
figsize=(10, 12),
show=False)
#~ c[1].set_title('Mapa Lluvia de Radar Acumulada', fontsize=16)
if verbose:
print 'Aviso: Se ha producido un campo sin lluvia para ' + rutaFigura[
49:-4]
print fecha_f - fecha_i
return 0
except:
#si no lo logra que no haga nada.
print 'Aviso: no se puede construir una serie porque las fechas solicitada no existen, no se genera png de acumulado ' + str(
fecha_f - fecha_i)
pass
PosDates = []
pos1 = [0]
for d1,d2 in zip(datesDt[:-1],datesDt[1:]):
pos2 = np.where((datesDias<d2) & (datesDias>=d1))[0].tolist()
if len(pos2) == 0:
pos2 = pos1
else:
pos1 = pos2
PosDates.append(pos2)
#-------------------------------------------------------------------------------------------------------------------------------------
#CARGADO DE LA CUENCA SOBRE LA CUAL SE REALIZA EL TRABAJO DE OBTENER CAMPOS
#-------------------------------------------------------------------------------------------------------------------------------------
#Carga la cuenca del AMVA
cuAMVA = wmf.SimuBasin(rute = args.cuenca)
cuConv = wmf.SimuBasin(rute = args.cuenca)
cuStra = wmf.SimuBasin(rute = args.cuenca)
cuHigh = wmf.SimuBasin(rute = args.cuenca)
cuLow = wmf.SimuBasin(rute = args.cuenca)
#si el binario el viejo, establece las variables para actualizar
if args.old:
cuAMVA.rain_radar2basin_from_array(status='old',ruta_out= args.rutaRes)
if args.save_class:
cuAMVA.rain_radar2basin_from_array(status='old',ruta_out= args.rutaRes + '_conv')
cuAMVA.rain_radar2basin_from_array(status='old',ruta_out= args.rutaRes + '_stra')
if args.save_escenarios:
cuHigh.rain_radar2basin_from_array(status='old',ruta_out= args.rutaRes + '_high')
cuLow.rain_radar2basin_from_array(status='old',ruta_out= args.rutaRes + '_low')
#Itera sobre las fechas para actualizar el binario de campos
"--coord",
help="Escribe archivo con coordenadas",
default=False,
type=bool)
parser.add_argument("-v",
"--verbose",
help="Informa sobre la fecha que esta agregando",
action='store_true')
#lee todos los argumentos
args = parser.parse_args()
#-------------------------------------------------------------------------------------------------------
#-------------------------------------------------------------------------------------------------------
#Lectura de cuenca y variables
cu = wmf.SimuBasin(rute=args.cuenca, SimSlides=True)
wmf.models.slide_allocate(cu.ncells, 10)
#Se marcan con 1 las celdas incondicionalmente inestables.
R = np.copy(wmf.models.sl_riskvector)
R1 = np.zeros(cu.ncells)
pos_ever = np.where(R == 2)[1]
R1[pos_ever] = 1
#Lee el archivo de configuracion
ListConfig = al.get_rutesList(args.rutaConfig)
#Se define ruta donde se leeran los resultados a plotear
ruta_in = al.get_ruta(ListConfig, 'ruta_slides')
#Lectura de rutas de salida de la imagen
ruta_out = al.get_ruta(ListConfig, 'ruta_map_slides')
#Diccionario con info de plot: se lee la info de todos los parametrizaciones
ListPlotVar = al.get_modelConfig_lines(ListConfig,
def plot_acum_radar():
#DEFINICION DE COSAS
rutafig = '/media/nicolas/Home/Jupyter/Soraya/Op_Alarmas/Result_to_web/operacional/acum_radar/'
selfN = cprv1.Nivel(codigo=260,
user='******',
passwd='s@mple_p@ss',
SimuBasin=True)
codigos = selfN.infost.index[:]
#setting the est indexes and order.
pos_1st = [51, 36, 37, 40, 54, 64]
codigos = np.delete(codigos, pos_1st)
codigos = np.insert(codigos, 0, 260)
#time windows
windows_t = ['30m_ahead', '10m', '5m', '3h'] #,'6h','24h','3d']
#PLOTS
for window_t in windows_t[:2]:
print window_t
if window_t == '30m_ahead':
start = pd.to_datetime('2019-05-09 22:00')
# start= fs.round_time(dt.datetime.now())
end = start + pd.Timedelta('30m')
else:
end = pd.to_datetime('2019-05-09 22:00')
# end = fs.round_time(dt.datetime.now())
start = end - pd.Timedelta(window_t)
path_basins = '/media/nicolas/maso/Mario/basins/'
#acumulado para la cuenca mas grande
path_radtif = '/media/nicolas/maso/Soraya/op_files/radar/tifs/260-' + window_t + '.tif'
dfAll, rvec = fs.get_radar_rain(
start,
end,
300.,
path_basins + '%s.nc' % (260),
codigos,
accum=True,
path_tif=
path_radtif, #+start.strftime('%Y%m%d%H%M')+'_'+start.strftime('%Y%m%d%H%M')+'.tif',
meanrain_ALL=True)
dfAll.to_csv(rutafig + window_t + '/dfAcum' + window_t + '.csv')
#plots
for codigo in codigos[0:]:
if '%s.nc' % (codigo) in os.listdir(path_basins):
cu = wmf.SimuBasin(rute=path_basins + '%s.nc' % (codigo))
a, b = wmf.read_map_raster(path_radtif)
vec_rain = cu.Transform_Map2Basin(a, b)
#Plot
fig = pl.figure(figsize=(10, 12))
ax = fig.add_subplot(111)
if window_t == '30m_ahead':
fs.plot_basin_rain(cu,
vec_rain,
codigo,
window_t='30m',
ax=ax,
cbar=True)
else:
fs.plot_basin_rain(cu,
vec_rain,
codigo,
window_t='30m',
ax=ax,
cbar=True)
ax.set_title('Est. ' + str(codigo) + ' | ' +
selfN.infost.loc[codigo].nombre + '\n' +
pd.to_datetime(start).strftime('%Y%m%d%H%M') +
'-' + pd.to_datetime(end).strftime('%Y%m%d%H%M'))
pl.savefig(rutafig + window_t + '/' +
selfN.infost.loc[codigo].slug + '.png',
bbox_inches='tight')