def main():
# GET PARAMETER VALUES
Map_Units_Provided = arcpy.GetParameterAsText(0)
Transects_Provided = arcpy.GetParameterAsText(1) # optional
Project_Folder = arcpy.GetParameterAsText(2)
Project_Name = arcpy.GetParameterAsText(3) # optional
# DEFINE DIRECTORIES
# Get the pathname to this script
scriptPath = sys.path[0]
arcpy.AddMessage("Script folder: " + scriptPath)
arcpy.AddMessage("Python version: " + sys.version)
# Construct pathname to workspace
projectGDB = arcpy.Describe(Map_Units_Provided).path
arcpy.AddMessage("Project geodatabase: " + projectGDB)
# Instantiate a idStandard object
cheStandard = cohqt.cheStandard(projectGDB, scriptPath)
# ENVIRONMENT SETTINGS
# Set workspaces
arcpy.env.workspace = projectGDB
scratch_folder = os.path.join(arcpy.Describe(projectGDB).path, 'scratch')
if arcpy.Exists(scratch_folder):
pass
else:
arcpy.CreateFolder_management(
arcpy.Describe(projectGDB).path, 'scratch')
arcpy.env.scratchWorkspace = scratch_folder
# Overwrite outputs
arcpy.env.overwriteOutput = True
# DEFINE GLOBAL VARIABLES
# Filenames for feature classes or rasters used by this script
MAP_UNITS = "Map_Units"
# Filenames for feature classes or rasters created by this script
TRANSECTS_SJ = "Transects_SpatialJoin"
# ------------------------------------------------------------------------
# FUNCTION CALLS
# Check Map_Units_Dissolve layer
required_fields = ["Transects"]
no_null_fields = None
expected_fcs = None
hqtlib.CheckPolygonInput(Map_Units_Provided, required_fields, expected_fcs,
no_null_fields)
# Update Map Units layer with provided layer and add to map
Map_Units = util.AdoptParameter(Map_Units_Provided,
MAP_UNITS,
preserve_existing=False)
layerFile = cheStandard.getLayerFile("MapUnits.lyr")
util.AddToMap(Map_Units, layerFile)
if Transects_Provided:
# Update message
arcpy.AddMessage("Executing spatial join of Transects and "
"Map_Unit_Dissolve layer")
out_name = TRANSECTS_SJ
transects = Transects_Provided
hqtlib.TransectJoin(Map_Units, transects, out_name)
else:
# arcpy.AddError("ERROR:: Please provide the transects feature"
# "class or shapefile provided by the SETT")
# sys.exit(0)
# Check out Spatial Analyst extension
hqtlib.CheckOutSpatialAnalyst()
# Generate transects
field_name = "Transects"
out_name = "Transects"
transects = hqtlib.GenerateTransects(projectGDB, Map_Units, field_name,
out_name)
# Add transect fields
hqtlib.AddTransectFields(transects)
util.AddToMap(out_name)
# Identify the map unit associated with each transect
out_name = TRANSECTS_SJ
transects = transects
hqtlib.TransectJoin(Map_Units, transects, out_name)
# Remove unnecessary fields
allowable_fields = [
"Bearing1", "Bearing2", "Bearing3", "UTM_E", "UTM_N", "Map_Unit_ID",
"Map_Unit_Name", "Precip", "Transects"
]
util.SimplifyFields(TRANSECTS_SJ, allowable_fields)
# Add Transects to map
util.AddToMap(TRANSECTS_SJ)
# Export data to Excel
table = TRANSECTS_SJ
hqtlib.ExportToExcel(table, Project_Folder, Project_Name)
# Save map document and exit
if arcpy.ListInstallations()[0] == 'arcgispro':
p = arcpy.mp.ArcGISProject("CURRENT")
p.save()
else:
mxd = arcpy.mapping.MapDocument("CURRENT")
mxd.save()
def main():
# GET PARAMETER VALUES
Map_Units_Dissolve_Provided = arcpy.GetParameterAsText(0)
Transects_Provided = arcpy.GetParameterAsText(1) # optional
Project_Folder = arcpy.GetParameterAsText(2)
Project_Name = arcpy.GetParameterAsText(3) # optional
# DEFINE DIRECTORIES & PATH NAMES FOR FOLDERS & GBDs
# Get the pathname to this script
scriptPath = sys.path[0]
arcpy.AddMessage("Script folder: " + scriptPath)
# Construct pathname to workspace
projectGDB = arcpy.Describe(Map_Units_Dissolve_Provided).path
arcpy.AddMessage("Project geodatabase: " + projectGDB)
# ENVIRONMENT SETTINGS
# Set workspaces
arcpy.env.workspace = projectGDB
scratch_folder = os.path.join(arcpy.Describe(projectGDB).path, 'scratch')
if arcpy.Exists(scratch_folder):
pass
else:
arcpy.CreateFolder_management(
arcpy.Describe(projectGDB).path, 'scratch')
arcpy.env.scratchWorkspace = scratch_folder
# Overwrite outputs
arcpy.env.overwriteOutput = True
# DEFINE GLOBAL VARIABLES
# Filenames for feature classes or rasters used by this script
MAP_UNITS_DISSOLVE = "Map_Units_Dissolve"
# Filenames for feature classes or rasters created by this script
TRANSECTS_SJ = "Transects_SpatialJoin"
# ------------------------------------------------------------------------
# FUNCTION CALLS
if Transects_Provided:
# Update message
arcpy.AddMessage("Executing spatial join of Transects and "
"Map_Unit_Dissolve layer")
# hqtlib.AddTransectFields(Transects)
Map_Units_Dissolve = MAP_UNITS_DISSOLVE
out_name = TRANSECTS_SJ
hqtlib.TransectJoin(Map_Units_Dissolve, Transects_Provided, out_name)
else:
# arcpy.AddError("ERROR:: Please provide the transects feature "
# "class or shapefile. See User's Guide.")
# sys.exit(0)
# Check out Spatial Analyst extension
hqtlib.CheckOutSpatialAnalyst()
# Check Map_Units_Dissolve layer
required_fields = ["Transects"]
no_null_fields = ["Transects"]
expected_fcs = None
hqtlib.CheckPolygonInput(Map_Units_Dissolve_Provided, required_fields,
expected_fcs, no_null_fields)
Map_Units = Map_Units_Dissolve_Provided
field_name = "Transects"
out_name = "Transects"
transects = hqtlib.GenerateTransects(
projectGDB, Map_Units, field_name,
out_name) ##swapped "workspace" for "project GDB"
hqtlib.AddTransectFields(transects)
# Identify the map unit associated with each transect
hqtlib.TransectJoin(MAP_UNITS_DISSOLVE, transects, TRANSECTS_SJ)
# Remove unnecessary fields
allowable_fields = [
"Bearing1", "Bearing2", "Bearing3", "UTM_E", "UTM_N", "Map_Unit_ID",
"Map_Unit_Name", "Indirect", "Acres", "PropLek", "PropMesic",
"Current_Breed", "Current_Summer", "Current_Winter", "Projected_Breed",
"Projected_Summer", "Projected_Winter", "Permanent_Breed",
"Permanent_Summer", "Permanent_Winter", "Transects"
]
util.SimplifyFields(TRANSECTS_SJ, allowable_fields)
# Add Transects to map
util.AddToMap(TRANSECTS_SJ)
# Export data to Excel
table = TRANSECTS_SJ
hqtlib.ExportToExcel(table, Project_Folder, Project_Name)
# Save map document
if arcpy.ListInstallations()[0] == 'arcgispro':
p = arcpy.mp.ArcGISProject("CURRENT")
p.save()
else:
mxd = arcpy.mapping.MapDocument("CURRENT")
mxd.save()
def main():
# GET PARAMETER VALUES
Map_Units_Provided = arcpy.GetParameterAsText(0) # optional
Proposed_Modified_Features_Provided = arcpy.GetParameterAsText(
1) # optional
Project_Name = arcpy.GetParameterAsText(2)
# DEFINE DIRECTORIES
# Get the pathname to this script
scriptPath = sys.path[0]
arcpy.AddMessage("Script folder: " + scriptPath)
arcpy.AddMessage("Python version: " + sys.version)
# Construct pathname to workspace
if Map_Units_Provided:
projectGDB = arcpy.Describe(Map_Units_Provided).path
elif Proposed_Modified_Features_Provided:
projectGDB = arcpy.Describe(Proposed_Modified_Features_Provided).path
else:
arcpy.AddMessage("Please provide either a Map_Units or " +
"Proposed_Modified_Features layer.")
sys.exit(0)
arcpy.AddMessage("Project geodatabase: " + projectGDB)
Project_Folder = arcpy.Describe(projectGDB).path
arcpy.AddMessage("Project folder:" + Project_Folder)
# Instantiate a cheStandard object
cheStandard = cohqt.cheStandard(projectGDB, scriptPath)
# ENVIRONMENT SETTINGS
# Set workspaces
arcpy.env.workspace = projectGDB
scratch_folder = os.path.join(arcpy.Describe(projectGDB).path, 'scratch')
if arcpy.Exists(scratch_folder):
pass
else:
arcpy.CreateFolder_management(
arcpy.Describe(projectGDB).path, 'scratch')
arcpy.env.scratchWorkspace = scratch_folder
# Overwrite outputs
arcpy.env.overwriteOutput = True
# DEFINE GLOBAL VARIABLES
Parameter_Values = cheStandard.ParameterValues
ConiferModifier = cheStandard.ConiferModifier
GrSG_LDI = cheStandard.GrSG_LDI
LekPresenceRaster = cheStandard.LekPresenceRaster
Lek_Distance_Modifier = cheStandard.LekDistanceModifier
SageModifier = cheStandard.SageModifier
GrSG_Habitat = cheStandard.GrSGHabitatRaster
MigrationModifier = cheStandard.MuleDeerMigrationMod
WinterModifier = cheStandard.MuleDeerWinterMod
SummerModifier = cheStandard.MuleDeerSummerMod
MuleDeer_LDI = cheStandard.MuleDeerLDI
emptyRaster = cheStandard.EmptyRaster
BWMD_Open = cheStandard.BWMD_Open
GrSG_Range = cheStandard.GrSGHabitat
Mule_Range = cheStandard.MuleDeerHabitat
cellSize = arcpy.GetRasterProperties_management(emptyRaster,
"CELLSIZEX").getOutput(0)
# Filenames for feature classes or rasters used by this script
MAP_UNITS = "Map_Units"
PROPOSED_MODIFIED_FEATURES = "Proposed_Modified_Features"
CREDIT_PROJECT_AREA = "Credit_Project_Area"
CONIFER_TREATMENT_AREA = "Conifer_Treatment_Area"
# Filenames for feature class and rasters created by this script
INDIRECT_IMPACT_AREA = "Indirect_Impact_Area"
ANALYSIS_AREA = "Analysis_Area"
MAP_UNITS_DISSOLVE = "Map_Units_Dissolve"
# GrSG Filenames
CURRENT_ANTHRO_DISTURBANCE = "GRSG_Pre_Anthro_Disturbance"
PROJECTED_ANTHRO_DISTURBANCE = "GRSG_Post_Anthro_Disturbance"
GRSG_PRE_BREEDING = "GRSG_Pre_Breeding"
GRSG_PRE_SUMMER = "GRSG_Pre_Summer"
GRSG_PRE_WINTER = "GRSG_Pre_Winter"
GRSG_POST_BREEDING = "GRSG_Post_Breeding"
GRSG_POST_SUMMER = "GRSG_Post_Summer"
GRSG_POST_WINTER = "GRSG_Post_Winter"
POST_CONIFER_MODIFIER = "Post_Conifer_Modifier"
# Mule Deer Filenames
CURRENT_ANTHRO_DISTURBANCE_MD = "MuleDeer_Pre_Anthro_Disturbance"
PROJECTED_ANTHRO_DISTURBANCE_MD = "MuleDeer_Post_Anthro_Disturbance"
MULE_PRE_SUMMER = "MuleDeer_Pre_Summer"
MULE_PRE_MIGRATION = "MuleDeer_Pre_Migration"
MULE_PRE_WINTER = "MuleDeer_Pre_Winter"
MULE_POST_SUMMER = "MuleDeer_Post_Summer"
MULE_POST_MIGRATION = "MuleDeer_Post_Migration"
MULE_POST_WINTER = "MuleDeer_Post_Winter"
# ------------------------------------------------------------------------
# FUNCTION CALLS
# Check out Spatial Analyst extension
hqtlib.CheckOutSpatialAnalyst()
# Check provided layers
if not Map_Units_Provided and not Proposed_Modified_Features_Provided:
arcpy.AddError("ERROR:: Please provide a 'Map_Units' and/or "
"'Proposed_Modified_Features' feature.")
sys.exit(0)
if not Proposed_Modified_Features_Provided:
# Ensure Proposed_Modified_Features does not exist
if arcpy.Exists("Proposed_Modified_Features"):
arcpy.AddError("ERROR:: A 'Proposed_Modified_Features' layer "
"was detected in the project's geodatabase. "
"Provide the 'Proposed_Modified_Features' layer "
"and re-run Credit Tool 2.")
sys.exit(0)
if Map_Units_Provided:
# Clear selection, if present
util.ClearSelectedFeatures(Map_Units_Provided)
# Check provided layer
feature = Map_Units_Provided
required_fields = ["Map_Unit_ID", "Map_Unit_Name"]
no_null_fields = ["Map_Unit_ID"]
expected_fcs = [CREDIT_PROJECT_AREA]
hqtlib.CheckPolygonInput(feature, required_fields, expected_fcs,
no_null_fields)
# Update Map Units layer with provided layer
provided_input = Map_Units_Provided
parameter_name = MAP_UNITS
preserve_existing = False
Map_Units = util.AdoptParameter(provided_input, parameter_name,
preserve_existing)
# Add Map Units layer to map
layerFile = cheStandard.getLayerFile("MapUnits.lyr")
util.AddToMap(Map_Units, layerFile)
# Provide location of Credit Project Area
Credit_Project_Area = CREDIT_PROJECT_AREA
if Proposed_Modified_Features_Provided:
# Clear selection, if present
util.ClearSelectedFeatures(Proposed_Modified_Features_Provided)
# Check provided layer
required_fields = ["Type", "Subtype"]
no_null_fields = required_fields
expected_fcs = None
hqtlib.CheckPolygonInput(Proposed_Modified_Features_Provided,
required_fields, expected_fcs, no_null_fields)
# Update Proposed_Modified_Features with provided layer
provided_input = Proposed_Modified_Features_Provided
parameterName = PROPOSED_MODIFIED_FEATURES
preserve_existing = False
Proposed_Modified_Features = util.AdoptParameter(
provided_input, parameterName, preserve_existing)
# Add Proposed Modified Features layer to map
layerFile = cheStandard.getLayerFile("DebitProjectArea.lyr")
util.AddToMap(Proposed_Modified_Features, layerFile)
# Update message
arcpy.AddMessage("Creating the area of indirect benefit")
# Create Credit_Project_Area for projects that propose to modify
# anthropogenic features
# Create the Indirect_Impact_Area
in_data = Proposed_Modified_Features
out_name = INDIRECT_IMPACT_AREA
Indirect_Impact_Area = hqtlib.CreateIndirectImpactArea(
in_data, Parameter_Values, out_name)
# Add field "Indirect"
input_feature = Indirect_Impact_Area
fieldsToAdd = ["Indirect"]
fieldTypes = ["TEXT"]
util.AddFields(input_feature, fieldsToAdd, fieldTypes)
# Update field 'Indirect' to equal 'True'
with arcpy.da.UpdateCursor(Indirect_Impact_Area,
fieldsToAdd) as cursor:
for row in cursor:
row[0] = "True"
cursor.updateRow(row)
if Map_Units_Provided:
# Merge with Credit_Project_Boundary
fileList = [Map_Units_Provided, Indirect_Impact_Area]
out_name = "in_memory/Credit_Project_Boundary"
Project_Area = arcpy.Union_analysis(fileList, out_name)
else:
Project_Area = Indirect_Impact_Area
# Eliminate areas of non-habitat to create Credit_Project_Area
out_name = CREDIT_PROJECT_AREA
habitat_bounds = cheStandard.HabitatMgmtArea
Credit_Project_Area = hqtlib.EliminateNonHabitat(
Project_Area, out_name, habitat_bounds)
# Detect habitat types impacted directly or indirectly
is_grsg = cohqt.DetectHabitat(Credit_Project_Area, GrSG_Range)
is_mule = cohqt.DetectHabitat(Credit_Project_Area, Mule_Range)
# Update message
arcpy.AddMessage("Dissolving all multi-part map units to create "
"Map_Units_Dissolve")
# Dissolve Map Units
in_features = MAP_UNITS
allowable_fields = ["Map_Unit_ID", "Map_Unit_Name", "Indirect"]
out_name = MAP_UNITS_DISSOLVE
anthro_features = None
Map_Units_Dissolve = hqtlib.DissolveMapUnits(in_features, allowable_fields,
out_name, anthro_features)
# Update message
arcpy.AddMessage("Adding Map_Units_Dissolve to map")
# Add layer to map document
feature = Map_Units_Dissolve
layerFile = cheStandard.getLayerFile("MapUnits.lyr")
util.AddToMap(feature, layerFile, zoom_to=True)
# Update message
arcpy.AddMessage("Calculating area in acres for each map unit")
# Calculate Area
hqtlib.CalcAcres(Map_Units_Dissolve)
# Update message
arcpy.AddMessage("Adding transect field to Map Units Dissolve")
# Add transects field to map units table
fields = ["Transects"]
fieldTypes = ["SHORT"]
util.AddFields(Map_Units_Dissolve, fields, fieldTypes)
# Update message
arcpy.AddMessage("Creating Analysis Area")
# Create Analysis Area
out_name = ANALYSIS_AREA
Analysis_Area = hqtlib.CreateAnalysisArea(Credit_Project_Area,
Parameter_Values, out_name)
# Add Analysis_Area to map
layerFile = cheStandard.getLayerFile("AnalysisArea.lyr")
util.AddToMap(Analysis_Area, layerFile, zoom_to=True)
# Set processing extent to Analysis_Area
arcpy.env.extent = ANALYSIS_AREA
### GREATER SAGE-GROUSE ANTHRO DIST & MODIFIERS ###
if is_grsg:
# Update message
arcpy.AddMessage("Calculating proportion of each map unit within 1 km "
"of a lek")
# Calculate proportion of map unit within 1 km of a lek
inZoneData = Map_Units_Dissolve
inValueRaster = cheStandard.LekPresenceRaster
zoneField = "Map_Unit_ID"
outTable = "Proportion_Lek"
hqtlib.CalcZonalStats(inZoneData, zoneField, inValueRaster, outTable)
# Join the zonal statistic to the Map Units Dissolve table
field_name = "PropLek"
hqtlib.JoinMeanToTable(inZoneData, outTable, zoneField, field_name)
# Update message
arcpy.AddMessage(
"Calculating proportion of each map unit in the mesic "
"precip zone")
# Calculate Proportion of each map unit in the mesic precip zone
inZoneData = Map_Units_Dissolve
inValueRaster = cheStandard.Precip
zoneField = "Map_Unit_ID"
outTable = "Proportion_Mesic"
hqtlib.CalcZonalStats(inZoneData, zoneField, inValueRaster, outTable)
# Join the zonal statistic to the Map Units Dissolve table
field_name = "PropMesic"
hqtlib.JoinMeanToTable(inZoneData, outTable, zoneField, field_name)
# Update message
arcpy.AddMessage("Calculating pre-project anthropogenic "
"disturbance modifier for greater sage-grouse")
# Calculate Current_Anthro_Disturbance
dist_field = "GrSG_Dist"
weight_field = "GrSG_Weight"
term = cheStandard.CreditTerms[0]
unique_proposed_subtypes = []
anthro_disturbance_type = "Pre"
Current_Anthro_Disturbance = cohqt.CalcAnthroDisturbance(
Parameter_Values, term, unique_proposed_subtypes,
anthro_disturbance_type, cheStandard, dist_field, weight_field,
cellSize, emptyRaster)
Current_Anthro_Disturbance.save(CURRENT_ANTHRO_DISTURBANCE)
# Update message
arcpy.AddMessage("Current_Anthro_Disturbance Calculated")
arcpy.AddMessage("Calculating Pre-Project Habitat Modifiers for"
"Greater Sage-Grouse")
# Calculate pre-project cumulative habitat modifiers
winterHabitatPre = cohqt.calcWinterHabitatGRSG(
Current_Anthro_Disturbance, ConiferModifier, GrSG_LDI,
GrSG_Habitat)
LSDMWinterPre = cohqt.applyLekUpliftModifierPre(
winterHabitatPre, LekPresenceRaster)
breedingHabitatPre = cohqt.calcBreedingHabitatGRSG(
Current_Anthro_Disturbance, ConiferModifier, GrSG_LDI,
Lek_Distance_Modifier, GrSG_Habitat)
LSDMBreedingPre = cohqt.applyLekUpliftModifierPre(
breedingHabitatPre, LekPresenceRaster)
summerHabitatPre = cohqt.calcSummerHabitatGRSG(
Current_Anthro_Disturbance, ConiferModifier, GrSG_LDI,
SageModifier, GrSG_Habitat)
LSDMSummerPre = cohqt.applyLekUpliftModifierPre(
summerHabitatPre, LekPresenceRaster)
seasonalHabitatRasters = [
LSDMWinterPre, LSDMBreedingPre, LSDMSummerPre
]
# Save outputs
# winterHabitatPre.save(GRSG_PRE_WINTER)
LSDMWinterPre.save(GRSG_PRE_WINTER)
# breedingHabitatPre.save(GRSG_PRE_BREEDING)
LSDMBreedingPre.save(GRSG_PRE_BREEDING)
# summerHabitatPre.save(GRSG_PRE_SUMMER)
LSDMSummerPre.save(GRSG_PRE_SUMMER)
# Initialize list of uplift rasters to combine for LekUpliftModifier
upliftRasters = []
if arcpy.Exists(CONIFER_TREATMENT_AREA):
# Calculate post-project conifer modifier
Conifer_Cover = cheStandard.ConiferCover
coniferModifierPost = cohqt.calcConiferPost(
CONIFER_TREATMENT_AREA, Conifer_Cover)
coniferModifierPost.save(POST_CONIFER_MODIFIER)
# Calculate uplift from conifer removal
coniferUplift = cohqt.calcUplift(ConiferModifier,
coniferModifierPost)
upliftRasters.append(coniferUplift)
else:
coniferModifierPost = ConiferModifier
if arcpy.Exists(PROPOSED_MODIFIED_FEATURES):
# Prepare proposed anthropogenic features
unique_proposed_subtypes = cohqt.convertProposedToRasterCredit(
PROPOSED_MODIFIED_FEATURES, cellSize)
anthroPath = cheStandard.AnthroFeaturePath
cohqt.combineProposedWithCurrentCredit(anthroPath,
unique_proposed_subtypes)
# Update message
arcpy.AddMessage("Calculating post-project anthropogenic "
"disturbance modifier for greater sage-grouse")
# Calculate post-project anthropogenic disturbance
term = cheStandard.CreditTerms[1]
anthro_disturbance_type = "Post"
Projected_Anthro_Disturbance = cohqt.CalcAnthroDisturbance(
Parameter_Values, term, unique_proposed_subtypes,
anthro_disturbance_type, cheStandard, dist_field, weight_field,
cellSize, emptyRaster)
Projected_Anthro_Disturbance.save(PROJECTED_ANTHRO_DISTURBANCE)
# Update message
arcpy.AddMessage("Projected_Anthro_Disturbance Calculated")
# Calculate uplift from anthro feature removal
anthroUplift = cohqt.calcUplift(Current_Anthro_Disturbance,
Projected_Anthro_Disturbance)
upliftRasters.append(anthroUplift)
# Update message
arcpy.AddMessage(
"Merging indirect benefits area and map units layer")
# Combine the Map Units layer and Indirect Impact Layer
indirect_benefit_area = CREDIT_PROJECT_AREA
mgmt_map_units = Map_Units_Dissolve
Map_Units_Dissolve = hqtlib.AddIndirectBenefitArea(
indirect_benefit_area, mgmt_map_units)
else:
Projected_Anthro_Disturbance = Current_Anthro_Disturbance
# Add Indirect field to Map Units layer and populate with False
# Add field "Indirect"
feature = Map_Units_Dissolve
fieldsToAdd = ["Indirect"]
fieldTypes = ["TEXT"]
util.AddFields(feature, fieldsToAdd, fieldTypes)
# Update field to equal "False"
with arcpy.da.UpdateCursor(feature, fieldsToAdd) as cursor:
for row in cursor:
row[0] = "False"
cursor.updateRow(row)
# Calc zonal stats for pre-project modifiers (three seasons)
term = cheStandard.CreditTerms[0]
for season, raster in zip(cheStandard.GrSGSeasons,
seasonalHabitatRasters):
# Update message
arcpy.AddMessage("Summarizing GrSG " + term + " " + season)
# Calculate zonal statistics for each map unit
inZoneData = Map_Units_Dissolve
inValueRaster = raster
zoneField = "Map_Unit_ID"
outTable = "GrSG_Stats_" + term + "_" + season
hqtlib.CalcZonalStats(inZoneData, zoneField, inValueRaster,
outTable)
# Join the zonal statistic to the Map Units Dissolve table
field_name = "GrSG_" + term + "_" + season
hqtlib.JoinMeanToTable(inZoneData, outTable, zoneField, field_name)
if arcpy.Exists("Conifer_Treatment_Area") or \
arcpy.Exists("Anthro_Features_Removed"):
# Update message
arcpy.AddMessage("Calculating Lek Uplift Modifier")
# Calculate Lek Uplift Modifier
lekUpliftModifier = cohqt.calcLekUpliftModifier(
LekPresenceRaster, upliftRasters)
lekUpliftModifier.save("Lek_Uplift_Modifier")
# Update message
arcpy.AddMessage("Calculating Post-Project Habitat Modifiers")
# Calculate post-project cumulative habtiat modifiers
winterHabitatPost = cohqt.calcWinterHabitatGRSG(
Projected_Anthro_Disturbance, ConiferModifier, GrSG_LDI,
GrSG_Habitat)
LSDMWinterPost = cohqt.applyLekUpliftModifierPost(
winterHabitatPost, LekPresenceRaster, lekUpliftModifier)
breedingHabitatPost = cohqt.calcBreedingHabitatGRSG(
Projected_Anthro_Disturbance, ConiferModifier, GrSG_LDI,
Lek_Distance_Modifier, GrSG_Habitat)
LSDMBreedingPost = cohqt.applyLekUpliftModifierPost(
breedingHabitatPost, LekPresenceRaster, lekUpliftModifier)
summerHabitatPost = cohqt.calcSummerHabitatGRSG(
Projected_Anthro_Disturbance, ConiferModifier, GrSG_LDI,
SageModifier, GrSG_Habitat)
LSDMSummerPost = cohqt.applyLekUpliftModifierPost(
summerHabitatPost, LekPresenceRaster, lekUpliftModifier)
seasonalHabitatRasters = [
LSDMWinterPost, LSDMBreedingPost, LSDMSummerPost
]
# Save outputs
# winterHabitatPost.save("Post_Seasonal_Winter")
LSDMWinterPost.save(GRSG_POST_WINTER)
# breedingHabitatPost.save("Post_Seasonal_Breeding")
LSDMBreedingPost.save(GRSG_POST_BREEDING)
# summerHabitatPost.save("Post_Seasonal_Summer")
LSDMSummerPost.save(GRSG_POST_SUMMER)
# Calc zonal stats for post-project modifiers
term = cheStandard.CreditTerms[1]
for season, raster in zip(cheStandard.GrSGSeasons,
seasonalHabitatRasters):
# Update message
arcpy.AddMessage("Summarizing GrSG " + term + " " + season)
# Calculate zonal statistics for each map unit
inZoneData = Map_Units_Dissolve
inValueRaster = raster
zoneField = "Map_Unit_ID"
outTable = "GrSG_Stats_" + term + "_" + season
hqtlib.CalcZonalStats(inZoneData, zoneField, inValueRaster,
outTable)
# Join the zonal statistic to the Map Units Dissolve table
field_name = "GrSG_" + term + "_" + season
hqtlib.JoinMeanToTable(inZoneData, outTable, zoneField,
field_name)
# Calculate Credit Intensity
### END GREATER SAGE-GROUSE ###
### MULE DEER ANTHRO DIST & MODIFIERS ###
if is_mule:
# Update message
arcpy.AddMessage("Calculating pre-project anthropogenic disturbance "
"modifier for mule deer - process may repeat for "
"habitats in mixed PJ and open habitat")
# # Calculat pre-project anthropogenic disturbance
# dist_field = "MDO_Dist"
# weight_field = "MDO_Weight"
# term = cheStandard.CreditTerms[0]
# unique_proposed_subtypes = []
# anthro_disturbance_type = "Pre"
#
# Current_Anthro_Disturbance = hqtlib.cheCalcAnthroDisturbance(
# Parameter_Values, term, unique_proposed_subtypes,
# anthro_disturbance_type, cheStandard, dist_field, weight_field,
# cellSize, emptyRaster
# )
# Current_Anthro_Disturbance.save(CURRENT_ANTHRO_DISTURBANCE_MD)
# Calculate pre-project anthropogenic disturbance
# Calculate pre-project in PJ
dist_field = "MDP_Dist"
weight_field = "MDP_Weight"
term = cheStandard.CreditTerms[0]
unique_proposed_subtypes = []
anthro_disturbance_type = "Pre"
anthro_pj = cohqt.CalcAnthroDisturbance(Parameter_Values, term,
unique_proposed_subtypes,
anthro_disturbance_type,
cheStandard, dist_field,
weight_field, cellSize,
emptyRaster)
anthro_pj.save(CURRENT_ANTHRO_DISTURBANCE_MD + "_P")
# Calculate pre-project in Open
dist_field = "MDO_Dist"
weight_field = "MDO_Weight"
term = cheStandard.CreditTerms[0]
unique_proposed_subtypes = []
anthro_disturbance_type = "Pre"
anthro_open = cohqt.CalcAnthroDisturbance(Parameter_Values,
term,
unique_proposed_subtypes,
anthro_disturbance_type,
cheStandard,
dist_field,
weight_field,
cellSize,
emptyRaster,
mask=BWMD_Open)
anthro_open.save(CURRENT_ANTHRO_DISTURBANCE_MD + "_O")
# Combine PJ and Open
# If outside open, make 1
anthro_open_only = Con(BWMD_Open == 1, anthro_open, 1)
anthro_open_only.save(CURRENT_ANTHRO_DISTURBANCE_MD + "_OO")
# Select minimum of pj and open rasters
Current_Anthro_Disturbance = Con(anthro_open_only < anthro_pj,
anthro_open_only, anthro_pj)
Current_Anthro_Disturbance.save(CURRENT_ANTHRO_DISTURBANCE_MD)
# Clean up
arcpy.Delete_management("temp_masked_raster")
# arcpy.Delete_management(CURRENT_ANTHRO_DISTURBANCE_MD + "_P")
# arcpy.Delete_management(CURRENT_ANTHRO_DISTURBANCE_MD + "_O")
# arcpy.Delete_management(CURRENT_ANTHRO_DISTURBANCE_MD + "_OO")
# Update message
arcpy.AddMessage("Calculating Pre-Project Habitat Modifiers")
# Calculate pre-project cumulative habitat modifiers
summerHabitatPre = cohqt.calcSummerHabitatMD(
Current_Anthro_Disturbance,
MuleDeer_LDI,
SummerModifier,
SuitableHabitat=None)
# LSDMWinterPre = cohqt.applyLekUpliftModifierPre(summerHabitatPre,
# LekPresenceRaster)
migratoryHabitatPre = cohqt.calcMigratoryHabitatMD(
Current_Anthro_Disturbance,
MuleDeer_LDI,
MigrationModifier,
SuitableHabitat=None)
# LSDMBreedingPre = cohqt.applyLekUpliftModifierPre(migratoryHabitatPre,
# LekPresenceRaster)
winterHabitatPre = cohqt.calcWinterHabitatMD(
Current_Anthro_Disturbance,
MuleDeer_LDI,
WinterModifier,
SuitableHabitat=None)
# LSDMSummerPre = cohqt.applyLekUpliftModifierPre(winterHabitatPre,
# LekPresenceRaster)
seasonalHabitatRasters = [
summerHabitatPre, migratoryHabitatPre, winterHabitatPre
]
# Save outputs
summerHabitatPre.save(MULE_PRE_SUMMER)
# LSDMWinterPre.save("Pre_LSDM_Winter")
migratoryHabitatPre.save(MULE_PRE_MIGRATION)
# LSDMBreedingPre.save("Pre_LSDM_Breeding")
winterHabitatPre.save(MULE_PRE_WINTER)
# LSDMSummerPre.save("Pre_LSDM_Summer")
# Update message
arcpy.AddMessage("Current_Anthro_Disturbance Calculated")
# Calc zonal stats for pre-project modifiers (three seasons)
term = cheStandard.DebitTerms[0]
for season, raster in zip(cheStandard.MuleDeerSeasons,
seasonalHabitatRasters):
# Update message
arcpy.AddMessage("Summarizing Mule Deer " + term + " " + season)
# Calculate zonal statistics for each map unit
inZoneData = Map_Units_Dissolve
inValueRaster = raster
zoneField = "Map_Unit_ID"
outTable = "Mule_Stats_" + term + "_" + season
hqtlib.CalcZonalStats(inZoneData, zoneField, inValueRaster,
outTable)
# Join the zonal statistic to the Map Units Dissolve table
field_name = "Mule_" + term + "_" + season
hqtlib.JoinMeanToTable(inZoneData, outTable, zoneField, field_name)
# # Calculate average of three seasonal habitat rasters pre-project
# finalPreCumulative = hqtlib.calcAverageHabitatQuality(
# seasonalHabitatRasters
# )
# finalPreCumulative.save(CUMULATIVE_MODIFIER_PRE)
if arcpy.Exists(PROPOSED_MODIFIED_FEATURES):
# Update message
arcpy.AddMessage("Calculating post-project anthropogenic "
"disturbance modifier")
# Calculate post-project anthropogenic disturbance
term = cheStandard.CreditTerms[1]
anthro_disturbance_type = "Post"
Projected_Anthro_Disturbance = cohqt.CalcAnthroDisturbance(
Parameter_Values, term, unique_proposed_subtypes,
anthro_disturbance_type, cheStandard, dist_field, weight_field,
cellSize, emptyRaster)
Projected_Anthro_Disturbance.save(PROJECTED_ANTHRO_DISTURBANCE_MD)
# Update message
arcpy.AddMessage("Projected_Anthro_Disturbance Calculated")
# Calculate post-project cumulative habitat modifiers
summerHabitatPost = cohqt.calcSummerHabitatMD(
Projected_Anthro_Disturbance,
MuleDeer_LDI,
SummerModifier,
SuitableHabitat=None)
# LSDMWinterPost = cohqt.applyLekUpliftModifierPost(summerHabitatPost,
# LekPresenceRaster)
migratoryHabitatPost = cohqt.calcMigratoryHabitatMD(
Projected_Anthro_Disturbance,
MuleDeer_LDI,
MigrationModifier,
SuitableHabitat=None)
# LSDMBreedingPost = cohqt.applyLekUpliftModifierPost(migratoryHabitatPost,
# LekPresenceRaster)
winterHabitatPost = cohqt.calcWinterHabitatMD(
Projected_Anthro_Disturbance,
MuleDeer_LDI,
WinterModifier,
SuitableHabitat=None)
# LSDMSummerPost = cohqt.applyLekUpliftModifierPost(winterHabitatPost,
# LekPresenceRaster)
seasonalHabitatRasters = [
summerHabitatPost, migratoryHabitatPost, winterHabitatPost
]
# Save outputs
summerHabitatPost.save(MULE_POST_SUMMER)
# LSDMWinterPre.save("Pre_LSDM_Winter")
migratoryHabitatPost.save(MULE_POST_MIGRATION)
# LSDMBreedingPre.save("Pre_LSDM_Breeding")
winterHabitatPost.save(MULE_POST_WINTER)
# LSDMSummerPre.save("Pre_LSDM_Summer")
# Calc zonal stats for pre-project modifiers (three seasons)
term = cheStandard.DebitTerms[1]
for season, raster in zip(cheStandard.MuleDeerSeasons,
seasonalHabitatRasters):
# Update message
arcpy.AddMessage("Summarizing Mule Deer " + term + season)
# Calculate zonal statistics for each map unit
inZoneData = Map_Units_Dissolve
inValueRaster = raster
zoneField = "Map_Unit_ID"
outTable = "Mule_Stats_" + term + season
hqtlib.CalcZonalStats(inZoneData, zoneField, inValueRaster,
outTable)
# Join the zonal statistic to the Map Units Dissolve table
field_name = "Mule_" + term + "_" + season
hqtlib.JoinMeanToTable(inZoneData, outTable, zoneField,
field_name)
# # Calculate average of three seasonal habitat rasters post-project
# finalPostCumulative = hqtlib.calcAverageHabitatQuality(
# seasonalHabitatRasters
# )
# finalPostCumulative.save(CUMULATIVE_MODIFIER_POST)
# Calculate permanent cumulative habtiat modifiers
# Update message
arcpy.AddMessage("Calculating Mule Deer Benefit")
# Calculate impact
pre_fields = [
"Mule_Pre_Summer", "Mule_Pre_Migration", "Mule_Pre_Winter"
]
post_fields = [
"Mule_Post_Summer", "Mule_Post_Migration", "Mule_Post_Winter"
]
out_fields = [
"Mule_Summer_Benefit", "Mule_Migration_Benefit",
"Mule_Winter_Benefit"
]
for i in range(len(pre_fields)):
pre_field = pre_fields[i]
post_field = post_fields[i]
out_field = out_fields[i]
cohqt.calcDebits(Map_Units_Dissolve, pre_field, post_field,
out_field)
# # Export data to Excel
input_Tables = [MAP_UNITS_DISSOLVE]
for table in input_Tables:
hqtlib.ExportToExcel(table, Project_Folder, Project_Name)
### END MULE DEER ###
if not is_grsg and not is_mule:
arcpy.AddMessage("Impacts were not detected in any habitat type. "
"Please check credit project boundary and try "
"again")
# Clean up
for raster in arcpy.ListRasters("*_Subtype_Disturbance"):
arcpy.Delete_management(raster)
for raster in arcpy.ListRasters("*_Type_Disturbance"):
arcpy.Delete_management(raster)
arcpy.Delete_management("in_memory")
# Save map document
if arcpy.ListInstallations()[0] == 'arcgispro':
p = arcpy.mp.ArcGISProject("CURRENT")
p.save()
else:
mxd = arcpy.mapping.MapDocument("CURRENT")
mxd.save()
def main():
# GET PARAMETER VALUES
Map_Units_Provided = arcpy.GetParameterAsText(0)
# DEFINE DIRECTORIES
# Get the pathname to this script
scriptPath = sys.path[0]
arcpy.AddMessage("Script folder: " + scriptPath)
arcpy.AddMessage("Python version: " + sys.version)
# Construct pathname to workspace
projectGDB = arcpy.Describe(Map_Units_Provided).path
arcpy.AddMessage("Project geodatabase: " + projectGDB)
# Instantiate a idStandard object
cheStandard = cohqt.cheStandard(projectGDB, scriptPath)
# ENVIRONMENT SETTINGS
# Set workspaces
arcpy.env.workspace = projectGDB
scratch_folder = os.path.join(arcpy.Describe(projectGDB).path, 'scratch')
if arcpy.Exists(scratch_folder):
pass
else:
arcpy.CreateFolder_management(scratch_folder)
arcpy.env.scratchWorkspace = scratch_folder
# Overwrite outputs
arcpy.env.overwriteOutput = True
# DEFINE GLOBAL VARIABLES
cell_size = 30
inputDataPath = cheStandard.InputDataPath
GrSG_Habitat = cheStandard.GrSGHabitatRaster
ConiferModifier = cheStandard.ConiferModifier
GrSG_LDI = cheStandard.GrSG_LDI
LekPresenceRaster = cheStandard.LekPresenceRaster
Lek_Distance_Modifier = cheStandard.LekDistanceModifier
SageModifier = cheStandard.SageModifier
GrSG_Habitat = cheStandard.BWSGHab
# Filenames of feature classes and rasters used by this script
MAP_UNITS = "Map_Units"
PROPOSED_SURFACE_DISTURBANCE_DEBITS = "Proposed_Surface_Disturbance_Debits"
DISTURBED_FOOTPRINT = "Disturbed_Footprint"
CURRENT_ANTHRO_FEATURES = "Current_Anthro_Features"
CURRENT_ANTHRO_DISTURBANCE = "GrSG_Pre_Anthro_Disturbance"
PROJECTED_ANTHRO_DISTURBANCE = "GRSG_Post_Anthro_Disturbance"
LEK_DISTURBANCE_MODIFIER = "Lek_Disturbance_Modifier"
DEBIT_PROJECT_AREA = "Debit_Project_Area"
DEBIT_PROJECT_IMPACT_A = "Debit_Project_Impact_Adjusted"
# Filenames of feature classes and rasters created by this script
# GrSG Filenames
GRSG_PRE_BREEDING_A = "GRSG_Pre_Breeding_adjusted"
GRSG_PRE_SUMMER_A = "GRSG_Pre_Summer_adjusted"
GRSG_PRE_WINTER_A = "GRSG_Pre_Winter_adjusted"
GRSG_POST_BREEDING_A = "GRSG_Post_Breeding_adjusted"
GRSG_POST_SUMMER_A = "GRSG_Post_Summer_adjusted"
GRSG_POST_WINTER_A = "GRSG_Post_Winter_adjusted"
CUMULATIVE_MODIFIER_PRE_A = "GRSG_Pre_Cumulative_Modifier_adjusted"
CUMULATIVE_MODIFIER_POST_A = "GRSG_Post_Cumulative_Modifier_adjusted"
# ------------------------------------------------------------------------
# FUNCTION CALLS
# Check out Spatial Analyst extension
hqtlib.CheckOutSpatialAnalyst()
# Clear selection, if present
util.ClearSelectedFeatures(Map_Units_Provided)
# Check Map_Units layer
feature = Map_Units_Provided
required_fields = ["Map_Unit_ID", "Map_Unit_Name"]
no_null_fields = ["Map_Unit_ID"]
expected_fcs = None
hqtlib.CheckPolygonInput(feature, required_fields, expected_fcs,
no_null_fields)
# Update Map Units layer with provided layer and add to map
Map_Units = util.AdoptParameter(Map_Units_Provided,
MAP_UNITS,
preserve_existing=False)
layerFile = cheStandard.getLayerFile("MapUnits.lyr")
util.AddToMap(Map_Units, layerFile)
# # Udpate message
# arcpy.AddMessage("Dissolving all multi-part map units to create "
# "Map_Units_Dissolve")
# # Dissolve Map Units
# allowable_fields = ["Map_Unit_ID", "Map_Unit_Name", "Notes",
# "Disturbance_Type", "Precip", ]
# out_name = MAP_UNITS_DISSOLVE
# anthro_features = CURRENT_ANTHRO_FEATURES
# Map_Units_Dissolve = hqtlib.DissolveMapUnits(MUs, allowable_fields,
# out_name, anthro_features)
# # Update message
# arcpy.AddMessage("Adding Map_Units_Dissolve to map")
# # Add layer to map document
# feature = Map_Units_Dissolve
# layerFile = cheStandard.getLayerFile("Map_Units.lyr")
# util.AddToMap(feature, layerFile)
# # Update message
# arcpy.AddMessage("Calculating area in acres for each map unit")
# # Calculate Area
# hqtlib.CalcAcres(Map_Units_Dissolve)
# Update message
arcpy.AddMessage("Creating site-scale habitat quality rasters")
# # ADD Join from Excel Doc
# out_table = os.path.join(projectGDB, "Site_Scale_Scores")
# summary_table = arcpy.ExcelToTable_conversion(Debit_Calculator,
# out_table,
# "Summary")
# arcpy.AddJoin_management(Map_Units, "Map_Unit_ID",
# summary_table, "MapUnitID")
# Convert Map Units to raster of Habitat Quality (0 - 1 scale) and mask
# out BWSG habitat
seasonsList = cheStandard.GrSGSeasons
for season in seasonsList:
mu_raster_path = cohqt.convertMapUnitsToRaster(projectGDB, Map_Units,
season, cell_size)
mu_raster = Raster(mu_raster_path)
# Mask out BWSG habitat
SuitableHabitat_adjusted = Con(IsNull(Float(mu_raster)), GrSG_Habitat,
Float(mu_raster))
SuitableHabitat_adjusted.save(
os.path.join(projectGDB, season + "_Habitat_adjusted"))
# Update message
arcpy.AddMessage("Calculating Pre-Project Habitat Modifiers")
# Re-run fron calcWinterHabitat down with updated BWSG layer (append
# "_adjusted")
WinterSuitableHabitat = os.path.join(projectGDB, "Winter_Habitat_adjusted")
winterHabitatPre = cohqt.calcWinterHabitatGRSG(CURRENT_ANTHRO_DISTURBANCE,
ConiferModifier, GrSG_LDI,
WinterSuitableHabitat)
LSDMWinterPre = cohqt.applyLekUpliftModifierPre(winterHabitatPre,
LekPresenceRaster)
BreedingSuitableHabitat = os.path.join(projectGDB,
"Breed_Habitat_adjusted")
breedingHabitatPre = cohqt.calcBreedingHabitatGRSG(
CURRENT_ANTHRO_DISTURBANCE, ConiferModifier, GrSG_LDI,
Lek_Distance_Modifier, BreedingSuitableHabitat)
LSDMBreedingPre = cohqt.applyLekUpliftModifierPre(breedingHabitatPre,
LekPresenceRaster)
SummerSuitableHabitat = os.path.join(projectGDB, "Summer_Habitat_adjusted")
summerHabitatPre = cohqt.calcSummerHabitatGRSG(CURRENT_ANTHRO_DISTURBANCE,
ConiferModifier, GrSG_LDI,
SageModifier,
SummerSuitableHabitat)
LSDMSummerPre = cohqt.applyLekUpliftModifierPre(summerHabitatPre,
LekPresenceRaster)
seasonalHabitatRasters = [LSDMWinterPre, LSDMBreedingPre, LSDMSummerPre]
# Save outputs
# winterHabitatPre.save("Pre_Seasonal_Winter_adjusted")
LSDMWinterPre.save(GRSG_PRE_WINTER_A)
# breedingHabitatPre.save("Pre_Seasonal_Breeding_adjusted")
LSDMBreedingPre.save(GRSG_PRE_BREEDING_A)
# summerHabitatPre.save("Pre_Seasonal_Summer_adjusted")
LSDMSummerPre.save(GRSG_PRE_SUMMER_A)
# Calculate average of three seasonal habitat rasters pre-project
finalPreCumulative = cohqt.calcAverageHabitatQuality(
seasonalHabitatRasters)
finalPreCumulative.save(CUMULATIVE_MODIFIER_PRE_A)
# Calculate post-project cumulative habtiat modifiers
winterHabitatPost = cohqt.calcWinterHabitatGRSG(
PROJECTED_ANTHRO_DISTURBANCE, ConiferModifier, GrSG_LDI,
WinterSuitableHabitat)
LSDMWinterPost = cohqt.applyLekUpliftModifierPost(
winterHabitatPost, LekPresenceRaster, LEK_DISTURBANCE_MODIFIER)
breedingHabitatPost = cohqt.calcBreedingHabitatGRSG(
PROJECTED_ANTHRO_DISTURBANCE, ConiferModifier, GrSG_LDI,
Lek_Distance_Modifier, BreedingSuitableHabitat)
LSDMBreedingPost = cohqt.applyLekUpliftModifierPost(
breedingHabitatPost, LekPresenceRaster, LEK_DISTURBANCE_MODIFIER)
summerHabitatPost = cohqt.calcSummerHabitatGRSG(
PROJECTED_ANTHRO_DISTURBANCE, ConiferModifier, GrSG_LDI, SageModifier,
SummerSuitableHabitat)
LSDMSummerPost = cohqt.applyLekUpliftModifierPost(
summerHabitatPost, LekPresenceRaster, LEK_DISTURBANCE_MODIFIER)
seasonalHabitatRasters = [LSDMWinterPost, LSDMBreedingPost, LSDMSummerPost]
# Save outputs
# winterHabitatPost.save("Post_Seasonal_Winter")
LSDMWinterPost.save(GRSG_POST_WINTER_A)
# breedingHabitatPost.save("Post_Seasonal_Breeding")
LSDMBreedingPost.save(GRSG_POST_BREEDING_A)
# summerHabitatPost.save("Post_Seasonal_Summer")
LSDMSummerPost.save(GRSG_POST_SUMMER_A)
# Calculate average of three seasonal habitat rasters post-project
finalPostCumulative = cohqt.calcAverageHabitatQuality(
seasonalHabitatRasters)
finalPostCumulative.save(CUMULATIVE_MODIFIER_POST_A)
# Calculate Zonal Statistics for cumulative modifier rasters
# Calculate zonal statistics for pre-project
inZoneData = DEBIT_PROJECT_AREA
inValueRaster = finalPreCumulative
zoneField = "ZONAL"
outTable = "GRSG_Stats_Pre_adjusted"
hqtlib.CalcZonalStats(inZoneData, zoneField, inValueRaster, outTable)
# Join the zonal statistic to the Debit Project Area table
fieldName = "GRSG_Pre_Project_A"
hqtlib.JoinMeanToTable(inZoneData, outTable, zoneField, fieldName)
# Calculate zonal statistics for post-project
inZoneData = DEBIT_PROJECT_AREA
inValueRaster = finalPostCumulative
zoneField = "ZONAL"
outTable = "GRSG_Stats_Post_adjusted"
hqtlib.CalcZonalStats(inZoneData, zoneField, inValueRaster, outTable)
# Join the zonal statistic to the Debit Project Area table
fieldName = "GrSG_Post_Project_A"
hqtlib.JoinMeanToTable(inZoneData, outTable, zoneField, fieldName)
# Calculate debits using field data
cohqt.calcDebits(DEBIT_PROJECT_AREA, "GRSG_Pre_Project_A",
"GrSG_Post_Project_A", "Debits_adj")
# Update message
arcpy.AddMessage("Creating visualization of impact from debit project")
# Calculate impact intensity for debit project
debit_impact = cohqt.calcImpact(finalPreCumulative, finalPostCumulative)
debit_impact.save(DEBIT_PROJECT_IMPACT_A)
# Add Debit Impact raster to map and save map document
feature = debit_impact
layerFile = cheStandard.getLayerFile("DebitProjectImpact.lyr")
util.AddToMap(feature, layerFile, zoom_to=True)
# Clean up
arcpy.Delete_management("in_memory")
# Save map document
if arcpy.ListInstallations()[0] == 'arcgispro':
p = arcpy.mp.ArcGISProject("CURRENT")
p.save()
else:
mxd = arcpy.mapping.MapDocument("CURRENT")
mxd.save()
def main():
# GET PARAMETER VALUES
projectGDB = arcpy.GetParameterAsText(0)
Credit_Project_Boundary = arcpy.GetParameterAsText(1)
includes_Conifer_Treatment = arcpy.GetParameterAsText(2) # optional
Conifer_Treatment_Area_Provided = arcpy.GetParameterAsText(3) # optional
includes_anthro_mod = arcpy.GetParameterAsText(4) # optional
Proposed_Modified_Features_Provided = arcpy.GetParameterAsText(
5) # optional
# Update boolean parameters
includes_anthro_mod = util.Str2Bool(includes_anthro_mod)
# DEFINE DIRECTORIES
# Get the pathname to this script
scriptPath = sys.path[0]
arcpy.AddMessage("Script folder: " + scriptPath)
arcpy.AddMessage("Python version: " + sys.version)
# Instantiate a cheStandard object
cheStandard = cohqt.cheStandard(projectGDB, scriptPath)
# ENVIRONMENT SETTINGS
# Set workspaces
arcpy.env.workspace = projectGDB
arcpy.env.scratchWorkspace = projectGDB
# Overwrite outputs
arcpy.env.overwriteOutput = True
# DEFINE GLOBAL VARIABLES
parameter_values = cheStandard.ParameterValues
coordinate_system = cheStandard.CoorSystem
habitat_bounds = cheStandard.HabitatMgmtArea
# File names for feature classes and rasters created by this script
CREDIT_PROJECT_AREA = "Credit_Project_Area"
CONIFER_TREATMENT_AREA = "Conifer_Treatment_Area"
PROPOSED_MODIFIED_FEATURES = "Proposed_Modified_Features"
MAP_UNITS = "Map_Units"
# ------------------------------------------------------------------------
# FUNCTION CALLS
# Update includes_anthro_mod if Proposed_Modified_Features is
# provided
if Proposed_Modified_Features_Provided and not includes_anthro_mod:
includes_anthro_mod = True
# Update includes_conifer_treatment if Conifer Treatment Area
# provided
if Conifer_Treatment_Area_Provided and not includes_Conifer_Treatment:
includes_Conifer_Treatment = True
# Exit with warning if no Credit Project Boundary is provided and project
# is does not propose to remove or modify anthropogenic disturbance
if not Credit_Project_Boundary and not includes_anthro_mod:
arcpy.AddError("ERROR:: A credit project boundary must be provided "
"unless the project proposes to remove or modify "
"anthropogenic features. Ensure 'Credit Project will "
"remove or modify existing anthropogenic features' is "
"checked if true. Please see the User's Guide for "
"additional instruction.")
sys.exit(0)
# Check input features
if Credit_Project_Boundary:
# Check provided input for polygon shape type
hqtlib.CheckPolygonInput(Credit_Project_Boundary)
if includes_Conifer_Treatment:
# Check provided input for polygon shape type
hqtlib.CheckPolygonInput(Conifer_Treatment_Area_Provided)
if Proposed_Modified_Features_Provided:
# Check provided feature for polygon shape type
hqtlib.CheckPolygonInput(Proposed_Modified_Features_Provided)
# Set up zoom to for map units variable
zoom_to_mu = False
# Check input features for existence of features and feature type;
# create template if Credit_Project_Boundary is not provided
if Credit_Project_Boundary:
# Create a local copy of the credit project boundary in case it is
# the output of the projected input from re-running Credit Tool 1
CPB_copy = arcpy.CopyFeatures_management(Credit_Project_Boundary,
"in_memory/CPB_provided")
# Update message
arcpy.AddMessage("Projecting provided feature(s) to " +
coordinate_system.name)
# Project input to standard projection
in_dataset = CPB_copy
out_dataset = "Credit_Project_Boundary_Projected"
projectedFeature = hqtlib.ProjectInput(in_dataset, out_dataset,
coordinate_system)
# Update message
arcpy.AddMessage("Determining project area - eliminating areas of non-"
"habitat from the Project Area")
# Eliminate areas of non-habitat from project boundary
Project_Area = projectedFeature
outName = "in_memory/Credit_Project_Boundary_Clipped"
clippedFeature = hqtlib.EliminateNonHabitat(Project_Area, outName,
habitat_bounds)
# Create Credit Project Area
in_features = clippedFeature
out_feature_class = CREDIT_PROJECT_AREA
arcpy.Dissolve_management(in_features, out_feature_class)
# Update message
arcpy.AddMessage("Creating Map Units layer")
# Create Map_Units layer
in_data = clippedFeature
out_data = MAP_UNITS
Map_Units = hqtlib.CreateMapUnits(in_data, out_data)
zoom_to_mu = True
# Add Map_Units to map
layerFile = cheStandard.getLayerFile("MapUnits.lyr")
util.AddToMap(Map_Units, layerFile, zoom_to_mu)
if includes_Conifer_Treatment:
# Create a template for digitizing anthropogenic features proposed for
# modification
out_name = "Conifer_Treatment_Area_tmp"
Template_Features = util.CreateTemplate(projectGDB, out_name,
coordinate_system)
# Set up zoom to for proposed surface disturbance variable
zoom_to_cta = False
if Conifer_Treatment_Area_Provided:
# Merge the template created with the provided layer, if provided
fileList = [Conifer_Treatment_Area_Provided, Template_Features]
out_name = "in_memory/tmp_Conifer"
merged_features = util.MergeFeatures(fileList, out_name)
# Rename the provided as merged (cannot merge two files with
# equivalent filenames) as Conifer_Treatment_Area
in_data = merged_features
out_data = CONIFER_TREATMENT_AREA
Conifer_Treatment_Area = arcpy.CopyFeatures_management(
in_data, out_data)
zoom_to_cta = True
else:
# Save the template as Conifer_Treatment_Area
in_data = Template_Features
out_data = CONIFER_TREATMENT_AREA
Conifer_Treatment_Area = util.RenameFeatureClass(in_data, out_data)
# Clean up
arcpy.Delete_management("Conifer_Treatment_Area_tmp")
# Add layer to map for editing
util.AddToMap(Conifer_Treatment_Area, zoom_to=zoom_to_cta)
if includes_anthro_mod:
# Create a template for digitizing anthropogenic features proposed for
# modification
out_name = "Proposed_Modified_Features_tmp"
Template_Features = util.CreateTemplate(projectGDB, out_name,
coordinate_system)
# Update message
arcpy.AddMessage("Adding fields Type and Subtype to "
"the Proposed_Modified_Features layer")
# Add fields Type and Subtype
inputFeature = Template_Features
fieldsToAdd = ["Type", "Subtype"]
fieldTypes = ["TEXT", "TEXT"]
util.AddFields(inputFeature,
fieldsToAdd,
fieldTypes,
copy_existing=True)
# Set up zoom to for proposed surface disturbance variable
zoom_to_psd = False
if Proposed_Modified_Features_Provided:
# Merge the template created with the provided layer, if provided
fileList = [Proposed_Modified_Features_Provided, Template_Features]
out_name = "in_memory/tmp_Modified"
merged_features = util.MergeFeatures(fileList, out_name)
# Rename the provided as merged (cannot merge two files with
# equivalent filenames) as Proposed_Modified_Features
in_data = merged_features
out_data = PROPOSED_MODIFIED_FEATURES
Proposed_Modified_Features = arcpy.CopyFeatures_management(
in_data, out_data)
zoom_to_psd = True
else:
# Save the template as Proposed_Modified_Features
in_data = Template_Features
out_data = PROPOSED_MODIFIED_FEATURES
Proposed_Modified_Features = util.RenameFeatureClass(
in_data, out_data)
# Clean up
arcpy.Delete_management("Proposed_Modified_Features_tmp")
# Add Domains to Proposed_Modified_Features layer
featureList = [Proposed_Modified_Features]
# Create Domain for Subtype attributes and assign to Subtype field
util.AddSubtypeDomains(featureList, projectGDB, parameter_values)
# Create Domain for Type attributes and assign to Type field
typeList = [
row[0] for row in arcpy.da.SearchCursor(parameter_values, "Type")
]
util.AddCodedTextDomain(featureList, projectGDB, "Type", typeList)
# Add layer to map for editing
layerFile = cheStandard.getLayerFile("DebitProjectArea.lyr")
util.AddToMap(Proposed_Modified_Features, layerFile, zoom_to_psd)
if not Credit_Project_Boundary:
# Create dummy Map Units layer if no Credit Project Boundary provided
out_name = MAP_UNITS
Map_Units = util.CreateTemplate(projectGDB, out_name,
coordinate_system)
if Proposed_Modified_Features_Provided:
# Zoom to the Modified Anthro Feature layer
if arcpy.ListInstallations()[0] == 'arcgispro':
p = arcpy.mp.ArcGISProject("CURRENT")
m = p.activeMap
layer = m.Layer(PROPOSED_MODIFIED_FEATURES)
pass
# df.extent = layer.getSelectedExtent()
else:
mxd = arcpy.mapping.MapDocument("CURRENT")
df = mxd.activeDataFrame
layer = arcpy.mapping.Layer(PROPOSED_MODIFIED_FEATURES)
df.extent = layer.getSelectedExtent()
# Add fields Map_Unit_ID, Map_Unit_Name, and Meadow to Map_Units
fields = ["Map_Unit_ID", "Map_Unit_Name", "Notes"]
fieldTypes = ["SHORT", "TEXT", "TEXT"]
util.AddFields(Map_Units, fields, fieldTypes, copy_existing=True)
# Add Domains to Map_Units layer
# Create Domain for Map_Unit_ID attributes
domainName = "Map_Unit_ID"
range_low = 0
range_high = 10000
util.AddRangeDomain(Map_Units, projectGDB, domainName, range_low,
range_high)
# Clean up
arcpy.Delete_management("in_memory")
# Save map document
if arcpy.ListInstallations()[0] == 'arcgispro':
p = arcpy.mp.ArcGISProject("CURRENT")
p.save()
else:
mxd = arcpy.mapping.MapDocument("CURRENT")
mxd.save()
def main():
# GET PARAMETER VALUES
projectGDB = arcpy.GetParameterAsText(0)
Provided_Disturbance = arcpy.GetParameterAsText(1)
includes_anthro_mod = arcpy.GetParameterAsText(2) # optional
Proposed_Modified_Features_Provided = arcpy.GetParameterAsText(
3) # optional
# Update boolean parameters
includes_anthro_mod = util.Str2Bool(includes_anthro_mod)
# DEFINE DIRECTORIES
# Get the pathname to this script
scriptPath = sys.path[0]
arcpy.AddMessage("Script folder: " + scriptPath)
arcpy.AddMessage("Python version: " + sys.version)
# Instantiate an cheStandard object
cheStandard = cohqt.cheStandard(projectGDB, scriptPath)
# ENVIRONMENT SETTINGS
# Set workspaces
arcpy.env.workspace = projectGDB
arcpy.env.scratchWorkspace = projectGDB
# Overwrite outputs
arcpy.env.overwriteOutput = True
# DEFINE GLOBAL VARIABLES
parameter_values = cheStandard.ParameterValues
coordinate_system = cheStandard.CoorSystem
# Filenames for feature classes and rasters created by this script
PROPOSED_SURFACE_DISTURBANCE_DEBITS = "Proposed_Surface_Disturbance_Debits"
PROPOSED_MODIFIED_FEATURES = "Proposed_Modified_Features"
# ------------------------------------------------------------------------
# FUNCTION CALLS
# Update includes_anthro_mod if Proposed_Modified_Features is
# provided
if Proposed_Modified_Features_Provided and not includes_anthro_mod:
includes_anthro_mod = True
# Check input features for existence of features and feature type;
# create template if Proposed_Surface_Disturbance is not provided
if Provided_Disturbance:
# Check provided input
hqtlib.CheckPolygonInput(Provided_Disturbance)
# Create a local copy of the provided disturbance in case it is
# the output of the projected input from re-running Debit Tool 1
PSD_copy = arcpy.CopyFeatures_management(Provided_Disturbance,
"in_memory/PSD_provided")
# Update message
arcpy.AddMessage("Projecting provided feature(s) to " +
coordinate_system.name)
# Project input to standard coordinate system
inputFeature = PSD_copy
out_name = PROPOSED_SURFACE_DISTURBANCE_DEBITS
Proposed_Surface_Disturbance = hqtlib.ProjectInput(
inputFeature, out_name, coordinate_system)
zoom_to = True
else:
# Update message
arcpy.AddMessage("Creating template for digitizing proposed "
"surface disturbance \nDigitize features in "
"feature class named "
"Proposed_Surface_Disturbance_Debits created within "
"the project's unique geodatabase")
# Create a template
out_name = PROPOSED_SURFACE_DISTURBANCE_DEBITS
Proposed_Surface_Disturbance = util.CreateTemplate(
projectGDB, out_name, coordinate_system)
zoom_to = False
if includes_anthro_mod:
# Create a template for digitizing anthropogenic features proposed for
# modification
out_name = "Proposed_Modified_Features_tmp"
Template_Features = util.CreateTemplate(projectGDB, out_name,
coordinate_system)
if Proposed_Modified_Features_Provided:
# Do not zoom to proposed surface disturbance
zoom_to = False
# Merge with the provided layer, if provided
fileList = [Proposed_Modified_Features_Provided, Template_Features]
out_name = "in_memory/tmp_Modified"
merged_features = util.MergeFeatures(fileList, out_name)
# Rename the provided as merged (cannot merge two files with
# equivalent filenames) as Proposed_Modified_Features
in_data = merged_features
out_data = PROPOSED_MODIFIED_FEATURES
Proposed_Modified_Features = arcpy.CopyFeatures_management(
in_data, out_data)
else:
# Save the template as Proposed_Modified_Features
in_data = Template_Features
out_data = PROPOSED_MODIFIED_FEATURES
Proposed_Modified_Features = util.RenameFeatureClass(
in_data, out_data)
# Update message
arcpy.AddMessage("Adding fields Type and Subtype to "
"the Proposed_Modified_Features layer")
# Add fields Type and Subtype
inputFeature = Proposed_Modified_Features
fieldsToAdd = ["Type", "Subtype"]
fieldTypes = ["TEXT", "TEXT"]
util.AddFields(inputFeature,
fieldsToAdd,
fieldTypes,
copy_existing=True)
# Clean up
arcpy.Delete_management(Template_Features)
# Create Domain for Subtype attributes and assign to Subtype field
featureList = [Proposed_Modified_Features]
util.AddSubtypeDomains(featureList, projectGDB, parameter_values)
# Add layer to map for editing
layerFile = cheStandard.getLayerFile("ProposedSurfaceDisturbance.lyr")
util.AddToMap(Proposed_Modified_Features, layerFile)
# Add layer to map document
layerFile = cheStandard.getLayerFile("ProposedSurfaceDisturbance.lyr")
util.AddToMap(Proposed_Surface_Disturbance, layerFile, zoom_to)
# Update message
arcpy.AddMessage("Adding fields to Proposed_Surface_Disturbance")
# Add fields for Type, Subtype, Surface Disturbance, and Reclassifed Subtype
input_feature = Proposed_Surface_Disturbance
fields = ["Type", "Subtype", "Surface_Disturbance", "Reclassified_Subtype"]
fieldTypes = ["TEXT", "TEXT", "TEXT", "TEXT"]
util.AddFields(input_feature, fields, fieldTypes, copy_existing=True)
# Add Domains to Proposed_Surface_Disturbance_Debits layer
featureList = [Proposed_Surface_Disturbance]
domain_name = "Type"
code_list = [
row[0] for row in arcpy.da.SearchCursor(parameter_values, "Type")
]
# Create Domain for Subtype attributes and assign to Subtype field
util.AddSubtypeDomains(featureList, projectGDB, parameter_values)
# Create Domain for Type attributes and assign to Type field
util.AddCodedTextDomain(featureList, projectGDB, domain_name, code_list)
# Create Domain for Type attributes and assign to Surface Disturbance field
domain_name = "Surface_Disturbance"
code_list = [
"Term_Reclaimed", "Term_Retired", "Term_Reclassified", "Permanent"
]
util.AddCodedTextDomain(featureList, projectGDB, domain_name, code_list)
# Create Domain for Type attributes and assign to Reclassified Subtype
# field
domain_name = "Reclassified_Subtype"
code_list = [
row[0] for row in arcpy.da.SearchCursor(parameter_values, "Subtype")
]
util.AddCodedTextDomain(featureList, projectGDB, domain_name, code_list)
if includes_anthro_mod:
# Extend type domain to Proposed_Modified_Features
try:
arcpy.AssignDomainToField_management(Proposed_Modified_Features,
"Type", "Type")
except arcpy.ExecuteError:
arcpy.AddMessage("Type domain not updated for "
"Proposed_Modified_Features")
# Save map document and exit
if arcpy.ListInstallations()[0] == 'arcgispro':
p = arcpy.mp.ArcGISProject("CURRENT")
p.save()
else:
mxd = arcpy.mapping.MapDocument("CURRENT")
mxd.save()
def main():
# GET PARAMETER VALUES
Proposed_Surface_Disturbance_Provided = arcpy.GetParameterAsText(0)
Proposed_Modified_Features_Provided = arcpy.GetParameterAsText(
1) # optional
# DEFINE DIRECTORIES
# Get the pathname to this script
scriptPath = sys.path[0]
arcpy.AddMessage("Script folder: " + scriptPath)
arcpy.AddMessage("Python version: " + sys.version)
# Construct pathname to workspace
projectGDB = arcpy.Describe(Proposed_Surface_Disturbance_Provided).path
arcpy.AddMessage("Project geodatabase: " + projectGDB)
# Instantiate a cheStandard object
cheStandard = cohqt.cheStandard(projectGDB, scriptPath)
# ENVIRONMENT SETTINGS
# Set workspaces
arcpy.env.workspace = projectGDB
scratch_folder = os.path.join(arcpy.Describe(projectGDB).path, 'scratch')
if arcpy.Exists(scratch_folder):
pass
else:
arcpy.CreateFolder_management(
arcpy.Describe(projectGDB).path, 'scratch')
arcpy.env.scratchWorkspace = scratch_folder
# Overwrite outputs
arcpy.env.overwriteOutput = True
# DEFINE GLOBAL VARIABLES
Parameter_Values = cheStandard.ParameterValues
habitat_bounds = cheStandard.HabitatMgmtArea
ConiferModifier = cheStandard.ConiferModifier
GrSG_LDI = cheStandard.GrSG_LDI
LekPresenceRaster = cheStandard.LekPresenceRaster
Lek_Distance_Modifier = cheStandard.LekDistanceModifier
SageModifier = cheStandard.SageModifier
GrSGHabitat = cheStandard.BWSGHab
MuleDeerHabitat = cheStandard.BWMDHab
emptyRaster = cheStandard.EmptyRaster
MigrationModifier = cheStandard.MuleDeerMigrationMod
WinterModifier = cheStandard.MuleDeerWinterMod
SummerModifier = cheStandard.MuleDeerSummerMod
MuleDeer_LDI = cheStandard.MuleDeerLDI
BWMD_Open = cheStandard.BWMD_Open
GrSG_Range = cheStandard.GrSGHabitat
Mule_Range = cheStandard.MuleDeerHabitat
cellSize = arcpy.GetRasterProperties_management(emptyRaster,
"CELLSIZEX").getOutput(0)
# Filenames for feature classes or rasters used by this script
PROPOSED_SURFACE_DISTURBANCE_DEBITS = "Proposed_Surface_Disturbance_Debits"
# Filenames for feature classes or rasters created by this script
ANALYSIS_AREA = "Analysis_Area"
DEBIT_PROJECT_AREA = "Debit_Project_Area"
INDIRECT_IMPACT_AREA = "Indirect_Impact_Area"
INDIRECT_BENEFIT_AREA = "Indirect_Benefit_Area"
PROPOSED_MODIFIED_FEATURES = "Proposed_Modified_Features"
DEBIT_PROJECT_IMPACT = "GrSG_Impact"
MAP_UNITS = "Map_Units"
# GrSG Filenames
LEK_DISTURBANCE_MODIFIER = "Lek_Disturbance_Modifier"
CUMULATIVE_MODIFIER_PRE = "GRSG_Pre_Cumulative_Modifier"
CUMULATIVE_MODIFIER_POST = "GRSG_Post_Cumulative_Modifier"
CURRENT_ANTHRO_DISTURBANCE = "GRSG_Pre_Anthro_Disturbance"
PROJECTED_ANTHRO_DISTURBANCE = "GRSG_Post_Anthro_Disturbance"
GRSG_PRE_BREEDING = "GRSG_Pre_Breeding"
GRSG_PRE_SUMMER = "GRSG_Pre_Summer"
GRSG_PRE_WINTER = "GRSG_Pre_Winter"
GRSG_POST_BREEDING = "GRSG_Post_Breeding"
GRSG_POST_SUMMER = "GRSG_Post_Summer"
GRSG_POST_WINTER = "GRSG_Post_Winter"
# Mule Deer Filenames
CURRENT_ANTHRO_DISTURBANCE_MD = "MuleDeer_Pre_Anthro_Disturbance"
PROJECTED_ANTHRO_DISTURBANCE_MD = "MuleDeer_Post_Anthro_Disturbance"
MULE_PRE_SUMMER = "MuleDeer_Pre_Summer"
MULE_PRE_MIGRATION = "MuleDeer_Pre_Migration"
MULE_PRE_WINTER = "MuleDeer_Pre_Winter"
MULE_POST_SUMMER = "MuleDeer_Post_Summer"
MULE_POST_MIGRATION = "MuleDeer_Post_Migration"
MULE_POST_WINTER = "MuleDeer_Post_Winter"
# ------------------------------------------------------------------------
# FUNCTION CALLS
# Check out Spatial Analyst extension
hqtlib.CheckOutSpatialAnalyst()
if not Proposed_Modified_Features_Provided:
# Ensure Proposed_Modified_Features does not exist
if arcpy.Exists("Proposed_Modified_Features"):
arcpy.AddError("ERROR:: A 'Proposed_Modified_Features' layer "
"was detected in the project's geodatabase. "
"Provide the 'Proposed_Modified_Features' layer "
"and re-run Debit Tool 2.")
sys.exit(0)
# Clear selection, if present
util.ClearSelectedFeatures(Proposed_Surface_Disturbance_Provided)
# Check Proposed_Surface_Disturbance
feature = Proposed_Surface_Disturbance_Provided
required_fields = ["Type", "Subtype", "Surface_Disturbance"]
no_null_fields = required_fields
expected_fcs = None
hqtlib.CheckPolygonInput(feature, required_fields, expected_fcs,
no_null_fields)
# Update Proposed_Surface_Disturbance layer with provided layer
provided_input = Proposed_Surface_Disturbance_Provided
parameter_name = PROPOSED_SURFACE_DISTURBANCE_DEBITS
Proposed_Surface_Disturbance = util.AdoptParameter(provided_input,
parameter_name,
preserve_existing=False)
# Replace Proposed_Surface_Disturbance_Debits layer on map
layerFile = cheStandard.getLayerFile("ProposedSurfaceDisturbance.lyr")
util.AddToMap(Proposed_Surface_Disturbance, layerFile)
# Add field for Disturbance_Type and populate. Values will be used in
# Map_Units_Dissolve to identify map units of direct disturbance
feature = Proposed_Surface_Disturbance
fields = ["Disturbance_Type"]
fieldTypes = ["TEXT"]
util.AddFields(feature, fields, fieldTypes)
with arcpy.da.UpdateCursor(feature,
["Surface_Disturbance"] + fields) as cursor:
for row in cursor:
row[1] = "Direct_" + row[0]
cursor.updateRow(row)
# Update message
arcpy.AddMessage("Creating the area of indirect impact")
# Buffer proposed surface disturbance to create Indirect_Impact_Area
in_data = Proposed_Surface_Disturbance
out_name = INDIRECT_IMPACT_AREA
Indirect_Impact_Area = hqtlib.CreateIndirectImpactArea(
in_data, Parameter_Values, out_name)
# Set up flag for projects that propose to modify anthro features
includes_anthro_mod = False
if Proposed_Modified_Features_Provided:
# Update flag
includes_anthro_mod = True
# Clear selection, if present
util.ClearSelectedFeatures(Proposed_Modified_Features_Provided)
# Check provided layer
required_fields = ["Type", "Subtype"]
no_null_fields = required_fields
expected_fcs = None
hqtlib.CheckPolygonInput(Proposed_Modified_Features_Provided,
required_fields, expected_fcs, no_null_fields)
# Update Proposed_Modified_Features with provided layer and add to map
provided_input = Proposed_Modified_Features_Provided
parameterName = PROPOSED_MODIFIED_FEATURES
preserve_existing = False
Proposed_Modified_Features = util.AdoptParameter(
provided_input, parameterName, preserve_existing)
# Add Proposed Modified Features layer to map
layerFile = cheStandard.getLayerFile("ProposedSurfaceDisturbance.lyr")
util.AddToMap(Proposed_Modified_Features, layerFile)
# Update message
arcpy.AddMessage("Creating the area of indirect benefit")
# Create the Indirect_Impact_Area
in_data = Proposed_Modified_Features
out_name = INDIRECT_BENEFIT_AREA
Indirect_Benefit_Area = hqtlib.CreateIndirectImpactArea(
in_data, Parameter_Values, out_name)
# Union the indirect benefit area and the indirect impact area
in_features = [Indirect_Impact_Area, Indirect_Benefit_Area]
out_name = "in_memory/Impact_Union"
Impact_Union = arcpy.Union_analysis(in_features, out_name)
# Dissolve the unioned indirect impact and benefit areas as
# Indirect Impact Area
in_features = Impact_Union
out_feature_class = INDIRECT_IMPACT_AREA
Indirect_Impact_Area = arcpy.Dissolve_management(
in_features, out_feature_class)
# Detect habitat types impacted directly or indirectly
is_grsg = cohqt.DetectHabitat(Indirect_Impact_Area, GrSG_Range)
is_mule = cohqt.DetectHabitat(Indirect_Impact_Area, Mule_Range)
# Update message
arcpy.AddMessage("Determining project area - eliminating areas of non-"
"habitat from the Project Area")
# Eliminate non-habitat
project_area = Indirect_Impact_Area
out_name = DEBIT_PROJECT_AREA
Debit_Project_Area = hqtlib.EliminateNonHabitat(project_area, out_name,
habitat_bounds)
# Calculate Area
hqtlib.CalcAcres(Debit_Project_Area)
# Add Debit Project Area to map
feature = Debit_Project_Area
layerFile = cheStandard.getLayerFile("DebitProjectArea.lyr")
util.AddToMap(feature, layerFile, zoom_to=True)
# Update message
arcpy.AddMessage("Creating Analysis Area")
# Create Analysis_Area
out_name = ANALYSIS_AREA
Analysis_Area = hqtlib.CreateAnalysisArea(Debit_Project_Area,
Parameter_Values, out_name)
# Add Analysis_Area to map
layerFile = cheStandard.getLayerFile("AnalysisArea.lyr")
util.AddToMap(Analysis_Area, layerFile, zoom_to=True)
# Set processing extent to Analysis_Area
arcpy.env.extent = ANALYSIS_AREA
# Prepare proposed anthropogenic features
unique_proposed_subtypes = cohqt.convertProposedToRasterDebit(
Proposed_Surface_Disturbance, cellSize)
anthroPath = cheStandard.AnthroFeaturePath
cohqt.combineProposedWithCurrentDebit(anthroPath, unique_proposed_subtypes)
# # Do something about anthropogenic mod features
# if includes_anthro_mod:
# unique_proposed_subtypes_removed = hqtlib.convertProposedToRaster(
# Proposed_Modified_Features, cellSize
# )
#
# anthroPath = cheStandard.AnthroFeaturePath
# hqtlib.combineProposedWithCurrent(anthroPath, unique_proposed_subtypes)
### GREATER SAGE-GROUSE ANTHRO DIST & MODIFIERS ###
if is_grsg:
# Update message
arcpy.AddMessage("Calculating pre-project anthropogenic disturbance "
"modifier for greater sage-grouse")
# Calculate pre-project anthropogenic disturbance
dist_field = "GrSG_Dist"
weight_field = "GrSG_Weight"
term = cheStandard.DebitTerms[0]
anthro_disturbance_type = "Pre"
Current_Anthro_Disturbance = cohqt.CalcAnthroDisturbance(
Parameter_Values, term, unique_proposed_subtypes,
anthro_disturbance_type, cheStandard, dist_field, weight_field,
cellSize, emptyRaster)
Current_Anthro_Disturbance.save(CURRENT_ANTHRO_DISTURBANCE)
# Update message
arcpy.AddMessage("Current_Anthro_Disturbance Calculated")
arcpy.AddMessage("Calculating post-project anthropogenic "
"disturbance modifier for greater sage-grouse")
# Calculate post-project anthropogenic disturbance
term = cheStandard.DebitTerms[1]
anthro_disturbance_type = "Post"
Projected_Anthro_Disturbance = cohqt.CalcAnthroDisturbance(
Parameter_Values, term, unique_proposed_subtypes,
anthro_disturbance_type, cheStandard, dist_field, weight_field,
cellSize, emptyRaster)
Projected_Anthro_Disturbance.save(PROJECTED_ANTHRO_DISTURBANCE)
# Update message
arcpy.AddMessage("Projected_Anthro_Disturbance Calculated")
arcpy.AddMessage("Calculating lek disturbance modifier")
# Calculate permanent anthropogenic disturbance
# Calculate Lek Disturbance Modifier
term = cheStandard.DebitTerms[1]
anthro_disturbance_type = "LekDisturbanceModifier"
Lek_Disturbance_Modifier = cohqt.CalcAnthroDisturbance(
Parameter_Values, term, unique_proposed_subtypes,
anthro_disturbance_type, cheStandard, dist_field, weight_field,
cellSize, emptyRaster)
Lek_Disturbance_Modifier.save(LEK_DISTURBANCE_MODIFIER)
# Update message
arcpy.AddMessage("Calculating Pre-Project Habitat Modifiers")
# Calculate pre-project cumulative habitat modifiers
winterHabitatPre = cohqt.calcWinterHabitatGRSG(
Current_Anthro_Disturbance, ConiferModifier, GrSG_LDI, GrSGHabitat)
LSDMWinterPre = cohqt.applyLekUpliftModifierPre(
winterHabitatPre, LekPresenceRaster)
breedingHabitatPre = cohqt.calcBreedingHabitatGRSG(
Current_Anthro_Disturbance, ConiferModifier, GrSG_LDI,
Lek_Distance_Modifier, GrSGHabitat)
LSDMBreedingPre = cohqt.applyLekUpliftModifierPre(
breedingHabitatPre, LekPresenceRaster)
summerHabitatPre = cohqt.calcSummerHabitatGRSG(
Current_Anthro_Disturbance, ConiferModifier, GrSG_LDI,
SageModifier, GrSGHabitat)
LSDMSummerPre = cohqt.applyLekUpliftModifierPre(
summerHabitatPre, LekPresenceRaster)
seasonalHabitatRasters = [
LSDMWinterPre, LSDMBreedingPre, LSDMSummerPre
]
# Save outputs
# winterHabitatPre.save(GRSG_PRE_WINTER)
LSDMWinterPre.save(GRSG_PRE_WINTER)
# breedingHabitatPre.save(GRSG_PRE_BREEDING)
LSDMBreedingPre.save(GRSG_PRE_BREEDING)
# summerHabitatPre.save(GRSG_PRE_SUMMER)
LSDMSummerPre.save(GRSG_PRE_SUMMER)
# Calculate average of three seasonal habitat rasters pre-project
finalPreCumulative = cohqt.calcAverageHabitatQuality(
seasonalHabitatRasters)
finalPreCumulative.save(CUMULATIVE_MODIFIER_PRE)
# Calculate post-project cumulative habtiat modifiers
winterHabitatPost = cohqt.calcWinterHabitatGRSG(
Projected_Anthro_Disturbance, ConiferModifier, GrSG_LDI,
GrSGHabitat)
LSDMWinterPost = cohqt.applyLekUpliftModifierPost(
winterHabitatPost, LekPresenceRaster, Lek_Disturbance_Modifier)
breedingHabitatPost = cohqt.calcBreedingHabitatGRSG(
Projected_Anthro_Disturbance, ConiferModifier, GrSG_LDI,
Lek_Distance_Modifier, GrSGHabitat)
LSDMBreedingPost = cohqt.applyLekUpliftModifierPost(
breedingHabitatPost, LekPresenceRaster, Lek_Disturbance_Modifier)
summerHabitatPost = cohqt.calcSummerHabitatGRSG(
Projected_Anthro_Disturbance, ConiferModifier, GrSG_LDI,
SageModifier, GrSGHabitat)
LSDMSummerPost = cohqt.applyLekUpliftModifierPost(
summerHabitatPost, LekPresenceRaster, Lek_Disturbance_Modifier)
seasonalHabitatRasters = [
LSDMWinterPost, LSDMBreedingPost, LSDMSummerPost
]
# Save outputs
# winterHabitatPost.save("Post_Seasonal_Winter")
LSDMWinterPost.save(GRSG_POST_WINTER)
# breedingHabitatPost.save("Post_Seasonal_Breeding")
LSDMBreedingPost.save(GRSG_POST_BREEDING)
# summerHabitatPost.save("Post_Seasonal_Summer")
LSDMSummerPost.save(GRSG_POST_SUMMER)
# Calculate average of three seasonal habitat rasters post-project
finalPostCumulative = cohqt.calcAverageHabitatQuality(
seasonalHabitatRasters)
finalPostCumulative.save(CUMULATIVE_MODIFIER_POST)
# Calculate permanent cumulative habtiat modifiers
# Calculate Zonal Statistics for cumulative modifier rasters
# Add field to use for zonal statistics
inTable = Debit_Project_Area
fields = ["ZONAL"]
field_types = ["SHORT"]
util.AddFields(inTable, fields, field_types)
# Populate field with value 1
arcpy.CalculateField_management(inTable, fields[0], 1, "PYTHON_9.3",
"")
# Update message
arcpy.AddMessage("Calculating debits for greater sage-grouse")
# Calculate zonal statistics for pre-project
inZoneData = Debit_Project_Area
inValueRaster = finalPreCumulative
zoneField = fields[0]
outTable = "GRSG_Stats_Pre"
hqtlib.CalcZonalStats(inZoneData, zoneField, inValueRaster, outTable)
# Join the zonal statistic to the Debit Project Area table
fieldName = "GRSG_Pre_Project"
hqtlib.JoinMeanToTable(inZoneData, outTable, zoneField, fieldName)
# Calculate zonal statistics for post-project
inZoneData = Debit_Project_Area
inValueRaster = finalPostCumulative
zoneField = fields[0]
outTable = "GRSG_Stats_Post"
hqtlib.CalcZonalStats(inZoneData, zoneField, inValueRaster, outTable)
# Join the zonal statistic to the Debit Project Area table
fieldName = "GrSG_Post_Project"
hqtlib.JoinMeanToTable(inZoneData, outTable, zoneField, fieldName)
# Calculate debits (if not collecting field data)
cohqt.calcDebits(Debit_Project_Area, "GRSG_Pre_Project",
"GrSG_Post_Project", "Debits")
# Update message
arcpy.AddMessage("Creating visualization of impact from debit project")
# Calculate impact intensity for debit project
debit_impact = cohqt.calcImpact(finalPreCumulative,
finalPostCumulative)
debit_impact.save(DEBIT_PROJECT_IMPACT)
# Add Debit Impact raster to map and save map document
feature = debit_impact
layerFile = cheStandard.getLayerFile("DebitProjectImpact.lyr")
util.AddToMap(feature, layerFile, zoom_to=True)
### END GREATER SAGE-GROUSE ###
### MULE DEER ANTHRO DIST & MODIFIERS ###
if not is_grsg:
# Calculate Zonal Statistics for cumulative modifier rasters
# Add field to use for zonal statistics
inTable = Debit_Project_Area
fields = ["ZONAL"]
field_types = ["SHORT"]
util.AddFields(inTable, fields, field_types)
# Populate field with value 1
arcpy.CalculateField_management(inTable, fields[0], 1, "PYTHON_9.3",
"")
# Update message
if is_mule:
arcpy.AddMessage("Calculating pre-project anthropogenic disturbance "
"modifier for mule deer")
# Calculate pre-project anthropogenic disturbance
# Calculate pre-project in PJ
dist_field = "MDP_Dist"
weight_field = "MDP_Weight"
term = cheStandard.DebitTerms[0]
#unique_proposed_subtypes = []
anthro_disturbance_type = "Pre"
anthro_pj = cohqt.CalcAnthroDisturbance(Parameter_Values, term,
unique_proposed_subtypes,
anthro_disturbance_type,
cheStandard, dist_field,
weight_field, cellSize,
emptyRaster)
anthro_pj.save(CURRENT_ANTHRO_DISTURBANCE_MD + "_P")
# Calculate pre-project in Open
dist_field = "MDO_Dist"
weight_field = "MDO_Weight"
term = cheStandard.DebitTerms[0]
#unique_proposed_subtypes = []
anthro_disturbance_type = "Pre"
anthro_open = cohqt.CalcAnthroDisturbance(Parameter_Values,
term,
unique_proposed_subtypes,
anthro_disturbance_type,
cheStandard,
dist_field,
weight_field,
cellSize,
emptyRaster,
mask=BWMD_Open)
anthro_open.save(CURRENT_ANTHRO_DISTURBANCE_MD + "_O")
# Combine PJ and Open
# If outside open, make 1
anthro_open_only = Con(BWMD_Open == 1, anthro_open, 1)
anthro_open_only.save(CURRENT_ANTHRO_DISTURBANCE_MD + "_OO")
# Select minimum of pj and open rasters
Current_Anthro_Disturbance = Con(anthro_open_only < anthro_pj,
anthro_open_only, anthro_pj)
Current_Anthro_Disturbance.save(CURRENT_ANTHRO_DISTURBANCE_MD)
# Clean up
arcpy.Delete_management("temp_masked_raster")
# arcpy.Delete_management(CURRENT_ANTHRO_DISTURBANCE_MD + "_P")
# arcpy.Delete_management(CURRENT_ANTHRO_DISTURBANCE_MD + "_O")
# arcpy.Delete_management(CURRENT_ANTHRO_DISTURBANCE_MD + "_OO")
# Update message
arcpy.AddMessage("Current_Anthro_Disturbance Calculated")
arcpy.AddMessage("Calculating post-project anthropogenic "
"disturbance modifier")
# Calculate post-project anthropogenic disturbance
# Calculate post-project in PJ
dist_field = "MDP_Dist"
weight_field = "MDP_Weight"
term = cheStandard.DebitTerms[1]
#unique_proposed_subtypes = []
anthro_disturbance_type = "Post"
anthro_pj = cohqt.CalcAnthroDisturbance(Parameter_Values, term,
unique_proposed_subtypes,
anthro_disturbance_type,
cheStandard, dist_field,
weight_field, cellSize,
emptyRaster)
anthro_pj.save(PROJECTED_ANTHRO_DISTURBANCE_MD + "_P")
# Calculate pre-project in Open
dist_field = "MDO_Dist"
weight_field = "MDO_Weight"
term = cheStandard.DebitTerms[1]
#unique_proposed_subtypes = []
anthro_disturbance_type = "Post"
anthro_open = cohqt.CalcAnthroDisturbance(Parameter_Values,
term,
unique_proposed_subtypes,
anthro_disturbance_type,
cheStandard,
dist_field,
weight_field,
cellSize,
emptyRaster,
mask=BWMD_Open)
anthro_open.save(PROJECTED_ANTHRO_DISTURBANCE_MD + "_O")
# Combine PJ and Open
# If outside open, make 1
anthro_open_only = Con(BWMD_Open == 1, anthro_open, 1)
anthro_open_only.save(PROJECTED_ANTHRO_DISTURBANCE_MD + "_OO")
# Select minimum of pj and open rasters
Projected_Anthro_Disturbance = Con(anthro_open_only < anthro_pj,
anthro_open_only, anthro_pj)
Projected_Anthro_Disturbance.save(PROJECTED_ANTHRO_DISTURBANCE_MD)
# Update message
arcpy.AddMessage("Projected_Anthro_Disturbance Calculated")
# arcpy.AddMessage("Calculating lek disturbance modifier")
#
# # Calculate permanent anthropogenic disturbance
#
# # Calculate Lek Disturbance Modifier
# term = cheStandard.CreditTerms[1]
# anthro_disturbance_type = "LekDisturbanceModifier"
#
# Lek_Disturbance_Modifier = hqtlib.cheCalcAnthroDisturbance(
# Parameter_Values, term, unique_proposed_subtypes,
# anthro_disturbance_type, cheStandard, dist_field, weight_field,
# cellSize, emptyRaster
# )
#
# Lek_Disturbance_Modifier.save(LEK_DISTURBANCE_MODIFIER)
# Update message
arcpy.AddMessage("Calculating Pre-Project Habitat Modifiers")
# Calculate pre-project cumulative habitat modifiers
summerHabitatPre = cohqt.calcSummerHabitatMD(
Current_Anthro_Disturbance,
MuleDeer_LDI,
SummerModifier,
SuitableHabitat=MuleDeerHabitat)
# LSDMWinterPre = cohqt.applyLekUpliftModifierPre(summerHabitatPre,
# LekPresenceRaster)
migratoryHabitatPre = cohqt.calcMigratoryHabitatMD(
Current_Anthro_Disturbance,
MuleDeer_LDI,
MigrationModifier,
SuitableHabitat=MuleDeerHabitat)
# LSDMBreedingPre = cohqt.applyLekUpliftModifierPre(migratoryHabitatPre,
# LekPresenceRaster)
winterHabitatPre = cohqt.calcWinterHabitatMD(
Current_Anthro_Disturbance,
MuleDeer_LDI,
WinterModifier,
SuitableHabitat=MuleDeerHabitat)
# LSDMSummerPre = cohqt.applyLekUpliftModifierPre(winterHabitatPre,
# LekPresenceRaster)
seasonalHabitatRasters = [
summerHabitatPre, migratoryHabitatPre, winterHabitatPre
]
# Save outputs
summerHabitatPre.save(MULE_PRE_SUMMER)
# LSDMWinterPre.save("Pre_LSDM_Winter")
migratoryHabitatPre.save(MULE_PRE_MIGRATION)
# LSDMBreedingPre.save("Pre_LSDM_Breeding")
winterHabitatPre.save(MULE_PRE_WINTER)
# LSDMSummerPre.save("Pre_LSDM_Summer")
# Calc zonal stats for pre-project modifiers (three seasons)
term = cheStandard.DebitTerms[0]
for season, raster in zip(cheStandard.MuleDeerSeasons,
seasonalHabitatRasters):
# Update message
arcpy.AddMessage("Summarizing Mule Deer " + term + " " + season)
# Calculate zonal statistics for each map unit
inZoneData = Debit_Project_Area
inValueRaster = raster
zoneField = fields[0]
outTable = "Mule_Stats_" + term + "_" + season
hqtlib.CalcZonalStats(inZoneData, zoneField, inValueRaster,
outTable)
# Join the zonal statistic to the Map Units Dissolve table
fieldName = "Mule_" + term + "_" + season
hqtlib.JoinMeanToTable(inZoneData, outTable, zoneField, fieldName)
# # Calculate average of three seasonal habitat rasters pre-project
# finalPreCumulative = hqtlib.calcAverageHabitatQuality(
# seasonalHabitatRasters
# )
# finalPreCumulative.save(CUMULATIVE_MODIFIER_PRE)
# Calculate post-project cumulative habitat modifiers
summerHabitatPost = cohqt.calcSummerHabitatMD(
Projected_Anthro_Disturbance,
MuleDeer_LDI,
SummerModifier,
SuitableHabitat=MuleDeerHabitat)
# LSDMWinterPost = cohqt.applyLekUpliftModifierPost(summerHabitatPost,
# LekPresenceRaster)
migratoryHabitatPost = cohqt.calcMigratoryHabitatMD(
Projected_Anthro_Disturbance,
MuleDeer_LDI,
MigrationModifier,
SuitableHabitat=MuleDeerHabitat)
# LSDMBreedingPost = cohqt.applyLekUpliftModifierPost(migratoryHabitatPost,
# LekPresenceRaster)
winterHabitatPost = cohqt.calcWinterHabitatMD(
Projected_Anthro_Disturbance,
MuleDeer_LDI,
WinterModifier,
SuitableHabitat=MuleDeerHabitat)
# LSDMSummerPost = cohqt.applyLekUpliftModifierPost(winterHabitatPost,
# LekPresenceRaster)
seasonalHabitatRasters = [
summerHabitatPost, migratoryHabitatPost, winterHabitatPost
]
# Save outputs
summerHabitatPost.save(MULE_POST_SUMMER)
# LSDMWinterPre.save("Pre_LSDM_Winter")
migratoryHabitatPost.save(MULE_POST_MIGRATION)
# LSDMBreedingPre.save("Pre_LSDM_Breeding")
winterHabitatPost.save(MULE_POST_WINTER)
# LSDMSummerPre.save("Pre_LSDM_Summer")
# Calc zonal stats for pre-project modifiers (three seasons)
term = cheStandard.DebitTerms[1]
for season, raster in zip(cheStandard.MuleDeerSeasons,
seasonalHabitatRasters):
# Update message
arcpy.AddMessage("Summarizing Mule Deer " + term + " " + season)
# Calculate zonal statistics for each map unit
inZoneData = Debit_Project_Area
inValueRaster = raster
zoneField = fields[0]
outTable = "Mule_Stats_" + term + "_" + season
hqtlib.CalcZonalStats(inZoneData, zoneField, inValueRaster,
outTable)
# Join the zonal statistic to the Map Units Dissolve table
fieldName = "Mule_" + term + "_" + season
hqtlib.JoinMeanToTable(inZoneData, outTable, zoneField, fieldName)
# # Calculate average of three seasonal habitat rasters post-project
# finalPostCumulative = hqtlib.calcAverageHabitatQuality(
# seasonalHabitatRasters
# )
# finalPostCumulative.save(CUMULATIVE_MODIFIER_POST)
# Calculate permanent cumulative habtiat modifiers
# Update message
arcpy.AddMessage("Calculating Mule Deer Impact")
# Calculate impact
pre_fields = [
"Mule_Pre_Summer", "Mule_Pre_Migration", "Mule_Pre_Winter"
]
post_fields = [
"Mule_Post_Summer", "Mule_Post_Migration", "Mule_Post_Winter"
]
out_fields = [
"Mule_Summer_Impact", "Mule_Migration_Impact", "Mule_Winter_Impact"
]
for i in range(len(pre_fields)):
pre_field = pre_fields[i]
post_field = post_fields[i]
out_field = out_fields[i]
cohqt.calcDebits(Debit_Project_Area, pre_field, post_field,
out_field)
# # Update message
# arcpy.AddMessage("Creating visualization of impact from debit project")
#
# # Calculate impact intensity for debit project
# debit_impact = hqtlib.calcImpact(finalPreCumulative, finalPostCumulative)
# debit_impact.save(DEBIT_PROJECT_IMPACT)
#
# # Add Debit Impact raster to map and save map document
# feature = debit_impact
# layerFile = cheStandard.getLayerFile("DebitProjectImpact.lyr")
# hqtlib.AddToMap(feature, layerFile, zoom_to=True)
### END MULE DEER ###
if not is_grsg and not is_mule:
arcpy.AddMessage("Impacts were not detected in any habitat type. "
"Please check credit project boundary and try "
"again")
# Create Map_Units layer
in_data = Debit_Project_Area
out_data = MAP_UNITS
Map_Units = hqtlib.CreateMapUnits(in_data, out_data)
# Add Map_Units to map
layerFile = cheStandard.getLayerFile("MapUnits.lyr")
util.AddToMap(Map_Units, layerFile)
# Add fields Map_Unit_ID, Map_Unit_Name, and Meadow to Map_Units
fields = ["Map_Unit_ID", "Map_Unit_Name", "Notes", "Precip", "Transects"]
fieldTypes = ["SHORT", "TEXT", "TEXT", "TEXT", "SHORT"]
util.AddFields(Map_Units, fields, fieldTypes, copy_existing=True)
# Add Domains to Map_Units layer
# Create Domain for Map_Unit_ID attributes
domainName = "Map_Unit_ID"
range_low = 0
range_high = 10000
util.AddRangeDomain(Map_Units, projectGDB, domainName, range_low,
range_high)
# Create Domain for Precip attributes
feature_list = [Map_Units]
domain_name = "Precip"
code_list = ["Arid", "Mesic"]
util.AddCodedTextDomain(feature_list, projectGDB, domain_name, code_list)
# Update message
arcpy.AddMessage("Cleaning up workspace")
# Clean up
for raster in arcpy.ListRasters("*_Subtype_Disturbance"):
arcpy.Delete_management(raster)
for raster in arcpy.ListRasters("*_Type_Disturbance"):
arcpy.Delete_management(raster)
arcpy.Delete_management("in_memory")
try:
arcpy.Delete_management(scratch_folder)
except:
pass
# Save map document and exit
if arcpy.ListInstallations()[0] == 'arcgispro':
p = arcpy.mp.ArcGISProject("CURRENT")
p.save()
else:
mxd = arcpy.mapping.MapDocument("CURRENT")
mxd.save()