Ejemplo n.º 1
0
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,
                                       '-p',
                                       Calib_Storage='Plot',
                                       PlotType='Slides')

#construye las listas para plotear en paralelo para cada parametrizacion
#Ademas se acumula el numero de celdas acumuladas de todas las parametrizaciones.
ListaEjec = []
Vsum = np.zeros(cu.ncells)

for l in range(0, len(ListPlotVar)):
    #Mira la ruta del folder y si no existe la crea
    ruta_folder = ruta_out + ListPlotVar[l] + '/'
    Esta = glob.glob(ruta_folder)
    if len(Esta) == 0:
        os.system('mkdir ' + ruta_folder)
    #Obtiene las rutas de los archivos de salida
    ruta_out_png = ruta_folder + 'Slides' + ListPlotVar[
Ejemplo n.º 2
0
wmf.models.retorno = float(DictParam['Retorno'])
# Prepara los que son binarios (1) si (0) no
if DictParam['Almacenamiento medio'] == 'True':
	wmf.models.show_storage = 1
if DictParam['Separar Flujos'] == 'True':
	wmf.models.separate_fluxes = 1
if DictParam['Simular Deslizamientos'] == 'True':
	wmf.models.sim_slides = 1
	wmf.models.sl_fs = float(DictParam['Factor de Seguridad FS'])
	cu.set_Slides(wmf.models.sl_zs * float(DictParam['Factor Corrector Zg']), 'Zs')
print wmf.models.sl_zs.mean()

############################ LECTURA DE CALIBRACIONES #############################

#Lista de calibraciones
DictCalib = al.get_modelConfig_lines(ListConfig, '-c', 'Calib')
DictStore = al.get_modelConfig_lines(ListConfig, '-s', 'Store')

############################ EJECUCION ###########################################

#Prepara las ejecuciones
ListEjecs = []
Npasos = DataRain[u' Record'].shape[0]
for i in DictStore.keys():
	#trata de leer el almacenamiento 
	FileName = glob.glob(ruta_sto + DictStore[i]['Nombre'])
	if len(FileName):
		S = wmf.models.read_float_basin_ncol(ruta_sto+DictStore[i]['Nombre'],1,cu.ncells,5)[0]
	else:
		#no tiene sentido que las par que se pusieron corran sin sus C.I.
		#~ S = al.model_get_constStorage(List, cu.ncells)
Ejemplo n.º 3
0
	default = 1, type = int)
parser.add_argument("-v","--verbose",help="Informa sobre la fecha que esta agregando", 
	action = 'store_true')
	
#lee todos los argumentos
args=parser.parse_args()

#-------------------------------------------------------------------------------------------------------
#-------------------------------------------------------------------------------------------------------
#Lee el archivo de configuracion
ListConfig = al.get_rutesList(args.rutaConfig)
#Lectura de rutas
ruta_qsim = al.get_ruta(ListConfig,'ruta_map_qsim')
ruta_sto = al.get_ruta(ListConfig,'ruta_almsim')
#Dicctionario con info de plot
ListPlotVar = al.get_modelConfig_lines(ListConfig, '-p', Calib_Storage='Plot',PlotType='Qsim_map')
DictStore = al.get_modelConfig_lines(ListConfig, '-s', 'Store')

#-------------------------------------------------------------------------------------------------------
#-------------------------------------------------------------------------------------------------------
#Lectura de cuenca y variables
cu = wmf.SimuBasin(rute=args.cuenca)
#lectura de constantes 
qmed = cu.Load_BasinVar('qmed')
horton = cu.Load_BasinVar('horton')
cauce = cu.Load_BasinVar('cauce')

#construye las listas para plotear en paralelo
ListaEjec = []
for l in ListPlotVar:
	ruta_in = ruta_sto + DictStore['-s '+l]['Nombre']
Ejemplo n.º 4
0
DataRain = wmf.read_rain_struct(rain_hdr)
Rain = wmf.read_mean_rain(rain_hdr)
ruta_rain_hist = al.get_ruta(ListConfig, 'ruta_rainHistoryFile')
ruta_rain_temp =  '/var/tmp/RainTemp.hdr'

#Lee archivo de configuracion y la cuenca, almacenamiento 
ruta_sto = al.get_ruta(ListConfig, 'ruta_almsim')
ruta_bck_sto = al.get_ruta(ListConfig, 'ruta_bkc_alm')

#Delta de tiempo
DeltaT = float(al.get_ruta(ListConfig, 'Dt[seg]'))

############################ DICCIONARIOS CON DATOS #############################

#Lista de calibraciones
DictStore = al.get_modelConfig_lines(ListConfig, '-s', 'Store')
DictUpdate = al.get_modelConfig_lines(ListConfig, '-t', 'Update')

############################ ACTUALIZACION ###########################################

#Fecha Actual pasada como parametro
DateNow = pd.to_datetime(args.date)
#Calcula la cantidad de horas desde la ultima actualizacion
for k in DictUpdate.keys():
	dat = pd.to_datetime(DictUpdate[k]['LastUpdate'])
	deltaT = DateNow - dat
	DictUpdate[k].update({'Horas': deltaT.total_seconds()/3600.0})
#si la cantidad de horas es inferior al umbral evalua si cumple la 
#regla establecida 
for k in DictStore.keys():
	#Evalua si esas condiciones se van a actualizar o no, y si cumplen