Data Manipulation


Functions

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.
Boolean_t TecUtilDataAlterX (ArgList_pa ArgList)
  Operates on a data set within Tecplot using FORTRAN-like equations.
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.
Boolean_t TecUtilPolarToRectangular (Set_pa ZoneSet)
 
Boolean_t TecUtilFourierTransform (EntIndex_t independentVar, WindowFunction_e windowFunction, Set_pa dependentVars, Set_pa sourceZones, Boolean_t includeConjugates, Boolean_t obeySourceZoneBlanking)
  Performs a Fourier transform for each dependent variable for each source zone.
Boolean_t TecUtilFourierTransformX (ArgList_pa ArgList)
  Performs a Fourier transform for each dependent variable for each source zone.
Boolean_t TecUtilTransformCoordinatesX (ArgList_pa ArgList)
  Transform Coordinates.
Boolean_t TecUtilDataRotate2D (Set_pa ZoneSet, double RotateAmountInDegrees, double XOrigin, double YOrigin)
  Rotate field data in 2-D about any point.
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.
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.
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.
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.
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.

Function Documentation

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:

  1. Determine which variables are cell-centered values in your data.
  2. 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).
  3. 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.
Precondition:
ZoneSet Pointer must be a valid address or NULL.

VarSet Pointer must be a valid address or NULL.

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

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. For nodal finite-element data, the starting node index on which to operate. Not used for finite-element cell-centered data.
IMax Operate on values ending at an I-Index range of IMax. Set to 0 to specify the maximum I index. Not used for finite-element cell-centered data.
ISkip Operate on values skipping by ISkip in the I-Direction. Set to 0 to specify one less than the maximum I index range. Not used for finite-element cell-centered data.
JMin Operate on values starting at an J-Index range of JMin. Set to 1 when operating on the entire range. For cell-centered finite-element data, the starting cell index on which to operate. Not used for finite-element nodal data.
JMax See IMax. Not used for finite-element nodal data.
JSkip See ISkip. Not used for finite-element nodal data.
KMin See IMin. Not used for finite-element data.
KMax See IMax. Not used for finite-element data.
KSkip See ISkip. Not used for finite-element data.
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.
Precondition:
Must have one or more frames.

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

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

ZoneSet Pointer must be a valid address or NULL.

I range arguments (IMin, IMax, ISkip) must be within range -MAXINDEX ... MAXINDEX.

J range arguments (JMin, JMax, JSkip) must be within range -MAXINDEX ... MAXINDEX.

K range arguments (KMin, KMax, KSkip) must be within range -MAXINDEX ... MAXINDEX.

DestDataType Must specify a valid data type.

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

See also:
TecUtilDataAlterX

Boolean_t TecUtilDataAlterX ( ArgList_pa  ArgList  ) 

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:
ArgList Set of Arglist entries. This is built using calls to TecUtilArgListAppendXXXX functions.

Arglist Values

SV_EQUATION
Type: const char *
Arg Function: TecUtilArgListAppendString()
Required: Yes
Notes: String containing the equation.

SV_ZONESET
Type: Set_pa
Arg Function: TecUtilArgListAppendSet()
Default: NULL
Required: No
Notes: Set of zones to operate on. If the zone set is not specified, the equation will be applied to all zones.

SV_IMIN
Type: LgIndex_t
Arg Function: TecUtilArgListAppendInt()
Default: 1
Required: No
Notes: Operate on values starting at an I-Index range of IMin. Set to 1 when operating on the entire range. For nodal finite-element data, the starting node index on which to operate. Not used for finite-element cell-centered data.

SV_JMIN
Type: LgIndex_t
Arg Function: TecUtilArgListAppendInt()
Default: 1
Required: No
Notes: Operate on values starting at an J-Index range of JMin. Set to 1 when operating on the entire range. For cell-centered finite-element data, the starting cell index on which to operate. Not used for finite-element nodal data.

SV_KMIN
Type: LgIndex_t
Arg Function: TecUtilArgListAppendInt()
Default: 1
Required: No
Notes: See IMin. Not used for finite-element data.

SV_IMAX
Type: LgIndex_t
Arg Function: TecUtilArgListAppendInt()
Default: 0 (Mx)
Required: No
Notes: Operate on values ending at an I-Index range of IMax. Set to 0 to specify the maximum I index. Not used for finite-element cell-centered data.

