asp = 'NS'
# modify weather 'up','down','avg'
# runs average weather
# wStations = ['BRW', 'LDP', 'Treeline', 'SCR', 'LW']
# for w in wStations:
# mpiGO_(weatherstation=w, T='avg', P='avg')
weatherstation = 'Treeline'
Temp = 'avg'
Precip = 'avg'
iteration = 1
# Read the DEM
(grid, elevation) = read_esri_ascii('topoDEM_{}_d100x.asc'.format(asp))
# Representative grid
grid1 = rmg(5,4,5)
# reads in the inputs
InputFile = 'CA_veginputs_{}_{}T_{}P.txt'.format(weatherstation, Temp, Precip)
data = txt_data_dict(InputFile) # Create dictionary that holds the inputs
PD_D, PD_W, Rad, Rad_PET, PET_Tree_W, PET_Shrub_W, PET_Grass_W, \
PET_Tree_D, PET_Shrub_D, PET_Grass_D, SM, VEG, \
vegca = Initialize_(data, grid, grid1, elevation)
storms = EstimateStormsPerYear_(data)
n = n_years * storms # Number of storms the model will be run for
# creates empty arrays to store data
P, Tb, Tr, Time, CumWaterStress, VegType, VegTypeN, VegTypeE, VegTypeS, \
VegTypeW, PET_, Rad_Factor, EP30, PET_threshold = \
print(name_simulation)
try:
os.chdir(sim)
except:
os.mkdir(sim)
## Creating folders to categorize and store plots
sim_R = sim + 'Elev/'
sim_V = sim + 'Veg/'
sim_Rnorm = sim + 'norm_Elev/'
ensure_dir(sim_R)
ensure_dir(sim_V)
ensure_dir(sim_Rnorm)
## Initialize grid
grid = rmg((1000, 1000), 2.5) # Grid creation
# Create State Variable - R
R = np.ones(grid.number_of_cells)
#R = np.random.random(grid.number_of_cells) * 2 + \
# (-2)*np.ones(grid.number_of_cells, dtype=float)
print('R_sum() - Initial = ', R.sum())
# Create State Variable - V
V = compose_veg_grid(grid,
percent_bare=0.3,
percent_grass=0.3,
percent_shrub=0.4) # Organization is random
## Inputs
n_years = 300 # number of years to run model
plot_interval = 50 # interval at which plots are generated
# Fire Inputs
m, n = line.split(':')
line = f.next()
e = line[:].strip()
if e[0].isdigit():
if e.find('.') != -1:
data1[m.strip()] = float(line[:].strip())
else:
data1[m.strip()] = int(line[:].strip())
else:
data1[m.strip()] = line[:].strip()
f.close()
return data1.copy()
## Initialize domain
grid1 = rmg(100,100,5.) # Grid for Cellular Automaton modeling of plant types
grid1['node']['Elevation'] = 1700. * np.ones(grid1.number_of_nodes)
grid = rmg(5,4,5) # Representative grid for Ecohydrology of each plant type
grid['node']['Elevation'] = 1700. * np.ones(grid.number_of_nodes)
## Initialize random plant type field
grid1['cell']['VegetationType'] = np.random.choice([0,1,2,3,4,5],grid1.number_of_cells)
## Plant types are defined as following:
# GRASS = 0; SHRUB = 1; TREE = 2; BARE = 3;
# SHRUBSEEDLING = 4; TREESEEDLING = 5
## Assign plant type for representative ecohydrologic simulations
grid['cell']['VegetationType'] = np.arange(0,6)
## Create input dictionary from text file
InputFile = 'Inputs_Vegetation_CA.txt'
This tutorial is on:
landlab/tutorials/ecohydrology/cellular_automaton_vegetation_flat_surface.ipynb
Creating a (.py) version of the same.
@author: Sai Nudurupati & Erkan Istanbulluoglu
"""
import time
import numpy as np
from landlab import RasterModelGrid as rmg
from Ecohyd_functions_flat import (txt_data_dict, Initialize_, Empty_arrays,
Create_PET_lookup, Save_, Plot_)
grid1 = rmg((100, 100), spacing=(5., 5.))
grid = rmg((5, 4), spacing=(5., 5.))
InputFile = 'Inputs_Vegetation_CA_flat.txt'
data = txt_data_dict(InputFile) # Create dictionary that holds the inputs
PD_D, PD_W, Rad, PET_Tree, PET_Shrub, PET_Grass, SM, VEG, vegca = Initialize_(
data, grid, grid1)
n_years = 1200 # Approx number of years for model to run
# Calculate approximate number of storms per year
fraction_wet = (data['doy__end_of_monsoon']-data['doy__start_of_monsoon'])/365.
fraction_dry = 1 - fraction_wet
no_of_storms_wet = (8760 * (fraction_wet)/(data['mean_interstorm_wet'] +
data['mean_storm_wet']))
no_of_storms_dry = (8760 * (fraction_dry)/(data['mean_interstorm_dry'] +
landlab/tutorials/ecohydrology/cellular_automaton_vegetation_DEM.ipynb
Creating a (.py) version of the same.
@author: Sai Nudurupati & Erkan Istanbulluoglu
"""
import time
import numpy as np
from landlab.io import read_esri_ascii
from landlab import RasterModelGrid as rmg
from Ecohyd_functions_DEM import (txt_data_dict, Initialize_, Empty_arrays,
Create_PET_lookup, Save_, Plot_)
(grid, elevation) = read_esri_ascii('DEM_10m.asc') # Read the DEM
grid1 = rmg((5, 4), spacing=(5., 5.)) # Representative grid
InputFile = 'Inputs_Vegetation_CA.txt'
data = txt_data_dict(InputFile) # Creates dictionary that holds the inputs
PD_D, PD_W, Rad, Rad_PET, PET_Tree, PET_Shrub, PET_Grass, SM, VEG, vegca = (
Initialize_(data, grid, grid1, elevation))
n_years = 50 # Approx number of years for model to run
# Calculate approximate number of storms per year
fraction_wet = (data['doy__end_of_monsoon'] -
data['doy__start_of_monsoon']) / 365.
fraction_dry = 1 - fraction_wet
no_of_storms_wet = (8760 * (fraction_wet) /
(data['mean_interstorm_wet'] + data['mean_storm_wet']))
no_of_storms_dry = (8760 * (fraction_dry) /
def run_ecohydrology_model(grid,
input_data,
input_file,
synthetic_storms=True,
number_of_storms=None,
number_of_years=None,
first_julian_day_of_observations=0,
pet_method='Cosine',
save_files=False,
sim_name='Trial'):
# Create data object by reading in the input_file
data = load_params(input_file)
# Create a grid that can hold enough cells to represent all individual
# vegetation types
grid_veg = rmg((5, 4), spacing=(5., 5.))
if pet_method == 'Cosine':
(precip_dry, precip_wet, radiation, pet_tree, pet_shrub, pet_grass,
soil_moisture, vegetation,
vegca) = initialize_components(data,
grid_veg,
grid,
pet_method='Cosine')
elif pet_method == 'PriestleyTaylor':
(precip_dry, precip_wet, radiation, pet_met, soil_moisture, vegetation,
vegca) = initialize_components(data,
grid_veg,
grid,
pet_method='PriestleyTaylor')
if number_of_years != None:
# Calculate approximate number of storms per year
fraction_wet = (
(data['doy__end_of_monsoon'] - data['doy__start_of_monsoon']) /
365.)
fraction_dry = (1 - fraction_wet)
number_of_storms_wet = (
8760 * (fraction_wet) /
(data['mean_interstorm_wet'] + data['mean_storm_wet']))
number_of_storms_dry = (
8760 * (fraction_dry) /
(data['mean_interstorm_dry'] + data['mean_storm_dry']))
number_of_storms = int(number_of_years *
(number_of_storms_wet + number_of_storms_dry))
(precip, inter_storm_dt, storm_dt, Time, VegType, pet_arr, Rad_Factor,
Rad_Factor_met, EP30, EP30_met,
pet_threshold) = create_empty_arrays(number_of_storms,
grid_veg,
grid,
pet_method=pet_method)
if pet_method == 'Cosine':
(pet_arr, EP30) = create_pet_lookup(grid_veg,
radiation=radiation,
Rad_Factor=Rad_Factor,
EP30=EP30,
pet_tree=pet_tree,
pet_shrub=pet_shrub,
pet_grass=pet_grass,
pet_arr=pet_arr)
if pet_method == 'PriestleyTaylor':
(pet_arr, EP30_met) = create_pet_lookup(
grid_veg,
radiation=radiation,
Rad_Factor_met=Rad_Factor_met,
number_of_storms=number_of_storms,
pet_met=pet_met,
Tmax_met=input_data['Tmax_met'],
Tmin_met=input_data['Tmin_met'],
EP30_met=EP30_met,
first_day=first_julian_day_of_observations,
pet_method=pet_method,
pet_arr=pet_arr)
# declaring few variables that will be used in the storm loop
current_time = first_julian_day_of_observations / 365.25 # Initial time
time_check = 0. # Buffer to store current_time at previous storm
yrs = 0 # Keep track of number of years passed
water_stress = 0. # Buffer for Water Stress
Tg = 0 # Growing season in days
# # Run storm Loop
for i in range(0, number_of_storms):
# Update objects
# Calculate Day of Year (DOY)
julian = np.int(
np.floor((current_time - np.floor(current_time)) * 365.))
if synthetic_storms:
# Generate seasonal storms
# for Dry season
if julian < data['doy__start_of_monsoon'] or julian > data[
'doy__end_of_monsoon']:
precip_dry.update()
precip[i] = precip_dry.storm_depth
storm_dt[i] = precip_dry.storm_duration
inter_storm_dt[i] = precip_dry.interstorm_duration
# Wet Season - Jul to Sep - NA Monsoon
else:
precip_wet.update()
precip[i] = precip_wet.storm_depth
storm_dt[i] = precip_wet.storm_duration
inter_storm_dt[i] = precip_wet.interstorm_duration
else:
precip[i] = input_data['precip_met'][i]
storm_dt[i] = 0.
inter_storm_dt[i] = 24.
# Spatially distribute PET and its 30-day-mean (analogous to degree day)
if pet_method == 'Cosine':
grid_veg.at_cell['surface__potential_evapotranspiration_rate'] = (
pet_arr[julian])
grid_veg.at_cell[
'surface__potential_evapotranspiration_30day_mean'] = (
EP30[julian])
grid_veg.at_cell[
'surface__potential_evapotranspiration_rate__grass'] = (
np.full(grid_veg.number_of_cells, pet_arr[julian, 0]))
elif pet_method == 'PriestleyTaylor':
grid_veg.at_cell['surface__potential_evapotranspiration_rate'] = (
pet_arr[i])
grid_veg.at_cell[
'surface__potential_evapotranspiration_30day_mean'] = (
EP30_met[i])
grid_veg.at_cell[
'surface__potential_evapotranspiration_rate__grass'] = (
np.full(grid_veg.number_of_cells, pet_arr[i, 0]))
# Assign spatial rainfall data
grid_veg.at_cell['rainfall__daily_depth'] = (np.full(
grid_veg.number_of_cells, precip[i]))
# Update soil moisture component
current_time = soil_moisture.update(current_time,
Tr=storm_dt[i],
Tb=inter_storm_dt[i])
# Decide whether its growing season or not
if pet_method == 'Cosine':
if julian != 364:
if EP30[julian + 1, 0] > EP30[julian, 0]:
pet_threshold = 1
# 1 corresponds to ETThresholdup (begin growing season)
if EP30[julian, 0] > vegetation._ETthresholdup:
growing_season = True
else:
growing_season = False
else:
pet_threshold = 0
# 0 corresponds to ETThresholddown (end growing season)
if EP30[julian, 0] > vegetation._ETthresholddown:
growing_season = True
else:
growing_season = False
elif pet_method == 'PriestleyTaylor':
if i != number_of_storms - 1:
if EP30_met[i + 1, 0] > EP30_met[i, 0]:
pet_threshold = 1
# 1 corresponds to ETThresholdup (begin growing season)
if EP30_met[i, 0] > vegetation._ETthresholdup:
growing_season = True
else:
growing_season = False
else:
pet_threshold = 0
# 0 corresponds to ETThresholddown (end growing season)
if EP30_met[i, 0] > vegetation._ETthresholddown:
growing_season = True
else:
growing_season = False
# Update vegetation component
vegetation.update(PETThreshold_switch=pet_threshold,
Tb=inter_storm_dt[i],
Tr=storm_dt[i])
if growing_season:
# Update yearly cumulative water stress data
Tg += (storm_dt[i] + inter_storm_dt[i]
) / 24. # Incrementing growing season storm count
water_stress += ((grid_veg.at_cell['vegetation__water_stress']) *
inter_storm_dt[i] / 24.)
# Record time (optional)
Time[i] = current_time
# Update spatial PFTs with Cellular Automata rules
if (current_time - time_check) >= 1.:
if yrs % 100 == 0:
print('Elapsed time = ', yrs, ' years')
VegType[yrs] = grid.at_cell['vegetation__plant_functional_type']
WS_ = np.choose(VegType[yrs], water_stress)
grid.at_cell['vegetation__cumulative_water_stress'] = WS_ / Tg
vegca.update()
time_check = np.floor(current_time)
water_stress = 0
yrs += 1
Tg = 0
VegType[yrs] = grid.at_cell['vegetation__plant_functional_type']
if save_files:
save_data(sim_name, inter_storm_dt, storm_dt, precip, VegType, yrs, 0,
Time)
if pet_method == 'Cosine':
returns_debug = [
grid_veg, precip_dry, precip_wet, radiation, pet_tree, pet_shrub,
pet_grass, soil_moisture, vegetation, vegca
]
elif pet_method == 'PriestleyTaylor':
returns_debug = [
grid_veg, precip_dry, precip_wet, radiation, pet_met,
soil_moisture, vegetation, vegca
]
return (VegType, yrs - 1, returns_debug)
data1[m.strip()] = line[:].strip()
f.close()
return data1.copy()
## Point to the input DEM
_DEFAULT_INPUT_FILE_1 = os.path.join(os.path.dirname(__file__),
'DEM_10m.asc')
InputFile = 'Inputs_Vegetation_CA.txt'
data = txt_data_dict( InputFile ) # Create dictionary that holds the inputs
## Importing Grid and Elevations from DEM
(grid1,elevation) = read_esri_ascii(_DEFAULT_INPUT_FILE_1)
grid1['node']['Elevation'] = elevation
grid = rmg(5,4,5)
grid['node']['Elevation'] = 1700. * np.ones(grid.number_of_nodes)
grid1['cell']['VegetationType'] = np.random.randint(0,4,grid1.number_of_cells)
# Age of the plants is randomnly generated by the constructor of vegca
# component. Seedlings of shrubs and trees are determined by their age
# within the constructor as well. Hence the random vegetation type
# field is called for types GRASS, SHRUB, TREE and BARE only. -SN 10Mar15
grid['cell']['VegetationType'] = np.arange(0,6)
# Create radiation, soil moisture and Vegetation objects
PD_D = PrecipitationDistribution(mean_storm = data['mean_storm_dry'], \
mean_interstorm = data['mean_interstorm_dry'],
mean_storm_depth = data['mean_storm_depth_dry'])
PD_W = PrecipitationDistribution(mean_storm = data['mean_storm_wet'], \
mean_interstorm = data['mean_interstorm_wet'],
'DEM_10m.asc')
## Point to the input elevation file
_DEFAULT_INPUT_FILE_2 = os.path.join(os.path.dirname(__file__),
'elevation_NS.npy')
InputFile = 'Inputs_Vegetation_CA.txt'
data = txt_data_dict( InputFile ) # Create dictionary that holds the inputs
USE_DEM = 1 # Make this 0 to use a custom grid
if USE_DEM == 1:
## Importing Grid and Elevations from DEM
(grid,elevation) = read_esri_ascii(_DEFAULT_INPUT_FILE_1)
grid['node']['Elevation'] = elevation
else:
## Use an open book like grid - custom grid
grid = rmg(53,67,10.)
elev = np.load(_DEFAULT_INPUT_FILE_2)
grid['node']['Elevation'] = elev
grid['cell']['VegetationType'] = np.random.randint(0,4,grid.number_of_cells)
# Age of the plants is randomnly generated by the constructor of vegca
# component. Seedlings of shrubs and trees are determined by their age
# within the constructor as well. Hence the random vegetation type
# field is called for types GRASS, SHRUB, TREE and BARE only. -SN 10Mar15
# Dummy grid for PET
grid1 = rmg(5,4,5)
grid1['node']['Elevation'] = 1700. * np.ones(grid1.number_of_nodes)
grid1['cell']['VegetationType'] = np.arange(0,6)
# Create radiation, soil moisture and Vegetation objects
PD_D = PrecipitationDistribution(mean_storm = data['mean_storm_dry'], \
mean_interstorm = data['mean_interstorm_dry'],
else:
data1[m.strip()] = line[:].strip()
f.close()
return data1.copy()
## Point to the input DEM
_DEFAULT_INPUT_FILE_1 = os.path.join(os.path.dirname(__file__), 'DEM_10m.asc')
InputFile = 'Inputs_Vegetation_CA.txt'
data = txt_data_dict(InputFile) # Create dictionary that holds the inputs
## Importing Grid and Elevations from DEM
(grid1, elevation) = read_esri_ascii(_DEFAULT_INPUT_FILE_1)
grid1['node']['Elevation'] = elevation
grid = rmg(5, 4, 5)
grid['node']['Elevation'] = 1700. * np.ones(grid.number_of_nodes)
grid1['cell']['VegetationType'] = np.random.randint(0, 4,
grid1.number_of_cells)
# Age of the plants is randomnly generated by the constructor of vegca
# component. Seedlings of shrubs and trees are determined by their age
# within the constructor as well. Hence the random vegetation type
# field is called for types GRASS, SHRUB, TREE and BARE only. -SN 10Mar15
grid['cell']['VegetationType'] = np.arange(0, 6)
# Create radiation, soil moisture and Vegetation objects
PD_D = PrecipitationDistribution(mean_storm = data['mean_storm_dry'], \
mean_interstorm = data['mean_interstorm_dry'],
mean_storm_depth = data['mean_storm_depth_dry'])
PD_W = PrecipitationDistribution(mean_storm = data['mean_storm_wet'], \
This tutorial is on:
landlab/tutorials/ecohydrology/cellular_automaton_vegetation_flat_surface.ipynb
Creating a (.py) version of the same.
@author: Sai Nudurupati & Erkan Istanbulluoglu
"""
import time
import numpy as np
from landlab import RasterModelGrid as rmg
from Ecohyd_functions_flat import (txt_data_dict, Initialize_, Empty_arrays,
Create_PET_lookup, Save_, Plot_)
grid1 = rmg((100, 100), spacing=(5., 5.))
grid = rmg((5, 4), spacing=(5., 5.))
InputFile = 'Inputs_Vegetation_CA.txt'
data = txt_data_dict(InputFile) # Create dictionary that holds the inputs
PD_D, PD_W, Rad, PET_Tree, PET_Shrub, PET_Grass, SM, VEG, vegca = Initialize_(
data, grid, grid1)
n_years = 1200 # Approx number of years for model to run
# Calculate approximate number of storms per year
fraction_wet = (data['doy__end_of_monsoon'] -
data['doy__start_of_monsoon']) / 365.
fraction_dry = 1 - fraction_wet
no_of_storms_wet = (8760 * (fraction_wet) /
(data['mean_interstorm_wet'] + data['mean_storm_wet']))
import matplotlib as mpl
import matplotlib.pyplot as plt
## Point to the input DEM
_DEFAULT_INPUT_FILE_1 = os.path.join(os.path.dirname(__file__), 'DEM_10m.asc')
## Point to the input elevation file
_DEFAULT_INPUT_FILE_2 = os.path.join(os.path.dirname(__file__),
'elevation_NS.npy')
USE_DEM = 1 # Make this 0 to use a custom grid
if USE_DEM == 1:
## Importing Grid and Elevations from DEM
(grid, elevation) = read_esri_ascii(_DEFAULT_INPUT_FILE_1)
grid['node']['Elevation'] = elevation
else:
## Use an open book like grid - custom grid
grid = rmg(53, 67, 10.)
elev = np.load(_DEFAULT_INPUT_FILE_2)
grid['node']['Elevation'] = elev
sim = 'long_DEM_'
CumWaterStress = np.load(sim + 'CumWaterStress.npy')
P = np.load(sim + 'P.npy')
Tb = np.load(sim + 'Tb.npy')
Tr = np.load(sim + 'Tr.npy')
yrs = np.load(sim + 'Years.npy')
VegType = np.load(sim + 'VegType.npy')
n = P.shape[0] # Number of iterations
Time = np.empty(n)
Time[0] = 0
for x in range(1, n):
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt
## Point to the input DEM
_DEFAULT_INPUT_FILE_1 = os.path.join(os.path.dirname(__file__), "DEM_10m.asc")
## Point to the input elevation file
_DEFAULT_INPUT_FILE_2 = os.path.join(os.path.dirname(__file__), "elevation_NS.npy")
USE_DEM = 1 # Make this 0 to use a custom grid
if USE_DEM == 1:
## Importing Grid and Elevations from DEM
(grid, elevation) = read_esri_ascii(_DEFAULT_INPUT_FILE_1)
grid["node"]["Elevation"] = elevation
else:
## Use an open book like grid - custom grid
grid = rmg(53, 67, 10.0)
elev = np.load(_DEFAULT_INPUT_FILE_2)
grid["node"]["Elevation"] = elev
sim = "long_DEM_"
CumWaterStress = np.load(sim + "CumWaterStress.npy")
P = np.load(sim + "P.npy")
Tb = np.load(sim + "Tb.npy")
Tr = np.load(sim + "Tr.npy")
yrs = np.load(sim + "Years.npy")
VegType = np.load(sim + "VegType.npy")
n = P.shape[0] # Number of iterations
Time = np.empty(n)
Time[0] = 0
for x in range(1, n):
landlab/tutorials/ecohydrology/cellular_automaton_vegetation_DEM.ipynb
Creating a (.py) version of the same.
@author: Sai Nudurupati & Erkan Istanbulluoglu
"""
import time
import numpy as np
from landlab.io import read_esri_ascii
from landlab import RasterModelGrid as rmg
from Ecohyd_functions_DEM import (txt_data_dict, Initialize_, Empty_arrays,
Create_PET_lookup, Save_, Plot_)
(grid, elevation) = read_esri_ascii('DEM_10m.asc') # Read the DEM
grid1 = rmg((5, 4), spacing=(5., 5.)) # Representative grid
InputFile = 'Inputs_Vegetation_CA_DEM.txt'
data = txt_data_dict(InputFile) # Creates dictionary that holds the inputs
PD_D, PD_W, Rad, Rad_PET, PET_Tree, PET_Shrub, PET_Grass, SM, VEG, vegca = (
Initialize_(data, grid, grid1, elevation))
n_years = 50 # Approx number of years for model to run
# Calculate approximate number of storms per year
fraction_wet = (data['doy__end_of_monsoon']-data['doy__start_of_monsoon'])/365.
fraction_dry = 1 - fraction_wet
no_of_storms_wet = (8760 * (fraction_wet)/(data['mean_interstorm_wet'] +
data['mean_storm_wet']))
no_of_storms_dry = (8760 * (fraction_dry)/(data['mean_interstorm_dry'] +
data['mean_storm_dry']))
m, n = line.split(':')
line = f.next()
e = line[:].strip()
if e[0].isdigit():
if e.find('.') != -1:
data1[m.strip()] = float(line[:].strip())
else:
data1[m.strip()] = int(line[:].strip())
else:
data1[m.strip()] = line[:].strip()
f.close()
return data1.copy()
## Initialize domain
grid1 = rmg(100, 100,
5.) # Grid for Cellular Automaton modeling of plant types
grid1['node']['Elevation'] = 1700. * np.ones(grid1.number_of_nodes)
grid = rmg(5, 4, 5) # Representative grid for Ecohydrology of each plant type
grid['node']['Elevation'] = 1700. * np.ones(grid.number_of_nodes)
## Initialize random plant type field
grid1['cell']['VegetationType'] = np.random.choice([0, 1, 2, 3, 4, 5],
grid1.number_of_cells)
## Plant types are defined as following:
# GRASS = 0; SHRUB = 1; TREE = 2; BARE = 3;
# SHRUBSEEDLING = 4; TREESEEDLING = 5
## Assign plant type for representative ecohydrologic simulations
grid['cell']['VegetationType'] = np.arange(0, 6)
## Create input dictionary from text file
from landlab.plot import imshow_grid
from landlab.plot import channel_profile as prf
from landlab.components.uniform_precip import PrecipitationDistribution
from matplotlib.pyplot import loglog
import matplotlib as mpl
#construct a 2D numerical model on a raster grid
#erosional degradation of a karst sinkhole
#randomly generate rain onto the grid
#evolves from downhole vertical movement of aqueous carbonate rock and hole radially widens
#downhole vert movement and hole widening proportional water input (w carbonic acid) * transport coefficient
#should make a 3d conical shape
######## model the sinkhole development in plan view and cross section ##################################
mg = rmg((40, 40),
1.0) #master grid with 40 rows, 40 columns, grid spacing of 1m
z = mg.add_zeros('node', 'Plan view topography') #call function add zeros
# make plan view sinkhole trace by equation of a circle line (x-h)**2 + (y-k)**2 = r**2
# h,k represents the coordinates of the center of the circle. r is radius
r = 5 #[m]
h = 20
k = 20
sinkhole_trace_y_upper = (((r**2) - (
(mg.x_of_node - h)**2))**0.5) + k # half circle upper eq
sinkhole_trace_y_lower = (-1 * (((r**2) - (
(mg.x_of_node - h)**2))**0.5)) + k # half circle lower eq
# outside of the sinkhole trace, the ground is moving up relative to the sinkhole
sinkdown_nodes1 = np.where(mg.y_of_node < sinkhole_trace_y_upper)
_DEFAULT_INPUT_FILE_1 = os.path.join(os.path.dirname(__file__), 'DEM_10m.asc')
## Point to the input elevation file
_DEFAULT_INPUT_FILE_2 = os.path.join(os.path.dirname(__file__),
'elevation_NS.npy')
InputFile = 'Inputs_Vegetation_CA.txt'
data = txt_data_dict(InputFile) # Create dictionary that holds the inputs
USE_DEM = 1 # Make this 0 to use a custom grid
if USE_DEM == 1:
## Importing Grid and Elevations from DEM
(grid, elevation) = read_esri_ascii(_DEFAULT_INPUT_FILE_1)
grid['node']['Elevation'] = elevation
else:
## Use an open book like grid - custom grid
grid = rmg(53, 67, 10.)
elev = np.load(_DEFAULT_INPUT_FILE_2)
grid['node']['Elevation'] = elev
grid['cell']['VegetationType'] = np.random.randint(0, 4, grid.number_of_cells)
# Age of the plants is randomnly generated by the constructor of vegca
# component. Seedlings of shrubs and trees are determined by their age
# within the constructor as well. Hence the random vegetation type
# field is called for types GRASS, SHRUB, TREE and BARE only. -SN 10Mar15
# Dummy grid for PET
grid1 = rmg(5, 4, 5)
grid1['node']['Elevation'] = 1700. * np.ones(grid1.number_of_nodes)
grid1['cell']['VegetationType'] = np.arange(0, 6)
# Create radiation, soil moisture and Vegetation objects
PD_D = PrecipitationDistribution(mean_storm = data['mean_storm_dry'], \
mean_interstorm = data['mean_interstorm_dry'],
