def HighOrderMeshLine(C,
mesh,
Decimals=10,
equally_spaced=False,
check_duplicates=True,
Parallel=False,
nCPU=1):
from Florence.FunctionSpace import Line
from Florence.QuadratureRules import GaussLobattoPoints1D
from Florence.QuadratureRules.EquallySpacedPoints import EquallySpacedPoints
from Florence.MeshGeneration.NodeArrangement import NodeArrangementLine
# ARRANGE NODES FOR LINES HERE (DONE ONLY FOR LINES) - IMPORTANT
node_aranger = NodeArrangementLine(C)
if not equally_spaced:
eps = GaussLobattoPoints1D(C).ravel()
eps = eps[node_aranger]
# COMPUTE BASES FUNCTIONS AT ALL NODAL POINTS
Neval = np.zeros((2, eps.shape[0]), dtype=np.float64)
for i in range(0, eps.shape[0]):
Neval[:, i] = Line.LagrangeGaussLobatto(0, eps[i])[0]
else:
eps = EquallySpacedPoints(2, C).ravel()
eps = eps[node_aranger]
# COMPUTE BASES FUNCTIONS AT ALL NODAL POINTS
Neval = np.zeros((2, eps.shape[0]), dtype=np.float64)
for i in range(0, eps.shape[0]):
Neval[:, i] = Line.Lagrange(0, eps[i])[0]
makezero(Neval)
nodeperelem = mesh.elements.shape[1]
renodeperelem = int(C + 2)
left_over_nodes = renodeperelem - nodeperelem
reelements = -1 * np.ones(
(mesh.elements.shape[0], renodeperelem), dtype=np.int64)
reelements[:, :2] = mesh.elements
iesize = int(C)
repoints = np.zeros(
(mesh.points.shape[0] + iesize * mesh.elements.shape[0],
mesh.points.shape[1]),
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(ElementLoopTri,
np.arange(0, mesh.elements.shape[0]),
mesh.elements,
mesh.points,
'line',
eps,
Neval,
pool=MP.Pool(processes=nCPU))
# LOOP OVER ELEMENTS
maxNode = np.max(reelements)
for elem in range(0, mesh.elements.shape[0]):
# GET HIGHER ORDER COORDINATES
if Parallel:
xycoord_higher = ParallelTuple1[elem]
else:
xycoord_higher = GetInteriorNodesCoordinates(
mesh.points[mesh.elements[elem, :], :], 'line', elem, eps,
Neval)
# EXPAND THE ELEMENT CONNECTIVITY
newElements = np.arange(maxNode + 1, maxNode + 1 + left_over_nodes)
# reelements[elem,3:] = np.arange(maxNode+1,maxNode+1+left_over_nodes)
reelements[elem, 2:] = newElements
maxNode = newElements[-1]
repoints[mesh.points.shape[0] + elem * iesize:mesh.points.shape[0] +
(elem + 1) * iesize] = xycoord_higher[2:, :]
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 = 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)
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[:, 2:],
return_inverse=True)
unique_reelements = unique_reelements[inv_repoints]
reelements = unique_reelements[inv_reelements]
reelements = reelements.reshape(mesh.elements.shape[0], renodeperelem - 2)
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
#------------------------------------------------------------------------------------------
class nmesh(object):
points = repoints
elements = reelements
edges = []
faces = []
nnode = repoints.shape[0]
nelem = reelements.shape[0]
info = 'line'
# MESH CORNERS REMAIN THE SAME FOR ALL POLYNOMIAL DEGREES
if isinstance(mesh.corners, np.ndarray):
nmesh.corners = mesh.corners
return nmesh
def HighOrderMeshQuad(C,
mesh,
Decimals=10,
equally_spaced=False,
check_duplicates=True,
parallelise=False,
nCPU=1,
compute_boundary_info=True):
from Florence.FunctionSpace import Quad, QuadES
from Florence.QuadratureRules import GaussLobattoPointsQuad
from Florence.QuadratureRules.EquallySpacedPoints import EquallySpacedPoints
from Florence.MeshGeneration.NodeArrangement import NodeArrangementQuad
Parallel = parallelise
if not equally_spaced:
eps = GaussLobattoPointsQuad(C)
# COMPUTE BASES FUNCTIONS AT ALL NODAL POINTS
Neval = np.zeros((4, eps.shape[0]), dtype=np.float64)
for i in range(0, eps.shape[0]):
Neval[:, i] = Quad.LagrangeGaussLobatto(0,
eps[i, 0],
eps[i, 1],
arrange=1)[:, 0]
else:
eps = EquallySpacedPoints(3, C)
# COMPUTE BASES FUNCTIONS AT ALL NODAL POINTS
Neval = np.zeros((4, eps.shape[0]), dtype=np.float64)
for i in range(0, eps.shape[0]):
Neval[:, i] = QuadES.Lagrange(0, eps[i, 0], eps[i, 1],
arrange=1)[:, 0]
makezero(Neval)
nodeperelem = mesh.elements.shape[1]
renodeperelem = int((C + 2)**2)
left_over_nodes = renodeperelem - nodeperelem
reelements = -1 * np.ones(
(mesh.elements.shape[0], renodeperelem), dtype=np.int64)
reelements[:, :4] = mesh.elements
iesize = int(4 * C + C**2)
repoints = np.zeros(
(mesh.points.shape[0] + iesize * mesh.elements.shape[0],
mesh.points.shape[1]),
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(ElementLoopTri,
np.arange(0, mesh.elements.shape[0]),
mesh.elements,
mesh.points,
'quad',
eps,
Neval,
pool=MP.Pool(processes=nCPU))
# LOOP OVER ELEMENTS
maxNode = np.max(reelements)
for elem in range(0, mesh.elements.shape[0]):
# GET HIGHER ORDER COORDINATES
if Parallel:
xycoord_higher = ParallelTuple1[elem]
else:
xycoord_higher = GetInteriorNodesCoordinates(
mesh.points[mesh.elements[elem, :], :], 'quad', elem, eps,
Neval)
# EXPAND THE ELEMENT CONNECTIVITY
newElements = np.arange(maxNode + 1, maxNode + 1 + left_over_nodes)
# reelements[elem,3:] = np.arange(maxNode+1,maxNode+1+left_over_nodes)
reelements[elem, 4:] = newElements
maxNode = newElements[-1]
repoints[mesh.points.shape[0] + elem * iesize:mesh.points.shape[0] +
(elem + 1) * iesize] = xycoord_higher[4:, :]
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 = 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)
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
#------------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------------
reedges = np.array([])
if compute_boundary_info:
# BUILD EDGES NOW
tedges = time()
edge_to_elements = mesh.GetElementsWithBoundaryEdgesQuad()
node_arranger = NodeArrangementQuad(C)[0]
reedges = np.zeros((mesh.edges.shape[0], C + 2), dtype=np.int64)
reedges = reelements[edge_to_elements[:, 0][:, None],
node_arranger[edge_to_elements[:, 1], :]]
tedges = time() - tedges
#------------------------------------------------------------------------------------------
class nmesh(object):
points = repoints
elements = reelements
edges = reedges
faces = []
nnode = repoints.shape[0]
nelem = reelements.shape[0]
info = 'quad'
# print('\npMeshing timing:\n\t\tElement loop 1:\t '+str(telements)+' seconds\n\t\tNode loop:\t\t '+str(tnodes)+\
# ' seconds'+'\n\t\tElement loop 2:\t '+str(telements_2)+' seconds\n\t\tEdge loop:\t\t '+str(tedges)+' 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 HighOrderMeshHex(C,
mesh,
Decimals=10,
equally_spaced=False,
check_duplicates=True,
Zerofy=True,
Parallel=False,
nCPU=1,
ComputeAll=True):
from Florence.FunctionSpace import Hex, HexES
from Florence.QuadratureRules import GaussLobattoPointsHex
from Florence.QuadratureRules.EquallySpacedPoints import EquallySpacedPoints
from Florence.MeshGeneration.NodeArrangement import NodeArrangementHex
# SWITCH OFF MULTI-PROCESSING FOR SMALLER PROBLEMS WITHOUT GIVING A MESSAGE
if (mesh.elements.shape[0] < 500) and (C < 5):
Parallel = False
nCPU = 1
if not equally_spaced:
eps = GaussLobattoPointsHex(C)
# COMPUTE BASES FUNCTIONS AT ALL NODAL POINTS
Neval = np.zeros((8, eps.shape[0]), dtype=np.float64)
hpBases = Hex.LagrangeGaussLobatto
for i in range(8, eps.shape[0]):
Neval[:, i] = hpBases(0, eps[i, 0], eps[i, 1], eps[i, 2])[:, 0]
else:
eps = EquallySpacedPoints(4, C)
# COMPUTE BASES FUNCTIONS AT ALL NODAL POINTS
Neval = np.zeros((8, eps.shape[0]), dtype=np.float64)
hpBases = HexES.Lagrange
for i in range(8, eps.shape[0]):
Neval[:, i] = hpBases(0, eps[i, 0], eps[i, 1], eps[i, 2])[:, 0]
# THIS IS NECESSARY FOR REMOVING DUPLICATES
makezero(Neval, tol=1e-12)
nodeperelem = mesh.elements.shape[1]
renodeperelem = int((C + 2)**3)
left_over_nodes = renodeperelem - nodeperelem
reelements = -1 * np.ones(
(mesh.elements.shape[0], renodeperelem), dtype=np.int64)
reelements[:, :8] = mesh.elements
# TOTAL NUMBER OF (INTERIOR+EDGE+FACE) NODES
iesize = renodeperelem - 8
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,
'hex',
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, 'hex', elem, eps, Neval)
# EXPAND THE ELEMENT CONNECTIVITY
newElements = np.arange(maxNode + 1, maxNode + 1 + left_over_nodes)
reelements[elem, 8:] = 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[8:, :]
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 #, flattened_repoints
idx_repoints = np.concatenate(
(np.arange(nnode_linear), idx_repoints + nnode_linear))
repoints = repoints[idx_repoints, :]
unique_reelements, inv_reelements = np.unique(reelements[:, 8:],
return_inverse=True)
unique_reelements = unique_reelements[inv_repoints]
reelements = unique_reelements[inv_reelements]
reelements = reelements.reshape(mesh.elements.shape[0], renodeperelem - 8)
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
#------------------------------------------------------------------------------------------
# USE ALTERNATIVE APPROACH TO GET MESH EDGES AND FACES
reedges = np.zeros((mesh.edges.shape[0], C + 2))
fsize = int((C + 2.) * (C + 3.) / 2.)
refaces = np.zeros((mesh.faces.shape[0], fsize), dtype=mesh.faces.dtype)
if ComputeAll == True:
#------------------------------------------------------------------------------------------
# BUILD FACES NOW
tfaces = time()
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.GetElementsWithBoundaryFacesHex()
node_arranger = NodeArrangementHex(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 = "quad"
tmesh.elements = refaces
tmesh.nelem = tmesh.elements.shape[0]
# GET BOUNDARY EDGES
reedges = tmesh.GetEdgesQuad()
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 = 'hex'
if ComputeAll is True:
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
=======
raise ImportError("PostMesh is not installed. Please install using 'pip install PostMeshPy'")
>>>>>>> upstream/master
from Florence.FunctionSpace import Tri
C = mesh.InferPolynomialDegree() - 1
if formulation.ndim == 2:
# CHOOSE TYPE OF BOUNDARY SPACING
boundary_fekete = np.array([[]])
if self.nodal_spacing_for_cad == 'fekete':
boundary_fekete = GaussLobattoQuadrature(C+2)[0]
else:
boundary_fekete = EquallySpacedPoints(formulation.ndim,C)
# IT IS IMPORTANT TO ENSURE THAT THE DATA IS C-CONITGUOUS
boundary_fekete = boundary_fekete.copy(order="c")
curvilinear_mesh = PostMeshCurve(mesh.element_type,dimension=formulation.ndim)
curvilinear_mesh.SetMeshElements(mesh.elements)
curvilinear_mesh.SetMeshPoints(mesh.points)
curvilinear_mesh.SetMeshEdges(mesh.edges)
curvilinear_mesh.SetMeshFaces(np.zeros((1,4),dtype=np.uint64))
curvilinear_mesh.SetScale(self.scale_value_on_projection)
curvilinear_mesh.SetCondition(self.condition_for_projection)
curvilinear_mesh.SetProjectionPrecision(1.0e-04)
curvilinear_mesh.SetProjectionCriteria(self.projection_flags)
curvilinear_mesh.ScaleMesh()
# curvilinear_mesh.InferInterpolationPolynomialDegree()
curvilinear_mesh.SetNodalSpacing(boundary_fekete)
=======
from Florence.MeshGeneration.NodeArrangement import NodeArrangementLine
# ARRANGE NODES FOR LINES HERE (DONE ONLY FOR LINES) - IMPORTANT
node_aranger = NodeArrangementLine(C)
if not equally_spaced:
eps = GaussLobattoPoints1D(C).ravel()
eps = eps[node_aranger]
>>>>>>> upstream/master
# COMPUTE BASES FUNCTIONS AT ALL NODAL POINTS
Neval = np.zeros((2,eps.shape[0]),dtype=np.float64)
for i in range(0,eps.shape[0]):
Neval[:,i] = Line.LagrangeGaussLobatto(0,eps[i])[0]
else:
eps = EquallySpacedPoints(2,C).ravel()
<<<<<<< HEAD
=======
eps = eps[node_aranger]
>>>>>>> upstream/master
# COMPUTE BASES FUNCTIONS AT ALL NODAL POINTS
Neval = np.zeros((2,eps.shape[0]),dtype=np.float64)
for i in range(0,eps.shape[0]):
Neval[:,i] = Line.Lagrange(0,eps[i])[0]
makezero(Neval)
<<<<<<< HEAD
=======
>>>>>>> upstream/master
nodeperelem = mesh.elements.shape[1]
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