Provided by: libfuntools-dev_1.4.7-4_amd64 bug

NAME

       FunColumnSelect - select Funtools columns

SYNOPSIS

         #include <funtools.h>

         int FunColumnSelect(Fun fun, int size, char *plist,
                             char *name1, char *type1, char *mode1, int offset1,
                             char *name2, char *type2, char *mode2, int offset2,
                             ...,
                             NULL)

         int FunColumnSelectArr(Fun fun, int size, char *plist,
                                char **names, char **types, char **modes,
                                int *offsets, int nargs);

DESCRIPTION

       The FunColumnSelect() routine is used to select the columns from a Funtools binary table
       extension or raw event file for processing. This routine allows you to specify how columns
       in a file are to be read into a user record structure or written from a user record
       structure to an output FITS file.

       The first argument is the Fun handle associated with this set of columns. The second
       argument specifies the size of the user record structure into which columns will be read.
       Typically, the sizeof() macro is used to specify the size of a record structure.  The
       third argument allows you to specify keyword directives for the selection and is described
       in more detail below.

       Following the first three required arguments is a variable length list of column
       specifications.  Each column specification will consist of four arguments:

       ·   name: the name of the column

       ·   type: the data type of the column as it will be stored in the user record struct (not
           the data type of the input file). The following basic data types are recognized:

           ·   A: ASCII characters

           ·   B: unsigned 8-bit char

           ·   I: signed 16-bit int

           ·   U: unsigned 16-bit int (not standard FITS)

           ·   J: signed 32-bit int

           ·   V: unsigned 32-bit int (not standard FITS)

           ·   E: 32-bit float

           ·   D: 64-bit float

           The syntax used is similar to that which defines the TFORM parameter in FITS binary
           tables. That is, a numeric repeat value can precede the type character, so that "10I"
           means a vector of 10 short ints, "E" means a single precision float, etc.  Note that
           the column value from the input file will be converted to the specified data type as
           the data is read by FunTableRowGet().

           [ A short digression regarding bit-fields: Special attention is required when reading
           or writing the FITS bit-field type ("X"). Bit-fields almost always have a numeric
           repeat character preceding the 'X' specification. Usually this value is a multiple of
           8 so that bit-fields fit into an integral number of bytes. For all cases, the byte
           size of the bit-field B is (N+7)/8, where N is the numeric repeat character.

           A bit-field is most easily declared in the user struct as an array of type char of
           size B as defined above. In this case, bytes are simply moved from the file to the
           user space.  If, instead, a short or int scalar or array is used, then the algorithm
           for reading the bit-field into the user space depends on the size of the data type
           used along with the value of the repeat character.  That is, if the user data size is
           equal to the byte size of the bit-field, then the data is simply moved (possibly with
           endian-based byte-swapping) from one to the other. If, on the other hand, the data
           storage is larger than the bit-field size, then a data type cast conversion is
           performed to move parts of the bit-field into elements of the array.  Examples will
           help make this clear:

           ·   If the file contains a 16X bit-field and user space specifies a 2B char array[2],
               then the bit-field is moved directly into the char array.

           ·   If the file contains a 16X bit-field and user space specifies a 1I scalar short
               int, then the bit-field is moved directly into the short int.

           ·   If the file contains a 16X bit-field and user space specifies a 1J scalar int,
               then the bit-field is type-cast to unsigned int before being moved (use of
               unsigned avoids possible sign extension).

           ·   If the file contains a 16X bit-field and user space specifies a 2J int array[2],
               then the bit-field is handled as 2 chars, each of which are type-cast to unsigned
               int before being moved (use of unsigned avoids possible sign extension).

           ·   If the file contains a 16X bit-field and user space specifies a 1B char, then the
               bit-field is treated as a char, i.e., truncation will occur.

           ·   If the file contains a 16X bit-field and user space specifies a 4J int array[4],
               then the results are undetermined.

           For all user data types larger than char, the bit-field is byte-swapped as necessary
           to convert to native format, so that bits in the resulting data in user space can be
           tested, masked, etc. in the same way regardless of platform.]

           In addition to setting data type and size, the type specification allows a few
           ancillary parameters to be set, using the full syntax for type:

            [@][n]<type>[[['B']poff]][:[tlmin[:tlmax[:binsiz]]]]

           The special character "@" can be prepended to this specification to indicated that the
           data element is a pointer in the user record, rather than an array stored within the
           record.

           The [n] value is an integer that specifies the number of elements that are in this
           column (default is 1). TLMIN, TLMAX, and BINSIZ values also can be specified for this
           column after the type, separated by colons. If only one such number is specified, it
           is assumed to be TLMAX, and TLMIN  and BINSIZ are set to 1.

           The [poff] value can be used to specify the offset into an array. By default, this
           offset value is set to zero and the data specified starts at the beginning of the
           array. The offset usually is specified in terms of the data type of the column. Thus
           an offset specification of [5] means a 20-byte offset if the data type is a 32-bit
           integer, and a 40-byte offset for a double. If you want to specify a byte offset
           instead of an offset tied to the column data type, precede the offset value with 'B',
           e.g. [B6] means a 6-bye offset, regardless of the column data type.

           The [poff] is especially useful in conjunction with the pointer @ specification, since
           it allows the data element to anywhere stored anywhere in the allocated array.  For
           example, a specification such as "@I[2]" specifies the third (i.e., starting from 0)
           element in the array pointed to by the pointer value. A value of "@2I[4]" specifies
           the fifth and sixth values in the array. For example, consider the following
           specification:

             typedef struct EvStruct{
               short x[4], *atp;
             } *Event, EventRec;
             /* set up the (hardwired) columns */
             FunColumnSelect( fun, sizeof(EventRec), NULL,
                              "2i",    "2I  ",    "w", FUN_OFFSET(Event, x),
                              "2i2",   "2I[2]",   "w", FUN_OFFSET(Event, x),
                              "at2p",  "@2I",     "w", FUN_OFFSET(Event, atp),
                              "at2p4", "@2I[4]",  "w", FUN_OFFSET(Event, atp),
                              "atp9",  "@I[9]",   "w", FUN_OFFSET(Event, atp),
                              "atb20", "@I[B20]", "w", FUN_OFFSET(Event, atb),
                              NULL);

           Here we have specified the following columns:

           ·   2i: two short ints in an array which is stored as part the record

           ·   2i2: the 3rd and 4th elements of an array which is stored as part of the record

           ·   an array of at least 10 elements, not stored in the record but allocated
               elsewhere, and used by three different columns:

               ·   at2p: 2 short ints which are the first 2 elements of the allocated array

               ·   at2p4: 2 short ints which are the 5th and 6th elements of the allocated array

               ·   atp9: a short int which is the 10th element of the allocated array

           ·   atb20: a short int which is at byte offset 20 of another allocated array

           In this way, several columns can be specified, all of which are in a single array. NB:
           it is the programmer's responsibility to ensure that specification of a positive value
           for poff does not point past the end of valid data.

       ·   read/write mode: "r" means that the column is read from an input file into user space
           by FunTableRowGet(), "w" means that the column is written to an output file. Both can
           specified  at the same time.

       ·   offset: the offset into the user data to store this column. Typically, the macro
           FUN_OFFSET(recname, colname) is used to define the offset into a record structure.

       When all column arguments have been specified, a final NULL argument must added to signal
       the column selection list.

       As an alternative to the varargs FunColumnSelect() routine, a non-varargs routine called
       FunColumnSelectArr() also is available. The first three arguments (fun, size, plist) of
       this routine are the same as in FunColumnSelect().  Instead of a variable argument list,
       however, FunColumnSelectArr() takes 5 additional arguments. The first 4 arrays arguments
       contain the names, types, modes, and offsets, respectively, of the columns being selected.
       The final argument is the number of columns that are contained in these arrays. It is the
       user's responsibility to free string space allocated in these arrays.

       Consider the following example:

         typedef struct evstruct{
           int status;
           float pi, pha, *phas;
           double energy;
         } *Ev, EvRec;

         FunColumnSelect(fun, sizeof(EvRec), NULL,
           "status",  "J",     "r",   FUN_OFFSET(Ev, status),
           "pi",      "E",     "r",  FUN_OFFSET(Ev, pi),
           "pha",     "E",     "r",  FUN_OFFSET(Ev, pha),
           "phas",    "@9E",   "r",  FUN_OFFSET(Ev, phas),
           NULL);

       Each time a row is read into the Ev struct, the "status" column is converted to an int
       data type (regardless of its data type in the file) and stored in the status value of the
       struct.  Similarly, "pi" and "pha", and the phas vector are all stored as floats. Note
       that the "@" sign indicates that the "phas" vector is a pointer to a 9 element array,
       rather than an array allocated in the struct itself. The row record can then be processed
       as required:

         /* get rows -- let routine allocate the row array */
         while( (ebuf = (Ev)FunTableRowGet(fun, NULL, MAXROW, NULL, &got)) ){
           /* process all rows */
           for(i=0; i<got; i++){
             /* point to the i'th row */
             ev = ebuf+i;
             ev->pi = (ev->pi+.5);
             ev->pha = (ev->pi-.5);
           }

       FunColumnSelect() can also be called to define "writable" columns in order to generate a
       FITS Binary Table, without reference to any input columns.  For example, the following
       will generate a 4-column FITS binary table when FunTableRowPut() is used to write Ev
       records:

         typedef struct evstruct{
           int status;
           float pi, pha
           double energy;
         } *Ev, EvRec;

         FunColumnSelect(fun, sizeof(EvRec), NULL,
           "status",  "J",     "w",   FUN_OFFSET(Ev, status),
           "pi",      "E",     "w",   FUN_OFFSET(Ev, pi),
           "pha",     "E",     "w",   FUN_OFFSET(Ev, pha),
           "energy",  "D",       "w",   FUN_OFFSET(Ev, energy),
           NULL);

       All columns are declared to be write-only, so presumably the column data is being
       generated or read from some other source.

       In addition, FunColumnSelect() can be called to define both "readable" and "writable"
       columns.  In this case, the "read" columns are associated with an input file, while the
       "write" columns are associated with the output file. Of course, columns can be specified
       as both "readable" and "writable", in which case they are read from input and (possibly
       modified data values are) written to the output.  The FunColumnSelect() call itself is
       made by passing the input Funtools handle, and it is assumed that the output file has been
       opened using this input handle as its Funtools reference handle.

       Consider the following example:

         typedef struct evstruct{
           int status;
           float pi, pha, *phas;
           double energy;
         } *Ev, EvRec;

         FunColumnSelect(fun, sizeof(EvRec), NULL,
           "status",  "J",     "r",   FUN_OFFSET(Ev, status),
           "pi",      "E",     "rw",  FUN_OFFSET(Ev, pi),
           "pha",     "E",     "rw",  FUN_OFFSET(Ev, pha),
           "phas",    "@9E",   "rw",  FUN_OFFSET(Ev, phas),
           "energy",  "D",     "w",   FUN_OFFSET(Ev, energy),
           NULL);

       As in the "read" example above, each time an row is read into the Ev struct, the "status"
       column is converted to an int data type (regardless of its data type in the file) and
       stored in the status value of the struct.  Similarly, "pi" and "pha", and the phas vector
       are all stored as floats.  Since the "pi", "pha", and "phas" variables are declared as
       "writable" as well as "readable", they also will be written to the output file.  Note,
       however, that the "status" variable is declared as "readable" only, and hence it will not
       be written to an output file.  Finally, the "energy" column is declared as "writable"
       only, meaning it will not be read from the input file. In this case, it can be assumed
       that "energy" will be calculated in the program before being output along with the other
       values.

       In these simple cases, only the columns specified as "writable" will be output using
       FunTableRowPut().  However, it often is the case that you want to merge the user columns
       back in with the input columns, even in cases where not all of the input column names are
       explicitly read or even known. For this important case, the merge=[type] keyword is
       provided in the plist string.

       The merge=[type] keyword tells Funtools to merge the columns from the input file with user
       columns on output.  It is normally used when an input and output file are opened and the
       input file provides the Funtools reference handle for the output file. In this case, each
       time FunTableRowGet() is called, the raw input rows are saved in a special buffer. If
       FunTableRowPut() then is called (before another call to FunTableRowGet()), the contents of
       the raw input rows are merged with the user rows according to the value of type as
       follows:

       ·   update: add new user columns, and update value of existing ones (maintaining the input
           data type)

       ·   replace: add new user columns, and replace the data type and value of existing ones.
           (Note that if tlmin/tlmax values are not specified in the replacing column, but are
           specified in the original column being replaced, then the original tlmin/tlmax values
           are used in the replacing column.)

       ·   append: only add new columns, do not "replace" or "update" existing ones

       Consider the example above. If merge=update is specified in the plist string, then
       "energy" will be added to the input columns, and the values of "pi", "pha", and "phas"
       will be taken from the user space (i.e., the values will be updated from the original
       values, if they were changed by the program).  The data type for "pi", "pha", and "phas"
       will be the same as in the original file.  If merge=replace is specified, both the data
       type and value of these three input columns will be changed to the data type and value in
       the user structure.  If merge=append is specified, none of these three columns will be
       updated, and only the "energy" column will be added. Note that in all cases, "status" will
       be written from the input data, not from the user record, since it was specified as
       read-only.

       Standard applications will call FunColumnSelect() to define user columns. However, if this
       routine is not called, the default behavior is to transfer all input columns into user
       space. For this purpose a default record structure is defined such that each data element
       is properly aligned on a valid data type boundary.  This mechanism is used by programs
       such as fundisp and funtable to process columns without needing to know the specific names
       of those columns.  It is not anticipated that users will need such capabilities (contact
       us if you do!)

       By default, FunColumnSelect() reads/writes rows to/from an "array of structs", where each
       struct contains the column values for a single row of the table. This means that the
       returned values for a given column are not contiguous. You can set up the IO to return a
       "struct of arrays" so that each of the returned columns are contiguous by specifying
       org=structofarrays (abbreviation: org=soa) in the plist.  (The default case is
       org=arrayofstructs or org=aos.)

       For example, the default setup to retrieve rows from a table would be to define a record
       structure for a single event and then call
        FunColumnSelect() as follows:

         typedef struct evstruct{
           short region;
           double x, y;
           int pi, pha;
           double time;
         } *Ev, EvRec;

         got = FunColumnSelect(fun, sizeof(EvRec), NULL,
                               "x",       "D:10:10", mode, FUN_OFFSET(Ev, x),
                               "y",       "D:10:10", mode, FUN_OFFSET(Ev, y),
                               "pi",      "J",       mode, FUN_OFFSET(Ev, pi),
                               "pha",     "J",       mode, FUN_OFFSET(Ev, pha),
                               "time",    "1D",      mode, FUN_OFFSET(Ev, time),
                               NULL);

       Subsequently, each call to FunTableRowGet() will return an array of structs, one for each
       returned row. If instead you wanted to read columns into contiguous arrays, you specify
       org=soa:

         typedef struct aevstruct{
           short region[MAXROW];
           double x[MAXROW], y[MAXROW];
           int pi[MAXROW], pha[MAXROW];
           double time[MAXROW];
         } *AEv, AEvRec;

         got = FunColumnSelect(fun, sizeof(AEvRec), "org=soa",
                             "x",       "D:10:10", mode, FUN_OFFSET(AEv, x),
                             "y",       "D:10:10", mode, FUN_OFFSET(AEv, y),
                             "pi",      "J",       mode, FUN_OFFSET(AEv, pi),
                             "pha",     "J",       mode, FUN_OFFSET(AEv, pha),
                             "time",    "1D",      mode, FUN_OFFSET(AEv, time),
                             NULL);

       Note that the only modification to the call is in the plist string.

       Of course, instead of using statically allocated arrays, you also can specify dynamically
       allocated pointers:

         /* pointers to arrays of columns (used in struct of arrays) */
         typedef struct pevstruct{
           short *region;
           double *x, *y;
           int *pi, *pha;
           double *time;
         } *PEv, PEvRec;

         got = FunColumnSelect(fun, sizeof(PEvRec), "org=structofarrays",
                             "$region", "@I",       mode, FUN_OFFSET(PEv, region),
                             "x",       "@D:10:10", mode, FUN_OFFSET(PEv, x),
                             "y",       "@D:10:10", mode, FUN_OFFSET(PEv, y),
                             "pi",      "@J",       mode, FUN_OFFSET(PEv, pi),
                             "pha",     "@J",       mode, FUN_OFFSET(PEv, pha),
                             "time",    "@1D",      mode, FUN_OFFSET(PEv, time),
                             NULL);

       Here, the actual storage space is either allocated by the user or by the FunColumnSelect()
       call).

       In all of the above cases, the same call is made to retrieve rows, e.g.:

           buf = (void *)FunTableRowGet(fun, NULL, MAXROW, NULL, &got);

       However, the individual data elements are accessed differently.  For the default case of
       an "array of structs", the individual row records are accessed using:

         for(i=0; i<got; i++){
           ev = (Ev)buf+i;
           fprintf(stdout, "%.2f\t%.2f\t%d\t%d\t%.4f\t%.4f\t%21.8f\n",
                   ev->x, ev->y, ev->pi, ev->pha, ev->dx, ev->dy, ev->time);
         }

       For a struct of arrays or a struct of array pointers, we have a single struct through
       which we access individual columns and rows using:

         aev = (AEv)buf;
         for(i=0; i<got; i++){
           fprintf(stdout, "%.2f\t%.2f\t%d\t%d\t%.4f\t%.4f\t%21.8f\n",
                   aev->x[i], aev->y[i], aev->pi[i], aev->pha[i],
                   aev->dx[i], aev->dy[i], aev->time[i]);
         }

       Support for struct of arrays in the FunTableRowPut() call is handled analogously.

       See the evread example code and evmerge example code for working examples of how
       FunColumnSelect() is used.

SEE ALSO

       See funtools(7) for a list of Funtools help pages