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() # reset sy with bmi set_value sy_tag = mf6.get_var_address("SY", name, "STO") new_sy = mf6.get_value(sy_tag) new_sy.fill(sy_val) mf6.set_value(sy_tag, new_sy) # model time loop idx = 0 while current_time < end_time: # run the time step try: mf6.update() except: return api_return(success, model_ws) # update time 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() # 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() # 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)