For the most part these VIDF fields set limits for some of the UDF header and data record array sizes, give details on timing within array data and give information on the UDF fill data value which may be used in the the UDF data records to flag bad data. All of these fields are used by the UDF kernel software in establishing data access and data timing.
This is a scalar field which specifies the maximum length of an a array sensor or the maximum number of rows in a matrix sensor. This does not define the array or row length that is actually returned in the data but only the maximum that might be returned. The UDF kernel uses this value to determine the number of elements to retrieve from lookup tables which are being used to modify the array indices returned in the UDF header Array Index field.
NOTE: If the VIDF data storage format field is set to 1 (scalar), then the Maximum Sweep Length must be set to 1.The field begins with the line format id s followed by an integer specifying maximum array length. An optional comment field may follow. The maximum array size cannot exceed 32767.
Sample MAXIMUM SENSOR ARRAY SIZE field:s 256 /* Maximum Sen Array Size */
A scalar field, this field contains the maximum number of sensor sets which can exist in a data record. This value determines the size of the fixed array of header offsets in the UDF data record and is used by the UDF kernel software in determining the byte offset to the UDF data area in the UDF data record. A data record does not need to make use all of the possible sensor sets in filling its data area but header offsets field is dimensioned to be able to contain the offsets for the maximum number provided.
The field should be set to 1 for UDF definitions in which the data records make exclusive use of the negative number of sensor sets feature - that is where there is only a single header offset which is valid for all sensor sets are defined in the data record.
The field begins with the line format id s followed by an integer specifying maximum number of sensor sets. An optional comment field may follow. The maximum number of sensor sets cannot exceed 32767.
Sample MAXIMUM SENSOR SET SIZE field:s 256 /* Maximum Sen Array Size */
This is a scalar field containing the byte size of the UDF data record. The UDF data record is fixed in length for any individual UDF definition. The value is used in the UDF kernel when parsing the UDF data file and in establishing some memory blocks.
The field begins with the line format id l followed by an integer specifying data record size in bytes. An optional comment field may follow.
Sample DATA RECORD BYTE SIZE field:l 1456 /* Record Length */
This is a scalar field whose contents specify whether there is a defined fill value for the UDF. If a fill value definition exists this field is set to 1 and the fill value is given in the next VIDF field. If no fill value exists, this VIDF field is set to 0 and the following field is set to a null.
The field begins with the line format id b followed by an integer specifying if a fill value has been defined. An optional comment field may follow.
Sample FILL VALUE DEFINED field:b 0 /* Fill Value Defined (No) */
A scalar field which contains the fill data value used in the UDF definition. The field is defined only if the VIDF fill value defined field has been set to 1. If there is no defined fill value then this field is undefined and is entered in the VIDF as a null line.
The UDF kernel does not make direct usage of the fill value field. The convert_to_units routine does allow for a fill value to be used to filter the data. This is an input value and programs my obtain the UDF defined fill value by querying this field in the VIDF.
When the fill value is defined, the VIDF field consists of the line format id l followed by the integer fill value. An optional comment field may follow.
Sample FILL VALUE field:l 1023 /* Fill Value */
This is a scalar field used by the UDF kernel software to select the timing algorithm to use when computing the starting and ending time of array elements within array or matrix sensors. (See the VIDF data storage format field for definitions of sensor designations). If the UDF sensors are scalar sensors then the field has no meaning and should be set to 0.
The recognized field values are shown in the table below and will be discussed in detail later in this section.
| ARRAY TIMING DEFINITIONS | ||
|---|---|---|
| VALUE | DEFINITION | |
| 0 | Continuous Time Flow | |
| 1 | Full Discontinuous Time Flow | |
| 2 | Partial Discontinuous Time Flow | |
| 3 | Blocked Time Flow | |
The field begins with the line format id b followed by the integer array timing format. An optional comment field may follow.
Sample ARRAY TIMING FORMAT field:b 0 /* Timing Method (Accum + Lat) */
The timing algorithms which compute the start and stop times of the elements in a UDF data array make use of several fields in the UDF header record. These fields with abbreviated definitions are shown in the table below.
| IMPORTANT HEADER RECORD FIELDS | |
|---|---|
| FIELD | DEFINITION |
| DataAccum | The time during which a measurement occurs. |
| DataLat | The dead time between successive measurements. |
| NSamples | The current array length of the sensor. |
| ArrayIndex | An integer array of the returned array elements. |
Each element in the data array is acquired within the time given in the header field DataAccum. The time between successive elements in the array is computed as:
dT = DataAccum + DataLat
For a sequentially acquired array the beginning time of any array element N is given by:
TN = T0 + N * dTwhere T0 is the beginning time of the first array element. NOTE: The above algorithm does not depend on which array elements are being returned but only on the index number into the array. Discontinuities in the array elements which would be indicated in the ArrayIndex field do not come into play here.
The total time spanned by the array (start to finish) is given by:
Tarray = NSamples * dT
Each element in a data array is acquired within the time given in the header field DataAccum. The time between successive elements in the array is computed as
dT = DataAccum + DataLat
For a sequentially acquired array the beginning time of any array element N is given by:
TN = T0 + ArrayIndex[N] * dT
where T0 is the beginning time of the first array element.
The difference between this timing definition and that presented in timing definition 0 is that in this definition it is assumed that all possible array elements have been acquired but that only a subset of them have been returned. The array elements not returned form an effective dead time or additional data latency between the returned elements.
The total time spanned by the array (start to finish) is given by:
Tarray = MaxArrayLen * dT
where MaxArrayLen is the value returned in the VIDF
maximum data array size field.
This definition is identical to that used in timing format 1 with the exception that the time duration of a complete data array lasts only from the first to last array element in the ArrayIndex array.
As in the case of timing format 1 the time between successive elements in the array is computed as:
dT = DataAccum + DataLat
For a sequentially acquired array the beginning time of any array element N is again given by:
TN = T0 + ArrayIndex[N] * dT
where T0 is the beginning time of the first array element.
The total array acquisition time of the array, however, now becomes:
Tarray = [ArrayIndex[NSamples-1] - ArrayIndex[0] + 1] * dT
This timing format is restricted to array sensors whose elements are evenly spaced within the total number of array elements available which is equivalent to requiring that each element in the ArrayIndex array be able to be determined from the first by an algorithm of the form:
ArrayIndex[J] = J * SKIP + ArrayIndex[0]
Basically this timing format is identical to that used for array timing format 0 but with a different definition of dT. In this algorithm each element in the array is acquired within the time DataAccum * SKIP. SKIP is computed as:
SKIP = ArrayIndex[1] - ArrayIndex[0]The time between successive elements is then given by given
dT = SKIP * DataAccum + DataLatNOTE: The data latency is only included once per array element. The returned element is assumed to constitute a single measurement and not one formed by the average of the individual elements between returned elements.
For a sequentially acquired array the beginning time of any array element N is given by:
TN = T0 + N * dTwhere T0 is the beginning time of the first array element.
The total time of the array (start to finish) is given by:
Tarray = N * dT