Tecplot: Data Services

ArgList_pa TecUtilArgListAlloc ( void )

Allocate an argument list.

Argument lists are used with all of the "X" (extended) functions in Tecplot.

Returns:: Returns an ArgList object if successful, otherwise NULL.

Fortran Syntax:

    SUBROUTINE TecUtilArgListAlloc(ResultPtr)
    POINTER (ResultPtr, Result)

Python Syntax:

    This function is not supported in Python.

Boolean_t TecUtilArgListAppendArbParam	(	ArgList_pa	ArgList,
		const char *	Name,
		ArbParam_t	Value
	)

Append an ArbParam_t type parameter to an argument list.

Parameters:

	ArgList	The argument list.
	Name	Parameter name. Use the SV_constants listed with the extended function.
	Value	Value associated with the parameter name.

Returns:: Returns TRUE if append is successful, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilArgListAppendArbParam(
   &                   ArgListPtr,
   &                   Name,
   &                   ValuePtr)
    POINTER         (ArgListPtr, ArgList)
    CHARACTER*(*)   Name
    POINTER         (ValuePtr, Value)

Python Syntax:

    This function is not supported in Python.

Boolean_t TecUtilArgListAppendArbParamPtr	(	ArgList_pa	ArgList,
		const char *	Name,
		ArbParam_t *	Value
	)

Appends an ArbParam_t pointer parameter to an argument list.

Parameters:

	ArgList	The argument list
	Name	Parameter Name. Use the SV_ constants listed with the extended function.
	Value	Pointer value associated with the parameter name

Returns:: Returns TRUE is append is successful, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilArgListAppendArbParamPtr(
   &                   ArgListPtr,
   &                   Name,
   &                   ValuePtr)
    POINTER         (ArgListPtr, ArgList)
    CHARACTER*(*)   Name
    POINTER         (ValuePtr, Value)

Python Syntax:

    This function is not supported in Python.

Boolean_t TecUtilArgListAppendArray	(	ArgList_pa	ArgList,
		const char *	Name,
		const void *	Value
	)

Appends a named array to the argument list.

Parameters:

	ArgList	The argument list.
	Name	Parameter name. Use the SV_constants listed with the extended function.
	Value	Value associated with the parameter name.

Returns:: Returns TRUE if append is successful, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilArgListAppendArray(
   &                   ArgListPtr,
   &                   Name,
   &                   Value)
    POINTER         (ArgListPtr, ArgList)
    CHARACTER*(*)   Name
    POINTER         (ValuePtr, Value)

Python Syntax:

    This function is not supported in Python.

Boolean_t TecUtilArgListAppendDouble	(	ArgList_pa	ArgList,
		const char *	Name,
		double	Value
	)

Append a double parameter to an argument list.

Parameters:

	ArgList	The argument list.
	Name	Parameter name. Use the SV_constants listed with the extended function.
	Value	Value associated with the parameter name.

Returns:: Returns TRUE if append is successful, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilArgListAppendDouble(
   &                   ArgListPtr,
   &                   Name,
   &                   Value)
    POINTER         (ArgListPtr, ArgList)
    CHARACTER*(*)   Name
    REAL*8          Value

Python Syntax:

    This function is not supported in Python.

Boolean_t TecUtilArgListAppendDoublePtr	(	ArgList_pa	ArgList,
		const char *	Name,
		double *	Value
	)

Appends a double pointer parameter to an argument list.

Parameters:

	ArgList	The argument list
	Name	Parameter Name. Use the SV_ constants listed with the extended function
	Value	Pointer value associated with the parameter name

Returns:: Returns TRUE is append is successful, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilArgListAppendDoublePtr(
   &                   ArgListPtr,
   &                   Name,
   &                   Value)
    POINTER         (ArgListPtr, ArgList)
    CHARACTER*(*)   Name
    REAL*8          Value

Python Syntax:

    This function is not supported in Python.

See TecUtilStyleGetLowLevelX() for a complete example.

Boolean_t TecUtilArgListAppendFunction	(	ArgList_pa	ArgList,
		const char *	Name,
		const void *	Value
	)

Append a named function pointer to an argument list.

Parameters:

	ArgList	The argument list.
	Name	Parameter name. Use the SV_constants listed with the extended function.
	Value	Function pointer associated with the parameter name.

Returns:: Returns TRUE if append is successful, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilArgListAppendFunction(
   &                   ArgListPtr,
   &                   Name,
   &                   Value)
    POINTER         (ArgListPtr, ArgList)
    CHARACTER*(*)   Name
    POINTER         (ValuePtr, Value)

Python Syntax:

    This function is not supported in Python.

Boolean_t TecUtilArgListAppendInt	(	ArgList_pa	ArgList,
		const char *	Name,
		LgIndex_t	Value
	)

Append an integer parameter to an argument list.

Parameters:

	ArgList	The argument list.
	Name	Parameter name. Use the SV_constants listed with the extended function.
	Value	Value associated with the parameter name.

Returns:: Returns TRUE if append is successful, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilArgListAppendInt(
   &                   ArgListPtr,
   &                   Name,
   &                   Value)
    POINTER         (ArgListPtr, ArgList)
    CHARACTER*(*)   Name
    INTEGER*4       Value

Python Syntax:

    This function is not supported in Python.

Boolean_t TecUtilArgListAppendSet	(	ArgList_pa	ArgList,
		const char *	Name,
		Set_pa	Value
	)

Append a named set to an argument list.

Parameters:

	ArgList	The argument list.
	Name	Parameter name. Use the SV_constants listed with the extended function.
	Value	Set associated with the parameter name.

Returns:: Returns TRUE if append is successful, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilArgListAppendSet(
   &                   ArgListPtr,
   &                   Name,
   &                   ValuePtr)
    POINTER         (ArgListPtr, ArgList)
    CHARACTER*(*)   Name
    POINTER         (ValuePtr, Value)

Python Syntax:

    This function is not supported in Python.

Boolean_t TecUtilArgListAppendString	(	ArgList_pa	ArgList,
		const char *	Name,
		const char *	Value
	)

Append a string to an argument list.

Parameters:

	ArgList	The argument list.
	Name	Parameter name. Use the SV_constants listed with the extended function.
	Value	String value associated with the parameter name.

Returns:: Returns TRUE if append is successful, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilArgListAppendString(
   &                   ArgListPtr,
   &                   Name,
   &                   Value)
    POINTER         (ArgListPtr, ArgList)
    CHARACTER*(*)   Name
    CHARACTER*(*)   Value

Python Syntax:

    This function is not supported in Python.

Boolean_t TecUtilArgListAppendStringList	(	ArgList_pa	ArgList,
		const char *	Name,
		StringList_pa	StringList
	)

Append a named string list to an argument list.

Parameters:

	ArgList	The argument list.
	Name	Parameter name. Use the SV_constants listed with the extended function.
	StringList	String List associated with the parameter name.

Returns:: Returns TRUE if append is successful, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilArgListAppendStringList(
   &                   ArgListPtr,
   &                   Name,
   &                   StringListPtr)
    POINTER         (ArgListPtr, ArgList)
    CHARACTER*(*)   Name
    POINTER         (StringListPtr, StringList)

Python Syntax:

    This function is not supported in Python.

void TecUtilArgListClear ( ArgList_pa ArgList )

Clear all arguments from an argument list.

Fortran Syntax:

    SUBROUTINE TecUtilArgListClear(ArgListPtr)
    POINTER (ArgListPtr, ArgList)

Python Syntax:

    This function is not supported in Python.

void TecUtilArgListDealloc ( ArgList_pa * ArgList )

Deallocate an argument list.

Parameters:

ArgList

The argument list.

Fortran Syntax:

    SUBROUTINE TecUtilArgListDealloc(ArgListPtr)
    POINTER (ArgListPtr, ArgList)

Python Syntax:

    This function is not supported in Python.

AuxData_pa TecUtilAuxDataDataSetGetRef ( void )

Gets a reference to the current data set's auxiliary data.

Returns:: Reference to the current data set's auxiliary data.

Fortran Syntax:

    SUBROUTINE TecUtilAuxDataDataSetGetRef(ResultPtr)
    POINTER (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.AuxDataDataSetGetRef()

  Output:
    Results[0]    ReturnVal            opaque pointer

void TecUtilAuxDataDeleteItemByIndex	(	AuxData_pa	AuxDataRef,
		LgIndex_t	Index
	)

Deletes the auxiliary data item.

Parameters:

	AuxDataRef	Reference to the auxiliary data.
	Index	Index of the auxiliary data item of interest.

Fortran Syntax:

    SUBROUTINE TecUtilAuxDataDeleteItemByIndex(
   &           AuxDataRefPtr,
   &           Index)
    POINTER         (AuxDataRefPtr, AuxDataRef)
    INTEGER*4       Index

Python Syntax:

  Results = TecUtil.AuxDataDeleteItemByIndex(AuxDataRef, Index)

  Input:
                  AuxDataRef           opaque pointer
                  Index                int
  Output:
    Results[0]    ReturnVal            NONE

Delete the dataset's fourth auxiliary data item:

   AuxData_pa AuxDataRef = TecUtilAuxDataDataSetGetRef();
   if (AuxDataRef != NULL)
     {
       TecUtilAuxDataDeleteItemByIndex(AuxDataRef, 4);
     }
   else
     {
       // ... allocation failure ...
     }

Boolean_t TecUtilAuxDataDeleteItemByName	(	AuxData_pa	AuxDataRef,
		const char *	Name
	)

Deletes the auxiliary data item by the specified name if it exists.

Parameters:

	AuxDataRef	Reference to the auxiliary data.
	Name	Name used for the search.

Returns:: TRUE if successful, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilAuxDataDeleteItemByName(
   &                   AuxDataRefPtr,
   &                   Name)
    POINTER         (AuxDataRefPtr, AuxDataRef)
    CHARACTER*(*)   Name

Python Syntax:

  Results = TecUtil.AuxDataDeleteItemByName(AuxDataRef, Name)

  Input:
                  AuxDataRef           opaque pointer
                  Name                 string
  Output:
    Results[0]    ReturnVal            boolean

If it exists, delete the dataset's auxiliary data item named "MachNumber":

   AuxData_pa AuxDataRef = TecUtilAuxDataDataSetGetRef();
   if (AuxDataRef != NULL)
     {
       if (TecUtilAuxDataDeleteItemByName(AuxDataRef, "MachNumber"))
         {
           // ... item found and deleted ...
         }
       else
         {
           // ... item not found ...
         }
     }
   else
     {
       // ... allocation failure ...
     }

AuxData_pa TecUtilAuxDataFrameGetRef ( void )

Gets a reference to the current frame's auxiliary data.

Returns:: Reference to the current frame's auxiliary data.

Fortran Syntax:

    SUBROUTINE TecUtilAuxDataFrameGetRef(ResultPtr)
    POINTER (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.AuxDataFrameGetRef()

  Output:
    Results[0]    ReturnVal            opaque pointer

void TecUtilAuxDataGetItemByIndex	(	AuxData_pa	AuxDataRef,
		LgIndex_t	Index,
		char **	Name,
		ArbParam_t *	Value,
		AuxDataType_e *	Type,
		Boolean_t *	Retain
	)

Gets the auxiliary data item at the specified index.

The resulting name and value are allocated copies and therefore it is the client's responsibility to release them when no longer needed.

See also:: TecUtilStringDealloc()

Note:: This function is only available in C/C++. For other languages use TecUtilAuxDataGetStrItemByIndex().

Parameters:

	AuxDataRef	Reference to the auxiliary data.
	Index	Index of the auxiliary data of interest.
	Name	Address to hold the auxiliary data item name string. It is the client's responsibility release it with TecUtilStringDealloc() when no longer needed.
	Value	Address to hold the auxiliary data item value. If the value is a pointer to a string, it is the client's responsibility release it with TecUtilStringDealloc() when no longer needed.
	Type	Address to hold the auxiliary data item type.
	Retain	Address to hold the auxiliary data item retain flag.

Get the frame's fourth auxiliary data item:

   AuxData_pa AuxDataRef = TecUtilAuxDataFrameGetRef();
   if (AuxDataRef != NULL)
     {
       char          *Name;
       ArbParam_t     Value;
       AuxDataType_e  Type;
       Boolean_t      Retain;
       TecUtilAuxDataGetItemByIndex(AuxDataRef, 4,
                                    &Name,
                                    &Value,
                                    &Type,
                                    &Retain);
       if (Type == AuxDataType_String)
         // currently the only type supported
         {
           char *ValueString = (char *)Value;
           if (ValueString != NULL)
             {
              // ... do something with the value string ...
              // release the allocated string copy
               TecUtilStringDealloc(&Name);
               TecUtilStringDealloc(&ValueString);
             }
           else
             {
               // ... handle the NULL condition ...
             }
         }
       else
         {
           // value type not yet supported by this addon
         }
     }
   else
     {
       // ... allocation failure ...
     }

Python Syntax:

    This function is not supported in Python.

Boolean_t TecUtilAuxDataGetItemByName	(	AuxData_pa	AuxDataRef,
		const char *	Name,
		ArbParam_t *	Value,
		AuxDataType_e *	Type,
		Boolean_t *	Retain
	)

Gets the auxiliary data item by the specified name if it exists.

Note:: The resulting value is an allocated copy and therefore it is the caller's responsibility to release using TecUtilStringDealloc() when no longer needed. This function is only available in C/C++. For other languages, use TecUtilAuxDataGetStrItemByName().

Parameters:

	AuxDataRef	Reference to the auxiliary data.
	Name	Auxiliary data name to fetch.
	Value	Address to hold the auxiliary data item value. If the value is a pointer to a string, it is the client's responsibility release it with TecUtilStringDealloc() when no longer needed.
	Type	Address to hold the auxiliary data item type.
	Retain	Address to hold the auxiliary data item retain flag. If Retain is set to TRUE, then saving the data set will include this item.

Python Syntax:

    This function is not supported in Python.

If it exists, get the frame's auxiliary data item named "MachNumber":

   // If it exists, get the frame's auxiliary
   // data item named "MachNumber".
   AuxData_pa AuxDataRef = TecUtilAuxDataFrameGetRef();
   if (AuxDataRef != NULL)
     {
       ArbParam_t    Value;
       AuxDataType_e Type;
       Boolean_t     Retain;
       if (TecUtilAuxDataGetItemByName(AuxDataRef, "MachNumber",
                                       &Value, &Type, &Retain))
         {
           if (Type == AuxDataType_String) // currently the only type supported
             {
               char *ValueString = (char *)Value;
               if (ValueString != NULL)
                 {
                   // ... do something with the value string ...
                   double MachNumber;
                   if (sscanf(ValueString, "%lf", &MachNumber) == 1)
                     {
                     }
                   else
                     {
                       // ... invalid value ...
                     }
   
                   // release the allocated string copy
                   TecUtilStringDealloc(&ValueString);
                 }
               else
                 {
                   // ... handle the NULL condition ...
                 }
             }
           else
             {
               // ... value type not yet supported by this addon ...
             }
         }
       else
         {
           // ... item not found ...
         }
     }
   else
     {
       // ... allocation failure ...
     }

Boolean_t TecUtilAuxDataGetItemIndex	(	AuxData_pa	AuxDataRef,
		const char *	Name,
		LgIndex_t *	ItemIndex
	)

Gets the index of the named auxiliary data item if found or if not found the index where an auxiliary data item could be inserted in sorted order.

Parameters:

	AuxDataRef	Reference to auxiliary data.
	Name	Name used for search.
	ItemIndex	Address to hold the index of the found item or the index where an auxiliary data item could be inserted.

Returns:: TRUE if the named item was found, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilAuxDataGetItemIndex(
   &                   AuxDataRefPtr,
   &                   Name,
   &                   ItemIndex)
    POINTER         (AuxDataRefPtr, AuxDataRef)
    CHARACTER*(*)   Name
    INTEGER*4       ItemIndex

Python Syntax:

  Results = TecUtil.AuxDataGetItemIndex(AuxDataRef, Name)

  Input:
                  AuxDataRef           opaque pointer
                  Name                 string
  Output:
    Results[0]    ReturnVal            boolean
    Results[1]    ItemIndex            int

If it exists, get the item index of the frame's auxiliary data item named "MachNumber":

   // If it exists, get the item index of the frame's
   // auxiliary data item named "MachNumber".
   AuxData_pa AuxDataRef = TecUtilAuxDataFrameGetRef();
   if (AuxDataRef != NULL)
     {
       LgIndex_t ItemIndex;
       if (TecUtilAuxDataGetItemIndex(AuxDataRef,
                                      "MachNumber",
                                      &ItemIndex))
         {
           // ...do something with the item index ...
         }
       else
         {
           // ...item not found ...
         }
     }
   else
     {
       // ...allocation failure ...
     }

LgIndex_t TecUtilAuxDataGetNumItems ( AuxData_pa AuxDataRef )

Gets the current number of auxiliary data items maintained by the auxiliary data reference.

Parameters:

AuxDataRef

Reference to auxiliary data.

Returns:: Number of items maintained by the auxiliary data.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilAuxDataGetNumItems(AuxDataRefPtr)
    POINTER (AuxDataRefPtr, AuxDataRef)

Python Syntax:

  Results = TecUtil.AuxDataGetNumItems(AuxDataRef)

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

Find the number of auxiliary data items linked to the frame:

   AuxData_pa AuxDataRef = TecUtilAuxDataFrameGetRef();
   if (AuxDataRef != NULL)
     {
       LgIndex_t NumItems = TecUtilAuxDataGetNumItems(AuxDataRef);
       if (NumItems != 0)
         {
           // ... do something with the 1..NumItems items ...
         }
     }
   else
     {
       // ... allocation failure ...
     }

void TecUtilAuxDataGetStrItemByIndex	(	AuxData_pa	AuxDataRef,
		LgIndex_t	Index,
		char **	Name,
		char **	Value,
		Boolean_t *	Retain
	)

Gets the auxiliary string data item at the specified index.

The resulting name and value are allocated copies and therefore it is the client's responsibility to release them with TecUtilStringDealloc() when no longer needed.

Since:: 11.0-0-007

See also:: TecUtilStringDealloc()

Parameters:

	AuxDataRef	Reference to the auxiliary data.
	Index	Index of the auxiliary data of interest.
	Name	Address to hold the auxiliary data item name string. It is the client's responsibility release it with TecUtilStringDealloc() when no longer needed.
	Value	Address to hold the auxiliary data item value string. It is the client's responsibility release it with TecUtilStringDealloc() when no longer needed.
	Retain	Address to hold the auxiliary data item retain flag.

Fortran Syntax:

    SUBROUTINE TecUtilAuxDataGetStrItemByIndex(
   &           AuxDataRefPtr,
   &           Index,
   &           Name,
   &           NameLength,
   &           ValuePtr,
   &           Retain)
    POINTER         (AuxDataRefPtr, AuxDataRef)
    INTEGER*4       Index
    CHARACTER*(*)   Name
    INTEGER*4       NameLength
    CHARACTER*(*)   Value
    INTEGER*4       ValueLength
    INTEGER*4       Retain

Python Syntax:

  Results = TecUtil.AuxDataGetStrItemByIndex(AuxDataRef, Index)

  Input:
                  AuxDataRef           opaque pointer
                  Index                int
  Output:
    Results[0]    Name                 string
    Results[1]    Value                string
    Results[2]    Retain               boolean

Get the frame's fourth auxiliary data item:

   AuxData_pa AuxDataRef = TecUtilAuxDataFrameGetRef();
   if (AuxDataRef != NULL)
     {
       char          *Name = NULL;
       char          *Value = NULL;
       Boolean_t      Retain;
       TecUtilAuxDataGetStrItemByIndex(AuxDataRef,
                                       4,
                                       &Name,
                                       &Value,
                                       &Retain);
       if (Value != NULL)
         {
           // ... do something with the value string ...
           // release the allocated string copy
            TecUtilStringDealloc(&Name);
            TecUtilStringDealloc(&Value);
         }
       else
         {
           // ... handle the NULL condition ...
         }
     }
   else
     {
       // ... allocation failure ...
     }

Boolean_t TecUtilAuxDataGetStrItemByName	(	AuxData_pa	AuxDataRef,
		const char *	Name,
		char **	Value,
		Boolean_t *	Retain
	)

Gets the auxiliary string data item by the specified name if it exists.

Note:: The resulting value is an allocated copy and therefore it is the caller's responsibility to release using TecUtilStringDealloc() when no longer needed.

Since:: 11.0-0-007

Parameters:

	AuxDataRef	Reference to the auxiliary data.
	Name	Auxiliary data name to fetch.
	Value	Address to hold the auxiliary data item value string. It is the client's responsibility release it with TecUtilStringDealloc() when no longer needed.
	Retain	Address to hold the auxiliary data item retain flag. If Retain is set to TRUE, then saving the data set will include this item.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilAuxDataGetStrItemByName(
   &                   AuxDataRefPtr,
   &                   Name,
   &                   ValuePtr,
   &                   Retain)
    POINTER         (AuxDataRefPtr, AuxDataRef)
    CHARACTER*(*)   Name
    POINTER         (ValuePtr, Value)
    INTEGER*4       Type
    INTEGER*4       Retain

Python Syntax:

  Results = TecUtil.AuxDataGetStrItemByName(AuxDataRef, Name)

  Input:
                  AuxDataRef           opaque pointer
                  Name                 string
  Output:
    Results[0]    ReturnVal            boolean
    Results[1]    Value                string
    Results[2]    Retain               boolean

If it exists, get the frame's auxiliary data item named "MachNumber":

   // If it exists, get the frame's auxiliary
   // data item named "MachNumber".
   AuxData_pa AuxDataRef = TecUtilAuxDataFrameGetRef();
   if (AuxDataRef != NULL)
     {
       char     **Value;
       Boolean_t     Retain;
       if (TecUtilAuxDataGetStrItemByName(AuxDataRef, "MachNumber",
                                          &Value, &Retain))
         {
            if (Value != NULL)
              {
                // ... do something with the value string ...
                double MachNumber;
                if (sscanf(Value, "%lf", &MachNumber) == 1)
                  {
                  }
                else
                  {
                    // ... invalid value ...
                  }
                  // release the allocated string copy
                TecUtilStringDealloc(&Value);
              }
            else
              {
                // ... handle the NULL condition ...
              }
         }
       else
         {
           // ... item not found ...
         }
     }
   else
     {
       // ... allocation failure ...
     }

AuxData_pa TecUtilAuxDataLineMapGetRef ( EntIndex_t Map )

Gets a reference to the specified line map's auxiliary data.

Since:: 10.0-3-129

Parameters:

Map

Line map number for which the auxiliary data is desired.

Returns:: Reference to the specified line map's auxiliary data.

Fortran Syntax:

    SUBROUTINE TecUtilAuxDataLineMapGetRef(
   &           Map,
   &           ResultPtr)
    INTEGER*4       Map
    POINTER         (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.AuxDataLineMapGetRef(Map)

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

AuxData_pa TecUtilAuxDataPageGetRef ( void )

Gets a reference to the current page's auxiliary data.

Returns:: Reference to the current page's auxiliary data.

Fortran Syntax:

    SUBROUTINE TecUtilAuxDataPageGetRef(ResultPtr)
    POINTER (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.AuxDataPageGetRef()

  Output:
    Results[0]    ReturnVal            opaque pointer

Boolean_t TecUtilAuxDataSetItem	(	AuxData_pa	AuxDataRef,
		const char *	Name,
		ArbParam_t	Value,
		AuxDataType_e	Type,
		Boolean_t	Retain
	)

Adds the auxiliary data item to the auxiliary data or replaces it if one already exists by the same name.

Note:: This function is available only in C/C++. For other languages, use TecUtilAuxDataSetStrItem.

Parameters:

	AuxDataRef	Reference to the auxiliary data.
	Name	Auxiliary data item's name. Be sure to consider a unique naming convention for your auxiliary data to avoid naming conflicts with auxiliary data produced by other addons or macros. By convention, addons that wish to share auxiliary data can prepend the name with the "Common" prefix. For example, the Plot3D loader uses CommonReferenceMachNumber for the reference Mach number.
	Value	Value of the item to set. If the type is a string, a copy of the string pointed to by Value is used for the auxiliary data value.
	Type	Type of item being set.
	Retain	Flag specifying whether or not to retain this item on file export such as writing out a datafile, etc.

Returns:: TRUE if the item was added to the auxiliay data, FALSE if otherwise.

Python Syntax:

  Results = TecUtil.AuxDataSetItem(AuxDataRef, Name, Value, Type, Retain)

  Input:
                  AuxDataRef           opaque pointer
                  Name                 string
                  Value                (depends on attribute)
                  Type                 AuxDataType_e  (defined in TecVals.py)
                  Retain               boolean
  Output:
    Results[0]    ReturnVal            boolean

Add an item named "MachNumber" to the frame's auxiliary data.

   AuxData_pa AuxDataRef = TecUtilAuxDataFrameGetRef();
   if (AuxDataRef != NULL)
     {
       ArbParam_t Value = (ArbParam_t)"1.75";
       if (TecUtilAuxDataSetItem(AuxDataRef,
                                 "MachNumber",
                                 Value,
                                 AuxDataType_String,
                                 TRUE)) // Retain
         {
           // ... item was added ...
         }
       else
         {
           // ... item failed to be added ...
         }
     }
   else
     {
       // ... allocation failure ...
     }

Boolean_t TecUtilAuxDataSetStrItem	(	AuxData_pa	AuxDataRef,
		const char *	Name,
		const char *	Value,
		Boolean_t	Retain
	)

Adds the auxiliary data string item to the auxiliary data or replaces it if one already exists by the same name.

Parameters:

	AuxDataRef	Reference to the auxiliary data.
	Name	Auxiliary data item's name. Be sure to consider a unique naming convention for your auxiliary data to avoid naming conflicts with auxiliary data produed by other addonaddons or macros. By convention addons that wish to share auxiliary data can prepend the name with the "Common" prefix. For example, the Plot3D loader uses CommonReferenceMachNumber for the reference Mach number.
	Value	Value string pointer of the item to set. A copy of this string is used for the auxiliary data value.
	Retain	Flag specifying whether or not to retain this item on file export such as writing out a datafile, etc.

Returns:: TRUE if the item was added to the auxiliay data, FALSE if otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilAuxDataSetStrItem(
   &                   AuxDataRefPtr,
   &                   Name,
   &                   ValuePtr,
   &                   Retain)
    POINTER         (AuxDataRefPtr, AuxDataRef)
    CHARACTER*(*)   Name
    POINTER         (ValuePtr, Value)
    INTEGER*4       Retain

Python Syntax:

  Results = TecUtil.AuxDataSetStrItem(AuxDataRef, Name, Value, Retain)

  Input:
                  AuxDataRef           opaque pointer
                  Name                 string
                  Value                string
                  Retain               boolean
  Output:
    Results[0]    ReturnVal            boolean

Add an item named "MachNumber" to the frame's auxiliary data.

   AuxData_pa AuxDataRef = TecUtilAuxDataFrameGetRef();
   if (AuxDataRef != NULL)
     {
       const char *Value = "1.75";
       if (TecUtilAuxDataSetStrItem(AuxDataRef,
                                 "MachNumber",
                                 Value,
                                 TRUE)) // Retain
         {
           // ... item was added ...
         }
       else
         {
           // ... item failed to be added ...
         }
     }
   else
     {
       // ... allocation failure ...
     }

AuxData_pa TecUtilAuxDataVarGetRef ( EntIndex_t Var )

Gets a reference to the specified variable's auxiliary data.

Since:: 10.0-3-129

Parameters:

Var

Variable number for which the auxiliary data is desired.

Returns:: Reference to the specified variable's auxiliary data.

Fortran Syntax:

    SUBROUTINE TecUtilAuxDataVarGetRef(
   &           Var,
   &           ResultPtr)
    INTEGER*4       Var
    POINTER         (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.AuxDataVarGetRef(Var)

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

AuxData_pa TecUtilAuxDataZoneGetRef ( EntIndex_t Zone )

Gets a reference to the specified zone's auxiliary data.

Parameters:

Zone

Zone number for which the auxiliary data is desired.

Returns:: Reference to the specified zone's auxiliary data.

Fortran Syntax:

    SUBROUTINE TecUtilAuxDataZoneGetRef(
   &           Zone,
   &           ResultPtr)
    INTEGER*4       Zone
    POINTER         (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.AuxDataZoneGetRef(Zone)

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

Boolean_t TecUtilAverageCellCenterData	(	Set_pa	ZoneSet,
		Set_pa	VarSet
	)

Most plotting in Tecplot is based on using values at the corners (nodes) of each cell.

If you have some field values that are cell-centered then you need a way to interpolate those values to cell corners. TecUtilAverageCellCenterData() is used to interpolate cell centered data in IJ- or IJK-ordered datasets from the cell-center to the nodes. This same objective can be accomplished by using one of the interpolation options in Tecplot but that is usually more involved and requires more processing time. In preparation for using this function, you must:

Determine which variables are cell-centered values in your data.
Construct the Tecplot input data file as follows;
1. Treat all node data in the usual manner.
2. Assign the cell-centered data to the lowest
  indexed node of the cell it represents.
3. Assign dummy values (0.0) to all nodes at I=IMAX, J=JMAX,
  (and K=KMAX, for IJK-ordered data).
Load your data into Tecplot and call this function.

The data from the lowest indexed corners of each cell are treated as if they are positioned in the cell center.TecUtilAverageCellCenterData() then takes these values and replaces the values at the nodes with the new interpolated values.

If your objective is only to view a flooded contour plot where each cell is filled with a single color representing the cell-centered value, then do steps 1 and 2 above and set the contour plot type to Corner. Only call this routine if the current frame is in 2D or 3D frame mode.

Parameters:

	ZoneSet	Set of zones to operate on. NULL will do all zones.
	VarSet	Set of variables to shift from the cell center to the nodes. NULL will do all variables not assigned to the X-, Y- or Z-axis.

Returns:: TRUE if successful, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilAverageCellCenterData(
   &                   ZoneSetPtr,
   &                   VarSetPtr)
    POINTER         (ZoneSetPtr, ZoneSet)
    POINTER         (VarSetPtr, VarSet)

Python Syntax:

  Results = TecUtil.AverageCellCenterData(ZoneSet, VarSet)

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

Average the cell-centered values for variables 4, 7, 8, and 9 in zones 1-3:

   if (TecUtilFrameGetMode() == Frame_TwoD ||
       TecUtilFrameGetMode() == Frame_ThreeD)
     {
       Set_pa    ZoneSet;
       Set_pa    VarSet;
       Boolean_t IsOk = FALSE;
   
       ZoneSet = TecUtilSetAlloc(TRUE);
       VarSet  = TecUtilSetAlloc(TRUE);
       if (ZoneSet && VarSet)
         {
           TecUtilSetAddMember(ZoneSet,1,TRUE);
           TecUtilSetAddMember(ZoneSet,2,TRUE);
           TecUtilSetAddMember(ZoneSet,3,TRUE);
           TecUtilSetAddMember(VarSet,4,TRUE);
           TecUtilSetAddMember(VarSet,7,TRUE);
           TecUtilSetAddMember(VarSet,8,TRUE);
           TecUtilSetAddMember(VarSet,9,TRUE);
           IsOk = TecUtilAverageCellCenterData(ZoneSet,VarSet);
           TecUtilSetDealloc(&ZoneSet);
           TecUtilSetDealloc(&VarSet);
         }
     }

Set_pa TecUtilConnectGetShareZoneSet ( EntIndex_t Zone )

Gets the set of zones that share the connectivity with the specified zone.

If the specified zone's connectivity is shared then it is also a member of the resulting set otherwise an empty set is returned.

Parameters:

Zone

Zone for which sharing information is desired.

Returns:: Allocated set of zones that share the connectivity with the specified zone.

Fortran Syntax:

    SUBROUTINE TecUtilConnectGetShareZoneSet(
   &           Zone,
   &           ResultPtr)
    INTEGER*4       Zone
    POINTER         (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.ConnectGetShareZoneSet(Zone)

  Input:
                  Zone                 int
  Output:
    Results[0]    ReturnVal            sequence of ints

Boolean_t TecUtilCreateCircularZone	(	LgIndex_t	IMax,
		LgIndex_t	JMax,
		LgIndex_t	KMax,
		double	XOrigin,
		double	YOrigin,
		double	Radius,
		double	ZMin,
		double	ZMax,
		FieldDataType_e	FieldDataType
	)

Create a circular (or cylindrical) IJ- or IJK-ordered zone.

If no data set exists when this command is executed, a data set is created with variables X, Y (and Z, if KMAX>1). If a data set exists prior to this command, the non-coordinate variables for the zone created are initialized to zero.

Parameters:

	IMax	I-Dimension of the zone to create. I is in the radial direction.
	JMax	J-Dimension of the zone to create. J is in the circumferential direction.
	KMax	K-Dimension of the zone to create. K is in the Z-direction. Set K to 1 to create a circle
	XOrigin	X-Origin for the circle or cylinder.
	YOrigin	Y-Origin for the circle or cylinder.
	Radius	Radius of the circle or cylinder
	ZMin	Z-Min value used when creating a cylinder
	ZMax	Z-Max value used when creating a cylinder
	FieldDataType	Data type for the variables in the new zone. The possible choices are: FieldDataType_Float, FieldDataType_Double, FieldDataType_Int32, FieldDataType_Int16, FieldDataType_Bit, FieldDataType_Byte, or FieldDataType_Invalid. If set to FieldDataType_Invalid, Tecplot will choose the type for you.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilCreateCircularZone(
   &                   IMax,
   &                   JMax,
   &                   KMax,
   &                   XOrigin,
   &                   YOrigin,
   &                   Radius,
   &                   ZMin,
   &                   ZMax,
   &                   FieldDataType)
    INTEGER*4       IMax
    INTEGER*4       JMax
    INTEGER*4       KMax
    REAL*8          XOrigin
    REAL*8          YOrigin
    REAL*8          Radius
    REAL*8          ZMin
    REAL*8          ZMax
    INTEGER*4       FieldDataType

Python Syntax:

  Results = TecUtil.CreateCircularZone(IMax, JMax, KMax, XOrigin, YOrigin, Radius, ZMin, ZMax, FieldDataType)

  Input:
                  IMax                 int
                  JMax                 int
                  KMax                 int
                  XOrigin              double
                  YOrigin              double
                  Radius               double
                  ZMin                 double
                  ZMax                 double
                  FieldDataType        FieldDataType_e  (defined in TecVals.py)
  Output:
    Results[0]    ReturnVal            boolean

Create a circular 10 by 20 IJ-ordered zone centered at (5, 5) with a radius of two:

   Boolean_t IsOk;
   
   IsOk = TecUtilCreateCircularZone(10,20,1,
                                    5.0,5.0,2.0,
                                    0.0,0.0,
                                    FieldDataType_Float);

Create a cylindrical 5 by 6 by 8 IJK-ordered zone with the bottom centered at (4, 4, 0) and the top centered at (4, 4, 7) and a radius of three:

   IsOk = TecUtilCreateCircularZone(5,6,8,
                                    4.0,4.0,3.0,
                                    0.0,7.0,
                                    FieldDataType_Float);

Boolean_t TecUtilCreateContourLineZones ( void )

Create zones from contour lines.

Contour lines will only come from those zones with a contour style set to contour lines or lines and flood. One zone will be made from each contour level. The resulting zones are of type FE-Triangle.

Returns:: TRUE if successful, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilCreateContourLineZones()

Python Syntax:

  Results = TecUtil.CreateContourLineZones()

  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilCreateContourLineZonesX ( ArgList_pa ArgList )

Create zones from contour lines.

Parameters:

ArgList

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

Arglist Values

SV_CONTLINECREATEMODE

Type:	ContCreateMode_e
Arg Function:	TecUtilArgListAppendInt()
Default:	ContLineCreateMode_OneZonePerContourLevel
Required:	No
Notes:	Possible values: ContLineCreateMode_OneZonePerCountourLevel or ContLineCreateMode_OneZonePerIndependentPolyline.

Returns:: TRUE if create zone successful, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilCreateContourLineZonesX(ArgListPtr)
    POINTER (ArgListPtr, ArgList)

Python Syntax:

  Results = TecUtil.CreateContourLineZonesX(ArgList)

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

ArgList_pa ArgList;

   TecUtilLockStart(AddOnID);
   ArgList = TecUtilArgListAlloc();
   
   TecUtilArgListAppendInt(ArgList, SV_CONTLINECREATEMODE, (LgIndex_t)ContLineCreateMode_OneZonePerContourLevel);
   
   TecUtilCreateContourLineZonesX(ArgList);
   
   TecUtilArgListDealloc(&ArgList);
   TecUtilLockFinish(AddOnID);

Boolean_t TecUtilCreateFEBoundary	(	EntIndex_t	SourceZone,
		Boolean_t	RemoveBlankedSurfaces
	)

Finite element volume boundaries cannot be turned on or off using the edge plot layer in Tecplot.

You can, however, create a separate zone which is a FE surface zone of the volume boundary. This new zone can then be turned on or off. One requirement for this function to work correctly is that adjacent cells must share the same node points along their common boundary.

Parameters:

	SourceZone	Zone to use. This must be a finite-element zone.
	RemoveBlankedSurfaces	If blanking is turned on, do not include faces of cells that border on blanked regions in the set of faces that become the resulting finite-element boundary zone.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilCreateFEBoundary(
   &                   SourceZone,
   &                   RemoveBlankedSurfaces)
    INTEGER*4       SourceZone
    INTEGER*4       RemoveBlankedSurfaces

Python Syntax:

  Results = TecUtil.CreateFEBoundary(SourceZone, RemoveBlankedSurfaces)

  Input:
                  SourceZone           int
                  RemoveBlankedSurfaces boolean
  Output:
    Results[0]    ReturnVal            boolean

Create a separate zone which is the boundary of the first zone:

    TecUtilCreateFEBoundary(1,TRUE);
   // zone 1 must be finite element

Boolean_t TecUtilCreateIsoZones ( void )

Create finite element surface zones out of iso-surfaces in volume zones.

One zone will be made for each contour level.

Returns:: TRUE if successfull, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilCreateIsoZones()

Python Syntax:

  Results = TecUtil.CreateIsoZones()

  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilCreateMirrorZones	(	Set_pa	SourceZones,
		char	MirrorVar
	)

Create new zones that are mirror images of the source zones.

Parameters:

	SourceZones	Set of zones to mirror. A separate new zone is created for each zone in the set. Pass NULL to mirror all zones
	MirrorVar	Variable to negate. Use the following table to determine the value of MirrorVarin 2-D: Mirror about: MirrorVarX-Axis 'Y'Y-Axis 'X'in 3-D: Mirror about: MirrorVarX-Y Plane 'Z'Y-Z Plane 'X'X-Z Plane 'Y'

Returns:: TRUE if successfull, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilCreateMirrorZones(
   &                   SourceZonesPtr,
   &                   MirrorVar)
    POINTER         (SourceZonesPtr, SourceZones)
    CHARACTER*(*)   MirrorVar

Python Syntax:

  Results = TecUtil.CreateMirrorZones(SourceZones, MirrorVar)

  Input:
                  SourceZones          sequence of ints
                  MirrorVar            int
  Output:
    Results[0]    ReturnVal            boolean

Create two mirror zones about the X-axis:

   Set_pa set = TecUtilSetAlloc(FALSE);
   if (set)
   {
     TecUtilSetAddMember(set,1,FALSE); // mirror zones 1 and 2 
     TecUtilSetAddMember(set,2,FALSE);
   
     TecUtilCreateMirrorZones(set,'X');
     TecUtilSetDealloc(&set);
   }

Boolean_t TecUtilCreateRectangularZone	(	LgIndex_t	IMax,
		LgIndex_t	JMax,
		LgIndex_t	KMax,
		double	XMin,
		double	YMin,
		double	ZMin,
		double	XMax,
		double	YMax,
		double	ZMax,
		FieldDataType_e	FieldDataType
	)

Create a rectangular zone.

If no data set exists when this command is executed, a data set is created with variables X, Y (and Z, if KMAX>1). If a data set exists prior to this command, the non-coordinate variables for the zone created are initialized to zero.

Parameters:

	IMax	I-Dimension of the zone to create.
	JMax	J-Dimension of the zone to create.
	KMax	K-Dimension of the zone to create.
	XMin	X min (occurs at I = 1) for the recangular zone.
	YMin	Y min (occurs at J = 1) for the recangular zone.
	ZMin	Z min (occurs at K = 1) for the recangular zone.
	XMax	X max (occurs at I = I-Max) for the recangular zone.
	YMax	Y max (occurs at J = J-Max) for the recangular zone.
	ZMax	Z max (occurs at K = K-Max) for the recangular zone.
	FieldDataType	Data type for the variables in the new zone. The possible choices are: FieldDataType_Float, FieldDataType_Double, FieldDataType_Int32, FieldDataType_Int16, FieldDataType_Bit, FieldDataType_Byte, or FieldDataType_Invalid. If set to FieldDataType_Invalid, Tecplot will choose the type for you.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilCreateRectangularZone(
   &                   IMax,
   &                   JMax,
   &                   KMax,
   &                   XMin,
   &                   YMin,
   &                   ZMin,
   &                   XMax,
   &                   YMax,
   &                   ZMax,
   &                   FieldDataType)
    INTEGER*4       IMax
    INTEGER*4       JMax
    INTEGER*4       KMax
    REAL*8          XMin
    REAL*8          YMin
    REAL*8          ZMin
    REAL*8          XMax
    REAL*8          YMax
    REAL*8          ZMax
    INTEGER*4       FieldDataType

Python Syntax:

  Results = TecUtil.CreateRectangularZone(IMax, JMax, KMax, XMin, YMin, ZMin, XMax, YMax, ZMax, FieldDataType)

  Input:
                  IMax                 int
                  JMax                 int
                  KMax                 int
                  XMin                 double
                  YMin                 double
                  ZMin                 double
                  XMax                 double
                  YMax                 double
                  ZMax                 double
                  FieldDataType        FieldDataType_e  (defined in TecVals.py)
  Output:
    Results[0]    ReturnVal            boolean

Create a 16 by 8 by 2 zone that is specified from zero to one in all directions:

   Boolean_t ISOK;
   ISOK = TecUtilCreateRectangularZone(16,  // imax 
                                     8,     // jmax 
                                     2,     // kmax 
                                     0,0,0, // x,y,z min 
                                     1,1,1, // x,y,z max 
                                     FieldDataType_Float);

FORTRAN EXAMPLE: Create 10x10x10 zone:

   IErr = TecUtilCreateRectangularZone(10,10,10,
  &                                    0.0D0,0.0D0,0.0D0,
  &                                    1.0D0,1.0D0,1.0D0,
  &

Boolean_t TecUtilCreateSimpleXYZone	(	LgIndex_t	NumPoints,
		const double *	XValues,
		const double *	YValues,
		FieldDataType_e	FieldDataType
	)

Deprecated:: Please use TecUtilCreateSimpleZone() instead.

Boolean_t TecUtilCreateSimpleZone	(	LgIndex_t	NumPoints,
		const double *	V1Values,
		const double *	V2Values,
		FieldDataType_e	FieldDataType
	)

Create a new zone by specifying only a list of XY pairs of data.

If other zones exist prior to using this function and there are more than two variables, then the additional variables are also created and set to zero.

Parameters:

	NumPoints	Number of XY pairs of data.
	V1Values	Array of X (or theta) values for the zone.
	V2Values	Array of Y (or R) values for the zone.
	FieldDataType	Data type for the variables in the new zone. The possible choices are: FieldDataType_Float, FieldDataType_Double, FieldDataType_Int32, FieldDataType_Int16, FieldDataType_Bit, FieldDataType_Byte, or FieldDataType_Invalid. If set to FieldDataType_Invalid, Tecplot will choose the type for you.

Returns:: TRUE if the zone could be created, FALSE if not.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilCreateSimpleZone(
   &                   NumPoints,
   &                   V1Values,
   &                   V2Values,
   &                   FieldDataType)
    INTEGER*4       NumPoints
    REAL*8          V1Values
    REAL*8          V2Values
    INTEGER*4       FieldDataType

Python Syntax:

  Results = TecUtil.CreateSimpleZone(NumPoints, V1Values, V2Values, FieldDataType)

  Input:
                  NumPoints            int
                  V1Values             list of doubles
                  V2Values             list of doubles
                  FieldDataType        FieldDataType_e  (defined in TecVals.py)
  Output:
    Results[0]    ReturnVal            boolean

Create a zone containing three points: (0.0, 1.0), (1.0, 1.1), and (2.0, 1.3):

   double xarray[3] = {0.0, 1.0, 2.0};
   double yarray[3] = {1.0, 1.1, 1.3);
   Boolean_t IsOk;
   IsOk = TecUtilCreateSimpleZone(3, xarray, yarray,
                                  FieldDataType_Float);

Boolean_t TecUtilCreateSliceZone	(	double	OriginX,
		double	OriginY,
		double	OriginZ,
		double	NormalX,
		double	NormalY,
		double	NormalZ
	)

Deprecated:: Please use TecUtilCreateSliceZoneFromPlane() instead.

Boolean_t TecUtilCreateSliceZoneFromPlane	(	SliceSource_e	SliceSource,
		double	OriginX,
		double	OriginY,
		double	OriginZ,
		double	NormalX,
		double	NormalY,
		double	NormalZ
	)

Create a new zone as a slice through the currently active zones that match the specified slice source and are intersected by a slice plane having the specified origin and normal.

Parameters:

	SliceSource	Source for slicing. The possible choices are:SliceSource_SurfaceZonesSliceSource_VolumeZonesSliceSource_SurfacesOfVolumeZones
	OriginX	X-Coordinate for the slicing plane origin.
	OriginY	Y-Coordinate for the slicing plane origin.
	OriginZ	Z-Coordinate for the slicing plane origin.
	NormalX	X-Component for the vector normal to the slicing plane
	NormalY	Y-Component for the vector normal to the slicing plane
	NormalZ	Z-Component for the vector normal to the slicing plane

Returns:: TRUE if the zone is created successfully, FALSE if not.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilCreateSliceZoneFromPlane(
   &                   SliceSource,
   &                   OriginX,
   &                   OriginY,
   &                   OriginZ,
   &                   NormalX,
   &                   NormalY,
   &                   NormalZ)
    INTEGER*4       SliceSource
    REAL*8          OriginX
    REAL*8          OriginY
    REAL*8          OriginZ
    REAL*8          NormalX
    REAL*8          NormalY
    REAL*8          NormalZ

Python Syntax:

  Results = TecUtil.CreateSliceZoneFromPlane(SliceSource, OriginX, OriginY, OriginZ, NormalX, NormalY, NormalZ)

  Input:
                  SliceSource          SliceSource_e  (defined in TecVals.py)
                  OriginX              double
                  OriginY              double
                  OriginZ              double
                  NormalX              double
                  NormalY              double
                  NormalZ              double
  Output:
    Results[0]    ReturnVal            boolean

Slice 3-D volume zones with a the plane X=2.5:

   TecUtilCreateSliceZoneFromPlane(SliceSource_VolumeZones,
                                   2.5, 0.0, 0.0, 
                                   1.0, 0.0, 0.0);

Boolean_t TecUtilCreateSliceZoneFromPlneX ( ArgList_pa ArgList )

Create a zone from a slice taken from a 3D plot.

Parameters:

ArgList

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

Arglist Values

SV_SLICESOURCE

Type:	SliceSource_e
Arg Function:	TecUtilArgListAppendInt()
Default:	SliceSourceVolumeZones
Required:	No

SV_FORCEEXTRACTIONTOSINGLEZONE

Type:	Boolean_t
Arg Function:	TecUtilArgListAppendInt()
Default:	TRUE
Required:	No
Notes:	Boolean value which forces Tecplot to make the taken slice into a single zone if made to be TRUE. This option is turned off with the value of FALSE

SV_COPYCELLCENTEREDVALUES

Type:	Boolean_t
Arg Function:	TecUtilArgListAppendInt()
Default:	FALSE
Required:	No
Notes:	If TRUE, cell-center values will be copied when possible to the extracted slice plane. Cell-centers are copied when a variable is cell-centered for all the source zones through which the slice passes. Otherwise, extracted planes use node-centered data, which is calculated by interpolation.

SV_ORIGINX

Type:	double
Arg Function:	TecUtilArgListAppendDouble()
Required:	Yes
Notes:	Sets the origin values of the created slice zone

SV_ORIGINY

Type:	double
Arg Function:	TecUtilArgListAppendDouble()
Required:	Yes

SV_ORIGINZ

Type:	double
Arg Function:	TecUtilArgListAppendDouble()
Required:	Yes

SV_NORMALX

Type:	double
Arg Function:	TecUtilArgListAppendDouble()
Required:	Yes
Notes:	Sets the normal values of the created slice zone

SV_NORMALY

Type:	double
Arg Function:	TecUtilArgListAppendDouble()
Required:	Yes

SV_NORMALZ

Type:	double
Arg Function:	TecUtilArgListAppendDouble()
Required:	Yes

Returns:: TRUE if animation was successful, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilCreateSliceZoneFromPlneX(ArgListPtr)
    POINTER (ArgListPtr, ArgList)

Python Syntax:

  Results = TecUtil.CreateSliceZoneFromPlneX(ArgList)

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

   ArgList_pa ArgList;
   TecUtilLockStart(AddOnID);
   ArgList = TecUtilArgListAlloc();
   
   TecUtilArgListAppendInt(ArgList,    SV_SLICESOURCE,                 (LgIndex_t)SliceSource_SurfaceZones);
   TecUtilArgListAppendInt(ArgList,    SV_FORCEEXTRACTIONTOSINGLEZONE, (LgIndex_t)TRUE);
   TecUtilArgListAppendInt(ArgList,    SV_COPYCELLCENTEREDVALUES,      (LgIndex_t)TRUE);
   TecUtilArgListAppendDouble(ArgList, SV_ORIGINX,                     0.0);
   TecUtilArgListAppendDouble(ArgList, SV_ORIGINY,                     0.0);
   TecUtilArgListAppendDouble(ArgList, SV_ORIGINZ,                     0.0);
   TecUtilArgListAppendDouble(ArgList, SV_NORMALX,                     0.9);
   TecUtilArgListAppendDouble(ArgList, SV_NORMALY,                     0.9);
   TecUtilArgListAppendDouble(ArgList, SV_NORMALZ,                     0.9);
   
   TecUtilCreateSliceZoneFromPlneX(ArgList);
   
   TecUtilArgListDealloc(&ArgList);
   TecUtilLockFinish(AddOnID);

Boolean_t TecUtilCreateSliceZones ( void )

Create surface zones out of all slices currently defined in volume zones.

One zone is made for each defined slice.

Returns:: TRUE if the zone is created successfully, otherwise FALSE.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilCreateSliceZones()

Python Syntax:

  Results = TecUtil.CreateSliceZones()

  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilCreateSphericalZone	(	LgIndex_t	IMax,
		LgIndex_t	JMax,
		double	XOrigin,
		double	YOrigin,
		double	ZOrigin,
		double	Radius,
		FieldDataType_e	FieldDataType
	)

Create a Spherical IJ-ordered zone.

If no data set exists when this command is executed, a data set is created with variables X, Y and Z. If a data set exists prior to this command, the non-coordinate variables for the zone created are initialized to zero.

Since:: 11.2-0-500

Parameters:

	IMax	I-Dimension of the zone to create. I is in the psi direction, where psi represents the angle from the Z-axis.
	JMax	J-Dimension of the zone to create. J is in the theta direction, where theta represents the angle in the XY-plane.
	XOrigin	X-Origin for the sphere.
	YOrigin	Y-Origin for the sphere.
	ZOrigin	Y-Origin for the sphere.
	Radius	Radius of the sphere.
	FieldDataType	Data type for the variables in the new zone. The possible choices are: FieldDataType_Float, FieldDataType_Double, FieldDataType_Int32, FieldDataType_Int16, FieldDataType_Bit, FieldDataType_Byte, or FieldDataType_Invalid. If set to FieldDataType_Invalid, Tecplot will choose the type for you.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilCreateSphericalZone(
   &                   IMax,
   &                   JMax,
   &                   XOrigin,
   &                   YOrigin,
   &                   ZOrigin,
   &                   Radius,
   &                   FieldDataType)
    INTEGER*4       IMax
    INTEGER*4       JMax
    REAL*8          XOrigin
    REAL*8          YOrigin
    REAL*8          ZOrigin
    REAL*8          Radius
    INTEGER*4       FieldDataType

Python Syntax:

  Results = TecUtil.CreateSphericalZone(IMax, JMax, XOrigin, YOrigin, ZOrigin, Radius, FieldDataType)

  Input:
                  IMax                 int
                  JMax                 int
                  XOrigin              double
                  YOrigin              double
                  ZOrigin              double
                  Radius               double
                  FieldDataType        FieldDataType_e  (defined in TecVals.py)
  Output:
    Results[0]    ReturnVal            boolean

Create a Spherical 10 by 20 IJ-ordered zone centered at (5,6,7) with a radius of two:

   Boolean_t IsOk;
   
   IsOk = TecUtilCreateSphericalZone(10,20,
                                     5.0,6.0,7.0,
                                     2.0,
                                     FieldDataType_Float);

Boolean_t TecUtilCreateStreamZones ( Boolean_t ConcatenateStreams )

Create one or more zones out of the currently defined streamtraces.

The new zones have the same number of variables per data point as the other zones in the data set with all non-coordinate variables interpolated at the positions along the streamtrace.

Parameters:

ConcatenateStreams

Set to TRUE to create a single zone out of all common streamtraces. The cell that connects the end of one streamtrace with the beginning of the next can later be turned off using value-blanking

Returns:: TRUE if the zone could be created, FALSE if not.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilCreateStreamZones(ConcatenateStreams)
    INTEGER*4 ConcatenateStreams

Python Syntax:

  Results = TecUtil.CreateStreamZones(ConcatenateStreams)

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

Boolean_t TecUtilCurveRegisterExtCrvFit	(	const char *	CurveFitName,
		GetLinePlotDataPointsCallback_pf	GetLinePlotDataPointsCallback,
		GetProbeValueCallback_pf	GetProbeValueCallback,
		GetCurveInfoStringCallback_pf	GetCurveInfoStringCallback,
		GetCurveSettingsCallback_pf	GetCurveSettingsCallback,
		GetAbbreviatedSettingsStringCallback_pf	GetAbbreviatedSettingsStringCallback
	)

Registers an extended curve fit add-on.

This will add an option to the single selection list launched by the Curve Type/Extended option on the Curves page of the Plot Attributes dialog.

Parameters:

	CurveFitName	Unique name given to the extended curve fit. This name is used in the list of extended curve fits in the Extended Curve Fits dialog, launched from Curve Type/Extended in the Plot Attributes dialog.
	GetLinePlotDataPointsCallback	The name of the function that will calculate the curve fit. This is the only function that needs to be defined to create an extended curve fit add-on.
	GetProbeValueCallback	The name of the function that will return the dependent value when the extended curve fit is probed at a given independent value. If this function is set to NULL, Tecplot will perform a linear interpolation based on the values returned by the GetLinePlotDataPoints function.
	GetCurveInfoStringCallback	The name of the function that will create a string to be presented in the Data/LinePlot Curve Info dialog. This callback may be set to NULL if you do not wish to present a string to the LinePlot Curve Info dialog.
	GetCurveSettingsCallback	The name of the function that is called when the Curve Settings button on the Curves page of the Plot Attributes dialog is pressed while the extended curve fit is set as the Curve Type. This function may be set to NULL if there are not configurable settings for the extended curve fit. If settings are changed, it is the responsibility of the add-on writer to inform Tecplot of the change by calling the function TecUtilCurveSetExtendedSettings(). This function is usually called when OK is clicked on the add-on dialog.
	GetAbbreviatedSettingsStringCallback	See GetAbbreviatedSettingsStringCallback_pf.

Returns:: Returns TRUE if the extended curve fit was added.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilCurveRegisterExtCrvFit(
   &                   CurveFitName,
   &                   GetLinePlotDataPointsCallback,
   &                   GetProbeValueCallback,
   &                   GetCurveInfoStringCallback,
   &                   GetCurveSettingsCallback,
   &                   GetAbbreviatedSettingsStringCallback)
    CHARACTER*(*)   CurveFitName
    POINTER         (GetLinePlotDataPointsCallbackPtr, GetLinePlotDataPointsCallback)
    POINTER         (GetProbeValueCallbackPtr, GetProbeValueCallback)
    POINTER         (GetCurveInfoStringCallbackPtr, GetCurveInfoStringCallback)
    POINTER         (GetCurveSettingsCallbackPtr, GetCurveSettingsCallback)
    POINTER         (GetAbbreviatedSettingsStringCallbackPtr, GetAbbreviatedSettingsStringCallback)

Python Syntax:

    This function is not supported in Python.

SetValueReturnCode_e TecUtilCurveSetExtendedSettings	(	EntIndex_t	LineMapNum,
		const char *	Settings
	)

Sets the extended curve fit settings for the set of Line-maps selected in the Plot Attributes dialog.

Parameters:

	LineMapNum	LineMapNum is the map number that is currently being operated on.
	Settings	Settings is the current settings for your extended curve fit. This string will be maintained by Tecplot and saved in layouts.

Returns:: The setvalue return code (of type SetValueReturnCode_e).

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilCurveSetExtendedSettings(
   &                   LineMapNum,
   &                   Settings)
    INTEGER*4       LineMapNum
    CHARACTER*(*)   Settings

Python Syntax:

  Results = TecUtil.CurveSetExtendedSettings(LineMapNum, Settings)

  Input:
                  LineMapNum           int
                  Settings             string
  Output:
    Results[0]    ReturnVal            SetValueReturnCode_e  (defined in TecVals.py)

Boolean_t TecUtilCurveWriteInfo	(	const char *	FileName,
		EntIndex_t	LineMap,
		CurveInfoMode_e	CurveInfoMode
	)

Write out the coefficients or the calculated data points for the equations used to draw the curve for a selected line-mapping.

Parameters:

	FileName	File name. Must not be NULL
	LineMap	The number of a line-mapping that does some type of curve fit or spline
	CurveInfoMode	The possible values are: CurveInfoMode_Coefficients, CurveInfoMode_RawData, and CurveInfoMode_Macro

Returns:: TRUE if the curve information wrote, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilCurveWriteInfo(
   &                   FileName,
   &                   LineMap,
   &                   CurveInfoMode)
    CHARACTER*(*)   FileName
    INTEGER*4       LineMap
    INTEGER*4       CurveInfoMode

Python Syntax:

  Results = TecUtil.CurveWriteInfo(FileName, LineMap, CurveInfoMode)

  Input:
                  FileName             string
                  LineMap              int
                  CurveInfoMode        CurveInfoMode_e  (defined in TecVals.py)
  Output:
    Results[0]    ReturnVal            boolean

Write out the coefficients for line-mapping number 3 to the file map3.out:

   Boolean_t IsOk;
   IsOk = TecUtilCurveWriteInfo("map3.out", 3,CurveInfoMode_Coefficients);

Boolean_t TecUtilDataAlter	(	const char *	Equation,
		Set_pa	ZoneSet,
		LgIndex_t	IMin,
		LgIndex_t	IMax,
		LgIndex_t	ISkip,
		LgIndex_t	JMin,
		LgIndex_t	JMax,
		LgIndex_t	JSkip,
		LgIndex_t	KMin,
		LgIndex_t	KMax,
		LgIndex_t	KSkip,
		FieldDataType_e	DestDataType
	)

Operates on a data set within Tecplot using FORTRAN-like equations.

See Section 8.2, "Data Alteration through Equations," in the Tecplot User's Manual for more information on using equations in Tecplot.

Parameters:

	Equation	String containing the equation
	ZoneSet	Set of zones to operate on. Pass NULL to operate on all zones
	IMin	Operate on values starting at an I-Index range of IMin. Set to 1 when operating on the entire range.
	IMax	Operate on values ending at an I-Index range of IMax. Set to 0 to specify the maximum I index.
	ISkip	Operate on values skipping by ISkip in the I-Direction. Set to 0 to specify one less than the maximum I index range.
	JMin	See IMin.
	JMax	See IMax.
	JSkip	See ISkip.
	KMin	See IMin.
	KMax	See IMax.
	KSkip	See ISkip.
	DestDataType	Data type for the variable on the left hand side. This is used only if this variable is being created for the first time. The possible choices are: FieldDataType_Float, FieldDataType_Double, FieldDataType_Int32, FieldDataType_Int16, FieldDataType_Bit, FieldDataType_Byte, or FieldDataType_Invalid. If set to FieldDataType_Invalid, Tecplot will choose the type for you.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataAlter(
   &                   Equation,
   &                   ZoneSetPtr,
   &                   IMin,
   &                   IMax,
   &                   ISkip,
   &                   JMin,
   &                   JMax,
   &                   JSkip,
   &                   KMin,
   &                   KMax,
   &                   KSkip,
   &                   DestDataType)
    CHARACTER*(*)   Equation
    POINTER         (ZoneSetPtr, ZoneSet)
    INTEGER*4       IMin
    INTEGER*4       IMax
    INTEGER*4       ISkip
    INTEGER*4       JMin
    INTEGER*4       JMax
    INTEGER*4       JSkip
    INTEGER*4       KMin
    INTEGER*4       KMax
    INTEGER*4       KSkip
    INTEGER*4       DestDataType

Python Syntax:

  Results = TecUtil.DataAlter(Equation, ZoneSet, IMin, IMax, ISkip, JMin, JMax, JSkip, KMin, KMax, KSkip, DestDataType)

  Input:
                  Equation             string
                  ZoneSet              sequence of ints
                  IMin                 int
                  IMax                 int
                  ISkip                int
                  JMin                 int
                  JMax                 int
                  JSkip                int
                  KMin                 int
                  KMax                 int
                  KSkip                int
                  DestDataType         FieldDataType_e  (defined in TecVals.py)
  Output:
    Results[0]    ReturnVal            boolean

Add 2 to X in zones 1 and 3. Operate only data points where J is greater than or equal to three and less than or equal to ten:

   if (TecUtilDataSetIsAvailable())
     {
       Set_pa    ZoneSet;
       Boolean_t IsOk = FALSE;
       ZoneSet = TecUtilSetAlloc(TRUE);
   
       if (ZoneSet)
         {
           TecUtilSetAddMember(ZoneSet,1,TRUE);
           TecUtilSetAddMember(ZoneSet,3,TRUE);
   
           IsOk = TecUtilDataAlter("X = X + 2",
                                   ZoneSet,
                                   1,0,1,  // All I-Values 
                                   3,10,1  // 3 <= J <= 10 
                                   1,0,1,  // All K Values 
                                   FieldDataType_Float);
           TecUtilSetDealloc(&ZoneSet);
         }
     }

Fortran Example. Execute X = X + 2 on all points in all zones:

      POINTER(NullPtr, Null)
      INTEGER*4 IsOk

      NullPtr = 0

      if (TecUtilDataSetIsAvailable().EQ.TRUE) then
        IsOk = TecUtilDataAlter('X = X + 2'//char(0),
     &                          NullPtr,
     &                          1,0,1,
     &                          1,0,1,
     &                          1,0,1,
     &                          FieldDataType_Float)
      Endif

Boolean_t TecUtilDataConnectBranchShared ( EntIndex_t Zone )

Branch the connectivity information.

Returns False if out of memory.

Parameters:

Zone

Zone number where connectivity is to be branched.

Returns:: TRUE if connectivity is branched, FALSE if out of memory.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataConnectBranchShared(Zone)
    INTEGER*4 Zone

Python Syntax:

  Results = TecUtil.DataConnectBranchShared(Zone)

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

EntIndex_t TecUtilDataConnectGetShareCount ( EntIndex_t Zone )

Returns the share count for connectivity for the given zone.

This is the number of times the connectivity is shared. 1 means not shared (shared once), 2 means two zones share it, etc.

Parameters:

Zone

Zone number where connectivity is to be branched.

Returns:: Number of zones sharing connectivity.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataConnectGetShareCount(Zone)
    INTEGER*4 Zone

Python Syntax:

  Results = TecUtil.DataConnectGetShareCount(Zone)

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

Boolean_t TecUtilDataConnectIsSharingOk	(	EntIndex_t	SourceZone,
		EntIndex_t	DestZone
	)

Determine if it is ok to share the connectivity between zones.

Parameters:

	SourceZone	The source zone (the zone where the values will be stored).
	DestZone	The destination zone (the zone acquiring the shared values).

Returns:: Returns TRUE if the specified connectivity sharing is allowed, FALSE if otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataConnectIsSharingOk(
   &                   SourceZone,
   &                   DestZone)
    INTEGER*4       SourceZone
    INTEGER*4       DestZone

Python Syntax:

  Results = TecUtil.DataConnectIsSharingOk(SourceZone, DestZone)

  Input:
                  SourceZone           int
                  DestZone             int
  Output:
    Results[0]    ReturnVal            boolean

If sharing is ok for connectivity between zones 3 and 5 then share the connectivity.

   if (TecUtilDataConnectIsSharingOk(3,5))
     TecUtilDataConnectShare(3,5);

See also:: TecUtilDataSetIsSharingAllowed() and TecUtilDataValueIsSharingOk().

void TecUtilDataConnectShare	(	EntIndex_t	SourceZone,
		EntIndex_t	DestZone
	)

Sets the properties of the connectivity so that it is shared between source and destination zones (using the source for values).

Both zones must have the same structure (both Ordered with the same I,J, and K values; or both are finite-elements with the same element type and same number of nodes). Both zones must also have the same local face neighbor mode.

Parameters:

	SourceZone	The zone number where the connectivity is based.
	DestZone	The zone number where the connectivity will be shared from the source zone.

Fortran Syntax:

    SUBROUTINE TecUtilDataConnectShare(
   &           SourceZone,
   &           DestZone)
    INTEGER*4       SourceZone
    INTEGER*4       DestZone

Python Syntax:

  Results = TecUtil.DataConnectShare(SourceZone, DestZone)

  Input:
                  SourceZone           int
                  DestZone             int
  Output:
    Results[0]    ReturnVal            NONE

Set the connectivity in zone 3 to be shared with zone 2:

   TecUtilDataConnectShare(2, 3);

LgIndex_t TecUtilDataElemGetFace	(	ElemToFaceMap_pa	ElemToFaceMap,
		LgIndex_t	Elem,
		ElemFaceOffset_t	FaceOffset
	)

Gets the specified face number for the specified polyhedral or polygonal element.

Since:: 11.2-1-0

Parameters:

	ElemToFaceMap	The element-to-face map handle
	Elem	The element for which to return the number of faces.
	FaceOffset	The face offset for which to return the face number. Must be in the range [1, n], where n is the number of faces returned by TecUtilDataElemGetNumFaces for the specified element.

Returns:: The face number for the element.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataElemGetNumFaces (
   &           ElemToFaceMapPtr,
   &           Elem,
   &           FaceOffset)
    POINTER   (ElemToFaceMapPtr, ElemToFaceMap)
    INTEGER*4 Elem
    INTEGER*4 FaceOffset

Python Syntax:

  Results = TecUtil.DataElemGetFace(ElemToFaceMap, Elem, FaceOffset)

  Input:
                  ElemToFaceMap        opaque pointer
                  Elem                 int
                  FaceOffset           int
  Output:
    Results[0]    ReturnVal            int

LgIndex_t TecUtilDataElemGetNumFaces	(	ElemToFaceMap_pa	ElemToFaceMap,
		LgIndex_t	Elem
	)

Gets the number of faces that comprise the specified polyhedral or polygonal element.

Since:: 11.2-1-0

Parameters:

	ElemToFaceMap	The element-to-face map handle
	Elem	The element for which to return the number of faces.

Returns:: The number of faces that comprise the element.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataElemGetNumFaces (
   &           ElemToFaceMapPtr,
   &           Elem)
    POINTER   (ElemToFaceMapPtr, ElemToFaceMap)
    INTEGER*4 Elem

Python Syntax:

  Results = TecUtil.DataElemGetNumFaces(ElemToFaceMap, Elem)

  Input:
                  ElemToFaceMap        opaque pointer
                  Elem                 int
  Output:
    Results[0]    ReturnVal            int

ElemToFaceMap_pa TecUtilDataElemGetReadableRef ( EntIndex_t Zone )

Gets a readable element-to-face mapping for the specified polyhedral or polygonal zone of the current frame.

Since:: 11.2-1-0

Parameters:

Zone

Polyhedral or polygonal zone number.

Returns:: A readable element-to-face mapping for the specified polyhedral or polygonal zone or NULL if unsuccessful.

Fortran Syntax:

    SUBROUTINE TecUtilDataElemGetReadableRef (
   &           Zone,
   &           ElemToFaceMapPtr)
    INTEGER*4 Zone
    POINTER   (ElemToFaceMapPtr, ElemToFaceMap)

Python Syntax:

  Results = TecUtil.DataElemGetReadableRef(Zone)

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

Boolean_t TecUtilDataFaceMapAlloc	(	EntIndex_t	Zone,
		LgIndex_t	NumFaces,
		LgIndex_t	NumFaceNodes,
		LgIndex_t	NumFaceBndryFaces,
		LgIndex_t	NumFaceBndryConns
	)

Allocates the space needed for the face mapping.

Since:: 11.2-1-0

Parameters:

	Zone	The zone needing the face mapping allocated.
	NumFaces	Total number of unique faces.
	NumFaceNodes	Total number of nodes for all faces. This is not the number of unique nodes but the total number. For example if a face map defined two triangles polygons that share a common face, NumFaces would be 5 and NumFaceNodes would be 6, not 4.
	NumFaceBndryFaces	Total number of faces boundary faces.
	NumFaceBndryConns	Total number of boundary face elements or boundary face element/zone pairs.

Returns:: TRUE if the face mapping was successfully allocated, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataFaceMapAlloc(
   &                   Zone,
   &                   NumFaces,
   &                   NumFaceNodes,
   &                   NumFaceBndryFaces,
   &                   NumFaceBndryConns)
    INTEGER*4       Zone
    INTEGER*4       NumFaces
    INTEGER*4       NumFaceNodes
    INTEGER*4       NumFaceBndryFaces
    INTEGER*4       NumFaceBndryConns

Python Syntax:

  Results = TecUtil.DataFaceMapAlloc(Zone, NumFaces, NumFaceNodes, NumFaceBndryFaces, NumFaceBndryConns)

  Input:
                  Zone                 int
                  NumFaces             int
                  NumFaceNodes         int
                  NumFaceBndryFaces    int
                  NumFaceBndryConns    int
  Output:
    Results[0]    ReturnVal            boolean

Allocate the face map of zone 3.

   IsOk = TecUtilDataFaceMapAlloc(3,
                                  NumFaces, NumFaceNodes,
                                  NumFaceBndryFaces, NumFaceBndryConns);

See also:: TecUtilDataConnectShare(), TecUtilDataFaceMapCustomLOD()

void TecUtilDataFaceMapAssignBConns	(	FaceMap_pa	FaceMap,
		LgIndex_t	NumBndryFaces,
		const LgIndex_t *	NumBndryConns,
		const LgIndex_t *	FaceBndryElems,
		const EntIndex_t *	FaceBndryElemZones
	)

Assigns the supplied boundary connected elements and zones to the open face-mapping assignment context.

The boundary faces were assigned using a negative number for the left or right element of the face.

Since:: 11.2-1-0

Parameters:

	FaceMap	An open face-mapping assignment context to which the boundary face elements (and zones if appropriate) are assigned.
	NumBndryFaces	The number of boundary faces being delivered.
	NumBndryConns	Array of boundary connection counts dimensioned by NumBndryFaces.
	FaceBndryElems	Array of boundary connected elements for the supplied faces dimensioned by the sum of the members of the NumBndryConns array. If only a portion of a boundary face has adjacent elements, use TECUTIL_NO_NEIGHBORING_ELEM for the first neighboring element, and follow this with the actual elements.
	FaceBndryElemZones	Array of zone numbers indicating which zone each of the elements in the FaceBndryElems array resides in. It has the same dimension as the FaceBndryElems array. For boundary faces that are only partially bounded by neighboring elements (indicated by TECUTIL_NO_NEIGHBORING_ELEM in the FaceBndryElems array), use TECUTIL_NO_NEIGHBORING_ZONE for the zone numbers corresponding to the 0-th entry in FaceBndryElems. Also use TECUTIL_NO_NEIGHBORING_ZONE to indicate the boundary element is in the current zone (do not use the current zone number).

Fortran Syntax:

    SUBROUTINE TecUtilDataFaceMapAssignBConns (
   &           FaceMapPtr,
   &           NumBndryFaces,
   &           NumBndryConns,
   &           FaceBndryElems,
   &           FaceBndryElemZones)
    POINTER   (FaceMapPtr, FaceMap)
    INTEGER*4 NumBndryFaces
    INTEGER*4 NumBndryConns(*)
    INTEGER*4 FaceBndryElems(*)
    INTEGER*4 FaceBndryElemZones(*)

Python Syntax:

  Results = TecUtil.DataFaceMapAssignBConns(FaceMap, NumBndryFaces, NumBndryConns, FaceBndryElems, FaceBndryElemZones)

  Input:
                  FaceMap              opaque pointer
                  NumBndryFaces        int
                  NumBndryConns        list of ints
                  FaceBndryElems       list of ints
                  FaceBndryElemZones   list of ints
  Output:
    Results[0]    ReturnVal            NONE

void TecUtilDataFaceMapAssignElems	(	FaceMap_pa	FaceMap,
		LgIndex_t	NumFaces,
		const LgIndex_t *	FaceLeftElems,
		const LgIndex_t *	FaceRightElems
	)

Assigns the supplied face left and right elements to the open face-mapping assignment context.

The faces for the elements are implicitly given sequential face numbers. Calls to this routine may be intermingled with calls to TecUtilDataFaceMapAssignNodes. The only requirement is that the nodes and elements be delivered in the same order. That is, the nth face defined by TecUtilDataFaceMapAssignNodes must correspond to the nth pair of neighboring elements passed into TecUtilDataFaceMapAssignElems.

Since:: 11.2-1-0

Parameters:

	FaceMap	An open face-mapping assignment context to which the face left and right elements are assigned.
	NumFaces	The number of faces being delivered.
	FaceLeftElems	Array of face left elements for the supplied faces dimensioned by NumFaces.
	FaceRightElems	Array of face right elements for the supplied faces dimensioned by NumFaces.

Fortran Syntax:

    SUBROUTINE TecUtilDataFaceMapAssignElems (
   &           FaceMapPtr,
   &           NumFaces,
   &           FaceLeftElems,
   &           FaceRightElems)
    POINTER   (FaceMapPtr, FaceMap)
    INTEGER*4 NumFaces
    INTEGER*4 FaceLeftElems(*)
    INTEGER*4 FaceRightElems(*)

Python Syntax:

  Results = TecUtil.DataFaceMapAssignElems(FaceMap, NumFaces, FaceLeftElems, FaceRightElems)

  Input:
                  FaceMap              opaque pointer
                  NumFaces             int
                  FaceLeftElems        list of ints
                  FaceRightElems       list of ints
  Output:
    Results[0]    ReturnVal            NONE

void TecUtilDataFaceMapAssignNodes	(	FaceMap_pa	FaceMap,
		LgIndex_t	NumFaces,
		const LgIndex_t *	NumFaceNodes,
		const LgIndex_t *	FaceNodes
	)

Assigns the supplied face nodes to the open face-mapping assignment context.

The faces for the nodes are implicitly given sequential face numbers. This function can deliver all the face nodes at once or one or more faces at a time. Calls to this routine may be intermingled with calls to TecUtilDataFaceMapAssignElems. The only requirement is that the nodes and elements be delivered in the same order. That is, the nth face defined by TecUtilDataFaceMapAssignNodes must correspond to the nth pair of neighboring elements passed into TecUtilDataFaceMapAssignElems.

Since:: 11.2-1-0

Parameters:

	FaceMap	An open face-mapping assignment context to which the face nodes are assigned.
	NumFaces	The number of faces being delivered.
	NumFaceNodes	Array of face nodes counts dimensioned by NumFaces.
	FaceNodes	Array of face nodes for the supplied faces dimensioned by the sum of the members of the NumFaceNodes array.

Fortran Syntax:

    SUBROUTINE TecUtilDataFaceMapAssignNodes (
   &           FaceMapPtr,
   &           NumFaces,
   &           NumFaceNodes,
   &           FaceNodes)
    POINTER   (FaceMapPtr, FaceMap)
    INTEGER*4 NumFaces
    INTEGER*4 NumFaceNodes(*)
    INTEGER*4 FaceNodes(*)

Python Syntax:

  Results = TecUtil.DataFaceMapAssignNodes(FaceMap, NumFaces, NumFaceNodes, FaceNodes)

  Input:
                  FaceMap              opaque pointer
                  NumFaces             int
                  NumFaceNodes         list of ints
                  FaceNodes            list of ints
  Output:
    Results[0]    ReturnVal            NONE

void TecUtilDataFaceMapBeginAssign ( FaceMap_pa FaceMap )

Opens a face-mapping assignment context.

All face nodes and elements must be delivered between the face map begin/end assignment clause.

Since:: 11.2-1-0

Parameters:

FaceMap

Face mapping to which face nodes and elements are assigned.

Fortran Syntax:

    SUBROUTINE TecUtilDataFaceMapBeginAssign (
   &           FaceMapPtr)
    POINTER   (FaceMapPtr, FaceMap)

Python Syntax:

  Results = TecUtil.DataFaceMapBeginAssign(FaceMap)

  Input:
                  FaceMap              opaque pointer
  Output:
    Results[0]    ReturnVal            NONE

Boolean_t TecUtilDataFaceMapCustomLOD	(	EntIndex_t	Zone,
		LgIndex_t	NumFaces,
		LgIndex_t	NumFaceNodes,
		LgIndex_t	NumFaceBndryFaces,
		LgIndex_t	NumFaceBndryConns,
		LoadOnDemandFaceMapLoad_pf	LoadCallback,
		LoadOnDemandFaceMapUnload_pf	UnloadCallback,
		LoadOnDemandFaceMapCleanup_pf	CleanupCallback,
		ArbParam_t	ClientData
	)

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

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

All callbacks must be written in a thread-safe manner so that Tecplot can make parallel requests to load (and/or unload) multiple face 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 face 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_DEFERVARCREATION option for TecUtilDataSetAddZoneX() and TecUtilDataSetAddVarX() for details.

The method for loading and accessing face 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 face map data into the Tecplot prepared face map backing. Tecplot is responsible for allocating and freeing the space for the face map backing. In addition, the add-on must supply the CleanupCallback() callback to receive notification of when the face map is no longer needed. Optionally, the add-on may supply the UnloadCallback() callback to receive notification of when the face map is being unloaded. Most add-ons should supply NULL for the UnloadCallback() callback, instructing Tecplot to assume responsibility for unloading the face map and re-loading it in an efficient form.

Since:: 11.2-1-0

Parameters:

	Zone	Zone for which the face map will now be custom load-on-demand.
	NumFaces	Total number of unique faces.
	NumFaceNodes	Total number of nodes for all faces. This is not the number of unique nodes but the total number. For example if a face map defined two triangles polygons that share a common face, NumFaces would be 5 and NumFaceNodes would be 6, not 4.
	NumFaceBndryFaces	Total number of faces boundary faces.
	NumFaceBndryConns	Total number of boundary connected elements or element/zone pairs.
	LoadCallback	Tecplot calls this callback when the face map is to be loaded. The LoadCallback() callback may never get called if the face map is not needed or it may get called immediately if load-on-demand capabilities are not available. This callback is called asynchronously. This callback must NOT lock/unlock Tecplot.
	UnloadCallback	Most add-ons will supply NULL for this callback. Supplying NULL instructs Tecplot to handle the unloading (and subsequent reloading) of the face map without the intervention of the add-on. If the add-on does supply this callback, Tecplot calls it when the face map is to be unloaded. This query provides the add-on an opportunity to allow or deny a face 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 face map (i.e. the UnloadCallback() callback should return TRUE). An add-on may also cleanup any private resources that are not needed when the face map is unloaded, however the add-on must still maintain enough information to load the face map again if requested by Tecplot. The UnloadCallback() callback may never get called if the face map does not need to be unloaded nor will the UnloadCallback() callback necessarily be called before the CleanupCallback() callback. This callback is called asynchronously. This callback must NOT lock/unlock Tecplot.
	CleanupCallback	Tecplot calls this callback when the face 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 face map. After a face 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 face map was never loaded. This callback is called asynchronously. This callback must NOT lock/unlock Tecplot.
	ClientData	Private client data needed by the custom load-on-demand callbacks to perform the duties of loading, unloading, and cleaning up the face. Tecplot stores the client data in the face map structure and must be retrieved by the callbacks using TecUtilDataFaceMapGetClientData(). 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.

Following is an example of how to create a face map using the Custom Load on Demand.

   typedef struct
     {
       char      *DataFileName;
       long       SeekOffset;
       ... other information needed to load face map data
     } MyFaceMapClientData_s;

   Boolean_t MyFaceMapLoader(FaceMap_pa FaceMap)
   {
     REQUIRE(VALID_REF(FaceMap));

     MyFaceMapClientData_s *MyClientData = (MyFaceMapClientData_s *)TecUtilDataFaceMapGetClientData(FaceMap);

     // 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 map data is located
     IsOk = IsOk && (fseek(MyDataFile, MyClientData->SeekOffset, SEEK_SET) == 0);
     if (IsOk)
       {
         // load the data into the zone's face map
         IsOk = ReadMyFaceMapDataIntoZone(MyDataFile, MyClientData, FaceMap);
       }

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

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

   Boolean_t MyFaceMapUnload(FaceMap_pa FaceMap)
   {
     REQUIRE(VALID_REF(FaceMap));

     // 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 map.
     Boolean_t Result = TRUE; // ...tell Tecplot to go ahead and unload the face map

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

   void MyFaceMapCleanup(FaceMap_pa FaceMap)
   {
     REQUIRE(VALID_REF(FaceMap));

     MyFaceMapClientData_s *MyClientData = (MyFaceMapClientData_s *)TecUtilDataFaceMapGetClientData(FaceMap);

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

   .
   .
   .
   LgIndex_t NumFaces          = ... // number of unique faces
   LgIndex_t NumFaceNodes      = ... // total number of face nodes
   LgIndex_t NumFaceBndryFaces = ... // total number of boundary faces
   LgIndex_t NumFaceBndryConns = ... // total number of boundary face Connections
   MyFaceMapClientData_s *MyClientData = (MyFaceMapClientData_s *)malloc(sizeof(MyFaceMapClientData_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 map data
   IsOk = TecUtilDataFaceMapCustomLOD(3,
                                      NumFaces,
                                      NumFaceNodes,
                                      NumFaceBndryFaces,
                                      NumFaceBndryConns,
                                      MyFaceMapLoader,
                                      MyFaceMapUnload, // most add-ons should pass NULL instead of MyFaceMapUnload
                                      MyFaceMapCleanup,
                                      (ArbParam_t)MyClientData);

Python Syntax:

    This function is not supported in Python.

See also:: TecUtilDataFaceMapAlloc(), TecUtilDataConnectShare(), TecUtilDataFaceMapBeginAssign(), TecUtilDataFaceMapAssignNodes(), TecUtilDataFaceMapAssignZones(), TecUtilDataFaceMapEndAssign(), TecUtilMemoryChangeNotify()

Boolean_t TecUtilDataFaceMapEndAssign ( FaceMap_pa FaceMap )

Ends a face-mapping assignment sequence.

All face nodes and elements must be delivered between the face map begin/end assignment clause.

Since:: 11.2-1-0

Parameters:

FaceMap

An open face-mapping assignment context to which the face nodes and elements were assigned.

Returns:: TRUE if all face nodes and elements were supplied and the supplied face nodes and left and right elements are within the range of the zone structure, FALSE otherwise.

Fortran Syntax:

    SUBROUTINE TecUtilDataFaceMapEndAssign (
   &           FaceMapPtr)
    POINTER   (FaceMapPtr, FaceMap)

Python Syntax:

  Results = TecUtil.DataFaceMapEndAssign(FaceMap)

  Input:
                  FaceMap              opaque pointer
  Output:
    Results[0]    ReturnVal            boolean

void TecUtilDataFaceMapGetBndryConn	(	FaceMap_pa	FaceMap,
		LgIndex_t	Face,
		LgIndex_t	BndryConnOffset,
		LgIndex_t *	BndryElem,
		EntIndex_t *	BndryElemZone
	)

Fetch a connected element and its zone for a boundary face.

Since:: 11.2-1-0

Parameters:

	FaceMap	Face mapping.
	Face	The boundary face for which the connected element is desired.
	BndryConnOffset	The boundary connection offset for the element. This must be between 1 and the number of boundary elements returned by TecUtilDataFaceMapGetNBndryConns.
	BndryElem	The desired connected element. A returned element number of TECUTIL_NO_NEIGHBORING_ELEM indicates no neighboring element. If this is the only boundary connection for the face, then the boundary face has no neighboring elements. If there are more boundary connections for this boundary face, then the boundary face is partially obscured, and the remaining boundary connections for the face will list the elements and zones that partially obscure the face.
	BndryElemZone	The desired connected zone. A returned zone number of TECUTIL_NO_NEIGHBORING_ZONE indicates a self reference (in other words, the zone associated with the face mapping).

Fortran Syntax:

    SUBROUTINE TecUtilDataFaceMapGetBndryConn (
   &           FaceMapPtr,
   &           Face,
   &           BndryConnOffset,
   &           BndryElem,
   &           BndryElemZone)
    POINTER   (FaceMapPtr, FaceMap)
    INTEGER*4 Face
    INTEGER*4 BndryConnOffset
    INTEGER*4 BndryElem
    INTEGER*4 BndryElemZone

Python Syntax:

  Results = TecUtil.DataFaceMapGetBndryConn(FaceMap, Face, BndryConnOffset, BndryElem, BndryElemZone)

  Input:
                  FaceMap              opaque pointer
                  Face                 int
                  BndryConnOffset      int
                  BndryElem            list of ints
                  BndryElemZone        list of ints
  Output:
    Results[0]    ReturnVal            NONE

ArbParam_t TecUtilDataFaceMapGetClientData ( FaceMap_pa FaceMap )

Return the custom load-on-demand client data from a face 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.

Note:: This is implemented as a macro.

Parameters:

FaceMap

Custom load-on-demand face map handle.

Returns:: Client data for the custom load-on-demand add-on.

Python Syntax:

    This function is not supported in Python.

     Boolean_t MyFaceMapLoader(FaceMap_pa FaceMap)
     {
       Boolean_t Result;
       MyClientData_s *MyClientData = (MyClientData_s *)TecUtilDataFaceMapGetClientData(FaceMap);

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

     return Result;
   }

See also:: TecUtilDataFaceMapCustomLOD()

LgIndex_t TecUtilDataFaceMapGetFaceNode	(	FaceMap_pa	FaceMap,
		LgIndex_t	Face,
		LgIndex_t	NodeOffset
	)

Fetch a node from the face.

Since:: 11.2-1-0

Parameters:

	FaceMap	Face mapping.
	Face	The face for which the node is desired.
	NodeOffset	The node offset within the face.

Returns:: The desired node.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataFaceMapGetFaceNode (
   &          FaceMapPtr,
   &          Face,
   &          NodeOffset)
    POINTER   (FaceMapPtr, FaceMap)
    INTEGER*4 Face
    INTEGER*4 NodeOffset

Python Syntax:

  Results = TecUtil.DataFaceMapGetFaceNode(FaceMap, Face, NodeOffset)

  Input:
                  FaceMap              opaque pointer
                  Face                 int
                  NodeOffset           int
  Output:
    Results[0]    ReturnVal            int

LgIndex_t TecUtilDataFaceMapGetLeftElem	(	FaceMap_pa	FaceMap,
		LgIndex_t	Face
	)

The left element associated with the specified face.

Since:: 11.2-1-0

Parameters:

	FaceMap	Face mapping.
	Face	The face for which the left element is desired.

Returns:: Left element number, TECUTIL_NO_NEIGHBORING_ELEM if there is no neighbor, or TECUTIL_BOUNDARY_FACE indicating that this is a boundary face. Further information about a boundary face may be gathered. See TecUtilDataFaceMapGetNBndryConns for more details.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataFaceMapGetLeftElem (
   &          FaceMapPtr,
   &          Face)
    POINTER   (FaceMapPtr, FaceMap)
    INTEGER*4 Face

Python Syntax:

  Results = TecUtil.DataFaceMapGetLeftElem(FaceMap, Face)

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

LgIndex_t TecUtilDataFaceMapGetNBndryConns	(	FaceMap_pa	FaceMap,
		LgIndex_t	Face
	)

Retrieves the number of boundary connections for the specified face.

Since:: 11.2-1-0

Parameters:

	FaceMap	Face mapping.
	Face	The face for which the number of connections is desired.

Returns:: The number of boundary connections for the face.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataFaceMapGetNBndryConns (
   &          FaceMapPtr,
   &          Face)
    POINTER   (FaceMapPtr, FaceMap)
    INTEGER*4 Face

Python Syntax:

  Results = TecUtil.DataFaceMapGetNBndryConns(FaceMap, Face)

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

LgIndex_t TecUtilDataFaceMapGetNFaceNodes	(	FaceMap_pa	FaceMap,
		LgIndex_t	Face
	)

Indicates how many nodes comprise the specified face.

Always returns 2 for polygonal zones.

Since:: 11.2-1-0

Parameters:

	FaceMap	Face mapping.
	Face	The face for which the number of nodes is desired.

Returns:: Number of face nodes.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataFaceMapGetNFaceNodes (
   &          FaceMapPtr,
   &          Face)
    POINTER   (FaceMapPtr, FaceMap)
    INTEGER*4 Face

Python Syntax:

  Results = TecUtil.DataFaceMapGetNFaceNodes(FaceMap, Face)

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

FaceMap_pa TecUtilDataFaceMapGetReadableRef ( EntIndex_t Zone )

Gets a readable face mapping for the specified polyhedral or polygonal zone of the current frame.

Since:: 11.2-1-0

Parameters:

Zone

Polyhedral or polygonal zone number.

Returns:: A readable face mapping for the specified polyhedral or polygonal zone or NULL if unsuccessful.

Fortran Syntax:

    SUBROUTINE TecUtilDataFaceMapGetReadableRef (
   &           Zone,
   &           FaceMapPtr)
    INTEGER*4 Zone
    POINTER   (FaceMapPtr, FaceMap)

Python Syntax:

  Results = TecUtil.DataFaceMapGetReadableRef(Zone)

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

LgIndex_t TecUtilDataFaceMapGetRightElem	(	FaceMap_pa	FaceMap,
		LgIndex_t	Face
	)

The right element associated with the specified face.

Since:: 11.2-1-0

Parameters:

	FaceMap	Face mapping.
	Face	The face for which the right element is desired.

Returns:: Right element number, TECUTIL_NO_NEIGHBORING_ELEM if there is no neighbor, or TECUTIL_BOUNDARY_FACE indicating that this is a boundary face. Further information about a boundary face may be gathered. See TecUtilDataFaceMapGetNBndryConns for more details.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataFaceMapGetRightElem (
   &          FaceMapPtr,
   &          Face)
    POINTER   (FaceMapPtr, FaceMap)
    INTEGER*4 Face

Python Syntax:

  Results = TecUtil.DataFaceMapGetRightElem(FaceMap, Face)

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

FaceMap_pa TecUtilDataFaceMapGetWritableRef ( EntIndex_t Zone )

Gets a writable face mapping for the specified polyhedral or polygonal zone of the current frame.

If the current face mapping for the zone is not writable, the current face mapping will be replaced with a writable copy. If the original face mapping was shared with other zones, the writable copy will be shared with the same zones.

Since:: 11.2-1-0

Parameters:

Zone

Polyhedral or polygonal zone number.

Returns:: A writable face mapping for the specified polyhedral or polygonal zone or NULL if unsuccessful.

Fortran Syntax:

    SUBROUTINE TecUtilDataFaceMapGetWritableRef (
   &           Zone,
   &           FaceMapPtr)
    INTEGER*4 Zone
    POINTER   (FaceMapPtr, FaceMap)

Python Syntax:

  Results = TecUtil.DataFaceMapGetWritableRef(Zone)

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

void TecUtilDataFaceNbrArrayAssign	(	LgIndex_t	DestOffset,
		LgIndex_t	DestCount,
		LgIndex_t *	NeighborElems
	)

Copies the specified number of local one-to-one face neighbors from the base of the neighbor element array to the currently open face neighbor context 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.

Note:: If this function is used in conjunction with TecUtilDataFaceNbrAssign() then the local one-to-one face neighbors must be delivered via this function before delivering discrete face neighbor assignments via TecUtilDataFaceNbrAssign().

Since:: 11.0-3-008

Parameters:

	DestOffset	Offset in Tecplot's face neighbor array to begin assigning the supplied neighbor elements.
	DestCount	Number of neighbor elements to assign to Tecplot's face neighbor array.
	NeighborElems	An array containing the one based face neighbor elements to copy. The first element is assumed to be at the base of the array.

Python Syntax:

  Results = TecUtil.DataFaceNbrArrayAssign(DestOffset, DestCount, NeighborElems)

  Input:
                  DestOffset           int
                  DestCount            int
                  NeighborElems        list of ints
  Output:
    Results[0]    ReturnVal            NONE

Boolean_t TecUtilDataFaceNbrAssign	(	LgIndex_t	Element,
		LgIndex_t	Face,
		Boolean_t	NeighborsCompletelyObscure,
		LgIndex_t	NumNeighbors,
		LgIndex_t *	NeighborElems,
		EntIndex_t *	NeighborZones
	)

Sets the user defined face neighbors within an open face neighbor assignment context for the specified element and face.

Parameters:

	Element	The element number (starts at one)
	Face	Face for which the face neighbor information is desired
	NeighborsCompletelyObscure	Set to TRUE if the supplied neighbors completely obscure the face.
	NumNeighbors	Number of neighbors for this face
	NeighborElems	Array containing the element numbers of the neighbors
	NeighborZones	Array containing the zone numbers of the neighbors

Returns:: TRUE if successful in assigning to the context, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataFaceNbrAssign(
   &                   Element,
   &                   Face,
   &                   NeighborsCompletelyObscure,
   &                   NumNeighbors,
   &                   NeighborElems,
   &                   NeighborZones)
    INTEGER*4       Element
    INTEGER*4       Face
    INTEGER*4       NeighborsCompletelyObscure
    INTEGER*4       NumNeighbors
    INTEGER*4       NeighborElems
    INTEGER*4       NeighborZones

Python Syntax:

  Results = TecUtil.DataFaceNbrAssign(Element, Face, NeighborsCompletelyObscure, NumNeighbors, NeighborElems, NeighborZones)

  Input:
                  Element              int
                  Face                 int
                  NeighborsCompletelyObscure boolean
                  NumNeighbors         int
                  NeighborElems        list of ints
                  NeighborZones        list of ints
  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilDataFaceNbrBeginAssign ( EntIndex_t Zone )

Clears any previous user defined face neighbor assignments and opens a new face neighbor assignment context.

One and only one face neighbor assignment context must be open prior to calling TecUtilDataFaceNbrAssign(). The context must be closed with a call to TecUtilDataFaceNbrEndAssign() when all face neighbor assignments have been delivered.

Note:: If you are also delivering a node map to Tecplot you must be sure to call TecUtilStateChanged() or TecUtilStateChangedX() with a StateChange_NodeMapsAltered before calling this function because Tecplot invalidates face neighbors when the nod map is altered.

Parameters:

Zone

Zone number to which the face neighors are to be assigned.

Returns:: TRUE if successful in opening the context, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataFaceNbrBeginAssign(Zone)
    INTEGER*4 Zone

Python Syntax:

  Results = TecUtil.DataFaceNbrBeginAssign(Zone)

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

Boolean_t TecUtilDataFaceNbrBeginAssignX ( ArgList_pa ArgList )

Clears any previous user defined face neighbor assignments and opens a new face neighbor assignment context.

One and only one face neighbor assignment context must be open prior to calling TecUtilDataFaceNbrAssign(). The context must be closed with a call to TecUtilDataFaceNbrEndAssign() when all face neighbor assignments have been delivered.

Note:: If you are also delivering a node map to Tecplot you must be sure to call TecUtilStateChanged() or TecUtilStateChangedX() with a StateChange_NodeMapsAltered before calling this function because Tecplot invalidates face neighbors when the nod map is altered.

Parameters:

ArgList

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

Arglist Values

SV_ZONE

Type:	EntIndex_t
Arg Function:	TecUtilArgListAppendInt()
Required:	Yes
Notes:	Number of the zone to which face neighbors are assigned.

SV_AUTOASSIGNFN

Type:	Boolean_t
Arg Function:	TecUtilArgListAppendInt()
Default:	TRUE if the zone was created by TecUtilDataSetAddZone(), otherwise if the zone was created by TecUtilDataSetAddZoneX() it retains the value of SV_AUTOASSIGNFN used for that function.
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.

Returns:: TRUE if successful in opening the context, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataFaceNbrBeginAssignX(ArgListPtr)
    POINTER (ArgListPtr, ArgList)

Python Syntax:

  Results = TecUtil.DataFaceNbrBeginAssignX(ArgList)

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

Boolean_t TecUtilDataFaceNbrEndAssign ( void )

Closes the open face neighbor assignment context and packs the assignments into an efficient storage within Tecplot.

Returns:: TRUE if successful in assigning to the context, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataFaceNbrEndAssign()

Python Syntax:

  Results = TecUtil.DataFaceNbrEndAssign()

  Output:
    Results[0]    ReturnVal            boolean

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

Deprecated:: Please use TecUtilDataFaceNbrGetNbrByRef() instead.

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

Deprecated:: Please use TecUtilDataFaceNbrGetNbrByRef() instead.

FaceNeighborMode_e TecUtilDataFaceNbrGetModeByRef ( FaceNeighbor_pa FaceNeighbor )

Returns the FaceNeigborMode_e value for the referenced face neighbor.

Parameters:

FaceNeighbor

The face neighbor handle to the specified zone in the data set attached to the current frame

Returns:: Mode of the face neighbor.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataFaceNbrGetModeByRef(FaceNeighborPtr)
    POINTER (FaceNeighborPtr, FaceNeighbor)

Python Syntax:

  Results = TecUtil.DataFaceNbrGetModeByRef(FaceNeighbor)

  Input:
                  FaceNeighbor         opaque pointer
  Output:
    Results[0]    ReturnVal            FaceNeighborMode_e  (defined in TecVals.py)

void TecUtilDataFaceNbrGetNbrByRef	(	FaceNeighbor_pa	FaceNeighbor,
		LgIndex_t	Element,
		LgIndex_t	Face,
		LgIndex_t	NeighborNumber,
		LgIndex_t *	NeighborElem,
		EntIndex_t *	NeighborZone
	)

Get the cell index of the element the is a neighbor of the specified Element and Face.

To use this function you must have already obtained a handle to face neighbors.

Parameters:

	FaceNeighbor	Handle to the face neighbors. Use TecUtilDataFaceNbrGetRef() to get handles to the face neighbors.
	Element	The element number (starts at one).
	Face	The face number of the element. Different element types have different number of faces. Use TecUtilZoneGetType() to get the element type for a particular zone. Face numbers start at one. ZoneType_FETriangle: has three faces. ZoneType_FEQuad has four faces. ZoneType_FETetra has four faces. ZoneType_FEBrick has six faces. Please see section 4.1.2.g "Face Neighbors" in the Tecplot User's Manual for a description of how nodes and faces map to one another.
	NeighborNumber	Specify which neighbor to retrieve. Use TecUtilDataFaceNbrGetNumNByRef() to get the number of neighbors
	NeighborElem	Pointer that gives the value of the neighboring element number
	NeighborZone	Pointer that gives the value of the neighboring zone number

Fortran Syntax:

    SUBROUTINE TecUtilDataFaceNbrGetNbrByRef(
   &           FaceNeighborPtr,
   &           Element,
   &           Face,
   &           NeighborNumber,
   &           NeighborElem,
   &           NeighborZone)
    POINTER         (FaceNeighborPtr, FaceNeighbor)
    INTEGER*4       Element
    INTEGER*4       Face
    INTEGER*4       NeighborNumber
    INTEGER*4       NeighborElem
    INTEGER*4       NeighborZone

Python Syntax:

  Results = TecUtil.DataFaceNbrGetNbrByRef(FaceNeighbor, Element, Face, NeighborNumber)

  Input:
                  FaceNeighbor         opaque pointer
                  Element              int
                  Face                 int
                  NeighborNumber       int
  Output:
    Results[0]    NeighborElem         int
    Results[1]    NeighborZone         int

Get the cell index of the cell next to face 5 of element 23 in zone 2. It is assumed that zone 2 is of type ZoneType_FEBrick.

   FaceNeighbor_pa FNPtr = TecUtilDataFaceNbrGetRef(2);
   if (FNPtr != NULL)
     {
       LgIndex_t  NeighborElem;
       EntIndex_t NeighborZone;
       TecUtilDataFaceNbrGetNbrByRef(FNPtr, 23, 5, 1,
                                     &NeighborElem,
                                     &NeighborZone);
   
       // Do something with NeighborElem and NeighborZone.
    }

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

Gets the number of face neighbors for the elements's face.

Parameters:

	FaceNeighbor	Handle to the face neighbors. Use TecUtilDataFaceNbrGetRef() to get handles to the face neighbors
	Element	The element number (starts at one)
	Face	The face number of the element. Different element types have different number of faces. Use TecUtilZoneGetType() to get the element type for a particular zone. Face numbers start at one.ZoneType_FETriangle: Three faces.ZoneType_FEQuad: Four faces.ZoneType_FETetra: Four faces.ZoneType_FEBrick: Six faces

Returns:: Number of neighbors for the element's face.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataFaceNbrGetNumNByRef(
   &                   FaceNeighborPtr,
   &                   Element,
   &                   Face)
    POINTER         (FaceNeighborPtr, FaceNeighbor)
    INTEGER*4       Element
    INTEGER*4       Face

Python Syntax:

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

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

Get the number of neighbors for face 5 of element 23 of zone 2. It is assumed that zone 2 is of type ZoneType_FEBrick.

   LgIndex_t NumNeighbors;
   FaceNeighbor_pa FNbr;
   FNbr = TecUtilDataFaceNbrGetRef(2);
   NumNeighbors = TecUtilDataFaceNbrGetNumNByRef(FNbr, 23, 5);

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 anymore.

FaceNeighbor_pa TecUtilDataFaceNbrGetRef ( EntIndex_t Zone )

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

Parameters:

Zone

Number of the zone for which to get the face neighbor handle.

Returns:: The face neighbor handle to the specified zone in the data set attached to the current frame.

Fortran Syntax:

    SUBROUTINE TecUtilDataFaceNbrGetRef(
   &           Zone,
   &           ResultPtr)
    INTEGER*4       Zone
    POINTER         (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.DataFaceNbrGetRef(Zone)

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

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.

Parameters:

	Zone	Zone in which the cell exists. This must be a finite-element zone.
	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.
	I2	Second Node index.
	I3	Third Node index.
	I4	Fourth Node index (not valid if triangle element).

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.

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.

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.

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.

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.

Parameters:

	Zone	Zone in which the cell exists
	Plane	Plane in which the cell resides. The possible values are: Planes_I, Planes_J, Planes_K or Planes_Volume. For I- or IJ-ordered data use Planes_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.

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,
                                Planes_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,
                                Planes_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,
                                Planes_K,
                                CellIndex,
                                &I1,&I2,&I3,&I4);

void TecUtilDataLoadBegin ( void )

Notifies Tecplot that a major data load operation is about to begin.

Please see TecUtilDataLoadEnd() for more details.

TecUtilDataLoadBegin() and TecUtilDataLoadEnd() are used together with add-ons that perform a moving window of calculations through data. This is particularly important for add-ons processing transient data.

Since:: 11.0-0-430

See also:: TecUtilDataLoadEnd, TecUtilDataValueAutoLOD, TecUtilDataValueCustomLOD

Python Syntax:

  Results = TecUtil.DataLoadBegin()

  Output:
    Results[0]    ReturnVal            NONE

void TecUtilDataLoadEnd ( void )

Notifies Tecplot that a major data load operation has completed.

After each major data load operation Tecplot examines its current memory use and decides if it needs to unload any data.

After this call all data references (i.e. field data, node maps, face neighbors, etc.) previously acquired by the add-on are invalid and should be re-acquired before using them again.

TecUtilDataLoadBegin() and TecUtilDataLoadEnd() are used together with add-ons that perform a moving window of calculations through data. This is particularly important for add-ons processing transient data.

Since:: 11.0-0-430

See also:: TecUtilDataLoadBegin, TecUtilDataValueAutoLOD, TecUtilDataValueCustomLOD

Python Syntax:

  Results = TecUtil.DataLoadEnd()

  Output:
    Results[0]    ReturnVal            NONE

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.

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.

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.

Note:: 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.
	SourceNodeArray	An array containing the one based nodes to copy. The first node is assumed to be at the base of the array.

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.

Parameters:

	NodeMapPtr	Handle to the connectivity list (that is, the node map). Use TecUtilDataNodeGetByRef() or TecUtilZoneGetInfo() to get handles to the zone map
	Element	The element number (starts at 1)
	Corner	The element corner (starts at 1)

Returns:: The index of the node.

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 = TecUtilDataNodeGetRef(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.

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.

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);

void TecUtilDataNodeGetRawPtr	(	EntIndex_t	Zone,
		NodeMap_t **	NodeMapPtr
	)

Get a handle to the raw node map data in the data set attached to the current frame.

Use this function with extreme caution and only as a last resort. TecUtilDataNodeGetByRef() and TecUtilDataNodeSetByRef() should be used instead in most cases.

Note:: Do not assume that raw data internal to Tecplot remain in the same location at all times. Always call this function again after any event where Tecplot itself may move or alter the raw data. Also, make sure to call TecUtilStateChanged() after any values have changed.

Parameters:

	Zone	Number of the zone for which to get the raw node map data. This must be a finite-element zone.
	NodeMapPtr	Receives address of the raw node map data

Fortran Syntax:

    SUBROUTINE TecUtilDataNodeGetRawPtr(
   &           Zone,
   &           NodeMapPtr)
    INTEGER*4       Zone
    POINTER         (NodeMapPtrPtr, NodeMapPtr)

Python Syntax:

    This function is not supported in Python.

Get and then set the first and second node of the 43rd element of zone 5 using a raw data pointer. The 43rd element is accessed by 42*nodes_per_element and the first and second nodes are accessed by +0 and +1 respectively since the raw data is accessed with a zero-base numbering system. Be sure to call TecUtilStateChanged() when you change the node map in this way:

   // assume we already know zone 5 is a finite element zone with
   // triangle elements (by using TecUtilZoneGetInfo() or
   // TecUtilZoneGetType())
   LgIndex_t zone = 5;
   NodeMap_t *raw_nm_ptr = NULL;
   LgIndex_t nodes_per_element = 3; // triangular
   TecUtilDataNodeGetRawPtr(zone, &raw_nm_ptr);
   if ( raw_nm_ptr )
     {
       Set_pa altered_zones = TecUtilSetAlloc(TRUE);
       LgIndex n1, n2;
       n1 = raw_nm_ptr[42*nodes_per_element + 0]; // zero-based numbering
       n2 = raw_nm_ptr[42*nodes_per_element + 1];
       // alter n1 and n2 in some way
       n1++;
       n2++;
       raw_nm_ptr[42*nodes_per_element + 0] = n1;
       raw_nm_ptr[42*nodes_per_element + 1] = n2;
       // inform Tecplot of node map change
       TecUtilSetAddMember(altered_zones, 5, TRUE);
       TecUtilStateChanged(StateChange_NodeMapsAltered,
                           (ArbParam_t)altered_zones);
       TecUtilSetDealloc(&altered_zones);
     }

NodeMap_pa TecUtilDataNodeGetRef ( EntIndex_t Zone )

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

Parameters:

Zone

Number of the zone for which to get the 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.

Fortran Syntax:

    SUBROUTINE TecUtilDataNodeGetRef(
   &           Zone,
   &           ResultPtr)
    INTEGER*4       Zone
    POINTER         (ResultPtr, Result)

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.

Note:: 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 TecUtilDataNodeGetRef() or TecUtilZoneGetInfo() 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

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 = TecUtilDataNodeGetRef(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.

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);

Boolean_t TecUtilDataRotate2D	(	Set_pa	ZoneSet,
		double	RotateAmountInDegrees,
		double	XOrigin,
		double	YOrigin
	)

Rotate field data in 2-D about any point.

Parameters:

	ZoneSet	Zones to rotate
	RotateAmountInDegrees	Angle of rotation in degrees
	XOrigin	X-origin about which to rotate
	YOrigin	Y-origin about which to rotate

Returns:: Returns TRUE if append is successful, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataRotate2D(
   &                   ZoneSetPtr,
   &                   RotateAmountInDegrees,
   &                   XOrigin,
   &                   YOrigin)
    POINTER         (ZoneSetPtr, ZoneSet)
    REAL*8          RotateAmountInDegrees
    REAL*8          XOrigin
    REAL*8          YOrigin

Python Syntax:

  Results = TecUtil.DataRotate2D(ZoneSet, RotateAmountInDegrees, XOrigin, YOrigin)

  Input:
                  ZoneSet              sequence of ints
                  RotateAmountInDegrees double
                  XOrigin              double
                  YOrigin              double
  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilDataSetAddJournalCommand	(	const char *	CommandProcessorIDString,
		const char *	Instructions,
		const char *	RawData
	)

Adds a command to the data journal.

Note:: Using this function will render your layout files incompatibile with Tecplot 11.2-0-382 or earlier.

Parameters:

	CommandProcessorIDString	The ID string of the command processor. You must have registered a macro command callback with Tecplot to use this functionality. See TecUtilMacroAddCommandCallback for more information on registering a macro command callback
	Instructions	Command Instrunctions
	RawData	Raw Data. Please see TecUtilMacroRecordExtComRaw() for a description of the raw data format.

Returns:: Returns TRUE if successful, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataSetAddJournalCommand(
   &                   AddOnIDString,
   &                   Instructions,
   &                   RawData)
    CHARACTER*(*)   AddOnIDString
    CHARACTER*(*)   Instructions
    CHARACTER*(*)   RawData

Python Syntax:

  Results = TecUtil.DataSetAddJournalCommand(CommandProcessorIDString, Instructions, RawData)

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

See also:: TecUtilMacroAddCommandCallback, TecUtilMacroRecordExtComRaw

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

Deprecated:: Please use TecUtilDataSetAddJournalCommand() instead.

Boolean_t TecUtilDataSetAddRawJournalCom ( const char * Command )

Adds a raw macro command to the data journal.

Parameters:

Command

The raw macro command to add to the journal.

Returns:: Returns TRUE if successful (i.e., the command is valid and could be attached to the journal), FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataSetAddRawJournalCom(Command)
    CHARACTER*(*) Command

Python Syntax:

  Results = TecUtil.DataSetAddRawJournalCom(Command)

  Input:
                  Command              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.
	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.

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.

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.

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.
	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 IMax is the number of data points, JMax is the number of elements, and KMax is the number of faces. KMax is only used for FEPolygon and FEPolyhedron fe zone types.
	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.
	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:

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.

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. 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_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.

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

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 TecUtilDataSetCreate	(	const char *	DataSetTitle,
		StringList_pa	VarNames,
		Boolean_t	ResetStyle
	)

Create a new data set and attach it to the current frame.

This only allocates space for a data set specification. You must immediately begin to add zones to the data set by calling TecUtilDataSetAddZone() after creating a data set.

Parameters:

	DataSetTitle	Title for the data set.
	VarNames	String list of variable names. See TecUtilStringListXXX functions for string list details
	ResetStyle	Clears out all style information for the current frame before creating the data set. It is highly recommended that you always pass TRUE for this parameter.

Returns:: Returns TRUE if a data set could be allocated and attached.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataSetCreate(
   &                   DataSetTitle,
   &                   VarNamesPtr,
   &                   ResetStyle)
    CHARACTER*(*)   DataSetTitle
    POINTER         (VarNamesPtr, VarNames)
    INTEGER*4       ResetStyle

Python Syntax:

  Results = TecUtil.DataSetCreate(DataSetTitle, VarNames, ResetStyle)

  Input:
                  DataSetTitle         string
                  VarNames             sequence of strings
                  ResetStyle           boolean
  Output:
    Results[0]    ReturnVal            boolean

Create a data set with two variables:

   StringList_pa sl = TecUtilStringListAlloc();
   TecUtilStringListAppendString(sl,"V1");  // first variable 
   TecUtilStringListAppendString(sl,"V2");  // second variable 
   
   if ( TecUtilDataSetCreate("My Data Set",sl, TRUE));
      {
   
      // Immediately call TecUtilDataSetAddZone() here 
      }
   TecUtilStringListDealloc(&sl);

Boolean_t TecUtilDataSetDefVarLoadFinish ( Boolean_t IsDataSetOk )

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

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.

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.

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.

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.

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);

Strand_t TecUtilDataSetGetMaxStrandID ( void )

Get the largest Strand number currently in use.

Use this value to ensure that your strand assignments are correct when adding zones

Returns:: Returns the largest strand number currently in use.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataSetGetMaxStrandID()

Python Syntax:

  Results = TecUtil.DataSetGetMaxStrandID()

  Output:
    Results[0]    ReturnVal            int

   Arglist_pa ArgList;
   Strand_t   MaxStrand;
   TecUtilLockStart(AddOnID);
   ArgList = TecUtilArgListAlloc();
   TecUtilArgListAppendString(ArgList, SV_NAME, "New Zone");
   TecUtilArgListAppendInt(ArgList, SV_ZONETYPE,
                           (ArbParam_t)ZoneType_Ordered);
   TecUtilArgListAppendInt(ArgList, SV_IMAX, 10);
   TecUtilArgListAppendInt(ArgList, SV_JMAX, 20);

   MaxStrand = TecUtilDataSetGetMaxStrandID();
   TecUtilArgListAppendInt(ArgList, SV_STRANDID, MaxStrand+1);

   TecUtilDataSetAddZoneX(ArgList);
   TecUtilArgListDealloc(&ArgList);
   TecUtilLockFinish(AddOnID);

See also:: TecUtilDataSetAddZoneX

EntIndex_t TecUtilDataSetGetNumVars ( void )

Get the number of variables in the data set attached to the current frame.

Returns:: The number of variables in the data set attached to the current frame.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataSetGetNumVars()

Python Syntax:

  Results = TecUtil.DataSetGetNumVars()

  Output:
    Results[0]    ReturnVal            int

See also:: TecUtilDataSetGetInfo, TecUtilDataSetGetNumZones

EntIndex_t TecUtilDataSetGetNumZones ( void )

Get the number of zones in the data set attached to the current frame.

Returns:: The number of zones in the data set attached to the current frame.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataSetGetNumZones()

Python Syntax:

  Results = TecUtil.DataSetGetNumZones()

  Output:
    Results[0]    ReturnVal            int

See also:: TecUtilDataSetGetInfo, TecUtilDataSetGetNumVars

UniqueID_t TecUtilDataSetGetUniqueID ( void )

Gets a unique ID for a data set.

A unique ID is an integer that is unique to a data set. This ID can be used to determine if the data sets from several frames are the same.

Returns:: A unique ID for the current data set.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataSetGetUniqueID()

Python Syntax:

  Results = TecUtil.DataSetGetUniqueID()

  Output:
    Results[0]    ReturnVal            long

Determine if the datasets of the top 2 frames are the same:

   {
     UniqueID_t ID;
     TecUtilLockStart(AddOnID);
     ID = TecUtilDataSetGetUniqueID();
     TecUtilFramePushTop();
     if ( ID == TecUtilDataSetGetUniqueID() )
       {
         // Datasets are the same for both frames
       }
     else
       {
         // Datasets are different
       }
     TecUtilLockFinish(AddOnID);
   }

VarLoadMode_e TecUtilDataSetGetVarLoadMode ( void )

Get the variable load mode for the current data set.

Returns:: The variable load mode. Possible values are VarLoadMode_ByName and VarLoadMode_ByPosition.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataSetGetVarLoadMode()

Python Syntax:

  Results = TecUtil.DataSetGetVarLoadMode()

  Output:
    Results[0]    ReturnVal            VarLoadMode_e  (defined in TecVals.py)

Get the variable load mode for the current data set:

   VarLoadMode_e VarLoadMode;
   if ( TecUtilDataSetIsAvailable() )
     {
        VarLoadMode = TecUtilDataSetGetVarLoadMode();
       ...
     }

Boolean_t TecUtilDataSetIsAvailable ( void )

Determine if the current frame has a data set attached.

Returns:: TRUE if the current frame has an attached data set, FALSE if not.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataSetIsAvailable()

Python Syntax:

  Results = TecUtil.DataSetIsAvailable()

  Output:
    Results[0]    ReturnVal            boolean

Get the number of zones for the data set for the current frame, or use zero if there is no data set:

   EntIndex_t nzones = 0;
   if ( TecUtilDataSetIsAvailable() )
     TecUtilDataSetGetInfo(NULL, &nzones, NULL);

Boolean_t TecUtilDataSetIsLocked ( char ** LockString )

Query to see of the data set attached to the current frame is locked.

Parameters:

LockString

Allocated return string telling you the identifier originally used to lock the data set. You must deallocate this string when you are through with it. You can pass NULL for this parameter if you do not need to know who locked the data set

Returns:: Returns TRUE if the data set is locked, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataSetIsLocked(
   &                   LockString,
   &                   LockStringLength)
    CHARACTER*(*)   LockString
    INTEGER*4       LockStringLength

Python Syntax:

  Results = TecUtil.DataSetIsLocked()

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

Boolean_t TecUtilDataSetIsSharingAllowed ( void )

Query to see if variable and connectivity sharing is permitted for this dataset.

You must still call TecUtilDataValueIsSharingOk() for variables and TecUtilDataConnectIsSharingOk() for connectivity to determine if a particular variable or if the connectivity may be shared.

Returns:: Returns TRUE if sharing is allowed in Tecplot, FALSE if otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataSetIsSharingAllowed()

Python Syntax:

  Results = TecUtil.DataSetIsSharingAllowed()

  Output:
    Results[0]    ReturnVal            boolean

   Boolean_t IsSharing;
   IsSharing = TecUtilDataSetIsSharingAllowed();.

See also:: TecUtilDataValueIsSharingOk() and TecUtilDataConnectIsSharingOk().

Boolean_t TecUtilDataSetJournalIsValid ( void )

Query Tecplot to see if the journal for the data set attached to the current frame is valid.

This is a concern if a layout file is to be generated from an addon. When layouts are generated from an addon the layout must be able to reproduce all data sets via named files and journal entries. A data set will require saving if any un-journaled data operations are performed on it.

Returns:: Returns TRUE if the data set journal is valid, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataSetJournalIsValid()

Python Syntax:

  Results = TecUtil.DataSetJournalIsValid()

  Output:
    Results[0]    ReturnVal            boolean

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.

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.

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 TecUtilDataSetReadX ( ArgList_pa ArgList )

Read one or more data files into Tecplot to form a new data set in the current frame.

Parameters:

ArgList

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

Arglist Values

SV_READDATAOPTION

Type:	ReadDataOption_e
Arg Function:	TecUtilArgListAppendInt()
Default:	ReadDataOption_NewData
Required:	No
Notes:	Determine how to handle the situation where a data set already exists in the current frame. The possible values are:

SV_RESETSTYLE

Type:	Boolean_t
Arg Function:	TecUtilArgListAppendInt()
Default:	TRUE
Required:	No
Notes:	TRUE if you want to reset the style of the current frame, FALSE if you want to keep the same style.

SV_FILENAMESORINSTRUCTIONS

Type:	StringList_pa
Arg Function:	TecUtilArgListAppendStringList()
Required:	Yes
Notes:	A string list containing the file names to load or the instructions to send to the data set reader (converter or loader).

SV_DATASETREADER

Type:	char *
Arg Function:	TecUtilArgListAppendInt()
Default:	"TECPLOT"
Required:	No
Notes:	Name of the data set reader (converter or loader). To let Tecplot load the data, use NULL.

SV_INITIALPLOTFIRSTZONEONLY

Type:	Boolean_t
Arg Function:	TecUtilArgListAppendInt()
Default:	FALSE
Required:	No
Notes:	Informs Tecplot that after the data is loaded it only needs to activate the first enabled zone for the initial plot. This option is particularly usefull if you have many zones and want to get the data into Tecplot and the first zone drawn as fast as possible. The inactive zones can always be activated when needed.

SV_INITIALPLOTTYPE

Type:	PlotType_e
Arg Function:	TecUtilArgListAppendInt()
Default:	PlotType_Automatic
Required:	No
Notes:	Initial frame plot type for the data. Only used if SV_RESETSTYLE is TRUE. To have Tecplot determine the most appropriate frame plot type for the data, use PlotType_Automatic (the default).

SV_INCLUDETEXT

Type:	Boolean_t
Arg Function:	TecUtilArgListAppendInt()
Default:	TRUE
Required:	No
Notes:	Set to TRUE to load any text, geometries, or custom labels in the data files.

SV_INCLUDEGEOM

Type:	Boolean_t
Arg Function:	TecUtilArgListAppendInt()
Default:	TRUE
Required:	No

SV_INCLUDECUSTOMLABL

Type:	Boolean_t
Arg Function:	TecUtilArgListAppendInt()
Default:	TRUE
Required:	No

SV_INCLUDEDATA

Type:	Boolean_t
Arg Function:	TecUtilArgListAppendInt()
Default:	TRUE
Required:	No
Notes:	Set to TRUE to load the data from the data files. Set to FALSE to only load text, geometries and/or customer labels, depending on SV_INCLUDETEXT, SV_INCLUDEGEOM, and SV_INCLUDECUSTOMLABELS

SV_COLLAPSEZONESANDVARS

Type:	Boolean_t
Arg Function:	TecUtilArgListAppendInt()
Default:	FALSE
Required:	No
Notes:	Set to TRUE to renumber zones and variables if any are disabled. For more information on collapsing zones and variables, see Section 5.1.1.7, "Zone and Variable List Collapsing," in the Tecplot User's Manual.

SV_ASSIGNSTRANDIDS

Type:	Boolean_t
Arg Function:	TecUtilArgListAppendInt()
Default:	FALSE
Required:	No
Notes:	Set to TRUE to request that Tecplot assign strand ID's to zones that hava a strand ID of -1.

SV_ADDZONESTOEXISTINGSTRANDS

Type:	Boolean_t
Arg Function:	TecUtilArgListAppendInt()
Default:	FALSE
Required:	No
Notes:	Set to TRUE to request that Tecplot add the zones to matching strands, if they exist. Otherwise, if the new data specifies strands, Tecplot will create new strands beginning after the last strand in the dataset.

SV_ZONELIST

Type:	Set_pa
Arg Function:	TecUtilArgListAppendSet()
Default:	NULL
Required:	No
Notes:	Set of zones to load from the data files. Use NULL to load all zones.

SV_VARLOADMODE

Type:	VarLoadMode_e
Arg Function:	TecUtilArgListAppendInt()
Default:	VarLoadMode_ByPosition
Required:	No
Notes:	Choose to load variables by name or by their position in the data file.

SV_VARPOSITIONLIST

Type:	Set_pa
Arg Function:	TecUtilArgListAppendSet()
Default:	NULL
Required:	No
Notes:	Set of variables to load from the data files. Use NULL to load all variables. Must be NULL if SV_VARLOADMODE is VarLoadMode_ByName.

SV_VARNAMELIST

Type:	StringList_pa
Arg Function:	TecUtilArgListAppendStringList()
Default:	NULL
Required:	No
Notes:	Set of variable names to laod from the data files.

SV_ISKIP

Type:	LgIndex_t
Arg Function:	TecUtilArgListAppendInt()
Default:	1
Required:	No
Notes:	The default value of 1 loads every data point in the I-, J-, or K-directions. A value of 2 for each loads every other data point and so forth. These values only apply to ordered dat

SV_JSKIP

Type:	LgIndex_t
Arg Function:	TecUtilArgListAppendInt()
Default:	1
Required:	No

SV_KSKIP

Type:	LgIndex_t
Arg Function:	TecUtilArgListAppendInt()
Default:	1
Required:	No

Returns:: TRUE if the input parameters are valid and the data was successfully loaded, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataSetReadX(ArgListPtr)
    POINTER (ArgListPtr, ArgList)

Python Syntax:

  Results = TecUtil.DataSetReadX(ArgList)

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

Read in a the file newdata.plt. Note that some arglist entries are shown here using their default values as an example only as they normally would not have to be provided.

   StringList_pa Instructions = TecUtilStringListAlloc();
   ArgList_pa ArgList;
   TecUtilLockStart(AddOnID);
   ArgList = TecUtilArgListAlloc();
   
   TecUtilStringListAppendString(Instructions, "newdata.plt");
   
   TecUtilArgListAppendInt(ArgList,       SV_READDATAOPTION,  ReadDataOption_NewData);
   TecUtilArgListAppendInt(ArgList,       SV_RESETSTYLE,      TRUE);
   TecUtilArgListAppendStringList(ArgList,SV_FILENAMESORINSTRUCTIONS, Instructions);
   TecUtilArgListAppendInt(ArgList,       SV_INITIALPLOTFIRSTZONEONLY,FALSE);
   TecUtilArgListAppendInt(ArgList,       SV_INITIALPLOTTYPE,PlotType_Automatic);
   TecUtilArgListAppendInt(ArgList,       SV_INCLUDETEXT,      TRUE);
   TecUtilArgListAppendInt(ArgList,       SV_INCLUDEGEOM,     TRUE);
   TecUtilArgListAppendInt(ArgList,       SV_INCLUDECUSTOMLABELS,  TRUE);
   TecUtilArgListAppendInt(ArgList,       SV_INCLUDEDATA,     TRUE);
   TecUtilArgListAppendInt(ArgList,       SV_COLLAPSEZONESANDVARS,    FALSE);
   TecUtilArgListAppendInt(ArgList,       SV_VARLOADMODE,     VarLoadMode_ByPosition);
   TecUtilArgListAppendArray(ArgList,     SV_VARPOSITIONLIST, NULL);
   TecUtilArgListAppendInt(ArgList,       SV_ISKIP, 1);
   TecUtilArgListAppendInt(ArgList,       SV_JSKIP, 1);
   TecUtilArgListAppendInt(ArgList,       SV_KSKIP, 1);
   
   TecUtilDataSetReadX(ArgList);

   TecUtilStringListDealloc(&Instructions);
   TecUtilArgListDealloc(&ArgList);
   TecUtilLockFinish(AddOnID);

Boolean_t TecUtilDataSetRequiresSaving ( void )

Deprecated:: Please use TecUtilDataSetJournalIsValid() instead.

Boolean_t TecUtilDataSetSetTitle ( const char * DataSetTitle )

Set the title for the current data set.

Parameters:

DataSetTitle

New title for the current frame's data set.

Returns:: TRUE if successful, FALSE if not.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataSetSetTitle(DataSetTitle)
    CHARACTER*(*) DataSetTitle

Python Syntax:

  Results = TecUtil.DataSetSetTitle(DataSetTitle)

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

Set the current frame's data set title to be "Tecplot Data Set #1":

   TecUtilDataSetSetTitle("Tecplot Data Set #1");

void TecUtilDataSetSuspendMarking ( Boolean_t DoSuspend )

Stops Tecplot for altering or marking the loaded dataset.

Parameters:

DoSuspend

A TRUE value to suspend the marking of the dataset and a FALSE value to allow marking.

Fortran Syntax:

    SUBROUTINE TecUtilDataSetSuspendMarking(DoSuspend)
    INTEGER*4 DoSuspend

Python Syntax:

  Results = TecUtil.DataSetSuspendMarking(DoSuspend)

  Input:
                  DoSuspend            boolean
  Output:
    Results[0]    ReturnVal            NONE

Set the Marking property to be TRUE:

   TecUtilDataSetSuspendMarking(TRUE);

Boolean_t TecUtilDataSetWriteX ( ArgList_pa ArgList )

Write the specified components of the current frame's data set to a file.

Parameters:

ArgList

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

Arglist Values

SV_FNAME

Type:	char *
Arg Function:	TecUtilArgListAppendString()
Required:	Yes
Notes:	Name of the data file to write.

SV_INCLUDETEXT

Type:	Boolean_t
Arg Function:	TecUtilArgListAppendInt()
Default:	TRUE
Required:	No
Notes:	Set to TRUE to write any text, geometries, or custom labels to the data files.

SV_INCLUDEGEOM

Type:	Boolean_t
Arg Function:	TecUtilArgListAppendInt()
Default:	TRUE
Required:	No

SV_INCLUDEDATA

Type:	Boolean_t
Arg Function:	TecUtilArgListAppendInt()
Default:	TRUE
Required:	No
Notes:	Set to TRUE to write the data to the data files. Set to FALSE to only write text and geometries, depending on SV_INCLUDETEXT and SV_INCLUDEGEOM

SV_INCLUDEDATASHARELINKAGE

Type:	Boolean_t
Arg Function:	TecUtilArgListAppendInt()
Default:	TRUE
Required:	No
Notes:	Set to TRUE to conserve space and write the variable and connectivity linkage to the data file wherever possible. Set to FALSE to write all the data to the data file and loose the variable and connectivity sharing linkage for future dataset reads of the file.

SV_INCLUDEAUTOGENFACENEIGHBORS

Type:	Boolean_t
Arg Function:	TecUtilArgListAppendInt()
Default:	FALSE
Required:	No
Notes:	Set to TRUE to save the face neighbor connectivity to the data file. This may produce very large data files.

SV_USEPOINTFORMAT

Type:	Boolean_t
Arg Function:	TecUtilArgListAppendInt()
Default:	FALSE
Required:	No
Notes:	Set to TRUE to write the data file in point format and FALSE for block format.

SV_BINARY

Type:	Boolean_t
Arg Function:	TecUtilArgListAppendInt()
Default:	TRUE
Required:	No
Notes:	Set to TRUE to write the data in binary format and FALSE for ASCII.

SV_ASSOCIATELAYOUTWITHDATAFILE

Type:	Boolean_t
Arg Function:	TecUtilArgListAppendInt()
Default:	TRUE
Required:	No
Notes:	Set to TRUE to assoicate this data file with the current layout. Set to FALSE to write the datafile without modifying Tecplot's current data file to layout association.

SV_ZONELIST

Type:	Set_pa
Arg Function:	TecUtilArgListAppendSet()
Default:	NULL
Required:	No
Notes:	Set of zones to write to the data file. Use NULL to write all zones.

SV_VARLIST

Type:	Set_pa
Arg Function:	TecUtilArgListAppendSet()
Default:	NULL
Required:	No
Notes:	Set of variables to write to the data file. Use NULL to write all variables.

Returns:: TRUE if the input parameters are valid and the data was successfully written, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataSetWriteX(ArgListPtr)
    POINTER (ArgListPtr, ArgList)

Python Syntax:

  Results = TecUtil.DataSetWriteX(ArgList)

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

Boolean_t TecUtilDataValueAlloc	(	EntIndex_t	Zone,
		EntIndex_t	Var
	)

Allocates the space needed for the variable.

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

Since:: 10.0-3-129

Parameters:

	Zone	The zone needing the variable allocated.
	Var	The variable to be allocated.

Returns:: TRUE if the variable was sucessfully allocated, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataValueAlloc(
   &                   Zone,
   &                   Var)
    INTEGER*4       Zone
    INTEGER*4       Var

Python Syntax:

  Results = TecUtil.DataValueAlloc(Zone, Var)

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

Allocate the first variable of zone 3. Note that this example is only valid if the zone was added with the deferred variable creation option set to true.

   IsOk = TecUtilDataValueAlloc(3, 1);

See also:: TecUtilDataValueShare()

void TecUtilDataValueArrayGetByRef	(	FieldData_pa	SourceFieldData,
		LgIndex_t	SourceOffset,
		LgIndex_t	SourceCount,
		void *	DestValueArray
	)

Fetch an Array of values by reference.

This function fetches the specified number of values from the source field data starting at the specified source item offset and copies them to the base of the destination value array. Note that the destination value array must be of the same data type as the source field data.

Since:: 10.0-3-12

Parameters:

	SourceFieldData	Field data containing the data to fetch.
	SourceOffset	Member offset in the source field data to begin fetching values.
	SourceCount	Number of values to fetch from the source field data.
	DestValueArray	Pre-allocated array large enough to hold the requested members. The first member is placed at the base of the array. The native type of the array must match that of the field data.

Python Syntax:

    This function is not supported in Python.

void TecUtilDataValueArraySetByRef	(	FieldData_pa	DestFieldData,
		LgIndex_t	DestOffset,
		LgIndex_t	DestCount,
		void *	SourceValueArray
	)

Copies the specified number of values from the base of the source value array to the destination field data starting at the specified offset.

Note that the source value array must be of the same data type as the destination field data.

Since:: 10.0-3-12

Parameters:

	DestFieldData	Field data to receive the source values.
	DestOffset	Member offset in the destination field data to begin assigning values. DestOffset >= 1 and DestOffset <= DestCount.
	DestCount	Number of values to assign to the destination field data.
	SourceValueArray	An array containing the members to copy. The first member is assumed to be at the base of the array.

Python Syntax:

    This function is not supported in Python.

Boolean_t TecUtilDataValueAutoLOD	(	EntIndex_t	Zone,
		EntIndex_t	Var,
		DataValueStructure_e	DataValueStructure,
		const char *	FileName,
		FileOffset_t	Offset,
		Int64_t	Stride,
		Boolean_t	IsDataNativeByteOrder
	)

Specifies where in the data file the data for the specified variable resides.

The variable must be layed out in memory using the structure specified. Using this information Tecplot will automatically load and unload the variable 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 variable at unspecified times.

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

Since:: 11.0-0-001

Parameters:

	Zone	The zone of the variable to have Tecplot automatically load on demand.
	Var	Variable to have Tecplot automatically load on demand.
	DataValueStructure	Specifies the structure type to which the data in the file conforms.
	FileName	Data file name containing the variable data layed out using Tecplot's binary block data format.
	Offset	Absolute offset to the start of the variable data in the file.
	Stride	The stride tells Tecplot how to skip through the file for nodal data. Only nodal data can specify a stride greater than one. A stride of one offers much higher load/unload performance than strides greater than one.
	IsDataNativeByteOrder	Indicates if the byte ordering of the data in the file matches the machine's native byte ordering.

Returns:: TRUE if the variable is setup for auto loading, FALSE otherwise.

See also:: TecUtilDataValueCustomLOD()

Python Syntax:

  Results = TecUtil.DataValueAutoLOD(Zone, Var, DataValueStructure, FileName, Offset, Stride, IsDataNativeByteOrder)

  Input:
                  Zone                 int
                  Var                  int
                  DataValueStructure   DataValueStructure_e  (defined in TecVals.py)
                  FileName             string
                  Offset               long
                  Stride               long
                  IsDataNativeByteOrder boolean
  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilDataValueBranchShared	(	EntIndex_t	Zone,
		EntIndex_t	Var
	)

Branch off a shared variable.

The specified variable of the specified zone is branched so it is no longer shared with anything.

Parameters:

	Zone	Zone in which the shared variable is located.
	Var	Variable that will be branched

Returns:: TRUE if successful, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataValueBranchShared(
   &                   Zone,
   &                   Var)
    INTEGER*4       Zone
    INTEGER*4       Var

Python Syntax:

  Results = TecUtil.DataValueBranchShared(Zone, Var)

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

Branch variable 2 in zone 1.

   TecUtilDataValueBranchShared(1, 2);

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

Deprecated:: Please use TecUtilDataValueAutoLOD() instead.

void TecUtilDataValueCopy	(	EntIndex_t	SourceZone,
		EntIndex_t	DestZone,
		EntIndex_t	Var
	)

Copies the data from the source zone's variable to the destination zone.

The destination zone's variable must already be allocated or memory mapped and it may not be shared. Both zones must have the same structure (both Ordered with the same I,J, and K values; or both are finite-elements with the same element type and same number of nodes.

Parameters:

	SourceZone	The zone number where the data values are based.
	DestZone	The zone number where the data values will be copied from the source zone.
	Var	The variable to be copied.

Fortran Syntax:

    SUBROUTINE TecUtilDataValueCopy(
   &           SourceZone,
   &           DestZone,
   &           Var)
    INTEGER*4       SourceZone
    INTEGER*4       DestZone
    INTEGER*4       Var

Python Syntax:

  Results = TecUtil.DataValueCopy(SourceZone, DestZone, Var)

  Input:
                  SourceZone           int
                  DestZone             int
                  Var                  int
  Output:
    Results[0]    ReturnVal            NONE

Copy the values from variable 1 of zone 2 to zone 3.

   TecUtilDataValueCopy(2, 3, 1);

Boolean_t TecUtilDataValueCustomLOD	(	EntIndex_t	Zone,
		EntIndex_t	Var,
		LoadOnDemandVarLoad_pf	VariableLoad,
		LoadOnDemandVarUnload_pf	VariableUnload,
		LoadOnDemandVarCleanup_pf	VariableCleanup,
		FieldValueGetFunction_pf	GetValueFunction,
		FieldValueSetFunction_pf	SetValueFunction,
		ArbParam_t	ClientData
	)

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

Tecplot will notify the add-on via the callbacks when the variable needs to be loaded, unloaded, and cleaned up or when a value needs to be fetched or submitted.

All callbacks must be written in a thread-safe manner so that Tecplot can make parallel requests to load (and/or unload) multiple variables. The easiest way to write thread-safe callbacks is to not 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.

It is important that GetValue and SetValue callbacks do NOT lock/unlock Tecplot or call TecUtil functions that require Tecplot to be locked as this will incur a performance penalty. GetValue and SetValue functions should be lightweight and fast.

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 variable. In addition, no state changes should be broadcast by the callbacks.

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

Two methods for loading and accessing data are available for custom load-on-demand (see ADK Users Manual for details):

Custom Load Variable on Demand:
The add-on supplied VariableLoad() callback is responsible for loading the entire variable data into the Tecplot prepared field data backing. Tecplot is responsible for allocating and freeing the space for the field data backing. In addition the add-on must supply the VariableCleanup() callback to receive notification when the variable source is no longer needed. Optionally the add-on may supply the VariableUnload() callback to receive notification of the variable being unloaded. Most add-ons should supply NULL for the VariableUnload() callback instructing Tecplot to assume responsibility for unloading the variable and re-loading it in an efficient form. The "Custom Load Variable on Demand" method is signified by passing NULL for the GetValueFunction() and SetValueFunction() callback parameters.
Custom Load Value on Demand:
The add-on supplied GetValueFunction() and an optional SetValueFunction() are used by Tecplot to fetch and submit variable data. If the SetValueFunction() is not provided Tecplot will create its own copy of the variable when an attempt is made to modify the variable values (such as via a Tecplot Data Alter operation). The VariableLoad(), VariableUnload(), and VariableCleanup() callbacks are optional. The add-on may supply these callback to receive notification of Tecplot's intent or NULL if the add-on is not interested in the notifications.

Since:: 11.0-0-001

Parameters:

	Zone	Zone containing the variable that will now be custom load-on-demand.
	Var	Variable that will now be custom load-on-demand.
	VariableLoad	Tecplot calls this callback when the variable is to be loaded. The VariableLoad() callback may never get called if the variable is not needed or it may get called immediately if load-on-demand capabilities are not available. Depending on the load-on-demand method the callback has different responsibilities: If the variable is using the "Custom Load Variable on Demand" method (signified by passing NULL for the GetValueFunction() and SetValueFunction() callback parameters) the callback is responsible for loading the entire variable data into the Tecplot prepared field data backing using information from its private client to locate or generate the data. If the variable is using the "Custom Load Value on Demand" method (signified by passing a non-NULL GetValueFunction() callback parameter) the callback is simply a notification that Tecplot is getting ready to fetch data via the GetValueFunction() or, if supplied, submit data via the SetValueFunction().
	VariableUnload	Most add-ons will supply NULL for this callback. Supplying NULL instructs Tecplot to handled the unloading (and subsequent reloading) of the variable without the intervention of the add-on. If the add-on does supply this callback, Tecplot calls it when the variable is to be unloaded. This query provides the add-on an opportunity to allow or deny a variable 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 variable (i.e. the VariableUnload() callback should return TRUE). An add-on may also cleanup any private resources that are not needed when the variable is unloaded, however the add-on must still maintain enough information to load the variable again if requested by Tecplot. The VariableUnload() callback may never get called if the variable does not need to be unloaded nor will the VariableUnload() callback necessarily be called before the VariableCleanup() callback.
	VariableCleanup	Tecplot calls this callback when the variable 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 variable. After a variable is cleaned up Tecplot will never again request it to be loaded. Tecplot may or may not call the VariableUnload() callback before calling the VariableCleanup() callback. Additionally, the VariableCleanup() callback will be called even if the variable was never loaded.
	GetValueFunction	Tecplot calls this callback to fetch the value from the field data at the specified index. This callback is only registered by add-ons that are using the "Custom Load Value on Demand" method, otherwise pass NULL.
	SetValueFunction	Tecplot calls this callback to submit a value to the field data at the specified index. This callback is only registered by add-ons that are using the "Custom Load Value on Demand" method, otherwise pass NULL. By providing a SetValueFunction() callback the add-on is signifying it will store any changes to the field data until the variable is cleaned up. Most "Custom Load Value on Demand" add-ons should pass NULL for this callback and allow Tecplot to store variable modifications.
	ClientData	Private client data needed by the custom load-on-demand callbacks to perform the duties of loading, unloading, and cleaning up the variable or to perform the get or set requests. Tecplot stores the client data in the field data structure and must be retrieved by the callbacks using TecUtilDataValueGetClientData(). The client data should ONLY be retrieved in response to a custom load, unload, cleanup, get-value, or set-value callback. At no other time is the request valid.

Returns:: TRUE if successful, FALSE otherwise.

Following is an example of how to create a variable using the "Custom Load Value on Demand" method by registering a very simple GetValueFunction() that always returns zero without the overhead of allocating any data.

   double *ZeroVariableGetValue(const FieldData_pa FieldData,
                                        LgIndex_t          PointIndex)
   {
     return 0.0;
   }

   .
   .
   .
   IsOk = TecUtilDataValueCustomLOD(3, 4, NULL, NULL, NULL,
                                    ZeroVariableGetValue, NULL, 0);

Following is an example of how to create a variable using the "Custom Load Variable on Demand" method by registering some simple load/unload/cleanup callbacks.

   typedef struct
     {
       char      *DataFileName;
       long       SeekOffset;
       LgIndex_t  NumValues;
       ... other information needed to load variable data
     } MyVariableClientData_s;

   Boolean_t MyVariableLoader(FieldData_pa FieldData)
   {
     REQUIRE(VALID_REF(FieldData));

     MyVariableClientData_s *MyClientData = (MyVariableClientData_s *)TecUtilDataValueGetClientData(FieldData);

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

     // seek to the place in the file where the variable data is located
     IsOk = IsOk && (fseek(MyDataFile, MyClientData->SeekOffset, SEEK_SET) == 0);
     if (IsOk)
       {
         // load the data into the variable's field data
         IsOk = ReadMyDataInfoVariable(MyDataFile, MyClientData, FieldData);
       }

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

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

   Boolean_t MyVariableUnload(FieldData_pa FieldData)
   {
     REQUIRE(VALID_REF(FieldData));

     // 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 variable.
     Boolean_t Result = TRUE; // ...tell Tecplot to go ahead and unload the variable

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

   void MyVariableCleanup(FieldData_pa FieldData)
   {
     REQUIRE(VALID_REF(FieldData));

     MyVariableClientData_s *MyClientData = (MyVariableClientData_s *)TecUtilDataValueGetClientData(FieldData);

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

   .
   .
   .
   MyVariableClientData_s *MyClientData = (MyVariableClientData_s *)malloc(sizeof(MyVariableClientData_s));
   const char *MyDataFileName = "MyDataFileName.dat";
   MyClientData->MyDataFileName = (char *)malloc(strlen(MyDataFileName)+1);
   strcpy(MyClientData->MyDataFileName, MyDataFileName);
   MyClientData->SeekOffset = ... determined somewhere else
   MyClientData->NumValues = ... determined somewhere else
   ... initialize any other client data information needed to load variable data
   IsOk = TecUtilDataValueCustomLOD(3, 4,
                                    MyVariableLoader,
                                    MyVariableUnload, // most add-ons should pass NULL instead of MyVariableUnload
                                    MyVariableCleanup,
                                    NULL, // passing NULL for GetValue function signifies load-variable-on-demand
                                    NULL,
                                    (ArbParam_t)MyClientData);

Python Syntax:

    This function is not supported in Python.

See also:: TecUtilDataValueAutoLOD(), TecUtilDataValueSetMinMaxByZoneVar(), TecUtilMemoryChangeNotify()

double TecUtilDataValueGetByRef	(	FieldData_pa	FieldData,
		LgIndex_t	PointIndex
	)

Get a field data value.

To use this function you must have already obtained a handle to field data.

Parameters:

	FieldData	A field data reference usually obtained via a call to one of the following functions: TecUtilDataValueGetReadableNativeRef(), TecUtilDataValueGetReadableDerivedRef(), TecUtilDataValueGetReadableNLRef(), or TecUtilDataValueGetReadableCCRef().
	PointIndex	Position in the array of field data values. Position starts at one. If FieldData came from an IJ- or IJK-ordered zone then the position is calculated by treating the two- or three-dimensional array as a one-dimensional array.

Returns:: The value at a given position in field data FieldData

Fortran Syntax:

    REAL*8 FUNCTION TecUtilDataValueGetByRef(
   &                   FieldDataPtr,
   &                   PointIndex)
    POINTER         (FieldDataPtr, FieldData)
    INTEGER*4       PointIndex

Python Syntax:

  Results = TecUtil.DataValueGetByRef(FieldData, PointIndex)

  Input:
                  FieldData            opaque pointer
                  PointIndex           int
  Output:
    Results[0]    ReturnVal            double

Get the first twenty data values for the second variable in zone 5:

   FieldData_pa fd = TecUtilDataValueGetReadableNativeRef(5, 2);
   LgIndex_t numpts = TecUtilDataValueGetCountByRef(fd);
   if ( fd )
     {
       int ii;
       for ( ii = 1; ii <= numpts; ii++ )
         {
           double val = TecUtilDataValueGetByRef(fd, ii);
           // do something with val
         }
     }

See also:: TecUtilDataValueRefGetGetFunc() for obtaining a function as a high performance alternative.

double TecUtilDataValueGetByZoneVar	(	EntIndex_t	Zone,
		EntIndex_t	Var,
		LgIndex_t	PointIndex
	)

Get a field data value.

This function does not require you to obtain the handle to the field data as does TecUtilDataValueGetByRef(), however, this function is not very efficient. Use TecUtilDataValueGetByRef() if you are getting multiple values from the same zone.

Parameters:

	Zone	The zone number
	Var	The variable number
	PointIndex	Position in the array of field data values. Position starts at one. If FieldData came from an IJ- or IJK-ordered zone then the position is calculated by treating the two- or three-dimensional array as a one-dimensional array

Returns:: The variable value at a specific point in a zone.

Fortran Syntax:

    REAL*8 FUNCTION TecUtilDataValueGetByZoneVar(
   &                   Zone,
   &                   Var,
   &                   PointIndex)
    INTEGER*4       Zone
    INTEGER*4       Var
    INTEGER*4       PointIndex

Python Syntax:

  Results = TecUtil.DataValueGetByZoneVar(Zone, Var, PointIndex)

  Input:
                  Zone                 int
                  Var                  int
                  PointIndex           int
  Output:
    Results[0]    ReturnVal            double

Get the twenty-first value of the second variable of zone 5:

   double dd = TecUtilDataValueGetByZoneVar(5, 2, 21);
   // Use val.

ArbParam_t TecUtilDataValueGetClientData ( FieldData_pa FieldData )

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

The client data should ONLY be retrieved in response to a custom load, unload, cleanup, get-value, or set-value callback. At no other time is the request valid.

Note:: This is implemented as a macro.

Parameters:

FieldData

Custom load-on-demand field data handle.

Returns:: Client data for the custom load-on-demand add-on.

Python Syntax:

    This function is not supported in Python.

   double MyGetValueFunction(const FieldData_pa FieldData,
                                     LgIndex_t          PointIndex)
   {
     double Result;
     MyClientData_s *MyClientData = (MyClientData_s *)TecUtilDataValueGetClientData(FieldData);

     // calculate or extract the requested value from the client data
       .
       .
       .

     return Result;
   }

See also:: TecUtilDataValueCustomLOD()

LgIndex_t TecUtilDataValueGetCountByRef ( FieldData_pa FieldData )

Gets the number of values associated with the field data reference.

Since:: 11.0-0-353

Parameters:

FieldData

Handle to the field data. Use TecUtilDataValueGetReadableNativeRef(), TecUtilDataValueGetReadableDerivedRef(), TecUtilDataValueGetReadableNLRef(), TecUtilDataValueGetReadableCCRef(), or TecUtilDataValueGetWritableNativeRef() to get readable or writable handles to the field data.

Returns:: The number of values associated with the field data reference.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataValueGetCountByRef(FieldDataPtr)
   &                   FieldDataPtr)
    POINTER         (FieldDataPtr, FieldData)

Python Syntax:

  Results = TecUtil.DataValueGetCountByRef(FieldData)

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

Determine how many values are associated with the second variable of zone 5.

   FieldData_pa FD = TecUtilDataValueGetReadableNativeRef(5, 2);
   LgIndex_t NumValues = TecUtilDataValueGetCountByRef(FD);

ValueLocation_e TecUtilDataValueGetLocation	(	EntIndex_t	Zone,
		EntIndex_t	Var
	)

Queries for the location of the variable.

Parameters:

	Zone	The zone number.
	Var	The variable number

Returns:: The value location of the variable.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataValueGetLocation(
   &                   Zone,
   &                   Var)
    INTEGER*4       Zone
    INTEGER*4       Var

Python Syntax:

  Results = TecUtil.DataValueGetLocation(Zone, Var)

  Input:
                  Zone                 int
                  Var                  int
  Output:
    Results[0]    ReturnVal            ValueLocation_e  (defined in TecVals.py)

Get the value location of variable 2 in zone 5:

   ValueLocation_e ValLoc = TecUtilDataValueGetLocation(5, 2);

void TecUtilDataValueGetMinMaxByRef	(	FieldData_pa	FieldData,
		double *	Min,
		double *	Max
	)

Get the minimum and maximum values for a tecplot variable using the field data reference.

Parameters:

	FieldData	A field data reference usually obtained via a call to one of the following functions: TecUtilDataValueGetReadableNativeRef(), TecUtilDataValueGetReadableDerivedRef(), TecUtilDataValueGetReadableNLRef(), or TecUtilDataValueGetReadableCCRef().
	Min	Returned minimum value.
	Max	Returned maximum value.

Returns:: TRUE if the min/max value could be retrieved, FALSE otherwise.

Fortran Syntax:

    SUBROUTINE TecUtilDataValueGetMinMaxByRef(
   &           FieldDataPtr,
   &           Min,
   &           Max)
    POINTER         (FieldDataPtr, FieldData)
    REAL*8          Min
    REAL*8          Max

Python Syntax:

  Results = TecUtil.DataValueGetMinMaxByRef(FieldData)

  Input:
                  FieldData            opaque pointer
  Output:
    Results[0]    Min                  double
    Results[1]    Max                  double

Get the minimum and maximum values for the third variable in zone 2 in the current data set.

   FieldData_pa FD;
   double       Min;
   double       Max;

   FD = TecUtilDataValueGetReadableNativeRef(2,3);
   TecUtilDataValueGetMinMaxByRef(FD,&Min,&Max);

See also:: TecUtilDataValueGetYMinMaxByZoneVar(), TecUtilDataValueSetMinMaxByZoneVar()

Boolean_t TecUtilDataValueGetMinMaxByZoneVar	(	EntIndex_t	Zone,
		EntIndex_t	Var,
		double *	Min,
		double *	Max
	)

Get the minimum and maximum values for a tecplot variable using a zone and variable number.

Since:: 11.0-0-007

Parameters:

	Zone	The zone number of the variable to be examinined for min/max values.
	Var	The variable number to be examinined for min/max values.
	Min	Returned minimum value.
	Max	Returned maximum value.

Returns:: TRUE if the min/max value could be retrieved, FALSE otherwise.

Fortran Syntax:

    SUBROUTINE TecUtilDataValueGetMinMaxByZoneVar(
   &           Zone,
   &           Var,
   &           Min,
   &           Max)
    INTEGER*4       Zone
    INTEGER*4       Var
    REAL*8          Min
    REAL*8          Max

Python Syntax:

  Results = TecUtil.DataValueGetMinMaxByZoneVar(Zone, Var)

  Input:
                  Zone                 int
                  Var                  int
  Output:
    Results[0]    ReturnVal            boolean
    Results[1]    Min                  double
    Results[2]    Max                  double

Get the minimum and maximum values for the third variable in zone 2 in the current data set.

   double Min;
   double Max;
   TecUtilDataValueGetMinMaxByZoneVar(2,3,&Min,&Max);

See also:: TecUtilDataValueSetMinMaxByZoneVar()

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().

FieldData_pa TecUtilDataValueGetReadableCCRef	(	EntIndex_t	Zone,
		EntIndex_t	Var
	)

Get a read-only handle to the cell centered data for the specified zone and variable in the data set attached to the current frame.

Since:: 11.2-0-397

Parameters:

	Zone	Number of the zone for which to get the field data
	Var	Number of the variable for which to get the field data

Returns:: A read-only field data handle to the cell centered data for the specified zone and variable in the data set attached to the current frame or NULL if Tecplot was interrupted or was not able to load or derive the data.

Fortran Syntax:

    SUBROUTINE TecUtilDataValueGetReadableCCRef(
   &           Zone,
   &           Var,
   &           ResultPtr)
    INTEGER*4       Zone
    INTEGER*4       Var
    POINTER         (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.DataValueGetReadableCCRef(Zone, Var)

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

Function that loads the values of a field variable into a supplied double precision array. Assume the array is already dimensioned correctly and the dataset, zone, and variable exist.

 static void ReadVals(double     Var[],
                      EntIndex_t ZoneNum,
                      EntIndex_t VarNum)
 {
   FieldData_pa FieldData = TecUtilDataValueGetReadableCCRef(ZoneNum, VarNum);
   if (FieldData)
     {
       int i;
       LgIndex_t NumValues = TecUtilDataValueGetCountByRef(FieldData);

       // Remember that the GetByRef function is 1-based....
       for (i = 0; i < NumPointsInZone; i++)
         Var[i] = TecUtilDataValueGetByRef(FieldData, i+1);
     }
 }

See also:: TecUtilDataValueGetReadableNativeRef(), TecUtilDataValueGetReadableDerivedRef(), TecUtilDataValueGetReadableNLRef(), TecUtilDataValueGetWritableNativeRef()

FieldData_pa TecUtilDataValueGetReadableDerivedRef	(	EntIndex_t	Zone,
		EntIndex_t	Var
	)

Get a read-only handle to the derived data for the specified zone and variable in the data set attached to the current frame.

Since:: 11.2-0-397

Parameters:

	Zone	Number of the zone for which to get the field data
	Var	Number of the variable for which to get the field data

Returns:: A read-only field data handle to the derived data for the specified zone and variable in the data set attached to the current frame or NULL if Tecplot was interrupted or was not able to load or derive the data.

Fortran Syntax:

    SUBROUTINE TecUtilDataValueGetReadableDerivedRef(
   &           Zone,
   &           Var,
   &           ResultPtr)
    INTEGER*4       Zone
    INTEGER*4       Var
    POINTER         (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.DataValueGetReadableDerivedRef(Zone, Var)

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

Function that loads the values of a field variable into a supplied double precision array. Assume the array is already dimensioned correctly and the dataset, zone, and variable exist.

 static void ReadVals(double     Var[],
                      EntIndex_t ZoneNum,
                      EntIndex_t VarNum)
 {
   FieldData_pa FieldData = TecUtilDataValueGetReadableDerivedRef(ZoneNum, VarNum);
   if (FieldData)
     {
       int i;
       LgIndex_t NumValues = TecUtilDataValueGetCountByRef(FieldData);

       // Remember that the GetByRef function is 1-based....
       for (i = 0; i < NumPointsInZone; i++)
         Var[i] = TecUtilDataValueGetByRef(FieldData, i+1);
     }
 }

See also:: TecUtilDataValueGetReadableNativeRef(), TecUtilDataValueGetReadableNLRef(), TecUtilDataValueGetReadableCCRef(), TecUtilDataValueGetWritableNativeRef()

FieldData_pa TecUtilDataValueGetReadableNativeRef	(	EntIndex_t	Zone,
		EntIndex_t	Var
	)

Get a read-only handle to the native data for the specified zone and variable in the data set attached to the current frame.

Since:: 11.2-0-397

Parameters:

	Zone	Number of the zone for which to get the field data
	Var	Number of the variable for which to get the field data

Returns:: A read-only field data handle to the native data for the specified zone and variable in the data set attached to the current frame or NULL if Tecplot was not able to load the data.

Fortran Syntax:

    SUBROUTINE TecUtilDataValueGetReadableNativeRef(
   &           Zone,
   &           Var,
   &           ResultPtr)
    INTEGER*4       Zone
    INTEGER*4       Var
    POINTER         (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.DataValueGetReadableNativeRef(Zone, Var)

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

Function that loads the values of a field variable into a supplied double precision array. Assume the array is already dimensioned correctly and the dataset, zone, and variable exist.

 static void ReadVals(double     Var[],
                      EntIndex_t ZoneNum,
                      EntIndex_t VarNum)
 {
   FieldData_pa FieldData = TecUtilDataValueGetReadableNativeRef(ZoneNum, VarNum);
   if (FieldData)
     {
       int i;
       LgIndex_t NumValues = TecUtilDataValueGetCountByRef(FieldData);

       // Remember that the GetByRef function is 1-based....
       for (i = 0; i < NumPointsInZone; i++)
         Var[i] = TecUtilDataValueGetByRef(FieldData, i+1);
     }
 }

See also:: TecUtilDataValueGetReadableDerivedRef(), TecUtilDataValueGetReadableNLRef(), TecUtilDataValueGetReadableCCRef(), TecUtilDataValueGetWritableNativeRef()

FieldData_pa TecUtilDataValueGetReadableNLRef	(	EntIndex_t	Zone,
		EntIndex_t	Var
	)

Get a read-only handle to the node located data for the specified zone and variable in the data set attached to the current frame.

Since:: 11.2-0-397

Parameters:

	Zone	Number of the zone for which to get the field data
	Var	Number of the variable for which to get the field data

Returns:: A read-only field data handle to the node located data for the specified zone and variable in the data set attached to the current frame or NULL if Tecplot was interrupted or was not able to load or derive the data.

Fortran Syntax:

    SUBROUTINE TecUtilDataValueGetReadableNLRef(
   &           Zone,
   &           Var,
   &           ResultPtr)
    INTEGER*4       Zone
    INTEGER*4       Var
    POINTER         (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.DataValueGetReadableNLRef(Zone, Var)

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

Function that loads the values of a field variable into a supplied double precision array. Assume the array is already dimensioned correctly and the dataset, zone, and variable exist.

 static void ReadVals(double     Var[],
                      EntIndex_t ZoneNum,
                      EntIndex_t VarNum)
 {
   FieldData_pa FieldData = TecUtilDataValueGetReadableNLRef(ZoneNum, VarNum);
   if (FieldData)
     {
       int i;
       LgIndex_t NumValues = TecUtilDataValueGetCountByRef(FieldData);

       // Remember that the GetByRef function is 1-based....
       for (i = 0; i < NumPointsInZone; i++)
         Var[i] = TecUtilDataValueGetByRef(FieldData, i+1);
     }
 }

See also:: TecUtilDataValueGetReadableNativeRef(), TecUtilDataValueGetReadableDerivedRef(), TecUtilDataValueGetReadableCCRef(), TecUtilDataValueGetWritableNativeRef()

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

Get a read-only handle to the raw field data in the data set attached to the current frame.

If possible this function provides direct access to a Tecplot variable's internal representation. If performance is not a concern consider using TecUtilDataValueGetByRef(), TecUtilDataValueSetByRef(). If high performance is essential then use TecUtilDataValueArrayGetByRef(), and TecUtilDataValueArraySetByRef() which provide nearly equivalent preformance to direct access. Alternatively for high performance consider using the field data's accessor functions by calling TecUtilDataValueRefGetGetFunc() and TecUtilDataValueRefGetSetFunc(). Note that these high performance functions are a very thin layer over a Tecplot variable's internal representation and unlike the raw field data pointer provided by this function, they are always available.

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.

Since:: 11.0-0-007

Parameters:

	Zone	Number of the zone for which to get the raw field data.
	Var	Number of the variable for which to get the raw field data.
	DataPtr	Receives the address of the raw field data. May return NULL if the type is too complex. If the type is too complex, you may use TecUtilDataValueRefGetGetFunc() and TecUtilDataValueRefGetSetFunc() to get functions that will deal with the data at a lower level than TecUtilDataValueGetByRef() and TecUtilDataValueSetByRef().
	FieldDataType	Receives the data type of the raw field data. The following table shows the possible values for FieldDataType along with the corresponding data type that DataPtr references:

     FieldDataType            DataPtr references
     -------------------------------------------
     FieldDataType_Float      float *
     FieldDataType_Double     double *
     FieldDataType_Int32      Int32_t *
     FieldDataType_Int16      Int16_t *
     FieldDataType_Byte       char *
     FieldDataType_Bit        UInt32_t *
     FieldDataType_Invalid    too complex

Fortran Syntax:

    SUBROUTINE TecUtilDataValueGetReadableRawPtr(
   &           Zone,
   &           Var,
   &           DataPtr,
   &           FieldDataType)
    INTEGER*4       Zone
    INTEGER*4       Var
    POINTER         (DataPtrPtr, DataPtr)
    INTEGER*4       FieldDataType

Python Syntax:

    This function is not supported in Python.

Get the first and second value values of the second variable of zone 5 using a raw data pointer. Note that the first and second values are accessed by zero and one respectively since the raw data is accessed with a zero-base numbering system.

   EntIndex_t zone = 5;
   EntIndex_t var = 2;
   void *raw_fd_ptr = NULL;
   FieldDataType_e field_data_type;
   TecUtilDataValueGetReadableRawPtr(zone, var, &raw_fd_ptr, &field_data_type);
   if ( raw_fd_ptr )
     {
       if ( field_data_type == FieldData_Float )
         {
           const float *float_ptr = (const float *)raw_fd_ptr;
           float v1 = float_ptr[0];
           float v2 = float_ptr[1];
           ... do something with the data
         }
     }

See also:: TecUtilDataValueGetReadableNativeRef(), TecUtilDataValueGetReadableDerivedRef(), TecUtilDataValueGetReadableNLRef(), TecUtilDataValueGetReadableCCRef(), TecUtilDataValueGetWritableNativeRef(), TecUtilDataValueArrayGetByRef(), TecUtilDataValueArraySetByRef(), TecUtilDataValueRefGetGetFunc(), and TecUtilDataValueRefGetSetFunc().

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().

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().

FieldDataType_e TecUtilDataValueGetRefType ( FieldData_pa FieldData )

Get the field data type of a field data handle.

Parameters:

FieldData

The field data reference for which the data type is desired.

Returns:: The field data type of FieldData. The possible values are: FieldDataType_Float, FieldDataType_Double, FieldDataType_Int32, FieldDataType_Int16, FieldDataType_Byte, or FieldDataType_Bit.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataValueGetRefType(FieldDataPtr)
    POINTER (FieldDataPtr, FieldData)

Python Syntax:

  Results = TecUtil.DataValueGetRefType(FieldData)

  Input:
                  FieldData            opaque pointer
  Output:
    Results[0]    ReturnVal            FieldDataType_e  (defined in TecVals.py)

Get the type of the data for variable 2 in zone 5 of the data set attached to the current frame and do something special if that type is FieldDataType_Bit

   FieldData_pa fd = TecUtilDataValueGetReadableNativeRef(5, 2);
   FieldDataType_e field_data_type = TecUtilDataValueGetRefType(fd);
   if (field_data_type == FieldDataType_Bit)
     {
       // do something special
     }

See also:: TecUtilDataValueGetType()

EntIndex_t TecUtilDataValueGetShareCount	(	EntIndex_t	Zone,
		EntIndex_t	Var
	)

Get a count for the number of times a particular variable is shared.

Parameters:

	Zone	Zone in which the shared variable is located.
	Var	Variable that is shared.

Returns:: Returns share count for the given variable within the given zone. This is the number of times the data handle is shared. 1 means not shared (shared once), 2 means two zones share it, etc.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataValueGetShareCount(
   &                   Zone,
   &                   Var)
    INTEGER*4       Zone
    INTEGER*4       Var

Python Syntax:

  Results = TecUtil.DataValueGetShareCount(Zone, Var)

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

Get share count of variable 2 in zone 1.

   EntIndex_t ShareCount = TecUtilDataValueGetShareCount(1, 2);

Set_pa TecUtilDataValueGetShareZoneSet	(	EntIndex_t	Zone,
		EntIndex_t	Var
	)

Gets the set of zones that share the variable with the specified zone.

If the specified zone's variable is shared then it is also a member of the resulting set otherwise an empty set is returned.

Parameters:

	Zone	Zone for which sharing information is desired.
	Var	Variable for which sharing information is desired.

Returns:: Allocated set of zones that share the variable with the specified zone.

Fortran Syntax:

    SUBROUTINE TecUtilDataValueGetShareZoneSet(
   &           Zone,
   &           Var,
   &           ResultPtr)
    INTEGER*4       Zone
    INTEGER*4       Var
    POINTER         (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.DataValueGetShareZoneSet(Zone, Var)

  Input:
                  Zone                 int
                  Var                  int
  Output:
    Results[0]    ReturnVal            sequence of ints

FieldDataType_e TecUtilDataValueGetType	(	EntIndex_t	Zone,
		EntIndex_t	Var
	)

Queries for the data type of the variable.

Since:: 11.0-0-001

Parameters:

	Zone	The zone number.
	Var	The variable number

Returns:: The data type of the variable.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataValueGetType(
   &                   Zone,
   &                   Var)
    INTEGER*4       Zone
    INTEGER*4       Var

Python Syntax:

  Results = TecUtil.DataValueGetType(Zone, Var)

  Input:
                  Zone                 int
                  Var                  int
  Output:
    Results[0]    ReturnVal            FieldDataType_e  (defined in TecVals.py)

Get the data type of variable 2 in zone 5:

   FieldDataType_e ValLoc = TecUtilDataValueGetType(5, 2);

See also:: TecUtilDataValueGetRefType()

FieldData_pa TecUtilDataValueGetWritableNativeRef	(	EntIndex_t	Zone,
		EntIndex_t	Var
	)

Get a native read/write handle to the data for the specified zone and variable in the data set attached to the current frame.

It is important to realize that when altering the values this variable may in fact be shared. If you want the new values to only apply to the specific zone and variable associated with this handle then you must first call TecUtilDataValueBranchShared() prior to calling TecUtilDataValueGetWritableNativeRef().

Since:: 11.2-0-397

Parameters:

	Zone	Number of the zone for which to get the field data
	Var	Number of the variable for which to get the field data

Returns:: A read/write field data handle to the native data for the specified zone and variable in the data set attached to the current frame or NULL if Tecplot was interrupted or was not able to load the data.

Fortran Syntax:

    SUBROUTINE TecUtilDataValueGetWritableNativeRef(
   &           Zone,
   &           Var,
   &           ResultPtr)
    INTEGER*4       Zone
    INTEGER*4       Var
    POINTER         (ResultPtr, Result)

Python Syntax:

  Results = TecUtil.DataValueGetWritableNativeRef(Zone, Var)

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

Function that multiplies variable VarNum in Zone ZoneNum by 2.

 static void MultiplyV3By2(EntIndex_t ZoneNum,
                           EntIndex_t VarNum)
 {
   // Make sure we are only modifying var VarNum in zone ZoneNum.
   if (TecUtilDataValueBranchShared(ZoneNum,VarNum))
     {
       FieldData_pa FieldData = TecUtilDataValueGetWritableNativeRef(ZoneNum, VarNum);
       if (FieldData)
         {
           int i;
           LgIndex_t NumValues = TecUtilDataValueGetCountByRef(FieldData);

           // Note 1-based 
           for (i = 1; i <= NumPointsInZone; i++)
             {
               double OldValue = TecUtilDataValueGetByRef(FieldData, i);
               TecUtilDataValueSetByRef(FieldData,i,OldValue*2.0);
             }
         }
     }
 }

See also:: TecUtilDataValueGetReadableNativeRef(), TecUtilDataValueGetReadableDerivedRef(), TecUtilDataValueGetReadableNLRef(), TecUtilDataValueGetReadableCCRef()

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

Get a read/write handle to the raw field data in the data set attached to the current frame.

If possible this function provides direct access to a Tecplot variable's internal representation. If performance is not a concern consider using TecUtilDataValueGetByRef(), TecUtilDataValueSetByRef(). If high performance is essential then use TecUtilDataValueArrayGetByRef(), and TecUtilDataValueArraySetByRef() which provide nearly equivalent preformance to direct access. Alternatively for high performance consider using the field data's accessor functions by calling TecUtilDataValueRefGetGetFunc() and TecUtilDataValueRefGetSetFunc(). Note that these high performance functions are a very thin layer over a Tecplot variable's internal representation and unlike the raw field data pointer provided by this function, they are always available.

Note:: 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. Make sure to call TecUtilStateChanged() after any field values have changed.

Since:: 11.0-0-007

Parameters:

	Zone	Number of the zone for which to get the raw field data.
	Var	Number of the variable for which to get the raw field data.
	DataPtr	Receives the address of the raw field data. May return NULL if the type is too complex. If the type is too complex, you may use TecUtilDataValueRefGetGetFunc() and TecUtilDataValueRefGetSetFunc() to get functions that will deal with the data at a lower level than TecUtilDataValueGetByRef() and TecUtilDataValueSetByRef().
	FieldDataType	Receives the data type of the raw field data. The following table shows the possible values for FieldDataType along with the corresponding data type that DataPtr references:

     FieldDataType            DataPtr references
     -------------------------------------------
     FieldDataType_Float      float *
     FieldDataType_Double     double *
     FieldDataType_Int32      Int32_t *
     FieldDataType_Int16      Int16_t *
     FieldDataType_Byte       char *
     FieldDataType_Bit        UInt32_t *
     FieldDataType_Invalid    too complex

Fortran Syntax:

    SUBROUTINE TecUtilDataValueGetWritableRawPtr(
   &           Zone,
   &           Var,
   &           DataPtr,
   &           FieldDataType)
    INTEGER*4       Zone
    INTEGER*4       Var
    POINTER         (DataPtrPtr, DataPtr)
    INTEGER*4       FieldDataType

Python Syntax:

    This function is not supported in Python.

Get and then set the first and second values of the second variable of zone 5 using a raw data pointer. Note that the first and second values are accessed by zero and one respectively since the raw data is accessed with a zero-base numbering system. Be sure to call TecUtilStateChanged() when you change the data in this way:

   EntIndex_t zone = 5;
   EntIndex_t var = 2;
   void *raw_fd_ptr = NULL;
   FieldDataType_e field_data_type;
   TecUtilDataValueGetWritableRawPtr(zone, var, &raw_fd_ptr, &field_data_type);
   if ( raw_fd_ptr )
     {
       if ( field_data_type == FieldData_Float )
         {
           Set_pa altered_vars = TecUtilSetAlloc(TRUE);
           float *float_ptr = (float *)raw_fd_ptr;
           float v1 = float_ptr[0];
           float v2 = float_ptr[1];
           // alter v1 and v2 in some way
           v1 = 2.0 * v1;
           v2 = 2.0 * v2;
           float_ptr[0] = v1;
           float_ptr[1] = v2;
           // inform Tecplot of var value change
           TecUtilSetAddMember(altered_vars, var, TRUE);
           TecUtilStateChanged(StateChange_VarsAltered,
                               (ArbParam_t)altered_vars);
           TecUtilSetDealloc(&altered_vars);
         }
     }

See also:: TecUtilDataValueGetReadableNativeRef(), TecUtilDataValueGetReadableDerivedRef(), TecUtilDataValueGetReadableNLRef(), TecUtilDataValueGetReadableCCRef(), TecUtilDataValueGetWritableNativeRef(), TecUtilDataValueArrayGetByRef(), TecUtilDataValueArraySetByRef(), TecUtilDataValueRefGetGetFunc(), and TecUtilDataValueRefGetSetFunc().

FieldData_pa TecUtilDataValueGetWritableRef	(	EntIndex_t	Zone,
		EntIndex_t	Var
	)

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

Boolean_t TecUtilDataValueGetZoneVarByRef	(	FieldData_pa	FD,
		EntIndex_t *	Zone,
		EntIndex_t *	Var
	)

Get a candidate zone and variable associated with the given field data reference.

Note that if the variable is shared then more than one zone and variable combination exists, therefore the first zone and variable combination associated with the field data reference is returned. The following search rules are used: Active relevant zones are searched first and then all remaining enabled zones.

Since:: 11.0-1-099

Parameters:

	FD	A field data reference usually obtained via a call to one of the following functions: TecUtilDataValueGetReadableNativeRef(), TecUtilDataValueGetReadableDerivedRef(), TecUtilDataValueGetReadableNLRef(), TecUtilDataValueGetReadableCCRef(), or TecUtilDataValueGetWritableNativeRef().
	Zone	Pointer to the resulting candidate Zone associated with the field data.
	Var	Pointer to the resulting Variable associated with the field data.

Returns:: Returns TRUE if such a zone and variable exists that uses this field data handle.

Fortran Syntax:

   None.

Python Syntax:

  Results = TecUtil.DataValueGetZoneVarByRef(FD, Zone, Var)

  Input:
                  FD                   opaque pointer
                  Zone                 list of ints
                  Var                  list of ints
  Output:
    Results[0]    ReturnVal            boolean

Get a candidate zone and variable associated with field data FD;

   EntIndex_t  Zone;
   EntIndex_t  Var;
   FieldData_pa FD = TecUtilDataValueGetReadableNaiveRef(5, 2);;

   if (TecUtilDataValueGetZoneVarByRef(FD,&Zone,&Var))
     {
       // Do something with Zone and Var.
     }

Boolean_t TecUtilDataValueIsPassive	(	EntIndex_t	Zone,
		EntIndex_t	Var
	)

Determine if a variable is passive for a particular zone.

Refer to the Data Format Guide for more information on passive variables.

Since:: 11.2-0-380

Parameters:

	Zone	The number of the zone to which the variable belongs.
	Var	The number of the variable in question.

Returns:: Returns TRUE if the specified variable is passive, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataValueIsPassive(
   &                   Zone,
   &                   Var)
    INTEGER*4       Zone
    INTEGER*4       Var

Python Syntax:

  Results = TecUtil.DataValueIsPassive(Zone, Var)

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

Boolean_t TecUtilDataValueIsSharingOk	(	EntIndex_t	SourceZone,
		EntIndex_t	DestZone,
		EntIndex_t	Var
	)

Determine if it is ok to share a variable between zones.

For rules on sharing between zones, see TecUtilDataValueShare().

Parameters:

	SourceZone	The source zone (the zone where the values will be stored).
	DestZone	The destination zone (the zone acquiring the shared values).
	Var	The variable to be shared.

Returns:: Returns TRUE if the specified variable sharing is allowed, FALSE if otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataValueIsSharingOk(
   &                   SourceZone,
   &                   DestZone,
   &                   Var)
    INTEGER*4       SourceZone
    INTEGER*4       DestZone
    INTEGER*4       Var

Python Syntax:

  Results = TecUtil.DataValueIsSharingOk(SourceZone, DestZone, Var)

  Input:
                  SourceZone           int
                  DestZone             int
                  Var                  int
  Output:
    Results[0]    ReturnVal            boolean

If sharing is ok for variable 7 between zones 3 and 5 then share the variable.

   if (TecUtilDataValueIsSharingOk(3,5,7))
     TecUtilDataValueShare(3,5,7);

See also:: TecUtilDataSetIsSharingAllowed() and TecUtilDataConnectIsSharingOk().

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

Deprecated:: Please use TecUtilDataValueAutoLOD() instead.

FieldValueGetFunction_pf TecUtilDataValueRefGetGetFunc ( FieldData_pa FD )

Get the low-level "get value" function associated with a field data handle.

In general, using this function is faster than calling TecUtilDataValueGetByRef().

Since:: 10.0-3-128

Note:: Do not assume that raw data internal to Tecplot remain in the same location at all times. Always re-fetch the field data reference and subsequently the "get value" function after any major event as Tecplot may move/alter the raw data. Make sure to call TecUtilStateChanged() after any field values have changed.

Parameters:

FD

A field data reference usually obtained via a call to one of the following functions: TecUtilDataValueGetReadableNativeRef(), TecUtilDataValueGetReadableDerivedRef(), TecUtilDataValueGetReadableNLRef(), TecUtilDataValueGetReadableCCRef(), or TecUtilDataValueGetWritableNativeRef().

Returns:: The low-level "get value" function associated with a field data handle. This function takes zero-based values and has no assertions associated with it.

Python Syntax:

    This function is not supported in Python.

Efficiently get the first twenty-one values of the second variable of zone 5:

   LgIndex pt;
   FieldData_pa FD = TecUtilDataValueGetReadableNaiveRef(5, 2);
   FieldValueGetFunction_pf GetFunction = TecUtilDataValueRefGetGetFunc(FD);
   for ( pt = 0; pt < 21; pt++ ) // use =0 and <21 becaused SetFunction is 0-based
     {
       double val = GetFunction(fd, pt);
       // Use val.
     }

FieldValueSetFunction_pf TecUtilDataValueRefGetSetFunc ( FieldData_pa FD )

Get the low-level "set value" function associated with a field data handle.

In general, using this function is faster than calling TecUtilDataValueSetByRef().

Since:: 10.0-3-128

Note:: Do not assume that raw data internal to Tecplot remain in the same location at all times. Always re-fetch the native field data reference and subsequently the "set value" function associated with that reference after any major event as Tecplot itself may move/alter the raw data. Make sure to call TecUtilStateChanged() after any field values have changed.

Parameters:

FD

A field data handle usually obtained via TecUtilDataValueGetWritableNativeRef().

Returns:: The low-level "set value" function associated with a field data handle. This function takes zero-based values and has no assertions associated with it.

Fortran Syntax:

   None.

Python Syntax:

    This function is not supported in Python.

Efficiently set the twenty-first values of the second variable of zone 5 to 17.6:

   Set_pa alteredVars = TecUtilSetAlloc(TRUE);
   LgIndex pt;
   FieldData_pa FD = TecUtilDataValueGetWritableNativeRef(5, 2);
   FieldValueSetFunction_pf setFunction = TecUtilDataValueRefSetGetFunc(FD);
   for ( pt = 0; pt < 21; pt++ ) // use =0 and <21 becaused setFunction is 0-based
     setFunction(fd, pt, 17.6);

   // inform Tecplot of var value change
   TecUtilSetAddMember(alteredVars, 2, TRUE);
   TecUtilStateChanged(StateChange_VarsAltered,
                       (ArbParam_t)alteredVars);
   TecUtilSetDealloc(&alteredVars);

void TecUtilDataValueSetByRef	(	FieldData_pa	FD,
		LgIndex_t	PointIndex,
		double	Value
	)

Assign a value to a field variable at a specific position.

If the zone referenced is IJ- or IJK-ordered, the position is calculated by treating the two- or three-dimensional array as a one-dimensional array. Be sure to call TecUtilStateChanged() after changing field data in this way.

Parameters:

	FD	A field data reference usually obtained via a call to one of the following functions: TecUtilDataValueGetReadableNativeRef(), TecUtilDataValueGetReadableDerivedRef(), TecUtilDataValueGetReadableNLRef(), TecUtilDataValueGetReadableCCRef(), or TecUtilDataValueGetWritableRef().
	PointIndex	Position in the array of field data values. Position starts at one. For cell centered variables in ordered zones, the array includes values for IMax, JMax and KMax, even though these values are not used. You must account for these "ghost" cells in calculating the PointIndex. The formula for PointIndex in terms of I,J, and K is the same for both Nodal and cell centered variables. PointIndex = I + (J-1)IMax + (K-1)IMax*JMax;
	Value	New value for the position in the field data.

Fortran Syntax:

    SUBROUTINE TecUtilDataValueSetByRef(
   &           FDPtr,
   &           PointIndex,
   &           Value)
    POINTER         (FDPtr, FD)
    INTEGER*4       PointIndex
    REAL*8          Value

Python Syntax:

  Results = TecUtil.DataValueSetByRef(FD, PointIndex, Value)

  Input:
                  FD                   opaque pointer
                  PointIndex           int
                  Value                double
  Output:
    Results[0]    ReturnVal            NONE

Set the first two values of the second variable of zone 5 to be 1.25 and 1.35 respectively:

   Set_pa altered_vars;
   FieldData_pa fd = TecUtilDataValueGetWritableNativeRef(5, 2);
   if ( fd )
     {
       TecUtilDataValueSetByRef(fd, 1, 1.25);
       TecUtilDataValueSetByRef(fd, 2, 1.35);
   
       // inform Tecplot of var value change 
   
       altered_vars = TecUtilSetAlloc(TRUE);
   
       TecUtilSetAddMember(altered_vars, var, TRUE);
       TecUtilStateChanged(StateChange_VarsAltered,
                           (ArbParam_t)altered_vars);
       TecUtilSetDealloc(&altered_vars);
     }

See also:: TecUtilDataValueRefGetSetFunc() for obtaining a function as a high performance alternative.

Boolean_t TecUtilDataValueSetByZoneVar	(	EntIndex_t	Zone,
		EntIndex_t	Var,
		LgIndex_t	PointIndex,
		double	Value
	)

Assign a value to a field variable at a specific position.

This function does not require you to obtain the handle to the field data as does TecUtilDataValueSetByRef(), however this function is not very efficient. Use TecUtilDataValueSetByRef() if you are setting multiple values in the same zone. If the zone referenced is IJ- or IJK-ordered then the position is calculated by treating the two- or three-dimensional array as a one-dimensional array. TecUtilStateChanged() need not be called after changing data in this way since Tecplot will handle that for you.

Parameters:

	Zone	The zone number.
	Var	The variable number.
	PointIndex	Position in the array of field data values. Position starts at one.
	Value	New value for the position in the field data.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilDataValueSetByZoneVar(
   &                   Zone,
   &                   Var,
   &                   PointIndex,
   &                   Value)
    INTEGER*4       Zone
    INTEGER*4       Var
    INTEGER*4       PointIndex
    REAL*8          Value

Python Syntax:

  Results = TecUtil.DataValueSetByZoneVar(Zone, Var, PointIndex, Value)

  Input:
                  Zone                 int
                  Var                  int
                  PointIndex           int
                  Value                double
  Output:
    Results[0]    ReturnVal            boolean

Set the first value of the second variable of zone 5 to be 0.0.

   TecUtilDataValueSetByZoneVar(5, 2, 1, 0.0);

void TecUtilDataValueSetMinMaxByRef	(	FieldData_pa	FieldData,
		double	MinValue,
		double	MaxValue
	)

Set the minimum and maximum values for a tecplot variable using a field data reference.

Although Tecplot will calculate the min/max value for a variable if one is not supplied there are cases where it is valuable to supply these values. If a loader add-on knows the min/max values it may save a significant amount of time to supply them. Additionally, if an add-on is loading variables using Tecplot's load-on-demand facility supplying the min/max value for a variable prevents Tecplot from having to load the variable in some situations, saving time and memory. It is important that the supplied values accurately represent the min/max values of the data and not a subset of the data.

Note:: If supplied, the min/max values MUST be assigned after a vars altered state change as the state change call will invalidate the min/max values.

Since:: 11.0-0-314

Parameters:

	FieldData	The field data handle of the variable to receive the min/max value assignments.
	MinValue	Minimum variable value.
	MaxValue	Maximum variable value.

Fortran Syntax:

    SUBROUTINE TecUtilDataValueSetMinMaxByRef(
   &           FieldDataPtr,
   &           MinValue,
   &           MaxValue)
    POINTER         (FieldDataPtr, FieldData)
    REAL*8          MinValue
    REAL*8          MaxValue

Python Syntax:

  Results = TecUtil.DataValueSetMinMaxByRef(FieldData, MinValue, MaxValue)

  Input:
                  FieldData            opaque pointer
                  MinValue             double
                  MaxValue             double
  Output:
    Results[0]    ReturnVal            NONE

Set the minimum and maximum values for a newly loaded variable.

   ... after defining the data to load, issue state change ...

   // supply the min/max value of the variable reference
   TecUtilDataValueSetMinMaxByRef(FieldData, MinValue, MaxValue);

Multiply the value of the 3rd variable of the 2nd zone and then tell Tecplot the new min/max value so it doesn't have to recalculate it.

   double     MinValue;
   double     MaxValue;
   double     Factor = 3.0;
   EntIndex_t Zone   = 2;
   EntIneex_t Var    = 3;

   FieldData_pa FieldData = TecUtilDataValueReadableGetRef(Zone, Var);
   TecUtilDataValueGetMinMaxByRef(FieldData, &MinValue, &MaxValue);

   // mutiply variable by the factor and issue a vars altered state change
   MyFuncToMultiplyVarByFactor(Zone, Var, Factor); //...not shown
   MyFuncToBroadcastStateChange(Zone, Var); //...not shown

   // assign the min/max values after a vars altered state change
   // as the state change call will invalidate the min/max values
   TecUtilDataValueSetMinMaxByRef(FieldData, MinValue*Factor, MaxValue*Factor);

See also:: TecUtilDataValueGetMinMaxByRef(), TecUtilDataValueGetMinMaxByZoneVar(), TecUtilDataValueSetMinMaxByZoneVar(), TecUtilDataValueCustomLOD()

void TecUtilDataValueSetMinMaxByZoneVar	(	EntIndex_t	Zone,
		EntIndex_t	Var,
		double	MinValue,
		double	MaxValue
	)

Set the minimum and maximum values for a tecplot variable using a zone and variable number.

Although Tecplot will calculate the min/max value for a variable if one is not supplied there are cases where it is valuable to supply these values. If a loader add-on knows the min/max values it may save a significant amount of time to supply them. Additionally, if an add-on is loading variables using Tecplot's load-on-demand facility supplying the min/max value for a variable prevents Tecplot from having to load the variable in some situations, saving time and memory. It is important that the supplied values accurately represent the min/max values of the data and not a subset of the data.

Note:: If supplied, the min/max values must be assigned after a vars altered state change as the state change call will invalidate the min/max values.

Since:: 11.0-0-007

Parameters:

	Zone	The zone number of the variable to receive the min/max value assignments.
	Var	The variable number to receive the min/max value assignments.
	MinValue	Minimum variable value.
	MaxValue	Maximum variable value.

Fortran Syntax:

    SUBROUTINE TecUtilDataValueSetMinMaxByZoneVar(
   &           Zone,
   &           Var,
   &           MinValue,
   &           MaxValue)
    INTEGER*4       Zone
    INTEGER*4       Var
    REAL*8          MinValue
    REAL*8          MaxValue

Python Syntax:

  Results = TecUtil.DataValueSetMinMaxByZoneVar(Zone, Var, MinValue, MaxValue)

  Input:
                  Zone                 int
                  Var                  int
                  MinValue             double
                  MaxValue             double
  Output:
    Results[0]    ReturnVal            NONE

Set the minimum and maximum values for a newly loaded variable.

   ... after defining the data to load, issue state change ...

   // supply the min/max value for the variable 2 of zone 5
   TecUtilDataValueSetMinMaxByZoneVar(5, 2, MinValue, MaxValue);

Multiply the value of the 3rd variable of the 2nd zone and then tell Tecplot the new min/max value so it doesn't have to recalculate it.

   double     MinValue;
   double     MaxValue;
   double     Factor = 3.0;
   EntIndex_t Zone   = 2;
   EntIneex_t Var    = 3;

   TecUtilDataValueGetMinMaxByZoneVar(Zone Var, &MinValue, &MaxValue);

   // mutiply variable by the factor and issue a vars altered state change
   MyFuncToMultiplyVarByFactor(Zone, Var, Factor); //...not shown
   MyFuncToBroadcastStateChange(Zone, Var); //...not shown

   TecUtilDataValueSetMinMaxByZoneVar(Zone, Var, MinValue*Factor, MaxValue*Factor);

See also:: TecUtilDataValueGetMinMaxByZoneVar(), TecUtilDataValueCustomLOD()

void TecUtilDataValueShare	(	EntIndex_t	SourceZone,
		EntIndex_t	DestZone,
		EntIndex_t	Var
	)

Sets the properties of the variable so that it is shared between source and destination zones (using the source for values).

Both zones must have the same structure and value location: Ordered zones must have the same number of points if nodal but cell centered zones must specifically have the same I,J, and K values. Finite-element zones must have the same number of points if nodal or the same number of elements if cell centered. Sharing data between ordered and finite-element zones is only allowed if the values are nodal and the zones have the same number of points. Cell centered sharing is not allowed because ordered zones have ghost cells and finite-element zones do not.

Parameters:

	SourceZone	The zone number where the data values are based.
	DestZone	The zone number where the data values will be shared from the source zone.
	Var	The variable to be shared.

Fortran Syntax:

    SUBROUTINE TecUtilDataValueShare(
   &           SourceZone,
   &           DestZone,
   &           Var)
    INTEGER*4       SourceZone
    INTEGER*4       DestZone
    INTEGER*4       Var

Python Syntax:

  Results = TecUtil.DataValueShare(SourceZone, DestZone, Var)

  Input:
                  SourceZone           int
                  DestZone             int
                  Var                  int
  Output:
    Results[0]    ReturnVal            NONE

Set the first variable of zone 3 to be shared with zone 2:

   TecUtilDataValueShare(2, 3, 1);

See also:: TecUtilDataValueAlloc() and TecUtilDataValueIsSharingOk()

Boolean_t TecUtilDataValueUnload	(	EntIndex_t	Zone,
		EntIndex_t	Var
	)

Instructs Tecplot to unload the variable.

All field data references to the unloaded variable are invalid. If after unloading the variable you wish to inspect or modify the field data you must re-obtain a readable or writable field data reference or raw pointer.

Since:: 11.0-0-244

Parameters:

	Zone	Zone containing the variable to unload.
	Var	Variable to unload.

Returns:: TRUE if the variable was unloaded, FALSE otherwise.

See also:: TecUtilDataValueGetReadableNativeRef(), TecUtilDataValueGetReadableDerivedRef(), TecUtilDataValueGetReadableNLRef(), TecUtilDataValueGetReadableCCRef(), TecUtilDataValueGetWritableNativeRef(), TecUtilDataValueGetReadableRawPtr(), TecUtilDataValueGetWritableRawPtr()

Python Syntax:

  Results = TecUtil.DataValueUnload(Zone, Var)

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

Boolean_t TecUtilExtractFromGeom	(	Boolean_t	ExtractOnlyPointsOnPolyline,
		Boolean_t	IncludeDistanceVariable,
		LgIndex_t	NumPtsToExtractAlongPolyline,
		Boolean_t	ExtractToFile,
		const char *	ExtractFName
	)

Extract data from a 2D or 3D field plot.

The locations at which to extract the data come from a polyline geometry that must be picked prior to issuing this command. When the frame mode is 3D and the ExtractThroughVolume parameter is false, the coordinates must be provided in the eye coordinate system, rather than in 3D grid coordinates.

Parameters:

	ExtractOnlyPointsOnPolyline	Extract only from the points that define the polyline
	IncludeDistanceVariable	Include the distance variable in the resulting data extracted. This is only available if ExtractToFile is TRUE
	NumPtsToExtractAlongPolyline	Number of points to evenly distribute along the polyline. Data is extracted from these points if ExtractOnlyPointsOnPolyline is FALSE
	ExtractToFile	If set to TRUE the data is sent to the file ExtractFName in the form of a valid Tecplot ASCII data file. If FALSE then a new zone is created within Tecplot
	ExtractFName	Name of the file where extracted data is sent if ExtractToFile is TRUE.

Returns:: TRUE if successful, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilExtractFromGeom(
   &                   ExtractOnlyPointsOnPolyline,
   &                   IncludeDistanceVariable,
   &                   NumPtsToExtractAlongPolyline,
   &                   ExtractToFile,
   &                   ExtractFName)
    INTEGER*4       ExtractOnlyPointsOnPolyline
    INTEGER*4       IncludeDistanceVariable
    INTEGER*4       NumPtsToExtractAlongPolyline
    INTEGER*4       ExtractToFile
    CHARACTER*(*)   ExtractFName

Python Syntax:

  Results = TecUtil.ExtractFromGeom(ExtractOnlyPointsOnPolyline, IncludeDistanceVariable, NumPtsToExtractAlongPolyline, ExtractToFile, ExtractFName)

  Input:
                  ExtractOnlyPointsOnPolyline boolean
                  IncludeDistanceVariable boolean
                  NumPtsToExtractAlongPolyline int
                  ExtractToFile        boolean
                  ExtractFName         string
  Output:
    Results[0]    ReturnVal            boolean

Extract 20 points from along the currently picked geometry. Send the result to a file called "extract.dat":

   TecUtilExtractFromGeom(FALSE,FALSE,20,TRUE,"extract.dat");

Boolean_t TecUtilExtractFromPolyline	(	const double *	PolylineXPts_Array,
		const double *	PolylineYPts_Array,
		const double *	PolylineZPts_Array,
		LgIndex_t	NumPtsInPolyline,
		Boolean_t	ExtractThroughVolume,
		Boolean_t	ExtractOnlyPointsOnPolyline,
		Boolean_t	IncludeDistanceVariable,
		LgIndex_t	NumPtsToExtractAlongPolyline,
		Boolean_t	ExtractToFile,
		const char *	ExtractFName
	)

Extract data from a 2-D or 3-D field plot.

Parameters:

	PolylineXPts_Array	X-array defining the polyline used to extract the data.
	PolylineYPts_Array	Y-array defining the polyline used to extract the data.
	PolylineZPts_Array	Z-array defining the polyline used to extract the data.
	NumPtsInPolyline	Number of points in the supplied polyline
	ExtractThroughVolume	If this is TRUE and the current frame mode is 3D then this will extract data from within any active volume zones in the data set. If the frame mode is 3D and this is FALSE then a projection is made from each extraction point onto the nearest surface away from your eye with respect to the eye coordinate system. If the frame mode is 2D then this parameter is ignored
	ExtractOnlyPointsOnPolyline	Extract only from the points that define the polyline
	IncludeDistanceVariable	Include the distance variable in the resulting extracted data. This is only available if ExtractToFile is TRUE.
	NumPtsToExtractAlongPolyline	Number of points to evenly distribute along the polyline. Data is extracted from these points if ExtractOnlyPointsOnPolyline is FALSE
	ExtractToFile	If set to TRUE the data is sent to the file ExtractFName in the form of a valid Tecplot ASCII data file. If FALSE then a new zone is created within Tecplot
	ExtractFName	Name of the file where extracted data is sent if ExtractToFile is TRUE

Returns:: TRUE if successful, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilExtractFromPolyline(
   &                   PolylineXPts_Array,
   &                   PolylineYPts_Array,
   &                   PolylineZPts_Array,
   &                   NumPtsInPolyline,
   &                   ExtractThroughVolume,
   &                   ExtractOnlyPointsOnPolyline,
   &                   IncludeDistanceVariable,
   &                   NumPtsToExtractAlongPolyline,
   &                   ExtractToFile,
   &                   ExtractFName)
    REAL*8          PolylineXPts_Array
    REAL*8          PolylineYPts_Array
    REAL*8          PolylineZPts_Array
    INTEGER*4       NumPtsInPolyline
    INTEGER*4       ExtractThroughVolume
    INTEGER*4       ExtractOnlyPointsOnPolyline
    INTEGER*4       IncludeDistanceVariable
    INTEGER*4       NumPtsToExtractAlongPolyline
    INTEGER*4       ExtractToFile
    CHARACTER*(*)   ExtractFName

Python Syntax:

  Results = TecUtil.ExtractFromPolyline(PolylineXPts_Array, PolylineYPts_Array, PolylineZPts_Array, NumPtsInPolyline, ExtractThroughVolume, ExtractOnlyPointsOnPolyline, IncludeDistanceVariable, NumPtsToExtractAlongPolyline, ExtractToFile, ExtractFName)

  Input:
                  PolylineXPts_Array   list of doubles
                  PolylineYPts_Array   list of doubles
                  PolylineZPts_Array   list of doubles
                  NumPtsInPolyline     int
                  ExtractThroughVolume boolean
                  ExtractOnlyPointsOnPolyline boolean
                  IncludeDistanceVariable boolean
                  NumPtsToExtractAlongPolyline int
                  ExtractToFile        boolean
                  ExtractFName         string
  Output:
    Results[0]    ReturnVal            boolean

Extract ten points from specific locations in a field plot. Create a zone with the extracted data:

   // raw data 
   double X[10] = { 0, 1, 2, 3, 3, 4, 4, 3, 4, 5 };
   double Y[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
   double Z[10] = { 4, 3, 2, 5, 3, 1, 2, 3, 4, 3 };
   
   TecUtilExtractFromPolyline(X,Y,Z,10,
                             TRUE,TRUE,FALSE,10,FALSE,NULL);

Boolean_t TecUtilExtractInstallCallback	(	ExtractDestination_pf	ExtractDestination,
		const char *	InformationLineText
	)

If the current frame is 2D or 3D, change the mouse mode to be the extract discrete points tool and instruct Tecplot to call a different function when the user completes an extract-like operation in the work area.

This function callback will remain in effect until the user changes mouse modes in the Tecplot interface.

Parameters:

	ExtractDestination	Function to call when the extract event has been completed
	InformationLineText	Text to write on the information line when the override is in effect

Returns:: TRUE if successfully installed.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilExtractInstallCallback(
   &                   ExtractDestination,
   &                   InformationLineText)
    EXTERNAL        ExtractDestination
    CHARACTER*(*)   InformationLineText

Python Syntax:

    This function is not supported in Python.

Change the mouse mode to be the Extract Discrete Points tool and install an extract callback function.

   void MyExtractFunction(LgIndex_t NumPts,
                                  double   *XValues,
                                  double   *YValues)
   {
     // do something 
   }
   .
   .
   .
     // elsewhere in the add-on 
     TecUtilExtractInstallCallback(MyExtractFunction,
                             "Status line info for my function");

SetValueReturnCode_e TecUtilFieldMapSetActive	(	Set_pa	FieldMapSet,
		AssignOp_e	AssignModifier
	)

Assign which field maps are active.

Parameters:

	FieldMapSet	Set of field maps used to change the set of active field maps. The way in which the active field maps are changed is based on the AssignModifier. Must not be NULL.
	AssignModifier	The possible values are: AssignOp_Equals, AssignOp_PlusEquals, AssignOp_MinusEquals

Returns:: The setvalue return code (of type SetValueReturnCode_e).

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilFieldMapSetActive(
   &                   FieldMapSetPtr,
   &                   AssignModifier)
    POINTER         (FieldMapSetPtr, FieldMapSet)
    INTEGER*4       AssignModifier

Python Syntax:

  Results = TecUtil.FieldMapSetActive(FieldMapSet, AssignModifier)

  Input:
                  FieldMapSet          sequence of ints
                  AssignModifier       AssignOp_e  (defined in TecVals.py)
  Output:
    Results[0]    ReturnVal            SetValueReturnCode_e  (defined in TecVals.py)

Activate field map 3:

   Set_pa FieldMapSet = TecUtilSetAlloc(TRUE);
   TecUtilSetAddMember(FieldMapSet, 3,TRUE);
   TecUtilFieldMapSetActive(FieldMapSet, AssignOp_PlusEquals);
   TecUtilSetDealloc(&FieldMapSet);

Boolean_t TecUtilImportAddConverter	(	DataSetConverter_pf	ConverterCallback,
		const char *	ConverterName,
		const char *	FNameExtension
	)

Register a data set converter with Tecplot.

This will add an option to the list of data imports accessed via the File/Import menu option. See Section 9.2, "Data Set Loaders," in the ADK User's Manual for a discussion of data set loaders.

Parameters:

	ConverterCallback	Name of the function to call to convert data to the Tecplot binary format.
	ConverterName	Unique name given to the data set converter. This name is used in the list of importers in the dialog launched by choosing File/Import. If a layout file is created the $READDATASET macro command will also use this name to identify the converter to use.
	FNameExtension	This is the file name extension used by files converted with this data set converter

Returns:: Returns TRUE if the data set converter is added.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilImportAddConverter(
   &                   ConverterCallback,
   &                   ConverterName,
   &                   FNameExtension)
    POINTER         (ConverterCallbackPtr, ConverterCallback)
    CHARACTER*(*)   ConverterName
    CHARACTER*(*)   FNameExtension

Python Syntax:

    This function is not supported in Python.

An add-on is created that has the following data set converter function:

   Boolean_t  ConvertBananaData(char  *DataFName,
                                char  *TempBinFName,
                                char **MessageString);
   {
      Boolean_t IsOk = TRUE;
      //
      // Code here to open DataFName,
      // read in the data and write out a binary
      // Tecplot datafile to TempBinFName using
      // calls to TecUtilTecXxx functions. If there is
      // a problem, call TecUtilStringAlloc() on
      // MessageString, supply a message describing the
      // issue, and set ISOk to FALSE.
      //
      return (IsOk);
   }
   The call to register the data set converter with Tecplot is then accomplished using the following:
   .
   .
       IsOk = TecUtilImportAddConverter(ConvertBananaData,
                                        "BANANA",
                                        "*.ban");

Boolean_t TecUtilImportAddLoader	(	DataSetLoader_pf	LoaderCallback,
		const char *	DataSetLoaderName,
		DynamicMenuCallback_pf	LoaderSelectedCallback,
		DataSetLoaderInstructionOverride_pf	InstructionOverrideCallback
	)

Register a data set loader with Tecplot.

This will add an option to the list of data imports accessed via the File/Import menu option. Data set loaders are more complex than data set converters, but provide you with greater flexibility in terms of the graphical user interface and how the data can be retrieved. See Section 9.2, "Data Set Loaders," in the ADK User's Manual for a discussion of data set loaders.

Parameters:

	LoaderCallback	Name of the function to call to load non-Tecplot format data into Tecplot. The data set loader itself calls this function when a request is made to load non-Tecplot format data in via the user interface. Tecplot also calls this function when processing a $!READDATASET macro command that identifies this loader.
	DataSetLoaderName	Unique name given to the DataSet Loader. This name is used in the list of importers in the dialog launched by choosing File/Import. If a layout file is created, the $READDATASET macro command will also use this name to identify the loader to use.
	LoaderSelectedCallback	Name of the function that is called when the user selects this data set loader from the list of importers in the File/Import dialog. This function typically will launch a custom dialog to prompt the user to identify the data to be loaded
	InstructionOverrideCallback	Name of the function to call when the user chooses to override the data source for a given data set when a layout file is being read in. If set to NULL then Tecplot will issue an error message stating that this operation is not available. If provided, this function typically will launch a dialog that shows the user what the current settings are to load the data and provide a means by which the user can alter these instructions. The Instructions stringlist is updated according to changes made by the user and the new information is then used to load the data.

Returns:: Returns TRUE if the data set loader is added.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilImportAddLoader(
   &                   LoaderCallback,
   &                   DataSetLoaderName,
   &                   LoaderSelectedCallback,
   &                   InstructionOverrideCallback)
    POINTER         (LoaderCallbackPtr, LoaderCallback)
    CHARACTER*(*)   DataSetLoaderName
    POINTER         (LoaderSelectedCallbackPtr, LoaderSelectedCallback)
    POINTER         (InstructionOverrideCallbackPtr, InstructionOverrideCallback)

Python Syntax:

    This function is not supported in Python.

An add-on is created that has the following data set loader function:

   Boolean_t LoadBananaData (StringList_pa Instructions)
   {
     Boolean_t IsOk = TRUE;
     //
     // Add code to scan through instructions
     // and load the data.  When done, inform
     // Tecplot about the instructions used to
     // load the data.
     //
      if (IsOk)
        TecUtilImportSetLoaderInstr("BANANA", Instructions);
      return (IsOk);
   }
   
   A function is also created to handle user requests to use the loader from the File/Import dialog:
   
     void BananaLoaderDialog (void)
     {
      //
      // Launch a custom dialog to prompt the
      // user to identify the data to be loaded.
      //
     }
   A function is also created to handle user requests to modify the instructions.  This function is optional.
     Boolean_t OverrideBananaInstructions
              (StringList_pa Instructions)
     {
        Boolean_t IsOk = TRUE;
        //
        // Code here to view the current instructions and present
        // an interface to the user to change them.
        //
         return (IsOk);
     }
   The call to register the data set loader with Tecplot is then accomplished using the following:
      .
      .
      IsOk = TecUtilImportAddLoader(LoadBananaData,
                                    "BANANA",
                                    BananaLoaderDialog,
                                    OverrideBananaInstructions);

Boolean_t TecUtilImportGetLoaderInstr	(	char **	DataSetLoaderName,
		StringList_pa *	DataSetLoaderInstructions
	)

Get the instructions of the last data loader used to load the data into the data set attached to the current frame.

If a foreign data set loader addon was used to load the data, then the instruction string passed to the loader is returned. If the data was loaded by Tecplot, then the DataSetReaderName returned is "TECPLOT" and each file name in the data set is returned in the DataSetLoaderInstructions stringlist parameter. The current frame must have an attached data set when this function is used.

Note:: This function now has less usefulness in Tecplot than it once did in previous versions. Tecplot now maintains a data journal which allows for more complex data load sequences. It is important to note that other data altering instructions may follow your data loader instructions. This function does not provide any such information to the add-on.

Parameters:

	DataSetLoaderName	Name of the data set loader. You must use TecUtilStringDealloc() to free this string when you are done with it.
	DataSetLoaderInstructions	The data set loader instructions. You must use TecUtilStringListDealloc() to free this string list when you are done with it.

Returns:: Returns TRUE if the data was loaded using a data set loader.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilImportGetLoaderInstr(
   &                   DataSetLoaderName,
   &                   DataSetLoaderNameLength,
   &                   DataSetLoaderInstructionsPtr)
    CHARACTER*(*)   DataSetLoaderName
    INTEGER*4       DataSetLoaderNameLength
    POINTER         (DataSetLoaderInstructionsPtr, DataSetLoaderInstructions)

Python Syntax:

  Results = TecUtil.ImportGetLoaderInstr()

  Output:
    Results[0]    ReturnVal            boolean
    Results[1]    DataSetLoaderName    string
    Results[2]    DataSetLoaderInstructions sequence of strings

Get the data set loader and instructions used to load the current frame's data set:

   if (TecUtilDataSetIsAvailable())
     {
       char *LoaderName;
       StringList_pa LoaderInstructs;
       Boolean_t IsOk = TecUtilImportGetLoaderInstr(&LoaderName,
                                                    &LoaderInstructs);
       if (IsOk                    &&
           LoaderName != NULL      &&
           LoaderInstructs != NULL &&
           strcmp(LoaderName, "BANANA") == 0)
         {
           ...
         }

       if (LoaderName != NULL)
         TecUtilStringDealloc(&LoaderName);
       if (LoaderInstructs != NULL)
         TecUtilStringListDealloc(&LoaderInstructs);
     }

void TecUtilImportGetLoaderInstrByNum	(	LgIndex_t	Index,
		char **	DataSetReaderName,
		StringList_pa *	DataSetLoaderInstructions
	)

Retrieves the instructions of the n'th data loader used to load the data into the data set attached to the current frame.

Use 1 for the first data loader, or call TecUtilImportGetLoaderInstrCount(), and use this value to get the most recent data loader. If a foreign data set loader addon was used to load the data, then the instruction string passed to the loader is returned. If the data was loaded by Tecplot, then the DataSetReaderName returned is "TECPLOT" and each file name in the data set is returned in the DataSetLoaderInstructions stringlist parameter. The current frame must have an attached data set when this function is used. You MUST call TecUtilImportGetLoaderInstrCount before calling this function in order to verify that at least 1 load command exists in the data journal. This function will assert if the Index parameter is invalid.

Parameters:

	Index	Index of the loader instruction list to retrieve
	DataSetReaderName	Receives the DataSet reader name of the selected instruction list This parameter must be released after use with TecUtilStringDealloc. This parameter may be NULL.
	DataSetLoaderInstructions	Receives the instruction string list selected This parameter must be released after use with TecUtilStringListDealloc. This parameter may be NULL.

Fortran Syntax:

    SUBROUTINE TecUtilImportGetLoaderInstrByNum 
   &           Index,
   &           DataSetReaderName
   &           DataSetReaderNameLength
   &           DataSetLoaderInstructions,
    INTEGER*4       Index
    CHARACTER*(*)   DataSetReaderName
    INTEGER*4       DataSetReaderNameLength
    POINTER         (DataSetLoaderInstructions, StringList)

Python Syntax:

  Results = TecUtil.ImportGetLoaderInstrByNum(Index)

  Input:
                  Index                int
  Output:
    Results[0]    DataSetReaderName    string
    Results[1]    DataSetLoaderInstructions sequence of strings

   if (TecUtilDataSetIsAvailable())
     {
       LgIndex_t MaxInstr = TecUtilImportGetLoaderInstrCount();
       if ( MaxInstr > 0 ) 
         {
           // only call TecUtilImportGetLoaderInstrByNum if
           // at least one dataset read instruction list exists

           StringList_pa Instr = NULL;
           char *LoaderName = NULL;
           // Get the last instruction list available
           TecUtilImportGetLoaderInstrByNum(MaxInstr, // 1-based
                                            &LoaderName,
                                            &Instr);

           // release when finished
           TecUtilStringDealloc(&LoaderName);
           TecUtilStringListDealloc(&Instr);
         }
     }

See also:: TecUtilImportGetLoaderInstr TecUtilImportGetLoaderInstrCount

LgIndex_t TecUtilImportGetLoaderInstrCount ( void )

Gets the number of loader instruction lists available for retrieval by TecUtilImportGetLoaderInstrByNum.

You must call this function before calling TecUtilImportGetLoaderInstrByNum, to determine the maximum index of the dataset reader instruction index parameter. This function will return 0 if there are no dataset read commands in the journal. You must call this function before calling TecUtilImportGetLoaderInstrCount() in order to verify that at least one dataset read command has been executed.

Returns:: The number of instruction lists (read commands) available for retrieval by TecUtilImportGetLoaderInstrByNum. Returns 0 if there have been no dataset read commands.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilImportGetLoaderInstrCount()

Python Syntax:

  Results = TecUtil.ImportGetLoaderInstrCount()

  Output:
    Results[0]    ReturnVal            int

   if (TecUtilDataSetIsAvailable())
     {
       LgIndex_t MaxInstr = TecUtilImportGetLoaderInstrCount();
       if ( MaxInstr > 0 ) 
         {
           // only call TecUtilImportGetLoaderInstrByNum if
           // at least one dataset read instruction list exists

           StringList_pa *Instr = NULL;
           char *LoaderName = NULL;
           // Get the last instruction list available
           TecUtilImportGetLoaderInstrByNum(MaxInstr, // 1-based
                                            &LoaderName,
                                            &Instr);

           // release when finished
           TecUtilStringDealloc(&LoaderName);
           TecUtilStringListDealloc(&Instr);
         }
     }

See also:: TecUtilImportGetLoaderInstr TecUtilImportGetLoaderInstrByNum

Boolean_t TecUtilImportSetLoaderInstr	(	const char *	DataSetLoaderName,
		StringList_pa	Instructions
	)

Inform Tecplot about the instructions used to load the current data set.

It is assumed that the current data set was loaded via a data set loader. The current frame must have an attached data set when this function is used.

Parameters:

	DataSetLoaderName	Unique loader name. This same name must be used in TecUtilImportAddLoader().
	Instructions	Instructions used to load the current data set

Returns:: Returns TRUE if the instructions were successfully loaded.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilImportSetLoaderInstr(
   &                   DataSetLoaderName,
   &                   InstructionsPtr)
    CHARACTER*(*)   DataSetLoaderName
    POINTER         (InstructionsPtr, Instructions)

Python Syntax:

  Results = TecUtil.ImportSetLoaderInstr(DataSetLoaderName, Instructions)

  Input:
                  DataSetLoaderName    string
                  Instructions         sequence of strings
  Output:
    Results[0]    ReturnVal            boolean

void TecUtilImportWriteLoaderInstr	(	const char *	DataSetLoaderName,
		StringList_pa	Instructions
	)

Writes a $!READDATASET macro command to the macro file if macro recording is on.

Note:: Since TecUtilImportSetLoaderInstr() will automatically call this function, you normally do not need to call this function. If you are writing a loader that does not use an instruction string, that is it does not call TecUtilImportSetLoaderInstr(), then you should call this function before displaying your data.

Parameters:

	DataSetLoaderName	Unique loader name. This same name must be used when calling TecUtilImportAddLoader().
	Instructions	Instructions used to load the current data set. If you are not calling TecUtilImportSetLoaderInstr(), then typically this would be the filename which was used to load your data.

Fortran Syntax:

    SUBROUTINE TecUtilImportWriteLoaderInstr(
   &           DataSetLoaderName,
   &           InstructionsPtr)
    CHARACTER*(*)   DataSetLoaderName
    POINTER         (InstructionsPtr, Instructions)

Python Syntax:

  Results = TecUtil.ImportWriteLoaderInstr(DataSetLoaderName, Instructions)

  Input:
                  DataSetLoaderName    string
                  Instructions         sequence of strings
  Output:
    Results[0]    ReturnVal            NONE

Set up an instruction containing a filename and write a $!READDATASET macro command to the current macro file:

   StringList_pa Instructs = TecUtilStringListAlloc();
   TecUtilStringListAppendString(Instructs, "myfile.dat");
   TecUtilImportWriteLoaderInstr("BANANA", Instructs);
   TecUtilStringListDealloc(&Instructs);

Boolean_t TecUtilInverseDistInterpolation	(	Set_pa	SourceZones,
		EntIndex_t	DestZone,
		Set_pa	VarList,
		double	InvDistExponent,
		double	InvDistMinRadius,
		PtSelection_e	InterpPtSelection,
		LgIndex_t	InterpNPoints
	)

Interpolate selected variables from one or more zones onto a destination zone using the inverse distance method.

See Section 8.8.1, "Inverse-Distance Interpolation," in the Tecplot User's Manual for more information about inverse distance interpolation and its available options.

Parameters:

	SourceZones	Set of zones used to obtain the field values from for the interpolation. Use NULL to specify all zones except DestZone.
	DestZone	Destination zone for the interpolation
	VarList	Set of variables to interpolate. Use NULL to specify all variables except those assigned to the axes
	InvDistExponent	Exponent for the inverse-distance weighting. (Normal default value is 3.5.)
	InvDistMinRadius	Minimum distance used for the inverse-distance weighting. (Normal default value is 0.0.)
	InterpPtSelection	Method for determining which source points to consider for each destination data point. (Normal default value is PtSelection_OctantN.) The possible values are: PtSelection_All (All points in the source zone). PtSelection_NearestN (Closest N points to the destination point). PtSelection_OctantN (Closest N points selected by coordinate-system octants)
	InterpNPoints	Number of source points to consider for each destination data point. Only used if InterpPtSelection is PtSelection_NearestN or PtSelection_OctantN. (Normal default value is eight.) Must be greater than zero

Returns:: Returns TRUE if the interpolation completes successfully. A FALSE return value indicates that the user pressed cancel during the interpolation process or that the input parameters are not valid.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilInverseDistInterpolation(
   &                   SourceZonesPtr,
   &                   DestZone,
   &                   VarListPtr,
   &                   InvDistExponent,
   &                   InvDistMinRadius,
   &                   InterpPtSelection,
   &                   InterpNPoints)
    POINTER         (SourceZonesPtr, SourceZones)
    INTEGER*4       DestZone
    POINTER         (VarListPtr, VarList)
    REAL*8          InvDistExponent
    REAL*8          InvDistMinRadius
    INTEGER*4       InterpPtSelection
    INTEGER*4       InterpNPoints

Python Syntax:

  Results = TecUtil.InverseDistInterpolation(SourceZones, DestZone, VarList, InvDistExponent, InvDistMinRadius, InterpPtSelection, InterpNPoints)

  Input:
                  SourceZones          sequence of ints
                  DestZone             int
                  VarList              sequence of ints
                  InvDistExponent      double
                  InvDistMinRadius     double
                  InterpPtSelection    PtSelection_e  (defined in TecVals.py)
                  InterpNPoints        int
  Output:
    Results[0]    ReturnVal            boolean

Interpolate all of the variables (except those assigned to the axes) from zones 1-3 to zone 4 using inverse-distance.

   Boolean_t IsOk;
   Set_pa Zones = TecUtilSetAlloc(TRUE);
   TecUtilSetAddMember(Zones, 1, TRUE);
   TecUtilSetAddMember(Zones, 2, TRUE);
   TecUtilSetAddMember(Zones, 3, TRUE);
   IsOk = TecUtilInverseDistInterpolation(
            Zones,
            4,
            (Set_pa)NULL,
            3.5,
            0.0,
            PtSelection_OctantN,
            8);
   TecUtilSetDealloc(&Zones);

Boolean_t TecUtilKrig	(	Set_pa	SourceZones,
		EntIndex_t	DestZone,
		Set_pa	VarList,
		double	KrigRange,
		double	KrigZeroValue,
		Drift_e	KrigDrift,
		PtSelection_e	InterpPtSelection,
		LgIndex_t	InterpNPoints
	)

Interpolate selected variables from a set of source zones to a destination zone using the kriging method.

See Section 8.8.2, "Kriging," in the Tecplot User's Manual for more information about kriging and its available options.

Parameters:

	SourceZones	Set of zones used to obtain the field values for interpolation. Use NULL to specify all zones except DestZone
	DestZone	Destination zone for interpolation
	VarList	Set of variables to interpolate. Use NULL to specify all variables except those assigned to the axes
	KrigRange	Distance beyond which source points become insignificant. (Normal default value is 0.3.) Must be between zero and one, inclusive
	KrigZeroValue	Semi-variance at each source data point on a normalized scale from zero to one. (Normal default value is 0.0.)
	KrigDrift	Overall trend for the data. (Normal default value is Drift_Linear.) The possible values are: Drift_None (No trend). Drift_Linear (Linear trend). Drift_Quad (Quadratic trend).
	InterpPtSelection	Method for determining which source points to consider for each destination data point. The possible values are: PtSelection_All (All points in the source zone). PtSelection_NearestN (Closest N points to the destination point). PtSelection_OctantN (Closest N points selected by coordinate-system octants)
	InterpNPoints	Number of source points to consider for each destination data point. Only used if InterpPtSelection is PtSelection_NearestN or PtSelection_OctantN. (Normal default value is eight.) Must be greater than zero

Returns:: Returns TRUE if the interpolation completes successfully. A FALSE return value indicates that the user pressed cancel during the interpolation process or that the input parameters are not valid.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilKrig(
   &                   SourceZonesPtr,
   &                   DestZone,
   &                   VarListPtr,
   &                   KrigRange,
   &                   KrigZeroValue,
   &                   KrigDrift,
   &                   InterpPtSelection,
   &                   InterpNPoints)
    POINTER         (SourceZonesPtr, SourceZones)
    INTEGER*4       DestZone
    POINTER         (VarListPtr, VarList)
    REAL*8          KrigRange
    REAL*8          KrigZeroValue
    INTEGER*4       KrigDrift
    INTEGER*4       InterpPtSelection
    INTEGER*4       InterpNPoints

Python Syntax:

  Results = TecUtil.Krig(SourceZones, DestZone, VarList, KrigRange, KrigZeroValue, KrigDrift, InterpPtSelection, InterpNPoints)

  Input:
                  SourceZones          sequence of ints
                  DestZone             int
                  VarList              sequence of ints
                  KrigRange            double
                  KrigZeroValue        double
                  KrigDrift            Drift_e  (defined in TecVals.py)
                  InterpPtSelection    PtSelection_e  (defined in TecVals.py)
                  InterpNPoints        int
  Output:
    Results[0]    ReturnVal            boolean

Interpolate all of the variables (except those assigned to the axes) from zones 1-3 to zone 4 using kriging:

   Boolean_t IsOk;
   Set_pa Zones = TecUtilSetAlloc(TRUE);
   TecUtilSetAddMember(Zones, 1, TRUE);
   TecUtilSetAddMember(Zones, 2, TRUE);
   TecUtilSetAddMember(Zones, 3, TRUE);
   IsOk = TecUtilKrig(
            Zones,
            4,
            (Set_pa)NULL,
            0.3,
            0.0,
            Drift_Linear,
            PtSelection_OctantN,
            8);
   TecUtilSetDealloc(&Zones);

Boolean_t TecUtilLinearInterpolate	(	Set_pa	SourceZones,
		EntIndex_t	DestZone,
		Set_pa	VarList,
		double	LinearInterpConst,
		LinearInterpMode_e	LinearInterpMode
	)

Interpolate selected variables from a set of source zones to a destination zone using linear interpolation.

The source zones cannot be I-ordered. Values assigned to the destination zone are equivalent to the results of using the Probe tool in Tecplot. See Section 8.8.3, "Linear Interpolation," in the Tecplot User's Manual for more information about linear interpolation and its available options.

Parameters:

	SourceZones	Set of zones used to obtain the field values for interpolation. Use NULL to specify all zones except DestZone.
	DestZone	Destination zone for interpolation
	VarList	Set of variables to interpolate. Use NULL to specify all variables except those assigned to the axes
	LinearInterpConst	Constant value to which all points outside the data field are set. Only used if LinearInterpMode is LinearInterpMode_SetToConst. (Normal default value is 0.0.)
	LinearInterpMode	How to deal with points that are outside the source zones' data field. (Normal default value is LinearInterpMode_SetToConst.) The possible values are: LinearInterpMode_DontChange (Preserves the points values). LinearInterpMode_SetToConst (Sets all points to LinearInterpConst).

Returns:: Returns TRUE if the interpolation completes successfully. A FALSE return value indicates that the user pressed cancel during the interpolation process or that the input parameters are not valid.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilLinearInterpolate(
   &                   SourceZonesPtr,
   &                   DestZone,
   &                   VarListPtr,
   &                   LinearInterpConst,
   &                   LinearInterpMode)
    POINTER         (SourceZonesPtr, SourceZones)
    INTEGER*4       DestZone
    POINTER         (VarListPtr, VarList)
    REAL*8          LinearInterpConst
    INTEGER*4       LinearInterpMode

Python Syntax:

  Results = TecUtil.LinearInterpolate(SourceZones, DestZone, VarList, LinearInterpConst, LinearInterpMode)

  Input:
                  SourceZones          sequence of ints
                  DestZone             int
                  VarList              sequence of ints
                  LinearInterpConst    double
                  LinearInterpMode     LinearInterpMode_e  (defined in TecVals.py)
  Output:
    Results[0]    ReturnVal            boolean

Interpolate all of the variables (except those assigned to the axes) from zones 1-3 to zone 4 using linear interpolation:

   Boolean_t IsOk;
   Set_pa Zones = TecUtilSetAlloc(TRUE);
   TecUtilSetAddMember(Zones, 1, TRUE);
   TecUtilSetAddMember(Zones, 2, TRUE);
   TecUtilSetAddMember(Zones, 3, TRUE);
   IsOk = TecUtilLinearInterpolate(
            Zones,
            4,
            (Set_pa)NULL,
            0.0,
            LinearInterpMode_SetToConst);
   TecUtilSetDealloc(&Zones);

void TecUtilMemoryChangeNotify ( Int64_t ChangeInKBytes )

Notify Tecplot when a significant change in memory occurs that is outside Tecplot's knowledge.

The additional information allows Tecplot to make better estimates about when to perform load-on-demand house keeping. The change in kilobytes is summed with Tecplot's overall memory statistics. Therefore, it is important that an add-on provide symmetric values. In other words, at the end of the add-on's life cycle, the sum of memory increases should equal the sum of memory decreases.

Since:: 11.0-0-089

Parameters:

ChangeInKBytes

A value indicating the change in kilobytes. A positive value indicates an increased memory change while a negative value indicate a decreased memory change. A value of zero may also be passed indicating no change.

Notify Tecplot of a large change in memory.

   size_t BytesToAllocate = NumPoints * sizeof(MyStruct_s);
   MyStruct_s *MyArray = (MyStruct_s *)malloc(BytesToAllocate);
   if (MyArray != NULL)
     {
       Int64_t ChangeInKBytes = BytesToAllocate/1024
       TecUtilMemoryChangeNotify(ChangeInKBytes);

       ...do something useful with the array

       // cleanup
       free(MyArray);
       TecUtilMemoryChangeNotify(-ChangeInKBytes);
     }

See also:: TecUtilDataValueCustomLOD()

Python Syntax:

  Results = TecUtil.MemoryChangeNotify(ChangeInKBytes)

  Input:
                  ChangeInKBytes       long
  Output:
    Results[0]    ReturnVal            NONE

Boolean_t TecUtilPolarToRectangular ( Set_pa ZoneSet )

Deprecated:: Please use TecUtilTransformCoordinatesX() instead.

Boolean_t TecUtilReadDataSet	(	ReadDataOption_e	ReadDataOption,
		Boolean_t	ResetStyle,
		StringList_pa	FileNamesOrInstructions,
		const char *	DataSetReader,
		PlotType_e	InitialPlotType,
		Boolean_t	IncludeText,
		Boolean_t	IncludeGeom,
		Boolean_t	IncludeCustomLabels,
		Boolean_t	IncludeData,
		Boolean_t	CollapseZonesAndVars,
		Set_pa	ZonesToRead,
		VarLoadMode_e	VarLoadMode,
		Set_pa	VarPositionList,
		StringList_pa	VarNameList,
		LgIndex_t	ISkip,
		LgIndex_t	JSkip,
		LgIndex_t	KSkip
	)

Read one or more data files into Tecplot to form a new data set in the current frame.

Parameters:

	ReadDataOption	Determine how to handle the situation where a data set already exists in the current frame. The possible values are: ReadDataOption_NewData (Remove the data set from the current frame before loading the new data set), ReadDataOption_AppendData (Append the new data to the current data set), and ReadDataOption_ReplaceData (Replace the data set in the current frame and in all frames which share the data set with the new data).
	ResetStyle	TRUE if you want to reset the style of the current frame, FALSE if you want to keep the same style. Only used if ReadDataOption is ReadDataOption_NewData or ReadDataOption_ReplaceData.FileNamesOr
	FileNamesOrInstructions	A string list containing the file names to load or the instructions to send to the data set reader (converter or loader)
	DataSetReader	Name of the data set reader (converter or loader). To let Tecplot load the data, use "TECPLOT."
	InitialPlotType	Initial PlotType for the data. Only used if ResetStyle is TRUE. To have Tecplot determine the most appropriate frame mode for the data, use Frame_Empty. The possible values are: PlotType_Automatic: PlotType_Cartesian3D, PlotType_Cartesian2D, PlotType_XYLine, PlotType_PolarLine, and PlotType_Sketch. PlotType_Automatic instructs Tecplot to choose the best frame mode.
	IncludeText	Set to TRUE to load any text in the data files.
	IncludeGeom	Set to TRUE to load any geometries in the data files.
	IncludeCustomLabels	Set to TRUE to load any custom labels in the data files
	IncludeData	Set to TRUE to load the data from the data files. Set to FALSE to only load text, geometries and/or custom labels, depending on IncludeText, IncludeGeom, and IncludeCustomLabels
	CollapseZonesAndVars	Set to TRUE to renumber zones and variables if any are disabled. For more information on collapsing zones and variables, see Section 5.1.1.7, "Zone and Variable List Collapsing," in the Tecplot User's Manual
	ZonesToRead	Set of zones to load from the data files. Use NULL to load all zones
	VarLoadMode	Choose to load variables by name or by their position in the data file. See Section 5.1.1.6, "Variable Loading by Position," in the Tecplot User's Manual for more information about loading variables by name or by position. If ReadDataOption is ReadDataOption_AppendData, this must be same as the mode of the data set in the current frame. Use TecUtilDataSetGetVarLoadMode() to get this information. The possible values are: VarLoadMode_ByName and VarLoadMode_ByPosition.
	VarPositionList	Set of variables to load from the data files. Use NULL to load all variables. Ignored if VarLoadMode is VarLoadMode_ByName
	VarNameList	Set of variable names to load from the data files. Use NULL to load only variable names common to all data files. Must be NULL if VarLoadMode is VarLoadMode_ByPosition. When appending to the existing data set you must supply a new VarNameList where the new VarNameList is a superset of the existing one. A VarNameList that is a superset is one that contains all the variable names currently in use Tecplot. They must be in the same position. You can add new names either at the end of the list, or as aliases in the already established positions. Use a newline character to separate aliased names.If you do not create a VarNameList that is a superset then it is indeterminant which variable is in which position for the original data
	ISkip	Set to 1 to load every data point in the I-direction; 2 to load every other data point, and so forth.
	JSkip	Same as ISkip but for J-direction.
	KSkip	Same as ISkip but for K-direction.

Returns:: TRUE if the input parameters are valid and the data was successfully loaded, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilReadDataSet(
   &                   ReadDataOption,
   &                   ResetStyle,
   &                   FileNamesOrInstructionsPtr,
   &                   DataSetReader,
   &                   InitialPlotType,
   &                   IncludeText,
   &                   IncludeGeom,
   &                   IncludeCustomLabels,
   &                   IncludeData,
   &                   CollapseZonesAndVars,
   &                   ZonesToReadPtr,
   &                   VarLoadMode,
   &                   VarPositionListPtr,
   &                   VarNameListPtr,
   &                   ISkip,
   &                   JSkip,
   &                   KSkip)
    INTEGER*4       ReadDataOption
    INTEGER*4       ResetStyle
    POINTER         (FileNamesOrInstructionsPtr, FileNamesOrInstructions)
    CHARACTER*(*)   DataSetReader
    INTEGER*4       InitialPlotType
    INTEGER*4       IncludeText
    INTEGER*4       IncludeGeom
    INTEGER*4       IncludeCustomLabels
    INTEGER*4       IncludeData
    INTEGER*4       CollapseZonesAndVars
    POINTER         (ZonesToReadPtr, ZonesToRead)
    INTEGER*4       VarLoadMode
    POINTER         (VarPositionListPtr, VarPositionList)
    POINTER         (VarNameListPtr, VarNameList)
    INTEGER*4       ISkip
    INTEGER*4       JSkip
    INTEGER*4       KSkip

Python Syntax:

  Results = TecUtil.ReadDataSet(ReadDataOption, ResetStyle, FileNamesOrInstructions, DataSetReader, InitialPlotType, IncludeText, IncludeGeom, IncludeCustomLabels, IncludeData, CollapseZonesAndVars, ZonesToRead, VarLoadMode, VarPositionList, VarNameList, ISkip, JSkip, KSkip)

  Input:
                  ReadDataOption       ReadDataOption_e  (defined in TecVals.py)
                  ResetStyle           boolean
                  FileNamesOrInstructions sequence of strings
                  DataSetReader        string
                  InitialPlotType      PlotType_e  (defined in TecVals.py)
                  IncludeText          boolean
                  IncludeGeom          boolean
                  IncludeCustomLabels  boolean
                  IncludeData          boolean
                  CollapseZonesAndVars boolean
                  ZonesToRead          sequence of ints
                  VarLoadMode          VarLoadMode_e  (defined in TecVals.py)
                  VarPositionList      sequence of ints
                  VarNameList          sequence of strings
                  ISkip                int
                  JSkip                int
                  KSkip                int
  Output:
    Results[0]    ReturnVal            boolean

Good: Var names currently in Tecplot = "A" "B" "C" VarNameList is appended to read = "A" "B\nR" "C" "D"

Bad: Var names currently in Tecplot = "A" "B" "C" VarNameList is appended to read "A" "C" "B" "D"

In the good example the integrity of the original data is always maintained, that is, the new VarNameList works for the original data as well as the new data. Variable 2 can be either "B" or "R".

In the bad example, the new VarNameList states that variable 2 must contain "C" but "C" has already been assigned to variable 3 with the original data. Keep in mind that once variables are in Tecplot all style assignements are made based on variable position and not by name. Thus the variable positioning is important.

   StringList_pa FileNames, VarNames;
   FileNames = TecUtilStringListAlloc();
   TecUtilStringListAppendString(FileNames, "file1.plt");
   TecUtilStringListAppendString(FileNames, "file2.plt");
   VarNames  = TecUtilStringListAlloc();
   TecUtilStringListAppendString(VarNames,  "X");
   TecUtilStringListAppendString(VarNames,  "Y");
   TecUtilStringListAppendString(VarNames,  "P\nPress");
   IsOk = TecUtilReadDataSet(ReadDataOption_NewData,
                             TRUE,
                             FileNames,
                             "TECPLOT",
                             PlotType_Automatic,
                             TRUE, TRUE, TRUE, TRUE,
                             FALSE,
                             (Set_pa)NULL,
                             VarLoadMode_ByName,
                             (Set_pa)NULL,
                             VarNames,
                             1, 1, 1))
   TecUtilStringListDealloc(&FileNames);
   TecUtilStringListDealloc(&VarNames);

Read a data set consisting of file1.plt and file2.plt. Load the variables named "X", "Y", and either "P" or "Press."

   StringList_pa FileNames, VarNames;
   FileNames = TecUtilStringListAlloc();
   TecUtilStringListAppendString(FileNames, "file1.plt");
   TecUtilStringListAppendString(FileNames, "file2.plt");
   VarNames  = TecUtilStringListAlloc();
   TecUtilStringListAppendString(VarNames,  "X");
   TecUtilStringListAppendString(VarNames,  "Y");
   TecUtilStringListAppendString(VarNames,  "P\nPress");
   IsOk = TecUtilReadDataSet(ReadDataOption_NewData,
                             TRUE,
                             FileNames,
                             "TECPLOT",
                             PlotType_Automatic,
                             TRUE, TRUE, TRUE, TRUE,
                             FALSE,
                             (Set_pa)NULL,
                             VarLoadMode_ByName,
                             (Set_pa)NULL,
                             VarNames,
                             1, 1, 1))
   TecUtilStringListDealloc(&FileNames);
   TecUtilStringListDealloc(&VarNames);

Boolean_t TecUtilSaveLayout	(	const char *	FName,
		Boolean_t	UseRelativePaths
	)

Save the current layout to a file.

You must supply the file name.

Parameters:

	FName	The name of the layout file to save
	UseRelativePaths	Set to TRUE to make all of the files referenced by the layout file use paths relative to the current directory. Set to FALSE to make all of the files referenced by absolute paths

Returns:: TRUE if the current layout was saved, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilSaveLayout(
   &                   FName,
   &                   UseRelativePaths)
    CHARACTER*(*)   FName
    INTEGER*4       UseRelativePaths

Python Syntax:

  Results = TecUtil.SaveLayout(FName, UseRelativePaths)

  Input:
                  FName                string
                  UseRelativePaths     boolean
  Output:
    Results[0]    ReturnVal            boolean

Save a layout file called temp.lay, using absolute paths:

   Boolean_t IsOk = TecUtilSaveLayout("temp.lay", FALSE);

Boolean_t TecUtilSetAddMember	(	Set_pa	Set,
		SetIndex_t	Member,
		Boolean_t	ShowErr
	)

Add the specified member to the specified set.

See the chapter "Using Sets" in the ADK User's Manual for a discussion of sets.

Parameters:

	Set	The set to which to add the specified member.
	Member	The item to add to the specified set. Members start at one.
	ShowErr	TRUE to display an error message if the function's return value is FALSE; FALSE to display no error message

Returns:: TRUE if successful, FALSE if not. A FALSE value is highly unlikely and only occurs if the set cannot be expanded to accomodate the new member.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilSetAddMember(
   &                   SetPtr,
   &                   Member,
   &                   ShowErr)
    POINTER         (SetPtr, Set)
    INTEGER*4       Member
    INTEGER*4       ShowErr

Python Syntax:

    This function is not supported in Python.

Create a set called ZonesToDelete and add zones 2 and 4 to it:

   Set_pa ZonesToDelete = TecUtilSetAlloc(TRUE);
   TecUtilSetAddMember(ZonesToDelete, 2, TRUE);
   TecUtilSetAddMember(ZonesToDelete, 4, TRUE);

Set_pa TecUtilSetAlloc ( Boolean_t ShowErr )

Allocate a new empty set.

See the chapter "Using Sets" in the ADK User's Manual for a discussion of sets.

Parameters:

ShowErr

TRUE to display an error message if the function's return value is FALSE; FALSE to display no error message

Returns:: The new set if successful, NULL if not. An unsuccessful return value indicates that there was not enough memory to create a new set.

Fortran Syntax:

    SUBROUTINE TecUtilSetAlloc(
   &           ShowErr,
   &           ResultPtr)
    INTEGER*4       ShowErr
    POINTER         (ResultPtr, Result)

Python Syntax:

    This function is not supported in Python.

Create two sets, A and B:

   Set_pa A, B;
   A = TecUtilSetAlloc(TRUE);
   B = TecUtilSetAlloc(TRUE);

void TecUtilSetClear ( Set_pa Set )

Empties the specified set.

See the chapter "Using Sets" in the ADK User's Manual for a discussion of sets.

Parameters:

Set

The set to empty

Fortran Syntax:

    SUBROUTINE TecUtilSetClear(SetPtr)
    POINTER (SetPtr, Set)

Python Syntax:

    This function is not supported in Python.

Get the set of active zones, then clear the set so it can be used again:

   Set_pa Zones = NULL;
   TecUtilZoneGetActive(&Zones);
   .
   . // Use the set of active zones 
   .
   TecUtilSetClear(Zones);
   .
   . // Use the set for something else

Boolean_t TecUtilSetCopy	(	Set_pa	DstSet,
		Set_pa	SrcSet,
		Boolean_t	ShowErr
	)

Copy one set to another.

See the chapter "Using Sets" in the ADK User's Manual for a discussion of sets.

Parameters:

	DstSet	The destination set, which must already be allocated with TecUtilSetAlloc().
	SrcSet	The source set
	ShowErr	Set to TRUE to display an error message if an error occurs during the call

Returns:: TRUE if successful, FALSE if not. FALSE indicates that SrcSet contains elements that cannot be added to DstSet.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilSetCopy(
   &                   DstSetPtr,
   &                   SrcSetPtr,
   &                   ShowErr)
    POINTER         (DstSetPtr, DstSet)
    POINTER         (SrcSetPtr, SrcSet)
    INTEGER*4       ShowErr

Python Syntax:

    This function is not supported in Python.

Make a copy of the set of active Line-maps:

   Set_pa MySet, LineMaps = NULL;
   MySet = TecUtilSetAlloc(TRUE);
   TecUtilLineMapGetActive(&LineMaps);
   TecUtilSetCopy(MySet, LineMaps, TRUE);
   .
   .
   .
   TecUtilSetDealloc(&MySet);
   TecUtilSetDealloc(&LineMaps);

void TecUtilSetDealloc ( Set_pa * Set )

Free all memory associated with the specified set and assign the set to be NULL.

See the chapter "Using Sets" in the ADK User's Manual for a discussion of sets.

Parameters:

Set

The set to deallocate.

Fortran Syntax:

    SUBROUTINE TecUtilSetDealloc(SetPtr)
    POINTER (SetPtr, Set)

Python Syntax:

    This function is not supported in Python.

SetIndex_t TecUtilSetGetMember	(	Set_pa	Set,
		SetIndex_t	Position
	)

Get the member of the specified set at the specified position.

See the chapter "Using Sets" in the ADK User's Manual for a discussion of sets.

Parameters:

	Set	The set from which to get the member.
	Position	The position in the set.

Returns:: The member of the specified set at the specified position. Members start at one. If the set does not contain a member at the specified position, the return value is TECUTILSETNOTMEMBER.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilSetGetMember(
   &                   SetPtr,
   &                   Position)
    POINTER         (SetPtr, Set)
    INTEGER*4       Position

Python Syntax:

    This function is not supported in Python.

Get each member from the set MySet:

   Set_pa MySet;
   .
   .
   SetIndex_t Member;
   SetIndex_t Count;
   SetIndex_t Position;

   Count = TecUtilSetGetMemberCount(MySet);
   for (Position = 1; Position <= Count; Position++)
     {
       Member = TecUtilSetGetMember(MySet, Position);
       .
       .
     }

SetIndex_t TecUtilSetGetMemberCount ( Set_pa Set )

Get the count of the number of members in a set.

See the chapter "Using Sets" in the ADK User's Manual for a discussion of sets.

Parameters:

Set

The set for which to get the count

Returns:: The count of the number of members in the set Set.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilSetGetMemberCount(SetPtr)
    POINTER (SetPtr, Set)

Python Syntax:

    This function is not supported in Python.

SetIndex_t TecUtilSetGetNextMember	(	Set_pa	Set,
		SetIndex_t	Member
	)

Get the next member in the specified set which is located after the specified member.

See Chapter 20, "Using Sets," in the ADK User's Manual for a discussion of sets.

Parameters:

	Set	The set from which to get the member
	Member	The member after which to return the next member. Members start at one. Use TECUTILSETNOTMEMBER to get the first member of the set

Returns:: The next member of the specified set after the specified member. Members start at one. If the specified member is not found or if it is the last member in the set, the return value is TECUTILSETNOTMEMBER.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilSetGetNextMember(
   &                   SetPtr,
   &                   Member)
    POINTER         (SetPtr, Set)
    INTEGER*4       Member

Python Syntax:

    This function is not supported in Python.

Loop through all members of the set MySet:

   Set_pa MySet;
   .
   .
   SetIndex_t Member = TecUtilSetGetNextMember(MySet,
                                               TECUTILSETNOTMEMBER);

   while (Member != TECUTILSETNOTMEMBER)
      {
        .
        .
        Member = TecUtilSetGetNextMember(MySet, Member);
      }

SetIndex_t TecUtilSetGetPosition	(	Set_pa	Set,
		SetIndex_t	Member
	)

Get the position in the specified set at which the specified member is located.

See the chapter "Using Sets" in the ADK User's Manual for a discussion of sets.

Parameters:

	Set	The set from which to get the member
	Member	The member after which to get the position. Members start at one.

Returns:: The position in the specified set at which the specified member is located. If the specified member is not found, the return value is TECUTILSETNOTMEMBER.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilSetGetPosition(
   &                   SetPtr,
   &                   Member)
    POINTER         (SetPtr, Set)
    INTEGER*4       Member

Python Syntax:

    This function is not supported in Python.

Get the position of the member MyMember of the set MySet:

   Set_pa MySet;
   SetIndex_t Member;
   .
   .
   SetIndex_t Position =
     TecUtilSetGetPosition(MySet, MyMember);

Boolean_t TecUtilSetIsEmpty ( Set_pa Set )

Determine if the specified set is NULL or contains no members.

See the chapter "Using Sets" in the ADK User's Manual for a discussion of sets.

Parameters:

Set

The set to check for members

Returns:: TRUE if Set is NULL or contains no members, FALSE if not.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilSetIsEmpty(SetPtr)
    POINTER (SetPtr, Set)

Python Syntax:

    This function is not supported in Python.

Determine if the set MySet is empty or contains no members:

   Set_pa MySet;
   
   if (TecUtilSetIsEmpty(MySet))
     {
       .... take action based on the set being empty.
     }

Boolean_t TecUtilSetIsEqual	(	Set_pa	Set1,
		Set_pa	Set2
	)

Determines if the specified sets are equal (have the same members).

See the chapter "Using Sets" in the ADK User's Manual for a discussion of sets.

Parameters:

	Set1	The set to compare with Set2.
	Set2	The set to compare with Set1

Returns:: TRUE if the specified sets are equal, FALSE if they are not.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilSetIsEqual(
   &                   Set1Ptr,
   &                   Set2Ptr)
    POINTER         (Set1Ptr, Set1)
    POINTER         (Set2Ptr, Set2)

Python Syntax:

    This function is not supported in Python.

Determine if all enabled zones are active:

   Boolean_t AllEnabledZonesAreActive;
   Set_pa ActiveZones  = NULL;
   Set_pa EnabledZones = NULL;

   TecUtilZoneGetActive(&ActiveZones);
   TecUtilZoneGetEnabled(&EnabledZones);
   AllEnabledZonesAreActive = TecUtilSetIsEqual(ActiveZones, EnabledZones);

Boolean_t TecUtilSetIsMember	(	Set_pa	Set,
		SetIndex_t	Member
	)

Determine if the specified member is in the specified set.

See the chapter "Using Sets" in the ADK User's Manual for a discussion of sets.

Parameters:

	Set	The set to check for the specified member.
	Member	The item for which to check the specified set. Members start at one

Returns:: TRUE if Member is a member of Set, FALSE if not.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilSetIsMember(
   &                   SetPtr,
   &                   Member)
    POINTER         (SetPtr, Set)
    INTEGER*4       Member

Python Syntax:

    This function is not supported in Python.

Determine if the set MySet contains the member MyMember, and if so, remove MyMember from MySet:

   Set_pa MySet;
   SetIndex_t MyMember;
   .
   .
   if (TecUtilSetIsMember(MySet, MyMember))
     TecUtilSetRemoveMember(MySet, MyMember);

void TecUtilSetRemoveMember	(	Set_pa	Set,
		SetIndex_t	Member
	)

Remove a member from a set.

See the chapter "Using Sets" in the ADK User's Manual for a discussion of sets.

Parameters:

	Set	The set from which to remove the specified member.
	Member	The member to remove from the specified set. Members start at one

Fortran Syntax:

    SUBROUTINE TecUtilSetRemoveMember(
   &           SetPtr,
   &           Member)
    POINTER         (SetPtr, Set)
    INTEGER*4       Member

Python Syntax:

    This function is not supported in Python.

Boolean_t TecUtilSmooth	(	EntIndex_t	Zone,
		EntIndex_t	SmoothVar,
		LgIndex_t	NumSmoothPasses,
		double	SmoothWeight,
		BoundaryCondition_e	SmoothBndryCond
	)

Smooth data (that is, reduce the spikes) for selected variables in selected zones.

Parameters:

	Zone	The number of the zone to smooth. The zone must be an ordered zone (not a finite-element zone)
	SmoothVar	The number of the variable to smooth. This cannot be a variable which is assigned to an axis
	NumSmoothPasses	The number of smoothing passes to perform. The normal default value is on
	SmoothWeight	The relaxation factor for each pass of smoothing. Must be a number between zero and one (exclusively). Higher numbers indicate a greater smoothing effect. The normal default value is 0.8
	SmoothBndryCond	The boundary condition by which to smooth.

Returns:: TRUE if the input parameters are valid and the current frame mode is XY, 2D, or 3D. Otherwise, FALSE.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilSmooth(
   &                   Zone,
   &                   SmoothVar,
   &                   NumSmoothPasses,
   &                   SmoothWeight,
   &                   SmoothBndryCond)
    INTEGER*4       Zone
    INTEGER*4       SmoothVar
    INTEGER*4       NumSmoothPasses
    REAL*8          SmoothWeight
    INTEGER*4       SmoothBndryCond

Python Syntax:

  Results = TecUtil.Smooth(Zone, SmoothVar, NumSmoothPasses, SmoothWeight, SmoothBndryCond)

  Input:
                  Zone                 int
                  SmoothVar            int
                  NumSmoothPasses      int
                  SmoothWeight         double
                  SmoothBndryCond      BoundaryCondition_e  (defined in TecVals.py)
  Output:
    Results[0]    ReturnVal            boolean

Perform one smoothing pass on variable 3 in zone 2:

   TecUtilSmooth(2, 3, 1, 0.8, BoundaryCondition_Fixed);

StringList_pa TecUtilStringListAlloc ( void )

Create an empty string list.

See the Chapter "Using String Lists," in the ADK User's Manual for a discussion of string lists. Use TecUtilStringListDealloc() to deallocate the string list when it is no longer needed.

Returns:: Handle to an empty string list. A handle of NULL is returned if sufficient memory is not available.

Fortran Syntax:

    SUBROUTINE TecUtilStringListAlloc(ResultPtr)
    POINTER (ResultPtr, Result)

Python Syntax:

    This function is not supported in Python.

Allocate and deallocate a string list.

   StringList_pa Names = NULL;
   
   Names = TecUtilStringListAlloc();
   if (Names != NULL)
     {
       // do something with the name list, append, clear, etc 
         .
         .
         .
   
       // get rid of the name list 
       TecUtilStringListDealloc(&Names);
     }

Boolean_t TecUtilStringListAppend	(	StringList_pa	Target,
		StringList_pa	Source
	)

Append a copy of the contents of the source string list to the target string list.

See the Chapter "Using String Lists," in the ADK User's Manual for a discussion of string lists.

Parameters:

	Target	String list to which the Source string list is appended. Use TecUtilStringListAlloc() to allocate a string list
	Source	String list to append to the Target. Use TecUtilStringListAlloc() to allocate a string list.

Returns:: A return value of TRUE indicates the operation was successful. A return value of FALSE indicates that sufficient memory was not available for the request.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilStringListAppend(
   &                   TargetPtr,
   &                   SourcePtr)
    POINTER         (TargetPtr, Target)
    POINTER         (SourcePtr, Source)

Python Syntax:

    This function is not supported in Python.

Append one string list to another.

   Boolean_t     IsOk = FALSE;
   StringList_pa Names = NULL;
   StringList_pa DefaultNames = NULL;
   
   // call some function to get a names list from the user 
   Names = MyFuncForGettingNamesFromUser();
   
   // call some function to get some default name list 
   DefaultNames = MyFuncForGettingDefaultNames();
   
   // combine the two name lists into one 
   if (Names != NULL && DefaultNames != NULL)
     {
       IsOk = TecUtilStringListAppend(Names, DefaultNames);
       if (IsOk)
         {
           // do more processing 
             .
             .
             .
   
           // get rid of the name lists 
           TecUtilStringListDealloc(&Names);
           TecUtilStringListDealloc(&DefaultNames);
         }
     }

Boolean_t TecUtilStringListAppendString	(	StringList_pa	StringList,
		const char *	String
	)

Append a copy of the string to the string list.

The string list expands to accommodate the additional item. See the Chapter "Using String Lists," in the ADK User's Manual for a discussion of string lists.

Parameters:

	StringList	Handle to a valid string list. Use TecUtilStringListAlloc() to allocate a string list.
	String	A copy of String is appended to the string list. String may be NULL

Returns:: A return value of TRUE indicates the operation was successful. A return value of FALSE indicates that sufficient memory was not available for the additional item.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilStringListAppendString(
   &                   StringListPtr,
   &                   String)
    POINTER         (StringListPtr, StringList)
    CHARACTER*(*)   String

Python Syntax:

    This function is not supported in Python.

Append two variable names to a string list

   Boolean_t     IsOk = FALSE;
   StringList_pa Names = NULL;
   
   Names = TecUtilStringListAlloc();
   if (Names != NULL)
     {
       IsOk = TecUtilStringListAppendString(Names, "X");
       IsOk = TecUtilStringListAppendString(Names, "Y");
       if (IsOk)
         {
           // do some processing with the name list 
             .
             .
             .
         }
   
       // get rid of the name list 
       TecUtilStringListDealloc(&Names);
     }

void TecUtilStringListClear ( StringList_pa StringList )

Remove all members of the string list.

See the Chapter "Using String Lists," in the ADK User's Manual for a discussion of string lists.

Parameters:

StringList

Handle to a valid string list. Use TecUtilStringListAlloc() to allocate a string list

Fortran Syntax:

    SUBROUTINE TecUtilStringListClear(StringListPtr)
    POINTER (StringListPtr, StringList)

Python Syntax:

    This function is not supported in Python.

Clear a string list so that it no longer maintains any strings items.

   Boolean_t     ClearNames = FALSE;
   StringList_pa Names = NULL;
   
   // do some processing to get names 
     .
     .
     .
   
   if (ClearNames)
     {
       TecUtilStringListClear(Names);
       TecUtilDialogMessageBox("All names cleared.",
                               MessageBox_Information);
     }

StringList_pa TecUtilStringListCopy ( StringList_pa StringList )

Return a handle to a duplicate of the specified string list and its contents.

See the Chapter "Using String Lists," in the ADK User's Manual for a discussion of string lists.

Note:: The caller is responsible for deallocating the string list when it is no longer needed.

Parameters:

StringList

Handle to a valid string list. Use TecUtilStringListAlloc() to create a string list.

Returns:: A handle to a duplicate string list is returned if the operation was successful. A handle of NULL is returned if sufficient memory is not available.

Fortran Syntax:

    SUBROUTINE TecUtilStringListCopy(
   &           StringListPtr,
   &           ResultPtr)
    POINTER         (StringListPtr, StringList)
    POINTER         (ResultPtr, Result)

Python Syntax:

    This function is not supported in Python.

Make a copy of a string list.

   StringList_pa Names = NULL;
   StringList_pa CopyOfNames = NULL;
   
   // do some processing to get names 
     .
     .
     .
   
   CopyOfNames = TecUtilStringListCopy(Names);
   if (CopyOfNames != NULL)
     {
       // do some processing on the name list copy 
         .
         .
         .
   
       // get rid of the name list copy 
       TecUtilStringListDealloc(&CopyOfNames);
     }

void TecUtilStringListDealloc ( StringList_pa * StringList )

Deallocate the string list members and handle, and set the handle to NULL.

See the Chapter "Using String Lists," in the ADK User's Manual for a discussion of string lists.

Parameters:

StringList

Reference to a valid string list handle. Use TecUtilStringListAlloc() to create a string list

Fortran Syntax:

    SUBROUTINE TecUtilStringListDealloc(StringListPtr)
    POINTER (StringListPtr, StringList)

Python Syntax:

    This function is not supported in Python.

Create and then deallocate a string list:

   StringList_pa MyStrList = TecUtilStringListAlloc();
   .
   .
   .
   TecUtilStringListDealloc(&MyStrList);

StringList_pa TecUtilStringListFromNLString ( const char * String )

Create a string list from a newline delimited string.

A newline delimited string is a character string with newlines (\n) used to separate one substring from the next. See the Chapter "Using String Lists," in the ADK User's Manual for a discussion of string lists.

Note:: The caller is responsible for deallocating the string list when it is no longer needed.

Parameters:

String

The newline delimited string

Returns:: Handle to the created string list. A handle of NULL is returned if sufficient memory is not available.

Fortran Syntax:

    SUBROUTINE TecUtilStringListFromNLString(
   &           String,
   &           ResultPtr)
    CHARACTER*(*)   String
    POINTER         (ResultPtr, Result)

Python Syntax:

    This function is not supported in Python.

Given the string, Hello\n\nWorld, the function will return a string list containing 3 members: "Hello, "" (that is, an empty string), and "World."

   StringList_pa List = NULL;
   
   List = TecUtilStringListFromNLString("Hello\\n\\nWorld");
   if (List != NULL)
     {
       LgIndex_t I = 0;
       LgIndex_t Count = 0;
   
       // print each element of the string list 
       for (I = 0, Count = TecUtilStringListGetCount(List);
             I < Count;
             I++)
         {
           String = TecUtilStringListGetString(List, I+1);
           if (String != NULL)
             {
               printf("Item #%d: %s\n", I+1, String);
               TecUtilStringDealloc(&String);
             }
         }
   
       // get rid of the list 
       TecUtilStringListDealloc(&List);
     }

LgIndex_t TecUtilStringListGetCount ( StringList_pa StringList )

Count the number of strings currently maintained by the string list.

See the Chapter "Using String Lists," in the ADK User's Manual for a discussion of string lists.

Parameters:

StringList

Handle to a valid string list. Use TecUtilStringListAlloc() to create a string list.

Returns:: The number of strings maintained by the string list.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilStringListGetCount(StringListPtr)
    POINTER (StringListPtr, StringList)

Python Syntax:

    This function is not supported in Python.

Get each instruction used to load the current frame's data set:

   StringList_pa LoaderInstructs;
   char *LoaderName = NULL;
   if (TecUtilImportGetLoaderInstr(&LoaderName,&LoaderInstructs))
     {
      LgIndex_t ii, Count =
        TecUtilStringListGetCount(LoaderInstructs);
      for (ii = 1; ii <= Count; ii++)
       {
        char *Instruct =
          TecUtilStringListGetString(LoaderInstructs, ii);
        // Do some processing 
        .
        .
        .
        TecUtilStringDealloc(&Instruct);
       }
     }

const char* TecUtilStringListGetRawStringPtr	(	StringList_pa	StringList,
		LgIndex_t	StringNumber
	)

Return a reference to the nth string in a string list.

See the Chapter "Using String Lists", in the ADK User's Manual for a discussion of string lists.

Parameters:

	StringList	Handle to a valid string list. Use TecUtilStringListAlloc() to allocate a string list
	StringNumber	Position of string to be copied into the string list. StringNumber must be greater than or equal to one, and less than or equal to the number of items maintained by the string list. Use TecUtilStringListGetCount() to get the number of items.

Returns:: Returns a REFERENCE to the string. DO OT DEALLOCATE THIS REFERENCE.

Python Syntax:

    This function is not supported in Python.

Operate on the set of files retrieved using TecUtilDialogGetFileNames().

   StringList_pa FileNames = NULL;
   
   if (TecUtilDialogGetFileNames(SelectFileOption_ReadMultiFile,
                                 &FileNames,
                                 "any file",
                                 (StringList_pa)NULL,
                                 "*"))
     {
       LgIndex_t N,NumFiles;
   
       NumFiles = TecUtilStringListGetCount(FileNames);
       for (N = 1; N < Numfiles; N++)
         {
           const char *RawFNamePtr = TecUtilStringListGetRawStringPtr(FileNames,N);
   
           //
           // Do something with RawFNamePtr.  DO NOT DEALLOCATE RawFNamePtr.
           //
         }
   
       //
       // We do however dealloc the stringlist itself.
       //
   
       TecUtilStringListDealloc(&FileNames);
     }

char* TecUtilStringListGetString	(	StringList_pa	StringList,
		LgIndex_t	StringNumber
	)

Return a copy of the nth string from a string list.

See the Chapter "Using String Lists," in the ADK User's Manual for a discussion of string lists.

Note:: The caller is responsible for de-allocating the copy of the string when it is no longer needed.

Parameters:

	StringList	Handle to a valid string list. Use TecUtilStringListAlloc() to allocate a string list
	StringNumber	Position of string to be copied into the string list. StringNumber must be greater than or equal to one, and less than or equal to the number of items maintained by the string list. Use TecUtilStringListGetCount() to get the number of items

Returns:: Copy of the nth string.

Fortran Syntax:

    SUBROUTINE TecUtilStringListGetString(
   &           StringListPtr,
   &           StringNumber,
   &           Result,
   &           ResultLength)
    POINTER         (StringListPtr, StringList)
    INTEGER*4       StringNumber
    CHARACTER*(*)   Result
    INTEGER*4       ResultLength

Python Syntax:

    This function is not supported in Python.

Boolean_t TecUtilStringListInsertString	(	StringList_pa	StringList,
		LgIndex_t	StringNumber,
		const char *	String
	)

Insert a copy of the string into the nth position of the string list.

The string list expands and the items are shifted to accommodate the additional item. See the Chapter "Using String Lists," in the ADK User's Manual for a discussion of string lists.

Parameters:

	StringList	Handle to a valid string list. Use TecUtilStringListAlloc() to allocate a string list
	StringNumber	Position where string is inserted in the string list. This value must be greater than or equal to one, and less than or equal to the number of items maintained by the string list. Use TecUtilStringListGetCount() to get the number of items
	String	A copy of String is inserted into the string list. String may be NULL

Returns:: A return value of TRUE indicates the operation was successful. FALSE indicates that the memory available was not sufficient for the additional item.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilStringListInsertString(
   &                   StringListPtr,
   &                   StringNumber,
   &                   String)
    POINTER         (StringListPtr, StringList)
    INTEGER*4       StringNumber
    CHARACTER*(*)   String

Python Syntax:

    This function is not supported in Python.

Insert a string at the beginning and end of an existing list.

   Boolean_t     IsOk = FALSE;
   StringList_pa Names = NULL;
   LgIndex_t     Count = 0;
   
   // do some processing to get names 
     .
     .
     .
   
   // insert a name at the beginning and end of the list 
   IsOk = TecUtilStringListInsertString(Names, 1,
                                        "Very First Name");
   Count = TecUtilStringListGetCount(Names);
   IsOk = TecUtilStringListInsertString(Names, Count+1,
                                        "Very Last Name");

void TecUtilStringListRemoveString	(	StringList_pa	StringList,
		LgIndex_t	StringNumber
	)

Remove the nth string from the string list.

The members following the removed item are shifted to fill the vacated space. See the Chapter "Using String Lists," in the ADK User's Manual for a discussion of string lists.

Parameters:

	StringList	Handle to a valid string list. Use TecUtilStringListAlloc() to allocate a string list.
	StringNumber	Number of the string to remove. Must be greater than or equal to one, and less than or equal to the number of items maintained by the string list. Use TecUtilStringListGetCount() to get the number of items

Fortran Syntax:

    SUBROUTINE TecUtilStringListRemoveString(
   &           StringListPtr,
   &           StringNumber)
    POINTER         (StringListPtr, StringList)
    INTEGER*4       StringNumber

Python Syntax:

    This function is not supported in Python.

Remove the first name from a name list.

   StringList_pa Names = NULL;
   
   // do some processing to get names 
     .
     .
     .
   
   TecUtilStringListRemoveString(Names, 1);

void TecUtilStringListRemoveStrings	(	StringList_pa	StringList,
		LgIndex_t	StringNumber,
		LgIndex_t	Count
	)

Remove the specified number of strings beginning at the nth string.

The members following the items removed are shifted to fill the vacated space. See the Chapter "Using String Lists," in the ADK User's Manual for a discussion of string lists.

Parameters:

	StringList	Handle to a valid string list. Use TecUtilStringListAlloc() to allocate a string list
	StringNumber	Start position in the string list. Value must be greater than or equal to one, and less than or equal to the number of items maintained by the string list. Use TecUtilStringListGetCount() to get the number of strings in the string list
	Count	Number of items to remove from the string list. Value must be greater than or equal to one, and less than or equal to the number of items remaining, including the string at the start position. Use TecUtilStringListGetCount() to get the number of strings in the string list

Fortran Syntax:

    SUBROUTINE TecUtilStringListRemoveStrings(
   &           StringListPtr,
   &           StringNumber,
   &           Count)
    POINTER         (StringListPtr, StringList)
    INTEGER*4       StringNumber
    INTEGER*4       Count

Python Syntax:

    This function is not supported in Python.

Remove all but the first and last item from a name list.

   LgIndex_t     Count = 0;
   StringList_pa Names = NULL;
   
   // do some processing to get names 
     .
     .
     .
   
   Count = TecUtilStringListGetCount(Names);
   TecUtilStringListRemoveStrings(Names, 2, Count-2);

Boolean_t TecUtilStringListSetString	(	StringList_pa	StringList,
		LgIndex_t	StringNumber,
		const char *	String
	)

Place a copy of the specified string at the nth position in the string list.

If the position is beyond the end of the string list, the string list is resized, so that the string references between the last item of the string list in its original state and the last item of the string list in its new state are assigned NULL. If the position is within the boundaries of the original string list, the string at the specified position is replaced by the new value. See the Chapter "Using String Lists," in the ADK User's Manual for a discussion of string lists.

Parameters:

	StringList	Handle to a valid string list. Use TecUtilStringListAlloc() to allocate a string list
	StringNumber	Item position in the string list. Value must be greater than or equal to one
	String	A copy of String is appended to the string list. String may be NULL

Returns:: A return value of TRUE indicates the operation was successful. FALSE indicates that sufficient memory was not available for the additional item at the specified position.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilStringListSetString(
   &                   StringListPtr,
   &                   StringNumber,
   &                   String)
    POINTER         (StringListPtr, StringList)
    INTEGER*4       StringNumber
    CHARACTER*(*)   String

Python Syntax:

    This function is not supported in Python.

Replace the first item of a name list with a new value and put a new item ten positions past the current last item.

   LgIndex_t     Count = 0;
   StringList_pa Names = NULL;
   
   // do some processing to get names 
     .
     .
     .
   
   IsOk = TecUtilStringListSetString(Names, 1,
                                     "New First Name");
   Count = TecUtilStringListGetCount(Names);
   IsOk = TecUtilStringListSetString(Names, Count+10,
                                     "New Last Name");

void TecUtilStringListSort	(	StringList_pa	StringList,
		StringListStringComparator_pf	Comparator,
		ArbParam_t	ClientData
	)

Sorts the string list by repeatedly calling the 'Comparator' function until the list is in order.

Since:: 10.0-3-129

Parameters:

	StringList	String list to sort.
	Comparator	Function called to compare two string list strings or NULL for the default sort. The default sorting handles NULL elements and uses the system's strcmp utility for comparing valid strings elements.
	ClientData	Contextual information that is passed along to the comparator function. Client data isn't used by the default comparator and can be passed any value. For specialized comparator functions the client data is used to hold contextual information so that global variable do not have to be used.

Fortran Syntax:

    SUBROUTINE TecUtilStringListSort(
   &           StringListPtr,
   &           ComparatorPtr,
   &           ClientDataPtr)
    POINTER         (StringListPtr, StringList)
    POINTER         (ComparatorPtr, Comparator)
    POINTER         (ClientDataPtr, ClientData)

Python Syntax:

    This function is not supported in Python.

Sort the variable string list using Tecplot's default comparator:

   TecUtilStringListSort(MyVarList, NULL, 0);

Sort the variable string list using own own comparator function. We pass some client data to our own comparator function simply to show how to use it. In this case all the client data is used for is to keep track of the number of times our comparator function was called... not very useful.

   static int MyStrComparator(const char *String1,
                              const char *String2,
                              ArbParam_t  ClientData)
   {
     int Result = 0;
     LgIndex_t *NumTimesCalled;

     REQUIRE(VALID_REF(String1) || String1 == NULL);
     REQUIRE(VALID_REF(String2) || String2 == NULL);

     NumTimesCalled = (LgIndex_t *)ClientData;
     (*NumTimesCalled) += 1;

     if (String1 != NULL && String2 != NULL)
       Result = strcmp(String1, String2);
     else if (String1 == NULL && String2 == NULL)
       Result = 0;
     else if (String1 == NULL)
       Result = -1;
     else if (String2 == NULL)
       Result = 1;
     else
       CHECK(FALSE);

     return Result;
   }

 ...

   // After calling TecUtilStringListSort NumTimesCalled will contain the
   // number of times that our comparator was called.
   LgIndex_t NumTimesCalled = 0;
   TecUtilStringListSort(MyVarList, MyStrComparator, &NumTimesCalled);

char* TecUtilStringListToNLString ( StringList_pa StringList )

Return a newline delimited string representation of the string list.

A newline delimited string is a character string with newlines (\n) used to separate one substring from the next. See the chapter on "Using String Lists" in the ADK User's Manual for a discussion of string lists.

Note:: The caller is responsible for de-allocating the copy of the newline delimited string when it is no longer needed.

Parameters:

StringList

Handle to a valid string list. Use TecUtilStringListAlloc() to allocate a string list.

Returns:: A newline, (\n), delimited string representation of the string list.

Fortran Syntax:

    SUBROUTINE TecUtilStringListToNLString(
   &           StringListPtr,
   &           Result,
   &           ResultLength)
    POINTER         (StringListPtr, StringList)
    CHARACTER*(*)   Result
    INTEGER*4       ResultLength

Python Syntax:

    This function is not supported in Python.

Given a string list containing 3 members: "Hello", "", and "World", the function will return the following string: "Hello\\n\\nWorld".

   StringList_pa List = NULL;
   
   List = TecUtilStringListAlloc();
   if (List != NULL)
     {
       // add items to the string list 
       TecUtilStringListAppendString(List, "Hello");
       TecUtilStringListAppendString(List, "");
       TecUtilStringListAppendString(List, "World");
   
       //print the newline separated string representation 
       String = TecUtilStringListToNLString(List);
       if (String != NULL)
         {
           printf("%s\n", String);
           TecUtilStringDealloc(&String);
         }
   
       // get rid of the list 
       TecUtilStringListDealloc(&List);
     }

Boolean_t TecUtiltDataSetDefVarLoadFinish ( Boolean_t IsDataSetOk )

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

LgIndex_t TecUtilTecAux	(	char *	Name,
		char *	Value
	)

Writes the name/value data set auxiliary data pair to the data file.

Parameters:

	Name	Name of the data set auxiliary item
	Value	The value associates with the named data set auxiliary data item

Returns:: 0 if successful, -1 if unsuccessful.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilTecAux(
   &                   Name,
   &                   Value)
    CHARACTER*(*)   Name
    CHARACTER*(*)   Value

Python Syntax:

  Results = TecUtil.TecAux(Name, Value)

  Input:
                  Name                 string
                  Value                string
  Output:
    Results[0]    ReturnVal            int

LgIndex_t TecUtilTecDat	(	LgIndex_t *	N,
		void *	FieldData_Array,
		LgIndex_t *	IsDouble
	)

Writes an array of data to the data file.

If the ZoneFormat specified in TecUtilTecZneX() or TecUtilTecZne() is BLOCK, the array must be dimensioned (IMax, JMax, KMax, NumVars) (FORTRAN syntax, where the first element moves the fastest).

If the ZoneFormat is POINT, the data must be dimensioned (NumVars, IMax, JMax, KMax).

If the ZoneFormat is FEBLOCK, then the data must be dimensioned (NumPts, NumVars).

If the ZoneFormat is FEPOINT, then the data must be dimensioned (NumVars,NumPts).

TecUtilTecDat() allows you to write your data in a piecemeal fashion in case it is not contained in one contiguous block in your program. Enough calls to TECDAT must be made that the correct number of values are written for each zone and that the aggregate order for the data is correct.

In the above summary, NumVars is based on the number of variable names supplied in a previous call to TecUtilTecIni() or TecUtilTecIniX().

Parameters:

	N	Handle to an integer value specifying number of values to write
	FieldData_Array	Array of single or double precision data values
	IsDouble	Handle to the integer flag stating whether the array Data is single (0) or double (1) precision.

Returns:: 0 if successful, -1 if unsuccessful.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilTecDat(
   &                   N,
   &                   FieldData_Array,
   &                   IsDouble)
    INTEGER*4       N
    POINTER         (FieldData_ArrayPtr, FieldData_Array)
    INTEGER*4       IsDouble

Python Syntax:

    This function is not supported in Python.

LgIndex_t TecUtilTecEnd ( void )

Must be called to close out the current data file.

There must be a corresponding TecUtilTecEnd() for each TecUtilTecIni() or TecUtilTecIniX().

Returns:: 0 if successful, -1 if unsuccessful.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilTecEnd()

Python Syntax:

  Results = TecUtil.TecEnd()

  Output:
    Results[0]    ReturnVal            int

LgIndex_t TecUtilTecFace ( LgIndex_t * FaceConnections )

Writes the face neighbor connections to the data file.

For polygonal and polyhedral zones, use TecUtilTecPoly().

Parameters:

FaceConnections

Array of face connections dimensioned by the number of face neighbor connections (supplied in the call to TecUtilTecZneX()) multiplied by the number of values needed for each connection. See the ADK reference manual for details.

Returns:: 0 if successful, -1 if unsuccessful.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilTecFace(FaceConnections)
    INTEGER*4 FaceConnections

Python Syntax:

  Results = TecUtil.TecFace(FaceConnections)

  Input:
                  FaceConnections      list of ints
  Output:
    Results[0]    ReturnVal            int

LgIndex_t TecUtilTecFil ( LgIndex_t * F )

Switch output context to a different file.

Each time TecUtilTecIni() or TecUtilTecIniX() iscalled, a new file "context" is switched to. This allows you to write multiple data files at the same time.

Parameters:

F

Handle to integer specifying file number to switch to

Returns:: 0 if successful, -1 if unsuccessful.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilTecFil(F)
    INTEGER*4 F

Python Syntax:

  Results = TecUtil.TecFil(F)

  Input:
                  F                    list of ints
  Output:
    Results[0]    ReturnVal            int

void TecUtilTecForeign ( LgIndex_t * OutputForeignByteOrder )

Sets the byte ordering request for subsequent calls to TecUtilTecIni().

The byte ordering request will remain in effect until changed by another call to this function. Calling this function after a call to TecUtilTecIni() has no effect on any files opened by previous calls to TecUtilTecIni() and only effects future files created by TecUtilTecIni().

Since:: 10.0-3-129

Parameters:

OutputForeignByteOrder

Reference to a boolean value indicating if subsequent calls to TecUtilTecIni() should create files with foreign or native byte ordering.

Fortran Syntax:

    SUBROUTINE TecUtilTecForeign(
   &                   OutputForeignByteOrder)
    INTEGER*4       OutputForeignByteOrder

Python Syntax:

  Results = TecUtil.TecForeign(OutputForeignByteOrder)

  Input:
                  OutputForeignByteOrder list of ints
  Output:
    Results[0]    ReturnVal            NONE

LgIndex_t TecUtilTecGeo	(	double *	XPos,
		double *	YPos,
		double *	ZPos,
		LgIndex_t *	PosCoordMode,
		LgIndex_t *	AttachToZone,
		LgIndex_t *	Zone,
		LgIndex_t *	Color,
		LgIndex_t *	FillColor,
		LgIndex_t *	IsFilled,
		LgIndex_t *	GeomType,
		LgIndex_t *	LinePattern,
		double *	PatternLength,
		double *	LineThickness,
		LgIndex_t *	NumEllipsePts,
		LgIndex_t *	ArrowheadStyle,
		LgIndex_t *	ArrowheadAttachment,
		double *	ArrowheadSize,
		double *	ArrowheadAngle,
		LgIndex_t *	Scope,
		LgIndex_t *	NumSegments,
		LgIndex_t *	NumSegPts,
		float *	XGeomData,
		float *	YGeomData,
		float *	ZGeomData,
		const char *	MacroFunctionCommand
	)

Write a geometry to a binary tecplot datafile.

This function mimicks the TecGeo function that is part of the TecIO library.

Parameters:

	MacroFunctionCommand	Macro command to execute when user cntrl-clicks on the geometry. Set to NULL to not use
	XPos	X-Anchor position of the geometry
	YPos	Y-Anchor position of the geometry
	ZPos	Z-Anchor position of the geometry
	PosCoordMode	Position coordinate mode of the geometry. Zero=Grid, 1=Frame, 6=Grid3D
	AttachToZone	Flag specifying whether or not to attach the geometry to a zone. Zero=Attach, one=Don't attach
	Zone	Zone to attach to
	Color	Color of the geometry. (0-63)
	FillColor	Fill Color of the geometry. (0-63)
	IsFilled	Flag specifying whether or not to fill the geometry. 1=Fill Zero=Don't fill
	GeomType	Type of geometry. Zero=2D line segments, 1=Rectangle, 2=Square, 3=Circle, 4=Ellipse, 5=3D line segments
	LinePattern	Line pattern. Zero=Solid, 1=Dashed, 2=DashDot, 3=Dotted, 4=LongDash, 5=DashDotDot
	PatternLength	Line Pattern Length in frame units (0 < L <= 100.0).
	LineThickness	Line thickness in frame units (0 < L <= 100.0)
	NumEllipsePts	Number of points to use to draw ellipses or circles
	ArrowheadStyle	Style of arrowhead. Zero=Plain, 1=Filled, 2=Hollow
	ArrowheadAttachment	How to attach the arrowhead(s). Zero=None, 1=Beginning, 2=End, 3=Both.
	ArrowheadSize	Size of the arrowhead in frame units
	ArrowheadAngle	Angle of the arrowhead in degrees
	Scope	Scope for the geometry. Zero=Global, 1=Local
	NumSegments	Number of polyline segments in the geometry
	NumSegPts	Array of the number of points in each polyline segment
	XGeomData	Array of X-values for the geometry
	YGeomData	Array of Y-values for the geometry
	ZGeomData	Array of Z-values for the geometry

Returns:: Returns 0 if successful, -1 if not.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilTecGeo(
   &                   XPos,
   &                   YPos,
   &                   ZPos,
   &                   PosCoordMode,
   &                   AttachToZone,
   &                   Zone,
   &                   Color,
   &                   FillColor,
   &                   IsFilled,
   &                   GeomType,
   &                   LinePattern,
   &                   PatternLength,
   &                   LineThickness,
   &                   NumEllipsePts,
   &                   ArrowheadStyle,
   &                   ArrowheadAttachment,
   &                   ArrowheadSize,
   &                   ArrowheadAngle,
   &                   Scope,
   &                   NumSegments,
   &                   NumSegPts,
   &                   XGeomData,
   &                   YGeomData,
   &                   ZGeomData,
   &                   MacroFunctionCommand)
    REAL*8          XPos
    REAL*8          YPos
    REAL*8          ZPos
    INTEGER*4       PosCoordMode
    INTEGER*4       AttachToZone
    INTEGER*4       Zone
    INTEGER*4       Color
    INTEGER*4       FillColor
    INTEGER*4       IsFilled
    INTEGER*4       GeomType
    INTEGER*4       LinePattern
    REAL*8          PatternLength
    REAL*8          LineThickness
    INTEGER*4       NumEllipsePts
    INTEGER*4       ArrowheadStyle
    INTEGER*4       ArrowheadAttachment
    REAL*8          ArrowheadSize
    REAL*8          ArrowheadAngle
    INTEGER*4       Scope
    INTEGER*4       NumSegments
    INTEGER*4       NumSegPts
    REAL*4          XGeomData
    REAL*4          YGeomData
    REAL*4          ZGeomData
    CHARACTER*(*)   MacroFunctionCommand

Python Syntax:

  Results = TecUtil.TecGeo(XPos, YPos, ZPos, PosCoordMode, AttachToZone, Zone, Color, FillColor, IsFilled, GeomType, LinePattern, PatternLength, LineThickness, NumEllipsePts, ArrowheadStyle, ArrowheadAttachment, ArrowheadSize, ArrowheadAngle, Scope, NumSegments, NumSegPts, XGeomData, YGeomData, ZGeomData, MacroFunctionCommand)

  Input:
                  XPos                 list of doubles
                  YPos                 list of doubles
                  ZPos                 list of doubles
                  PosCoordMode         list of ints
                  AttachToZone         list of ints
                  Zone                 list of ints
                  Color                list of ints
                  FillColor            list of ints
                  IsFilled             list of ints
                  GeomType             list of ints
                  LinePattern          list of ints
                  PatternLength        list of doubles
                  LineThickness        list of doubles
                  NumEllipsePts        list of ints
                  ArrowheadStyle       list of ints
                  ArrowheadAttachment  list of ints
                  ArrowheadSize        list of doubles
                  ArrowheadAngle       list of doubles
                  Scope                list of ints
                  NumSegments          list of ints
                  NumSegPts            list of ints
                  XGeomData            list of doubles
                  YGeomData            list of doubles
                  ZGeomData            list of doubles
                  MacroFunctionCommand string
  Output:
    Results[0]    ReturnVal            int

LgIndex_t TecUtilTecGeoX ( ArgList_pa ArgList )

Writes the geometry item to the data file.

Parameters:

ArgList

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

Arglist Values

SV_GEOMTYPE

Type:	GeomType_e
Arg Function:	TecUtilArgListAppendInt()
Required:	Yes
Notes:	Geometry type may have any of the following values: GeomType_LineSegs, GeomType_Rectangle, GeomType_Square, GeomType_Circle, GeomType_Ellipse, GeomType_LineSegs3D,

SV_NUMGEOSEGMENTS

Type:	LgIndex_t
Arg Function:	TecUtilArgListAppendInt()
Required:	Yes
Notes:	Only applies to a geometry of type GeomType_LineSegs and is the number of geometry line segments. The value must be greater than or equal to 1

SV_NUMSEGPTS

Type:	LgIndex_t *
Arg Function:	TecUtilArgListAppendArray()
Required:	Yes
Notes:	Only applies to a geometry of type GeomType_LineSegs and is an array dimensioned by the number of geometry segments where each member of the array holds the number of points defining each geometry segment

SV_ARROWHEADSTYLE

Type:	ArrowheadStyle_e
Arg Function:	TecUtilArgListAppendInt()
Default:	Arrowhead_Plain
Required:	No
Notes:	Only applies to a geometry of type GeomType_LineSegs and is the arrowhead style may have any of the following values: Arrowhead_Plain, Arrowhead_Filled, Arrowhead_Hollow.

SV_ARROHEADATTACHMENT

Type:	ArroheadAttachment_e
Arg Function:	TecUtilArgListAppendInt()
Default:	ArrowheadAttach_None
Required:	No
Notes:	Only applies to a geometry of type GeomType_LineSegs and is the arrowhead attachment may have any of the following values: ArrowheadAttach_None, ArrowheadAttach_AtBeginning, ArrowheadAttach_AtEnd, ArrowheadAttach_AtBothEnds,

SV_ARROWHEADSIZE

Type:	double
Arg Function:	TecUtilArgListAppendDouble()
Default:	5.0
Required:	No
Notes:	Only applies to a geometry of type GeomType_LineSegs and is the arrowhead size if assigned. The value must be greater than or equal to zero and less than or equal to 50

SV_ARROWHEADANGLE

Type:	double
Arg Function:	TecUtilArgListAppendDouble()
Default:	12.0
Required:	No
Notes:	Only applies to a geometry of type GeomType_LineSegs and is the arrowhead angle must be greater than or equal to 1 and less than or equal to 90

SV_NUMELLIPSEPTS

Type:	LgIndex_t
Arg Function:	TecUtilArgListAppendInt()
Default:	72.0
Required:	No
Notes:	Only applies to a geometry of type GeomType_Ellipse and is the number of points used to define an ellipse. The value must be greater than or equal to 3 and less than or equal to 720

SV_XGEOMDATA

Type:	float *
Arg Function:	TecUtilArgListAppendArray()
Required:	Yes
Notes:	Floating point arrays containing the point data for the specific geometry

SV_YGEOMDATA

Type:	float *
Arg Function:	TecUtilArgListAppendArray()
Required:	Yes

SV_ZGEOMDATA

Type:	float *
Arg Function:	TecUtilArgListAppendArray()
Required:	Yes

SV_XPOS

Type:	double
Arg Function:	TecUtilArgListAppendDouble()
Default:	0.0
Required:	No
Notes:	Anchor position for the geometry

SV_YPOS

Type:	double
Arg Function:	TecUtilArgListAppendDouble()
Default:	0.0
Required:	No

SV_ZPOS

Type:	double
Arg Function:	TecUtilArgListAppendDouble()
Default:	0.0
Required:	No

SV_POSITIONCOORDSYS

Type:	CoordSys_e
Arg Function:	TecUtilArgListAppendInt()
Default:	CoordSys_Grid
Required:	No
Notes:	Coordinate system to which the geometry belongs and may have any of the following values: CoordSys_Grid, CoordSys_Frame, CoordSys_Grid3D,

SV_ATTACHTOZONE

Type:	Boolean_t
Arg Function:	TecUtilArgListAppendInt()
Default:	FALSE
Required:	No
Notes:	A value of TRUE indicates that the geometry is attached to the specified zone or map. A value of FALSE indicates that the geometry is not attached to a specific zone or map

SV_ZONE

Type:	EntIndex_t
Arg Function:	TecUtilArgListAppendInt()
Default:	1
Required:	No
Notes:	Zone or map number to which the geometry is attached

SV_COLOR

Type:	ColorIndex_t
Arg Function:	TecUtilArgListAppendInt()
Default:	Black_C
Required:	No
Notes:	Line color for the geometry may be a value greater than or equal to zero

SV_FILLCOLOR

Type:	ColorIndex_t
Arg Function:	TecUtilArgListAppendInt()
Default:	White_C
Required:	No
Notes:	Fill color for the geometry may be a value greater than or equal to zero

SV_ISFILLED

Type:	Boolean_t
Arg Function:	TecUtilArgListAppendInt()
Default:	FALSE
Required:	No
Notes:	If applicable a value of TRUE indicates the geometry is filled.

SV_LINEPATTERN

Type:	LinePattern_e
Arg Function:	TecUtilArgListAppendInt()
Default:	LinePattern_Solid
Required:	No
Notes:	Line pattern to use for the drawing the lines and may have any ofthe following values: LinePattern_Solid, LinePattern_Dashed, LinePattern_DashDot, LinePattern_Dotted, LinePattern_LongDash, LinePattern_DashDotDot.

SV_PATTERNLENGTH

Type:	double
Arg Function:	TecUtilArgListAppendDouble()
Default:	2.0
Required:	No
Notes:	Pattern length may be a value greater than or equal to zero and less than or equal to 100

SV_LINETHICKNESS

Type:	double
Arg Function:	TecUtilArgListAppendDouble()
Default:	0.1
Required:	No
Notes:	Line thickness may be a value greater than or equal to zero and less than or equal to 100

SV_SCOPE

Type:	Scope_e
Arg Function:	TecUtilArgListAppendInt()
Default:	Scope_Local
Required:	No
Notes:	A geometry with local scope is displayed only in the frame in which it is created. If the geometry is defined as having global scope it will appear in all "like" frames, that is, those frames using the same data set as the one in which the geometry was created. Scope may be either Scope_Global or Scope_Local.

SV_CLIPPING

Type:	Clipping_e
Arg Function:	TecUtilArgListAppendInt()
Default:	Clipping_ClipToViewport
Required:	No
Notes:	Clipping applied to the geometry may be either Clipping_ClipToViewport or Clipping_ClipToFrame.

SV_MACROFUNCTIONCOMMAND

Type:	char *
Arg Function:	TecUtilArgListAppendString()
Default:	NULL
Required:	No
Notes:	Macro function command associated with the geometry

Returns:: TRUE if the input parameters are valid and the data was successfully written, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilTecGeoX(ArgListPtr)
    POINTER (ArgListPtr, ArgList)

Python Syntax:

  Results = TecUtil.TecGeoX(ArgList)

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

LgIndex_t TecUtilTecIni	(	const char *	Title,
		const char *	Variables,
		const char *	FName,
		const char *	ScratchDir,
		LgIndex_t *	Debug,
		LgIndex_t *	VIsDouble
	)

Initializes the process of writing a binary data file.

This must be called first before any other TecUtilTecXxx calls are made. You may write to multiple files by calling TecUtilTecIni() more than once. Each time TecUtilTecIni() is called, a new file is opened. Use TecUtilTecFil() to switch between files.

Parameters:

	Title	Title of the data set. Must be NULL terminated
	Variables	List of variable names. Separate variable names with a newline, comma or space. If a newline is detected anywhere in the string it is used as the separator otherwise if a comma is detected then the comma is the separator otherwise a space is used. The string must be NULL terminated
	FName	Name of the file to create. Must be NULL terminated
	ScratchDir	Name of the directory to put the scratch file. Must be NULL terminated
	Debug	Handle to the integer flag for debugging. Set to 0 for no debugging or 1 to debug
	VIsDouble	Handle to the integer flag for specifying whether field data generated in future calls to TecUtilTecIni() are to be written in single or double precision. Set to 0 for single precision or 1 for double

Returns:: 0 if successful, -1 if unsuccessful.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilTecIni(
   &                   Title,
   &                   Variables,
   &                   FName,
   &                   ScratchDir,
   &                   Debug,
   &                   VIsDouble)
    CHARACTER*(*)   Title
    CHARACTER*(*)   Variables
    CHARACTER*(*)   FName
    CHARACTER*(*)   ScratchDir
    INTEGER*4       FileType
    INTEGER*4       Debug
    INTEGER*4       VIsDouble

Python Syntax:

  Results = TecUtil.TecIni(Title, Variables, FName, ScratchDir, Debug, VIsDouble)

  Input:
                  Title                string
                  Variables            string
                  FName                string
                  ScratchDir           string
                  Debug                list of ints
                  VIsDouble            list of ints
  Output:
    Results[0]    ReturnVal            int

LgIndex_t TecUtilTecIniX ( ArgList_pa ArgList )

Initializes the process of writing a binary data file.

This must be called first before any other TecUtilTecXxx calls are made. You may write to multiple files by calling TecUtilTecIniX() more than once. Each time TecUtilTecIniX() is called, a new file is opened. Use TecUtilTecFil() to switch between files.

Parameters:

ArgList

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

Arglist Values

SV_DATASETTITLE

Type:	char *
Arg Function:	TecUtilArgListAppendString()
Default:	""
Required:	No
Notes:	Data set title

SV_VARIABLES

Type:	char *
Arg Function:	TecUtilArgListAppendString()
Default:	""
Required:	No
Notes:	Only optional for files with DataFileType_Grid file type. Required for file types DataFileType_Full and DataFileType_Solution. See TecUtilTecIni() for more details

SV_FILENAME

Type:	char *
Arg Function:	TecUtilArgListAppendString()
Required:	Yes
Notes:	Name of the file to create. Must be NULL terminated

SV_SCRATCHDIR

Type:	char *
Arg Function:	TecUtilArgListAppendString()
Default:	NULL
Required:	No
Notes:	Name of the directory to put the scratch file. Must be NULL terminated

SV_DATAFILETYPE

Type:	DataFileType_e
Arg Function:	TecUtilArgListAppendInt()
Default:	DataFileType_Full
Required:	No
Notes:	Must be set to one of DataFileType_Full, DataFileType_Grid, or DataFileType_Solution. Use DataFileType_Full for a classic Tecplot data file. Use DataFileType_Grid for data files that will share all data with files marked DataFileType_Solution to make complete zones

SV_DEBUG

Type:	Boolean_t
Arg Function:	TecUtilArgListAppendInt()
Default:	FALSE
Required:	No
Notes:	Handle to the integer flag for debugging. Set to 0 for no debugging or 1 to debug

SV_VISDOUBLE

Type:	Boolean_t
Arg Function:	TecUtilArgListAppendInt()
Default:	FALSE
Required:	No
Notes:	Handle to the integer flag for specifying whether field data generated in future calls to TecUtilTecIni() or TecUtilTecIniX() are to be written in single or double precision. Set to 0 for single precision or 1 for double.

Returns:: 0 if successful, -1 if unsuccessful.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilTecIniX(ArgListPtr)
    POINTER (ArgListPtr, ArgList)

Python Syntax:

  Results = TecUtil.TecIniX(ArgList)

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

LgIndex_t TecUtilTecLab ( const char * S )

Write a set of custom labels to the data file.

Parameters:

S

Character string of custom labels. Separate labels by a comma or space. For example, a set of custom labels for each day of the week is:"Sun Mon Tue Wed Thu Fri Sat."

Returns:: 0 if successful, -1 if unsuccessful.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilTecLab(S)
    CHARACTER*(*) S

Python Syntax:

  Results = TecUtil.TecLab(S)

  Input:
                  S                    string
  Output:
    Results[0]    ReturnVal            int

LgIndex_t TecUtilTecNod ( LgIndex_t * NData_Array )

Writes an array of node data to the binary data file.

This is the connectivity list for finite element zones. For polygonal and polyhedral zones, use TecUtilTecPoly().

Parameters:

NData_Array

Array of integers. This is the connectivity list, dimensioned (m,JMax) (m moving fastest), where m is 3 for triangles, 4 for quads and tets, and 8 for bricks.

Returns:: 0 if successful, -1 if unsuccessful.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilTecNod(NData_Array)
    INTEGER*4 NData_Array

Python Syntax:

  Results = TecUtil.TecNod(NData_Array)

  Input:
                  NData_Array          list of ints
  Output:
    Results[0]    ReturnVal            int

LgIndex_t TecUtilTecPoly	(	LgIndex_t *	FaceNodeCounts,
		LgIndex_t *	FaceNodes,
		LgIndex_t *	FaceLeftElems,
		LgIndex_t *	FaceRightElems,
		LgIndex_t *	FaceBndryConnectionCounts,
		LgIndex_t *	FaceBndryConnectionElems,
		EntIndex_t *	FaceBndryConnectionZones
	)

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

Parameters:

	FaceNodeCounts	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.
	FaceNodes	Array of 1-based nodes for each face dimensioned by TotalNumFaceNodes.
	FaceLeftElems	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.
	FaceRightElems	Array of 1-based right elements for each face dimensioned by NumFaces. See description of FaceLeftElems for more details.
	FaceBndryConnectionCounts	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.
	FaceBndryConnectionElems	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.
	FaceBndryConnectionZones	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.

Returns:: 0 if successful, -1 if unsuccessful.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilTecPoly(FaceNodeCounts,
                                      FaceNodes,
                                      FaceLeftElems,
                                      FaceRightElems,
                                      FaceBndryConnectionCounts,
                                      FaceBndryConnectionElems,
                                      FaceBndryConnectionZones)
    INTEGER*4 *FaceNodeCounts,
    INTEGER*4 *FaceNodes,
    INTEGER*4 *FaceLeftElems,
    INTEGER*4 *FaceRightElems,
    INTEGER*4 *FaceBndryConnectionCounts,
    INTEGER*4 *FaceBndryConnectionElems,
    INTEGER*2 *FaceBndryConnectionZones

Python Syntax:

  Results = TecUtil.TecPoly(FaceNodeCounts, FaceNodes, FaceLeftElems, FaceRightElems, FaceBndryConnectionCounts, FaceBndryConnectionElems, FaceBndryConnectionZones)

  Input:
                  FaceNodeCounts       list of ints
                  FaceNodes            list of ints
                  FaceLeftElems        list of ints
                  FaceRightElems       list of ints
                  FaceBndryConnectionCounts list of ints
                  FaceBndryConnectionElems list of ints
                  FaceBndryConnectionZones list of ints
  Output:
    Results[0]    ReturnVal            int

LgIndex_t TecUtilTecTxt	(	double *	XPos,
		double *	YPos,
		LgIndex_t *	PosCoordMode,
		LgIndex_t *	AttachToZone,
		LgIndex_t *	Zone,
		LgIndex_t *	Font,
		LgIndex_t *	FontHeightUnits,
		double *	FontHeight,
		LgIndex_t *	BoxType,
		double *	BoxMargin,
		double *	BoxLineThickness,
		LgIndex_t *	BoxColor,
		LgIndex_t *	BoxFillColor,
		double *	Angle,
		LgIndex_t *	Anchor,
		double *	LineSpacing,
		LgIndex_t *	TextColor,
		LgIndex_t *	Scope,
		const char *	Text,
		const char *	MacroFunctionCommand
	)

Write a text label to a binary tecplot data file.

This function mimicks the TECTXT function that is part of the TecIO library.

Parameters:

	XPos	X-Anchor position of the text
	YPos	Y-Anchor position of the text
	PosCoordMode	Coordinate system used by the anchor position 0=Grid, 1=Frame, 6=Grid3D
	AttachToZone	Flag specifying whether or not to attach the text to a zone. One=Attach 0=Don't attach
	Zone	Zone to attach to
	Font	Font to use. Zero=Helv, 1=HelvBold, 2=Greek, 3=Math, 4=UserDef, 5=Times, 6=TimesItalic, 7=TimesBold, 8=TimesItalicBold, 9=Courier, 10=CourierBold
	FontHeightUnits	Units for the font height. Zero=Grid, 1=Frame, 2=Point
	FontHeight	Height of the text
	BoxType	Type of box to use. Zero=None, 1=Filled, 2=Hollow
	BoxMargin	Box Margin in percentage of the font height
	BoxLineThickness	Line thickness of the box in frame units.
	TextColor	Color of the text, 0=Black, 1=Red, 2=Green, 3=Blue, 4=Cyan, 5=Yellow, 6=Purple, 7=White, 8-64 are Custom colors.
	BoxColor	Color of the text box outline. 0=Black, 1=Red, 2=Green, 3=Blue, 4=Cyan, 5=Yellow, 6=Purple, 7=White, 8-64 are Custom colors.
	BoxFillColor	Color of the text box interior. 0=Black, 1=Red, 2=Green, 3=Blue, 4=Cyan, 5=Yellow, 6=Purple, 7=White, 8-64 are Custom colors.
	Angle	Angle of the text in degrees
	Anchor	Anchor position of the text. Zero=Left, 1=Center, 2=Right, 3=MidLeft, 4=MidCenter, 5=MidRight, 6=HeadLeft, 7=HeadCenter, 8=HeadRight
	LineSpacing	Line spacing of the text
	Scope	Scope for the text. Zero=Global, 1=Local
	Text	Actual text string
	MacroFunctionCommand	Macro command to execute when user cntrl-clicks on the text label. Set to NULL to not use.

Returns:: Returns 0 if successful, -1 if not.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilTecTxt(
   &                   XPos,
   &                   YPos,
   &                   PosCoordMode,
   &                   AttachToZone,
   &                   Zone,
   &                   Font,
   &                   FontHeightUnits,
   &                   FontHeight,
   &                   BoxType,
   &                   BoxMargin,
   &                   BoxLineThickness,
   &                   BoxColor,
   &                   BoxFillColor,
   &                   Angle,
   &                   Anchor,
   &                   LineSpacing,
   &                   TextColor,
   &                   Scope,
   &                   Text,
   &                   MacroFunctionCommand)
    REAL*8          XPos
    REAL*8          YPos
    INTEGER*4       PosCoordMode
    INTEGER*4       AttachToZone
    INTEGER*4       Zone
    INTEGER*4       Font
    INTEGER*4       FontHeightUnits
    REAL*8          FontHeight
    INTEGER*4       BoxType
    REAL*8          BoxMargin
    REAL*8          BoxLineThickness
    INTEGER*4       BoxColor
    INTEGER*4       BoxFillColor
    REAL*8          Angle
    INTEGER*4       Anchor
    REAL*8          LineSpacing
    INTEGER*4       TextColor
    INTEGER*4       Scope
    CHARACTER*(*)   Text
    CHARACTER*(*)   MacroFunctionCommand

Python Syntax:

  Results = TecUtil.TecTxt(XPos, YPos, PosCoordMode, AttachToZone, Zone, Font, FontHeightUnits, FontHeight, BoxType, BoxMargin, BoxLineThickness, BoxColor, BoxFillColor, Angle, Anchor, LineSpacing, TextColor, Scope, Text, MacroFunctionCommand)

  Input:
                  XPos                 list of doubles
                  YPos                 list of doubles
                  PosCoordMode         list of ints
                  AttachToZone         list of ints
                  Zone                 list of ints
                  Font                 list of ints
                  FontHeightUnits      list of ints
                  FontHeight           list of doubles
                  BoxType              list of ints
                  BoxMargin            list of doubles
                  BoxLineThickness     list of doubles
                  BoxColor             list of ints
                  BoxFillColor         list of ints
                  Angle                list of doubles
                  Anchor               list of ints
                  LineSpacing          list of doubles
                  TextColor            list of ints
                  Scope                list of ints
                  Text                 string
                  MacroFunctionCommand string
  Output:
    Results[0]    ReturnVal            int

LgIndex_t TecUtilTecTxtX ( ArgList_pa ArgList )

Writes the text item to the data file.

Parameters:

ArgList

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

Arglist Values

SV_TEXT

Type:	char *
Arg Function:	TecUtilArgListAppendString()
Required:	Yes

SV_XPOS

Type:	double
Arg Function:	TecUtilArgListAppendDouble()
Default:	0.0
Required:	No
Notes:	Anchor position for the text

SV_YPOS

Type:	double
Arg Function:	TecUtilArgListAppendDouble()
Default:	0.0
Required:	No

SV_ZPOS

Type:	double
Arg Function:	TecUtilArgListAppendDouble()
Default:	0.0
Required:	No

SV_POSITIONCOORDSYS

Type:	CoordSys_e
Arg Function:	TecUtilArgListAppendInt()
Default:	CoordSys_Grid
Required:	No
Notes:	Coordinate system to which the text belongs and may have any of the following values: CoordSys_Grid, CoordSys_Frame, CoordSys_Grid3D.

SV_ATTACHZONE

Type:	Boolean_t
Arg Function:	TecUtilArgListAppendInt()
Default:	FALSE
Required:	No
Notes:	A value of TRUE intedictates that the text is attached to the specified zone or map. A value of FALSE indicates that the text is not attached to a specific zone or map

SV_ZONE

Type:	EntIndex_t
Arg Function:	TecUtilArgListAppendInt()
Default:	1
Required:	No
Notes:	Zone or map number to which the text is attached

SV_FONT

Type:	Font_e
Arg Function:	TecUtilArgListAppendInt()
Default:	Font_HelveticaBold
Required:	No
Notes:	Font used to render the text may have any of the following values: Font_Helvetica, Font_HelveticaBold Font_Greek, Font_Math, Font_UserDefined, Font_Times, Font_TimesItalic, Font_TimesBold, Font_TimesItalicBold, Font_Courier, Font_CourierBold

SV_SIZEUNITS

Type:	Units_e
Arg Function:	TecUtilArgListAppendInt()
Default:	Units_Point
Required:	No
Notes:	Text sizing untis may have any of the following values: Untis_Grid, Units_Frame or Untis_Point

SV_HEIGHT

Type:	double
Arg Function:	TecUtilArgListAppendDouble()
Default:	14.0
Required:	No
Notes:	Text height in the specified units

SV_BOXTYPE

Type:	TextBox_e
Arg Function:	TecUtilArgListAppendInt()
Default:	TextBox_None
Required:	No
Notes:	Text box type may have any of the following values: TextBox_None, TextBox_Filled, or TextBox_Hollow

SV_MARGIN

Type:	double
Arg Function:	TecUtilArgListAppendDouble()
Default:	20.0
Required:	No
Notes:	Margin between the text and the text box may be a value greater than or equal to zero and less than or equal to 2000

SV_LINETHICKNESS

Type:	double
Arg Function:	TecUtilArgListAppendDouble()
Default:	0.1
Required:	No
Notes:	Text box line thickness may be a value greater than or equal to 0.001 or less than or equal to 100

SV_COLOR

Type:	ColorIndex_t
Arg Function:	TecUtilArgListAppendInt()
Default:	Black_C
Required:	No
Notes:	Text box line color may be a value greater or equal to zero.

SV_FILLCOLOR

Type:	ColorIndex_t
Arg Function:	TecUtilArgListAppendInt()
Default:	White_C
Required:	No
Notes:	Text box fill color may be a value greater or equal to zero

SV_ANGLE

Type:	double
Arg Function:	TecUtilArgListAppendDouble()
Default:	0.0
Required:	No
Notes:	Text angle may have a value greater than or equal to -360 and less than or equal to 360

SV_ANCHOR

Type:	TextAnchor_e
Arg Function:	TecUtilArgListAppendInt()
Default:	TextAnchor_Left
Required:	No
Notes:	Text anchor may have any of the following values: TextAnchor_Left, TextAnchor_Center, TextAnchor_Right, TextAnchor_MidLeft, TextAnchor_MidCenter, TextAnchor_MidRight, TextAnchor_HeadLeft, TextAnchor_HeadCenter, TextAnchor_HeadRight, TextAnchor_OnSide,

SV_LINESPACING

Type:	double
Arg Function:	TecUtilArgListAppendDouble()
Default:	1.0
Required:	No
Notes:	Line spacing may have a value greater that or equal to zero and less than or equal to 50

SV_TEXTCOLOR

Type:	ColorIndex_t
Arg Function:	TecUtilArgListAppendInt()
Default:	Black_C
Required:	No
Notes:	Text color may be a value greater than or equal to zero

SV_SCOPE

Type:	Scope_e
Arg Function:	TecUtilArgListAppendInt()
Default:	Scope_Local
Required:	No
Notes:	Text with local scope is displayed onlu in the frame in which it is created. If the text is defined as having global scope, it will appear in all "like" frames, that is, those frames using the same data set as the one in which the text was created. Scope may have any of the following values: Scope_Global or Scope_Local.

SV_CLIPPING

Type:	Clipping_e
Arg Function:	TecUtilArgListAppendInt()
Default:	Clipping_ClipToViewport
Required:	No
Notes:	Clipping applied to the text may have any of the following values: Clipping_ClipToViewport or Clipping_ClipToFrame

SV_MACROFUNCTIONCOMMAND

Type:	char *
Arg Function:	TecUtilArgListAppendString()
Default:	NULL
Required:	No
Notes:	Macro function command associated with the text

Returns:: TRUE if the input parameters are valid and the data was successfully written, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilTecTxtX(ArgListPtr)
    POINTER (ArgListPtr, ArgList)

Python Syntax:

  Results = TecUtil.TecTxtX(ArgList)

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

LgIndex_t TecUtilTecUsr ( const char * S )

Add a user-defined record, in the form of a character string, to the Tecplot data file.

Tecplot currently ignores this record when reading Tecplot data files.

Parameters:

S

String used in the user-defined record

Returns:: 0 if successful, -1 if unsuccessful.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilTecUsr(S)
    CHARACTER*(*) S

Python Syntax:

  Results = TecUtil.TecUsr(S)

  Input:
                  S                    string
  Output:
    Results[0]    ReturnVal            int

This function is comparable to $!TECUSR, a Tecplot macro command. Please refer to the examples given for $!TECUSR in the Tecplot Reference Manual.

   Insert a user-defined record with the string "Hi Mom" into the data file.
   TecUtilTecUsr("Hi Mom");

LgIndex_t TecUtilTecVAux	(	LgIndex_t *	Var,
		char *	Name,
		char *	Value
	)

Writes the name/value variable auxiliary data pair to the data file.

Since:: 10.0-3-129

Parameters:

	Var	Variable number assoicated with the auxiliary data.
	Name	Name of the variable auxiliary data item.
	Value	The value associated with the named variable auxiliary data item.

Returns:: 0 if successful, -1 if unsuccessful.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilTecVAux(
   &                   Var,
   &                   Name,
   &                   Value)
    INTEGER*4       Var
    CHARACTER*(*)   Name
    CHARACTER*(*)   Value

Python Syntax:

  Results = TecUtil.TecVAux(Var, Name, Value)

  Input:
                  Var                  list of ints
                  Name                 string
                  Value                string
  Output:
    Results[0]    ReturnVal            int

LgIndex_t TecUtilTecZAux	(	char *	Name,
		char *	Value
	)

Writes the name/value zone auxiliary data pair to the data file.

Parameters:

	Name	Name of the zone auxiliary data item.
	Value	The value associated with the named zone auxiliary data item

Returns:: 0 if successful, -1 if unsuccessful.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilTecZAux(
   &                   Name,
   &                   Value)
    CHARACTER*(*)   Name
    CHARACTER*(*)   Value

Python Syntax:

  Results = TecUtil.TecZAux(Name, Value)

  Input:
                  Name                 string
                  Value                string
  Output:
    Results[0]    ReturnVal            int

LgIndex_t TecUtilTecZne	(	const char *	ZoneTitle,
		LgIndex_t *	IMx,
		LgIndex_t *	JMx,
		LgIndex_t *	KMx,
		const char *	ZFormat,
		const char *	DupList
	)

Writes header information about the next zone to be added to the data file.

After TECZNE is called, you must call TECDAT one or more times (and then call TECNOD if the data format is FEBLOCK or FEPOINT).

Parameters:

	ZoneTitle	Title of the zone. Must be NULL terminated.
	IMx	Pointer to integer specifying I-Dimension of the zone. If the data is finite-element then IMx is the number of data points.
	JMx	Pointer to integer specifying J-Dimension of the zone if ordered otherwise the number of elements if finite element.
	KMx	Pointer to integer specifying K-Dimension of the zone if ordered otherwise is set according to the following: KMx for triangles is 0, quads is 1, tets is 2, and bricks is 3. Use TecUtilTecZneX() for polygonal and polyhedral zones.
	ZFormat	Must be set to one of BLOCK, POINT, FEBLOCK, or FEPOINT. Must be NULL terminated.
	DupList	This parameter specifies a list of variables to duplicate from the preceding zone. For a complete explination of the DupList parameter, see the Tecplot User's Manual. The DupList parameter is a string of the following form: "[n1,n2,...,nn][,FECONNECT]"where n1...nn are the numbers of the variables to duplicate. If the zone is finite element, you may optionally include FECONNECT, which will duplicate the connectivity list from the last zone. Notes for using the DupList parameter:1. You cannot use the DupList parameter for the first zone, since in that case there is nothing to duplicate.2. If you use FECONNECT, you cannot call TECNOD for this zone, since FECONNECT specifies that the entire connectivity list from the previous zone will be duplicated.3. For finite-element zones, you can pass "FECONNECT" to duplicate only the connectivity list.4. You may pass either NULL or a zero length string if you are not using this parameter.

Returns:: 0 if successful, -1 if unsuccessful.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilTecZne(
   &                   ZoneTitle,
   &                   IMx,
   &                   JMx,
   &                   KMx,
   &                   ZFormat,
   &                   DupList)
    CHARACTER*(*)   ZoneTitle
    INTEGER*4       IMx
    INTEGER*4       JMx
    INTEGER*4       KMx
    CHARACTER*(*)   ZFormat
    CHARACTER*(*)   DupList

Python Syntax:

  Results = TecUtil.TecZne(ZoneTitle, IMx, JMx, KMx, ZFormat, DupList)

  Input:
                  ZoneTitle            string
                  IMx                  list of ints
                  JMx                  list of ints
                  KMx                  list of ints
                  ZFormat              string
                  DupList              string
  Output:
    Results[0]    ReturnVal            int

LgIndex_t TecUtilTecZneX ( ArgList_pa ArgList )

Writes the zone to the data file.

Parameters:

ArgList

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

Arglist Values

SV_TITLE

Type:	char *
Arg Function:	TecUtilArgListAppendString()
Default:	Zone
Required:	No
Notes:	Zone title

SV_ZONETYPE

Type:	ZoneType_e
Arg Function:	TecUtilArgListAppendInt()
Required:	Yes
Notes:	Zone type may be any of the following values: ZoneType_Ordered, ZoneType_FETriangle, ZoneType_FEQuad, ZoneType_FETetra, ZoneType_FEBrick, ZoneType_FELineSeg, ZoneType_FEPolygon, ZoneType_FEPolyhedron.

SV_IMAX

Type:	LgIndex_t
Arg Function:	TecUtilArgListAppendInt()
Required:	Yes
Notes:	Number of points for the zone. The values must each be greater than or equal to 1. For ordered zones these are the I,J, and K index dimensions. For finite-element zones IMax is the number of nodes.

SV_JMAX

Type:	LgIndex_t
Arg Function:	TecUtilArgListAppendInt()
Required:	Yes
Notes:	JMax. For finite-element zones JMax is the number of elements.

SV_KMAX

Type:	LgIndex_t
Arg Function:	TecUtilArgListAppendInt()
Required:	Yes
Notes:	KMax. For polygonal or polyhedral zones, KMax is the number of faces.

SV_SOLUTIONTIME

Type:	double
Arg Function:	TecUtilArgListAppendDouble()
Default:	0.0
Required:	No
Notes:	Solution Time for the zone.

SV_STRANDID

Type:	LgIndex_t
Arg Function:	TecUtilArgListAppendInt()
Default:	0
Required:	No
Notes:	If the zone is static (not transient) then set the strand ID to zero, otherwise values greater than zero are used to assoicated zones with a particular strand. If the strand ID is given a value of -1 Tecplot can perform auto-stranding based upon the solution time given for each zone.

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_ISBLOCK

Type:	Boolean_t
Arg Function:	TecUtilArgListAppendInt()
Required:	Yes
Notes:	If TRUE the variables are written in block formate otherwise the less efficient point format is used.

SV_NUMFACECONNECTIONS

Type:	LgIndex_t
Arg Function:	TecUtilArgListAppendInt()
Default:	0
Required:	No
Notes:	Indicates the number of user defined face neighbor connections that will be supplied. The value must be greater than or equal to zero

SV_FACENEIGHBORMODE

Type:	FaceNeighborMode_e
Arg Function:	TecUtilArgListAppendInt()
Default:	FaceNeighborMode_LocalOneToOne
Required:	No
Notes:	None

SV_NUMFACENODES

Type:	LgIndex_t
Arg Function:	TecUtilArgListAppendInt()
Required:	Yes
Notes:	Total number of face nodes equivalent to the sum of the values in the FaceNodeCounts array supplied to TecUtilTecPoly(). For polyhedron zones this value is required. For polygonal zones this value is optional but if specified must be equivalent to 2*NumFaces, where NumFaces equals the total number of faces in the zone. This argument is only applicable to polytope zones.

SV_NUMFACEBNDRYFACES

Type:	LgIndex_t
Arg Function:	TecUtilArgListAppendInt()
Default:	0
Required:	No
Notes:	Total number of boundary faces - faces that either have more than one neighboring cell on a side or have a neighboring cell from another zone. If there are boundary faces and any faces don't have a neighboring element, then include at least one boundary face to represent it. This argument is only applicable to polytope zones.

SV_NUMFACEBNDRYCONNS

Type:	LgIndex_t
Arg Function:	TecUtilArgListAppendInt()
Default:	0
Required:	No
Notes:	The dimension of the FaceBndryConnectionElems and FaceBndryConnectionZones arrays supplied to TecUtilTecPoly(), representing the total number of boundary element-zone tuples listed in the arrays. This argument is only applicable to polytope zones.

SV_PASSIVEVARLIST

Type:	LgIndex_t *
Arg Function:	TecUtilArgListAppendArray()
Default:	NULL (all variables are active)
Required:	No
Notes:	Array dimensioned by the number of variables where each member contains a value of 0 or 1. A value of 1 indicates that the variable is passive while a value of 0 indicates the variable is active. TecUtilTecDat() assumes that you will not supply values for variables marked as passive. Passive variables do not consume any space in Tecplot and always return a value of zero for every point. Additionally, they are not considered when Tecplot is calculating the min/max values for the dataset.

SV_VALUELOCATION

Type:	ValueLocation_e *
Arg Function:	TecUtilArgListAppendArray()
Default:	NULL (all nodal)
Required:	No
Notes:	Array dimensioned by the number of variables where each member contains the value location for the associated variable. Each member may have any of the following values: ValueLocation_CellCentered or ValueLocation_Nodal

SV_VARSHAREZONELIST

Type:	LgIndex_t *
Arg Function:	TecUtilArgListAppendArray()
Default:	NULL (no sharing)
Required:	No
Notes:	Array dimensioned by the number of variables where each member contains the zone which the variable shares its data from or specified zero if it doesn't share with any zone. If a zone number is specified it must always be less than the current zone number.

SV_CONNECTSHAREZONE

Type:	LgIndex_t
Arg Function:	TecUtilArgListAppendInt()
Default:	0 (no sharing)
Required:	No
Notes:	Zone number with which the connectivity shares its data from or zero if it doesn't share with any zone. If a zone number is specidied it must always be less than the current zone number

Returns:: TRUE if the input parameters are valid and the data was successfully written, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilTecZneX(ArgListPtr)
    POINTER (ArgListPtr, ArgList)

Python Syntax:

  Results = TecUtil.TecZneX(ArgList)

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

Boolean_t TecUtilTransformCoordinatesX ( ArgList_pa ArgList )

Transform Coordinates.

Parameters:

ArgList

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

Arglist Values

SV_CREATENEWVARIABLES

Type:	Boolean_t
Arg Function:	TecUtilArgListAppendInt()
Default:	FALSE
Required:	No
Notes:	If TRUE, the transform creates new variables for the transformed coordinates. If FALSE, the transformed coordinates are placed in the specified variable numbers. Default is FALSE

SV_THETAVAR

Type:	EntIndex_t
Arg Function:	TecUtilArgListAppendInt()
Required:	Yes
Notes:	The variable numbers of the theta and r coordinate variables in polar of spherical coordinates. They are required source variable numbers for polar-to-rectangular transformations. If SV_CREATENEWVARIABLES is FALSE, they are required destination variable numbers for the rectangular-to-polar and rectangular-to-spherical transformation

SV_RVAR

Type:	EntIndex_t
Arg Function:	TecUtilArgListAppendInt()
Required:	Yes

SV_PSIVAR

Type:	EntIndex_t
Arg Function:	TecUtilArgListAppendInt()
Required:	Yes
Notes:	The variable number of the psi variable in spherical coordinates. This is a required source variable for spherical-to-rectangular coordinate transformations. If SV_CREATENEWVARIABLES is FALSE, it is a required destinations variable number for the rectangular-to-spherical coordinate transformation.

SV_XVAR

Type:	EntIndex_t
Arg Function:	TecUtilArgListAppendInt()
Required:	Yes
Notes:	The variable numbers of the X and Y coordinate variables in rectangular coordinates. The are required source variable numbers for the rectangular-to-polar or rectangular-to-spherical coordinate transformations. If SV_CREATENEWVARIABLES is FALSE, they are required destination variable numbers for the polar-to-rectangular or spherical-to-rectangular transformations

SV_YVAR

Type:	EntIndex_t
Arg Function:	TecUtilArgListAppendInt()
Required:	Yes

SV_ZVAR

Type:	entIndex_t
Arg Function:	TecUtilArgListAppendInt()
Required:	Yes
Notes:	The variable number of the z-coordinate variable in rectangular coordinates. It is required source variable number for the rectangular-to-spherical coordinate transformation. If SV_CREATENEWVARIABLES is FALSE, it is required a required destination variable number for the spherical-to-polar transformation

SV_ZONESET

Type:	Set_pa
Arg Function:	TecUtilArgListAppendSet()
Default:	NULL
Required:	No
Notes:	The set of zones to operate on. If not supplied then all active zones will be operated on

SV_ANGLESPEC

Type:	ThetaMode_e
Arg Function:	TecUtilArgListAppendInt()
Default:	ThetaMode_Radians
Required:	No
Notes:	Units of angle variables (optional). Possible values are: ThetaMode_Degrees, ThetaMode_Radians, ThetaMode_Arbitrary.

SV_TRANSFORMATION

Type:	Transform_e
Arg Function:	TecUtilArgListAppendInt()
Required:	Yes
Notes:	The desired transformation (required). Possible values are: Transform_PolarToRect, Transform_SphericalToRect, Transform_RectToPolar, Transform_RectToSpherical.

Returns:: TRUE if transformation was successful, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilTransformCoordinatesX(ArgListPtr)
    POINTER (ArgListPtr, ArgList)

Python Syntax:

  Results = TecUtil.TransformCoordinatesX(ArgList)

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

Transform spherical coordinate variables (varibles 1, 2 and 3) to rectangular (cartesian) coordinate variables.

   ArgList_pa ArgList;
   Set_pa ZoneSet = TecUtilSetAlloc(TRUE);
   TecUtilSetAddMember(ZoneSet, 1, TRUE);
   
   TecUtilLockStart(AddOnID);
   ArgList = TecUtilArgListAlloc();
       TecUtilArgListAppendInt(ArgList,
    SV_THETAVAR,
    (LgIndex_t)1);
       TecUtilArgListAppendInt(ArgList,
    SV_RVAR,
    (LgIndex_t)2);
       TecUtilArgListAppendInt(ArgList,
    SV_PSIVAR,
    (LgIndex_t)3);
       TecUtilArgListAppendInt(ArgList,
    SV_XVAR,
    (LgIndex_t)4);
       TecUtilArgListAppendInt(ArgList,
    SV_YVAR,
    (LgIndex_t)5);
       TecUtilArgListAppendInt(ArgList,
    SV_ZVAR,
    (LgIndex_t)6);
       TecUtilArgListAppendSet(ArgList,
    SV_ZONESET,
    ZoneSet);
       TecUtilArgListAppendInt(ArgList,
    SV_ANGLESPEC,
    (LgIndex_t)ThetaMode_Arbitrary);
       TecUtilArgListAppendInt(ArgList,
    SV_TRANSFORMATION,
    (LgIndex_t)Transform_SphericalToRect);
   
   TecUtilTransformCoordinatesX(ArgList);
   
   TecUtilArgListDealloc(&ArgList);
   
   TecUtilSetDealloc(&ZoneSet);
   TecUtilLockFinish(AddOnID);

Boolean_t TecUtilTriangulate	(	Set_pa	SourceZones,
		Boolean_t	DoBoundary,
		Set_pa	BoundaryZones,
		Boolean_t	IncludeBoundaryPts,
		LgIndex_t *	NumCoincidentPts,
		double	TriangleKeepFactor
	)

Create a new zone by forming triangles from data points in existing zones.

Parameters:

	SourceZones	Set of zones to triangulate
	DoBoundary	If TRUE, BoundaryZones must specify one or more I-ordered zones that define the boundaries across which no triangles can be created
	BoundaryZones	Set of zones for DoBoundary. Required if DoBoundary is TRUE, ignored otherwise
	IncludeBoundaryPts	TRUE if you also want the boundary points to be used to create triangles
	NumCoincidentPts	Returns the number of coincident points
	TriangleKeepFactor	A number between zero and 0.5. The smaller the number, the more likely it will be that highly obtuse triangles will be created opening toward the outside of the triangulated zone

Returns:: TRUE if successful, FALSE otherwise

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilTriangulate(
   &                   SourceZonesPtr,
   &                   DoBoundary,
   &                   BoundaryZonesPtr,
   &                   IncludeBoundaryPts,
   &                   NumCoincidentPts,
   &                   TriangleKeepFactor)
    POINTER         (SourceZonesPtr, SourceZones)
    INTEGER*4       DoBoundary
    POINTER         (BoundaryZonesPtr, BoundaryZones)
    INTEGER*4       IncludeBoundaryPts
    INTEGER*4       NumCoincidentPts
    REAL*8          TriangleKeepFactor

Python Syntax:

  Results = TecUtil.Triangulate(SourceZones, DoBoundary, BoundaryZones, IncludeBoundaryPts, TriangleKeepFactor)

  Input:
                  SourceZones          sequence of ints
                  DoBoundary           boolean
                  BoundaryZones        sequence of ints
                  IncludeBoundaryPts   boolean
                  TriangleKeepFactor   double
  Output:
    Results[0]    ReturnVal            boolean
    Results[1]    NumCoincidentPts     int

Create a zone by triangulating data points from zones 1 and 2:

   LgIndex_t NumCoincidentPts;
   Set_pa set = TecUtilSetAlloc(FALSE);
   TecUtilSetAddMember(set,1,FALSE);
   TecUtilSetAddMember(set,2,FALSE);
   TecUtilTriangulate(set,FALSE,NULL,FALSE,&NumCoincidentPts,0.25);
   TecUtilSetDealloc(&set);

Boolean_t TecUtilVarGetEnabled ( Set_pa * EnabledVars )

Get the set of enabled variables.

Variables are enabled/disabled when they are read in. There must be a data set attached to the current frame.

Parameters:

EnabledVars

Set of enabled variables. Must not be NULL

Returns:: TRUE if successful, FALSE otherwise

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilVarGetEnabled(EnabledVarsPtr)
    POINTER (EnabledVarsPtr, EnabledVars)

Python Syntax:

  Results = TecUtil.VarGetEnabled()

  Output:
    Results[0]    ReturnVal            boolean
    Results[1]    EnabledVars          sequence of ints

Get the set of enabled variables. It is assumed that a data set has been created:

   Set_pa set = NULL;
   TecUtilVarGetEnabled(&set);
   // Do something with set
   TecUtilSetDealloc(&set);

void TecUtilVarGetMinMax	(	EntIndex_t	Var,
		double *	VarMin,
		double *	VarMax
	)

Gets the minimum and maximum values of a variable.

Parameters:

	Var	Index of the variable. Must be greater than zero and the variable must be enabled
	VarMin	Receives the minimum value of the variable. Must not be NULL
	VarMax	Receives the maximum value of the variable. Must not be NULL

Fortran Syntax:

    SUBROUTINE TecUtilVarGetMinMax(
   &           Var,
   &           VarMin,
   &           VarMax)
    INTEGER*4       Var
    REAL*8          VarMin
    REAL*8          VarMax

Python Syntax:

  Results = TecUtil.VarGetMinMax(Var)

  Input:
                  Var                  int
  Output:
    Results[0]    VarMin               double
    Results[1]    VarMax               double

Get the minimum and maximum values of the first variable in a data set:

   double VarMin,VarMax;
   TecUtilVarGetMinMax(1,&VarMin,&VarMax);

Boolean_t TecUtilVarGetName	(	EntIndex_t	VarNum,
		char **	VName
	)

Get the name of a variable in the data set attached to the current frame.

There must be a data set attached to the current frame.

Parameters:

	VarNum	Number of the variable for which to get the variable name information. Must be greater than zero, and the variable must be enabled
	VName	Receives the name of the specified variable. Must not be NULL. You must free this string with TecUtilStringDealloc().

Returns:: TRUE if successful, FALSE if not.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilVarGetName(
   &                   VarNum,
   &                   VName,
   &                   VNameLength)
    INTEGER*4       VarNum
    CHARACTER*(*)   VName
    INTEGER*4       VNameLength

Python Syntax:

  Results = TecUtil.VarGetName(VarNum)

  Input:
                  VarNum               int
  Output:
    Results[0]    ReturnVal            boolean
    Results[1]    VName                string

Get the name of the first variable:

   char buffer[100];
   VarName_t Name;
   TecUtilVarGetName(1,&Name);
   sprintf(buffer,"The name of the first variable is %s",Name);
   TecUtilStringDealloc(&Name);

EntIndex_t TecUtilVarGetNumByAssignment ( char Var )

Gets the number (that is, the index) of a variable based on the variable assignment.

Parameters:

	Var	Variable to get. The frame mode must be 2-D or 3-D.If the frame mode is 2-D, select one of 'X', 'Y', 'U', 'V', 'B', 'C', or 'S'.If the frame mode is 3-D, select one of 'X','Y','Z','U','V','W', 'B', 'C', or 'S'Table 0-1. Variable assignment identifiers (Var) and descriptions.
	Var	Description'X' X-axis variable'Y' Y-axis variable'Z' Z-axis variable'U' U-velocity variable'V' V-velocity variable'W' W-velocity variable'B' Blanking variable'C' Contouring variable'S' Scatter sizing variable

Returns:: The index (number) of the variable referenced by Var.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilVarGetNumByAssignment(Var)
    CHARACTER*(*) Var

Python Syntax:

  Results = TecUtil.VarGetNumByAssignment(Var)

  Input:
                  Var                  int
  Output:
    Results[0]    ReturnVal            int

Get the index of the 'X' variable:

   // frame mode must be 2-D or 3-D
   EntIndex_t i = TecUtilVarGetNumByAssignment('X');

EntIndex_t TecUtilVarGetNumByName ( const char * VarName )

Gets the number (that is, the index) of a variable based on variable name.

Parameters:

VarName

Name of the variable. Must not be NULL

Returns:: The index (number) of the variable with name VarName, otherwise TECUTILSETNOTMEMBER if the variable is not a member of the current frame's data set.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilVarGetNumByName(VarName)
    CHARACTER*(*) VarName

Python Syntax:

  Results = TecUtil.VarGetNumByName(VarName)

  Input:
                  VarName              string
  Output:
    Results[0]    ReturnVal            int

Get the index of the variable Rainfall:

   EntIndex_t i = TecUtilVarGetNumByName("Rainfall");

EntIndex_t TecUtilVarGetNumByUniqueID ( UniqueID_t UniqueID )

Gets a variable number, given a unique ID.

Parameters:

UniqueID

Unique ID of the variable

Returns:: The variable number of the variable represented by the unique ID. If there is no variable number for the given unique ID, the return value is TECUTILBADID.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilVarGetNumByUniqueID(UniqueID)
    INTEGER*4 UniqueID

Python Syntax:

  Results = TecUtil.VarGetNumByUniqueID(UniqueID)

  Input:
                  UniqueID             long
  Output:
    Results[0]    ReturnVal            int

Get a variable number from a unique ID:

   {
     extern UniqueID_t ID; // previously initialized
   
     TecUtilLockStart(AddOnID);
     if ( TecUtilDataSetIsAvailable() )
       {
         EntIndex_t VarNum = TecUtilVarGetNumByUniqueID(ID);
         if (VarNum != TECUTILBADID)
           {
             ...
           }
       }
     TecUtilLockFinish(AddOnID);
   }

UniqueID_t TecUtilVarGetUniqueID ( EntIndex_t Var )

Gets a unique ID for a variable.

A unique ID is an integer that uniquely identifies a variable. An addon can use these IDs to internally keep track of a set of variables. TecUtilVarGetNumByUniqueID() can be used to convert between a unique ID and a variable number.

Parameters:

Var

Variable number to query.

Returns:: A unique ID for a variable.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilVarGetUniqueID(Var)
    INTEGER*4 Var

Python Syntax:

  Results = TecUtil.VarGetUniqueID(Var)

  Input:
                  Var                  int
  Output:
    Results[0]    ReturnVal            long

Get the unique ID for variable 1:

   {
     TecUtilLockStart(AddOnID);
     if ( TecUtilDataSetIsAvailable() && TecUtilVarIsEnabled(1) )
       {
         UniqueID_t ID = TecUtilVarGetUniqueID(1);
         ...
       }
     TecUtilLockFinish(AddOnID);
   }

Boolean_t TecUtilVariableIsLocked	(	EntIndex_t	Var,
		VarLockMode_e *	VarLockMode,
		char **	LockOwner
	)

Indicates if the variable is locked and optionally the mode in which it was locked and the current lock owner.

Since:: 11.0-0-321

Parameters:

	Var	Offset of the variable in question.
	VarLockMode	Reference to a variable locking mode enumeration. If NULL the argument is ignored otherwise the current locking mode is placed into the location pointed to by the reference.
	LockOwner	Reference to a lock owner string pointer. If NULL the argument is ignored otherwise the a copy of the lock owner string is placed into the location pointed to by the reference. It is the client's responsibility to free the resulting lock owner string with TecUtilStringDealloc() when finished with it.

Returns:: TRUE if the variable is locked, FALSE otherwise.

See also:: TecUtilVariableLockOn(), TecUtilVariableLockOff().

Python Syntax:

  Results = TecUtil.VariableIsLocked(Var)

  Input:
                  Var                  int
  Output:
    Results[0]    ReturnVal            boolean
    Results[1]    VarLockMode          VarLockMode_e  (defined in TecVals.py)
    Results[2]    LockOwner            string

Boolean_t TecUtilVariableLockOff	(	EntIndex_t	Var,
		const char *	LockOwner
	)

Unlock the variable.

The variable must have been previously locked by the same lock owner.

Since:: 11.0-0-321

Parameters:

	Var	Offset of the variable to unlock. The offset used to lock the variable may not be the same as variables could be deleted or inserted into the For help tracking variables see TecUtilVarGetUniqueID() and TecUtilVarGetNumByUniqueID().
	LockOwner	A unique non-zero length string identifying the lock owner. Add-ons can use the ADDON_NAME define for this value. This string must match that of the variable locker.

Returns:: TRUE if the variable could be unlocked, FALSE otherwise.

See also:: TecUtilVariableLockOn(), TecUtilVariableIsLocked().

Python Syntax:

  Results = TecUtil.VariableLockOff(Var, LockOwner)

  Input:
                  Var                  int
                  LockOwner            string
  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilVariableLockOn	(	EntIndex_t	Var,
		VarLockMode_e	VarLockMode,
		const char *	LockOwner
	)

Lock the variable from being altered according to the specified locking mode.

The variable can only be locked if it isn't already locked.

Since:: 11.0-0-321

Parameters:

	Var	Current offset of the variable to lock. The offset may change over the course of a Tepclot session as other variables are deleted or inserted into the dataset. For help tracking variables see TecUtilVarGetUniqueID() and TecUtilVarGetNumByUniqueID().
	VarLockMode	Variable locking mode. The possible values are: VarLockMode_ValueChange (prevents modification of values in a variable but permits deletion), and VarLockMode_Delete (prevents deletion of a varaible but permits modification).
	LockOwner	A unique non-zero length string identifying the lock owner. Add-ons can use the ADDON_NAME define for this value.

Returns:: TRUE if the variable could be locked, FALSE otherwise.

See also:: TecUtilVariableLockOff(), TecUtilVariableIsLocked().

Python Syntax:

  Results = TecUtil.VariableLockOn(Var, VarLockMode, LockOwner)

  Input:
                  Var                  int
                  VarLockMode          VarLockMode_e  (defined in TecVals.py)
                  LockOwner            string
  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilVarIsEnabled ( EntIndex_t Var )

Determine if a variable is enabled.

Returns:: TRUE, if a variable is enabled, otherwise, FALSE.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilVarIsEnabled(Var)
    INTEGER*4 Var

Python Syntax:

  Results = TecUtil.VarIsEnabled(Var)

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

Check if the first variable is enabled:

   if (TecUtilVarIsEnabled(1))
     {
       // sure is!
     }

Boolean_t TecUtilVarRename	(	EntIndex_t	VarNum,
		const char *	VarName
	)

Rename a data set variable in Tecplot.

Parameters:

	VarNum	The number of the variable to be renamed. The variable must be greater than zero and the variable must be enabled
	VarName	A string containing the new variable name. Must not be NULL

Returns:: TRUE if successful, FALSE if not.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilVarRename(
   &                   VarNum,
   &                   VarName)
    INTEGER*4       VarNum
    CHARACTER*(*)   VarName

Python Syntax:

  Results = TecUtil.VarRename(VarNum, VarName)

  Input:
                  VarNum               int
                  VarName              string
  Output:
    Results[0]    ReturnVal            boolean

Rename the first variable (assumed to be enabled for this example):

   TecUtilVarRename(1,"NewNameForVariable1");

Boolean_t TecUtilWriteDataSet	(	const char *	FName,
		Boolean_t	IncludeText,
		Boolean_t	IncludeGeom,
		Boolean_t	IncludeCustomLabels,
		Boolean_t	IncludeData,
		Set_pa	ZonesToWrite,
		Set_pa	VarsToWrite,
		Boolean_t	WriteBinary,
		Boolean_t	UsePointFormat,
		SmInteger_t	AsciiPrecision
	)

Write the data set attached to the current frame to a file.

Parameters:

	FName	File name. Must not be NULL
	IncludeText	Set to TRUE to include text.
	IncludeGeom	Set to TRUE to include geometries
	IncludeCustomLabels	Set to TRUE to include custom labels
	IncludeData	Set to TRUE to include data
	ZonesToWrite	Set of zones to write. Pass NULL to write all zones
	VarsToWrite	Set of vars to write. Pass NULL to write all variables
	WriteBinary	Set to TRUE to write a binary file, FALSE to write an ASCII file
	UsePointFormat	Valid only if WriteBinary is FALSE, ignored otherwise
	AsciiPrecision	Valid only if WriteBinary is FALSE, ignored otherwise

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilWriteDataSet(
   &                   FName,
   &                   IncludeText,
   &                   IncludeGeom,
   &                   IncludeCustomLabels,
   &                   IncludeData,
   &                   ZonesToWritePtr,
   &                   VarsToWritePtr,
   &                   WriteBinary,
   &                   UsePointFormat,
   &                   AsciiPrecision)
    CHARACTER*(*)   FName
    INTEGER*4       IncludeText
    INTEGER*4       IncludeGeom
    INTEGER*4       IncludeCustomLabels
    INTEGER*4       IncludeData
    POINTER         (ZonesToWritePtr, ZonesToWrite)
    POINTER         (VarsToWritePtr, VarsToWrite)
    INTEGER*4       WriteBinary
    INTEGER*4       UsePointFormat
    INTEGER*4       AsciiPrecision

Python Syntax:

  Results = TecUtil.WriteDataSet(FName, IncludeText, IncludeGeom, IncludeCustomLabels, IncludeData, ZonesToWrite, VarsToWrite, WriteBinary, UsePointFormat, AsciiPrecision)

  Input:
                  FName                string
                  IncludeText          boolean
                  IncludeGeom          boolean
                  IncludeCustomLabels  boolean
                  IncludeData          boolean
                  ZonesToWrite         sequence of ints
                  VarsToWrite          sequence of ints
                  WriteBinary          boolean
                  UsePointFormat       boolean
                  AsciiPrecision       int
  Output:
    Results[0]    ReturnVal            boolean

Write out only zone 3 to a file called zone3.plt:

   Set_pa set = TecUtilSetAlloc(FALSE);
   TecUtilSetAddMember(set,3,FALSE);
   TecUtilWriteDataSet("zone3.plt",FALSE,FALSE,FALSE,TRUE,set,NULL,
                       TRUE,FALSE,0);
   TecUtilSetDealloc(&set);

Boolean_t TecUtilWriteStylesheet	(	const char *	FName,
		Boolean_t	IncludePlotStyle,
		Boolean_t	IncludeText,
		Boolean_t	IncludeGeom,
		Boolean_t	IncludeStreamPositions,
		Boolean_t	IncludeContourLevels,
		Boolean_t	IncludeFactoryDefaults
	)

Write the style for the current frame to a file.

Parameters:

	FName	File name. Must not be NULL
	IncludePlotStyle	Set to TRUE to include the plot style
	IncludeText	Set to TRUE to include text
	IncludeGeom	Set to TRUE to include geometries
	IncludeStreamPositions	Set to TRUE to include stream positions
	IncludeContourLevels	Set to TRUE to include contour levels
	IncludeFactoryDefaults	Set to TRUE to include factory defaults

Returns:: TRUE if successful, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilWriteStylesheet(
   &                   FName,
   &                   IncludePlotStyle,
   &                   IncludeText,
   &                   IncludeGeom,
   &                   IncludeStreamPositions,
   &                   IncludeContourLevels,
   &                   IncludeFactoryDefaults)
    CHARACTER*(*)   FName
    INTEGER*4       IncludePlotStyle
    INTEGER*4       IncludeText
    INTEGER*4       IncludeGeom
    INTEGER*4       IncludeStreamPositions
    INTEGER*4       IncludeContourLevels
    INTEGER*4       IncludeFactoryDefaults

Python Syntax:

  Results = TecUtil.WriteStylesheet(FName, IncludePlotStyle, IncludeText, IncludeGeom, IncludeStreamPositions, IncludeContourLevels, IncludeFactoryDefaults)

  Input:
                  FName                string
                  IncludePlotStyle     boolean
                  IncludeText          boolean
                  IncludeGeom          boolean
                  IncludeStreamPositions boolean
                  IncludeContourLevels boolean
                  IncludeFactoryDefaults boolean
  Output:
    Results[0]    ReturnVal            boolean

Write the style for the current frame to the file f1.sty:

   TecUtilWriteStylesheet("f1.sty",TRUE,TRUE,TRUE,TRUE,TRUE,TRUE);.

Boolean_t TecUtilZoneCopy	(	EntIndex_t	ZoneUsed,
		LgIndex_t	IMin,
		LgIndex_t	IMax,
		LgIndex_t	ISkip,
		LgIndex_t	JMin,
		LgIndex_t	JMax,
		LgIndex_t	JSkip,
		LgIndex_t	KMin,
		LgIndex_t	KMax,
		LgIndex_t	KSkip
	)

Make a copy of an existing zone.

You can assign index ranges to create a new zone which is a sub-set of the source zone.

Parameters:

	ZoneUsed	Source zone. Must be greater than or equal to one
	IMin	Minimum I-index. Set to one to duplicate the entire zone
	IMax	Maximum I-index. Set to zero to duplicate the entire zone
	ISkip	I skip value. Set to one to duplicate the entire zone
	JMin	Minimum J-index. Set to one to duplicate the entire zone
	JMax	Maximum J-index. Set to zero to duplicate the entire zone
	JSkip	J skip value. Set to one to duplicate the entire zone.
	KMin	Minimum K-index. Set to one to duplicate the entire zone.
	KMax	Maximum K-index. Set to zero to duplicate the entire zone
	KSkip	K skip value. Set to one to duplicate the entire zone

Returns:: TRUE if successful, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilZoneCopy(
   &                   ZoneUsed,
   &                   IMin,
   &                   IMax,
   &                   ISkip,
   &                   JMin,
   &                   JMax,
   &                   JSkip,
   &                   KMin,
   &                   KMax,
   &                   KSkip)
    INTEGER*4       ZoneUsed
    INTEGER*4       IMin
    INTEGER*4       IMax
    INTEGER*4       ISkip
    INTEGER*4       JMin
    INTEGER*4       JMax
    INTEGER*4       JSkip
    INTEGER*4       KMin
    INTEGER*4       KMax
    INTEGER*4       KSkip

Python Syntax:

  Results = TecUtil.ZoneCopy(ZoneUsed, IMin, IMax, ISkip, JMin, JMax, JSkip, KMin, KMax, KSkip)

  Input:
                  ZoneUsed             int
                  IMin                 int
                  IMax                 int
                  ISkip                int
                  JMin                 int
                  JMax                 int
                  JSkip                int
                  KMin                 int
                  KMax                 int
                  KSkip                int
  Output:
    Results[0]    ReturnVal            boolean

Duplicate zone 3:

   Boolean_t IsOK = TecUtilZoneCopy(3,1,0,1,1,0,1,1,0,1);

Boolean_t TecUtilZoneCopyX ( ArgList_pa ArgList )

Make a copy of a zone.

Parameters:

ArgList

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

Arglist Values

SV_SOURCEZONE

Type:	EntIndex_t
Arg Function:	TecUtilArgListAppendInt()
Required:	Yes
Notes:	The source zone.

SV_IMIN

Type:	LgIndex_t
Arg Function:	TecUtilArgListAppendInt()
Default:	1
Required:	No

SV_IMAX

Type:	LgIndex_t
Arg Function:	TecUtilArgListAppendInt()
Default:	0
Required:	No
Notes:	0 = Max

SV_ISKIP

Type:	LgIndex_t
Arg Function:	TecUtilArgListAppendInt()
Default:	1
Required:	No

SV_JMIN

Type:	LgIndex_t
Arg Function:	TecUtilArgListAppendInt()
Default:	1
Required:	No

SV_JMAX

Type:	LgIndex_t
Arg Function:	TecUtilArgListAppendInt()
Default:	0
Required:	No
Notes:	0 = Max

SV_JSKIP

Type:	LgIndex_t
Arg Function:	TecUtilArgListAppendInt()
Default:	1
Required:	No

SV_KMIN

Type:	LgIndex_t
Arg Function:	TecUtilArgListAppendInt()
Default:	1
Required:	No

SV_KMAX

Type:	LgIndex_t
Arg Function:	TecUtilArgListAppendInt()
Default:	0
Required:	No
Notes:	0 = Max

SV_KSKIP

Type:	LgIndex_t
Arg Function:	TecUtilArgListAppendInt()
Default:	1
Required:	No

Returns:: Returns TRUE if successful, otherwise FALSE.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilZoneCopyX(ArgListPtr)
    POINTER (ArgListPtr, ArgList)

Python Syntax:

  Results = TecUtil.ZoneCopyX(ArgList)

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

Boolean_t TecUtilZoneDelete ( Set_pa ZoneList )

Deprecated:: Please use TecUtilDataSetDeleteZone() instead.

Boolean_t TecUtilZoneGetActive ( Set_pa * ActiveZones )

Obtain the set of active field zones.

Parameters:

ActiveZones

Receives the set of active field zones. You must call TecUtilSetDealloc() when you are through using the set.

Returns:: TRUE if successful, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilZoneGetActive(ActiveZonesPtr)
    POINTER (ActiveZonesPtr, ActiveZones)

Python Syntax:

  Results = TecUtil.ZoneGetActive()

  Output:
    Results[0]    ReturnVal            boolean
    Results[1]    ActiveZones          sequence of ints

Do something if zone 3 is active:

   Set_pa zone_set = NULL;
   TecUtilZoneGetActive(&zone_set);
   if ( TecUtilSetIsMember(zone_set, 3) )
     {
       // do something
     }
   TecUtilSetDealloc(&zone_set);

Boolean_t TecUtilZoneGetEnabled ( Set_pa * EnabledZones )

Get the set of enabled zones.

Zones are enabled/disabled when they are read in.

Parameters:

EnabledZones

Receives the set of enabled zones. You must free this pointer by calling TecUtilSetDealloc().

Returns:: TRUE if successful, FALSE otherwise

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilZoneGetEnabled(EnabledZonesPtr)
    POINTER (EnabledZonesPtr, EnabledZones)

Python Syntax:

  Results = TecUtil.ZoneGetEnabled()

  Output:
    Results[0]    ReturnVal            boolean
    Results[1]    EnabledZones         sequence of ints

Get the set of enabled zones:

   Set_pa set = NULL;
   if (TecUtilZoneGetEnabled(&set))
   {
    // do something with the set here
    TecUtilSetDealloc(&set);
   }

LgIndex_t TecUtilZoneGetFieldMap ( EntIndex_t Zone )

Gets the position of the zone in the Zone Style dialog.

This function may only be called when the Plot Type is 2D or 3D.

Python Syntax:

  Results = TecUtil.ZoneGetFieldMap(Zone)

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

void TecUtilZoneGetIJK	(	EntIndex_t	CurZone,
		LgIndex_t *	IMax,
		LgIndex_t *	JMax,
		LgIndex_t *	KMax
	)

Used to obtain the I, J, and K dimensions of a specific zone.

Parameters:

	CurZone	Number of the zone to query.
	IMax	Receives the I-dimension for ordered data. Number of data points for FE-data. Passing NULL indicates the value is not desired.
	JMax	Receives the J-dimension for ordered data. Number of elements for FE-data. Passing NULL indicates the value is not desired.
	KMax	Receives the K-dimension for ordered data. Number of nodes per cell for cell-based FE-data (triangle, brick, tetrahedral, quadtrilateral). Number of faces for face-based FE-data (polygons and polyhedrons). Passing NULL indicates the value is not desired.

Fortran Syntax:

    SUBROUTINE TecUtilZoneGetInfo(
   &           CurZone,
   &           IMax,
   &           JMax,
   &           KMax)
    INTEGER*4       CurZone
    INTEGER*4       IMax
    INTEGER*4       JMax
    INTEGER*4       KMax

Python Syntax:

  Results = TecUtil.ZoneGetIJK(CurZone, IMax, JMax, KMax)

  Input:
                  CurZone              int
                  IMax                 list of ints
                  JMax                 list of ints
                  KMax                 list of ints
  Output:
    Results[0]    ReturnVal            NONE

Get IMAX for the first zone:

   LgIndex_t IMax;
   // Use NULL for values we're not interested in
   TecUtilZoneGetInfo(1,&IMax,NULL,NULL);

See also:: TecUtilZoneGetInfo

void TecUtilZoneGetInfo	(	EntIndex_t	CurZone,
		LgIndex_t *	IMax,
		LgIndex_t *	JMax,
		LgIndex_t *	KMax,
		FieldData_pa *	XVar,
		FieldData_pa *	YVar,
		FieldData_pa *	ZVar,
		NodeMap_pa *	NMap,
		FieldData_pa *	UVar,
		FieldData_pa *	VVar,
		FieldData_pa *	WVar,
		FieldData_pa *	BVar,
		FieldData_pa *	CVar,
		FieldData_pa *	SVar
	)

Convenience function used to obtain information about a specific zone.

This function is primarily targeted for use with 2D and 3D frame modes. If the frame mode is XY, only the zone dimensions can be queried. To get a field data pointer to axis variables when the frame mode is XY use TecUtilLineMapGetAssignment().

Note:: This function always returns a writable native field data handle when one is requested. Getting a writable native field data handle is more expensive than getting a readable native one therefore if you only intend to inspect the data you should call TecUtilDataValueGetReadableNativeRef() instead.

Parameters:

	CurZone	Number of the zone to query.
	IMax	Receives the I-dimension for ordered data. Number of data points for FE-data. Passing NULL indicates the value is not desired.
	JMax	Receives the J-dimension for ordered data. Number of elements for FE-data. Passing NULL indicates the value is not desired.
	KMax	Receives the K-dimension for ordered data. Number of nodes per cell for cell-based FE-data (triangle, brick, tetrahedral, quadtrilateral). Number of faces for face-based FE-data (polygons and polyhedrons). Passing NULL indicates the value is not desired.
	XVar	Receives the handle to a writeable field data for X. Passing NULL indicates the value is not desired. If the frame mode is XY this parameter must be NULL.
	YVar	Receives the handle to a writeable field data for Y. Passing NULL indicates the value is not desired. If the frame mode is XY this parameter must be NULL.
	ZVar	Receives the handle to a writeable field data for Z. Passing NULL indicates the value is not desired. If the frame mode is XY this parameter must be NULL.
	NMap	Receives the handle for a writeable connectivity list. Passing NULL indicates the value is not desired. If the frame mode is XY this parameter must be NULL.
	UVar	Receives the Handle to a writeable field data for U. Passing NULL indicates the value is not desired. If the frame mode is XY this parameter must be NULL.
	VVar	Receives the handle to a writable field data for V. Passing NULL indicates the value is not desired. If the frame mode is XY this parameter must be NULL.
	WVar	Receives the handle to a writable field data for W. Passing NULL indicates the value is not desired. If the frame mode is XY this parameter must be NULL.
	BVar	Receives the handle to a writable field data for the blanking variable. Passing NULL indicates the value is not desired. If the frame mode is XY this parameter must be NULL.
	CVar	Receives the handle to a writable field data for the contouring variable. Passing NULL indicates the value is not desired. If the frame mode is XY this parameter must be NULL.
	SVar	Receives the handle to a writable field data for the scatter sizing variable. Passing NULL indicates the value is not desired. If the frame mode is XY this parameter must be NULL.

Fortran Syntax:

    SUBROUTINE TecUtilZoneGetInfo(
   &           CurZone,
   &           IMax,
   &           JMax,
   &           KMax,
   &           XVarPtr,
   &           YVarPtr,
   &           ZVarPtr,
   &           NMapPtr,
   &           UVarPtr,
   &           VVarPtr,
   &           WVarPtr,
   &           BVarPtr,
   &           CVarPtr,
   &           SVarPtr)
    INTEGER*4       CurZone
    INTEGER*4       IMax
    INTEGER*4       JMax
    INTEGER*4       KMax
    POINTER         (XVarPtr, XVar)
    POINTER         (YVarPtr, YVar)
    POINTER         (ZVarPtr, ZVar)
    POINTER         (NMapPtr, NMap)
    POINTER         (UVarPtr, UVar)
    POINTER         (VVarPtr, VVar)
    POINTER         (WVarPtr, WVar)
    POINTER         (BVarPtr, BVar)
    POINTER         (CVarPtr, CVar)
    POINTER         (SVarPtr, SVar)

Python Syntax:

  Results = TecUtil.ZoneGetInfo(CurZone)

  Input:
                  CurZone              int
  Output:
    Results[0]    IMax                 int
    Results[1]    JMax                 int
    Results[2]    KMax                 int
    Results[3]    XVar                 opaque pointer
    Results[4]    YVar                 opaque pointer
    Results[5]    ZVar                 opaque pointer
    Results[6]    NMap                 opaque pointer
    Results[7]    UVar                 opaque pointer
    Results[8]    VVar                 opaque pointer
    Results[9]    WVar                 opaque pointer
    Results[10]   BVar                 opaque pointer
    Results[11]   CVar                 opaque pointer
    Results[12]   SVar                 opaque pointer

Get IMAX for the first zone:

   LgIndex_t IMax;
   // Use NULL for values we're not interested in
   TecUtilZoneGetInfo(1,&IMax,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
                      NULL,NULL,NULL,NULL,NULL);

FORTRAN example to get IMAX for the first zone:

      INTEGER*4 IMax
      INTEGER*4 ZoneNum
      POINTER   (NullPntr, Null)
             .
             .
             .
      NullPntr = 0
      ZoneNum  = 1

      Call TecUtilZoneGetInfo(ZoneNum,
     &                        IMax,
     &                        Null,
     &                        Null,
     &                        Null,
     &                        Null,
     &                        Null,
     &                        Null,
     &                        Null,
     &                        Null,
     &                        Null,
     &                        Null,
     &                        Null,
     &                        Null)

Boolean_t TecUtilZoneGetName	(	EntIndex_t	Zone,
		char **	ZName
	)

Get the name of a specified zone in the data set attached to the current frame.

Parameters:

	Zone	Number of the zone for which to get the zone name information
	ZName	Receives the name of the specified zone. You must free the returned string with TecUtilStringDealloc().

Returns:: TRUE if successful, FALSE if not. FALSE usually indicates an invalid zone or that the current frame does not have an attached data set.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilZoneGetName(
   &                   Zone,
   &                   ZName,
   &                   ZNameLength)
    INTEGER*4       Zone
    CHARACTER*(*)   ZName
    INTEGER*4       ZNameLength

Python Syntax:

  Results = TecUtil.ZoneGetName(Zone)

  Input:
                  Zone                 int
  Output:
    Results[0]    ReturnVal            boolean
    Results[1]    ZName                string

Get the name of the first zone:

   char *name = NULL;
   if (TecUtilZoneGetName(1,&name)
   {
     // do something with the name here
     TecUtilStringDealloc(&name);
   }

EntIndex_t TecUtilZoneGetNumByUniqueID ( UniqueID_t UniqueID )

Gets a zone number, given a unique ID.

Parameters:

UniqueID

Unique ID of the zone

Returns:: The zone number of the vairable represented by the unique ID. If there is no zone number for the given unique ID, the return value is TECUTILBADID.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilZoneGetNumByUniqueID(UniqueID)
    INTEGER*4 UniqueID

Python Syntax:

  Results = TecUtil.ZoneGetNumByUniqueID(UniqueID)

  Input:
                  UniqueID             long
  Output:
    Results[0]    ReturnVal            int

Get a zone number from a unique ID:

   {
     extern UniqueID_t ID; // previously initialized
   
     TecUtilLockStart(AddOnID);
     if ( TecUtilDataSetIsAvailable() )
       {
         EntIndex_t ZoneNum = TecUtilZoneGetNumByUniqueID(ID);
         if (ZoneNum != TECUTILBADID)
           {
             ...
           }
       }
     TecUtilLockFinish(AddOnID);
   }

EntIndex_t TecUtilZoneGetParentZone ( EntIndex_t Zone )

Returns the number of the Parent Zone associated with the specified zone.

Returns:: Parent Zone for the zone. 0 indicates that the zone has no parent zone.

Parameters:

Zone

A zone number for a currently enabled zone.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilZoneGetParentZone(
   &                   Zone)
    INTEGER*4       Zone

Python Syntax:

  Results = TecUtil.ZoneGetParentZone(Zone)

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

Boolean_t TecUtilZoneGetRelevant	(	double	SolutionTime,
		Boolean_t	IgnoreStaticZones,
		Set_pa *	RelevantZones
	)

Get the set of relevant zones at the supplied solution time.

A transient zone is relevant if its solution time is less than the supplied solution time and there are no other zones in its strand that have closer solution times. No zones of a strand are relevant if the solution time is outside the range of solution times for the entire strand. Static zones (non-transient) are always considered relevant. For more information on transient zones see the Tecplot User's Manual.

Parameters:

	IgnoreStaticZones	If set to TRUE the resulting set will not include static zones. If FALSE, static zones will be included in the result. Static zones are always "relevant" regardless of the solution time.
	SolutionTime	The solution time for which to get the relevant zones.
	RelevantZones	A reference to a Set_pa in which to put the resulting set of zones.

Returns:: TRUE if successful, FALSE otherwise. If FALSE, RelevantZones will be NULL.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilZoneGetRelevant(
   &                   SolutionTime,
   &                   IgnoreStaticZones,
   &                   RelevantZones)
    REAL*8          SolutionTime
    INTEGER*4       IgnoreStaticZones
    POINTER (RelevantZonesPtr, RelevantZones)

Python Syntax:

  Results = TecUtil.ZoneGetRelevant(SolutionTime, IgnoreStaticZones)

  Input:
                  SolutionTime         double
                  IgnoreStaticZones    boolean
  Output:
    Results[0]    ReturnVal            boolean
    Results[1]    RelevantZones        sequence of ints

Get the set of relevant zones:

   Set_pa set = NULL;
   Boolean_t IsOk;
   IsOk = TecUtilZoneGetRelevant(0.4324,
                                 FALSE,
                                 &set);
   if ( IsOk )
     {
       // do something with the set here
       TecUtilSetDealloc(&set);
     }

double TecUtilZoneGetSolutionTime ( EntIndex_t Zone )

Returns the Solution Time associated with the specified zone.

Returns:: Solution time for the zone.

Parameters:

Zone

A zone number for a currently enabled zone.

Fortran Syntax:

    REAL*8 FUNCTION TecUtilZoneGetSolutionTime(
   &                Zone)
    INTEGER*4    Zone

Python Syntax:

  Results = TecUtil.ZoneGetSolutionTime(Zone)

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

See also:: TecUtilSolutionTimeSetCurrent() and TecUtilSolutionTimeGetCurrent()

Strand_t TecUtilZoneGetStrandID ( EntIndex_t Zone )

Returns the StrandID associated with the specified zone.

Returns:: StrandID for the zone. 0 indicates that the zone is not part of a strand. Transient zones will have a StrandID of 1 or greater.

Parameters:

Zone

A zone number for a currently enabled zone.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilZoneGetStrandID(
   &                   Zone)
    INTEGER*4       Zone

Python Syntax:

  Results = TecUtil.ZoneGetStrandID(Zone)

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

See also:: TecUtilZoneGetSolutionTime()

ZoneType_e TecUtilZoneGetType ( EntIndex_t Zone )

Get the type of a specified zone in the data set attached to the current frame.

Parameters:

Zone

Number of the zone for which to get the zone type information

Returns:: The zone type.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilZoneGetType(Zone)
    INTEGER*4 Zone

Python Syntax:

  Results = TecUtil.ZoneGetType(Zone)

  Input:
                  Zone                 int
  Output:
    Results[0]    ReturnVal            ZoneType_e  (defined in TecVals.py)

Get the time of the first zone:

   ZoneType_e type = TecUtilZoneGetType(1);

UniqueID_t TecUtilZoneGetUniqueID ( EntIndex_t Zone )

Gets a unique ID for a zone.

A unique ID is an integer that uniquely identifies a zone. An addon can use these IDs to internally keep track of a set of zones. TecUtilZoneGetNumByUniqueID() can be used to convert between a unique ID and a zone number.

Parameters:

Zone

Zone number to query.

Returns:: A unique ID for a zone.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilZoneGetUniqueID(Zone)
    INTEGER*4 Zone

Python Syntax:

  Results = TecUtil.ZoneGetUniqueID(Zone)

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

Get the UniqueID for zone 1:

   {
     TecUtilLockStart(AddOnID);
     if ( TecUtilDataSetIsAvailable() && TecUtilZoneIsEnabled(1) )
       {
         UniqueID_t ID = TecUtilZoneGetUniqueID(1);
         ...
       }
     TecUtilLockFinish(AddOnID);
   }

Boolean_t TecUtilZoneIsActive ( EntIndex_t Zone )

Determine if a zone is active.

Returns:: Returns TRUE if the zone is active, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilZoneIsActive(Zone)
    INTEGER*4 Zone

Python Syntax:

  Results = TecUtil.ZoneIsActive(Zone)

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

Boolean_t TecUtilZoneIsEnabled ( EntIndex_t Zone )

Determine if a zone is enabled.

Parameters:

Zone

Number of the zone for which to get the zone type information

Returns:: TRUE, if a zone is enabled, otherwise, FALSE.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilZoneIsEnabled(Zone)
    INTEGER*4 Zone

Python Syntax:

  Results = TecUtil.ZoneIsEnabled(Zone)

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

Check if the first zone is enabled:

   if (TecUtilZoneIsEnabled(1))
   {
     // sure is!
   }

Boolean_t TecUtilZoneIsFiniteElement ( EntIndex_t Zone )

Determine if a zone in the data set attached to the current frame contains finite-element data.

Parameters:

Zone

Number of the zone for which to get the zone type information

Returns:: TRUE if the zone is a finite-element zone, FALSE if it is not.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilZoneIsFiniteElement(Zone)
    INTEGER*4 Zone

Python Syntax:

  Results = TecUtil.ZoneIsFiniteElement(Zone)

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

Check if the first zone is finite element:

   if (TecUtilZoneIsFiniteElement(1))
   {
     // sure is!
   }

Boolean_t TecUtilZoneIsOrdered ( EntIndex_t Zone )

Determine if the specified zone in the data set attached to the current frame contains ordered data.

Parameters:

Zone

Number of the zone for which to get the zone type information

Returns:: TRUE if the zone is an I-ordered, IJ-ordered, or IJK-ordered zone; FALSE if it is not.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilZoneIsOrdered(Zone)
    INTEGER*4 Zone

Python Syntax:

  Results = TecUtil.ZoneIsOrdered(Zone)

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

Check if the first zone is ordered:

   if (TecUtilZoneIsOrdered(1))
   {
     // sure is!
   }

Boolean_t TecUtilZoneRealloc	(	EntIndex_t	Zone,
		LgIndex_t	NewIMaxOrNumDataPoints,
		LgIndex_t	NewJMaxOrNumElements,
		LgIndex_t	NewKMax
	)

Reallocate the classic FE or ordered zone in the data set attached to the current frame.

This in effect re-dimensions the raw data referenced by the zone.

Data in the reallocated zone is preserved as much as possible. If the zone is reduced in size all field data should be preserved where like I,J,K subscripted locations in the old zone (using the old dimensions to calculate the offset) are copied to the same I,J,K subscripted locations in the new zone (using the new dimensions). If the dimensions of the zone are increased then the field data at subscripts beyond the original dimensions are initialized to zero.

If the zone is classic finite element and an element contains a point that is no longer available (because the zone was reduced in size) it is reset to the first point in the dataset. If the connectivity list is expanded then all nodes in the newly created elements will reference the first point in the dataset.

Note:: The preferred method of resizing a zone is to call TecUtilDataSetAddZoneX() using the zone number of the target zone to resize.

Parameters:

	Zone	One-based index of the zone to reallocate
	NewIMaxOrNumDataPoints	New IMax or number of data points
	NewJMaxOrNumElements	New JMax or number of elements
	NewKMax	New KMax

Returns:: TRUE if successful, FALSE otherwise.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilZoneRealloc(
   &                   Zone,
   &                   NewIMaxOrNumDataPoints,
   &                   NewJMaxOrNumElements,
   &                   NewKMax)
    INTEGER*4       Zone
    INTEGER*4       NewIMaxOrNumDataPoints
    INTEGER*4       NewJMaxOrNumElements
    INTEGER*4       NewKMax

Python Syntax:

  Results = TecUtil.ZoneRealloc(Zone, NewIMaxOrNumDataPoints, NewJMaxOrNumElements, NewKMax)

  Input:
                  Zone                 int
                  NewIMaxOrNumDataPoints int
                  NewJMaxOrNumElements int
                  NewKMax              int
  Output:
    Results[0]    ReturnVal            boolean

Reallocate the first zone:

   TecUtilZoneRealloc(1,15,4,1);

Boolean_t TecUtilZoneRename	(	EntIndex_t	Zone,
		const char *	ZoneName
	)

Rename a data set zone in Tecplot.

Parameters:

	Zone	The number of the zone to be renamed. The first zone in Tecplot is at position 1
	ZoneName	A string containing the new zone name. Must not be NULL

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilZoneRename(
   &                   Zone,
   &                   ZoneName)
    INTEGER*4       Zone
    CHARACTER*(*)   ZoneName

Python Syntax:

  Results = TecUtil.ZoneRename(Zone, ZoneName)

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

Rename the first zone:

   TecUtilZoneRename(1,"New Zone Name");

SetValueReturnCode_e TecUtilZoneSetActive	(	Set_pa	ZoneSet,
		AssignOp_e	AssignModifier
	)

Assign which zones are active.

Parameters:

	ZoneSet	Set of zones used to change the set of active zones. The way in which the active zones are changed is based on the AssignModifier. Must not be NULL.
	AssignModifier	The possible values are: AssignOp_Equals, AssignOp_PlusEquals, AssignOp_MinusEquals

Returns:: The setvalue return code (of type SetValueReturnCode_e).

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilZoneSetActive(
   &                   ZoneSetPtr,
   &                   AssignModifier)
    POINTER         (ZoneSetPtr, ZoneSet)
    INTEGER*4       AssignModifier

Python Syntax:

  Results = TecUtil.ZoneSetActive(ZoneSet, AssignModifier)

  Input:
                  ZoneSet              sequence of ints
                  AssignModifier       AssignOp_e  (defined in TecVals.py)
  Output:
    Results[0]    ReturnVal            SetValueReturnCode_e  (defined in TecVals.py)

Activate zone 3:

   Set_pa zone_set = TecUtilSetAlloc();
   TecUtilSetAddMember(zone_set, 3,TRUE);
   TecUtilZoneSetActive(zone_set, AssignOp_PlusEquals);
   TecUtilSetDealloc(&zone_set);

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

Deprecated:: Please use TecUtilZoneSetEdgeLayer() instead.

void TecUtilZoneSetBuildZoneOptInfo	(	EntIndex_t	Zone,
		Boolean_t	BuildZoneOptInfo
	)

Instruct Tecplot to either build or forgo building zone optimization information.

Zone optimization information enhances interactive performance but has an upfront performance cost. This function can be called any time after the zone has been created.

Parameters:

	Zone	Zone for which the decision to build zone optimization information needs changing.
	BuildZoneOptInfo	Indicates if Tecplot should build zone optimization if needed.

Fortran Syntax:

    SUBROUTINE TecUtilZoneSetBuildZoneOptInfo(
   &           Zone,
   &           BuildZoneOptInfo)
    INTEGER*4       Zone
    INTEGER*4       BuildZoneOptInfo

Python Syntax:

  Results = TecUtil.ZoneSetBuildZoneOptInfo(Zone, BuildZoneOptInfo)

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

See also:: TecUtilDataSetAddZoneX() allows you to create a zone with the appropriate setting.

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

Assign values to attributes for contour plots.

Parameters:

Attribute

Specify the attribute to change from the possible values found below:

        Attribute                  I or D Value     Notes
        -----------------------------------------------------------------
        SV_SHOW                         IValue      TRUE, FALSE
        SV_CONTOURTYPE                  IValue      ContourType_e
        SV_COLOR                        IValue      ColorIndex_t
        SV_FLOODCOLORING                IValue      ContourColoring_e
        SV_LINECONTOURGROUP             IValue      integer value 1 through 4
        SV_LINEPATTERN                  IValue      LinePattern_e
        SV_PATTERNLENGTH                DValue      Valid length
        SV_LINETHICKNESS                DValue      Valid thickness
        SV_USELIGHTINGEFFECT            IValue      TRUE, FALSE

Parameters:

	ZoneSet	Set of zones to operate on. Pass NULL to operate on all zones.
	DValue	If the attribute requires a floating point value, put that value in DValue, otherwise DValue is not used.
	IValue	If the attribute requires an integer, enumerated value, or a handle to a string then assigned it to the IValue parameter. Always typecast the IValue parameter to ArbParam_t

Returns:: The setvalue return code (of type SetValueReturnCode_e).

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilZoneSetContour(
   &                   Attribute,
   &                   ZoneSetPtr,
   &                   DValue,
   &                   IValuePtr)
    CHARACTER*(*)   Attribute
    POINTER         (ZoneSetPtr, ZoneSet)
    REAL*8          DValue
    POINTER         (IValuePtr, IValue)

Python Syntax:

  Results = TecUtil.ZoneSetContour(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)

Change the contour plot type to flood for the first zone:

   Set_pa set = TecUtilSetAlloc(FALSE);
   TecUtilSetAddMember(set,1,FALSE);
   TecUtilZoneSetContour(SV_CONTOURTYPE,set,0.0,
                         (ArbParam_t)Contour_Flood);
   TecUtilSetDealloc(&set);

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

Assign values to attributes for edge plots.

Parameters:

Attribute

Specify the attribute to change from the possible values found below:

        Attribute                  I or D Value     Notes
        -----------------------------------------------------------------
        SV_SHOW                    IValue          TRUE, FALSE
        SV_EDGETYPE                IValue          EdgeType_e
        SV_IBORDER                 IValue          BorderLocation_e
        SV_JBORDER                 IValue          BorderLocation_e
        SV_KBORDER                 IValue          BorderLocation_e
        SV_COLOR                   IValue          Valid color index.
        SV_LINETHICKNESS           DValue          Valid line thickness.

Parameters:

	ZoneSet	Set of zones to operate on. Pass NULL to operate on all zones
	DValue	If the attribute requires a floating point value then put that value in DValue, otherwise DValue is not used
	IValue	If the attribute requires an integer, enumerated value, or a handle to a string then assigned it to the IValue parameter. Always typecast the IValue parameter to ArbParam_t

Returns:: The setvalue return code (of type SetValueReturnCode_e).

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilZoneSetEdgeLayer(
   &                   Attribute,
   &                   ZoneSetPtr,
   &                   DValue,
   &                   IValuePtr)
    CHARACTER*(*)   Attribute
    POINTER         (ZoneSetPtr, ZoneSet)
    REAL*8          DValue
    POINTER         (IValuePtr, IValue)

Python Syntax:

  Results = TecUtil.ZoneSetEdgeLayer(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)

Set the line thickness for the first zone to 0.1:

   Set_pa set = TecUtilSetAlloc(FALSE);
   TecUtilSetAddMember(set,1,FALSE);
   TecUtilZoneSetEdgeLayer( SV_LINETHICKNESS,set,0.1,(ArbParam_t)NULL);
   TecUtilSetDealloc(&set);

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

Deprecated:: Please use TecUtilZoneSetVolumeMode() instead.

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

Assign values to attributes for mesh plots.

Parameters:

Attribute

Specify the attribute to change from the possible values found below:

        Attribute              Assign To    Value Notes
        ---------------------------------------------------------
        SV_SHOW                IValue       TRUE,FALSE
        SV_MESHTYPE            IValue       MeshType_e
        SV_COLOR               IValue       ColorIndex_t
        SV_LINEPATTERN         IValue       LinePattern_e
        SV_PATTERNLENGTH       DValue       Valid pattern length
        SV_LINETHICKNESS       DValue       Valid line thickness

Parameters:

	ZoneSet	Set of zones to operate on. Pass NULL to operate on all zones.
	DValue	If the attribute requires a floating point value then put that value in DValue, otherwise DValue is not used.
	IValue	If the attribute requires an integer, enumerated value, or a handle to a string then assigned it to the IValue parameter. Always typecast the IValue parameter to ArbParam_t

Returns:: The setvalue return code (of type SetValueReturnCode_e).

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilZoneSetMesh(
   &                   Attribute,
   &                   ZoneSetPtr,
   &                   DValue,
   &                   IValuePtr)
    CHARACTER*(*)   Attribute
    POINTER         (ZoneSetPtr, ZoneSet)
    REAL*8          DValue
    POINTER         (IValuePtr, IValue)

Python Syntax:

  Results = TecUtil.ZoneSetMesh(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)

Set the mesh color for all zones to be red:

   TecUtilZoneSetMesh(SV_Color,NULL,0.0,(ArbParam_t)Blue_C);

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

Assign top level values to attributes for scatter plots.

Parameters:

Attribute

Specify the attribute to change from the possible values found below:

        Attribute              Assign To    Value Notes
        ---------------------------------------------------------
        SV_SHOW                IValue       TRUE,FALSE
        SV_COLOR               IValue       ColorIndex_t
        SV_ISFILLED            IValue       TRUE,FALSE
        SV_FILLMODE            IValue       FillMode_e
        SV_FILLCOLOR           IValue       ColorIndex_t
        SV_SIZEBYVARIABLE      IValue       TRUE,FALSE
        SV_FRAMESIZE           DValue       0.0-100.0
        SV_LINETHICKNESS       DValue       0.001-100.0

Parameters:

	ZoneSet	Set of zones to operate on. Pass NULL to operate on all zones
	DValue	If the attribute requires a double value then assigned it to the DValue parameter.
	IValue	If the attribute requires an integer, enumerated value, or a handle to a string then assigned it to the IValue parameter. Always typecast the IValue parameter to ArbParam_t

Returns:: The setvalue return code (of type SetValueReturnCode_e).

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilZoneSetScatter(
   &                   Attribute,
   &                   ZoneSetPtr,
   &                   DValue,
   &                   IValuePtr)
    CHARACTER*(*)   Attribute
    POINTER         (ZoneSetPtr, ZoneSet)
    REAL*8          DValue
    POINTER         (IValuePtr, IValue)

Python Syntax:

  Results = TecUtil.ZoneSetScatter(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)

Set scatter line thickness for all zones to 0.1:

   TecUtilZoneSetScatter(SV_LINETHICKNESS,NULL,0.1,(ArbParam_t)0);

SetValueReturnCode_e TecUtilZoneSetScatterIJKSkip	(	const char *	Attribute,
		Set_pa	ZoneSet,
		LgIndex_t	Skip
	)

Set the scatter I-, J-, or K-skipping.

Parameters:

	Attribute	Specify the attribute (in this case, I-, J-, or K-skip) to change. The possible values are SV_I, SV_J, or SV_K.
	ZoneSet	Set of zones to operate on. Pass NULL to operate on all zones.
	Skip	The scatter skip value to assign.

Returns:: The setvalue return code (of type SetValueReturnCode_e).

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilZoneSetScatterIJKSkip(
   &                   Attribute,
   &                   ZoneSetPtr,
   &                   Skip)
    CHARACTER*(*)   Attribute
    POINTER         (ZoneSetPtr, ZoneSet)
    INTEGER*4       Skip

Python Syntax:

  Results = TecUtil.ZoneSetScatterIJKSkip(Attribute, ZoneSet, Skip)

  Input:
                  Attribute            string
                  ZoneSet              sequence of ints
                  Skip                 int
  Output:
    Results[0]    ReturnVal            SetValueReturnCode_e  (defined in TecVals.py)

Set the scatter I-skip to two for all zones:

   TecUtilZoneSetScatterIJKSkip(SV_I,NULL,(ArbParam_t)2);

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

Assign values for the symbol shape in scatter plots.

Parameters:

Attribute

Specify the attribute to change from the possible values found below:

        Attribute              Assign To    Value Notes
        ---------------------------------------------------------
        SV_ISASCII             IValue       TRUE,FALSE
        SV_GEOMSHAPE           IValue       GeomShape_e
        SV_ASCIICHAR           IValue       Character string.  Must
                                            be a single character (like "A").

Parameters:

	ZoneSet	Set of zones to operate on. Pass NULL to operate on all zones
	IValue	If the attribute requires an integer, enumerated value, or a handle to a string then assigned it to the IValue parameter. Always typecast the IValue parameter to ArbParam_t

Returns:: The setvalue return code (of type SetValueReturnCode_e).

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilZoneSetScatterSymbolShap(
   &                   Attribute,
   &                   ZoneSetPtr,
   &                   IValuePtr)
    CHARACTER*(*)   Attribute
    POINTER         (ZoneSetPtr, ZoneSet)
    POINTER         (IValuePtr, IValue)

Python Syntax:

  Results = TecUtil.ZoneSetScatterSymbolShape(Attribute, ZoneSet, IValue)

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

Note:: IMPORTANT! Note that the FORTRAN Name for this function is truncated to 31 characters!

Set the scatter symbol shape to squares for all zones:

   TecUtilZoneSetScatterSymbolShape(SV_ISASCII,NULL,
                                    (ArbParam_t)FALSE);
   TecUtilZoneSetScatterSymbolShape(SV_GEOMSHAPE,NULL,
                                    (ArbParam_t)GeomShape_Square);

SetValueReturnCode_e TecUtilZoneSetStrandID	(	EntIndex_t	Zone,
		Strand_t	StrandID
	)

Sets the StrandID associated with the specified zone.

Data loader add-ons should specify the strand ID when creating the zone by using TecUtilAddZoneX().

Since:: 11.2-0-452

Parameters:

	Zone	A zone number for a currently enabled zone.
	StrandID	The strand ID to assign. Use STRAND_ID_STATIC to specify the zone as static (non-transient). Values greater than zero are used to associate zones with a particular strand.

Fortran Syntax:

    INTEGER*4 FUNCTION TecUtilZoneSetStrandID(
   &                   Zone,
   &                   StrandID)
    INTEGER*4       Zone
    INTEGER*4       StrandID

Python Syntax:

  Results = TecUtil.ZoneSetStrandID(Zone, StrandID)

  Input:
                  Zone                 int
                  StrandID             int
  Output:
    Results[0]    ReturnVal            SetValueReturnCode_e  (defined in TecVals.py)

See also:: TecUtilZoneSetSolutionTime()
TecUtilZoneGetStrandID()

Data Services

Functions

Function Documentation