oomph-convert Namespace Reference

Classes
class	TecplotParsingError
class	TecplotNode
class	TecplotZone
class	VtkXml
class	InputPoints
class	VtpXml

Functions
def	usage ()
def	main (argv)
def	ok_to_write_ofile (flag, in_file_name, out_file_name)
def	addTrailingZeros (filename, osuffix)
def	tecplot_to_vtkxml (inputFilename, outputFilename)
def	error (message)
def	tecplot_to_vtpxml (inputFilename, outputFilename, dim)

Function Documentation

addTrailingZeros()

def oomph-convert.addTrailingZeros	(		filename,
			osuffix
	)

def addTrailingZeros(filename,osuffix):
 
    # -- Rename file by adding trailing zeros
 
    # 1) Define the number of digits in file name (up to limit_digits)
 
    # Assumption:
    # - the last four characters in ofilename define the extension of filename(".vtu" or ".vtp")
 
    limit_digits = 11
    extension_len = 4
    digits = 0
    for i in range(1, limit_digits+1):
        try:
            dummy = int(filename[-extension_len-i:-extension_len])
            digits = i
        except:
            pass
 
    # 2) Rename the file
    # - digits in filename: filename[-extension_len-digits:-extension_len]
    # - extension in filename: filename[-extension_len:]
    # - base file name in filename: filename[:lenBaseName]
 
    # Note: only filenames with 4 or less digits will have a trailing zero if
    # the second digits in "%05i.vtu" is 5 in os.rename
 
    lenBaseName = len(filename) - digits - extension_len
    if digits == 0:
        cifer = 0
    else:
        cifer = int(filename[-extension_len-digits:-extension_len])
 
    return filename[:lenBaseName]+"%05i." % cifer+"%s" % osuffix
 
#

References int().

Referenced by main().

error()

def oomph-convert.error

(

message

)

 Write an error message

def error(message):
    """ Write an error message
    """
    sys.stderr.write("\nCONVERSION FAILED\n")
    for line in message.split("\n"):
        sys.stderr.write("*** %s\n" % line)
    sys.exit(2)
 
#

Referenced by main(), tecplot_to_vtkxml(), and tecplot_to_vtpxml().

main()

def oomph-convert.main

(

argv

)

 Main function

def main(argv):
    """ Main function
    """
    print "* oomph-convert.py, ver. 20110615"
 
    # Check python version. Bark at user if < 2.3 or if major is > 2
    if sys.version_info<(2,3): 
        print >>sys.stderr, "You need at least Python 2.3 " 
        sys.exit(3) 
 
    major = sys.version_info[0]
    if major > 2:
        print >>sys.stderr, "Python 3 and above versions are not supported yet "
        sys.exit(3)
 
    # Get command-line arguments
    try:
        opts, args = getopt.getopt(argv, "hozp:")
    except getopt.GetoptError:
        usage()
        sys.exit(2)
        
    # Get options
    zero_pad_name_flag = False
    write_points_flag = False
    overwrite_flag = False
    for opt, arg in opts:
        if opt in ("-h"):
            usage()
            sys.exit()
        if opt in ("-z"):
            zero_pad_name_flag = True
        if opt in ("-p"):
            write_points_flag = True
            argdim = arg
            if argdim not in ("2","3"):    
                usage()
                sys.exit() 
        if opt in ("-o"):
            overwrite_flag = True
 
          
    if len(args) == 1:
        # Get filename and suffix
        ifilename = args[0]
        isuffix = ifilename.split(".")[-1]
        # Set filename and suffix
        extension_len = len(isuffix) + 1
        lenBaseName = len(ifilename) - extension_len
        
        if write_points_flag:
            ofilename = ifilename[:lenBaseName]+".vtp"
        else:
            ofilename = ifilename[:lenBaseName]+".vtu"
 
        osuffix = ofilename.split(".")[-1]
 
    elif len(args) == 2:
        # Get filenames and suffixes
        ifilename = args[0]
        ofilename = args[1]
        isuffix = ifilename.split(".")[-1]
        osuffix = ofilename.split(".")[-1]
            
    else:
        usage()
        sys.exit(2)
 
 
    # Zero pad output names if requested
    if zero_pad_name_flag:
        ofilename = addTrailingZeros(ofilename, osuffix)
 
 
    # Check that we are allowed to write to the ofilename (allowed to
    # overwrite or nothing to overwrite).
    if ok_to_write_ofile(overwrite_flag, ifilename, ofilename):
        start = time.time()
 
        # Convert from oomph-lib Tecplot format to VTK XML format
        if isuffix == "dat" and osuffix == "vtu":
            tecplot_to_vtkxml(ifilename, ofilename)
 
        # Convert from oomph-lib Tecplot format to VTP XML format
        elif isuffix == "dat" and osuffix == "vtp":
            tecplot_to_vtpxml(ifilename, ofilename,string.atoi(argdim))
 
        else:   
            error("Sorry, cannot convert between .%s and .%s file formats." % (isuffix, osuffix))
 
        end = time.time()
        print "* Conversion done in %d seconds" % (end - start)
        print '* Output file name: %(fn)s ' %{'fn': ofilename}
 
 

