Data Services


Functions

Boolean_t TecUtilZoneDelete (Set_pa ZoneList)
 
Boolean_t TecUtilDataSetDeleteZone (Set_pa ZoneList)
  Deletes the specified set of zones.
Boolean_t TecUtilDataSetDeleteVar (Set_pa VarList)
  Deletes the specified set of variables.
Boolean_t TecUtilDataSetDefVarLoadFinish (Boolean_t IsDataSetOk)
 
Boolean_t TecUtiltDataSetDefVarLoadFinish (Boolean_t IsDataSetOk)
 
Boolean_t TecUtilDataSetAddZone (const char *Name, LgIndex_t IMax, LgIndex_t JMax, LgIndex_t KMax, ZoneType_e ZoneType, FieldDataType_e *VarDataType_Array)
  Add a zone to the data set attached to the current frame.
Boolean_t TecUtilDataSetAddZoneX (ArgList_pa ArgList)
  Add a zone to the current data set.
Boolean_t TecUtilDataSetAddVarX (ArgList_pa ArgList)
  Add a variable to the current data set.
Boolean_t TecUtilDataSetAddVar (const char *VarName, FieldDataType_e *FieldDataType_Array)
  Add a variable to the current data set.
Boolean_t TecUtilDataSetAddPostConvInstr (const char *AddOnIDString, const char *Instructions, const char *RawData)
 
Boolean_t TecUtilDataValueCanMemMapData (EntIndex_t Zone, EntIndex_t Var, MemMapOffset_t Offset, Boolean_t IsDataNativeByteOrder)
 
Boolean_t TecUtilDataValueMemMapData (EntIndex_t Zone, EntIndex_t Var, int FileDescriptor, MemMapOffset_t Offset, Boolean_t IsDataNativeByteOrder)
 
ArbParam_t TecUtilDataNodeGetClientData (NodeMap_pa NodeMap)
  Return the custom load-on-demand client data from a node map handle.
Boolean_t TecUtilDataNodeAutoLOD (EntIndex_t Zone, const char *FileName, FileOffset_t Offset, Boolean_t IsDataNativeByteOrder)
  Specifies where in the data file the data for the specified node map resides.
Boolean_t TecUtilDataNodeCustomLOD (EntIndex_t Zone, LoadOnDemandNodeMapLoad_pf LoadCallback, LoadOnDemandNodeMapUnload_pf UnloadCallback, LoadOnDemandNodeMapCleanup_pf CleanupCallback, ArbParam_t ClientData)
  Registers with Tecplot the load-on-demand callbacks and client data for a node mapping for a specific zone.
Boolean_t TecUtilDataNodeAlloc (EntIndex_t Zone)
  Allocates the space needed for the node mapping.
LgIndex_t TecUtilTecPolyX (ArgList_pa ArgList)
  Writes the face map for polygonal and polyhedral zones to the data file.
Boolean_t TecUtilDataSetLockOn (const char *LockString)
  Lock the data set attached to the current frame.
Boolean_t TecUtilDataSetLockOff (const char *LockString)
  Unlock the data set attached to the current frame.
void TecUtilDataValueGetRawPtr (EntIndex_t Zone, EntIndex_t Var, void **DataPtr, FieldDataType_e *FieldDataType)
 
void TecUtilDataNodeGetReadableRawPtr (EntIndex_t Zone, NodeMap_t **NodeMapPtr)
  Get a readable raw pointer to the finite-element node map of the specified zone in the data set attached to the current frame.
void TecUtilDataNodeGetWritableRawPtr (EntIndex_t Zone, NodeMap_t **NodeMapPtr)
  Get a writable raw pointer to the finite-element node map of the specified zone in the data set attached to the current frame.
void TecUtilDataFaceNbrGetRawPtr (EntIndex_t Zone, LgIndex_t **FNPtr)
 
Boolean_t TecUtilDataSetGetInfo (char **DataSetTitle, EntIndex_t *NumZones, EntIndex_t *NumVars)
  Get the title, number of zones, and number of variables of the data set attached to the current frame.
Boolean_t TecUtilDataSetRequiresSaving (void)
 
FieldData_pa TecUtilDataValueGetWritableRef (EntIndex_t Zone, EntIndex_t Var)
 
FieldData_pa TecUtilDataValueGetReadableRef (EntIndex_t Zone, EntIndex_t Var)
 
FieldData_pa TecUtilDataValueGetRef (EntIndex_t Zone, EntIndex_t Var)
 
NodeMap_pa TecUtilDataNodeGetReadableRef (EntIndex_t Zone)
  Get a readable finite-element node map handle to the specified zone in the data set attached to the current frame.
NodeMap_pa TecUtilDataNodeGetWritableRef (EntIndex_t Zone)
  Get a writable finite-element node map handle to the specified zone in the data set attached to the current frame.
LgIndex_t TecUtilDataFaceNbrGetByZone (EntIndex_t Zone, LgIndex_t Element, LgIndex_t Face)
 
LgIndex_t TecUtilDataFaceNbrGetByRef (FaceNeighbor_pa FaceNeighbor, LgIndex_t Element, LgIndex_t Face)
 
ArbParam_t TecUtilDataFaceNbrGetClientData (FaceNeighbor_pa FaceNeighbor)
  Return the custom load-on-demand client data from a face neighbor handle.
Boolean_t TecUtilDataFaceNbrCustomLOD (EntIndex_t Zone, Boolean_t AutoAssignFN, LoadOnDemandFaceNeighborLoad_pf LoadCallback, LoadOnDemandFaceNeighborUnload_pf UnloadCallback, LoadOnDemandFaceNeighborCleanup_pf CleanupCallback, ArbParam_t ClientData)
  Registers with Tecplot the load-on-demand callbacks and client data for the face neighbors for a specific zone.
FaceNeighbor_pa TecUtilDataFaceNbrGetReadableRef (EntIndex_t Zone)
  Get a readable face neighbor handle to the specified zone in the data set attached to the current frame.
void TecUtilDataFaceNbrAssignArrayByRef (FaceNeighbor_pa FaceNeighbor, LgIndex_t DestOffset, LgIndex_t NumNeighbors, const LgIndex_t *NeighborElems)
  Copies the specified number of local one-to-one cell face neighbors from the base of the neighbor element array to the currently open face neighbor assignment sequence starting at the specified destination offset.
Boolean_t TecUtilDataFaceNbrAssignByRef (FaceNeighbor_pa FaceNeighbor, LgIndex_t Element, LgIndex_t Face, Boolean_t NbrsCompObscure, LgIndex_t NumNeighbors, const LgIndex_t *NeighborElems, const EntIndex_t *NeighborZones)
  Sets the boundary connection face neighbors within an open face neighbor assignment sequence for the specified element and face.
NodeToElemMap_pa TecUtilDataNodeToElemMapGetReadableRef (EntIndex_t Zone)
  Gets a readable node-to-element mapping for the specified finite element zone of the current frame.
LgIndex_t TecUtilDataNodeToElemMapGetNumElems (NodeToElemMap_pa NodeToElemMap, LgIndex_t Node)
  Gets the number of elements that are connected to the specified node.
LgIndex_t TecUtilDataNodeToElemMapGetElem (NodeToElemMap_pa NodeToElemMap, LgIndex_t Node, LgIndex_t ElemOffset)
  Gets an element that is connected to the specified node.
SetValueReturnCode_e TecUtilZoneSetBoundary (const char *Attribute, Set_pa ZoneSet, double DValue, ArbParam_t IValue)
 
SetValueReturnCode_e TecUtilZoneSetIJKMode (const char *Attribute, const char *SubAttribute, Set_pa ZoneSet, ArbParam_t IValue)
 
Boolean_t TecUtilDataSetAutoAssignStrandIDs (Set_pa ZoneSet)
  Auto assign strand IDs for the specified set of zones.

Function Documentation

void TecUtilDataFaceNbrAssignArrayByRef ( FaceNeighbor_pa  FaceNeighbor,
LgIndex_t  DestOffset,
LgIndex_t  NumNeighbors,
const LgIndex_t *  NeighborElems 
)

Copies the specified number of local one-to-one cell face neighbors from the base of the neighbor element array to the currently open face neighbor assignment sequence starting at the specified destination offset.

The face neighbor element array should be organized as follows: E1F1 E1F2 ... E1Fm E2F1 E2F2 ... EnFm where n is the number of elements and m is the number of faces per element. In the above layout E1F1 is the neighboring element of element 1 face 1. This function is Thread Safe.

Note:
If TecUtilDataFaceNbrAssignArrayByRef() is used in conjunction with TecUtilDataFaceNbrAssignByRef() then the local one-to-one face neighbors must be delivered via TecUtilDataFaceNbrAssignArrayByRef() before delivering discrete boundary connection face neighbors via TecUtilDataFaceNbrAssignByRef().
Since:
11.3-0-020
Parameters:
FaceNeighbor Face neighbor handle that was passed to a custom face neighbor load callback.
DestOffset Offset in Tecplot's face neighbor array to begin assigning the supplied neighbor elements.
NumNeighbors Number of neighbor elements to assign to Tecplot's face neighbor array.
NeighborElems An array containing the one based cell face neighbor elements to copy. The first element is assumed to be at the base of the array.
Precondition:
Current frame must have a data set with at least one zone.

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

Python Syntax:
  Results = TecUtil.DataFaceNbrAssignArrayByRef(FaceNeighbor, DestOffset, NumNeighbors, NeighborElems)

  Input:
                  FaceNeighbor         opaque pointer
                  DestOffset           int
                  NumNeighbors         int
                  NeighborElems        list of ints
  Output:
    Results[0]    ReturnVal            NONE

