def __init__(self,
domain,
friction=lambda h: 0.03,
indices=None,
polygon=None,
center=None,
radius=None,
description = None,
label = None,
logging = False,
verbose = False):
Operator.__init__(self, domain, description, label, logging, verbose)
Region.__init__(self, domain,
indices=indices,
polygon=polygon,
center=center,
radius=radius,
verbose=verbose)
#------------------------------------------
# Local variables
#------------------------------------------
self.friction = friction
self.friction_c = self.domain.get_quantity('friction').centroid_values
def __init__(self,
domain,
quantity,
value=None,
indices=None,
polygon=None,
center=None,
radius=None,
line=None,
description=None,
label=None,
logging=False,
verbose=False,
test_stage=True,
test_elevation=True):
Set_quantity.__init__(self,
domain,
quantity,
value,
indices=indices,
polygon=polygon,
center=center,
radius=radius,
line=line,
test_stage=test_stage,
test_elevation=test_elevation)
Operator.__init__(self, domain, description, label, logging, verbose)
def __init__(self, domain,
indices=None,
description = None,
label = None,
logging = False,
verbose = False):
Operator.__init__(self, domain, description, label, logging, verbose)
try:
wet_depth = self.domain.get_quantity('wetting_front_depth')
except:
Quantity(domain, name='wetting_front_depth', register=True)
# initialize as 0.5 cm to avoid too-fast rates
self.domain.set_quantity('wetting_front_depth', 0.0005)
self.wet_depth = self.domain.quantities['wetting_front_depth'].centroid_values
self.depth = self.domain.quantities['height'].centroid_values
# values for sand from Rawls and Brakensiek (1993) Hydrology Handbook
self.Ks = 0.00006544444 # Saturated hydraulic conductivity (meters/second)
self.psi = 0.0495 # Wetting front soil suction head (meters)
theta_s = 0.5
theta_i = 0.25
self.dtheta = theta_s - theta_i
def __init__(self,
domain,
quantity,
value=None,
indices=None,
polygon=None,
center=None,
radius=None,
line=None,
description = None,
label = None,
logging = False,
verbose = False,
test_stage=True,
test_elevation=True):
Set_quantity.__init__(self,
domain,
quantity,
value,
indices=indices,
polygon=polygon,
center=center,
radius=radius,
line=line,
test_stage=test_stage,
test_elevation=test_elevation)
Operator.__init__(self, domain, description, label, logging, verbose)
def __init__(self,
domain,
indices=None,
polygon=None,
center=None,
radius=None,
description=None,
label=None,
logging=False,
verbose=False):
Operator.__init__(self, domain, description, label, logging, verbose)
Region.__init__(self,
domain,
indices=indices,
polygon=polygon,
center=center,
radius=radius,
verbose=verbose)
# set some alaises
self.stage = self.domain.quantities['stage'].centroid_values
self.conc = self.domain.quantities['concentration'].centroid_values
self.depth = self.domain.quantities['height'].centroid_values
self.elev = self.domain.quantities['elevation'].centroid_values
self.xmom = self.domain.quantities['xmomentum'].centroid_values
self.ymom = self.domain.quantities['ymomentum'].centroid_values
def __init__(self, domain, use_diffusivity=True,
indices=None,
description = None,
label = None,
logging = False,
verbose = False):
Operator.__init__(self, domain, description, label, logging, verbose)
self.use_diffusivity = use_diffusivity
self.xmom = self.domain.quantities['xmomentum'].centroid_values
self.ymom = self.domain.quantities['ymomentum'].centroid_values
self.depth = self.domain.quantities['height'].centroid_values
self.num_cells = len(self.depth)
if self.use_diffusivity:
self.diffusivity = num.zeros((self.num_cells,))
self.mix_length = num.zeros((self.num_cells,))
try:
diff = self.domain.get_quantity('diffusivity')
except:
Quantity(domain, name='diffusivity', register=True)
self.domain.set_use_kinematic_viscosity(self.use_diffusivity)
self.quantity_flag = False
def __init__(self,
domain,
friction=lambda h: 0.03,
indices=None,
polygon=None,
center=None,
radius=None,
description=None,
label=None,
logging=False,
verbose=False):
Operator.__init__(self, domain, description, label, logging, verbose)
Region.__init__(self,
domain,
indices=indices,
polygon=polygon,
center=center,
radius=radius,
verbose=verbose)
#------------------------------------------
# Local variables
#------------------------------------------
self.friction = friction
self.friction_c = self.domain.get_quantity('friction').centroid_values
def __init__(self, domain, indices=None, description=None, label=None, logging=False, verbose=False):
Operator.__init__(self, domain, description, label, logging, verbose)
self.Cd = None
self.veg = None
try:
# the value in quantity 'veg_diameter' should be the stem diameter in meters
self.veg_diameter = self.domain.quantities["veg_diameter"].centroid_values
# self.veg_diameter = self.veg_diameter * 0.00104725
self.veg_diameter[self.veg_diameter < 0] = 0
self.domain.quantities["veg_diameter"].set_values(self.veg_diameter, location="centroids")
except:
self.veg_diameter = None
try:
# the value in quantity 'veg_spacing' should be the stem spacing in meters
self.veg_spacing = self.domain.quantities["veg_spacing"].centroid_values
except:
self.veg_spacing = None
try:
diff = self.domain.get_quantity("diffusivity")
except:
Quantity(domain, name="diffusivity", register=True)
self.domain.set_use_kinematic_viscosity(True)
self.xmom = self.domain.quantities["xmomentum"].centroid_values
self.ymom = self.domain.quantities["ymomentum"].centroid_values
self.depth = self.domain.quantities["height"].centroid_values
def __init__(self, domain, use_diffusivity=True,
indices=None,
description = None,
label = None,
logging = False,
verbose = False):
Operator.__init__(self, domain, description, label, logging, verbose)
self.use_diffusivity = use_diffusivity
self.xmom = self.domain.quantities['xmomentum'].centroid_values
self.ymom = self.domain.quantities['ymomentum'].centroid_values
self.depth = self.domain.quantities['height'].centroid_values
self.elev = self.domain.quantities['elevation'].centroid_values
self.num_cells = len(self.depth)
if self.use_diffusivity:
self.diffusivity = num.zeros((self.num_cells,))
self.mix_length = num.zeros((self.num_cells,))
try:
diff = self.domain.get_quantity('diffusivity')
except:
Quantity(domain, name='diffusivity', register=True)
self.domain.set_use_kinematic_viscosity(self.use_diffusivity)
self.quantity_flag = False
def __init__(self,
domain,
description = None,
label = None,
logging = False,
verbose = False):
Operator.__init__(self, domain, description, label, logging, verbose)
"""
Switches for optional processes
"""
if self.use_turbulence:
try:
diff = self.domain.get_quantity('diffusivity')
self.domain.set_use_kinematic_viscosity(True)
except KeyError:
msg = 'Quantity diffusivity not yet created. '
msg += 'Initialize when creating domain or set '
msg += 'turbulence as False. '
msg += 'Continuing without turbulence.'
print msg
self.use_turbulence = False
"""
Call quantities
"""
self.q_elev = self.domain.quantities['elevation']
self.q_stage = self.domain.quantities['stage']
self.q_xmom=self.domain.quantities['xmomentum']
self.q_ymom=self.domain.quantities['ymomentum']
self.elev_v = self.q_elev.vertex_values
self.stage_v = self.q_stage.vertex_values
self.xmom_v = self.q_xmom.vertex_values
self.ymom_v = self.q_ymom.vertex_values
self.elev_c = self.q_elev.centroid_values
self.stage_c = self.q_stage.centroid_values
self.xmom_c = self.q_xmom.centroid_values
self.ymom_c = self.q_ymom.centroid_values
#-----------------------------------------
# Some extras
#-----------------------------------------
self.max_change = 0
self.domain.optimise_dry_cells = 0
# to allow for one-equation turbulence calculations
self.stem_diameter = 0 * self.elev_v
self.stem_spacing = 0 * self.elev_v
self.ad = 0 * self.elev_v
def __init__(self,
domain,
threshold=0.0,
base=0.0,
indices=None,
polygon=None,
center=None,
radius=None,
Ra=34.0,
description=None,
label=None,
logging=False,
verbose=False):
Operator.__init__(self, domain, description, label, logging, verbose)
Region.__init__(self,
domain,
indices=indices,
polygon=polygon,
center=center,
radius=radius,
verbose=verbose)
#-------------------------------------------
# set some sand and water properties
#-------------------------------------------
self.Wd = 1000 # water mass density kg/m3
self.Sd = 1800 # sediment mass density kg/m3
self.G = 9.8 # acceleration due to gravity m/sec/sec
self.n = 0.030 # sand mannings n - mostly bare with undulations
self.Tau_crit = 2.1 # critical (detachment) bed shear stress Pa
self.Kd = 0.025 # detachment factor Froelich Table 2 Kg/sec/m2/Pa
self.Ra = Ra # Repose angle in degrees for dry sand (note wet varies 30-45)
#------------------------------------------
# Local variables
#------------------------------------------
self.base = base
if self.indices is not []:
ind = self.indices
neighbours = self.domain.surrogate_neighbours
self.neighbourindices = neighbours[
ind] # get the neighbour Indices for each triangle in the erosion zone(s)
self.n0 = self.neighbourindices[:, 0] # separate into three lists
self.n1 = self.neighbourindices[:, 1]
self.n2 = self.neighbourindices[:, 2]
k = self.n0.shape[0] # Erosion poly lEN - num of triangles in poly
self.e = num.zeros(
(k, 3)) # create elev array k triangles, 3 neighbour elev
self.ident = num.arange(k) # ident is array 0.. k-1, step 1
def __init__(self,
domain,
threshold= 0.0,
base=0.0,
indices=None,
polygon=None,
center=None,
radius=None,
description = None,
label = None,
logging = False,
verbose = False):
Operator.__init__(self, domain, description, label, logging, verbose)
Region.__init__(self, domain,
indices=indices,
polygon=polygon,
center=center,
radius=radius,
verbose=verbose)
#------------------------------------------
# Local variables
#------------------------------------------
self.threshold = threshold
self.base = base
#------------------------------------------
# Extra aliases for changing elevation at
# vertices and edges
#------------------------------------------
self.elev_v = self.domain.quantities['elevation'].vertex_values
self.elev_e = self.domain.quantities['elevation'].edge_values
#------------------------------------------
# Need to turn off this optimization as it
# doesn't fixup the relationship between
# bed and stage vertex values in dry region
#------------------------------------------
if not self.domain.get_using_discontinuous_elevation():
self.domain.optimise_dry_cells = 0
#-----------------------------------------
# Extra structures to support maintaining
# continuity of elevation
#-----------------------------------------
if not self.domain.get_using_discontinuous_elevation():
self.setup_node_structures()
#-----------------------------------------
# Some extras for reporting
#-----------------------------------------
self.max_change = 0
def __init__(self, domain,
indices=None,
description = None,
label = None,
logging = False,
verbose = False):
Operator.__init__(self, domain, description, label, logging, verbose)
self.normals = self.domain.normals
self.neighbours = self.domain.neighbours
self.edgelengths = self.domain.edgelengths
try:
self.conc = self.domain.quantities['concentration'].centroid_values
except:
self.conc = None
self.depth = self.domain.quantities['height'].centroid_values
self.depth_e = self.domain.quantities['height'].edge_values
self.xmom_e = self.domain.quantities['xmomentum'].edge_values
self.ymom_e = self.domain.quantities['ymomentum'].edge_values
self.I_bounds = {'Hmin' : 0.2, 'Hmax' : 2., 'dH' : 0.25,
'Umin' : 0.1, 'Umax' : 2.5, 'dU' : 0.25,
'Smin' : 0.00001, 'Smax' : 0.0001, 'dS' : 0.00005}
self.I_flag = True
self.porosity = 0.3
self.c1 = 18.
self.c2 = 0.4
self.nu = 1.0e-6
self.kappa = 0.408
self.rho_s = 2650.
self.rho_w = 1000.
self.R = (self.rho_s - self.rho_w) / self.rho_w
self.grain_size = 0.00013 # from Griffin et al 2010
self.num_cells = len(self.depth)
self.bdry_indices = None
self.inflow_concentration = None
if self.domain.boundary_map:
self.initialize_inflow_boundary()
self.dx, self.dy = self.get_dx()
self.initialize_arrays()
self.x = self.domain.quantities['x'].centroid_values
self.y = self.domain.quantities['y'].centroid_values
def __init__(
self,
domain,
threshold=0.0,
base=0.0,
indices=None,
polygon=None,
center=None,
radius=None,
Ra=34.0,
description=None,
label=None,
logging=False,
verbose=False,
):
Operator.__init__(self, domain, description, label, logging, verbose)
Region.__init__(self, domain, indices=indices, polygon=polygon, center=center, radius=radius, verbose=verbose)
# -------------------------------------------
# set some sand and water properties
# -------------------------------------------
self.Wd = 1000 # water mass density kg/m3
self.Sd = 1800 # sediment mass density kg/m3
self.G = 9.8 # acceleration due to gravity m/sec/sec
self.n = 0.030 # sand mannings n - mostly bare with undulations
self.Tau_crit = 2.1 # critical (detachment) bed shear stress Pa
self.Kd = 0.025 # detachment factor Froelich Table 2 Kg/sec/m2/Pa
self.Ra = Ra # Repose angle in degrees for dry sand (note wet varies 30-45)
# ------------------------------------------
# Local variables
# ------------------------------------------
self.base = base
if self.indices is not []:
ind = self.indices
neighbours = self.domain.surrogate_neighbours
self.neighbourindices = neighbours[
ind
] # get the neighbour Indices for each triangle in the erosion zone(s)
self.n0 = self.neighbourindices[:, 0] # separate into three lists
self.n1 = self.neighbourindices[:, 1]
self.n2 = self.neighbourindices[:, 2]
k = self.n0.shape[0] # Erosion poly lEN - num of triangles in poly
self.e = num.zeros((k, 3)) # create elev array k triangles, 3 neighbour elev
self.ident = num.arange(k) # ident is array 0.. k-1, step 1
def __init__(self, domain,
indices=None,
description = None,
label = None,
logging = False,
verbose = False,
startSed = True):
Operator.__init__(self, domain, description, label, logging, verbose)
self.startSed = startSed
self.normals = self.domain.normals
self.neighbours = self.domain.neighbours
self.edgelengths = self.domain.edgelengths
try:
self.conc = self.domain.quantities['concentration'].centroid_values
except:
self.conc = None
self.depth = self.domain.quantities['height'].centroid_values
self.x = self.domain.quantities['x'].centroid_values
self.y = self.domain.quantities['y'].centroid_values
self.depth_e = self.domain.quantities['height'].edge_values
self.xmom_e = self.domain.quantities['xmomentum'].edge_values
self.ymom_e = self.domain.quantities['ymomentum'].edge_values
self.porosity = 0.3
self.c1 = 18.
self.c2 = 0.4
self.nu = 1.0e-6
self.kappa = 0.408
self.rho_s = 2650.
self.rho_w = 1000.
self.R = (self.rho_s - self.rho_w) / self.rho_w
self.grain_size = 0.000065 # from Griffin et al 2014
self.tau_crit = 0.088
self.num_cells = len(self.depth)
self.bdry_indices = None
self.inflow_concentration = None
if self.domain.boundary_map:
self.initialize_inflow_boundary()
self.dx = self.get_dx()
self.initialize_arrays()
self.prev_t = 0
def __init__(self,
domain,
threshold=0.0,
base=0.0,
indices=None,
polygon=None,
center=None,
radius=None,
description=None,
label=None,
logging=False,
verbose=False):
Operator.__init__(self, domain, description, label, logging, verbose)
Region.__init__(self,
domain,
indices=indices,
polygon=polygon,
center=center,
radius=radius,
verbose=verbose)
#------------------------------------------
# Local variables
#------------------------------------------
self.threshold = threshold
self.base = base
#------------------------------------------
# Extra aliases for changing elevation at
# vertices and edges
#------------------------------------------
self.elev_v = self.domain.quantities['elevation'].vertex_values
self.elev_e = self.domain.quantities['elevation'].edge_values
#------------------------------------------
# Need to turn off this optimization as it
# doesn't fixup the relationship between
# bed and stage vertex values in dry region
#------------------------------------------
if not self.domain.get_using_discontinuous_elevation():
self.domain.optimise_dry_cells = 0
#-----------------------------------------
# Extra structures to support maintaining
# continuity of elevation
#-----------------------------------------
if not self.domain.get_using_discontinuous_elevation():
self.setup_node_structures()
#-----------------------------------------
# Some extras for reporting
#-----------------------------------------
self.max_change = 0
def __init__(
self,
domain,
update_frequency=1,
collection_start_time=0.0,
velocity_zero_height=None,
description=None,
label=None,
logging=False,
verbose=False,
):
Operator.__init__(self, domain, description, label, logging, verbose)
self.domain = domain
# ------------------------------------------
# Setup a quantity to store max_stage
# ------------------------------------------
self.max_stage = num.zeros(len(domain.centroid_coordinates[:, 0])) - max_float
self.max_depth = num.zeros(len(domain.centroid_coordinates[:, 0]))
self.max_speed = num.zeros(len(domain.centroid_coordinates[:, 0]))
self.max_speedDepth = num.zeros(len(domain.centroid_coordinates[:, 0]))
# ------------------------------------------
# Aliases for stage quantity
# ------------------------------------------
self.xy = domain.centroid_coordinates
self.stage = domain.quantities["stage"]
self.elev = domain.quantities["elevation"]
self.xmom = domain.quantities["xmomentum"]
self.ymom = domain.quantities["ymomentum"]
# ------------------------------------------
# Counter so we don't have to update every timestep
# ------------------------------------------
self.counter = 0
assert update_frequency > 0, "Update frequency must be >=1"
self.update_frequency = update_frequency
self.collection_start_time = collection_start_time
# ------------------------------------------
# Can (rarely) get high velocities being recorded
# (e.g. in 3 cells out of 170000 for a 48 hour simulation,
# which are not persistent -- probably just spikes from nearly dry cells)
# Try to remove this by zeroing velocity in very shallow cells
# ------------------------------------------
if velocity_zero_height is not None:
self.velocity_zero_height = velocity_zero_height
else:
self.velocity_zero_height = domain.minimum_allowed_height
def __init__(self, domain, verbose=False):
if verbose: log.critical('Mannings Operator: Beginning Initialisation')
Operator.__init__(self, domain)
self.gamma_c = num.zeros_like(self.stage_c)
self.height_c = num.zeros_like(self.stage_c)
self.friction_c = self.domain.quantities['friction'].centroid_values
self.g = self.domain.g
self.exp_gamma_max = 0.0
self.exp_gamma_min = 1.0
if verbose: log.critical('Mannings Operator: Initialisation Done')
def __init__(self,
domain,
update_frequency=1,
collection_start_time=0.,
velocity_zero_height=None,
description=None,
label=None,
logging=False,
verbose=False):
Operator.__init__(self, domain, description, label, logging, verbose)
self.domain = domain
#------------------------------------------
# Setup a quantity to store max_stage
#------------------------------------------
self.max_stage = num.zeros(len(
domain.centroid_coordinates[:, 0])) - max_float
self.max_depth = num.zeros(len(domain.centroid_coordinates[:, 0]))
self.max_speed = num.zeros(len(domain.centroid_coordinates[:, 0]))
self.max_speedDepth = num.zeros(len(domain.centroid_coordinates[:, 0]))
#------------------------------------------
# Aliases for stage quantity
#------------------------------------------
self.xy = domain.centroid_coordinates
self.stage = domain.quantities['stage']
self.elev = domain.quantities['elevation']
self.xmom = domain.quantities['xmomentum']
self.ymom = domain.quantities['ymomentum']
#------------------------------------------
# Counter so we don't have to update every timestep
#------------------------------------------
self.counter = 0
assert update_frequency > 0, 'Update frequency must be >=1'
self.update_frequency = update_frequency
self.collection_start_time = collection_start_time
#------------------------------------------
# Can (rarely) get high velocities being recorded
# (e.g. in 3 cells out of 170000 for a 48 hour simulation,
# which are not persistent -- probably just spikes from nearly dry cells)
# Try to remove this by zeroing velocity in very shallow cells
#------------------------------------------
if velocity_zero_height is not None:
self.velocity_zero_height = velocity_zero_height
else:
self.velocity_zero_height = domain.minimum_allowed_height
def __init__(self,
domain,
rate=0.0,
factor=1.0,
indices=None,
polygon=None,
center=None,
radius=None,
relative_time=True,
default_rate=0.0,
description = None,
label = None,
logging = False,
verbose = False,
monitor = False):
Operator.__init__(self, domain, description, label, logging, verbose)
Region.__init__(self, domain,
indices=indices,
polygon=polygon,
center=center,
radius=radius,
verbose=verbose)
#------------------------------------------
# Local variables
#------------------------------------------
self.monitor = monitor
self.factor = factor
self.relative_time = relative_time
self.rate_callable = False
self.rate_spatial = False
self.set_rate(rate)
self.set_default_rate(default_rate)
self.default_rate_invoked = False # Flag
self.set_areas()
self.set_full_indices()
# Mass tracking
self.local_influx=0.
def __init__(self,
domain,
elevation=None,
indices=None,
polygon=None,
center=None,
radius=None,
description=None,
label=None,
logging=False,
verbose=False):
Set_elevation.__init__(self, domain, elevation, indices, polygon,
center, radius)
Operator.__init__(self, domain, description, label, logging, verbose)
def __init__(self,
domain,
threshold=0.0,
indices=None,
description=None,
label=None,
logging=False,
verbose=False):
Operator.__init__(self, domain, description, label, logging, verbose)
#------------------------------------------
# Local variables
#------------------------------------------
self.threshold = threshold
self.indices = indices
def __init__(self, domain, verbose=False):
if verbose: log.critical('Mannings Operator: Beginning Initialisation')
Operator.__init__(self,domain)
self.gamma_c = num.zeros_like(self.stage_c)
self.height_c = num.zeros_like(self.stage_c)
self.friction_c = self.domain.quantities['friction'].centroid_values
self.g = self.domain.g
self.exp_gamma_max = 0.0
self.exp_gamma_min = 1.0
if verbose: log.critical('Mannings Operator: Initialisation Done')
def __init__(self,
domain,
description=None,
label=None,
logging=False,
verbose=False):
Operator.__init__(self, domain, description, label, logging, verbose)
#------------------------------------------
# Setup a quantity to store the boundary flux integral
#------------------------------------------
self.boundary_flux_integral = num.array([0.])
# Alias for domain
self.domain = domain
def __init__(self,
domain,
rate=0.0,
factor=1.0,
indices=None,
polygon=None,
center=None,
radius=None,
time_relative=True,
default_rate=0.0,
description = None,
label = None,
logging = False,
verbose = False):
Operator.__init__(self, domain, description, label, logging, verbose)
Region.__init__(self, domain,
indices=indices,
polygon=polygon,
center=center,
radius=radius,
verbose=verbose)
#------------------------------------------
# Local variables
#------------------------------------------
self.factor = factor
self.time_relative = time_relative
self.rate_callable = False
self.rate_spatial = False
self.set_rate(rate)
self.set_default_rate(default_rate)
self.default_rate_invoked = False # Flag
self.set_areas()
self.set_full_indices()
# Mass tracking
self.local_influx=0.
def __init__(self,
domain,
threshold= 0.0,
indices=None,
description = None,
label = None,
logging = False,
verbose = False):
Operator.__init__(self, domain, description, label, logging, verbose)
#------------------------------------------
# Local variables
#------------------------------------------
self.threshold = threshold
self.indices = indices
def __init__(self,
domain,
description = None,
label = None,
logging = False,
verbose = False):
Operator.__init__(self, domain, description, label, logging, verbose)
#------------------------------------------
# Setup a quantity to store the boundary flux integral
#------------------------------------------
self.boundary_flux_integral=num.array([0.])
# Alias for domain
self.domain=domain
def __init__(self,
domain,
elevation=None,
indices=None,
polygon=None,
center=None,
radius=None,
description = None,
label = None,
logging = False,
verbose = False):
Set_elevation.__init__(self, domain, elevation, indices, polygon, center, radius)
Operator.__init__(self, domain, description, label, logging, verbose)
def __init__(self,
domain,
indices=None,
description=None,
label=None,
logging=False,
verbose=False):
Operator.__init__(self, domain, description, label, logging, verbose)
self.normals = self.domain.normals
self.neighbours = self.domain.neighbours
self.edgelengths = self.domain.edgelengths
try:
self.conc = self.domain.quantities['concentration'].centroid_values
except:
self.conc = None
self.depth = self.domain.quantities['height'].centroid_values
self.depth_e = self.domain.quantities['height'].edge_values
self.xmom_e = self.domain.quantities['xmomentum'].edge_values
self.ymom_e = self.domain.quantities['ymomentum'].edge_values
self.criticalshear_star = 0.06
# from Griffin et al 2010, from Wibert and Smith 1987
self.porosity = 0.3
self.c1 = 18.
self.c2 = 0.4
self.nu = 1.0e-6
self.kappa = 0.408
self.rho_s = 2650.
self.rho_w = 1000.
self.R = (self.rho_s - self.rho_w) / self.rho_w
self.grain_size = 0.00013 # from Griffin et al 2010
self.bdry_indices = None
self.inflow_concentration = None
if self.domain.boundary_map:
self.initialize_inflow_boundary()
def __init__(self,
domain,
description=None,
label=None,
logging=False,
verbose=False):
Operator.__init__(self, domain, description, label, logging, verbose)
#------------------------------------------
# Setup a quantity to store max_stage
#------------------------------------------
self.max_stage = Quantity(domain, name='max_stage', register=True)
self.max_stage.set_values(-1.0e+100)
#------------------------------------------
# Aliases for stage quantity
#------------------------------------------
self.stage = domain.quantities['stage']
def __init__(self,
domain,
indices=None,
polygon=None,
center=None,
radius=None,
description=None,
label=None,
logging=False,
verbose=False):
Operator.__init__(self, domain, description, label, logging, verbose)
Region.__init__(self,
domain,
indices=indices,
polygon=polygon,
center=center,
radius=radius,
verbose=verbose)
def __init__(self,
domain,
description = None,
label = None,
logging = False,
verbose = False):
Operator.__init__(self, domain, description, label, logging, verbose)
#------------------------------------------
# Setup a quantity to store max_stage
#------------------------------------------
self.max_stage = Quantity(domain, name = 'max_stage', register=True)
self.max_stage.set_values(-1.0e+100)
#------------------------------------------
# Aliases for stage quantity
#------------------------------------------
self.stage = domain.quantities['stage']
def __init__(self,
domain,
indices=None,
polygon=None,
center=None,
radius=None,
description=None,
label=None,
logging=False,
verbose=False):
Operator.__init__(self, domain, description, label, logging, verbose)
Region.__init__(self,
domain,
indices=indices,
polygon=polygon,
center=center,
radius=radius,
verbose=verbose)
# set some alaises
self.depth = self.domain.quantities['height'].centroid_values
def __init__(self,
domain,
w_uh_vh=None,
indices=None,
polygon=None,
center=None,
radius=None,
description = None,
label = None,
logging = False,
verbose = False):
Operator.__init__(self, domain, description, label, logging, verbose)
Region.__init__(self, domain,
indices=indices,
polygon=polygon,
center=center,
radius=radius,
verbose=verbose)
#print self.indices
self.set_w_uh_vh(w_uh_vh)
def __init__(self, domain, use_triangle_areas=True, verbose=False):
if verbose:
log.critical('Kinematic Viscosity: Beginning Initialisation')
Operator.__init__(self, domain)
#Expose the domain attributes
self.mesh = self.domain.mesh
self.boundary = domain.boundary
self.boundary_enumeration = domain.boundary_enumeration
# Setup a quantity as diffusivity
# FIXME SR: Could/Should pass a quantity which already exists
self.diffusivity = Quantity(self.domain)
self.diffusivity.set_values(1.0)
self.diffusivity.set_boundary_values(1.0)
self.n = len(self.domain)
self.dt = 0.0 #Need to set to domain.timestep
self.dt_apply = 0.0
self.boundary_len = len(self.domain.boundary)
self.tot_len = self.n + self.boundary_len
self.verbose = verbose
#Geometric Information
if verbose:
log.critical('Kinematic Viscosity: Building geometric structure')
self.geo_structure_indices = num.zeros((self.n, 3), num.int)
self.geo_structure_values = num.zeros((self.n, 3), num.float)
# Only needs to built once, doesn't change
kinematic_viscosity_operator_ext.build_geo_structure(self)
# Setup type of scaling
self.set_triangle_areas(use_triangle_areas)
# FIXME SR: should this really be a matrix?
temp = Sparse(self.n, self.n)
for i in range(self.n):
temp[i, i] = 1.0 / self.mesh.areas[i]
self.triangle_areas = Sparse_CSR(temp)
#self.triangle_areas
# FIXME SR: More to do with solving equation
self.qty_considered = 1 #1 or 2 (uh or vh respectively)
#Sparse_CSR.data
self.operator_data = num.zeros((4 * self.n, ), num.float)
#Sparse_CSR.colind
self.operator_colind = num.zeros((4 * self.n, ), num.int)
#Sparse_CSR.rowptr (4 entries in every row, we know this already) = [0,4,8,...,4*n]
self.operator_rowptr = 4 * num.arange(self.n + 1)
# Build matrix self.elliptic_matrix [A B]
self.build_elliptic_matrix(self.diffusivity)
self.boundary_term = num.zeros((self.n, ), num.float)
self.parabolic = False #Are we doing a parabolic solve at the moment?
self.u_stats = None
self.v_stats = None
if verbose: log.critical('Elliptic Operator: Initialisation Done')
def __init__(self, domain, use_triangle_areas=True, verbose=False):
if verbose: log.critical('Kinematic Viscosity: Beginning Initialisation')
Operator.__init__(self,domain)
#Expose the domain attributes
self.mesh = self.domain.mesh
self.boundary = domain.boundary
self.boundary_enumeration = domain.boundary_enumeration
# Setup a quantity as diffusivity
# FIXME SR: Could/Should pass a quantity which already exists
self.diffusivity = Quantity(self.domain)
self.diffusivity.set_values(1.0)
self.diffusivity.set_boundary_values(1.0)
self.n = len(self.domain)
self.dt = 0.0 #Need to set to domain.timestep
self.dt_apply = 0.0
self.boundary_len = len(self.domain.boundary)
self.tot_len = self.n + self.boundary_len
self.verbose = verbose
#Geometric Information
if verbose: log.critical('Kinematic Viscosity: Building geometric structure')
self.geo_structure_indices = num.zeros((self.n, 3), num.int)
self.geo_structure_values = num.zeros((self.n, 3), num.float)
# Only needs to built once, doesn't change
kinematic_viscosity_operator_ext.build_geo_structure(self)
# Setup type of scaling
self.set_triangle_areas(use_triangle_areas)
# FIXME SR: should this really be a matrix?
temp = Sparse(self.n, self.n)
for i in range(self.n):
temp[i, i] = 1.0 / self.mesh.areas[i]
self.triangle_areas = Sparse_CSR(temp)
#self.triangle_areas
# FIXME SR: More to do with solving equation
self.qty_considered = 1 #1 or 2 (uh or vh respectively)
#Sparse_CSR.data
self.operator_data = num.zeros((4 * self.n, ), num.float)
#Sparse_CSR.colind
self.operator_colind = num.zeros((4 * self.n, ), num.int)
#Sparse_CSR.rowptr (4 entries in every row, we know this already) = [0,4,8,...,4*n]
self.operator_rowptr = 4 * num.arange(self.n + 1)
# Build matrix self.elliptic_matrix [A B]
self.build_elliptic_matrix(self.diffusivity)
self.boundary_term = num.zeros((self.n, ), num.float)
self.parabolic = False #Are we doing a parabolic solve at the moment?
self.u_stats = None
self.v_stats = None
if verbose: log.critical('Elliptic Operator: Initialisation Done')
