IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 4832


Ignore:
Timestamp:
Aug 19, 2005, 5:13:28 PM (21 years ago)
Author:
eugene
Message:

added dvo phottable conversion types

Location:
trunk/Ohana/src
Files:
17 edited

Legend:

Unmodified
Added
Removed

  • trunk/Ohana/src/delstar/Makefile

    r4805 r4832  
    1616# 
    1717INCS    =       -I$(INC) -I$(LINC) -I$(XINC)
    18 LIBS    =       -L$(LLIB) -lFITS -lohana -lm
     18LIBS    =       -L$(LLIB) -lohana -lFITS -lm
    1919CFLAGS  =       -o $*.$(ARCH).o $(INCS) -O2
    2020CCFLAGS =       $(INCS) $(LIBS)

  • trunk/Ohana/src/delstar/include/delstar.h

    r4805 r4832  
    1717char   GSCFILE[256];
    1818char   CATDIR[256];
     19char   CATMODE[16];    /* raw, mef, split, mysql */
     20char   CATFORMAT[16];  /* internal, elixir, loneos, panstarrs */
    1921double NSIGMA;
    2022double ALPHA;

  • trunk/Ohana/src/delstar/src/ConfigInit.c

    r4680 r4832  
    2323  ScanConfig (config, "GSCFILE",                "%s", 0, GSCFILE);
    2424  ScanConfig (config, "CATDIR",                 "%s", 0, CATDIR);
     25  ScanConfig (config, "CATMODE",                "%s",  0, CATMODE);
     26  ScanConfig (config, "CATFORMAT",              "%s",  0, CATFORMAT);
    2527  ScanConfig (config, "PHOTCODE_FILE",          "%s", 0, PhotCodeFile);
    2628
    … …  
    3032  ScanConfig (config, "MJD-KEYWORD",            "%s", 0, MJDKeyword);
    3133  ScanConfig (config, "JD-KEYWORD",             "%s", 0, JDKeyword);
     34
     35  if (*CATMODE == 0) strcpy (CATMODE, "RAW");
     36  if (*CATFORMAT == 0) strcpy (CATFORMAT, "ELIXIR");
    3237
    3338  if (!LoadPhotcodes (PhotCodeFile)) {

  • trunk/Ohana/src/delstar/src/gcatalog.c

    r2463 r4832  
    55  int Nsecfilt;
    66  char mode;
     7
     8  /* no autodetect for CATMODE yet */
     9  strcpy (catalog[0].catmode, CATMODE);
    710
    811  /* read catalog header */

  • trunk/Ohana/src/delstar/src/wcatalog.c

    r4680 r4832  
    33int wcatalog (Catalog *catalog) {
    44 
    5   /* we'll leave these for now, but they are LONEOS specific */
    6   fits_modify (&catalog[0].header, "MARKSTAR", "%t", 1, FALSE);
    7   fits_modify (&catalog[0].header, "ADDUSNO", "%t", 1, FALSE);
    8   fits_modify (&catalog[0].header, "MARKROCK", "%t", 1, FALSE);
     5  /* set catalog format (elixir, loneos, etc) */
     6  if (!strcmp (CATFORMAT, "INTERNAL")) {
     7    sprintf (catalog[0].average_format, "DVO_AVERAGE");
     8    sprintf (catalog[0].measure_format, "DVO_MEASURE");
     9  } else {
     10    sprintf (catalog[0].average_format, "DVO_AVERAGE_%s", CATFORMAT);
     11    sprintf (catalog[0].measure_format, "DVO_MEASURE_%s", CATFORMAT);
     12  }
    913
    1014  if (!save_catalog (catalog, VERBOSE)) {

  • trunk/Ohana/src/libautocode/Makefile

    r4463 r4832  
    2525$(SRC)/coords.$(ARCH).o \
    2626$(SRC)/average.$(ARCH).o \
     27$(SRC)/average-loneos.$(ARCH).o \
     28$(SRC)/average-elixir.$(ARCH).o \
     29$(SRC)/average-panstarrs.$(ARCH).o \
    2730$(SRC)/secfilt.$(ARCH).o \
    2831$(SRC)/measure.$(ARCH).o \
     32$(SRC)/measure-loneos.$(ARCH).o \
     33$(SRC)/measure-elixir.$(ARCH).o \
     34$(SRC)/measure-panstarrs.$(ARCH).o \
    2935$(SRC)/missing.$(ARCH).o \
    3036$(SRC)/photcode.$(ARCH).o \
    … …  
    4147$(INC)/coords.h \
    4248$(INC)/average.h \
     49$(INC)/average-loneos.h \
     50$(INC)/average-elixir.h \
     51$(INC)/average-panstarrs.h \
    4352$(INC)/secfilt.h \
    4453$(INC)/measure.h \
     54$(INC)/measure-loneos.h \
     55$(INC)/measure-elixir.h \
     56$(INC)/measure-panstarrs.h \
    4557$(INC)/missing.h \
    4658$(INC)/photcode.h \

  • trunk/Ohana/src/libautocode/def/average-elixir.d

    r4800 r4832  
    1 STRUCT  Average
    2 EXTNAME DVO_AVERAGE
     1STRUCT  AverageElixir
     2EXTNAME DVO_AVERAGE_ELIXIR
    33TYPE    BINTABLE
    44SIZE    32

  • trunk/Ohana/src/libautocode/def/average.d

    r4800 r4832  
    66# elements of data structure / FITS table
    77
    8 FIELD R_PS,              RA,         double,            RA,                               decimal degrees
    9 FIELD D_PS,              DEC,        double,            DEC,                              decimal degrees
     8FIELD R_PS,           RA,         double,           RA,                           decimal degrees
     9FIELD D_PS,           DEC,        double,           DEC,                          decimal degrees
    1010FIELD M,              MAG,        short,            primary mag,                  millimag
    1111FIELD Nm,             NMEAS,      unsigned short,   number of measures

  • trunk/Ohana/src/libautocode/def/measure-elixir.d

    r4800 r4832  
    1 STRUCT  Measure
    2 EXTNAME DVO_MEASURE
     1STRUCT  MeasureElixir
     2EXTNAME DVO_MEASURE_ELIXIR
    33TYPE    BINTABLE
    44SIZE    32

  • trunk/Ohana/src/libautocode/def/measure-panstarrs.d

    r4800 r4832  
    1 STRUCT  Measure
    2 EXTNAME DVO_MEASURE
     1STRUCT  MeasurePanstarrs
     2EXTNAME DVO_MEASURE_PANSTARRS
    33TYPE    BINTABLE
    44SIZE    32

  • trunk/Ohana/src/libautocode/def/measure.d

    r4800 r4832  
    99# FIELD dR,             D_RA,      short,          RA offset,                     1/100 arcsec
    1010# FIELD dD,             D_DEC,     short,          DEC offset,                    1/100 arcsec
     11
    1112# replace these with the above names
    1213FIELD dR_PS,             D_RA,   float,          RA offset,                       arcsec
    1314FIELD dD_PS,             D_DEC,  float,          DEC offset,                      arcsec
    14 
    1515FIELD M,              MAG,        short,          catalog mag,                    millimag
    1616FIELD Mcal,           Mcal,       short,          image cal mag,                  millimag

  • trunk/Ohana/src/libohana/Makefile

    r4810 r4832  
    3333$(SRC)/ohana_allocate.$(ARCH).o  \
    3434$(SRC)/string.$(ARCH).o          \
    35 $(SRC)/time.$(ARCH).o            \
    3635$(SRC)/findexec.$(ARCH).o        \
    3736$(SRC)/glockfile.$(ARCH).o       \
     37$(SRC)/time.$(ARCH).o            \
    3838$(SRC)/config.$(ARCH).o          \
    3939$(SRC)/version.$(ARCH).o
    4040
    4141OBJ2 = \
     42$(SRC)/Fread.$(ARCH).o           \
    4243$(SRC)/coordops.$(ARCH).o        \
    43 $(SRC)/Fread.$(ARCH).o           \
    4444$(SRC)/LoadPhotcodes.$(ARCH).o   \
    45 $(SRC)/photfits.$(ARCH).o        \
    46 $(SRC)/phot_catalog.$(ARCH).o    \
    4745$(SRC)/imreg_datatypes.$(ARCH).o \
    4846$(SRC)/mosaic_astrom.$(ARCH).o   \
    49 $(SRC)/fits_db.$(ARCH).o         
     47$(SRC)/fits_db.$(ARCH).o         \
     48$(SRC)/photfits.$(ARCH).o        \
     49$(SRC)/phot_catalog.$(ARCH).o    \
     50$(SRC)/phot_catalog_mef.$(ARCH).o      \
     51$(SRC)/phot_catalog_raw.$(ARCH).o      \
     52$(SRC)/dvo_convert.$(ARCH).o           \
     53$(SRC)/dvo_convert_elixir.$(ARCH).o    \
     54$(SRC)/dvo_convert_loneos.$(ARCH).o    \
     55$(SRC)/dvo_convert_panstarrs.$(ARCH).o
    5056
    5157AOBJ = \
    5258$(ASRC)/coords.$(ARCH).o \
     59$(ASRC)/average.$(ARCH).o \
     60$(ASRC)/average-loneos.$(ARCH).o \
     61$(ASRC)/average-elixir.$(ARCH).o \
     62$(ASRC)/average-panstarrs.$(ARCH).o \
     63$(ASRC)/secfilt.$(ARCH).o \
     64$(ASRC)/measure.$(ARCH).o \
     65$(ASRC)/measure-loneos.$(ARCH).o \
     66$(ASRC)/measure-elixir.$(ARCH).o \
     67$(ASRC)/measure-panstarrs.$(ARCH).o \
     68$(ASRC)/missing.$(ARCH).o \
     69$(ASRC)/photcode.$(ARCH).o \
     70$(ASRC)/image.$(ARCH).o \
    5371$(ASRC)/regimage.$(ARCH).o \
    5472$(ASRC)/detreg.$(ARCH).o \
    … …  
    5775$(ASRC)/smpdata.$(ARCH).o \
    5876$(ASRC)/spectrum.$(ARCH).o \
    59 $(ASRC)/spectrum-ascii.$(ARCH).o \
    60 $(ASRC)/image.$(ARCH).o
     77$(ASRC)/spectrum-ascii.$(ARCH).o
    6178
    6279ACOM = $(ADEF)/autocode.c $(ADEF)/autocode.h $(ADEF)/common.h

  • trunk/Ohana/src/libohana/doc/dvo-structures.txt

    r3466 r4832  
    3636   (can be loaded with translation, losing the exptime,
    3737   and limited the number of Naverage to 0xffffff - in load_catalog) */
     38
     39------
     40
     41the DVO structure Catalog contains the data from a single sky patch, including:
     42    average, measure, missing, and secfilt. 
     43
     44the catalog may be saved in one of 4 modes (catalog.catmode):
     45    raw   : the old Elixir style which is a header + 4 binary tables
     46    mef   : catalog is a single file with header and 4 fits tables
     47    split : catalog is 5 files, one with the header and one for each table
     48    mysql : catalog is 4 (or 5?) mysql tables
     49
     50    in split mode, the filename is the file of the descriptive header
     51    and the averages, the measure, missing, and secfilt data are
     52    stored in additional files referenced in the header and named
     53    based on the filename (replacing extension .cpa with .cpb, .cpc,
     54    .cpd, for example)
     55
     56   

  • trunk/Ohana/src/libohana/doc/libohana.html

    r4810 r4832  
    11
    2 <h2> libohana API reference </h2>
     2<h1> libohana API reference </h1>
     3
     4<h2> generic ohana functions </h2>
     5
     6<h3> basic macros </h3>
     7
     8<pre>
     9TRUE
     10FALSE
     11SIGN(X) 
     12ROUND(X)
     13SQR(X)   
     14SQ(X)   
     15MIN(X,Y)
     16MAX(X,Y)
     17SWAP(X,Y)
     18whitespace (char c)
     19</pre>
    320
    421<h3> ohana memory management functions </h3>
    … …  
    6683<pre> int   fclearlockfile (char *filename, FILE *f, int type, int *state); </pre>
    6784
    68 <h3> read/write (Fread.c) </h3>
    69 
    70 <pre> int Fread (char ptr, int size, int nitems, FILE *f, char *type); </pre>
    71 <pre> int Fwrite (char ptr, int size, int nitems, FILE *f, char *type); </pre>
    72 <pre> int ByteSwap (char *ptr, int size, int nitems, char *type); </pre>
    73 <pre> int ConvertStruct (char *buffer, int size, int nitems, char *type); </pre>
    74 
    75 Several of these functions are used to perform byte-swapping for
    76 structures in the pre-autocode days.  They should be deprecated and
    77 dropped, but the autocoding must superceed the hard-wired structure
    78 first.
    79 
    80 <h3> miscellaneous functions </h3>
    81 
    82 <pre> char *ohana_version (); </pre>
    83 
    84 <h3> photcode manipulations (LoadPhotcodes.c) </h3>
    85 
    86 <pre> int       LoadPhotcodes (char *filename, PhotCodeData *photcodes); </pre>
    87 <pre> int       FreePhotcodes (PhotCodeData *photcodes); </pre>
    88 
    89 <pre> PhotCode *GetPhotcodebyName (char *name); </pre>
    90 <pre> PhotCode *GetPhotcodeEquivbyName (char *name); </pre>
    91 <pre> PhotCode *GetPhotcodebyCode (int code); </pre>
    92 <pre> PhotCode *GetPhotcodeEquivbyCode (int code); </pre>
    93 <pre> PhotCode *GetPhotcodebyNsec (int Nsec); </pre>
    94 <pre> char     *GetPhotcodeNamebyCode (int code); </pre>
    95 
    96 <pre> int       GetPhotcodeCodebyName (char *name); </pre>
    97 <pre> int       GetPhotcodeEquivCodebyName (char *name); </pre>
    98 <pre> int       GetPhotcodeEquivCodebyCode (int code); </pre>
    99 <pre> int       GetPhotcodeNsec (int code); </pre>
    100 <pre> int       GetPhotcodeNsecfilt (); </pre>
    101 <pre> int      *GetPhotcodeEquivList (int code, int *nlist); </pre>
    102 
    103 <pre> void      SetZeroPoint (double ZP); </pre>
    104 <pre> void      ParseColorTerms (char *terms, float *X, int *N); </pre>
    105 
    106 <pre> int       PhotColor (Average *average, SecFilt *secfilt, Measure *measure, int c1, int c2, double *color); </pre>
    107 <pre> short     iPhotColor (Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code); </pre>
    108 
    109 <pre> double    PhotInst (Measure *measure); </pre>
    110 <pre> double    PhotCat (Measure *measure); </pre>
    111 <pre> double    PhotSys (Measure *measure, Average *average, SecFilt *secfilt); </pre>
    112 <pre> double    PhotRel (Measure *measure, Average *average, SecFilt *secfilt); </pre>
    113 <pre> double    PhotCal (Measure *thisone, Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code); </pre>
    114 <pre> double    PhotAve (PhotCode *code, Average *average, SecFilt *secfilt); </pre>
    115 <pre> double    PhotRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure); </pre>
    116 <pre> double    PhotdM (PhotCode *code, Average *average, SecFilt *secfilt); </pre>
    117 <pre> double    PhotXm (PhotCode *code, Average *average, SecFilt *secfilt); </pre>
    118 
    119 <pre> short     iPhotInst (Measure *measure); </pre>
    120 <pre> short     iPhotCat (Measure *measure); </pre>
    121 <pre> short     iPhotSys (Measure *measure, Average *average, SecFilt *secfilt); </pre>
    122 <pre> short     iPhotRel (Measure *measure, Average *average, SecFilt *secfilt); </pre>
    123 <pre> short     iPhotCal (Measure *thisone, Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code); </pre>
    124 <pre> short     iPhotAve (PhotCode *code, Average *average, SecFilt *secfilt); </pre>
    125 <pre> short     iPhotRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure); </pre>
    126 <pre> short     iPhotdM (PhotCode *code, Average *average, SecFilt *secfilt); </pre>
    127 <pre> short     iPhotXm (PhotCode *code, Average *average, SecFilt *secfilt); </pre>
    128 
    129 <h3> functions in config.c </h3>
    130 
    131 <pre> char *SelectConfigFile (int *argc, char **argv, char *progname); </pre>
    132 <pre> char *LoadConfigFile (char *filename); </pre>
    133 <pre> char *ScanConfig (char *config, char *field, char *mode, int Nentry, ...); </pre>
    134 <pre> char *expandline (char *line, char *config); </pre>
    135 <pre> char *LoadRawConfigFile (char *filename, int options); </pre>
    136 
    137 <h3> functions in coordops.c </h3>
    138 
    139 <pre> int XY_to_RD (double *ra, double *dec, double x,  double y,   Coords *coords); </pre>
    140 <pre> int RD_to_XY (double *x,  double *y,   double ra, double dec, Coords *coords); </pre>
    141 <pre> int fXY_to_RD (float *ra, float *dec, float x,  float y,   Coords *coords); </pre>
    142 <pre> int fRD_to_XY (float *x,  float *y,   float ra, float dec, Coords *coords); </pre>
    143 <pre> int GetCoords (Coords *coords, Header *header); </pre>
    144 <pre> int coords_precess (double *ra, double *dec, double in_epoch, double out_epoch); </pre>
    145 
    146 <h3> functions in phot_catalog.c </h3>
    147 
    148 <pre> int lock_catalog (Catalog *catalog, int lockmode); </pre>
    149 <pre> int unlock_catalog (Catalog *catalog); </pre>
    150 <pre> int load_catalog (Catalog *catalog, char mode, int VERBOSE); </pre>
    151 <pre> int save_catalog (Catalog *catalog, char VERBOSE); </pre>
    152 <pre> Measure *FixOldMeasure (OldMeasure *in, int Nvalues); </pre>
    153 <pre> Average *FixOldAverage (OldAverage *in, int Nvalues); </pre>
    154 <pre> SecFilt *FixOldSecFilt (OldSecFilt *in, int Nvalues); </pre>
    155 
    156 <h3> functions in photfits.c </h3>
    157 
    158 <pre> short int putMi (double value); </pre>
    159 <pre> double getMi (short int value); </pre>
    160 <pre> void returnMcal (Image *image, double *c); </pre>
    161 <pre> void assignMcal (Image *image, double *c, int order); </pre>
    162 <pre> double applyMcal (Image *image, double x, double y); </pre>
    163 <pre> double findscatter (double *X, double *Y, double *M, double *dM, int N, double *c, int order); </pre>
    164 
    165 <h3> defined macros </h3>
    166 
    167 the ohana library includes the following macros:
     85associated constants:
    16886
    16987<pre>
    170 
    171 SIGN(X) 
    172 ROUND(X)
    173 SQR(X)   
    174 SQ(X)   
    175 MIN(X,Y)
    176 MAX(X,Y)
    177 SWAP(X,Y)
    178 
    179 whitespace (char c)
    180 </pre>
    181 
    182 <h3> defined constants </h3>
    183 
    184 <pre>
    185 TRUE
    186 FALSE
    187 
    18888LCK_SOFT - block writing
    18989LCK_XCLD - block reading and writing
    … …  
    200100LCK_UNKNOWN  - can't stat file to get size
    201101</pre>
     102
     103<h3> time / radec manipulation functions (time.c) </h3>
     104
     105<pre> int dms_to_ddd (double *Value, char *string); </pre>
     106<pre> int str_to_radec (double *ra, double *dec, char *str1, char *str2); </pre>
     107<pre> int chk_time (char *line); </pre>
     108<pre> int str_to_time (char *line, time_t *second); </pre>
     109<pre> int str_to_dtime (char *line, double *second); </pre>
     110<pre> double sec_to_jd (time_t second); </pre>
     111<pre> time_t jd_to_sec (double jd); </pre>
     112<pre> double sec_to_mjd (time_t second); </pre>
     113<pre> time_t mjd_to_sec (double mjd); </pre>
     114<pre> char *sec_to_date (time_t second); </pre>
     115<pre> time_t date_to_sec (char *date); </pre>
     116<pre> time_t short_date_to_sec (char *date); </pre>
     117<pre> int hstgsc_hms_to_deg (double *h0, double *h1, double *d0, double *d1, char *string); </pre>
     118
     119<h3> functions in config.c </h3>
     120
     121<pre> char *SelectConfigFile (int *argc, char **argv, char *progname); </pre>
     122<pre> char *LoadConfigFile (char *filename); </pre>
     123<pre> char *ScanConfig (char *config, char *field, char *mode, int Nentry, ...); </pre>
     124<pre> char *expandline (char *line, char *config); </pre>
     125<pre> char *LoadRawConfigFile (char *filename, int options); </pre>
     126
     127<h3> miscellaneous functions </h3>
     128
     129<pre> char *ohana_version (); </pre>
     130
     131<h2> DVO data structures and catalog I/O functions </h2>
     132
     133<h3> read/write (Fread.c) </h3>
     134
     135<pre> int Fread (char ptr, int size, int nitems, FILE *f, char *type); </pre>
     136<pre> int Fwrite (char ptr, int size, int nitems, FILE *f, char *type); </pre>
     137<pre> int ByteSwap (char *ptr, int size, int nitems, char *type); </pre>
     138<pre> int ConvertStruct (char *buffer, int size, int nitems, char *type); </pre>
     139
     140Several of these functions are used to perform byte-swapping for
     141structures in the pre-autocode days.  They should be deprecated and
     142dropped, but the autocoding must superceed the hard-wired structure
     143first.
     144
     145<h3> coordinate structure manipulations (coordops.c) </h3>
     146
     147<pre> int XY_to_RD (double *ra, double *dec, double x,  double y,   Coords *coords); </pre>
     148<pre> int RD_to_XY (double *x,  double *y,   double ra, double dec, Coords *coords); </pre>
     149<pre> int fXY_to_RD (float *ra, float *dec, float x,  float y,   Coords *coords); </pre>
     150<pre> int fRD_to_XY (float *x,  float *y,   float ra, float dec, Coords *coords); </pre>
     151<pre> int GetCoords (Coords *coords, Header *header); </pre>
     152<pre> int coords_precess (double *ra, double *dec, double in_epoch, double out_epoch); </pre>
     153
     154<h3> photcode manipulations (LoadPhotcodes.c) </h3>
     155
     156<pre> int       LoadPhotcodes (char *filename, PhotCodeData *photcodes); </pre>
     157<pre> int       FreePhotcodes (PhotCodeData *photcodes); </pre>
     158
     159<pre> PhotCode *GetPhotcodebyName (char *name); </pre>
     160<pre> PhotCode *GetPhotcodeEquivbyName (char *name); </pre>
     161<pre> PhotCode *GetPhotcodebyCode (int code); </pre>
     162<pre> PhotCode *GetPhotcodeEquivbyCode (int code); </pre>
     163<pre> PhotCode *GetPhotcodebyNsec (int Nsec); </pre>
     164<pre> char     *GetPhotcodeNamebyCode (int code); </pre>
     165
     166<pre> int       GetPhotcodeCodebyName (char *name); </pre>
     167<pre> int       GetPhotcodeEquivCodebyName (char *name); </pre>
     168<pre> int       GetPhotcodeEquivCodebyCode (int code); </pre>
     169<pre> int       GetPhotcodeNsec (int code); </pre>
     170<pre> int       GetPhotcodeNsecfilt (); </pre>
     171<pre> int      *GetPhotcodeEquivList (int code, int *nlist); </pre>
     172
     173<pre> void      SetZeroPoint (double ZP); </pre>
     174<pre> void      ParseColorTerms (char *terms, float *X, int *N); </pre>
     175
     176<pre> int       PhotColor (Average *average, SecFilt *secfilt, Measure *measure, int c1, int c2, double *color); </pre>
     177<pre> short     iPhotColor (Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code); </pre>
     178
     179<pre> double    PhotInst (Measure *measure); </pre>
     180<pre> double    PhotCat (Measure *measure); </pre>
     181<pre> double    PhotSys (Measure *measure, Average *average, SecFilt *secfilt); </pre>
     182<pre> double    PhotRel (Measure *measure, Average *average, SecFilt *secfilt); </pre>
     183<pre> double    PhotCal (Measure *thisone, Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code); </pre>
     184<pre> double    PhotAve (PhotCode *code, Average *average, SecFilt *secfilt); </pre>
     185<pre> double    PhotRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure); </pre>
     186<pre> double    PhotdM (PhotCode *code, Average *average, SecFilt *secfilt); </pre>
     187<pre> double    PhotXm (PhotCode *code, Average *average, SecFilt *secfilt); </pre>
     188
     189<pre> short     iPhotInst (Measure *measure); </pre>
     190<pre> short     iPhotCat (Measure *measure); </pre>
     191<pre> short     iPhotSys (Measure *measure, Average *average, SecFilt *secfilt); </pre>
     192<pre> short     iPhotRel (Measure *measure, Average *average, SecFilt *secfilt); </pre>
     193<pre> short     iPhotCal (Measure *thisone, Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code); </pre>
     194<pre> short     iPhotAve (PhotCode *code, Average *average, SecFilt *secfilt); </pre>
     195<pre> short     iPhotRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure); </pre>
     196<pre> short     iPhotdM (PhotCode *code, Average *average, SecFilt *secfilt); </pre>
     197<pre> short     iPhotXm (PhotCode *code, Average *average, SecFilt *secfilt); </pre>
     198
     199<h3> photometry catalog I/O functions (phot_catalog.c) </h3>
     200
     201<pre> int lock_catalog (Catalog *catalog, int lockmode); </pre>
     202<pre> int unlock_catalog (Catalog *catalog); </pre>
     203<pre> int load_catalog (Catalog *catalog, char mode, int VERBOSE); </pre>
     204<pre> int save_catalog (Catalog *catalog, char VERBOSE); </pre>
     205
     206<h3> DVO format conversions (dvo_convert.c) </h3>
     207
     208<pre> Measure *FixOldMeasure (OldMeasure *in, int Nvalues); </pre>
     209<pre> Average *FixOldAverage (OldAverage *in, int Nvalues); </pre>
     210<pre> SecFilt *FixOldSecFilt (OldSecFilt *in, int Nvalues); </pre>
     211
     212<h3> image type / mode lookups (imreg_datatypes.c) </h3>
     213<pre> int   get_image_type (char *name); </pre>
     214<pre> char *get_type_name (int type); </pre>
     215<pre> int   get_image_mode (char *name); </pre>
     216<pre> char *get_mode_name (int mode); </pre>
     217
     218<h3> mosaic astrometry functions (mosaic_astrom.c) </h3>
     219
     220<pre> int FindMosaicForImage (Image *images, int Nimages, int entry); </pre>
     221<pre> int FindMosaicForImage_TableSearch (Image *images, int Nimages, int entry); </pre>
     222<pre> int FindMosaicForImage_MatchSearch (Image *images, int Nimages, int entry); </pre>
     223<pre> int BuildChipMatch (Image *images, int Nimages); </pre>
     224
     225<h3> FITS DB I/O functions (fits_db.c) </h3>
     226
     227<pre> int fits_db_init (FITS_DB *db); </pre>
     228<pre> int fits_db_create (FITS_DB *db); </pre>
     229<pre> int fits_db_lock (FITS_DB *db, char *filename); </pre>
     230<pre> int fits_db_load (FITS_DB *db); </pre>
     231<pre> int fits_db_save (FITS_DB *db); </pre>
     232<pre> int fits_db_update (FITS_DB *db, VTable *vtable); </pre>
     233<pre> int fits_db_free (FITS_DB *db); </pre>
     234<pre> int fits_db_close (FITS_DB *db); </pre>
     235
     236<h3> functions in photfits.c </h3>
     237
     238<pre> short int putMi (double value); </pre>
     239<pre> double getMi (short int value); </pre>
     240<pre> void returnMcal (Image *image, double *c); </pre>
     241<pre> void assignMcal (Image *image, double *c, int order); </pre>
     242<pre> double applyMcal (Image *image, double x, double y); </pre>
     243<pre> double findscatter (double *X, double *Y, double *M, double *dM, int N, double *c, int order); </pre>
     244
     245These functions manipulate the high-order polynomial fit of magnitude
     246offset as a function of image position for the Image structure.
     247

  • trunk/Ohana/src/libohana/include/dvo.h

    r4810 r4832  
    108108/* a catalog contains this data */
    109109typedef struct {
    110   /* data in the file: */
     110  /* description of the catalog file: */
     111  char *filename;
     112  int lockmode;
     113  FILE *f;
     114
     115  /* extra table data if needed (move these to enums?) */
     116  char catmode[10];         /* storage mode: raw, mef, split, mysql */
     117  char average_format[80];  /* table format: internal, loneos, elixir, panstarrs */
     118  char measure_format[80];  /* table format: must match average_format */
     119 
     120  /* data in the catalog */
     121  Header  header;
    111122  Average *average;
    112123  Measure *measure;
    113124  Missing *missing;
    114125  SecFilt *secfilt;
    115   Header  header;
    116126  int Naverage, Nmeasure, Nmissing, Nsecfilt;
    117   /* description of the catalog file: */
    118   char *filename;
    119   int lockmode;
    120   FILE *f;
     127
    121128  /* pointers for data manipulation */
    122129  int *found;
    … …  
    222229int   ConvertStruct (char *buffer, int size, int Nbytes, char *type);
    223230
     231/*** conversion functions / I/O conversions ***/
     232
     233Average *AveragePanstarrsToInternal (AveragePanstarrs *in, int Nvalues);
     234Average *FtableToAverage (FTable *ftable, int *Naverage, char *extname);
     235Average *ReadRawAverage (FILE *f, int Naverage, char *format);
     236Average *AverageLoneosToInternal (AverageLoneos *in, int Nvalues);
     237Average *AverageElixirToInternal (AverageElixir *in, int Nvalues);
     238AverageElixir *AverageInternalToElixir (Average *in, int Nvalues);
     239AverageLoneos *AverageInternalToLoneos (Average *in, int Nvalues);
     240AveragePanstarrs *AverageInternalToPanstarrs (Average *in, int Nvalues);
     241Measure *MeasurePanstarrsToInternal (MeasurePanstarrs *in, int Nvalues);
     242Measure *FtableToMeasure (FTable *ftable, int *Nmeasure, char *extname);
     243Measure *ReadRawMeasure (FILE *f, int Nmeasure, char *format);
     244Measure *MeasureLoneosToInternal (MeasureLoneos *in, int Nvalues);
     245Measure *MeasureElixirToInternal (MeasureElixir *in, int Nvalues);
     246MeasureElixir *MeasureInternalToElixir (Measure *in, int Nvalues);
     247MeasureLoneos *MeasureInternalToLoneos (Measure *in, int Nvalues);
     248MeasurePanstarrs *MeasureInternalToPanstarrs (Measure *in, int Nvalues);
     249int AverageToFtable (FTable *ftable, Average *average, int Naverage, char *extname);
     250int MeasureToFtable (FTable *ftable, Measure *measure, int Nmeasure, char *extname);
     251int WriteRawAverage (FILE *f, Average *average, int Naverage, char *format);
     252int WriteRawMeasure (FILE *f, Measure *measure, int Nmeasure, char *format);
     253int load_catalog_raw (Catalog *catalog, char mode, int VERBOSE);
     254int save_catalog_raw (Catalog *catalog, char VERBOSE);
     255int load_catalog_mef (Catalog *catalog, char mode, int VERBOSE);
     256int save_catalog_mef (Catalog *catalog, char VERBOSE);
     257
    224258# endif

  • trunk/Ohana/src/libohana/src/dvo_convert.c

    r3473 r4832  
    1 SecFilt *FixOldSecFilt (OldSecFilt *in, int Nvalues);
    2 Average *FixOldAverage (OldAverage *in, int Nvalues);
    3 Measure *FixOldMeasure (OldMeasure *in, int Nvalues);
    4 
    5 /* the old load_catalog automatically converted
    6    now we error, and require conversion by hand
    7 */
    8 
    9 /* this is (a bit) dangerous: the load function will automatically
    10    convert from the old (Loneos) format to the new (CFHT) format.
    11    But, if you load an old-format catalog, then save the new-format
    12    version, the new file will be corrupted unless you load all four
    13    data components.  Actually, 'save_catalog' assumes you've loaded
    14    all four anyway, so it is not such a problem... */
    15 
    16 int load_catalog (Catalog *catalog, char mode, int VERBOSE) {
    17  
    18   int Nitems, nitems;
    19   int i, Nmeas, Nmiss, size, ssize;
    20   int NewMeasure, NewAverage, NewSecFilt;
    21   FILE *f;
    22   OldMeasure *tmpmeasure;
    23   OldAverage *tmpaverage;
    24   OldSecFilt *tmpsecfilt;
    25   struct stat filestatus;
    26 
    27   f = catalog[0].f;
    28   fseek (f, 0, SEEK_SET);
    29 
    30   /* read catalog header */
    31   if (!fits_load_header (f, &catalog[0].header)) {
    32     if (VERBOSE) fprintf (stderr, "catalog file does not exist: %s\n", catalog[0].filename);
     1# include <ohana.h>
     2# include <dvo.h>
     3
     4/* The Ftable-TYPE conversion functions determine the format of table based on EXTNAME in header.
     5   they convert the table to the internal format, and set 'extname'. 
     6
     7   The TYPE-Ftable conversions functions create output tables in the format requested
     8   by the 'extname' function parameter.
     9 */
     10
     11/** this file might be more readable if I use macros for the repetative
     12    constructions below **/
     13
     14/*** Average / FTable conversion functions ***/
     15
     16Average *FtableToAverage (FTable *ftable, int *Naverage, char *extname) {
     17
     18  Average *average;
     19
     20  /* convert to the internal format */
     21  if (!fits_scan (ftable[0].header, "EXTNAME", "%s", 1, extname)) {
     22    fprintf (stderr, "EXTNAME missing for average table\n");
    3323    return (FALSE);
    3424  }
    35 
    36   /* this is done by the load anyway... */
    37   fseek (f, catalog[0].header.size, SEEK_SET);
    38 
    39   /* get the components from the header */
    40   catalog[0].Naverage = catalog[0].Nmeasure = catalog[0].Nmissing = catalog[0].Nsecfilt = 0;
    41   if (!fits_scan (&catalog[0].header, "NSTARS",   "%d", 1, &catalog[0].Naverage)) return (FALSE);
    42   if (!fits_scan (&catalog[0].header, "NMEAS",    "%d", 1, &catalog[0].Nmeasure)) return (FALSE);
    43   if (!fits_scan (&catalog[0].header, "NMISS",    "%d", 1, &catalog[0].Nmissing)) return (FALSE);
    44   if (!fits_scan (&catalog[0].header, "NSECFILT", "%d", 1, &catalog[0].Nsecfilt)) catalog[0].Nsecfilt = 0;
    45   if (!fits_scan (&catalog[0].header, "NEWMEAS",  "%t", 1, &NewMeasure)) NewMeasure = FALSE;
    46   if (!fits_scan (&catalog[0].header, "NEWAVES",  "%t", 1, &NewAverage)) NewAverage = FALSE;
    47   if (!fits_scan (&catalog[0].header, "NEWSECF",  "%t", 1, &NewSecFilt)) NewSecFilt = FALSE;
    48 
    49   /* predicted file size - for double checking data validity */
    50   size = catalog[0].header.size;
    51   ssize = NewAverage ? sizeof (Average) : sizeof (OldAverage);
    52   size += ssize * catalog[0].Naverage;
    53   ssize = NewMeasure ? sizeof (Measure) : sizeof (OldMeasure);
    54   size += ssize * catalog[0].Nmeasure;
    55   ssize = sizeof (Missing);
    56   size += ssize * catalog[0].Nmissing;
    57   ssize = NewSecFilt ? sizeof (SecFilt) : sizeof (OldSecFilt);
    58   size += ssize * catalog[0].Nsecfilt * catalog[0].Naverage;
    59 
    60   /* check that file size makes sense */
    61   if (stat (catalog[0].filename, &filestatus) == -1) {
    62     if (VERBOSE) fprintf (stderr, "failed to get status of catalog\n");
     25  if (!strcmp (extname, "DVO_AVERAGE")) {
     26    average = fits_table_get_Average (ftable, Naverage);
     27    return (average);
     28  }
     29  if (!strcmp (extname, "DVO_AVERAGE_ELIXIR")) {
     30    AverageElixir *tmpaverage;
     31    tmpaverage = fits_table_get_AverageElixir (ftable, Naverage);
     32    average = AverageElixirToInternal (tmpaverage, *Naverage);
     33    free (tmpaverage);
     34    return (average);
     35  }
     36  if (!strcmp (extname, "DVO_AVERAGE_LONEOS")) {
     37    AverageLoneos *tmpaverage;
     38    tmpaverage = fits_table_get_AverageLoneos (ftable, Naverage);
     39    average = AverageLoneosToInternal (tmpaverage, *Naverage);
     40    free (tmpaverage);
     41    return (average);
     42  }
     43  if (!strcmp (extname, "DVO_AVERAGE_PANSTARRS")) {
     44    AveragePanstarrs *tmpaverage;
     45    tmpaverage = fits_table_get_AveragePanstarrs (ftable, Naverage);
     46    average = AveragePanstarrsToInternal (tmpaverage, *Naverage);
     47    free (tmpaverage);
     48    return (average);
     49  }
     50
     51  fprintf (stderr, "table format unknown: %s\n", extname);
     52
     53  *Naverage = 0;
     54  return (NULL);
     55}
     56
     57int AverageToFtable (FTable *ftable, Average *average, int Naverage, char *extname) {
     58
     59  /* convert from the internal format */
     60  if (!strcmp (extname, "DVO_AVERAGE")) {
     61    fits_table_set_Average (ftable, average, Naverage);
     62    return (TRUE);
     63  }
     64  if (!strcmp (extname, "DVO_AVERAGE_ELIXIR")) {
     65    AverageElixir *tmpaverage;
     66    tmpaverage = AverageInternalToElixir (average, Naverage);
     67    fits_table_set_AverageElixir (ftable, tmpaverage, Naverage);
     68    free (tmpaverage);
     69    return (TRUE);
     70  }
     71  if (!strcmp (extname, "DVO_AVERAGE_LONEOS")) {
     72    AverageLoneos *tmpaverage;
     73    tmpaverage = AverageInternalToLoneos (average, Naverage);
     74    fits_table_set_AverageLoneos (ftable, tmpaverage, Naverage);
     75    free (tmpaverage);
     76    return (TRUE);
     77  }
     78  if (!strcmp (extname, "DVO_AVERAGE_PANSTARRS")) {
     79    AveragePanstarrs *tmpaverage;
     80    tmpaverage = AverageInternalToPanstarrs (average, Naverage);
     81    fits_table_set_AveragePanstarrs (ftable, tmpaverage, Naverage);
     82    free (tmpaverage);
     83    return (TRUE);
     84  }
     85  fprintf (stderr, "table format unknown: %s\n", extname);
     86  return (FALSE);
     87}
     88
     89/*** Measure / FTable conversion functions ***/
     90
     91Measure *FtableToMeasure (FTable *ftable, int *Nmeasure, char *extname) {
     92
     93  Measure *measure;
     94
     95  /* convert to the internal format */
     96  if (!fits_scan (ftable[0].header, "EXTNAME", "%s", 1, extname)) {
     97    fprintf (stderr, "EXTNAME missing for measure table\n");
    6398    return (FALSE);
    6499  }
    65   if (size > filestatus.st_size) {
    66     if (VERBOSE) {
    67       fprintf (stderr, "star catalog has inconsistent size\n");
    68       ssize = NewAverage ? sizeof (Average) : sizeof (OldAverage);
    69       fprintf (stderr, "average: %d = %d bytes\n", catalog[0].Naverage, catalog[0].Naverage*ssize);
    70       ssize = NewMeasure ? sizeof (Measure) : sizeof (OldMeasure);
    71       fprintf (stderr, "measure: %d = %d bytes\n", catalog[0].Nmeasure, catalog[0].Nmeasure*ssize);
    72       ssize = sizeof (Missing);
    73       fprintf (stderr, "missing: %d = %d bytes\n", catalog[0].Nmissing, catalog[0].Nmissing*ssize);
    74       ssize = NewSecFilt ? sizeof (SecFilt) : sizeof (OldSecFilt);
    75       fprintf (stderr, "secfilt: %d = %d bytes\n", catalog[0].Nsecfilt, catalog[0].Nsecfilt*catalog[0].Naverage*ssize);
    76       fprintf (stderr, "expect: %d, found: %d\n", size, (int)filestatus.st_size);
    77     }
    78     return (FALSE);
    79   }
    80   if (size < filestatus.st_size) {
    81     if (VERBOSE) fprintf (stderr, "warning: file larger than expected\n");
    82   }
    83 
    84   if (catalog[0].Naverage == 0) {
    85     if (VERBOSE) fprintf (stderr, "no stars yet in catalog %s\n", catalog[0].filename);
    86     return (TRUE);
    87   }
    88 
    89   if (mode & LOAD_AVES) {
    90     /* read average values */
    91     if (NewAverage) {
    92       ALLOCATE (catalog[0].average, Average, MAX (catalog[0].Naverage, 1));
    93       Nitems = catalog[0].Naverage;
    94       nitems = Fread (catalog[0].average, sizeof(Average), Nitems, f, "average");
    95     } else {
    96       ALLOCATE (tmpaverage, OldAverage, MAX (catalog[0].Naverage, 1));
    97       Nitems = catalog[0].Naverage;
    98       nitems = Fread (tmpaverage, sizeof(OldAverage), Nitems, f, "oldaverage");
    99       catalog[0].average = FixOldAverage (tmpaverage, Nitems);
    100     }
    101     if (nitems != Nitems) {
    102       if (VERBOSE) fprintf (stderr, "failed to read averages from catalog file %s (%d vs %d)\n", catalog[0].filename, nitems, Nitems);
    103       return (FALSE);
    104     }
    105   } else {
    106     /* skip over averages */
    107     fseek (f, catalog[0].Naverage * sizeof(Average), SEEK_CUR);
    108   }   
    109  
    110   if (mode & LOAD_MEAS) {
    111     /* read measurements */
    112     if (NewMeasure) {
    113       ALLOCATE (catalog[0].measure, Measure, MAX (catalog[0].Nmeasure, 1));
    114       Nitems = catalog[0].Nmeasure;
    115       nitems = Fread (catalog[0].measure, sizeof(Measure), Nitems, f, "measure");
    116     } else {
    117       ALLOCATE (tmpmeasure, OldMeasure, MAX (catalog[0].Nmeasure, 1));
    118       Nitems = catalog[0].Nmeasure;
    119       nitems = Fread (tmpmeasure, sizeof(OldMeasure), Nitems, f, "oldmeasure");
    120       catalog[0].measure = FixOldMeasure (tmpmeasure, Nitems);
    121     }
    122     if (nitems != Nitems) {
    123       if (VERBOSE) fprintf (stderr, "failed to read measures from catalog file %s (%d vs %d)\n", catalog[0].filename, nitems, Nitems);
    124       return (FALSE);
    125     }
    126   } else {
    127     /* skip over measures */
    128     fseek (f, catalog[0].Nmeasure * sizeof(Measure), SEEK_CUR);
    129   }
    130 
    131   if (mode & LOAD_MISS) {
    132     /* read missing */
    133     ALLOCATE (catalog[0].missing, Missing, MAX (catalog[0].Nmissing, 1));
    134     Nitems = catalog[0].Nmissing;
    135     nitems = Fread (catalog[0].missing, sizeof(Missing), Nitems, f, "missing");
    136     if (nitems != Nitems) {
    137       if (VERBOSE) fprintf (stderr, "failed to read missing from catalog file %s (%d vs %d)\n", catalog[0].filename, nitems, Nitems);
    138       return (FALSE);
    139     }
    140   } else {
    141     /* skip over missings */
    142     fseek (f, catalog[0].Nmissing * sizeof(Missing), SEEK_CUR);
    143   }
    144  
    145   if (mode & LOAD_SECF) {
    146     /* read missing */
    147     if (NewSecFilt) {
    148       Nitems = catalog[0].Naverage * catalog[0].Nsecfilt;
    149       ALLOCATE (catalog[0].secfilt, SecFilt, MAX (Nitems, 1));
    150       nitems = Fread (catalog[0].secfilt, sizeof(SecFilt), Nitems, f, "secfilt");
    151     } else {
    152       Nitems = catalog[0].Naverage * catalog[0].Nsecfilt;
    153       ALLOCATE (tmpsecfilt, OldSecFilt, MAX (Nitems, 1));
    154       nitems = Fread (tmpsecfilt, sizeof(OldSecFilt), Nitems, f, "oldsecfilt");
    155       catalog[0].secfilt = FixOldSecFilt (tmpsecfilt, Nitems);
    156     }
    157     if (nitems != Nitems) {
    158       if (VERBOSE) fprintf (stderr, "failed to read secondary filters from catalog file %s (%d vs %d)\n", catalog[0].filename, nitems, Nitems);
    159       return (FALSE);
    160     }
    161   } else {
    162     /* skip over secfilts */
    163     fseek (f, catalog[0].Naverage * catalog[0].Nsecfilt * sizeof(SecFilt), SEEK_CUR);
    164   }
    165 
    166   if (VERBOSE) fprintf (stderr, "read %d stars from catalog file %s (%d measurements, %d missing, %d secondary filters)\n",
    167            catalog[0].Naverage, catalog[0].filename, catalog[0].Nmeasure, catalog[0].Nmissing, catalog[0].Nsecfilt);
    168 
    169   /* check data integrity */
    170   if (mode & LOAD_AVES) {
    171     for (i = Nmeas = Nmiss = 0; i < catalog[0].Naverage; i++) {
    172       Nmeas += catalog[0].average[i].Nm;
    173       Nmiss += catalog[0].average[i].Nn;
    174     }
    175     if ((Nmeas != catalog[0].Nmeasure) || (Nmiss != catalog[0].Nmissing)) {
    176       if (VERBOSE) {
    177         fprintf (stderr, "****** data in catalog %s is corrupt, sums don't check\n", catalog[0].filename);
    178         fprintf (stderr, "****** Nmeas: %d, %d\n", Nmeas, catalog[0].Nmeasure);
    179         fprintf (stderr, "****** Nmiss: %d, %d\n", Nmiss, catalog[0].Nmissing);
    180       }
    181       return (FALSE);
    182     }
    183   }
    184   return (TRUE);
    185 }
    186 
    187 /**** tools to convert between formats - this happens automatically in load_catalog */
    188 
    189 Measure *FixOldMeasure (OldMeasure *in, int Nvalues) {
    190 
    191   int i;
    192   Measure *out;
    193 
    194   ALLOCATE (out, Measure, Nvalues);
    195 
    196   for (i = 0; i < Nvalues; i++) {
    197     out[i].dR = in[i].dR;
    198     out[i].dD = in[i].dD;
    199     out[i].M  = in[i].M;
    200     out[i].dM = in[i].dM;
    201     out[i].Mcal = in[i].Mcal;
    202     out[i].dophot = in[i].dophot;
    203     out[i].source = in[i].source;
    204     out[i].t = in[i].t;
    205 
    206     out[i].dt = 0xffff;
    207     out[i].averef = in[i].average & 0x00ffffff;
    208     out[i].flags  = (in[i].average & 0xff000000) >> 24;
    209   }
    210 
    211   free (in);
    212  
    213   return (out);
    214 }
    215 
    216 Average *FixOldAverage (OldAverage *in, int Nvalues) {
    217 
    218   int i;
    219   Average *out;
    220 
    221   ALLOCATE (out, Average, Nvalues);
    222 
    223   for (i = 0; i < Nvalues; i++) {
    224     out[i].R       = in[i].R;     
    225     out[i].D       = in[i].D;     
    226     out[i].M       = in[i].M;     
    227     out[i].Xp      = in[i].Xp;     
    228     out[i].Xm      = in[i].Xm;     
    229     out[i].Nm      = in[i].Nm;     
    230     out[i].Nn      = in[i].Nn;     
    231     out[i].code    = in[i].code;   
    232     out[i].offset  = in[i].offset;
    233     out[i].missing = in[i].missing;
    234 
    235     out[i].dM = 0xffff;
    236   }
    237 
    238   free (in);
    239  
    240   return (out);
    241 }
    242 
    243 SecFilt *FixOldSecFilt (OldSecFilt *in, int Nvalues) {
    244 
    245   int i;
    246   SecFilt *out;
    247 
    248   ALLOCATE (out, SecFilt, Nvalues);
    249 
    250   for (i = 0; i < Nvalues; i++) {
    251     out[i].M    = in[i].M;     
    252     out[i].Xm   = in[i].Xm;     
    253 
    254     out[i].dM   = 0xffff;
    255   }
    256 
    257   free (in);
    258  
    259   return (out);
    260 }
    261 
     100  if (!strcmp (extname, "DVO_MEASURE")) {
     101    measure = fits_table_get_Measure (ftable, Nmeasure);
     102    return (measure);
     103  }
     104  if (!strcmp (extname, "DVO_MEASURE_ELIXIR")) {
     105    MeasureElixir *tmpmeasure;
     106    tmpmeasure = fits_table_get_MeasureElixir (ftable, Nmeasure);
     107    measure = MeasureElixirToInternal (tmpmeasure, *Nmeasure);
     108    free (tmpmeasure);
     109    return (measure);
     110  }
     111  if (!strcmp (extname, "DVO_MEASURE_LONEOS")) {
     112    MeasureLoneos *tmpmeasure;
     113    tmpmeasure = fits_table_get_MeasureLoneos (ftable, Nmeasure);
     114    measure = MeasureLoneosToInternal (tmpmeasure, *Nmeasure);
     115    free (tmpmeasure);
     116    return (measure);
     117  }
     118  if (!strcmp (extname, "DVO_MEASURE_PANSTARRS")) {
     119    MeasurePanstarrs *tmpmeasure;
     120    tmpmeasure = fits_table_get_MeasurePanstarrs (ftable, Nmeasure);
     121    measure = MeasurePanstarrsToInternal (tmpmeasure, *Nmeasure);
     122    free (tmpmeasure);
     123    return (measure);
     124  }
     125
     126  fprintf (stderr, "table format unknown: %s\n", extname);
     127
     128  *Nmeasure = 0;
     129  return (NULL);
     130}
     131
     132int MeasureToFtable (FTable *ftable, Measure *measure, int Nmeasure, char *extname) {
     133
     134  /* convert from the internal format */
     135  if (!strcmp (extname, "DVO_MEASURE")) {
     136    fits_table_set_Measure (ftable, measure, Nmeasure);
     137    return (TRUE);
     138  }
     139  if (!strcmp (extname, "DVO_MEASURE_ELIXIR")) {
     140    MeasureElixir *tmpmeasure;
     141    tmpmeasure = MeasureInternalToElixir (measure, Nmeasure);
     142    fits_table_set_MeasureElixir (ftable, tmpmeasure, Nmeasure);
     143    free (tmpmeasure);
     144    return (TRUE);
     145  }
     146  if (!strcmp (extname, "DVO_MEASURE_LONEOS")) {
     147    MeasureLoneos *tmpmeasure;
     148    tmpmeasure = MeasureInternalToLoneos (measure, Nmeasure);
     149    fits_table_set_MeasureLoneos (ftable, tmpmeasure, Nmeasure);
     150    free (tmpmeasure);
     151    return (TRUE);
     152  }
     153  if (!strcmp (extname, "DVO_MEASURE_PANSTARRS")) {
     154    MeasurePanstarrs *tmpmeasure;
     155    tmpmeasure = MeasureInternalToPanstarrs (measure, Nmeasure);
     156    fits_table_set_MeasurePanstarrs (ftable, tmpmeasure, Nmeasure);
     157    free (tmpmeasure);
     158    return (TRUE);
     159  }
     160
     161  fprintf (stderr, "table format unknown: %s\n", extname);
     162  return (FALSE);
     163}
     164
     165/** Average / Raw Table conversions **/
     166
     167Average *ReadRawAverage (FILE *f, int Naverage, char *format) {
     168
     169  int nitems;
     170  Average *average;
     171
     172  if (!strcmp (format, "DVO_AVERAGE")) {
     173    ALLOCATE (average, Average, MAX (Naverage, 1));
     174    nitems = fread (average, sizeof(Average), Naverage, f);
     175    if (nitems != Naverage) {
     176      fprintf (stderr, "failed to read averages (%d vs %d)\n", nitems, Naverage);
     177      return (NULL);
     178    }
     179    fits_convert_Average (average, sizeof(Average), Naverage);
     180    return (average);
     181  }
     182  if (!strcmp (format, "DVO_AVERAGE_ELIXIR")) {
     183    AverageElixir *tmpaverage;
     184    ALLOCATE (tmpaverage, AverageElixir, MAX (Naverage, 1));
     185    nitems = fread (tmpaverage, sizeof(AverageElixir), Naverage, f);
     186    if (nitems != Naverage) {
     187      fprintf (stderr, "failed to read averages (%d vs %d)\n", nitems, Naverage);
     188      return (NULL);
     189    }
     190    fits_convert_AverageElixir (tmpaverage, sizeof(AverageElixir), Naverage);
     191    average = AverageElixirToInternal (tmpaverage, Naverage);
     192    free (tmpaverage);
     193    return (average);
     194  }
     195  if (!strcmp (format, "DVO_AVERAGE_LONEOS")) {
     196    AverageLoneos *tmpaverage;
     197    ALLOCATE (tmpaverage, AverageLoneos, MAX (Naverage, 1));
     198    nitems = fread (tmpaverage, sizeof(AverageLoneos), Naverage, f);
     199    if (nitems != Naverage) {
     200      fprintf (stderr, "failed to read averages (%d vs %d)\n", nitems, Naverage);
     201      return (NULL);
     202    }
     203    fits_convert_AverageLoneos (tmpaverage, sizeof(AverageLoneos), Naverage);
     204    average = AverageLoneosToInternal (tmpaverage, Naverage);
     205    free (tmpaverage);
     206    return (average);
     207  }
     208  if (!strcmp (format, "DVO_AVERAGE_PANSTARRS")) {
     209    AveragePanstarrs *tmpaverage;
     210    ALLOCATE (tmpaverage, AveragePanstarrs, MAX (Naverage, 1));
     211    nitems = fread (tmpaverage, sizeof(AveragePanstarrs), Naverage, f);
     212    if (nitems != Naverage) {
     213      fprintf (stderr, "failed to read averages (%d vs %d)\n", nitems, Naverage);
     214      return (NULL);
     215    }
     216    fits_convert_AveragePanstarrs (tmpaverage, sizeof(AveragePanstarrs), Naverage);
     217    average = AveragePanstarrsToInternal (tmpaverage, Naverage);
     218    free (tmpaverage);
     219    return (average);
     220  }
     221  fprintf (stderr, "error reading averages\n");
     222  return (NULL);
     223}
     224
     225/* accepts and converts internal average formats and outputs
     226   raw data in the specified format */
     227int WriteRawAverage (FILE *f, Average *average, int Naverage, char *format) {
     228
     229  int nitems;
     230
     231  if (!strcmp (format, "DVO_AVERAGE")) {
     232    fits_convert_Average (average, sizeof(Average), Naverage);
     233    nitems = fwrite (average, sizeof(Average), Naverage, f);
     234    if (nitems != Naverage) {
     235      fprintf (stderr, "failed to write averages (%d vs %d)\n", nitems, Naverage);
     236      return (FALSE);
     237    }
     238    return (TRUE);
     239  }
     240  if (!strcmp (format, "DVO_AVERAGE_ELIXIR")) {
     241    AverageElixir *tmpaverage;
     242    tmpaverage = AverageInternalToElixir (average, Naverage);
     243    fits_convert_AverageElixir (tmpaverage, sizeof(AverageElixir), Naverage);
     244    nitems = fwrite (tmpaverage, sizeof(AverageElixir), Naverage, f);
     245    free (tmpaverage);
     246    if (nitems != Naverage) {
     247      fprintf (stderr, "failed to write averages (%d vs %d)\n", nitems, Naverage);
     248      return (FALSE);
     249    }
     250    return (TRUE);
     251  }
     252  if (!strcmp (format, "DVO_AVERAGE_LONEOS")) {
     253    AverageLoneos *tmpaverage;
     254    tmpaverage = AverageInternalToLoneos (average, Naverage);
     255    fits_convert_AverageLoneos (tmpaverage, sizeof(AverageLoneos), Naverage);
     256    nitems = fwrite (tmpaverage, sizeof(AverageLoneos), Naverage, f);
     257    free (tmpaverage);
     258    if (nitems != Naverage) {
     259      fprintf (stderr, "failed to write averages (%d vs %d)\n", nitems, Naverage);
     260      return (FALSE);
     261    }
     262    return (TRUE);
     263  }
     264  if (!strcmp (format, "DVO_AVERAGE_PANSTARRS")) {
     265    AveragePanstarrs *tmpaverage;
     266    tmpaverage = AverageInternalToPanstarrs (average, Naverage);
     267    fits_convert_AveragePanstarrs (tmpaverage, sizeof(AveragePanstarrs), Naverage);
     268    nitems = fwrite (tmpaverage, sizeof(AveragePanstarrs), Naverage, f);
     269    free (tmpaverage);
     270    if (nitems != Naverage) {
     271      fprintf (stderr, "failed to write averages (%d vs %d)\n", nitems, Naverage);
     272      return (FALSE);
     273    }
     274    return (TRUE);
     275  }
     276  fprintf (stderr, "error writing averages\n");
     277  return (FALSE);
     278}
     279/** Average / Raw Table conversions **/
     280
     281Measure *ReadRawMeasure (FILE *f, int Nmeasure, char *format) {
     282
     283  int nitems;
     284  Measure *measure;
     285
     286  if (!strcmp (format, "DVO_MEASURE")) {
     287    ALLOCATE (measure, Measure, MAX (Nmeasure, 1));
     288    nitems = fread (measure, sizeof(Measure), Nmeasure, f);
     289    if (nitems != Nmeasure) {
     290      fprintf (stderr, "failed to read measures (%d vs %d)\n", nitems, Nmeasure);
     291      return (NULL);
     292    }
     293    fits_convert_Measure (measure, sizeof(Measure), Nmeasure);
     294    return (measure);
     295  }
     296  if (!strcmp (format, "DVO_MEASURE_ELIXIR")) {
     297    MeasureElixir *tmpmeasure;
     298    ALLOCATE (tmpmeasure, MeasureElixir, MAX (Nmeasure, 1));
     299    nitems = fread (tmpmeasure, sizeof(MeasureElixir), Nmeasure, f);
     300    if (nitems != Nmeasure) {
     301      fprintf (stderr, "failed to read measures (%d vs %d)\n", nitems, Nmeasure);
     302      return (NULL);
     303    }
     304    fits_convert_MeasureElixir (tmpmeasure, sizeof(MeasureElixir), Nmeasure);
     305    measure = MeasureElixirToInternal (tmpmeasure, Nmeasure);
     306    free (tmpmeasure);
     307    return (measure);
     308  }
     309  if (!strcmp (format, "DVO_MEASURE_LONEOS")) {
     310    MeasureLoneos *tmpmeasure;
     311    ALLOCATE (tmpmeasure, MeasureLoneos, MAX (Nmeasure, 1));
     312    nitems = fread (tmpmeasure, sizeof(MeasureLoneos), Nmeasure, f);
     313    if (nitems != Nmeasure) {
     314      fprintf (stderr, "failed to read measures (%d vs %d)\n", nitems, Nmeasure);
     315      return (NULL);
     316    }
     317    fits_convert_MeasureLoneos (tmpmeasure, sizeof(MeasureLoneos), Nmeasure);
     318    measure = MeasureLoneosToInternal (tmpmeasure, Nmeasure);
     319    free (tmpmeasure);
     320    return (measure);
     321  }
     322  if (!strcmp (format, "DVO_MEASURE_PANSTARRS")) {
     323    MeasurePanstarrs *tmpmeasure;
     324    ALLOCATE (tmpmeasure, MeasurePanstarrs, MAX (Nmeasure, 1));
     325    nitems = fread (tmpmeasure, sizeof(MeasurePanstarrs), Nmeasure, f);
     326    if (nitems != Nmeasure) {
     327      fprintf (stderr, "failed to read measures (%d vs %d)\n", nitems, Nmeasure);
     328      return (NULL);
     329    }
     330    fits_convert_MeasurePanstarrs (tmpmeasure, sizeof(MeasurePanstarrs), Nmeasure);
     331    measure = MeasurePanstarrsToInternal (tmpmeasure, Nmeasure);
     332    free (tmpmeasure);
     333    return (measure);
     334  }
     335  fprintf (stderr, "error reading measures\n");
     336  return (NULL);
     337}
     338
     339/* accepts and converts internal measure formats and outputs
     340   raw data in the specified format */
     341int WriteRawMeasure (FILE *f, Measure *measure, int Nmeasure, char *format) {
     342
     343  int nitems;
     344
     345  if (!strcmp (format, "DVO_MEASURE")) {
     346    fits_convert_Measure (measure, sizeof(Measure), Nmeasure);
     347    nitems = fwrite (measure, sizeof(Measure), Nmeasure, f);
     348    if (nitems != Nmeasure) {
     349      fprintf (stderr, "failed to write measures (%d vs %d)\n", nitems, Nmeasure);
     350      return (FALSE);
     351    }
     352    return (TRUE);
     353  }
     354  if (!strcmp (format, "DVO_MEASURE_ELIXIR")) {
     355    MeasureElixir *tmpmeasure;
     356    tmpmeasure = MeasureInternalToElixir (measure, Nmeasure);
     357    fits_convert_MeasureElixir (tmpmeasure, sizeof(MeasureElixir), Nmeasure);
     358    nitems = fwrite (tmpmeasure, sizeof(MeasureElixir), Nmeasure, f);
     359    free (tmpmeasure);
     360    if (nitems != Nmeasure) {
     361      fprintf (stderr, "failed to write measures (%d vs %d)\n", nitems, Nmeasure);
     362      return (FALSE);
     363    }
     364    return (TRUE);
     365  }
     366  if (!strcmp (format, "DVO_MEASURE_LONEOS")) {
     367    MeasureLoneos *tmpmeasure;
     368    tmpmeasure = MeasureInternalToLoneos (measure, Nmeasure);
     369    fits_convert_MeasureLoneos (tmpmeasure, sizeof(MeasureLoneos), Nmeasure);
     370    nitems = fwrite (tmpmeasure, sizeof(MeasureLoneos), Nmeasure, f);
     371    free (tmpmeasure);
     372    if (nitems != Nmeasure) {
     373      fprintf (stderr, "failed to write measures (%d vs %d)\n", nitems, Nmeasure);
     374      return (FALSE);
     375    }
     376    return (TRUE);
     377  }
     378  if (!strcmp (format, "DVO_MEASURE_PANSTARRS")) {
     379    MeasurePanstarrs *tmpmeasure;
     380    tmpmeasure = MeasureInternalToPanstarrs (measure, Nmeasure);
     381    fits_convert_MeasurePanstarrs (tmpmeasure, sizeof(MeasurePanstarrs), Nmeasure);
     382    nitems = fwrite (tmpmeasure, sizeof(MeasurePanstarrs), Nmeasure, f);
     383    free (tmpmeasure);
     384    if (nitems != Nmeasure) {
     385      fprintf (stderr, "failed to write measures (%d vs %d)\n", nitems, Nmeasure);
     386      return (FALSE);
     387    }
     388    return (TRUE);
     389  }
     390  fprintf (stderr, "error writing measures\n");
     391  return (FALSE);
     392}

  • trunk/Ohana/src/libohana/src/phot_catalog.c

    r3649 r4832  
    3636int load_catalog (Catalog *catalog, char mode, int VERBOSE) {
    3737 
    38   int Nitems, nitems;
    39   int i, Nmeas, Nmiss, size, ssize;
    40   int NewMeasure, NewAverage, NewSecFilt;
    41   FILE *f;
    42   struct stat filestatus;
     38  if (!strcmp (catalog[0].catmode, "RAW")) {
     39    load_catalog_raw (catalog, mode, VERBOSE);
     40    return (TRUE);
     41  }
     42  if (!strcmp (catalog[0].catmode, "MEF")) {
     43    load_catalog_mef (catalog, mode, VERBOSE);
     44    return (TRUE);
     45  }
     46  /*
     47  if (!strcmp (catalog[0].catmode, "SPLIT")) {
     48    load_catalog_split (catalog, mode, VERBOSE);
     49    return (TRUE);
     50  }
     51  if (!strcmp (catalog[0].catmode, "MYSQL")) {
     52    load_catalog_mysql (catalog, mode, VERBOSE);
     53    return (TRUE);
     54  }
     55  */
     56  return (FALSE);
     57}
    4358
    44   f = catalog[0].f;
    45   fseek (f, 0, SEEK_SET);
     59int save_catalog (Catalog *catalog, char VERBOSE) {
    4660
    47   /* read catalog header */
    48   if (!fits_load_header (f, &catalog[0].header)) {
    49     if (VERBOSE) fprintf (stderr, "catalog file does not exist: %s\n", catalog[0].filename);
    50     return (FALSE);
     61  if (!strcmp (catalog[0].catmode, "RAW")) {
     62    save_catalog_raw (catalog, VERBOSE);
     63    return (TRUE);
    5164  }
    52 
    53   /* this is done by the load anyway... */
    54   fseek (f, catalog[0].header.size, SEEK_SET);
    55 
    56   /* require the file to contain the NEW versions (ELIXIR) */
    57   if (!fits_scan (&catalog[0].header, "NEWMEAS",  "%t", 1, &NewMeasure)) return (FALSE);
    58   if (!fits_scan (&catalog[0].header, "NEWAVES",  "%t", 1, &NewAverage)) return (FALSE);
    59   if (!fits_scan (&catalog[0].header, "NEWSECF",  "%t", 1, &NewSecFilt)) return (FALSE);
    60 
    61   /* get the components from the header */
    62   catalog[0].Naverage = catalog[0].Nmeasure = catalog[0].Nmissing = catalog[0].Nsecfilt = 0;
    63   if (!fits_scan (&catalog[0].header, "NSTARS",   "%d", 1, &catalog[0].Naverage)) return (FALSE);
    64   if (!fits_scan (&catalog[0].header, "NMEAS",    "%d", 1, &catalog[0].Nmeasure)) return (FALSE);
    65   if (!fits_scan (&catalog[0].header, "NMISS",    "%d", 1, &catalog[0].Nmissing)) return (FALSE);
    66   if (!fits_scan (&catalog[0].header, "NSECFILT", "%d", 1, &catalog[0].Nsecfilt)) catalog[0].Nsecfilt = 0;
    67 
    68   /* predicted file size - for double checking data validity */
    69   size = catalog[0].header.size;
    70   ssize = sizeof (Average);
    71   size += ssize * catalog[0].Naverage;
    72   ssize = sizeof (Measure);
    73   size += ssize * catalog[0].Nmeasure;
    74   ssize = sizeof (Missing);
    75   size += ssize * catalog[0].Nmissing;
    76   ssize = sizeof (SecFilt);
    77   size += ssize * catalog[0].Nsecfilt * catalog[0].Naverage;
    78 
    79   /* check that file size makes sense */
    80   if (stat (catalog[0].filename, &filestatus) == -1) {
    81     if (VERBOSE) fprintf (stderr, "failed to get status of catalog\n");
    82     return (FALSE);
    83   }
    84   if (size > filestatus.st_size) {
    85     if (VERBOSE) {
    86       fprintf (stderr, "star catalog has inconsistent size\n");
    87       ssize = sizeof (Average);
    88       fprintf (stderr, "average: %d = %d bytes\n", catalog[0].Naverage, catalog[0].Naverage*ssize);
    89       ssize = sizeof (Measure);
    90       fprintf (stderr, "measure: %d = %d bytes\n", catalog[0].Nmeasure, catalog[0].Nmeasure*ssize);
    91       ssize = sizeof (Missing);
    92       fprintf (stderr, "missing: %d = %d bytes\n", catalog[0].Nmissing, catalog[0].Nmissing*ssize);
    93       ssize = sizeof (SecFilt);
    94       fprintf (stderr, "secfilt: %d = %d bytes\n", catalog[0].Nsecfilt, catalog[0].Nsecfilt*catalog[0].Naverage*ssize);
    95       fprintf (stderr, "expect: %d, found: %d\n", size, (int)filestatus.st_size);
    96     }
    97     return (FALSE);
    98   }
    99   if (size < filestatus.st_size) {
    100     if (VERBOSE) fprintf (stderr, "warning: file larger than expected\n");
    101   }
    102 
    103   if (catalog[0].Naverage == 0) {
    104     if (VERBOSE) fprintf (stderr, "no stars yet in catalog %s\n", catalog[0].filename);
     65  if (!strcmp (catalog[0].catmode, "MEF")) {
     66    save_catalog_mef (catalog, VERBOSE);
    10567    return (TRUE);
    10668  }
    10769
    108   if (mode & LOAD_AVES) {
    109     ALLOCATE (catalog[0].average, Average, MAX (catalog[0].Naverage, 1));
    110     Nitems = catalog[0].Naverage;
    111     nitems = Fread (catalog[0].average, sizeof(Average), Nitems, f, "average");
    112     if (nitems != Nitems) {
    113       if (VERBOSE) fprintf (stderr, "failed to read averages from catalog file %s (%d vs %d)\n", catalog[0].filename, nitems, Nitems);
    114       return (FALSE);
    115     }
    116   } else {
    117     /* skip over averages */
    118     fseek (f, catalog[0].Naverage * sizeof(Average), SEEK_CUR);
    119   }   
    120  
    121   if (mode & LOAD_MEAS) {
    122     ALLOCATE (catalog[0].measure, Measure, MAX (catalog[0].Nmeasure, 1));
    123     Nitems = catalog[0].Nmeasure;
    124     nitems = Fread (catalog[0].measure, sizeof(Measure), Nitems, f, "measure");
    125     if (nitems != Nitems) {
    126       if (VERBOSE) fprintf (stderr, "failed to read measures from catalog file %s (%d vs %d)\n", catalog[0].filename, nitems, Nitems);
    127       return (FALSE);
    128     }
    129   } else {
    130     /* skip over measures */
    131     fseek (f, catalog[0].Nmeasure * sizeof(Measure), SEEK_CUR);
    132   }
    133 
    134   if (mode & LOAD_MISS) {
    135     /* read missing */
    136     ALLOCATE (catalog[0].missing, Missing, MAX (catalog[0].Nmissing, 1));
    137     Nitems = catalog[0].Nmissing;
    138     nitems = Fread (catalog[0].missing, sizeof(Missing), Nitems, f, "missing");
    139     if (nitems != Nitems) {
    140       if (VERBOSE) fprintf (stderr, "failed to read missing from catalog file %s (%d vs %d)\n", catalog[0].filename, nitems, Nitems);
    141       return (FALSE);
    142     }
    143   } else {
    144     /* skip over missings */
    145     fseek (f, catalog[0].Nmissing * sizeof(Missing), SEEK_CUR);
    146   }
    147  
    148   if (mode & LOAD_SECF) {
    149     Nitems = catalog[0].Naverage * catalog[0].Nsecfilt;
    150     ALLOCATE (catalog[0].secfilt, SecFilt, MAX (Nitems, 1));
    151     nitems = Fread (catalog[0].secfilt, sizeof(SecFilt), Nitems, f, "secfilt");
    152     if (nitems != Nitems) {
    153       if (VERBOSE) fprintf (stderr, "failed to read secondary filters from catalog file %s (%d vs %d)\n", catalog[0].filename, nitems, Nitems);
    154       return (FALSE);
    155     }
    156   } else {
    157     /* skip over secfilts */
    158     fseek (f, catalog[0].Naverage * catalog[0].Nsecfilt * sizeof(SecFilt), SEEK_CUR);
    159   }
    160 
    161   if (VERBOSE) fprintf (stderr, "read %d stars from catalog file %s (%d measurements, %d missing, %d secondary filters)\n",
    162            catalog[0].Naverage, catalog[0].filename, catalog[0].Nmeasure, catalog[0].Nmissing, catalog[0].Nsecfilt);
    163 
    164   /* check data integrity */
    165   if (mode & LOAD_AVES) {
    166     for (i = Nmeas = Nmiss = 0; i < catalog[0].Naverage; i++) {
    167       Nmeas += catalog[0].average[i].Nm;
    168       Nmiss += catalog[0].average[i].Nn;
    169     }
    170     if ((Nmeas != catalog[0].Nmeasure) || (Nmiss != catalog[0].Nmissing)) {
    171       if (VERBOSE) {
    172         fprintf (stderr, "****** data in catalog %s is corrupt, sums don't check\n", catalog[0].filename);
    173         fprintf (stderr, "****** Nmeas: %d, %d\n", Nmeas, catalog[0].Nmeasure);
    174         fprintf (stderr, "****** Nmiss: %d, %d\n", Nmiss, catalog[0].Nmissing);
    175       }
    176       return (FALSE);
    177     }
    178   }
    179   return (TRUE);
     70  return (FALSE);
    18071}
    18172
    182 /* this is not robust: an error will not return us to the original
    183    state.  But, it is faster: only limited data written to disk? *
     73/*
     74  mode   : items to read (LOAD_AVES | LOAD_MEAS | LOAD_MISS | LOAD_SECF)
     75  format : what structure on disk (INTERNAL, ELIXIR, LONEOS, PANSTARRS)
     76  style  : raw, mef, split, mysql
    18477*/
    185 
    186 int save_catalog (Catalog *catalog, char VERBOSE) {
    187 
    188   int Nitems, nitems;
    189   FILE *f;
    190 
    191   if (catalog[0].Naverage == 0) {
    192     if (VERBOSE) fprintf (stderr, "no stars in catalog, skipping\n");
    193     return (TRUE);
    194   }
    195 
    196   /* make sure header is consistent with data */
    197   fits_modify (&catalog[0].header, "NSTARS",   "%d", 1, catalog[0].Naverage);
    198   fits_modify (&catalog[0].header, "NMEAS",    "%d", 1, catalog[0].Nmeasure);
    199   fits_modify (&catalog[0].header, "NMISS",    "%d", 1, catalog[0].Nmissing);
    200   fits_modify (&catalog[0].header, "NSECFILT", "%d", 1, catalog[0].Nsecfilt);
    201   fits_modify (&catalog[0].header, "NEWMEAS",  "%t", 1, TRUE);
    202   fits_modify (&catalog[0].header, "NEWAVES",  "%t", 1, TRUE);
    203   fits_modify (&catalog[0].header, "NEWSECF",  "%t", 1, TRUE);
    204 
    205   f = catalog[0].f;
    206   /* rewind file pointers and truncate */
    207   fseek (f, 0, SEEK_SET);
    208   ftruncate (fileno (catalog[0].f), 0);
    209 
    210   nitems = Fwrite (catalog[0].header.buffer, 1, catalog[0].header.size, f, "char");
    211   if (nitems != catalog[0].header.size) {
    212     if (VERBOSE) fprintf (stderr, "failed to write header\n");
    213     return (FALSE);
    214   }
    215 
    216   Nitems = catalog[0].Naverage;
    217   nitems = Fwrite (catalog[0].average, sizeof(Average), Nitems, f, "average");
    218   if (nitems != Nitems) {
    219     if (VERBOSE) fprintf (stderr, "failed to write catalog file aves %s\n", catalog[0].filename);
    220     return (FALSE);
    221   }
    222  
    223   Nitems = catalog[0].Nmeasure;
    224   nitems = Fwrite (catalog[0].measure, sizeof(Measure), Nitems, f, "measure");
    225   if (nitems != Nitems) {
    226     if (VERBOSE) fprintf (stderr, "failed to write catalog file meas %s\n", catalog[0].filename);
    227     return (FALSE);
    228   }
    229 
    230   Nitems = catalog[0].Nmissing;
    231   nitems = Fwrite (catalog[0].missing, sizeof(Missing), Nitems, f, "missing");
    232   if (nitems != Nitems) {
    233     if (VERBOSE) fprintf (stderr, "failed to write catalog file miss %s\n", catalog[0].filename);
    234     return (FALSE);
    235   }
    236 
    237   Nitems = catalog[0].Naverage * catalog[0].Nsecfilt;
    238   nitems = Fwrite (catalog[0].secfilt, sizeof(SecFilt), Nitems, f, "secfilt");
    239   if (nitems != Nitems) {
    240     if (VERBOSE) fprintf (stderr, "failed to write catalog file secondary filters %s\n", catalog[0].filename);
    241     return (FALSE);
    242   }
    243 
    244   return (TRUE);
    245 
    246 }
    247 
Note: See TracChangeset for help on using the changeset viewer.