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)