Beispiel #1
0
def writeOutTriangulation(tri, filebase="mesh", nbase=0, verbose=0):
    """
    collect necessary steps to write out files for triangle data structures

    """
    failed = False
    if tri == None:
        failed = True
        return failed
    if not nbase in [0, 1]:
        print 'must have vertex base numbering = 0 or 1, got nbase= ', nbase
        failed = True
        return failed
    #end

    nodes = triangleWrappers.getPoints(tri)
    patts = triangleWrappers.getPointAttributes(tri)
    pmarks = triangleWrappers.getPointMarkers(tri)
    if verbose > 0:
        print 'writing node file'
    printNodeFile(nodes, filebase, patts, pmarks, nbase=nbase)

    elems = triangleWrappers.getTriangles(tri)
    eatts = triangleWrappers.getTriangleAttributes(tri)
    if verbose > 0:
        print 'writing elements file'
    printElemFile(elems, filebase, eatts, nbase=nbase)

    segms = triangleWrappers.getSegments(tri)
    segmmks = triangleWrappers.getSegmentMarkers(tri)
    holes = triangleWrappers.getHoles(tri)
    regions = triangleWrappers.getRegions(tri)
    if verbose > 0:
        print 'writing poly file'
    printPolyFile(nodes,
                  segms,
                  filebase,
                  patts,
                  pmarks,
                  segmmks,
                  holes,
                  regions,
                  nbase=nbase)

    edges = triangleWrappers.getEdges(tri)
    edgemks = triangleWrappers.getEdgeMarkers(tri)
    if verbose > 0:
        print 'writing edges file'
    printEdgeFile(edges, filebase, edgemks, nbase=nbase)

    neigs = triangleWrappers.getNeighbors(tri)
    if verbose > 0:
        print 'writing neighbors file'
    printNeighborFile(neigs, filebase, nbase=nbase)

    return failed
Beispiel #2
0
def writeOutTriangulation(tri,filebase="mesh",nbase=0,verbose=0):
    """
    collect necessary steps to write out files for triangle data structures

    """
    failed = False
    if tri is None:
        failed = True
        return failed
    if not nbase in [0,1]:
        print 'must have vertex base numbering = 0 or 1, got nbase= ',nbase
        failed = True
        return failed
    #end

    nodes = triangleWrappers.getPoints(tri)
    patts = triangleWrappers.getPointAttributes(tri)
    pmarks= triangleWrappers.getPointMarkers(tri)
    if verbose > 0:
        print 'writing node file'
    printNodeFile(nodes,filebase,patts,pmarks,nbase=nbase)

    elems = triangleWrappers.getTriangles(tri)
    eatts = triangleWrappers.getTriangleAttributes(tri)
    if verbose > 0:
        print 'writing elements file'
    printElemFile(elems,filebase,eatts,nbase=nbase)

    segms  = triangleWrappers.getSegments(tri)
    segmmks= triangleWrappers.getSegmentMarkers(tri)
    holes  = triangleWrappers.getHoles(tri)
    regions= triangleWrappers.getRegions(tri)
    if verbose > 0:
        print 'writing poly file'
    printPolyFile(nodes,segms,filebase,patts,pmarks,
                  segmmks,holes,regions,nbase=nbase)

    edges  = triangleWrappers.getEdges(tri)
    edgemks= triangleWrappers.getEdgeMarkers(tri)
    if verbose > 0:
        print 'writing edges file'
    printEdgeFile(edges,filebase,edgemks,nbase=nbase)

    neigs  = triangleWrappers.getNeighbors(tri)
    if verbose > 0:
        print 'writing neighbors file'
    printNeighborFile(neigs,filebase,nbase=nbase)

    return failed
Beispiel #3
0
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
Beispiel #4
0
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