Data Structure


Functions

void TecUtilDataNodeSetByZone (EntIndex_t Zone, LgIndex_t Element, LgIndex_t Corner, NodeMap_t Node)
  Set the node index for a particular corner of a finite-element.
void TecUtilDataNodeArraySetByRef (NodeMap_pa DestNodeMap, LgIndex_t DestOffset, LgIndex_t DestCount, NodeMap_t *SourceNodeArray)
  Copies the specified number of nodes from the base of the source node array to the destination node map starting at the specified offset.
void TecUtilDataNodeSetByRef (NodeMap_pa NM, LgIndex_t Element, LgIndex_t Corner, NodeMap_t Node)
  Set the node index for a particular corner of a finite-element.
Boolean_t TecUtilDataFEPolyGetCellNodesSizeAndCenter (FaceMap_pa FaceMap, ElemToFaceMap_pa ElemToFaceMap, LgIndex_t CellIndex, FieldData_pa XFieldData, FieldData_pa YFieldData, FieldData_pa ZFieldData, LgIndex_t *NumUniqueNodes, LgIndex_t *UniqueNodesSize, LgIndex_t **UniqueNodes, double *CellSize, XYZ_s *CellCenter)
  Gets the logically unique nodes, cell size, and cell center position of an entire finite element polytope cell.
Boolean_t TecUtilDataFECellGetUniqueNodes (EntIndex_t Zone, ElemFaceOffset_t FaceOffset, LgIndex_t CellIndex, LgIndex_t *NumUniqueNodes, LgIndex_t *UniqueNodesSize, LgIndex_t **UniqueNodes)
  Gets the logically unique nodes of an entire finite element cell or, for finite element volume data only, a finite element face.
void TecUtilDataFECellGetNodes (EntIndex_t Zone, int Face, LgIndex_t CellIndex, LgIndex_t *I1, LgIndex_t *I2, LgIndex_t *I3, LgIndex_t *I4)
  Get the indices for the nodes of a finite-element cell.
void TecUtilDataIJKCellGetIndices (EntIndex_t Zone, IJKPlanes_e Plane, LgIndex_t CellIndex, LgIndex_t *I1, LgIndex_t *I2, LgIndex_t *I3, LgIndex_t *I4)
  Get the indices for the nodes a cell in an ordered zone.
void TecUtilDataNodeGetRawPtr (EntIndex_t Zone, NodeMap_t **NodeMapPtr)
 
NodeMap_pa TecUtilDataNodeGetRef (EntIndex_t Zone)
 
NodeMap_t TecUtilDataNodeGetByZone (EntIndex_t Zone, LgIndex_t Element, LgIndex_t Corner)
  Get the node index for a particular corner of a finite-element.
void TecUtilDataNodeArrayGetByRef (NodeMap_pa SourceNodeMap, LgIndex_t SourceOffset, LgIndex_t SourceCount, NodeMap_t *DestNodeArray)
  Fetch an array of nodes by reference.
NodeMap_t TecUtilDataNodeGetByRef (NodeMap_pa NodeMapPtr, LgIndex_t Element, LgIndex_t Corner)
  Get the node index for a particular corner of a finite-element.
EntIndex_t TecUtilDataNodeGetNodesPerElem (NodeMap_pa NodeMapPtr)
  Get the number of nodes per element.

Function Documentation

void TecUtilDataFECellGetNodes ( EntIndex_t  Zone,
int  Face,
LgIndex_t  CellIndex,
LgIndex_t *  I1,
LgIndex_t *  I2,
LgIndex_t *  I3,
LgIndex_t *  I4 
)

Get the indices for the nodes of a finite-element cell.

This function is Thread Safe.

Parameters:
Zone Zone in which the cell exists. This must be a finite-element zone, but not polyhedral or polygonal.
Face Face of the finite-element cell. If the zone uses tetrahedrons this is a number between one and four. If the zone uses bricks this is a number between one and six. If the zone uses triangles or quadrilaterals then this is ignored.
CellIndex The cell index (that is, the element number) to query.
I1 First Node index or zero if the node map could not be loaded.
I2 Second Node index or zero if the node map could not be loaded.
I3 Third Node index or zero if the node map could not be loaded. For linear element type this is a repeat of I1.
I4 Fourth Node index or zero if the node map could not be loaded. For triangle or linear element types this is a repeat I1.
Precondition:
Must have one or more frames.