SV_JMAX
Type: LgIndex_t
Arg Function: TecUtilArgListAppendInt()
Default: 0 (Mx)
Required: No
Notes: See IMax. Not used for finite-element nodal data.

SV_KMAX
Type: LgIndex_t
Arg Function: TecUtilArgListAppendInt()
Default: 0 (Mx)
Required: No
Notes: See IMax. Not used for finite-element data.

SV_ISKIP
Type: LgIndex_t
Arg Function: TecUtilArgListAppendInt()
Default: 1
Required: No
Notes: Operate on values skipping by ISkip in the I-Direction. Set to 0 to specify one less than the maximum I index range. Not used for finite-element cell-centered data.

SV_JSKIP
Type: LgIndex_t
Arg Function: TecUtilArgListAppendInt()
Default: 1
Required: No
Notes: See ISkip. Not used for finite-element nodal data.

SV_KSKIP
Type: LgIndex_t
Arg Function: TecUtilArgListAppendInt()
Default: 1
Required: No
Notes: See ISkip. Not used for finite-element nodal data.

SV_VALUELOCATION
Type: ValueLocation_e
Arg Function: TecUtilArgListAppendInt()
Default: Auto
Required: No
Notes: Variable value location for the variable on the left hand side. This is used only if this variable is being created for the first time. If unspecified, Tecplot will choose the location for you.

SV_VARDATATYPE
Type: FieldDataType_e
Arg Function: TecUtilArgListAppendInt()
Default: Auto
Required: No
Notes: Data type for the variable on the left hand side. This is used only if this variable is being created for the first time. If unspecified, Tecplot will choose the type for you.

SV_IGNOREDIVIDEBYZERO
Type: Boolean_t
Arg Function: TecUtilArgListAppendInt()
Default: FALSE
Required: No
Notes: Boolean value which instructs Tecplot to ignore divide by zero errors. The result is clamped such that 0/0 is clamped to zero and (+/-N)/0 where N != 0 clamps to +/-maximum value for the given type.


Returns:
TRUE if successful, FALSE otherwise.
Fortran Syntax:
    INTEGER*4 FUNCTION TecUtilDataAlterX(ArgListPtr)
    POINTER (ArgListPtr, ArgList)

Python Syntax:

  Results = TecUtil.DataAlterX(ArgList)

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

See also:
TecUtilDataAlter

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.
Precondition:
Must have one or more frames.

ZoneSet Pointer must be a valid address or NULL.

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 TecUtilFourierTransform ( EntIndex_t  independentVar,
WindowFunction_e  windowFunction,
Set_pa  dependentVars,
Set_pa  sourceZones,
Boolean_t  includeConjugates,
Boolean_t  obeySourceZoneBlanking 
)

Performs a Fourier transform for each dependent variable for each source zone.

A new zone containing the resulting frequency, amplitude, and phase variables (three for each dependent variable) is created for each source zone. If the independent variable is non-uniform the resulting frequency is a modification of the original data (see discussion below for the independentVar and obeySourceZoneBlanking parameters). Resulting zones are assigned new time strands using the same groupings as the source zones if they belong to time stands, otherwise the resulting zones are made static.

Zones created by the Fourier transform are added with the name "Fourier Transform" followed by the source zone name in parenthesis. Similarly, the three variables created are added with the names, "Frequency", "Amplitude", and "Phase". The frequency variable name is followed by the independent variable name in parenthesis to the -1 power. The amplitude variable name is followed by the dependent variable name in parenthesis. Newly created zones are assigned passive variables for all variables that previously existed in the dataset and all previously existing zones are assigned passive variables for all new variables created by the Fourier transform.

Parameters:
independentVar Independent variable used as the frequency domain. If the spacing is non-uniform this variable is used in conjunction with each dependent variable for interpolation to create a uniform frequency for the Fourier transform.
windowFunction Window function or tapering function applied to the dependent data before performing the Fourier transform but after performing the non-uniform interpolation. For details see http://en.wikipedia.org/wiki/Window_function
dependentVars Set of dependent variables on which to perform a Fourier transform. The variables must not be the same as the independent variable. This must not be NULL or an empty set and must be a sub-set of Tecplot's variables.
sourceZones Set of source zones containing the dependent variables on which to perform the Fourier transform. This must not be NULL or an empty set and must be a sub-set of Tecplot's zones.
includeConjugates For purely real numbers the Fourier transform output satisfies the "Hermitian" redundancy where out[i] is the conjugate of out[n-i]. If includeConjugates is TRUE the conjugates are included otherwise they are not and approximately half of the output values, n/2+1, is computed.
obeySourceZoneBlanking If value blanking is active and this value is TRUE, value blanking is applied to the data values of both the independent and dependent variables before the data is interpolated for non-uniformity. If data values eliminated from the independent or dependent variables cause the data to be non-uniform the values are interpolated appropriately. Additionally, all blanked data values up to the first non-blanked data value and all blanked data values after the last non-blanked data value are ignored, providing a mechanism to constrain the domain over which the Fourier transformation is performed.
Returns:
TRUE if the Fourier transform succeeded, FALSE otherwise.
Precondition:
Current frame must have a data set with at least one zone.

