def create_output_table(gp, output_surface_table, area_ident, field_range):
"""
creates a new table when the table does not exist..
adds all fields thats are needed for writing output
"""
if not gp.exists(output_surface_table):
gp.CreateTable_management(os.path.dirname(
output_surface_table), os.path.basename(output_surface_table))
if not turtlebase.arcgis.is_fieldname(
gp, output_surface_table, area_ident):
gp.addfield_management(output_surface_table,
area_ident, "Text", "#", "#", '50')
for field in field_range:
if not turtlebase.arcgis.is_fieldname(
gp, output_surface_table, "MV_HGT_%s" % field):
gp.addfield_management(
output_surface_table, "MV_HGT_%s" % field, "Double")
if not turtlebase.arcgis.is_fieldname(gp, output_surface_table, 'SOURCE'):
gp.addfield_management(output_surface_table,
'SOURCE', "Text", "#", "#", '256')
if not turtlebase.arcgis.is_fieldname(
gp, output_surface_table, 'DATE_TIME'):
gp.addfield_management(output_surface_table,
'DATE_TIME', "Text", "#", "#", '40')
if not turtlebase.arcgis.is_fieldname(
gp, output_surface_table, 'COMMENTS'):
gp.addfield_management(output_surface_table,
'COMMENTS', "Text", "#", "#", '256')
def create_output_table(gp, output_table, area_ident, toetspunten_fields):
"""
creates a new table when the table does not exist..
adds all fields thats are needed for writing output
"""
if not gp.exists(output_table):
gp.CreateTable_management(os.path.dirname(output_table),
os.path.basename(output_table))
for fieldname in toetspunten_fields:
if not turtlebase.arcgis.is_fieldname(gp, output_table, fieldname):
gp.addfield_management(output_table, fieldname, "Double")
if not turtlebase.arcgis.is_fieldname(gp, output_table, 'SOURCE'):
gp.addfield_management(output_table, 'SOURCE', "Text", "#", "#", '256')
if not turtlebase.arcgis.is_fieldname(gp, output_table, 'DATE_TIME'):
gp.addfield_management(output_table,
'DATE_TIME', "Text", "#", "#", '40')
if not turtlebase.arcgis.is_fieldname(gp, output_table, 'COMMENTS'):
gp.addfield_management(output_table, 'COMMENTS',
"Text", "#", "#", '256')
def main():
try:
gp = mainutils.create_geoprocessor()
config = mainutils.read_config(__file__, "turtle-settings.ini")
logfile = mainutils.log_filename(config)
logging_config = LoggingConfig(gp, logfile=logfile)
mainutils.log_header(__name__)
# ----------------------------------------------------------------------------------------
# check inputfields
log.info("Getting commandline parameters")
if len(sys.argv) == 6:
rr_peilgebieden_tbl = sys.argv[1]
rr_oppervlak_tbl = sys.argv[2]
rr_toetspunten_tbl = sys.argv[3]
rr_resultaten_tbl = sys.argv[4]
output_waterbezwaar_tbl = sys.argv[5]
else:
log.error(
"Usage: python rural_indicatie_waterbezwaar.py <rr_peilgebieden_tbl> <rr_oppervlak_tbl> <rr_toetspunten_tbl> <rr_resultaten_tbl> <output_waterbezwaar_tbl>"
)
sys.exit(1)
# ----------------------------------------------------------------------------------------
# check input parameters
log.info("Checking presence of input files")
if not (gp.exists(rr_peilgebieden_tbl)):
log.error("tabel %s does not exist!" % rr_peilgebieden_tbl)
sys.exit(5)
if not (gp.exists(rr_oppervlak_tbl)):
log.error("tabel %s does not exist!" % rr_oppervlak_tbl)
sys.exit(5)
if not (gp.exists(rr_toetspunten_tbl)):
log.error("tabel %s does not exist!" % rr_toetspunten_tbl)
sys.exit(5)
if not (gp.exists(rr_resultaten_tbl)):
log.error("tabel %s does not exist!" % rr_resultaten_tbl)
sys.exit(5)
log.info("input parameters checked")
# ---------------------------------------------------------------------------
gpgident = config.get("GENERAL", "gpgident").lower()
# create list from geodatabase table
gegevens = nens.gp.get_table(gp, rr_resultaten_tbl, primary_key=gpgident)
nens.gp.join_on_primary_key(gp, gegevens, rr_toetspunten_tbl, gpgident)
nens.gp.join_on_primary_key(gp, gegevens, rr_peilgebieden_tbl, gpgident)
nens.gp.join_on_primary_key(gp, gegevens, rr_oppervlak_tbl, gpgident)
# calculating waterbezwaar
log.info("calculating surplus water")
# check input fields
check_row = gegevens.values()[0]
check_fields = [
config.get("waterbezwaar", "toetspunt_overlast_stedelijk"),
config.get("waterbezwaar", "toetspunt_overlast_hoogwlandbouw"),
config.get("waterbezwaar", "toetspunt_overlast_akkerbouw"),
config.get("waterbezwaar", "toetspunt_overlast_grasland"),
config.get("waterbezwaar", "toetspunt_inundatie_stedelijk"),
config.get("waterbezwaar", "toetspunt_inundatie_hoogwlandbouw"),
config.get("waterbezwaar", "toetspunt_inundatie_akkerbouw"),
config.get("waterbezwaar", "toetspunt_inundatie_grasland"),
config.get("waterbezwaar", "peilgebied_winterpeil"),
config.get("waterbezwaar", "peilgebied_helling"),
config.get("waterbezwaar", "waterstand_inundatie_stedelijk"),
config.get("waterbezwaar", "waterstand_inundatie_hoogwlandbouw"),
config.get("waterbezwaar", "waterstand_inundatie_akkerbouw"),
config.get("waterbezwaar", "waterstand_inundatie_grasland"),
config.get("waterbezwaar", "waterstand_overlast_stedelijk"),
config.get("waterbezwaar", "waterstand_overlast_hoogwlandbouw"),
config.get("waterbezwaar", "waterstand_overlast_akkerbouw"),
config.get("waterbezwaar", "waterstand_overlast_grasland"),
config.get("waterbezwaar", "oppervlak_openwater"),
]
missing_fields = check_items(check_row, check_fields)
if missing_fields:
log.error(
"at least one of the input fields is missing, check ini-file and database. %s" % (str(missing_fields))
)
sys.exit(6)
waterbezwaar = {}
for id, row in gegevens.items():
if row["tldhelling"] == None:
tp_slope = 0
else:
tp_slope = float(row["tldhelling"])
if row["winterpeil"] == None:
winterpeil = 0
else:
winterpeil = float(row["winterpeil"])
if row["openwat_ha"] == None:
ow_opp = 0
else:
ow_opp = float(row["openwat_ha"])
# bereken waterbezwaar inundatie stedelijk
toetshoogte_i_st = float(row["mtgmv_i_st"])
if toetshoogte_i_st == winterpeil:
toetshoogte_i_st = toetshoogte_i_st + 0.05
log.warning("Toetspunt inundatie stedelijk is gelijk aan winterpeil, toetspunt + 5cm")
waterstand_i_st = float(row["ws_100"])
sted_i_wb_m3, sted_i_wb_ha = calc_waterbezwaar(
toetshoogte_i_st, ow_opp, tp_slope, winterpeil, waterstand_i_st
)
# bereken waterbezwaar overlast stedelijk
toetshoogte_o_st = float(row["mtgmv_o_st"])
if toetshoogte_o_st == winterpeil:
toetshoogte_o_st = toetshoogte_o_st + 0.05
log.warning("Toetspunt overlast stedelijk is gelijk aan winterpeil, toetspunt + 5cm")
waterstand_o_st = float(row["ws_25"])
sted_o_wb_m3, sted_o_wb_ha = calc_waterbezwaar(
toetshoogte_o_st, ow_opp, tp_slope, winterpeil, waterstand_o_st
)
# bereken waterbezwaar inundatie hoogwaardige landbouw
toetshoogte_i_hl = float(row["mtgmv_i_hl"])
if toetshoogte_i_hl == winterpeil:
toetshoogte_i_hl = toetshoogte_i_hl + 0.05
log.warning("Toetspunt inundatie hoogwaardige landbouw is gelijk aan winterpeil, toetspunt + 5cm")
waterstand_i_hl = float(row["ws_50"])
hoogw_i_wb_m3, hoogw_i_wb_ha = calc_waterbezwaar(
toetshoogte_i_hl, ow_opp, tp_slope, winterpeil, waterstand_i_hl
)
# bereken waterbezwaar overlast hoogwaardige landbouw
toetshoogte_o_hl = float(row["mtgmv_o_hl"])
if toetshoogte_o_hl == winterpeil:
toetshoogte_o_hl = toetshoogte_o_hl + 0.05
log.warning("Toetspunt overlast hoogwaardige landbouw is gelijk aan winterpeil, toetspunt + 5cm")
waterstand_o_hl = float(row["ws_25"])
hoogw_o_wb_m3, hoogw_o_wb_ha = calc_waterbezwaar(
toetshoogte_o_hl, ow_opp, tp_slope, winterpeil, waterstand_o_hl
)
# bereken waterbezwaar inundatie akkerbouw
toetshoogte_i_ak = float(row["mtgmv_i_ak"])
if toetshoogte_i_ak == winterpeil:
toetshoogte_i_ak = toetshoogte_i_ak + 0.05
log.warning("Toetspunt inundatie akkerbouw is gelijk aan winterpeil, toetspunt + 5cm")
waterstand_i_ak = float(row["ws_25"])
akker_i_wb_m3, akker_i_wb_ha = calc_waterbezwaar(
toetshoogte_i_ak, ow_opp, tp_slope, winterpeil, waterstand_i_ak
)
# bereken waterbezwaar overlast akkerbouw
toetshoogte_o_ak = float(row["mtgmv_o_ak"])
if toetshoogte_o_ak == winterpeil:
toetshoogte_o_ak = toetshoogte_o_ak + 0.05
log.warning("Toetspunt overlast akkerbouw is gelijk aan winterpeil, toetspunt + 5cm")
waterstand_o_ak = float(row["ws_15"])
akker_o_wb_m3, akker_o_wb_ha = calc_waterbezwaar(
toetshoogte_o_ak, ow_opp, tp_slope, winterpeil, waterstand_o_ak
)
# bereken waterbezwaar inundatie grasland
toetshoogte_i_gr = float(row["mtgmv_i_gr"])
if toetshoogte_i_gr == winterpeil:
toetshoogte_i_gr = toetshoogte_i_gr + 0.05
log.warning("Toetspunt inundatie grasland is gelijk aan winterpeil, toetspunt + 5cm")
waterstand_i_gr = float(row["ws_10"])
gras_i_wb_m3, gras_i_wb_ha = calc_waterbezwaar(
toetshoogte_i_gr, ow_opp, tp_slope, winterpeil, waterstand_i_gr
)
# bereken waterbezwaar overlast grasland
toetshoogte_o_gr = float(row["mtgmv_o_gr"])
if toetshoogte_o_gr == winterpeil:
toetshoogte_o_gr = toetshoogte_o_gr + 0.05
log.warning("Toetspunt overlast grasland is gelijk aan winterpeil, toetspunt + 5cm")
waterstand_o_gr = float(row["ws_5"])
gras_o_wb_m3, gras_o_wb_ha = calc_waterbezwaar(
toetshoogte_o_gr, ow_opp, tp_slope, winterpeil, waterstand_o_gr
)
wb_i_m3 = max(sted_i_wb_m3, hoogw_i_wb_m3, akker_i_wb_m3, gras_i_wb_m3)
wb_o_m3 = max(sted_o_wb_m3, hoogw_o_wb_m3, akker_o_wb_m3, gras_o_wb_m3)
wb_i_ha = max(sted_i_wb_ha, hoogw_i_wb_ha, akker_i_wb_ha, gras_i_wb_ha)
wb_o_ha = max(sted_o_wb_ha, hoogw_o_wb_ha, akker_o_wb_ha, gras_o_wb_ha)
waterbezwaar[id] = {
"gpgident": id,
"wb_i_m3": wb_i_m3,
"wb_o_m3": wb_o_m3,
"wb_i_ha": wb_i_ha,
"wb_o_ha": wb_o_ha,
"wb_i_st_ha": sted_i_wb_ha,
"wb_i_hl_ha": hoogw_i_wb_ha,
"wb_i_ak_ha": akker_i_wb_ha,
"wb_i_gr_ha": gras_i_wb_ha,
"wb_o_st_ha": sted_o_wb_ha,
"wb_o_hl_ha": hoogw_o_wb_ha,
"wb_o_ak_ha": akker_o_wb_ha,
"wb_o_gr_ha": gras_o_wb_ha,
"wb_i_st_m3": sted_i_wb_m3,
"wb_i_hl_m3": hoogw_i_wb_m3,
"wb_i_ak_m3": akker_i_wb_m3,
"wb_i_gr_m3": gras_i_wb_m3,
"wb_o_st_m3": sted_o_wb_m3,
"wb_o_hl_m3": hoogw_o_wb_m3,
"wb_o_ak_m3": akker_o_wb_m3,
"wb_o_gr_m3": gras_o_wb_m3,
}
# Schrijf de resultaten weg als een nieuwe tabel
if not (gp.exists(output_waterbezwaar_tbl)):
log.info("creating table " + output_waterbezwaar_tbl)
gp.CreateTable(os.path.dirname(output_waterbezwaar_tbl), os.path.basename(output_waterbezwaar_tbl))
wb_fields = [
config.get("waterbezwaar", "output_field_wb_i_m3"),
config.get("waterbezwaar", "output_field_wb_i_ha"),
config.get("waterbezwaar", "output_field_wb_o_m3"),
config.get("waterbezwaar", "output_field_wb_o_ha"),
config.get("waterbezwaar", "output_field_wb_i_st_ha"),
config.get("waterbezwaar", "output_field_wb_i_hl_ha"),
config.get("waterbezwaar", "output_field_wb_i_ak_ha"),
config.get("waterbezwaar", "output_field_wb_i_gr_ha"),
config.get("waterbezwaar", "output_field_wb_o_st_ha"),
config.get("waterbezwaar", "output_field_wb_o_hl_ha"),
config.get("waterbezwaar", "output_field_wb_o_ak_ha"),
config.get("waterbezwaar", "output_field_wb_o_gr_ha"),
config.get("waterbezwaar", "output_field_wb_i_st_m3"),
config.get("waterbezwaar", "output_field_wb_i_hl_m3"),
config.get("waterbezwaar", "output_field_wb_i_ak_m3"),
config.get("waterbezwaar", "output_field_wb_i_gr_m3"),
config.get("waterbezwaar", "output_field_wb_o_st_m3"),
config.get("waterbezwaar", "output_field_wb_o_hl_m3"),
config.get("waterbezwaar", "output_field_wb_o_ak_m3"),
config.get("waterbezwaar", "output_field_wb_o_gr_m3"),
]
table_def = nens.gp.get_table_def(gp, output_waterbezwaar_tbl)
output_field_id = config.get("waterbezwaar", "output_field_id")
if not output_field_id in table_def:
log.info(" - add field %s to %s" % (output_field_id, os.path.basename(output_waterbezwaar_tbl)))
gp.AddField(output_waterbezwaar_tbl, output_field_id, "TEXT", "#", "#", 30)
for double_field in wb_fields:
if not double_field.lower() in table_def:
log.info(" - add field %s to %s" % (double_field, os.path.basename(output_waterbezwaar_tbl)))
gp.AddField(output_waterbezwaar_tbl, double_field, "DOUBLE")
turtlebase.arcgis.write_result_to_output(output_waterbezwaar_tbl, gpgident, waterbezwaar)
mainutils.log_footer()
except:
log.error(traceback.format_exc())
sys.exit(1)
finally:
logging_config.cleanup()
del gp
def main():
try:
gp = mainutils.create_geoprocessor()
config = mainutils.read_config(__file__, 'turtle-settings.ini')
logfile = mainutils.log_filename(config)
logging_config = LoggingConfig(gp, logfile=logfile)
mainutils.log_header(__name__)
# --------------------------------------------------------------------
# Create workspace
workspace = config.get('GENERAL', 'location_temp')
if workspace == "-":
workspace = tempfile.gettempdir()
turtlebase.arcgis.delete_old_workspace_gdb(gp, workspace)
if not os.path.isdir(workspace):
os.makedirs(workspace)
workspace_gdb, errorcode = (
turtlebase.arcgis.create_temp_geodatabase(gp, workspace))
if errorcode == 1:
log.error("failed to create a file geodatabase in %s" % workspace)
# --------------------------------------------------------------------
# check inputfields
log.info("Getting commandline parameters")
if len(sys.argv) == 6:
input_peilgebieden = sys.argv[1]
input_waterlevel_table = sys.argv[2]
input_ahn_raster = sys.argv[3]
output_inundation = sys.argv[4]
output_folder_waterlevel = sys.argv[5]
else:
log.error("Usage: python rural_inundatie.py <peilgebieden feature>\
<input_waterlevel_table> <input_ahn_raster> <output grid>")
sys.exit(1)
# --------------------------------------------------------------------
#check input parameters
log.info('Checking presence of input files')
if not(gp.exists(input_peilgebieden)):
log.error("inputfile peilgebieden: %s does not exist!",
input_peilgebieden)
sys.exit(5)
if not(gp.exists(input_waterlevel_table)):
log.error("inputfile resultaten: %s does not exist!",
input_waterlevel_table)
sys.exit(5)
if not(gp.exists(input_ahn_raster)):
log.error("inputfile hoogtegrid: %s does not exist!",
input_ahn_raster)
sys.exit(5)
log.info('input parameters checked')
# --------------------------------------------------------------------
# Check geometry input parameters
cellsize = gp.describe(input_ahn_raster).MeanCellHeight
log.info("Check geometry of input parameters")
geometry_check_list = []
log.debug(" - check level areas: %s" % input_peilgebieden)
if gp.describe(input_peilgebieden).ShapeType != 'Polygon':
log.error("Input level area is not a polygon feature class!")
geometry_check_list.append(input_peilgebieden + " -> (Polygon)")
log.debug(" - check ahn raster %s" % input_ahn_raster)
if gp.describe(input_ahn_raster).DataType != 'RasterDataset':
log.error("Input AHN is not a raster dataset")
sys.exit(1)
if gp.describe(input_ahn_raster).PixelType[0] not in ['U', 'S']:
log.error("Input AHN is a floating point raster,\
for this script an integer is nessecary")
geometry_check_list.append(input_ahn_raster + " -> (Integer)")
if len(geometry_check_list) > 0:
log.error("check input: %s" % geometry_check_list)
sys.exit(2)
log.info('input format checked')
#---------------------------------------------------------------------
# Check required fields in input data
log.info("Check required fields in input data")
gpgident = config.get('General', 'gpgident')
missing_fields = []
# create return period list
return_periods = config.get(
'Inundatie', 'herhalingstijden').split(", ")
log.debug(" - return periods: %s" % return_periods)
# <check required fields from input data,
# append them to list if missing>"
if not turtlebase.arcgis.is_fieldname(
gp, input_peilgebieden, gpgident):
log.debug(" - missing: %s in %s",
(gpgident, input_peilgebieden))
missing_fields.append("%s: %s",
(input_peilgebieden, gpgident))
if not turtlebase.arcgis.is_fieldname(
gp, input_waterlevel_table, gpgident):
log.debug(" - missing: %s in %s",
(gpgident, input_waterlevel_table))
missing_fields.append("%s: %s",
(input_waterlevel_table, gpgident))
for return_period in return_periods:
if not turtlebase.arcgis.is_fieldname(
gp, input_waterlevel_table, "WS_%s" % return_period):
log.debug(" - missing: %s in %s" % ("WS_%s",
return_period, input_waterlevel_table))
missing_fields.append("%s: %s",
(input_waterlevel_table, "WS_%s" % return_period))
if len(missing_fields) > 0:
log.error("missing fields in input data: %s" % missing_fields)
sys.exit(2)
#---------------------------------------------------------------------
# Environments
log.info("Setting environments")
temp_peilgebieden = (
turtlebase.arcgis.get_random_file_name(workspace_gdb))
log.debug(" - export level areas")
gp.select_analysis(input_peilgebieden, temp_peilgebieden)
# use extent from level areas
gp.extent = gp.describe(temp_peilgebieden).extent
# add waterlevel to peilgebieden
log.info("Read waterlevels from table")
waterlevel_dict = nens.gp.get_table(
gp, input_waterlevel_table, primary_key=gpgident.lower())
join_waterlevel_to_level_area(
gp, temp_peilgebieden, gpgident,
return_periods, waterlevel_dict)
#---------------------------------------------------------------------
log.info("A) Create rasters for waterlevels")
# Create waterlevel rasters
if output_folder_waterlevel == "#":
output_folder_waterlevel = workspace_gdb
for return_period in return_periods:
log.info(" - create raster for ws_%s" % return_period)
out_raster_dataset = os.path.join(
output_folder_waterlevel,
"ws_%s" % return_period)
if not gp.exists(out_raster_dataset):
input_field = "WS_%s" % return_period
gp.FeatureToRaster_conversion(temp_peilgebieden,
input_field,
out_raster_dataset,
int(cellsize))
else:
log.error("output waterlevel raster already exists,\
delete this first or change output folder")
sys.exit(1)
#---------------------------------------------------------------------
log.info("B) Create Inundation raster")
inundation_raster_list = []
# create ahn ascii
ahn_ascii = turtlebase.arcgis.get_random_file_name(workspace, ".asc")
log.debug("ahn ascii: %s" % ahn_ascii)
gp.RasterToASCII_conversion(input_ahn_raster, ahn_ascii)
# inundatie stedelijk
return_period_urban = config.get(
'Inundatie', 'herhalingstijd_inundatie_stedelijk')
if config.get('Inundatie', 'percentage_inundatie_stedelijk') != "-":
log.debug(" - create inundation urban")
waterlevel = "%s/ws_%s" % (
output_folder_waterlevel, return_period_urban)
if gp.exists(waterlevel):
inundation_urban = turtlebase.arcgis.get_random_file_name(
workspace, ".asc")
turtlebase.spatial.create_inundation_raster(
ahn_ascii, ahn_ascii, waterlevel, 1,
return_period_urban, inundation_urban,
workspace, use_lgn=False)
inundation_raster_list.append(inundation_urban)
else:
log.error("%s does not exists! check ini-file and tempfolder",
waterlevel)
# inundatie hoogwaardige landbouw
return_period_agriculture = config.get(
'Inundatie', 'herhalingstijd_inundatie_hoogwaardig')
if config.get('Inundatie', 'percentage_inundatie_hoogwaardig') != "-":
log.debug(" - create inundation agriculture")
waterlevel = "%s/ws_%s" % (
output_folder_waterlevel, return_period_agriculture)
if gp.exists(waterlevel):
# Inundation with lgn
inundation_agriculture = (
turtlebase.arcgis.get_random_file_name(
workspace, ".asc"))
turtlebase.spatial.create_inundation_raster(
ahn_ascii, ahn_ascii, waterlevel,
2, return_period_agriculture,
inundation_agriculture, workspace,
use_lgn=False)
inundation_raster_list.append(inundation_agriculture)
else:
log.error("%s does not exists! check ini-file and tempfolder",
waterlevel)
# inundatie akkerbouw
return_period_rural = config.get(
'Inundatie', 'herhalingstijd_inundatie_akker')
if config.get('Inundatie', 'percentage_inundatie_akker') != "-":
log.debug(" - create inundation rural")
waterlevel = "%s/ws_%s" % (
output_folder_waterlevel, return_period_rural)
if gp.exists(waterlevel):
inundation_rural = turtlebase.arcgis.get_random_file_name(
workspace, ".asc")
turtlebase.spatial.create_inundation_raster(
ahn_ascii, ahn_ascii, waterlevel,
3, return_period_rural, inundation_rural,
workspace, use_lgn=False)
inundation_raster_list.append(inundation_rural)
else:
log.error("%s does not exists! check ini-file and tempfolder",
waterlevel)
# inundatie grasland
return_period_grass = config.get(
'Inundatie', 'herhalingstijd_inundatie_grasland')
if config.get('Inundatie', 'percentage_inundatie_grasland') != "-":
log.debug(" - create inundation grass")
waterlevel = ("%s/ws_%s" % (
output_folder_waterlevel,
return_period_grass))
if gp.exists(waterlevel):
inundation_grass = turtlebase.arcgis.get_random_file_name(
workspace, ".asc")
turtlebase.spatial.create_inundation_raster(
ahn_ascii, ahn_ascii, waterlevel,
4, return_period_grass, inundation_grass,
workspace, use_lgn=False)
inundation_raster_list.append(inundation_grass)
else:
log.error("%s does not exists! check ini-file and tempfolder",
waterlevel)
if len(inundation_raster_list) > 1:
log.info(" - merge inundation rasters")
turtlebase.spatial.merge_ascii(
inundation_raster_list, output_inundation, workspace)
else:
log.error("there are no inundation rasters available")
#---------------------------------------------------------------------
# Delete temporary workspace geodatabase & ascii files
try:
log.debug("delete temporary workspace: %s" % workspace_gdb)
#gp.delete(workspace_gdb)
log.info("workspace deleted")
except:
log.warning("failed to delete %s" % workspace_gdb)
tempfiles = os.listdir(workspace)
for tempfile in tempfiles:
if tempfile.endswith('.asc'):
try:
os.remove(os.path.join(workspace, tempfile))
except Exception, e:
log.debug(e)
mainutils.log_footer()
def main():
try:
gp = mainutils.create_geoprocessor()
config = mainutils.read_config(__file__, 'turtle-settings.ini')
logfile = mainutils.log_filename(config)
logging_config = LoggingConfig(gp, logfile=logfile)
mainutils.log_header(__name__)
#----------------------------------------------------------------------------------------
# Create workspace
workspace = config.get('GENERAL', 'location_temp')
if workspace == "-":
workspace = tempfile.gettempdir()
turtlebase.arcgis.delete_old_workspace_gdb(gp, workspace)
if not os.path.isdir(workspace):
os.makedirs(workspace)
workspace_gdb, errorcode = turtlebase.arcgis.create_temp_geodatabase(gp, workspace)
if errorcode == 1:
log.error("failed to create a file geodatabase in %s" % workspace)
#----------------------------------------------------------------------------------------
# Input parameters
if len(sys.argv) == 11:
log.info("Reading input parameters")
peilgebied = sys.argv[1]
input_rr_peilgebied = sys.argv[2]
input_rr_maaiveld = sys.argv[3]
input_ahn = sys.argv[4]
input_lgn = sys.argv[5]
conversion = sys.argv[6]
input_hymstat = sys.argv[7]
output_risk_table = sys.argv[8]
output_risico = sys.argv[9]
output_risico_inundation = sys.argv[10]
else:
log.error("usage: <peilgebied> <input_rr_peilgebied> <input_rr_maaiveld> <input_ahn> <input_lgn>\
<conversion> <input_hymstat> <output_risk_table> <output_risico> <output_risico_inundation>")
sys.exit(1)
#----------------------------------------------------------------------------------------
log.info(" - read Conversion table")
conv_list = [d for d in csv.DictReader(open(conversion))]
expected_keys = ['LGN', 'K5', 'maxschade', 'sr1', 'sr2', 'sr3',
'sr4', 'sr5', 'sr6', 'sr7', 'sr8', 'sr9']
for k in expected_keys:
if k not in conv_list[0].keys():
log.error('could not find key %s in conversion table' % k)
sys.exit(2)
schadefuncties = {}
for item in conv_list:
schadefuncties[int(item['LGN'])] = item
#----------------------------------------------------------------------------------------
log.info(" - read hymstat table")
csv_list = [d for d in csv.DictReader(open(input_hymstat))]
expected_hymstat_keys = ['Location', 'Scale par. beta', 'Location par. x0']
for k in expected_hymstat_keys:
csv_list[0].keys()
if k not in csv_list[0].keys():
log.error('could not find key %s in hymstat table' % k)
sys.exit(2)
hymstat = {}
for item in csv_list:
hymstat[item[config.get('risico', 'hymstat_id')]] = item
#----------------------------------------------------------------------------------------
# Check geometry input parameters
log.info("Check geometry of input parameters")
geometry_check_list = []
#log.debug(" - check <input >: %s" % argument1)
"<check geometry from input data, append to list if incorrect>"
if len(geometry_check_list) > 0:
log.error("check input: %s" % geometry_check_list)
sys.exit(2)
#----------------------------------------------------------------------------------------
# Check required fields in input data
log.info("Check required fields in input data")
missing_fields = []
#<check required fields from input data, append them to list if missing>
check_fields = {}#check_fields = {input_1: [fieldname1, fieldname2], input_2: [fieldname1, fieldname2]}
for input_fc, fieldnames in check_fields.items():
for fieldname in fieldnames:
if not turtlebase.arcgis.is_fieldname(gp, input_fc, fieldname):
errormsg = "fieldname %s not available in %s" % (fieldname, input_fc)
log.error(errormsg)
missing_fields.append(errormsg)
if len(missing_fields) > 0:
log.error("missing fields in input data: %s" % missing_fields)
sys.exit(2)
#----------------------------------------------------------------------------------------
# Environments
log.info("Set environments")
temp_peilgebieden = turtlebase.arcgis.get_random_file_name(workspace_gdb)
gp.Select_analysis(peilgebied, temp_peilgebieden)
cellsize = gp.describe(input_ahn).MeanCellHeight # use same cell size as AHN
gp.extent = gp.describe(temp_peilgebieden).extent # use extent from Peilgebieden
gpgident = config.get('GENERAL', 'gpgident')
#----------------------------------------------------------------------------------------
# create ahn ascii
log.info("Create ascii from ahn")
ahn_ascii = turtlebase.arcgis.get_random_file_name(workspace, ".asc")
log.debug("ahn ascii: %s" % ahn_ascii)
gp.RasterToASCII_conversion(input_ahn, ahn_ascii)
#----------------------------------------------------------------------------------------
# create lgn ascii
log.info("Create ascii from lgn")
#read gpgident from file
lgn_desc = gp.describe(input_lgn)
if lgn_desc.DataType == 'ShapeFile' or lgn_desc.DataType == 'FeatureClass':
lgn_fieldnames = nens.gp.get_table_def(gp, input_lgn)
if "gridcode" in lgn_fieldnames:
gridcode = "GRIDCODE"
elif "grid_code" in lgn_fieldnames:
gridcode = "grid_code"
else:
log.error("Cannot find 'grid_code' or 'gridcode' field in input lgn file")
temp_lgn = turtlebase.arcgis.get_random_file_name(workspace_gdb)
gp.FeatureToRaster_conversion(input_lgn, gridcode, temp_lgn, cellsize)
elif lgn_desc.DataType == 'RasterDataset':
temp_lgn = input_lgn
if not lgn_desc.MeanCellHeight == cellsize:
log.error("LGN cellsize does not match AHN cellsize (%sx%s m)" % cellsize)
sys.exit(5)
else:
log.error("cannot recognize datatype of LGN, must be a fc, shapefile or a raster dataset")
sys.exit(5)
lgn_ascii = turtlebase.arcgis.get_random_file_name(workspace, ".asc")
log.debug("lgn ascii: %s" % lgn_ascii)
gp.RasterToASCII_conversion(temp_lgn, lgn_ascii)
#----------------------------------------------------------------------------------------
log.info("Create ascii from surface level areas")
if not turtlebase.arcgis.is_fieldname(gp, temp_peilgebieden, "ID_INT"):
gp.AddField(temp_peilgebieden, "ID_INT", "LONG")
id_int = 1
idint_to_peilvakid = {}
peilvakid_to_idint = {}
if turtlebase.arcgis.is_fieldname(gp, temp_peilgebieden, gpgident):
rows = gp.SearchCursor(temp_peilgebieden)
for row in nens.gp.gp_iterator(rows):
peilvakid = row.GetValue(gpgident)
idint_to_peilvakid[id_int] = peilvakid
peilvakid_to_idint[peilvakid] = id_int
id_int = id_int + 1 #each row gets a new id_int
log.info(" - calc value ID_INT")
rows = gp.UpdateCursor(temp_peilgebieden)
for row in nens.gp.gp_iterator(rows):
gpg_ident = row.GetValue(gpgident)
id_int = peilvakid_to_idint[gpg_ident]
row.SetValue("ID_INT", id_int)
rows.UpdateRow(row)
log.info("Conversion feature peilgebieden to raster")
InField = "ID_INT"
temp_peilgebieden_raster = turtlebase.arcgis.get_random_file_name(workspace_gdb)
gp.FeatureToRaster_conversion(temp_peilgebieden, InField, temp_peilgebieden_raster, cellsize)
peilgeb_asc = turtlebase.arcgis.get_random_file_name(workspace, ".asc")
gp.RasterToASCII_conversion(temp_peilgebieden_raster, peilgeb_asc)
#----------------------------------------------------------------------------------------
# Read input tables into dictionaries
log.info("Read input tables")
log.info(" - read RR_Peilgebied")
rr_peilgebied = nens.gp.get_table(gp, input_rr_peilgebied, primary_key=gpgident.lower())
log.info(" - read RR_Maaiveld")
rr_maaiveld = nens.gp.get_table(gp, input_rr_maaiveld, primary_key=gpgident.lower())
log.info(" - read conversion table between id_int and gpgident")
gpg_conv = nens.gp.get_table(gp, temp_peilgebieden, primary_key='id_int')
#----------------------------------------------------------------------------------------
log.info("Calculate Risk")
temp_risico = turtlebase.arcgis.get_random_file_name(workspace, "risk.asc")
temp_risico_in = turtlebase.arcgis.get_random_file_name(workspace, ".asc")
risico_tbl = turtlebase.risico.create_risk_grid(ahn_ascii, lgn_ascii,
peilgeb_asc, rr_peilgebied, rr_maaiveld,
hymstat, gpg_conv, schadefuncties, temp_risico,
temp_risico_in, cellsize)
risk_result = turtlebase.risico.create_risico_dict(risico_tbl, schadefuncties, primary_key=gpgident)
for k in risk_result.keys():
risk_result[k]['SOURCE'] = "hymstat: %s, ahn: %s, lgn: %s" % (os.path.basename(input_hymstat),
os.path.basename(input_ahn),
os.path.basename(input_lgn))
risk_result[k]['DATE_TIME'] = time.strftime("%d-%m-%Y, %H:%M:%S")
gp.ASCIIToRaster_conversion(temp_risico, output_risico, "FLOAT")
gp.ASCIIToRaster_conversion(temp_risico_in, output_risico_inundation, "FLOAT")
# Schrijf de resultaten weg als een nieuwe tabel
if not(gp.exists(output_risk_table)):
log.info("creating table " + output_risk_table)
gp.CreateTable(os.path.dirname(output_risk_table), os.path.basename(output_risk_table))
risk_fields = nens.gp.get_table_def(gp, output_risk_table)
fields_to_add = [{'fieldname': gpgident, 'fieldtype': 'text', 'length': 50},
{'fieldname': 'RIS_GW', 'fieldtype': 'Double'},
{'fieldname': 'RIS_GW_ST', 'fieldtype': 'Double'},
{'fieldname': 'RIS_GW_HL', 'fieldtype': 'Double'},
{'fieldname': 'RIS_GW_AK', 'fieldtype': 'Double'},
{'fieldname': 'RIS_GW_GR', 'fieldtype': 'Double'},
{'fieldname': 'RIS_GW_NT', 'fieldtype': 'Double'},
{'fieldname': 'RIS_IN', 'fieldtype': 'Double'},
{'fieldname': 'RIS_IN_ST', 'fieldtype': 'Double'},
{'fieldname': 'RIS_IN_HL', 'fieldtype': 'Double'},
{'fieldname': 'RIS_IN_AK', 'fieldtype': 'Double'},
{'fieldname': 'RIS_IN_GR', 'fieldtype': 'Double'},
{'fieldname': 'RIS_IN_NT', 'fieldtype': 'Double'},
{'fieldname': 'SOURCE', 'fieldtype': 'text', 'length': 256},
{'fieldname': 'DATE_TIME', 'fieldtype': 'text', 'length': 25},
{'fieldname': 'COMMENTS', 'fieldtype': 'text', 'length': 256}]
for field_to_add in fields_to_add:
if field_to_add['fieldname'].lower() not in risk_fields:
if 'length' in field_to_add:
gp.addfield_management(output_risk_table, field_to_add['fieldname'], field_to_add['fieldtype'], "#", "#", field_to_add['length'])
else:
gp.addfield_management(output_risk_table, field_to_add['fieldname'], field_to_add['fieldtype'])
turtlebase.arcgis.write_result_to_output(output_risk_table, gpgident, risk_result)
#----------------------------------------------------------------------------------------
# Delete temporary workspace geodatabase & ascii files
try:
log.debug("delete temporary workspace: %s" % workspace_gdb)
gp.delete(workspace_gdb)
log.info("workspace deleted")
except:
log.debug("failed to delete %s" % workspace_gdb)
tempfiles = os.listdir(workspace)
for tempfile in tempfiles:
if tempfile.endswith('.asc') or tempfile.endswith('.prj') :
try:
os.remove(os.path.join(workspace, tempfile))
log.debug("%s/%s removed" % (workspace, tempfile))
except Exception, e:
log.debug(e)
mainutils.log_footer()
def main():
try:
gp = mainutils.create_geoprocessor()
config = mainutils.read_config(__file__, 'turtle-settings.ini')
logfile = mainutils.log_filename(config)
logging_config = LoggingConfig(gp, logfile=logfile)
mainutils.log_header(__name__)
#----------------------------------------------------------------------------------------
# Create workspace
workspace = config.get('GENERAL', 'location_temp')
if workspace == "-":
workspace = tempfile.gettempdir()
turtlebase.arcgis.delete_old_workspace_gdb(gp, workspace)
if not os.path.isdir(workspace):
os.makedirs(workspace)
workspace_gdb, errorcode = turtlebase.arcgis.create_temp_geodatabase(gp, workspace)
if errorcode == 1:
log.error("failed to create a file geodatabase in %s" % workspace)
#----------------------------------------------------------------------------------------
#ernst rekenklasse
ernst_drainage = ernst()
#----------------------------------------------------------------------------------------
#check inputfields
log.info("Getting commandline parameters... ")
if len(sys.argv) == 7:
file_input_peilgebieden_feature = sys.argv[1] #shape
file_input_peilvakgegevens = sys.argv[2] #[ZOMERPEIL],[WINTERPEIL]
file_input_kwelstroom = sys.argv[3] #[KWELSTROOM]
file_input_maaiveldkarakteristiek = sys.argv[4] #[MV_HGT_50]
file_input_bodemsoort = sys.argv[5] #shape
file_output = sys.argv[6]
else:
log.error("Usage: python rural_drainageparameter.py <peilgebieden shape> <peilvakgegevens> <kwelstroom> <maaiveldkarakteristiek> <bodemsoort shape> <outputtabel HydroBase>")
sys.exit(1)
#----------------------------------------------------------------------------------------
# Check geometry
log.info("Check geometry of input parameters")
if not turtlebase.arcgis.is_file_of_type(gp, file_input_peilgebieden_feature, 'Polygon'):
log.error("Input %s does not contain polygons" % file_input_peilgebieden_feature)
sys.exit(1)
if not turtlebase.arcgis.is_file_of_type(gp, file_input_bodemsoort, 'Polygon'):
log.error("Input %s does not contain polygons" % file_input_bodemsoort)
sys.exit(1)
#----------------------------------------------------------------------------------------
# Check required fields
log.info("Check required fields in input data")
peilgebied_id = config.get('GENERAL', 'gpgident')
pawn_code = config.get('Ernst', 'input_bodemsoort_code')
missing_fields = []
check_fields = {file_input_peilgebieden_feature: peilgebied_id,
file_input_peilvakgegevens: peilgebied_id,
file_input_peilvakgegevens: config.get('Ernst', 'peilvakgegevens_zomerpeil'),
file_input_peilvakgegevens: config.get('Ernst', 'peilvakgegevens_winterpeil'),
file_input_kwelstroom: peilgebied_id,
file_input_kwelstroom: config.get('Ernst', 'kwelstroom_kwelstroom'),
file_input_maaiveldkarakteristiek: peilgebied_id,
file_input_maaiveldkarakteristiek: config.get('Ernst', 'maaiveldkarakteristiek_value'),
file_input_bodemsoort: pawn_code}
for input_file, field in check_fields.items():
if not turtlebase.arcgis.is_fieldname(gp, input_file, field):
log.error("Missing field %s in %s" % (field, input_file))
missing_fields.append("missing %s in %s" % (field, input_file))
if len(missing_fields) > 0:
log.error("missing fields in input data: %s" % missing_fields)
sys.exit(2)
#----------------------------------------------------------------------------------------
# Check record count
log.info("Check records of input parameters")
count_area = turtlebase.arcgis.fc_records(gp, file_input_peilgebieden_feature)
count_surface_level_table = turtlebase.arcgis.fc_records(gp, file_input_peilvakgegevens)
count_seepage = turtlebase.arcgis.fc_records(gp, file_input_kwelstroom)
count_scurve = turtlebase.arcgis.fc_records(gp, file_input_maaiveldkarakteristiek)
if count_surface_level_table != count_area:
log.error("input %s (%s records) contains not the same records as %s (%s records)" % (file_input_peilvakgegevens, count_surface_level_table,
file_input_peilgebieden_feature, count_area))
sys.exit(2)
if count_seepage != count_area:
log.error("input %s (%s records) contains not the same records as %s (%s records)" % (file_input_kwelstroom, count_seepage,
file_input_peilgebieden_feature, count_area))
sys.exit(2)
if count_scurve != count_area:
log.error("input %s (%s records) contains not the same records as %s (%s records)" % (file_input_maaiveldkarakteristiek,
count_scurve, file_input_peilgebieden_feature, count_area))
sys.exit(2)
#----------------------------------------------------------------------------------------
#A: bodemsoort
log.info("A-1) Copy peilgebieden to temporary workspace")
temp_peilgebieden = turtlebase.arcgis.get_random_file_name(workspace_gdb)
gp.select_analysis(file_input_peilgebieden_feature, temp_peilgebieden)
log.info("A-2) Copy bodemsoort to temporary workspace")
temp_bodemsoort = turtlebase.arcgis.get_random_file_name(workspace_gdb)
gp.select_analysis(file_input_bodemsoort, temp_bodemsoort)
log.info("A-3) Intersect bodemsoort + peilgebieden -> peilg+bodem")
temp_intersect_bodem_peilgebieden = turtlebase.arcgis.get_random_file_name(workspace_gdb)
gp.Intersect_analysis(temp_peilgebieden + "; " + temp_bodemsoort, temp_intersect_bodem_peilgebieden)
log.info("A-4) Dissolve peilg+bodem")
temp_dissolve_bodem_peilgebieden = turtlebase.arcgis.get_random_file_name(workspace_gdb)
gp.Dissolve_management (temp_intersect_bodem_peilgebieden, temp_dissolve_bodem_peilgebieden, peilgebied_id + " ;" + pawn_code, "")
log.info("A-5) Read peilg+bodem(dissolve)")
log.info(" - reading shape")
peilv_grondsoort = {}
row = gp.SearchCursor(temp_dissolve_bodem_peilgebieden)
for item in nens.gp.gp_iterator(row):
area_id = item.GetValue(peilgebied_id)
soil_id = item.GetValue(pawn_code)
area = item.Shape.Area
data_row = {'pawn_code': soil_id, 'area': area}
if not(peilv_grondsoort.has_key(area_id)):
peilv_grondsoort[area_id] = {'grondsoort':[]}
peilv_grondsoort[area_id]['grondsoort'].append(data_row)
log.info(" - sorting")
for key in peilv_grondsoort.keys():
peilv_grondsoort[key]['grondsoort'].sort(sort_area_rev)
peilv_grondsoort[key]['area'] = sum_grondsoort(peilv_grondsoort[key]['grondsoort'])
# ---------------------------------------------------------------------------
#B: ernst parameters
#inlezen van shape files: [ZOMERPEIL, WINTERPEIL, KWELSTROOM, MV_HGT_50]
log.info("B-1) Reading inputfile peilvakgegevens")
data_set = {}
row = gp.SearchCursor(file_input_peilvakgegevens)
for item in nens.gp.gp_iterator(row):
field_id = item.GetValue(peilgebied_id)
data_set[field_id] = {}
data_set[field_id]['zomerpeil'] = item.GetValue(config.get('Ernst', 'peilvakgegevens_zomerpeil'))
data_set[field_id]['winterpeil'] = item.GetValue(config.get('Ernst', 'peilvakgegevens_winterpeil'))
if (data_set[field_id]['zomerpeil'] < float(config.get('Ernst', 'validate_min_zomerpeil'))) or (data_set[field_id]['zomerpeil'] > float(config.get('Ernst', 'validate_max_zomerpeil'))):
log.error("zomerpeil has a non-valid value of " + str(data_set[field_id]['zomerpeil']))
sys.exit(5)
if (data_set[field_id]['winterpeil'] < float(config.get('Ernst', 'validate_min_winterpeil'))) or (data_set[field_id]['zomerpeil'] > float(config.get('Ernst', 'validate_max_winterpeil'))):
log.error("winterpeil has a non-valid value of " + str(data_set[field_id]['winterpeil']))
sys.exit(5)
#inlezen van shape files: [ZOMERPEIL, WINTERPEIL, KWELSTROOM, MV_HGT_50]
log.info("B-2) Reading inputfile kwelstroom")
row = gp.SearchCursor(file_input_kwelstroom)
for item in nens.gp.gp_iterator(row):
field_id = item.GetValue(peilgebied_id)
if not(data_set.has_key(field_id)):
log.error("non-matching kwelstroom and peilvakgegevens, check if peilvakgegevens has key '" + field_id + "'")
sys.exit(9)
data_set[field_id]['kwel'] = item.GetValue(config.get('Ernst', 'kwelstroom_kwelstroom'))
#inlezen van shape files: [ZOMERPEIL, WINTERPEIL, KWELSTROOM, MV_HGT_50]
log.info("B-3) Reading inputfile maaiveldkarakteristiek")
row = gp.SearchCursor(file_input_maaiveldkarakteristiek)
for item in nens.gp.gp_iterator(row):
field_id = item.GetValue(peilgebied_id)
if not(data_set.has_key(field_id)):
log.error("non-matching maaiveldkarakteristiek and peilvakgegevens, check if peilvakgegevens has key '" + field_id + "'")
sys.exit(9)
data_set[field_id]['maaiveld'] = item.GetValue(config.get('Ernst', 'maaiveldkarakteristiek_value'))
# ---------------------------------------------------------------------------
#check input: each record should contain all fields (count: 4)
log.info("B-4) Checking input")
for key, value in data_set.items():
if len(value.items()) != 4:
log.error(key, value)
log.error("check if inputfiles match with eachother!")
sys.exit(6)
# ---------------------------------------------------------------------------
#bepaling drooglegging: [DL] = [MV_HGT_50] - max([WINTERPEIL], [ZOMERPEIL])
#bepaling drainageweerstand [ALFA_LZ] = xx * [DL} - yy, waarbij xx, yy afhangen van de klasse
#bepaling INF_OPWAT, OPP_AFVOER
log.info("B-6) preparing data for output")
data_set_output = {}
import time
date_str = time.strftime("%d %B %Y %H:%M:%S")
log.info("Calculating GRONDSOORT, drooglegging, ALFA_LZ, INF_OPWAT, OPP_AFVOER... ")
log.info(" - Datum-string: " + date_str)
for key, item in data_set.items():
#print key, item
data_set[key]['drooglegging'] = ernst_drainage.calc_dl(item['maaiveld'], item['zomerpeil'], item['winterpeil'])
data_set_output[key] = {}
data_set_output[key][peilgebied_id] = key #important!
data_set_output[key][config.get('Ernst', 'output_alfa_lz')] = ernst_drainage.calc_alfa(data_set[key]['kwel'], data_set[key]['drooglegging'])
data_set_output[key][config.get('Ernst', 'output_inf_opwat')] = 500 #of dataset['key']['ALFA_LZ']*1.5
data_set_output[key][config.get('Ernst', 'output_opp_afvoer')] = 0.5
grondsrt_str = ""
try:
data_set_output[key][config.get('Ernst', 'output_grondsoort')] = peilv_grondsoort[key]['grondsoort'][0]['pawn_code']
for idx in range(min(len(peilv_grondsoort[key]['grondsoort']), 5)):
grondsrt_str = grondsrt_str + str(peilv_grondsoort[key]['grondsoort'][idx]['pawn_code']) + "(" + str(int(100 * peilv_grondsoort[key]['grondsoort'][idx]['area'] / peilv_grondsoort[key]['area'])) + "%) "
except Exception, e:
log.warning(e)
log.warning("id " + key + " has no " + config.get('Ernst', 'output_grondsoort') + " value!")
data_set_output[key][config.get('Ernst', 'output_grondsoort')] = -1
source_str = "grondsrt:" + grondsrt_str + "pv:" + os.path.basename(file_input_peilvakgegevens) + " kwel:" + os.path.basename(file_input_kwelstroom) + " mv:" + os.path.basename(file_input_maaiveldkarakteristiek)
if len(source_str) > 50:
source_str = source_str[:50]
data_set_output[key]['SOURCE'] = source_str
data_set_output[key]['DATE_TIME'] = date_str
# ---------------------------------------------------------------------------
#C: output
#add cols [ALFA_LZ], [INF_OPWAT], [OPP_AFVOER]
drainageFields = {peilgebied_id: {'type': 'TEXT', 'length': '30'},
config.get('Ernst', 'output_alfa_lz'):{'type': 'DOUBLE'},
config.get('Ernst', 'output_inf_opwat'):{'type': 'DOUBLE'},
config.get('Ernst', 'output_opp_afvoer'):{'type': 'DOUBLE'},
config.get('Ernst', 'output_grondsoort'):{'type': 'INTEGER'},
'SOURCE':{'type': 'TEXT', 'length': '256'},
'DATE_TIME':{'type': 'TEXT', 'length': '40'},
'COMMENTS':{'type': 'TEXT', 'length': '256'}}
#check if output_table exists. if not, create with correct rows
log.info("C-1) Checking output table... ")
if not(gp.exists(file_output)):
gp.CreateTable(os.path.dirname(file_output), os.path.basename(file_output))
#check if output_table has the correct rows
log.info("C-2) Checking fields... ")
for field_name, field_settings in drainageFields.items():
if field_settings.has_key('length'):
if not turtlebase.arcgis.is_fieldname(gp, file_output, field_name):
gp.AddField(file_output, field_name, field_settings['type'], '#', '#', field_settings['length'])
else:
if not turtlebase.arcgis.is_fieldname(gp, file_output, field_name):
gp.AddField(file_output, field_name, field_settings['type'])
# ---------------------------------------------------------------------------
# Write results to output table
log.info("Write results to output table")
turtlebase.arcgis.write_result_to_output(file_output, peilgebied_id, data_set_output)
#----------------------------------------------------------------------------------------
# Delete temporary workspace geodatabase & ascii files
try:
log.debug("delete temporary workspace: %s" % workspace_gdb)
gp.delete(workspace_gdb)
log.info("workspace deleted")
except:
log.warning("failed to delete %s" % workspace_gdb)
mainutils.log_footer()
def main():
try:
gp = mainutils.create_geoprocessor()
config = mainutils.read_config(__file__, 'turtle-settings.ini')
logfile = mainutils.log_filename(config)
logging_config = LoggingConfig(gp, logfile=logfile)
mainutils.log_header(__name__)
#----------------------------------------------------------------------------------------
# Create workspace
workspace = config.get('GENERAL', 'location_temp')
if workspace == "-":
workspace = tempfile.gettempdir()
log.info("location temp: %s" % workspace)
turtlebase.arcgis.delete_old_workspace_gdb(gp, workspace)
if not os.path.isdir(workspace):
os.makedirs(workspace)
workspace_gdb, errorcode = turtlebase.arcgis.create_temp_geodatabase(gp, workspace)
if errorcode == 1:
log.error("failed to create a file geodatabase in %s" % workspace)
#----------------------------------------------------------------------------------------
#get argv
log.info("Getting command parameters... ")
if len(sys.argv) == 7:
input_peilgebieden_feature = sys.argv[1] #from HydroBase
input_lgn = sys.argv[2]
input_conversiontable_dbf = sys.argv[3]
input_watershape = sys.argv[4]
output_table = sys.argv[5] #RR_oppervlak in HydroBase
output_crop_table = sys.argv[6]
else:
log.error("Arguments: <LGN raster> <peilgebied HydroBase-table> <conversiontable dbf> <output HydroBase-table>")
sys.exit(1)
#----------------------------------------------------------------------------------------
# Check geometry input parameters
log.info("Check geometry of input parameters")
geometry_check_list = []
lgn_desc = gp.describe(input_lgn)
if lgn_desc.DataType == 'RasterDataset' or lgn_desc.DataType == 'RasterLayer':
if lgn_desc.PixelType[0] not in ["S", "U"]:
errormsg = "input %s is not an integer raster!" % input_lgn
log.error(errormsg)
geometry_check_list.append(errormsg)
# Create shapefile from input raster
else:
log.info("Input LGN is a raster, convert to feature class")
temp_lgn_fc = turtlebase.arcgis.get_random_file_name(workspace_gdb)
gp.RasterToPolygon_conversion(input_lgn, temp_lgn_fc, "NO_SIMPLIFY")
elif lgn_desc.DataType == 'ShapeFile' or lgn_desc.DataType == 'FeatureClass':
if lgn_desc.ShapeType != 'Polygon':
errormsg = "input %s is not an integer raster!" % input_lgn
log.error(errormsg)
geometry_check_list.append(errormsg)
else:
# Copy shapefile to workspace
log.info("Input LGN is a feature class, copy to workspace")
temp_lgn_fc = turtlebase.arcgis.get_random_file_name(workspace_gdb)
gp.Select_analysis(input_lgn, temp_lgn_fc)
else:
log.error("datatype of LGN is %s , must be a ShapeFile, FeatureClass, RasterDataset or RasterLayer" % lgn_desc.DataType)
sys.exit(5)
if not(gp.exists(input_peilgebieden_feature)):
errormsg = "input %s does not exist!" % input_peilgebieden_feature
log.error(errormsg)
geometry_check_list.append(errormsg)
if not(gp.exists(input_conversiontable_dbf)):
errormsg = "input %s does not exist!" % input_conversiontable_dbf
log.error(errormsg)
geometry_check_list.append(errormsg)
if len(geometry_check_list) > 0:
log.error("check input: %s" % geometry_check_list)
sys.exit(2)
#----------------------------------------------------------------------------------------
# Check required fields in input data
log.info("Check required fields in input data")
missing_fields = []
"<check required fields from input data, append them to list if missing>"
gpgident = config.get('GENERAL', 'gpgident')
if not turtlebase.arcgis.is_fieldname(gp, input_peilgebieden_feature, gpgident):
log.debug(" - missing: %s in %s" % (gpgident, input_peilgebieden_feature))
missing_fields.append("%s: %s" % (input_peilgebieden_feature, gpgident))
hectares = config.get('OppervlakteParameters', 'input_oppervlak_area')
verhard_ha = config.get('OppervlakteParameters', 'input_oppervlak_verhard')
onvsted_ha = config.get('OppervlakteParameters', 'input_oppervlak_onvsted')
kassen_ha = config.get('OppervlakteParameters', 'input_oppervlak_kassen')
onvland_ha = config.get('OppervlakteParameters', 'input_oppervlak_onvland')
openwat_ha = config.get('OppervlakteParameters', 'input_oppervlak_openwat')
lgn_id = config.get('OppervlakteParameters', 'input_field_lgncode')
conversion_fields = [lgn_id, verhard_ha, onvsted_ha, kassen_ha, onvland_ha, openwat_ha, hectares]
for conversion_field in conversion_fields:
if not turtlebase.arcgis.is_fieldname(gp, input_conversiontable_dbf, conversion_field):
log.debug(" - missing: %s in %s" % (conversion_field, input_conversiontable_dbf))
missing_fields.append("%s: %s" % (input_conversiontable_dbf, conversion_field))
if len(missing_fields) > 0:
log.error("missing fields in input data: %s" % missing_fields)
sys.exit(2)
#----------------------------------------------------------------------------------------
# 2a) copy input targetlevel areas to workspace
log.info("A) Create feature class input_peilgebieden_feature -> tempfile_peilgebied")
peilgebieden_temp = turtlebase.arcgis.get_random_file_name(workspace_gdb)
gp.select_analysis(input_peilgebieden_feature, peilgebieden_temp)
# 2b) intersect(lgn+peilgebieden)
log.info("B) Intersect lgn_shape + tempfile_peilgebied -> lgn_peilgebieden")
intersect_temp = os.path.join(workspace_gdb, 'intersect_lgn_gpg')
gp.Union_analysis("%s;%s" % (temp_lgn_fc, peilgebieden_temp), intersect_temp)
# 3a) Read conversiontable into memory"
log.info("C-1) Read conversiontable into memory")
conversion = nens.gp.get_table(gp, input_conversiontable_dbf, primary_key=lgn_id.lower())
# 3b) calculate areas for lgn_id
log.info("C-2) Calculate areas for tempfile_LGN_peilgebied using conversiontable")
#read gpgident from file
lgn_fieldnames = nens.gp.get_table_def(gp, temp_lgn_fc)
if "gridcode" in lgn_fieldnames:
gridcode = "GRIDCODE"
elif "grid_code" in lgn_fieldnames:
gridcode = "grid_code"
else:
log.error("Cannot find 'grid_code' or 'gridcode' field in input lgn file")
gewastypen = {1: config.get('OppervlakteParameters', 'grass_area'),
2: config.get('OppervlakteParameters', 'corn_area'),
3: config.get('OppervlakteParameters', 'potatoes_area'),
4: config.get('OppervlakteParameters', 'sugarbeet_area'),
5: config.get('OppervlakteParameters', 'grain_area'),
6: config.get('OppervlakteParameters', 'miscellaneous_area'),
7: config.get('OppervlakteParameters', 'nonarable_land_area'),
8: config.get('OppervlakteParameters', 'greenhouse_area'),
9: config.get('OppervlakteParameters', 'orchard_area'),
10: config.get('OppervlakteParameters', 'bulbous_plants_area'),
11: config.get('OppervlakteParameters', 'foliage_forest_area'),
12: config.get('OppervlakteParameters', 'pine_forest_area'),
13: config.get('OppervlakteParameters', 'nature_area'),
14: config.get('OppervlakteParameters', 'fallow_area'),
15: config.get('OppervlakteParameters', 'vegetables_area'),
16: config.get('OppervlakteParameters', 'flowers_area'),
}
output_with_area = {}
output_gewas_areas = {}
unknown_lgn_codes = {}
source_str = "lgn:" + os.path.basename(input_lgn) + " pg:" + os.path.basename(input_peilgebieden_feature)
if len(source_str) > 50:
source_str = source_str[:50]
date_str = time.strftime('%x')
calc_count = 0
rows = gp.UpdateCursor(intersect_temp)
for row in nens.gp.gp_iterator(rows):
value_gpgident = row.GetValue(gpgident)
if value_gpgident == "":
continue
value_gridcode = row.GetValue(gridcode)
if value_gridcode == 0:
if value_gpgident in output_with_area:
output_with_area[value_gpgident][hectares] += float(row.shape.Area) / 10000
else:
output_with_area[value_gpgident] = {gpgident : value_gpgident, hectares : float(row.shape.Area) / 10000}
continue
value_lgn_id = int(value_gridcode)
value_peilgeb_area = float(row.shape.Area) / 10000 #Area is in m2
if 'gewastype' in conversion[value_lgn_id]:
gewastype = conversion[value_lgn_id]['gewastype']
else:
gewastype = 1
#add to area
if value_gpgident in output_with_area:
add_to_area, gewastype_ha, error = conv_ha(conversion, value_lgn_id, float(value_peilgeb_area), gewastype)
for key in add_to_area.keys(): #all relevant keys
if key in output_with_area[value_gpgident]:
output_with_area[value_gpgident][key] += float(add_to_area[key])
else:
output_with_area[value_gpgident][key] = float(add_to_area[key])
else:
output_with_area[value_gpgident], gewastype_ha, error = conv_ha(conversion, value_lgn_id, float(value_peilgeb_area), gewastype)
output_with_area[value_gpgident][gpgident] = value_gpgident #set GPGIDENT
if error and not(value_lgn_id in unknown_lgn_codes):
log.warning(" - Warning: lgncode " + str(value_lgn_id) + " not known (check conversiontable)")
unknown_lgn_codes[value_lgn_id] = 1
if gewastype != 0:
if value_gpgident not in output_gewas_areas:
output_gewas_areas[value_gpgident] = {gpgident: value_gpgident}
for key in gewastypen.keys():
output_gewas_areas[value_gpgident][gewastypen[key]] = 0
output_gewas_areas[value_gpgident][gewastypen[gewastype]] += gewastype_ha
output_with_area[value_gpgident]['LGN_SOURCE'] = source_str
output_with_area[value_gpgident]['LGN_DATE'] = date_str
calc_count = calc_count + 1
if calc_count % 100 == 0:
log.info("Calculating field nr " + str(calc_count))
#----------------------------------------------------------------------------------------
if input_watershape != "#":
log.info("C-3) Calculate open water from watershape")
# 1) intersect(watershape+peilgebieden)
log.info("- intersect water_shape + tempfile_peilgebied -> watershape_peilgebieden")
watershape_intersect = turtlebase.arcgis.get_random_file_name(workspace_gdb)
gp.Intersect_analysis("%s;%s" % (input_watershape, peilgebieden_temp), watershape_intersect)
source_watershape = os.path.basename(input_watershape)
if len(source_watershape) > 50:
source_watershape = source_watershape[:50]
watershape_areas = {}
rows = gp.SearchCursor(watershape_intersect)
for row in nens.gp.gp_iterator(rows):
water_area_ha = float(row.shape.Area) / 10000 #Area is in m2
peilgebied_id = row.GetValue(gpgident)
if peilgebied_id in watershape_areas:
subtotal_area = watershape_areas[peilgebied_id]['area']
#overwrite key with sum areas
watershape_areas[peilgebied_id] = {'area': subtotal_area + water_area_ha}
else:
#create new key with area
watershape_areas[peilgebied_id] = {'area': water_area_ha}
#update outputtable
for peilgebied_id in output_with_area.keys():
if peilgebied_id in watershape_areas:
output_with_area[peilgebied_id]['OPNWT_GBKN'] = watershape_areas[peilgebied_id]['area']
output_with_area[peilgebied_id]['GBKN_DATE'] = date_str
output_with_area[peilgebied_id]['GBKN_SOURCE'] = source_watershape
#----------------------------------------------------------------------------------------
# 4) put dictionary area into output_table (HydroBase)
log.info("D) Saving results... ")
#definition of fields
areaFields = {gpgident: {'type': 'TEXT', 'length': '30'},
'VERHRD_LGN':{'type': 'DOUBLE'},
'ONVSTD_LGN':{'type': 'DOUBLE'},
'KASSEN_LGN':{'type': 'DOUBLE'},
'ONVLND_LGN':{'type': 'DOUBLE'},
'OPENWT_LGN':{'type': 'DOUBLE'},
'HECTARES':{'type': 'DOUBLE'},
'OPNWT_GBKN':{'type': 'DOUBLE'},
'LGN_SOURCE':{'type': 'TEXT', 'length': '50'},
'LGN_DATE':{'type': 'TEXT', 'length': '50'},
'GBKN_DATE':{'type': 'TEXT', 'length': '50'},
'GBKN_SOURCE':{'type': 'TEXT', 'length': '50'}}
#check if output_table exists. if not, create with correct rows
log.info("Checking table...")
if not(gp.exists(output_table)):
try:
gp.CreateTable(os.path.dirname(output_table), os.path.basename(output_table))
except Exception, e:
log.error("Error: creating table " + output_table)
log.debug(e)
sys.exit(14)
#check if output_table has the correct rows
log.info("Checking fields...")
for field_name, field_settings in areaFields.items():
if 'length' in field_settings:
if not turtlebase.arcgis.is_fieldname(gp, output_table, field_name):
gp.AddField(output_table, field_name, field_settings['type'], '#', '#', field_settings['length'])
else:
if not turtlebase.arcgis.is_fieldname(gp, output_table, field_name):
gp.AddField(output_table, field_name, field_settings['type'])
#----------------------------------------------------------------------------------------
#log.info(output_with_area)
turtlebase.arcgis.write_result_to_output(output_table, gpgident.lower(), output_with_area)
#----------------------------------------------------------------------------------------
# 5) Calculate crop areas
if output_crop_table != "#":
log.info("E) Calculate crop areas... ")
#definition of fields
cropFields = {gpgident: {'type': 'TEXT', 'length': '30'},
'GRAS_HA':{'type': 'DOUBLE'},
'MAIS_HA':{'type': 'DOUBLE'},
'AARDAPL_HA':{'type': 'DOUBLE'},
'BIET_HA':{'type': 'DOUBLE'},
'GRAAN_HA':{'type': 'DOUBLE'},
'OVERIG_HA':{'type': 'DOUBLE'},
'NIETAGR_HA':{'type': 'DOUBLE'},
'GLAST_HA':{'type': 'DOUBLE'},
'BOOMGRD_HA':{'type': 'DOUBLE'},
'BOLLEN_HA':{'type': 'DOUBLE'},
'LOOFBOS_HA':{'type': 'DOUBLE'},
'NLDBOS_HA':{'type': 'DOUBLE'},
'NATUUR_HA':{'type': 'DOUBLE'},
'BRAAK_HA':{'type': 'DOUBLE'},
'GROENTN_HA':{'type': 'DOUBLE'},
'BLOEMEN_HA':{'type': 'DOUBLE'}}
#check if output_table exists. if not, create with correct rows
log.info("Checking table...")
if not(gp.exists(output_crop_table)):
try:
gp.CreateTable(os.path.dirname(output_crop_table), os.path.basename(output_crop_table))
except Exception, e:
log.error("Error: creating table " + output_crop_table)
log.debug(e)
sys.exit(14)
#check if output_table has the correct rows
log.info("Checking fields...")
for field_name, field_settings in cropFields.items():
if 'length' in field_settings:
if not turtlebase.arcgis.is_fieldname(gp, output_crop_table, field_name):
gp.AddField(output_crop_table, field_name, field_settings['type'], '#', '#', field_settings['length'])
else:
if not turtlebase.arcgis.is_fieldname(gp, output_crop_table, field_name):
gp.AddField(output_crop_table, field_name, field_settings['type'])
write_result_to_output(gp, output_crop_table, gpgident.lower(), output_gewas_areas)
def main():
try:
"""
Deze module controleert of hoeveel procent duikers onder streefpeil liggen en hoeveel procent duikers onder zij onder bodemniveau liggen.
"""
gp = mainutils.create_geoprocessor()
config = mainutils.read_config(__file__, 'turtle-settings.ini')
logfile = mainutils.log_filename(config)
logging_config = LoggingConfig(gp, logfile=logfile)
mainutils.log_header(__name__)
# wordt globaal al geladen. maar werkt niet (?)
#---------------------------------------------------------------------
# Create workspace
workspace = config.get('GENERAL', 'location_temp')
if workspace == "-":
workspace = tempfile.gettempdir()
turtlebase.arcgis.delete_old_workspace_gdb(gp, workspace)
if not os.path.isdir(workspace):
os.makedirs(workspace)
workspace_gdb, errorcode = turtlebase.arcgis.create_temp_geodatabase(
gp, workspace)
if errorcode == 1:
log.error("failed to create a file geodatabase in %s" % workspace)
#---------------------------------------------------------------------
# Input parameters
if len(sys.argv) == 9:
peilgebieden_fc = sys.argv[1]
input_duikers = sys.argv[2]
input_stuwen = sys.argv[3]
input_sifons = sys.argv[4]
input_waterlopen_legger = sys.argv[5]
output_duikers = sys.argv[6]
output_stuwen = sys.argv[7]
output_sifons = sys.argv[8]
else:
log.error("usage: <peilgebieden> <duikers> <stuwen> <sifons> <waterlopen_legger> <duikers_out> <stuwen_out> <sifons_out>")
sys.exit(1)
if not gp.exists(peilgebieden_fc):
log.error("Features '%s' is not available in the hydrobase" % peilgebieden_fc)
sys.exit(1)
# TOEVOEGEN: CONTROLE basisdata
#---------------------------------------------------------------------
# Check required fields in input data
log.info("Check required fields in input data")
missing_fields = []
#<check required fields from input data,
# append them to list if missing>
#check_fields = {}
gpgident = config.get("general", "gpgident").lower()
ovkident = config.get("general", "ovkident").lower()
#legger
bodemhoogte_benedenstrooms = config.get("controle_kunstwerken", "bodemhoogte_benedenstrooms").lower()
bodemhoogte_bovenstrooms = config.get("controle_kunstwerken", "bodemhoogte_bovenstrooms").lower()
# bodem_hoogte_berekend = config.get("controle_kunstwerken", "bodem_hoogte_berekend").lower()
lengte_waterloop = config.get("controle_kunstwerken", "lengte_waterloop").lower()
output_field_verhang_bodem = config.get("controle_kunstwerken", "output_field_verhang_bodem").lower()
#peilgebieden
winterpeil = config.get("controle_kunstwerken", "winterpeil").lower()
zomerpeil = config.get("controle_kunstwerken", "zomerpeil").lower()
#verhang = config.get("controle_kunstwerken", "verhang").lower()
#duikers
kduident = config.get("controle_kunstwerken", "kduident").lower()
duiker_middellijn_diam= config.get("controle_kunstwerken", "duiker_middellijn_diam").lower()
duiker_vorm= config.get("controle_kunstwerken", "duiker_vorm").lower()
duiker_lengte= config.get("controle_kunstwerken", "duiker_lengte").lower()
duikerhoogte_bovenstrooms= config.get("controle_kunstwerken", "duikerhoogte_bovenstrooms").lower()
duikerhoogte_benedenstrooms= config.get("controle_kunstwerken", "duikerhoogte_benedenstrooms").lower()
duikerhoogte= config.get("controle_kunstwerken", "duikerhoogte").lower()
# Inlezen outputveldnamen
output_field_duikerlengte = config.get("controle_kunstwerken", "output_field_duikerlengte").lower()
output_field_duikerverhang = config.get("controle_kunstwerken", "output_field_duikerverhang").lower()
output_field_percentage_bodem = config.get("controle_kunstwerken", "output_field_percentage_bodem").lower()
output_field_percentage_bovenwinterpeil = config.get("controle_kunstwerken", "output_field_percentage_bovenwinterpeil").lower()
output_field_percentage_bovenzomerpeil = config.get("controle_kunstwerken", "output_field_percentage_bovenzomerpeil").lower()
#standaardwaardes
nodatavalue = int(config.get("controle_kunstwerken", "nodatavalue").lower())
treshold_value_verhang_duikers = float(config.get("controle_kunstwerken", "treshold_value_verhang_duikers").lower())
treshold_value_verhang_sifons = config.get("controle_kunstwerken", "treshold_value_verhang_sifons").lower()
#stuwen
kstident = config.get("controle_kunstwerken", "kstident").lower()
stuw_hoogte = config.get("controle_kunstwerken", "stuw_hoogte").lower()
#sifons
ksyident = config.get("controle_kunstwerken", "ksyident").lower()
sifonhoogte_benedenstrooms = config.get("controle_kunstwerken", "sifonhoogte_benedenstrooms").lower()
sifonhoogte_bovenstrooms = config.get("controle_kunstwerken", "sifonhoogte_bovenstrooms").lower()
sifon_middellijn_diam = config.get("controle_kunstwerken", "sifon_middellijn_diam").lower()
sifon_vorm = config.get("controle_kunstwerken", "sifon_vorm").lower()
sifon_lengte = config.get("controle_kunstwerken", "sifon_lengte").lower()
sifonhoogte = config.get("controle_kunstwerken", "sifonhoogte").lower()
sifon_middellijn_diam2 = config.get("controle_kunstwerken", "sifon_middellijn_diam2").lower()
output_field_sifonverhang = config.get("controle_kunstwerken", "output_field_sifonverhang").lower()
output_field_sifon_percentage_bodem = config.get("controle_kunstwerken", "output_field_sifon_percentage_bodem").lower()
output_field_sifon_percentage_bovenwinterpeil = config.get("controle_kunstwerken", "output_field_sifon_percentage_bovenwinterpeil").lower()
output_field_sifon_percentage_bovenzomerpeil = config.get("controle_kunstwerken", "output_field_sifon_percentage_bovenzomerpeil").lower()
# store fieldnames in a list, for convenience in further use
list_fieldnames_watergangen = [ovkident, bodemhoogte_benedenstrooms,bodemhoogte_bovenstrooms, lengte_waterloop]
list_fieldnames_peilgebieden = [gpgident, winterpeil, zomerpeil]
list_fieldnames_duikers = [kduident, duiker_middellijn_diam,duikerhoogte_bovenstrooms,duikerhoogte_benedenstrooms, duikerhoogte, duiker_vorm, duiker_lengte]
list_fieldnames_stuwen = [kstident,stuw_hoogte]
list_fieldnames_sifons = [ksyident,sifonhoogte_benedenstrooms,sifonhoogte_bovenstrooms,sifon_middellijn_diam,sifon_middellijn_diam2, sifon_vorm, sifon_lengte, sifonhoogte]
check_fields = {peilgebieden_fc: list_fieldnames_peilgebieden,
input_waterlopen_legger: list_fieldnames_watergangen,
input_duikers: list_fieldnames_duikers,
input_stuwen: list_fieldnames_stuwen,
input_sifons: list_fieldnames_sifons
}
for input_fc, fieldnames in check_fields.items():
if input_fc !='#':
for fieldname in fieldnames:
if not turtlebase.arcgis.is_fieldname(
gp, input_fc, fieldname):
errormsg = "fieldname %s not available in %s" % (
fieldname, input_fc)
log.error(errormsg)
missing_fields.append(errormsg)
if len(missing_fields) > 0:
log.error("missing fields in input data: %s" % missing_fields)
sys.exit(2)
#---------------------------------------------------------------------
# Environments
log.info("Check numbers of fields in input data")
errorcode = 0
nr_gpg = turtlebase.arcgis.fc_records(gp, peilgebieden_fc)
if nr_gpg == 0:
log.error("%s fc is empty" % peilgebieden_fc)
errorcode += 1
if input_duikers != '#':
#-------------------------------------------------------------------------------------------------------------------------------
# SECTION DUIKERS
#
#
#---------------------------------------------------------------------
# check of alle benodigde bestanden zijn ingevuld:
benodigdebestanden = [input_waterlopen_legger, peilgebieden_fc, output_duikers]
for fc in benodigdebestanden:
if fc =='#':
log.error('Bestand %s is noodzakelijk om duikers te controleren' %fc)
# Initieer dictionary
duikers = {}
#---------------------------------------------------------------------
# Join van duikers met watergangen
log.info('Koppel kunstwerken met watergangen')
duikers_incl_watergangen = turtlebase.arcgis.get_random_file_name(workspace_gdb, "")
gp.Spatialjoin_analysis(input_duikers, input_waterlopen_legger, duikers_incl_watergangen)
# Wegschrijven data naar dictionary
log.info('Schrijf informatie weg naar kunstwerken')
duikers = add_fc_values_to_dict(gp, duikers_incl_watergangen, duikers, kduident, list_fieldnames_watergangen)
#---------------------------------------------------------------------
# Join van duikers met peilgebieden
log.info('Koppel kunstwerken met peilgebieden')
duikers_incl_peilgebieden = turtlebase.arcgis.get_random_file_name(workspace_gdb, "")
gp.Spatialjoin_analysis(input_duikers, peilgebieden_fc, duikers_incl_peilgebieden)
duikers = add_fc_values_to_dict(gp, duikers_incl_peilgebieden, duikers, kduident, list_fieldnames_peilgebieden)
# Inlezen data uit de duikers
output_field_duikerlengte = config.get("controle_kunstwerken", "output_field_duikerlengte").lower()
#duikers = add_fc_attribs_to_dict(gp, duikers_incl_peilgebieden, duikers, kduident, 'Length', output_field_duikerlengte)
duikers = add_fc_values_to_dict(gp, duikers_incl_peilgebieden, duikers, kduident, list_fieldnames_duikers)
#---------------------------------------------------------------------
# Berekeningen
# Bereken de percentages onder en boven maaiveld
log.info('Start calculation')
duikers = calculate_duikers(duikers, config, nodatavalue, treshold_value_verhang_duikers, duiker_vorm,\
bodemhoogte_benedenstrooms, bodemhoogte_bovenstrooms,duiker_middellijn_diam, duikerhoogte,\
duikerhoogte_bovenstrooms,duikerhoogte_benedenstrooms, zomerpeil, winterpeil,lengte_waterloop,\
duiker_lengte, output_field_duikerverhang, output_field_percentage_bodem,\
output_field_percentage_bovenwinterpeil, output_field_percentage_bovenzomerpeil,output_field_verhang_bodem)
#log.info(duikers)
#log.info('dict_fields %s' %dict_fields)
log.info('Creeer output file')
# create rough copy
duikers_temp = turtlebase.arcgis.get_random_file_name(workspace_gdb, "")
gp.Select_analysis(input_duikers,duikers_temp)
# Creeer output fields with types
dict_fields = create_dict_fields(duikers)
log.info('Vul output file met berekende waarden')
log.info('duikers_temp %s' %duikers_temp)
# Vul de dataset met de waarden uit de dictionary
addfieldnames(gp, duikers_temp, dict_fields)
add_dict_values_to_fc(gp, duikers_temp, kduident, duikers, nodatavalue)
# Create output file
log.info('Opschonen output file')
# Als Append gebruikt wordt, kan er gebruik worden gemaakt van fieldmapping
if output_duikers == '#':
log.error('Geen output feature class ingevuld. Kan waarden niet wegschrijven')
sys.exit(1)
create_output_dataset(gp, output_duikers, dict_fields)
gp.Append_management(duikers_temp,output_duikers, 'NO_TEST')
log.info('Duikers finished')
#---------------------------------------------------------------------
#-------------------------------------------------------------------------------------------------------------------------------
# END OF SECTION DUIKERS
#
#
#---------------------------------------------------------------------
if input_sifons != '#':
#-------------------------------------------------------------------------------------------------------------------------------
# SECTION SIFON
#
#
#---------------------------------------------------------------------
# check of alle benodigde bestanden zijn ingevuld:
benodigdebestanden = [input_waterlopen_legger, peilgebieden_fc, output_sifons]
for fc in benodigdebestanden:
if fc =='#':
log.error('Bestand %s is noodzakelijk om sifons te controleren' %fc)
# Initieer dictionary
sifons = {}
#---------------------------------------------------------------------
# Join van duikers met watergangen
log.info('Koppel kunstwerken met watergangen')
sifons_incl_watergangen = turtlebase.arcgis.get_random_file_name(workspace_gdb, "")
gp.Spatialjoin_analysis(input_sifons, input_waterlopen_legger, sifons_incl_watergangen)
# Wegschrijven data naar dictionary
log.info('Schrijf informatie weg naar kunstwerken')
sifons = add_fc_values_to_dict(gp, sifons_incl_watergangen, sifons, ksyident, list_fieldnames_watergangen)
#---------------------------------------------------------------------
# Join van duikers met peilgebieden
log.info('Koppel kunstwerken met peilgebieden')
sifons_incl_peilgebieden = turtlebase.arcgis.get_random_file_name(workspace_gdb, "")
gp.Spatialjoin_analysis(input_sifons, peilgebieden_fc, sifons_incl_peilgebieden)
sifons = add_fc_values_to_dict(gp, sifons_incl_peilgebieden, sifons, ksyident, list_fieldnames_peilgebieden)
# Inlezen data uit de sifons
output_field_sifonlengte = config.get("controle_kunstwerken", "output_field_sifonlengte").lower()
sifons = add_fc_attribs_to_dict(gp, sifons_incl_peilgebieden, sifons, ksyident, 'Length', output_field_sifonlengte)
sifons = add_fc_values_to_dict(gp, sifons_incl_peilgebieden, sifons, ksyident, list_fieldnames_sifons)
#---------------------------------------------------------------------
# Berekeningen
log.info('Start calculation')
sifons = calculate_duikers(sifons, config, nodatavalue, treshold_value_verhang_sifons, sifon_vorm,\
bodemhoogte_benedenstrooms, bodemhoogte_bovenstrooms,sifon_middellijn_diam, sifonhoogte,\
sifonhoogte_bovenstrooms,sifonhoogte_benedenstrooms, zomerpeil, winterpeil,lengte_waterloop,\
sifon_lengte, output_field_sifonverhang, output_field_sifon_percentage_bodem,\
output_field_sifon_percentage_bovenwinterpeil, output_field_sifon_percentage_bovenzomerpeil,output_field_verhang_bodem)
#log.info('dict_fields %s' %dict_fields)
log.info('Creeer output file')
# create rough copy
sifons_temp = turtlebase.arcgis.get_random_file_name(workspace_gdb, "")
gp.Select_analysis(input_sifons,sifons_temp)
# Creeer output fields with types
dict_fields = create_dict_fields(sifons)
log.info('Vul output file met berekende waarden')
log.info('duikers_temp %s' %sifons_temp)
# Vul de dataset met de waarden uit de dictionary
addfieldnames(gp, sifons_temp, dict_fields)
add_dict_values_to_fc(gp, sifons_temp, ksyident, sifons, nodatavalue)
# Create output file
log.info('Opschonen output file')
# Als Append gebruikt wordt, kan er gebruik worden gemaakt van fieldmapping
if output_sifons == '#':
log.error('Geen output feature class ingevuld. Kan waarden niet wegschrijven')
sys.exit(1)
create_output_dataset(gp, output_sifons, dict_fields)
gp.Append_management(sifons_temp,output_sifons, 'NO_TEST')
log.info('Sifons finished')
#---------------------------------------------------------------------
#-------------------------------------------------------------------------------------------------------------------------------
# END OF SECTION SIFONS
#
#
#---------------------------------------------------------------------
if input_stuwen != '#':
#-------------------------------------------------------------------------------------------------------------------------------
# SECTION STUWEN
#
#
#---------------------------------------------------------------------
# check of alle benodigde bestanden zijn ingevuld:
benodigdebestanden = [input_waterlopen_legger, peilgebieden_fc, output_stuwen]
for index, fc in enumerate(benodigdebestanden):
if fc =='#':
log.error('Bestand %s is noodzakelijk om duikers te controleren' %benodigdebestanden[index])
# Initieer dictionary
stuwen = {}
#---------------------------------------------------------------------
# Join van duikers met watergangen
log.info('Koppel kunstwerken met watergangen')
stuwen_incl_watergangen = turtlebase.arcgis.get_random_file_name(workspace_gdb, "")
gp.Spatialjoin_analysis(input_stuwen, input_waterlopen_legger,stuwen_incl_watergangen,'JOIN_ONE_TO_ONE', 'KEEP_ALL', '#', 'CLOSEST')
# Wegschrijven data naar dictionary
log.info('Schrijf informatie weg naar kunstwerken')
stuwen = add_fc_values_to_dict(gp, stuwen_incl_watergangen, stuwen, kstident, list_fieldnames_watergangen)
#---------------------------------------------------------------------
# Join van duikers met peilgebieden
log.info('Koppel kunstwerken met peilgebieden')
stuwen_incl_peilgebieden = turtlebase.arcgis.get_random_file_name(workspace_gdb, "")
gp.Spatialjoin_analysis(input_stuwen, peilgebieden_fc, stuwen_incl_peilgebieden)
stuwen = add_fc_values_to_dict(gp, stuwen_incl_peilgebieden, stuwen, kstident, list_fieldnames_peilgebieden)
# Inlezen data uit de duikers
stuwen = add_fc_values_to_dict(gp, stuwen_incl_peilgebieden, stuwen, kstident, list_fieldnames_stuwen)
#---------------------------------------------------------------------
# Berekeningen
log.info('Start calculation')
# Inlezen outputveldnamen
output_field_stuw_percentage_bodem = config.get("controle_kunstwerken", "output_field_stuw_percentage_bodem").lower()
output_field_stuw_tov_winterpeil = config.get("controle_kunstwerken", "output_field_stuw_tov_winterpeil").lower()
output_field_stuw_tov_zomerpeil = config.get("controle_kunstwerken", "output_field_stuw_tov_zomerpeil").lower()
stuwen = calculate_stuwen(stuwen, config, nodatavalue,\
bodemhoogte_benedenstrooms, bodemhoogte_bovenstrooms,\
stuw_hoogte, zomerpeil, winterpeil,\
output_field_stuw_percentage_bodem, output_field_stuw_tov_winterpeil,\
output_field_stuw_tov_zomerpeil)
#log.info('dict_fields %s' %dict_fields)
log.info('Creeer output file stuwen')
# create rough copy
stuwen_temp = turtlebase.arcgis.get_random_file_name(workspace_gdb, "")
gp.Select_analysis(input_stuwen, stuwen_temp)
# Creeer output fields with types
dict_fields = create_dict_fields(stuwen)
log.info('Vul output file met berekende waarden')
log.info('stuwen_temp %s' %stuwen_temp)
# Vul de dataset met de waarden uit de dictionary
addfieldnames(gp, stuwen_temp, dict_fields)
add_dict_values_to_fc(gp, stuwen_temp, kstident, stuwen, nodatavalue)
# Create output file
log.info('Opschonen output file')
# Als Append gebruikt wordt, kan er gebruik worden gemaakt van fieldmapping
if output_stuwen == '#':
log.error('Geen output feature class ingevuld. Kan waarden niet wegschrijven')
sys.exit(1)
create_output_dataset(gp, output_stuwen, dict_fields, 'POINT')
gp.Append_management(stuwen_temp,output_stuwen, 'NO_TEST')
log.info('Stuwen finished')
# Delete temporary workspace geodatabase & ascii files
try:
log.debug("delete temporary workspace: %s" % workspace_gdb)
#gp.delete(workspace_gdb)
log.info("workspace deleted")
except:
log.warning("failed to delete %s" % workspace_gdb)
mainutils.log_footer()
except:
log.error(traceback.format_exc())
sys.exit(1)
finally:
logging_config.cleanup()
del gp
def main():
try:
gp = mainutils.create_geoprocessor()
config = mainutils.read_config(__file__, 'turtle-settings.ini')
logfile = mainutils.log_filename(config)
logging_config = LoggingConfig(gp, logfile=logfile)
mainutils.log_header(__name__)
#----------------------------------------------------------------------------------------
# Create workspace
workspace = config.get('GENERAL', 'location_temp')
if workspace == "-":
workspace = tempfile.gettempdir()
turtlebase.arcgis.delete_old_workspace_gdb(gp, workspace)
if not os.path.isdir(workspace):
os.makedirs(workspace)
workspace_gdb, errorcode = turtlebase.arcgis.create_temp_geodatabase(gp, workspace)
if errorcode == 1:
log.error("failed to create a file geodatabase in %s" % workspace)
#----------------------------------------------------------------------------------------
# Input parameters
if len(sys.argv) == 5:
# input parameter
input_external_weir = sys.argv[1]
input_voronoi_polygon = sys.argv[2]
input_rrcf_waterlevel = sys.argv[3]
# output parameters
output_table_external_weir = sys.argv[4]
else:
log.error("usage: <input_external_weir> <input_voronoi_polygon> <input rrcf waterlevel> <output_table_external_weir>")
sys.exit(1)
temp_voronoi = turtlebase.arcgis.get_random_file_name(workspace_gdb)
gp.select_analysis(input_voronoi_polygon, temp_voronoi)
#----------------------------------------------------------------------------------------
# Check geometry input parameters
log.info("Check geometry of input parameters")
geometry_check_list = []
log.debug(" - check input_external_weir: %s" % input_external_weir)
if gp.describe(input_external_weir).ShapeType != 'Point':
log.error("Input_external_weir is not a point feature class!")
geometry_check_list.append(input_external_weir + " -> (Point)")
log.debug(" - check voronoi polygon: %s" % temp_voronoi)
if gp.describe(temp_voronoi).ShapeType != 'Polygon':
log.error("Input voronoi is not a polygon feature class!")
geometry_check_list.append(temp_voronoi + " -> (Polygon)")
if len(geometry_check_list) > 0:
log.error("check input: %s" % geometry_check_list)
sys.exit(2)
#----------------------------------------------------------------------------------------
# Check required fields in database
log.info("Check required fields in input data")
missing_fields = []
if not turtlebase.arcgis.is_fieldname(gp, temp_voronoi, config.get('toetsing_overstorten', 'calculation_point_ident')):
log.debug(" - missing: %s in %s" % (config.get('toetsing_overstorten', 'calculation_point_ident'), temp_voronoi))
missing_fields.append("%s: %s" % (temp_voronoi, config.get('toetsing_overstorten', 'calculation_point_ident')))
if not turtlebase.arcgis.is_fieldname(gp, input_rrcf_waterlevel, config.get('toetsing_overstorten', 'field_waterstand')):
log.debug(" - missing: %s in %s" % (config.get('toetsing_overstorten', 'field_waterstand'), input_rrcf_waterlevel))
missing_fields.append("%s: %s" % (input_rrcf_waterlevel, config.get('toetsing_overstorten', 'field_waterstand')))
if not turtlebase.arcgis.is_fieldname(gp, input_external_weir, config.get('toetsing_overstorten', 'overstort_ident')):
log.debug(" - missing: %s in %s" % (config.get('toetsing_overstorten', 'overstort_ident'), input_external_weir))
missing_fields.append("%s: %s" % (input_external_weir, config.get('toetsing_overstorten', 'overstort_ident')))
if not turtlebase.arcgis.is_fieldname(gp, input_external_weir, config.get('toetsing_overstorten', 'drempelhoogte')):
log.debug(" - missing: %s in %s" % (config.get('toetsing_overstorten', 'drempelhoogte'), input_external_weir))
missing_fields.append("%s: %s" % (input_external_weir, config.get('toetsing_overstorten', 'drempelhoogte')))
if len(missing_fields) > 0:
log.error("missing fields in input data: %s" % missing_fields)
sys.exit(2)
#----------------------------------------------------------------------------------------
# read waterlevel table as a dictionary
log.info("Read waterlevel table")
waterlevel_dict = nens.gp.get_table(gp, input_rrcf_waterlevel, primary_key=config.get('toetsing_overstorten', 'calculation_point_ident').lower())
log.debug(waterlevel_dict)
# Add fields to output
if not turtlebase.arcgis.is_fieldname(gp, temp_voronoi, config.get('toetsing_overstorten', 'field_waterstand')):
log.info(" - add field %s" % config.get('toetsing_overstorten', 'field_waterstand'))
gp.addfield(temp_voronoi, "%s" % config.get('toetsing_overstorten', 'field_waterstand'), "double")
# copy waterlevel to voronoi polygons
field_config_waterstand = config.get('toetsing_overstorten', 'field_waterstand').lower()
field_calculation_point_ident = config.get('toetsing_overstorten', 'calculation_point_ident')
rows = gp.UpdateCursor(temp_voronoi)
for row in nens.gp.gp_iterator(rows):
row_id = row.GetValue(field_calculation_point_ident)
if waterlevel_dict.has_key(row_id):
log.debug(waterlevel_dict[row_id])
row.SetValue(field_config_waterstand, waterlevel_dict[row_id][field_config_waterstand])
rows.UpdateRow(row)
#----------------------------------------------------------------------------------------
# Join external weirs to voronoi using spatial location (spatial join)
log.info("join waterlevel to external weirs using a spatial location")
temp_spatial_join = turtlebase.arcgis.get_random_file_name(workspace_gdb)
#gp.SpatialJoin_analysis(input_external_weir, temp_voronoi, temp_spatial_join, "JOIN_ONE_TO_ONE", "#", "#", "INTERSECTS")
gp.Intersect_Analysis(input_external_weir + ';' + temp_voronoi, temp_spatial_join)
external_weir_dict = nens.gp.get_table(gp, temp_spatial_join, primary_key=config.get('toetsing_overstorten', 'overstort_ident').lower())
result_dict = {}
for k, v in external_weir_dict.items():
waterlevel = v[config.get('toetsing_overstorten', 'field_waterstand').lower()]
weir_height = v[config.get('toetsing_overstorten', 'drempelhoogte').lower()]
if waterlevel is None or weir_height is None:
waterlevel = -999
weir_height = -999
result_value = 9
else:
if float(waterlevel) > float(weir_height):
result_value = 1
else:
result_value = 0
result_dict[k] = {config.get('toetsing_overstorten', 'overstort_ident'): k,
config.get('toetsing_overstorten', 'field_waterstand'): waterlevel,
config.get('toetsing_overstorten', 'drempelhoogte'): weir_height,
config.get('toetsing_overstorten', 'field_toetsing_overlast_stedelijk'): result_value}
#----------------------------------------------------------------------------------------
# Create output table
if not gp.exists(output_table_external_weir):
log.info("Create new output table")
temp_result_table = turtlebase.arcgis.get_random_file_name(workspace_gdb)
gp.CreateTable_management(os.path.dirname(temp_result_table), os.path.basename(temp_result_table))
copy_table = True
else:
temp_result_table = output_table_external_weir
copy_table = False
fields_to_add = [config.get('toetsing_overstorten', 'field_waterstand'),
config.get('toetsing_overstorten', 'drempelhoogte'),
config.get('toetsing_overstorten', 'field_toetsing_overlast_stedelijk')]
if not turtlebase.arcgis.is_fieldname(gp, temp_result_table, config.get('toetsing_overstorten', 'overstort_ident')):
log.debug(" - add field %s to %s" % (config.get('toetsing_overstorten', 'overstort_ident'), temp_result_table))
gp.addfield_management(temp_result_table, config.get('toetsing_overstorten', 'overstort_ident'), 'text')
for field in fields_to_add:
if not turtlebase.arcgis.is_fieldname(gp, temp_result_table, field):
log.debug(" - add field %s to %s" % (field, temp_result_table))
gp.addfield_management(temp_result_table, field, 'double')
#----------------------------------------------------------------------------------------
# Write results to output table
log.info("Write results to output table")
turtlebase.arcgis.write_result_to_output(temp_result_table, config.get('toetsing_overstorten', 'overstort_ident').lower(), result_dict)
if copy_table == True:
gp.TableToTable_conversion(temp_result_table, os.path.dirname(output_table_external_weir), os.path.basename(output_table_external_weir))
#----------------------------------------------------------------------------------------
# Delete temporary workspace geodatabase
try:
log.debug("delete temporary workspace: %s" % workspace_gdb)
gp.delete(workspace_gdb)
log.info("workspace deleted")
except:
log.debug("failed to delete %s" % workspace_gdb)
mainutils.log_footer()
except:
log.error(traceback.format_exc())
sys.exit(1)
finally:
logging_config.cleanup()
del gp
def main():
try:
gp = mainutils.create_geoprocessor()
config = mainutils.read_config(__file__, 'turtle-settings.ini')
logfile = mainutils.log_filename(config)
logging_config = LoggingConfig(gp, logfile=logfile)
mainutils.log_header(__name__)
#read conversion settings
modeltype = "RR+RR_CF"
#---------------------------------------------------------------------
#check inputfields
log.info("Getting commandline parameters")
if len(sys.argv) == 8:
peilgebieden_feature = sys.argv[1]
rr_dataset = sys.argv[2]
afvoerkunstwerken = sys.argv[4]
koppelpunten = sys.argv[5]
settings = sys.argv[6]
output_dir = sys.argv[7]
else:
log.error("Usage: python rural_rr_rrcf_conversie.py \
<peilgebieden_feature> <rr_dataset> <rr_afvoer> \
<afvoerkunstwerken> <koppelpunten> <settings>")
sys.exit(1)
rr_dataset = rr_dataset.replace("\\", "/")
rr_dataset = rr_dataset.replace("'", "")
sys.argv[2] = rr_dataset
log.info("output_dir: " + output_dir)
#add extra logfile
fileHandler2 = logging.FileHandler(output_dir + '\\rr_rrcf_convert.log')
logging.getLogger("nens.turtle").addHandler(fileHandler2)
#---------------------------------------------------------------------
#check input parameters
log.info('Checking presence of input files')
if not(gp.exists(peilgebieden_feature)):
log.error("input_toetspunten " + peilgebieden_feature + " does not exist!")
sys.exit(5)
#----------------------------------------------------------------------------------------
#default settings
if settings == "#":
location_script = os.path.dirname(sys.argv[0])
settings = os.path.join(location_script, config.get('RR', 'rr_rrcf_default_settings'))
rr_config = mainutils.read_config(settings, os.path.basename(settings))
if not rr_config.get("column.peilgebied", 'paved_runoff_coefficient'):
log.warning("paved_runoff_coefficient not available in rr+rrcf-settings, default will be used")
rr_config.set("column.peilgebied", 'paved_runoff_coefficient', "-")
rr_config.set("default.peilgebied", 'paved_runoff_coefficient', '0.2')
#----------------------------------------------------------------------------------------
# Create workspace
workspace = config.get('GENERAL', 'location_temp')
configfilename = os.path.join(workspace, "rr_rrcf_settings_temp.ini")
configfile = open(configfilename, "wb")
rr_config.write(configfile)
configfile.close()
settings = configfilename
#----------------------------------------------------------------------------------------
#checking if feature class contains polygons
log.info("Checking if feature contains polygons")
pg_obj = gp.describe(peilgebieden_feature)
if pg_obj.ShapeType != "Polygon":
log.error(peilgebieden_feature + " does not contain polygons, please add a feature class with polygons")
log.error(" - gp message: " + gp.GetMessages(2))
sys.exit(5)
# If rr_afvoer is empty, ignore this table, because trrrlib will crash
if sys.argv[3] != '#':
if turtlebase.arcgis.fc_is_empty(gp, sys.argv[3]):
log.warning("rr_afvoer is empty, this table will be ignored")
sys.argv[3] = '#'
# add xy coordinates
xcoord = 'XCOORD'
ycoord = 'YCOORD'
if not turtlebase.arcgis.is_fieldname(gp, peilgebieden_feature, xcoord):
gp.addfield(peilgebieden_feature, xcoord, "Double")
if not turtlebase.arcgis.is_fieldname(gp, peilgebieden_feature, ycoord):
gp.addfield(peilgebieden_feature, ycoord, "Double")
add_xy_coords(gp, peilgebieden_feature, xcoord, ycoord)
#checking if feature class contains points
if afvoerkunstwerken != "#":
log.info("Checking if feature contains points")
ak_obj = gp.describe(afvoerkunstwerken)
log.debug("ShapeType afvoerkunstwerken = " + ak_obj.ShapeType)
if ak_obj.ShapeType != "Point":
log.error(afvoerkunstwerken + " does not contain points, please add a feature class with points")
log.error(" - gp message: " + gp.GetMessages(2))
sys.exit(5)
#check op punten
if koppelpunten != "#":
log.info("Checking if feature contains points")
kp_obj = gp.describe(koppelpunten)
log.debug("ShapeType koppelpunten = " + kp_obj.ShapeType)
if kp_obj.ShapeType != "Point":
log.error(koppelpunten + " does not contain points, please add a feature class with points")
log.debug(gp.GetMessages(2))
sys.exit()
#copy settings to output directory
shutil.copyfile(settings, output_dir + '\\RR_RRCF_Settings.ini')
drainage = config.get('RR', 'drainage')
log.info("drainage type is " + drainage)
#export rrcf connection to output folder. Convert feature class to shape
output_shapefiles = output_dir + '\\shapefiles'
if not os.path.isdir(output_shapefiles):
os.makedirs(output_shapefiles)
log.debug("export rrcf connection nodes to" + output_shapefiles)
gp.Select_analysis(koppelpunten, output_shapefiles + "\\rrcf_connection.shp")
log.debug("features exported")
output_sobek = output_dir + "\\sobek_input"
if not os.path.isdir(output_sobek):
os.makedirs(output_sobek)
log.debug("from trrrlib import trrrlib")
trrrlib.main({}, sys.argv[1:6] + [settings] + [output_sobek] + [drainage] + [modeltype])
if os.path.isfile(output_sobek + "/struct.def"):
os.remove(output_sobek + "/struct.def")
if os.path.isfile(output_sobek + "/profile.dat"):
os.remove(output_sobek + "/profile.dat")
log.info("*********************************************************")
log.info(modeltype + " Conversie compleet")
log.info("*********************************************************")
mainutils.log_footer()
except:
log.error(traceback.format_exc())
sys.exit(1)
finally:
logging_config.cleanup()
del gp
def main():
try:
gp = mainutils.create_geoprocessor()
config = mainutils.read_config(__file__, 'turtle-settings.ini')
logfile = mainutils.log_filename(config)
logging_config = LoggingConfig(gp, logfile=logfile)
mainutils.log_header(__name__)
#---------------------------------------------------------------------
# Input parameters
if len(sys.argv) == 5:
hydrobase = sys.argv[1]
input_kwelkaart = sys.argv[2]
input_bodemkaart = sys.argv[3]
output_waterbalance = sys.argv[4]
else:
log.error("usage: <hydrobase> <input_kwelkaart> <input_bodemkaart> <output_waterbalance>")
sys.exit(1)
peilgebieden_fc = os.path.join(hydrobase, 'RR_Features',
config.get('waterbalans',
'peilgebieden_fc'))
if not gp.exists(peilgebieden_fc):
log.error("Features '%s' is not available in the hydrobase" % config.get('waterbalans', 'peilgebieden_fc'))
sys.exit(1)
rr_peilgebied = os.path.join(hydrobase,
config.get('waterbalans',
'rr_peilgebied'))
if not gp.exists(rr_peilgebied):
log.error("Table '%s' is not available in the hydrobase" % config.get('waterbalans', 'rr_peilgebied'))
sys.exit(1)
rr_oppervlak = os.path.join(hydrobase,
config.get('waterbalans',
'rr_oppervlak'))
if not gp.exists(rr_oppervlak):
log.error("Table '%s' is not available in the hydrobase" % config.get('waterbalans', 'rr_oppervlak'))
sys.exit(1)
if input_kwelkaart == '#':
rr_kwelwegzijging = os.path.join(hydrobase,
config.get('waterbalans',
'rr_kwelwegzijging'))
if not gp.exists(rr_kwelwegzijging):
log.error("No seepage data available")
sys.exit(1)
else:
rr_kwelwegzijging = '#'
if input_bodemkaart == '#':
rr_grondsoort = os.path.join(hydrobase,
config.get('waterbalans',
'rr_grondsoort'))
if not gp.exists(rr_grondsoort):
log.error("No soil data available")
sys.exit(1)
else:
rr_grondsoort = '#'
#---------------------------------------------------------------------
# Check required fields in input data
log.info("Check required fields in input data")
missing_fields = []
#<check required fields from input data,
# append them to list if missing>
#check_fields = {}
gpgident = config.get("general", "gpgident").lower()
gafident = config.get("waterbalance", "gafident").lower()
gafnaam = config.get("waterbalance", "gafnaam").lower()
check_fields = {peilgebieden_fc: [gpgident, gafident, gafnaam],
rr_peilgebied: [gpgident, "zomerpeil", "winterpeil"]}
for input_fc, fieldnames in check_fields.items():
for fieldname in fieldnames:
if not turtlebase.arcgis.is_fieldname(
gp, input_fc, fieldname):
errormsg = "fieldname %s not available in %s" % (
fieldname, input_fc)
log.error(errormsg)
missing_fields.append(errormsg)
if len(missing_fields) > 0:
log.error("missing fields in input data: %s" % missing_fields)
sys.exit(2)
#---------------------------------------------------------------------
# Environments
log.info("Check numbers of fields in input data")
errorcode = 0
nr_gpg = turtlebase.arcgis.fc_records(gp, peilgebieden_fc)
if nr_gpg == 0:
log.error("%s fc is empty" % peilgebieden_fc)
errorcode += 1
nr_peilgebied = turtlebase.arcgis.fc_records(gp, rr_peilgebied)
if not nr_peilgebied == nr_gpg:
log.error("%s (%s records) does not contain the same amount of records as %s (%s)" % (rr_peilgebied, nr_peilgebied,
peilgebieden_fc, nr_gpg))
errorcode += 1
nr_oppervlak = turtlebase.arcgis.fc_records(gp, rr_oppervlak)
if not nr_oppervlak == nr_gpg:
log.error("%s (%s records) does not contain the same amount of records as %s (%s)" % (rr_oppervlak, nr_oppervlak,
peilgebieden_fc, nr_gpg))
errorcode += 1
if rr_grondsoort != '#':
nr_grondsoort = turtlebase.arcgis.fc_records(gp, rr_grondsoort)
if not nr_grondsoort == nr_gpg:
log.error("%s (%s records) does not contain the same amount of records as %s (%s)" % (rr_grondsoort, nr_grondsoort,
peilgebieden_fc, nr_gpg))
errorcode += 1
else:
nr_grondsoort = 0
if rr_kwelwegzijging != '#':
nr_kwelwegzijging = turtlebase.arcgis.fc_records(gp, rr_kwelwegzijging)
if not nr_kwelwegzijging == nr_gpg:
log.error("%s (%s records) does not contain the same amount of records as %s (%s)" % (rr_kwelwegzijging, nr_kwelwegzijging,
peilgebieden_fc, nr_gpg))
errorcode += 1
else:
nr_kwelwegzijging = 0
if errorcode > 0:
log.error("%s errors found, see above" % errorcode)
sys.exit(1)
log.info("Join tables")
log.info(" - read %s" % peilgebieden_fc)
peilgebieden = nens.gp.get_table(gp, peilgebieden_fc, primary_key=gpgident, no_shape=True)
log.info(" - join %s" % rr_peilgebied)
nens.gp.join_on_primary_key(gp, peilgebieden, rr_peilgebied, gpgident)
log.info(" - join %s" % rr_oppervlak)
nens.gp.join_on_primary_key(gp, peilgebieden, rr_oppervlak, gpgident)
if rr_grondsoort != '#':
log.info(" - join %s" % rr_grondsoort)
nens.gp.join_on_primary_key(gp, peilgebieden, rr_grondsoort, gpgident)
if rr_kwelwegzijging != '#':
log.info(" - join %s" % rr_kwelwegzijging)
nens.gp.join_on_primary_key(gp, peilgebieden, rr_kwelwegzijging, gpgident)
required_keys = ["verhard_ha", "onvsted_ha", "kassen_ha",
"openwat_ha", "gras_ha", "natuur_ha", "zomerpeil",
"winterpeil", "shape_area", "hectares"]
#---------------------------------------------------------------------
# Calculate Kwel/Wegzijging
if input_kwelkaart == '#' == input_bodemkaart:
pass
else:
workspace = config.get('GENERAL', 'location_temp')
turtlebase.arcgis.delete_old_workspace_gdb(gp, workspace)
if not os.path.isdir(workspace):
os.makedirs(workspace)
workspace_gdb, errorcode = turtlebase.arcgis.create_temp_geodatabase(gp, workspace)
if errorcode == 1:
log.error("failed to create a file geodatabase in %s" % workspace)
if input_kwelkaart != '#':
# Check out Spatial Analyst extension license
gp.CheckOutExtension("Spatial")
kwel_table = os.path.join(workspace_gdb, 'kwel_zs_table')
#poldershape = os.path.join(workspace_gdb, 'polders')
#gp.Dissolve_management(peilgebieden_fc, poldershape, gafident)
gp.ZonalStatisticsAsTable_sa(peilgebieden_fc, gafident, input_kwelkaart, kwel_table, "DATA")
kwelwegzijging = nens.gp.get_table(gp, kwel_table, primary_key=gafident, no_shape=True)
#log.info(kwelwegzijging)
if input_bodemkaart != '#':
temp_bodemsoort = os.path.join(workspace_gdb, "temp_bodem")
gp.select_analysis(input_bodemkaart, temp_bodemsoort)
temp_peilgebied = os.path.join(workspace_gdb, "temp_peilgebied")
gp.select_analysis(peilgebieden_fc, temp_peilgebied)
intersect_bodem = os.path.join(workspace_gdb, "intersect_bodem")
gp.Intersect_analysis("%s;%s" % (temp_peilgebied, temp_bodemsoort), intersect_bodem)
bodemsoorten_polders = sort_bodemsoorten(gp, intersect_bodem, gafident)
"""
WAARDES INVULLEN VAN KWEL EN BODEM IN DICT!
"""
#---------------------------------------------------------------------
# Waterbalance
polders = {}
log.info("Extract data for waterbalance")
for k, v in peilgebieden.items():
for required_key in required_keys:
if required_key not in v.keys():
log.error("Cannot find %s for gpgident: %s" % (required_key, k))
sys.exit(1)
if 'grondsoort' not in v:
grondsoort = 0
else:
grondsoort = v['grondsoort']
if 'kwelstroom' not in v:
kwelstroom = 0
else:
kwelstroom = v['kwelstroom']
if v[gafident] in polders:
polders[v[gafident]]["peilgebieden"].append((k, v["shape_area"], v["verhard_ha"], v["onvsted_ha"], v["kassen_ha"],
v["openwat_ha"], v["gras_ha"], v["natuur_ha"], v['hectares'], grondsoort, kwelstroom))
else:
polders[v[gafident]] = {"peilgebieden": [(k, v["shape_area"], v["verhard_ha"], v["onvsted_ha"], v["kassen_ha"],
v["openwat_ha"], v["gras_ha"], v["natuur_ha"], v['hectares'], grondsoort, kwelstroom)]}
waterbalance = {}
log.info("Calculate data for waterbalance")
for polder, attributes in polders.items():
main_gpg, sum_area = max_gpg(attributes['peilgebieden'])
kwelstroom, verhard_ha, onvsted_ha, kassen_ha, openwat_ha, gras_ha, natuur_ha = calculate_averages(attributes['peilgebieden'], sum_area)
if input_bodemkaart == '#':
bod1, bod2, bod3 = calculate_soiltypes(attributes['peilgebieden'])
else:
bod1 = "Bodem 1"
bod2 = "Bodem 2"
bod3 = "Bodem 3"
if input_kwelkaart != '#':
if polder in kwelwegzijging:
kwelstroom = kwelwegzijging[polder]['mean']
else:
kwelstroom = 0
log.warning("%s has no seepage data" % polder)
if kwelstroom > 0:
kwel = kwelstroom
wegz = 0
else:
wegz = -1 * kwelstroom
kwel = 0
winterp = peilgebieden[main_gpg]['winterpeil']
zomerp = peilgebieden[main_gpg]['zomerpeil']
sum_ha = sum_area / 10000
waterbalance[polder] = [("Code", polder, "TEXT"), ("Naam", polder, "TEXT"),
("Main_GPG", main_gpg, "TEXT"), ("Bodemh", -999, "DOUBLE"),
("Kwel", kwel, "DOUBLE"), ("Wegz", wegz, "DOUBLE"),
("Winterpeil", winterp, "DOUBLE"), ("Zomerpeil", zomerp, "DOUBLE"),
("Totaal_ha", sum_ha, "DOUBLE"), ("Verhard_ha", verhard_ha, "DOUBLE"),
("Onvsted_ha", onvsted_ha, "DOUBLE"), ("Kassen_ha", kassen_ha, "DOUBLE"),
("Openwat_ha", openwat_ha, "DOUBLE"), ("Gras_ha", gras_ha, "DOUBLE"),
("Natuur_ha", natuur_ha, "DOUBLE"), ("Bodem1", bod1, "TEXT"),
("Bodem2", bod2, "TEXT"), ("Bodem3", bod3, "TEXT")]
log.info("Write output table")
gp.CreateTable(os.path.dirname(output_waterbalance), os.path.basename(output_waterbalance))
for key, values in waterbalance.items():
for attribute in values:
log.info(" - add field %s" % attribute[0])
gp.AddField(output_waterbalance, attribute[0], attribute[2])
break
log.info("Inserting new records")
update_count = 0
nsertCursor = gp.InsertCursor(output_waterbalance)
for key, values in waterbalance.items():
newRow = nsertCursor.NewRow()
for attribute in values:
newRow.SetValue(attribute[0], attribute[1])
nsertCursor.InsertRow(newRow)
update_count += 1
log.info(" - %s records have been inserted" % update_count)
log.info("Finished")
mainutils.log_footer()
except:
log.error(traceback.format_exc())
sys.exit(1)
finally:
logging_config.cleanup()
del gp
def main():
try:
gp = mainutils.create_geoprocessor()
config = mainutils.read_config(__file__, 'turtle-settings.ini')
logfile = mainutils.log_filename(config)
logging_config = LoggingConfig(gp, logfile=logfile)
mainutils.log_header(__name__)
#---------------------------------------------------------------------
# Create workspace
workspace = config.get('GENERAL', 'location_temp')
if workspace == "-":
workspace = tempfile.gettempdir()
turtlebase.arcgis.delete_old_workspace_gdb(gp, workspace)
if not os.path.isdir(workspace):
os.makedirs(workspace)
workspace_gdb, errorcode = turtlebase.arcgis.create_temp_geodatabase(
gp, workspace)
if errorcode == 1:
log.error("failed to create a file geodatabase in %s" % workspace)
# Input parameters
if len(sys.argv) == 11:
# input parameters
input_voronoi_polygon = sys.argv[1]
input_rrcf_waterlevel = sys.argv[2]
input_ahn_raster = sys.argv[3]
input_lgn_raster = sys.argv[4]
input_lgn_conversion = sys.argv[5]
# output parameters
output_result_table = sys.argv[6]
# optional output
output_inundation = sys.argv[7]
if output_inundation == "#":
output_inundation = os.path.join(workspace_gdb, "inun_nbw")
if len(os.path.basename(output_inundation)) > 13:
log.error("filename raster output (%s) cannot contain more than 13 characters" % os.path.basename(output_inundation))
sys.exit(1)
output_waterdamage = sys.argv[8]
if output_waterdamage == "#":
output_waterdamage = os.path.join(workspace_gdb, "damage_nbw")
if len(os.path.basename(output_waterdamage)) > 13:
log.error("filename raster output (%s) cannot contain more than 13 characters" % os.path.basename(output_waterdamage))
sys.exit(1)
output_inundation_total = sys.argv[9]
if len(os.path.basename(output_inundation_total)) > 13:
log.error("filename raster output (%s) cannot contain more than 13 characters" % os.path.basename(output_inundation_total))
sys.exit(1)
output_waterdamage_total = sys.argv[10]
if len(os.path.basename(output_waterdamage_total)) > 13:
log.error("filename raster output (%s) cannot contain more than 13 characters" % os.path.basename(output_waterdamage_total))
sys.exit(1)
else:
log.error("usage: <input_voronoi_polygon> <input_rrcf_waterlevel> <input_ahn_raster> \
<input_lgn_raster> <input_lgn_conversion> <output_result_table> \
<output_inundation> <output_waterdamage> <output inundation total> <output waterdamage total>")
sys.exit(1)
#----------------------------------------------------------------------------------------
temp_voronoi = os.path.join(workspace_gdb, "voronoi")
gp.select_analysis(input_voronoi_polygon, temp_voronoi)
# Check geometry input parameters
cellsize = gp.describe(input_ahn_raster).MeanCellHeight
log.info("Check geometry of input parameters")
geometry_check_list = []
if input_lgn_conversion != "#":
if not gp.exists(input_lgn_conversion):
errormsg = "%s does not exist" % input_lgn_conversion
log.error(errormsg)
geometry_check_list.append(errormsg)
log.debug(" - check voronoi polygon: %s" % temp_voronoi)
if gp.describe(temp_voronoi).ShapeType != 'Polygon':
log.error("Input voronoi is not a polygon feature class!")
geometry_check_list.append(temp_voronoi + " -> (Polygon)")
log.debug(" - check ahn raster %s" % input_ahn_raster)
if gp.describe(input_ahn_raster).DataType != 'RasterDataset':
log.error("Input AHN is not a raster dataset")
sys.exit(1)
if gp.describe(input_ahn_raster).PixelType[0] not in ['U', 'S']:
log.error("Input AHN is a floating point raster, for this script an integer is nessecary")
geometry_check_list.append(input_ahn_raster + " -> (Integer)")
log.debug(" - check lgn raster %s" % input_lgn_raster)
if gp.describe(input_lgn_raster).DataType != 'RasterDataset':
log.error("Input LGN is not a raster dataset")
sys.exit(1)
if gp.describe(input_lgn_raster).PixelType[0] not in ['U', 'S']:
log.error("Input LGN is a floating point raster, for this script an integer is nessecary")
geometry_check_list.append(input_lgn_raster + " -> (Integer)")
if gp.describe(input_lgn_raster).MeanCellHeight != float(cellsize):
log.error("Cell size of LGN is %s, must be %s" % (
gp.describe(input_lgn_raster).MeanCellHeight, cellsize))
geometry_check_list.append(input_lgn_raster + " -> (Cellsize %s)" % cellsize)
if len(geometry_check_list) > 0:
log.error("check input: %s" % geometry_check_list)
sys.exit(2)
#----------------------------------------------------------------------------------------
# Check required fields in database
log.info("Check required fields in input data")
# create return period list
return_periods = config.get('naverwerking_rrcf', 'herhalingstijden').split(", ")
log.debug(" - return periods: %s" % return_periods)
missing_fields = []
for return_period in return_periods:
if not turtlebase.arcgis.is_fieldname(gp, input_rrcf_waterlevel, "WS_%s" % return_period):
log.debug(" - missing: %s in %s" % ("WS_%s" % return_period, input_rrcf_waterlevel))
missing_fields.append("%s: %s" % (input_rrcf_waterlevel, "WS_%s" % return_period))
#<check required fields from input data, append them to list if missing>"
field_streefpeil = config.get('naverwerking_rrcf', 'field_streefpeil')
check_fields = {input_rrcf_waterlevel: [config.get('naverwerking_rrcf', 'calculation_point_ident'), field_streefpeil]}
if input_lgn_conversion != "#":
check_fields[input_lgn_conversion] = [config.get('naverwerking_rrcf', 'lgn_conv_ident'),
config.get('naverwerking_rrcf', 'input_field_k5')]
for input_fc, fieldnames in check_fields.items():
for fieldname in fieldnames:
if not turtlebase.arcgis.is_fieldname(gp, input_fc, fieldname):
errormsg = "fieldname %s not available in %s" % (fieldname, input_fc)
log.error(errormsg)
missing_fields.append(errormsg)
if len(missing_fields) > 0:
log.error("missing fields in input data: %s" % missing_fields)
sys.exit(2)
#---------------------------------------------------------------------
# Environments
log.info("Set environments")
gp.extent = gp.describe(temp_voronoi).extent # use extent from LGN
#---------------------------------------------------------------------
# read waterlevel table as a dictionary
log.info("Read waterlevel table")
waterlevel_dict = nens.gp.get_table(gp, input_rrcf_waterlevel, primary_key=config.get('naverwerking_rrcf', 'calculation_point_ident').lower())
log.debug(waterlevel_dict)
# Add fields to output
for return_period in return_periods:
if not turtlebase.arcgis.is_fieldname(gp, temp_voronoi, "WS_%s" % return_period):
log.info(" - add field WS_%s" % return_period)
gp.addfield(temp_voronoi, "WS_%s" % return_period, "double")
if not turtlebase.arcgis.is_fieldname(gp, temp_voronoi, field_streefpeil):
log.info(" - add field %s" % field_streefpeil)
gp.addfield(temp_voronoi, field_streefpeil, "double")
# copy waterlevel to voronoi polygons
rows = gp.UpdateCursor(temp_voronoi)
for row in nens.gp.gp_iterator(rows):
row_id = row.GetValue(config.get('naverwerking_rrcf', 'calculation_point_ident'))
if row_id in waterlevel_dict:
log.debug(waterlevel_dict[row_id])
for return_period in return_periods:
row.SetValue("WS_%s" % return_period, waterlevel_dict[row_id]['ws_%s' % return_period])
row.SetValue(field_streefpeil,
waterlevel_dict[row_id][field_streefpeil.lower()])
rows.UpdateRow(row)
#---------------------------------------------------------------------
# Create waterlevel rasters
log.info("Create rasters for waterlevels")
for return_period in return_periods:
log.info(" - create raster for ws_%s" % return_period)
out_raster_dataset = workspace_gdb + "/ws_%s" % return_period
gp.FeatureToRaster_conversion(temp_voronoi, "WS_%s" % return_period, out_raster_dataset, cellsize)
#---------------------------------------------------------------------
# Create target level raster
log.info("Create targetlevel raster")
out_raster_targetlevel = os.path.join(workspace_gdb, "targetlv")
gp.FeatureToRaster_conversion(temp_voronoi, field_streefpeil, out_raster_targetlevel, cellsize)
#---------------------------------------------------------------------
# Create freeboard raster
log.info("Create freeboard raster")
# create ahn ascii
ahn_ascii = os.path.join(workspace, "ahn.asc")
log.debug("ahn ascii: %s" % ahn_ascii)
gp.RasterToASCII_conversion(input_ahn_raster, ahn_ascii)
targetlevel_ascii = os.path.join(workspace, "targetlvl.asc")
log.debug("targetlevel ascii: %s" % targetlevel_ascii)
gp.RasterToASCII_conversion(out_raster_targetlevel, targetlevel_ascii)
freeboard_ascii = os.path.join(workspace, "freeboard.asc")
turtlebase.spatial.create_freeboard_raster(ahn_ascii, targetlevel_ascii, freeboard_ascii)
#----------------------------------------------------------------------------------------
# Create K5 LGN
log.info("Reclass LGN to K5 raster")
lgn_ascii = os.path.join(workspace, "lgn.asc")
lgn_k5_ascii = os.path.join(workspace, "lgn_k5.asc")
gp.RasterToASCII_conversion(input_lgn_raster, lgn_ascii)
if input_lgn_conversion != '#':
reclass_dict = nens.gp.get_table(gp, input_lgn_conversion,
primary_key=config.get('naverwerking_rrcf', 'lgn_conv_ident').lower())
turtlebase.spatial.reclass_lgn_k5(lgn_ascii, lgn_k5_ascii, reclass_dict)
else:
turtlebase.spatial.reclass_lgn_k5(lgn_ascii, lgn_k5_ascii)
#----------------------------------------------------------------------------------------
# Create inundation raster
# als ws_ > ahn, dan inundatie
inundation_raster_list = []
inundation_total_raster_list = []
log.info("Create inundation rasters")
# inundatie stedelijk
return_period_urban = config.get('naverwerking_rrcf', 'herhalingstijd_inundatie_stedelijk')
if config.get('naverwerking_rrcf', 'percentage_inundatie_stedelijk') != "-":
log.info(" - create inundation urban")
waterlevel = "%s/ws_%s" % (workspace_gdb, return_period_urban)
if gp.exists(waterlevel):
inundation_urban = os.path.join(workspace, "inun_urban.asc")
turtlebase.spatial.create_inundation_raster(lgn_k5_ascii, ahn_ascii, waterlevel, 1,
return_period_urban, inundation_urban, workspace, use_lgn=True)
inundation_raster_list.append(inundation_urban)
if output_inundation_total != '#':
# Inundation without lgn
inundation_total_urban = os.path.join(workspace, "inun_total_urban.asc")
turtlebase.spatial.create_inundation_raster(lgn_k5_ascii, ahn_ascii, waterlevel,
1, return_period_urban, inundation_total_urban, workspace, use_lgn=False)
inundation_total_raster_list.append(inundation_total_urban)
else:
log.error("%s does not exists! check ini-file and tempfolder" % waterlevel)
# inundatie hoogwaardige landbouw
return_period_agriculture = config.get('naverwerking_rrcf', 'herhalingstijd_inundatie_hoogwaardig')
if config.get('naverwerking_rrcf', 'percentage_inundatie_hoogwaardig') != "-":
log.info(" - create inundation agriculture")
waterlevel = "%s/ws_%s" % (workspace_gdb, return_period_agriculture)
if gp.exists(waterlevel):
# Inundation with lgn
inundation_agriculture = os.path.join(workspace, "inun_agri.asc")
turtlebase.spatial.create_inundation_raster(lgn_k5_ascii, ahn_ascii, waterlevel,
2, return_period_agriculture, inundation_agriculture, workspace, use_lgn=True)
inundation_raster_list.append(inundation_agriculture)
if output_inundation_total != '#':
# Inundation without lgn
inundation_total_agriculture = os.path.join(workspace, "inun_total_agri.asc")
turtlebase.spatial.create_inundation_raster(lgn_k5_ascii, ahn_ascii, waterlevel,
2, return_period_agriculture, inundation_total_agriculture, workspace, use_lgn=False)
inundation_total_raster_list.append(inundation_total_agriculture)
else:
log.error("%s does not exists! check ini-file and tempfolder" % waterlevel)
# inundatie akkerbouw
return_period_rural = config.get('naverwerking_rrcf', 'herhalingstijd_inundatie_akker')
if config.get('naverwerking_rrcf', 'percentage_inundatie_akker') != "-":
log.info(" - create inundation rural")
waterlevel = "%s/ws_%s" % (workspace_gdb, return_period_rural)
if gp.exists(waterlevel):
inundation_rural = os.path.join(workspace, "inun_rural.asc")
turtlebase.spatial.create_inundation_raster(lgn_k5_ascii, ahn_ascii, waterlevel,
3, return_period_rural, inundation_rural, workspace, use_lgn=True)
inundation_raster_list.append(inundation_rural)
if output_inundation_total != '#':
# Inundation without lgn
inundation_total_rural = os.path.join(workspace, "inun_total_rural.asc")
turtlebase.spatial.create_inundation_raster(lgn_k5_ascii, ahn_ascii, waterlevel,
3, return_period_rural, inundation_total_rural, workspace, use_lgn=False)
inundation_total_raster_list.append(inundation_total_rural)
else:
log.error("%s does not exists! check ini-file and tempfolder" % waterlevel)
# inundatie grasland
return_period_grass = config.get('naverwerking_rrcf', 'herhalingstijd_inundatie_grasland')
if config.get('naverwerking_rrcf', 'percentage_inundatie_grasland') != "-":
log.info(" - create inundation grass")
waterlevel = "%s/ws_%s" % (workspace_gdb, return_period_grass)
if gp.exists(waterlevel):
log.debug("waterlevel grasland = %s" % waterlevel)
inundation_grass = os.path.join(workspace, "inun_grass.asc")
turtlebase.spatial.create_inundation_raster(lgn_k5_ascii, ahn_ascii, waterlevel,
4, return_period_grass, inundation_grass, workspace, use_lgn=True)
inundation_raster_list.append(inundation_grass)
if output_inundation_total != '#':
# Inundation without lgn
inundation_total_grass = os.path.join(workspace, "inun_total_grass.asc")
turtlebase.spatial.create_inundation_raster(lgn_k5_ascii, ahn_ascii, waterlevel,
4, return_period_grass, inundation_total_grass, workspace, use_lgn=False)
inundation_total_raster_list.append(inundation_total_grass)
else:
log.error("%s does not exists! check ini-file and tempfolder" % waterlevel)
if len(inundation_raster_list) > 1:
log.info("Merge inundation rasters")
output_inundation_exists = turtlebase.spatial.merge_ascii(inundation_raster_list, output_inundation, workspace)
else:
log.error("there are no inundation rasters available")
if len(inundation_total_raster_list) > 1:
log.info("Merge inundation total rasters")
turtlebase.spatial.merge_ascii(inundation_total_raster_list, output_inundation_total, workspace)
#----------------------------------------------------------------------------------------
# Create waterdamage raster
# als ws_ > freeboard, dan overlast
damage_raster_list = []
damage_total_raster_list = []
log.info("Create waterdamage rasters")
# overlast stedelijk
return_period_urban_damage = config.get('naverwerking_rrcf', 'herhalingstijd_overlast_stedelijk')
if config.get('naverwerking_rrcf', 'percentage_overlast_stedelijk') != "-":
log.info(" - create waterdamage urban")
waterlevel = "%s/ws_%s" % (workspace_gdb, return_period_urban_damage)
if gp.exists(waterlevel):
damage_urban = os.path.join(workspace, "damage_urban.asc")
turtlebase.spatial.create_inundation_raster(lgn_k5_ascii, freeboard_ascii, waterlevel,
1, return_period_urban_damage, damage_urban, workspace, use_lgn=True)
damage_raster_list.append(damage_urban)
if output_waterdamage_total != '#':
# Waterdamage without lgn
damage_total_urban = os.path.join(workspace, "damage_total_urban.asc")
turtlebase.spatial.create_inundation_raster(lgn_k5_ascii, ahn_ascii, waterlevel,
1, return_period_urban_damage, damage_total_urban, workspace, use_lgn=False)
damage_total_raster_list.append(damage_total_urban)
else:
log.error("%s does not exists! check ini-file and tempfolder" % waterlevel)
# overlast hoogwaardig
return_period_agriculture_damage = config.get('naverwerking_rrcf', 'herhalingstijd_overlast_hoogwaardig')
if config.get('naverwerking_rrcf', 'percentage_overlast_hoogwaardig') != "-":
log.info(" - create waterdamage agriculture")
waterlevel = "%s/ws_%s" % (workspace_gdb, return_period_agriculture_damage)
if gp.exists(waterlevel):
damage_agriculture = workspace + "/damage_agri_%s.asc" % return_period_agriculture_damage
turtlebase.spatial.create_inundation_raster(lgn_k5_ascii, freeboard_ascii, waterlevel,
2, return_period_agriculture_damage, damage_agriculture, workspace, use_lgn=True)
damage_raster_list.append(damage_agriculture)
if output_waterdamage_total != '#':
# Waterdamage without lgn
damage_total_agriculture = os.path.join(workspace, "damage_total_agri.asc")
turtlebase.spatial.create_inundation_raster(lgn_k5_ascii, ahn_ascii, waterlevel,
1, return_period_agriculture_damage, damage_total_agriculture, workspace, use_lgn=False)
damage_total_raster_list.append(damage_total_agriculture)
else:
log.error("%s does not exists! check ini-file and tempfolder" % waterlevel)
# overlast akker
return_period_rural_damage = config.get('naverwerking_rrcf', 'herhalingstijd_overlast_akker')
if config.get('naverwerking_rrcf', 'percentage_overlast_akker') != "-":
log.info(" - create waterdamage rural")
waterlevel = "%s/ws_%s" % (workspace_gdb, return_period_rural_damage)
if gp.exists(waterlevel):
damage_rural = workspace + "/damage_rural_%s.asc" % return_period_rural_damage
turtlebase.spatial.create_inundation_raster(lgn_k5_ascii, freeboard_ascii, waterlevel,
3, return_period_rural_damage, damage_rural, workspace, use_lgn=True)
damage_raster_list.append(damage_rural)
if output_waterdamage_total != '#':
# Waterdamage without lgn
damage_total_rural = os.path.join(workspace_gdb, "damage_total_rural.asc")
turtlebase.spatial.create_inundation_raster(lgn_k5_ascii, ahn_ascii, waterlevel,
1, return_period_rural_damage, damage_total_rural, workspace, use_lgn=False)
damage_total_raster_list.append(damage_total_rural)
else:
log.error("%s does not exists! check ini-file and tempfolder" % waterlevel)
# overlast grasland
return_period_grass_damage = config.get('naverwerking_rrcf', 'herhalingstijd_overlast_grasland')
if config.get('naverwerking_rrcf', 'percentage_overlast_grasland') != "-":
log.info(" - create waterdamage grass")
waterlevel = "%s/ws_%s" % (workspace_gdb, return_period_grass_damage)
if gp.exists(waterlevel):
damage_grass = os.path.join(workspace_gdb, "damage_grass.asc")
turtlebase.spatial.create_inundation_raster(lgn_k5_ascii, freeboard_ascii, waterlevel,
4, return_period_grass_damage, damage_grass, workspace, use_lgn=True)
damage_raster_list.append(damage_grass)
if output_waterdamage_total != '#':
# Waterdamage without lgn
damage_total_grass = os.path.join(workspace_gdb, "damage_total_grass.asc")
turtlebase.spatial.create_inundation_raster(lgn_k5_ascii, ahn_ascii, waterlevel,
1, return_period_grass_damage, damage_total_grass, workspace, use_lgn=False)
damage_total_raster_list.append(damage_total_grass)
else:
log.error("%s does not exists! check ini-file and tempfolder" % waterlevel)
# Merge waterdamage rasters
if len(damage_raster_list) > 1:
log.info("Merge waterdamage rasters")
output_waterdamage_exists = turtlebase.spatial.merge_ascii(damage_raster_list, output_waterdamage, workspace)
else:
log.error("there are no waterdamage rasters available")
if len(damage_total_raster_list) > 1:
log.info("Merge waterdamage total rasters")
turtlebase.spatial.merge_ascii(damage_total_raster_list, output_waterdamage_total, workspace)
#----------------------------------------------------------------------------------------
# calculate percentage inundation
"""
input:
- inundatie / overlast (raster dataset)
- input_voronoi_polygon (met GPGIDENT) (feature class)
- lgn_k5 (raster dataset)
"""
gpgident_field = config.get('General', 'gpgident')
# dissolve voronoi based on gpgident
log.debug("dissolve voronoi polygons, based on gpgident")
temp_fc_gpgident = os.path.join(workspace_gdb, "temp_fc_gpgident")
gp.Dissolve_management(temp_voronoi, temp_fc_gpgident, gpgident_field)
# Calculate area total, gpgident
if not turtlebase.arcgis.is_fieldname(gp, temp_fc_gpgident, "area_total"):
gp.addfield(temp_fc_gpgident, "area_total", "Double")
turtlebase.arcgis.calculate_area(gp, temp_fc_gpgident, "area_total")
gpgident_dict = nens.gp.get_table(gp, temp_fc_gpgident, primary_key=gpgident_field.lower())
log.debug("gpgident_dict: %s" % gpgident_dict)
# create feature class from lgn k5 ascii
output_reclass_lgn = os.path.join(workspace_gdb, "reclass_lgn")
gp.ASCIIToRaster_conversion(lgn_k5_ascii, output_reclass_lgn)
temp_fc_lgn = os.path.join(workspace_gdb, "fc_lgn")
gp.RasterToPolygon_conversion(output_reclass_lgn, temp_fc_lgn, "NO_SIMPLIFY")
# union lgn with gpg-areas
temp_fc_union_lgn = os.path.join(workspace_gdb, "fc_union_lgn")
gp.Union_analysis(temp_fc_gpgident + ";" + temp_fc_lgn, temp_fc_union_lgn)
dissolve_lyr = turtlebase.arcgis.get_random_layer_name()
gp.MakeFeatureLayer_management(temp_fc_union_lgn, dissolve_lyr, "%s <> ''" % gpgident_field)
temp_fc_dissolve_lgn = os.path.join(workspace_gdb, "dissolve_lgn")
if turtlebase.arcgis.is_fieldname(gp, dissolve_lyr, "GRIDCODE"):
gp.Dissolve_management(dissolve_lyr, temp_fc_dissolve_lgn, "%s; GRIDCODE" % gpgident_field)
gridcode = "gridcode"
elif turtlebase.arcgis.is_fieldname(gp, dissolve_lyr, "grid_code"):
gp.Dissolve_management(dissolve_lyr, temp_fc_dissolve_lgn, "%s; grid_code" % gpgident_field)
gridcode = "grid_code"
else:
log.error("no field GRIDCODE or grid_code available in %s" % dissolve_lyr)
sys.exit(2)
# Calculate area lgn
if not turtlebase.arcgis.is_fieldname(gp, temp_fc_dissolve_lgn, "area_lgn"):
gp.addfield(temp_fc_dissolve_lgn, "area_lgn", "Double")
turtlebase.arcgis.calculate_area(gp, temp_fc_dissolve_lgn, "area_lgn")
lgn_dict = nens.gp.get_table(gp, temp_fc_dissolve_lgn)
translate_lgn_dict = translate_dict(lgn_dict, gridcode, 'area_lgn')
log.debug("translate_lgn_dict: %s" % translate_lgn_dict)
# Create feature class from inundation_grid
""" values: 10, 25, 50, 100"""
if output_inundation_exists == 0:
temp_fc_inundation = os.path.join(workspace_gdb, "inundation")
log.info(output_inundation)
gp.RasterToPolygon_conversion(output_inundation, temp_fc_inundation, "NO_SIMPLIFY")
temp_fc_union_inundation = os.path.join(workspace_gdb, "union_inun")
gp.Union_analysis(temp_fc_dissolve_lgn + ";" + temp_fc_inundation, temp_fc_union_inundation)
dissolve_inundation_lyr = turtlebase.arcgis.get_random_layer_name()
if turtlebase.arcgis.is_fieldname(gp, temp_fc_union_inundation, "GRIDCODE_1"):
gp.MakeFeatureLayer_management(temp_fc_union_inundation, dissolve_inundation_lyr, "GRIDCODE_1 > 0")
gridcode_1 = "gridcode_1"
elif turtlebase.arcgis.is_fieldname(gp, temp_fc_union_inundation, "GRID_CODE1"):
gp.MakeFeatureLayer_management(temp_fc_union_inundation, dissolve_inundation_lyr, "GRID_CODE1 > 0")
gridcode_1 = "grid_code1"
elif turtlebase.arcgis.is_fieldname(gp, temp_fc_union_inundation, "GRID_CODE_1"):
gp.MakeFeatureLayer_management(temp_fc_union_inundation, dissolve_inundation_lyr, "GRID_CODE_1 > 0")
gridcode_1 = "grid_code_1"
else:
log.error("No field available named gridcode_1 or grid_code1")
log.warning(nens.gp.get_table_def(gp, temp_fc_union_inundation))
sys.exit(1)
temp_fc_dissolve_inundation = os.path.join(workspace_gdb, "dissolve_inun")
dissolve_string = "%s;%s;%s" % (gpgident_field.upper(), gridcode, gridcode_1)
log.debug(" - dissolve layer: %s" % dissolve_inundation_lyr)
gp.Dissolve_management(dissolve_inundation_lyr, temp_fc_dissolve_inundation, dissolve_string)
# Calculate area inundation
if not turtlebase.arcgis.is_fieldname(gp, temp_fc_dissolve_inundation, "area_inund"):
gp.addfield(temp_fc_dissolve_inundation, "area_inun", "Double")
turtlebase.arcgis.calculate_area(gp, temp_fc_dissolve_inundation, "area_inun")
inundation_dict = nens.gp.get_table(gp, temp_fc_dissolve_inundation)
translate_inundation_dict = translate_dict(inundation_dict, gridcode_1, 'area_inun')
log.debug("translate_inundation_dict: %s" % translate_inundation_dict)
else:
translate_inundation_dict = {}
# Create feature class from waterdamage grid
""" values: 10, 15, 25"""
if output_waterdamage_exists == 0:
try:
temp_fc_waterdamage = os.path.join(workspace_gdb, "damage")
gp.RasterToPolygon_conversion(output_waterdamage, temp_fc_waterdamage, "NO_SIMPLIFY")
waterdamage = True
except:
log.warning("waterdamage raster is empty")
waterdamage = False
if waterdamage:
temp_fc_union_waterdamage = os.path.join(workspace_gdb, "damage_union")
gp.Union_analysis(temp_fc_dissolve_lgn + ";" + temp_fc_waterdamage, temp_fc_union_waterdamage)
dissolve_waterdamage_lyr = turtlebase.arcgis.get_random_layer_name()
gp.MakeFeatureLayer_management(temp_fc_union_waterdamage, dissolve_waterdamage_lyr, "%s > 0" % gridcode_1)
temp_fc_dissolve_waterdamage = os.path.join(workspace_gdb, "dissolve_damage")
gp.Dissolve_management(dissolve_waterdamage_lyr, temp_fc_dissolve_waterdamage, "%s; %s; %s" % (gpgident_field, gridcode, gridcode_1))
# Calculate area waterdamage
if not turtlebase.arcgis.is_fieldname(gp, temp_fc_dissolve_waterdamage, "area_damag"):
gp.addfield(temp_fc_dissolve_waterdamage, "area_damag", "Double")
turtlebase.arcgis.calculate_area(gp, temp_fc_dissolve_waterdamage, "area_damag")
waterdamage_dict = nens.gp.get_table(gp, temp_fc_dissolve_waterdamage)
translate_waterdamage_dict = translate_dict(waterdamage_dict, gridcode_1, 'area_damag')
log.debug("translate_waterdamage_dict: %s" % translate_waterdamage_dict)
else:
translate_waterdamage_dict = {}
else:
translate_waterdamage_dict = {}
no_data_value = float(config.get('naverwerking_rrcf', 'no_data_value'))
result_dict = {}
log.info("Calculating results")
for gpgident, fields in gpgident_dict.items():
# area_total
#area_total = fields['area_total']
#set defaults
percentage_inundation_urban = no_data_value
percentage_inundation_agriculture = no_data_value
percentage_inundation_rural = no_data_value
percentage_inundation_grass = no_data_value
toetsing_inundation_urban = 9
toetsing_inundation_agriculture = 9
toetsing_inundation_rural = 9
toetsing_inundation_grass = 9
percentage_waterdamage_urban = no_data_value
percentage_waterdamage_agriculture = no_data_value
percentage_waterdamage_rural = no_data_value
percentage_waterdamage_grass = no_data_value
toetsing_waterdamage_urban = 9
toetsing_waterdamage_agriculture = 9
toetsing_waterdamage_rural = 9
toetsing_waterdamage_grass = 9
if gpgident in translate_inundation_dict:
log.debug("Calculate percentage inundation for %s" % gpgident)
hhtijd = config.get('naverwerking_rrcf', 'herhalingstijd_inundatie_stedelijk')
toetsing_perc = config.get('naverwerking_rrcf', 'percentage_inundatie_stedelijk')
toetsing_inundation_urban, percentage_inundation_urban = calculate_toetsing(translate_inundation_dict,
gpgident, 1, translate_lgn_dict,
hhtijd, toetsing_perc, no_data_value)
hhtijd = config.get('naverwerking_rrcf', 'herhalingstijd_inundatie_hoogwaardig')
toetsing_perc = config.get('naverwerking_rrcf', 'percentage_inundatie_hoogwaardig')
toetsing_inundation_agriculture, percentage_inundation_agriculture = calculate_toetsing(translate_inundation_dict,
gpgident, 2, translate_lgn_dict,
hhtijd, toetsing_perc, no_data_value)
hhtijd = config.get('naverwerking_rrcf', 'herhalingstijd_inundatie_akker')
toetsing_perc = config.get('naverwerking_rrcf', 'herhalingstijd_inundatie_akker')
toetsing_inundation_rural, percentage_inundation_rural = calculate_toetsing(translate_inundation_dict, gpgident,
3, translate_lgn_dict, hhtijd,
toetsing_perc, no_data_value)
hhtijd = config.get('naverwerking_rrcf', 'herhalingstijd_inundatie_grasland')
toetsing_perc = config.get('naverwerking_rrcf', 'percentage_inundatie_grasland')
toetsing_inundation_grass, percentage_inundation_grass = calculate_toetsing(translate_inundation_dict, gpgident,
4, translate_lgn_dict, hhtijd,
toetsing_perc, no_data_value)
if gpgident in translate_waterdamage_dict:
log.debug("Calculate percentage waterdamage for %s" % gpgident)
hhtijd = config.get('naverwerking_rrcf', 'herhalingstijd_overlast_stedelijk')
toetsing_perc = config.get('naverwerking_rrcf', 'percentage_overlast_stedelijk')
toetsing_waterdamage_urban, percentage_waterdamage_urban = calculate_toetsing(translate_inundation_dict, gpgident,
1, translate_lgn_dict, hhtijd,
toetsing_perc, no_data_value)
hhtijd = config.get('naverwerking_rrcf', 'herhalingstijd_overlast_hoogwaardig')
toetsing_perc = config.get('naverwerking_rrcf', 'percentage_overlast_hoogwaardig')
toetsing_waterdamage_agriculture, percentage_waterdamage_agriculture = calculate_toetsing(translate_inundation_dict, gpgident,
2, translate_lgn_dict, hhtijd,
toetsing_perc, no_data_value)
hhtijd = config.get('naverwerking_rrcf', 'herhalingstijd_overlast_akker')
toetsing_perc = config.get('naverwerking_rrcf', 'herhalingstijd_overlast_akker')
toetsing_inundation_rural, percentage_waterdamage_rural = calculate_toetsing(translate_inundation_dict, gpgident,
3, translate_lgn_dict, hhtijd,
toetsing_perc, no_data_value)
hhtijd = config.get('naverwerking_rrcf', 'herhalingstijd_overlast_grasland')
toetsing_perc = config.get('naverwerking_rrcf', 'percentage_overlast_grasland')
toetsing_inundation_grass, percentage_waterdamage_grass = calculate_toetsing(translate_inundation_dict, gpgident,
4, translate_lgn_dict, hhtijd,
toetsing_perc, no_data_value)
result_dict[gpgident] = {
gpgident_field: gpgident,
config.get('naverwerking_rrcf',
'field_percentage_inundatie_stedelijk'):
percentage_inundation_urban,
config.get('naverwerking_rrcf',
'field_percentage_inundatie_hoogwaardig'):
percentage_inundation_agriculture,
config.get('naverwerking_rrcf',
'field_percentage_inundatie_akker'):
percentage_inundation_rural,
config.get('naverwerking_rrcf',
'field_percentage_inundatie_grasland'):
percentage_inundation_grass,
config.get('naverwerking_rrcf',
'field_percentage_overlast_stedelijk'):
percentage_waterdamage_urban,
config.get('naverwerking_rrcf',
'field_percentage_overlast_hoogwaardig'):
percentage_waterdamage_agriculture,
config.get('naverwerking_rrcf',
'field_percentage_overlast_akker'):
percentage_waterdamage_rural,
config.get('naverwerking_rrcf',
'field_percentage_overlast_grasland'):
percentage_waterdamage_grass,
config.get('naverwerking_rrcf',
'field_toetsing_inundatie_stedelijk'):
toetsing_inundation_urban,
config.get('naverwerking_rrcf',
'field_toetsing_inundatie_hoogwaardig'):
toetsing_inundation_agriculture,
config.get('naverwerking_rrcf',
'field_toetsing_inundatie_akker'):
toetsing_inundation_rural,
config.get('naverwerking_rrcf',
'field_toetsing_inundatie_grasland'):
toetsing_inundation_grass,
config.get('naverwerking_rrcf',
'field_toetsing_overlast_stedelijk'):
toetsing_waterdamage_urban,
config.get('naverwerking_rrcf',
'field_toetsing_overlast_hoogwaardig'):
toetsing_waterdamage_agriculture,
config.get('naverwerking_rrcf',
'field_toetsing_overlast_akker'):
toetsing_waterdamage_rural,
config.get('naverwerking_rrcf',
'field_toetsing_overlast_grasland'):
toetsing_waterdamage_grass,
}
#---------------------------------------------------------------------
# Create output table
if not gp.exists(output_result_table):
log.info("Create new output table")
temp_result_table = os.path.join(workspace_gdb, "result_table")
gp.CreateTable_management(os.path.dirname(temp_result_table), os.path.basename(temp_result_table))
copy_table = True
else:
temp_result_table = output_result_table
copy_table = False
fields_to_add = [config.get('naverwerking_rrcf',
'field_percentage_inundatie_stedelijk'),
config.get('naverwerking_rrcf',
'field_percentage_inundatie_hoogwaardig'),
config.get('naverwerking_rrcf',
'field_percentage_inundatie_akker'),
config.get('naverwerking_rrcf',
'field_percentage_inundatie_grasland'),
config.get('naverwerking_rrcf',
'field_percentage_overlast_stedelijk'),
config.get('naverwerking_rrcf',
'field_percentage_overlast_hoogwaardig'),
config.get('naverwerking_rrcf',
'field_percentage_overlast_akker'),
config.get('naverwerking_rrcf',
'field_percentage_overlast_grasland'),
config.get('naverwerking_rrcf',
'field_toetsing_inundatie_stedelijk'),
config.get('naverwerking_rrcf',
'field_toetsing_inundatie_hoogwaardig'),
config.get('naverwerking_rrcf',
'field_toetsing_inundatie_akker'),
config.get('naverwerking_rrcf',
'field_toetsing_inundatie_grasland'),
config.get('naverwerking_rrcf',
'field_toetsing_overlast_stedelijk'),
config.get('naverwerking_rrcf',
'field_toetsing_overlast_hoogwaardig'),
config.get('naverwerking_rrcf',
'field_toetsing_overlast_akker'),
config.get('naverwerking_rrcf',
'field_toetsing_overlast_grasland')]
if not turtlebase.arcgis.is_fieldname(gp, temp_result_table, gpgident_field):
log.debug(" - add field %s to %s" % (gpgident_field, temp_result_table))
gp.addfield_management(temp_result_table, gpgident_field, 'text')
for field in fields_to_add:
if not turtlebase.arcgis.is_fieldname(gp, temp_result_table, field):
log.debug(" - add field %s to %s" % (field, temp_result_table))
gp.addfield_management(temp_result_table, field, 'double')
#----------------------------------------------------------------------------------------
# Write results to output table
log.info("Write results to output table")
turtlebase.arcgis.write_result_to_output(temp_result_table, gpgident_field.lower(), result_dict)
if copy_table == True:
gp.TableToTable_conversion(temp_result_table, os.path.dirname(output_result_table), os.path.basename(output_result_table))
#---------------------------------------------------------------------
# Delete temporary workspace geodatabase & ascii files
try:
log.debug("delete temporary workspace: %s" % workspace_gdb)
gp.delete(workspace_gdb)
log.info("workspace deleted")
except:
log.debug("failed to delete %s" % workspace_gdb)
tempfiles = os.listdir(workspace)
for tempfile in tempfiles:
if tempfile.endswith('.asc'):
try:
os.remove(os.path.join(workspace, tempfile))
except Exception, e:
log.debug(e)
mainutils.log_footer()
def main():
try:
gp = mainutils.create_geoprocessor()
config = mainutils.read_config(__file__, 'turtle-settings.ini')
logfile = mainutils.log_filename(config)
logging_config = LoggingConfig(gp, logfile=logfile)
mainutils.log_header(__name__)
#----------------------------------------------------------------------------------------
#check inputfields
log.info("Getting commandline parameters... ")
#use_onderbemalingen = False
if len(sys.argv) == 6:
input_peilgebiedgegevens = sys.argv[1]
input_toetspunten = sys.argv[2]
input_resultaten = sys.argv[3]
output_table = sys.argv[4]
output_csv = sys.argv[5]
use_csv = not(output_csv == '#')
else:
log.error("Usage: python rural_naverwerking.py <peilvakgegevens table> <toetspunten_table> <resultaten_csv> <output_table> <output_csv>")
sys.exit(1)
#----------------------------------------------------------------------------------------
#check input parameters
log.info('Checking presence of input files... ')
if not(use_csv):
log.warning("no output has been defined, output will be written to temp workspace")
if not(gp.exists(input_toetspunten)):
log.error("input_toetspunten "+input_toetspunten+" does not exist!")
sys.exit(5)
if not(gp.exists(input_resultaten)):
log.error("input_resultaten "+input_resultaten+" does not exist!")
sys.exit(5)
log.info('input parameters checked... ')
#----------------------------------------------------------------------------------------
# Create workspace
workspace = config.get('GENERAL','location_temp')
if workspace == "-":
workspace = tempfile.gettempdir()
turtlebase.arcgis.delete_old_workspace_gdb(gp, workspace)
if not os.path.isdir(workspace):
os.makedirs(workspace)
workspace_gdb, errorcode = turtlebase.arcgis.create_temp_geodatabase(gp, workspace)
if errorcode == 1:
log.error("failed to create a file geodatabase in %s" % workspace)
#----------------------------------------------------------------------------------------
log.info("A-1) Reading peilgebiedgegevens... ")
gpgident = config.get('GENERAL', 'gpgident')
peilgebied_dict = nens.gp.get_table(gp, input_peilgebiedgegevens, primary_key=gpgident.lower())
log.info("A-2) Converting toetspunten to csv")
toetspunten_csv = os.path.join(workspace, "nav_toets.csv")
nav_toetspunten = nens.gp.join_on_primary_key(gp, peilgebied_dict, input_toetspunten, gpgident.lower())
turtlebase.arcgis.convert_dict_to_csv(nav_toetspunten, toetspunten_csv)
log.info("A-3) Preparing hymstat csv")
hymstat_csv = os.path.join(workspace, "nav_hym.csv")
#turtlebase.arcgis.convert_table_to_csv(gp, input_resultaten, hymstat_csv)
shutil.copyfile(input_resultaten, hymstat_csv)
#prepare naverwerking ini file
log.info("B-1) Reading naverwerkingstool.ini... ")
location_script = os.path.dirname(sys.argv[0])
nav_config = mainutils.read_config(__file__, config.get('GENERAL', 'filename_naverwerking_ini'))
configfilename = os.path.join(location_script, config.get('GENERAL', 'filename_naverwerking_ini'))
nav_config.set('GENERAL', 'CSVTOETSPUNTEN', toetspunten_csv) #input_toetspunten
nav_config.set('GENERAL', 'CSVINPUT1', hymstat_csv)
#image output of naverkingstool will go to the same outputdir as the csv!! So if csv output is selected,
#we MUST use that output-csv as the intermediate csv too
if use_csv:
log.info(" - using csv")
if not output_csv.endswith('.csv'):
output_csv += '.csv'
nav_config.set('GENERAL', 'CSVOUTPUT1', output_csv)
else:
log.info(" - not using csv")
output_csv = os.path.join(workspace, "nav_output.csv")
nav_config.set('GENERAL', 'CSVOUTPUT1', output_csv)
nav_config.set('GENERAL', 'CSVINPUT2', '')
nav_config.set('GENERAL', 'CSVOUTPUT2', '')
configfile = open(configfilename, "wb")
nav_config.write(configfile)
configfile.close()
#----------------------------------------------------------------------------------------
#call naverwerkingstool
arguments = ""
#change working path to exe directory
os.chdir(location_script)
#execute external program gridbewerking
log.info("Naverwerking calculation")
import subprocess
naverwerking_exe = config.get('GENERAL', 'filename_naverwerking_exe')
child = subprocess.Popen(os.path.join(location_script, naverwerking_exe) + arguments)
child.wait()
log.info("naverwerking.exe succesfully executed")
"""
HIERONDER ALLES HERSCHRIJVEN
"""
#----------------------------------------------------------------------------------------
#post: write to database, table and/or csv
log.info("C-1) Reading output csv")
data_set = csv.DictReader(file(output_csv))
#name is same as key is nothing is given; key is columnname from csv
#alle velden die niet hier voorkomen, hoeven niet van naam worden veranderd en zijn van het type "long", precision 10, scale 5
naverwerkingFields = {\
gpgident: {"NAME": gpgident, "TYPE": "TEXT", "PRECISION": "10", "SCALE": "5", "LENGTH": "50"},\
"X0": {"NAME": "X0", "TYPE": "DOUBLE", "PRECISION": "10", "SCALE": "5"},\
"B": {"NAME": "B", "TYPE": "DOUBLE", "PRECISION": "10", "SCALE": "5"},\
"WS_2": {"NAME": "WS_2", "TYPE": "DOUBLE", "PRECISION": "10", "SCALE": "5"},\
"WS_5": {"NAME": "WS_5", "TYPE": "DOUBLE", "PRECISION": "10", "SCALE": "5"},\
"WS_10": {"NAME": "WS_10", "TYPE": "DOUBLE", "PRECISION": "10", "SCALE": "5"},\
"WS_15": {"NAME": "WS_15", "TYPE": "DOUBLE", "PRECISION": "10", "SCALE": "5"},\
"WS_20": {"NAME": "WS_20", "TYPE": "DOUBLE", "PRECISION": "10", "SCALE": "5"},\
"WS_25": {"NAME": "WS_25", "TYPE": "DOUBLE", "PRECISION": "10", "SCALE": "5"},\
"WS_50": {"NAME": "WS_50", "TYPE": "DOUBLE", "PRECISION": "10", "SCALE": "5"},\
"WS_100": {"NAME": "WS_100", "TYPE": "DOUBLE", "PRECISION": "10", "SCALE": "5"},\
"STA_TP_I_S": {"NAME": "STA_TP_I_ST", "TYPE": "DOUBLE", "PRECISION": "10", "SCALE": "5"},\
"STA_TP_I_H": {"NAME": "STA_TP_I_HL", "TYPE": "DOUBLE", "PRECISION": "10", "SCALE": "5"},\
"STA_TP_I_A": {"NAME": "STA_TP_I_AK", "TYPE": "DOUBLE", "PRECISION": "10", "SCALE": "5"},\
"STA_TP_I_G": {"NAME": "STA_TP_I_GR", "TYPE": "DOUBLE", "PRECISION": "10", "SCALE": "5"},\
"STA_TP_O_S": {"NAME": "STA_TP_O_ST", "TYPE": "DOUBLE", "PRECISION": "10", "SCALE": "5"},\
"STA_TP_O_H": {"NAME": "STA_TP_O_HL", "TYPE": "DOUBLE", "PRECISION": "10", "SCALE": "5"},\
"STA_TP_O_A": {"NAME": "STA_TP_O_AK", "TYPE": "DOUBLE", "PRECISION": "10", "SCALE": "5"},\
"STA_TP_O_G": {"NAME": "STA_TP_O_GR", "TYPE": "DOUBLE", "PRECISION": "10", "SCALE": "5"},\
"T_I": {"NAME": "T_I", "TYPE": "DOUBLE", "PRECISION": "10", "SCALE": "5"},\
"T_O": {"NAME": "T_O", "TYPE": "DOUBLE", "PRECISION": "10", "SCALE": "5"},\
"RSLT_Bron": {"NAME": "RSLT_Bron", "TYPE": "TEXT", "LENGTH": "50", "PRECISION": "10", "SCALE": "5"},\
"RSLT_Datum": {"NAME": "RSLT_Datum", "TYPE": "DATE", "PRECISION": "10", "SCALE": "5"},\
}
#convert columnnames in data_set
data_set_converted = {}
source_str = "hymstat: %s" % os.path.basename(input_resultaten)
if len(source_str) > 50:
source_str = source_str[:50]
import time
date_str = time.strftime('%x')
for row in data_set:
peilgebied_id = row['PEILVAKID']
data_set_converted[peilgebied_id] = {gpgident: peilgebied_id}
for key in row.keys():
if key in naverwerkingFields:
data_set_converted[peilgebied_id][naverwerkingFields[key]["NAME"]] = row[key]
data_set_converted[peilgebied_id]["RSLT_Bron"] = source_str
data_set_converted[peilgebied_id]["RSLT_Datum"] = date_str
#----------------------------------------------------------------------------------------
#check if output_table exists. if not, create with correct rows
log.info("C-2) Checking output table... ")
if not(gp.exists(output_table)):
gp.CreateTable(os.path.dirname(output_table), os.path.basename(output_table))
#----------------------------------------------------------------------------------------
#for key,row in naverwerkingFields.items():
# print row["NAME"]+" "+row["TYPE"]+" "+row["PRECISION"]+" "+row["SCALE"]
#check if output_table has the correct rows
log.info("C-3) Checking fields")
for field_name, field_settings in naverwerkingFields.items():
if not turtlebase.arcgis.is_fieldname(gp, output_table, field_settings['NAME']):
if field_settings['TYPE'] == 'DOUBLE':
gp.AddField(output_table, field_settings['NAME'], field_settings['TYPE'], field_settings['PRECISION'], field_settings['SCALE'])
elif field_settings['TYPE'] == 'TEXT':
gp.AddField(output_table, field_settings['NAME'], field_settings['TYPE'], '#', '#', field_settings['LENGTH'])
else:
gp.AddField(output_table, field_settings['NAME'], field_settings['TYPE'], field_settings['PRECISION'], field_settings['SCALE'])
# ---------------------------------------------------------------------------
#add data to file_output
turtlebase.arcgis.write_result_to_output(output_table, gpgident, data_set_converted)
#----------------------------------------------------------------------------------------
# Delete temporary workspace geodatabase & ascii files
try:
log.debug("delete temporary workspace: %s" % workspace_gdb)
gp.delete(workspace_gdb)
log.info("workspace deleted")
except:
log.warning("failed to delete %s" % workspace_gdb)
if os.path.isfile(toetspunten_csv):
os.remove(toetspunten_csv)
if os.path.isfile(hymstat_csv):
os.remove(hymstat_csv)
mainutils.log_footer()
except:
log.error(traceback.format_exc())
sys.exit(1)
finally:
logging_config.cleanup()
del gp
def main():
try:
#----------------------------------------------------------------------------------------
# Input parameters
if len(sys.argv) == 5:
input_hymstat = sys.argv[1]
input_rekenpunten = sys.argv[2]
input_rr_peilgebied = sys.argv[3]
output_table = sys.argv[4]
else:
log.warning("usage: <input_hymstat> <input_rekenpunten> <input_rr_peilgebied> <output_table>")
sys.exit(1)
#----------------------------------------------------------------------------------------
# check required fields in input
log.info("Check required fields in input data")
missing_fields = []
if not turtlebase.arcgis.is_fieldname(gp, input_rekenpunten, calculation_id):
log.debug(" - missing: %s in %s" % (calculation_id, input_rekenpunten))
missing_fields.append("%s: %s" % (input_rekenpunten, calculation_id))
if not turtlebase.arcgis.is_fieldname(gp, input_rekenpunten, gpgident):
log.debug(" - missing: %s in %s" % (gpgident, input_rekenpunten))
missing_fields.append("%s: %s" % (input_rekenpunten, gpgident))
if not turtlebase.arcgis.is_fieldname(gp, input_rr_peilgebied, gpgident):
log.debug(" - missing: %s in %s" % (gpgident, input_rr_peilgebied))
missing_fields.append("%s: %s" % (input_rr_peilgebied, gpgident))
if not turtlebase.arcgis.is_fieldname(gp, input_rr_peilgebied, targetlevel):
log.debug(" - missing: %s in %s" % (targetlevel, input_rr_peilgebied))
missing_fields.append("%s: %s" % (input_rr_peilgebied, targetlevel))
if not turtlebase.arcgis.is_fieldname(gp, input_rr_peilgebied, maxlevel):
log.debug(" - missing: %s in %s" % (maxlevel, input_rr_peilgebied))
missing_fields.append("%s: %s" % (input_rr_peilgebied, maxlevel))
if len(missing_fields) > 0:
log.error("missing fields in input data: %s" % missing_fields)
sys.exit(2)
#----------------------------------------------------------------------------------------
log.info("read rekenpunten table")
rekenpunten_dict = nens.gp.get_table(gp, input_rekenpunten, primary_key=calculation_id)
log.info("read rr_peilgebied table")
rr_peilgebied_dict = nens.gp.get_table(gp, input_rr_peilgebied, primary_key=gpgident)
missing_fields_in_rekenpunten = is_key_in_dict(rekenpunten_dict, [gpgident])
if len(missing_fields_in_rekenpunten) > 0:
log.error("missing fields in input calculation points: %s" % missing_fields_in_rekenpunten)
missing_fields_in_rr_peilgebied = is_key_in_dict(rr_peilgebied_dict, [gpgident, targetlevel, maxlevel])
if len(missing_fields_in_rr_peilgebied) > 0:
log.error("missing fields in peilgebied table: %s" % missing_fields_in_rr_peilgebied)
rekenpunten_with_levels_dict = {}
for k, v in rekenpunten_dict.items():
peilgebied_ident = v[gpgident]
if rr_peilgebied_dict.has_key(peilgebied_ident):
streefpeil = rr_peilgebied_dict[peilgebied_ident][targetlevel]
afkaphoogte = rr_peilgebied_dict[peilgebied_ident][maxlevel]
else:
streefpeil = -999
afkaphoogte = 999
rekenpunten_with_levels_dict[k] = {gpgident: peilgebied_ident, targetlevel: streefpeil, maxlevel: afkaphoogte}
#----------------------------------------------------------------------------------------
return_periods = config.get('rrcf_waterlevel', 'herhalingstijden')
return_period_list = [int(hh) for hh in return_periods.split(', ')]
result_dict = calculate_waterlevel(input_hymstat, return_period_list, rekenpunten_with_levels_dict)
if not gp.exists(output_table):
gp.CreateTable_management(os.path.dirname(output_table),
os.path.basename(output_table))
fields_to_add = {calculation_id:"text", gpgident:"text", config.get('rrcf_waterlevel', 'output_targetlevel'):"double", maxlevel: "double"}
add_fields_to_output_table(output_table, fields_to_add, return_period_list)
turtlebase.arcgis.write_result_to_output(output_table, calculation_id, result_dict)
mainutils.log_footer()
except:
log.error(traceback.format_exc())
sys.exit(1)
finally:
logging_config.cleanup()
def main():
try:
gp = mainutils.create_geoprocessor()
config = mainutils.read_config(__file__, 'turtle-settings.ini')
logfile = mainutils.log_filename(config)
logging_config = LoggingConfig(gp, logfile=logfile)
mainutils.log_header(__name__)
#----------------------------------------------------------------------------------------
# Create workspace
workspace = config.get('GENERAL', 'location_temp')
if workspace == "-":
workspace = tempfile.gettempdir()
turtlebase.arcgis.delete_old_workspace_gdb(gp, workspace)
if not os.path.isdir(workspace):
os.makedirs(workspace)
workspace_gdb, errorcode = turtlebase.arcgis.create_temp_geodatabase(gp, workspace)
if errorcode == 1:
log.error("failed to create a file geodatabase in %s" % workspace)
#----------------------------------------------------------------------------------------
#check inputfields
log.info("Getting commandline parameters")
if len(sys.argv) == 5:
input_peilgebieden_feature = sys.argv[1]
input_kunstwerken_feature = sys.argv[2]
input_afvoer_table = sys.argv[3]
output_feature = sys.argv[4]
else:
log.error("Usage: python rural_afvoerrelaties.py \
<peilgebieden feature> <kunstwerken feature> \
<afvoerrelaties table> <output feature>")
sys.exit(1)
#----------------------------------------------------------------------------------------
#check input parameters
gpgident = config.get('GENERAL', 'gpgident').lower()
kwkident = config.get('GENERAL', 'kwkident').lower()
log.info('Checking presence of input files')
if not(gp.exists(input_peilgebieden_feature)):
log.error("inputfile peilgebieden %s does not exist!" % input_peilgebieden_feature)
sys.exit(5)
if not(gp.exists(input_afvoer_table)):
log.error("inputfile afvoerrelaties %s does not exist!" % input_afvoer_table)
sys.exit(5)
log.info('Input parameters checked')
#----------------------------------------------------------------------------------------
log.info("Prepare input_peilgebieden_feature")
temp_peilgebieden_feature = turtlebase.arcgis.get_random_file_name(workspace_gdb)
gp.Select_analysis(input_peilgebieden_feature, temp_peilgebieden_feature)
add_centroids(gp, temp_peilgebieden_feature)
peilgebieden_dict = nens.gp.get_table(gp, temp_peilgebieden_feature, primary_key=gpgident)
if input_kunstwerken_feature != '#':
log.info("Prepare input_kunstwerken_feature")
temp_kunstwerken_feature = turtlebase.arcgis.get_random_file_name(workspace_gdb)
gp.Select_analysis(input_kunstwerken_feature, temp_kunstwerken_feature)
gp.addxy(temp_kunstwerken_feature)
kunstwerken_dict = nens.gp.get_table(gp, temp_kunstwerken_feature, primary_key=kwkident)
else:
kunstwerken_dict = {}
log.info("Reading input_afvoer_table")
relaties_dict = nens.gp.get_table(gp, input_afvoer_table, primary_key=kwkident)
log.info("Calculating afvoerrelaties")
afvoer_van = config.get('afvoerrelaties', 'input_peilg_from').lower()
afvoer_naar = config.get('afvoerrelaties', 'input_peilg_to').lower()
output_relations = {}
data_source = "pg: %s, kw: %s, rel: %s" % (os.path.basename(input_peilgebieden_feature),
os.path.basename(input_kunstwerken_feature),
os.path.basename(input_afvoer_table))
data_source = data_source[:50]
for relation, attributes in relaties_dict.items():
id_from = attributes[afvoer_van]
id_to = attributes[afvoer_naar]
item_id = "%s_%s" % (id_from, id_to)
coords = []
# get start coords
x1 = peilgebieden_dict[id_from]['point_x']
y1 = peilgebieden_dict[id_from]['point_y']
coords.append((x1, y1))
if relation in kunstwerken_dict:
x2 = kunstwerken_dict[relation]['point_x']
y2 = kunstwerken_dict[relation]['point_y']
coords.append((x2, y2))
if id_to in peilgebieden_dict:
x3 = peilgebieden_dict[id_to]['point_x']
y3 = peilgebieden_dict[id_to]['point_y']
else:
x3 = x1 + 10
y3 = y1 + 10
coords.append((x3, y3))
output_relations[item_id] = {"Relation_id": item_id, "From": id_from, "To": id_to,
"Structure": relation, "Source": data_source, "coords": coords}
#put new data in output_table
insert_count = draw_lines_from_dict(gp, output_relations, output_feature)
log.info(" - %s records has been inserted" % insert_count)
#----------------------------------------------------------------------------------------
# Delete temporary workspace geodatabase
try:
log.debug("delete temporary workspace: %s" % workspace_gdb)
gp.delete(workspace_gdb)
log.info("workspace deleted")
except:
log.warning("failed to delete %s" % workspace_gdb)
mainutils.log_footer()
except:
log.error(traceback.format_exc())
sys.exit(1)
finally:
logging_config.cleanup()
del gp
def main():
try:
gp = mainutils.create_geoprocessor()
config = mainutils.read_config(__file__, 'turtle-settings.ini')
logfile = mainutils.log_filename(config)
logging_config = LoggingConfig(gp, logfile=logfile)
mainutils.log_header(__name__)
#---------------------------------------------------------------------
# Create workspace
workspace = config.get('GENERAL', 'location_temp')
if workspace == "-":
workspace = tempfile.gettempdir()
turtlebase.arcgis.delete_old_workspace_gdb(gp, workspace)
if not os.path.isdir(workspace):
os.makedirs(workspace)
workspace_gdb, errorcode = turtlebase.arcgis.create_temp_geodatabase(
gp, workspace)
if errorcode == 1:
log.error("failed to create a file geodatabase in %s" % workspace)
#---------------------------------------------------------------------
# check inputfields
log.info("Getting commandline parameters")
if len(sys.argv) == 8:
input_level_area_fc = sys.argv[1]
input_level_area_table = sys.argv[2]
input_ahn_raster = sys.argv[3]
input_lgn_raster = sys.argv[4]
input_lgn_conversion = sys.argv[5]
input_onderbemalingen = sys.argv[6]
if input_onderbemalingen == "#":
use_onderbemalingen = False
else:
use_onderbemalingen = True
output_file = sys.argv[7]
else:
log.error("Usage: python toetspuntenbepaling.py <ahn-file> \
<lgn-file> <onderbemalingen-optional> \
<peilgebieden-feature> <peilvakgegevens-table> \
<conversietabel> <outputfile-HydroBase>")
sys.exit(1)
#---------------------------------------------------------------------
# check input parameters
log.info('Checking presence of input files')
if not(gp.exists(input_level_area_fc)):
log.error("inputfile peilgebieden %s does not exist!",
input_level_area_fc)
sys.exit(5)
if not(gp.exists(input_level_area_table)):
log.error("inputfile peilvakgegevens %s does not exist!",
input_level_area_table)
sys.exit(5)
if (use_onderbemalingen and not(gp.exists(input_onderbemalingen))):
log.error("inputfile onderbemalingen %s does not exist!",
input_onderbemalingen)
sys.exit(5)
log.info('input parameters checked')
#---------------------------------------------------------------------
# Check geometry input parameters
cellsize = gp.describe(input_ahn_raster).MeanCellHeight
log.info("Check geometry of input parameters")
geometry_check_list = []
log.debug(" - check level area: %s" % input_level_area_fc)
if gp.describe(input_level_area_fc).ShapeType != 'Polygon':
errormsg = ("%s is not a polygon feature class!",
input_level_area_fc)
log.error(errormsg)
geometry_check_list.append(errormsg)
if turtlebase.arcgis.fc_is_not_empty(gp, input_level_area_fc):
errormsg = "input '%s' is empty" % input_level_area_fc
log.error(errormsg)
sys.exit(1)
if turtlebase.arcgis.fc_is_not_empty(gp, input_level_area_table):
errormsg = "input '%s' is empty" % input_level_area_table
log.error(errormsg)
sys.exit(1)
if use_onderbemalingen:
if turtlebase.arcgis.fc_is_not_empty(gp, input_onderbemalingen):
errormsg = "input '%s' is empty" % input_onderbemalingen
log.error(errormsg)
sys.exit(1)
log.debug(" - check ahn raster %s" % input_ahn_raster)
if gp.describe(input_ahn_raster).DataType != 'RasterDataset':
log.error("Input AHN is not a raster dataset")
sys.exit(1)
if gp.describe(input_ahn_raster).PixelType[0] not in ['U', 'S']:
errormsg = ("Input AHN is a floating point raster, \
for this script an integer is nessecary")
log.error(errormsg)
geometry_check_list.append(errormsg)
log.debug(" - check lgn raster %s" % input_lgn_raster)
if gp.describe(input_lgn_raster).DataType != 'RasterDataset':
log.error("Input LGN is not a raster dataset")
sys.exit(1)
if gp.describe(input_lgn_raster).PixelType[0] not in ['U', 'S']:
errormsg = ("Input LGN is a floating point raster, \
for this script an integer is nessecary")
log.error(errormsg)
geometry_check_list.append(errormsg)
if int(gp.describe(input_lgn_raster).MeanCellHeight) != int(cellsize):
errormsg = ("Cell size of LGN is %s, must be %s" % (
gp.describe(input_lgn_raster).MeanCellHeight,
int(cellsize)))
log.error(errormsg)
geometry_check_list.append(errormsg)
if len(geometry_check_list) > 0:
log.error("check input: %s" % geometry_check_list)
sys.exit(2)
#---------------------------------------------------------------------
# Check required fields in input data
log.info("Check required fields in input data")
gpgident = config.get('GENERAL', 'gpgident').lower()
streefpeil = config.get('toetspunten', 'field_streefpeil').lower()
missing_fields = []
# check required fields from input data, append them to list if missing
if not turtlebase.arcgis.is_fieldname(
gp, input_level_area_fc, gpgident):
log.debug(" - missing: %s in %s", (
gpgident, input_level_area_fc))
missing_fields.append("%s: %s", (
input_level_area_fc, gpgident))
if not turtlebase.arcgis.is_fieldname(
gp, input_level_area_table, gpgident):
log.debug(" - missing: %s in %s", (
gpgident, input_level_area_table))
missing_fields.append("%s: %s", (
input_level_area_table, gpgident))
if not turtlebase.arcgis.is_fieldname(
gp, input_level_area_table, streefpeil):
log.debug(" - missing: %s in %s", (
streefpeil, input_level_area_table))
missing_fields.append("%s: %s", (
input_level_area_table, streefpeil))
if len(missing_fields) > 0:
log.error("missing fields in input data: %s", missing_fields)
sys.exit(2)
#---------------------------------------------------------------------
# Environments
log.info("Set environments")
temp_level_area = os.path.join(workspace_gdb, "peilgebieden")
if input_level_area_fc.endswith(".shp"):
log.info("Copy features of level areas to workspace")
gp.select_analysis(input_level_area_fc, temp_level_area)
else:
log.info("Copy level areas to workspace")
gp.copy_management(input_level_area_fc, temp_level_area)
# use extent from level area
gp.extent = gp.describe(temp_level_area).extent
#---------------------------------------------------------------------
# Create K5 LGN
log.info("Translate LGN to NBW-classes")
lgn_ascii = turtlebase.arcgis.get_random_file_name(
workspace, ".asc")
lgn_k5_ascii = turtlebase.arcgis.get_random_file_name(
workspace, ".asc")
gp.RasterToASCII_conversion(input_lgn_raster, lgn_ascii)
lgn_ident = config.get('toetspunten', 'lgn_conv_ident')
if input_lgn_conversion != '#':
reclass_dict = nens.gp.get_table(gp, input_lgn_conversion,
primary_key=lgn_ident)
turtlebase.spatial.reclass_lgn_k5(
lgn_ascii, lgn_k5_ascii, reclass_dict)
else:
turtlebase.spatial.reclass_lgn_k5(lgn_ascii, lgn_k5_ascii)
#---------------------------------------------------------------------
# create ahn ascii
log.info("Create ascii from ahn")
ahn_ascii = turtlebase.arcgis.get_random_file_name(workspace, ".asc")
log.debug("ahn ascii: %s" % ahn_ascii)
gp.RasterToASCII_conversion(input_ahn_raster, ahn_ascii)
#---------------------------------------------------------------------
# Change ahn and lgn if use_ondermalingen == True
if use_onderbemalingen:
log.info("Cut out level deviations")
gridcode_fieldname = "GRIDCODE"
if not turtlebase.arcgis.is_fieldname(
gp, input_onderbemalingen, gridcode_fieldname):
log.debug(" - add field %s" % gridcode_fieldname)
gp.addfield_management(
input_onderbemalingen, gridcode_fieldname, "Short")
row = gp.UpdateCursor(input_onderbemalingen)
for item in nens.gp.gp_iterator(row):
item.SetValue(gridcode_fieldname, 1)
row.UpdateRow(item)
onderbemaling_raster = turtlebase.arcgis.get_random_file_name(
workspace_gdb)
gp.FeatureToRaster_conversion(
input_onderbemalingen, gridcode_fieldname,
onderbemaling_raster, cellsize)
onderbemaling_asc = turtlebase.arcgis.get_random_file_name(
workspace, ".asc")
gp.RasterToASCII_conversion(onderbemaling_raster,
onderbemaling_asc)
ahn_ascii = turtlebase.spatial.cut_out_onderbemaling(
ahn_ascii, onderbemaling_asc, workspace)
lgn_k5_ascii = turtlebase.spatial.cut_out_onderbemaling(
lgn_k5_ascii, onderbemaling_asc, workspace)
#---------------------------------------------------------------------
# Add ID Int to level area
log.info("Create level area ascii")
id_int = 'id_int'
area_id_dict = add_integer_ident(gp, temp_level_area,
id_int, gpgident)
out_raster_dataset = turtlebase.arcgis.get_random_file_name(
workspace_gdb)
gp.FeatureToRaster_conversion(temp_level_area, id_int,
out_raster_dataset, cellsize)
id_int_ascii = turtlebase.arcgis.get_random_file_name(
workspace, ".asc")
log.debug("id_int_ascii: %s" % id_int_ascii)
gp.RasterToASCII_conversion(out_raster_dataset, id_int_ascii)
#---------------------------------------------------------------------
log.info("Read targetlevel table")
area_level_dict = nens.gp.get_table(gp, input_level_area_table,
primary_key=gpgident)
target_level_dict = {}
for k, v in area_level_dict.items():
if k in area_id_dict:
int_id = area_id_dict[k][id_int]
target_level_dict[int_id] = {'targetlevel': v[streefpeil],
'gpgident': k}
toetspunten_fields = ["DFLT_I_ST", "DFLT_I_HL", "DFLT_I_AK",
"DFLT_I_GR", "DFLT_O_ST", "DFLT_O_HL",
"DFLT_O_AK", "DFLT_O_GR", "MTGMV_I_ST",
"MTGMV_I_HL", "MTGMV_I_AK", "MTGMV_I_GR",
"MTGMV_O_ST", "MTGMV_O_HL", "MTGMV_O_AK",
"MTGMV_O_GR"]
#---------------------------------------------------------------------
log.info("calculate toetspunten")
toetspunten_dict = turtlebase.spatial.calculcate_toetspunten(
ahn_ascii, lgn_k5_ascii, id_int_ascii,
toetspunten_fields, target_level_dict,
onderbemaling="#")
#---------------------------------------------------------------------
log.info("Create output table")
create_output_table(gp, output_file, gpgident, toetspunten_fields)
#---------------------------------------------------------------------
# Add metadata
import time
date_time_str = time.strftime("%d %B %Y %H:%M:%S")
source = input_ahn_raster
for area_id, values in toetspunten_dict.items():
toetspunten_dict[area_id]['date_time'] = date_time_str
toetspunten_dict[area_id]['source'] = source
#---------------------------------------------------------------------
# Write results to output table
log.info("Write results to output table")
turtlebase.arcgis.write_result_to_output(
output_file, gpgident, toetspunten_dict)
#---------------------------------------------------------------------
# Delete temporary workspace geodatabase & ascii files
try:
log.debug("delete temporary workspace: %s" % workspace_gdb)
gp.delete(workspace_gdb)
log.info("workspace deleted")
except:
log.warning("failed to delete %s" % workspace_gdb)
tempfiles = os.listdir(workspace)
for tempfile in tempfiles:
if tempfile.endswith('.asc'):
try:
os.remove(os.path.join(workspace, tempfile))
except Exception, e:
log.debug(e)
mainutils.log_footer()