Current frame must have a data set with at least one zone.

I1 Pointer must be a valid address and non-NULL.

I2 Pointer must be a valid address and non-NULL.

I3 Pointer must be a valid address and non-NULL.

I4 Pointer must be a valid address and non-NULL.

Fortran Syntax:
    SUBROUTINE TecUtilDataFECellGetNodes(
   &           Zone,
   &           Face,
   &           CellIndex,
   &           I1,
   &           I2,
   &           I3,
   &           I4)
    INTEGER*4       Zone
    INTEGER*4       Face
    INTEGER*4       CellIndex
    INTEGER*4       I1
    INTEGER*4       I2
    INTEGER*4       I3
    INTEGER*4       I4

Python Syntax:

  Results = TecUtil.DataFECellGetNodes(Zone, Face, CellIndex)

  Input:
                  Zone                 int
                  Face                 int
                  CellIndex            int
  Output:
    Results[0]    I1                   int
    Results[1]    I2                   int
    Results[2]    I3                   int
    Results[3]    I4                   int

Get the node indices for face number 2 of cell number 23 in zone 3:

   LgIndex_t I1,I2,I3,I4;

   // Add code here to make sure data exists, and the zone
   // exists and is the right size and type
   TecUtilDataFECellGetNodes(3,
                             2,
                             23,
                             &I1,&I2,&I3,&I4);

Boolean_t TecUtilDataFECellGetUniqueNodes ( EntIndex_t  Zone,
ElemFaceOffset_t  FaceOffset,
LgIndex_t  CellIndex,
LgIndex_t *  NumUniqueNodes,
LgIndex_t *  UniqueNodesSize,
LgIndex_t **  UniqueNodes 
)

Gets the logically unique nodes of an entire finite element cell or, for finite element volume data only, a finite element face.

This function is Thread Safe.

Since:
11.2-0-398
Parameters:
Zone Zone in which the cell exits. This must be a finite element zone.
FaceOffset For the unique nodes of an entire cell this value must be set to zero or, for finite element volume data only, this value must be set to the desired face number.
CellIndex The cell index to query.
NumUniqueNodes Pointer to the resulting number of unique nodes.
UniqueNodesSize As input this value is a pointer to the current dimension of the UniqueNodes array or a pointer to a dimension value of zero if the UniqueNodes array has not yet been allocated.
As output it is a pointer to the resulting dimension of the UniqueNodes array which is at least large enough to hold the unique nodes.
Parameters:
UniqueNodes As input this value is a pointer to NULL or a pointer to an allocated array dimensioned as specified by UniqueNodesSize items.
As output it is a pointer to the resulting allocated or reallocated array containing the unique nodes. The resulting array is only reallocated if the number of unique nodes exceeds the value pointed to by UniqueNodesSize.
If you supply a pre-allocated array for UniqueNodes that was not allocated by a previous call to this function, it MUST be sized large enough to hold the requested unique nodes. If it were not, Tecplot would attempt to release the undersized resource causing undefined behavior because Tecplot's allocator/deallocator is different than that of an add-on.
If UniqueNodes was allocated by a call to this function you must deallocated it when no longer needed by a call to TecUtilArrayDealloc().
Returns:
TRUE if successful, FALSE otherwise.
Precondition:
Must have one or more frames.

Current frame must have a data set with at least one zone.

NumUniqueNodes Pointer must be a valid address and non-NULL.

UniqueNodes Pointer must be a valid address and non-NULL.

Get the unique element nodes for an cell 362 and 535 of zone 5 letting Tecplot allocate the array of unique nodes. 
   EntIndex_t       Zone       = 5; // ...assume that this is an FE zone
   ElemFaceOffset_t FaceOffset = 0; // ...0 because we want the unique nodes for the entire cell
   LgIndex_t        NumUniqueNodes;
   LgIndex_t        UniqueNodesSize = 0;    // ...let Tecplot allocate
   LgIndex_t       *UniqueNodes     = NULL; // ...let Tecplot allocate
   IsOk = TecUtilDataFECellGetUniqueNodes(Zone, FaceOffset, 362,
                                          &NumUniqueNodes,
                                          &UniqueNodesSize,
                                          &UniqueNodes);
   if (IsOk)
     {
       ...do something useful with the unique nodes of cell 362
     }

   // Using the previously allocate array request the unique nodes of cell 535.
   // Note that the array may get reallocated if required to hold the unique
   // nodes of cell 535.
   if (IsOk)
     {
       IsOk = TecUtilDataFECellGetUniqueNodes(Zone, FaceOffset, 535,
                                              &NumUniqueNodes,
                                              &UniqueNodesSize,
                                              &UniqueNodes);
     }

   if (IsOk)
     {
       ...do something useful with the unique nodes of cell 535
     }

   // cleanup
   TecUtilArrayDealloc(&((void *)UniqueNodes));