References addTrailingZeros(), error(), ok_to_write_ofile(), tecplot_to_vtkxml(), tecplot_to_vtpxml(), and usage().

ok_to_write_ofile()

def oomph-convert.ok_to_write_ofile	(		flag,
			in_file_name,
			out_file_name
	)

Check if the output file exists, if so decide if we should overwrite it
and tell the user what we are doing.

def ok_to_write_ofile(flag, in_file_name, out_file_name):
    """Check if the output file exists, if so decide if we should overwrite it
    and tell the user what we are doing."""
 
    if not os.path.exists(out_file_name):
        return True
 
    print "File", in_file_name, "already exists!"
 
    # Get modification times (in seconds since unix epoch I think)
    in_mtime = os.path.getmtime(in_file_name)
    out_mtime = os.path.getmtime(out_file_name)
    
    if flag:
        print "Overwriting regardless of modification times because of flag."
        return True
    
    elif in_mtime > out_mtime:
        print "Overwriting because input file is newer than output file"
        return True
 
    else:
        print "Not overwriting."
        return False
 
 
#

Referenced by main().

tecplot_to_vtkxml()

def oomph-convert.tecplot_to_vtkxml	(		inputFilename,
			outputFilename
	)

 Converts Tecplot file generates by Oomph into Vtk XML file.

