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 parabolic_solve(self, u_in, b, a = None, u_out = None, update_matrix=True, \ imax=10000, tol=1.0e-8, atol=1.0e-8, iprint=None, output_stats=False): """ Solve for u in the equation ( I + dt div a grad ) u = b u | boundary = g u_in, u_out, f anf g are Quantity objects Dirichlet BC g encoded into u_in boundary_values Initial guess for iterative scheme is given by centroid values of u_in Centroid values of a and b provide diffusivity and rhs Solution u is retruned in u_out """ if u_out is None: u_out = Quantity(self.domain) if update_matrix: self.update_elliptic_matrix(a) self.update_elliptic_boundary_term(u_in) self.set_parabolic_solve(True) # Pull out arrays and a matrix operator IdtA = self rhs = b.centroid_values + (self.dt * self.boundary_term) x0 = u_in.centroid_values x, stats = conjugate_gradient(IdtA, rhs, x0, imax=imax, tol=tol, atol=atol, iprint=iprint, output_stats=True) self.set_parabolic_solve(False) u_out.set_values(x, location='centroids') u_out.set_boundary_values(u_in.boundary_values) if output_stats: return u_out, stats else: return u_out
def _parabolic_multiply_quantity(self, quantity_in, quantity_out): """ Assumes that update_elliptic_matrix has been run """ if quantity_out is None: quantity_out = Quantity(self.domain) array_in = quantity_in.centroid_values array_out = quantity_out.centroid_values X = self._parabolic_multiply_array(array_in, array_out) quantity_out.set_values(X, location='centroids') return quantity_out
def set_veg_quantity(self, name_in, quantity_name=None, convert_file=True, save_file=False, load_interp=False): """ Read raster file and sets a vegetation quantity. Veg quantities are: veg_diameter veg_spacing The values in the rasters should be in meters. Assumes all NODATA values in raster are zero vegetation Saves a (Nx3) .npy file of x,y,val of non-zero points on save_file """ Quantity(self.domain, name=quantity_name, register=True) points = None if load_interp: print 'Veg Load: loading', name_in + '_interp.npy' z_ = num.load(name_in + '_interp.npy') else: if convert_file: print 'Veg Load: converting asc file', name_in + '.asc' self.generic_asc2dem(name_in + '.asc', quantity_name=quantity_name) points = self.generic_dem2npy(name_in + '.dem', quantity_name=quantity_name) if points is None: print 'Veg Load: loading', name_in + '.npy' points = num.load(name_in + '.npy') interp = NearestNDInterpolator(points[:,0:2], points[:,2]) coord = self.domain.get_centroid_coordinates(absolute=True) z_ = interp( coord ) if save_file: print 'Veg Load: saving interpolated file: ', name_in + '_interp.npy' num.save(name_in + '_interp.npy', z_) print 'Veg Load: setting quantity', quantity_name self.domain.quantities[quantity_name].set_values(z_, location = 'centroids')
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 update_elliptic_matrix(self, a=None): """ Updates the data values of matrix representing div ( a grad ) If a is None then we set a = quantity which is set to 1 """ #Array self.operator_data is changed by this call, which should flow # through to the Sparse_CSR matrix. if a is None: a = Quantity(self.domain) a.set_values(1.0) a.set_boundary_values(1.0) kinematic_viscosity_operator_ext.update_elliptic_matrix(self, \ a.centroid_values, \ a.boundary_values)
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 distribute(domain, verbose=False, debug=False, parameters=None): """ Distribute the domain to all processes parameters allows user to change size of ghost layer """ if not pypar_available or numprocs == 1: return domain # Bypass if myid == 0: from sequential_distribute import Sequential_distribute partition = Sequential_distribute(domain, verbose, debug, parameters) partition.distribute(numprocs) kwargs, points, vertices, boundary, quantities, boundary_map, \ domain_name, domain_dir, domain_store, domain_store_centroids, \ domain_minimum_storable_height, domain_minimum_allowed_height, \ domain_flow_algorithm, domain_georef, \ domain_quantities_to_be_stored, domain_smooth \ = partition.extract_submesh(0) for p in range(1, numprocs): tostore = partition.extract_submesh(p) send(tostore, p) else: kwargs, points, vertices, boundary, quantities, boundary_map, \ domain_name, domain_dir, domain_store, domain_store_centroids, \ domain_minimum_storable_height, domain_minimum_allowed_height, \ domain_flow_algorithm, domain_georef, \ domain_quantities_to_be_stored, domain_smooth \ = receive(0) #--------------------------------------------------------------------------- # Now Create parallel domain #--------------------------------------------------------------------------- parallel_domain = Parallel_domain(points, vertices, boundary, **kwargs) #------------------------------------------------------------------------ # Copy in quantity data #------------------------------------------------------------------------ for q in quantities: try: parallel_domain.set_quantity(q, quantities[q]) except KeyError: #print 'Try to create quantity %s'% q from anuga import Quantity Q = Quantity(parallel_domain, name=q, register=True) parallel_domain.set_quantity(q, quantities[q]) #------------------------------------------------------------------------ # Transfer boundary conditions to each subdomain #------------------------------------------------------------------------ boundary_map['ghost'] = None # Add binding to ghost boundary parallel_domain.set_boundary(boundary_map) #------------------------------------------------------------------------ # Transfer other attributes to each subdomain #------------------------------------------------------------------------ parallel_domain.set_flow_algorithm(domain_flow_algorithm) parallel_domain.set_name(domain_name) parallel_domain.set_datadir(domain_dir) parallel_domain.set_store(domain_store) parallel_domain.set_store_centroids(domain_store_centroids) parallel_domain.set_minimum_storable_height(domain_minimum_storable_height) parallel_domain.set_minimum_allowed_height(domain_minimum_allowed_height) parallel_domain.geo_reference = domain_georef parallel_domain.set_quantities_to_be_stored(domain_quantities_to_be_stored) parallel_domain.smooth = domain_smooth return parallel_domain
def test_rate_operator_rate_quantity(self): from anuga.config import rho_a, rho_w, eta_w from math import pi, cos, sin a = [0.0, 0.0] b = [0.0, 2.0] c = [2.0, 0.0] d = [0.0, 4.0] e = [2.0, 2.0] f = [4.0, 0.0] points = [a, b, c, d, e, f] # bac, bce, ecf, dbe vertices = [[1, 0, 2], [1, 2, 4], [4, 2, 5], [3, 1, 4]] domain = Domain(points, vertices) #Flat surface with 1m of water domain.set_quantity('elevation', 0.0) domain.set_quantity('stage', 1.0) domain.set_quantity('friction', 0.0) Br = Reflective_boundary(domain) domain.set_boundary({'exterior': Br}) verbose = False if verbose: print domain.quantities['elevation'].centroid_values print domain.quantities['stage'].centroid_values print domain.quantities['xmomentum'].centroid_values print domain.quantities['ymomentum'].centroid_values # Apply operator to these triangles indices = [0, 1, 3] factor = 10.0 from anuga import Quantity rate_Q = Quantity(domain) rate_Q.set_values(1.0) operator = Rate_operator(domain, rate=rate_Q, factor=factor, \ indices=indices) # Apply Operator domain.timestep = 2.0 operator() rate = rate_Q.centroid_values[indices] t = operator.get_time() Q = operator.get_Q() rate = rate * factor Q_ex = num.sum(domain.areas[indices] * rate) d = operator.get_timestep() * rate + 1 #print "d" #print d #print Q_ex #print Q stage_ex = num.array([1.0, 1.0, 1.0, 1.0]) stage_ex[indices] = d verbose = False if verbose: print domain.quantities['elevation'].centroid_values print domain.quantities['stage'].centroid_values print domain.quantities['xmomentum'].centroid_values print domain.quantities['ymomentum'].centroid_values assert num.allclose(domain.quantities['stage'].centroid_values, stage_ex) assert num.allclose(domain.quantities['xmomentum'].centroid_values, 0.0) assert num.allclose(domain.quantities['ymomentum'].centroid_values, 0.0) assert num.allclose(Q_ex, Q) assert num.allclose(domain.fractional_step_volume_integral, ((d - 1.) * domain.areas[indices]).sum())