def _pair_periodic_fluid_faces(self, bpart, resid):
pfaces = defaultdict(list)
nodepts = self._nodepts
for k, (lpent, rpent) in self._pfacespents.items():
for pftype in bpart[lpent]:
lfnodes = bpart[lpent][pftype]
rfnodes = bpart[rpent][pftype]
lfpts = np.array([[nodepts[n] for n in fn] for fn in lfnodes])
rfpts = np.array([[nodepts[n] for n in fn] for fn in rfnodes])
lfidx = fuzzysort(lfpts.mean(axis=1).T, range(len(lfnodes)))
rfidx = fuzzysort(rfpts.mean(axis=1).T, range(len(rfnodes)))
for lfn, rfn in zip(lfnodes[lfidx], rfnodes[rfidx]):
# Add periodic face flags: periodic BC number offset plus 1 to avoid +/- 0
flg = int(k) + 1
# Left = +, right = -
lf = resid.pop(tuple(sorted(lfn)))[:-1] + (flg, )
rf = resid.pop(tuple(sorted(rfn)))[:-1] + (-flg, )
pfaces[pftype].append([lf, rf])
return pfaces
def _pair_periodic_fluid_faces(self, bpart, resid):
pfaces = defaultdict(list)
nodepts = self._nodepts
for lpent, rpent in self._pfacespents.itervalues():
for pftype in bpart[lpent]:
lfnodes = bpart[lpent][pftype]
rfnodes = bpart[rpent][pftype]
lfpts = np.array([[nodepts[n] for n in fn] for fn in lfnodes])
rfpts = np.array([[nodepts[n] for n in fn] for fn in rfnodes])
lfidx = fuzzysort(lfpts.mean(axis=1).T, xrange(len(lfnodes)))
rfidx = fuzzysort(rfpts.mean(axis=1).T, xrange(len(rfnodes)))
for lfn, rfn in izip(lfnodes[lfidx], rfnodes[rfidx]):
lf = resid.pop(tuple(sorted(lfn)))
rf = resid.pop(tuple(sorted(rfn)))
pfaces[pftype].append([lf, rf])
return pfaces
def _pair_periodic_fluid_faces(self, bpart, resid):
pfaces = defaultdict(list)
nodepts = self._nodepts
for lpent, rpent in self._pfacespents.values():
for pftype in bpart[lpent]:
lfnodes = bpart[lpent][pftype]
rfnodes = bpart[rpent][pftype]
lfpts = np.array([[nodepts[n] for n in fn] for fn in lfnodes])
rfpts = np.array([[nodepts[n] for n in fn] for fn in rfnodes])
lfidx = fuzzysort(lfpts.mean(axis=1).T, range(len(lfnodes)))
rfidx = fuzzysort(rfpts.mean(axis=1).T, range(len(rfnodes)))
for lfn, rfn in zip(lfnodes[lfidx], rfnodes[rfidx]):
lf = resid.pop(tuple(sorted(lfn)))
rf = resid.pop(tuple(sorted(rfn)))
pfaces[pftype].append([lf, rf])
return pfaces
def __init__(self, basiscls, eles, cfg):
self._be = None
self._eles = eles
self._cfg = cfg
self.nspts = nspts = eles.shape[0]
self.neles = neles = eles.shape[1]
self.ndims = ndims = eles.shape[2]
# Subclass checks
assert self._dynvarmap
assert self._nscal_fpts >= 1
assert self._nvect_upts >= 1
assert self._nvect_fpts >= 0
# Check the dimensionality of the problem
if ndims != basiscls.ndims or ndims not in self._dynvarmap:
raise ValueError('Invalid element matrix dimensions')
# Determine the number of dynamical variables
self.nvars = len(self._dynvarmap[ndims])
# Generate a symbol for each dimension (p,q or p,q,r)
dims = sy.symbols('p q r')[:ndims]
# Instantiate the basis class
self._basis = basis = basiscls(dims, nspts, cfg)
# Sizes
self.nupts = basis.nupts
self.nfpts = basis.nfpts
# Transform matrices at the soln points
self._gen_rcpdjac_smat_upts()
# Physical normals at the flux points
self._gen_pnorm_fpts()
# Construct the physical location operator matrix
plocop = np.asanyarray(basis.sbasis_at(basis.fpts), dtype=np.float)
# Apply the operator to the mesh elements and reshape
plocfpts = np.dot(plocop, eles.reshape(nspts, -1))
plocfpts = plocfpts.reshape(self.nfpts, neles, ndims)
plocfpts = plocfpts.transpose(1, 2, 0).tolist()
srtd_face_fpts = [[fuzzysort(pts, ffpts) for pts in plocfpts]
for ffpts in basis.facefpts]
self._srtd_face_fpts = np.array(srtd_face_fpts).swapaxes(0, 1)
def __init__(self, basiscls, eles, cfg):
self._be = None
self.eles = eles
self.cfg = cfg
self.nspts = nspts = eles.shape[0]
self.neles = neles = eles.shape[1]
self.ndims = ndims = eles.shape[2]
# Kernels we provide
self.kernels = {}
# Check the dimensionality of the problem
if ndims != basiscls.ndims or ndims not in self.privarmap:
raise ValueError('Invalid element matrix dimensions')
# Determine the number of dynamical variables
self.nvars = len(self.privarmap[ndims])
# Instantiate the basis class
self.basis = basis = basiscls(nspts, cfg)
# See what kind of projection the basis is using
self.antialias = basis.antialias
# If we need quadrature points or not
haveqpts = 'flux' in self.antialias or 'div-flux' in self.antialias
# Sizes
self.nupts = basis.nupts
self.nqpts = basis.nqpts if haveqpts else None
self.nfpts = basis.nfpts
self.nfacefpts = basis.nfacefpts
# Physical normals at the flux points
self._gen_pnorm_fpts()
# Construct the physical location operator matrix
plocop = basis.sbasis.nodal_basis_at(basis.fpts)
# Apply the operator to the mesh elements and reshape
plocfpts = np.dot(plocop, eles.reshape(nspts, -1))
self.plocfpts = plocfpts.reshape(self.nfpts, neles, ndims)
plocfpts = self.plocfpts.transpose(1, 2, 0).tolist()
self._srtd_face_fpts = [[fuzzysort(pts, ffpts) for pts in plocfpts]
for ffpts in basis.facefpts]
def __init__(self, basiscls, eles, cfg):
self._be = None
self._eles = eles
self._cfg = cfg
self.nspts = nspts = eles.shape[0]
self.neles = neles = eles.shape[1]
self.ndims = ndims = eles.shape[2]
# Kernels we provide
self.kernels = {}
# Check the dimensionality of the problem
if ndims != basiscls.ndims or ndims not in self._dynvarmap:
raise ValueError('Invalid element matrix dimensions')
# Determine the number of dynamical variables
self.nvars = len(self._dynvarmap[ndims])
# Instantiate the basis class
self._basis = basis = basiscls(nspts, cfg)
# See what kind of projection the basis is using
self.antialias = basis.antialias
# If we need quadrature points or not
haveqpts = 'flux' in self.antialias or 'div-flux' in self.antialias
# Sizes
self.nupts = basis.nupts
self.nqpts = basis.nqpts if haveqpts else None
self.nfpts = basis.nfpts
self.nfacefpts = basis.nfacefpts
# Physical normals at the flux points
self._gen_pnorm_fpts()
# Construct the physical location operator matrix
plocop = basis.sbasis.nodal_basis_at(basis.fpts)
# Apply the operator to the mesh elements and reshape
plocfpts = np.dot(plocop, eles.reshape(nspts, -1))
plocfpts = plocfpts.reshape(self.nfpts, neles, ndims)
plocfpts = plocfpts.transpose(1, 2, 0).tolist()
self._srtd_face_fpts = [[fuzzysort(pts, ffpts) for pts in plocfpts]
for ffpts in basis.facefpts]
def _srtd_face_fpts(self):
plocfpts = self.plocfpts.transpose(1, 2, 0)
return [[np.array(fuzzysort(pts.tolist(), ffpts)) for pts in plocfpts]
for ffpts in self.basis.facefpts]
def _srtd_face_fpts(self):
plocfpts = self.plocfpts.transpose(1, 2, 0).tolist()
return [[fuzzysort(pts, ffpts) for pts in plocfpts]
for ffpts in self.basis.facefpts]
def get_connectivity(self):
# For connectivity a first-order representation is sufficient
eles = self._to_first_order(self._elenodes)
# Split into fluid and boundary parts
fpart, bpart = self._split_fluid(eles)
# Extract the faces of the fluid elements
ffaces = self._extract_faces(fpart)
# Pair the fluid-fluid faces
fpairs, resid = self._pair_fluid_faces(ffaces)
# Identify periodic boundary face pairs
# ---- Create periodic boundary tags ---
pbc = {}
for k in self._pfacespents:
pbc['periodic_' + str(k) + '_l'] = bpart[self._pfacespents[k][0]]
pbc['periodic_' + str(k) + '_r'] = bpart[self._pfacespents[k][1]]
pbcfaces = defaultdict(list)
nodepts = self._nodepts
ret = {}
for lpent in pbc:
for pftype in pbc[lpent]:
lfnodes = pbc[lpent][pftype]
lfpts = np.array([[nodepts[n] for n in fn] for fn in lfnodes])
lfidx = fuzzysort(lfpts.mean(axis=1).T, range(len(lfnodes)))
for lfn in lfnodes[lfidx]:
lf = resid[tuple(sorted(lfn))]
pbcfaces[lpent].append(lf)
for k, v in pbcfaces.items():
ret['pcon_{0}_p0'.format(k)] = np.array(v, dtype='S4,i4,i1,i1')
# -------
pfpairs = self._pair_periodic_fluid_faces(bpart, resid)
# Identify the fixed boundary faces
bf = self._ident_boundary_faces(bpart, resid)
if any(resid.values()):
raise ValueError('Unpaired faces in mesh')
# Flattern the face-pair dicts
pairs = chain(chain.from_iterable(fpairs.values()),
chain.from_iterable(pfpairs.values()))
# Generate the internal connectivity array
con = list(pairs)
# Generate boundary condition connectivity arrays
bcon = {}
for pbcrgn, pent in self._bfacespents.items():
bcon[pbcrgn] = bf[pent]
# Output
ret['con_p0'] = np.array(con, dtype='S4,i4,i1,i1').T
for k, v in bcon.items():
ret['bcon_{0}_p0'.format(k)] = np.array(v, dtype='S4,i4,i1,i1')
return ret