def tecplot_to_vtkxml(inputFilename, outputFilename):
    """ Converts Tecplot file generates by Oomph into Vtk XML file.
    """
 
    #---------------------------------------------------------------------------
    # Retrieve the zones from the input Tecplot file
    #---------------------------------------------------------------------------
    try:
        input = open(inputFilename, "r")
    except:
        error("Failed to open input file for reading !")
 
    sys.stdout.write("Parse input file for Tecplot zones........")
    sys.stdout.flush()
    line = 0
    ignoredlines = 0
    zones = list()
    while 1:
        zone = None
        linetmp = line
        try:
            (zone, line) = TecplotZone.parse(input, line)
        except TecplotParsingError, e:
            input.close()
            error(str(e))
        
        if zone:
            zones.append(zone)
            ignoredlines+=line-linetmp-1-zone.nodesCount()
        else:
            print "done"
            input.close() # Close input file
            break
 
    nbzones = len(zones)
    sys.stdout.write("* %d lines ignored\n" % ignoredlines)
    if nbzones == 0:
 
        #---------------------------------------------------------------------------
        # Dummy output
        #---------------------------------------------------------------------------
        try:
            output = open(outputFilename, "w")
        except:
            error("Failed to open output file for writing !")
        
        output.close()
        error("The input file " + inputFilename + "\n does not contain any Tecplot zone! Created an empty file... \n You may want to try converting this file to point \n data with -p2 option if dim == 2 or -p3 option if dim == 3")
 
    #---------------------------------------------------------------------------
    # Compute global informations
    #---------------------------------------------------------------------------
 
    # Get the solution dimension (compute the maximum value)
    dimension=0
    for zone in zones:
        if zone.dimension > dimension:
            dimension=zone.dimension
 
    if dimension == 1:
        error("1D is not supported. Use GnuPlot to display the data file.")
 
    # Loop over the zones to get the number of nodes and cells
    nodesCount = 0
    cellsCount = 0
    for zone in zones:
        nodesCount += zone.nodesCount()
        cellsCount += zone.cellsCount[0]
 
    # Get the field count
    # Assumption: the number of fields is assumed to be constant over all zones
    fieldsCount = len(zones[0].nodes[0].fields)
 
    #---------------------------------------------------------------------------
    # Write into Vtk XML output file
    #---------------------------------------------------------------------------
    try:
        output = open(outputFilename, "w")
    except:
        error("Failed to open output file for writing !")
 
    output.write(VtkXml.header)
    output.write(VtkXml.unstructuredGridHeader)
    output.write(VtkXml.pieceHeader % (nodesCount, cellsCount))
 
    #---------------------------------------------------------------------------
    # Nodes
    #---------------------------------------------------------------------------
    sys.stdout.write("Write nodal coordinates...................")
    sys.stdout.flush()
    output.write(VtkXml.pointsHeader)
    for zone in zones:
        for node in zone.nodes:
            output.write("%e %e %e\n" %(node.coordinates[0], node.coordinates[1], node.coordinates[2]))
    output.write(VtkXml.pointsFooter)
    print "done"
 
    #---------------------------------------------------------------------------
    # Cells
    #---------------------------------------------------------------------------
    output.write(VtkXml.cellsHeader)
 
    # Cell connectivity
    #---------------------------------------------------------------------------
    sys.stdout.write("Write cell connectivity...................")
    sys.stdout.flush()
    output.write(VtkXml.connectivityHeader)
    pos = 0 # Current cell origin node index
 
    zoneCount=0
    for zone in zones:
 
        zoneCount+=1
        if zone.cellFormat[0] == 1:
 
            if zoneCount == 1: maxNode=0
 
            # dump connectivities
            for element in range (0, zone.cellsCount[0]):
                conn=zone.connectivities[element]
                for i in range(0, len(conn)):
                    dum=int(conn[i])
                    # renumber connectivity table if it belongs to zone > 1
                    if zoneCount > 1: dum+=maxNode+1
                    conn[i]=dum-1
                    output.write("%i " %(conn[i]))
                output.write("\n")
 
            # compute maximum node number for renumbering of next connectivity table
            maxNode=0
            for element in range (0, zone.cellsCount[0]):
                conn=zone.connectivities[element]
                for i in range(0, len(conn)):
                    conn[i]=int(conn[i])
                dum=max(conn)
                if dum > maxNode:
                    maxNode = dum
 
        if zone.cellFormat[0] == 2:
 
            dimI = zone.edges[0]
 
            if zone.dimension[0] == 1: # Line (dim I = 2)
                indexes = [pos, pos+1]
                output.write(" ".join(map(str, indexes)) + "\n")
                pos += dimI
 
            if zone.dimension[0] == 2: # Quad
                dimJ = zone.edges[1]
                indexes = 4 * [0]
                for j in range(dimJ - 1):
                    for i in range(dimI - 1):
                        # Unique face of the cell
                        indexes[0] = pos            # bottom-left node
                        indexes[1] = pos + 1        # bottom-right node
                        indexes[2] = pos + 1 + dimI # top-right node
                        indexes[3] = pos + dimI     # to-left node
                        output.write(" ".join(map(str, indexes)) + "\n")
                        # Next cell
                        pos += 1
                    # Next row of cells
                    pos += 1
                # Next zone
                pos += dimI
        
            if zone.dimension[0] == 3: # Hexahedron
                indexes = 8 * [0]
                dimJ = zone.edges[1]
                dimK = zone.edges[2]
                for k in range(dimK - 1):
                    for j in range(dimJ - 1):
                        for i in range(dimI - 1):
                            # Front face of the cell
                            indexes[0] = pos            # bottom-left node
                            indexes[1] = pos + 1        # bottom-right node
                            indexes[2] = pos + 1 + dimI # top-right node
                            indexes[3] = pos + dimI     # to-left node
                            # Back face of the cell
                            backPos = pos + dimI * dimJ
                            indexes[4] = backPos
                            indexes[5] = backPos + 1
                            indexes[6] = backPos + 1 + dimI
                            indexes[7] = backPos + dimI
                            output.write(" ".join(map(str, indexes)) + "\n")
                            # Next cell
                            pos += 1
                        # Next row of cells
                        pos += 1
                    # Next k
                    pos += dimI
                # Next zone
                pos += dimI * dimJ
 
    output.write(VtkXml.connectivityFooter)
    print "done"
 
    # Cell offset
    #---------------------------------------------------------------------------
    sys.stdout.write("Write cell offsets........................")
    sys.stdout.flush()
    output.write(VtkXml.offsetsHeader)
    offset = 0
    for zone in zones:
        for i in range(1,zone.cellsCount[0]+1):
            if zone.cellType[0] == 3: # VTK_LINE
                offset +=2
            if zone.cellType[0] == 5: # VTK_TRIANGLE
                offset +=3
            if zone.cellType[0] == 9: # VTK_QUAD
                offset +=4
            if zone.cellType[0] == 10: # VTK_TETRAHEDRON
                offset +=4
            if zone.cellType[0] == 12: # VTK_HEXAHEDRON
                offset +=8
            output.write(str(offset) + "\n")
    output.write(VtkXml.offsetsFooter)
    print "done"
 
    # Cell types
    #---------------------------------------------------------------------------
    sys.stdout.write("Write cell types..........................")
    sys.stdout.flush()
 
    output.write(VtkXml.typesHeader)    
    
    cellType0 = zones[0].cellType[0]
    warn = 0
    for zone in zones:
        if zone.cellType[0] == 3: # VTK_LINE
            cellType = "3"
        if zone.cellType[0] == 5: # VTK_TRIANGLE
            cellType = "5"
        if zone.cellType[0] == 9: # VTK_QUAD
            cellType = "9"
        if zone.cellType[0] == 10: # VTK_TETRAHEDRON
            cellType = "10"
        if zone.cellType[0] == 12: # VTK_HEXAHEDRON
            cellType = "12"
 
        if warn == 0 and not zone.cellType[0] == cellType0:#Check if types are differents
            warn = 1
        output.write(zone.cellsCount[0] * (cellType + "\n"))
 
    output.write(VtkXml.typesFooter)
    print "done"
    if warn == 1:
        sys.stdout.write("Warning: Different types of elements \n")
    output.write(VtkXml.cellsFooter)
 
    #---------------------------------------------------------------------------
    # Fields
    #---------------------------------------------------------------------------
    output.write(VtkXml.pointDataHeader)
    for fieldIndex in range(fieldsCount):
        sys.stdout.write("Write field %02d/%02d........................." % (fieldIndex + 1, fieldsCount))
        sys.stdout.flush()
        output.write(VtkXml.fieldHeader % (fieldIndex + 1))
        for zone in zones:
            for node in zone.nodes:
                output.write("%e\n" % node.fields[fieldIndex])
 
        print "done"
        output.write(VtkXml.fieldFooter)
 
    output.write(VtkXml.pointDataFooter)
 
    output.write(VtkXml.pieceFooter)
    output.write(VtkXml.unstructuredGridFooter)
    output.write(VtkXml.footer)
 
    #---------------------------------------------------------------------------
    # Close output file
    #---------------------------------------------------------------------------
    output.close()
 
