Public Member Functions
def	__init__ (self)

def	nodesCount (self)

Static Public Member Functions
def	parse (file, line)

Public Attributes
	edges

	nodes

	dimension

	cellType

	cellFormat

	cellsCount

	connectivities

Detailed Description

 This class handles Tecplot zone informations.

Constructor & Destructor Documentation

◆ init()

def oomph-convert.TecplotZone.__init__ ( self )

     def __init__(self):
         self.edges = list()
         self.nodes = list()
         self.dimension = list()
         self.cellType = list()
         self.cellFormat = list()
         self.cellsCount = list()
         self.connectivities = list()
         """ List of :class:`TecplotZone`
         """
  

Member Function Documentation

◆ nodesCount()

def oomph-convert.TecplotZone.nodesCount ( self )

 :return: The number of nodes in this zone

     def nodesCount(self):
         """ :return: The number of nodes in this zone
         """
         return len(self.nodes)
  

References oomph-convert.TecplotZone.nodes, and PQueueType.nodes.

◆ parse()

def oomph-convert.TecplotZone.parse	(	file,
		line
	)

static

 Parse the zone of the given file starting from current position.

    :param file: A file open for reading
    :param line: The current position in the file as line number (used for error messages)
    :return: :class:`TecplotZone` if a zone has been found before the end of the file otherwise :const:`None`
    :return: The updated line position in input file
    :raise:  :class:`TecplotParsingError` on parsing error

    .. note:: This method will seek until it reach a Tecplot zone header.

     def parse(file, line):
         """ Parse the zone of the given file starting from current position.
  
             :param file: A file open for reading
             :param line: The current position in the file as line number (used for error messages)
             :return: :class:`TecplotZone` if a zone has been found before the end of the file otherwise :const:`None`
             :return: The updated line position in input file
             :raise:  :class:`TecplotParsingError` on parsing error
  
             .. note:: This method will seek until it reach a Tecplot zone header.
         """
         #-----------------------------------------------------------------------
         # Seek to the next Tecplot zone
         #-----------------------------------------------------------------------
         
         while 1:
             header = file.readline()
             line += 1
  
             if not header:
                 # We reach the end of the file
                 return (None, line)
  
             if len(header) > 3 and header[0:4] == "ZONE":
                 # We got a zone !
                 break
  
         #-----------------------------------------------------------------------
         # Create the zone
         #-----------------------------------------------------------------------
         zone = TecplotZone()
  
         # Read header informations
         edges = header[len("ZONE"):].strip().split(",")
  
         # Assumption: Only two zone formats are possible.
         # The first (format 1) is defined with a zone header of the type
         # ZONE N=15, E=16, F=FEPOINT, ET=TRIANGLE
         # In this case, edges = ['N=15', ' E=16', ' F=FEPOINT', ' ET=TRIANGLE']
         # This zone has been coded for two ET keywords: TRIANGLE and TETRAHEDRON
         # The second (format 2) is defined in terms of the IJK indexes and a 
         # typical zone reads
         # ZONE I=5, J=5, K=5
         # One index, I, indicates a line element, 2 indexes, I and J, indicate
         # a 4 node quadrilateral element, and three indexes, I J and K, indicate
         # a tetrahedral element.
  
         if "TRIANGLE" in header:
  
             # Define data
             cell = 5 # VTK_TRIANGLE
             dim = 2
             format = 1
             nodesCount = int(edges[0].strip().strip("N="))
             cellsCount = int(edges[1].strip().strip("E="))
  
             # Append data to zone
             zone.dimension.append(dim)
             zone.cellType.append(cell)
             zone.cellFormat.append(format)
             zone.cellsCount.append(cellsCount)
  
         elif "TETRAHEDRON" in header:
  
             # Define data
             cell = 10 # VTK_TETRAHEDRON
             dim = 3
             format = 1
             nodesCount = int(edges[0].strip().strip("N="))
             cellsCount = int(edges[1].strip().strip("E="))
  
             # Append data to zone
             zone.dimension.append(dim)
             zone.cellType.append(cell)
             zone.cellFormat.append(format)
             zone.cellsCount.append(cellsCount)
  
         else:
  
             if not len(edges) in range(1, 4):
                 raise TecplotParsingError("Invalid zone header",\
                                           "wrong edges count! Try to convert with -p option",\
                                           line,\
                                           reminder=True)
  
             format = 2
  
             # define dimension of zone cell by counting the IJK indexes
             dim = len(edges)
  
             if dim == 1:
                 cell = 3 # VTK_LINE
             if dim == 2:
                 cell = 9 # VTK_QUAD
             if dim == 3:
                 cell = 12 # VTK_HEXAHEDRON
  
             # append dimension and cell type/format to the zone
             zone.dimension.append(dim)
             zone.cellType.append(cell)
             zone.cellFormat.append(format)
  
             # extract information from string
             labels = ["I", "J", "K"]
             for (index, edge) in enumerate(edges):
                 edge = edge.strip()
                 if len(edge) < 2 or edge[0] != labels[index]:
                     raise TecplotParsingError("Invalid zone header",\
                                               "wrong edges format (%s). Try to convert with -p option" % edges,\
                                               line,\
                                               reminder=True)
                 try:
                     zone.edges.append(int(edge[2:]))
                 except:
                     raise TecplotParsingError("Invalid zone header",\
                                               "wrong edge format (%s). Try to convert with -p option" % edge,\
                                               line)
  
             #-------------------------------------------------------------------
             # Node count in cell
             #-------------------------------------------------------------------
             nodesCount = 1
             for edge in zone.edges:
                 nodesCount *= edge
                 
             #-------------------------------------------------------------------
             # Cell count in zone
             #-------------------------------------------------------------------
             cellsCount = 1
             for edge in zone.edges:
                 cellsCount *= edge - 1
             zone.cellsCount.append(cellsCount)
  
         #-----------------------------------------------------------------------
         # Parse nodes
         #-----------------------------------------------------------------------
         for nodeIndex in range(nodesCount):
             data = file.readline()
             line += 1
  
             if not data or data.strip() == "":
                 data = file.readline() # ...in case of empty line
  
             data = data.strip().split(" ")
             if len(data) < dim:
                 raise TecplotParsingError("Invalid zone", "not enough values for this node ! Try to convert with -p option", line)
  
             node = TecplotNode()
             for i, value in enumerate(data):
                 try:
                     if i < dim:
                         node.coordinates[i] = float(value)
                     else:
                         node.fields.append(float(value))
                 except ValueError:
                     raise TecplotParsingError("Invalid zone", "wrong node values ! Try to convert with -p option", line)
  
             # Append this node to the zone
             zone.nodes.append(node)
  
         #-----------------------------------------------------------------------
         # Parse connectivities (format == 1)
         #-----------------------------------------------------------------------
         if format == 1:
             for cellIndex in range(cellsCount):
                 data = file.readline()
                 line += 1
  
                 if not data or data.strip() == "":
                     data = file.readline() # ...in case of empty line
  
                 data = data.strip().split(" ")
                 if cell == 3:  cellNodes = 2 # VTK_LINE
                 if cell == 5:  cellNodes = 3 # VTK_TRIANGLE
                 if cell == 9:  cellNodes = 4 # VTK_QUAD
                 if cell == 10: cellNodes = 4 # VTK_TETRAHEDRON
                 if cell == 12: cellNodes = 8 # VTK_HEXAHEDRON
  
                 if len(data) != cellNodes:
                     raise TecplotParsingError("Invalid zone", "wrong connectivity list for this element!", line)
  
                 # Append these connectivities to the zone
                 zone.connectivities.append(data)
  
         return (zone, line)
  
 #

References int(), and oomph::DoubleVectorHelpers.split().

Member Data Documentation

◆ cellFormat

oomph-convert.TecplotZone.cellFormat

◆ cellsCount

oomph-convert.TecplotZone.cellsCount

◆ cellType

oomph-convert.TecplotZone.cellType

◆ connectivities

oomph-convert.TecplotZone.connectivities

◆ dimension

oomph-convert.TecplotZone.dimension

◆ edges

oomph-convert.TecplotZone.edges

◆ nodes

oomph-convert.TecplotZone.nodes

Referenced by oomph-convert.TecplotZone.nodesCount().

The documentation for this class was generated from the following file:

oomph-convert.py

Public Member Functions

Static Public Member Functions

Public Attributes