def __init__(self,ghosted_csr_mat=None,par_bs=None,par_n=None,par_N=None,par_nghost=None,subdomain2global=None,blockVecType="simple",pde=None, par_nc=None, par_Nc=None, proteus_jacobian=None, nzval_proteus2petsc=None):
p4pyPETSc.Mat.__init__(self)
if ghosted_csr_mat is None:
return#when duplicating for petsc usage
self.pde = pde
if par_nc is None:
par_nc = par_n
if par_Nc is None:
par_Nc = par_N
self.proteus_jacobian=proteus_jacobian
self.nzval_proteus2petsc = nzval_proteus2petsc
self.ghosted_csr_mat=ghosted_csr_mat
self.blockVecType = blockVecType
assert self.blockVecType == "simple", "petsc4py wrappers require self.blockVecType=simple"
self.create(p4pyPETSc.COMM_WORLD)
self.blockSize = max(1,par_bs)
if self.blockSize > 1 and blockVecType != "simple":
## \todo fix block aij in ParMat_petsc4py
self.setType('baij')
self.setSizes([[self.blockSize*par_n,self.blockSize*par_N],[self.blockSize*par_nc,self.blockSize*par_Nc]],bsize=self.blockSize)
self.setBlockSize(self.blockSize)
self.subdomain2global = subdomain2global #no need to include extra block dofs?
else:
self.setType('aij')
self.setSizes([[par_n*self.blockSize,par_N*self.blockSize],[par_nc*self.blockSize,par_Nc*self.blockSize]],bsize=1)
if self.blockSize > 1: #have to build in block dofs
subdomain2globalTotal = numpy.zeros((self.blockSize*subdomain2global.shape[0],),'i')
for j in range(self.blockSize):
subdomain2globalTotal[j::self.blockSize]=subdomain2global*self.blockSize+j
self.subdomain2global=subdomain2globalTotal
else:
self.subdomain2global=subdomain2global
from proteus import Comm
comm = Comm.get()
logEvent("ParMat_petsc4py comm.rank= %s blockSize = %s par_n= %s par_N=%s par_nghost=%s par_jacobian.getSizes()= %s "
% (comm.rank(),self.blockSize,par_n,par_N,par_nghost,self.getSizes()))
self.csr_rep = ghosted_csr_mat.getCSRrepresentation()
if self.proteus_jacobian is not None:
self.proteus_csr_rep = self.proteus_jacobian.getCSRrepresentation()
if self.blockSize > 1:
blockOwned = self.blockSize*par_n
self.csr_rep_local = ghosted_csr_mat.getSubMatCSRrepresentation(0,blockOwned)
else:
self.csr_rep_local = ghosted_csr_mat.getSubMatCSRrepresentation(0,par_n)
self.petsc_l2g = p4pyPETSc.LGMap()
self.petsc_l2g.create(self.subdomain2global)
self.setUp()
self.setLGMap(self.petsc_l2g)
#
self.colind_global = self.petsc_l2g.apply(self.csr_rep_local[1]) #prealloc needs global indices
self.setPreallocationCSR([self.csr_rep_local[0],self.colind_global,self.csr_rep_local[2]])
self.setFromOptions()
def test_point_gauge_output():
filename = 'test_gauge_output.csv'
silent_rm(filename)
p = PointGauges(gauges=((('u0',), ((0, 0, 0), (1, 1, 1))),),
fileName=filename)
time_list=[0.0, 1.0, 2.0]
run_gauge(p, time_list)
correct_gauge_names = ['u0 [ 0 0 0]', 'u0 [ 1 1 1]']
correct_data = np.asarray([[ 0., 0., 111.],
[ 1., 0., 222.],
[ 2., 0., 333.]])
# synchronize processes before attempting to read file
Comm.get().barrier()
gauge_names, data = parse_gauge_output(filename)
eq_(correct_gauge_names, gauge_names)
npt.assert_allclose(correct_data, data)
def test_line_gauge_output():
filename = 'test_line_output.csv'
silent_rm(filename)
lines = (((0, 0, 0), (1, 1, 1)),)
fields = ('u0', )
l = LineGauges(gauges=((fields, lines),),
fileName=filename)
time_list=[0.0, 1.0, 2.0]
# good hard-code for up to 1,024 processes or so, but slow (about 8 seconds on single process).
run_gauge(l, time_list, total_nodes=2048)
correct_gauge_names = ['u0 [ 0 0 0]', 'u0 [ 0.076923 0.076923 0.076923]',
'u0 [ 0.15385 0.15385 0.15385]', 'u0 [ 0.23077 0.23077 0.23077]',
'u0 [ 0.30769 0.30769 0.30769]', 'u0 [ 0.38462 0.38462 0.38462]',
'u0 [ 0.46154 0.46154 0.46154]', 'u0 [ 0.53846 0.53846 0.53846]',
'u0 [ 0.61538 0.61538 0.61538]', 'u0 [ 0.69231 0.69231 0.69231]',
'u0 [ 0.76923 0.76923 0.76923]', 'u0 [ 0.84615 0.84615 0.84615]',
'u0 [ 0.92308 0.92308 0.92308]', 'u0 [ 1 1 1]']
correct_data = np.asarray([[0., 0., 8.53846154, 17.07692308, 25.61538462,
34.15384615, 42.69230769, 51.23076923, 59.76923077, 68.30769231,
76.84615385, 85.38461538, 93.92307692, 102.46153846, 111.],
[1., 0., 17.07692308, 34.15384615, 51.23076923,
68.30769231, 85.38461538, 102.46153846, 119.53846154, 136.61538462,
153.69230769, 170.76923077, 187.84615385, 204.92307692, 222.],
[2., 0., 25.61538462, 51.23076923, 76.84615385,
102.46153846, 128.07692308, 153.69230769, 179.30769231, 204.92307692,
230.53846154, 256.15384615, 281.76923077, 307.38461538, 333.]])
# synchronize processes before attempting to read file
Comm.get().barrier()
gauge_names, data = parse_gauge_output(filename)
eq_(correct_gauge_names, gauge_names)
npt.assert_allclose(correct_data, data)
delete_file(filename)
def test_2D_line_integral_gauge_output():
filename = 'test_2D_line_integral_gauge_output.csv'
silent_rm(filename)
lines = (((0, 0, 0), (1, 1, 0)),
((0, 0, 0), (1, 0, 0)),
((0, 0, 0), (0, 1, 0)),
((0, 0.5, 0), (1, 0.5, 0)),
((0, 1, 0), (1, 1, 0)),
((0.5, 0, 0), (0.5, 1, 0)))
fields = ('u0', )
l = LineIntegralGauges(gauges=((fields, lines),),
fileName=filename)
time_list=[0.0, 1.0, 2.0, 2.5]
run_gauge(l, time_list)
correct_gauge_names = ['u0 [ 0 0 0] - [ 1 1 0]',
'u0 [ 0 0 0] - [ 1 0 0]',
'u0 [ 0 0 0] - [ 0 1 0]',
'u0 [ 0 0.5 0] - [ 1 0.5 0]',
'u0 [ 0 1 0] - [ 1 1 0]',
'u0 [ 0.5 0 0] - [ 0.5 1 0]']
correct_data = np.asarray([[0., 7.77817459, 0.5, 5., 5.5, 10.5, 5.5],
[1., 15.55634919, 1., 10., 11., 21., 11.],
[2., 23.33452378, 1.5, 15., 16.5, 31.5, 16.5],
[2.5, 27.22361108, 1.75, 17.5, 19.25, 36.75, 19.25]])
# synchronize processes before attempting to read file
Comm.get().barrier()
gauge_names, data = parse_gauge_output(filename)
eq_(correct_gauge_names, gauge_names)
npt.assert_allclose(correct_data, data)
delete_file(filename)
def test_line_integral_gauge_output():
filename = 'test_line_integral_gauge_output.csv'
silent_rm(filename)
lines = (((0, 0, 0), (1, 1, 1)),)
fields = ('u0', )
l = LineIntegralGauges(gauges=((fields, lines),),
fileName=filename)
time_list=[0.0, 1.0, 2.0]
run_gauge(l, time_list)
correct_gauge_names = ['u0 [ 0 0 0] - [ 1 1 1]']
correct_data = np.asarray([[ 0., 96.128819820072678],
[ 1., 192.25763964014536],
[ 2., 288.38645946021808]])
# synchronize processes before attempting to read file
Comm.get().barrier()
gauge_names, data = parse_gauge_output(filename)
eq_(correct_gauge_names, gauge_names)
npt.assert_allclose(correct_data, data)
def gauge_setup(nd, total_nodes=None):
comm = Comm.get()
#Simplified Physics
p.name="test_gauges"
p.nd = nd
class LinearSolution:
def uOfXT(self,x,t):
return (x[0]+10*x[1]+100*x[2])*(t+1.0)
p.initialConditions = {0:LinearSolution()}
p.dirichletConditions = {0: lambda x,flag: None}
p.domain = Domain.RectangularDomain(name="test_gauges_domain")
p.coefficients = TransportCoefficients.PoissonEquationCoefficients(aOfX = [lambda x: np.eye(p.nd, p.nd)],
fOfX = [lambda x: 0], nc=1, nd=p.nd)
#Simplified and Incomplete Numerics
n.femSpaces = {0:FemTools.C0_AffineLinearOnSimplexWithNodalBasis}
n.elementQuadrature = Quadrature.SimplexGaussQuadrature(p.nd,3)
n.elementBoundaryQuadrature = Quadrature.SimplexGaussQuadrature(p.nd-1,3)
n.numericalFluxType = NumericalFlux.NoFlux
n.cfluxtag = None
n.conservativeFlux = None
if total_nodes is None:
total_nodes = 2*comm.size()
if p.nd == 1:
mlMesh = build1DMesh(p, total_nodes+1)
elif p.nd == 2:
nnx = nny = int(ceil(sqrt(total_nodes)))+1
mlMesh = build2DMesh(p, nnx, nny)
elif p.nd == 3:
nnx = nny = nnz = int(ceil(pow(total_nodes, 1.0/3.0)))+1
mlMesh = build3DMesh(p, nnx, nny, nnz)
model = Transport.MultilevelTransport(p, n, mlMesh)
return model, p.initialConditions
#!/usr/bin/env python
"""
Test module for linear boundary value problems (serial)
This module solves equations of the form
.. math::
\nabla \cdot \left( a(x) \nabla u \right) = f(x)
"""
from proteus.iproteus import *
from proteus import Comm
comm = Comm.get()
Profiling.logLevel=7
Profiling.verbose=True
import numpy.testing as npt
from nose.tools import ok_ as ok
from nose.tools import eq_ as eq
def test_c0p1():
import poisson_het_2d_p
import poisson_het_2d_c0pk_n
pList = [poisson_het_2d_p]
nList = [poisson_het_2d_c0pk_n]
so = default_so
so.name = pList[0].name = "poisson_2d_c0p1"+"pe"+`comm.size()`
so.sList=[default_s]
opts.logLevel=7
opts.verbose=True
opts.profile=True
def __init__(self,
uDict,
phiDict,
testSpaceDict,
matType,
dofBoundaryConditionsDict,
dofBoundaryConditionsSetterDict,
coefficients,
elementQuadrature,
elementBoundaryQuadrature,
fluxBoundaryConditionsDict=None,
advectiveFluxBoundaryConditionsSetterDict=None,
diffusiveFluxBoundaryConditionsSetterDictDict=None,
stressTraceBoundaryConditionsSetterDict=None,
stabilization=None,
shockCapturing=None,
conservativeFluxDict=None,
numericalFluxType=None,
TimeIntegrationClass=None,
massLumping=False,
reactionLumping=False,
options=None,
name='defaultName',
reuse_trial_and_test_quadrature=True,
sd=True,
movingDomain=False,
bdyNullSpace=True):
self.bdyNullSpace = bdyNullSpace
from proteus import Comm
#
# set the objects describing the method and boundary conditions
#
self.movingDomain = movingDomain
self.tLast_mesh = None
#
self.name = name
self.sd = sd
self.Hess = False
self.lowmem = True
self.timeTerm = True # allow turning off the time derivative
# self.lowmem=False
self.testIsTrial = True
self.phiTrialIsTrial = True
self.u = uDict
self.ua = {} # analytical solutions
self.phi = phiDict
self.dphi = {}
self.matType = matType
# mwf try to reuse test and trial information across components if
# spaces are the same
self.reuse_test_trial_quadrature = reuse_trial_and_test_quadrature # True#False
if self.reuse_test_trial_quadrature:
for ci in range(1, coefficients.nc):
assert self.u[ci].femSpace.__class__.__name__ == self.u[
0].femSpace.__class__.__name__, "to reuse_test_trial_quad all femSpaces must be the same!"
# Simplicial Mesh
# assume the same mesh for all components for now
self.mesh = self.u[0].femSpace.mesh
self.testSpace = testSpaceDict
self.dirichletConditions = dofBoundaryConditionsDict
# explicit Dirichlet conditions for now, no Dirichlet BC constraints
self.dirichletNodeSetList = None
self.coefficients = coefficients
self.coefficients.initializeMesh(self.mesh)
self.nc = self.coefficients.nc
self.stabilization = stabilization
self.shockCapturing = shockCapturing
# no velocity post-processing for now
self.conservativeFlux = conservativeFluxDict
self.fluxBoundaryConditions = fluxBoundaryConditionsDict
self.diffusiveFluxBoundaryConditionsSetterDictDict = diffusiveFluxBoundaryConditionsSetterDictDict
# determine whether the stabilization term is nonlinear
self.stabilizationIsNonlinear = False
# cek come back
if self.stabilization is not None:
for ci in range(self.nc):
if coefficients.mass.has_key(ci):
for flag in coefficients.mass[ci].values():
if flag == 'nonlinear':
self.stabilizationIsNonlinear = True
if coefficients.advection.has_key(ci):
for flag in coefficients.advection[ci].values():
if flag == 'nonlinear':
self.stabilizationIsNonlinear = True
if coefficients.diffusion.has_key(ci):
for diffusionDict in coefficients.diffusion[ci].values():
for flag in diffusionDict.values():
if flag != 'constant':
self.stabilizationIsNonlinear = True
if coefficients.potential.has_key(ci):
for flag in coefficients.potential[ci].values():
if flag == 'nonlinear':
self.stabilizationIsNonlinear = True
if coefficients.reaction.has_key(ci):
for flag in coefficients.reaction[ci].values():
if flag == 'nonlinear':
self.stabilizationIsNonlinear = True
if coefficients.hamiltonian.has_key(ci):
for flag in coefficients.hamiltonian[ci].values():
if flag == 'nonlinear':
self.stabilizationIsNonlinear = True
# determine if we need element boundary storage
self.elementBoundaryIntegrals = {}
for ci in range(self.nc):
self.elementBoundaryIntegrals[ci] = (
(self.conservativeFlux is not None) or (
numericalFluxType is not None) or (
self.fluxBoundaryConditions[ci] == 'outFlow') or (
self.fluxBoundaryConditions[ci] == 'mixedFlow') or (
self.fluxBoundaryConditions[ci] == 'setFlow'))
#
# calculate some dimensions
#
# assume same space dim for all variables
self.nSpace_global = self.u[0].femSpace.nSpace_global
self.nDOF_trial_element = [
u_j.femSpace.max_nDOF_element for u_j in self.u.values()]
self.nDOF_phi_trial_element = [
phi_k.femSpace.max_nDOF_element for phi_k in self.phi.values()]
self.n_phi_ip_element = [
phi_k.femSpace.referenceFiniteElement.interpolationConditions.nQuadraturePoints for phi_k in self.phi.values()]
self.nDOF_test_element = [
femSpace.max_nDOF_element for femSpace in self.testSpace.values()]
self.nFreeDOF_global = [
dc.nFreeDOF_global for dc in self.dirichletConditions.values()]
self.nVDOF_element = sum(self.nDOF_trial_element)
self.nFreeVDOF_global = sum(self.nFreeDOF_global)
#
NonlinearEquation.__init__(self, self.nFreeVDOF_global)
#
# build the quadrature point dictionaries from the input (this
# is just for convenience so that the input doesn't have to be
# complete)
#
elementQuadratureDict = {}
elemQuadIsDict = isinstance(elementQuadrature, dict)
if elemQuadIsDict: # set terms manually
for I in self.coefficients.elementIntegralKeys:
if elementQuadrature.has_key(I):
elementQuadratureDict[I] = elementQuadrature[I]
else:
elementQuadratureDict[I] = elementQuadrature['default']
else:
for I in self.coefficients.elementIntegralKeys:
elementQuadratureDict[I] = elementQuadrature
if self.stabilization is not None:
for I in self.coefficients.elementIntegralKeys:
if elemQuadIsDict:
if elementQuadrature.has_key(I):
elementQuadratureDict[
('stab',) + I[1:]] = elementQuadrature[I]
else:
elementQuadratureDict[
('stab',) + I[1:]] = elementQuadrature['default']
else:
elementQuadratureDict[
('stab',) + I[1:]] = elementQuadrature
if self.shockCapturing is not None:
for ci in self.shockCapturing.components:
if elemQuadIsDict:
if elementQuadrature.has_key(('numDiff', ci, ci)):
elementQuadratureDict[('numDiff', ci, ci)] = elementQuadrature[
('numDiff', ci, ci)]
else:
elementQuadratureDict[('numDiff', ci, ci)] = elementQuadrature[
'default']
else:
elementQuadratureDict[
('numDiff', ci, ci)] = elementQuadrature
if massLumping:
for ci in self.coefficients.mass.keys():
elementQuadratureDict[('m', ci)] = Quadrature.SimplexLobattoQuadrature(
self.nSpace_global, 1)
for I in self.coefficients.elementIntegralKeys:
elementQuadratureDict[
('stab',) + I[1:]] = Quadrature.SimplexLobattoQuadrature(self.nSpace_global, 1)
if reactionLumping:
for ci in self.coefficients.mass.keys():
elementQuadratureDict[('r', ci)] = Quadrature.SimplexLobattoQuadrature(
self.nSpace_global, 1)
for I in self.coefficients.elementIntegralKeys:
elementQuadratureDict[
('stab',) + I[1:]] = Quadrature.SimplexLobattoQuadrature(self.nSpace_global, 1)
elementBoundaryQuadratureDict = {}
if isinstance(elementBoundaryQuadrature, dict): # set terms manually
for I in self.coefficients.elementBoundaryIntegralKeys:
if elementBoundaryQuadrature.has_key(I):
elementBoundaryQuadratureDict[
I] = elementBoundaryQuadrature[I]
else:
elementBoundaryQuadratureDict[
I] = elementBoundaryQuadrature['default']
else:
for I in self.coefficients.elementBoundaryIntegralKeys:
elementBoundaryQuadratureDict[I] = elementBoundaryQuadrature
#
# find the union of all element quadrature points and
# build a quadrature rule for each integral that has a
# weight at each point in the union
# mwf include tag telling me which indices are which quadrature rule?
(self.elementQuadraturePoints, self.elementQuadratureWeights,
self.elementQuadratureRuleIndeces) = Quadrature.buildUnion(elementQuadratureDict)
self.nQuadraturePoints_element = self.elementQuadraturePoints.shape[0]
self.nQuadraturePoints_global = self.nQuadraturePoints_element * \
self.mesh.nElements_global
#
# Repeat the same thing for the element boundary quadrature
#
(self.elementBoundaryQuadraturePoints, self.elementBoundaryQuadratureWeights,
self.elementBoundaryQuadratureRuleIndeces) = Quadrature.buildUnion(elementBoundaryQuadratureDict)
self.nElementBoundaryQuadraturePoints_elementBoundary = self.elementBoundaryQuadraturePoints.shape[
0]
self.nElementBoundaryQuadraturePoints_global = (
self.mesh.nElements_global *
self.mesh.nElementBoundaries_element *
self.nElementBoundaryQuadraturePoints_elementBoundary)
if type(self.u[0].femSpace) == C0_AffineLinearOnSimplexWithNodalBasis:
# print self.nQuadraturePoints_element
if self.nSpace_global == 3:
assert(self.nQuadraturePoints_element == 5)
elif self.nSpace_global == 2:
assert(self.nQuadraturePoints_element == 6)
elif self.nSpace_global == 1:
assert(self.nQuadraturePoints_element == 3)
# print self.nElementBoundaryQuadraturePoints_elementBoundary
if self.nSpace_global == 3:
assert(self.nElementBoundaryQuadraturePoints_elementBoundary == 4)
elif self.nSpace_global == 2:
assert(self.nElementBoundaryQuadraturePoints_elementBoundary == 4)
elif self.nSpace_global == 1:
assert(self.nElementBoundaryQuadraturePoints_elementBoundary == 1)
#
# simplified allocations for test==trial and also check if space is mixed or not
#
self.added_mass_i = 0;
self.Aij = np.zeros((self.coefficients.flags_rigidbody.shape[0], 6, 6), 'd')
self.q = {}
self.ebq = {}
self.ebq_global = {}
self.ebqe = {}
self.phi_ip = {}
# mesh
#self.q['x'] = numpy.zeros((self.mesh.nElements_global,self.nQuadraturePoints_element,3),'d')
self.ebqe['x'] = numpy.zeros(
(self.mesh.nExteriorElementBoundaries_global,
self.nElementBoundaryQuadraturePoints_elementBoundary,
3),
'd')
self.q[('u', 0)] = numpy.zeros(
(self.mesh.nElements_global, self.nQuadraturePoints_element), 'd')
self.q[
('grad(u)',
0)] = numpy.zeros(
(self.mesh.nElements_global,
self.nQuadraturePoints_element,
self.nSpace_global),
'd')
self.ebqe[
('u',
0)] = numpy.zeros(
(self.mesh.nExteriorElementBoundaries_global,
self.nElementBoundaryQuadraturePoints_elementBoundary),
'd')
self.ebqe[
('grad(u)',
0)] = numpy.zeros(
(self.mesh.nExteriorElementBoundaries_global,
self.nElementBoundaryQuadraturePoints_elementBoundary,
self.nSpace_global),
'd')
self.q[('v', 0)] = numpy.zeros(
(self.mesh.nElements_global,
self.nQuadraturePoints_element,
self.nDOF_trial_element[0]),
'd')
self.q['J'] = numpy.zeros(
(self.mesh.nElements_global,
self.nQuadraturePoints_element,
self.nSpace_global,
self.nSpace_global),
'd')
self.q['det(J)'] = numpy.zeros(
(self.mesh.nElements_global,
self.nQuadraturePoints_element),
'd')
self.q['inverse(J)'] = numpy.zeros(
(self.mesh.nElements_global,
self.nQuadraturePoints_element,
self.nSpace_global,
self.nSpace_global),
'd')
self.ebq[('v', 0)] = numpy.zeros(
(self.mesh.nElements_global,
self.mesh.nElementBoundaries_element,
self.nElementBoundaryQuadraturePoints_elementBoundary,
self.nDOF_trial_element[0]),
'd')
self.ebq[('w', 0)] = numpy.zeros(
(self.mesh.nElements_global,
self.mesh.nElementBoundaries_element,
self.nElementBoundaryQuadraturePoints_elementBoundary,
self.nDOF_trial_element[0]),
'd')
self.ebq['x'] = numpy.zeros(
(self.mesh.nElements_global,
self.mesh.nElementBoundaries_element,
self.nElementBoundaryQuadraturePoints_elementBoundary,
3),
'd')
self.ebq['hat(x)'] = numpy.zeros(
(self.mesh.nElements_global,
self.mesh.nElementBoundaries_element,
self.nElementBoundaryQuadraturePoints_elementBoundary,
3),
'd')
self.ebq['inverse(J)'] = numpy.zeros(
(self.mesh.nElements_global,
self.mesh.nElementBoundaries_element,
self.nElementBoundaryQuadraturePoints_elementBoundary,
self.nSpace_global,
self.nSpace_global),
'd')
self.ebq['g'] = numpy.zeros(
(self.mesh.nElements_global,
self.mesh.nElementBoundaries_element,
self.nElementBoundaryQuadraturePoints_elementBoundary,
self.nSpace_global - 1,
self.nSpace_global - 1),
'd')
self.ebq['sqrt(det(g))'] = numpy.zeros(
(self.mesh.nElements_global,
self.mesh.nElementBoundaries_element,
self.nElementBoundaryQuadraturePoints_elementBoundary),
'd')
self.ebq['n'] = numpy.zeros(
(self.mesh.nElements_global,
self.mesh.nElementBoundaries_element,
self.nElementBoundaryQuadraturePoints_elementBoundary,
self.nSpace_global),
'd')
self.ebq[('dS_u', 0)] = numpy.zeros(
(self.mesh.nElements_global,
self.mesh.nElementBoundaries_element,
self.nElementBoundaryQuadraturePoints_elementBoundary),
'd')
self.ebqe['dS'] = numpy.zeros(
(self.mesh.nExteriorElementBoundaries_global,
self.nElementBoundaryQuadraturePoints_elementBoundary),
'd')
self.ebqe[('dS_u', 0)] = self.ebqe['dS']
self.ebqe['n'] = numpy.zeros(
(self.mesh.nExteriorElementBoundaries_global,
self.nElementBoundaryQuadraturePoints_elementBoundary,
self.nSpace_global),
'd')
self.ebqe['inverse(J)'] = numpy.zeros(
(self.mesh.nExteriorElementBoundaries_global,
self.nElementBoundaryQuadraturePoints_elementBoundary,
self.nSpace_global,
self.nSpace_global),
'd')
self.ebqe['g'] = numpy.zeros(
(self.mesh.nExteriorElementBoundaries_global,
self.nElementBoundaryQuadraturePoints_elementBoundary,
self.nSpace_global - 1,
self.nSpace_global - 1),
'd')
self.ebqe['sqrt(det(g))'] = numpy.zeros(
(self.mesh.nExteriorElementBoundaries_global,
self.nElementBoundaryQuadraturePoints_elementBoundary),
'd')
self.ebq_global['n'] = numpy.zeros(
(self.mesh.nElementBoundaries_global,
self.nElementBoundaryQuadraturePoints_elementBoundary,
self.nSpace_global),
'd')
self.ebq_global['x'] = numpy.zeros(
(self.mesh.nElementBoundaries_global,
self.nElementBoundaryQuadraturePoints_elementBoundary,
3),
'd')
self.ebqe[('diffusiveFlux_bc_flag', 0, 0)] = numpy.zeros(
(self.mesh.nExteriorElementBoundaries_global, self.nElementBoundaryQuadraturePoints_elementBoundary), 'i')
self.ebqe[('diffusiveFlux_bc', 0, 0)] = numpy.zeros(
(self.mesh.nExteriorElementBoundaries_global, self.nElementBoundaryQuadraturePoints_elementBoundary), 'd')
self.ebqe[('diffusiveFlux', 0, 0)] = numpy.zeros((self.mesh.nExteriorElementBoundaries_global, self.nElementBoundaryQuadraturePoints_elementBoundary), 'd')
self.points_elementBoundaryQuadrature = set()
self.scalars_elementBoundaryQuadrature = set(
[('u', ci) for ci in range(self.nc)])
self.vectors_elementBoundaryQuadrature = set()
self.tensors_elementBoundaryQuadrature = set()
logEvent(memory("element and element boundary Jacobians",
"OneLevelTransport"), level=4)
self.inflowBoundaryBC = {}
self.inflowBoundaryBC_values = {}
self.inflowFlux = {}
for cj in range(self.nc):
self.inflowBoundaryBC[cj] = numpy.zeros(
(self.mesh.nExteriorElementBoundaries_global,), 'i')
self.inflowBoundaryBC_values[cj] = numpy.zeros(
(self.mesh.nExteriorElementBoundaries_global, self.nDOF_trial_element[cj]), 'd')
self.inflowFlux[cj] = numpy.zeros(
(self.mesh.nExteriorElementBoundaries_global,
self.nElementBoundaryQuadraturePoints_elementBoundary),
'd')
self.internalNodes = set(range(self.mesh.nNodes_global))
# identify the internal nodes this is ought to be in mesh
# \todo move this to mesh
for ebNE in range(self.mesh.nExteriorElementBoundaries_global):
ebN = self.mesh.exteriorElementBoundariesArray[ebNE]
eN_global = self.mesh.elementBoundaryElementsArray[ebN, 0]
ebN_element = self.mesh.elementBoundaryLocalElementBoundariesArray[
ebN, 0]
for i in range(self.mesh.nNodes_element):
if i != ebN_element:
I = self.mesh.elementNodesArray[eN_global, i]
self.internalNodes -= set([I])
self.nNodes_internal = len(self.internalNodes)
self.internalNodesArray = numpy.zeros((self.nNodes_internal,), 'i')
for nI, n in enumerate(self.internalNodes):
self.internalNodesArray[nI] = n
#
del self.internalNodes
self.internalNodes = None
logEvent("Updating local to global mappings", 2)
self.updateLocal2Global()
logEvent("Building time integration object", 2)
logEvent(memory("inflowBC, internalNodes,updateLocal2Global",
"OneLevelTransport"), level=4)
# mwf for interpolating subgrid error for gradients etc
if self.stabilization and self.stabilization.usesGradientStabilization:
self.timeIntegration = TimeIntegrationClass(
self, integrateInterpolationPoints=True)
else:
self.timeIntegration = TimeIntegrationClass(self)
if options is not None:
self.timeIntegration.setFromOptions(options)
logEvent(memory("TimeIntegration", "OneLevelTransport"), level=4)
logEvent("Calculating numerical quadrature formulas", 2)
self.calculateQuadrature()
self.setupFieldStrides()
comm = Comm.get()
self.comm = comm
if comm.size() > 1:
assert numericalFluxType is not None and numericalFluxType.useWeakDirichletConditions, "You must use a numerical flux to apply weak boundary conditions for parallel runs"
logEvent(memory("stride+offset", "OneLevelTransport"), level=4)
if numericalFluxType is not None:
if options is None or options.periodicDirichletConditions is None:
self.numericalFlux = numericalFluxType(
self,
dofBoundaryConditionsSetterDict,
advectiveFluxBoundaryConditionsSetterDict,
diffusiveFluxBoundaryConditionsSetterDictDict)
else:
self.numericalFlux = numericalFluxType(
self,
dofBoundaryConditionsSetterDict,
advectiveFluxBoundaryConditionsSetterDict,
diffusiveFluxBoundaryConditionsSetterDictDict,
options.periodicDirichletConditions)
else:
self.numericalFlux = None
# strong Dirichlet
self.dirichletConditionsForceDOF = {0: DOFBoundaryConditions(self.u[cj].femSpace, dofBoundaryConditionsSetterDict[cj], weakDirichletConditions=False)}
# set penalty terms
# cek todo move into numerical flux initialization
if self.ebq_global.has_key('penalty'):
for ebN in range(self.mesh.nElementBoundaries_global):
for k in range(
self.nElementBoundaryQuadraturePoints_elementBoundary):
self.ebq_global['penalty'][ebN, k] = self.numericalFlux.penalty_constant / (
self.mesh.elementBoundaryDiametersArray[ebN]**self.numericalFlux.penalty_power)
# penalty term
# cek move to Numerical flux initialization
if self.ebqe.has_key('penalty'):
for ebNE in range(self.mesh.nExteriorElementBoundaries_global):
ebN = self.mesh.exteriorElementBoundariesArray[ebNE]
for k in range(
self.nElementBoundaryQuadraturePoints_elementBoundary):
self.ebqe['penalty'][ebNE, k] = self.numericalFlux.penalty_constant / \
self.mesh.elementBoundaryDiametersArray[ebN]**self.numericalFlux.penalty_power
logEvent(memory("numericalFlux", "OneLevelTransport"), level=4)
self.elementEffectiveDiametersArray = self.mesh.elementInnerDiametersArray
# use post processing tools to get conservative fluxes, None by default
from proteus import PostProcessingTools
self.velocityPostProcessor = PostProcessingTools.VelocityPostProcessingChooser(
self)
logEvent(memory("velocity postprocessor", "OneLevelTransport"), level=4)
# helper for writing out data storage
from proteus import Archiver
self.elementQuadratureDictionaryWriter = Archiver.XdmfWriter()
self.elementBoundaryQuadratureDictionaryWriter = Archiver.XdmfWriter()
self.exteriorElementBoundaryQuadratureDictionaryWriter = Archiver.XdmfWriter()
self.globalResidualDummy = None
compKernelFlag = 0
self.addedMass = cAddedMass.AddedMass(
self.nSpace_global,
self.nQuadraturePoints_element,
self.u[0].femSpace.elementMaps.localFunctionSpace.dim,
self .u[0].femSpace.referenceFiniteElement.localFunctionSpace.dim,
self.testSpace[0].referenceFiniteElement.localFunctionSpace.dim,
self.nElementBoundaryQuadraturePoints_elementBoundary,
compKernelFlag)
self.barycenters = self.coefficients.barycenters
self.flags_rigidbody = self.coefficients.flags_rigidbody
def computeWaterline(self, t):
self.waterline_calls += 1
if (
self.coefficients.waterline_interval > 0
and self.waterline_calls % self.coefficients.waterline_interval == 0
):
self.waterline_npoints = numpy.zeros((1,), "i")
self.waterline_data = numpy.zeros((self.mesh.nExteriorElementBoundaries_global, self.nSpace_global), "d")
self.ncls.calculateWaterline( # element
self.waterline_npoints,
self.waterline_data,
self.u[0].femSpace.elementMaps.psi,
self.u[0].femSpace.elementMaps.grad_psi,
self.mesh.nodeArray,
self.mesh.nodeVelocityArray,
self.MOVING_DOMAIN,
self.mesh.elementNodesArray,
self.elementQuadratureWeights[("u", 0)],
self.u[0].femSpace.psi,
self.u[0].femSpace.grad_psi,
self.u[0].femSpace.psi,
self.u[0].femSpace.grad_psi,
# element boundary
self.u[0].femSpace.elementMaps.psi_trace,
self.u[0].femSpace.elementMaps.grad_psi_trace,
self.elementBoundaryQuadratureWeights[("u", 0)],
self.u[0].femSpace.psi_trace,
self.u[0].femSpace.grad_psi_trace,
self.u[0].femSpace.psi_trace,
self.u[0].femSpace.grad_psi_trace,
self.u[0].femSpace.elementMaps.boundaryNormals,
self.u[0].femSpace.elementMaps.boundaryJacobians,
# physics
self.mesh.nElements_global,
self.coefficients.useMetrics,
self.timeIntegration.alpha_bdf, # mwf was self.timeIntegration.dt,
self.shockCapturing.lag,
self.shockCapturing.shockCapturingFactor,
self.coefficients.sc_uref,
self.coefficients.sc_beta,
self.u[0].femSpace.dofMap.l2g,
self.mesh.elementDiametersArray,
self.u[0].dof,
self.coefficients.u_old_dof,
self.coefficients.q_v,
self.timeIntegration.m_tmp[0],
self.q[("u", 0)],
self.q[("grad(u)", 0)],
self.q[("dH_sge", 0, 0)],
self.timeIntegration.beta_bdf[0], # mwf was self.timeIntegration.m_last[0],
self.q[("cfl", 0)],
self.shockCapturing.numDiff[0],
self.shockCapturing.numDiff_last[0],
self.offset[0],
self.stride[0],
self.mesh.nExteriorElementBoundaries_global,
self.mesh.exteriorElementBoundariesArray,
self.mesh.elementBoundaryElementsArray,
self.mesh.elementBoundaryLocalElementBoundariesArray,
self.mesh.elementBoundaryMaterialTypes,
self.coefficients.ebqe_v,
self.numericalFlux.isDOFBoundary[0],
self.numericalFlux.ebqe[("u", 0)],
self.ebqe[("u", 0)],
)
from proteus import Comm
comm = Comm.get()
filename = os.path.join(
self.coefficients.opts.dataDir, "waterline." + str(comm.rank()) + "." + str(self.waterline_prints)
)
numpy.save(filename, self.waterline_data[0 : self.waterline_npoints[0]])
self.waterline_prints += 1
def setup_profiling():
comm = Comm.get()
Profiling.procID = comm.rank()
Profiling.logLevel = 10
Profiling.logFile = sys.stdout
Profiling.logAllProcesses = True
#!/usr/bin/env python
"""
Test module for BDM2 Elements
"""
from proteus.iproteus import *
from proteus import Comm
comm = Comm.get()
Profiling.logLevel = 7
Profiling.verbose = True
import numpy.testing as npt
from nose.tools import ok_ as ok
from nose.tools import eq_ as eq
from nose.tools import set_trace
def test_BDM2_P2():
'''
Test the construction of a BDM2 projection matrix and rhs
on the reference triangle
'''
# bdm_tests_template loads
import example1 as ex
import numpy as np
import expected_output as eo
transport_obj = ex.ns.modelList[0].levelModelList[0]
bdm2_obj = transport_obj.velocityPostProcessor.vpp_algorithms[0]
assert eo.globalDOF2Element_test == bdm2_obj.globalDOF2globalElementList
def __init__(self,
uDict,
phiDict,
testSpaceDict,
matType,
dofBoundaryConditionsDict,
dofBoundaryConditionsSetterDict,
coefficients,
elementQuadrature,
elementBoundaryQuadrature,
fluxBoundaryConditionsDict=None,
advectiveFluxBoundaryConditionsSetterDict=None,
diffusiveFluxBoundaryConditionsSetterDictDict=None,
stressTraceBoundaryConditionsSetterDict=None,
stabilization=None,
shockCapturing=None,
conservativeFluxDict=None,
numericalFluxType=None,
TimeIntegrationClass=None,
massLumping=False,
reactionLumping=False,
options=None,
name='defaultName',
reuse_trial_and_test_quadrature=True,
sd=True,
movingDomain=False): #,
from proteus import Comm
#
#set the objects describing the method and boundary conditions
#
self.movingDomain = movingDomain
self.tLast_mesh = None
#
self.name = name
self.sd = sd
self.Hess = False
self.lowmem = True
self.timeTerm = True #allow turning off the time derivative
#self.lowmem=False
self.testIsTrial = True
self.phiTrialIsTrial = True
self.u = uDict
self.ua = {} #analytical solutions
self.phi = phiDict
self.dphi = {}
self.matType = matType
self.reuse_test_trial_quadrature = reuse_trial_and_test_quadrature #True#False
if self.reuse_test_trial_quadrature:
for ci in range(1, coefficients.nc):
assert self.u[ci].femSpace.__class__.__name__ == self.u[
0].femSpace.__class__.__name__, "to reuse_test_trial_quad all femSpaces must be the same!"
## Simplicial Mesh
self.mesh = self.u[
0].femSpace.mesh #assume the same mesh for all components for now
self.testSpace = testSpaceDict
self.dirichletConditions = dofBoundaryConditionsDict
self.dirichletNodeSetList = None #explicit Dirichlet conditions for now, no Dirichlet BC constraints
self.coefficients = coefficients
self.coefficients.initializeMesh(self.mesh)
self.nc = self.coefficients.nc
self.stabilization = stabilization
self.shockCapturing = shockCapturing
self.conservativeFlux = conservativeFluxDict #no velocity post-processing for now
self.fluxBoundaryConditions = fluxBoundaryConditionsDict
self.advectiveFluxBoundaryConditionsSetterDict = advectiveFluxBoundaryConditionsSetterDict
self.diffusiveFluxBoundaryConditionsSetterDictDict = diffusiveFluxBoundaryConditionsSetterDictDict
#determine whether the stabilization term is nonlinear
self.stabilizationIsNonlinear = False
#cek come back
if self.stabilization is not None:
for ci in range(self.nc):
if ci in coefficients.mass:
for flag in coefficients.mass[ci].values():
if flag == 'nonlinear':
self.stabilizationIsNonlinear = True
if ci in coefficients.advection:
for flag in coefficients.advection[ci].values():
if flag == 'nonlinear':
self.stabilizationIsNonlinear = True
if ci in coefficients.diffusion:
for diffusionDict in coefficients.diffusion[ci].values():
for flag in diffusionDict.values():
if flag != 'constant':
self.stabilizationIsNonlinear = True
if ci in coefficients.potential:
for flag in coefficients.potential[ci].values():
if flag == 'nonlinear':
self.stabilizationIsNonlinear = True
if ci in coefficients.reaction:
for flag in coefficients.reaction[ci].values():
if flag == 'nonlinear':
self.stabilizationIsNonlinear = True
if ci in coefficients.hamiltonian:
for flag in coefficients.hamiltonian[ci].values():
if flag == 'nonlinear':
self.stabilizationIsNonlinear = True
#determine if we need element boundary storage
self.elementBoundaryIntegrals = {}
for ci in range(self.nc):
self.elementBoundaryIntegrals[ci] = (
(self.conservativeFlux is not None)
or (numericalFluxType is not None)
or (self.fluxBoundaryConditions[ci] == 'outFlow')
or (self.fluxBoundaryConditions[ci] == 'mixedFlow')
or (self.fluxBoundaryConditions[ci] == 'setFlow'))
#
#calculate some dimensions
#
self.nSpace_global = self.u[
0].femSpace.nSpace_global #assume same space dim for all variables
self.nDOF_trial_element = [
u_j.femSpace.max_nDOF_element for u_j in self.u.values()
]
self.nDOF_phi_trial_element = [
phi_k.femSpace.max_nDOF_element for phi_k in self.phi.values()
]
self.n_phi_ip_element = [
phi_k.femSpace.referenceFiniteElement.interpolationConditions.
nQuadraturePoints for phi_k in self.phi.values()
]
self.nDOF_test_element = [
femSpace.max_nDOF_element for femSpace in self.testSpace.values()
]
self.nFreeDOF_global = [
dc.nFreeDOF_global for dc in self.dirichletConditions.values()
]
self.nVDOF_element = sum(self.nDOF_trial_element)
self.nFreeVDOF_global = sum(self.nFreeDOF_global)
#
NonlinearEquation.__init__(self, self.nFreeVDOF_global)
#
#build the quadrature point dictionaries from the input (this
#is just for convenience so that the input doesn't have to be
#complete)
#
elementQuadratureDict = {}
elemQuadIsDict = isinstance(elementQuadrature, dict)
if elemQuadIsDict: #set terms manually
for I in self.coefficients.elementIntegralKeys:
if I in elementQuadrature:
elementQuadratureDict[I] = elementQuadrature[I]
else:
elementQuadratureDict[I] = elementQuadrature['default']
else:
for I in self.coefficients.elementIntegralKeys:
elementQuadratureDict[I] = elementQuadrature
if self.stabilization is not None:
for I in self.coefficients.elementIntegralKeys:
if elemQuadIsDict:
if I in elementQuadrature:
elementQuadratureDict[('stab', ) +
I[1:]] = elementQuadrature[I]
else:
elementQuadratureDict[
('stab', ) + I[1:]] = elementQuadrature['default']
else:
elementQuadratureDict[('stab', ) +
I[1:]] = elementQuadrature
if self.shockCapturing is not None:
for ci in self.shockCapturing.components:
if elemQuadIsDict:
if ('numDiff', ci, ci) in elementQuadrature:
elementQuadratureDict[(
'numDiff', ci, ci)] = elementQuadrature[('numDiff',
ci, ci)]
else:
elementQuadratureDict[(
'numDiff', ci, ci)] = elementQuadrature['default']
else:
elementQuadratureDict[('numDiff', ci,
ci)] = elementQuadrature
if massLumping:
for ci in self.coefficients.mass.keys():
elementQuadratureDict[(
'm', ci)] = Quadrature.SimplexLobattoQuadrature(
self.nSpace_global, 1)
for I in self.coefficients.elementIntegralKeys:
elementQuadratureDict[
('stab', ) + I[1:]] = Quadrature.SimplexLobattoQuadrature(
self.nSpace_global, 1)
if reactionLumping:
for ci in self.coefficients.mass.keys():
elementQuadratureDict[(
'r', ci)] = Quadrature.SimplexLobattoQuadrature(
self.nSpace_global, 1)
for I in self.coefficients.elementIntegralKeys:
elementQuadratureDict[
('stab', ) + I[1:]] = Quadrature.SimplexLobattoQuadrature(
self.nSpace_global, 1)
elementBoundaryQuadratureDict = {}
if isinstance(elementBoundaryQuadrature, dict): #set terms manually
for I in self.coefficients.elementBoundaryIntegralKeys:
if I in elementBoundaryQuadrature:
elementBoundaryQuadratureDict[
I] = elementBoundaryQuadrature[I]
else:
elementBoundaryQuadratureDict[
I] = elementBoundaryQuadrature['default']
else:
for I in self.coefficients.elementBoundaryIntegralKeys:
elementBoundaryQuadratureDict[I] = elementBoundaryQuadrature
#
# find the union of all element quadrature points and
# build a quadrature rule for each integral that has a
# weight at each point in the union
(self.elementQuadraturePoints, self.elementQuadratureWeights,
self.elementQuadratureRuleIndeces
) = Quadrature.buildUnion(elementQuadratureDict)
self.nQuadraturePoints_element = self.elementQuadraturePoints.shape[0]
self.nQuadraturePoints_global = self.nQuadraturePoints_element * self.mesh.nElements_global
#
#Repeat the same thing for the element boundary quadrature
#
(self.elementBoundaryQuadraturePoints,
self.elementBoundaryQuadratureWeights,
self.elementBoundaryQuadratureRuleIndeces
) = Quadrature.buildUnion(elementBoundaryQuadratureDict)
self.nElementBoundaryQuadraturePoints_elementBoundary = self.elementBoundaryQuadraturePoints.shape[
0]
self.nElementBoundaryQuadraturePoints_global = (
self.mesh.nElements_global * self.mesh.nElementBoundaries_element *
self.nElementBoundaryQuadraturePoints_elementBoundary)
#
#simplified allocations for test==trial and also check if space is mixed or not
#
self.q = {}
self.ebq = {}
self.ebq_global = {}
self.ebqe = {}
self.phi_ip = {}
#mesh
self.q['x'] = np.zeros(
(self.mesh.nElements_global, self.nQuadraturePoints_element, 3),
'd')
self.ebqe['x'] = np.zeros(
(self.mesh.nExteriorElementBoundaries_global,
self.nElementBoundaryQuadraturePoints_elementBoundary, 3), 'd')
self.q[('u', 0)] = np.zeros(
(self.mesh.nElements_global, self.nQuadraturePoints_element), 'd')
self.q[('grad(u)', 0)] = np.zeros(
(self.mesh.nElements_global, self.nQuadraturePoints_element,
self.nSpace_global), 'd')
self.q[('a', 0, 0)] = np.zeros(
(self.mesh.nElements_global, self.nQuadraturePoints_element,
self.coefficients.sdInfo[(0, 0)][0][-1]), 'd')
self.q[('df', 0, 0)] = np.zeros(
(self.mesh.nElements_global, self.nQuadraturePoints_element,
self.nSpace_global), 'd')
self.q[('r', 0)] = np.zeros(
(self.mesh.nElements_global, self.nQuadraturePoints_element), 'd')
self.q[('cfl', 0)] = np.zeros(
(self.mesh.nElements_global, self.nQuadraturePoints_element), 'd')
self.q[('numDiff', 0, 0)] = np.zeros(
(self.mesh.nElements_global, self.nQuadraturePoints_element), 'd')
self.ebqe['penalty'] = np.zeros(
(self.mesh.nExteriorElementBoundaries_global,
self.nElementBoundaryQuadraturePoints_elementBoundary), 'd')
self.ebqe[('u', 0)] = np.zeros(
(self.mesh.nExteriorElementBoundaries_global,
self.nElementBoundaryQuadraturePoints_elementBoundary), 'd')
self.ebqe[('diffusiveFlux_bc_flag', 0, 0)] = np.zeros(
(self.mesh.nExteriorElementBoundaries_global,
self.nElementBoundaryQuadraturePoints_elementBoundary), 'i')
self.ebqe[('diffusiveFlux_bc', 0, 0)] = np.zeros(
(self.mesh.nExteriorElementBoundaries_global,
self.nElementBoundaryQuadraturePoints_elementBoundary), 'd')
self.ebqe[('advectiveFlux_bc_flag', 0)] = np.zeros(
(self.mesh.nExteriorElementBoundaries_global,
self.nElementBoundaryQuadraturePoints_elementBoundary), 'i')
self.ebqe[('advectiveFlux_bc', 0)] = np.zeros(
(self.mesh.nExteriorElementBoundaries_global,
self.nElementBoundaryQuadraturePoints_elementBoundary), 'd')
self.ebqe[('grad(u)', 0)] = np.zeros(
(self.mesh.nExteriorElementBoundaries_global,
self.nElementBoundaryQuadraturePoints_elementBoundary,
self.nSpace_global), 'd')
self.ebqe[('a', 0, 0)] = np.zeros(
(self.mesh.nExteriorElementBoundaries_global,
self.nElementBoundaryQuadraturePoints_elementBoundary,
self.coefficients.sdInfo[(0, 0)][0][-1]), 'd')
self.ebqe[('df', 0, 0)] = np.zeros(
(self.mesh.nExteriorElementBoundaries_global,
self.nElementBoundaryQuadraturePoints_elementBoundary,
self.nSpace_global), 'd')
self.ebqe[('r', 0)] = np.zeros(
(self.mesh.nExteriorElementBoundaries_global,
self.nElementBoundaryQuadraturePoints_elementBoundary), 'd')
self.points_elementBoundaryQuadrature = set()
self.scalars_elementBoundaryQuadrature = set([
('u', ci) for ci in range(self.nc)
])
self.vectors_elementBoundaryQuadrature = set()
self.tensors_elementBoundaryQuadrature = set()
log(memory("element and element boundary Jacobians",
"OneLevelTransport"),
level=4)
self.inflowBoundaryBC = {}
self.inflowBoundaryBC_values = {}
self.inflowFlux = {}
for cj in range(self.nc):
self.inflowBoundaryBC[cj] = np.zeros(
(self.mesh.nExteriorElementBoundaries_global, ), 'i')
self.inflowBoundaryBC_values[cj] = np.zeros(
(self.mesh.nExteriorElementBoundaries_global,
self.nDOF_trial_element[cj]), 'd')
self.inflowFlux[cj] = np.zeros(
(self.mesh.nExteriorElementBoundaries_global,
self.nElementBoundaryQuadraturePoints_elementBoundary), 'd')
self.internalNodes = set(range(self.mesh.nNodes_global))
#identify the internal nodes this is ought to be in mesh
##\todo move this to mesh
for ebNE in range(self.mesh.nExteriorElementBoundaries_global):
ebN = self.mesh.exteriorElementBoundariesArray[ebNE]
eN_global = self.mesh.elementBoundaryElementsArray[ebN, 0]
ebN_element = self.mesh.elementBoundaryLocalElementBoundariesArray[
ebN, 0]
for i in range(self.mesh.nNodes_element):
if i != ebN_element:
I = self.mesh.elementNodesArray[eN_global, i]
self.internalNodes -= set([I])
self.nNodes_internal = len(self.internalNodes)
self.internalNodesArray = np.zeros((self.nNodes_internal, ), 'i')
for nI, n in enumerate(self.internalNodes):
self.internalNodesArray[nI] = n
#
del self.internalNodes
self.internalNodes = None
log("Updating local to global mappings", 2)
self.updateLocal2Global()
log("Building time integration object", 2)
log(memory("inflowBC, internalNodes,updateLocal2Global",
"OneLevelTransport"),
level=4)
if self.stabilization and self.stabilization.usesGradientStabilization:
self.timeIntegration = TimeIntegrationClass(
self, integrateInterpolationPoints=True)
else:
self.timeIntegration = TimeIntegrationClass(self)
if options is not None:
self.timeIntegration.setFromOptions(options)
log(memory("TimeIntegration", "OneLevelTransport"), level=4)
log("Calculating numerical quadrature formulas", 2)
self.calculateQuadrature()
comm = Comm.get()
self.comm = comm
if comm.size() > 1:
assert numericalFluxType is not None and numericalFluxType.useWeakDirichletConditions, "You must use a numerical flux to apply weak boundary conditions for parallel runs"
self.setupFieldStrides()
log(memory("stride+offset", "OneLevelTransport"), level=4)
if numericalFluxType is not None:
if options is None or options.periodicDirichletConditions is None:
self.numericalFlux = numericalFluxType(
self, dofBoundaryConditionsSetterDict,
advectiveFluxBoundaryConditionsSetterDict,
diffusiveFluxBoundaryConditionsSetterDictDict)
else:
self.numericalFlux = numericalFluxType(
self, dofBoundaryConditionsSetterDict,
advectiveFluxBoundaryConditionsSetterDict,
diffusiveFluxBoundaryConditionsSetterDictDict,
options.periodicDirichletConditions)
else:
self.numericalFlux = None
#set penalty terms
#cek todo move into numerical flux initialization
if 'penalty' in self.ebq_global:
for ebN in range(self.mesh.nElementBoundaries_global):
for k in range(
self.nElementBoundaryQuadraturePoints_elementBoundary):
self.ebq_global['penalty'][
ebN, k] = self.numericalFlux.penalty_constant / (
self.mesh.elementBoundaryDiametersArray[ebN]**
self.numericalFlux.penalty_power)
#penalty term
#cek move to Numerical flux initialization
if 'penalty' in self.ebqe:
for ebNE in range(self.mesh.nExteriorElementBoundaries_global):
ebN = self.mesh.exteriorElementBoundariesArray[ebNE]
for k in range(
self.nElementBoundaryQuadraturePoints_elementBoundary):
self.ebqe['penalty'][
ebNE,
k] = self.numericalFlux.penalty_constant / self.mesh.elementBoundaryDiametersArray[
ebN]**self.numericalFlux.penalty_power
log(memory("numericalFlux", "OneLevelTransport"), level=4)
self.elementEffectiveDiametersArray = self.mesh.elementInnerDiametersArray
#use post processing tools to get conservative fluxes, None by default
from proteus import PostProcessingTools
self.velocityPostProcessor = PostProcessingTools.VelocityPostProcessingChooser(
self)
log(memory("velocity postprocessor", "OneLevelTransport"), level=4)
#helper for writing out data storage
from proteus import Archiver
self.elementQuadratureDictionaryWriter = Archiver.XdmfWriter()
self.elementBoundaryQuadratureDictionaryWriter = Archiver.XdmfWriter()
self.exteriorElementBoundaryQuadratureDictionaryWriter = Archiver.XdmfWriter(
)
for ci, fbcObject in self.fluxBoundaryConditionsObjectsDict.items():
self.ebqe[('advectiveFlux_bc_flag', ci)] = np.zeros(
self.ebqe[('advectiveFlux_bc', ci)].shape, 'i')
for t, g in fbcObject.advectiveFluxBoundaryConditionsDict.items():
if ci in self.coefficients.advection:
self.ebqe[('advectiveFlux_bc',
ci)][t[0],
t[1]] = g(self.ebqe[('x')][t[0], t[1]],
self.timeIntegration.t)
self.ebqe[('advectiveFlux_bc_flag', ci)][t[0], t[1]] = 1
for ck, diffusiveFluxBoundaryConditionsDict in fbcObject.diffusiveFluxBoundaryConditionsDictDict.items(
):
self.ebqe[('diffusiveFlux_bc_flag', ck, ci)] = np.zeros(
self.ebqe[('diffusiveFlux_bc', ck, ci)].shape, 'i')
for t, g in diffusiveFluxBoundaryConditionsDict.items():
self.ebqe[('diffusiveFlux_bc', ck,
ci)][t[0],
t[1]] = g(self.ebqe[('x')][t[0], t[1]],
self.timeIntegration.t)
self.ebqe[('diffusiveFlux_bc_flag', ck, ci)][t[0],
t[1]] = 1
self.numericalFlux.setDirichletValues(self.ebqe)
if self.movingDomain:
self.MOVING_DOMAIN = 1.0
else:
self.MOVING_DOMAIN = 0.0
#cek hack
self.movingDomain = False
self.MOVING_DOMAIN = 0.0
if self.mesh.nodeVelocityArray is None:
self.mesh.nodeVelocityArray = np.zeros(self.mesh.nodeArray.shape,
'd')
#cek/ido todo replace python loops in modules with optimized code if possible/necessary
self.forceStrongConditions = coefficients.forceStrongDirichlet
self.dirichletConditionsForceDOF = {}
if self.forceStrongConditions:
for cj in range(self.nc):
self.dirichletConditionsForceDOF[cj] = DOFBoundaryConditions(
self.u[cj].femSpace,
dofBoundaryConditionsSetterDict[cj],
weakDirichletConditions=False)
compKernelFlag = 0
self.adr = cADR_base(
self.nSpace_global, self.nQuadraturePoints_element,
self.u[0].femSpace.elementMaps.localFunctionSpace.dim,
self.u[0].femSpace.referenceFiniteElement.localFunctionSpace.dim,
self.testSpace[0].referenceFiniteElement.localFunctionSpace.dim,
self.nElementBoundaryQuadraturePoints_elementBoundary,
compKernelFlag)
