def testGenerateTriangulationFromPointSet(points):
"""
input: point-set
generate triangle representation of the points
output: an array contaning the points, and element to Node connectivity
"""
#mwf debug
#import pdb
#pdb.set_trace()
#default representation for holding input points
tri0 = triangleWrappers.new()
triangleWrappers.setPoints(tri0, points[:, :2])
flags = "qz" #just use simple quality mesh generation, number from zero
#default representation for holding output points
tri1 = triangleWrappers.new()
triangleWrappers.applyTriangulateNoVoronoi(flags, tri0, tri1)
#if returning nodeArray and elementNodesArray outside of routine
#use getPointsCopy, getTrianglesCopy
#otherwise if doing all the necessary generation of quadrature points
#and weights internally don't need deep copy
nodeArray2d = triangleWrappers.getPointsCopy(tri1)
elementNodesArray = triangleWrappers.getTrianglesCopy(tri1)
#clean up
del tri0
del tri1
return nodeArray2d, elementNodesArray
def convertFromProteusMesh(self, meshin, verbose=0):
"""
generate a Triangle mesh representation from an proteus mesh.
This version will copy over the nodes and elements from the
proteus mesh.
Deletes the existing Triangle mesh and regenerates.
"""
#first check that the input mesh has the correct dimensions and
#minimal information necessary
spaceDim = 2
assert (meshin.nElementBoundaries_element == spaceDim + 1)
assert (meshin.nodeArray is not None)
assert (meshin.elementNodesArray is not None)
#get a clean slate
tri0 = triangleWrappers.new()
#don't set any markers for now
#input array should be nNodes by spacedim
nodesIn = meshin.nodeArray[:, :spaceDim]
triangleWrappers.setPoints(tri0, nodesIn)
#triangle array should be nElements x 3
triAin = meshin.elementNodesArray[:, :spaceDim + 1]
triangleWrappers.setTriangles(tri0, triAin)
flagsAdd = "r" #use element and node connections
flags = flagsAdd + self.baseFlags
if flags.find('v') >= 0:
self.makeVoronoi = True
if verbose > 0:
logEvent('readNodeAndEle makeVoronoi= ', self.makeVoronoi,
' flags= ', flags)
#end if
self.lastFlags = flags
#reset data representations if necessary
self.resetDefaultTrirep(index=0, verbose=verbose)
if self.makeVoronoi:
self.resetDefaultVorrep(index=0, verbose=verbose)
#end vorrep initialized
if self.makeVoronoi:
triangleWrappers.applyTriangulate(flags, tri0, self.trirep[0],
self.vorrep[0])
#handles no longer contain trivial representations
self.trirepDefaultInit[0] = False
self.vorrepDefaultInit[0] = False
else:
triangleWrappers.applyTriangulateNoVoronoi(flags, tri0,
self.trirep[0])
#handle no longer contains trivial representations
self.trirepDefaultInit[0] = False
#end if
#clean up explicitly
del tri0
def convertFromProteusMesh(self,meshin,verbose=0):
"""
generate a Triangle mesh representation from an proteus mesh.
This version will copy over the nodes and elements from the
proteus mesh.
Deletes the existing Triangle mesh and regenerates.
"""
#first check that the input mesh has the correct dimensions and
#minimal information necessary
spaceDim = 2
assert(meshin.nElementBoundaries_element == spaceDim+1)
assert(meshin.nodeArray is not None)
assert(meshin.elementNodesArray is not None)
#get a clean slate
tri0 = triangleWrappers.new()
#don't set any markers for now
#input array should be nNodes by spacedim
nodesIn = meshin.nodeArray[:,:spaceDim]
triangleWrappers.setPoints(tri0,nodesIn)
#triangle array should be nElements x 3
triAin = meshin.elementNodesArray[:,:spaceDim+1]
triangleWrappers.setTriangles(tri0,triAin)
flagsAdd = "r" #use element and node connections
flags = flagsAdd+self.baseFlags
if flags.find('v') >= 0:
self.makeVoronoi = True
if verbose > 0:
logEvent('readNodeAndEle makeVoronoi= ',self.makeVoronoi,' flags= ',flags)
#end if
self.lastFlags = flags
#reset data representations if necessary
self.resetDefaultTrirep(index=0,verbose=verbose)
if self.makeVoronoi:
self.resetDefaultVorrep(index=0,verbose=verbose)
#end vorrep initialized
if self.makeVoronoi:
triangleWrappers.applyTriangulate(flags,tri0,self.trirep[0],self.vorrep[0])
#handles no longer contain trivial representations
self.trirepDefaultInit[0] = False
self.vorrepDefaultInit[0] = False
else:
triangleWrappers.applyTriangulateNoVoronoi(flags,tri0,self.trirep[0])
#handle no longer contains trivial representations
self.trirepDefaultInit[0] = False
#end if
#clean up explicitly
del tri0
def testGenerateTriangulationFromPointSet(points):
"""
input: point-set
generate triangle representation of the points
output: an array contaning the points, and element to Node connectivity
"""
#mwf debug
#import pdb
#pdb.set_trace()
#default representation for holding input points
tri0 = triangleWrappers.new()
triangleWrappers.setPoints(tri0,points[:,:2])
flags = "qz" #just use simple quality mesh generation, number from zero
#default representation for holding output points
tri1 = triangleWrappers.new()
triangleWrappers.applyTriangulateNoVoronoi(flags,tri0,tri1)
#if returning nodeArray and elementNodesArray outside of routine
#use getPointsCopy, getTrianglesCopy
#otherwise if doing all the necessary generation of quadrature points
#and weights internally don't need deep copy
nodeArray2d = triangleWrappers.getPointsCopy(tri1)
elementNodesArray = triangleWrappers.getTrianglesCopy(tri1)
#clean up
del tri0
del tri1
return nodeArray2d,elementNodesArray
def readFromPolyFile(self, filebase, flagsAdd="", verbose=0):
"""
read triangle representation from filebase.poly file
assumes the nbase data member is set appropriately
"""
reader = TriangleUtils.TriangleInputFileReader()
if verbose > 0:
print 'readFromPolyFile filebase= ', filebase
#end if
polyDataInfo, polyData = reader.readPoly(filebase,
nbase=self.nbase,
verbose=verbose)
if verbose > 3:
for type in ['node', 'segment', 'hole', 'region']:
print 'Poly: ', type, 'Info= \n', polyDataInfo[type], '\n'
#end for
#end if
nodes, nodesA, nodesM = (polyData['node']['nodes'],
polyData['node']['nodeAttributes'],
polyData['node']['nodeMarkers'])
segments, segmentsM = (polyData['segment']['segments'],
polyData['segment']['segmentMarkers'])
holes = polyData['hole']['holes']
regions = polyData['region']['regions']
if verbose > 3:
print """Poly file read:
nodes = \n%s\n nodeAttributes= \n%s\n nodeMarkers= \n%s\n
segments= \n%s\n segmentMarkers= \n%s\n
holes = \n%s\n
regions = \n%s\n
""" % (nodes, nodesA, nodesM, segments, segmentsM, holes, regions)
#end if
tri0 = triangleWrappers.new()
if nodesM == None:
triangleWrappers.setPoints(tri0, nodes)
else:
nodesMtmp = numpy.zeros(nodesM.shape, 'i')
nodesMtmp[:] = nodesM
nodesM = nodesMtmp
triangleWrappers.setPointsAndMarkers(tri0, nodes, nodesM)
if not nodesA == None:
triangleWrappers.setPointAttributes(tri0, nodesA)
#end if
if segmentsM == None:
triangleWrappers.setSegments(tri0, segments)
else:
triangleWrappers.setSegmentsAndMarkers(tri0, segments, segmentsM)
#end if
if (not holes == None):
triangleWrappers.setHoles(tri0, holes)
#end if
if (not regions == None):
#print 'setting trin1 regions=\n',regions2
triangleWrappers.setRegions(tri0, regions)
#end if
flags = flagsAdd + self.baseFlags
if flags.find('p') == -1:
print 'flags = ', flags, ' must have p, appending'
flags += "p"
#end
if flags.find('v') >= 0:
self.makeVoronoi = True
if verbose > 0:
print 'readNodeAndEle makeVoronoi= ', self.makeVoronoi, ' flags= ', flags
#end if
self.lastFlags = flags
#reset data representations if necessary
self.resetDefaultTrirep(index=0, verbose=verbose)
if self.makeVoronoi:
self.resetDefaultVorrep(index=0, verbose=verbose)
#end vorrep initialized
if self.makeVoronoi:
triangleWrappers.applyTriangulate(flags, tri0, self.trirep[0],
self.vorrep[0])
#handles no longer contain trivial representations
self.trirepDefaultInit[0] = False
self.vorrepDefaultInit[0] = False
else:
triangleWrappers.applyTriangulateNoVoronoi(flags, tri0,
self.trirep[0])
#handle no longer contains trivial representations
self.trirepDefaultInit[0] = False
#end if
#clean up?
del tri0
def readFromNodeAndEleFiles(self, filebase, flagsAdd="", verbose=0):
"""
read triangle representation from filebase.node and filebase.ele
files. assumes the nbase data member is set appropriately
"""
reader = TriangleUtils.TriangleInputFileReader()
if verbose > 0:
print 'readFromNodeAndEleFiles filebase= ', filebase
#end if
nodeDataInfo, nodeData = reader.readNodes(filebase, nbase=self.nbase)
nodes, nodesA, nodesM = (nodeData['nodes'], nodeData['nodeAttributes'],
nodeData['nodeMarkers'])
if verbose > 3:
print 'Nodes: nodeInfo= ', nodeDataInfo
print """Nodes: nodes= \n%s\n nodeAttributes= \n%s\n nodeMarkers= \n%s
""" % (nodes, nodesA, nodesM)
#end if
triDataInfo, triData = reader.readTriangles(filebase, nbase=self.nbase)
triangles, trianglesA = triData['triangles'], triData[
'triangleAttributes']
if verbose > 3:
print 'Triangles: triInfo= ', triDataInfo
print """Triangles: elems= \n%s\n triAttributes= \n%s
""" % (triangles, trianglesA)
#end if
#now create an initial representation
tri0 = triangleWrappers.new()
if nodesM == None:
triangleWrappers.setPoints(tri0, nodes)
else:
triangleWrappers.setPointsAndMarkers(tri0, nodes, nodesM)
if not nodesA == None:
triangleWrappers.setPointAttributes(tri0, nodesA)
#end if
triangleWrappers.setTriangles(tri0, triangles)
if not trianglesA == None:
triangleWrappers.setTriangleAttributes(tri0, trianglesA)
#run triangulate on it using the base flags and whatever else was
#added
flags = flagsAdd + self.baseFlags
if flags.find('v') >= 0:
self.makeVoronoi = True
if verbose > 0:
print 'readNodeAndEle makeVoronoi= ', self.makeVoronoi, ' flags= ', flags
#end if
self.lastFlags = flags
#reset data representations if necessary
self.resetDefaultTrirep(index=0, verbose=verbose)
if self.makeVoronoi:
self.resetDefaultVorrep(index=0, verbose=verbose)
#end vorrep initialized
if self.makeVoronoi:
triangleWrappers.applyTriangulate(flags, tri0, self.trirep[0],
self.vorrep[0])
#handles no longer contain trivial representations
self.trirepDefaultInit[0] = False
self.vorrepDefaultInit[0] = False
else:
triangleWrappers.applyTriangulateNoVoronoi(flags, tri0,
self.trirep[0])
#handle no longer contains trivial representations
self.trirepDefaultInit[0] = False
#end if
#do I need to clean up explicitly?
del tri0
def testGenerateSSIPtriangulation(points):
"""
input: vertices and SSIP points belonging to a single element
generate triangle representation of the points
output: an array contaning the points, and element quadrature weights for the points
test with input
import numpy
from proteus import TriangleTools
points = numpy.array([[0.0,0.0,0.0],[0.5,0.4,0.],[1.0,0.0,0.0],[0.2,0.3,0.0],[0.0,1.0,0.0]])
dV,x = TriangleTools.testGenerateSSIPtriangulation(points)
"""
#mwf debug
#import pdb
#pdb.set_trace()
#default representation for holding input points
tri0 = triangleWrappers.new()
triangleWrappers.setPoints(tri0, points[:, :2])
flags = "z" #"qz" #just use simple quality mesh generation, number from zero
#default representation for holding output points
tri1 = triangleWrappers.new()
triangleWrappers.applyTriangulateNoVoronoi(flags, tri0, tri1)
#doing all the necessary generation of quadrature points
#and weights internally don't need deep copy
nodeArray2d = triangleWrappers.getPoints(tri1)
elementNodesArray = triangleWrappers.getTriangles(tri1)
import Quadrature, cfemIntegrals
#try Gauss quadrature different orders
#subElementQuadrature = Quadrature.GaussTriangle()
#subElementQuadrature.setOrder(2) #order(1)
#What about vertex quadrature
subElementQuadrature = Quadrature.LobattoTriangle()
subElementQuadrature.setOrder(3)
nSubQuadraturePoints = len(subElementQuadrature.weights)
nElements = elementNodesArray.shape[0]
nQuadraturePoints = nElements * nSubQuadraturePoints
nSpace = 2
nDOF_element = 3
weights_ref = numpy.array(subElementQuadrature.weights)
points_ref = numpy.array(subElementQuadrature.points)
#loop through elements, compute area, map reference points to physical space,
#and compute physical space weights
#to be consistent need to have nodes be 3d
nodeArray = numpy.zeros((nodeArray2d.shape[0], 3), 'd')
nodeArray[:, 0:2] = nodeArray2d
#need to store psi and grad_psi to avoid recalculating across a lot of elements?
#shape functions are 1-x-y, x, y
psi = numpy.zeros((nSubQuadraturePoints, nDOF_element), 'd')
psi[:, 0] = 1.0 - points_ref[:, 0] - points_ref[:, 1]
psi[:, 1] = points_ref[:, 0]
psi[:, 2] = points_ref[:, 1]
#for k in range(nSubQuadraturePoints):
# psi[k,0] = 1.0-subElementQuadrature.points[k][0]-subElementQuadrature.points[k][1]
# psi[k,1] = subElementQuadrature.points[k][0]
# psi[k,2] = subElementQuadrature.points[k][1]
grad_psi = numpy.zeros((nSubQuadraturePoints, nDOF_element, nSpace), 'd')
#shape functions are 1-x-y, x, y
grad_psi[:, 0, 0].fill(-1.)
grad_psi[:, 0, 1].fill(-1.)
grad_psi[:, 1, 0].fill(1.0)
grad_psi[:, 2, 1].fill(1.0)
#waste space to reuse code
jacobianArray = numpy.zeros(
(nElements, nSubQuadraturePoints, nSpace, nSpace), 'd')
jacobianDetArray = numpy.zeros((nElements, nSubQuadraturePoints), 'd')
jacobianInvArray = numpy.zeros(
(nElements, nSubQuadraturePoints, nSpace, nSpace), 'd')
cfemIntegrals.parametricMaps_getJacobianValues(grad_psi, elementNodesArray,
nodeArray, jacobianArray,
jacobianDetArray,
jacobianInvArray)
jacobianDetArrayAbs = numpy.absolute(jacobianDetArray)
#weights and points shaped like nSubElements x nQuadraturePointsSubElement
q_sub_dV = numpy.zeros((nElements, nSubQuadraturePoints), 'd')
q_sub_x = numpy.zeros((nElements, nSubQuadraturePoints, 3), 'd')
cfemIntegrals.calculateIntegrationWeights(jacobianDetArrayAbs, weights_ref,
q_sub_dV)
cfemIntegrals.parametricMaps_getValues(psi, elementNodesArray, nodeArray,
q_sub_x)
#clean up
del tri0
del tri1
#exit
return q_sub_dV, q_sub_x
def readFromPolyFile(self,filebase,flagsAdd="",verbose=0):
"""Reads in the triangle representation from filebase.poly file.
Parameters
----------
filebase : str
The filename with the triangluation.
flagsAdd : str
verbose : int
A flag indicating how much information to pipe to stdout.
Notes
-----
Function assumes the nbase data member is set appropriately.
"""
reader = TriangleUtils.TriangleInputFileReader()
if verbose > 0:
logEvent('readFromPolyFile filebase= ',filebase)
#end if
polyDataInfo,polyData = reader.readPoly(filebase,nbase=self.nbase,
verbose=verbose)
if verbose > 3:
for type in ['node','segment','hole','region']:
logEvent('Poly: ',type,'Info= \n',polyDataInfo[type],'\n')
#end for
#end if
nodes,nodesA,nodesM = (polyData['node']['nodes'],
polyData['node']['nodeAttributes'],
polyData['node']['nodeMarkers'])
segments,segmentsM = (polyData['segment']['segments'],
polyData['segment']['segmentMarkers'])
holes = polyData['hole']['holes']
regions = polyData['region']['regions']
if verbose > 3:
logEvent("""Poly file read:
nodes = \n%s\n nodeAttributes= \n%s\n nodeMarkers= \n%s\n
segments= \n%s\n segmentMarkers= \n%s\n
holes = \n%s\n
regions = \n%s\n
""" % (nodes,nodesA,nodesM,segments,segmentsM,holes,regions))
#end if
tri0 = triangleWrappers.new()
if nodesM is None:
triangleWrappers.setPoints(tri0,nodes)
else:
nodesMtmp = numpy.zeros(nodesM.shape,'i')
nodesMtmp[:] = nodesM
nodesM = nodesMtmp
triangleWrappers.setPointsAndMarkers(tri0,nodes,nodesM)
if nodesA is not None:
triangleWrappers.setPointAttributes(tri0,nodesA)
#end if
if segmentsM is None:
triangleWrappers.setSegments(tri0,segments)
else:
triangleWrappers.setSegmentsAndMarkers(tri0,segments,segmentsM)
#end if
if (holes is not None):
triangleWrappers.setHoles(tri0,holes)
#end if
if (regions is not None):
#print 'setting trin1 regions=\n',regions2
triangleWrappers.setRegions(tri0,regions)
#end if
flags = flagsAdd+self.baseFlags
if flags.find('p') == -1:
logEvent('flags = ',flags,' must have p, appending')
flags += "p"
#end
if flags.find('v') >= 0:
self.makeVoronoi = True
if verbose > 0:
logEvent('readNodeAndEle makeVoronoi= ',self.makeVoronoi,' flags= ',flags)
#end if
self.lastFlags = flags
#reset data representations if necessary
self.resetDefaultTrirep(index=0,verbose=verbose)
if self.makeVoronoi:
self.resetDefaultVorrep(index=0,verbose=verbose)
#end vorrep initialized
if self.makeVoronoi:
triangleWrappers.applyTriangulate(flags,tri0,self.trirep[0],self.vorrep[0])
#handles no longer contain trivial representations
self.trirepDefaultInit[0] = False
self.vorrepDefaultInit[0] = False
else:
triangleWrappers.applyTriangulateNoVoronoi(flags,tri0,self.trirep[0])
#handle no longer contains trivial representations
self.trirepDefaultInit[0] = False
#end if
#clean up?
del tri0
def readFromNodeAndEleFiles(self,filebase,flagsAdd="",verbose=0):
"""
read triangle representation from filebase.node and filebase.ele
files. assumes the nbase data member is set appropriately
"""
reader = TriangleUtils.TriangleInputFileReader()
if verbose > 0:
logEvent('readFromNodeAndEleFiles filebase= ',filebase)
#end if
nodeDataInfo,nodeData = reader.readNodes(filebase,nbase=self.nbase)
nodes,nodesA,nodesM = (nodeData['nodes'],
nodeData['nodeAttributes'],
nodeData['nodeMarkers'])
if verbose > 3:
logEvent('Nodes: nodeInfo= ',nodeDataInfo)
logEvent("""Nodes: nodes= \n%s\n nodeAttributes= \n%s\n nodeMarkers= \n%s
""" % (nodes,nodesA,nodesM))
#end if
triDataInfo,triData = reader.readTriangles(filebase,nbase=self.nbase)
triangles,trianglesA = triData['triangles'],triData['triangleAttributes']
if verbose > 3:
logEvent('Triangles: triInfo= ',triDataInfo)
logEvent("""Triangles: elems= \n%s\n triAttributes= \n%s
""" % (triangles,trianglesA))
#end if
#now create an initial representation
tri0 = triangleWrappers.new()
if nodesM is None:
triangleWrappers.setPoints(tri0,nodes)
else:
triangleWrappers.setPointsAndMarkers(tri0,nodes,nodesM)
if nodesA is not None:
triangleWrappers.setPointAttributes(tri0,nodesA)
#end if
triangleWrappers.setTriangles(tri0,triangles)
if trianglesA is not None:
triangleWrappers.setTriangleAttributes(tri0,trianglesA)
#run triangulate on it using the base flags and whatever else was
#added
flags = flagsAdd+self.baseFlags
if flags.find('v') >= 0:
self.makeVoronoi = True
if verbose > 0:
logEvent('readNodeAndEle makeVoronoi= ',self.makeVoronoi,' flags= ',flags)
#end if
self.lastFlags = flags
#reset data representations if necessary
self.resetDefaultTrirep(index=0,verbose=verbose)
if self.makeVoronoi:
self.resetDefaultVorrep(index=0,verbose=verbose)
#end vorrep initialized
if self.makeVoronoi:
triangleWrappers.applyTriangulate(flags,tri0,self.trirep[0],self.vorrep[0])
#handles no longer contain trivial representations
self.trirepDefaultInit[0] = False
self.vorrepDefaultInit[0] = False
else:
triangleWrappers.applyTriangulateNoVoronoi(flags,tri0,self.trirep[0])
#handle no longer contains trivial representations
self.trirepDefaultInit[0] = False
#end if
#do I need to clean up explicitly?
del tri0
def testGenerateSSIPtriangulation(points):
"""
input: vertices and SSIP points belonging to a single element
generate triangle representation of the points
output: an array contaning the points, and element quadrature weights for the points
test with input
import numpy
from proteus import TriangleTools
points = numpy.array([[0.0,0.0,0.0],[0.5,0.4,0.],[1.0,0.0,0.0],[0.2,0.3,0.0],[0.0,1.0,0.0]])
dV,x = TriangleTools.testGenerateSSIPtriangulation(points)
"""
#mwf debug
#import pdb
#pdb.set_trace()
#default representation for holding input points
tri0 = triangleWrappers.new()
triangleWrappers.setPoints(tri0,points[:,:2])
flags = "z"#"qz" #just use simple quality mesh generation, number from zero
#default representation for holding output points
tri1 = triangleWrappers.new()
triangleWrappers.applyTriangulateNoVoronoi(flags,tri0,tri1)
#doing all the necessary generation of quadrature points
#and weights internally don't need deep copy
nodeArray2d = triangleWrappers.getPoints(tri1)
elementNodesArray = triangleWrappers.getTriangles(tri1)
import Quadrature,cfemIntegrals
#try Gauss quadrature different orders
#subElementQuadrature = Quadrature.GaussTriangle()
#subElementQuadrature.setOrder(2) #order(1)
#What about vertex quadrature
subElementQuadrature = Quadrature.LobattoTriangle()
subElementQuadrature.setOrder(3)
nSubQuadraturePoints = len(subElementQuadrature.weights)
nElements = elementNodesArray.shape[0]
nQuadraturePoints = nElements*nSubQuadraturePoints
nSpace = 2
nDOF_element = 3
weights_ref = numpy.array(subElementQuadrature.weights)
points_ref = numpy.array(subElementQuadrature.points)
#loop through elements, compute area, map reference points to physical space,
#and compute physical space weights
#to be consistent need to have nodes be 3d
nodeArray = numpy.zeros((nodeArray2d.shape[0],3),'d')
nodeArray[:,0:2] = nodeArray2d
#need to store psi and grad_psi to avoid recalculating across a lot of elements?
#shape functions are 1-x-y, x, y
psi = numpy.zeros((nSubQuadraturePoints,nDOF_element),'d')
psi[:,0] = 1.0-points_ref[:,0]-points_ref[:,1]
psi[:,1] = points_ref[:,0]
psi[:,2] = points_ref[:,1]
#for k in range(nSubQuadraturePoints):
# psi[k,0] = 1.0-subElementQuadrature.points[k][0]-subElementQuadrature.points[k][1]
# psi[k,1] = subElementQuadrature.points[k][0]
# psi[k,2] = subElementQuadrature.points[k][1]
grad_psi = numpy.zeros((nSubQuadraturePoints,nDOF_element,nSpace),'d')
#shape functions are 1-x-y, x, y
grad_psi[:,0,0].fill(-1.); grad_psi[:,0,1].fill(-1.)
grad_psi[:,1,0].fill(1.0);
grad_psi[:,2,1].fill(1.0)
#waste space to reuse code
jacobianArray = numpy.zeros((nElements,nSubQuadraturePoints,nSpace,nSpace),'d')
jacobianDetArray = numpy.zeros((nElements,nSubQuadraturePoints),'d')
jacobianInvArray = numpy.zeros((nElements,nSubQuadraturePoints,nSpace,nSpace),'d')
cfemIntegrals.parametricMaps_getJacobianValues(grad_psi,
elementNodesArray,
nodeArray,
jacobianArray,
jacobianDetArray,
jacobianInvArray)
jacobianDetArrayAbs = numpy.absolute(jacobianDetArray)
#weights and points shaped like nSubElements x nQuadraturePointsSubElement
q_sub_dV = numpy.zeros((nElements,nSubQuadraturePoints),'d')
q_sub_x = numpy.zeros((nElements,nSubQuadraturePoints,3),'d')
cfemIntegrals.calculateIntegrationWeights(jacobianDetArrayAbs,
weights_ref,
q_sub_dV)
cfemIntegrals.parametricMaps_getValues(psi,
elementNodesArray,
nodeArray,
q_sub_x)
#clean up
del tri0
del tri1
#exit
return q_sub_dV,q_sub_x