independentVar Must specify a valid variable.

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

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

includeConjugates Value must be TRUE or FALSE.

obeySourceZoneBlanking Value must be TRUE or FALSE.

Since:
13.0.0.14113
See also:
TecUtilFourierTransformX
Python Syntax:
  Results = TecUtil.FourierTransform(independentVar, windowFunction, dependentVars, sourceZones, includeConjugates, obeySourceZoneBlanking)

  Input:
                  independentVar       int
                  windowFunction       WindowFunction_e  (defined in TecVals.py)
                  dependentVars        sequence of ints
                  sourceZones          sequence of ints
                  includeConjugates    boolean
                  obeySourceZoneBlanking boolean
  Output:
    Results[0]    ReturnVal            boolean

Boolean_t TecUtilFourierTransformX ( ArgList_pa  ArgList  ) 

Performs a Fourier transform for each dependent variable for each source zone.

A new zone containing the resulting frequency, amplitude, and phase variables (three for each dependent variable) is created for each source zone. If the user instructs to replace zones and/or variables, the ones created by the latest Fourier trasform will be used. If the independent variable is non-uniform the resulting frequency is a modification of the original data (see discussion below for the independentVar and obeySourceZoneBlanking parameters). Resulting zones are assigned new time strands using the same groupings as the source zones if they belong to time stands, otherwise the resulting zones are made static.

Zones created by the Fourier transform are added with the name "Fourier Transform" followed by the source zone name in parenthesis. Similarly, the three variables created are added with the names, "Frequency", "Amplitude", and "Phase". The frequency variable name is followed by the independent variable name in parenthesis to the -1 power. The amplitude variable name is followed by the dependent variable name in parenthesis. Newly created zones are assigned passive variables for all variables that previously existed in the dataset and all previously existing zones are assigned passive variables for all new variables created by the Fourier transform.

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

Arglist Values

SV_INDEPENDENTVAR
Type: EntIndex_t
Arg Function: TecUtilArgListAppendInt()
Required: Yes
Notes: Associated value is the independent variable used as the frequency domain. If the spacing is non-uniform this variable is used in conjunction with each dependent variable for interpolation to create a uniform frequency for the Fourier transform.

SV_WINDOWFUNCTION
Type: WindowFunction_e
Arg Function: TecUtilArgListAppendInt()
Default: WindowFunction_Rectangular
Required: No
Notes: Associated value indicates window function or tapering function applied to the dependent data before performing the Fourier transform but after performing the non-uniform interpolation. For details see http://en.wikipedia.org/wiki/Window_function

SV_DEPENDENTVARS
Type: Set_pa
Arg Function: TecUtilArgListAppendSet()
Required: Yes
Notes: Associated value contains the set of dependent variables on which to perform a Fourier transform. The variables must not be the same as the independent variable. This must not be NULL or an empty set and must be a sub-set of Tecplot's variables.

SV_SOURCEZONES
Type: Set_pa
Arg Function: TecUtilArgListAppendSet()
Required: Yes
Notes: Associated value contains the set of source zones containing the dependent variables on which to perform the Fourier transform. This must not be NULL or an empty set and must be a sub-set of Tecplot's zones.

SV_INCLUDECONJUGATES
Type: Boolean_t
Arg Function: TecUtilArgListAppendInt()
Default: TRUE
Required: No
Notes: For purely real numbers the Fourier transform output satisfies the "Hermitian" redundancy where out[i] is the conjugate of out[n-i]. If includeConjugates is TRUE the conjugates are included otherwise they are not and approximately half of the output values, n/2+1, is computed.