Get the unique face nodes for a classic FE cell where we supply an automatic variable that is guaranteed to be large enough to hold the unique face nodes. 

   EntIndex_t       Zone       = 3; // ...assume that this is a classic FE brick zone
   ElemFaceOffset_t FaceOffset = 2; // ...face 2 of the brick
   LgIndex_t        NumUniqueNodes;
   LgIndex_t        UniqueNodesSize = 4;    // ...classic FE zones have at most 4 nodes per face
   LgIndex_t        ClassicUniqueNodes[4];  // ...classic FE zones have at most 4 nodes per face
   IsOk = TecUtilDataFECellGetUniqueNodes(Zone, FaceOffset, 276,
                                          &NumUniqueNodes,
                                          &UniqueNodesSize,
                                          &UniqueNodes);
   if (IsOk)
     {
       ...do something useful with the unique face nodes of cell 276, face 2
     }

   // using the same array request the unique face nodes of cell 657, face 6
   if (IsOk)
     {
       FaceOffset = 6; // ...face 6 of the brick
       IsOk = TecUtilDataFECellGetUniqueNodes(Zone, FaceOffset, 657,
                                              &NumUniqueNodes,
                                              &UniqueNodesSize,
                                              &UniqueNodes);
     }

   if (IsOk)
     {
       ...do something useful with the unique face nodes of cell 657, face 6
     }

   // no need to cleanup because the unique nodes array should never have been resized

Python Syntax:

    This function is not supported in Python.

See also:
TecUtilDataFEPolyGetCellNodesSizeAndCenter()

Boolean_t TecUtilDataFEPolyGetCellNodesSizeAndCenter ( FaceMap_pa  FaceMap,
ElemToFaceMap_pa  ElemToFaceMap,
LgIndex_t  CellIndex,
FieldData_pa  XFieldData,
FieldData_pa  YFieldData,
FieldData_pa  ZFieldData,
LgIndex_t *  NumUniqueNodes,
LgIndex_t *  UniqueNodesSize,
LgIndex_t **  UniqueNodes,
double *  CellSize,
XYZ_s *  CellCenter 
)

Gets the logically unique nodes, cell size, and cell center position of an entire finite element polytope cell.

This function is Thread Safe.

Since:
11.2-0-541
Parameters:
FaceMap Face map handle.
ElemToFaceMap The element-to-face map handle
CellIndex The cell index to query.
XFieldData X variable field data handle.
YFieldData Y variable field data handle or NULL if not to be used for calculating the cell size and center.
ZFieldData Z variable field data handle or NULL if not to be used for calculating the cell size and center.
NumUniqueNodes Pointer to the resulting number of unique nodes.
UniqueNodesSize As input this value is a pointer to the current dimension of the UniqueNodes array or a pointer to a dimension value of zero if the UniqueNodes array has not yet been allocated.
As output it is a pointer to the resulting dimension of the UniqueNodes array which is at least large enough to hold the unique nodes.
Parameters:
UniqueNodes As input this value is a pointer to NULL or a pointer to an allocated array dimensioned as specified by UniqueNodesSize items.
As output it is a pointer to the resulting allocated or reallocated array containing the unique nodes. The resulting array is only reallocated if the number of unique nodes exceeds the value pointed to by UniqueNodesSize.
If you supply a pre-allocated array for UniqueNodes that was not allocated by a previous call to this function, it MUST be sized large enough to hold the requested unique nodes. If it were not, Tecplot would attempt to release the undersized resource causing undefined behavior because Tecplot's allocator/deallocator is different than that of an add-on.
If UniqueNodes was allocated by a call to this function you must deallocated it when no longer needed by a call to TecUtilArrayDealloc().
Parameters:
CellSize Cell size. The size is area for surface data and volume for volume data.
CellCenter Cell center using the nodal average.
Returns:
TRUE if successful, FALSE otherwise.
Precondition:
NumUniqueNodes Pointer must be a valid address and non-NULL.

