iauWrite.c

00001 /******************************************************************************
00002 *******************************************************************************
00003 *                European Southern Observatory
00004 *              VLTI MIDI Data Reduction Software
00005 *
00006 * Module name:    iauWrite.c
00007 * Description:    Routines to write MIDI product data in accordance with the IAU 
00008 *                Exchange format 
00009 *
00010 * History:        
00011 * 01-Jun-06        (csabet) Removed static memory allocation
00012 * 10-Jul-03        (csabet) Created. Derived from John Young <jsy1001@cam.ac.uk>
00013 *******************************************************************************
00014 ******************************************************************************/
00015 
00016 /******************************************************************************
00017 *    Compiler directives
00018 ******************************************************************************/
00019 
00020 /******************************************************************************
00021 *    Include files
00022 ******************************************************************************/
00023 #include <stdlib.h>
00024 #include <stdio.h>
00025 #include <cpl.h>
00026 #include <string.h>
00027 #include "iauExchange.h"
00028 #include "iauWrite.h"
00029 #include "midiGlobal.h"
00030 #include "qfits.h"
00031 #include "qfits_header.h"
00032 
00033 /******************************************************************************
00034 *    Global Variables 
00035 ******************************************************************************/
00036 
00037 /******************************************************************************
00038 *    Local Prototypes 
00039 ******************************************************************************/
00040 
00041 /*============================ C O D E    A R E A ===========================*/
00042 
00043 
00044 /******************************************************************************
00045 *                European Southern Observatory
00046 *              VLTI MIDI Data Reduction Software 
00047 *
00048 * Module name:    writeOiArray
00049 * Input/Output:    See function arguments to avoid duplication
00050 * Description:    Writes OI_ARRAY fits binary table
00051 *
00052 *
00053 * History:        
00054 * 15-Apr-04        (csabet) Converted to qfits
00055 * 10-Jul-03        (csabet) Created. Derived from John Young <jsy1001@cam.ac.uk>
00056 ******************************************************************************/
00057 void writeOiArray (
00058     char    *outFitsName,     // In: Name of output FITS file
00059     OiArray    *array,        // In:    Pointer to the OiArray structure
00060     int     *status)    // IO:    Error status
00061 {
00062 
00063     //    Local Declarations
00064     //    ------------------
00065     const char    routine[] = "writeOiArray";
00066     FILE        *outFitsPtr;
00067     qfits_table    *oiArrayTable;
00068     int        tableWidth, numOfColumns, numOfRows, numOfElemStaIndex, 
00069             numOfElemStaName, numOfElemTelName, numOfElemDiameter, numOfElemStaxyz;
00070     qfits_col    *colPtr;
00071     qfits_header    *oiArrayHeader;
00072     const void    **outArrayPtr;
00073     char        *telName, *staName, *telPtr, *staPtr;
00074     char        *tempString;
00075     int        i, j, k, arrayStatus;
00076     float        *diameter;
00077     double        *staxyz;
00078     short        *staIndex;
00079     
00080     
00081     //    Algorithm
00082     //    ---------
00083 
00084     //    Reset status and set table parameters
00085     *status = 0;
00086     arrayStatus = 0;
00087     numOfRows = array->nelement;
00088     numOfColumns = 5;
00089     tableWidth = -1;
00090     numOfElemTelName = 16;
00091     numOfElemStaName = 16;
00092     numOfElemStaIndex = 1;
00093     numOfElemDiameter = 1;
00094     numOfElemStaxyz = 3;
00095 
00096     //    Allocate memory
00097     tempString = (char *) calloc ( MAX_STRING_LENGTH, sizeof (char));
00098     
00099     //    Open the output FITS file for writing
00100     outFitsPtr = fopen (outFitsName, "a");
00101     if (outFitsPtr == NULL)
00102     {
00103         *status = 1;
00104        cpl_msg_info(cpl_func,"<<Warning>> from '%s'. Cannot open output FITS file for writing %s\n", routine, outFitsName);
00105         free (tempString);
00106         return;
00107     }
00108 
00109     //    Create a new table
00110     oiArrayTable = qfits_table_new (outFitsName, QFITS_BINTABLE, tableWidth, numOfColumns, numOfRows);
00111     if (!oiArrayTable)
00112     {
00113         *status = 1;
00114        cpl_msg_info(cpl_func,"<<Warning>> from '%s'. Cannot create OI_ARRAY table \n", routine);
00115         free (tempString);
00116         fclose (outFitsPtr);
00117         remove (outFitsName);
00118         return;
00119     }
00120 
00121     //    Fill in the column information
00122     colPtr = oiArrayTable->col;
00123     qfits_col_fill (colPtr, numOfElemTelName, 0, sizeof(char), TFITS_BIN_TYPE_A, "TEL_NAME", " ", " ", " ", 
00124         0, 0.0, 0, 0.0, 0);
00125     colPtr++;
00126     qfits_col_fill (colPtr, numOfElemStaName, 0, sizeof(char), TFITS_BIN_TYPE_A, "STA_NAME", " ", " ", " ", 
00127         0, 0.0, 0, 0.0, 0);
00128     colPtr++;
00129     qfits_col_fill (colPtr, numOfElemStaIndex, 0, sizeof(short), TFITS_BIN_TYPE_I, "STA_INDEX", " ", " ", " ", 
00130         0, 0.0, 0, 0.0, 0);
00131     colPtr++;
00132     qfits_col_fill (colPtr, numOfElemDiameter, 0, sizeof(float), TFITS_BIN_TYPE_E, "DIAMETER", "m", " ", " ", 
00133         0, 0.0, 0, 0.0, 0);
00134     colPtr++;
00135     qfits_col_fill (colPtr, numOfElemStaxyz, 0, sizeof(double), TFITS_BIN_TYPE_D, "STAXYZ", "m", " ", " ", 
00136         0, 0.0, 0, 0.0, 0);
00137 
00138     //    Create OI_ARRAY header
00139     oiArrayHeader = qfits_table_ext_header_default (oiArrayTable);
00140     qfits_header_add (oiArrayHeader, "EXTNAME", "OI_ARRAY", "Name of this binary table extension", "");      
00141     qfits_header_add (oiArrayHeader, "OI_REVN", array->revision, "Revision number of the table definition", "");
00142     qfits_header_add (oiArrayHeader, "ARRNAME", array->arrname, "Array name", "");
00143     qfits_header_add (oiArrayHeader, "FRAME", array->frame, "Coordinate frame", "");
00144     sprintf (tempString, "%f", array->arrayx);
00145     qfits_header_add (oiArrayHeader, "ARRAYX", tempString, "Array centre x coordinate", "");
00146     sprintf (tempString, "%f", array->arrayy);
00147     qfits_header_add (oiArrayHeader, "ARRAYY", tempString, "Array centre y coordinate", "");
00148     sprintf (tempString, "%f", array->arrayz);
00149     qfits_header_add (oiArrayHeader, "ARRAYZ", tempString, "Array centre z coordinate", "");
00150 
00151     //    Diagnostics
00152     if (diagnostic > 2) qfits_header_dump (oiArrayHeader, midiReportPtr);
00153 
00154     //    Allocate space for the array of data
00155     outArrayPtr = (const void **) calloc (numOfColumns, sizeof(const void *));
00156     telName = (char *) calloc (numOfRows *  MAX_STRING_LENGTH, sizeof(char));
00157     staName = (char *) calloc (numOfRows *  MAX_STRING_LENGTH, sizeof(char));
00158     staIndex = (short *) calloc (numOfRows, sizeof(short));
00159     diameter = (float *) calloc (numOfRows, sizeof(float));
00160     staxyz = (double *) calloc (numOfRows * numOfElemStaxyz, sizeof(double));
00161     
00162     //    Load buffer
00163     telPtr = telName;
00164     for (i = 0; i < numOfRows; i++)
00165     {
00166         sprintf (telPtr, "%s", array->elem[i].tel_name);
00167         telPtr += numOfElemTelName;
00168     }
00169     
00170     staPtr = staName;
00171     for (i = 0; i < numOfRows; i++)
00172     {
00173         sprintf (staPtr, "%s", array->elem[i].sta_name);
00174         staPtr += numOfElemStaName;
00175     }
00176 
00177     k = 0;
00178     for (i = 0; i < numOfRows; i++)
00179     {
00180         staIndex[i] = array->elem[i].sta_index;
00181         diameter[i] = array->elem[i].diameter;
00182         for (j = 0; j < numOfElemStaxyz; j++)
00183         {
00184             staxyz[k++] = array->elem[i].staxyz[j];
00185         }
00186     }
00187 
00188     //    Point to the correct elements
00189     outArrayPtr[0] = (void *) telName;
00190     outArrayPtr[1] = (void *) staName;
00191     outArrayPtr[2] = (void *) staIndex;
00192     outArrayPtr[3] = (void *) diameter;
00193     outArrayPtr[4] = (void *) staxyz;
00194 
00195     arrayStatus = qfits_table_append_xtension_hdr (outFitsPtr, oiArrayTable, outArrayPtr, oiArrayHeader);
00196     if (arrayStatus == - 1)
00197     {
00198         *status = 1;
00199        cpl_msg_info(cpl_func,"<<Warning>> from '%s'. Cannot write into OI_ARRAY table \n", routine);
00200         remove (outFitsName);
00201     }
00202     
00203     //    Close files and release memory
00204     qfits_header_destroy (oiArrayHeader);
00205     qfits_table_close (oiArrayTable);
00206     free (tempString);
00207     free (outArrayPtr);
00208     fclose (outFitsPtr);
00209     free (telName);
00210     free (staName);
00211     free (staIndex);
00212     free (diameter);
00213     free (staxyz);
00214         
00215     return;
00216 }
00217 /*****************************************************************************/
00218 
00219 /******************************************************************************
00220 *                European Southern Observatory
00221 *              VLTI MIDI Data Reduction Software 
00222 *
00223 * Module name:    writeOiTarget
00224 * Input/Output:    See function arguments to avoid duplication
00225 * Description:    Write OI_TARGET fits binary table
00226 *
00227 *
00228 * History:        
00229 * 13-May-04        (csabet) Converted to qfits
00230 * 10-Jul-03        (csabet) Created. Derived from John Young <jsy1001@cam.ac.uk>
00231 ******************************************************************************/
00232 void writeOiTarget (
00233     char        *outFitsName,     // In: Name of output FITS file
00234     OiTarget    *targets,    // In:    Pointer to OiTarget
00235     int        *status)     // IO:    Error status
00236 {
00237 
00238     //    Local Declaration
00239     //    -----------------
00240     const char    routine[] = "writeOiTarget";
00241     FILE        *outFitsPtr;
00242     qfits_table    *oiTargetTable;
00243     int        tableWidth, numOfColumns, numOfRows, numOfElements, numOfElemTargetName,
00244             numOfElemVeltyp, numOfElemVeldef, numOfElemSpectyp, arrayStatus;
00245     qfits_col    *colPtr;
00246     qfits_header    *oiTargetHeader;
00247     const void    **outTargetPtr;
00248     char        *tempString;
00249     
00250     //    Algorithm
00251     //    ---------
00252 
00253     //    Reset status and set table parameters
00254     *status = 0;
00255     arrayStatus = 0;
00256     numOfRows = targets->ntarget;
00257     numOfColumns = 17;
00258     tableWidth = -1;
00259     numOfElements = 1;
00260     numOfElemTargetName = 16;
00261     numOfElemVeltyp = 8;
00262     numOfElemVeldef    = 8;
00263     numOfElemSpectyp = 16;
00264     
00265     //    Allocate memory
00266     tempString = (char *) calloc ( MAX_STRING_LENGTH, sizeof (char));
00267     
00268     //    Open the output FITS file for writing
00269     outFitsPtr = fopen (outFitsName, "a");
00270     if (outFitsPtr == NULL)
00271     {
00272         *status = 1;
00273        cpl_msg_info(cpl_func,"<<Warning>> from '%s'. Cannot open output FITS file for writing %s\n", routine, outFitsName);
00274         free (tempString);
00275         return;
00276     }
00277 
00278     //    Create a new table
00279     oiTargetTable = qfits_table_new (outFitsName, QFITS_BINTABLE, tableWidth, numOfColumns, numOfRows);
00280     if (!oiTargetTable)
00281     {
00282         *status = 1;
00283        cpl_msg_info(cpl_func,"<<Warning>> from '%s'. Cannot create OI_TARGET table \n", routine);
00284         free (tempString);
00285         fclose (outFitsPtr);
00286         remove (outFitsName);
00287         return;
00288     }
00289 
00290     //    Fill in the column information
00291     colPtr = oiTargetTable->col;
00292     qfits_col_fill (colPtr, numOfElements, 0, sizeof(short), TFITS_BIN_TYPE_I, "TARGET_ID", " ", " ", " ", 
00293         0, 0.0, 0, 0.0, 0);
00294     colPtr++;
00295     qfits_col_fill (colPtr, numOfElemTargetName, 0, sizeof(char), TFITS_BIN_TYPE_A, "TARGET", " ", " ", " ", 
00296         0, 0.0, 0, 0.0, 0);
00297     colPtr++;
00298     qfits_col_fill (colPtr, numOfElements, 0, sizeof(double), TFITS_BIN_TYPE_D, "RAEP0", "deg", " ", " ", 
00299         0, 0.0, 0, 0.0, 0);
00300     colPtr++;
00301     qfits_col_fill (colPtr, numOfElements, 0, sizeof(double), TFITS_BIN_TYPE_D, "DECEP0", "deg", " ", " ", 
00302         0, 0.0, 0, 0.0, 0);
00303     colPtr++;
00304     qfits_col_fill (colPtr, numOfElements, 0, sizeof(float), TFITS_BIN_TYPE_E, "EQUINOX", "year", " ", " ", 
00305         0, 0.0, 0, 0.0, 0);
00306     colPtr++;
00307     qfits_col_fill (colPtr, numOfElements, 0, sizeof(double), TFITS_BIN_TYPE_D, "RA_ERR", "deg", " ", " ", 
00308         0, 0.0, 0, 0.0, 0);
00309     colPtr++;
00310     qfits_col_fill (colPtr, numOfElements, 0, sizeof(double), TFITS_BIN_TYPE_D, "DEC_ERR", "deg", " ", " ", 
00311         0, 0.0, 0, 0.0, 0);
00312     colPtr++;
00313     qfits_col_fill (colPtr, numOfElements, 0, sizeof(double), TFITS_BIN_TYPE_D, "SYSVEL", "m/s", " ", " ", 
00314         0, 0.0, 0, 0.0, 0);
00315     colPtr++;
00316     qfits_col_fill (colPtr, numOfElemVeltyp, 0, sizeof(char), TFITS_BIN_TYPE_A, "VELTYP", " ", " ", " ", 
00317         0, 0.0, 0, 0.0, 0);
00318     colPtr++;
00319     qfits_col_fill (colPtr, numOfElemVeldef, 0, sizeof(char), TFITS_BIN_TYPE_A, "VELDEF", " ", " ", " ", 
00320         0, 0.0, 0, 0.0, 0);
00321     colPtr++;
00322     qfits_col_fill (colPtr, numOfElements, 0, sizeof(double), TFITS_BIN_TYPE_D, "PMRA", "deg/year", " ", " ", 
00323         0, 0.0, 0, 0.0, 0);
00324     colPtr++;
00325     qfits_col_fill (colPtr, numOfElements, 0, sizeof(double), TFITS_BIN_TYPE_D, "PMDEC", "deg/year", " ", " ", 
00326         0, 0.0, 0, 0.0, 0);
00327     colPtr++;
00328     qfits_col_fill (colPtr, numOfElements, 0, sizeof(double), TFITS_BIN_TYPE_D, "PMRA_ERR", "deg/year", " ", " ", 
00329         0, 0.0, 0, 0.0, 0);
00330     colPtr++;
00331     qfits_col_fill (colPtr, numOfElements, 0, sizeof(double), TFITS_BIN_TYPE_D, "PMDEC_ERR", "deg/year", " ", " ", 
00332         0, 0.0, 0, 0.0, 0);
00333     colPtr++;
00334     qfits_col_fill (colPtr, numOfElements, 0, sizeof(float), TFITS_BIN_TYPE_E, "PARALLAX", "deg", " ", " ", 
00335         0, 0.0, 0, 0.0, 0);
00336     colPtr++;
00337     qfits_col_fill (colPtr, numOfElements, 0, sizeof(float), TFITS_BIN_TYPE_E, "PARA_ERR", "deg", " ", " ", 
00338         0, 0.0, 0, 0.0, 0);
00339     colPtr++;
00340     qfits_col_fill (colPtr, numOfElemSpectyp, 0, sizeof(char), TFITS_BIN_TYPE_A, "SPECTYP", " ", " ", " ", 
00341         0, 0.0, 0, 0.0, 0);
00342 
00343     //    Create OI_RARGET header
00344     oiTargetHeader = qfits_table_ext_header_default (oiTargetTable);
00345     qfits_header_add (oiTargetHeader, "EXTNAME", "OI_TARGET", "Name of this binary table extension", "");      
00346     qfits_header_add (oiTargetHeader, "OI_REVN", targets->revision, "Revision number of the table definition", "");
00347 
00348     //    Diagnostics
00349     if (diagnostic > 2) qfits_header_dump (oiTargetHeader, midiReportPtr);
00350 
00351     //    Allocate space for the array of data
00352     outTargetPtr = (const void **) calloc (numOfColumns, sizeof(const void *));
00353 
00354     //    Point to the correct elements
00355     outTargetPtr[0] = (void *) &(targets->targ->target_id);
00356     outTargetPtr[1] = (void *) targets->targ->target;
00357     outTargetPtr[2] = (void *) &(targets->targ->raep0);
00358     outTargetPtr[3] = (void *) &(targets->targ->decep0);
00359     outTargetPtr[4] = (void *) &(targets->targ->equinox);
00360     outTargetPtr[5] = (void *) &(targets->targ->ra_err);
00361     outTargetPtr[6] = (void *) &(targets->targ->dec_err);
00362     outTargetPtr[7] = (void *) &(targets->targ->sysvel);
00363     outTargetPtr[8] = (void *) targets->targ->veltyp;
00364     outTargetPtr[9] = (void *) targets->targ->veldef;
00365     outTargetPtr[10] = (void *) &(targets->targ->pmra);
00366     outTargetPtr[11] = (void *) &(targets->targ->pmdec);
00367     outTargetPtr[12] = (void *) &(targets->targ->pmra_err);
00368     outTargetPtr[13] = (void *) &(targets->targ->pmdec_err);
00369     outTargetPtr[14] = (void *) &(targets->targ->parallax);
00370     outTargetPtr[15] = (void *) &(targets->targ->para_err);
00371     outTargetPtr[16] = (void *) targets->targ->spectyp;
00372 
00373     arrayStatus = qfits_table_append_xtension_hdr (outFitsPtr, oiTargetTable, outTargetPtr, oiTargetHeader);
00374     if (arrayStatus == - 1)
00375     {
00376         *status = 1;
00377        cpl_msg_info(cpl_func,"<<Warning>> from '%s'. Cannot write into OI_TARGET table \n", routine);
00378         remove (outFitsName);
00379     }
00380     
00381     //    Close files and release memory
00382     qfits_header_destroy (oiTargetHeader);
00383     qfits_table_close (oiTargetTable);
00384     free (tempString);
00385     free (outTargetPtr);
00386     fclose (outFitsPtr);
00387         
00388     return;
00389 }
00390 /*****************************************************************************/
00391 
00392 /******************************************************************************
00393 *                European Southern Observatory
00394 *              VLTI MIDI Data Reduction Software 
00395 *
00396 * Module name:    writeOiWavelength
00397 * Input/Output:    See function arguments to avoid duplication
00398 * Description:    Write OI_WAVELENGTH fits binary table
00399 *
00400 *
00401 * History:        
00402 * 13-May-04        (csabet) Converted to qfits
00403 * 10-Jul-03        (csabet) Created. Derived from John Young <jsy1001@cam.ac.uk>
00404 ******************************************************************************/
00405 void writeOiWavelength (
00406     char            *outFitsName,     // In: Name of output FITS file
00407     OiWavelength    *wave,             // In:    Pointer to OiWavelength
00408     int                *status)         // IO:    Status
00409 {
00410 
00411     //    Local Declarations
00412     //    ------------------
00413     const char    routine[] = "writeOiWavelength";
00414     FILE            *outFitsPtr;
00415     qfits_table        *oiWaveTable;
00416     int                i, tableWidth, numOfColumns, numOfRows, numOfElements, arrayStatus;
00417     qfits_col        *colPtr;
00418     qfits_header    *oiWaveHeader;
00419     const void            **outWavePtr;
00420     char            *tempString;
00421     float            *effWave, *effBand;
00422     
00423     //    Algorithm
00424     //    ---------
00425 
00426     //    Reset status and set table parameters
00427     *status = 0;
00428     arrayStatus = 0;
00429     numOfRows = wave->nwave;
00430     numOfColumns = 2;
00431     tableWidth = -1;
00432     numOfElements = 1;
00433     
00434     //    Allocate memory
00435     tempString = (char *) calloc ( MAX_STRING_LENGTH, sizeof (char));
00436     
00437     //    Open the output FITS file for writing
00438     outFitsPtr = fopen (outFitsName, "a");
00439     if (outFitsPtr == NULL)
00440     {
00441         *status = 1;
00442        cpl_msg_info(cpl_func,"<<Warning>> from '%s'. Cannot open output FITS file for writing %s\n", routine, outFitsName);
00443         free (tempString);
00444         return;
00445     }
00446 
00447     //    Create a new table
00448     oiWaveTable = qfits_table_new (outFitsName, QFITS_BINTABLE, tableWidth, numOfColumns, numOfRows);
00449     if (!oiWaveTable)
00450     {
00451         *status = 1;
00452        cpl_msg_info(cpl_func,"<<Warning>> from '%s'. Cannot create OI_WAVELENGTH table \n", routine);
00453         free (tempString);
00454         fclose (outFitsPtr);
00455         remove (outFitsName);
00456         return;
00457     }
00458 
00459     //    Fill in the column information
00460     colPtr = oiWaveTable->col;
00461     qfits_col_fill (colPtr, numOfElements, 0, sizeof(float), TFITS_BIN_TYPE_E, "EFF_WAVE", "m", " ", " ", 
00462         0, 0.0, 0, 0.0, 0);
00463     colPtr++;
00464     qfits_col_fill (colPtr, numOfElements, 0, sizeof(float), TFITS_BIN_TYPE_E, "EFF_BAND", "m", " ", " ", 
00465         0, 0.0, 0, 0.0, 0);
00466 
00467     //    Create OI_WAVELENGTH header
00468     oiWaveHeader = qfits_table_ext_header_default (oiWaveTable);
00469     qfits_header_add (oiWaveHeader, "EXTNAME", "OI_WAVELENGTH", "Name of this binary table extension", "");      
00470     qfits_header_add (oiWaveHeader, "OI_REVN", wave->revision, "Revision number of the table definition", "");
00471     qfits_header_add (oiWaveHeader, "INSNAME", wave->insname, "Detector name", "");
00472 
00473     //    Diagnostics
00474     if (diagnostic > 2) qfits_header_dump (oiWaveHeader, midiReportPtr);
00475 
00476     //    Allocate space for the array of data
00477     outWavePtr = (const void **) calloc (numOfColumns, sizeof(const void *));
00478     effWave = (float *) calloc (numOfRows * numOfElements, sizeof(float));
00479     effBand = (float *) calloc (numOfRows * numOfElements, sizeof(float));
00480     
00481     //    Load data
00482     for (i = 0; i < numOfRows; i++)
00483     {
00484         effWave[i] = wave->eff_wave[i];
00485         effBand[i] = wave->eff_band[i];
00486     }
00487     
00488     //    Point to the correct elements
00489     outWavePtr[0] = (void *) effWave;
00490     outWavePtr[1] = (void *) effBand;
00491 
00492     arrayStatus = qfits_table_append_xtension_hdr (outFitsPtr, oiWaveTable, outWavePtr, oiWaveHeader);
00493     if (arrayStatus == - 1)
00494     {
00495         *status = 1;
00496        cpl_msg_info(cpl_func,"<<Warning>> from '%s'. Cannot write into OI_TARGET table \n", routine);
00497         remove (outFitsName);
00498     }
00499     
00500     //    Close files and release memory
00501     qfits_header_destroy (oiWaveHeader);
00502     qfits_table_close (oiWaveTable);
00503     free (tempString);
00504     free (effWave);
00505     free (effBand);
00506     free (outWavePtr);
00507     fclose (outFitsPtr);
00508         
00509     return;
00510 }
00511 /*****************************************************************************/
00512 
00513 
00514 /******************************************************************************
00515 *                European Southern Observatory
00516 *              VLTI MIDI Data Reduction Software 
00517 *
00518 * Module name:    writeOiVis
00519 * Input/Output:    See function arguments to avoid duplication
00520 * Description:    Write OI_VIS fits binary table
00521 *
00522 *
00523 * History:        
00524 * 14-May-04        (csabet) Converted to qfits
00525 * 10-Jul-03        (csabet) Created. Derived from John Young <jsy1001@cam.ac.uk>
00526 ******************************************************************************/
00527 void writeOiVis (                // Ou: On error, returns non-zero cfitsio error code, and sets status
00528     char        *outFitsName,     // In: Name of output FITS file
00529     OiVis         *vis,             // In: Pointer to OiVis structure
00530     int         *status)         // IO: Status
00531 {
00532 
00533     //    Local Declarations
00534     //    ------------------
00535     const char     routine[] = "writeOiVis";
00536     FILE            *outFitsPtr;
00537     qfits_table        *oiVisTable;
00538     int                tableWidth, numOfColumns, numOfRows, numOfElements, numOfElemStaIndex, numOfElemVis;
00539     qfits_col        *colPtr;
00540     qfits_header    *oiVisHeader;
00541     const void            **outVisPtr;
00542     char            *tempString, *flag, *stringPtr;
00543     int                i, j, k, l, m, *targetId, arrayStatus;
00544     double            *time, *mjd, *integTime, *visAmp, *visAmapErr, *visPhi, *visPhiErr,
00545                     *uCoord, *vCoord; 
00546     short *staIndex;
00547 
00548     //    Algorithm
00549     //    ---------
00550 
00551     //    Reset status and set table parameters
00552     *status = 0;
00553     arrayStatus = 0;
00554     numOfRows = vis->numrec;
00555     numOfColumns = 12;
00556     tableWidth = -1;
00557     numOfElements = 1;
00558     numOfElemStaIndex = 2;
00559     numOfElemVis = vis->nwave;
00560     
00561     //    Allocate memory
00562     tempString = (char *) calloc ( MAX_STRING_LENGTH, sizeof (char));
00563     
00564     //    Open the output FITS file for writing
00565     outFitsPtr = fopen (outFitsName, "a");
00566     if (outFitsPtr == NULL)
00567     {
00568         *status = 1;
00569        cpl_msg_info(cpl_func,"<<Warning>> from '%s'. Cannot open output FITS file for writing %s\n", routine, outFitsName);
00570         free (tempString);
00571         return;
00572     }
00573 
00574     //    Create a new table
00575     oiVisTable = qfits_table_new (outFitsName, QFITS_BINTABLE, tableWidth, numOfColumns, numOfRows);
00576     if (!oiVisTable)
00577     {
00578         *status = 1;
00579        cpl_msg_info(cpl_func,"<<Warning>> from '%s'. Cannot create OI_VIS table \n", routine);
00580         free (tempString);
00581         fclose (outFitsPtr);
00582         remove (outFitsName);
00583         return;
00584     }
00585 
00586     //    Fill in the column information
00587     colPtr = oiVisTable->col;
00588     qfits_col_fill (colPtr, numOfElements, 0, sizeof(short), TFITS_BIN_TYPE_I, "TARGET_ID", " ", " ", " ", 
00589         0, 0.0, 0, 0.0, 0);
00590     colPtr++;
00591     qfits_col_fill (colPtr, numOfElements, 0, sizeof(double), TFITS_BIN_TYPE_D, "TIME", "s", " ", " ", 
00592         0, 0.0, 0, 0.0, 0);
00593     colPtr++;
00594     qfits_col_fill (colPtr, numOfElements, 0, sizeof(double), TFITS_BIN_TYPE_D, "MJD", "day", " ", " ", 
00595         0, 0.0, 0, 0.0, 0);
00596     colPtr++;
00597     qfits_col_fill (colPtr, numOfElements, 0, sizeof(double), TFITS_BIN_TYPE_D, "INT_TIME", "s", " ", " ", 
00598         0, 0.0, 0, 0.0, 0);
00599     colPtr++;
00600     qfits_col_fill (colPtr, numOfElemVis, 0, sizeof(double), TFITS_BIN_TYPE_D, "VISAMP", " ", " ", " ", 
00601         0, 0.0, 0, 0.0, 0);
00602     colPtr++;
00603     qfits_col_fill (colPtr, numOfElemVis, 0, sizeof(double), TFITS_BIN_TYPE_D, "VISAMPERR", " ", " ", " ", 
00604         0, 0.0, 0, 0.0, 0);
00605     colPtr++;
00606     qfits_col_fill (colPtr, numOfElemVis, 0, sizeof(double), TFITS_BIN_TYPE_D, "VISPHI", "deg", " ", " ", 
00607         0, 0.0, 0, 0.0, 0);
00608     colPtr++;
00609     qfits_col_fill (colPtr, numOfElemVis, 0, sizeof(double), TFITS_BIN_TYPE_D, "VISPHIERR", "deg", " ", " ", 
00610         0, 0.0, 0, 0.0, 0);
00611     colPtr++;
00612     qfits_col_fill (colPtr, numOfElements, 0, sizeof(double), TFITS_BIN_TYPE_D, "UCOORD", "m", " ", " ", 
00613         0, 0.0, 0, 0.0, 0);
00614     colPtr++;
00615     qfits_col_fill (colPtr, numOfElements, 0, sizeof(double), TFITS_BIN_TYPE_D, "VCOORD", "m", " ", " ", 
00616         0, 0.0, 0, 0.0, 0);
00617     colPtr++;
00618     qfits_col_fill (colPtr, numOfElemStaIndex, 0, sizeof(short), TFITS_BIN_TYPE_I, "STA_INDEX", " ", " ", " ", 
00619         0, 0.0, 0, 0.0, 0);
00620     colPtr++;
00621     qfits_col_fill (colPtr, numOfElemVis, 0, sizeof(char), TFITS_BIN_TYPE_L, "FLAG", " ", " ", " ", 
00622         0, 0.0, 0, 0.0, 0);
00623     colPtr++;
00624 
00625     //    Create OI_VIS header
00626     oiVisHeader = qfits_table_ext_header_default (oiVisTable);
00627     qfits_header_add (oiVisHeader, "EXTNAME", "OI_VIS", "Name of this binary table extension", "");
00628     qfits_header_add (oiVisHeader, "OI_REVN", vis->revision, "Revision number of the table definition", "");
00629     qfits_header_add (oiVisHeader, "DATE-OBS", vis->date_obs, "UTC start date of observations", "");
00630     if (strlen(vis->arrname) > 0)
00631         qfits_header_add (oiVisHeader, "ARRNAME", vis->arrname, "Array name", "");
00632   
00633     qfits_header_add (oiVisHeader, "INSNAME", vis->insname, "Detector name", "");
00634 
00635     //    Diagnostics
00636     if (diagnostic > 2) qfits_header_dump (oiVisHeader, midiReportPtr);
00637 
00638     //    Allocate space for the array of data
00639     outVisPtr = (const void **) calloc (numOfColumns, sizeof(const void *));
00640     targetId = (int *) calloc (numOfRows * numOfElements, sizeof (int));
00641     time = (double *) calloc (numOfRows * numOfElements, sizeof (double));
00642     mjd = (double *) calloc (numOfRows * numOfElements, sizeof (double));
00643     integTime = (double *) calloc (numOfRows * numOfElements, sizeof (double));
00644     visAmp = (double *) calloc (numOfRows * numOfElemVis, sizeof (double));
00645     visAmapErr = (double *) calloc (numOfRows * numOfElemVis, sizeof (double));
00646     visPhi = (double *) calloc (numOfRows * numOfElemVis, sizeof (double));
00647     visPhiErr = (double *) calloc (numOfRows * numOfElemVis, sizeof (double));
00648     uCoord = (double *) calloc (numOfRows * numOfElements, sizeof (double));
00649     vCoord = (double *) calloc (numOfRows * numOfElements, sizeof (double));
00650     staIndex = (short *) calloc (numOfRows * numOfElemStaIndex, sizeof (short));
00651     flag = (char *) calloc (numOfRows * numOfElemVis+1, sizeof (char));
00652 
00653     //    Load the data
00654     k = 0;
00655     l = 0;
00656     m = 0;
00657     stringPtr = flag;
00658     for (i = 0; i < numOfRows; i++)
00659     {
00660         for (j = 0; j < numOfElements; j++)
00661         {
00662             targetId[k] = vis->record[j].target_id;
00663             time[k]  = vis->record[j].time;
00664             mjd[k]  = vis->record[j].mjd;
00665             integTime[k]  = vis->record[j].int_time;
00666             uCoord[k] = vis->record[j].ucoord;
00667             vCoord[k++] = vis->record[j].vcoord;
00668         }
00669 
00670 
00671 
00672         for (j = 0; j < numOfElemVis; j++)
00673         {
00674             visAmp[l] = vis->record[i].visamp[j];
00675             visAmapErr[l] = vis->record[i].visamperr[j];
00676             visPhi[l] = vis->record[i].visphi[j];
00677             visPhiErr[l++] = vis->record[i].visphierr[j];
00678             
00679             if (strcmp (vis->record[i].flag, "FALSE") == 0)
00680                sprintf (stringPtr, "%s", "F");
00681             else
00682                sprintf (stringPtr, "%s", "T");
00683             stringPtr += numOfElements;
00684             
00685         }
00686 /*         stringPtr += numOfElements; */
00687 
00688         for (j = 0; j < numOfElemStaIndex; j++)
00689         {
00690             staIndex[m++] = vis->record[i].sta_index[j];
00691         }
00692     }
00693     
00694     //    Point to the correct elements
00695     outVisPtr[0] = (void *) targetId;
00696     outVisPtr[1] = (void *) time;
00697     outVisPtr[2] = (void *) mjd;
00698     outVisPtr[3] = (void *) integTime;
00699     outVisPtr[4] = (void *) visAmp;
00700     outVisPtr[5] = (void *) visAmapErr;
00701     outVisPtr[6] = (void *) visPhi;
00702     outVisPtr[7] = (void *) visPhiErr;
00703     outVisPtr[8] = (void *) uCoord;
00704     outVisPtr[9] = (void *) vCoord;
00705     outVisPtr[10] = (void *) staIndex;
00706     outVisPtr[11] = (void *) flag;
00707 
00708     arrayStatus = qfits_table_append_xtension_hdr (outFitsPtr, oiVisTable, outVisPtr, oiVisHeader);
00709     if (arrayStatus == - 1)
00710     {
00711         *status = 1;
00712        cpl_msg_info(cpl_func,"<<Warning>> from '%s'. Cannot write into OI_VIS table \n", routine);
00713         remove (outFitsName);
00714     }
00715     
00716     //    Close files and release memory
00717     qfits_header_destroy (oiVisHeader);
00718     qfits_table_close (oiVisTable);
00719     free (tempString);
00720     free (outVisPtr);
00721     fclose (outFitsPtr);
00722     free (targetId);
00723     free (time);
00724     free (mjd);
00725     free (integTime);
00726     free (visAmp);
00727     free (visAmapErr);
00728     free (visPhi);
00729     free (visPhiErr);
00730     free (uCoord);
00731     free (vCoord);
00732     free (staIndex);
00733     free (flag);
00734     
00735     return;
00736 }
00737 /*****************************************************************************/
00738 
00739 
00740 /******************************************************************************
00741 *                European Southern Observatory
00742 *              VLTI MIDI Data Reduction Software 
00743 *
00744 * Module name:    writeOiVis2
00745 * Input/Output:    See function arguments to avoid duplication
00746 * Description:    Write OI_VIS2 fits binary table
00747 *
00748 *
00749 * History:        
00750 * 14-May-04        (csabet) Converted to qfits
00751 * 10-Jul-03        (csabet) Created. Derived from John Young <jsy1001@cam.ac.uk>
00752 ******************************************************************************/
00753 void writeOiVis2 (            // Ou: On error, returns non-zero cfitsio error code, and sets status
00754     char    *outFitsName,     // In: Name of output FITS file
00755     OiVis2     *vis2,             // In: Pointer to OiVis2 structure
00756     int     *status)          // IO: Status
00757 {
00758 
00759 
00760     //    Local Declarations
00761     //    ------------------
00762     const char     routine[] = "writeOiVis2";
00763     FILE            *outFitsPtr;
00764     qfits_table        *oiVis2Table;
00765     int                tableWidth, numOfColumns, numOfRows, numOfElements, numOfElemStaIndex, numOfElemVis2;
00766     qfits_col        *colPtr;
00767     qfits_header    *oiVis2Header;
00768     const void            **outVis2Ptr;
00769     char            *tempString, *flag, *stringPtr;
00770     int                i, j, k, l, m, *targetId, arrayStatus;
00771     double            *time, *mjd, *integTime, *vis2Data, *vis2Err, *uCoord, *vCoord; 
00772     short *staIndex;
00773 
00774     //    Algorithm
00775     //    ---------
00776 
00777     //    Reset status and set table parameters
00778     *status = 0;
00779     arrayStatus = 0;
00780     numOfRows = vis2->numrec;
00781     numOfColumns = 10;
00782     tableWidth = -1;
00783     numOfElements = 1;
00784     numOfElemStaIndex = 2;
00785     numOfElemVis2 = vis2->nwave;
00786     
00787     //    Allocate memory
00788     tempString = (char *) calloc ( MAX_STRING_LENGTH, sizeof (char));
00789     
00790     //    Open the output FITS file for writing
00791     outFitsPtr = fopen (outFitsName, "a");
00792     if (outFitsPtr == NULL)
00793     {
00794         *status = 1;
00795        cpl_msg_info(cpl_func,"<<Warning>> from '%s'. Cannot open output FITS file for writing %s\n", routine, outFitsName);
00796         free (tempString);
00797         return;
00798     }
00799 
00800     //    Create a new table
00801     oiVis2Table = qfits_table_new (outFitsName, QFITS_BINTABLE, tableWidth, numOfColumns, numOfRows);
00802     if (!oiVis2Table)
00803     {
00804         *status = 1;
00805        cpl_msg_info(cpl_func,"<<Warning>> from '%s'. Cannot create OI_VIS2 table \n", routine);
00806         free (tempString);
00807         fclose (outFitsPtr);
00808         remove (outFitsName);
00809         return;
00810     }
00811 
00812     //    Fill in the column information
00813     colPtr = oiVis2Table->col;
00814     qfits_col_fill (colPtr, numOfElements, 0, sizeof(short), TFITS_BIN_TYPE_I, "TARGET_ID", " ", " ", " ", 
00815         0, 0.0, 0, 0.0, 0);
00816     colPtr++;
00817     qfits_col_fill (colPtr, numOfElements, 0, sizeof(double), TFITS_BIN_TYPE_D, "TIME", "s", " ", " ", 
00818         0, 0.0, 0, 0.0, 0);
00819     colPtr++;
00820     qfits_col_fill (colPtr, numOfElements, 0, sizeof(double), TFITS_BIN_TYPE_D, "MJD", "day", " ", " ", 
00821         0, 0.0, 0, 0.0, 0);
00822     colPtr++;
00823     qfits_col_fill (colPtr, numOfElements, 0, sizeof(double), TFITS_BIN_TYPE_D, "INT_TIME", "s", " ", " ", 
00824         0, 0.0, 0, 0.0, 0);
00825     colPtr++;
00826     qfits_col_fill (colPtr, numOfElemVis2, 0, sizeof(double), TFITS_BIN_TYPE_D, "VIS2DATA", " ", " ", " ", 
00827         0, 0.0, 0, 0.0, 0);
00828     colPtr++;
00829     qfits_col_fill (colPtr, numOfElemVis2, 0, sizeof(double), TFITS_BIN_TYPE_D, "VIS2ERR", " ", " ", " ", 
00830         0, 0.0, 0, 0.0, 0);
00831     colPtr++;
00832     qfits_col_fill (colPtr, numOfElements, 0, sizeof(double), TFITS_BIN_TYPE_D, "UCOORD", "m", " ", " ", 
00833         0, 0.0, 0, 0.0, 0);
00834     colPtr++;
00835     qfits_col_fill (colPtr, numOfElements, 0, sizeof(double), TFITS_BIN_TYPE_D, "VCOORD", "m", " ", " ", 
00836         0, 0.0, 0, 0.0, 0);
00837     colPtr++;
00838     qfits_col_fill (colPtr, numOfElemStaIndex, 0, sizeof(short), TFITS_BIN_TYPE_I, "STA_INDEX", " ", " ", " ", 
00839         0, 0.0, 0, 0.0, 0);
00840     colPtr++;
00841     qfits_col_fill (colPtr, numOfElemVis2, 0, sizeof(char), TFITS_BIN_TYPE_L, "FLAG", " ", " ", " ", 
00842         0, 0.0, 0, 0.0, 0);
00843     colPtr++;
00844 
00845     //    Create OI_VIS header
00846     oiVis2Header = qfits_table_ext_header_default (oiVis2Table);
00847     qfits_header_add (oiVis2Header, "EXTNAME", "OI_VIS2", "Name of this binary table extension", "");
00848     qfits_header_add (oiVis2Header, "OI_REVN", vis2->revision, "Revision number of the table definition", "");
00849     qfits_header_add (oiVis2Header, "DATE-OBS", vis2->date_obs, "UTC start date of observations", "");
00850     if (strlen(vis2->arrname) > 0)
00851         qfits_header_add (oiVis2Header, "ARRNAME", vis2->arrname, "Array name", "");
00852   
00853     qfits_header_add (oiVis2Header, "INSNAME", vis2->insname, "Detector name", "");
00854 
00855     //    Diagnostics. Comment out later
00856     if (diagnostic > 2) qfits_header_dump (oiVis2Header, midiReportPtr);
00857 
00858     //    Allocate space for the array of data
00859     outVis2Ptr = (const void **) calloc (numOfColumns, sizeof(const void *));
00860     targetId = (int *) calloc (numOfRows * numOfElements, sizeof (int));
00861     time = (double *) calloc (numOfRows * numOfElements, sizeof (double));
00862     mjd = (double *) calloc (numOfRows * numOfElements, sizeof (double));
00863     integTime = (double *) calloc (numOfRows * numOfElements, sizeof (double));
00864     vis2Data = (double *) calloc (numOfRows * numOfElemVis2, sizeof (double));
00865     vis2Err = (double *) calloc (numOfRows * numOfElemVis2, sizeof (double));
00866     uCoord = (double *) calloc (numOfRows * numOfElements, sizeof (double));
00867     vCoord = (double *) calloc (numOfRows * numOfElements, sizeof (double));
00868     staIndex = (short *) calloc (numOfRows * numOfElemStaIndex, sizeof (short));
00869     flag = (char *) calloc (numOfRows *  numOfElemVis2+1, sizeof (char));
00870 
00871     //    Load the data
00872     k = 0;
00873     l = 0;
00874     m = 0;
00875     stringPtr = flag;
00876     for (i = 0; i < numOfRows; i++)
00877     {
00878         for (j = 0; j < numOfElements; j++)
00879         {
00880             targetId[k] = vis2->record[j].target_id;
00881             time[k]  = vis2->record[j].time;
00882             mjd[k]  = vis2->record[j].mjd;
00883             integTime[k]  = vis2->record[j].int_time;
00884             uCoord[k] = vis2->record[j].ucoord;
00885             vCoord[k++] = vis2->record[j].vcoord;
00886         }
00887             
00888 
00889         for (j = 0; j < numOfElemVis2; j++)
00890         {
00891             vis2Data[l] = vis2->record[i].vis2data[j];
00892             vis2Err[l++] = vis2->record[i].vis2err[j];
00893 
00894         if (strcmp (vis2->record[i].flag, "FALSE") == 0)
00895             sprintf (stringPtr, "%s", "F");
00896         else
00897             sprintf (stringPtr, "%s", "T");
00898         stringPtr += numOfElements;
00899 
00900         }
00901 
00902         for (j = 0; j < numOfElemStaIndex; j++)
00903         {
00904             staIndex[m++] = vis2->record[i].sta_index[j];
00905         }
00906     }
00907     
00908     //    Point to the correct elements
00909     outVis2Ptr[0] = (void *) targetId;
00910     outVis2Ptr[1] = (void *) time;
00911     outVis2Ptr[2] = (void *) mjd;
00912     outVis2Ptr[3] = (void *) integTime;
00913     outVis2Ptr[4] = (void *) vis2Data;
00914     outVis2Ptr[5] = (void *) vis2Err;
00915     outVis2Ptr[6] = (void *) uCoord;
00916     outVis2Ptr[7] = (void *) vCoord;
00917     outVis2Ptr[8] = (void *) staIndex;
00918     outVis2Ptr[9] = (void *) flag;
00919 
00920     arrayStatus = qfits_table_append_xtension_hdr (outFitsPtr, oiVis2Table, outVis2Ptr, oiVis2Header);
00921     if (arrayStatus == - 1)
00922     {
00923         *status = 1;
00924        cpl_msg_info(cpl_func,"<<Warning>> from '%s'. Cannot write into OI_VIS2 table \n", routine);
00925         remove (outFitsName);
00926     }
00927     
00928     //    Close files and release memory
00929     qfits_header_destroy (oiVis2Header);
00930     qfits_table_close (oiVis2Table);
00931     free (tempString);
00932     free (outVis2Ptr);
00933     fclose (outFitsPtr);
00934     free (targetId);
00935     free (time);
00936     free (mjd);
00937     free (integTime);
00938     free (vis2Data);
00939     free (vis2Err);
00940     free (uCoord);
00941     free (vCoord);
00942     free (staIndex);
00943     free (flag);
00944     
00945     return;
00946 }
00947 /*****************************************************************************/
00948 
00949 
00950 /******************************************************************************
00951 *                European Southern Observatory
00952 *              VLTI MIDI Data Reduction Software 
00953 *
00954 * Module name:    writeOiT3
00955 * Input/Output:    See function arguments to avoid duplication
00956 * Description:    Write OI_T3 fits binary table
00957 *
00958 *                Warning: This routine is not tested as it is not used in the MIDI
00959 * History:        
00960 * 14-May-04        (csabet) Converted to qfits
00961 * 10-Jul-03        (csabet) Created. Derived from John Young <jsy1001@cam.ac.uk>
00962 ******************************************************************************/
00963 void writeOiT3 (            // Ou: On error, returns non-zero cfitsio error code, and sets status
00964     char    *outFitsName,     // In: Name of output FITS file
00965     OiT3     *t3,             // In: Pointer to OiT3 structure
00966     int     *status)          // IO: Status
00967 {
00968 
00969     //    Local Declarations
00970     //    ------------------
00971     const char     routine[] = "writeOiT3";
00972     FILE            *outFitsPtr;
00973     qfits_table        *oiT3Table;
00974     int                tableWidth, numOfColumns, numOfRows, numOfElements, numOfElemStaIndex, numOfElemT3;
00975     qfits_col        *colPtr;
00976     qfits_header    *oiT3Header;
00977     const void            **outT3Ptr;
00978     char            *tempString, *flag, *stringPtr;
00979     int                i, j, k, l, m, *targetId, *staIndex;
00980     double            *time, *mjd, *integTime, *t3Amp, *t3AmpErr, *t3Phi, *t3PhiErr,
00981                     *u1Coord, *v1Coord, *u2Coord, *v2Coord;
00982 
00983     //    Algorithm
00984     //    ---------
00985 
00986     //    Reset status and set table parameters
00987     *status = 0;
00988     numOfRows = t3->numrec;
00989     numOfColumns = 14;
00990     tableWidth = -1;
00991     numOfElements = 1;
00992     numOfElemStaIndex = 1;
00993     numOfElemT3 = t3->nwave;
00994     
00995     //    Allocate memory
00996     tempString = (char *) calloc ( MAX_STRING_LENGTH, sizeof (char));
00997     
00998     //    Open the output FITS file for writing
00999     outFitsPtr = fopen (outFitsName, "a");
01000     if (outFitsPtr == NULL)
01001     {
01002         *status = 1;
01003        cpl_msg_info(cpl_func,"<<Warning>> from '%s'. Cannot open output FITS file for writing %s\n", routine, outFitsName);
01004         free (tempString);
01005         return;
01006     }
01007 
01008     //    Create a new table
01009     oiT3Table = qfits_table_new (outFitsName, QFITS_BINTABLE, tableWidth, numOfColumns, numOfRows);
01010     if (!oiT3Table)
01011     {
01012         *status = 1;
01013        cpl_msg_info(cpl_func,"<<Warning>> from '%s'. Cannot create OI_T3 table \n", routine);
01014         free (tempString);
01015         fclose (outFitsPtr);
01016         remove (outFitsName);
01017         return;
01018     }
01019 
01020     //    Fill in the column information
01021     colPtr = oiT3Table->col;
01022     qfits_col_fill (colPtr, numOfElements, 0, sizeof(short), TFITS_BIN_TYPE_I, "TARGET_ID", " ", " ", " ", 
01023         0, 0.0, 0, 0.0, 0);
01024     colPtr++;
01025     qfits_col_fill (colPtr, numOfElements, 0, sizeof(double), TFITS_BIN_TYPE_D, "TIME", "s", " ", " ", 
01026         0, 0.0, 0, 0.0, 0);
01027     colPtr++;
01028     qfits_col_fill (colPtr, numOfElements, 0, sizeof(double), TFITS_BIN_TYPE_D, "MJD", "day", " ", " ", 
01029         0, 0.0, 0, 0.0, 0);
01030     colPtr++;
01031     qfits_col_fill (colPtr, numOfElements, 0, sizeof(double), TFITS_BIN_TYPE_D, "INT_TIME", "s", " ", " ", 
01032         0, 0.0, 0, 0.0, 0);
01033     colPtr++;
01034     qfits_col_fill (colPtr, numOfElemT3, 0, sizeof(double), TFITS_BIN_TYPE_D, "T3AMP", " ", " ", " ", 
01035         0, 0.0, 0, 0.0, 0);
01036     colPtr++;
01037     qfits_col_fill (colPtr, numOfElemT3, 0, sizeof(double), TFITS_BIN_TYPE_D, "T3AMPERR", " ", " ", " ", 
01038         0, 0.0, 0, 0.0, 0);
01039     colPtr++;
01040     qfits_col_fill (colPtr, numOfElemT3, 0, sizeof(double), TFITS_BIN_TYPE_D, "T3PHI", " ", " ", " ", 
01041         0, 0.0, 0, 0.0, 0);
01042     colPtr++;
01043     qfits_col_fill (colPtr, numOfElemT3, 0, sizeof(double), TFITS_BIN_TYPE_D, "T3PHIERR", " ", " ", " ", 
01044         0, 0.0, 0, 0.0, 0);
01045     colPtr++;
01046     qfits_col_fill (colPtr, numOfElements, 0, sizeof(double), TFITS_BIN_TYPE_D, "U1COORD", "m", " ", " ", 
01047         0, 0.0, 0, 0.0, 0);
01048     colPtr++;
01049     qfits_col_fill (colPtr, numOfElements, 0, sizeof(double), TFITS_BIN_TYPE_D, "V1COORD", "m", " ", " ", 
01050         0, 0.0, 0, 0.0, 0);
01051     colPtr++;
01052     qfits_col_fill (colPtr, numOfElements, 0, sizeof(double), TFITS_BIN_TYPE_D, "U2COORD", "m", " ", " ", 
01053         0, 0.0, 0, 0.0, 0);
01054     colPtr++;
01055     qfits_col_fill (colPtr, numOfElements, 0, sizeof(double), TFITS_BIN_TYPE_D, "V2COORD", "m", " ", " ", 
01056         0, 0.0, 0, 0.0, 0);
01057     colPtr++;
01058     qfits_col_fill (colPtr, numOfElemStaIndex, 0, sizeof(short), TFITS_BIN_TYPE_I, "STA_INDEX", " ", " ", " ", 
01059         0, 0.0, 0, 0.0, 0);
01060     colPtr++;
01061     qfits_col_fill (colPtr, numOfElements, 0, sizeof(char), TFITS_BIN_TYPE_A, "FLAG", " ", " ", " ", 
01062         0, 0.0, 0, 0.0, 0);
01063     colPtr++;
01064 
01065     //    Create OI_VIS header
01066     oiT3Header = qfits_table_ext_header_default (oiT3Table);
01067     qfits_header_add (oiT3Header, "EXTNAME", "OI_T3", "Name of this binary table extension", "");
01068     qfits_header_add (oiT3Header, "OI_REVN", t3->revision, "Revision number of the table definition", "");
01069     qfits_header_add (oiT3Header, "DATE-OBS", t3->date_obs, "UTC start date of observations", "");
01070     if (strlen(t3->arrname) > 0)
01071         qfits_header_add (oiT3Header, "ARRNAME", t3->arrname, "Array name", "");
01072   
01073     qfits_header_add (oiT3Header, "INSNAME", t3->insname, "Detector name", "");
01074 
01075     //    Diagnostics. Comment out later
01076     if (diagnostic > 2) qfits_header_dump (oiT3Header, midiReportPtr);
01077 
01078     //    Allocate space for the array of data
01079     outT3Ptr = (const void **) calloc (numOfColumns, sizeof(const void *));
01080     targetId = (int *) calloc (numOfRows * numOfElements, sizeof (int));
01081     time = (double *) calloc (numOfRows * numOfElements, sizeof (double));
01082     mjd = (double *) calloc (numOfRows * numOfElements, sizeof (double));
01083     integTime = (double *) calloc (numOfRows * numOfElements, sizeof (double));
01084     t3Amp = (double *) calloc (numOfRows * numOfElemT3, sizeof (double));
01085     t3AmpErr = (double *) calloc (numOfRows * numOfElemT3, sizeof (double));
01086     t3Phi = (double *) calloc (numOfRows * numOfElemT3, sizeof (double));
01087     t3PhiErr = (double *) calloc (numOfRows * numOfElemT3, sizeof (double));
01088     u1Coord = (double *) calloc (numOfRows * numOfElements, sizeof (double));
01089     v1Coord = (double *) calloc (numOfRows * numOfElements, sizeof (double));
01090     u2Coord = (double *) calloc (numOfRows * numOfElements, sizeof (double));
01091     v2Coord = (double *) calloc (numOfRows * numOfElements, sizeof (double));
01092     staIndex = (int *) calloc (numOfRows * numOfElemStaIndex, sizeof (int));
01093     flag = (char *) calloc (numOfRows *  MAX_STRING_LENGTH, sizeof (char));
01094 
01095     //    Load the data
01096     k = 0;
01097     l = 0;
01098     m = 0;
01099     stringPtr = flag;
01100     for (i = 0; i < numOfRows; i++)
01101     {
01102         for (j = 0; j < numOfElements; j++)
01103         {
01104             targetId[k] = t3->record[j].target_id;
01105             time[k]  = t3->record[j].time;
01106             mjd[k]  = t3->record[j].mjd;
01107             integTime[k]  = t3->record[j].int_time;
01108             u1Coord[k] = t3->record[j].u1coord;
01109             v1Coord[k++] = t3->record[j].v1coord;
01110             u2Coord[k] = t3->record[j].u2coord;
01111             v2Coord[k++] = t3->record[j].v2coord;
01112         }
01113             
01114        cpl_msg_info(cpl_func,"flag = %s\n", t3->record[i].flag);
01115         if (strcmp (t3->record[i].flag, "FALSE") == 0)
01116             sprintf (stringPtr, "%s", "F");
01117         else
01118             sprintf (stringPtr, "%s", "T");
01119         stringPtr += numOfElements;
01120 
01121         for (j = 0; j < numOfElemT3; j++)
01122         {
01123             t3Amp[l] = t3->record[i].t3amp[j];
01124             t3AmpErr[l] = t3->record[i].t3amperr[j];
01125             t3Phi[l] = t3->record[i].t3phi[j];
01126             t3PhiErr[l] = t3->record[i].t3phierr[j];
01127         }
01128 
01129         for (j = 0; j < numOfElemStaIndex; j++)
01130         {
01131             staIndex[m++] = t3->record[i].sta_index[j];
01132         }
01133     }
01134     
01135     //    Point to the correct elements
01136     outT3Ptr[0] = (void *) targetId;
01137     outT3Ptr[1] = (void *) time;
01138     outT3Ptr[2] = (void *) mjd;
01139     outT3Ptr[3] = (void *) integTime;
01140     outT3Ptr[4] = (void *) t3Amp;
01141     outT3Ptr[5] = (void *) t3AmpErr;
01142     outT3Ptr[6] = (void *) t3Phi;
01143     outT3Ptr[7] = (void *) t3PhiErr;
01144     outT3Ptr[8] = (void *) u1Coord;
01145     outT3Ptr[9] = (void *) v1Coord;
01146     outT3Ptr[10] = (void *) u2Coord;
01147     outT3Ptr[11] = (void *) v2Coord;
01148     outT3Ptr[12] = (void *) staIndex;
01149     outT3Ptr[13] = (void *) flag;
01150 
01151     if (qfits_table_append_xtension_hdr (outFitsPtr, oiT3Table, outT3Ptr, oiT3Header) == -1)
01152     {
01153         *status = 1;
01154        cpl_msg_info(cpl_func,"<<Warning>> from '%s'. Cannot write into OI_T3 table \n", routine);
01155         remove (outFitsName);
01156     }
01157     
01158     //    Close files and release memory
01159     qfits_header_destroy (oiT3Header);
01160     qfits_table_close (oiT3Table);
01161     free (tempString);
01162     free (outT3Ptr);
01163     fclose (outFitsPtr);
01164     free (targetId);
01165     free (time);
01166     free (mjd);
01167     free (integTime);
01168     free (t3Amp);
01169     free (t3AmpErr);
01170     free (t3Phi);
01171     free (t3PhiErr);
01172     free (u1Coord);
01173     free (v1Coord);
01174     free (u2Coord);
01175     free (v2Coord);
01176     free (staIndex);
01177     free (flag);
01178 
01179     return;
01180 }
01181 /*****************************************************************************/

Generated on 11 Feb 2011 for MIDI Pipeline Reference Manual by  doxygen 1.6.1