#

References error(), int(), max, and compute_granudrum_aor.str.

Referenced by main().

tecplot_to_vtpxml()

def oomph-convert.tecplot_to_vtpxml	(		inputFilename,
			outputFilename,
			dim
	)

 Converts Tecplot file generates by Oomph into Vtp XML file.

def tecplot_to_vtpxml(inputFilename, outputFilename, dim):
    """ Converts Tecplot file generates by Oomph into Vtp XML file.
    """
 
    #---------------------------------------------------------------------------
    # Retrieve the points from the input Tecplot file
    #---------------------------------------------------------------------------
    try:
        input = open(inputFilename, "r")
    except:
        error("Failed to open input file for reading !")
 
    sys.stdout.write("Parse input file for points........")
    sys.stdout.flush()
    line = 0
    prev_line=0
    offset_list=[]
    count=0
    nzone=1
    points = list()
    while 1:
        point = None
        try:
            (point, line) = InputPoints.parse(input, line, dim)
            #print "line %d %d is..." % (line, prev_line)
            if line != prev_line+1 :
                #print "...normal point"
                #else:
                #print "...start point"
                if prev_line !=0: 
                    offset_list.append(count)
                    nzone+=1
            count+=1
            prev_line=line
 
        except TecplotParsingError, e:
            input.close()
            error(str(e))
 
        if point:
            points.append(point)
        else:
            print "done"
            input.close() # Close input file
            break
 
    offset_list.append(count-1)
    nbpoints = len(points)
 
    if nbpoints == 0:
        error("The input file does not contain any point !")
 
 
    #---------------------------------------------------------------------------
    # Compute global informations
    #---------------------------------------------------------------------------
 
    # Get the field count
    # Assumption: the number of fields is assumed to be constant over all points
    fieldsCount = len(points[0].fields)
 
    #---------------------------------------------------------------------------
    # Write into Vtp XML output file
    #---------------------------------------------------------------------------
    try:
        output = open(outputFilename, "w")
    except:
        error("Failed to open output file for writing !")
 
    output.write(VtpXml.header)
    output.write(VtpXml.polyDataHeader)
    output.write(VtpXml.pieceHeader % (nbpoints,nzone))
 
    #---------------------------------------------------------------------------
    # Nodes
    #---------------------------------------------------------------------------
    sys.stdout.write("Write points coordinates...................")
    sys.stdout.flush()
    output.write(VtpXml.pointsHeader)
    for point in points:
        output.write("%e %e %e\n" %(point.coordinates[0], point.coordinates[1], point.coordinates[2]))
    output.write(VtpXml.pointsFooter)
    print "done"
 
    #---------------------------------------------------------------------------
    # Fields
    #---------------------------------------------------------------------------
    output.write(VtpXml.pointDataHeader)
    for fieldIndex in range(fieldsCount):
        sys.stdout.write("Write field %02d/%02d........................." % (fieldIndex + 1, fieldsCount))
        sys.stdout.flush()
        output.write(VtpXml.fieldHeader % (fieldIndex + 1))
        for point in points:
            output.write("%e\n" % point.fields[fieldIndex])
 
        print "done"
        output.write(VtpXml.fieldFooter)
 
    output.write(VtpXml.pointDataFooter)
 
    #---------------------------------------------------------------------------
    # Headers and footers
    #---------------------------------------------------------------------------
 
    output.write(VtpXml.vertsHeader)
    output.write(VtpXml.vertsFooter)
    output.write(VtpXml.linesHeader)
    #Prepare line information:
    output.write(VtkXml.connectivityHeader)
    for i in range(0,nbpoints):
        output.write("%i "%i)
    output.write(VtkXml.connectivityFooter)
    output.write(VtkXml.offsetsHeader)
    for offset in offset_list:
         output.write("%i "%offset)
    output.write(VtkXml.offsetsFooter)
    #end line information
    output.write(VtpXml.linesFooter)
    output.write(VtpXml.stripsHeader)
    output.write(VtpXml.stripsFooter)
    output.write(VtpXml.polysHeader)
    output.write(VtpXml.polysFooter)
    output.write(VtpXml.pieceFooter)
    output.write(VtpXml.polyDataFooter)
    output.write(VtpXml.footer)
 
    #---------------------------------------------------------------------------
    # Close output file
    #---------------------------------------------------------------------------
    output.close()
 