Boolean_t TecUtilDataFaceNbrAssignByRef ( FaceNeighbor_pa  FaceNeighbor,
LgIndex_t  Element,
LgIndex_t  Face,
Boolean_t  NbrsCompObscure,
LgIndex_t  NumNeighbors,
const LgIndex_t *  NeighborElems,
const EntIndex_t *  NeighborZones 
)

Sets the boundary connection face neighbors within an open face neighbor assignment sequence for the specified element and face.

This function is Thread Safe.

Parameters:
FaceNeighbor Face neighbor handle that was passed to a custom face neighbor load callback.
Element The one based element number (starts at one).
Face The one based face for which the face neighbor information is desired.
NbrsCompObscure Set to TRUE if the supplied neighbors completely obscure the face.
NumNeighbors Number of neighbors for this face.
NeighborElems Array containing the one based element numbers of the neighbors.
NeighborZones Array containing the one based zone numbers of the neighbors for global neighbors or NULL for local neighbors.
Returns:
TRUE if successful in assigning to the open face neighbor assignment sequence, FALSE otherwise.
Precondition:
Current frame must have a data set with at least one zone.

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

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

Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilDataFaceNbrAssignByRef(
   &                   FaceNeighborPtr,
   &                   Element,
   &                   Face,
   &                   NbrsCompObscure,
   &                   NumNeighbors,
   &                   NeighborElems,
   &                   NeighborZones)
    POINTER         (FaceNeighborPtr, FaceNeighbor)
    INTEGER*4       Element
    INTEGER*4       Face
    INTEGER*4       NbrsCompObscure
    INTEGER*4       NumNeighbors
    INTEGER*4       NeighborElems
    INTEGER*4       NeighborZones

Python Syntax:

  Results = TecUtil.DataFaceNbrAssignByRef(FaceNeighbor, Element, Face, NbrsCompObscure, NumNeighbors, NeighborElems, NeighborZones)

  Input:
                  FaceNeighbor         opaque pointer
                  Element              int
                  Face                 int
                  NbrsCompObscure      boolean
                  NumNeighbors         int
                  NeighborElems        list of ints
                  NeighborZones        list of ints
  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilDataFaceNbrCustomLOD ( EntIndex_t  Zone,
Boolean_t  AutoAssignFN,
LoadOnDemandFaceNeighborLoad_pf  LoadCallback,
LoadOnDemandFaceNeighborUnload_pf  UnloadCallback,
LoadOnDemandFaceNeighborCleanup_pf  CleanupCallback,
ArbParam_t  ClientData 
)

Registers with Tecplot the load-on-demand callbacks and client data for the face neighbors for a specific zone.

Tecplot will notify the add-on via the callbacks when the face neighbors need to be loaded, unloaded, and cleaned up.

All callbacks must be written in a thread-safe manner so that Tecplot can make concurrent requests to load (and/or unload) multiple zone's face neighbors. The easiest way to write thread-safe callbacks is not to use any shared state (i.e. global or static state) in order to perform the requested action but instead to use private client data to maintain all the information needed to perform the requested action.

Calls made back to Tecplot in response to a load, unload, or cleanup request should be limited to queries except in the case where data is being loaded into a face neighbor. In addition, no state changes should be broadcast by the callbacks.

This function is used in conjunction with deferred variable creation. See the SV_DEFERFACENBRCREATION option for TecUtilDataSetAddZoneX()for details.

The method for loading and accessing face neighbor data with custom load-on-demand is similar to custom load-on-demand for field data (see ADK Users Manual for details): The add-on supplied LoadCallback() callback is responsible for loading the entire face neighbor data into the Tecplot prepared face neighbor backing. Tecplot is responsible for allocating and freeing the space for the face neighbor backing. In addition, the add-on must supply the CleanupCallback() callback to receive notification of when the face neighbor is no longer needed. Optionally, the add-on may supply the UnloadCallback() callback to receive notification of when the face neighbor is being unloaded. Most add-ons should supply NULL for the UnloadCallback() callback, instructing Tecplot to assume responsibility for unloading the face neighbor and re-loading it in an efficient form. This function is Thread Safe.

Since:
11.3-0-020
Parameters:
Zone Zone for which the face neighbor will now be custom load-on-demand.
AutoAssignFN Indicates if Tecplot should auto assign any remaining face neighbors after the add-on has supplied the boundary connection face neighbors. This is useful when an add-on only needs to deliver a few specific neighbors. See TecUtilDataFaceNbrAssignArrayByRef() and TecUtilDataFaceNbrAssignByRef() for details. Add-ons that wish to supply all the face neighbor connections should set this value to FALSE.
LoadCallback Tecplot calls this callback when the face neighbor is to be loaded. The LoadCallback() callback may never get called if the face neighbor is not needed or it may get called immediately if load-on-demand capabilities are not available. This callback is called asynchronously.
UnloadCallback Add-ons can supply NULL for this callback. Supplying NULL instructs Tecplot to handle the unloading (and subsequent reloading) of the face neighbor without the intervention of the add-on, however Tecplot will be forced to write the data to its temporary directory when unloaded thereby incurring additional I/O expense. If the add-on does supply this callback, Tecplot calls it when the face neighbor is to be unloaded. This query provides the add-on an opportunity to allow or deny a face neighbor to be unloaded by returning TRUE or FALSE respectively. Unless there is a compelling reason, such as very expensive load costs (in which case NULL should probably be supplied for this callback), the add-on should honor Tecplot's request to unload the face neighbor (i.e. the UnloadCallback() callback should return TRUE). An add-on may also cleanup any private resources that are not needed when the face neighbor is unloaded, however the add-on must still maintain enough information to load the face neighbor again if requested by Tecplot. The UnloadCallback() callback may never get called if the face neighbor does not need to be unloaded nor will the UnloadCallback() callback necessarily be called before the CleanupCallback() callback. This callback is called asynchronously.
CleanupCallback Tecplot calls this callback when the face neighbor is to be cleaned up. This allows the add-on to cleanup any private resources that were used in conjunction with identifying or loading this face neighbor. After a face neighbor is cleaned up Tecplot will never again request it to be loaded. Tecplot may or may not call the UnloadCallback() callback before calling the CleanupCallback() callback. Additionally, the CleanupCallback() callback will be called even if the face neighbor was never loaded. This callback is called asynchronously.
ClientData Private client data needed by the custom load-on-demand callbacks to perform the duties of loading, unloading, and cleaning up the face neighbor. Tecplot stores the client data in the face neighbor structure and must be retrieved by the callbacks using TecUtilDataFaceNbrGetClientData(). The client data should ONLY be retrieved in response to a custom load, unload, or cleanup callback. At no other time is the request valid.
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.

Following is an example of how to create a face neighbor using the Custom Load on Demand. 
   typedef struct
     {
       char* DataFileName;
       long  SeekOffset;
       ... other information needed to load face neighbor data
     } MyFaceNbrClientData_s;

   Boolean_t MyFaceNbrLoader(FaceNeighbor_pa FaceNeighbor)
   {
     REQUIRE(VALID_REF(FaceNeighbor));

     MyFaceNbrClientData_s *MyClientData = (MyFaceNbrClientData_s *)TecUtilDataFaceNbrGetClientData(FaceNeighbor);

     // open the data file
     FILE *MyDataFile = fopen(MyClientData->DataFileName, "rb");
     Boolean_t IsOk = (MyDataFile != NULL);

     // seek to the place in the file where the face neighbor data is located
     IsOk = IsOk && (fseek(MyDataFile, MyClientData->SeekOffset, SEEK_SET) == 0);
     if (IsOk)
       {
         // load the data into the zone's face neighbor
         IsOk = ReadMyFaceNbrDataIntoZone(MyDataFile,
                                          MyClientData,
                                          FaceNeighbor);
       }

     // cleanup
     if (MyDataFile != NULL)
       fclose(MyDataFile);

     ENSURE(VALID_BOOLEAN(IsOk));
     return IsOk;
   }

   Boolean_t MyFaceNbrUnload(FaceNeighbor_pa FaceNeighbor)
   {
     REQUIRE(VALID_REF(FaceNeighbor));

     // We don't have any private data to cleanup (i.e. in addition to the
     // private client data which we don't cleanup here) so all we have to do
     // is return TRUE or FALSE letting Tecplot know that it can or can not
     // unload the face neighbor.
     Boolean_t Result = TRUE; // ...tell Tecplot to go ahead and unload the face neighbor

     ENSURE(VALID_BOOLEAN(Result));
     return Result;
   }

   void MyFaceNbrCleanup(FaceNeighbor_pa FaceNeighbor)
   {
     REQUIRE(VALID_REF(FaceNeighbor));

     MyFaceNbrClientData_s *MyClientData = (MyFaceNbrClientData_s *)TecUtilDataFaceNbrGetClientData(FaceNeighbor);

     // cleanup privately allocated resources
     free(MyClientData->DataFileName);
     free(MyClientData);
   }

   .
   .
   .
   MyFaceNbrClientData_s *MyClientData = (MyFaceNbrClientData_s *)malloc(sizeof(MyFaceNbrClientData_s));
   const char *MyDataFileName = "MyDataFileName.dat";
   MyClientData->MyDataFileName = (char *)malloc(strlen(MyDataFileName)+1);
   strcpy(MyClientData->MyDataFileName, MyDataFileName);
   MyClientData->SeekOffset = ... determined somewhere else
   ...initialize any other client data information needed to load face neighbor data
   IsOk = TecUtilDataFaceNbrCustomLOD(3,
                                      TRUE,            // AutoAssignFN
                                      MyFaceNbrLoader,
                                      MyFaceNbrUnload, // most add-ons should pass NULL instead of MyFaceNbrUnload
                                      MyFaceNbrCleanup,
                                      (ArbParam_t)MyClientData);

Python Syntax:

    This function is not supported in Python.

