def hpBases(C, xi, eta, zeta, Transform=0, EvalOpt=0, equally_spaced=False):
"""
Transform: transform to from degenrate quad
EvalOpt: evaluate 1 as an approximation 0.9999999
"""
eps = FeketePointsTet(C)
if equally_spaced:
eps = EquallySpacedPointsTet(C)
N = eps.shape[0]
# Make the Vandermonde matrix
V = np.zeros((N, N))
for i in range(0, N):
x = eps[i, :]
p = NormalisedJacobiTet(C, x)
V[i, :] = p
nsize = int((C + 2.) * (C + 3.) * (C + 4.) / 6.)
Bases = np.zeros((nsize, 1))
gBases = np.zeros((nsize, 3))
# GradNormalisedJacobiTet IS ALWAYS CALLED WITH (HEX) R,S,T COORDINATE
if Transform:
# IF A TRANSFORMATION TO HEX COORDINATE IS NEEDED
r, s, t = MapXiEtaZeta2RST(xi, eta, zeta)
p, dp_dxi, dp_deta, dp_dzeta = GradNormalisedJacobiTet(
C, np.array([r, s, t]), EvalOpt)
else:
# IF XI,ETA,ZETA ARE DIRECTLY GIVEN IN HEX FORMAT
p, dp_dxi, dp_deta, dp_dzeta = GradNormalisedJacobiTet(
C, np.array([xi, eta, zeta]), EvalOpt)
# ACTUAL WAY
# Bases = np.linalg.solve(V.T,p)
# gBases[:,0] = np.linalg.solve(V.T,dp_dxi)
# gBases[:,1] = np.linalg.solve(V.T,dp_deta)
# gBases[:,2] = np.linalg.solve(V.T,dp_dzeta)
# SOLVE FOR MULTIPLE RIGHT HAND SIDES
# ps = np.concatenate((p[:,None],dp_dxi[:,None],dp_deta[:,None],dp_dzeta[:,None]),axis=1)
ps = np.concatenate((p, dp_dxi, dp_deta, dp_dzeta)).reshape(4,
p.shape[0]).T
tup = np.linalg.solve(V.T, ps)
Bases = tup[:, 0]
gBases[:, 0] = tup[:, 1]
gBases[:, 1] = tup[:, 2]
gBases[:, 2] = tup[:, 3]
return Bases, gBases
def HighOrderMeshTet_SEMISTABLE(C,
mesh,
Decimals=10,
equally_spaced=False,
check_duplicates=True,
parallelise=False,
nCPU=1,
compute_boundary_info=True):
from Florence.FunctionSpace import Tet
from Florence.QuadratureRules.FeketePointsTet import FeketePointsTet
from Florence.MeshGeneration.NodeArrangement import NodeArrangementTet
# SWITCH OFF MULTI-PROCESSING FOR SMALLER PROBLEMS WITHOUT GIVING A MESSAGE
Parallel = parallelise
if (mesh.elements.shape[0] < 500) and (C < 5):
Parallel = False
nCPU = 1
if not equally_spaced:
eps = FeketePointsTet(C)
# COMPUTE BASES FUNCTIONS AT ALL NODAL POINTS
Neval = np.zeros((4, eps.shape[0]), dtype=np.float64)
hpBases = Tet.hpNodal.hpBases
for i in range(4, eps.shape[0]):
Neval[:, i] = hpBases(0,
eps[i, 0],
eps[i, 1],
eps[i, 2],
Transform=1,
EvalOpt=1)[0]
else:
from Florence.QuadratureRules.EquallySpacedPoints import EquallySpacedPointsTet
eps = EquallySpacedPointsTet(C)
# COMPUTE BASES FUNCTIONS AT ALL NODAL POINTS
hpBases = Tet.hpNodal.hpBases
Neval = np.zeros((4, eps.shape[0]), dtype=np.float64)
for i in range(4, eps.shape[0]):
Neval[:, i] = hpBases(0,
eps[i, 0],
eps[i, 1],
eps[i, 2],
Transform=1,
EvalOpt=1,
equally_spaced=True)[0]
# THIS IS NECESSARY FOR REMOVING DUPLICATES
makezero(Neval, tol=1e-12)
nodeperelem = mesh.elements.shape[1]
renodeperelem = int((C + 2.) * (C + 3.) * (C + 4.) / 6.)
left_over_nodes = renodeperelem - nodeperelem
reelements = -1 * np.ones(
(mesh.elements.shape[0], renodeperelem), dtype=np.int64)
reelements[:, :4] = mesh.elements
# TOTAL NUMBER OF (INTERIOR+EDGE+FACE) NODES
iesize = np.int64(C * (C - 1) * (C - 2) / 6. + 6. * C + 2 * C * (C - 1))
repoints = np.zeros(
(mesh.points.shape[0] + iesize * mesh.elements.shape[0], 3),
dtype=np.float64)
repoints[:mesh.points.shape[0], :] = mesh.points
telements = time()
xycoord_higher = []
ParallelTuple1 = []
if Parallel:
# GET HIGHER ORDER COORDINATES - PARALLEL
ParallelTuple1 = parmap.map(ElementLoopTet,
np.arange(0, mesh.elements.shape[0]),
mesh.elements,
mesh.points,
'tet',
eps,
Neval,
pool=MP.Pool(processes=nCPU))
maxNode = np.max(reelements)
for elem in range(0, mesh.elements.shape[0]):
# maxNode = np.max(reelements) # BIG BOTTLENECK
if Parallel:
xycoord_higher = ParallelTuple1[elem]
else:
xycoord = mesh.points[mesh.elements[elem, :], :]
# GET HIGHER ORDER COORDINATES
xycoord_higher = GetInteriorNodesCoordinates(
xycoord, 'tet', elem, eps, Neval)
# EXPAND THE ELEMENT CONNECTIVITY
newElements = np.arange(maxNode + 1, maxNode + 1 + left_over_nodes)
reelements[elem, 4:] = newElements
# INSTEAD COMPUTE maxNode BY INDEXING
maxNode = newElements[-1]
repoints[mesh.points.shape[0] + elem * iesize:mesh.points.shape[0] +
(elem + 1) * iesize] = xycoord_higher[4:, :]
if Parallel:
del ParallelTuple1
telements = time() - telements
#--------------------------------------------------------------------------------------
# NOW REMOVE DUPLICATED POINTS
tnodes = time()
nnode_linear = mesh.points.shape[0]
# KEEP ZEROFY ON, OTHERWISE YOU GET STRANGE BEHVAIOUR
# rounded_repoints = makezero(repoints[nnode_linear:,:].copy())
rounded_repoints = repoints[nnode_linear:, :].copy()
makezero(rounded_repoints)
rounded_repoints = np.round(rounded_repoints, decimals=Decimals)
_, idx_repoints, inv_repoints = unique2d(rounded_repoints,
order=False,
consider_sort=False,
return_index=True,
return_inverse=True)
# idx_repoints.sort()
del rounded_repoints
idx_repoints = np.concatenate(
(np.arange(nnode_linear), idx_repoints + nnode_linear))
repoints = repoints[idx_repoints, :]
unique_reelements, inv_reelements = np.unique(reelements[:, 4:],
return_inverse=True)
unique_reelements = unique_reelements[inv_repoints]
reelements = unique_reelements[inv_reelements]
reelements = reelements.reshape(mesh.elements.shape[0], renodeperelem - 4)
reelements = np.concatenate((mesh.elements, reelements), axis=1)
# SANITY CHECK fOR DUPLICATES
#---------------------------------------------------------------------#
# NOTE THAT THIS REMAPS THE ELEMENT CONNECTIVITY FOR THE WHOLE MESH
# AND AS A RESULT THE FIRST FEW COLUMNS WOULD NO LONGER CORRESPOND TO
# LINEAR CONNECTIVITY
if check_duplicates:
last_shape = repoints.shape[0]
deci = int(Decimals) - 2
if Decimals < 6:
deci = Decimals
repoints, idx_repoints, inv_repoints = remove_duplicates_2D(
repoints, decimals=deci)
unique_reelements, inv_reelements = np.unique(reelements,
return_inverse=True)
unique_reelements = unique_reelements[inv_repoints]
reelements = unique_reelements[inv_reelements]
reelements = reelements.reshape(mesh.elements.shape[0], renodeperelem)
if last_shape != repoints.shape[0]:
warn(
'Duplicated points generated in high order mesh. Lower the "Decimals". I have fixed it for now'
)
#---------------------------------------------------------------------#
tnodes = time() - tnodes
#------------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------------
if compute_boundary_info:
# BUILD FACES NOW
tfaces = time()
# GET MESH EDGES AND FACES
fsize = int((C + 2.) * (C + 3.) / 2.)
refaces = np.zeros((mesh.faces.shape[0], fsize),
dtype=mesh.faces.dtype)
refaces = np.zeros((mesh.faces.shape[0], fsize))
# DO NOT CHANGE THE FACES, BY RECOMPUTING THEM, AS THE LINEAR FACES CAN COME FROM
# AN EXTERNAL MESH GENERATOR, WHOSE ORDERING MAY NOT BE THE SAME, SO JUST FIND WHICH
# ELEMENTS CONTAIN THESE FACES
face_to_elements = mesh.GetElementsWithBoundaryFacesTet()
node_arranger = NodeArrangementTet(C)[0]
refaces = reelements[face_to_elements[:, 0][:, None],
node_arranger[face_to_elements[:, 1], :]].astype(
mesh.faces.dtype)
tfaces = time() - tfaces
#------------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------------
# BUILD EDGES NOW
tedges = time()
# BUILD A 2D MESH
from Florence import Mesh
tmesh = Mesh()
tmesh.element_type = "tri"
tmesh.elements = refaces
tmesh.nelem = tmesh.elements.shape[0]
# GET BOUNDARY EDGES
reedges = tmesh.GetEdgesTri()
del tmesh
tedges = time() - tedges
#------------------------------------------------------------------------------------------
class nmesh(object):
# """Construct pMesh"""
points = repoints
elements = reelements
edges = np.array([[], []])
faces = np.array([[], []])
nnode = repoints.shape[0]
nelem = reelements.shape[0]
info = 'tet'
if compute_boundary_info:
nmesh.edges = reedges
nmesh.faces = refaces
gc.collect()
# print '\nHigh order meshing timing:\n\t\tElement loop:\t '+str(telements)+' seconds\n\t\tNode loop:\t\t '+str(tnodes)+\
# ' seconds'+'\n\t\tEdge loop:\t\t '+str(tedges)+' seconds'+\
# '\n\t\tFace loop:\t\t '+str(tfaces)+' seconds\n'
return nmesh
def test_quadrature_functionspace():
print("Running tests on QuadratureRule and FunctionSpace modules")
mesh = Mesh()
etypes = ["line", "tri", "quad", "tet", "hex"]
for etype in etypes:
if etype == "line":
mesh.Line()
elif etype == "tri":
mesh.Circle(element_type="tri")
elif etype == "quad":
mesh.Circle(element_type="quad")
elif etype == "tet":
mesh.Cube(element_type="tet", nx=1, ny=1, nz=1)
elif etype == "hex":
mesh.Cube(element_type="hex", nx=1, ny=1, nz=1)
for p in range(2, 7):
mesh.GetHighOrderMesh(p=p, check_duplicates=False)
q = QuadratureRule(mesh_type=etype, norder=p + 2, flatten=False)
FunctionSpace(mesh, q, p=p, equally_spaced=False)
FunctionSpace(mesh, q, p=p, equally_spaced=True)
q = QuadratureRule(mesh_type=etype, norder=p + 2, flatten=True)
FunctionSpace(mesh, q, p=p, equally_spaced=False)
FunctionSpace(mesh, q, p=p, equally_spaced=True)
# now test all Fekete/ES point creation
from Florence.QuadratureRules import FeketePointsTri
from Florence.QuadratureRules.QuadraturePointsWeightsTri import QuadraturePointsWeightsTri
from Florence.QuadratureRules import FeketePointsTet
from Florence.QuadratureRules.QuadraturePointsWeightsTet import QuadraturePointsWeightsTet
from Florence.QuadratureRules import GaussLobattoPoints1D, GaussLobattoPointsQuad, GaussLobattoPointsHex
from Florence.QuadratureRules.QuadraturePointsWeightsTri import QuadraturePointsWeightsTri
from Florence.QuadratureRules.WVQuadraturePointsWeightsQuad import WVQuadraturePointsWeightsQuad
from Florence.QuadratureRules.WVQuadraturePointsWeightsHex import WVQuadraturePointsWeightsHex
from Florence.QuadratureRules.EquallySpacedPoints import EquallySpacedPoints, EquallySpacedPointsTri, EquallySpacedPointsTet
from Florence.MeshGeneration.NodeArrangement import NodeArrangementLine, NodeArrangementTri, NodeArrangementQuad
from Florence.MeshGeneration.NodeArrangement import NodeArrangementTet, NodeArrangementHex, NodeArrangementQuadToTri
from Florence.MeshGeneration.NodeArrangement import NodeArrangementHexToTet, NodeArrangementLayeredToHex
for i in range(21):
FeketePointsTri(i)
QuadraturePointsWeightsTri(i, 3)
QuadraturePointsWeightsTet(i)
EquallySpacedPoints(2, i)
EquallySpacedPoints(3, i)
EquallySpacedPoints(4, i)
EquallySpacedPointsTri(i)
EquallySpacedPointsTet(i)
NodeArrangementLine(i)
NodeArrangementTri(i)
NodeArrangementQuad(i)
NodeArrangementHex(i)
NodeArrangementLayeredToHex(i)
if i < 6:
NodeArrangementQuadToTri(i)
if i < 2:
NodeArrangementHexToTet(i)
if i < 18:
FeketePointsTet(i)
NodeArrangementTet(i)
WVQuadraturePointsWeightsQuad(i)
if i <= 16:
WVQuadraturePointsWeightsHex(i)
print(
"Successfully finished running tests on QuadratureRule and FunctionSpace modules\n"
)
def GetIdealElement(self, elem, fem_solver, function_space,
LagrangeElemCoords):
"""Retrieves ideal element/domain
"""
from Florence.Tensor import makezero
from Florence.FunctionSpace import Tri, Tet, Quad, Hex
from Florence.QuadratureRules.EquallySpacedPoints import EquallySpacedPoints, EquallySpacedPointsTri, EquallySpacedPointsTet
sqrt = np.sqrt
if function_space.element_type == "tri":
nodeperlinearelem = 3
eps = EquallySpacedPointsTri(function_space.degree - 1)
hpBases = Tri.hpNodal.hpBases
Neval = np.zeros((nodeperlinearelem, eps.shape[0]),
dtype=np.float64)
for i in range(0, eps.shape[0]):
Neval[:, i] = hpBases(0,
eps[i, 0],
eps[i, 1],
Transform=1,
EvalOpt=1,
equally_spaced=True)[0]
xycoord = LagrangeElemCoords[:nodeperlinearelem, :]
xycoord = np.array([[-0.5, 0], [0.5, 0], [0., np.sqrt(3.) / 2.]])
# xycoord = eps[:nodeperlinearelem,:]
# xycoord = fem_solver.imesh.points[elem,:]
elif function_space.element_type == "quad":
nodeperlinearelem = 4
eps = EquallySpacedPoints(3, function_space.degree - 1)
hpBases = Quad.LagrangeGaussLobatto
Neval = np.zeros((nodeperlinearelem, eps.shape[0]),
dtype=np.float64)
for i in range(0, eps.shape[0]):
Neval[:, i] = hpBases(0, eps[i, 0], eps[i, 1], arrange=1)[:, 0]
xycoord = LagrangeElemCoords[:nodeperlinearelem, :]
xycoord = np.array([[0., 0], [1., 0], [1., 1.], [0., 1.]])
xycoord = eps[:nodeperlinearelem, :]
elif function_space.element_type == "tet":
nodeperlinearelem = 4
eps = EquallySpacedPointsTet(function_space.degree - 1)
hpBases = Tet.hpNodal.hpBases
Neval = np.zeros((nodeperlinearelem, eps.shape[0]),
dtype=np.float64)
for i in range(0, eps.shape[0]):
Neval[:, i] = hpBases(0,
eps[i, 0],
eps[i, 1],
eps[i, 2],
Transform=1,
EvalOpt=1,
equally_spaced=True)[0]
xycoord = LagrangeElemCoords[:nodeperlinearelem, :]
xycoord = np.array([[sqrt(8. / 9.), 0, -1 / 3.],
[-sqrt(2. / 9.),
sqrt(2. / 3.), -1 / 3.],
[-sqrt(2. / 9.), -sqrt(2. / 3.), -1 / 3.],
[0., 0, 1.]])
elif function_space.element_type == "hex":
nodeperlinearelem = 8
eps = EquallySpacedPoints(4, function_space.degree - 1)
hpBases = Hex.LagrangeGaussLobatto
Neval = np.zeros((nodeperlinearelem, eps.shape[0]),
dtype=np.float64)
for i in range(0, eps.shape[0]):
Neval[:, i] = hpBases(0,
eps[i, 0],
eps[i, 1],
eps[i, 2],
arrange=1)[:, 0]
xycoord = LagrangeElemCoords[:nodeperlinearelem, :]
xycoord = eps[:nodeperlinearelem, :]
makezero(Neval)
xycoord_higher = np.copy(LagrangeElemCoords)
xycoord_higher[:nodeperlinearelem, :] = xycoord
if function_space.degree > 1:
xycoord_higher[nodeperlinearelem:, :] = np.dot(
Neval[:, nodeperlinearelem:].T, xycoord)
LagrangeElemCoords = xycoord_higher
return LagrangeElemCoords