UniqueNodes Pointer must be a valid address and non-NULL.

Get the unique element nodes for an cell 362 and 535 of zone 5 letting Tecplot allocate the array of unique nodes. We assume X, Y, and Z are the first three variables. 
   EntIndex_t       Zone = 5; // ...assume that this is an FE polytope zone
   FaceMap_pa       FM   = TecUtilDataFaceMapGetReadableRef(Zone);
   ElemToFaceMap_pa EFM  = TecUtilDataElemGetReadableRef(Zone);
   FieldData_pa     XFD  = TecUtilDataValueGetReadableNLRef(Zone, 1);
   FieldData_pa     YFD  = TecUtilDataValueGetReadableNLRef(Zone, 2);
   FieldData_pa     ZFD  = TecUtilDataValueGetReadableNLRef(Zone, 3);
   double           CellSize;
   XYZ_s            CellCenter;
   LgIndex_t        NumUniqueNodes;
   LgIndex_t        UniqueNodesSize = 0;    // ...let Tecplot allocate
   LgIndex_t       *UniqueNodes     = NULL; // ...let Tecplot allocate

   IsOk = ((FM != NULL && EFM != NULL)                 &&
           (XFD != NULL && YFD != NULL && ZFD != NULL) &&
           TecUtilDataFEPolyGetCellNodesSizeAndCenter(FM, EFM, 362,
                                                      XFD, YFD, ZFD,
                                                      &NumUniqueNodes,
                                                      &UniqueNodesSize,
                                                      &UniqueNodes,
                                                      &CellSize,
                                                      &CellCenter);
   if (IsOk)
     {
       ...do something useful with the unique nodes, size, or center of cell 362
     }

   // Using the previously allocate array request the unique nodes of cell 535.
   // Note that the array may get reallocated if required to hold the unique
   // nodes of cell 535.
   if (IsOk)
     {
       IsOk = TecUtilDataFEPolyGetCellNodesSizeAndCenter(FM, EFM, 535,
                                                         XFD, YFD, ZFD,
                                                         &NumUniqueNodes,
                                                         &UniqueNodesSize,
                                                         &UniqueNodes,
                                                         &CellSize,
                                                         &CellCenter);
     }

   if (IsOk)
     {
       ...do something useful with the unique nodes, size, or center of cell 535
     }

   // cleanup
   TecUtilArrayDealloc(&((void *)UniqueNodes));

Python Syntax:

    This function is not supported in Python.

See also:
TecUtilDataFECellGetUniqueNodes()

void TecUtilDataIJKCellGetIndices ( EntIndex_t  Zone,
IJKPlanes_e  Plane,
LgIndex_t  CellIndex,
LgIndex_t *  I1,
LgIndex_t *  I2,
LgIndex_t *  I3,
LgIndex_t *  I4 
)

Get the indices for the nodes a cell in an ordered zone.

This function is Thread Safe.

Parameters:
Zone Zone in which the cell exists
Plane Plane in which the cell resides. The possible values are: IJKPlanes_I, IJKPlanes_J, IJKPlanes_K or IJKPlanes_Volume. For I- or IJ-ordered data use IJKPlanes_K. For IJK-ordered data this determines which of the three faces (I, J, or K) to use to determine which cell to query.
CellIndex The index of the lowest indexed corner of the cell to query
I1 First node index for the cell. If the zone is IJ-ordered or IJK-ordered, these indices are calculated from treating the two- or three-dimensional array as a one-dimensional array.
I2 Second node index for the cell. If the zone is IJ-ordered or IJK-ordered, these indices are calculated from treating the two- or three-dimensional array as a one-dimensional array.
I3 Third node index for the cell. If the zone is IJ-ordered or IJK-ordered, these indices are calculated from treating the two- or three-dimensional array as a one-dimensional array.
I4 Fourth node index for the cell. If the zone is IJ-ordered or IJK-ordered, these indices are calculated from treating the two- or three-dimensional array as a one-dimensional array.
Precondition:
Must have one or more frames.

Current frame must have a data set with at least one zone.

I1 Pointer must be a valid address and non-NULL.

I2 Pointer must be a valid address and non-NULL.

I3 Pointer must be a valid address and non-NULL.

I4 Pointer must be a valid address and non-NULL.

Fortran Syntax:
    SUBROUTINE TecUtilDataIJKCellGetIndices(
   &           Zone,
   &           Plane,
   &           CellIndex,
   &           I1,
   &           I2,
   &           I3,
   &           I4)
    INTEGER*4       Zone
    INTEGER*4       Plane
    INTEGER*4       CellIndex
    INTEGER*4       I1
    INTEGER*4       I2
    INTEGER*4       I3
    INTEGER*4       I4

Python Syntax:

  Results = TecUtil.DataIJKCellGetIndices(Zone, Plane, CellIndex)

  Input:
                  Zone                 int
                  Plane                IJKPlanes_e  (defined in TecVals.py)
                  CellIndex            int
  Output:
    Results[0]    I1                   int
    Results[1]    I2                   int
    Results[2]    I3                   int
    Results[3]    I4                   int

Get the node indices for the face that lies in the J-plane of the cell that resides at (1, 1, 1) in zone 2 which is an IJK-ordered data set:

   LgIndex_t I1,I2,I3,I4;

   // Add code here to make sure data exists and the zone
   // exists and is the right size and type
   TecUtilDataIJKCellGetIndices(2,
                                IJKPlanes_J,
                                1,
                                &I1,&I2,&I3,&I4);

   LgIndex_t I1,I2,I3,I4;
   LgIndex_t CellIndex;

   // Add code here to make sure data exists, and the zone
   // exists and is the right size and type

   CellIndex = 2+10*((5-1)+20*(13-1));

   TecUtilDataIJKCellGetIndices(2,
                                IJKPlanes_K,
                                CellIndex,
                                &I1,&I2,&I3,&I4);

Get the nodel indices for the face that lies in the K-plane of the cell that resides at (2, 5, 13) in zone 2, which is an IJK-ordered data set dimensioned 10 by 20 by 30:

   LgIndex_t I1,I2,I3,I4;
   LgIndex_t CellIndex;

   // Add code here to make sure data exists, and the zone
   // exists and is the right size and type

   CellIndex = 2+10*((5-1)+20*(13-1));

   TecUtilDataIJKCellGetIndices(2,
                                IJKPlanes_K,
                                CellIndex,
                                &I1,&I2,&I3,&I4);

void TecUtilDataNodeArrayGetByRef ( NodeMap_pa  SourceNodeMap,
LgIndex_t  SourceOffset,
LgIndex_t  SourceCount,
NodeMap_t *  DestNodeArray 
)

Fetch an array of nodes by reference.

This function fetches the specified number of nodes from the source node map starting at the specified source item offset and copies them to the base of the destination node array. This function is Thread Safe.

Since:
11.0-0-019
Parameters:
SourceNodeMap Node map containing the data to fetch.
SourceOffset Node offset in the source node map to begin fetching nodes.
SourceCount Number of nodes to fetch from the source node map.
DestNodeArray Pre-allocated array large enough to hold the requested node. The first node is placed at the base of the array. The node values are one based.
Precondition:
SourceNodeMap Pointer must be a valid address and non-NULL.

DestNodeArray Pointer must be a valid address and non-NULL.

Python Syntax:
    This function is not supported in Python.

void TecUtilDataNodeArraySetByRef ( NodeMap_pa  DestNodeMap,
LgIndex_t  DestOffset,
LgIndex_t  DestCount,
NodeMap_t *  SourceNodeArray 
)

Copies the specified number of nodes from the base of the source node array to the destination node map starting at the specified offset.

This function is Thread Safe.

Note:
Unless this call is in response to a custom load-on-demand callback be sure to issue a state change StateChange_NodeMapsAltered before returning control to Tecplot.
Since:
11.0-0-019
Parameters:
DestNodeMap Node map to receive the source nodes.
DestOffset Node offset in the destination node map to begin assigning nodes.
DestCount Number of nodes to assign to the destination node map. This value must not exceed the number of items supplied by SourceValueArray.
SourceNodeArray An array containing the one based nodes to copy. The first node is assumed to be at the base of the array.
Precondition:
DestNodeMap Pointer must be a valid address and non-NULL.

SourceNodeArray Pointer must be a valid address and non-NULL.

Python Syntax:
  Results = TecUtil.DataNodeArraySetByRef(DestNodeMap, DestOffset, DestCount, SourceNodeArray)

  Input:
                  DestNodeMap          opaque pointer
                  DestOffset           int
                  DestCount            int
                  SourceNodeArray      list of ints
  Output:
    Results[0]    ReturnVal            NONE

NodeMap_t TecUtilDataNodeGetByRef ( NodeMap_pa  NodeMapPtr,
LgIndex_t  Element,
LgIndex_t  Corner 
)

Get the node index for a particular corner of a finite-element.

To use this function you must have already obtained a handle to a node map. This function is Thread Safe.

Parameters:
NodeMapPtr Handle to the connectivity list (that is, the node map). Use TecUtilDataNodeGetByRef() or TecUtilZoneGetInfo() to get handles to the node map
Element The element number (starts at 1)
Corner The element corner (starts at 1)
Returns:
The index of the node.
Precondition:
NodeMapPtr Pointer must be a valid address and non-NULL.
Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilDataNodeGetByRef(
   &                   NodeMapPtrPtr,
   &                   Element,
   &                   Corner)
    POINTER         (NodeMapPtrPtr, NodeMapPtr)
    INTEGER*4       Element
    INTEGER*4       Corner

Python Syntax:

  Results = TecUtil.DataNodeGetByRef(NodeMapPtr, Element, Corner)

  Input:
                  NodeMapPtr           opaque pointer
                  Element              int
                  Corner               int
  Output:
    Results[0]    ReturnVal            int

Get the first two nodes of the 43rd element of zone 5:

   NodeMap_pa nm;
   nm = TecUtilDataNodeGetReadableRef(5);
   if ( nm )
     {
       NodeMap_t n1, n2;
       n1 = TecUtilDataNodeGetByRef(nm, 43, 1);
       n2 = TecUtilDataNodeGetByRef(nm, 43, 2);
       // use n1 and n2
     }

NodeMap_t TecUtilDataNodeGetByZone ( EntIndex_t  Zone,
LgIndex_t  Element,
LgIndex_t  Corner 
)

Get the node index for a particular corner of a finite-element.

This function does not require you to obtain the handle to the node map as does TecUtilDataNodeGetByRef(), however, this function is not very efficient. Use TecUtilDataNodeGetByRef() if you are getting multiple nodes from the same zone. This function is Thread Safe.

Parameters:
Zone Zone number. This must be a finite-element zone.
Element The element number (starts at 1)
Corner The element corner (starts at 1)
Returns:
The index of the node or zero if the node map could not be loaded.
Precondition:
Must have one or more frames.

Current frame must have a data set with at least one zone.

Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilDataNodeGetByZone(
   &                   Zone,
   &                   Element,
   &                   Corner)
    INTEGER*4       Zone
    INTEGER*4       Element
    INTEGER*4       Corner

Python Syntax:

  Results = TecUtil.DataNodeGetByZone(Zone, Element, Corner)

  Input:
                  Zone                 int
                  Element              int
                  Corner               int
  Output:
    Results[0]    ReturnVal            int

Get the third node of the 43rd element of zone 5:

   NodeMap_t n3;
   n3 = TecUtilDataNodeGetByZone(5, 43, 3);

EntIndex_t TecUtilDataNodeGetNodesPerElem ( NodeMap_pa  NodeMapPtr  ) 

Get the number of nodes per element.

To use this function you must have already obtained a handle to a node map. This function is Thread Safe.

Since:
12.1.1.6765
Parameters:
NodeMapPtr Handle to the connectivity list (that is, the node map). Use TecUtilDataNodeGetByRef() or TecUtilZoneGetInfo() to get handles to the node map
Returns:
The number of nodes per element.
Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilDataNodeGetNodesPerElem(
   &                   NodeMapPtrPtr)
    POINTER         (NodeMapPtrPtr, NodeMapPtr)

Python Syntax:

  Results = TecUtil.DataNodeGetNodesPerElem(NodeMapPtr)

  Input:
                  NodeMapPtr           opaque pointer
  Output:
    Results[0]    ReturnVal            int

void TecUtilDataNodeGetRawPtr ( EntIndex_t  Zone,
NodeMap_t **  NodeMapPtr 
)

Deprecated:
Please use TecUtilDataNodeGetReadableRef() or TecUtilDataNodeGetWritableRef() in conjunction with TecUtilDataNodeArrayGetByRef() or TecUtilDataNodeArraySetByRef() or else use TecUtilDataNodeGetReadableRawPtr() or TecUtilDataNodeGetWritableRawPtr() instead. Calling TecUtilDataNodeGetRawPtr() is equivalent to calling TecUtilDataNodeGetWritableRef() and the acquiring the raw data pointer.

Python Syntax:

    This function is not supported in Python.

NodeMap_pa TecUtilDataNodeGetRef ( EntIndex_t  Zone  ) 

Deprecated:
Please use TecUtilDataNodeGetReadableRef() or TecUtilDataNodeGetWritableRef() instead. Calling TecUtilDataNodeGetRef() is equivalent to calling TecUtilDataNodeGetWritableRef().

Python Syntax:

  Results = TecUtil.DataNodeGetRef(Zone)

  Input:
                  Zone                 int
  Output:
    Results[0]    ReturnVal            opaque pointer

void TecUtilDataNodeSetByRef ( NodeMap_pa  NM,
LgIndex_t  Element,
LgIndex_t  Corner,
NodeMap_t  Node 
)

Set the node index for a particular corner of a finite-element.

To use this function you must have already obtained the handle to the node map.

This function is Thread Safe.

Note:
Unless this call is in response to a custom load-on-demand callback be sure to issue a state change StateChange_NodeMapsAltered before returning control to Tecplot.
Parameters:
NM Handle to the connectivity list (that is, the node map). Use TecUtilDataNodeGetReadableRef() or TecUtilDataNodeGetWritableRef() to get a handle to the node map.
Element The element number (starts at 1)
Corner The element corner (starts at 1).
Node The new node index for that element at that corner
Precondition:
NM Pointer must be a valid address and non-NULL.
Fortran Syntax:
    SUBROUTINE TecUtilDataNodeSetByRef(
   &           NMPtr,
   &           Element,
   &           Corner,
   &           Node)
    POINTER         (NMPtr, NM)
    INTEGER*4       Element
    INTEGER*4       Corner
    INTEGER*4       Node

Python Syntax:

  Results = TecUtil.DataNodeSetByRef(NM, Element, Corner, Node)

  Input:
                  NM                   opaque pointer
                  Element              int
                  Corner               int
                  Node                 int
  Output:
    Results[0]    ReturnVal            NONE

Set the first two nodes of the 43rd element of zone 5 to be 127 and 128 respectively:

   Set_pa altered_zones;
   NodeMap_pa nm;
   nm = TecUtilDataNodeGetWritableRef(5);
   if ( nm )
     {
       TecUtilDataNodeSetByRef(nm, 43, 1, 127);
       TecUtilDataNodeSetByRef(nm, 43, 2, 128);
       // inform Tecplot of node map change
       altered_zones = TecUtilSetAlloc(TRUE);
       TecUtilSetAddMember(altered_zones, 5, TRUE);
       TecUtilStateChanged(StateChange_NodeMapsAltered,
                           (ArbParam_t)altered_zones);
       TecUtilSetDealloc(&altered_zones);
   }

void TecUtilDataNodeSetByZone ( EntIndex_t  Zone,
LgIndex_t  Element,
LgIndex_t  Corner,
NodeMap_t  Node 
)

Set the node index for a particular corner of a finite-element.

This function does not require you to obtain the handle to the node map as does TecUtilDataNodeArraySetByRef() or TecUtilDataNodeSetByRef(), however, this function is not very efficient. Use TecUtilDataNodeArraySetByRef() or TecUtilDataNodeSetByRef() if you are setting multiple nodes for the same zone. You do not need to call TecUtilStateChanged() after calling this function as Tecplot does that for you.

Parameters:
Zone Zone number.
Element The element number (starts at 1).
Corner The element corner (starts at 1).
Node The new node index for that element at that corner.
Precondition:
Must have one or more frames.

Current frame must have a data set with at least one zone.

Fortran Syntax:
    SUBROUTINE TecUtilDataNodeSetByZone(
   &           Zone,
   &           Element,
   &           Corner,
   &           Node)
    INTEGER*4       Zone
    INTEGER*4       Element
    INTEGER*4       Corner
    INTEGER*4       Node

Python Syntax:

  Results = TecUtil.DataNodeSetByZone(Zone, Element, Corner, Node)

  Input:
                  Zone                 int
                  Element              int
                  Corner               int
                  Node                 int
  Output:
    Results[0]    ReturnVal            NONE

Set the third node of the 43rd element of zone 5 to be 129:

   TecUtilDataNodeSetByZone(5, 43, 3, 129);

Generated on Tue Mar 12 02:24:41 2013 for Tecplot by  doxygen 1.5.5