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