def api_func(exe, idx, model_ws=None):
success = False
name = ex[idx].upper()
if model_ws is None:
model_ws = "."
try:
mf6 = ModflowApi(exe, working_directory=model_ws)
except Exception as e:
print("Failed to load " + exe)
print("with message: " + str(e))
return api_return(success, model_ws)
# initialize the model
try:
mf6.initialize()
except:
return api_return(success, model_ws)
# time loop
current_time = mf6.get_current_time()
end_time = mf6.get_end_time()
# get copy of (multi-dim) array with river parameters
riv_tag = mf6.get_var_address("BOUND", name, riv_packname)
new_spd = mf6.get_value(riv_tag)
# model time loop
idx = 0
while current_time < end_time:
# get dt
dt = mf6.get_time_step()
# prepare... and reads the RIV data from file!
mf6.prepare_time_step(dt)
# set the RIV data through the BMI
if current_time < 5:
# set columns of BOUND data (we're setting entire columns of the
# 2D array for convenience, setting only the value for the active
# stress period should work too)
new_spd[:] = [riv_stage, riv_cond, riv_bot]
mf6.set_value(riv_tag, new_spd)
else:
# change only stage data
new_spd[:] = [riv_stage2, riv_cond, riv_bot]
mf6.set_value(riv_tag, new_spd)
kiter = 0
mf6.prepare_solve()
while kiter < nouter:
has_converged = mf6.solve()
kiter += 1
if has_converged:
msg = ("Component {}".format(1) +
" converged in {}".format(kiter) + " outer iterations")
print(msg)
break
if not has_converged:
return api_return(success, model_ws)
# finalize time step
mf6.finalize_solve()
# finalize time step and update time
mf6.finalize_time_step()
current_time = mf6.get_current_time()
# increment counter
idx += 1
# cleanup
try:
mf6.finalize()
success = True
except:
return api_return(success, model_ws)
# cleanup and return
return api_return(success, model_ws)
def api_func(exe, idx, model_ws=None):
success = False
name = ex[idx].upper()
if model_ws is None:
model_ws = "."
try:
mf6 = ModflowApi(exe, working_directory=model_ws)
except Exception as e:
print("Failed to load " + exe)
print("with message: " + str(e))
return api_return(success, model_ws)
# initialize the model
try:
mf6.initialize()
except:
return api_return(success, model_ws)
# time loop
current_time = mf6.get_current_time()
end_time = mf6.get_end_time()
# get pointer to simulated heads
head_tag = mf6.get_var_address("X", "LIBGWF_EVT01")
head = mf6.get_value_ptr(head_tag)
# maximum outer iterations
mxit_tag = mf6.get_var_address("MXITER", "SLN_1")
max_iter = mf6.get_value(mxit_tag)
# get copy of well data
well_tag = mf6.get_var_address("BOUND", name, "WEL_0")
well = mf6.get_value(well_tag)
twell = np.zeros(ncol, dtype=np.float64)
# model time loop
idx = 0
while current_time < end_time:
# get dt and prepare for non-linear iterations
dt = mf6.get_time_step()
mf6.prepare_time_step(dt)
# convergence loop
kiter = 0
mf6.prepare_solve()
while kiter < max_iter:
# update well rate
twell[:] = head2et_wellrate(head[0])
well[:, 0] = twell[:]
mf6.set_value(well_tag, well)
# solve with updated well rate
has_converged = mf6.solve()
kiter += 1
if has_converged:
msg = (
"Component {}".format(1)
+ " converged in {}".format(kiter)
+ " outer iterations"
)
print(msg)
break
if not has_converged:
return api_return(success, model_ws)
# finalize time step
mf6.finalize_solve()
# finalize time step and update time
mf6.finalize_time_step()
current_time = mf6.get_current_time()
# increment counter
idx += 1
# cleanup
try:
mf6.finalize()
success = True
except:
return api_return(success, model_ws)
# cleanup and return
return api_return(success, model_ws)
def api_func(exe, idx, model_ws=None):
success = False
name = ex[idx].upper()
if model_ws is None:
model_ws = "."
try:
mf6 = ModflowApi(exe, working_directory=model_ws)
except Exception as e:
print("Failed to load " + exe)
print("with message: " + str(e))
return api_return(success, model_ws)
# initialize the model
try:
mf6.initialize()
except:
return api_return(success, model_ws)
# time loop
current_time = mf6.get_current_time()
end_time = mf6.get_end_time()
# maximum outer iterations
max_iter = mf6.get_value(mf6.get_var_address("MXITER", "SLN_1"))
# get pointer to simulated heads
head_tag = mf6.get_var_address("X", name.upper())
head = mf6.get_value_ptr(head_tag)
# get pointers to API data
nbound_tag = mf6.get_var_address("NBOUND", name.upper(), ghb_packname)
nbound = mf6.get_value_ptr(nbound_tag)
nodelist_tag = mf6.get_var_address("NODELIST", name.upper(), ghb_packname)
nodelist = mf6.get_value_ptr(nodelist_tag)
hcof_tag = mf6.get_var_address("HCOF", name.upper(), ghb_packname)
hcof = mf6.get_value_ptr(hcof_tag)
rhs_tag = mf6.get_var_address("RHS", name.upper(), ghb_packname)
rhs = mf6.get_value_ptr(rhs_tag)
# set nbound and nodelist
nbound[0] = 1
nodelist[0] = ncol
# model time loop
while current_time < end_time:
# get dt
dt = mf6.get_time_step()
# prepare... and reads the RIV data from file!
mf6.prepare_time_step(dt)
# convergence loop
kiter = 0
mf6.prepare_solve()
while kiter < max_iter:
# update api package
hcof[:], rhs[:] = api_ghb_pak(
hcof,
rhs,
)
# solve with updated api data
has_converged = mf6.solve()
kiter += 1
if has_converged:
msg = "Converged in {}".format(kiter) + " outer iterations"
print(msg)
break
# finalize time step
mf6.finalize_solve()
# finalize time step and update time
mf6.finalize_time_step()
current_time = mf6.get_current_time()
# terminate if model did not converge
if not has_converged:
print("model did not converge")
break
# cleanup
try:
mf6.finalize()
success = True
except:
return api_return(success, model_ws)
# cleanup and return
return api_return(success, model_ws)
def api_func(exe, idx, model_ws=None):
success = False
name = ex[idx].upper()
if model_ws is None:
model_ws = "."
try:
mf6 = ModflowApi(exe, working_directory=model_ws)
except Exception as e:
print("Failed to load " + exe)
print("with message: " + str(e))
return api_return(success, model_ws)
# initialize the model
try:
mf6.initialize()
except:
return api_return(success, model_ws)
# time loop
current_time = mf6.get_current_time()
end_time = mf6.get_end_time()
# maximum outer iterations
mxit_tag = mf6.get_var_address("MXITER", "SLN_1")
max_iter = mf6.get_value(mxit_tag)
# get copy of recharge array
rch_tag = mf6.get_var_address("BOUND", name, rch_pname)
new_recharge = mf6.get_value(rch_tag)
# model time loop
idx = 0
while current_time < end_time:
# get dt and prepare for non-linear iterations
dt = mf6.get_time_step()
mf6.prepare_time_step(dt)
# convergence loop
kiter = 0
mf6.prepare_solve()
# update recharge
new_recharge[:, 0] = rch_spd[idx] * area
mf6.set_value(rch_tag, new_recharge)
while kiter < max_iter:
has_converged = mf6.solve()
kiter += 1
if has_converged:
msg = (
"Component {}".format(1)
+ " converged in {}".format(kiter)
+ " outer iterations"
)
print(msg)
break
if not has_converged:
return api_return(success, model_ws)
# finalize time step
mf6.finalize_solve()
# finalize time step and update time
mf6.finalize_time_step()
current_time = mf6.get_current_time()
# increment counter
idx += 1
# cleanup
try:
mf6.finalize()
success = True
except:
return api_return(success, model_ws)
# cleanup and return
return api_return(success, model_ws)