SV_OBEYSOURCEZONEBLANKING
Type: Boolean_t
Arg Function: TecUtilArgListAppendInt()
Default: FALSE
Required: No
Notes: If value blanking is active and this value is TRUE, value blanking is applied to the data values of both the independent and dependent variables before the data is interpolated for non-uniformity. If data values eliminated from the independent or dependent variables cause the data to be non-uniform the values are interpolated appropriately. Additionally, all blanked data values up to the first non-blanked data value and all blanked data values after the last non-blanked data value are ignored, providing a mechanism to constrain the domain over which the Fourier transformation is performed.

SV_REPLACEMATHINGRESULTZONES
Type: Boolean_t
Arg Function: TecUtilArgListAppendInt()
Default: TRUE
Required: No
Notes: If this value is TRUE, then the zones created by the latest Fourier transform will be reused. If no zones have been created previously, then this setting is disregarded and new zones are created.

SV_REPLACEMATHINGRESULTVARIABLES
Type: Boolean_t
Arg Function: TecUtilArgListAppendInt()
Default: TRUE
Required: No
Notes: If this value is TRUE, then the variables created by the latest Fourier transform will be reused. If no variables have been created previously, then this setting is disregarded and new variables are created.


Returns:
TRUE if successful, FALSE otherwise.
Precondition:
Must have one or more pages.

ArgList Argument list must be valid.

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

VarIsValid(independentVar) Must specify a valid variable.

VALID_REF(dependentVars) Pointer must be a valid address and non-NULL.

VALID_REF(sourceZones) Pointer must be a valid address and non-NULL.

VALID_BOOLEAN(includeConjugates) Value must be TRUE or FALSE.

VALID_BOOLEAN(obeySourceZoneBlanking) Value must be TRUE or FALSE.

VALID_BOOLEAN(replaceMatchingResultZones) Value must be TRUE or FALSE.

VALID_BOOLEAN(replaceMatchingResultVariables) Value must be TRUE or FALSE.

Since:
13.0.0.15770
See also:
TecUtilFourierTransform
Python Syntax:
  Results = TecUtil.FourierTransformX(ArgList)

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

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.
Precondition:
Must have one or more frames.

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

SourceZones Pointer must be a valid address or NULL.

IMPLICATION(VarSet != NULL,VALID_REF(VarSet)) Pointer must be a valid address or NULL.

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.
Precondition:
Must have one or more frames.

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

SourceZones Pointer must be a valid address or NULL.

IMPLICATION(VarSet != NULL,VALID_REF(VarSet)) Pointer must be a valid address or NULL.

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.
Precondition:
Must have one or more frames.

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

SourceZones Pointer must be a valid address or NULL.

IMPLICATION(VarSet != NULL,VALID_REF(VarSet)) Pointer must be a valid address or NULL.

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

Boolean_t TecUtilPolarToRectangular ( Set_pa  ZoneSet  ) 

Deprecated:
Please use TecUtilTransformCoordinatesX() instead.

Python Syntax:

  Results = TecUtil.PolarToRectangular(ZoneSet)

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

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.
Precondition:
Must have one or more frames.

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

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

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_ZONELIST
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.
Precondition:
ArgList Argument list must be valid.

Must have one or more frames.

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

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.

   TecUtilLockStart(AddOnID);
   ArgList_pa ArgList;
   Set_pa ZoneSet = TecUtilSetAlloc(TRUE);
   TecUtilSetAddMember(ZoneSet, 1, TRUE);

   ArgList = TecUtilArgListAlloc();
   TecUtilArgListAppendInt(ArgList, SV_THETAVAR,       1);
   TecUtilArgListAppendInt(ArgList, SV_RVAR,           2);
   TecUtilArgListAppendInt(ArgList, SV_PSIVAR,         3);
   TecUtilArgListAppendInt(ArgList, SV_XVAR,           4);
   TecUtilArgListAppendInt(ArgList, SV_YVAR,           5);
   TecUtilArgListAppendInt(ArgList, SV_ZVAR,           6);
   TecUtilArgListAppendSet(ArgList, SV_ZONELIST,       ZoneSet);
   TecUtilArgListAppendInt(ArgList, SV_ANGLESPEC,      ThetaMode_Arbitrary);
   TecUtilArgListAppendInt(ArgList, SV_TRANSFORMATION, 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
Precondition:
SourceZones Pointer must be a valid address or NULL.

BoundaryZones Pointer must be a valid address or NULL.

NumCoincidentPts Pointer must be a valid address or NULL.

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

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