def createPMPfc():
arcpy.AddMessage(
"\nCreating feature class: 'PMP_Points' in Scratch.gdb...")
dm.MakeFeatureLayer(
home + "\\Input\Non_Storm_Data.gdb\Vector_Grid",
"vgLayer") # make a feature layer of vector grid cells
dm.SelectLayerByLocation(
"vgLayer", "INTERSECT", aoiBasin
) # select the vector grid cells that intersect the aoiBasin polygon
dm.MakeFeatureLayer(home + "\\Input\Non_Storm_Data.gdb\Grid_Points",
"gpLayer") # make a feature layer of grid points
dm.SelectLayerByLocation(
"gpLayer", "HAVE_THEIR_CENTER_IN", "vgLayer"
) # select the grid points within the vector grid selection
con.FeatureClassToFeatureClass(
"gpLayer", env.scratchGDB,
"PMP_Points") # save feature layer as "PMP_Points" feature class
arcpy.AddMessage("(" + str(dm.GetCount("gpLayer")) +
" grid points will be analyzed)\n")
# Add PMP Fields
for dur in durList:
arcpy.AddMessage("\t...adding field: PMP_" + str(dur))
dm.AddField(env.scratchGDB + "\\PMP_Points", "PMP_" + dur,
"DOUBLE")
# Add STORM Fields (this string values identifies the driving storm by SPAS ID number)
for dur in durList:
arcpy.AddMessage("\t...adding field: STORM_" + str(dur))
dm.AddField(env.scratchGDB + "\\PMP_Points", "STORM_" + dur,
"TEXT", "", "", 16)
return
def get_path_residence_times (in_file, cost_rast, out_raster, t_diff_fld_name, workspace):
if len (out_raster) == 0:
arcpy.AddError ("Missing argument: out_rast")
raise Exception
if len (t_diff_fld_name) == 0:
t_diff_fld_name = "T_DIFF_HRS"
arcpy.env.overwriteOutput = True # This is underhanded. It should be an argument.
if arcpy.env.outputCoordinateSystem is None:
arcpy.env.outputCoordinateSystem = cost_rast
arcpy.AddMessage ("coordinate system is %s" % arcpy.env.outputCoordinateSystem.name)
if len(workspace):
arcpy.env.workspace = workspace
if arcpy.env.workspace is None or len(arcpy.env.workspace) == 0:
arcpy.env.workspace = os.getcwd()
if '.gdb' in arcpy.env.workspace:
arcpy.AddError (
"Worskpace is a geodatabase. " +
"This brings too much pain for this script to work.\n" +
"%s" % arcpy.env.workspace
)
raise WorkspaceIsGeodatabase
r = Raster(cost_rast)
if r.maximum == 0 and r.minimum == 0:
arcpy.AddMessage ('Cost raster has only zero value. Cannot calculate cost distances.')
raise CostRasterIsZero
size = r.height * r.width * 4
if size > 2 * 1028 ** 3:
import struct
struct_size = struct.calcsize("P") * 8
if struct_size == 32:
size_in_gb = float (size) / (1028 ** 3)
arcpy.AddMessage (
'Cost raster exceeds 2 GiB in size (%s GiB). This is too large for a 32 bit NumPy.' % size_in_gb
)
raise NumPyArrayExceedsSizeLimits
if not check_points_are_in_cost_raster(in_file, cost_rast):
arcpy.AddError ('One or more input points do not intersect the cost raster')
raise PointNotOnRaster
arcpy.env.snapRaster = cost_rast
suffix = None
wk = arcpy.env.workspace
if not '.gdb' in wk:
suffix = '.shp'
ext = arcpy.env.extent
if ext is None:
arcpy.env.extent = r.extent
arcpy.AddMessage ("Extent is %s" % arcpy.env.extent)
arcpy.env.cellSize = r.meanCellWidth
arcpy.AddMessage ("Cell size is %s" % arcpy.env.cellSize)
cellsize_used = float (arcpy.env.cellSize)
extent = arcpy.env.extent
lower_left_coord = extent.lowerLeft
arcpy.AddMessage ('Currently in directory: %s\n' % os.getcwd())
arcpy.AddMessage ('Workspace is: %s' % arcpy.env.workspace)
arcpy.AddMessage ("lower left is %s" % lower_left_coord)
if arcpy.env.mask is None:
arcpy.AddMessage ("Setting mask to %s" % cost_rast)
arcpy.env.mask = cost_rast
# accumulated transits
transit_array_accum = arcpy.RasterToNumPyArray (Raster(cost_rast) * 0)
feat_layer = "feat_layer"
arcmgt.MakeFeatureLayer(in_file, feat_layer)
desc = arcpy.Describe (feat_layer)
oid_fd_name = desc.OIDFieldName
arcpy.AddMessage("oid_fd_name = %s" % oid_fd_name)
# variable name is redundant now??? - should all calls be to oid_fd_name?
target_fld = oid_fd_name
proc_layer = "process_layer"
arcmgt.MakeFeatureLayer(in_file, proc_layer)
rows = arcpy.SearchCursor(proc_layer)
last_target = None
for row_cur in rows:
transit_time = row_cur.getValue (t_diff_fld_name)
if last_target is None or transit_time == 0:
message = 'Skipping %s = %s' % (oid_fd_name, row_cur.getValue(oid_fd_name))
if transit_time == 0:
message = message + " Transit time is zero"
arcpy.AddMessage(message)
last_target = row_cur.getValue(target_fld)
last_oid = row_cur.getValue(oid_fd_name)
continue
arcpy.AddMessage ("Processing %s %i" % (oid_fd_name, row_cur.getValue(oid_fd_name)))
arcmgt.SelectLayerByAttribute(
feat_layer,
"NEW_SELECTION",
'%s = %s' % (target_fld, last_target)
)
backlink_rast = arcpy.CreateScratchName("backlink")
path_dist_rast = PathDistance(feat_layer, cost_rast, out_backlink_raster = backlink_rast)
# extract the distance from the last point
shp = row_cur.shape
centroid = shp.centroid
(x, y) = (centroid.X, centroid.Y)
result = arcmgt.GetCellValue(path_dist_rast, "%s %s" % (x, y), "1")
res_val = result.getOutput(0)
if res_val == "NoData":
this_oid = row_cur.getValue(oid_fd_name)
arcpy.AddMessage ("Got nodata for coordinate (%s, %s)" % (x, y))
arcpy.AddMessage ("Is the path between features %s and %s wholly contained by the cost raster?" % (last_oid, this_oid))
pras_name = "pth_%s_%s.tif" % (last_oid, this_oid)
arcpy.AddMessage ("Attempting to save path raster as %s" % pras_name)
try:
path_dist_rast.save(pras_name)
except Exception as e:
arcpy.AddMessage (e)
raise PathDistanceIsNoData
try:
path_distance = float (res_val)
except:
# kludge around locale/radix issues
if res_val.find(","):
res_val = res_val.replace(",", ".")
path_distance = float (res_val)
else:
raise
arcpy.AddMessage("Path distance is %s\nTransit time is %s" % (path_distance, transit_time))
# get a raster of the path from origin to destination
condition = '%s in (%i, %i)' % (oid_fd_name, last_oid, row_cur.getValue(oid_fd_name))
dest_layer = "dest_layer" + str (last_oid)
arcmgt.MakeFeatureLayer(in_file, dest_layer, where_clause = condition)
count = arcmgt.GetCount(dest_layer)
count = int (count.getOutput(0))
if count == 0:
raise NoFeatures("No features selected. Possible coordinate system issues.\n" + condition)
try:
path_cost_rast = CostPath(dest_layer, path_dist_rast, backlink_rast)
#path_dist_rast.save("xx_pr" + str (last_oid))
except Exception as e:
raise
try:
pcr_mask = 1 - IsNull (path_cost_rast)
#pcr_mask.save ("xx_pcr_mask" + str (last_oid))
dist_masked = path_dist_rast * pcr_mask
path_array = arcpy.RasterToNumPyArray(dist_masked, nodata_to_value = -9999)
path_array_idx = numpy.where(path_array > 0)
transit_array = numpy.zeros_like(path_array) # past experience suggests we might need to use a different approach to guarantee we get zeroes
except:
raise
path_sum = None
arcpy.AddMessage ("processing %i cells of path raster" % (len(path_array_idx[0])))
if path_distance == 0 or not len(path_array_idx[0]):
path_sum = 1 # stayed in the same cell
mask_array = arcpy.RasterToNumPyArray(pcr_mask, nodata_to_value = -9999)
mask_array_idx = numpy.where(mask_array == 1)
i = mask_array_idx[0][0]
j = mask_array_idx[1][0]
transit_array[i][j] = path_sum
else:
row_count = len (path_array)
col_count = len (path_array[0])
for idx in range (len(path_array_idx[0])):
i = path_array_idx[0][idx]
j = path_array_idx[1][idx]
val = path_array[i][j]
nbrs = []
for k in (i-1, i, i+1):
if k < 0 or k >= row_count:
continue
checkrow = path_array[k]
for l in (j-1, j, j+1):
if l < 0 or l >= col_count:
continue
if k == i and j == l:
continue # don't check self
checkval = checkrow[l]
# negs are nodata, and this way we
# don't need to care what that value is
if checkval >= 0:
diff = val - checkval
if diff > 0:
nbrs.append(diff)
#arcpy.AddMessage ("Check and diff vals are %s %s" % (checkval, diff))
diff = min (nbrs)
#arcpy.AddMessage ("Diff val is %s" % diff)
transit_array[i][j] = diff
path_sum = path_array.max() # could use path_distance?
#arcpy.AddMessage ("path_array.max is %s" % path_sum)
# sometimes we get a zero path_sum even when the path_distance is non-zero
if path_sum == 0:
path_sum = 1
# Increment the cumulative transit array by the fraction of the
# transit time spent in each cell.
# Use path_sum because it corrects for cases where we stayed in the same cell.
transit_array_accum = transit_array_accum + ((transit_array / path_sum) * transit_time)
#xx = arcpy.NumPyArrayToRaster (transit_array, lower_left_coord, cellsize_used, cellsize_used, 0)
#tmpname = "xx_t_arr_" + str (last_oid)
#print "Saving transit array to %s" % tmpname
#xx.save (tmpname)
try:
arcmgt.Delete(backlink_rast)
arcmgt.Delete(dest_layer)
except Exception as e:
arcpy.AddMessage (e)
# getting off-by-one errors when using the environment, so use this directly
ext = path_cost_rast.extent
lower_left_coord = ext.lowerLeft
last_target = row_cur.getValue(target_fld)
last_oid = row_cur.getValue(oid_fd_name)
# need to use env settings to get it to be the correct size
try:
arcpy.AddMessage ("lower left is %s" % lower_left_coord)
xx = arcpy.NumPyArrayToRaster (transit_array_accum, lower_left_coord, cellsize_used, cellsize_used, 0)
print "Saving to %s" % out_raster
xx.save (out_raster)
except:
raise
print "Completed"
return ()
raise e
feat = cur.newRow()
feat.shape = poly_pnt
#arcpy.AddMessage ("t_diff_fld_name = %s, t_diff_in_hours = %s" % (t_diff_fld_name, t_diff_in_hours))
for fld in fields:
name = name_dict[fld.name]
val = row.getValue(fld.name)
#arcpy.AddMessage ("name = %s, val = %s" % (name, val))
feat.setValue(name, val)
feat.ID = row_count
feat.setValue(t_diff_fld_name, t_diff_in_hours)
cur.insertRow(feat)
prev_time = this_time
count = arcmgt.GetCount(out_fc_name)
count = int(count.getOutput(0))
if count == 0:
arcpy.AddError("No features created - is there a file lock issue?")
arcpy.DefineProjection_management(out_fc_name, coord_sys)
print arcpy.GetMessages()
print "Completed"
def snap_points_to_mask_raster (in_file, mask, out_file, distance, workspace):
if distance is None or len (distance) == 0:
distance = "100 METERS"
if arcpy.env.outputCoordinateSystem is None:
arcpy.env.outputCoordinateSystem = mask
print arcpy.env.outputCoordinateSystem.name
if len(workspace):
arcpy.env.workspace = workspace
if arcpy.env.workspace is None or len(arcpy.env.workspace) == 0:
arcpy.env.workspace = os.getcwd()
arcpy.AddMessage ("workspace is %s" % arcpy.env.workspace)
try:
suffix = None
wk = arcpy.env.workspace
if not '.gdb' in wk:
suffix = '.shp'
poly_file = arcpy.CreateScratchName(None, suffix, 'POLYGON')
arcpy.RasterToPolygon_conversion (mask, poly_file, 'NO_SIMPLIFY')
except:
raise
arcpy.AddMessage ("poly_file is %s" % poly_file)
# handle layers and datasets
desc = arcpy.Describe(in_file)
in_file = desc.catalogPath
# add .shp extension if needed - clunky, but otherwise system fails below
re_gdb = re.compile ('\.gdb$')
re_shp = re.compile ('\.shp$')
path = os.path.dirname(out_file)
if len (path) == 0:
path = arcpy.env.workspace
if not re_gdb.search (path) and not re_shp.search (out_file):
out_file += '.shp'
arcpy.AddMessage ("Input point file is %s" % in_file)
arcpy.AddMessage ("Output point file is %s" % out_file)
arcmgt.CopyFeatures (in_file, out_file)
try:
snap_layer_name = 'get_layer_for_snapping'
arcmgt.MakeFeatureLayer (out_file, snap_layer_name)
arcmgt.SelectLayerByLocation (snap_layer_name, 'intersect', poly_file, '#', 'NEW_SELECTION')
arcmgt.SelectLayerByAttribute(snap_layer_name, 'SWITCH_SELECTION')
if arcmgt.GetCount(snap_layer_name) > 0:
arcpy.Snap_edit (snap_layer_name, [[poly_file, "EDGE", distance]])
else:
arcpy.AddMessage ('No features selected, no snapping applied')
except Exception as e:
print arcpy.GetMessages()
raise e
arcmgt.Delete (snap_layer_name)
arcmgt.Delete (poly_file)
print arcpy.GetMessages()
print "Completed"
return
polyZoLyr = "polyZoLayer"
# join the table from the raster to the poly zone layer
man.MakeFeatureLayer(polyZo, polyZoLyr)
man.AddJoin(polyZoLyr, "OBJECTID", curZo, "OBJECTID", "KEEP_ALL")
# find any polys with Richness below zone level
# each dict entry is [zone: min richness]
dictMinRich = {1: 1, 2: 2, 3: 5}
targMinRich = dictMinRich[int(classLevel)]
expr = "Richness >= " + str(targMinRich)
man.SelectLayerByAttribute(polyZoLyr, "NEW_SELECTION", expr)
# write out the selected set
outFeat = wrk + "/zon_Joined_C" + classLevel
man.CopyFeatures(polyZoLyr, outFeat)
# if rows were dropped AND we are above level 1, then need
# to add dropped polys to one level down.
numRowsSelSet = int(man.GetCount(polyZoLyr).getOutput(0))
numRowsLyr = int(man.GetCount(polyZo).getOutput(0))
if numRowsSelSet < numRowsLyr & int(classLevel) > 1:
expr = "Richness < " + str(targMinRich)
man.SelectLayerByAttribute(polyZoLyr, "NEW_SELECTION", expr)
destinedLevel = int(classLevel) - 1
# write out the selected set
outFeat = wrk + "/zon_AddThesePolysTo_C" + str(destinedLevel)
man.CopyFeatures(polyZoLyr, outFeat)
# if the prev if statement was acted on, then grab
# those data in the next loop
feats = arcpy.ListFeatureClasses()
primFeat = wrk + "/zon_Joined_C" + classLevel
outFeat = wrk + "/zon_Joined_final_C" + classLevel
targFeat = "zon_AddThesePolysTo_C" + classLevel
if targFeat in feats:
def classify_lakes(nhd,
out_feature_class,
exclude_intermit_flowlines=False,
debug_mode=False):
if debug_mode:
arcpy.env.overwriteOutput = True
temp_gdb = cu.create_temp_GDB('classify_lake_connectivity')
arcpy.env.workspace = temp_gdb
arcpy.AddMessage('Debugging workspace located at {}'.format(temp_gdb))
else:
arcpy.env.workspace = 'in_memory'
if arcpy.Exists("temp_fc"):
print("There is a problem here.")
raise Exception
# Tool temporary feature classes
temp_fc = "temp_fc"
csiwaterbody_10ha = "csiwaterbody_10ha"
nhdflowline_filtered = "nhdflowline_filtered"
dangles = "dangles"
start = "start"
end = "end"
startdangles = "startdangles"
enddangles = "enddangles"
non_artificial_end = "non_artificial_end"
flags_10ha_lake_junctions = "flags_10ha_lake_junctions"
midvertices = "midvertices"
non10vertices = "non10vertices"
non10junctions = "non10junctions"
all_non_flag_points = "all_non_flag_points"
barriers = "barriers"
trace1_junctions = "trace1_junctions"
trace1_flowline = "trace1_flowline"
trace2_junctions = "trace2junctions"
trace2_flowline = "trace2_flowline"
# Clean up workspace in case of bad exit from prior run in same session.
this_tool_layers = [
"dangles_lyr", "nhdflowline_lyr", "junction_lyr", "midvertices_lyr",
"all_non_flag_points_lyr", "non10vertices_lyr", "out_fc_lyr", "trace1",
"trace2"
]
this_tool_temp = [
temp_fc, csiwaterbody_10ha, nhdflowline_filtered, dangles, start, end,
startdangles, enddangles, non_artificial_end,
flags_10ha_lake_junctions, midvertices, non10vertices, non10junctions,
all_non_flag_points, barriers, trace1_junctions, trace1_flowline,
trace2_junctions, trace2_flowline
]
for item in this_tool_layers + this_tool_temp:
try:
DM.Delete(item)
except:
pass
# Local variables:
nhdflowline = os.path.join(nhd, "Hydrography", "NHDFLowline")
nhdjunction = os.path.join(nhd, "Hydrography", "HYDRO_NET_Junctions")
nhdwaterbody = os.path.join(nhd, "Hydrography", "NHDWaterbody")
network = os.path.join(nhd, "Hydrography", "HYDRO_NET")
# Get lakes, ponds and reservoirs over a hectare.
#csi_population_filter = '''"AreaSqKm" >=0.01 AND\
#"FCode" IN (39000,39004,39009,39010,39011,39012,43600,43613,43615,43617,43618,43619,43621)'''
all_lakes_reservoirs_filter = '''"FType" IN (390, 436)'''
# Can't see why we shouldn't just attribute all lakes and reservoirs
# arcpy.Select_analysis(nhdwaterbody, "csiwaterbody", lake_population_filter)
arcpy.AddMessage("Initializing output.")
if exclude_intermit_flowlines:
DM.CopyFeatures(out_feature_class, temp_fc)
DM.Delete(out_feature_class)
else:
arcpy.Select_analysis(nhdwaterbody, temp_fc,
all_lakes_reservoirs_filter)
# Get lakes, ponds and reservoirs over 10 hectares.
lakes_10ha_filter = '''"AreaSqKm" >= 0.1 AND "FType" IN (390, 436)'''
arcpy.Select_analysis(nhdwaterbody, csiwaterbody_10ha, lakes_10ha_filter)
# Exclude intermittent flowlines, if requested
if exclude_intermit_flowlines:
flowline_where_clause = '''"FCode" NOT IN (46003,46007)'''
nhdflowline = arcpy.Select_analysis(nhdflowline, nhdflowline_filtered,
flowline_where_clause)
# Make dangle points at end of nhdflowline
DM.FeatureVerticesToPoints(nhdflowline, dangles, "DANGLE")
DM.MakeFeatureLayer(dangles, "dangles_lyr")
# Isolate start dangles from end dangles.
DM.FeatureVerticesToPoints(nhdflowline, start, "START")
DM.FeatureVerticesToPoints(nhdflowline, end, "END")
DM.SelectLayerByLocation("dangles_lyr", "ARE_IDENTICAL_TO", start)
DM.CopyFeatures("dangles_lyr", startdangles)
DM.SelectLayerByLocation("dangles_lyr", "ARE_IDENTICAL_TO", end)
DM.CopyFeatures("dangles_lyr", enddangles)
# Special handling for lakes that have some intermittent flow in and some permanent
if exclude_intermit_flowlines:
DM.MakeFeatureLayer(nhdflowline, "nhdflowline_lyr")
DM.SelectLayerByAttribute("nhdflowline_lyr", "NEW_SELECTION",
'''"WBArea_Permanent_Identifier" is null''')
DM.FeatureVerticesToPoints("nhdflowline_lyr", non_artificial_end,
"END")
DM.SelectLayerByAttribute("nhdflowline_lyr", "CLEAR_SELECTION")
arcpy.AddMessage("Found source area nodes.")
# Get junctions from lakes >= 10 hectares.
DM.MakeFeatureLayer(nhdjunction, "junction_lyr")
DM.SelectLayerByLocation("junction_lyr", "INTERSECT", csiwaterbody_10ha,
XY_TOLERANCE, "NEW_SELECTION")
DM.CopyFeatures("junction_lyr", flags_10ha_lake_junctions)
arcpy.AddMessage("Found lakes >= 10 ha.")
# Make points shapefile and layer at flowline vertices to act as potential flags and/or barriers.
arcpy.AddMessage("Tracing...")
DM.FeatureVerticesToPoints(nhdflowline, midvertices, "MID")
DM.MakeFeatureLayer(midvertices, "midvertices_lyr")
# Get vertices that are not coincident with 10 hectare lake junctions.
DM.SelectLayerByLocation("midvertices_lyr", "INTERSECT",
flags_10ha_lake_junctions, "", "NEW_SELECTION")
DM.SelectLayerByLocation("midvertices_lyr", "INTERSECT",
flags_10ha_lake_junctions, "", "SWITCH_SELECTION")
DM.CopyFeatures("midvertices_lyr", non10vertices)
# Get junctions that are not coincident with 10 hectare lake junctions.
DM.SelectLayerByLocation("junction_lyr", "INTERSECT",
flags_10ha_lake_junctions, "", "NEW_SELECTION")
DM.SelectLayerByLocation("junction_lyr", "INTERSECT",
flags_10ha_lake_junctions, "", "SWITCH_SELECTION")
DM.CopyFeatures("junction_lyr", non10junctions)
# Merge non10vertices with non10junctions
DM.Merge([non10junctions, non10vertices],
all_non_flag_points) # inputs both point fc in_memory
DM.MakeFeatureLayer(all_non_flag_points, "all_non_flag_points_lyr")
# Tests the counts...for some reason I'm not getting stable behavior from the merge.
mid_n = int(DM.GetCount(non10vertices).getOutput(0))
jxn_n = int(DM.GetCount(non10junctions).getOutput(0))
merge_n = int(DM.GetCount(all_non_flag_points).getOutput(0))
if merge_n < mid_n + jxn_n:
arcpy.AddWarning(
"The total number of flags ({0}) is less than the sum of the input junctions ({1}) "
"and input midpoints ({2})".format(merge_n, jxn_n, mid_n))
# For tracing barriers, select all_non_flag_points points that intersect a 10 ha lake.
DM.SelectLayerByLocation("all_non_flag_points_lyr", "INTERSECT",
csiwaterbody_10ha, XY_TOLERANCE, "NEW_SELECTION")
DM.CopyFeatures("all_non_flag_points_lyr", barriers)
# Trace1-Trace downstream to first barrier (junctions+midvertices in 10 ha lake) starting from flags_10ha_lake_junctions flag points.
DM.TraceGeometricNetwork(network, "trace1", flags_10ha_lake_junctions,
"TRACE_DOWNSTREAM", barriers)
# Save trace1 flowlines and junctions to layers on disk.
DM.CopyFeatures("trace1\HYDRO_NET_Junctions",
trace1_junctions) # extra for debugging
DM.CopyFeatures("trace1\NHDFlowline", trace1_flowline)
# Select vertice midpoints that intersect trace1 flowlines selection for new flags for trace2.
DM.MakeFeatureLayer(non10vertices, "non10vertices_lyr")
DM.SelectLayerByLocation("non10vertices_lyr", "INTERSECT", trace1_flowline,
"", "NEW_SELECTION")
# Trace2-Trace downstream from midpoints of flowlines that intersect the selected flowlines from trace1.
DM.TraceGeometricNetwork(network, "trace2", "non10vertices_lyr",
"TRACE_DOWNSTREAM")
# Save trace1 flowlines and junctions to layers and then shapes on disk.
DM.CopyFeatures("trace2\HYDRO_NET_Junctions", trace2_junctions)
DM.CopyFeatures("trace2\NHDFlowline",
trace2_flowline) # extra for debugging
arcpy.AddMessage("Done tracing.")
# Make shapefile for seepage lakes. (Ones that don't intersect flowlines)
if exclude_intermit_flowlines:
class_field_name = "Lake_Connectivity_Permanent"
else:
class_field_name = "Lake_Connectivity_Class"
DM.AddField(temp_fc, class_field_name, "TEXT", field_length=13)
DM.MakeFeatureLayer(temp_fc, "out_fc_lyr")
DM.SelectLayerByLocation("out_fc_lyr", "INTERSECT", nhdflowline,
XY_TOLERANCE, "NEW_SELECTION")
DM.SelectLayerByLocation("out_fc_lyr", "INTERSECT", nhdflowline, "",
"SWITCH_SELECTION")
DM.CalculateField("out_fc_lyr", class_field_name, """'Isolated'""",
"PYTHON")
# New type of "Isolated" classification, mostly for "permanent" but there were some oddballs in "maximum" too
DM.SelectLayerByLocation("out_fc_lyr", "INTERSECT", startdangles,
XY_TOLERANCE, "NEW_SELECTION")
DM.SelectLayerByLocation("out_fc_lyr", "INTERSECT", enddangles,
XY_TOLERANCE, "SUBSET_SELECTION")
DM.CalculateField("out_fc_lyr", class_field_name, """'Isolated'""",
"PYTHON")
# Get headwater lakes.
DM.SelectLayerByLocation("out_fc_lyr", "INTERSECT", startdangles,
XY_TOLERANCE, "NEW_SELECTION")
DM.SelectLayerByAttribute(
"out_fc_lyr", "REMOVE_FROM_SELECTION",
'''"{}" = 'Isolated' '''.format(class_field_name))
DM.CalculateField("out_fc_lyr", class_field_name, """'Headwater'""",
"PYTHON")
# Select csiwaterbody that intersect trace2junctions
arcpy.AddMessage("Beginning connectivity attribution...")
DM.SelectLayerByLocation("out_fc_lyr", "INTERSECT", trace2_junctions,
XY_TOLERANCE, "NEW_SELECTION")
DM.CalculateField("out_fc_lyr", class_field_name, """'DrainageLk'""",
"PYTHON")
# Get stream drainage lakes. Either unassigned so far or convert "Headwater" if a permanent stream flows into it,
# which is detected with "non_artificial_end"
DM.SelectLayerByAttribute("out_fc_lyr", "NEW_SELECTION",
'''"{}" IS NULL'''.format(class_field_name))
DM.CalculateField("out_fc_lyr", class_field_name, """'Drainage'""",
"PYTHON")
if exclude_intermit_flowlines:
DM.SelectLayerByAttribute(
"out_fc_lyr", "NEW_SELECTION",
'''"{}" = 'Headwater' '''.format(class_field_name))
DM.SelectLayerByLocation("out_fc_lyr", "INTERSECT", non_artificial_end,
XY_TOLERANCE, "SUBSET_SELECTION")
DM.CalculateField("out_fc_lyr", class_field_name, """'Drainage'""",
"PYTHON")
# Prevent 'upgrades' due to very odd flow situations and artifacts of bad digitization. The effects of these
# are varied--to avoid confusion, just keep the class assigned with all flowlines
# 1--Purely hypothetical, not seen in testing
DM.SelectLayerByAttribute(
"out_fc_lyr", "NEW_SELECTION",
'''"Lake_Connectivity_Class" = 'Isolated' AND "Lake_Connectivity_Permanent" <> 'Isolated' '''
)
DM.CalculateField("out_fc_lyr", class_field_name, """'Isolated'""",
"PYTHON")
# 2--Headwater to Drainage upgrade seen in testing with odd multi-inlet flow situation
DM.SelectLayerByAttribute(
"out_fc_lyr", "NEW_SELECTION",
'''"Lake_Connectivity_Class" = 'Headwater' AND "Lake_Connectivity_Permanent" IN ('Drainage', 'DrainageLk') '''
)
DM.CalculateField("out_fc_lyr", class_field_name, """'Headwater'""",
"PYTHON")
# 3--Drainage to DrainageLk upgrade seen in testing when intermittent stream segments were used
# erroneously instead of artificial paths
DM.SelectLayerByAttribute(
"out_fc_lyr", "NEW_SELECTION",
'''"Lake_Connectivity_Class" = 'Drainage' AND "Lake_Connectivity_Permanent" = 'DrainageLk' '''
)
DM.CalculateField("out_fc_lyr", class_field_name, """'Drainage'""",
"PYTHON")
DM.SelectLayerByAttribute("out_fc_lyr", "CLEAR_SELECTION")
# Add change flag for users
DM.AddField(temp_fc,
"Lake_Connectivity_Fluctuates",
"Text",
field_length="1")
flag_codeblock = """def flag_calculate(arg1, arg2):
if arg1 == arg2:
return 'N'
else:
return 'Y'"""
expression = 'flag_calculate(!Lake_Connectivity_Class!, !Lake_Connectivity_Permanent!)'
DM.CalculateField(temp_fc, "Lake_Connectivity_Fluctuates", expression,
"PYTHON", flag_codeblock)
# Project output once done with both. Switching CRS earlier causes trace problems.
if not exclude_intermit_flowlines:
DM.CopyFeatures(temp_fc, out_feature_class)
else:
DM.Project(temp_fc, out_feature_class, arcpy.SpatialReference(102039))
# Clean up
if not debug_mode:
for item in this_tool_layers + this_tool_temp:
if arcpy.Exists(item):
DM.Delete(item)
if not debug_mode:
DM.Delete("trace1")
DM.Delete("trace2")
arcpy.AddMessage("{} classification is complete.".format(class_field_name))