IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 33254


Ignore:
Timestamp:
Feb 14, 2012, 6:38:28 AM (14 years ago)
Author:
eugene
Message:

relphot with parallelizations now builds (no tests on running yet)

Location:
branches/eam_branches/ipp-20111122/Ohana/src/relphot
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • branches/eam_branches/ipp-20111122/Ohana/src/relphot/Makefile

    r30616 r33254  
    1 default: relphot
     1default: relphot relphot_client
    22help:
    33        @echo "make options: relphot (default)"
    … …  
    1818
    1919relphot: $(BIN)/relphot.$(ARCH)
    20 install: $(DESTBIN)/relphot
     20relphot_client: $(BIN)/relphot_client.$(ARCH)
     21
     22install: $(DESTBIN)/relphot $(DESTBIN)/relphot_client
    2123
    2224RELPHOT = \
    … …  
    2426$(SRC)/GridOps.$(ARCH).o         \
    2527$(SRC)/ImageOps.$(ARCH).o        \
     28$(SRC)/ImageSubset.$(ARCH).o     \
     29$(SRC)/BrightCatalog.$(ARCH).o   \
    2630$(SRC)/MosaicOps.$(ARCH).o       \
    2731$(SRC)/SetSignals.$(ARCH).o      \
    … …  
    4852$(RELPHOT): $(INC)/relphot.h
    4953$(BIN)/relphot.$(ARCH): $(RELPHOT)
     54
     55RELPHOT_CLIENT = \
     56$(SRC)/ConfigInit.$(ARCH).o      \
     57$(SRC)/GridOps.$(ARCH).o         \
     58$(SRC)/ImageOps.$(ARCH).o        \
     59$(SRC)/ImageSubset.$(ARCH).o     \
     60$(SRC)/BrightCatalog.$(ARCH).o   \
     61$(SRC)/MosaicOps.$(ARCH).o       \
     62$(SRC)/SetSignals.$(ARCH).o      \
     63$(SRC)/Shutdown.$(ARCH).o        \
     64$(SRC)/StarOps.$(ARCH).o         \
     65$(SRC)/bcatalog.$(ARCH).o        \
     66$(SRC)/args.$(ARCH).o            \
     67$(SRC)/help.$(ARCH).o            \
     68$(SRC)/plotstuff.$(ARCH).o       \
     69$(SRC)/liststats.$(ARCH).o       \
     70$(SRC)/initialize.$(ARCH).o      \
     71$(SRC)/load_catalogs.$(ARCH).o   \
     72$(SRC)/reload_catalogs.$(ARCH).o \
     73$(SRC)/relphot_client.$(ARCH).o  \
     74$(SRC)/setExclusions.$(ARCH).o   \
     75$(SRC)/setMrelFinal.$(ARCH).o    \
     76$(SRC)/write_coords.$(ARCH).o
     77
     78$(RELPHOT_CLIENT): $(INC)/relphot.h
     79$(BIN)/relphot_client.$(ARCH): $(RELPHOT_CLIENT)

  • branches/eam_branches/ipp-20111122/Ohana/src/relphot/doc/parallel.txt

    r33244 r33254  
     1
     22012.02.13
     3
     4Image fields needed by relphot_client (saved by ImageSubsetSave):
     5
     6imageID
     7photom_map_id
     8flags
     9Mcal
     10dMcal
     11tzero
     12trate
     13
     14(if we have USE_GRID == T):
     15photcode
     16
    117
    2182012.02.10

  • branches/eam_branches/ipp-20111122/Ohana/src/relphot/include/relphot.h

    r33169 r33254  
    77# define GRID_V2
    88# define NO_IMAGE -100
     9
     10typedef enum {
     11    MODE_NONE   = 0,
     12    MODE_LOAD   = 1,
     13    MODE_UPDATE = 2,
     14} ModeType;
    915
    1016typedef struct {
    … …  
    3440} StatType;
    3541
     42typedef struct {
     43    AverageTiny *average;
     44    MeasureTiny *measure;
     45    SecFilt     *secfilt;
     46    off_t Naverage;
     47    off_t Nmeasure;
     48} BrightCatalog;
     49
     50typedef struct {
     51  float Mcal;
     52  float dMcal;
     53  unsigned int imageID;
     54  unsigned int photom_map_id;
     55  unsigned int flags;
     56  unsigned int tzero;
     57  unsigned char trate;
     58} ImageSubset;
     59
    3660/* global variables set in parameter file */
    3761char   ImageCat[256];
    … …  
    4569char   SKY_TABLE[256];
    4670int    SKY_DEPTH;  /** XXX EAM : depth of catalog tables, fix usage */
     71
     72int          HOST_ID;
     73char        *HOSTDIR;
     74char        *IMAGES;
     75char        *BCATALOG;
     76ModeType     MODE;
    4777
    4878double MAG_LIM;
    … …  
    133163off_t        *SelectRefMosaic     PROTO((Mosaic **refmosaic, off_t *Nimage));
    134164int           args                PROTO((int argc, char **argv));
     165int           args_client         PROTO((int argc, char **argv));
    135166int           bcatalog            PROTO((Catalog *subcatalog, Catalog *catalog));
    136167void          clean_images        PROTO((void));
    … …  
    165196Image        *getimage            PROTO((off_t N));
    166197Image        *getimages           PROTO((off_t *N, off_t **LineNumber));
     198ImageSubset  *getimages_subset    PROTO((off_t *N));
    167199void          global_stats        PROTO((Catalog *catalog, int Ncatalog, FlatCorrectionTable *flatcorr));
    168200void          initGrid            PROTO((int dX, int dY));
    169201void          initGridBins        PROTO((Catalog *catalog, int Ncatalog));
    170202void          initImageBins       PROTO((Catalog *catalog, int Ncatalog, int doImageList));
     203void          initImagesSubset    PROTO((ImageSubset *input, off_t *line_number, off_t N));
    171204void          initImages          PROTO((Image *input, off_t *LineNumber, off_t N));
    172205void          initMosaicBins      PROTO((Catalog *catalog, int Ncatalog, int doMosaicList));
    … …  
    175208void          initMrel            PROTO((Catalog *catalog, int Ncatalog));
    176209void          initialize          PROTO((int argc, char **argv));
     210void          initialize_client   PROTO((int argc, char **argv));
    177211void          initstats           PROTO((char *mode));
    178212int           liststats           PROTO((double *value, double *dvalue, int N, StatType *stats));
    179 Catalog       *load_catalogs      PROTO((SkyList *skylist, int *Ncatalog));
     213Catalog      *load_catalogs       PROTO((SkyList *skylist, int *Ncatalog, int hostID, char *hostpath));
     214Catalog      *load_catalogs_parallel PROTO((SkyList *sky, int *Ncatalog));
     215
    180216SkyList      *load_images         PROTO((FITS_DB *db, char *regionName, SkyRegion *region, int RegionSelect));
    181 Image         *select_images      PROTO((SkyList *skylist, Image *timage, off_t Ntimage, off_t **LineNumber, off_t *Nimage));
     217Image        *select_images       PROTO((SkyList *skylist, Image *timage, off_t Ntimage, off_t **LineNumber, off_t *Nimage));
    182218
    183219int           main                PROTO((int argc, char **argv));
    … …  
    196232void          plot_star_coords    PROTO((Catalog *catalog, int Ncatalog));
    197233void          plot_stars          PROTO((Catalog *catalog, int Ncatalog));
    198 void          reload_catalogs     PROTO((SkyList *skylist, FlatCorrectionTable *flatcorr));
     234void          reload_catalogs     PROTO((SkyList *skylist, FlatCorrectionTable *flatcorr, int hostID, char *hostpath));
     235int           reload_catalogs_parallel PROTO((SkyList *sky));
    199236int           reload_images       PROTO((FITS_DB *db));
    200237int           setExclusions       PROTO((Catalog *catalog, int Ncatalog));
    … …  
    234271void relphot_help (int argc, char **argv);
    235272
     273void relphot_client_usage (void);
     274void relphot_client_help (int argc, char **argv);
     275
    236276off_t getImageByID (off_t ID);
    237277
    … …  
    241281int populate_tiny_values (Catalog *catalog);
    242282int free_tiny_values (Catalog *catalog);
     283
     284BrightCatalog *BrightCatalogLoad(char *filename);
     285int BrightCatalogSave(char *filename, BrightCatalog *catalog);
     286BrightCatalog *BrightCatalogMerge (Catalog *catalog, int Ncatalog);
     287
     288int ImageSubsetSave(char *filename, ImageSubset *image, off_t Nimage);
     289ImageSubset *ImageSubsetLoad(char *filename, off_t *nimage);
     290
     291int CopyAverageTiny (AverageTiny *averageT, Average *average);
     292int CopyMeasureTiny (MeasureTiny *measureT, Measure *measure);

  • branches/eam_branches/ipp-20111122/Ohana/src/relphot/src/BrightCatalog.c

    r33244 r33254  
    88// reassign correctly on read
    99
    10 typedef struct {
    11     AverageTiny *average;
    12     MeasureTiny *measure;
    13     Secfilt     *secfilt;
    14     off_t Naverage;
    15     off_t Nmeasure;
    16 } BrightCatalog;
    17 
    18 # define GET_COLUMN(OUT,NAME,TYPE) \
     10# define GET_COLUMN(OUT,NAME,TYPE)                                      \
    1911  TYPE *OUT = gfits_get_bintable_column_data (&theader, &ftable, NAME, type, &Nrow, &Ncol); \
    2012  myAssert (!strcmp(type, #TYPE), "wrong column type");
    … …  
    2618BrightCatalog *BrightCatalogLoad(char *filename) {
    2719
    28   int i, Ncol, Ncol2;
     20  int i, Ncol;
    2921  off_t Nrow;
    3022  char type[16];
    … …  
    6153  ftable.header = &theader;
    6254
    63   // load data for this header
    64   if (!gfits_load_header (f, &theader)) return (NULL);
    65 
    66   // read the fits table bytes
    67   if (!gfits_fread_ftable_data (f, &ftable, FALSE)) return (NULL);
     55  // *** Measure Data ***
     56  {
     57    // load data for this header
     58    if (!gfits_load_header (f, &theader)) return (NULL);
     59
     60    // read the fits table bytes
     61    if (!gfits_fread_ftable_data (f, &ftable, FALSE)) return (NULL);
    6862 
    69   // need to create and assign to flat-field correction
    70   GET_COLUMN(dR,       "RA_OFF",   float);
    71   GET_COLUMN(dD,       "DEC_OFF",  float);
    72   GET_COLUMN(M,        "MAG_SYS",  float);
    73   GET_COLUMN(Mcal,     "MAG_CAL",  float);
    74   GET_COLUMN(dM,       "MAG_ERR",  float);
    75   GET_COLUMN(airmass,  "AIRMASS",  float);
    76   GET_COLUMN(Xccd,     "X_CCD",    float);
    77   GET_COLUMN(Yccd,     "Y_CCD",    float);
    78   GET_COLUMN(dt,       "EXPTIME",  float);
    79   GET_COLUMN(t,        "TIME",     int);
    80   GET_COLUMN(averef,   "AVE_REF",  int); // XXX signed vs unsigned?
    81   GET_COLUMN(imageID,  "IMAGE_ID", int);
    82   GET_COLUMN(dbFlags,  "DB_FLAGS", int);
    83   GET_COLUMN(catID,    "CAT_ID",   int);
    84   GET_COLUMN(photcode, "PHOTCODE", short);
    85   // XXX free the fits table data here
    86 
    87   ALLOCATE (measure, MeasureTiny, Nrow);
    88   for (i = 0; i < Nrow; i++) {
    89     measure[i].dR       = dR[i];
    90     measure[i].dD       = dD[i];
    91     measure[i].M        = M[i];
    92     measure[i].Mcal     = Mcal[i];
    93     measure[i].dM       = dM[i];
    94     measure[i].airmass  = airmass[i];
    95     measure[i].Xccd     = Xccd[i];
    96     measure[i].Yccd     = Yccd[i];
    97     measure[i].dt       = dt[i];
    98     measure[i].t        = t[i];
    99     measure[i].averef   = averef[i];
    100     measure[i].imageID  = imageID[i];
    101     measure[i].dbFlags  = dbFlags[i];
    102     measure[i].catID    = catID[i];
    103     measure[i].photcode = photcode[i];
    104   }
    105   fprintf (stderr, "loaded data for %lld measures\n", (long long) Nrow);
    106 
    107   free (dR      );
    108   free (dD      );
    109   free (M       );
    110   free (Mcal    );
    111   free (dM      );
    112   free (airmass );
    113   free (Xccd    );
    114   free (Yccd    );
    115   free (dt      );
    116   free (t       );
    117   free (averef  );
    118   free (imageID );
    119   free (dbFlags );
    120   free (catID   );
    121   free (photcode);
    122 
    123   catalog->measure = measure;
    124   catalog->Nmeasure = Nrow;
     63    // need to create and assign to flat-field correction
     64    GET_COLUMN(dR,       "RA_OFF",   float);
     65    GET_COLUMN(dD,       "DEC_OFF",  float);
     66    GET_COLUMN(M,        "MAG_SYS",  float);
     67    GET_COLUMN(Mcal,     "MAG_CAL",  float);
     68    GET_COLUMN(dM,       "MAG_ERR",  float);
     69    GET_COLUMN(airmass,  "AIRMASS",  float);
     70    GET_COLUMN(Xccd,     "X_CCD",    float);
     71    GET_COLUMN(Yccd,     "Y_CCD",    float);
     72    GET_COLUMN(dt,       "EXPTIME",  float);
     73    GET_COLUMN(t,        "TIME",     int);
     74    GET_COLUMN(averef,   "AVE_REF",  int); // XXX signed vs unsigned?
     75    GET_COLUMN(imageID,  "IMAGE_ID", int);
     76    GET_COLUMN(dbFlags,  "DB_FLAGS", int);
     77    GET_COLUMN(catID,    "CAT_ID",   int);
     78    GET_COLUMN(photcode, "PHOTCODE", short);
     79    // XXX free the fits table data here
     80
     81    MeasureTiny *measure = NULL;
     82    ALLOCATE (measure, MeasureTiny, Nrow);
     83    for (i = 0; i < Nrow; i++) {
     84      measure[i].dR       = dR[i];
     85      measure[i].dD       = dD[i];
     86      measure[i].M        = M[i];
     87      measure[i].Mcal     = Mcal[i];
     88      measure[i].dM       = dM[i];
     89      measure[i].airmass  = airmass[i];
     90      measure[i].Xccd     = Xccd[i];
     91      measure[i].Yccd     = Yccd[i];
     92      measure[i].dt       = dt[i];
     93      measure[i].t        = t[i];
     94      measure[i].averef   = averef[i];
     95      measure[i].imageID  = imageID[i];
     96      measure[i].dbFlags  = dbFlags[i];
     97      measure[i].catID    = catID[i];
     98      measure[i].photcode = photcode[i];
     99    }
     100    fprintf (stderr, "loaded data for %lld measures\n", (long long) Nrow);
     101
     102    free (dR      );
     103    free (dD      );
     104    free (M       );
     105    free (Mcal    );
     106    free (dM      );
     107    free (airmass );
     108    free (Xccd    );
     109    free (Yccd    );
     110    free (dt      );
     111    free (t       );
     112    free (averef  );
     113    free (imageID );
     114    free (dbFlags );
     115    free (catID   );
     116    free (photcode);
     117
     118    catalog->measure = measure;
     119    catalog->Nmeasure = Nrow;
     120  }
    125121
    126122  /*** load Average values ***/
    127 
    128   // load data for this header
    129   if (!gfits_load_header (f, &theader)) return (NULL);
    130 
    131   // read the fits table bytes
    132   if (!gfits_fread_ftable_data (f, &ftable, FALSE)) return (NULL);
     123  {
     124
     125    // load data for this header
     126    if (!gfits_load_header (f, &theader)) return (NULL);
     127
     128    // read the fits table bytes
     129    if (!gfits_fread_ftable_data (f, &ftable, FALSE)) return (NULL);
    133130 
    134   // need to create and assign to flat-field correction
    135   GET_COLUMN(R,             "RA",          double);
    136   GET_COLUMN(D,             "DEC",         double);
    137   GET_COLUMN(Nmeasure,      "NMEAS",       int);
    138   GET_COLUMN(measureOffset, "MEASURE_OFF", int);
    139   GET_COLUMN(flags,         "FLAGS",       int);
    140   GET_COLUMN(catID,         "CAT_ID",      int);
    141   // XXX free the fits table data here
    142 
    143   ALLOCATE (average, AverageTiny, Nrow);
    144   for (i = 0; i < Nrow; i++) {
    145     average[i].R              = R[i];
    146     average[i].D              = D[i];
    147     average[i].Nmeasure       = Nmeasure[i];
    148     average[i].measureOffset  = measureOffset[i];
    149     average[i].flags          = flags[i];
    150     average[i].catID          = catID[i];
    151   }
    152   fprintf (stderr, "loaded data for %lld averages\n", (long long) Nrow);
    153 
    154   free (R             );
    155   free (D             );
    156   free (Nmeasure      );
    157   free (measureOffset );
    158   free (flags         );
    159   free (catID         );
    160 
    161   catalog->average = average;
    162   catalog->Naverage = Nrow;
     131    // need to create and assign to flat-field correction
     132    GET_COLUMN(R,             "RA",        double);
     133    GET_COLUMN(D,             "DEC",       double);
     134    GET_COLUMN(Nmeasure,      "NMEAS",       int);
     135    GET_COLUMN(measureOffset, "MEASURE_OFF", int);
     136    GET_COLUMN(flags,         "FLAGS",       int);
     137    GET_COLUMN(catID,         "CAT_ID",      int);
     138    // XXX free the fits table data here
     139
     140    AverageTiny *average = NULL;
     141    ALLOCATE (average, AverageTiny, Nrow);
     142    for (i = 0; i < Nrow; i++) {
     143      average[i].R              = R[i];
     144      average[i].D              = D[i];
     145      average[i].Nmeasure       = Nmeasure[i];
     146      average[i].measureOffset  = measureOffset[i];
     147      average[i].flags          = flags[i];
     148      average[i].catID          = catID[i];
     149    }
     150    fprintf (stderr, "loaded data for %lld averages\n", (long long) Nrow);
     151
     152    free (R             );
     153    free (D             );
     154    free (Nmeasure      );
     155    free (measureOffset );
     156    free (flags         );
     157    free (catID         );
     158
     159    catalog->average = average;
     160    catalog->Naverage = Nrow;
     161  }
    163162
    164163  /*** load Secfilt values ***/
    165 
    166   // load data for this header
    167   if (!gfits_load_header (f, &theader)) return (NULL);
    168 
    169   // read the fits table bytes
    170   if (!gfits_fread_ftable_data (f, &ftable, FALSE)) return (NULL);
     164  {
     165
     166    // load data for this header
     167    if (!gfits_load_header (f, &theader)) return (NULL);
     168
     169    // read the fits table bytes
     170    if (!gfits_fread_ftable_data (f, &ftable, FALSE)) return (NULL);
    171171 
    172   // need to create and assign to flat-field correction
    173   GET_COLUMN(M,     "MAG",      float);
    174   GET_COLUMN(dM,    "MAG_ERR",  float);
    175   GET_COLUMN(Xm,    "MAG_CHI",  float);
    176   GET_COLUMN(flags, "FLAGS",    int);
    177   GET_COLUMN(Ncode, "NCODE",    short);
    178   GET_COLUMN(Nused, "NUSED",    short);
    179   GET_COLUMN(M_20,  "MAG_20",   short);
    180   GET_COLUMN(M_80,  "MAG_80",   short);
    181   // XXX free the fits table data here
    182 
    183   ALLOCATE (secfilt, SecFilt, Nrow);
    184   for (i = 0; i < Nrow; i++) {
    185     secfilt[i].M     = M[i];         
    186     secfilt[i].dM    = dM[i];
    187     secfilt[i].Xm    = Xm[i];
    188     secfilt[i].flags = flags[i];
    189     secfilt[i].Ncode = Ncode[i];
    190     secfilt[i].Nused = Nused[i];
    191     secfilt[i].M_20  = M_20[i];
    192     secfilt[i].M_80  = M_80[i];
    193   }
    194   fprintf (stderr, "loaded data for %lld averages\n", (long long) Nrow);
    195 
    196   free (M    );
    197   free (dM   );
    198   free (Xm   );
    199   free (flags);
    200   free (Ncode);
    201   free (Nused);
    202   free (M_20 );
    203   free (M_80 );
    204 
    205   catalog->secfilt = secfilt;
    206   // assert Nsecfilt * Naverage = Nrow?
     172    // need to create and assign to flat-field correction
     173    GET_COLUMN(M,     "MAG",      float);
     174    GET_COLUMN(dM,    "MAG_ERR",  float);
     175    GET_COLUMN(Xm,    "MAG_CHI",  float);
     176    GET_COLUMN(flags, "FLAGS",    int);
     177    GET_COLUMN(Ncode, "NCODE",    short);
     178    GET_COLUMN(Nused, "NUSED",    short);
     179    GET_COLUMN(M_20,  "MAG_20",   short);
     180    GET_COLUMN(M_80,  "MAG_80",   short);
     181    // XXX free the fits table data here
     182
     183    SecFilt *secfilt = NULL;
     184    ALLOCATE (secfilt, SecFilt, Nrow);
     185    for (i = 0; i < Nrow; i++) {
     186      secfilt[i].M     = M[i];         
     187      secfilt[i].dM    = dM[i];
     188      secfilt[i].Xm    = Xm[i];
     189      secfilt[i].flags = flags[i];
     190      secfilt[i].Ncode = Ncode[i];
     191      secfilt[i].Nused = Nused[i];
     192      secfilt[i].M_20  = M_20[i];
     193      secfilt[i].M_80  = M_80[i];
     194    }
     195    fprintf (stderr, "loaded data for %lld averages\n", (long long) Nrow);
     196
     197    free (M    );
     198    free (dM   );
     199    free (Xm   );
     200    free (flags);
     201    free (Ncode);
     202    free (Nused);
     203    free (M_20 );
     204    free (M_80 );
     205    catalog->secfilt = secfilt;
     206    // assert Nsecfilt * Naverage = Nrow?
     207  }
    207208
    208209  // close files
    … …  
    237238
    238239  /*** MeasureTiny ***/
    239   gfits_create_table_header (&theader, "BINTABLE", "MEASURE_TINY");
    240 
    241   gfits_define_bintable_column (&theader, "E", "RA_OFF",   "ra offset",                "arcsec", 1.0, 0.0);
    242   gfits_define_bintable_column (&theader, "E", "DEC_OFF",  "dec offset",               "arcsec", 1.0, 0.0);
    243   gfits_define_bintable_column (&theader, "E", "MAG_SYS",  "magnitude (sys)",          NULL,     1.0, 0.0);
    244   gfits_define_bintable_column (&theader, "E", "MAG_CAL",  "magnitude (cal)",          NULL,     1.0, 0.0);
    245   gfits_define_bintable_column (&theader, "E", "MAG_ERR",  "magnitude (err)",          NULL,     1.0, 0.0);
    246   gfits_define_bintable_column (&theader, "E", "AIRMASS",  "airmass",                  NULL,     1.0, 0.0);
    247   gfits_define_bintable_column (&theader, "E", "X_CCD",    "ccd x coord",              "pix",    1.0, 0.0);
    248   gfits_define_bintable_column (&theader, "E", "Y_CCD",    "ccd y coord",              "pix",    1.0, 0.0);
    249   gfits_define_bintable_column (&theader, "E", "EXPTIME",  "-2.5 * log (exposure time)", "sec",  1.0, 0.0);
    250   gfits_define_bintable_column (&theader, "J", "TIME",     "time of exp",              "sec",    1.0, 1.0*0x8000);
    251   gfits_define_bintable_column (&theader, "J", "AVE_REF",  "pointer to average table", NULL,     1.0, 1.0*0x8000);
    252   gfits_define_bintable_column (&theader, "J", "IMAGE_ID", "image",                    NULL,     1.0, 1.0*0x8000);
    253   gfits_define_bintable_column (&theader, "J", "DB_FLAGS", "flags",                    NULL,     1.0, 1.0*0x8000);
    254   gfits_define_bintable_column (&theader, "J", "CAT_ID",   "catalog",                  NULL,     1.0, 0.0);
    255   gfits_define_bintable_column (&theader, "K", "PHOTCODE", "photcode",                 NULL,     1.0, 0.0);
    256 
    257   // generate the output array that carries the data
    258   gfits_create_table (&theader, &ftable);
    259 
    260   // create intermediate storage arrays
    261   float *dR        ; ALLOCATE (dR      ,  float, catalog->Nmeasure);
    262   float *dD        ; ALLOCATE (dD      ,  float, catalog->Nmeasure);
    263   float *M         ; ALLOCATE (M       ,  float, catalog->Nmeasure);
    264   float *Mcal      ; ALLOCATE (Mcal    ,  float, catalog->Nmeasure);
    265   float *dM        ; ALLOCATE (dM      ,  float, catalog->Nmeasure);
    266   float *airmass   ; ALLOCATE (airmass ,  float, catalog->Nmeasure);
    267   float *Xccd      ; ALLOCATE (Xccd    ,  float, catalog->Nmeasure);
    268   float *Yccd      ; ALLOCATE (Yccd    ,  float, catalog->Nmeasure);
    269   float *dt        ; ALLOCATE (dt      ,  float, catalog->Nmeasure);
    270   int   *t         ; ALLOCATE (t       ,  int  , catalog->Nmeasure);
    271   int   *averef    ; ALLOCATE (averef  ,  int  , catalog->Nmeasure);
    272   int   *imageID   ; ALLOCATE (imageID ,  int  , catalog->Nmeasure);
    273   int   *dbFlags   ; ALLOCATE (dbFlags ,  int  , catalog->Nmeasure);
    274   int   *catID     ; ALLOCATE (catID   ,  int  , catalog->Nmeasure);
    275   short *photcode  ; ALLOCATE (photcode,  short, catalog->Nmeasure);
    276 
    277   // assign the storage arrays
    278   for (i = 0; i < catalog->Nmeasure; i++) {
    279     dR[i]       = measure[i].dR       ;
    280     dD[i]       = measure[i].dD       ;
    281     M[i]        = measure[i].M        ;
    282     Mcal[i]     = measure[i].Mcal     ;
    283     dM[i]       = measure[i].dM       ;
    284     airmass[i]  = measure[i].airmass  ;
    285     Xccd[i]     = measure[i].Xccd     ;
    286     Yccd[i]     = measure[i].Yccd     ;
    287     dt[i]       = measure[i].dt       ;
    288     t[i]        = measure[i].t        ;
    289     averef[i]   = measure[i].averef   ;
    290     catID[i]    = measure[i].catID    ;
    291     imageID[i]  = measure[i].imageID  ;
    292     dbFlags[i]  = measure[i].dbFlags  ;
    293     photcode[i] = measure[i].photcode ;
    294   }
    295 
    296   // add the columns to the output array
    297   gfits_set_bintable_column (&theader, &ftable, "RA_OFF",   dR,       catalog->Nmeasure);
    298   gfits_set_bintable_column (&theader, &ftable, "DEC_OFF",  dD,       catalog->Nmeasure);
    299   gfits_set_bintable_column (&theader, &ftable, "MAG_SYS",  M,        catalog->Nmeasure);
    300   gfits_set_bintable_column (&theader, &ftable, "MAG_CAL",  Mcal,     catalog->Nmeasure);
    301   gfits_set_bintable_column (&theader, &ftable, "MAG_ERR",  dM,       catalog->Nmeasure);
    302   gfits_set_bintable_column (&theader, &ftable, "AIRMASS",  airmass,  catalog->Nmeasure);
    303   gfits_set_bintable_column (&theader, &ftable, "X_CCD",    Xccd,     catalog->Nmeasure);
    304   gfits_set_bintable_column (&theader, &ftable, "Y_CCD",    Yccd,     catalog->Nmeasure);
    305   gfits_set_bintable_column (&theader, &ftable, "EXPTIME",  dt,       catalog->Nmeasure);
    306   gfits_set_bintable_column (&theader, &ftable, "TIME",     t,        catalog->Nmeasure);
    307   gfits_set_bintable_column (&theader, &ftable, "AVE_REF",  averef,   catalog->Nmeasure);
    308   gfits_set_bintable_column (&theader, &ftable, "IMAGE_ID", imageID,  catalog->Nmeasure);
    309   gfits_set_bintable_column (&theader, &ftable, "DB_FLAGS", dbFlags,  catalog->Nmeasure);
    310   gfits_set_bintable_column (&theader, &ftable, "CAT_ID",   catID,    catalog->Nmeasure);
    311   gfits_set_bintable_column (&theader, &ftable, "PHOTCODE", photcode, catalog->Nmeasure);
    312 
    313   free (dR      );
    314   free (dD      );
    315   free (M       );
    316   free (Mcal    );
    317   free (dM      );
    318   free (airmass );
    319   free (Xccd    );
    320   free (Yccd    );
    321   free (dt      );
    322   free (t       );
    323   free (averef  );
    324   free (imageID );
    325   free (dbFlags );
    326   free (catID   );
    327   free (photcode);
    328 
    329   gfits_fwrite_Theader (f, &theader);
    330   gfits_fwrite_table  (f, &ftable);
    331   gfits_free_header (&theader);
    332   gfits_free_table (&ftable);
     240  {
     241    gfits_create_table_header (&theader, "BINTABLE", "MEASURE_TINY");
     242
     243    gfits_define_bintable_column (&theader, "E", "RA_OFF",   "ra offset",              "arcsec", 1.0, 0.0);
     244    gfits_define_bintable_column (&theader, "E", "DEC_OFF",  "dec offset",             "arcsec", 1.0, 0.0);
     245    gfits_define_bintable_column (&theader, "E", "MAG_SYS",  "magnitude (sys)",                NULL,     1.0, 0.0);
     246    gfits_define_bintable_column (&theader, "E", "MAG_CAL",  "magnitude (cal)",                NULL,     1.0, 0.0);
     247    gfits_define_bintable_column (&theader, "E", "MAG_ERR",  "magnitude (err)",                NULL,     1.0, 0.0);
     248    gfits_define_bintable_column (&theader, "E", "AIRMASS",  "airmass",                  NULL,   1.0, 0.0);
     249    gfits_define_bintable_column (&theader, "E", "X_CCD",    "ccd x coord",            "pix",    1.0, 0.0);
     250    gfits_define_bintable_column (&theader, "E", "Y_CCD",    "ccd y coord",            "pix",    1.0, 0.0);
     251    gfits_define_bintable_column (&theader, "E", "EXPTIME",  "-2.5 * log (exposure time)", "sec",        1.0, 0.0);
     252    gfits_define_bintable_column (&theader, "J", "TIME",     "time of exp",              "sec",          1.0, 1.0*0x8000);
     253    gfits_define_bintable_column (&theader, "J", "AVE_REF",  "pointer to average table", NULL,   1.0, 1.0*0x8000);
     254    gfits_define_bintable_column (&theader, "J", "IMAGE_ID", "image",                          NULL,     1.0, 1.0*0x8000);
     255    gfits_define_bintable_column (&theader, "J", "DB_FLAGS", "flags",                          NULL,     1.0, 1.0*0x8000);
     256    gfits_define_bintable_column (&theader, "J", "CAT_ID",   "catalog",                        NULL,     1.0, 0.0);
     257    gfits_define_bintable_column (&theader, "K", "PHOTCODE", "photcode",                       NULL,     1.0, 0.0);
     258
     259    // generate the output array that carries the data
     260    gfits_create_table (&theader, &ftable);
     261
     262    // create intermediate storage arrays
     263    float *dR        ; ALLOCATE (dR      ,  float, catalog->Nmeasure);
     264    float *dD        ; ALLOCATE (dD      ,  float, catalog->Nmeasure);
     265    float *M         ; ALLOCATE (M       ,  float, catalog->Nmeasure);
     266    float *Mcal      ; ALLOCATE (Mcal    ,  float, catalog->Nmeasure);
     267    float *dM        ; ALLOCATE (dM      ,  float, catalog->Nmeasure);
     268    float *airmass   ; ALLOCATE (airmass ,  float, catalog->Nmeasure);
     269    float *Xccd      ; ALLOCATE (Xccd    ,  float, catalog->Nmeasure);
     270    float *Yccd      ; ALLOCATE (Yccd    ,  float, catalog->Nmeasure);
     271    float *dt        ; ALLOCATE (dt      ,  float, catalog->Nmeasure);
     272    int   *t         ; ALLOCATE (t       ,  int  , catalog->Nmeasure);
     273    int   *averef    ; ALLOCATE (averef  ,  int  , catalog->Nmeasure);
     274    int   *imageID   ; ALLOCATE (imageID ,  int  , catalog->Nmeasure);
     275    int   *dbFlags   ; ALLOCATE (dbFlags ,  int  , catalog->Nmeasure);
     276    int   *catID     ; ALLOCATE (catID   ,  int  , catalog->Nmeasure);
     277    short *photcode  ; ALLOCATE (photcode,  short, catalog->Nmeasure);
     278
     279    // assign the storage arrays
     280    MeasureTiny *measure = catalog->measure;
     281    for (i = 0; i < catalog->Nmeasure; i++) {
     282      dR[i]       = measure[i].dR       ;
     283      dD[i]       = measure[i].dD       ;
     284      M[i]        = measure[i].M        ;
     285      Mcal[i]     = measure[i].Mcal     ;
     286      dM[i]       = measure[i].dM       ;
     287      airmass[i]  = measure[i].airmass  ;
     288      Xccd[i]     = measure[i].Xccd     ;
     289      Yccd[i]     = measure[i].Yccd     ;
     290      dt[i]       = measure[i].dt       ;
     291      t[i]        = measure[i].t        ;
     292      averef[i]   = measure[i].averef   ;
     293      catID[i]    = measure[i].catID    ;
     294      imageID[i]  = measure[i].imageID  ;
     295      dbFlags[i]  = measure[i].dbFlags  ;
     296      photcode[i] = measure[i].photcode ;
     297    }
     298
     299    // add the columns to the output array
     300    gfits_set_bintable_column (&theader, &ftable, "RA_OFF",   dR,       catalog->Nmeasure);
     301    gfits_set_bintable_column (&theader, &ftable, "DEC_OFF",  dD,       catalog->Nmeasure);
     302    gfits_set_bintable_column (&theader, &ftable, "MAG_SYS",  M,        catalog->Nmeasure);
     303    gfits_set_bintable_column (&theader, &ftable, "MAG_CAL",  Mcal,     catalog->Nmeasure);
     304    gfits_set_bintable_column (&theader, &ftable, "MAG_ERR",  dM,       catalog->Nmeasure);
     305    gfits_set_bintable_column (&theader, &ftable, "AIRMASS",  airmass,  catalog->Nmeasure);
     306    gfits_set_bintable_column (&theader, &ftable, "X_CCD",    Xccd,     catalog->Nmeasure);
     307    gfits_set_bintable_column (&theader, &ftable, "Y_CCD",    Yccd,     catalog->Nmeasure);
     308    gfits_set_bintable_column (&theader, &ftable, "EXPTIME",  dt,       catalog->Nmeasure);
     309    gfits_set_bintable_column (&theader, &ftable, "TIME",     t,        catalog->Nmeasure);
     310    gfits_set_bintable_column (&theader, &ftable, "AVE_REF",  averef,   catalog->Nmeasure);
     311    gfits_set_bintable_column (&theader, &ftable, "IMAGE_ID", imageID,  catalog->Nmeasure);
     312    gfits_set_bintable_column (&theader, &ftable, "DB_FLAGS", dbFlags,  catalog->Nmeasure);
     313    gfits_set_bintable_column (&theader, &ftable, "CAT_ID",   catID,    catalog->Nmeasure);
     314    gfits_set_bintable_column (&theader, &ftable, "PHOTCODE", photcode, catalog->Nmeasure);
     315
     316    free (dR      );
     317    free (dD      );
     318    free (M       );
     319    free (Mcal    );
     320    free (dM      );
     321    free (airmass );
     322    free (Xccd    );
     323    free (Yccd    );
     324    free (dt      );
     325    free (t       );
     326    free (averef  );
     327    free (imageID );
     328    free (dbFlags );
     329    free (catID   );
     330    free (photcode);
     331
     332    gfits_fwrite_Theader (f, &theader);
     333    gfits_fwrite_table  (f, &ftable);
     334    gfits_free_header (&theader);
     335    gfits_free_table (&ftable);
     336  }
    333337
    334338  /*** AverageTiny ***/
    335   gfits_create_table_header (&theader, "BINTABLE", "AVERAGE_TINY");
    336 
    337   gfits_define_bintable_column (&theader, "D", "RA",          "ra (J2000)",            "degree", 1.0, 0.0);
    338   gfits_define_bintable_column (&theader, "D", "DEC",         "dec (J2000)",           "degree", 1.0, 0.0);
    339   gfits_define_bintable_column (&theader, "J", "NMEAS",       "number of measures",     NULL,    1.0, 0.0);
    340   gfits_define_bintable_column (&theader, "J", "MEASURE_OFF", "index to measurements",  NULL,    1.0, 0.0);
    341   gfits_define_bintable_column (&theader, "J", "FLAGS",       "flags",                  NULL,    1.0, 0.0);
    342   gfits_define_bintable_column (&theader, "J", "CAT_ID",      "catalog ref",            NULL,    1.0, 0.0);
    343 
    344   // generate the output array that carries the data
    345   gfits_create_table (&theader, &ftable);
    346 
    347   // create intermediate storage arrays
    348   double *R             ; ALLOCATE (R,             double, catalog->Naverage);
    349   double *D             ; ALLOCATE (D,             double, catalog->Naverage);
    350   int   *Nmeasure       ; ALLOCATE (Nmeasure,      int,    catalog->Naverage);
    351   int   *measureOffset  ; ALLOCATE (measureOffset, int,    catalog->Naverage);
    352   int   *flags          ; ALLOCATE (flags,         int,    catalog->Naverage);
    353   int   *catID          ; ALLOCATE (catID,         int,    catalog->Naverage);
    354 
    355   // assign the storage arrays
    356   for (i = 0; i < catalog->Nmeasure; i++) {
     339  {
     340    gfits_create_table_header (&theader, "BINTABLE", "AVERAGE_TINY");
     341
     342    gfits_define_bintable_column (&theader, "D", "RA",                "ra (J2000)",            "degree", 1.0, 0.0);
     343    gfits_define_bintable_column (&theader, "D", "DEC",               "dec (J2000)",           "degree", 1.0, 0.0);
     344    gfits_define_bintable_column (&theader, "J", "NMEAS",       "number of measures",     NULL,          1.0, 0.0);
     345    gfits_define_bintable_column (&theader, "J", "MEASURE_OFF", "index to measurements",  NULL,          1.0, 0.0);
     346    gfits_define_bintable_column (&theader, "J", "FLAGS",       "flags",                  NULL,          1.0, 0.0);
     347    gfits_define_bintable_column (&theader, "J", "CAT_ID",      "catalog ref",            NULL,          1.0, 0.0);
     348
     349    // generate the output array that carries the data
     350    gfits_create_table (&theader, &ftable);
     351
     352    // create intermediate storage arrays
     353    double *R             ; ALLOCATE (R,             double, catalog->Naverage);
     354    double *D             ; ALLOCATE (D,             double, catalog->Naverage);
     355    int   *Nmeasure       ; ALLOCATE (Nmeasure,      int,    catalog->Naverage);
     356    int   *measureOffset  ; ALLOCATE (measureOffset, int,    catalog->Naverage);
     357    int   *flags          ; ALLOCATE (flags,         int,    catalog->Naverage);
     358    int   *catID          ; ALLOCATE (catID,         int,    catalog->Naverage);
     359
     360    // assign the storage arrays
     361    AverageTiny *average = catalog->average;
     362    for (i = 0; i < catalog->Naverage; i++) {
    357363      R[i]              = average[i].R       ;
    358364      D[i]              = average[i].D       ;
    … …  
    361367      flags[i]          = average[i].flags;
    362368      catID[i]          = average[i].catID;
    363   }
    364 
    365   // add the columns to the output array
    366   gfits_set_bintable_column (&theader, &ftable, "RA",          R,             catalog->Naverage);
    367   gfits_set_bintable_column (&theader, &ftable, "DEC",         D,             catalog->Naverage);
    368   gfits_set_bintable_column (&theader, &ftable, "NMEAS",       Nmeasure,      catalog->Naverage);
    369   gfits_set_bintable_column (&theader, &ftable, "MEASURE_OFF", measureOffset, catalog->Naverage);
    370   gfits_set_bintable_column (&theader, &ftable, "FLAGS",       flags,         catalog->Naverage);
    371   gfits_set_bintable_column (&theader, &ftable, "CAT_ID",      catID,         catalog->Naverage);
    372 
    373   free (R             );
    374   free (D             );
    375   free (Nmeasure      );
    376   free (measureOffset );
    377   free (flags         );
    378   free (catID         );
    379 
    380   gfits_fwrite_Theader (f, &theader);
    381   gfits_fwrite_table  (f, &ftable);
    382   gfits_free_header (&theader);
    383   gfits_free_table (&ftable);
     369    }
     370
     371    // add the columns to the output array
     372    gfits_set_bintable_column (&theader, &ftable, "RA",          R,             catalog->Naverage);
     373    gfits_set_bintable_column (&theader, &ftable, "DEC",         D,             catalog->Naverage);
     374    gfits_set_bintable_column (&theader, &ftable, "NMEAS",       Nmeasure,      catalog->Naverage);
     375    gfits_set_bintable_column (&theader, &ftable, "MEASURE_OFF", measureOffset, catalog->Naverage);
     376    gfits_set_bintable_column (&theader, &ftable, "FLAGS",       flags,         catalog->Naverage);
     377    gfits_set_bintable_column (&theader, &ftable, "CAT_ID",      catID,         catalog->Naverage);
     378
     379    free (R             );
     380    free (D             );
     381    free (Nmeasure      );
     382    free (measureOffset );
     383    free (flags         );
     384    free (catID         );
     385
     386    gfits_fwrite_Theader (f, &theader);
     387    gfits_fwrite_table  (f, &ftable);
     388    gfits_free_header (&theader);
     389    gfits_free_table (&ftable);
     390  }
    384391
    385392  /*** SecFilt ***/
    386   gfits_create_table_header (&theader, "BINTABLE", "SECFILT");
    387 
    388   gfits_define_bintable_column (&theader, "E", "MAG",      "ra offset",                "arcsec", 1.0, 0.0);
    389   gfits_define_bintable_column (&theader, "E", "MAG_ERR",  "dec offset",               "arcsec", 1.0, 0.0);
    390   gfits_define_bintable_column (&theader, "E", "MAG_CHI",  "magnitude (sys)",          NULL,     1.0, 0.0);
    391   gfits_define_bintable_column (&theader, "J", "FLAGS",    "magnitude (cal)",          NULL,     1.0, 0.0);
    392   gfits_define_bintable_column (&theader, "I", "NCODE",    "magnitude (err)",          NULL,     1.0, 0.0);
    393   gfits_define_bintable_column (&theader, "I", "NUSED",    "airmass",                  NULL,     1.0, 0.0);
    394   gfits_define_bintable_column (&theader, "I", "MAG_20",   "ccd x coord",              "pix",    1.0, 0.0);
    395   gfits_define_bintable_column (&theader, "I", "MAG_80",   "ccd y coord",              "pix",    1.0, 0.0);
    396 
    397   // generate the output array that carries the data
    398   gfits_create_table (&theader, &ftable);
    399 
    400   // create intermediate storage arrays
    401   float *M        ; ALLOCATE (M      ,  float, catalog->Nmeasure);
    402   float *dM       ; ALLOCATE (dM     ,  float, catalog->Nmeasure);
    403   float *Xm       ; ALLOCATE (Xm     ,  float, catalog->Nmeasure);
    404   int   *flags    ; ALLOCATE (flags  ,  int,   catalog->Nmeasure);
    405   short *Ncode    ; ALLOCATE (Ncode  ,  short, catalog->Nmeasure);
    406   short *Nused    ; ALLOCATE (Nused  ,  short, catalog->Nmeasure);
    407   short *M_20     ; ALLOCATE (M_20   ,  short, catalog->Nmeasure);
    408   short *M_80     ; ALLOCATE (M_80   ,  short, catalog->Nmeasure);
    409 
    410   // assign the storage arrays
    411   for (i = 0; i < catalog->Nmeasure; i++) {
    412     M     [i]       = secfilt[i]. M      ;
    413     dM    [i]       = secfilt[i]. dM     ;
    414     Xm    [i]       = secfilt[i]. Xm     ;
    415     flags [i]       = secfilt[i]. flags  ;
    416     Ncode [i]       = secfilt[i]. Ncode  ;
    417     Nused [i]       = secfilt[i]. Nused  ;
    418     M_20  [i]       = secfilt[i]. M_20   ;
    419     M_80  [i]       = secfilt[i]. M_80   ;
    420   }
    421 
    422   // add the columns to the output array
    423   gfits_set_bintable_column (&theader, &ftable, "MAG",      M     ,catalog->Nmeasure);
    424   gfits_set_bintable_column (&theader, &ftable, "MAG_ERR",  dM    ,catalog->Nmeasure);
    425   gfits_set_bintable_column (&theader, &ftable, "MAG_CHI",  Xm    ,catalog->Nmeasure);
    426   gfits_set_bintable_column (&theader, &ftable, "FLAGS",    flags ,catalog->Nmeasure);
    427   gfits_set_bintable_column (&theader, &ftable, "NCODE",    Ncode ,catalog->Nmeasure);
    428   gfits_set_bintable_column (&theader, &ftable, "NUSED",    Nused ,catalog->Nmeasure);
    429   gfits_set_bintable_column (&theader, &ftable, "MAG_20",   M_20  ,catalog->Nmeasure);
    430   gfits_set_bintable_column (&theader, &ftable, "MAG_80",   M_80  ,catalog->Nmeasure);
    431 
    432   free (M      );
    433   free (dM     );
    434   free (Xm     );
    435   free (flags  );
    436   free (Ncode  );
    437   free (Nused  );
    438   free (M_20   );
    439   free (M_80   );
    440 
    441   gfits_fwrite_Theader (f, &theader);
    442   gfits_fwrite_table  (f, &ftable);
    443   gfits_free_header (&theader);
    444   gfits_free_table (&ftable);
    445 
     393  {
     394    gfits_create_table_header (&theader, "BINTABLE", "SECFILT");
     395
     396    gfits_define_bintable_column (&theader, "E", "MAG",      "ra offset",                "arcsec", 1.0, 0.0);
     397    gfits_define_bintable_column (&theader, "E", "MAG_ERR",  "dec offset",               "arcsec", 1.0, 0.0);
     398    gfits_define_bintable_column (&theader, "E", "MAG_CHI",  "magnitude (sys)",          NULL,     1.0, 0.0);
     399    gfits_define_bintable_column (&theader, "J", "FLAGS",    "magnitude (cal)",          NULL,     1.0, 0.0);
     400    gfits_define_bintable_column (&theader, "I", "NCODE",    "magnitude (err)",          NULL,     1.0, 0.0);
     401    gfits_define_bintable_column (&theader, "I", "NUSED",    "airmass",                  NULL,     1.0, 0.0);
     402    gfits_define_bintable_column (&theader, "I", "MAG_20",   "ccd x coord",              "pix",    1.0, 0.0);
     403    gfits_define_bintable_column (&theader, "I", "MAG_80",   "ccd y coord",              "pix",    1.0, 0.0);
     404
     405    // generate the output array that carries the data
     406    gfits_create_table (&theader, &ftable);
     407
     408    // Nsecfilt is number of average filters, Nsec is total number of values
     409    int Nsecfilt = GetPhotcodeNsecfilt();
     410    int Nsec = Nsecfilt * catalog->Naverage;
     411
     412    // create intermediate storage arrays
     413    float *M        ; ALLOCATE (M      ,  float, Nsec);
     414    float *dM       ; ALLOCATE (dM     ,  float, Nsec);
     415    float *Xm       ; ALLOCATE (Xm     ,  float, Nsec);
     416    int   *flags    ; ALLOCATE (flags  ,  int,   Nsec);
     417    short *Ncode    ; ALLOCATE (Ncode  ,  short, Nsec);
     418    short *Nused    ; ALLOCATE (Nused  ,  short, Nsec);
     419    short *M_20     ; ALLOCATE (M_20   ,  short, Nsec);
     420    short *M_80     ; ALLOCATE (M_80   ,  short, Nsec);
     421
     422    // assign the storage arrays
     423    SecFilt *secfilt = catalog->secfilt;
     424    for (i = 0; i < Nsec; i++) {
     425      M     [i]       = secfilt[i]. M      ;
     426      dM    [i]       = secfilt[i]. dM     ;
     427      Xm    [i]       = secfilt[i]. Xm     ;
     428      flags [i]       = secfilt[i]. flags  ;
     429      Ncode [i]       = secfilt[i]. Ncode  ;
     430      Nused [i]       = secfilt[i]. Nused  ;
     431      M_20  [i]       = secfilt[i]. M_20   ;
     432      M_80  [i]       = secfilt[i]. M_80   ;
     433    }
     434
     435    // add the columns to the output array
     436    gfits_set_bintable_column (&theader, &ftable, "MAG",      M    , Nsec);
     437    gfits_set_bintable_column (&theader, &ftable, "MAG_ERR",  dM   , Nsec);
     438    gfits_set_bintable_column (&theader, &ftable, "MAG_CHI",  Xm   , Nsec);
     439    gfits_set_bintable_column (&theader, &ftable, "FLAGS",    flags, Nsec);
     440    gfits_set_bintable_column (&theader, &ftable, "NCODE",    Ncode, Nsec);
     441    gfits_set_bintable_column (&theader, &ftable, "NUSED",    Nused, Nsec);
     442    gfits_set_bintable_column (&theader, &ftable, "MAG_20",   M_20 , Nsec);
     443    gfits_set_bintable_column (&theader, &ftable, "MAG_80",   M_80 , Nsec);
     444
     445    free (M      );
     446    free (dM     );
     447    free (Xm     );
     448    free (flags  );
     449    free (Ncode  );
     450    free (Nused  );
     451    free (M_20   );
     452    free (M_80   );
     453
     454    gfits_fwrite_Theader (f, &theader);
     455    gfits_fwrite_table  (f, &ftable);
     456    gfits_free_header (&theader);
     457    gfits_free_table (&ftable);
     458  }
    446459  return TRUE;
    447460}
    448461
    449462BrightCatalog *BrightCatalogMerge (Catalog *catalog, int Ncatalog) {
     463
     464  off_t i, j, k;
    450465
    451466  BrightCatalog *bcatalog = NULL;
    … …  
    466481  for (i = 0; i < Ncatalog; i++) {
    467482    for (j = 0; j < catalog[i].Naverage; j++) {
    468       bcatalog[0].average[Na] = catalog[i].average[j];
     483      CopyAverageTiny (&bcatalog[0].average[Na], &catalog[i].average[j]);
     484      bcatalog[0].average[Na].catID = catalog[i].catID;
     485      int Nsecfilt = catalog[i].Nsecfilt;
    469486      for (k = 0; k < Nsecfilt; k++) {
    470487        bcatalog[0].secfilt[Nsecfilt*Na + k] = catalog[i].secfilt[Nsecfilt*j + k];
    … …  
    474491    }
    475492    for (j = 0; j < catalog[i].Nmeasure; j++) {
    476       bcatalog[0].measure[Nm] = catalog[i].measure[j];
     493      CopyMeasureTiny (&bcatalog[0].measure[Nm], &catalog[i].measure[j]);
     494      bcatalog[0].measure[Nm].catID = catalog[i].catID;
    477495      Nm++;
    478496      assert (Nm <= Nmeas);

  • branches/eam_branches/ipp-20111122/Ohana/src/relphot/src/ImageOps.c

    r33169 r33254  
    5858  }
    5959  llsortpair (imageIDs, imageIdx, Nimage);
     60}
     61
     62void initImagesSubset (ImageSubset *input, off_t *line_number, off_t N) {
     63
     64  off_t i;
     65
     66  // we have been given an ImageSubset array, containing a reduced set of image fields
     67  // create full a Image array and save the needed values
     68  ALLOCATE (image, Image, N);
     69  for (i = 0; i < N; i++) {
     70    image[i].imageID       = input[i].imageID      ;
     71    image[i].photom_map_id = input[i].photom_map_id;
     72    image[i].flags         = input[i].flags        ;
     73    image[i].Mcal          = input[i].Mcal         ;
     74    image[i].dMcal         = input[i].dMcal        ;
     75    image[i].tzero         = input[i].tzero        ;
     76    image[i].trate         = input[i].trate        ;
     77  }
     78  LineNumber = line_number;
     79  Nimage = N;
     80
     81  ALLOCATE (imageIDs, off_t, Nimage);
     82  ALLOCATE (imageIdx, off_t, Nimage);
     83
     84  for (i = 0; i < Nimage; i++) {
     85    imageIdx[i] = i;
     86    imageIDs[i] = image[i].imageID;
     87  }
     88  llsortpair (imageIDs, imageIdx, Nimage);
     89}
     90
     91ImageSubset *getimages_subset (off_t *N) {
     92
     93  *N = Nimage;
     94
     95  off_t i;
     96
     97  // we have been given an ImageSubset array, containing a reduced set of image fields
     98  // create full a Image array and save the needed values
     99  ImageSubset *subset = NULL;
     100  ALLOCATE (subset, ImageSubset, Nimage);
     101  for (i = 0; i < Nimage; i++) {
     102    subset[i].imageID       = image[i].imageID      ;
     103    subset[i].photom_map_id = image[i].photom_map_id;
     104    subset[i].flags         = image[i].flags        ;
     105    subset[i].Mcal          = image[i].Mcal         ;
     106    subset[i].dMcal         = image[i].dMcal        ;
     107    subset[i].tzero         = image[i].tzero        ;
     108    subset[i].trate         = image[i].trate        ;
     109  }
     110  return subset;
    60111}
    61112
    … …  
    131182}
    132183
    133 /* select all image equivalent to the active photcode set */
     184/* select all images equivalent to the active photcode set */
    134185void findImages (Catalog *catalog, int Ncatalog, int doImageList) {
    135186

  • branches/eam_branches/ipp-20111122/Ohana/src/relphot/src/ImageSubset.c

    r33244 r33254  
    11# include "relphot.h"
    22
    3 // this is (nearly?) identical to the one in 'uniphot/src' used by setphot / setphot_client
    4 // there may be difference in the specific columns used, however (if not, we can move to libdvo?)
     3# define GET_COLUMN(OUT,NAME,TYPE) \
     4  TYPE *OUT = gfits_get_bintable_column_data (&theader, &ftable, NAME, type, &Nrow, &Ncol); \
     5  myAssert (!strcmp(type, #TYPE), "wrong column type");
     6
     7// this is nearly identical to the one in 'uniphot/src' used by setphot / setphot_client.
     8// Here, we use a handful of different columns (if not, we could move to libdvo)
    59ImageSubset *ImageSubsetLoad(char *filename, off_t *nimage) {
    610
    7   int i, Ncol, Ncol2;
     11  int i, Ncol;
    812  off_t Nrow;
    913  Header header;
    … …  
    4448  // XXX close the fits file here
    4549
    46   // a bit annoying : we read the entire block of data (180M), then extract the columns, then set the image structure values.
     50  // a bit annoying : we read the entire block of data, then extract the columns, then set the image structure values.
    4751  // this means I need 3 copies in memory at some point.  ugh.
    4852
    4953  char type[16];
    5054
    51   // need to create and assign to flat-field correction
    52   float *Mcal = gfits_get_bintable_column_data (&theader, &ftable, "MCAL", type, &Nrow, &Ncol);
    53   myAssert (!strcmp(type, "float"), "wrong column type");
    54 
    55   float *dMcal = gfits_get_bintable_column_data (&theader, &ftable, "MCAL_ERR", type, &Nrow, &Ncol2);
    56   myAssert (!strcmp(type, "float"), "wrong column type");
    57   myAssert (Ncol == Ncol2, "table length mismatch");
    58 
    59   unsigned int *imageID = gfits_get_bintable_column_data (&theader, &ftable, "IMAGE_ID", type, &Nrow, &Ncol2);
    60   myAssert (!strcmp(type, "int"), "wrong column type");
    61   myAssert (Ncol == Ncol2, "table length mismatch");
    62 
    63   unsigned int *map = gfits_get_bintable_column_data (&theader, &ftable, "PHOTOM_MAP", type, &Nrow, &Ncol2);
    64   myAssert (!strcmp(type, "int"), "wrong column type");
    65   myAssert (Ncol == Ncol2, "table length mismatch");
    66 
    67   unsigned int *flags = gfits_get_bintable_column_data (&theader, &ftable, "FLAGS", type, &Nrow, &Ncol2);
    68   myAssert (!strcmp(type, "int"), "wrong column type");
    69   myAssert (Ncol == Ncol2, "table length mismatch");
     55  GET_COLUMN (Mcal,    "MCAL",       float);
     56  GET_COLUMN (dMcal,   "MCAL_ERR",   float);
     57  GET_COLUMN (imageID, "IMAGE_ID",   int);
     58  GET_COLUMN (map,     "PHOTOM_MAP", int);
     59  GET_COLUMN (flags,   "FLAGS",      int);
     60  GET_COLUMN (tzero,   "TZERO",      int);
     61  GET_COLUMN (trate,   "TRATE",      char);
    7062
    7163  // XXX free the fits table data here
    … …  
    7365  ALLOCATE (image, ImageSubset, Nrow);
    7466  for (i = 0; i < Nrow; i++) {
     67    image[i].Mcal          = Mcal[i];
     68    image[i].dMcal         = dMcal[i];
    7569    image[i].imageID       = imageID[i];
    7670    image[i].photom_map_id = map[i];
    7771    image[i].flags         = flags[i];
    78     image[i].Mcal          = Mcal[i];
    79     image[i].dMcal         = dMcal[i];
     72    image[i].tzero         = tzero[i];
     73    image[i].trate         = trate[i];
    8074  }
    8175  fprintf (stderr, "loaded data for %lld images\n", (long long) Nrow);
    … …  
    8680  free (map);
    8781  free (flags);
     82  free (tzero);
     83  free (trate);
    8884
    8985  *nimage = Nrow;
    … …  
    9187}
    9288
    93 int ImageSubsetSave(char *filename, Image *image, off_t Nimage) {
     89int ImageSubsetSave(char *filename, ImageSubset *image, off_t Nimage) {
    9490
    9591  int i;
    … …  
    109105  gfits_define_bintable_column (&theader, "E", "MCAL_ERR", "zero point error", "magnitudes", 1.0, 0.0);
    110106
    111   // an unsigned int needs to have bzero of 0x8000
    112107  gfits_define_bintable_column (&theader, "J", "IMAGE_ID", "image ID", NULL, 1.0, 1.0*0x8000);
    113108  gfits_define_bintable_column (&theader, "J", "PHOTOM_MAP", "map", NULL, 1.0, 1.0*0x8000);
    114109  gfits_define_bintable_column (&theader, "J", "FLAGS", "flags", NULL, 1.0, 1.0*0x8000);
     110
     111  gfits_define_bintable_column (&theader, "J", "TZERO", "exposure start", NULL, 1.0, 1.0*0x8000);
     112  gfits_define_bintable_column (&theader, "I", "TRATE", "tti rate", NULL, 1.0, 0.0);
    115113
    116114  // generate the output array that carries the data
    … …  
    118116
    119117  float *Mcal, *dMcal;
    120   unsigned int *imageID, *map, *flags;
     118  unsigned int *imageID, *map, *flags, *tzero;
     119  unsigned char *trate;
    121120
    122   // create intermediate storage arrays
    123   ALLOCATE (Mcal,  float, Nimage);
    124   ALLOCATE (dMcal, float, Nimage);
     121  // create interme  diate storage arrays
     122  ALLOCATE (Mcal,    float,        Nimage);
     123  ALLOCATE (dMcal,   float,        Nimage);
    125124  ALLOCATE (imageID, unsigned int, Nimage);
    126125  ALLOCATE (map,     unsigned int, Nimage);
    127126  ALLOCATE (flags,   unsigned int, Nimage);
     127  ALLOCATE (tzero,   unsigned int, Nimage);
     128  ALLOCATE (trate,   unsigned char, Nimage);
    128129
    129130  // assign the storage arrays
    130131  for (i = 0; i < Nimage; i++) {
     132    Mcal[i]    = image[i].Mcal;
     133    dMcal[i]   = image[i].dMcal;
    131134    imageID[i] = image[i].imageID;
    132135    map[i]     = image[i].photom_map_id;
    133136    flags[i]   = image[i].flags;
    134     Mcal[i]    = image[i].Mcal;
    135     dMcal[i]   = image[i].dMcal;
     137    tzero[i]   = image[i].tzero;
     138    trate[i]   = image[i].trate;
    136139  }
    137140
    … …  
    142145  gfits_set_bintable_column (&theader, &ftable, "PHOTOM_MAP", map,     Nimage);
    143146  gfits_set_bintable_column (&theader, &ftable, "FLAGS",      flags,   Nimage);
     147  gfits_set_bintable_column (&theader, &ftable, "TZERO",      tzero,   Nimage);
     148  gfits_set_bintable_column (&theader, &ftable, "TRATE",      trate,   Nimage);
    144149
    145150  free (Mcal);
    … …  
    148153  free (map);
    149154  free (flags);
     155  free (tzero);
     156  free (trate);
    150157
    151158  FILE *f = fopen (filename, "w");

  • branches/eam_branches/ipp-20111122/Ohana/src/relphot/src/args.c

    r33244 r33254  
    311311    if (MODE) {
    312312      fprintf (stderr, "ERROR: cannot use both -load and -update options!\n");
    313       usage();
     313      relphot_client_usage();
    314314    }
    315315    MODE = MODE_UPDATE;

  • branches/eam_branches/ipp-20111122/Ohana/src/relphot/src/initialize.c

    r33244 r33254  
    9696}
    9797
    98 void initialize_relphot_client (int argc, char **argv) {
    99 
    100   int N;
     98void initialize_client (int argc, char **argv) {
    10199
    102100  relphot_client_help (argc, argv);

  • branches/eam_branches/ipp-20111122/Ohana/src/relphot/src/load_catalogs.c

    r33244 r33254  
    1616
    1717  // XXX need to decide how to determine PARALLEL mode...
     18# define PARALLEL 1
    1819  if (PARALLEL & !hostID) {
    1920    catalog = load_catalogs_parallel (skylist, Ncatalog);
    … …  
    3031  // load data from each region file, only use bright stars
    3132  for (i = 0; i < skylist[0].Nregions; i++) {
     33    // XXX keep in mind that not all catalogs are loaded
    3234    dvo_catalog_init (&catalog[i], TRUE);
    3335
    … …  
    9092
    9193// CATDIR is supplied globally
    92 Catalog *load_catalogs_parallel (SkyTable *sky, int *Ncatalog) {
     94# define DEBUG 1
     95Catalog *load_catalogs_parallel (SkyList *sky, int *Ncatalog) {
     96
     97  int Nsecfilt  = GetPhotcodeNsecfilt ();               // set the desired number in case we need to create the catalog
    9398
    9499  // launch the setphot_client jobs to the parallel hosts
    … …  
    130135  // we don't know how many catalogs we actually need.  allocate a single entry, then
    131136  // below we will allocate the max number needed after the BrightCatalog is loaded
    132   int Ncatalog = 0;
    133137  int NCATALOG = 1;
     138  Catalog *catalog = NULL;
    134139  ALLOCATE (catalog, Catalog, NCATALOG);
    135140
    … …  
    157162    assert (bcatalog);
    158163   
     164    // XXX this is wrong : I need to distinguish between the array of catalogs
     165    // and the range of catID values.
     166
     167    // I need to determine the set of unique catID values and count them,
     168    // I'll also need a lookup table from catID -> index.
     169
    159170    // XXX put the code below into a function equivalent to BrightCatalogMerge?
    160171
    … …  
    162173    // just average?)
    163174    int catIDmax = 0;
     175    int j;
    164176    for (j = 0; j < bcatalog->Naverage; j++) {
    165177      catIDmax = MAX(catIDmax, bcatalog->average[j].catID);
    … …  
    173185    REALLOCATE (NAVERAGE, int, NCATALOG);
    174186    REALLOCATE (NMEASURE, int, NCATALOG);
    175     for (i = NCATALOG_OLD; i < NCATALOG; i++) {
    176       NAVERAGE[i] = 100;
    177       NMEASURE[i] = 100;
    178       catalog[i].Naverage = 0;
    179       catalog[i].Nmeasure = 0;
    180       ALLOCATE (catalog[i].averageT, AverageTiny, NAVERAGE[i]);
    181       ALLOCATE (catalog[i].measureT, MeasureTiny, NMEASURE[i]);
    182       ALLOCATE (catalog[i].secfilt, SecFilt, Nsecfilt*NAVERAGE[i]);
     187    for (j = NCATALOG_OLD; j < NCATALOG; j++) {
     188      NAVERAGE[j] = 100;
     189      NMEASURE[j] = 100;
     190      catalog[j].Naverage = 0;
     191      catalog[j].Nmeasure = 0;
     192      ALLOCATE (catalog[j].averageT, AverageTiny, NAVERAGE[j]);
     193      ALLOCATE (catalog[j].measureT, MeasureTiny, NMEASURE[j]);
     194      ALLOCATE (catalog[j].secfilt, SecFilt, Nsecfilt*NAVERAGE[j]);
    183195    }
    184196
    … …  
    189201    // assign the averages to the corresponding catalog
    190202    for (j = 0; j < bcatalog->Naverage; j++) {
    191       Nc = bcatalog->average[j].catID;
     203      int Nc = bcatalog->average[j].catID;
    192204      assert (Nc < NCATALOG);
    193       Na = catalog[Nc].Naverage;
     205      int Na = catalog[Nc].Naverage;
    194206      catalog[Nc].averageT[Na] = bcatalog->average[j];
    195207
    196208      // secfilt entries are grouped in blocks for each average
     209      int k;
    197210      for (k = 0; k < Nsecfilt; k++) {
    198211        catalog[Nc].secfilt[Na*Nsecfilt + k] = bcatalog->secfilt[j*Nsecfilt + k];
    … …  
    200213
    201214      catalog[Nc].Naverage ++;
    202       if (catalog[Nc].Naverage >= NAVERAGE[N]) {
     215      if (catalog[Nc].Naverage >= NAVERAGE[Nc]) {
    203216        NAVERAGE[Nc] += 100;
    204217        REALLOCATE (catalog[Nc].averageT, AverageTiny, NAVERAGE[Nc]);
    … …  
    210223    // XXX what about averef and related links?  Do I need them?
    211224    for (j = 0; j < bcatalog->Nmeasure; j++) {
    212       Nc = bcatalog->measure[j].catID;
     225      int Nc = bcatalog->measure[j].catID;
    213226      assert (Nc < NCATALOG);
    214       Na = catalog[Nc].Nmeasure;
     227      int Na = catalog[Nc].Nmeasure;
    215228      catalog[Nc].measureT[Na] = bcatalog->measure[j];
    216229      catalog[Nc].Nmeasure ++;
    217       if (catalog[Nc].Nmeasure >= NMEASURE[N]) {
     230      if (catalog[Nc].Nmeasure >= NMEASURE[Nc]) {
    218231        NMEASURE[Nc] += 100;
    219232        REALLOCATE (catalog[Nc].measureT, MeasureTiny, NMEASURE[Nc]);

  • branches/eam_branches/ipp-20111122/Ohana/src/relphot/src/reload_catalogs.c

    r33244 r33254  
    11# include "relphot.h"
     2
     3# define DEBUG 1
    24
    35# define TIMESTAMP(TIME) \
    … …  
    79    gettimeofday (&start, (void *) NULL);
    810
    9 void reload_catalogs (SkyList *skylist, FlatCorrectionTable *flatcorr) {
     11void reload_catalogs (SkyList *skylist, FlatCorrectionTable *flatcorr, int hostID, char *hostpath) {
    1012
    1113  int i;
    … …  
    2527  double time7 = 0.0;
    2628
     29  // XXX need to decide how to determine PARALLEL mode...
     30# define PARALLEL 1
     31  if (PARALLEL & !hostID) {
     32    reload_catalogs_parallel (skylist);
     33    return;
     34  }
     35
    2736  if (VERBOSE) fprintf (stderr, "re-loading catalog data\n");
    2837
    2938  /* load data from each region file */
    3039  for (i = 0; i < skylist[0].Nregions; i++) {
     40    if (hostID && (skylist[0].regions[i]->hostID != hostID)) continue;
     41
    3142    gettimeofday (&start, (void *) NULL);
    32     catalog.filename = skylist[0].filename[i];
     43
     44    // set up the basic catalog info
     45    char hostfile[1024];
     46    snprintf (hostfile, 1024, "%s/%s.cpt", hostpath, skylist[0].regions[i]->name);
     47    catalog.filename = hostID ? hostfile : skylist[0].filename[i];
    3348
    3449    // only update existing db tables
    … …  
    6075    TIMESTAMP(time3a);
    6176
     77    // XXX need to worry about the image subset data
    6278    initImageBins  (&catalog, 1, FALSE);
    6379    initMosaicBins (&catalog, 1, FALSE);
    … …  
    95111}
    96112
    97 int reload_catalogs_parallel (SkyTable *sky, Image *image, off_t Nimage) {
     113// XXX Image to Image Subset
     114int reload_catalogs_parallel (SkyList *sky) {
     115
     116  off_t Nimage;
     117  ImageSubset *image = getimages_subset (&Nimage);
    98118
    99119  // write out the subset table of image information
    … …  
    104124    exit (1);
    105125  }
     126  free (image);
    106127
    107128  // now launch the relphot_client jobs to the parallel hosts
    … …  
    114135
    115136    char command[1024];
    116     snprintf (command, 1024, "relphot_client -reload -hostname %s -catdir %s -hostdir %s -images %s",
    117               table->hosts[i].hostname, CATDIR, table->hosts[i].pathname, imageFile);
     137    snprintf (command, 1024, "relphot_client -reload %s -hostname %s -catdir %s -hostdir %s",
     138              imageFile, table->hosts[i].hostname, CATDIR, table->hosts[i].pathname);
    118139
    119140    fprintf (stderr, "command: %s\n", command);

  • branches/eam_branches/ipp-20111122/Ohana/src/relphot/src/relphot.c

    r33244 r33254  
    6969  FlatCorrectionTable *flatcorr = FlatCorrectionLoad (flatcorrfile, VERBOSE);
    7070
    71   /* load catalog data from region files */
    72   catalog = load_catalogs (skylist, &Ncatalog);
     71  /* load catalog data from region files (hostID is 0 since we are not a client */
     72  catalog = load_catalogs (skylist, &Ncatalog, 0, NULL);
    7373  MARKTIME("-- load catalog data: %f sec\n", dtime);
    7474 
    … …  
    241241
    242242  /* load catalog data from region files, update Mrel include all data */
    243   if (PARALLEL) {
    244     reload_catalogs_parallel ();
    245   } else {
    246     reload_catalogs (skylist, flatcorr);
    247   }
     243  reload_catalogs (skylist, flatcorr, 0, NULL);
    248244  MARKTIME("-- updated all catalogs: %f sec\n", dtime);
    249245

  • branches/eam_branches/ipp-20111122/Ohana/src/relphot/src/relphot_client.c

    r33244 r33254  
    1717int main (int argc, char **argv) {
    1818
    19   // get configuration info, args, lockfile (set CATDIR, HOSTDIR, HOSTNAME, IMAGES)
    20   // XXX pass in both HOSTDIR and HOSTID or just HOSTNAME (and read the host table)?
    21   initialize_relphot_client (argc, argv);
    22 
    23   // need to supply the region selected by the calling program -> UserPatch
     19  // get configuration info, args, lockfile (set CATDIR, HOST_ID, HOSTDIR, etc)
     20  initialize_client (argc, argv);
    2421
    2522  // load the current sky table (layout of all SkyRegions)
    26   sky = SkyTableLoadOptimal (CATDIR, NULL, NULL, TRUE, -1, VERBOSE);
     23  SkyTable *sky = SkyTableLoadOptimal (CATDIR, NULL, NULL, TRUE, -1, VERBOSE);
    2724  SkyTableSetFilenames (sky, CATDIR, "cpt");
    2825
    29   skylist = SkyListByPatch (sky, -1, &UserPatch);
     26  SkyList *skylist = SkyListByPatch (sky, -1, &UserPatch);
    3027 
    3128  switch (MODE) {
    3229    case MODE_LOAD: {
    33       // need to pass in HOSTDIR, HOST_ID,
     30      int Ncatalog;
    3431      Catalog *catalog = load_catalogs (skylist, &Ncatalog, HOST_ID, HOSTDIR);
    35    
    36       BrightCatalog *bcatalog = BrightCatalogMerge (Catalog *catalog, int Ncatalog);
    37 
     32      BrightCatalog *bcatalog = BrightCatalogMerge (catalog, Ncatalog);
    3833      if (!BrightCatalogSave (BCATALOG, bcatalog)) {
    3934        abort();
    … …  
    4742      ImageSubset *image = ImageSubsetLoad (IMAGES, &Nimage);
    4843     
     44      // save the available image information in the static array in ImageOps.c
     45      initImagesSubset (image, NULL, Nimage);
     46
    4947      // load the flat-field correction table from CATDIR
    5048      char flatcorrFile[1024];
    5149      snprintf (flatcorrFile, 1024, "%s/flatcorr.fits", CATDIR);
    52       FlatCorrectionTable *flatcorrTable = FlatCorrectionLoad (flatcorrFile, VERBOSE);
     50      FlatCorrectionTable *flatcorr = FlatCorrectionLoad (flatcorrFile, VERBOSE);
     51
     52      reload_catalogs (skylist, flatcorr, HOST_ID, HOSTDIR);
    5353      break;
    5454    }
Note: See TracChangeset for help on using the changeset viewer.