See also:
TecUtilDataConnectShare(), TecUtilDataFaceNbrAssignArrayByRef(), TecUtilDataFaceNbrAssignByRef(), TecUtilMemoryChangeNotify()

LgIndex_t TecUtilDataFaceNbrGetByRef ( FaceNeighbor_pa  FaceNeighbor,
LgIndex_t  Element,
LgIndex_t  Face 
)

Deprecated:
Please use TecUtilDataFaceNbrGetNbrByRef() instead.

Python Syntax:

  Results = TecUtil.DataFaceNbrGetByRef(FaceNeighbor, Element, Face)

  Input:
                  FaceNeighbor         opaque pointer
                  Element              int
                  Face                 int
  Output:
    Results[0]    ReturnVal            int

LgIndex_t TecUtilDataFaceNbrGetByZone ( EntIndex_t  Zone,
LgIndex_t  Element,
LgIndex_t  Face 
)

Deprecated:
Please use TecUtilDataFaceNbrGetNbrByRef() instead.

Python Syntax:

  Results = TecUtil.DataFaceNbrGetByZone(Zone, Element, Face)

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

ArbParam_t TecUtilDataFaceNbrGetClientData ( FaceNeighbor_pa  FaceNeighbor  ) 

Return the custom load-on-demand client data from a face neighbor handle.

The client data should ONLY be retrieved in response to a custom load, unload, or cleanup callback. At no other time is the request valid. This function is Thread Safe.

Parameters:
FaceNeighbor Custom load-on-demand face neighbor handle.
Returns:
Client data for the custom load-on-demand add-on.
Python Syntax:
    This function is not supported in Python.


     Boolean_t MyFaceNbrLoader(FaceNeighbor_pa FaceNeighbor)
     {
       Boolean_t Result;
       MyClientData_s *MyClientData = (MyClientData_s *)TecUtilDataFaceNbrGetClientData(FaceNeighbor);

       // load the custom face neighbor using client data
       .
       .
       .

     return Result;
   }

See also:
TecUtilDataFaceNbrCustomLOD()

void TecUtilDataFaceNbrGetRawPtr ( EntIndex_t  Zone,
LgIndex_t **  FNPtr 
)

Deprecated:
There is no replacement for this function. Please do not access face neighbors using raw pointers, use TecUtilDataFaceNbrGetReadableRef() instead.

Python Syntax:

    This function is not supported in Python.

FaceNeighbor_pa TecUtilDataFaceNbrGetReadableRef ( EntIndex_t  Zone  ) 

Get a readable face neighbor handle to the specified zone in the data set attached to the current frame.

This function is Thread Safe.

Parameters:
Zone Number of the zone for which to get the readable face neighbor handle.
Returns:
The face neighbor handle to the specified zone in the data set attached to the current frame or NULL if it was not able to load it.
Precondition:
Must have one or more frames.

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