#

References error(), and compute_granudrum_aor.str.

Referenced by main().

usage()

def oomph-convert.usage

(

)

 Display usage

def usage():
    """ Display usage
    """
    print """\
 
NAME
        oomph-convert.py - script for converting from oomph-lib tecplot format to VTK XML. 
 
 
SYNOPSIS
        oomph-convert.py [OPTION] [input_file.dat] [output_file]
 
 
OPTIONS
        -p2 or -p3 outputs only points in 2D or 3D (.vtp)
        -h         display this help text and exit
        -z         add trailing zeros to the output filename
        -o         force overwrite existing files
 
        By default output files will overwrite old ones only if the input file is
        newer than the output file.
 
 
TYPICAL USAGE EXAMPLES
        oomph-convert.py -h                             -> display help text
        oomph-convert.py soln12.dat soln12.vtu          -> generate soln12.vtu
        oomph-convert.py -z soln12.dat soln12.vtu       -> generate soln00012.vtu
        oomph-convert.py soln12.dat                     -> generate soln12.vtu
        oomph-convert.py -z soln12.dat                  -> generate soln00012.vtu
        oomph-convert.py soln12.dat nsol2.vtu           -> generate nsol2.vtu
        oomph-convert.py -z soln12.dat nsol2.vtu        -> generate nsol00002.vtu
        oomph-convert.py soln.dat                       -> generate soln.vtu
        oomph-convert.py -z soln.dat                    -> generate soln00000.vtu
        oomph-convert.py -p3 soln12.dat soln12.vtp          -> generate soln12.vtp
        oomph-convert.py -p2 -z soln12.dat soln12.vtp       -> generate soln00012.vtp
        oomph-convert.py -p3 soln12.dat                     -> generate soln12.vtp
        oomph-convert.py -p2 -z soln12.dat                  -> generate soln00012.vtp
        oomph-convert.py -p3 soln12.dat nsol2.vtp           -> generate nsol2.vtp
        oomph-convert.py -p2 -z soln12.dat nsol2.vtp        -> generate nsol00002.vtp
        oomph-convert.py -p3 soln.dat                       -> generate soln.vtp
        oomph-convert.py -p2 -z soln.dat                    -> generate soln00000.vtp"""
 
#

Referenced by main().