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')