PIDF ARRAY INDEX DEFINITION BLOCK

The PIDF array index data block contains the descriptions of the array indices associated with VIDF array and matrix sensor measurements. The array index definitions are used primarily by GUI applications to obtain the unit definitions associated with the array indices. Information is also provided on the computation of the bin edges of the array elements assuming that each element has some physical width associated with it.

Historically the measurement array indices data have been referred to as scan indices. This arose from the fact that the first UDF array measurements were generally from instruments which scanned through a range of parameters. In this document array is substituted for scan (except in field and structure names) as being more descriptive of the UDF measurement.

The UDF makes a tacit assumption that in an array of measurement each of the array elements has associated with it an inherent width. This is a range of values over which the measurement is valid. One of the primary functions of the array index block is to provide information on computing the upper and lower edges associated with each array element.

A PIDF array index definition block consists of a single field which gives the number of array index definition structures followed by the individual structures themselves, each of which contains one array index definition. A PIDF array index definition block has the generalized form:

int num_scan = ENTRY;
struct ScanN {
   int    scan_block_num = Entry;
   int    num_units = Entry;
   struct ScanUnitM {
      char spacing = 'Entry';
      int  units_index = Entry;
      char bin_location = 'Entry';
      int  var_units = Entry;
   };
};

KEYWORD: num_scan

The number of array index definition structures in the PIDF. If there are no array index definition structures listed in the PIDF then this field should be set to 0. The num_scan field can be placed anywhere within the overall PIDF file above the first Scan structure definition and external to any internal PIDF structures. It is an int field.

KEYWORD: scan_block_num

The number of the Scan structure. This is an int field which must be present in the structure.

KEYWORD: num_units

The number of ScanUnit structures defined under the Scan structure. The entry cannot be 0. Each physical unit definition defines the necessary PIDF unit definitions needed to convert the scan index data into physical units.

This is an int field which must be present in the structure.

KEYWORD: units_index

The structure number of one of the PIDF unit definitions. This provides the information to take the raw array index values into one of the unit definitions provided for it. These values represent center bin values unless the spacing field has been set to 'V' in which case the relationship between the values and the array bins must be obtained from the bin_location field

This is an int field of which at least one instance must be present in the structure.

KEYWORD: spacing

The spacing between the array elements after conversion into physical units. This field is used to in the computation of the edges of the array bins. The recognized field entries are:

This is an char field which must be present in the structure.

KEYWORD: bin_location

The position of the array index values provided through units_index relative to the array bin. This field only has meaning if the spacing field has been set to 'V'. Recognized options are:

This is a char field.

KEYWORD: var_units

The structure number of one of the PIDF unit definitions. This unit definition converts the array indices into bin widths. The field only has meaning if the spacing field has been set to 'V'. The bin widths are used in conjunction with the values produced from the application of the unit_index unit definition to compute the bin edges.

EXAMPLES

The following are examples of fully functional PIDF array index block definitions. The entries are shown within the overall PIDF definition braces which would occur only once within the PIDF file.

EXAMPLE 1

pidf v2_IMLIMAGE {
$*********************************************************************
    int num_scan = 2;                               $$ no. scan blocks
    struct Scan0 {
$----------------------SCAN BLOCK 00----------------------------------
        int scan_block_num = 0;                     $$ scan block no.
        int num_units = 5;                          $$ no. scan units
        struct ScanUnit0 {
            char spacing = 'I';                     $$ linear
            int units_index = 1;                    $$ raw sweep
        };
        struct ScanUnit1 {
            char spacing = 'L';                     $$ log
            int units_index = 3;                    $$ center energy
        };
        struct ScanUnit2 {
            char spacing = 'L';                     $$ log
            int units_index = 5;                    $$ lower edge
        };
        struct ScanUnit3 {
            char spacing = 'L';                     $$ log
            int units_index = 7;                    $$ upper edge
        };
        struct ScanUnit4 {
            char spacing = 'V';                     $$ variable
            int units_index = 5;                    $$ lower 
            int bin_location = L;                   $$ center 
            int var_units = 9;                      $$ widths 
        };
    };
    struct Scan1 {
$----------------------SCAN BLOCK 01----------------------------------
        int scan_block_num = 1;                     $$ scan block no.
        int num_units = 5;                          $$ no. scan units
        struct ScanUnit0 {
            char spacing = 'I';                     $$ linear
            int units_index = 1;                    $$ raw sweep
        };
        struct ScanUnit1 {
            char spacing = 'L';                     $$ log
            int units_index = 4;                    $$ center energy
        };
        struct ScanUnit2 {
            char spacing = 'L';                     $$ log
            int units_index = 6;                    $$ lower edge
        };
        struct ScanUnit3 {
            char spacing = 'L';                     $$ log
            int units_index = 8;                    $$ upper edge
        };
        struct ScanUnit4 {
            char spacing = 'V';                     $$ variable
            int units_index = 6;                    $$ lower 
            int bin_location = L;                   $$ center 
            int var_units = 9;                      $$ widths 
        };
    };
$*********************************************************************
};

EXAMPLE 2

pidf v2_IMES0IMG {
$*********************************************************************
    int num_scan = 1;                                     $$ no. of scan blocks
    struct Scan0 {
$----------------------SCAN BLOCK 00----------------------------------
        int scan_block_num = 0;                           $$ scan block number
        int num_units = 1;                                $$ no. scan of units
        struct ScanUnit0 {
            char spacing = 'I';                           $$ raw sweep
            int units_index = 1;                          $$ raw sweep
        };
    };
$*********************************************************************
};