def iwfm_read_lake(lake_file):
''' iwfm_read_lake() - Read an IWFM Lake file and returns
(a) a list of elements and (b) a list of properties for each lake
Parameters
----------
lake_file : str
IWFM Preprocessor Lake file name
Returns
-------
lake_elems : list
element numbers for each lake
lakes : list
configuration info for each lake
lake_id : int
lake number
max_elev : int
column number in maximum elevation time series file
dest : int
destination stream node or lake id
nelem : int
number of elements in lake
'''
import iwfm as iwfm
iwfm.file_test(lake_file)
lake_lines = open(lake_file).read().splitlines()
lake_index = iwfm.skip_ahead(0, lake_lines, 0)
nlakes = int(lake_lines[lake_index].split()[0])
lakes, lake_elems = [], []
for i in range(0, nlakes):
lake_index = iwfm.skip_ahead(lake_index + 1, lake_lines, 0)
l = lake_lines[lake_index].split()
lake_id = int(l.pop(0))
max_elev = float(l.pop(0))
dest = int(l.pop(0))
nelem = int(l.pop(0))
lakes.append([lake_id, max_elev, dest, nelem])
for j in range(0, nelem):
e = []
if j > 0:
lake_index = iwfm.skip_ahead(lake_index + 1, lake_lines, 0)
l = lake_lines[lake_index].split()
e.append(lake_id)
e.append(int(l[0]))
lake_elems.append(e)
return lake_elems, lakes
def iwfm_read_elements(elem_file, verbose=False):
''' iwfm_read_elements() - Read an IWFM Element file, and return a list
of the nodes making up each element
Parameters
----------
elem_file : str
IWFM Preprocessor Elements file name
Returns
-------
elem_ids : list
element numbers
elem_nodes : list
nodes for each element
elem_sub : list
subregion for each element
'''
import re
import iwfm as iwfm
iwfm.file_test(elem_file)
elem_lines = open(elem_file).read().splitlines()
line_index = iwfm.skip_ahead(0, elem_lines, 0)
elements = int(re.findall('\d+', elem_lines[line_index])[0])
line_index = iwfm.skip_ahead(line_index + 1, elem_lines, 0)
subregions = int(re.findall('\d+', elem_lines[line_index])[0])
line_index = iwfm.skip_ahead(line_index + 1, elem_lines, 0)
line_index = iwfm.skip_ahead(line_index + 1, elem_lines, subregions - 1)
elem_ids, elem_nodes, elem_sub = [], [], []
for i in range(0, elements):
l = elem_lines[line_index + i].split()
this_elem = int(l.pop(0))
elem_ids.append(this_elem)
nodes = [int(s) for s in l]
elem_sub.append(nodes.pop(4))
if nodes[3] == 0:
nodes.pop(3) # remove empty node on triangles
elem_nodes.append(nodes)
if verbose:
print(f' Read {len(elem_nodes):,} elements from {elem_file}')
return elem_ids, elem_nodes, elem_sub
def iwfm_read_nodes(node_file, factor=0.0):
''' iwfm_read_nodes() - Read an IWFM Node file and return a list of the
nodes and their coordinates
Parameters
----------
node_file : str
IWFM preprocessor node file
Returns
-------
node_coord : list
Nodes and coordinates
node_list : list
Node numbers
factor : float
If factor = 0.0, use the factor from the input file
Else if factor <> 0.0 use this as the factor
'''
import iwfm as iwfm
import re
iwfm.file_test(node_file)
node_lines = open(node_file).read().splitlines()
line_index = iwfm.skip_ahead(0, node_lines, 0)
inodes = int(re.findall('\d+', node_lines[line_index])[0])
line_index = iwfm.skip_ahead(line_index + 1, node_lines, 0)
read_factor = float(node_lines[line_index].split()[0])
if factor == 0:
factor = read_factor
line_index = iwfm.skip_ahead(line_index + 1, node_lines, 0)
node_list, node_coord = [], []
for i in range(0, inodes):
l = node_lines[line_index + i].split()
node_list.append(int(l.pop(0)))
coords = [float(s) * factor for s in l]
node_coord.append(coords)
return node_coord, node_list
def dll_open(iwfm_dll, pre_file, sim_file, routed_streams=1, for_inquiry=1):
''' IWFM DLL: instantiate an IWFM_Model object from Preprocessor and Simulation filenames
Parameters
----------
iwfm_dll : IWFM DLL object
instantiated IWFM DLL object
pre_file : str
file path and name of the model preprocessor input file
sim_file : str
file path and name of the model simulation input file
routed_streams : int, default=1
1: model has routed streams
0: stream routing in a linked model
for_inquiry : int, default=1
1: accessing the model to return input and output data
0: running simulations
Returns
-------
iwfm_model : object
instantiated IWFM model object
status : int
0 if everything worked
'''
#import ctypes
from ctypes import byref, c_int, create_string_buffer, sizeof
import iwfm as iwfm
iwfm.file_test(pre_file)
iwfm.file_test(sim_file)
pfile = create_string_buffer(pre_file.encode('utf-8'))
sfile = create_string_buffer(sim_file.encode('utf-8'))
status = c_int(-1)
iwfm_dll.IW_Model_New(byref(c_int(sizeof(pfile))), pfile,
byref(c_int(sizeof(sfile))), sfile,
byref(c_int(routed_streams)),
byref(c_int(for_inquiry)), byref(status))
return status.value
def iwfm_read_strat(strat_file, node_coords):
''' iwfm_read_strat() - Read an IWFM Stratigraphy file and return a
list of stratigraphy for each node
Parameters:
-----------
strat_file : str
name of existing IWFM stratigraphy file
node_coords : list
(x,y) locations of IWFM model nodes
Returns
-------
strat : list
stratigraphy for each node
nlayers : int
number of layers
'''
import iwfm as iwfm
import re
iwfm.file_test(strat_file)
strat_lines = open(strat_file).read().splitlines()
line_index = iwfm.skip_ahead(0, strat_lines, 0)
layers = int(re.findall('\d+', strat_lines[line_index])[0])
line_index = iwfm.skip_ahead(line_index + 1, strat_lines, 0)
factor = float(re.findall('\d+', strat_lines[line_index])[0])
line_index = iwfm.skip_ahead(line_index + 1, strat_lines, 0)
strat = []
for i in range(0, len(node_coords)):
l = strat_lines[line_index + i].split()
s = []
s.append(int(l.pop(0)))
for j in range(0, len(l)):
s.append(factor * float(l.pop(0)))
strat.append(s)
nlayers = int((len(strat[0]) - 1) / 2)
return strat, nlayers
def dll_init(dll_path):
''' dll_init() - Initialize IWFM DLL
Parameters
----------
dll_path : str
file path and name of the IWFM DLL to access IWFM procedures
Returns
-------
iwfm_dll : object
iwfm dll object
'''
import ctypes
import iwfm as iwfm
iwfm.file_test(dll_path)
return ctypes.windll.LoadLibrary(dll_path)
if __name__ == '__main__':
' Run nearest_node() from command line '
import sys
import iwfm.debug as idb
import iwfm as iwfm
if len(sys.argv) > 1: # arguments are listed on the command line
node_file = sys.argv[1]
well_file = sys.argv[2]
else: # ask for file names from terminal
node_file = input('IWFM Node file name: ')
well_file = input('Well file name: ')
iwfm.file_test(node_file)
iwfm.file_test(well_file)
idb.exe_time() # initialize timer
node_coord, node_list = iwfm.iwfm_read_nodes(node_file)
# read list of points from well file
# ** TODO: NEED TO ADD THIS PART **
print(f' ** NEED TO UPDATE nearest_node.py TO READ WELL FILE ')
print(f' ** EXITING')
sys.exit()
# cycle through points for nearest node
nearest = iwfm.nearest_node(point, node_set)
idb.exe_time() # print elapsed time
iwfm.bias_calc(sim_all, meas_all)))
if verbose:
print(f' Wrote {out_file}')
return
if __name__ == '__main__':
' Run pest_res_stats() from command line '
import sys
import iwfm.debug as idb
import iwfm as iwfm
if len(sys.argv) > 1: # arguments are listed on the command line
pest_smp_file = sys.argv[1]
gwhyd_info_file = sys.argv[2]
gwhyd_file = sys.argv[3]
else:
# ask for file names from terminal
pest_smp_file = input(' Observation file name: ')
gwhyd_info_file = input(' IWFM Groundwater.dat file name: ')
gwhyd_file = input(' IWFM Groundwater Hydrograph file name: ')
iwfm.file_test(pest_smp_file)
iwfm.file_test(gwhyd_info_file)
iwfm.file_test(gwhyd_file)
idb.exe_time() # initialize timer
pest_res_stats(pest_smp_file, gwhyd_info_file, gwhyd_file, verbose=True)
idb.exe_time() # print elapsed time
excel.DisplayAlerts = False # return to defaults
excel.Visible = False
excel.Application.Quit()
if verbose:
print(f' Closed {excel_file}')
return
if __name__ == '__main__':
' Run bud2xl() from command line '
import sys
import iwfm.debug as idb
import iwfm as iwfm
if len(sys.argv) > 1: # arguments are listed on the command line
budget_file = sys.argv[1]
excel_file = sys.argv[2]
else: # ask for file names from terminal
budget_file = input('IWFM Budget file name: ')
excel_file = input('Output Excel file name: ')
iwfm.file_test(budget_file)
iwfm.file_test(excel_file)
idb.exe_time() # initialize timer
bud2xl(budget_file, excel_file, verbose=True)
idb.exe_time() # print elapsed time
for line in gwhyd_lines_out:
f.write("%s\n" % line)
return
if __name__ == '__main__':
' Run hyd_diff() from command line '
import sys
import iwfm as iwfm
import iwfm.debug as idb
if len(sys.argv) > 1: # arguments are listed on the command line
gwhyd_file_1 = sys.argv[1]
gwhyd_file_2 = sys.argv[2]
outname = sys.argv[3]
else: # get everything form the command line
gwhyd_file_1 = input('Base IWFM hydrograph file name: ')
gwhyd_file_2 = input('Comparison IWFM hydrograph file name: ')
outname = input('Output hydrograph file name: ')
# test that the input files exist
iwfm.file_test(gwhyd_file_1)
iwfm.file_test(gwhyd_file_2)
idb.exe_time() # initialize timer
hyd_diff(gwhyd_file_1, gwhyd_file_2, outname)
print(f' Created hydrograph file {outname}') # update cli
idb.exe_time() # print elapsed time
sys.argv[6 + i * 2]) # IWFM groundwater hydrograph file
gwhyd_names.append(sys.argv[6 + i * 2 +
1]) # Legend name for this hydrograph
else: # get everything form the command line
titlewords = input('Graph title: ')
obs_file = input(
'Observed values file name (smp format) or \'none\'): ')
gwhyd_info_file = input('IWFM Groundwater.dat file name: ')
yaxis_width = input('Minimum y-axis scale (-1 to autoscale): ')
no_hyds = int(input('Number of hydrographs to plot: '))
for i in range(0, no_hyds):
filename = input(
f' IWFM Groundwater Hydrograph {i+1} file name: ')
gwhyd_files.append(filename)
legendname = input(f' Graph legend for {filename}: ')
gwhyd_names.append(legendname)
# test that the input files exist
if obs_file.lower() != 'none':
iwfm.file_test(obs_file)
iwfm.file_test(gwhyd_info_file)
for i in range(0, no_hyds):
iwfm.file_test(gwhyd_files[i])
idb.exe_time() # initialize timer
count = gw_plot(obs_file, gwhyd_info_file, gwhyd_files, gwhyd_names,
yaxis_width, titlewords)
print(f' Created {count} PDF hydrograph files') # update cli
idb.exe_time() # print elapsed time
def iwfm_read_streams(stream_file):
''' iwfm_read_streams() - Read an IWFM Stream Geometry file and return
a list of stream reaches, a dictionary of stream nodes, and the
number of stream nodes
Parameters
----------
stream_file : str
IWFM Streams file name
Returns
-------
reach_list : list
information for each stream reach
stnodes_dict : dictionary
key = stream node ID, value = groundwater node
len(snodes_list) : int
number of stream nodes
rating_dict : dictionary
key = stream node ID, values = rating table
'''
import iwfm as iwfm
iwfm.file_test(stream_file)
comments = 'Cc*#'
stream_lines = open(stream_file).read().splitlines()
stream_type = stream_lines[0][1:]
stream_index = iwfm.skip_ahead(1, stream_lines, 0)
nreach = int(stream_lines[stream_index].split()[0])
stream_index += 1
rating = int(stream_lines[stream_index].split()[0])
reach_list, snodes_list, nsnodes = [], [], 0
for i in range(0, nreach):
stream_index = iwfm.skip_ahead(stream_index + 1, stream_lines, 0)
l = stream_lines[stream_index].split()
# ***** TODO ************************************
# Handle multiple types of stream packages (stream_type)
# ***** TODO ************************************
# streams package version 4.2
# if stream_type == '4.2':
reach = int(l.pop(0))
snodes = int(l.pop(0))
# streams package version 5
# elif stream_type == '5':
# upper = int(l.pop(0))
# lower = int(l.pop(0))
# snodes = lower - upper + 1
oflow = int(l.pop(0))
# read stream node information
for j in range(0, snodes):
stream_index = iwfm.skip_ahead(stream_index, stream_lines, 1)
l = stream_lines[stream_index].split()
t = [int(l[0]), int(l[1]), reach]
snodes_list.append(t)
if j == 0:
upper = int(l[0])
else:
lower = int(l[0])
reach_list.append([reach, upper, lower, oflow])
stream_index = iwfm.skip_ahead(stream_index + 1, stream_lines, 3)
rating_dict = {}
selev = []
for i in range(0, len(snodes_list)):
l = stream_lines[stream_index].split()
snd = l[0]
selev.append(float(l[1]))
# read the rating table values for this stream node
temp = [[l[2], l[3]]]
stream_index += 1
for t in range(0, rating - 1):
if any((c in comments) for c in stream_lines[stream_index][0]):
stream_index += 1
temp.append(stream_lines[stream_index].split())
stream_index += 1
rating_dict[snd] = temp
if i < len(snodes_list) - 1: # stop at end
stream_index = iwfm.skip_ahead(stream_index, stream_lines, 0)
# put stream node info into a dictionary
stnodes_dict = {}
for i in range(0, len(snodes_list)):
j = 0
while snodes_list[j][0] != i + 1: # find info for i in snodes list
j += 1
key, values = i + 1, [snodes_list[j][1], snodes_list[j][2], selev[i]]
stnodes_dict[key] = values
return reach_list, stnodes_dict, len(snodes_list), rating_dict
if __name__ == '__main__':
' Run iwfm_lu4scenario() from command line '
import sys
import iwfm.debug as idb
import iwfm as iwfm
if len(sys.argv) > 1: # arguments are listed on the command line
out_base_name = sys.argv[1]
in_npag_file = sys.argv[2]
in_ponded_file = sys.argv[3]
in_urban_file = sys.argv[4]
in_nvrv_file = sys.argv[5]
else: # ask for file names from terminal
out_base_name = input('Output file basename: ')
in_npag_file = input('IWFM Non-Ponded Ag file name: ')
in_ponded_file = input('IWFM Pondes Ag file name: ')
in_urban_file = input('IWFM Urban file name: ')
in_nvrv_file = input('IWFM Native file name: ')
iwfm.file_test(in_nvrv_file)
iwfm.file_test(in_npag_file)
iwfm.file_test(in_ponded_file)
iwfm.file_test(in_urban_file)
idb.exe_time() # initialize timer
iwfm_lu4scenario(out_base_name,in_npag_file,in_ponded_file,
in_urban_file,in_nvrv_file,verbose=False)
idb.exe_time() # print elapsed time
gis.snodes2shp(nsnodes, stnodes_dict, node_coords, shape_name, verbose=verbose)
gis.reach2shp(reach_list, stnodes_dict, node_coords, shape_name, verbose=verbose)
if verbose:
print(f' Wrote node, element, stream node and stream reache shapefiles\n')
return
if __name__ == "__main__":
''' Run igsm2shp() from command line '''
import sys
import iwfm.debug as idb
import iwfm as iwfm
if len(sys.argv) > 1: # arguments are listed on the command line
input_file = sys.argv[1]
output_basename = sys.argv[2]
else: # ask for file names from terminal
input_file = input('IGSM Preprocessor main file name: ')
output_basename = input('Output shapefile basename: ')
iwfm.file_test(input_file)
idb.exe_time() # initialize timer
igsm2shp(input_file, output_basename, verbose=True)
idb.exe_time() # print elapsed time
this_line = out_lines[i]
for j in range(0, len(this_line)):
f.write(this_line[j])
f.write('\n')
return len(out_lines)
if __name__ == '__main__':
' Run iwfm_lu2sub() from command line '
import sys
import iwfm.debug as idb
import iwfm as iwfm
if len(sys.argv) > 1: # arguments are listed on the command line
elem_file = sys.argv[1]
lu_file = sys.argv[2]
out_file = sys.argv[3]
else: # ask for file names from terminal
elem_file = input('IEFM Element file name: ')
lu_file = input('IWFM land use file name: ')
out_file = input('Output file name: ')
iwfm.file_test(elem_file)
iwfm.file_test(lu_file)
idb.exe_time() # initialize timer
iwfm_lu2sub(elem_file, lu_file, out_file, verbose=True)
idb.exe_time() # print elapsed time
if __name__ == "__main__":
''' Run iwfm_sub_sim() from command line '''
import sys
import iwfm.debug as idb
import iwfm as iwfm
verbose = True
if len(sys.argv) > 1: # arguments are listed on the command line
in_sim_file = sys.argv[1] # old model simulaiton.in file
elem_pairs_file = sys.argv[2] # file with element pairs
out_base_name = sys.argv[3] # output file base name
else: # ask for file names from terminal
in_sim_file = input('Existing IWFM Simulation.in file: ')
elem_pairs_file = input('Element pairs file: ')
out_base_name = input('Output file base name: ')
# == test that the input files exist
iwfm.file_test(in_sim_file)
iwfm.file_test(elem_pairs_file)
idb.exe_time() # initialize timer
iwfm_sub_sim(in_sim_file, elem_pairs_file, out_base_name, verbose=verbose)
if verbose:
print(' ')
print(
f' Created submodel {out_base_name} simulation files from {in_sim_file}.'
) # update cli
idb.exe_time() # print elapsed time
ctypes.byref(has_routed_streams),
ctypes.byref(is_for_inquiry),
ctypes.byref(status))
if __name__ == '__main__':
' Run dll_init() from command line '
import sys
import iwfm.debug as idb
import iwfm as iwfm
#import iwfm.dll as dll
if len(sys.argv) > 1: # arguments are listed on the command line
dll_path = sys.argv[1]
preprocessor_file_name = sys.argv[2]
simulation_file_name = sys.argv[3]
else: # ask for file names from terminal
dll_path = input('Path to IWFM DLL: ')
preprocessor_file_name = input('IWFM Preprocessor file name: ')
simulation_file_name = input('IWFM Simulation file name: ')
iwfm.file_test(preprocessor_file_name)
iwfm.file_test(simulation_file_name)
idb.exe_time() # initialize timer
dll_init(dll_path, preprocessor_file_name, simulation_file_name)
idb.exe_time() # print elapsed time
out_file.write('\n')
if verbose:
print(f' Wrote results to {outFileName}\n')
return
if __name__ == "__main__":
''' Run vic_2_table() from command line '''
import sys
import iwfm.debug as idb
import iwfm as iwfm
if len(sys.argv) > 1: # arguments are listed on the command line
factorsFileName = sys.argv[1]
output_file = sys.argv[2]
col = int(sys.argv[3])
else: # ask for file names from terminal
factorsFileName = input(' P-ET factor file name: ')
output_file = input(' Output file name: ')
col = input(' Column to process: ')
iwfm.file_test(factorsFileName)
idb.exe_time() # initialize timer
vic_2_table(factorsFileName, output_file, col, verbose=True)
print(f' Read {factorsFileName} and wrote {output_file}.') # update cli
idb.exe_time() # print elapsed time
import iwfm as iwfm
if len(sys.argv) > 1: # arguments are listed on the command line
precip_filename = sys.argv[1]
elem_VIC_filemane = sys.argv[2]
factors_filename = sys.argv[3]
years_filename = sys.argv[4]
out_filename = sys.argv[5]
else: # ask for file names from terminal
precip_filename = input('IWFM Precipitation file name: ')
elem_VIC_filemane = input('Element-VIC file name: ')
factors_filename = input('Factors file name: ')
years_filename = input('Years file name: ')
out_filename = input('Output file name: ')
iwfm.file_test(precip_filename)
iwfm.file_test(elem_VIC_filemane)
iwfm.file_test(factors_filename)
iwfm.file_test(years_filename)
idb.exe_time() # initialize timer
iwfm_precip_adj(precip_filename,
elem_VIC_filemane,
factors_filename,
years_filename,
out_filename,
verbose=True)
idb.exe_time() # print elapsed time
import iwfm.debug as idb
import iwfm as iwfm
verbose = True
if len(sys.argv) > 1: # arguments are listed on the command line
in_pp_file = sys.argv[1] # in: old model preprocessor.in file
elem_pairs_file = sys.argv[2] # in: file with element pairs
out_base_name = sys.argv[3] # output file base name
else: # ask for file names from terminal
in_pp_file = input('Existing IWFM Preprocessor.in file: ')
elem_pairs_file = input('Element pairs file: ')
out_base_name = input('Output file base name: ')
# == test that the input files exist
iwfm.file_test(in_pp_file)
iwfm.file_test(elem_pairs_file)
idb.exe_time() # initialize timer
iwfm_sub_preproc(in_pp_file,
elem_pairs_file,
out_base_name,
verbose=verbose)
if verbose:
print(' ')
print(
f' Created submodel {out_base_name} preprocessor files from {in_pp_file}'
)
idb.exe_time() # print elapsed time
item = file_lines[line].split() # read line w/date
data.append(item)
end_date = item.pop(0) # remove the date
return
if __name__ == '__main__':
' Run headall2table() from command line '
import sys
import os
import iwfm.debug as idb
import iwfm as iwfm
if len(sys.argv) > 1: # arguments are listed on the command line
heads_file = sys.argv[1]
output_file = sys.argv[2]
out_date = sys.argv[3]
else: # ask for file names from terminal
heads_file = input('IWFM Headall file name: ')
output_file = input('Output file name: ')
out_date = input('Output date: ')
iwfm.file_test(heads_file)
idb.exe_time() # initialize timer
headall2table(heads_file, output_file, out_date)
print(f' Read {heads_file} and wrote {output_file}.') # update cli
idb.exe_time() # print elapsed time
if __name__ == '__main__':
' Run get_node_ids() from command line '
import sys
import iwfm.debug as idb
import iwfm as iwfm
import iwfm.dll as idll
if len(sys.argv) > 1: # arguments are listed on the command line
dll_path, pre_file, sim_file = sys.argv[1], sys.argv[2], sys.argv[3]
else: # ask for file names from terminal
dll_path = input('Path to IWFM DLL: ')
pre_file = input('IWFM Preprocessor file name: ')
sim_file = input('IWFM Simulation file name: ')
iwfm.file_test(pre_file)
iwfm.file_test(sim_file)
idb.exe_time() # initialize timer
iwfm_dll = idll.dll_init(dll_path) # instatiate the IWFM DLL
status = idll.dll_open(iwfm_dll, pre_file,
sim_file) # instantiate the model
node_ids, status = get_node_ids(iwfm_dll)
print(f' No of node IDs: {len(node_ids):,}')
print(f' First node ID: {node_ids[0]:,}')
idb.exe_time() # print elapsed time
def igsm2shp(main_file, shape_name, verbose=False):
''' igsm2shp() - Read the names of the preprocessor component input files,
read the contents of these files, and create node, element, stream
node and stream reach shapefiles
Parameters
----------
main_file : str
IGSM Preprocessor input file name
shape_name : str
output shapefiles base name
Returns
-------
nothing
'''
import iwfm as iwfm
import iwfm.gis as gis
main_lines = open(main_file).read().splitlines()
line_index = iwfm.skip_ahead(0, main_lines, 6)
elem_file = main_lines[line_index].split()[0]
line_index += 1
node_file = main_lines[line_index].split()[0]
line_index += 1
strat_file = main_lines[line_index].split()[0]
line_index += 1
stream_file = main_lines[line_index].split()[0]
line_index += 1
lake_file = main_lines[line_index].split()[0]
if lake_file[0] == '/': # no lake file listed
lake_file = ''
line_index += 2
char_file = main_lines[line_index].split()[0]
iwfm.file_test(elem_file)
iwfm.file_test(node_file)
iwfm.file_test(strat_file)
iwfm.file_test(stream_file)
if len(lake_file) > 1:
iwfm.file_test(lake_file)
iwfm.file_test(char_file)
elem_nodes, elem_list = iwfm.igsm_read_elements(elem_file)
if verbose:
print(f' Read nodes of {len(elem_nodes):,} elements from {elem_file}')
node_coords, node_list = iwfm.igsm_read_nodes(node_file)
if verbose:
print(f' Read coordinates of {len(node_coords):,} nodes from {node_file}')
elem_char = iwfm.igsm_read_chars(char_file, elem_nodes)
if verbose:
print(f' Read characteristics for {len(elem_char):,} elements from {char_file}')
node_strat, nlayers = iwfm.igsm_read_strat(strat_file, node_coords)
if verbose:
print(f' Read stratigraphy for {len(node_strat):,} nodes from {strat_file}')
if len(lake_file) > 1:
lake_elems, lakes = iwfm.igsm_read_lake(lake_file)
if verbose:
if len(lakes) > 1:
print(f' Read info for {len(lakes):,} lakes from {lake_file}')
elif len(lakes) == 1:
print(f' Read info for {len(lakes):,} lake from {lake_file}')
else:
lake_elems = [[0,0,0]]
if verbose:
print(f' No lakes')
reach_list, stnodes_dict, nsnodes = iwfm.igsm_read_streams(stream_file)
if verbose:
print(f' Read info for {len(reach_list):,} stream reaches and {nsnodes:,} stream nodes from {stream_file}\n')
gis.nodes2shp(node_coords, node_strat, nlayers, shape_name, verbose=verbose)
gis.igsm_elem2shp(elem_nodes,node_coords,elem_char,lake_elems,
shape_name,verbose=verbose)
gis.snodes2shp(nsnodes, stnodes_dict, node_coords, shape_name, verbose=verbose)
gis.reach2shp(reach_list, stnodes_dict, node_coords, shape_name, verbose=verbose)
if verbose:
print(f' Wrote node, element, stream node and stream reache shapefiles\n')
return
if len(line) > 10:
value = mydict.get(items[0][0 : line.find(',')])
if value is not None:
outfile.write(line)
lines_out = lines_out + 1
if verbose:
print(f'Processed {lines_in:,} lines from {waterlevel_file}')
print(f'Wrote {lines_out:,} lines to {output_file}')
return
if __name__ == '__main__':
' Run wdl_ts_4_wells() from command line'
import sys
import iwfm.debug as idb
import iwfm as iwfm
if len(sys.argv) > 1: # arguments are listed on the command line
station_file = sys.argv[1]
waterlevel_file = sys.argv[2]
else: # ask for file names from terminal
station_file = input('Well station file name: ')
waterlevel_file = input('Water level file name: ')
iwfm.file_test(station_file)
iwfm.file_test(waterlevel_file)
idb.exe_time() # initialize timer
iwfm.wdl_ts_4_wells(station_file, waterlevel_file, verbose=True)
idb.exe_time() # print elapsed time
def iwfm_lu2sub(elem_file,
lu_file,
out_file,
skip=4,
verbose=False,
per_line=6):
''' iwfm_IWFM_lu2sub() - Read an IWFM Preprocessor Element File for a
submodel and an IWFM Land Use File for the base model, and write
a new land use file with land use for only the elements in the
Elements File
Parameters
----------
elem_file : str
IWFM submodel Preprocessor Element file name
lu_file : str
IWFM base model land use area file
out_file : str
IWFM submodel land use area file name (output)
skip : int, default=4
number of non-comment lines to skip in each file
verbose : bool, default=False
True = command-line output on
per_line : int, default=6
if verbose==True, items per line to write to the console
Returns
-------
nothing
'''
import sys, re, os
import iwfm as iwfm
iwfm.file_test(elem_file)
iwfm.file_test(lu_file)
elem_ids, _, _ = iwfm.iwfm_read_elements(elem_file)
elem_ids.sort()
lu_lines = open(lu_file).read().splitlines() # open and read input file
line_index = iwfm.skip_ahead(0, lu_lines, 4) # skip comments
header = line_index
if verbose:
outport = iwfm.Unbuffered(
sys.stdout) # to write unbuffered output to console
out_lines, print_count = [], 0
while line_index < len(lu_lines):
out = []
this_line = lu_lines[line_index].split()
if re.search('/', lu_lines[line_index]): # catch date
this_date = this_line.pop(0)
if verbose: # write progress to console
if print_count > per_line - 2:
outport.write(' ' + this_date[:10])
print_count = 0
else:
if print_count == 0:
outport.write('\n ' + this_date[:10])
else:
outport.write(' ' + this_date[:10])
print_count += 1
# -- build the output line
if int(this_line[0]) in elem_ids:
if int(this_line[0]) == elem_ids[0]: # first element -> add date
out.append(this_date)
for j in range(0, len(this_line)): # add the rest of the line
out.append('\t' + this_line[j])
out_lines.append(out)
line_index += 1
outport.write('\n')
with open(out_file, 'w') as f:
for i in range(0, header): # copy top of input file to output
f.write(lu_lines[i])
f.write('\n')
for i in range(0, len(out_lines)):
this_line = out_lines[i]
for j in range(0, len(this_line)):
f.write(this_line[j])
f.write('\n')
return len(out_lines)
in_chg_file_UR = sys.argv[4]
in_area_npag = sys.argv[5]
in_area_nvrv = sys.argv[6]
in_area_urban = sys.argv[7]
out_basename = sys.argv[8]
else: # ask for file names from terminal
in_year = input('Year: ')
in_zone_file = input('Zone file name: ')
in_chg_file_NV = input('Ag to Native change factors file name: ')
in_chg_file_UR = input('Ag to Urban change factors file name: ')
in_area_npag = input('Input Ag file name: ')
in_area_nvrv = input('Input Native file name: ')
in_area_urban = input('Input Urban file name: ')
out_basename = input('Output file base name: ')
iwfm.file_test(in_zone_file)
iwfm.file_test(in_chg_file_NV)
iwfm.file_test(in_chg_file_UR)
iwfm.file_test(in_area_npag)
iwfm.file_test(in_area_nvrv)
iwfm.file_test(in_area_urban)
idb.exe_time() # initialize timer
iwfm_adj_crops(
in_year,
in_zone_file,
in_chg_file_NV,
in_chg_file_UR,
in_area_npag,
in_area_nvrv,
in_area_urban,
