def print_l1_stats(full_edge):
numprocs = pypar.size()
myid = pypar.rank()
tri_norm = zeros(3, Float)
recv_norm = zeros(3, Float)
tri_norm[0] = l1_norm(full_edge[:, 0])
tri_norm[1] = l1_norm(full_edge[:, 1])
tri_norm[2] = l1_norm(full_edge[:, 2])
if myid == 0:
for p in range(numprocs-1):
pypar.receive(p+1, recv_norm)
tri_norm[0] = tri_norm[0]+recv_norm[0]
tri_norm[1] = tri_norm[1]+recv_norm[1]
tri_norm[2] = tri_norm[2]+recv_norm[2]
print 'l1_norm along each axis : [', tri_norm[0],', ', tri_norm[1], ', ', tri_norm[2], ']'
else:
pypar.send(tri_norm, 0)
def evolution_test(parallel=False):
domain = create_domain_from_file(mesh_filename)
domain.set_quantity('stage', Set_Stage(756000.0, 756500.0, 2.0))
#--------------------------------------------------------------------------
# Create parallel domain if requested
#--------------------------------------------------------------------------
if parallel:
if par.myid == 0 and verbose: print 'DISTRIBUTING PARALLEL DOMAIN'
domain = distribute(domain)
#------------------------------------------------------------------------------
# Setup boundary conditions
# This must currently happen *after* domain has been distributed
#------------------------------------------------------------------------------
domain.store = False
Br = Reflective_boundary(domain) # Solid reflective wall
domain.set_boundary({
'outflow': Br,
'inflow': Br,
'inner': Br,
'exterior': Br,
'open': Br
})
#------------------------------------------------------------------------------
# Setup diagnostic arrays
#------------------------------------------------------------------------------
l1list = []
l2list = []
linflist = []
l1norm = num.zeros(3, num.float)
l2norm = num.zeros(3, num.float)
linfnorm = num.zeros(3, num.float)
recv_norm = num.zeros(3, num.float)
#------------------------------------------------------------------------------
# Evolution
#------------------------------------------------------------------------------
if parallel:
if par.myid == 0 and verbose: print 'PARALLEL EVOLVE'
else:
if verbose: print 'SEQUENTIAL EVOLVE'
for t in domain.evolve(yieldstep=yieldstep, finaltime=finaltime):
edges = domain.quantities[quantity].edge_values.take(num.flatnonzero(
domain.tri_full_flag),
axis=0)
l1norm[0] = l1_norm(edges[:, 0])
l1norm[1] = l1_norm(edges[:, 1])
l1norm[2] = l1_norm(edges[:, 2])
l2norm[0] = l2_norm(edges[:, 0])
l2norm[1] = l2_norm(edges[:, 1])
l2norm[2] = l2_norm(edges[:, 2])
linfnorm[0] = linf_norm(edges[:, 0])
linfnorm[1] = linf_norm(edges[:, 1])
linfnorm[2] = linf_norm(edges[:, 2])
if parallel:
l2norm[0] = pow(l2norm[0], 2)
l2norm[1] = pow(l2norm[1], 2)
l2norm[2] = pow(l2norm[2], 2)
if par.myid == 0:
#domain.write_time()
#print edges[:,1]
for p in range(1, par.numprocs):
recv_norm = par.receive(p)
l1norm += recv_norm
recv_norm = par.receive(p)
l2norm += recv_norm
recv_norm = par.receive(p)
linfnorm[0] = max(linfnorm[0], recv_norm[0])
linfnorm[1] = max(linfnorm[1], recv_norm[1])
linfnorm[2] = max(linfnorm[2], recv_norm[2])
l2norm[0] = pow(l2norm[0], 0.5)
l2norm[1] = pow(l2norm[1], 0.5)
l2norm[2] = pow(l2norm[2], 0.5)
l1list.append(l1norm)
l2list.append(l2norm)
linflist.append(linfnorm)
else:
par.send(l1norm, 0)
par.send(l2norm, 0)
par.send(linfnorm, 0)
else:
#domain.write_time()
l1list.append(l1norm)
l2list.append(l2norm)
linflist.append(linfnorm)
return (l1list, l2list, linflist)
def run_simulation(parallel=False):
domain = create_domain_from_file(mesh_filename)
domain.set_quantity('stage', Set_Stage(756000.0, 756500.0, 2.0))
#--------------------------------------------------------------------------
# Create parallel domain if requested
#--------------------------------------------------------------------------
if parallel:
if myid == 0 and verbose: print 'DISTRIBUTING PARALLEL DOMAIN'
domain = distribute(domain)
#------------------------------------------------------------------------------
# Setup boundary conditions
# This must currently happen *after* domain has been distributed
#------------------------------------------------------------------------------
domain.store = False
Br = Reflective_boundary(domain) # Solid reflective wall
domain.set_boundary({'outflow' :Br, 'inflow' :Br, 'inner' :Br, 'exterior' :Br, 'open' :Br})
#------------------------------------------------------------------------------
# Setup diagnostic arrays
#------------------------------------------------------------------------------
l1list = []
l2list = []
linflist = []
l1norm = num.zeros(3, num.float)
l2norm = num.zeros(3, num.float)
linfnorm = num.zeros(3, num.float)
recv_norm = num.zeros(3, num.float)
#------------------------------------------------------------------------------
# Evolution
#------------------------------------------------------------------------------
if parallel:
if myid == 0 and verbose: print 'PARALLEL EVOLVE'
else:
if verbose: print 'SEQUENTIAL EVOLVE'
for t in domain.evolve(yieldstep = yieldstep, finaltime = finaltime):
edges = domain.quantities[quantity].edge_values.take(num.flatnonzero(domain.tri_full_flag),axis=0)
l1norm[0] = l1_norm(edges[:,0])
l1norm[1] = l1_norm(edges[:,1])
l1norm[2] = l1_norm(edges[:,2])
l2norm[0] = l2_norm(edges[:,0])
l2norm[1] = l2_norm(edges[:,1])
l2norm[2] = l2_norm(edges[:,2])
linfnorm[0] = linf_norm(edges[:,0])
linfnorm[1] = linf_norm(edges[:,1])
linfnorm[2] = linf_norm(edges[:,2])
if parallel:
l2norm[0] = pow(l2norm[0], 2)
l2norm[1] = pow(l2norm[1], 2)
l2norm[2] = pow(l2norm[2], 2)
if myid == 0:
#domain.write_time()
#print edges[:,1]
for p in range(1, numprocs):
recv_norm = pypar.receive(p)
l1norm += recv_norm
recv_norm = pypar.receive(p)
l2norm += recv_norm
recv_norm = pypar.receive(p)
linfnorm[0] = max(linfnorm[0], recv_norm[0])
linfnorm[1] = max(linfnorm[1], recv_norm[1])
linfnorm[2] = max(linfnorm[2], recv_norm[2])
l2norm[0] = pow(l2norm[0], 0.5)
l2norm[1] = pow(l2norm[1], 0.5)
l2norm[2] = pow(l2norm[2], 0.5)
l1list.append(l1norm)
l2list.append(l2norm)
linflist.append(linfnorm)
else:
pypar.send(l1norm, 0)
pypar.send(l2norm, 0)
pypar.send(linfnorm, 0)
else:
#domain.write_time()
l1list.append(l1norm)
l2list.append(l2norm)
linflist.append(linfnorm)
return (l1list, l2list, linflist)