Fortran Syntax:
    SUBROUTINE TecUtilDataFaceNbrGetReadableRef(
   &           Zone,
   &           ResultPtr)
    INTEGER*4       Zone
    POINTER         (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.DataFaceNbrGetReadableRef(Zone)

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

Boolean_t TecUtilDataNodeAlloc ( EntIndex_t  Zone  ) 

Allocates the space needed for the node mapping.

This function is used in conjunction with deferred node map creation. See the SV_DEFERNODEMAPCREATION option for TecUtilDataSetAddZoneX() for details.

Since:
11.3-0-010
Parameters:
Zone The zone needing the node mapping allocated.
Returns:
TRUE if the node mapping was successfully allocated, FALSE otherwise.
Precondition:
Must have one or more frames.

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

Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilDataNodeAlloc(
   &                   Zone)
    INTEGER*4       Zone

Python Syntax:

  Results = TecUtil.DataNodeAlloc(Zone)

  Input:
                  Zone                 int
  Output:
    Results[0]    ReturnVal            boolean

Allocate the node map of zone 3.

   IsOk = TecUtilDataNodeAlloc(3);

See also:
TecUtilDataConnectShare(), TecUtilDataNodeCustomLOD()

Boolean_t TecUtilDataNodeAutoLOD ( EntIndex_t  Zone,
const char *  FileName,
FileOffset_t  Offset,
Boolean_t  IsDataNativeByteOrder 
)

Specifies where in the data file the data for the specified node map resides.

The node map must be laid out in memory exactly as expected by Tecplot where zero based node numbers for each element are specified consecutively. Using this information Tecplot will automatically load and unload the node map when Tecplot deems it necessary. It is the responsibility of the add-on to ensure that the file remains present and unaltered while Tecplot maintains a reference to this file as Tecplot may unload and subsequently reload the node map at unspecified times.

This function is used in conjunction with deferred variable creation. See the SV_DEFERNODEMAPCREATION option for TecUtilDataSetAddZoneX() for details.

Since:
11.3-0-010
Parameters:
Zone The zone number of the node map to have Tecplot automatically load on demand.
FileName Data file name containing the node map data laid out using Tecplot's binary data format.
Offset Absolute offset to the start of the node map data in the file.
IsDataNativeByteOrder Indicates if the byte ordering of the data in the file matches the machine's native byte ordering.
Returns:
TRUE if the node map is setup for auto loading, FALSE otherwise.
Precondition:
Must have one or more frames.

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

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

See also:
TecUtilDataNodeCustomLOD()
Python Syntax:
  Results = TecUtil.DataNodeAutoLOD(Zone, FileName, Offset, IsDataNativeByteOrder)

  Input:
                  Zone                 int
                  FileName             string
                  Offset               long
                  IsDataNativeByteOrder boolean
  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilDataNodeCustomLOD ( EntIndex_t  Zone,
LoadOnDemandNodeMapLoad_pf  LoadCallback,
LoadOnDemandNodeMapUnload_pf  UnloadCallback,
LoadOnDemandNodeMapCleanup_pf  CleanupCallback,
ArbParam_t  ClientData 
)

Registers with Tecplot the load-on-demand callbacks and client data for a node mapping for a specific zone.

Tecplot will notify the add-on via the callbacks when the node mapping needs to be loaded, unloaded, and cleaned up.

All callbacks must be written in a thread-safe manner so that Tecplot can make concurrent requests to load (and/or unload) multiple node mappings. The easiest way to write thread-safe callbacks is not to use any shared state (i.e. global or static state) in order to perform the requested action but instead to use private client data to maintain all the information needed to perform the requested action.

Calls made back to Tecplot in response to a load, unload, or cleanup request should be limited to queries except in the case where data is being loaded into a node mapping. In addition, no state changes should be broadcast by the callbacks.

This function is used in conjunction with deferred variable creation. See the SV_DEFERNODEMAPCREATION option for TecUtilDataSetAddZoneX()for details.

The method for loading and accessing node map data with custom load-on-demand is similar to custom load-on-demand for field data (see ADK Users Manual for details): The add-on supplied LoadCallback() callback is responsible for loading the entire node map data into the Tecplot prepared node map backing. Tecplot is responsible for allocating and freeing the space for the node map backing. In addition, the add-on must supply the CleanupCallback() callback to receive notification of when the node map is no longer needed. Optionally, the add-on may supply the UnloadCallback() callback to receive notification of when the node map is being unloaded. Most add-ons should supply NULL for the UnloadCallback() callback, instructing Tecplot to assume responsibility for unloading the node map and re-loading it in an efficient form.

Since:
11.3-0-010
Parameters:
Zone Zone for which the node map will now be custom load-on-demand.
LoadCallback Tecplot calls this callback when the node map is to be loaded. The LoadCallback() callback may never get called if the node map is not needed or it may get called immediately if load-on-demand capabilities are not available. This callback is called asynchronously.
UnloadCallback Add-ons can supply NULL for this callback. Supplying NULL instructs Tecplot to handle the unloading (and subsequent reloading) of the node map without the intervention of the add-on, however Tecplot will be forced to write the data to its temporary directory when unloaded thereby incurring additional I/O expense. If the add-on does supply this callback, Tecplot calls it when the node map is to be unloaded. This query provides the add-on an opportunity to allow or deny a node map to be unloaded by returning TRUE or FALSE respectively. Unless there is a compelling reason, such as very expensive load costs (in which case NULL should probably be supplied for this callback), the add-on should honor Tecplot's request to unload the node map (i.e. the UnloadCallback() callback should return TRUE). An add-on may also cleanup any private resources that are not needed when the node map is unloaded, however the add-on must still maintain enough information to load the node map again if requested by Tecplot. The UnloadCallback() callback may never get called if the node map does not need to be unloaded nor will the UnloadCallback() callback necessarily be called before the CleanupCallback() callback. This callback is called asynchronously.
CleanupCallback Tecplot calls this callback when the node map is to be cleaned up. This allows the add-on to cleanup any private resources that were used in conjunction with identifying or loading this node map. After a node map is cleaned up Tecplot will never again request it to be loaded. Tecplot may or may not call the UnloadCallback() callback before calling the CleanupCallback() callback. Additionally, the CleanupCallback() callback will be called even if the node map was never loaded. This callback is called asynchronously.
ClientData Private client data needed by the custom load-on-demand callbacks to perform the duties of loading, unloading, and cleaning up the node map. Tecplot stores the client data in the node map structure and must be retrieved by the callbacks using TecUtilDataNodeGetClientData(). The client data should ONLY be retrieved in response to a custom load, unload, or cleanup callback. At no other time is the request valid.
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.

Following is an example of how to create a node map using the Custom Load on Demand. 
   typedef struct
     {
       char* DataFileName;
       long  SeekOffset;
       ... other information needed to load node map data
     } MyNodeMapClientData_s;

   Boolean_t MyNodeMapLoader(NodeMap_pa NodeMap)
   {
     REQUIRE(VALID_REF(NodeMap));

     MyNodeMapClientData_s *MyClientData = (MyNodeMapClientData_s *)TecUtilDataNodeGetClientData(NodeMap);

     // open the data file
     FILE *MyDataFile = fopen(MyClientData->DataFileName, "rb");
     Boolean_t IsOk = (MyDataFile != NULL);

     // seek to the place in the file where the node map data is located
     IsOk = IsOk && (fseek(MyDataFile, MyClientData->SeekOffset, SEEK_SET) == 0);
     if (IsOk)
       {
         // load the data into the zone's node map
         IsOk = ReadMyNodeMapDataIntoZone(MyDataFile, MyClientData, NodeMap);
       }

     // cleanup
     if (MyDataFile != NULL)
       fclose(MyDataFile);

     ENSURE(VALID_BOOLEAN(IsOk));
     return IsOk;
   }

   Boolean_t MyNodeMapUnload(NodeMap_pa NodeMap)
   {
     REQUIRE(VALID_REF(NodeMap));

     // We don't have any private data to cleanup (i.e. in addition to the
     // private client data which we don't cleanup here) so all we have to do
     // is return TRUE or FALSE letting Tecplot know that it can or can not
     // unload the node map.
     Boolean_t Result = TRUE; // ...tell Tecplot to go ahead and unload the node map

     ENSURE(VALID_BOOLEAN(Result));
     return Result;
   }

   void MyNodeMapCleanup(NodeMap_pa NodeMap)
   {
     REQUIRE(VALID_REF(NodeMap));

     MyNodeMapClientData_s *MyClientData = (MyNodeMapClientData_s *)TecUtilDataNodeGetClientData(NodeMap);

     // cleanup privately allocated resources
     free(MyClientData->DataFileName);
     free(MyClientData);
   }

   .
   .
   .
   MyNodeMapClientData_s *MyClientData = (MyNodeMapClientData_s *)malloc(sizeof(MyNodeMapClientData_s));
   const char *MyDataFileName = "MyDataFileName.dat";
   MyClientData->MyDataFileName = (char *)malloc(strlen(MyDataFileName)+1);
   strcpy(MyClientData->MyDataFileName, MyDataFileName);
   MyClientData->SeekOffset = ... determined somewhere else
   ...initialize any other client data information needed to load node map data
   IsOk = TecUtilDataNodeCustomLOD(3,
                                   MyNodeMapLoader,
                                   MyNodeMapUnload, // most add-ons should pass NULL instead of MyNodeMapUnload
                                   MyNodeMapCleanup,
                                   (ArbParam_t)MyClientData);

Python Syntax:

    This function is not supported in Python.

See also:
TecUtilDataNodeAlloc(), TecUtilDataConnectShare(), TecUtilDataNodeArraySetByRef(), TecUtilMemoryChangeNotify()

ArbParam_t TecUtilDataNodeGetClientData ( NodeMap_pa  NodeMap  ) 

Return the custom load-on-demand client data from a node map handle.

The client data should ONLY be retrieved in response to a custom load, unload, or cleanup callback. At no other time is the request valid. This function is Thread Safe.

Parameters:
NodeMap Custom load-on-demand node map handle.
Returns:
Client data for the custom load-on-demand add-on.
Python Syntax:
    This function is not supported in Python.


     Boolean_t MyNodeMapLoader(NodeMap_pa NodeMap)
     {
       Boolean_t Result;
       MyClientData_s *MyClientData = (MyClientData_s *)TecUtilDataNodeGetClientData(NodeMap);

       // load the custom node map using client data
       .
       .
       .

     return Result;
   }

See also:
TecUtilDataNodeCustomLOD()

void TecUtilDataNodeGetReadableRawPtr ( EntIndex_t  Zone,
NodeMap_t **  NodeMapPtr 
)

Get a readable raw pointer to the finite-element node map of the specified zone in the data set attached to the current frame.

This function is Thread Safe.

Since:
12.0-1-5410
Note:
The array is read-only thefore be sure not to change any value. Do not assume that raw data internal to Tecplot remains in the same location at all times. Always call this function again after any event where Tecplot itself may move/alter the raw data.
Parameters:
Zone Number of the zone for which to get the readable raw node map pointer. This must be a finite-element zone
NodeMapPtr Receives the address of the raw node map. May return NULL if the type is too complex. If the type is too complex, you may use TecUtilDataNodeGetReadableRef() in conjunction with TecUtilDataNodeGetByRef().
Precondition:
Must have one or more frames.

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

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

Fortran Syntax:
    SUBROUTINE TecUtilDataNodeGetReadableRawPtr(
   &           Zone,
   &           ResultPtr)
    INTEGER*4       Zone
    POINTER         (ResultPtr, Result)

Python Syntax:

    This function is not supported in Python.

NodeMap_pa TecUtilDataNodeGetReadableRef ( EntIndex_t  Zone  ) 

Get a readable finite-element node map handle to the specified zone in the data set attached to the current frame.

This function is Thread Safe.

Parameters:
Zone Number of the zone for which to get the readable node map handle. This must be a finite-element zone
Returns:
The finite-element node map handle to the specified zone in the data set attached to the current frame or NULL if it was not able to load it.
Precondition:
Must have one or more frames.

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

Fortran Syntax:
    SUBROUTINE TecUtilDataNodeGetReadableRef(
   &           Zone,
   &           ResultPtr)
    INTEGER*4       Zone
    POINTER         (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.DataNodeGetReadableRef(Zone)

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

void TecUtilDataNodeGetWritableRawPtr ( EntIndex_t  Zone,
NodeMap_t **  NodeMapPtr 
)

Get a writable raw pointer to the finite-element node map of the specified zone in the data set attached to the current frame.

This function is Thread Safe.

Since:
12.0-1-5410
Parameters:
Zone Number of the zone for which to get the writable raw node map pointer. This must be a finite-element zone
NodeMapPtr Receives the address of the raw node map. May return NULL if the type is too complex. If the type is too complex, you may use TecUtilDataNodeGetWritableRef() in conjunction with TecUtilDataNodeGetByRef() or TecUtilDataNodeSetByRef().
Precondition:
Must have one or more frames.

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

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

Fortran Syntax:
    SUBROUTINE TecUtilDataNodeGetWritableRawPtr(
   &           Zone,
   &           ResultPtr)
    INTEGER*4       Zone
    POINTER         (ResultPtr, Result)

Python Syntax:

    This function is not supported in Python.

NodeMap_pa TecUtilDataNodeGetWritableRef ( EntIndex_t  Zone  ) 

Get a writable finite-element node map handle to the specified zone in the data set attached to the current frame.

This function is Thread Safe.

Parameters:
Zone Number of the zone for which to get the writable node map handle. This must be a finite-element zone
Returns:
The finite-element node map handle to the specified zone in the data set attached to the current frame or NULL if it was not able to load it and create a writable copy.
Precondition:
Must have one or more frames.

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

Fortran Syntax:
    SUBROUTINE TecUtilDataNodeGetWritableRef(
   &           Zone,
   &           ResultPtr)
    INTEGER*4       Zone
    POINTER         (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.DataNodeGetWritableRef(Zone)

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

LgIndex_t TecUtilDataNodeToElemMapGetElem ( NodeToElemMap_pa  NodeToElemMap,
LgIndex_t  Node,
LgIndex_t  ElemOffset 
)

Gets an element that is connected to the specified node.

This function is Thread Safe.

Since:
12.0.1.5894
Parameters:
NodeToElemMap The node-to-element map handle.
Node The node for which the connected element is desired.
ElemOffset The element offset of the desired node element. Must be in the range [1, n], where n is the number of elements returned by TecUtilDataNodeToElemMapGetNumElems() for the specified node.
Returns:
The element connected to the specified node.
Precondition:
NodeToElemMap Pointer must be a valid address and non-NULL.
Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilDataNodeToElemMapGetElem (
   &           NodeToElemMapPtr,
   &           Node,
   &           ElemOffset)
    POINTER   (NodeToElemMapPtr, NodeToElemMap)
    INTEGER*4 Node
    INTEGER*4 ElemOffset

Python Syntax:

  Results = TecUtil.DataNodeToElemMapGetElem(NodeToElemMap, Node, ElemOffset)

  Input:
                  NodeToElemMap        opaque pointer
                  Node                 int
                  ElemOffset           int
  Output:
    Results[0]    ReturnVal            int

LgIndex_t TecUtilDataNodeToElemMapGetNumElems ( NodeToElemMap_pa  NodeToElemMap,
LgIndex_t  Node 
)

Gets the number of elements that are connected to the specified node.

This function is Thread Safe.

Since:
12.0.1.5894
Parameters:
NodeToElemMap The node-to-element map handle.
Node The node for which the connected elements are desired.
Returns:
The number of elements that are connected to the specified node.
Precondition:
NodeToElemMap Pointer must be a valid address and non-NULL.
Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilDataNodeToElemMapGetNumElems (
   &           NodeToElemMapPtr,
   &           Node)
    POINTER   (NodeToElemMapPtr, NodeToElemMap)
    INTEGER*4 Node

Python Syntax:

  Results = TecUtil.DataNodeToElemMapGetNumElems(NodeToElemMap, Node)

  Input:
                  NodeToElemMap        opaque pointer
                  Node                 int
  Output:
    Results[0]    ReturnVal            int

NodeToElemMap_pa TecUtilDataNodeToElemMapGetReadableRef ( EntIndex_t  Zone  ) 

Gets a readable node-to-element mapping for the specified finite element zone of the current frame.

This function is Thread Safe.

Since:
12.0.1.5894
Parameters:
Zone Finite element zone number.
Returns:
A readable node-to-element mapping for the specified finite element zone or NULL if unsuccessful.
Precondition:
Must have one or more frames.

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

Fortran Syntax:
    SUBROUTINE TecUtilDataNodeToElemMapGetReadableRef (
   &           Zone,
   &           NodeToElemMapPtr)
    INTEGER*4 Zone
    POINTER   (NodeToElemMapPtr, NodeToElemMap)

Python Syntax:

  Results = TecUtil.DataNodeToElemMapGetReadableRef(Zone)

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

Boolean_t TecUtilDataSetAddPostConvInstr ( const char *  AddOnIDString,
const char *  Instructions,
const char *  RawData 
)

Deprecated:
Please use TecUtilDataSetAddJournalCommand() instead.

Python Syntax:

  Results = TecUtil.DataSetAddPostConvInstr(AddOnIDString, Instructions, RawData)

  Input:
                  AddOnIDString        string
                  Instructions         string
                  RawData              string
  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilDataSetAddVar ( const char *  VarName,
FieldDataType_e *  FieldDataType_Array 
)

Add a variable to the current data set.

Call TecUtilStateChanged() after adding a variable. This function is superceded by TecUtilDataSetAddVarX().

Parameters:
VarName Name of the variable being added. The name will be trimmed of any leading or trailing whitespace and truncated to be no more than 128 characters in length.
FieldDataType_Array This is an array of the data types to use for each zone (i.e., it must be dimensioned by the number of zones). If you pass NULL, the data types of the variables in variable 1 of the existing data set are used. The possible choices are: FieldDataType_Float, FieldDataType_Double, FieldDataType_Int32, FieldDataType_Int16, FieldDataType_Byte, or FieldDataType_Bit.
Returns:
Returns TRUE if the variable was added successfully, otherwise FALSE.
Precondition:
Must have one or more frames.

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

FieldDataType_Array Pointer must be a valid address or NULL.

Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilDataSetAddVar(
   &                   VarName,
   &                   VarFieldDataType)
    CHARACTER*(*)   AddOnIDString
    INTEGER*4       VarFieldDataType(1)

Python Syntax:

  Results = TecUtil.DataSetAddVar(VarName, FieldDataType_Array)

  Input:
                  VarName              string
                  FieldDataType_Array  list of TecVals.FieldDataType_e constants
  Output:
    Results[0]    ReturnVal            boolean

Note:
VarFieldDataType is an INTEGER*4 array dimensioned by the number of zones.
Add a variable to the current data set:

   if ( TecUtilDataSetAddVar("New Variable", NULL) )
     {
       // New variable is always last variable.
       EntIndex_t newvar;
       TecUtilDataSetGetInfo(NULL, NULL, &newvar);
       // Fill new var with values for all zones.
       .
       .
       .
       // Inform Tecplot a variable has been added.
       TecUtilStateChanged(StateChange_VarsAdded,
                           (ArbParam_t)NULL);
     }

Boolean_t TecUtilDataSetAddVarX ( ArgList_pa  ArgList  ) 

Add a variable to the current data set.

Make sure and call TecUtilStateChanged() after adding variables. Note that all settings for variable properties apply ONLY to those specific variables created in the existing set of zones.

Parameters:
ArgList Set of Arglist entries. This is built using calls to TecUtilArgListAppendXXXX functions.

Arglist Values

SV_NAME
Type: char *
Arg Function: TecUtilArgListAppendString()
Required: Yes
Notes: Name of newly created variable. The name will be trimmed of any leading or trailing whitespace and truncated to be no more than 128 characters in length.

SV_VARDATATYPE
Type: FieldDataType_e *
Arg Function: TecUtilArgListAppendArray()
Default: NULL
Required: No
Notes: Array of FieldDataType_e dimensioned by the number of zones currently defined in the dataset where each member specifies type of data. If you set this to NULL then FieldData_Float is used if this is the first variable in the dataset otherwise the type from the first variable for each zone is used.

SV_VALUELOCATION
Type: ValueLocation_e *
Arg Function: TecUtilArgListAppendArray()
Default: NULL
Required: No
Notes: Array of ValueLocation_e dimensioned by the number of zones currently defined in the dataset where each member specifies the data value location. If NULL then ValueLocation_Nodal is used.

SV_TRYSHAREVARWITHALLZONES
Type: Boolean_t
Arg Function: TecUtilArgListAppendInt()
Default: FALSE
Required: No
Notes: A boolean property that instructs Tecplot to share the variable with all applicable zones in the dataset. This option is mutually exclusive with SV_DEFERVARCREATION. To use variable sharing with SV_DEFERVARCREATION you must use TecUtilDataValueShare().

SV_DEFERVARCREATION
Type: Boolean_t
Arg Function: TecUtilArgListAppendInt()
Default: FALSE
Required: No
Notes: Indicates if the creation of the variable should be deferred until the variable data is ready to be populated or shared. A data loader should allocate, share, auto or custom load the variable with TecUtilDataValueAlloc(), TecUtilDataValueShare(), TecUtilDataValueAutoLOD(), or TecUtilDataValueCustomLOD() before returning control to Tecplot. Any variables that have not been allocated, shared, auto or custom loaded will become passive variables. Passive variables always return zero for every point but do not participate in Tecplot's min/max calculations such as when Tecplot is choosing good contour levels based on the available data. This option is mutually exclusive with SV_VARSHAREZONELIST.


Returns:
TRUE if the variable was added, FALSE otherwise.
Precondition:
Must have one or more frames.

ArgList Argument list must be valid.

Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilDataSetAddVarX(ArgListPtr)
    POINTER (ArgListPtr, ArgList)

Python Syntax:

  Results = TecUtil.DataSetAddVarX(ArgList)

  Input:
                  ArgList              dictionary
  Output:
    Results[0]    ReturnVal            boolean

Add a variable called "newvar" to the dataset.

   ArgList_pa ArgList;
   FieldDataType_e *VarDataType;   // dimension by zone
   ValueLocation_e *ValueLocation; // dimension by zone

   TecUtilLockStart(AddOnID);

   ...

   //
   // Allocate and populate VarDataType and ValueLocation
   // with the appropriate value for each zone.

   ...

   // collect the function arguments
   ArgList = TecUtilArgListAlloc();
   TecUtilArgListAppendString(ArgList,
                              SV_NAME,
                              "newvar");
   TecUtilArgListAppendArray(ArgList,
                             SV_VARDATATYPE,
                             (void *)VarDataType);
   TecUtilArgListAppendArray(ArgList,
                             SV_VALUELOCATION,
                             (void *)ValueLocation);
   TecUtilArgListAppendInt(ArgList,
                           SV_SHAREVARWITHALLZONES,
                           FALSE);

   // add the variable for all zones in the dataset
   TecUtilDataSetAddVarX(ArgList);

   // cleanup
   TecUtilArgListDealloc(&ArgList);

   // Inform Tecplot that a variable was added

   VarsAdded = TecUtilSetAlloc(FALSE);
   if (VarsAdded)
     {
       EntIndex_t NumVars;
       TecUtilDataSetGetInfo((char **)NULL,
                             (EntIndex_t *)NULL,
                             &NumVars);
       TecUtilSetAddMember(VarsAdded,NumVars,FALSE);
       TecUtilStateChanged(StateChange_VarsAdded,
                           (ArbParam_t)VarsAdded);
       TecUtilSetDealloc(&VarsAdded);
     }

   ...

   // cleanup VarDataType and ValueLocation allocations

   TecUtilLockFinish(AddOnID);

See also:
TecUtilDataSetAddZoneX()

Boolean_t TecUtilDataSetAddZone ( const char *  Name,
LgIndex_t  IMax,
LgIndex_t  JMax,
LgIndex_t  KMax,
ZoneType_e  ZoneType,
FieldDataType_e *  VarDataType_Array 
)

Add a zone to the data set attached to the current frame.

This function call does not load any data into the zone. In the case of finite-element zones, this function also does not assign values to the connectivity list. This function only allocates space for the zone. Call TecUtilStateChanged() after adding a zone.

Parameters:
Name Name of the zone. The name will be trimmed of any leading or trailing whitespace and truncated to be no more than 128 characters in length.
IMax I-Dimension of the zone if ordered. If the zone is finite-element then IMax is the number of data points.
JMax J-Dimension of the zone if ordered. If the zone is finite-element then JMax is the total number of element.
KMax K-Dimension of the zone. If the zone is a finite-element polyhedral or polygon, KMax is the number of faces. KMax is not used for other finite-element zone types. If you do not know the number of faces for a finite-element zone, you may specify 0 for this parameter and later call TecUtilDataFaceMapAssignElemToNodeMap() inside a TecUtilDataFaceMapCustomLOD() callback to set this value and generate the zone's face map.
ZoneType The possible values are: ZoneType_Ordered, ZoneType_FETriangle, ZoneType_FEQuad, ZoneType_FETetra, ZoneType_FEBrick, ZoneType_FELineSeg, ZoneType_FEPolygon or ZoneType_FEPolyhedron For polytope zones you must subsequently give the face mapping a data backing by calling TecUtilDataFaceMapAlloc() or TecUtilDataConnectShare() or give it deferred load-on-demand status by calling TecUtilDataFaceMapCustomLOD().
VarDataType_Array This is an array of the data types to use for each variable. If you set this to NULL then the data types of the variables in zone 1 of the existing data set are used or FieldDataType_Float if this is the first zone. The possible values are: FieldDataType_Float, FieldDataType_Double, FieldDataType_Int32, FieldDataType_Int16, FieldDataType_Byte, or FieldDataType_Bit.
Returns:
Returns TRUE if the zone was successfully added, otherwise FALSE.
Add a 10 by 10 by 10 zone to the current data set:

Precondition:
Must have one or more frames.

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

VarDataType_Array Pointer must be a valid address or NULL.

Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilDataSetAddZone(
   &                   ZoneName,
   &                   IMax,
   &                   JMax,
   &                   KMax,
   &                   ZoneType,
   &                   VarFieldDataType)
    CHARACTER*(*)   AddOnIDString
    INTEGER*4       IMax
    INTEGER*4       JMax
    INTEGER*4       KMax
    INTEGER*4       ZoneType
    INTEGER*4       VarFieldDataType(1)

Python Syntax:

  Results = TecUtil.DataSetAddZone(Name, IMax, JMax, KMax, ZoneType, VarDataType_Array)

  Input:
                  Name                 string
                  IMax                 int
                  JMax                 int
                  KMax                 int
                  ZoneType             ZoneType_e  (defined in TecVals.py)
                  VarDataType_Array    list of TecVals.FieldDataType_e constants
  Output:
    Results[0]    ReturnVal            boolean

Note:
VarFieldDataType is an INTEGER*4 array dimensioned by the number of variables.
   if ( TecUtilDataSetAddZone("New Ordered Zone", 10, 10, 1,
                              ZoneType_Ordered, NULL) )
     {
       Set_pa zones_added = TecUtilSetAlloc(TRUE);
       // new zone is always last zone
       EntIndex_t newzone;
       TecUtilDataSetGetInfo(NULL, &newzone, NULL);
       // fill new zone with values for all variables
       .
       .
       .
       // inform Tecplot of new zone
       TecUtilSetAddMember(zones_added, newzone, TRUE);
       TecUtilStateChanged(StateChange_ZonesAdded,
                           (ArbParam_t)zones_added);
       TecUtilSetDealloc(&zones_added);
     }

Boolean_t TecUtilDataSetAddZoneX ( ArgList_pa  ArgList  ) 

Add a zone to the current data set.

This function was extended from TecUtilDataSetAddZone() to allow addition of zones in locations where zombie zones currently exist in a data set. For a simpler, less flexible interface use TecUtilDataSetAddZone() instead. Be sure to call TecUtilStateChanged() after adding zones. Note that all settings for variable properties apply ONLY to those specific variables in this newly created zone and do not apply to any other variables in other zones created in the future.

Parameters:
ArgList Set of Arglist entries. This is built using calls to TecUtilArgListAppendXXXX functions.

Arglist Values

SV_NAME
Type: char *
Arg Function: TecUtilArgListAppendString()
Required: Yes
Notes: The name of the zone to create. The name will be trimmed of any leading or trailing whitespace and truncated to be no more than 128 characters in length.

SV_PARENTZONE
Type: LgIndex_t
Arg Function: TecUtilArgListAppendInt()
Default: 0
Required: No
Notes: A value of zero indicates that this zone is not associated with a parent zone otherwise a value greater than zero is considered this zone's parent. A zone may not specify itself as its own parent. With a parent zone association, Tecplot can generate surface-restricted streamtraces.

SV_STRANDID
Type: LgIndex_t
Arg Function: TecUtilArgListAppendInt()
Default: 0
Required: No
Notes: If 0 no strand ID is assigned to the zone otherwise values greater than zero are used to assoicated zones with a particular strand.

SV_SOLUTIONTIME
Type: double
Arg Function: TecUtilArgListAppendDouble()
Default: 0.0
Required: No
Notes: The solution time for the zone.

SV_ZONETYPE
Type: ZoneType_e
Arg Function: TecUtilArgListAppendInt()
Default: ZoneType_Ordered
Required: No
Notes: The possible values are: ZoneType_Ordered, ZoneType_FETriangle, ZoneType_FEQuad, ZoneType_FETetra, ZoneType_FEBrick, ZoneType_FELineSeg, ZoneType_FEPolyhedron, or ZoneType_FEPolygon. For polytope zones you must subsequently give the face mapping a data backing by calling TecUtilDataFaceMapAlloc() or TecUtilDataConnectShare() or give it deferred load-on-demand status by calling TecUtilDataFaceMapCustomLOD().

SV_ZONE
Type: EntIndex_t
Arg Function: TecUtilArgListAppendInt()
Default: NumZones+1
Required: No
Notes: Number of the zone to add or replace. If omitted, the new zone number will be assigned a zone number, NumZones+1, where NumZones is the previous number of zones. This value can be set to the number of a zone that already exists thereby replacing the existing zone.

SV_BUILDZONEOPTINFO
Type: Boolean_t
Arg Function: TecUtilArgListAppendInt()
Default: TRUE
Required: No
Notes: Set to FALSE to instruct Tecplot to forgo building zone optimization information. Zone optimization information enhances interactive performance but has an upfront performance cost. This value can be enabled or disabled at a later time by calling TecUtilZoneSetBuildZoneOptInfo().

SV_IMAX
Type: LgIndex_t
Arg Function: TecUtilArgListAppendInt()
Default: 1
Required: No
Notes: For an ordered zone SV_IMAX is the number of data points in the I dimension and for a finite-element zone it is the number of data points.

SV_JMAX
Type: LgIndex_t
Arg Function: TecUtilArgListAppendInt()
Default: 1
Required: No
Notes: For an ordered zone SV_JMAX is the number of data points in the J dimension and for a finite-element zone it is the number of elements.

SV_KMAX
Type: LgIndex_t
Arg Function: TecUtilArgListAppendInt()
Default: 1
Required: No
Notes: For an ordered zone, SV_KMAX is the number of data points in the K dimension, and for a polytope zones it is the total number of faces. If the number of polytope faces is unknown, do not supply this argument - the number of faces will be determined later by calling TecUtilDataFaceMapAssignElemToNodeMap() inside a TecUtilDataFaceMapCustomLOD() callback. For a classic FE zone, if the value is supplied, it is ignored.

SV_VARDATATYPE
Type: FieldDataType_e *
Arg Function: TecUtilArgListAppendArray()
Default: NULL
Required: No
Notes: An array of FieldDataType_e dimensioned by the number of variables currently defined in the dataset where each member specifies the type of data. If you set this to NULL then the data types of the variables in zone 1 of the existing data set are used or FieldDataType_Float if this is the first zone. These settings ONLY apply to the data types of the variables in this newly created zone. The possible values are: FieldDataType_Float, FieldDataType_Double, FieldDataType_Int32, FieldDataType_Int16, FieldDataType_Byte, or FieldDataType_Bit.

SV_VALUELOCATION
Type: ValueLocation_e *
Arg Function: TecUtilArgListAppendArray()
Default: NULL
Required: No
Notes: An array of ValueLocation_e values (sized by the number of variables). This will assign the value locations for all variables in the zone. If NULL, all variables will use the locations from zone 1 of the existing data set or ValueLocation_Nodal if this is the first zone.

SV_VARSHAREZONELIST
Type: EntIndex_t *
Arg Function: TecUtilArgListAppendArray()
Default: NULL
Required: No
Notes: An array of zone numbers dimensioned by the number of variables currently defined in the dataset where each member specifies the zone used for sharing each variable. Set the zone number to 0 to specify no sharing for a specific variable. This option is mutually exclusive with SV_DEFERVARCREATION. To use variable sharing with SV_DEFERVARCREATION you must use TecUtilDataValueShare().

SV_DEFERVARCREATION
Type: Boolean_t
Arg Function: TecUtilArgListAppendInt()
Default: FALSE
Required: No
Notes: Indicates if the creation of the variable should be deferred until the variable data is ready to be populated or shared. A data loader should allocate, share, auto or custom load the variable with TecUtilDataValueAlloc(), TecUtilDataValueShare(), TecUtilDataValueAutoLOD(), or TecUtilDataValueCustomLOD() before returning control to Tecplot. Any variables that have not been allocated, shared, auto or custom loaded will become passive variables. Passive variables always return zero for every point but do not participate in Tecplot's min/max calculations such as when Tecplot is choosing good contour levels based on the available data. This option is mutually exclusive with SV_VARSHAREZONELIST.

SV_DEFERNODEMAPCREATION
Type: Boolean_t
Arg Function: TecUtilArgListAppendInt()
Default: FALSE
Required: No
Notes: Indicates if the creation of the node map should be deferred until the node map data is ready to be populated or the connectivity shared. A data loader must allocate, share, auto or custom load the node map with TecUtilDataNodeAlloc(), TecUtilDataConnectShare(), TecUtilDataNodeAutoLOD(), or TecUtilDataNodeCustomLOD() before returning control to Tecplot. This option is mutually exclusive with SV_CONNECTSHAREZONE.

SV_DEFERFACENBRCREATION
Type: Boolean_t
Arg Function: TecUtilArgListAppendInt()
Default: FALSE
Required: No
Notes: Indicates if the creation of the face neighbor should be deferred until the face neighbor data is ready to be populated or the connectivity shared. A data loader must allocate, share, or custom load the face neighbor data with TecUtilDataConnectShare(), or TecUtilDataFaceNbrCustomLOD() before returning control to Tecplot. This option is mutually exclusive with SV_CONNECTSHAREZONE.

SV_CONNECTSHAREZONE
Type: EntIndex_t
Arg Function: TecUtilArgListAppendInt()
Default: TECUTILBADZONENUMBER
Required: No
Notes: Number of the zone to use for sharing of connectivity information. If not supplied the connectivity will not be shared. This option is mutually exclusive with SV_DEFERNODEMAPCREATION and SV_DEFERFACENBRCREATION. To use node map sharing with SV_DEFERNODEMAPCREATION and/or SV_DEFERFACENBRCREATION you must use TecUtilDataConnectShare().

SV_AUTOASSIGNFN
Type: Boolean_t
Arg Function: TecUtilArgListAppendInt()
Default: TRUE
Required: No
Notes: Associated value indicates if Tecplot should auto assign any remaining face neighbors after the add-on has supplied the faces. This is useful when an add-on only needs to deliver a few specific neighbors. Add-ons that wish to supply all the face neighbor connections should set this value to FALSE.

SV_FACENEIGHBORMODE
Type: FaceNeighborMode_e
Arg Function: TecUtilArgListAppendInt()
Default: FaceNeighborMode_LocalOneToOne
Required: No
Notes: Specifies the face-neighbor mode. Options are: FaceNeighborMode_LocalOneToOne, FaceNeighborMode_LocalOneToMany, FaceNeighborMode_GlobalOneToOne, FaceNeighborMode_GlobalOneToMany. The default is FaceNeighborMode_LocalOneToOne


Precondition:
Must have one or more frames.

ArgList Argument list must be valid.

Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilDataSetAddZoneX(ArgListPtr)
    POINTER (ArgListPtr, ArgList)

Python Syntax:

  Results = TecUtil.DataSetAddZoneX(ArgList)

  Input:
                  ArgList              dictionary
  Output:
    Results[0]    ReturnVal            boolean

Add a 10 by 20 ordered zone as zone number 3.

   ArgList_pa ArgList;
   TecUtilLockStart(AddOnID);
   ArgList = TecUtilArgListAlloc();
   TecUtilArgListAppendString(ArgList, SV_NAME, "New Zone");
   TecUtilArgListAppendInt(ArgList, SV_ZONE, 3);
   TecUtilArgListAppendInt(ArgList, SV_ZONETYPE,
                           (ArbParam_t)ZoneType_Ordered);
   TecUtilArgListAppendInt(ArgList, SV_IMAX, 10);
   TecUtilArgListAppendInt(ArgList, SV_JMAX, 20);
   TecUtilDataSetAddZoneX(ArgList);
   TecUtilArgListDealloc(&ArgList);
   TecUtilLockFinish(AddOnID);

Add a volume zone and two associated child patch zones. The child zones are loosely associated with the parent volume zone. With this association, Tecplot can generate surface-restricted streamtraces.

   ArgList_pa ArgList;
   TecUtilLockStart(AddOnID);
   ArgList = TecUtilArgListAlloc();

   TecUtilArgListAppendString(ArgList, SV_NAME, "Parent Volume Zone");
   TecUtilArgListAppendInt(ArgList, SV_ZONE, 1);
   TecUtilArgListAppendInt(ArgList, SV_ZONETYPE, (ArbParam_t)ZoneType_Ordered);
   TecUtilArgListAppendInt(ArgList, SV_IMAX, 10);
   TecUtilArgListAppendInt(ArgList, SV_JMAX, 20);
   TecUtilArgListAppendInt(ArgList, SV_KMAX, 30);
   TecUtilDataSetAddZoneX(ArgList);

   TecUtilArgListAppendString(ArgList, SV_NAME, "Child Patch Zone 1");
   TecUtilArgListAppendInt(ArgList, SV_ZONE, 2);
   TecUtilArgListAppendInt(ArgList, SV_PARENTZONE, 1); // absolution reference to the parent zone
   TecUtilArgListAppendInt(ArgList, SV_ZONETYPE, (ArbParam_t)ZoneType_Ordered);
   TecUtilArgListAppendInt(ArgList, SV_IMAX, 10);
   TecUtilArgListAppendInt(ArgList, SV_JMAX, 20);
   TecUtilDataSetAddZoneX(ArgList);

   TecUtilArgListAppendString(ArgList, SV_NAME, "Child Patch Zone 2");
   TecUtilArgListAppendInt(ArgList, SV_ZONE, 3);
   TecUtilArgListAppendInt(ArgList, SV_PARENTZONE, 1); // absolution reference to the parent zone
   TecUtilArgListAppendInt(ArgList, SV_ZONETYPE, (ArbParam_t)ZoneType_Ordered);
   TecUtilArgListAppendInt(ArgList, SV_IMAX, 20);
   TecUtilArgListAppendInt(ArgList, SV_JMAX, 30);
   TecUtilDataSetAddZoneX(ArgList);

   TecUtilArgListDealloc(&ArgList);
   TecUtilLockFinish(AddOnID);

See also:
TecUtilDataSetAddVarX()

Boolean_t TecUtilDataSetAutoAssignStrandIDs ( Set_pa  ZoneSet  ) 

Auto assign strand IDs for the specified set of zones.

Tecplot examines the solution times from the subset of zones and groups those zones by their respective solution times within a defined time tolerance. After grouping the zones into time steps the first zone from each time step is assigned to strand 1, the second zone in each time step to strand 2, and so on until there are no more unassigned zones remaining in any time steps.

Parameters:
ZoneSet A subset of the enabled zones that should have their strand ID's assigned. If they zones were previously assigned to other strands or static they are reassigned.
Returns:
TRUE if successful, FALSE if an error occurred while assigning strand ID's.
Precondition:
Must have one or more frames.
See also:
TecUtilZoneSetSolutionTime()

TecUtilZoneGetStrandID()

TecUtilZoneSetStrandID()

Python Syntax:
  Results = TecUtil.DataSetAutoAssignStrandIDs(ZoneSet)

  Input:
                  ZoneSet              sequence of ints
  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilDataSetDefVarLoadFinish ( Boolean_t  IsDataSetOk  ) 

Deprecated:
Tecplot no longer requires that this function be called and it does nothing.

Python Syntax:

  Results = TecUtil.DataSetDefVarLoadFinish(IsDataSetOk)

  Input:
                  IsDataSetOk          boolean
  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilDataSetDeleteVar ( Set_pa  VarList  ) 

Deletes the specified set of variables.

Parameters:
VarList Set of variables to delete.
Returns:
Returns TRUE if variables were deleted, FALSE otherwise.
Precondition:
Must have one or more frames.
Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilDataSetDeleteVar(VarListPtr)
    POINTER (VarListPtr, VarList)

Python Syntax:

  Results = TecUtil.DataSetDeleteVar(VarList)

  Input:
                  VarList              sequence of ints
  Output:
    Results[0]    ReturnVal            boolean

Delete variables 1,3, and 9 

   Set_pa VarList;

   Set_pa VarList = TecUtilSetAlloc(FALSE);
   if (VarList)
     {
       TecUtilSetAddMember(VarList,1,FALSE);
       TecUtilSetAddMember(VarList,3,FALSE);
       TecUtilSetAddMember(VarList,9,FALSE);
       if (TecUtilDataSetDeleteVar(VarList))
         {
           ... variables deleted successfully.   Take approp. action.
         }
       TecUtilSetDealloc(&VarList);
     }

Boolean_t TecUtilDataSetDeleteZone ( Set_pa  ZoneList  ) 

Deletes the specified set of zones.

Parameters:
ZoneList Set of zones to delete.
Returns:
Returns TRUE if zones were deleted, FALSE otherwise.
Precondition:
Must have one or more frames.

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

Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilDataSetDeleteZone(ZoneListPtr)
    POINTER (ZoneListPtr, ZoneList)

Python Syntax:

  Results = TecUtil.DataSetDeleteZone(ZoneList)

  Input:
                  ZoneList             sequence of ints
  Output:
    Results[0]    ReturnVal            boolean

Delete zones 1,3, and 9 

   Set_pa ZoneList;

   Set_pa ZoneList = TecUtilSetAlloc(FALSE);
   if (ZoneList)
     {
       TecUtilSetAddMember(ZoneList,1,FALSE);
       TecUtilSetAddMember(ZoneList,3,FALSE);
       TecUtilSetAddMember(ZoneList,9,FALSE);
       if (TecUtilDataSetDeleteZone(ZoneList))
         {
           ... zones deleted successfully.   Take approp. action.
         }
       TecUtilSetDealloc(&ZoneList);
     }

Boolean_t TecUtilDataSetGetInfo ( char **  DataSetTitle,
EntIndex_t *  NumZones,
EntIndex_t *  NumVars 
)

Get the title, number of zones, and number of variables of the data set attached to the current frame.

This function is Thread Safe.

Parameters:
DataSetTitle Character string containing the title of the data set attached to the current frame. If you pass NULL, this will not be assigned. Deallocate the returned string with TecUtilStringDealloc() when you are done with it.
NumZones The number of zones in the data set attached to the current frame. If you pass NULL, this will not be assigned
NumVars The number of variables in the data set attached to the current frame. If you pass NULL, this will not be assigned.
Returns:
TRUE if successful, FALSE if not.
Precondition:
Must have one or more frames.

Current frame must have a data set.

DataSetTitle Pointer must be a valid address or NULL.

NumZones Pointer must be a valid address or NULL.

NumVars Pointer must be a valid address or NULL.

Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilDataSetGetInfo(
   &                   DataSetTitle,
   &                   DataSetTitleLength,
   &                   NumZones,
   &                   NumVars)
    CHARACTER*(*)   DataSetTitle
    INTEGER*4       DataSetTitleLength
    INTEGER*4       NumZones
    INTEGER*4       NumVars

Python Syntax:

  Results = TecUtil.DataSetGetInfo()

  Output:
    Results[0]    ReturnVal            boolean
    Results[1]    DataSetTitle         string
    Results[2]    NumZones             int
    Results[3]    NumVars              int

Get the data set title and number of zones and variables from the current data set:

   char *dataset_title = NULL;
   EntIndex_t nzones, nvars;

   TecUtilDataSetGetInfo(&dataset_title, &nzones, &nvars);
   // use dataset_title
   TecUtilStringDealloc(&dataset_title);

Boolean_t TecUtilDataSetLockOff ( const char *  LockString  ) 

Unlock the data set attached to the current frame.

Parameters:
LockString Unique string identifier originally used to lock the data set.
Returns:
Returns TRUE if the data set can be unlocked, FALSE otherwise.
Precondition:
Must have one or more frames.

LockString String must have a valid address and non-zero length.

Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilDataSetLockOff(LockString)
    CHARACTER*(*) LockString

Python Syntax:

  Results = TecUtil.DataSetLockOff(LockString)

  Input:
                  LockString           string
  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilDataSetLockOn ( const char *  LockString  ) 

Lock the data set attached to the current frame.

Parameters:
LockString Unique string identifier originally used to lock the data set.
Returns:
Returns TRUE if the data set can be locked, FALSE otherwise.
Precondition:
Must have one or more frames.

LockString String must have a valid address and non-zero length.

Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilDataSetLockOn(LockString)
    CHARACTER*(*) LockString

Python Syntax:

  Results = TecUtil.DataSetLockOn(LockString)

  Input:
                  LockString           string
  Output:
    Results[0]    ReturnVal            boolean

Lock the data set using the identifier "banana."

   Boolean_t IsBananaLocked = FALSE;
   if (!TecUtilLockIsOn((char **)NULL))
     {
       IsLocked = TecUtilDataSetLockOn("banana");
     }
   ...
   if (IsBananaLocked)
     TecUtilDataSetLockOff("banana");

Boolean_t TecUtilDataSetRequiresSaving ( void   ) 

Deprecated:
Please use TecUtilDataSetJournalIsValid() instead.

Python Syntax:

  Results = TecUtil.DataSetRequiresSaving()

  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilDataValueCanMemMapData ( EntIndex_t  Zone,
EntIndex_t  Var,
MemMapOffset_t  Offset,
Boolean_t  IsDataNativeByteOrder 
)

Deprecated:
Please use TecUtilDataValueAutoLOD() instead.

Python Syntax:

  Results = TecUtil.DataValueCanMemMapData(Zone, Var, Offset, IsDataNativeByteOrder)

  Input:
                  Zone                 int
                  Var                  int
                  Offset               long
                  IsDataNativeByteOrder boolean
  Output:
    Results[0]    ReturnVal            boolean

void TecUtilDataValueGetRawPtr ( EntIndex_t  Zone,
EntIndex_t  Var,
void **  DataPtr,
FieldDataType_e *  FieldDataType 
)

Deprecated:
Please use TecUtilDataValueGetReadableRawPtr() or TecUtilDataValueGetWritableRawPtr() instead. Calling TecUtilDataValueGetRawPtr() is equivalent to calling TecUtilDataValueGetWritableRawPtr() and acquiring the raw data pointer.

Python Syntax:

    This function is not supported in Python.

FieldData_pa TecUtilDataValueGetReadableRef ( EntIndex_t  Zone,
EntIndex_t  Var 
)

Deprecated:
Please use TecUtilDataValueGetReadableNativeRef(), TecUtilDataValueGetReadableDerivedRef(), TecUtilDataValueGetReadableNLRef(), or TecUtilDataValueGetReadableCCRef() instead. Calling TecUtilDataValueGetReadableRef() is equivalent to calling TecUtilDataValueGetReadableNativeRef().

Python Syntax:

  Results = TecUtil.DataValueGetReadableRef(Zone, Var)

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

FieldData_pa TecUtilDataValueGetRef ( EntIndex_t  Zone,
EntIndex_t  Var 
)

Deprecated:
Please use TecUtilDataValueGetReadableNativeRef(), TecUtilDataValueGetReadableDerivedRef(), TecUtilDataValueGetReadableNLRef(), TecUtilDataValueGetReadableCCRef(), or TecUtilDataValueGetWritableNativeRef() instead. Calling TecUtilDataValueGetRef() is equivalent to calling TecUtilDataValueGetWritableNativeRef().

Python Syntax:

  Results = TecUtil.DataValueGetRef(Zone, Var)

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

FieldData_pa TecUtilDataValueGetWritableRef ( EntIndex_t  Zone,
EntIndex_t  Var 
)

Deprecated:
Please use TecUtilDataValueGetWritableNativeRef() instead. Calling TecUtilDataValueGetWritableRef() is equivalent to calling TecUtilDataValueGetWritableNativeRef().

Python Syntax:

  Results = TecUtil.DataValueGetWritableRef(Zone, Var)

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

Boolean_t TecUtilDataValueMemMapData ( EntIndex_t  Zone,
EntIndex_t  Var,
int  FileDescriptor,
MemMapOffset_t  Offset,
Boolean_t  IsDataNativeByteOrder 
)

Deprecated:
Please use TecUtilDataValueAutoLOD() instead.

Python Syntax:

  Results = TecUtil.DataValueMemMapData(Zone, Var, FileDescriptor, Offset, IsDataNativeByteOrder)

  Input:
                  Zone                 int
                  Var                  int
                  FileDescriptor       int
                  Offset               long
                  IsDataNativeByteOrder boolean
  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtiltDataSetDefVarLoadFinish ( Boolean_t  IsDataSetOk  ) 

Deprecated:
This function was originally misspelled. Please use TecUtilDataSetDefVarLoadFinish() instead.

Python Syntax:

  Results = TecUtil.tDataSetDefVarLoadFinish(IsDataSetOk)

  Input:
                  IsDataSetOk          boolean
  Output:
    Results[0]    ReturnVal            boolean

LgIndex_t TecUtilTecPolyX ( ArgList_pa  ArgList  ) 

Writes the face map for polygonal and polyhedral zones to the data file.

Since:
11.3-0-028
Parameters:
ArgList Set of Arglist entries. This is built using calls to TecUtilArgListAppendXXXX functions.

Arglist Values

SV_FACENODECOUNTS
Type: LgIndex_t *
Arg Function: TecUtilArgListAppendArray()
Required: Yes
Notes: Array of counts of nodes in the FaceNodes array dimensioned by NumFaces. This array is NULL for polygonal zones since each face always has 2 nodes. Required for polyhedral zones, no for polygonal zones.

SV_FACENODES
Type: LgIndex_t *
Arg Function: TecUtilArgListAppendArray()
Required: Yes
Notes: Array of 1-based nodes for each face dimensioned by TotalNumFaceNodes.

SV_FACELEFTELEMS
Type: LgIndex_t *
Arg Function: TecUtilArgListAppendArray()
Required: Yes
Notes: Array of 1-based left elements for each face dimensioned by NumFaces. Boundary faces use a negative value which is the (negated) offset into the FaceBndryConnectionCounts array. The boundary face value must be <= TotalNumBndryFaces. TECUTIL_NO_NEIGHBORING_ELEM = 0 indicates that there is no left element for the face.

SV_FACERIGHTELEMS
Type: LgIndex_t *
Arg Function: TecUtilArgListAppendArray()
Required: Yes
Notes: Array of 1-based right elements for each face dimensioned by NumFaces. See description of FaceLeftElems for more details.

SV_FACEBNDRYCONNECTIONCOUNTS
Type: LgIndex_t *
Arg Function: TecUtilArgListAppendArray()
Required: Yes
Notes: Array of boundary connection counts for each boundary face dimensioned by TotalNumBndryFaces used to access the FaceBndryConnectionElems and FaceBndryConnectionZones arrays. If the number of elements for a face (F) is 0, then there is no neighboring element. This is NULL if TotalNumBndryFaces = 0. Required if TotalNumBndryFaces > 0.

SV_FACEBNDRYCONNECTIONELEMS
Type: LgIndex_t *
Arg Function: TecUtilArgListAppendArray()
Required: Yes
Notes: Array dimensioned by TotalNumBndryConnections of neighboring elements of any boundary faces. It is referenced through the FaceBndryConnectionCounts array. A value of TECUTIL_NO_NEIGHBORING_ELEM = 0 indicates that there is no element on part of the face. This is NULL if TotalNumBndryFaces = 0. Required if TotalNumBndryFaces > 0.

SV_FACEBNDRYCONNECTIONZONES
Type: EntIndex_t *
Arg Function: TecUtilArgListAppendArray()
Required: Yes
Notes: Array dimensioned by TotalNumBndryConnections of zones for each neighboring element of any boundary faces referenced through the FaceBndryConnectionCounts array. A value of TECUTIL_NO_NEIGHBORING_ZONE = 0 indicates the current zone. This is NULL if TotalNumBndryFaces = 0. Required if TotalNumBndryFaces > 0.


Returns:
0 if successful, -1 if unsuccessful.
Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilTecPolyX(ArgListPtr)
    POINTER (ArgListPtr, ArgList)

Python Syntax:

  Results = TecUtil.TecPolyX(ArgList)

  Input:
                  ArgList              dictionary
  Output:
    Results[0]    ReturnVal            int

Boolean_t TecUtilZoneDelete ( Set_pa  ZoneList  ) 

Deprecated:
Please use TecUtilDataSetDeleteZone() instead.

Python Syntax:

  Results = TecUtil.ZoneDelete(ZoneList)

  Input:
                  ZoneList             sequence of ints
  Output:
    Results[0]    ReturnVal            boolean

SetValueReturnCode_e TecUtilZoneSetBoundary ( const char *  Attribute,
Set_pa  ZoneSet,
double  DValue,
ArbParam_t  IValue 
)

Deprecated:
Please use TecUtilZoneSetEdgeLayer() instead.

Python Syntax:

  Results = TecUtil.ZoneSetBoundary(Attribute, ZoneSet, DValue, IValue)

  Input:
                  Attribute            string
                  ZoneSet              sequence of ints
                  DValue               double
                  IValue               (depends on attribute)
  Output:
    Results[0]    ReturnVal            SetValueReturnCode_e  (defined in TecVals.py)

SetValueReturnCode_e TecUtilZoneSetIJKMode ( const char *  Attribute,
const char *  SubAttribute,
Set_pa  ZoneSet,
ArbParam_t  IValue 
)

Deprecated:
Please use TecUtilZoneSetVolumeMode() instead.

Python Syntax:

  Results = TecUtil.ZoneSetIJKMode(Attribute, SubAttribute, ZoneSet, IValue)

  Input:
                  Attribute            string
                  SubAttribute         string
                  ZoneSet              sequence of ints
                  IValue               (depends on attribute)
  Output:
    Results[0]    ReturnVal            SetValueReturnCode_e  (defined in TecVals.py)

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