def __init__(self,baseFlags="zen",nbase=0,verbose=0):
"""
initialize the triangulation object,
keep track of what numbering scheme it uses,
create a base set of flags for triangulate (e.g., z if using base 0)
does not create a Voronoi diagram by default
"""
self.trirep = []
self.trirep.append(triangleWrappers.new())
self.trirepDefaultInit = []
self.trirepDefaultInit.append(True)
self.vorrep = []
self.vorrep.append(triangleWrappers.new()) #don't create a Voronoi diagram by default
self.makeVoronoi = False
self.vorrepDefaultInit = []
self.vorrepDefaultInit.append(True)
assert(nbase in [0,1])
self.nbase = nbase
self.baseFlags = baseFlags
if self.nbase == 0 and self.baseFlags.find('z') == -1:
print """WARNING TriangleMesh base numbering= %d
reqires z in baseFlags = %s, adding """ % (self.nbase,self.baseFlags)
self.baseFlags += "z"
#end if
if self.baseFlags.find('v') >= 0:
self.makeVoronoi = True
if verbose > 0:
logEvent("""TriangleBaseMesh nbase=%d baseFlags= %s """ % (self.nbase,
self.baseFlags))
#end if
#keep track of last set of flags used to generate rep
self.lastFlags = None
#to make printing out info easier
self.infoFormat = """triangulation:
def resetDefaultTrirep(self,index=0,verbose=0):
"""
reset the Triangle mesh representation if it has been set to something nontrivial
"""
assert(index in range(0,len(self.trirep)))
#delete the existing representation if it has been initialized
if not self.trirepDefaultInit[index]:
if verbose > -1:
logEvent('TriangleIface deleting current trirep[',index,']')
#end verbose
del self.trirep[index]
#get a new represenation
if index == 0:
self.trirep.append(triangleWrappers.new())
else:
self.trirep[index] = triangleWrappers.new()
self.trirepDefaultInit[index] = True
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 resetDefaultVorrep(self,index=0,verbose=0):
"""
reset the Triangle mesh Voronoi representation if it has
been set to something nontrivial
"""
assert(index in range(0,len(self.vorrep)))
#delete the existing representation if it has been initialized
if not self.vorrepDefaultInit[index]:
if verbose > -1:
print 'TriangleIface deleting current vorrep[',index,']'
#end verbose
del self.vorrep[index]
#get a new represenation
self.vorrep[index] = triangleWrappers.new()
self.vorrepDefaultInit[index] = True
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
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 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:
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:
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
