def initialize(self, input_stream):
# Create a ModelParameterDictionary for the inputs
if type(input_stream)==ModelParameterDictionary:
inputs = input_stream
else:
inputs = ModelParameterDictionary(input_stream)
# Read input/configuration parameters
self.kd = inputs.read_float('DIFMOD_KD')
try:
self.uplift_rate = inputs.read_float('DIFMOD_UPLIFT_RATE')
except:
self.uplift_rate = inputs.read_float('uplift_rate')
try:
self.values_to_diffuse = inputs.read_str('values_to_diffuse')
except:
self.values_to_diffuse = 'planet_surface__elevation'
try:
self.timestep_in = inputs.read_float('dt')
except:
print 'No fixed timestep supplied, it must be set dynamically somewhere else. Be sure to call input_timestep(timestep_in) as part of your run loop.'
# Create grid if one doesn't already exist
if self.grid==None:
self.grid = create_and_initialize_grid(input_stream)
# Set internal time step
# ..todo:
# implement mechanism to compute time-steps dynamically if grid is
# adaptive/changing
dx = self.grid.min_active_link_length() # smallest active link length
self.dt = _ALPHA*dx*dx/self.kd # CFL condition
try:
self.tstep_ratio = self.timestep_in/self.dt
except:
pass
# Get a list of interior cells
self.interior_cells = self.grid.get_core_cell_node_ids()
# Here we're experimenting with different approaches: with
# 'make_all_data', we create and manage all the data we need and embed
# it all in the grid. With 'explicit', we require the caller/user to
# provide data.
if _VERSION=='make_all_data':
#print 'creating internal data'
self.z = self.grid.add_zeros('node', 'landscape_surface__elevation')
self.g = self.grid.add_zeros('active_link', 'landscape_surface__gradient') # surface gradients
self.qs = self.grid.add_zeros('active_link','unit_sediment_flux') # unit sediment flux
self.dqds = self.grid.add_zeros('node', 'sediment_flux_divergence') # sed flux derivative
elif _VERSION=='explicit':
pass
else:
# Create data arrays for variables that won't (?) be shared with other
# components
self.g = self.grid.create_active_link_array_zeros() # surface gradients
self.qs = self.grid.create_active_link_array_zeros() # unit sediment flux
self.dqds = self.grid.create_node_array_zeros() # sed flux derivative
def initialize(self, grid=None, input_file=None, intensity=None, stormduration=None):
self.grid = grid
if self.grid==None:
self.grid = create_and_initialize_grid(input_file)
##self.current_time = current_time <- this isn't being used yet.
# Create a ModelParameterDictionary for the inputs
MPD = ModelParameterDictionary()
## I am not sure we want to use an instance of MPD as an input_file. I'm confused about this. SO for
## now I changed this to reflect other component types
if input_file is None:
input_file = _DEFAULT_INPUT_FILE
MPD.read_from_file(input_file)
## This was the old way... where an instance of MPD is an input_file
#if type(input_file)==MPD:
# inputs = input_file
#else:
# inputs = MPD(input_file)
# Read input/configuration parameters
self.m_n = MPD.read_float('MANNINGS_N')
if intensity == None:
self.rainfall_mmhr = MPD.read_float( 'RAINFALL_RATE')
else:
self.rainfall_mmhr = intensity
if stormduration == None:
self.rain_duration = MPD.read_float( 'RAIN_DURATION' )
else:
self.rain_duration = stormduration
#self.h_init = 0.001 # initial thin layer of water (m)
#self.g = 9.8 # gravitational acceleration (m/s2)
#self.alpha = 0.2 # time-step factor (ND; from Bates et al., 2010)
#self.m_n_sq = self.m_n*self.m_n # manning's n squared
#self.rho = 1000 # density of water, kg/m^3
# Derived parameters ## THIS IS IMPORTANT - UNITS!!!! Double check precip component...
self.rainfall_rate = (self.rainfall_mmhr/1000.)/3600. # rainfall in m/s
# Set up state variables
self.hstart = grid.zeros(centering='node') + self.h_init
self.h = grid.zeros(centering='node') + self.h_init # water depth (m)
#NG why is water depth at each node and not at cells, which are only active
self.q = grid.zeros(centering='active_link') # unit discharge (m2/s)
self.dhdt = grid.zeros(centering='active_cell') # rate of water-depth change
def initialize(self, input_stream=None):
# If no input file/stream specified, use default (or command line?)
# (or default values?)
if input_stream==None:
input_stream = str(raw_input('Enter name of input file: '))
# Open input file
inputs = ModelParameterDictionary(input_stream)
# Create grid
self.grid = create_and_initialize_grid(inputs)
# Create a diffusion component
self.diffusion_component = diffusion.DiffusionComponent(self.grid)
self.diffusion_component.initialize(input_stream)
# Read parameters
self.run_duration = inputs.get('RUN_DURATION', ptype=float)
self.opt_netcdf_output = inputs.get('OPT_FILE_OUTPUT', ptype='bool')
self.opt_display_output = inputs.get('OPT_DISPLAY_OUTPUT', ptype='bool')
self.setup_output_timing(inputs)
def initialize(self, input_stream=None):
# If no input file/stream specified, use default (or command line?)
# (or default values?)
if input_stream == None:
input_stream = str(raw_input('Enter name of input file: '))
# Open input file
inputs = ModelParameterDictionary(input_stream)
# Create grid
self.grid = create_and_initialize_grid(inputs)
# Create a diffusion component
self.diffusion_component = diffusion.DiffusionComponent(self.grid)
self.diffusion_component.initialize(input_stream)
# Read parameters
self.run_duration = inputs.get('RUN_DURATION', ptype=float)
self.opt_netcdf_output = inputs.get('OPT_FILE_OUTPUT', ptype='bool')
self.opt_display_output = inputs.get('OPT_DISPLAY_OUTPUT',
ptype='bool')
self.setup_output_timing(inputs)
def initialize(self, input_stream):
# Create a ModelParameterDictionary for the inputs
if type(input_stream)==ModelParameterDictionary:
inputs = input_stream
else:
inputs = ModelParameterDictionary(input_stream)
# Read input/configuration parameters
self.kd = inputs.read_float('linear_diffusivity')
try:
self.uplift_rate = inputs.read_float('uplift_rate')
except MissingKeyError:
self.uplift_rate = 0.
try:
self.values_to_diffuse = inputs.read_string('values_to_diffuse')
except MissingKeyError:
self.values_to_diffuse = 'topographic__elevation'
else:
#take switch in the new field name in the class properties
for mysets in (self._input_var_names, self._output_var_names):
mysets.remove('topographic__elevation')
mysets.add(self.values_to_diffuse)
for mydicts in (self._var_units, self._var_mapping, self._var_doc):
mydicts[self.values_to_diffuse] = mydicts.pop('topographic__elevation')
try:
self.timestep_in = inputs.read_float('dt')
except MissingKeyError:
pass
# Create grid if one doesn't already exist
if self._grid is None:
self._grid = create_and_initialize_grid(input_stream)
# Set internal time step
# ..todo:
# implement mechanism to compute time-steps dynamically if grid is
# adaptive/changing
dx = self._grid.min_active_link_length() # smallest active link length
self.dt = _ALPHA*dx*dx/self.kd # CFL condition
try:
self.tstep_ratio = self.timestep_in/self.dt
except AttributeError:
pass
# Get a list of interior cells
self.interior_cells = self._grid.node_at_core_cell
##DEJH bites the bullet and forces the 2015 style with fields
# # Here we're experimenting with different approaches: with
# # 'make_all_data', we create and manage all the data we need and embed
# # it all in the grid. With 'explicit', we require the caller/user to
# # provide data.
# if _VERSION=='make_all_data':
# #print('creating internal data')
# self.z = self._grid.add_zeros('node', 'landscape_surface__elevation')
# self.g = self._grid.add_zeros('active_link', 'landscape_surface__gradient') # surface gradients
# self.qs = self._grid.add_zeros('active_link','unit_sediment_flux') # unit sediment flux
# self.dqds = self._grid.add_zeros('node', 'sediment_flux_divergence') # sed flux derivative
# elif _VERSION=='explicit':
# pass
# else:
# # Create data arrays for variables that won't (?) be shared with other
# # components
# self.g = self._grid.create_active_link_array_zeros() # surface gradients
# self.qs = self._grid.create_active_link_array_zeros() # unit sediment flux
# self.dqds = self._grid.create_node_array_zeros() # sed flux derivative
self.z = self._grid.at_node[self.values_to_diffuse]
g = self._grid.zeros(centering='link')
qs = self._grid.zeros(centering='link')
try:
self.g = self._grid.add_field('link', 'surface__gradient', g, noclobber=True) #note this will object if this exists already
except FieldError:
pass #field exists, so no problem
try:
self.qs = self._grid.add_field('link', 'unit_flux', qs, noclobber=True)
except FieldError:
pass
def initialize(self, input_stream):
# Create a ModelParameterDictionary for the inputs
if type(input_stream) == ModelParameterDictionary:
inputs = input_stream
else:
inputs = ModelParameterDictionary(input_stream)
# Read input/configuration parameters
self.kd = inputs.read_float('DIFMOD_KD')
try:
self.uplift_rate = inputs.read_float('DIFMOD_UPLIFT_RATE')
except:
self.uplift_rate = inputs.read_float('uplift_rate')
try:
self.values_to_diffuse = inputs.read_str('values_to_diffuse')
except:
self.values_to_diffuse = 'topographic_elevation'
try:
self.timestep_in = inputs.read_float('dt')
except:
print 'No fixed timestep supplied, it must be set dynamically somewhere else. Be sure to call input_timestep(timestep_in) as part of your run loop.'
# Create grid if one doesn't already exist
if self.grid == None:
self.grid = create_and_initialize_grid(input_stream)
# Set internal time step
# ..todo:
# implement mechanism to compute time-steps dynamically if grid is
# adaptive/changing
dx = self.grid.min_active_link_length() # smallest active link length
self.dt = _ALPHA * dx * dx / self.kd # CFL condition
try:
self.tstep_ratio = self.timestep_in / self.dt
except:
pass
# Get a list of interior cells
self.interior_cells = self.grid.get_core_cell_node_ids()
# Here we're experimenting with different approaches: with
# 'make_all_data', we create and manage all the data we need and embed
# it all in the grid. With 'explicit', we require the caller/user to
# provide data.
if _VERSION == 'make_all_data':
#print 'creating internal data'
self.z = self.grid.add_zeros('node',
'landscape_surface__elevation')
self.g = self.grid.add_zeros(
'active_link',
'landscape_surface__gradient') # surface gradients
self.qs = self.grid.add_zeros(
'active_link', 'unit_sediment_flux') # unit sediment flux
self.dqds = self.grid.add_zeros(
'node', 'sediment_flux_divergence') # sed flux derivative
elif _VERSION == 'explicit':
pass
else:
# Create data arrays for variables that won't (?) be shared with other
# components
self.g = self.grid.create_active_link_array_zeros(
) # surface gradients
self.qs = self.grid.create_active_link_array_zeros(
) # unit sediment flux
self.dqds = self.grid.create_node_array_zeros(
) # sed flux derivative
