def update_run_model(varlist,
it,
m=m,
homogenous=2,
runyn=True,
plotyn=False,
silent=True,
start_basecase=True,
f_basecase=None,
pooling=True,
output=None,
results=[]):
# Make timestamp
ts = utils.make_timestamp()
print('Running it {} at time {}'.format(it, ts))
if start_basecase:
strt, sconc = get_base_hds_conc(basecase_ws)
if pooling:
model_ws_orig = Path(m.model_ws).as_posix() + ''
tmp = Path(model_ws).joinpath('tmp{}'.format(it))
if not tmp.exists():
tmp.mkdir()
m.model_ws = tmp.as_posix()
print('temp ws', m.model_ws)
# unpack values from varlist
vka = varlist['vka'][it]
al = varlist['al'][it]
dmcoef = varlist['dmcoef'][it]
ss = varlist['ss'][it]
sy = varlist['sy'][it]
riv_stg = varlist['riv_stg'][it]
riv_cond = varlist['riv_cond'][it]
head_inland_sum = varlist['head_inland_sum'][it]
head_inland_wint = varlist['head_inland_wint'][it]
wel = varlist['wel'][:, it]
rech_farm_pct = varlist['rech_farm'][0]
farm_size = (200, 200)
rech_farm = [rech_farm_pct * flx / np.prod(farm_size) for flx in wel]
rech_precip = varlist['rech'][it]
CF_glob = varlist['CF_glob'][it]
CF_var = varlist['CF_var'][it]
seed = varlist['seed'][it]
hk_mean = varlist['hk_mean'][it]
hk_var = varlist['hk_var'][it]
por_mean = varlist['por_mean'][it]
por_var = varlist['por_var'][it]
corr_len = varlist['corr_len'][it]
corr_len_yx = varlist['corr_len_yx'][it]
corr_len_zx = varlist['corr_len_zx'][it]
clay_lyr_yn = varlist['clay_lyr_yn'][it]
vario_type = varlist['vario_type'][it]
#set ghb data and create dicts
chd_data, ssm_data_base, ghb_data, wel_data_base = make_bc_dicts(
(head_inland_sum, head_inland_wint))
utils.save_obj(m.MC_file.parent, wel_data_base, 'wel_data_base')
utils.save_obj(m.MC_file.parent, ssm_data_base, 'ssm_data_base')
ssm_data = {}
# write recharge data
rech_farm_mat = np.zeros((nrow, ncol), dtype=np.float32)
for i in range(len(rech_farm)):
rech_farm_mat[farm_loc_list[i]] = rech_farm[i]
rech_data = {}
for i in range(len(perlen)):
if i in kper_even:
rech_data[i] = rech_precip
elif i in kper_odd:
rech_data[i] = rech_farm_mat
# write wel data
# ssm_data_base = load_obj(m.MC_file.parent, 'ssm_data_base')
# wel_data_base = load_obj(m.MC_file.parent, 'wel_data_base')
wel_data, ssm_data, wel_cells = add_pumping_wells(wel_data_base,
ssm_data_base,
n_wells,
flx=wel,
rowcol=farm_orig,
kper=kper_odd)
if homogenous == 1:
CF_grid = 1
hk_grid = 10**hk_mean
por_grid = .4
elif homogenous == 2:
#Create Gaussian Simulation
lcol = int(corr_len / delr)
llay = int(corr_len * corr_len_zx / np.mean(delv))
lrow = int(corr_len * corr_len_yx / delc)
# fft_grid = np.exp(simulationFFT.simulFFT(nrow, nlay, ncol, mu, sill, vario_type, lrow , llay, lcol))
CF_grid = simulationFFT.simulFFT(nrow,
nlay,
ncol,
CF_glob,
CF_var,
vario_type,
lrow,
llay,
lcol,
seed=seed)
hk_grid = 10**normal_transform(CF_grid, CF_glob, hk_mean,
np.sqrt(CF_var), np.sqrt(hk_var))
por_grid = normal_transform(CF_grid, CF_glob, por_mean,
np.sqrt(CF_var), np.sqrt(por_var))
CF_grid[CF_grid > 1.] = 1.
CF_grid[CF_grid < 0.] = 0.
por_grid[por_grid > 1.] = .99
por_grid[por_grid < 0.] = 0.01
hk_grid[wel_cells] = np.max((hk_grid.max(), 200))
# np.save(m.MC_file.parent.joinpath('{}_hk.npy'.format(ts)),hk_grid)
else:
pass
# # Write river data--take SSM data from WEL!!
# riv_grad = .0005
# riv_data, ssm_data = write_river_data(
# riv_loc, riv_stg, riv_cond, riv_grad, kper_even, ssm_data)
ipakcb = 53
icbund = np.ones((nlay, nrow, ncol), dtype=np.int)
icbund[np.where(m.bas6.ibound.array == -1)] = -1
timprs = np.round(np.linspace(1, np.sum(perlen), 20), decimals=0)
oc_data = {}
for kper in range(nper):
if kper % 5 == 0:
oc_data[(kper, 0)] = ['save head', 'save budget']
flopy.modflow.ModflowBas(m, m.bas6.ibound.array, strt=strt)
flopy.modflow.ModflowDis(m,
nlay,
nrow,
ncol,
nper=nper,
delr=delr,
delc=delc,
laycbd=0,
top=henry_top,
botm=henry_botm,
perlen=perlen,
nstp=nstp,
steady=steady,
itmuni=itmuni,
lenuni=lenuni,
tsmult=tsmult)
flopy.modflow.ModflowGhb(m, stress_period_data=ghb_data)
flopy.modflow.ModflowWel(m, stress_period_data=wel_data, ipakcb=ipakcb)
## REMOVED FOR CONFINED SIMULATION ##
# flopy.modflow.ModflowRch(m, rech=rech_data)
# flopy.modflow.ModflowRiv(m, stress_period_data=riv_data)
# Add LPF package to the MODFLOW model
flopy.modflow.ModflowLpf(m,
hk=hk_grid,
vka=vka,
ipakcb=ipakcb,
laytyp=0,
laywet=1,
ss=ss,
sy=sy)
# Add PCG Package to the MODFLOW model
flopy.modflow.ModflowPcg(m, hclose=1.e-8)
# Add OC package to the MODFLOW model
flopy.modflow.ModflowOc(m, stress_period_data=oc_data, compact=True)
# Create the basic MT3DMS model structure
flopy.mt3d.Mt3dBtn(m,
laycon=m.lpf.laytyp,
htop=henry_top,
dz=m.dis.thickness.get_value(),
prsity=por_grid,
icbund=icbund,
sconc=sconc,
nprs=1,
timprs=timprs)
flopy.mt3d.Mt3dAdv(m, mixelm=-1)
flopy.mt3d.Mt3dDsp(m, al=al, dmcoef=dmcoef)
flopy.mt3d.Mt3dGcg(m, iter1=50, mxiter=1, isolve=1, cclose=1e-5)
flopy.mt3d.Mt3dSsm(m, stress_period_data=ssm_data)
#vdf = flopy.seawat.SeawatVdf(m, iwtable=0, densemin=0, densemax=0,denseref=1000., denseslp=0.7143, firstdt=1e-3)
flopy.seawat.SeawatVdf(m,
mtdnconc=1,
mfnadvfd=1,
nswtcpl=0,
iwtable=1,
densemin=0.,
densemax=0.,
denseslp=denseslp,
denseref=densefresh)
# Write input
m.write_input()
# Try to delete the output files, to prevent accidental use of older files
flist = [
os.path.join(model_ws, 'MT3D.CNF'),
os.path.join(model_ws, 'MT3D001.MAS'),
os.path.join(model_ws, modelname + '.hds'),
os.path.join(model_ws, 'MT3D001.UCN'),
os.path.join(model_ws, 'MT3D001.UCN'),
os.path.join(model_ws, modelname + '.cbc')
]
for f in flist:
try:
os.remove(f)
except:
pass
# Plot model?
if plotyn:
m.plot_hk_ibound(rowslice=farm_orig[0][0], gridon=True)
# Run model
if runyn:
v = m.run_model(silent=silent, report=True)
for idx in range(-3, 0): # Report
print(v[1][idx])
# Record success/failure and store data
varlist['success'][it] = v[0]
if v[0] is False:
pass
else:
# Record final salinity as .npy, also move full CBC and UCN files
# to expt folder
fname = os.path.join(m.model_ws, 'MT3D001.UCN')
totim = flopy.utils.binaryfile.UcnFile(fname).get_times()[-1]
conc_fname = 'conc{}_{}_totim{}.UCN'.format(
it, ts, str(int(totim)))
_ = record_salinity(
m,
ts_hms=ts,
fname_write=m.MC_file.parent.joinpath(conc_fname))
utils.copy_rename(os.path.join(m.model_ws, 'MT3D001.UCN'),
m.MC_file.parent.joinpath(conc_fname).as_posix())
if pooling:
try:
# [print(p) for p in tmp.iterdir() if (p.suffix is not '.UCN')]
[
p.unlink() for p in tmp.iterdir()
if (p.suffix not in ('.UCN', '.list'))
]
# shutil.rmtree(tmp.as_posix())
# tmp.rmdir()
except:
print('didnt work!')
pass
m.model_ws = model_ws_orig
print('resetting ws:', m.model_ws)
if output is None:
return (it, varlist['success'][it])
else:
output.put((it, varlist['success'][it]))
# results.append((it,varlist['success'][it]))
return
else:
utils.save_obj(m.MC_file.parent, (it, varlist['success'][it]),
'success{}'.format(it))
[
p.unlink() for p in model_ws.iterdir()
if (p.suffix not in ('.UCN', '.list'))
]
return m, varlist
def run_MC(tot_it,plotyn=False):
#### MAKE NEW/ADD TO OLD EXPT ####
check_MC_inputParams()
#### VARY PARAMS ####
it = 0
while it < tot_it:
ssm_data = {}
it += 1
''' HOMOGENOUS ONLY
#hk
low,high= (-3,0)
parname='hk'
val = sample_dist(sts.uniform,1,*(low,high-low))
add_to_paramdict(m.inputParams,parname,val)
hk = 10**val
'''
#########HETEROGENOUS ONLY ##############
#hk1
low= -2
high = 0
parname='hk1'
val = sample_dist(sts.uniform,1,*(low,high-low))
add_to_paramdict(m.inputParams,parname,val)
hk1 = 10**val
#hk2
low= 0
high = 2
parname='hk2'
val = sample_dist(sts.uniform,1,*(low,high-low))
add_to_paramdict(m.inputParams,parname,val)
hk2 = 10**val
#lith_prop
low= 0
high = 0.3
parname='lith_prop'
val = sample_dist(sts.uniform,1,*(low,high-low))
add_to_paramdict(m.inputParams,parname,val)
lith_prop = val
#vario_type
parname='vario_type'
val = int(round(np.random.rand()))
add_to_paramdict(m.inputParams,parname,val)
if val==1:
vario_type = 'Gaussian'
elif val==0:
vario_type = 'Exponential'
else:
pass
#corr_len
low= 250
high = 1000
parname='corr_len'
val = sample_dist(sts.uniform,1,*(low,high-low))
add_to_paramdict(m.inputParams,parname,val)
corr_len = val
#corr_len_zx
# equal to lz/lx
low= .01
high = .1
parname='corr_len_zx'
val = sample_dist(sts.uniform,1,*(low,high-low))
add_to_paramdict(m.inputParams,parname,val)
corr_len_zx = val
#corr_len_yx
# equal to ly/lx
low= 0.1
high = 1
parname='corr_len_yx'
val = sample_dist(sts.uniform,1,*(low,high-low))
add_to_paramdict(m.inputParams,parname,val)
corr_len_yx = val
#Create hk grid
mu = np.log(hkSand)
sill = 1
lcol = int(corr_len/delr)
llay = int(corr_len*corr_len_zx/np.mean(delv))
lrow = int(corr_len*corr_len_yx/delc)
fft_grid = np.exp(simulationFFT.simulFFT(nrow, nlay, ncol, mu, sill, vario_type, lrow , llay, lcol))
grid = np.log10(fft_grid)
lith_props = [lith_prop,1-lith_prop]
hk_vals = [hk1,hk2]
hk = truncate_grf(grid,lith_props,hk_vals,log10trans=False,plotyn=plotyn)
hk[wel_cells] = hk.max()
######## END OF HETEROGENOUS BLOCK ############
##vka: ratio of vk/hk
# Uniform (1/20,1)
low= 1/20
high = 1
parname='vka'
val = sample_dist(sts.uniform,1,*(low,high-low))
add_to_paramdict(m.inputParams,parname,val)
vka = val
##al: #longitudinal dispersivity (m)
# Uniform [0.1,20] #10 from Walther et al
low= 0.1
high = 20
parname='al'
val = sample_dist(sts.uniform,1,*(low,high-low))
add_to_paramdict(m.inputParams,parname,val)
al = val
##dmcoef: #dispersion coefficient (m2/day)
# log-uniform [1e-10,1e-5] #2e-9 from Walther et al
low,high = np.log10([1e-10,1e-5])
parname='dmcoef'
val = sample_dist(sts.uniform,1,*(low,high-low))
add_to_paramdict(m.inputParams,parname,val)
dmcoef = 10**val
##wel
low,high = np.log10((1e1,1e3))
parname='wel'
val = sample_dist(sts.uniform,n_wells,*(low,high-low))
wel_flux = val
for i in range(n_wells):
parname_temp = parname+str(i)
add_to_paramdict(m.inputParams,parname_temp,wel_flux[i])
#write wel data
ssm_data_base = load_obj(m.MC_file.parent,'ssm_data_base')
wel_data_base = load_obj(m.MC_file.parent,'wel_data_base')
wel_data,ssm_data,_ = add_pumping_wells(wel_data_base,ssm_data_base,n_wells,wel_flux,farm_orig,kper_odd)
##rech_precip
low,high = np.log10([1e-6,1e-1])
val = sample_dist(sts.uniform,1,*(low,high-low))
parname='rech_precip'
add_to_paramdict(m.inputParams,parname,val)
rech_precip = 10**val/(nrow*ncol)
#rech_farm
low,high = [0.05,0.2] #percentage of the well extraction
val = sample_dist(sts.uniform,1,*(low,high-low))
parname='rech_farm'
add_to_paramdict(m.inputParams,parname,val)
rech_farm = [val*flux/np.prod(farm_size) for flux in wel_flux]
#Assign recharge data
rech_farm_mat = np.zeros((nrow,ncol),dtype=np.float32)
for i in range(nfarms):
rech_farm_mat[farm_loc_list[i]] = rech_farm[i]
rech_data = {}
for i in range(len(perlen)):
if i in kper_even:
rech_data[i] = rech_precip
elif i in kper_odd:
rech_data[i] = rech_farm_mat
##riv_stg
low,high = (.5,1.5)
val = sample_dist(sts.uniform,1,*(low,high-low))
parname='riv_stg'
add_to_paramdict(m.inputParams,parname,val)
riv_stg = val
##riv_cond
low,high = np.log10((.1,100))
val = sample_dist(sts.uniform,1,*(low,high-low))
parname='riv_cond'
add_to_paramdict(m.inputParams,parname,val)
riv_cond = val
#Write river data--take SSM data from WEL!!
riv_grad = .0005
riv_data,ssm_data = write_river_data(riv_loc,stage,cond,riv_grad,kper_even,ssm_data)
#Create instances in flopy
bas = flopy.modflow.ModflowBas(m, ibound, strt=strt)
if bc_ocean=='CHD' or bc_inland=='CHD' :
chd = flopy.modflow.ModflowChd(m, stress_period_data=chd_data)
if bc_ocean=='GHB' or bc_inland=='GHB'or bc_right_edge=='GHB':
ghb = flopy.modflow.ModflowGhb(m, stress_period_data=ghb_data)
rch = flopy.modflow.ModflowRch(m, rech=rech_data)
wel = flopy.modflow.ModflowWel(m, stress_period_data=wel_data, ipakcb=ipakcb)
riv = flopy.modflow.ModflowRiv(m, stress_period_data=riv_data)
# Add LPF package to the MODFLOW model
lpf = flopy.modflow.ModflowLpf(m, hk=hk, vka=vka, ipakcb=ipakcb,laytyp=1,laywet=1,
ss=ss,sy=sy)
# Add PCG Package to the MODFLOW model
pcg = flopy.modflow.ModflowPcg(m, hclose=1.0e-8)
# Add OC package to the MODFLOW model
oc = flopy.modflow.ModflowOc(m,
stress_period_data=oc_data,
compact=True)
#Create the basic MT3DMS model structure
btn = flopy.mt3d.Mt3dBtn(m,
laycon=lpf.laytyp, htop=henry_top,
dz=dis.thickness.get_value(), prsity=por, icbund=icbund,
sconc=sconc, nprs=1,timprs=timprs)
adv = flopy.mt3d.Mt3dAdv(m, mixelm=-1)
dsp = flopy.mt3d.Mt3dDsp(m, al=al, dmcoef=dmcoef)
gcg = flopy.mt3d.Mt3dGcg(m, iter1=50, mxiter=1, isolve=1, cclose=1e-5)
ssm = flopy.mt3d.Mt3dSsm(m, stress_period_data=ssm_data)
#vdf = flopy.seawat.SeawatVdf(m, iwtable=0, densemin=0, densemax=0,denseref=1000., denseslp=0.7143, firstdt=1e-3)
vdf = flopy.seawat.SeawatVdf(m, mtdnconc=1, mfnadvfd=1, nswtcpl=0, iwtable=1,
densemin=0., densemax=0., denseslp=denseslp, denseref=densefresh)
#Write input
'''DEBUG SIMPLIFYING
m.remove_package('RIV')
m.remove_package('RCH')
m.remove_package('WEL')
ssm_data = load_obj(m.MC_file.parent,'ssm_data_base')
wel_data = load_obj(m.MC_file.parent,'wel_data_base')
DEBUG SIMPLIFYING'''
m.write_input()
# Try to delete the output files, to prevent accidental use of older files
flist = [os.path.join(model_ws,'MT3D.CNF'),
os.path.join(model_ws,'MT3D001.MAS'),
os.path.join(model_ws, modelname + '.hds'),
os.path.join(model_ws, 'MT3D001.UCN'),
os.path.join(model_ws, 'MT3D001.UCN'),
os.path.join(model_ws, modelname + '.cbc')]
for f in flist:
try:
os.remove(f)
except:
print('did not find file to remove: {}'.format(f))
#Make timestamp
import datetime
sep = '-'
ts = datetime.datetime.now().strftime('%m'+sep+'%d'+sep+'%H'+sep+'%M'+sep+'%S')
ts_hms = ts.split(sep)[2:]
ts_hms = sep.join(ts_hms)
if plotyn:
m.plot_hk_ibound(rowslice=rowslice,gridon=gridon)
#Run model
print('Running iteration {} of {}...'.format(it,tot_it))
v = m.run_model(silent=False, report=True)
for idx in range(-3, 0):
print(v[1][idx])
if v[0]:
#Record final salinity as .npy, also move full CBC and UCN files to expt folder
_ = record_salinity(m,ts_hms=ts_hms);
copy_rename(os.path.join(m.model_ws,'MT3D001.UCN'),m.MC_file.parent.joinpath('conc_'+ts_hms+'.UCN').as_posix())
#copy_rename(os.path.join(m.model_ws,m.name+'.cbc'),m.MC_file.parent.joinpath('cbc_'+ts_hms+'.cbc').as_posix())
print('Finished iteration {} of {} successfully'.format(it,tot_it))
else:
print('Unsuccessful iteration {} of {}'.format(it,tot_it))
m.inputParams = rem_last_ind_from_dict(m.inputParams)
#Save inputParams immediately to prevent accidental destruction of them
savemat(m.MC_file.parent.joinpath('inputParams.mat').as_posix(),m.inputParams)
np.save(m.MC_file.parent.joinpath('inputParams.npy'),m.inputParams)
save_obj(m.MC_file.parent,m.inputParams,'inputParams')
save_obj(m.MC_file.parent,m.dis.get_node_coordinates(),'yxz')
return m.inputParams,ssm_data
def create_CF_from_dir(dirname,
ucn_dict=None,
modsize=(26, 20, 100),
varlist=None,
ftype='mat',
saveyn=True):
import simulationFFT
nlay, nrow, ncol = modsize
delv, delc, delr = (3, 30, 30)
if varlist is None:
varlist = load_obj(dirname, 'varlist_final')
if ucn_dict is None:
try:
ucn_dict = load_obj(dirname, 'ucn_dict')
except:
ucn_dict = create_ucn_from_dir(dirname,
totims=(1, 180, 360),
saveyn=False)
CF_mat = {}
for it in ucn_dict.keys():
CF_glob = varlist['CF_glob'][it]
CF_var = varlist['CF_var'][it]
seed = varlist['seed'][it]
corr_len = varlist['corr_len'][it]
corr_len_yx = varlist['corr_len_yx'][it]
corr_len_zx = varlist['corr_len_zx'][it]
vario_type = varlist['vario_type'][it]
#Create Gaussian Simulation
lcol = int(corr_len / delr)
llay = int(corr_len * corr_len_zx / delv)
lrow = int(corr_len * corr_len_yx / delc)
CF_mat['CF{}'.format(it)] = simulationFFT.simulFFT(nrow,
nlay,
ncol,
CF_glob,
CF_var,
vario_type,
lrow,
llay,
lcol,
seed=seed)
if saveyn:
if ftype == 'mat':
from scipy.io import savemat
savemat(dirname.joinpath('CF_mat.mat'),
CF_mat,
do_compression=True)
print('saved {}'.format(dirname.joinpath('CF_mat.mat')))
elif ftype == 'npy':
from numpy import save
for k, v in CF_mat.items():
save(dirname.joinpath('CF_mat{}.npy'.format(k)), v)
print('saved {}'.format(
dirname.joinpath('conc_mat{}.npy'.format(k))))
else:
raise (Exception('allowed ftypes: "mat", "npy"'))
return CF_mat
#Hydraulic conductivity field
hkSand = 10. #horizontal hydraulic conductivity m/day
hkClay = hkSand*.01
heterogenous = True
mu = np.log(hkSand)
sill = .1
modeltype = 'Exponential'
llay = int(20/np.mean(delv))
lrow = int(2000/delc)
lcol = int(2000/delr)
if heterogenous:
import simulationFFT
fft_grid = np.exp(simulationFFT.simulFFT(nrow, nlay, ncol, mu, sill, modeltype, lrow , llay, lcol))
#hk[0:int(np.where(henry_botm==find_nearest(henry_botm,ocean_elev))[0])+1,:,:] = hkSand
else:
hk = hkSand*np.ones((nlay,nrow,ncol), dtype=np.int32)
grid = np.log10(fft_grid)
#lith_props = [0.2,0.5,0.3]
#hk_vals = [-1,0,2]
lith_props = [0.2,0.8]
hk_vals = [0,2]
log10trans = True
plotyn= True
hk = truncate_grf(grid,lith_props,hk_vals,log10trans=True,plotyn=plotyn)