IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Mar 8, 2007, 12:21:18 PM (19 years ago)
Author:
eugene
Message:

complete merge from branch dvo-mods-2007-02

Location:
trunk/Ohana/src/libdvo
Files:
8 added
19 edited

Legend:

Unmodified
Added
Removed

  • trunk/Ohana/src/libdvo/Makefile

    r11880 r12332  
    2929$(SRC)/version.$(ARCH).o         \
    3030$(SRC)/coordops.$(ARCH).o        \
     31$(SRC)/dvo_photcode_ops.$(ARCH).o \
    3132$(SRC)/LoadPhotcodes.$(ARCH).o   \
     33$(SRC)/LoadPhotcodesText.$(ARCH).o   \
     34$(SRC)/LoadPhotcodesFITS.$(ARCH).o   \
     35$(SRC)/SavePhotcodesText.$(ARCH).o   \
     36$(SRC)/SavePhotcodesFITS.$(ARCH).o   \
    3237$(SRC)/imreg_datatypes.$(ARCH).o \
    3338$(SRC)/mosaic_astrom.$(ARCH).o   \
    … …  
    4146$(SRC)/dvo_catalog_split.$(ARCH).o     \
    4247$(SRC)/dvo_catalog_create.$(ARCH).o    \
     48$(SRC)/dvo_catalog_chipcoords.$(ARCH).o \
    4349$(SRC)/dvo_convert.$(ARCH).o           \
    4450$(SRC)/dvo_convert_elixir.$(ARCH).o    \
    4551$(SRC)/dvo_convert_loneos.$(ARCH).o    \
    46 $(SRC)/dvo_convert_panstarrs.$(ARCH).o \
    47 $(SRC)/dvo_convert_pmtest.$(ARCH).o \
     52$(SRC)/dvo_convert_panstarrs_DEV_0.$(ARCH).o \
    4853$(SRC)/skyregion_io.$(ARCH).o    \
    4954$(SRC)/skyregion_gsc.$(ARCH).o    \
    5055$(SRC)/skyregion_ops.$(ARCH).o
     56
     57# $(SRC)/dvo_convert_panstarrs.$(ARCH).o \
     58# $(SRC)/dvo_convert_pmtest.$(ARCH).o \
    5159
    5260include ../libautocode/Makefile.Targets

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

    r11991 r12332  
     1
     22007.02.22
     3
     4I have several DVO improvements to implement.  I need to plan them a
     5bit carefully.  Here are my thoughts on these updates.
     6
     7- add chip X,Y to measure table
     8
     9  this is a fairly simple addition.  In addstar/find_matches, I just need
     10  to assign the X,Y value from the incoming star data.  For loading
     11  old catalogs which don't include X,Y in the table, I need to
     12  calculate the X,Y position based on the R,D after finding the
     13  matching image.  I have code to do this calculation currently in
     14  dvo/photometry.c for looking up X,Y on the fly.  once this is moved
     15  into the load functions, it will not be needed in photometry.c
     16
     17- remove PRI/SEC and only use secfilt table for mags
     18
     19  this is not a very difficult change, conceptually, but it may be a
     20  fair amount of work.  all of the functions which currently switch on
     21  the case of PRI/SEC just need to look in the secfilt location.  the
     22  value of Nsec needs to increase by 1.  the load from tables which
     23  used PRI/SEC need to move the PRI values to the correct location in
     24  secfilt
     25
     26  eventually, rename 'secfilt' to a better name choice
     27
     28- add image, average, measure IDs
     29
     30  for PS1, the image and measure need to be generated by the external
     31  software.  they would just be part of the input stream.  for the
     32  case were the IDs are not supplied, DVO needs to generate them in a
     33  unique way.  I probably need to understand / define that mechanism
     34  before tackling this problem.
     35
     36  one point: I need to keep the old averef index.  how do this index
     37  and the objID work together?
     38
     39- link measure to image
     40
     41  temporariliy use an index like averef?
     42
     43- move photcode table to catdir (also zero points)
     44
     45  should be fairly easy: just like the SkyTable, look in the catdir
     46  first, then generate from the default text table if it is missing.
     47
     48- color term as a function of mosaic position
     49 
     50- mextract field,field,field
     51
     52  this should not be a very difficult job.  just add a loop to the
     53  avextract / mextract functions.
     54
     55- mextract field(s) where condition
     56
     57  this is a bit trickier, and could make use of the code in the dvo
     58  math functions
     59
     60- dvo select from mysql
     61
     62  not very difficult: need to define the commands to select the
     63  database and set up a connection, then parse the select line into
     64  the appropriate format.  just need to as the db for the type of the
     65  fields that are requested: must be numerical.
     66
     67  select field,field,field from table where condition
     68
     69- change vectors to doubles
     70
     71  probably not a terrible job.  this will depend on how the union is
     72  defined.  I don't want this to explode the size of an image!
     73
     74---------
    175
    276I now have the ability to load and save DVO databases in old formats,
    … …  
    1286- CFHT Elixir databases: cmp files, ELIXIR format
    1387- Brandon's Taurus db: incorrect 'PANSTARRS' format, should be called
    14   'PSTEST1'
     88  'PSTEST1'.  drop support for this eventually? have brandon migrate to
     89  the new panstarrs formats?
    1590
    1691I am going to use the following naming convention for future db table
    1792updates:
    1893
    19 - PANSTARRS.DEV.0
     94- PANSTARRS.DEV.0, PANSTARRS.DEV.1, etc
    2095- PANSTARRS.PS1.0, PANSTARRS.PS1.1, etc
    2196- PANSTARRS.PS4.0, PANSTARRS.PS4.1, etc

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

    r10931 r12332  
    1818
    1919/* DVO table formats */
    20 enum {DVO_FORMAT_UNDEF, DVO_FORMAT_INTERNAL, DVO_FORMAT_ELIXIR, DVO_FORMAT_LONEOS, DVO_FORMAT_PANSTARRS, DVO_FORMAT_PMTEST} DVOTableFormat;
     20enum {DVO_FORMAT_UNDEF,
     21      DVO_FORMAT_INTERNAL,
     22      DVO_FORMAT_ELIXIR,
     23      DVO_FORMAT_LONEOS,
     24      DVO_FORMAT_PANSTARRS,
     25      DVO_FORMAT_PMTEST,
     26      DVO_FORMAT_PANSTARRS_DEV_0
     27} DVOTableFormat;
    2128
    2229/* image data modes in RegImage */
    2330enum {T_UNDEF = -1, T_NONE, T_OBJECT, T_DARK, T_BIAS, T_FLAT, T_MASK, T_FRINGE, T_SCATTER, T_MODES, T_FRINGEPTS, T_ANY, N_TYPE};
    2431enum {M_UNDEF = -1, M_NONE, M_MEF, M_SPLIT, M_SINGLE, M_CUBE, M_SLICE, M_MODES, N_MODE};
     32
     33typedef enum {
     34    PROJ_NONE, // undefined
     35    PROJ_ZEA, // zenithal
     36    PROJ_ZPL, // zenithal
     37    PROJ_ARC, // zenithal
     38    PROJ_STG, // zenithal
     39    PROJ_SIN, // zenithal
     40    PROJ_TAN, // zenithal
     41    PROJ_DIS, // zenithal (TAN + polyterms)
     42    PROJ_LIN, // cartesian
     43    PROJ_PLY, // cartesian
     44    PROJ_WRP, // cartesian
     45    PROJ_AIT, // pseudocyl
     46    PROJ_GLS, // pseudocyl
     47    PROJ_PAR, // pseudocyl
     48} OhanaProjection;
     49
     50typedef enum {
     51  PROJ_MODE_NONE,
     52  PROJ_MODE_CARTESIAN,
     53  PROJ_MODE_ZENITHAL,
     54  PROJ_MODE_PSEUDOCYL,
     55} OhanaProjectionMode;
    2556
    2657/* RegImage.flag values */
    … …  
    3970
    4071/* photometry code types */
    41 # define PHOT_PRI 0x01
     72// # define PHOT_PRI 0x01
    4273# define PHOT_SEC 0x02
    4374# define PHOT_DEP 0x03
    … …  
    133164
    134165typedef struct {
    135   int Ncode;
    136   int Nsecfilt;
    137   int hashcode[0x10000];
    138   int hashNsec[0x10000];
     166  int Ncode;                                      // number of photcodes
     167  int Nsecfilt;                                   // number of average magnitudes
     168  int hashcode[0x10000];                  // index from photcode value to sequence
     169  int hashNsec[0x10000];                  // index from photcode value to Nsec seq
     170  int codeNsec[0x10000];                  // index from Nsec seq to photcode value
    139171  PhotCode *code;
    140172} PhotCodeData;
    … …  
    191223
    192224/* in coords.c, using libautocode/def/coords.d */
     225int  XY_to_LM (double *L, double *M, double x,  double y,   Coords *coords);
     226int  LM_to_XY (double *x,  double *y,   double L, double M, Coords *coords);
     227int  RD_to_LM (double *L, double *M, double ra,  double dec,   Coords *coords);
     228int  LM_to_RD (double *ra, double *dec,   double L, double M, Coords *coords);
    193229int  XY_to_RD (double *ra, double *dec, double x,  double y,   Coords *coords);
    194230int  RD_to_XY (double *x,  double *y,   double ra, double dec, Coords *coords);
    … …  
    199235void RegisterMosaic (Coords *coords);
    200236void coords_precess (double *ra, double *dec, double in_epoch, double out_epoch);
     237OhanaProjection GetProjection (char *ctype);
     238int SetProjection (char *ctype, OhanaProjection proj);
     239OhanaProjectionMode GetProjectionMode (OhanaProjection proj);
    201240
    202241char *libdvo_version ();
    … …  
    232271float PhotdM (PhotCode *code, Average *average, SecFilt *secfilt);
    233272
    234 # if (0)
    235 short iPhotInst (Measure *measure);
    236 short iPhotAbs (Measure *measure);
    237 short iPhotCat (Measure *measure);
    238 short iPhotSys (Measure *measure, Average *average, SecFilt *secfilt);
    239 short iPhotRel (Measure *measure, Average *average, SecFilt *secfilt);
    240 short iPhotCal (Measure *thisone, Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code);
    241 short iPhotAve (PhotCode *code, Average *average, SecFilt *secfilt);
    242 short iPhotRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure);
    243 short iPhotXm (PhotCode *code, Average *average, SecFilt *secfilt);
    244 short iPhotdM (PhotCode *code, Average *average, SecFilt *secfilt);
    245 # endif
    246 
    247 float iPhotColor (Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code);
     273float PhotColorForCode (Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code);
    248274int PhotColor (Average *average, SecFilt *secfilt, Measure *measure, int c1, int c2, double *color);
    249275
    250 int LoadPhotcodes (char *filename);
     276PhotCodeData *GetPhotcodeTable ();
     277
     278int LoadPhotcodes (char *catdir_file, char *master_file);
     279int LoadPhotcodesText (char *filename);
     280int LoadPhotcodesFITS (char *filename);
     281int SavePhotcodesText (char *filename);
     282int SavePhotcodesFITS (char *filename);
     283
     284void PrintPhotcodeNamebyCode (FILE *f, char *format, int code);
     285
    251286int GetPhotcodeCodebyName (char *name);
    252287int GetPhotcodeEquivCodebyName (char *name);
    … …  
    297332
    298333/*** conversion functions / I/O conversions ***/
    299 Average *ReadRawAverage (FILE *f, int Naverage, int format);
     334Average *ReadRawAverage (FILE *f, int Naverage, int format, SecFilt **primary);
    300335Measure *ReadRawMeasure (FILE *f, int Nmeasure, int format);
    301336SecFilt *ReadRawSecFilt (FILE *f, int Nsecfilt, int format);
    302 int WriteRawAverage (FILE *f, Average *average, int Naverage, int format);
     337int WriteRawAverage (FILE *f, Average *average, int Naverage, int format, SecFilt *primary);
    303338int WriteRawMeasure (FILE *f, Measure *measure, int Nmeasure, int format);
    304339int WriteRawSecFilt (FILE *f, SecFilt *secfilt, int Nsecfilt, int format);
    305340
    306 Average *FtableToAverage (FTable *ftable, int *Naverage, int *format);
    307 Average *AverageLoneosToInternal (AverageLoneos *in, int Nvalues);
    308 Average *AverageElixirToInternal (AverageElixir *in, int Nvalues);
    309 Average *AveragePanstarrsToInternal (AveragePanstarrs *in, int Nvalues);
    310 Average *AveragePMtestToInternal (AveragePMtest *in, int Nvalues);
    311 AverageLoneos *AverageInternalToLoneos (Average *in, int Nvalues);
    312 AverageElixir *AverageInternalToElixir (Average *in, int Nvalues);
    313 AveragePanstarrs *AverageInternalToPanstarrs (Average *in, int Nvalues);
    314 AveragePMtest *AverageInternalToPMtest (Average *in, int Nvalues);
    315 
     341Average *FtableToAverage (FTable *ftable, int *Naverage, int *format, SecFilt **primary);
    316342Measure *FtableToMeasure (FTable *ftable, int *Nmeasure, int *format);
    317 Measure *MeasureLoneosToInternal (MeasureLoneos *in, int Nvalues);
    318 Measure *MeasureElixirToInternal (MeasureElixir *in, int Nvalues);
    319 Measure *MeasurePanstarrsToInternal (MeasurePanstarrs *in, int Nvalues);
    320 MeasureLoneos *MeasureInternalToLoneos (Measure *in, int Nvalues);
    321 MeasureElixir *MeasureInternalToElixir (Measure *in, int Nvalues);
    322 MeasurePanstarrs *MeasureInternalToPanstarrs (Measure *in, int Nvalues);
    323 
    324343SecFilt *FtableToSecFilt (FTable *ftable, int *Nsecfilt, int *format);
    325 SecFilt *SecFiltLoneosToInternal (SecFiltLoneos *in, int Nvalues);
    326 SecFilt *SecFiltElixirToInternal (SecFiltElixir *in, int Nvalues);
    327 SecFilt *SecFiltPanstarrsToInternal (SecFiltPanstarrs *in, int Nvalues);
    328 SecFiltLoneos *SecFiltInternalToLoneos (SecFilt *in, int Nvalues);
    329 SecFiltElixir *SecFiltInternalToElixir (SecFilt *in, int Nvalues);
    330 SecFiltPanstarrs *SecFiltInternalToPanstarrs (SecFilt *in, int Nvalues);
    331 
    332 int AverageToFtable (FTable *ftable, Average *average, int Naverage, int format);
     344int FtableToImage (FTable *ftable, Header *theader, int *format);
     345
     346int AverageToFtable (FTable *ftable, Average *average, int Naverage, int format, SecFilt *primary);
    333347int MeasureToFtable (FTable *ftable, Measure *measure, int Nmeasure, int format);
    334348int SecFiltToFtable (FTable *ftable, SecFilt *secfilt, int Nsecfilt, int format);
     349int ImageToFtable (FTable *ftable, Header *theader, int format);
     350int ImageToVtable (VTable *vtable, Header *theader, int format);
     351
     352Image                  *ImageElixirToInternal (ImageElixir *in, int Nvalues);
     353Image                  *ImageLoneosToInternal (ImageLoneos *in, int Nvalues);
     354Image                  *ImagePanstarrsToInternal (ImagePanstarrs *in, int Nvalues);
     355Image                  *ImagePanstarrs_DEV_0_ToInternal (ImagePanstarrs_DEV_0 *in, int Nvalues);
     356
     357ImageElixir            *ImageInternalToElixir (Image *in, int Nvalues);
     358ImageLoneos            *ImageInternalToLoneos (Image *in, int Nvalues);
     359ImagePanstarrs         *ImageInternalToPanstarrs (Image *in, int Nvalues);
     360ImagePanstarrs_DEV_0   *ImageInternalToPanstarrs_DEV_0 (Image *in, int Nvalues);
     361
     362Average                *AverageLoneosToInternal (AverageLoneos *in, int Nvalues, SecFilt **primary);
     363Average                *AverageElixirToInternal (AverageElixir *in, int Nvalues, SecFilt **primary);
     364Average                *AveragePanstarrsToInternal (AveragePanstarrs *in, int Nvalues);
     365Average                *AveragePanstarrs_DEV_0_ToInternal (AveragePanstarrs_DEV_0 *in, int Nvalues);
     366
     367AverageLoneos          *AverageInternalToLoneos (Average *in, int Nvalues, SecFilt *primary);
     368AverageElixir          *AverageInternalToElixir (Average *in, int Nvalues, SecFilt *primary);
     369AveragePanstarrs       *AverageInternalToPanstarrs (Average *in, int Nvalues);
     370AveragePanstarrs_DEV_0 *AverageInternalToPanstarrs_DEV_0 (Average *in, int Nvalues);
     371
     372Measure                *MeasureLoneosToInternal (MeasureLoneos *in, int Nvalues);
     373Measure                *MeasureElixirToInternal (MeasureElixir *in, int Nvalues);
     374Measure                *MeasurePanstarrsToInternal (MeasurePanstarrs *in, int Nvalues);
     375Measure                *MeasurePanstarrs_DEV_0_ToInternal (MeasurePanstarrs_DEV_0 *in, int Nvalues);
     376
     377MeasureLoneos          *MeasureInternalToLoneos (Measure *in, int Nvalues);
     378MeasureElixir          *MeasureInternalToElixir (Measure *in, int Nvalues);
     379MeasurePanstarrs       *MeasureInternalToPanstarrs (Measure *in, int Nvalues);
     380MeasurePanstarrs_DEV_0 *MeasureInternalToPanstarrs_DEV_0 (Measure *in, int Nvalues);
     381
     382SecFilt                *SecFiltLoneosToInternal (SecFiltLoneos *in, int Nvalues);
     383SecFilt                *SecFiltElixirToInternal (SecFiltElixir *in, int Nvalues);
     384SecFilt                *SecFiltPanstarrsToInternal (SecFiltPanstarrs *in, int Nvalues);
     385SecFilt                *SecFiltPanstarrs_DEV_0_ToInternal (SecFiltPanstarrs_DEV_0 *in, int Nvalues);
     386
     387SecFiltLoneos          *SecFiltInternalToLoneos (SecFilt *in, int Nvalues);
     388SecFiltElixir          *SecFiltInternalToElixir (SecFilt *in, int Nvalues);
     389SecFiltPanstarrs       *SecFiltInternalToPanstarrs (SecFilt *in, int Nvalues);
     390SecFiltPanstarrs_DEV_0 *SecFiltInternalToPanstarrs_DEV_0 (SecFilt *in, int Nvalues);
    335391
    336392/*** DVO image db I/O Functions ***/
    … …  
    345401int dvo_image_addrows (FITS_DB *db, Image *new, int Nnew);
    346402void dvo_image_create (FITS_DB *db, double ZeroPoint);
    347 
    348 int FtableToImage (FTable *ftable, Header *theader, int *format);
    349 int ImageToFtable (FTable *ftable, Header *theader, int format);
    350 int ImageToVtable (VTable *vtable, Header *theader, int format);
    351 Image *ImageElixirToInternal (ImageElixir *in, int Nvalues);
    352 ImageElixir *ImageInternalToElixir (Image *in, int Nvalues);
    353 Image *ImageLoneosToInternal (ImageLoneos *in, int Nvalues);
    354 ImageLoneos *ImageInternalToLoneos (Image *in, int Nvalues);
    355 Image *ImagePanstarrsToInternal (ImagePanstarrs *in, int Nvalues);
    356 ImagePanstarrs *ImageInternalToPanstarrs (Image *in, int Nvalues);
    357403
    358404/* skyregion APIs */

  • trunk/Ohana/src/libdvo/src/LoadPhotcodes.c

    r9631 r12332  
    11# include <dvo.h>
    22
    3 # define NCTERMS 4
    4 # define F_PS 0.001
    5 # define NO_MAG_PS 100.0
     3int LoadPhotcodes (char *catdir_file, char *master_file) {
    64
    7 static PhotCodeData *photcodes = NULL;
    8 static double ZERO_POINT;
    9 static short int Nseclist[0x10000];
    10 
    11 /* static short int iZERO_POINT; */
    12 
    13 void SetZeroPoint (double ZP) {
    14   ZERO_POINT = ZP;
    15   /* iZERO_POINT = 1000 * ZP; */
    16 }
    17 
    18 int LoadPhotcodes (char *filename) {
     5  /* first try to load the photcodes from the specified CATDIR location */
     6  if (LoadPhotcodesFITS (catdir_file)) return TRUE;
    197 
    20   FILE *f;
    21   int i, Ns, Np, NPHOTCODE, Npri, Nfield;
    22   PhotCode *photcode;
    23   int code;
    24   char *c;
    25   char line[256];
    26   char name[32], type[32], Zero[32], Airmass[32], Offset[32],
    27     C1[32], C2[32], Slope[32], Color[32], Primary[32];
    28   int c1, c2;
    29 
    30   /* allocate space to photcode table, free existing data */
    31   if (photcodes == NULL) {
    32     ALLOCATE (photcodes, PhotCodeData, 1);
    33     photcodes[0].code = NULL;
    34   }
    35   if (photcodes[0].code != NULL) free (photcodes[0].code);
    36 
    37   f = fopen (filename, "r");
    38   if (f == (FILE *) NULL) {
    39     photcodes[0].Ncode    = 0;
    40     photcodes[0].Nsecfilt = 0;
    41     photcodes[0].code     = (PhotCode *) NULL;
    42     return (FALSE);
     8  /* next try to load the photcodes from the master text photcode file */
     9  /* automatically (or on demand?) save the text file to the FITS version */
     10  if (LoadPhotcodesText (master_file)) {
     11      if (!check_file_access (catdir_file, TRUE, TRUE)) return TRUE;
     12      SavePhotcodesFITS (catdir_file);
     13      return TRUE;
    4314  }
    4415
    45   Np = 0;
    46   NPHOTCODE = 10;
    47   ALLOCATE (photcode, PhotCode, NPHOTCODE);
    48   photcodes[0].Nsecfilt = 0;
    49   for (i = 0; i < 0x10000; i++) {
    50     photcodes[0].hashcode[i] = -1;
    51     photcodes[0].hashNsec[i] = -1;
    52   }
    53 
    54   while (scan_line (f, line) != EOF) {
    55     for (c = line; isspace (*c); c++);
    56     if (*c == '#') continue;
    57     Nfield = sscanf (c, "%d %s %s %s %s %s %s %s %s %s %s",
    58                      &code, name, type, Zero, Airmass, Offset, C1, C2, Slope, Color, Primary);
    59     if (Nfield != 11) { continue; }
    60    
    61     c1 = atof (C1);
    62     c2 = atof (C2);
    63     if (!strcmp (C1, "-")) { c1 = 0; }
    64     if (!strcmp (C2, "-")) { c2 = 0; }
    65 
    66     photcode[Np].type = 0;
    67     photcode[Np].code = code;
    68     strcpy (photcode[Np].name, name);
    69     if (!strncasecmp (type, "pri", 3)) {
    70       photcode[Np].type  = PHOT_PRI;
    71       photcode[Np].C     = 1000*atof (Zero);
    72       photcode[Np].K     = atof (Airmass);
    73       photcode[Np].dC    = 1000*atof (Offset);
    74       photcode[Np].dX    = 1000*atof (Color);
    75       photcode[Np].c1    = c1;
    76       photcode[Np].c2    = c2;
    77       photcode[Np].equiv = atoi (Primary);
    78       ParseColorTerms (Slope, photcode[Np].X, &photcode[Np].Nc);
    79       Nseclist[0] = Np;
    80     }     
    81     if (!strncasecmp (type, "sec", 3)) {
    82       photcode[Np].type  = PHOT_SEC;
    83       photcode[Np].C     = 1000*atof (Zero);
    84       photcode[Np].K     = atof (Airmass);
    85       photcode[Np].dC    = 1000*atof (Offset);
    86       photcode[Np].dX    = 1000*atof (Color);
    87       photcode[Np].c1    = c1;
    88       photcode[Np].c2    = c2;
    89       photcode[Np].equiv = atoi (Primary);
    90       photcodes[0].Nsecfilt ++;
    91       ParseColorTerms (Slope, photcode[Np].X, &photcode[Np].Nc);
    92       Nseclist[photcodes[0].Nsecfilt] = Np;
    93     }     
    94     if (!strncasecmp (type, "dep", 3)) {
    95       photcode[Np].type  = PHOT_DEP;
    96       photcode[Np].C     = 1000*atof (Zero);    /* zero point in millimags */
    97       photcode[Np].K     = atof (Airmass);      /* airmass coeff (millimag / millimag) */
    98       photcode[Np].dC    = 1000*atof (Offset);  /* color ref z.p. (millimag) */
    99       photcode[Np].dX    = 1000*atof (Color);   /* average color (millimag) */
    100       photcode[Np].c1    = c1;
    101       photcode[Np].c2    = c2;
    102       photcode[Np].equiv = atoi (Primary);
    103       ParseColorTerms (Slope, photcode[Np].X, &photcode[Np].Nc);
    104     }     
    105     if (!strncasecmp (type, "ref", 3)) {
    106       photcode[Np].type  = PHOT_REF;
    107       photcode[Np].C     = 0;
    108       photcode[Np].K     = 0;
    109       photcode[Np].dC    = 0;
    110       photcode[Np].dX    = 0;
    111       photcode[Np].c1    = 0;
    112       photcode[Np].c2    = 0;
    113       photcode[Np].equiv = atoi (Primary);
    114       photcode[Np].X[0]  = 0;
    115       photcode[Np].Nc    = 0;
    116     }
    117 
    118     /* alt photcodes are a little different: they have the SAME photcode as an existing
    119        pri/sec photcode, but define an alternate transformation for that code */
    120     if (!strncasecmp (type, "alt", 3)) {
    121       photcode[Np].type  = PHOT_ALT;
    122       photcode[Np].C     = 1000*atof (Zero);    /* zero point in millimags */
    123       photcode[Np].K     = atof (Airmass);      /* airmass coeff (millimag / millimag) */
    124       photcode[Np].dC    = 1000*atof (Offset);  /* color ref z.p. (millimag) */
    125       photcode[Np].dX    = 1000*atof (Color);   /* average color (millimag) */
    126       photcode[Np].c1    = c1;
    127       photcode[Np].c2    = c2;
    128       photcode[Np].equiv = atoi (Primary);
    129       ParseColorTerms (Slope, photcode[Np].X, &photcode[Np].Nc);
    130     }
    131     if (!photcode[Np].type) {
    132       fprintf (stderr, "error in Photfile: unknown type %s\n", type);
    133     }
    134 
    135     Np++;
    136     if (Np == NPHOTCODE) {
    137       NPHOTCODE += 10;
    138       REALLOCATE (photcode, PhotCode, NPHOTCODE);
    139     }
    140   }
    141   fclose (f);
    142  
    143   /* set up hashcode for photcode refs:
    144    * the hashcode gives the structure sequence for a given photcode:
    145    * photcode[i].hashcode[photcode[i].code] == i
    146    */
    147 
    148   Ns = 0;
    149   for (i = 0; i < Np; i++) {
    150     if (photcode[i].type == PHOT_ALT) continue; /* no hashcode for ALT codes */
    151     if (photcodes[0].hashcode[photcode[i].code] != -1) {
    152       fprintf (stderr, "duplicate photcodes in file\n");
    153       code = photcodes[0].hashcode[photcode[i].code];
    154       fprintf (stderr, "conflict between %s (%d) and %s (%d)\n",
    155                photcode[i].name, photcode[i].code, photcode[code].name, photcode[code].code);
    156       free (photcode);
    157       return (FALSE);
    158     }
    159     photcodes[0].hashcode[photcode[i].code] = i;
    160     if (photcode[i].type == PHOT_SEC) {
    161       photcodes[0].hashNsec[photcode[i].code] = Ns;
    162       Ns ++;
    163     }
    164   }
    165   /* validity check for references */
    166   for (i = 0; i < Np; i++) {
    167     if (photcode[i].type == PHOT_DEP) {
    168       Npri = photcodes[0].hashcode[photcode[i].equiv];
    169       if ((Npri >= Np) || (Npri < 0)) {
    170         fprintf (stderr, "reference for dependent photcode is not in photcodes\n");
    171         free (photcode);
    172         return (FALSE);
    173       }
    174       if ((photcode[Npri].type != PHOT_PRI) && (photcode[Npri].type != PHOT_SEC)) {
    175         fprintf (stderr, "reference for dependent photcode is not a primary or secondary code\n");
    176         free (photcode);
    177         return (FALSE);
    178       }
    179     }
    180     if (photcode[i].type == PHOT_ALT) {
    181       Npri = photcodes[0].hashcode[photcode[i].code];
    182       if ((Npri >= Np) || (Npri < 0)) {
    183         fprintf (stderr, "reference for alternate photcode is not in photcodes\n");
    184         free (photcode);
    185         return (FALSE);
    186       }
    187       if ((photcode[Npri].type != PHOT_PRI) && (photcode[Npri].type != PHOT_SEC)) {
    188         fprintf (stderr, "reference for alternate photcode is not a primary or secondary code\n");
    189         free (photcode);
    190         return (FALSE);
    191       }
    192     }
    193   }
    194   photcodes[0].code = photcode;
    195   photcodes[0].Ncode = Np;
    196 
    197   return (TRUE);
    198 
     16  return FALSE;
    19917}
    200 
    201 void ParseColorTerms (char *terms, float *X, int *N) {
    202 
    203   int i;
    204   char *p;
    205 
    206   p = terms;
    207 
    208   for (i = 0; (p != NULL) && (i < NCTERMS); i++) {
    209     X[i] = atof (p);
    210     p = strchr (p, ',');
    211     if (p == (char *) NULL) continue;
    212     p ++;
    213   }
    214   *N = i;
    215 }
    216 
    217 /********** photcode lookups **********/
    218 
    219 /* return photcode for given name */
    220 PhotCode *GetPhotcodebyName (char *name) {
    221  
    222   int i;
    223 
    224   if (name == (char *) NULL ) return (NULL);
    225  
    226   for (i = 0; i < photcodes[0].Ncode; i++) {
    227     if (!strcmp (photcodes[0].code[i].name, name)) {
    228       return (&photcodes[0].code[i]);
    229     }
    230   }
    231   return (NULL);
    232 }
    233 /* return photcode.code for given name */
    234 int GetPhotcodeCodebyName (char *name) {
    235  
    236   int i;
    237  
    238   if (name == (char *) NULL ) return (0);
    239 
    240   for (i = 0; i < photcodes[0].Ncode; i++) {
    241     if (!strcmp (photcodes[0].code[i].name, name)) {
    242       return (photcodes[0].code[i].code);
    243     }
    244   }
    245   return (0);
    246 }
    247 /* return equivalent photcode for given name */
    248 PhotCode *GetPhotcodeEquivbyName (char *name) {
    249  
    250   int i, equiv;
    251  
    252   if (name == (char *) NULL ) return (NULL);
    253 
    254   for (i = 0; i < photcodes[0].Ncode; i++) {
    255     if (!strcmp (photcodes[0].code[i].name, name)) {
    256       if (photcodes[0].code[i].equiv == 0) return (NULL);
    257       equiv = photcodes[0].hashcode[photcodes[0].code[i].equiv];
    258       if (equiv == -1) return (NULL);
    259       return (&photcodes[0].code[equiv]);
    260     }
    261   }
    262   return (NULL);
    263 }
    264 /* return equivalent photcode.code for given name */
    265 int GetPhotcodeEquivCodebyName (char *name) {
    266  
    267   int i, equiv;
    268  
    269   if (name == (char *) NULL ) return (0);
    270 
    271   for (i = 0; i < photcodes[0].Ncode; i++) {
    272     if (!strcmp (photcodes[0].code[i].name, name)) {
    273       if (photcodes[0].code[i].equiv == 0) return (0);
    274       equiv = photcodes[0].hashcode[photcodes[0].code[i].equiv];
    275       if (equiv == -1) return (0);
    276       return (photcodes[0].code[equiv].code);
    277     }
    278   }
    279   return (0);
    280 }
    281 
    282 /* return photcode for given code */
    283 PhotCode *GetPhotcodebyCode (int code) {
    284  
    285   int entry;
    286  
    287   if (code < 0) return (NULL);
    288   if (code > 0x10000) return (NULL);
    289 
    290   entry = photcodes[0].hashcode[code];
    291   if (entry == -1) return (NULL);
    292 
    293   return (&photcodes[0].code[entry]);
    294 }
    295 /* return photcode.code for given code */
    296 char *GetPhotcodeNamebyCode (int code) {
    297  
    298   int entry;
    299  
    300   if (code < 0) return (NULL);
    301   if (code > 0x10000) return (NULL);
    302 
    303   entry = photcodes[0].hashcode[code];
    304   if (entry == -1) return (NULL);
    305 
    306   return (photcodes[0].code[entry].name);
    307 }
    308 /* return equivalent photcode for given code */
    309 PhotCode *GetPhotcodeEquivbyCode (int code) {
    310  
    311   int entry, equiv;
    312  
    313   if (code < 0) return (NULL);
    314   if (code > 0x10000) return (NULL);
    315 
    316   entry = photcodes[0].hashcode[code];
    317   if (entry == -1) return (NULL);
    318 
    319   if (photcodes[0].code[entry].equiv == 0) return (NULL);
    320   equiv = photcodes[0].hashcode[photcodes[0].code[entry].equiv];
    321 
    322   if (equiv == -1) return (NULL);
    323   return (&photcodes[0].code[equiv]);
    324 }
    325 /* return equivalent photcode.code for given code */
    326 int GetPhotcodeEquivCodebyCode (int code) {
    327  
    328   int entry;
    329  
    330   if (code < 0) return (0);
    331   if (code > 0x10000) return (0);
    332 
    333   entry = photcodes[0].hashcode[code];
    334   if (entry == -1) return (0);
    335   return (photcodes[0].code[entry].equiv);
    336 }
    337 
    338 int GetPhotcodeNsec (int code) {
    339  
    340   int Nsec;
    341  
    342   if (code < 0) return (-1);
    343   if (code > 0x10000) return (-1);
    344 
    345   Nsec = photcodes[0].hashNsec[code];
    346   return (Nsec);
    347 }
    348 
    349 /* Nsec of 0 is PRI */
    350 PhotCode *GetPhotcodebyNsec (int Nsec) {
    351  
    352   if (Nsec > photcodes[0].Nsecfilt) return (NULL);
    353   if (Nsec < 0) return (NULL);
    354  
    355   return (&photcodes[0].code[Nseclist[Nsec]]);
    356 }
    357 
    358 int GetPhotcodeNsecfilt () {
    359   return (photcodes[0].Nsecfilt);
    360 }
    361 
    362 /* ALLOCATE and return list of all photcodes
    363    with photcode.equiv == code */
    364 int *GetPhotcodeEquivList (int code, int *nlist) {
    365 
    366   int i, Nlist;
    367   int *list;
    368 
    369   ALLOCATE (list, int, MAX (1, photcodes[0].Ncode));
    370   Nlist = 0;
    371   for (i = 0; i < photcodes[0].Ncode; i++) {
    372     if (photcodes[0].code[i].equiv != code) continue;
    373     list[Nlist] = photcodes[0].code[i].code;
    374     Nlist ++;
    375   }
    376   REALLOCATE (list, int, MAX (1, Nlist));
    377 
    378   *nlist = Nlist;
    379   return (list);
    380 }
    381 
    382 /**** conversion to INTERNAL vs TABLE types makes the iPhot versions irrelevant ****/
    383 # if (0)
    384 /******** photometry conversions *********/
    385 double PhotInst (Measure *measure) {
    386 
    387   short Mi;
    388   double M;
    389 
    390   Mi = iPhotInst (measure);
    391   M = 0.001*Mi;
    392   return (M);
    393 }
    394 
    395 /****/
    396 double PhotCat (Measure *measure) {
    397 
    398   short Mi;
    399   double M;
    400 
    401   Mi = iPhotCat (measure);
    402   M = 0.001*Mi;
    403   return (M);
    404 }
    405 
    406 /****/
    407 double PhotSys (Measure *measure, Average *average, SecFilt *secfilt) {
    408 
    409   short Mi;
    410   double M;
    411 
    412   Mi = iPhotSys (measure, average, secfilt);
    413   M = 0.001*Mi;
    414   return (M);
    415 }
    416 
    417 /****/
    418 double PhotRel (Measure *measure, Average *average, SecFilt *secfilt) {
    419 
    420   short Mi;
    421   double M;
    422 
    423   Mi = iPhotRel (measure, average, secfilt);
    424   M = 0.001*Mi;
    425   return (M);
    426 }
    427 
    428 /****/
    429 double PhotCal (Measure *thisone, Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code) {
    430 
    431   short Mi;
    432   double M;
    433 
    434   Mi = iPhotCal (thisone, average, secfilt, measure, code);
    435   M = 0.001*Mi;
    436   return (M);
    437 }
    438 
    439 /****/
    440 double PhotRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure) {
    441 
    442   short Mi;
    443   double M;
    444 
    445   Mi = iPhotRef (code, average, secfilt, measure);
    446   M = 0.001*Mi;
    447   return (M);
    448 }
    449 
    450 /****/
    451 double PhotAve (PhotCode *code, Average *average, SecFilt *secfilt) {
    452 
    453   short Mi;
    454   double M;
    455 
    456   Mi = iPhotAve (code, average, secfilt);
    457   M = 0.001*Mi;
    458   return (M);
    459 }
    460 
    461 /****/
    462 double PhotdM (PhotCode *code, Average *average, SecFilt *secfilt) {
    463 
    464   short Mi;
    465   double M;
    466 
    467   Mi = iPhotdM (code, average, secfilt);
    468   M = 0.001*Mi;
    469   return (M);
    470 }
    471 
    472 /****/
    473 double PhotXm (PhotCode *code, Average *average, SecFilt *secfilt) {
    474 
    475   int Mi;
    476   double Xm;
    477 
    478   Mi = iPhotXm (code, average, secfilt);
    479   Xm = (Mi == NO_MAG) ? -1.0 : pow (10.0, 0.01*Mi);
    480   return (Xm);
    481 }
    482 
    483 # endif
    484 
    485 /******** internal photometry conversions (keeps values in short int millimags) *********/
    486 float PhotInst (Measure *measure) {
    487 
    488   int Np;
    489   float M;
    490 
    491   Np = photcodes[0].hashcode[measure[0].source];
    492   if (Np == -1) return (NO_MAG_PS);
    493 
    494   if (photcodes[0].code[Np].type == PHOT_REF) {
    495     M = measure[0].M_PS;
    496     return (M);
    497   }
    498 
    499   M = measure[0].M_PS - measure[0].dt_PS - ZERO_POINT;
    500          
    501   return (M);
    502 
    503 }
    504 
    505 float PhotCat (Measure *measure) {
    506 
    507   int Np;
    508   float Mcat;
    509   PhotCode *code;
    510 
    511   Np = photcodes[0].hashcode[measure[0].source];
    512   if (Np == -1) return (NO_MAG_PS);
    513 
    514   if (photcodes[0].code[Np].type == PHOT_REF) {
    515     Mcat = measure[0].M_PS;
    516     return (Mcat);
    517   }
    518   code = &photcodes[0].code[Np];
    519   Mcat = measure[0].M_PS - ZERO_POINT + code[0].K*(measure[0].airmass_PS - 1.000) + F_PS*code[0].C;
    520  
    521   return (Mcat);
    522 }
    523 
    524 float PhotSys (Measure *measure, Average *average, SecFilt *secfilt) {
    525 
    526   int i, Np;
    527   float Mcat, Mcol, Msys, mc, Mc;
    528   PhotCode *code;
    529 
    530   Np = photcodes[0].hashcode[measure[0].source];
    531   if (Np == -1) return (NO_MAG_PS);
    532 
    533   if (photcodes[0].code[Np].type == PHOT_REF) {
    534     Msys = measure[0].M_PS;
    535     return (Msys);
    536   }
    537   code = &photcodes[0].code[Np];
    538   Mcat = measure[0].M_PS - ZERO_POINT + code[0].K*(measure[0].airmass_PS - 1.000) + F_PS*code[0].C;
    539 
    540   /* for DEP, color must be made of PRI/SEC */
    541   mc = iPhotColor (average, secfilt, NULL, code);
    542   if (mc == NO_MAG_PS) return (Mcat);
    543   mc = mc - F_PS*code[0].dX;
    544 
    545   Mc = mc;
    546   Mcol = 0;
    547   for (i = 0; i < code[0].Nc; i++) {
    548     Mcol += code[0].X[i]*Mc;
    549     Mc *= mc;
    550   }
    551   Msys = Mcat + Mcol;
    552   return (Msys);
    553 }
    554 
    555 float PhotRel (Measure *measure, Average *average, SecFilt *secfilt) {
    556 
    557   int i, Np;
    558   float Mcat, Mcol, Mrel, mc, Mc;
    559   PhotCode *code;
    560 
    561   Np = photcodes[0].hashcode[measure[0].source];
    562   if (Np == -1) return (NO_MAG_PS);
    563 
    564   if (photcodes[0].code[Np].type == PHOT_REF) {
    565     Mcat = measure[0].M_PS;
    566     return (Mcat);
    567   }
    568   code = &photcodes[0].code[Np];
    569   Mrel = measure[0].M_PS - ZERO_POINT + code[0].K*(measure[0].airmass_PS - 1.000) + F_PS*code[0].C - measure[0].Mcal_PS;
    570 
    571   /* for DEP, color must be made of PRI/SEC */
    572   mc = iPhotColor (average, secfilt, NULL, code);
    573   if (mc == NO_MAG_PS) return (Mrel);
    574   mc = mc - F_PS*code[0].dX;
    575 
    576   Mc = mc;
    577   Mcol = 0;
    578   for (i = 0; i < code[0].Nc; i++) {
    579     Mcol += code[0].X[i]*Mc;
    580     Mc *= mc;    /* the 0.001 is needed for higher order terms to keep the units mag = mag^n */
    581   }
    582   Mrel += Mcol;
    583   return (Mrel);
    584 }
    585 
    586 /* return calibrated magnitude from measure for given photcode */
    587 float PhotCal (Measure *thisone, Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code) {
    588 
    589   int i, Np;
    590   float Mcal, Mrel, Mcol, mc, Mc;
    591 
    592   /* code must be the matching PRI/SEC code for this measurement or an equivalent ALT */
    593   Np = photcodes[0].hashcode[thisone[0].source];
    594   if (Np == -1) {
    595     return (NO_MAG_PS);
    596   }
    597 
    598   if (photcodes[0].code[Np].type == PHOT_REF) {
    599     Mrel = thisone[0].M_PS;
    600     return (Mrel);
    601   }
    602   if (code[0].code != photcodes[0].code[Np].equiv) {
    603     return (NO_MAG_PS);
    604   }
    605 
    606   Mcal = PhotRel (thisone, average, secfilt) + F_PS*code[0].C;
    607 
    608   mc = iPhotColor (average, secfilt, measure, code);
    609   if (mc == NO_MAG_PS) return (Mcal);
    610   mc = mc - F_PS*code[0].dX;
    611 
    612   Mc = mc;
    613   Mcol = 0;
    614   for (i = 0; i < code[0].Nc; i++) {
    615     Mcol += code[0].X[i]*Mc;
    616     Mc *= mc;
    617   }
    618   Mcal += Mcol;
    619   return (Mcal);
    620 }
    621 
    622 /* color term may not use DEP magnitude */
    623 float iPhotColor (Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code) {
    624 
    625   int i, Ns1, Ns2, Ns;
    626   float m1, m2, mc;
    627   PhotCode *color;
    628 
    629   m1 = m2 = NO_MAG_PS;
    630 
    631   if (measure == NULL) {
    632     Ns1 = photcodes[0].hashNsec[code[0].c1];
    633     Ns2 = photcodes[0].hashNsec[code[0].c2];
    634  
    635     m1 = (Ns1 == -1) ? average[0].M : secfilt[Ns1].M_PS;
    636     m2 = (Ns2 == -1) ? average[0].M : secfilt[Ns2].M_PS;
    637     mc = ((m1 == NO_MAG_PS) || (m2 == NO_MAG_PS)) ? NO_MAG_PS : (m1 - m2);
    638     return (mc);
    639   }
    640 
    641   /* find magnitude matching first color term */
    642   color = GetPhotcodebyCode (code[0].c1);
    643   if (color == NULL) return (NO_MAG_PS);
    644   if (color[0].type == PHOT_REF) {
    645     for (i = 0; (i < average[0].Nm) && (m1 == NO_MAG_PS); i++) {
    646       if (measure[i].source == color[0].code) {
    647         m1 = measure[i].M_PS;
    648       }
    649     }
    650   } else {
    651     Ns = photcodes[0].hashNsec[color[0].code];
    652     m1 = (Ns == -1) ? average[0].M : secfilt[Ns].M_PS;
    653   }     
    654 
    655   /* find magnitude matching second color term */
    656   color = GetPhotcodebyCode (code[0].c2);
    657   if (color == NULL) return (NO_MAG_PS);
    658   if (color[0].type == PHOT_REF) {
    659     for (i = 0; (i < average[0].Nm) && (m2 == NO_MAG_PS); i++) {
    660       if (measure[i].source == color[0].code) {
    661         m2 = measure[i].M_PS;
    662       }
    663     }
    664   } else {
    665     Ns = photcodes[0].hashNsec[color[0].code];
    666     m2 = (Ns == -1) ? average[0].M : secfilt[Ns].M_PS;
    667   }     
    668   mc = ((m1 == NO_MAG_PS) || (m2 == NO_MAG_PS)) ? NO_MAG_PS : (m1 - m2);
    669   return (mc);
    670 }
    671 
    672 /* return calibrated magnitude from average/secfilt for given photcode */
    673 float PhotRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure) {
    674 
    675   int i, Ns;
    676   float Mave, Mref, Mcol, mc;
    677   double Mc;
    678 
    679   Ns = photcodes[0].hashNsec[code[0].code];
    680   Mave = (Ns == -1) ? average[0].M : secfilt[Ns].M_PS;
    681   Mref = Mave + F_PS*code[0].C;
    682 
    683   mc = iPhotColor (average, secfilt, measure, code);
    684   if (mc == NO_MAG_PS) return (Mref);
    685   mc = mc - F_PS*code[0].dX;
    686 
    687   Mc = mc;
    688   Mcol = 0;
    689   for (i = 0; i < code[0].Nc; i++) {
    690     Mcol += code[0].X[i]*Mc;
    691     Mc *= mc;    /* the 0.001 is needed for higher order terms to keep the units mag = mag^n */
    692   }
    693   Mref += Mcol;
    694   return (Mref);
    695 }
    696 
    697 /***/
    698 float PhotAve (PhotCode *code, Average *average, SecFilt *secfilt) {
    699 
    700   int Ns;
    701   float Mave;
    702 
    703   Ns = photcodes[0].hashNsec[code[0].code];
    704   Mave = (Ns == -1) ? average[0].M : secfilt[Ns].M_PS;
    705   return (Mave);
    706 }
    707 
    708 /*** note that this is NOT a wrapper around iPhotdM ***/
    709 float PhotdM (PhotCode *code, Average *average, SecFilt *secfilt) {
    710 
    711   int Ns;
    712   float dM;
    713 
    714   Ns = photcodes[0].hashNsec[code[0].code];
    715   dM  = (Ns == -1) ? average[0].dM : secfilt[Ns].dM_PS;
    716   return (dM);
    717 }
    718 
    719 /*** note that this is NOT a wrapper around iPhotXm ***/
    720 float PhotXm (PhotCode *code, Average *average, SecFilt *secfilt) {
    721 
    722   int Ns;
    723   short Mi;
    724   float Xm;
    725 
    726   Ns = photcodes[0].hashNsec[code[0].code];
    727   Mi = (Ns == -1) ? average[0].Xm : secfilt[Ns].Xm;
    728   Xm = (Mi == NO_MAG_PS) ? -1.0 : pow (10.0, 0.01*Mi);
    729   return (Xm);
    730 }
    731 
    732 /* given a photcode pair c1 & c2, return the color of this star (NaN if not found) */
    733 int PhotColor (Average *average, SecFilt *secfilt, Measure *measure, int c1, int c2, double *color) {
    734 
    735   int i, Ns;
    736   double M1, M2, dM;
    737   PhotCode *code;
    738  
    739   code = GetPhotcodebyCode (c1);
    740   if (code == NULL) return (FALSE);
    741   if (code[0].type == PHOT_REF) {
    742     for (i = 0; i < average[0].Nm; i++) {
    743       if (measure[i].source == c1) {
    744         M1 = measure[i].M_PS;
    745         goto filter1;
    746       }
    747     }   
    748     return (FALSE);
    749   } else {
    750     Ns = photcodes[0].hashNsec[code[0].code];
    751     M1 = (Ns == -1) ? average[0].M : secfilt[Ns].M_PS;
    752   }     
    753 
    754 filter1:
    755   code = GetPhotcodebyCode (c2);
    756   if (code == NULL) return (FALSE);
    757   if (code[0].type == PHOT_REF) {
    758     for (i = 0; i < average[0].Nm; i++) {
    759       if (measure[i].source == c2) {
    760         M2 = measure[i].M_PS;
    761         goto filter2;
    762       }
    763     }   
    764     return (FALSE);
    765   } else {
    766     Ns = photcodes[0].hashNsec[code[0].code];
    767     M2 = (Ns == -1) ? average[0].M : secfilt[Ns].M_PS;
    768   }     
    769  
    770 filter2:
    771 
    772   dM = M1 - M2;
    773   *color = dM;
    774  
    775   return (TRUE);
    776 }
    777 
    778 /* photcode table should have the following format:
    779 
    780 # code name     type  zero  airmass  offset  c1 c2  slope  <color>  primary
    781 1    B        pri   24.0  0.15     -       -  -   -      -        -
    782 2    B        pri   24.0  0.15     -       -  -   -      -        -
    783 3    B1       sec   22.5  0.18     0.15    1  2   0.10   0.50     1
    784 1000 USNO_B   ref   -     -        -       -  -   -      -        -
    785 
    786 */
    787 
    788 
    789 /*
    790   Nc1 = photcodes[0].code[Np].c1;
    791   Ns1 = photcodes[0].hashNsec[Nc1];
    792 
    793   Nc2 = photcodes[0].code[Np].c2;
    794   Ns2 = photcodes[0].hashNsec[Nc2];
    795 
    796   Xlam = photcodes[0].code[Np].X[0];
    797   Klam = photcodes[0].code[Np].K;
    798  
    799   m1 = (Ns1 == -1) ? average[0].M : secfilt[Ns1].M;
    800   m2 = (Ns2 == -1) ? average[0].M : secfilt[Ns2].M;
    801 */

  • trunk/Ohana/src/libdvo/src/coordops.c

    r10510 r12332  
    77}
    88
    9 int XY_to_RD (double *ra, double *dec, double x, double y, Coords *coords) {
    10 
    11   int Zenith1, Zenith2, Zenithal, Polynomial, Cartesian, PseudoCyl;
    12   char *type;
    13   double L, M, X, Y, T, Z, Z2;
    14   double R, sphi, cphi, stht, ctht;
    15   double alpha, delta, salp, calp, sdel, sdp, cdp;
    16  
    17   *ra  = 0;
    18   *dec = 0;
    19   stht = ctht = 1;
    20   type = &coords[0].ctype[4];
    21  
    22   /* PLY is equiv to LIN with higher order terms
    23      ZPL is equiv to ZEA with higher order terms
    24      DIS is equiv to TAN with higher order terms
    25      WRP is equiv to PLY, with implied mosaic */
    26 
    27   Polynomial = !strcmp(type, "-PLY") || !strcmp(type, "-DIS") || !strcmp(type, "-WRP") || !strcmp(type, "-ZPL");
    28   Cartesian  = !strcmp(type, "-LIN") || !strcmp(type, "-PLY") || !strcmp(type, "-WRP") || !strcmp(&coords[0].ctype[0], "GENE");
    29   PseudoCyl  = !strcmp(type, "-AIT") || !strcmp(type, "-GLS") || !strcmp(type, "-PAR");
    30   Zenith1    = !strcmp(type, "-DIS") || !strcmp(type, "-TAN") || !strcmp(type, "-STG");
    31   Zenith2    = !strcmp(type, "-SIN") || !strcmp(&coords[0].ctype[0], "MM");
    32   Zenithal   = !strcmp(type, "-ZEA") || !strcmp(type, "-ZPL") || Zenith1 || Zenith2;
    33   if (!Zenithal && !Cartesian && !PseudoCyl) return (FALSE);
     9int XY_to_LM (double *L, double *M, double x, double y, Coords *coords) {
     10
     11  double X, Y;
    3412
    3513  /** convert pixel coordinates to cartesian system **/
    … …  
    3715  Y = coords[0].cdelt2*(y - coords[0].crpix2);
    3816
    39   L = (X*coords[0].pc1_1 + Y*coords[0].pc1_2);
    40   M = (X*coords[0].pc2_1 + Y*coords[0].pc2_2);
     17  *L = (X*coords[0].pc1_1 + Y*coords[0].pc1_2);
     18  *M = (X*coords[0].pc2_1 + Y*coords[0].pc2_2);
    4119
    4220  /** extra polynomial terms **/
    4321  if (coords[0].Npolyterms > 1) {
    44     L += X*X*coords[0].polyterms[0][0] + X*Y*coords[0].polyterms[1][0] + Y*Y*coords[0].polyterms[2][0];
    45     M += X*X*coords[0].polyterms[0][1] + X*Y*coords[0].polyterms[1][1] + Y*Y*coords[0].polyterms[2][1];
     22    *L += X*X*coords[0].polyterms[0][0] + X*Y*coords[0].polyterms[1][0] + Y*Y*coords[0].polyterms[2][0];
     23    *M += X*X*coords[0].polyterms[0][1] + X*Y*coords[0].polyterms[1][1] + Y*Y*coords[0].polyterms[2][1];
    4624  }
    4725  if (coords[0].Npolyterms > 2) {
    48     L += X*X*X*coords[0].polyterms[3][0] + X*X*Y*coords[0].polyterms[4][0] + X*Y*Y*coords[0].polyterms[5][0] + Y*Y*Y*coords[0].polyterms[6][0];
    49     M += X*X*X*coords[0].polyterms[3][1] + X*X*Y*coords[0].polyterms[4][1] + X*Y*Y*coords[0].polyterms[5][1] + Y*Y*Y*coords[0].polyterms[6][1];
    50   }
    51 
    52   /**** Locally Cartesian Projections ****/
    53   if (Cartesian) {
     26    *L += X*X*X*coords[0].polyterms[3][0] + X*X*Y*coords[0].polyterms[4][0] + X*Y*Y*coords[0].polyterms[5][0] + Y*Y*Y*coords[0].polyterms[6][0];
     27    *M += X*X*X*coords[0].polyterms[3][1] + X*X*Y*coords[0].polyterms[4][1] + X*Y*Y*coords[0].polyterms[5][1] + Y*Y*Y*coords[0].polyterms[6][1];
     28  }
     29
     30  return (TRUE);
     31}
     32
     33int LM_to_RD (double *ra, double *dec, double L, double M, Coords *coords) {
     34
     35  OhanaProjection proj;
     36  OhanaProjectionMode mode;
     37  double R, T, Z, Z2, sphi, cphi, stht, ctht;
     38  double alpha, delta, salp, calp, sdel, sdp, cdp;
     39
     40  proj = GetProjection (coords[0].ctype);
     41  mode = GetProjectionMode (proj);
     42  if (proj == PROJ_NONE) return (FALSE);
     43  if (proj == PROJ_MODE_NONE) return (FALSE);
     44
     45  stht = ctht = 1;
     46
     47  /** Locally Cartesian Projections **/
     48  if (mode == PROJ_MODE_CARTESIAN) {
    5449    *ra  = L + coords[0].crval1;
    5550    *dec = M + coords[0].crval2;
    5651
    5752    /* mosaic astrometry : WRP is chip astrometry; apply mosaic (DIS) term */
    58     if (!strcmp(type, "-WRP")) {
     53    if (proj == PROJ_WRP) {
    5954      if (mosaic == NULL) return (FALSE);
    6055      XY_to_RD (ra, dec, L + coords[0].crval1, M + coords[0].crval2, mosaic);
    … …  
    6358  }
    6459 
    65   /**** Zenithal Projections ****/
    66   if (Zenithal) {
     60  /** Zenithal Projections **/
     61  if (mode == PROJ_MODE_ZENITHAL) {
    6762    R = hypot (L,M);
    6863    if ((L == 0) && (M == 0)) {
    … …  
    7469    }
    7570
    76     /* this is wrong : STG is not TAN - need to put in correct relationships.  but is a close approx */
    77     if (Zenith1) {
    78       if (R == 0) {
    79         stht = 1.0;
    80         ctht = 0.0;
    81       } else {
    82         T = DEG_RAD / R;
    83         stht =   T / sqrt ( 1.0 + T*T);
    84         ctht = 1.0 / sqrt ( 1.0 + T*T);
    85       }
    86     }
    87     if (Zenith2) {
    88       ctht = RAD_DEG * R;
    89       stht = sqrt (1 - ctht*ctht);
    90     }
    91     if (!strcmp(type, "-ZEA") || !strcmp(type, "-ZPL")) {
    92       if (R > 2*DEG_RAD) {
    93         *ra = L;
    94         *dec = M;
     71    switch (proj) {
     72      case PROJ_TAN:
     73        if (R == 0) {
     74          stht = 1.0;
     75          ctht = 0.0;
     76        } else {
     77          T = DEG_RAD / R;
     78          stht =   T / sqrt ( 1.0 + T*T);
     79          ctht = 1.0 / sqrt ( 1.0 + T*T);
     80        }
     81        break;
     82      case PROJ_STG:
     83        stht = (4 - RAD_DEG*R) / (4 + RAD_DEG*R);
     84        ctht = sqrt (1 - stht*stht);
     85        break;
     86      case PROJ_SIN:
     87        ctht = RAD_DEG * R;
     88        stht = sqrt (1 - ctht*ctht);
     89        break;
     90      case PROJ_ZEA:
     91      case PROJ_ZPL:
     92        if (R > 2*DEG_RAD) {
     93          *ra = L;
     94          *dec = M;
     95          return (FALSE);
     96        }
     97        stht = 1 - 0.5*SQ(R*RAD_DEG);
     98        ctht = sqrt (1 - stht*stht);
     99        break;
     100      default:
    95101        return (FALSE);
    96       }
    97       stht = 1 - 0.5*SQ(R*RAD_DEG);
    98       ctht = sqrt (1 - stht*stht);
    99     }
    100 
     102    }
    101103    sdp  = sin(RAD_DEG*coords[0].crval2);
    102104    cdp  = cos(RAD_DEG*coords[0].crval2);
    … …  
    119121 
    120122  /**** Other Conventional Projections ****/
    121   if (PseudoCyl) {
    122     if (!strcmp(type, "-AIT")) {
     123  if (mode == PROJ_MODE_PSEUDOCYL) {
     124    switch (proj) {
     125      case PROJ_AIT:
    123126      Z2 = (1.0 - SQ(RAD_DEG*0.25*L) - SQ(RAD_DEG*0.5*M));
    124127      if (Z2 < 0) return (FALSE);
    … …  
    126129      alpha = 2.0 * DEG_RAD * atan2 (RAD_DEG*0.5*Z*L, 2.0*Z2 - 1.0);
    127130      delta = DEG_RAD * asin (RAD_DEG*M*Z);
    128       *ra  = alpha + coords[0].crval1;
    129       *dec = delta + coords[0].crval2;
    130     }
    131     if (!strcmp(type, "-GLS")) {
    132       /* L,M in degrees, alpha,delta in degrees */
    133       alpha = L / cos (RAD_DEG * M);
    134       delta = M;
    135       *ra  = alpha + coords[0].crval1;
    136       *dec = delta + coords[0].crval2;
    137     }
    138     if (!strcmp(type, "-PAR")) {
    139       /* L,M in degrees, alpha,delta in degrees */
    140       alpha = L / (1.0 - SQ(2.0*M/180));
    141       delta = 3 * DEG_RAD * asin (M/180.0);
    142       *ra  = alpha + coords[0].crval1;
    143       *dec = delta + coords[0].crval2;
    144     }
     131      break;
     132     
     133      case PROJ_GLS:
     134        /* L,M in degrees, alpha,delta in degrees */
     135        alpha = L / cos (RAD_DEG * M);
     136        delta = M;
     137        break;
     138      case PROJ_PAR:
     139        /* L,M in degrees, alpha,delta in degrees */
     140        alpha = L / (1.0 - SQ(2.0*M/180));
     141        delta = 3 * DEG_RAD * asin (M/180.0);
     142        break;
     143      default:
     144        return (FALSE);
     145    }
     146    *ra  = alpha + coords[0].crval1;
     147    *dec = delta + coords[0].crval2;
    145148
    146149    /* rationalize ra range 0 - 360.0 */
    … …  
    153156}
    154157
    155 int RD_to_XY (double *x, double *y, double ra, double dec, Coords *coords) {
    156 
    157   char *type;
    158   int i, status, Polynomial, Zenith1, Zenith2, Zenithal, Cartesian, PseudoCyl;
     158int RD_to_LM (double *L, double *M, double ra, double dec, Coords *coords) {
     159
    159160  double phi, theta;
    160   double determ;
    161   double X, Y, L, M, Lo, Mo, dL, dM;
     161  double Lo, Mo;
    162162  double sphi, cphi, stht;
    163163  double salp, calp, sdel, cdel, sdp, cdp;
    164164  double P, A, Rc;
    165 
    166   status = TRUE;
    167   *x = 0;
    168   *y = 0;
    169   type = &coords[0].ctype[4];
    170   L = M = 0;
    171 
    172   Polynomial = !strcmp(type, "-PLY") || !strcmp(type, "-DIS") || !strcmp(type, "-WRP") || !strcmp(type, "-ZPL");
    173   Cartesian  = !strcmp(type, "-LIN") || !strcmp(type, "-PLY") || !strcmp(type, "-WRP") || !strcmp(&coords[0].ctype[0], "GENE");
    174   PseudoCyl  = !strcmp(type, "-AIT") || !strcmp(type, "-GLS") || !strcmp(type, "-PAR");
    175   Zenith1    = !strcmp(type, "-DIS") || !strcmp(type, "-TAN") || !strcmp(type, "-STG");
    176   Zenith2    = !strcmp(type, "-SIN") || !strcmp(&coords[0].ctype[0], "MM");
    177   Zenithal   = !strcmp(type, "-ZEA") || !strcmp(type, "-ZPL") || Zenith1 || Zenith2;
    178   if (!Zenithal && !Cartesian && !PseudoCyl) return (FALSE);
     165  OhanaProjection proj;
     166  OhanaProjectionMode mode;
     167
     168  *L = *M = 0;
     169
     170  proj = GetProjection (coords[0].ctype);
     171  mode = GetProjectionMode (proj);
     172  if (proj == PROJ_NONE) return (FALSE);
     173  if (proj == PROJ_MODE_NONE) return (FALSE);
    179174
    180175  /**** Locally Cartesian Projections ****/
    181   if (Cartesian) {
    182     if (!strcmp(type, "-WRP")) {
     176  if (mode == PROJ_MODE_CARTESIAN) {
     177    if (proj == PROJ_WRP) {
    183178      if (mosaic == NULL) return (FALSE);
    184179      RD_to_XY (&Lo, &Mo, ra, dec, mosaic);
    185       L = (Lo - coords[0].crval1);
    186       M = (Mo - coords[0].crval2);
    187     } else {
    188       L = (ra  - coords[0].crval1);
    189       M = (dec - coords[0].crval2);
    190     }
     180      *L = (Lo - coords[0].crval1);
     181      *M = (Mo - coords[0].crval2);
     182      return (TRUE);
     183    }
     184    *L = (ra  - coords[0].crval1);
     185    *M = (dec - coords[0].crval2);
     186    return (TRUE);
    191187  }
    192188 
    193189  /**** Zenithal Projections ****/
    194   if (Zenithal) {
     190  if (mode == PROJ_MODE_ZENITHAL) {
    195191    sdp  = sin(RAD_DEG*coords[0].crval2);
    196192    cdp  = cos(RAD_DEG*coords[0].crval2);
    … …  
    203199    sphi = cdel*salp;                   /* = cos(theta)*sin(phi) */
    204200    cphi = cdel*sdp*calp - sdel*cdp;    /* = cos(theta)*cos(phi) */
    205     if (stht < 0) status = FALSE;
    206 
    207     if (Zenith1) {
    208       L =  DEG_RAD * sphi / stht;
    209       M = -DEG_RAD * cphi / stht;
    210     }
    211     if (Zenith2) {
    212       L =  DEG_RAD * sphi;
    213       M = -DEG_RAD * cphi;
    214     }
    215     if (!strcmp(type, "-ZEA") || !strcmp(type, "-ZPL")) {
    216       Rc = DEG_RAD * M_SQRT2 / sqrt (1 + stht);
    217       L =  Rc * sphi;
    218       M = -Rc * cphi;
    219       status = TRUE;
    220     }
     201    if (stht < 0) return (FALSE);
     202
     203    switch (proj) {
     204      case PROJ_TAN:
     205      case PROJ_DIS:
     206        *L =  DEG_RAD * sphi / stht;
     207        *M = -DEG_RAD * cphi / stht;
     208        return (TRUE);
     209      case PROJ_SIN:
     210        *L =  DEG_RAD * sphi;
     211        *M = -DEG_RAD * cphi;
     212        return (TRUE);
     213      case PROJ_ZEA:
     214      case PROJ_ZPL:
     215        Rc = DEG_RAD * M_SQRT2 / sqrt (1 + stht);
     216        *L =  Rc * sphi;
     217        *M = -Rc * cphi;
     218        return (TRUE);
     219      default:
     220        return (FALSE);
     221    }
     222    return (FALSE);
    221223  }
    222224
    223225  /**** Other Standard Projections ****/
    224   if (PseudoCyl) {
    225     if (!strcmp(type, "-AIT")) {
    226       phi = RAD_DEG*(ra - coords[0].crval1);
    227       theta = RAD_DEG*(dec - coords[0].crval2);
    228       P = 1.0 + cos (theta) * cos (0.5*phi);
    229       if (P != 0.0) {
     226  if (mode == PROJ_MODE_PSEUDOCYL) {
     227    switch (proj) {
     228      case PROJ_AIT:
     229        phi = RAD_DEG*(ra - coords[0].crval1);
     230        theta = RAD_DEG*(dec - coords[0].crval2);
     231        P = 1.0 + cos (theta) * cos (0.5*phi);
     232        if (P == 0.0) {
     233          *L =  0.0;
     234          *M =  0.0;
     235          return (TRUE);
     236        }
    230237        A =  DEG_RAD * sqrt (2.0 / P);
    231         L =  2.0 * A * cos (theta) * sin (0.5*phi);
    232         M =  A * sin (theta);
    233       } else {
    234         L =  0.0;
    235         M =  0.0;
    236       }
    237     }
    238     if (!strcmp(type, "-GLS")) {
    239       phi = ra - coords[0].crval1;
    240       theta = dec - coords[0].crval2;
    241       L = phi * cos(RAD_DEG * theta);
    242       M = theta;
    243     }
    244     if (!strcmp(type, "-PAR")) {
    245       phi = ra - coords[0].crval1;
    246       theta = dec - coords[0].crval2;
    247       L = phi * (2.0*cos(2*RAD_DEG*theta/3.0) - 1);
    248       M = 180.0 * sin (RAD_DEG*theta/3.0);
    249     }
    250   }
     238        *L =  2.0 * A * cos (theta) * sin (0.5*phi);
     239        *M =  A * sin (theta);
     240        return (TRUE);
     241      case PROJ_GLS:
     242        phi = ra - coords[0].crval1;
     243        theta = dec - coords[0].crval2;
     244        *L = phi * cos(RAD_DEG * theta);
     245        *M = theta;
     246        return (TRUE);
     247      case PROJ_PAR:
     248        phi = ra - coords[0].crval1;
     249        theta = dec - coords[0].crval2;
     250        *L = phi * (2.0*cos(2*RAD_DEG*theta/3.0) - 1);
     251        *M = 180.0 * sin (RAD_DEG*theta/3.0);
     252        return (TRUE);
     253      default:
     254        return (FALSE);
     255    }
     256    return (FALSE);
     257  }
     258  return (FALSE);
     259}
     260
     261int LM_to_XY (double *x, double *y, double L, double M, Coords *coords) {
     262
     263  int i;
     264  double determ;
     265  double X, Y, Lo, Mo, dL, dM;
     266
     267  *x = 0;
     268  *y = 0;
    251269
    252270  /* convert L,M to X,Y */
    … …  
    270288      dL = (L - Lo);
    271289      dM = (M - Mo);
    272       // fprintf (stderr, "%d: %f,%f : %f,%f : %f,%f : %f,%f\n", i, L, M, X, Y, Lo, Mo, dL, dM);
    273290
    274291      X += determ * (coords[0].pc2_2*dL - coords[0].pc1_2*dM);
    … …  
    281298  *y = Y / coords[0].cdelt2 + coords[0].crpix2;
    282299
     300  return (TRUE);
     301}
     302
     303int XY_to_RD (double *ra, double *dec, double x, double y, Coords *coords) {
     304
     305  double L, M;
     306  int status;
     307
     308  status = XY_to_LM (&L, &M, x, y, coords);
     309  if (!status) return FALSE;
     310
     311  status = LM_to_RD (ra, dec, L, M, coords);
    283312  return (status);
    284  
     313}
     314
     315int RD_to_XY (double *x, double *y, double ra, double dec, Coords *coords) {
     316
     317  double L, M;
     318  int status;
     319
     320  status = RD_to_LM (&L, &M, ra, dec, coords);
     321  if (!status) return FALSE;
     322
     323  status = LM_to_XY (x, y, L, M, coords);
     324  return (status);
    285325}
    286326
    … …  
    599639
    600640*/
     641
     642  /* PLY is equiv to LIN with higher order terms
     643     ZPL is equiv to ZEA with higher order terms
     644     DIS is equiv to TAN with higher order terms
     645     WRP is equiv to PLY, with implied mosaic */
     646
     647OhanaProjection GetProjection (char *ctype) {
     648  if (!strcmp(&ctype[4], "-ZEA")) return PROJ_ZEA;
     649  if (!strcmp(&ctype[4], "-ZPL")) return PROJ_ZPL;
     650  if (!strcmp(&ctype[4], "-ARC")) return PROJ_ARC;
     651  if (!strcmp(&ctype[4], "-STG")) return PROJ_STG;
     652  if (!strcmp(&ctype[4], "-SIN")) return PROJ_SIN;
     653  if (!strcmp(&ctype[0], "MM"))   return PROJ_SIN; // note ctype[0]
     654  if (!strcmp(&ctype[4], "-TAN")) return PROJ_TAN;
     655  if (!strcmp(&ctype[4], "-DIS")) return PROJ_DIS;
     656  if (!strcmp(&ctype[4], "-LIN")) return PROJ_LIN;
     657  if (!strcmp(&ctype[0], "GENE")) return PROJ_LIN; // note ctype[0]
     658  if (!strcmp(&ctype[4], "-PLY")) return PROJ_PLY;
     659  if (!strcmp(&ctype[4], "-WRP")) return PROJ_WRP;
     660  if (!strcmp(&ctype[4], "-AIT")) return PROJ_AIT;
     661  if (!strcmp(&ctype[4], "-GLS")) return PROJ_GLS;
     662  if (!strcmp(&ctype[4], "-PAR")) return PROJ_PAR;
     663  return PROJ_NONE;
     664}
     665 
     666int SetProjection (char *ctype, OhanaProjection proj) {
     667  switch (proj) {
     668    case PROJ_ZEA: strcpy(&ctype[4], "-ZEA"); return TRUE;
     669    case PROJ_ZPL: strcpy(&ctype[4], "-ZPL"); return TRUE;
     670    case PROJ_ARC: strcpy(&ctype[4], "-ARC"); return TRUE;
     671    case PROJ_STG: strcpy(&ctype[4], "-STG"); return TRUE;
     672    case PROJ_SIN: strcpy(&ctype[4], "-SIN"); return TRUE;
     673    case PROJ_TAN: strcpy(&ctype[4], "-TAN"); return TRUE;
     674    case PROJ_DIS: strcpy(&ctype[4], "-DIS"); return TRUE;
     675    case PROJ_LIN: strcpy(&ctype[4], "-LIN"); return TRUE;
     676    case PROJ_PLY: strcpy(&ctype[4], "-PLY"); return TRUE;
     677    case PROJ_WRP: strcpy(&ctype[4], "-WRP"); return TRUE;
     678    case PROJ_AIT: strcpy(&ctype[4], "-AIT"); return TRUE;
     679    case PROJ_GLS: strcpy(&ctype[4], "-GLS"); return TRUE;
     680    case PROJ_PAR: strcpy(&ctype[4], "-PAR"); return TRUE;
     681    case PROJ_NONE: return FALSE;
     682  }
     683  return FALSE;
     684} 
     685
     686OhanaProjectionMode GetProjectionMode (OhanaProjection proj) {
     687  switch (proj) {
     688    case PROJ_ZEA:
     689    case PROJ_ZPL:
     690    case PROJ_ARC:
     691    case PROJ_STG:
     692    case PROJ_SIN:
     693    case PROJ_TAN:
     694    case PROJ_DIS:
     695      return PROJ_MODE_ZENITHAL;
     696    case PROJ_LIN:
     697    case PROJ_PLY:
     698    case PROJ_WRP:
     699      return PROJ_MODE_CARTESIAN;
     700    case PROJ_AIT:
     701    case PROJ_GLS:
     702    case PROJ_PAR:
     703      return PROJ_MODE_PSEUDOCYL;
     704    default: PROJ_MODE_NONE;
     705  }
     706  return PROJ_MODE_NONE;
     707}
     708

  • trunk/Ohana/src/libdvo/src/coordops.update.c

    r8638 r12332  
    8686      case PROJ_ZEA:
    8787      case PROJ_ZPL:
     88        if (R > 2*DEG_RAD) {
     89          *ra = L;
     90          *dec = M;
     91          return (FALSE);
     92        }
    8893        stht = 1 - 0.5*SQ(R*RAD_DEG);
    8994        ctht = sqrt (1 - stht*stht);
    … …  
    110115 
    111116  /**** Other Conventional Projections ****/
    112   if (mode == PROJ_MODE_ZENITHAL) {
     117  if (mode == PROJ_MODE_PSEUDOCLY) {
    113118    switch (proj) {
    114119      case PROJ_AIT:
    … …  
    119124      delta = DEG_RAD * asin (RAD_DEG*M*Z);
    120125      break;
    121 
     126     
    122127      case PROJ_GLS:
    123128        /* L,M in degrees, alpha,delta in degrees */
    … …  
    213218
    214219  /**** Other Standard Projections ****/
    215   if (PseudoCyl) {
    216     if (!strcmp(type, "-AIT")) {
    217       phi = RAD_DEG*(ra - coords[0].crval1);
    218       theta = RAD_DEG*(dec - coords[0].crval2);
    219       P = 1.0 + cos (theta) * cos (0.5*phi);
    220       if (P != 0.0) {
    221         A =  DEG_RAD * sqrt (2.0 / P);
    222         L =  2.0 * A * cos (theta) * sin (0.5*phi);
    223         M =  A * sin (theta);
    224       } else {
    225         L =  0.0;
    226         M =  0.0;
    227       }
    228     }
    229     if (!strcmp(type, "-GLS")) {
    230       phi = ra - coords[0].crval1;
    231       theta = dec - coords[0].crval2;
    232       L = phi * cos(RAD_DEG * theta);
    233       M = theta;
    234     }
    235     if (!strcmp(type, "-PAR")) {
    236       phi = ra - coords[0].crval1;
    237       theta = dec - coords[0].crval2;
    238       L = phi * (2.0*cos(2*RAD_DEG*theta/3.0) - 1);
    239       M = 180.0 * sin (RAD_DEG*theta/3.0);
     220  if (mode == PROJ_MODE_PSEUDOCYL) {
     221    switch (proj) {
     222      case PROJ_AIT:
     223        phi = RAD_DEG*(ra - coords[0].crval1);
     224        theta = RAD_DEG*(dec - coords[0].crval2);
     225        P = 1.0 + cos (theta) * cos (0.5*phi);
     226        if (P != 0.0) {
     227          A =  DEG_RAD * sqrt (2.0 / P);
     228          L =  2.0 * A * cos (theta) * sin (0.5*phi);
     229          M =  A * sin (theta);
     230        } else {
     231          L =  0.0;
     232          M =  0.0;
     233        }       
     234        break;
     235      case PROJ_GLS:
     236        phi = ra - coords[0].crval1;
     237        theta = dec - coords[0].crval2;
     238        L = phi * cos(RAD_DEG * theta);
     239        M = theta;
     240        break;
     241      case PROJ_PAR:
     242        phi = ra - coords[0].crval1;
     243        theta = dec - coords[0].crval2;
     244        L = phi * (2.0*cos(2*RAD_DEG*theta/3.0) - 1);
     245        M = 180.0 * sin (RAD_DEG*theta/3.0);
     246        break;
    240247    }
    241248  }
    … …  
    261268      dL = (L - Lo);
    262269      dM = (M - Mo);
    263       // fprintf (stderr, "%d: %f,%f : %f,%f : %f,%f : %f,%f\n", i, L, M, X, Y, Lo, Mo, dL, dM);
    264270
    265271      X += determ * (coords[0].pc2_2*dL - coords[0].pc1_2*dM);
    … …  
    273279
    274280  return (status);
    275  
    276281}
    277282

  • trunk/Ohana/src/libdvo/src/dvo_catalog.c

    r8520 r12332  
    5050  if (!strcasecmp (catformat, "PANSTARRS")) return (DVO_FORMAT_PANSTARRS);
    5151  if (!strcasecmp (catformat, "PMTEST"))    return (DVO_FORMAT_PMTEST);
     52  if (!strcasecmp (catformat, "PANSTARRS_DEV_0")) return (DVO_FORMAT_PANSTARRS_DEV_0);
    5253  return (DVO_FORMAT_UNDEF);
    5354}
    … …  
    340341    for (in = out = i = 0; i < catalog[0].Naverage; i++) {
    341342      for (j = 0; j < catalog[0].Nsecfilt; j++, in++, out++) {
    342         outsec[out].M_PS  = insec[in].M_PS;
    343         outsec[out].dM_PS = insec[in].dM_PS;
     343        outsec[out].M  = insec[in].M;
     344        outsec[out].dM = insec[in].dM;
    344345        outsec[out].Xm = insec[in].Xm;
    345346      }
    346347      for (j = 0; j < Nextra; j++, out++) {
    347         outsec[out].M_PS  = NO_MAG;
    348         outsec[out].dM_PS = NO_MAG;
     348        outsec[out].M  = NO_MAG;
     349        outsec[out].dM = NO_MAG;
    349350        outsec[out].Xm    = NO_MAG;
    350351      }
    … …  
    386387/*
    387388  mode   : items to read (LOAD_AVES | LOAD_MEAS | LOAD_MISS | LOAD_SECF)
    388   format : what structure on disk (INTERNAL, ELIXIR, LONEOS, PANSTARRS)
     389  format : what table structure on disk (INTERNAL, LONEOS, etc, )
    389390  style  : raw, mef, split, mysql
    390391*/

  • trunk/Ohana/src/libdvo/src/dvo_catalog_mef.c

    r8328 r12332  
    99  Matrix matrix;
    1010  FTable ftable;
     11  SecFilt *primary;
    1112
    1213  f = catalog[0].f;
    … …  
    4445      return (FALSE);
    4546    }
    46     catalog[0].average = FtableToAverage (&ftable, &catalog[0].Naverage, &catalog[0].catformat);
     47    /* old versions of DVO stored one of the average magnitudes in Average. we save this if needed */
     48    catalog[0].average = FtableToAverage (&ftable, &catalog[0].Naverage, &catalog[0].catformat, &primary);
    4749    if (Naverage != catalog[0].Naverage) {
    4850      fprintf (stderr, "Warning: mismatch between Naverage in PHU and Table headers (%d vs %d)\n", Naverage, catalog[0].Naverage);
    … …  
    9698  }
    9799
    98   // catalog[0].secfilt = gfits_table_get_SecFilt (&ftable, &Nitems, NULL);
    99   // catalog[0].Nsecfilt = Nitems / catalog[0].Naverage;
    100 
    101100  /* read secfilt table header */
    102101  if (!gfits_fread_header (f, &header)) {
    … …  
    110109      return (FALSE);
    111110    }
     111
     112    /* how many entries do we expect from the secfilt table? */
    112113    Nexpect = catalog[0].Nsecfilt * catalog[0].Naverage;
    113114    catalog[0].secfilt = FtableToSecFilt (&ftable, &Nitems, &catalog[0].catformat);
    … …  
    115116      fprintf (stderr, "Warning: mismatch between Nsecfilt items in PHU and Table headers (%d vs %d)\n", Nexpect, Nitems);
    116117    }
     118
     119    /* if primary is defined, we were supplied with one additional average magnitude from Average
     120       we need to interleave these magnitudes with the secfilt entries just loaded */
     121    if (primary != NULL) {
     122      int Ntmpfilt, Ntotal, i, j;
     123      SecFilt *tmpfilt;
     124      tmpfilt  = catalog[0].secfilt;
     125      Ntmpfilt = catalog[0].Nsecfilt;
     126      Nsecfilt = catalog[0].Nsecfilt + 1;
     127      Ntotal = Nsecfilt * catalog[0].Naverage;
     128      ALLOCATE (catalog[0].secfilt, SecFilt, Ntotal);
     129      for (i = 0; i < catalog[0].Naverage; i++) {
     130        catalog[0].secfilt[i*Nsecfilt + 0] = primary[i];
     131        for (j = 0; j < Ntmpfilt; j++) {
     132          catalog[0].secfilt[i*Nsecfilt + j + 1] = tmpfilt[i*Ntmpfilt + j];
     133        }
     134      }         
     135      catalog[0].Nsecfilt = Nsecfilt;
     136      free (primary);
     137    }
     138
    117139  } else {
    118140    /* no real need to skip the data array here... */
    119141    Nbytes = gfits_matrix_size (&header);
    120142    fseek (f, Nbytes, SEEK_CUR);
     143    if (primary != NULL) free (primary);
    121144  }
    122145
    … …  
    129152}
    130153
     154/* XXX need to decompose the primary and secfilt entries for Elixir and Loneos */
    131155/* save_catalog_mef writes a complete new file from scratch */
    132 
    133156int dvo_catalog_save_mef (Catalog *catalog, char VERBOSE) {
    134157
    … …  
    138161  Header header;
    139162  FTable ftable;
     163  SecFilt *primary;
     164  SecFilt *secfilt;
     165  int i, j, Nsecfilt, Nallfilt, Ntotal;
    140166
    141167  if (catalog[0].Naverage == 0) {
    … …  
    171197  gfits_free_matrix (&matrix);
    172198
     199  /* for the appropriate types, pull out the first secfilt and pass to AverageToFtable as primary */
     200  if ((catalog[0].catformat == DVO_FORMAT_ELIXIR) || // special case for ELIXIR
     201      (catalog[0].catformat == DVO_FORMAT_LONEOS)) { // special case for LONEOS
     202    Nallfilt = catalog[0].Nsecfilt;
     203    Nsecfilt = catalog[0].Nsecfilt - 1;
     204    Ntotal = Nsecfilt * catalog[0].Naverage;
     205    ALLOCATE (primary, SecFilt, catalog[0].Naverage);
     206    ALLOCATE (secfilt, SecFilt, Ntotal);
     207
     208    for (i = 0; i < catalog[0].Naverage; i++) {
     209      primary[i] = catalog[0].secfilt[i*Nallfilt + 0];
     210      for (j = 0; j < Nsecfilt; j++) {
     211        secfilt[i*Nsecfilt + j] = catalog[0].secfilt[i*Nallfilt + j + 1];
     212      }
     213    }           
     214  } else {
     215    primary = NULL;
     216    secfilt = catalog[0].secfilt;
     217    Nsecfilt = catalog[0].Nsecfilt;
     218  }
     219
    173220  /* write out Average table (convert to FITS table format) */
    174   AverageToFtable (&ftable, catalog[0].average, catalog[0].Naverage, catalog[0].catformat);
     221  AverageToFtable (&ftable, catalog[0].average, catalog[0].Naverage, catalog[0].catformat, primary);
    175222  if (!gfits_fwrite_Theader (catalog[0].f, &header)) {
    176223    fprintf (stderr, "can't write table header");
    … …  
    211258
    212259  /* write out SecFilt table (convert to FITS table format) */
    213   Nitems = catalog[0].Naverage * catalog[0].Nsecfilt;
    214   SecFiltToFtable (&ftable, catalog[0].secfilt, Nitems, catalog[0].catformat);
    215   if (!gfits_fwrite_Theader (catalog[0].f, &header)) {
    216     fprintf (stderr, "can't write table header");
    217     return (FALSE);
    218   }
    219   if (!gfits_fwrite_table (catalog[0].f, &ftable)) {
    220     fprintf (stderr, "can't write table data");
    221     return (FALSE);
    222   }
    223   gfits_free_table (&ftable);
    224   gfits_free_header (&header);
     260  Nitems = catalog[0].Naverage * Nsecfilt;
     261  SecFiltToFtable (&ftable, secfilt, Nitems, catalog[0].catformat);
     262  if (!gfits_fwrite_Theader (catalog[0].f, &header)) {
     263    fprintf (stderr, "can't write table header");
     264    return (FALSE);
     265  }
     266  if (!gfits_fwrite_table (catalog[0].f, &ftable)) {
     267    fprintf (stderr, "can't write table data");
     268    return (FALSE);
     269  }
     270  gfits_free_table (&ftable);
     271  gfits_free_header (&header);
     272
     273  /* free temp storage */
     274  if (primary != NULL) {
     275    free (primary);
     276    free (secfilt);
     277  }
    225278
    226279  return (TRUE);
    … …  
    228281
    229282/*
    230    catalog data is:
    231    header (bitpix == 8)
    232    matrix (empty)
    233    average header
    234    average table
    235    measure header
    236    measure table
    237    missing header
    238    missing table
    239    secfilt header
    240    secfilt table
     283  catalog data is:
     284  header (bitpix == 8)
     285  matrix (empty)
     286  average header
     287  average table
     288  measure header
     289  measure table
     290  missing header
     291  missing table
     292  secfilt header
     293  secfilt table
    241294*/
    242295   

  • trunk/Ohana/src/libdvo/src/dvo_catalog_raw.c

    r8456 r12332  
    1212  struct stat filestatus;
    1313  char format[80], telescope[80];
     14  SecFilt *primary;
    1415
    1516  f = catalog[0].f;
    … …  
    2829  catalog[0].catformat = DVO_FORMAT_UNDEF;
    2930  if (gfits_scan (&catalog[0].header, "FORMAT",  "%s", 1, format)) {
    30     if (!strcmp (format, "INTERNAL")) catalog[0].catformat = DVO_FORMAT_INTERNAL;
    31     if (!strcmp (format, "LONEOS")) catalog[0].catformat = DVO_FORMAT_LONEOS;
    32     if (!strcmp (format, "ELIXIR")) catalog[0].catformat = DVO_FORMAT_ELIXIR;
    33     if (!strcmp (format, "PANSTARRS")) catalog[0].catformat = DVO_FORMAT_PANSTARRS;
    34     if (!strcmp (format, "PMTEST")) catalog[0].catformat = DVO_FORMAT_PMTEST;
     31    catalog[0].catformat = dvo_catalog_catformat (format);
    3532    if (catalog[0].catformat != DVO_FORMAT_UNDEF) goto got_format;
    3633  }
    3734  /* special cases: old versions of the DB tables which were poorly identified */
    3835  if (gfits_scan (&catalog[0].header, "NEWMEAS",  "%t", 1, &NewMeasure)) {
    39     catalog[0].catformat = DVO_FORMAT_ELIXIR;
     36    catalog[0].catformat = DVO_FORMAT_ELIXIR; // special case for ELIXIR
    4037    goto got_format;
    4138  }
    4239  if (gfits_scan (&catalog[0].header, "TELESCOP",  "%s", 1, telescope)) {
    4340    if (!strncmp (telescope, "LONEOS", strlen("LONEOS"))) {
    44       catalog[0].catformat = DVO_FORMAT_LONEOS;
     41      catalog[0].catformat = DVO_FORMAT_LONEOS; // special case for LONEOS
    4542      goto got_format;
    4643    }
    4744    if (!strncmp (telescope, "1.3m McGraw-Hill", strlen("1.3m McGraw-Hill"))) {
    48       catalog[0].catformat = DVO_FORMAT_ELIXIR;
     45      catalog[0].catformat = DVO_FORMAT_ELIXIR; // special case for ELIXIR
    4946      goto got_format;
    5047    }
    … …  
    5956      AverageSize = sizeof(Average);
    6057      MeasureSize = sizeof(Measure);
    61       SecFiltSize = sizeof (SecFilt);
     58      SecFiltSize = sizeof(SecFilt);
    6259      break;
    6360    case DVO_FORMAT_LONEOS:
    6461      AverageSize = sizeof(AverageLoneos);
    6562      MeasureSize = sizeof(MeasureLoneos);
    66       SecFiltSize = sizeof (SecFiltLoneos);
     63      SecFiltSize = sizeof(SecFiltLoneos);
    6764      break;
    6865    case DVO_FORMAT_ELIXIR:
    6966      AverageSize = sizeof(AverageElixir);
    7067      MeasureSize = sizeof(MeasureElixir);
    71       SecFiltSize = sizeof (SecFiltElixir);
     68      SecFiltSize = sizeof(SecFiltElixir);
    7269      break;
     70    case DVO_FORMAT_PANSTARRS_DEV_0:
     71      AverageSize = sizeof(AveragePanstarrs_DEV_0);
     72      MeasureSize = sizeof(MeasurePanstarrs_DEV_0);
     73      SecFiltSize = sizeof(SecFiltPanstarrs_DEV_0);
     74      break;
     75# if 0
    7376    case DVO_FORMAT_PANSTARRS:
    7477      AverageSize = sizeof(AveragePanstarrs);
    7578      MeasureSize = sizeof(MeasurePanstarrs);
    76       SecFiltSize = sizeof (SecFiltPanstarrs);
     79      SecFiltSize = sizeof(SecFiltPanstarrs);
    7780      break;
    7881    case DVO_FORMAT_PMTEST:
    7982      AverageSize = sizeof(AveragePMtest);
    8083      MeasureSize = sizeof(MeasurePanstarrs);
    81       SecFiltSize = sizeof (SecFiltPanstarrs);
     84      SecFiltSize = sizeof(SecFiltPanstarrs);
    8285      break;
     86# endif
    8387    default:
    8488      fprintf (stderr, "programming error in phot_catalog_raw\n");
    … …  
    120124
    121125  /* read and convert the averages (use a macro to clean this up?) */
     126  /* old versions of DVO stored one of the average magnitudes in Average. we save this if needed */
    122127  if (catalog[0].catflags & LOAD_AVES) {
    123     catalog[0].average = ReadRawAverage (catalog[0].f, catalog[0].Naverage, catalog[0].catformat);
     128    catalog[0].average = ReadRawAverage (catalog[0].f, catalog[0].Naverage, catalog[0].catformat, &primary);
    124129  } else {
    125130    /* skip over averages */
    … …  
    157162    Nitems = catalog[0].Naverage * catalog[0].Nsecfilt;
    158163    catalog[0].secfilt = ReadRawSecFilt (catalog[0].f, Nitems, catalog[0].catformat);
     164
     165    /* if primary is defined, we were supplied with one additional average magnitude from Average
     166       we need to interleave these magnitudes with the secfilt entries just loaded */
     167    if (primary != NULL) {
     168      int Ntmpfilt, Nsecfilt, Ntotal, i, j;
     169      SecFilt *tmpfilt;
     170      tmpfilt  = catalog[0].secfilt;
     171      Ntmpfilt = catalog[0].Nsecfilt;
     172      Nsecfilt = catalog[0].Nsecfilt + 1;
     173      Ntotal = Nsecfilt * catalog[0].Naverage;
     174      ALLOCATE (catalog[0].secfilt, SecFilt, Ntotal);
     175      for (i = 0; i < catalog[0].Naverage; i++) {
     176        catalog[0].secfilt[i*Nsecfilt + 0] = primary[i];
     177        for (j = 0; j < Ntmpfilt; j++) {
     178          catalog[0].secfilt[i*Nsecfilt + j + 1] = tmpfilt[i*Ntmpfilt + j];
     179        }
     180      }         
     181      catalog[0].Nsecfilt = Nsecfilt;
     182      free (primary);
     183    }
     184
    159185  } else {
    160186    /* skip over secfilts */
    161187    Nskip = catalog[0].Nsecfilt * catalog[0].Naverage * SecFiltSize;
    162188    fseek (f, Nskip, SEEK_CUR);
     189    if (primary != NULL) free (primary);
    163190  }
    164191
    … …  
    194221  int Nitems, nitems;
    195222  FILE *f;
     223  SecFilt *primary;
     224  SecFilt *secfilt;
     225  int i, j, Nsecfilt, Nallfilt, Ntotal;
    196226
    197227  if (catalog[0].Naverage == 0) {
    … …  
    210240  if (catalog[0].catformat == DVO_FORMAT_LONEOS)    gfits_modify (&catalog[0].header, "FORMAT", "%s", 1, "LONEOS");
    211241  if (catalog[0].catformat == DVO_FORMAT_ELIXIR)    gfits_modify (&catalog[0].header, "FORMAT", "%s", 1, "ELIXIR");
    212   if (catalog[0].catformat == DVO_FORMAT_PANSTARRS) gfits_modify (&catalog[0].header, "FORMAT", "%s", 1, "PANSTARRS");
    213   if (catalog[0].catformat == DVO_FORMAT_PMTEST)    gfits_modify (&catalog[0].header, "FORMAT", "%s", 1, "PMTEST");
     242  if (catalog[0].catformat == DVO_FORMAT_PANSTARRS_DEV_0) gfits_modify (&catalog[0].header, "FORMAT", "%s", 1, "PANSTARRS_DEV_0");
     243  // if (catalog[0].catformat == DVO_FORMAT_PANSTARRS) gfits_modify (&catalog[0].header, "FORMAT", "%s", 1, "PANSTARRS");
     244  // if (catalog[0].catformat == DVO_FORMAT_PMTEST)    gfits_modify (&catalog[0].header, "FORMAT", "%s", 1, "PMTEST");
    214245
    215246  /* rewind file pointers and truncate file */
    … …  
    225256  }
    226257
     258  /* for the appropriate types, pull out the first secfilt and pass to WriteRawAverage as primary */
     259  if ((catalog[0].catformat == DVO_FORMAT_ELIXIR) || // special case for ELIXIR
     260      (catalog[0].catformat == DVO_FORMAT_LONEOS)) { // special case for LONEOS
     261    Nallfilt = catalog[0].Nsecfilt;
     262    Nsecfilt = catalog[0].Nsecfilt - 1;
     263    Ntotal = Nsecfilt * catalog[0].Naverage;
     264    ALLOCATE (primary, SecFilt, catalog[0].Naverage);
     265    ALLOCATE (secfilt, SecFilt, Ntotal);
     266
     267    for (i = 0; i < catalog[0].Naverage; i++) {
     268      primary[i] = catalog[0].secfilt[i*Nallfilt + 0];
     269      for (j = 0; j < Nsecfilt; j++) {
     270        secfilt[i*Nsecfilt + j] = catalog[0].secfilt[i*Nallfilt + j + 1];
     271      }
     272    }           
     273  } else {
     274    primary = NULL;
     275    secfilt = catalog[0].secfilt;
     276    Nsecfilt = catalog[0].Nsecfilt;
     277  }
     278
    227279  /* write averages and measures */
    228   WriteRawAverage (f, catalog[0].average, catalog[0].Naverage, catalog[0].catformat);
     280  WriteRawAverage (f, catalog[0].average, catalog[0].Naverage, catalog[0].catformat, primary);
    229281  WriteRawMeasure (f, catalog[0].measure, catalog[0].Nmeasure, catalog[0].catformat);
    230282
    … …  
    240292  Nitems = catalog[0].Naverage * catalog[0].Nsecfilt;
    241293  WriteRawSecFilt (f, catalog[0].secfilt, Nitems, catalog[0].catformat);
     294
     295  /* free temp storage */
     296  if (primary != NULL) {
     297    free (primary);
     298    free (secfilt);
     299  }
     300
    242301  return (TRUE);
    243302}
    … …  
    250309/** Average / Raw Table conversions **/
    251310
    252 Average *ReadRawAverage (FILE *f, int Naverage, int format) {
     311Average *ReadRawAverage (FILE *f, int Naverage, int format, SecFilt **primary) {
    253312
    254313  int nitems;
    255314  Average *average;
    256   AverageElixir *tmpAverageElixir;
    257   AverageLoneos *tmpAverageLoneos;
    258   AveragePanstarrs *tmpAveragePanstarrs;
    259   AveragePMtest *tmpAveragePMtest;
     315
     316  /* in the Elixir and Loneos cases, we are supplied with an average magnitude in Average
     317     in these cases, save these values in primary; otherwise set primary to NULL */
     318  *primary = NULL;
    260319
    261320  switch (format) {
    262     case DVO_FORMAT_INTERNAL:
     321    case DVO_FORMAT_INTERNAL: {
    263322      ALLOCATE (average, Average, MAX (Naverage, 1));
    264323      nitems = fread (average, sizeof(Average), Naverage, f);
    … …  
    268327      }
    269328      gfits_convert_Average (average, sizeof(Average), Naverage);
    270       break;
    271     case DVO_FORMAT_ELIXIR:
    272       ALLOCATE (tmpAverageElixir, AverageElixir, MAX (Naverage, 1));
    273       nitems = fread (tmpAverageElixir, sizeof(AverageElixir), Naverage, f);
     329      break; }
     330    case DVO_FORMAT_ELIXIR: {
     331      AverageElixir *tmpAverage;
     332      ALLOCATE (tmpAverage, AverageElixir, MAX (Naverage, 1));
     333      nitems = fread (tmpAverage, sizeof(AverageElixir), Naverage, f);
    274334      if (nitems != Naverage) {
    275335        fprintf (stderr, "failed to read averages (%d vs %d)\n", nitems, Naverage);
    276336        return (NULL);
    277337      }
    278       gfits_convert_AverageElixir (tmpAverageElixir, sizeof(AverageElixir), Naverage);
    279       average = AverageElixirToInternal (tmpAverageElixir, Naverage);
    280       free (tmpAverageElixir);
    281       break;
    282     case DVO_FORMAT_LONEOS:
    283       ALLOCATE (tmpAverageLoneos, AverageLoneos, MAX (Naverage, 1));
    284       nitems = fread (tmpAverageLoneos, sizeof(AverageLoneos), Naverage, f);
     338      gfits_convert_AverageElixir (tmpAverage, sizeof(AverageElixir), Naverage);
     339      average = AverageElixirToInternal (tmpAverage, Naverage, primary);
     340      free (tmpAverage);
     341      break; }
     342    case DVO_FORMAT_LONEOS: {
     343      AverageLoneos *tmpAverage;
     344      ALLOCATE (tmpAverage, AverageLoneos, MAX (Naverage, 1));
     345      nitems = fread (tmpAverage, sizeof(AverageLoneos), Naverage, f);
    285346      if (nitems != Naverage) {
    286347        fprintf (stderr, "failed to read averages (%d vs %d)\n", nitems, Naverage);
    287348        return (NULL);
    288349      }
    289       gfits_convert_AverageLoneos (tmpAverageLoneos, sizeof(AverageLoneos), Naverage);
    290       average = AverageLoneosToInternal (tmpAverageLoneos, Naverage);
    291       free (tmpAverageLoneos);
    292       break;
    293     case DVO_FORMAT_PANSTARRS:
    294       ALLOCATE (tmpAveragePanstarrs, AveragePanstarrs, MAX (Naverage, 1));
    295       nitems = fread (tmpAveragePanstarrs, sizeof(AveragePanstarrs), Naverage, f);
     350      gfits_convert_AverageLoneos (tmpAverage, sizeof(AverageLoneos), Naverage);
     351      average = AverageLoneosToInternal (tmpAverage, Naverage, primary);
     352      free (tmpAverage);
     353      break; }
     354    case DVO_FORMAT_PANSTARRS_DEV_0: {
     355      AveragePanstarrs_DEV_0 *tmpAverage;
     356      ALLOCATE (tmpAverage, AveragePanstarrs_DEV_0, MAX (Naverage, 1));
     357      nitems = fread (tmpAverage, sizeof(AveragePanstarrs_DEV_0), Naverage, f);
    296358      if (nitems != Naverage) {
    297359        fprintf (stderr, "failed to read averages (%d vs %d)\n", nitems, Naverage);
    298360        return (NULL);
    299361      }
    300       gfits_convert_AveragePanstarrs (tmpAveragePanstarrs, sizeof(AveragePanstarrs), Naverage);
    301       average = AveragePanstarrsToInternal (tmpAveragePanstarrs, Naverage);
    302       free (tmpAveragePanstarrs);
    303       break;
    304     case DVO_FORMAT_PMTEST:
    305       ALLOCATE (tmpAveragePMtest, AveragePMtest, MAX (Naverage, 1));
    306       nitems = fread (tmpAveragePMtest, sizeof(AveragePMtest), Naverage, f);
     362      gfits_convert_AveragePanstarrs_DEV_0 (tmpAverage, sizeof(AveragePanstarrs_DEV_0), Naverage);
     363      average = AveragePanstarrs_DEV_0_ToInternal (tmpAverage, Naverage);
     364      free (tmpAverage);
     365      break; }
     366# if 0
     367    case DVO_FORMAT_PANSTARRS: {
     368      AveragePanstarrs *tmpAverage;
     369      ALLOCATE (tmpAverage, AveragePanstarrs, MAX (Naverage, 1));
     370      nitems = fread (tmpAverage, sizeof(AveragePanstarrs), Naverage, f);
    307371      if (nitems != Naverage) {
    308372        fprintf (stderr, "failed to read averages (%d vs %d)\n", nitems, Naverage);
    309373        return (NULL);
    310374      }
    311       gfits_convert_AveragePMtest (tmpAveragePMtest, sizeof(AveragePMtest), Naverage);
    312       average = AveragePMtestToInternal (tmpAveragePMtest, Naverage);
    313       free (tmpAveragePMtest);
    314       break;
     375      gfits_convert_AveragePanstarrs (tmpAverage, sizeof(AveragePanstarrs), Naverage);
     376      average = AveragePanstarrsToInternal (tmpAverage, Naverage);
     377      free (tmpAverage);
     378      break; }
     379    case DVO_FORMAT_PMTEST: {
     380      AveragePMtest *tmpAverage;
     381      ALLOCATE (tmpAverage, AveragePMtest, MAX (Naverage, 1));
     382      nitems = fread (tmpAverage, sizeof(AveragePMtest), Naverage, f);
     383      if (nitems != Naverage) {
     384        fprintf (stderr, "failed to read averages (%d vs %d)\n", nitems, Naverage);
     385        return (NULL);
     386      }
     387      gfits_convert_AveragePMtest (tmpAverage, sizeof(AveragePMtest), Naverage);
     388      average = AveragePMtestToInternal (tmpAverage, Naverage);
     389      free (tmpAverage);
     390      break; }
     391# endif
    315392    default:
    316393      fprintf (stderr, "error reading measures\n");
    … …  
    322399/* accepts and converts internal average formats and outputs
    323400   raw data in the specified format */
    324 int WriteRawAverage (FILE *f, Average *average, int Naverage, int format) {
     401int WriteRawAverage (FILE *f, Average *average, int Naverage, int format, SecFilt *primary) {
    325402
    326403  int nitems;
    327   AverageElixir *tmpAverageElixir;
    328   AverageLoneos *tmpAverageLoneos;
    329   AveragePanstarrs *tmpAveragePanstarrs;
    330   AveragePMtest *tmpAveragePMtest;
    331404
    332405  switch (format) {
    333     case DVO_FORMAT_INTERNAL:
     406    case DVO_FORMAT_INTERNAL: {
    334407      gfits_convert_Average (average, sizeof(Average), Naverage);
    335408      nitems = fwrite (average, sizeof(Average), Naverage, f);
    … …  
    338411        return (FALSE);
    339412      }
    340       break;
    341     case DVO_FORMAT_ELIXIR:
    342       tmpAverageElixir = AverageInternalToElixir (average, Naverage);
    343       gfits_convert_AverageElixir (tmpAverageElixir, sizeof(AverageElixir), Naverage);
    344       nitems = fwrite (tmpAverageElixir, sizeof(AverageElixir), Naverage, f);
    345       free (tmpAverageElixir);
     413      break; }
     414    case DVO_FORMAT_ELIXIR: {
     415      AverageElixir *tmpAverage;
     416      tmpAverage = AverageInternalToElixir (average, Naverage, primary);
     417      gfits_convert_AverageElixir (tmpAverage, sizeof(AverageElixir), Naverage);
     418      nitems = fwrite (tmpAverage, sizeof(AverageElixir), Naverage, f);
     419      free (tmpAverage);
    346420      if (nitems != Naverage) {
    347421        fprintf (stderr, "failed to write averages (%d vs %d)\n", nitems, Naverage);
    348422        return (FALSE);
    349423      }
    350       break;
    351     case DVO_FORMAT_LONEOS:
    352       tmpAverageLoneos = AverageInternalToLoneos (average, Naverage);
    353       gfits_convert_AverageLoneos (tmpAverageLoneos, sizeof(AverageLoneos), Naverage);
    354       nitems = fwrite (tmpAverageLoneos, sizeof(AverageLoneos), Naverage, f);
    355       free (tmpAverageLoneos);
     424      break; }
     425    case DVO_FORMAT_LONEOS: {
     426      AverageLoneos *tmpAverage;
     427      tmpAverage = AverageInternalToLoneos (average, Naverage, primary);
     428      gfits_convert_AverageLoneos (tmpAverage, sizeof(AverageLoneos), Naverage);
     429      nitems = fwrite (tmpAverage, sizeof(AverageLoneos), Naverage, f);
     430      free (tmpAverage);
    356431      if (nitems != Naverage) {
    357432        fprintf (stderr, "failed to write averages (%d vs %d)\n", nitems, Naverage);
    358433        return (FALSE);
    359434      }
    360       break;
    361     case DVO_FORMAT_PANSTARRS:
    362       tmpAveragePanstarrs = AverageInternalToPanstarrs (average, Naverage);
    363       gfits_convert_AveragePanstarrs (tmpAveragePanstarrs, sizeof(AveragePanstarrs), Naverage);
    364       nitems = fwrite (tmpAveragePanstarrs, sizeof(AveragePanstarrs), Naverage, f);
    365       free (tmpAveragePanstarrs);
     435      break; }
     436    case DVO_FORMAT_PANSTARRS_DEV_0: {
     437      AveragePanstarrs_DEV_0 *tmpAverage;
     438      tmpAverage = AverageInternalToPanstarrs_DEV_0 (average, Naverage);
     439      gfits_convert_AveragePanstarrs_DEV_0 (tmpAverage, sizeof(AveragePanstarrs_DEV_0), Naverage);
     440      nitems = fwrite (tmpAverage, sizeof(AveragePanstarrs_DEV_0), Naverage, f);
     441      free (tmpAverage);
    366442      if (nitems != Naverage) {
    367443        fprintf (stderr, "failed to write averages (%d vs %d)\n", nitems, Naverage);
    368444        return (FALSE);
    369445      }
    370       break;
    371     case DVO_FORMAT_PMTEST:
    372       tmpAveragePMtest = AverageInternalToPMtest (average, Naverage);
    373       gfits_convert_AveragePMtest (tmpAveragePMtest, sizeof(AveragePMtest), Naverage);
    374       nitems = fwrite (tmpAveragePMtest, sizeof(AveragePMtest), Naverage, f);
    375       free (tmpAveragePMtest);
     446      break; }
     447# if 0
     448    case DVO_FORMAT_PANSTARRS: {
     449      AveragePanstarrs *tmpAverage;
     450      tmpAverage = AverageInternalToPanstarrs (average, Naverage);
     451      gfits_convert_AveragePanstarrs (tmpAverage, sizeof(AveragePanstarrs), Naverage);
     452      nitems = fwrite (tmpAverage, sizeof(AveragePanstarrs), Naverage, f);
     453      free (tmpAverage);
    376454      if (nitems != Naverage) {
    377455        fprintf (stderr, "failed to write averages (%d vs %d)\n", nitems, Naverage);
    378456        return (FALSE);
    379457      }
    380       break;
     458      break; }
     459    case DVO_FORMAT_PMTEST: {
     460      AveragePMtest *tmpAverage;
     461      tmpAverage = AverageInternalToPMtest (average, Naverage);
     462      gfits_convert_AveragePMtest (tmpAverage, sizeof(AveragePMtest), Naverage);
     463      nitems = fwrite (tmpAverage, sizeof(AveragePMtest), Naverage, f);
     464      free (tmpAverage);
     465      if (nitems != Naverage) {
     466        fprintf (stderr, "failed to write averages (%d vs %d)\n", nitems, Naverage);
     467        return (FALSE);
     468      }
     469      break; }
     470# endif
    381471    default:
    382472      fprintf (stderr, "error writing averages\n");
    … …  
    392482  int nitems;
    393483  Measure *measure;
    394   MeasureElixir *tmpMeasureElixir;
    395   MeasureLoneos *tmpMeasureLoneos;
    396   MeasurePanstarrs *tmpMeasurePanstarrs;
    397484
    398485  switch (format) {
    399     case DVO_FORMAT_INTERNAL:
     486    case DVO_FORMAT_INTERNAL: {
    400487      ALLOCATE (measure, Measure, MAX (Nmeasure, 1));
    401488      nitems = fread (measure, sizeof(Measure), Nmeasure, f);
    … …  
    405492      }
    406493      gfits_convert_Measure (measure, sizeof(Measure), Nmeasure);
    407       break;
    408     case DVO_FORMAT_ELIXIR:
    409       ALLOCATE (tmpMeasureElixir, MeasureElixir, MAX (Nmeasure, 1));
    410       nitems = fread (tmpMeasureElixir, sizeof(MeasureElixir), Nmeasure, f);
     494      break; }
     495    case DVO_FORMAT_ELIXIR: {
     496      MeasureElixir *tmpMeasure;
     497      ALLOCATE (tmpMeasure, MeasureElixir, MAX (Nmeasure, 1));
     498      nitems = fread (tmpMeasure, sizeof(MeasureElixir), Nmeasure, f);
    411499      if (nitems != Nmeasure) {
    412500        fprintf (stderr, "failed to read measures (%d vs %d)\n", nitems, Nmeasure);
    413501        return (NULL);
    414502      }
    415       gfits_convert_MeasureElixir (tmpMeasureElixir, sizeof(MeasureElixir), Nmeasure);
    416       measure = MeasureElixirToInternal (tmpMeasureElixir, Nmeasure);
    417       free (tmpMeasureElixir);
    418       break;
    419     case DVO_FORMAT_LONEOS:
    420       ALLOCATE (tmpMeasureLoneos, MeasureLoneos, MAX (Nmeasure, 1));
    421       nitems = fread (tmpMeasureLoneos, sizeof(MeasureLoneos), Nmeasure, f);
     503      gfits_convert_MeasureElixir (tmpMeasure, sizeof(MeasureElixir), Nmeasure);
     504      measure = MeasureElixirToInternal (tmpMeasure, Nmeasure);
     505      free (tmpMeasure);
     506      break; }
     507    case DVO_FORMAT_LONEOS: {
     508      MeasureLoneos *tmpMeasure;
     509      ALLOCATE (tmpMeasure, MeasureLoneos, MAX (Nmeasure, 1));
     510      nitems = fread (tmpMeasure, sizeof(MeasureLoneos), Nmeasure, f);
    422511      if (nitems != Nmeasure) {
    423512        fprintf (stderr, "failed to read measures (%d vs %d)\n", nitems, Nmeasure);
    424513        return (NULL);
    425514      }
    426       gfits_convert_MeasureLoneos (tmpMeasureLoneos, sizeof(MeasureLoneos), Nmeasure);
    427       measure = MeasureLoneosToInternal (tmpMeasureLoneos, Nmeasure);
    428       free (tmpMeasureLoneos);
    429       break;
    430     case DVO_FORMAT_PANSTARRS:
    431     case DVO_FORMAT_PMTEST:
    432       ALLOCATE (tmpMeasurePanstarrs, MeasurePanstarrs, MAX (Nmeasure, 1));
    433       nitems = fread (tmpMeasurePanstarrs, sizeof(MeasurePanstarrs), Nmeasure, f);
     515      gfits_convert_MeasureLoneos (tmpMeasure, sizeof(MeasureLoneos), Nmeasure);
     516      measure = MeasureLoneosToInternal (tmpMeasure, Nmeasure);
     517      free (tmpMeasure);
     518      break; }
     519    case DVO_FORMAT_PANSTARRS_DEV_0: {
     520      MeasurePanstarrs_DEV_0 *tmpMeasure;
     521      ALLOCATE (tmpMeasure, MeasurePanstarrs_DEV_0, MAX (Nmeasure, 1));
     522      nitems = fread (tmpMeasure, sizeof(MeasurePanstarrs_DEV_0), Nmeasure, f);
    434523      if (nitems != Nmeasure) {
    435524        fprintf (stderr, "failed to read measures (%d vs %d)\n", nitems, Nmeasure);
    436525        return (NULL);
    437526      }
    438       gfits_convert_MeasurePanstarrs (tmpMeasurePanstarrs, sizeof(MeasurePanstarrs), Nmeasure);
    439       measure = MeasurePanstarrsToInternal (tmpMeasurePanstarrs, Nmeasure);
    440       free (tmpMeasurePanstarrs);
    441       break;
     527      gfits_convert_MeasurePanstarrs_DEV_0 (tmpMeasure, sizeof(MeasurePanstarrs_DEV_0), Nmeasure);
     528      measure = MeasurePanstarrs_DEV_0_ToInternal (tmpMeasure, Nmeasure);
     529      free (tmpMeasure);
     530      break; }
     531# if 0
     532    case DVO_FORMAT_PANSTARRS: {
     533      MeasurePanstarrs *tmpMeasure;
     534      ALLOCATE (tmpMeasure, MeasurePanstarrs, MAX (Nmeasure, 1));
     535      nitems = fread (tmpMeasure, sizeof(MeasurePanstarrs), Nmeasure, f);
     536      if (nitems != Nmeasure) {
     537        fprintf (stderr, "failed to read measures (%d vs %d)\n", nitems, Nmeasure);
     538        return (NULL);
     539      }
     540      gfits_convert_MeasurePanstarrs (tmpMeasure, sizeof(MeasurePanstarrs), Nmeasure);
     541      measure = MeasurePanstarrsToInternal (tmpMeasure, Nmeasure);
     542      free (tmpMeasure);
     543      break; }
     544# endif
    442545    default:
    443546      fprintf (stderr, "error reading measures\n");
    … …  
    452555
    453556  int nitems;
    454   MeasureElixir *tmpMeasureElixir;
    455   MeasureLoneos *tmpMeasureLoneos;
    456   MeasurePanstarrs *tmpMeasurePanstarrs;
    457557
    458558  switch (format) {
    459     case DVO_FORMAT_INTERNAL:
     559    case DVO_FORMAT_INTERNAL: {
    460560      gfits_convert_Measure (measure, sizeof(Measure), Nmeasure);
    461561      nitems = fwrite (measure, sizeof(Measure), Nmeasure, f);
    … …  
    464564        return (FALSE);
    465565      }
    466       break;
    467     case DVO_FORMAT_ELIXIR:
    468       tmpMeasureElixir = MeasureInternalToElixir (measure, Nmeasure);
    469       gfits_convert_MeasureElixir (tmpMeasureElixir, sizeof(MeasureElixir), Nmeasure);
    470       nitems = fwrite (tmpMeasureElixir, sizeof(MeasureElixir), Nmeasure, f);
    471       free (tmpMeasureElixir);
     566      break; }
     567    case DVO_FORMAT_ELIXIR: {
     568      MeasureElixir *tmpMeasure;
     569      tmpMeasure = MeasureInternalToElixir (measure, Nmeasure);
     570      gfits_convert_MeasureElixir (tmpMeasure, sizeof(MeasureElixir), Nmeasure);
     571      nitems = fwrite (tmpMeasure, sizeof(MeasureElixir), Nmeasure, f);
     572      free (tmpMeasure);
    472573      if (nitems != Nmeasure) {
    473574        fprintf (stderr, "failed to write measures (%d vs %d)\n", nitems, Nmeasure);
    474575        return (FALSE);
    475576      }
    476       break;
    477     case DVO_FORMAT_LONEOS:
    478       tmpMeasureLoneos = MeasureInternalToLoneos (measure, Nmeasure);
    479       gfits_convert_MeasureLoneos (tmpMeasureLoneos, sizeof(MeasureLoneos), Nmeasure);
    480       nitems = fwrite (tmpMeasureLoneos, sizeof(MeasureLoneos), Nmeasure, f);
    481       free (tmpMeasureLoneos);
     577      break; }
     578    case DVO_FORMAT_LONEOS: {
     579      MeasureLoneos *tmpMeasure;
     580      tmpMeasure = MeasureInternalToLoneos (measure, Nmeasure);
     581      gfits_convert_MeasureLoneos (tmpMeasure, sizeof(MeasureLoneos), Nmeasure);
     582      nitems = fwrite (tmpMeasure, sizeof(MeasureLoneos), Nmeasure, f);
     583      free (tmpMeasure);
    482584      if (nitems != Nmeasure) {
    483585        fprintf (stderr, "failed to write measures (%d vs %d)\n", nitems, Nmeasure);
    484586        return (FALSE);
    485587      }
    486       break;
    487     case DVO_FORMAT_PANSTARRS:
    488     case DVO_FORMAT_PMTEST:
    489       tmpMeasurePanstarrs = MeasureInternalToPanstarrs (measure, Nmeasure);
    490       gfits_convert_MeasurePanstarrs (tmpMeasurePanstarrs, sizeof(MeasurePanstarrs), Nmeasure);
    491       nitems = fwrite (tmpMeasurePanstarrs, sizeof(MeasurePanstarrs), Nmeasure, f);
    492       free (tmpMeasurePanstarrs);
     588      break; }
     589    case DVO_FORMAT_PANSTARRS_DEV_0: {
     590      MeasurePanstarrs_DEV_0 *tmpMeasure;
     591      tmpMeasure = MeasureInternalToPanstarrs_DEV_0 (measure, Nmeasure);
     592      gfits_convert_MeasurePanstarrs_DEV_0 (tmpMeasure, sizeof(MeasurePanstarrs_DEV_0), Nmeasure);
     593      nitems = fwrite (tmpMeasure, sizeof(MeasurePanstarrs_DEV_0), Nmeasure, f);
     594      free (tmpMeasure);
    493595      if (nitems != Nmeasure) {
    494596        fprintf (stderr, "failed to write measures (%d vs %d)\n", nitems, Nmeasure);
    495597        return (FALSE);
    496598      }
    497       break;
     599      break; }
     600# if 0
     601    case DVO_FORMAT_PANSTARRS: {
     602      MeasurePanstarrs *tmpMeasure;
     603      tmpMeasure = MeasureInternalToPanstarrs (measure, Nmeasure);
     604      gfits_convert_MeasurePanstarrs (tmpMeasure, sizeof(MeasurePanstarrs), Nmeasure);
     605      nitems = fwrite (tmpMeasure, sizeof(MeasurePanstarrs), Nmeasure, f);
     606      free (tmpMeasure);
     607      if (nitems != Nmeasure) {
     608        fprintf (stderr, "failed to write measures (%d vs %d)\n", nitems, Nmeasure);
     609        return (FALSE);
     610      }
     611      break; }
     612# endif
    498613    default:
    499614      fprintf (stderr, "error writing measures\n");
    … …  
    509624  int nitems;
    510625  SecFilt *secfilt;
    511   SecFiltElixir *tmpSecFiltElixir;
    512   SecFiltLoneos *tmpSecFiltLoneos;
    513   SecFiltPanstarrs *tmpSecFiltPanstarrs;
    514626
    515627  switch (format) {
    516     case DVO_FORMAT_INTERNAL:
     628    case DVO_FORMAT_INTERNAL: {
    517629      ALLOCATE (secfilt, SecFilt, MAX (Nsecfilt, 1));
    518630      nitems = fread (secfilt, sizeof(SecFilt), Nsecfilt, f);
    … …  
    522634      }
    523635      gfits_convert_SecFilt (secfilt, sizeof(SecFilt), Nsecfilt);
    524       break;
    525     case DVO_FORMAT_ELIXIR:
    526       ALLOCATE (tmpSecFiltElixir, SecFiltElixir, MAX (Nsecfilt, 1));
    527       nitems = fread (tmpSecFiltElixir, sizeof(SecFiltElixir), Nsecfilt, f);
     636      break; }
     637    case DVO_FORMAT_ELIXIR: {
     638      SecFiltElixir *tmpSecFilt;
     639      ALLOCATE (tmpSecFilt, SecFiltElixir, MAX (Nsecfilt, 1));
     640      nitems = fread (tmpSecFilt, sizeof(SecFiltElixir), Nsecfilt, f);
    528641      if (nitems != Nsecfilt) {
    529642        fprintf (stderr, "failed to read secfilts (%d vs %d)\n", nitems, Nsecfilt);
    530643        return (NULL);
    531644      }
    532       gfits_convert_SecFiltElixir (tmpSecFiltElixir, sizeof(SecFiltElixir), Nsecfilt);
    533       secfilt = SecFiltElixirToInternal (tmpSecFiltElixir, Nsecfilt);
    534       free (tmpSecFiltElixir);
    535       break;
    536     case DVO_FORMAT_LONEOS:
    537       ALLOCATE (tmpSecFiltLoneos, SecFiltLoneos, MAX (Nsecfilt, 1));
    538       nitems = fread (tmpSecFiltLoneos, sizeof(SecFiltLoneos), Nsecfilt, f);
     645      gfits_convert_SecFiltElixir (tmpSecFilt, sizeof(SecFiltElixir), Nsecfilt);
     646      secfilt = SecFiltElixirToInternal (tmpSecFilt, Nsecfilt);
     647      free (tmpSecFilt);
     648      break; }
     649    case DVO_FORMAT_LONEOS: {
     650      SecFiltLoneos *tmpSecFilt;
     651      ALLOCATE (tmpSecFilt, SecFiltLoneos, MAX (Nsecfilt, 1));
     652      nitems = fread (tmpSecFilt, sizeof(SecFiltLoneos), Nsecfilt, f);
    539653      if (nitems != Nsecfilt) {
    540654        fprintf (stderr, "failed to read secfilts (%d vs %d)\n", nitems, Nsecfilt);
    541655        return (NULL);
    542656      }
    543       gfits_convert_SecFiltLoneos (tmpSecFiltLoneos, sizeof(SecFiltLoneos), Nsecfilt);
    544       secfilt = SecFiltLoneosToInternal (tmpSecFiltLoneos, Nsecfilt);
    545       free (tmpSecFiltLoneos);
    546       break;
    547     case DVO_FORMAT_PANSTARRS:
    548     case DVO_FORMAT_PMTEST:
    549       ALLOCATE (tmpSecFiltPanstarrs, SecFiltPanstarrs, MAX (Nsecfilt, 1));
    550       nitems = fread (tmpSecFiltPanstarrs, sizeof(SecFiltPanstarrs), Nsecfilt, f);
     657      gfits_convert_SecFiltLoneos (tmpSecFilt, sizeof(SecFiltLoneos), Nsecfilt);
     658      secfilt = SecFiltLoneosToInternal (tmpSecFilt, Nsecfilt);
     659      free (tmpSecFilt);
     660      break; }
     661    case DVO_FORMAT_PANSTARRS_DEV_0: {
     662      SecFiltPanstarrs_DEV_0 *tmpSecFilt;
     663      ALLOCATE (tmpSecFilt, SecFiltPanstarrs_DEV_0, MAX (Nsecfilt, 1));
     664      nitems = fread (tmpSecFilt, sizeof(SecFiltPanstarrs_DEV_0), Nsecfilt, f);
    551665      if (nitems != Nsecfilt) {
    552666        fprintf (stderr, "failed to read secfilts (%d vs %d)\n", nitems, Nsecfilt);
    553667        return (NULL);
    554668      }
    555       gfits_convert_SecFiltPanstarrs (tmpSecFiltPanstarrs, sizeof(SecFiltPanstarrs), Nsecfilt);
    556       secfilt = SecFiltPanstarrsToInternal (tmpSecFiltPanstarrs, Nsecfilt);
    557       free (tmpSecFiltPanstarrs);
    558       break;
     669      gfits_convert_SecFiltPanstarrs_DEV_0 (tmpSecFilt, sizeof(SecFiltPanstarrs_DEV_0), Nsecfilt);
     670      secfilt = SecFiltPanstarrs_DEV_0_ToInternal (tmpSecFilt, Nsecfilt);
     671      free (tmpSecFilt);
     672      break; }
     673# if 0
     674    case DVO_FORMAT_PANSTARRS: {
     675      SecFiltPanstarrs *tmpSecFilt;
     676      ALLOCATE (tmpSecFilt, SecFiltPanstarrs, MAX (Nsecfilt, 1));
     677      nitems = fread (tmpSecFilt, sizeof(SecFiltPanstarrs), Nsecfilt, f);
     678      if (nitems != Nsecfilt) {
     679        fprintf (stderr, "failed to read secfilts (%d vs %d)\n", nitems, Nsecfilt);
     680        return (NULL);
     681      }
     682      gfits_convert_SecFiltPanstarrs (tmpSecFilt, sizeof(SecFiltPanstarrs), Nsecfilt);
     683      secfilt = SecFiltPanstarrsToInternal (tmpSecFilt, Nsecfilt);
     684      free (tmpSecFilt);
     685      break; }
     686# endif
    559687    default:
    560688      fprintf (stderr, "error reading measures\n");
    … …  
    569697
    570698  int nitems;
    571   SecFiltElixir *tmpSecFiltElixir;
    572   SecFiltLoneos *tmpSecFiltLoneos;
    573   SecFiltPanstarrs *tmpSecFiltPanstarrs;
    574699
    575700  switch (format) {
    576     case DVO_FORMAT_INTERNAL:
     701    case DVO_FORMAT_INTERNAL: {
    577702      gfits_convert_SecFilt (secfilt, sizeof(SecFilt), Nsecfilt);
    578703      nitems = fwrite (secfilt, sizeof(SecFilt), Nsecfilt, f);
    … …  
    581706        return (FALSE);
    582707      }
    583       break;
    584     case DVO_FORMAT_ELIXIR:
    585       tmpSecFiltElixir = SecFiltInternalToElixir (secfilt, Nsecfilt);
    586       gfits_convert_SecFiltElixir (tmpSecFiltElixir, sizeof(SecFiltElixir), Nsecfilt);
    587       nitems = fwrite (tmpSecFiltElixir, sizeof(SecFiltElixir), Nsecfilt, f);
    588       free (tmpSecFiltElixir);
     708      break; }
     709    case DVO_FORMAT_ELIXIR: {
     710      SecFiltElixir *tmpSecFilt;
     711      tmpSecFilt = SecFiltInternalToElixir (secfilt, Nsecfilt);
     712      gfits_convert_SecFiltElixir (tmpSecFilt, sizeof(SecFiltElixir), Nsecfilt);
     713      nitems = fwrite (tmpSecFilt, sizeof(SecFiltElixir), Nsecfilt, f);
     714      free (tmpSecFilt);
    589715      if (nitems != Nsecfilt) {
    590716        fprintf (stderr, "failed to write secfilts (%d vs %d)\n", nitems, Nsecfilt);
    591717        return (FALSE);
    592718      }
    593       break;
    594     case DVO_FORMAT_LONEOS:
    595       tmpSecFiltLoneos = SecFiltInternalToLoneos (secfilt, Nsecfilt);
    596       gfits_convert_SecFiltLoneos (tmpSecFiltLoneos, sizeof(SecFiltLoneos), Nsecfilt);
    597       nitems = fwrite (tmpSecFiltLoneos, sizeof(SecFiltLoneos), Nsecfilt, f);
    598       free (tmpSecFiltLoneos);
     719      break; }
     720    case DVO_FORMAT_LONEOS: {
     721      SecFiltLoneos *tmpSecFilt;
     722      tmpSecFilt = SecFiltInternalToLoneos (secfilt, Nsecfilt);
     723      gfits_convert_SecFiltLoneos (tmpSecFilt, sizeof(SecFiltLoneos), Nsecfilt);
     724      nitems = fwrite (tmpSecFilt, sizeof(SecFiltLoneos), Nsecfilt, f);
     725      free (tmpSecFilt);
    599726      if (nitems != Nsecfilt) {
    600727        fprintf (stderr, "failed to write secfilts (%d vs %d)\n", nitems, Nsecfilt);
    601728        return (FALSE);
    602729      }
    603       break;
    604     case DVO_FORMAT_PANSTARRS:
    605     case DVO_FORMAT_PMTEST:
    606       tmpSecFiltPanstarrs = SecFiltInternalToPanstarrs (secfilt, Nsecfilt);
    607       gfits_convert_SecFiltPanstarrs (tmpSecFiltPanstarrs, sizeof(SecFiltPanstarrs), Nsecfilt);
    608       nitems = fwrite (tmpSecFiltPanstarrs, sizeof(SecFiltPanstarrs), Nsecfilt, f);
    609       free (tmpSecFiltPanstarrs);
     730      break; }
     731    case DVO_FORMAT_PANSTARRS_DEV_0: {
     732      SecFiltPanstarrs_DEV_0 *tmpSecFilt;
     733      tmpSecFilt = SecFiltInternalToPanstarrs_DEV_0 (secfilt, Nsecfilt);
     734      gfits_convert_SecFiltPanstarrs_DEV_0 (tmpSecFilt, sizeof(SecFiltPanstarrs_DEV_0), Nsecfilt);
     735      nitems = fwrite (tmpSecFilt, sizeof(SecFiltPanstarrs_DEV_0), Nsecfilt, f);
     736      free (tmpSecFilt);
    610737      if (nitems != Nsecfilt) {
    611738        fprintf (stderr, "failed to write secfilts (%d vs %d)\n", nitems, Nsecfilt);
    612739        return (FALSE);
    613740      }
    614       break;
     741      break; }
     742# if 0
     743    case DVO_FORMAT_PANSTARRS: {
     744      SecFiltPanstarrs *tmpSecFilt;
     745      tmpSecFilt = SecFiltInternalToPanstarrs (secfilt, Nsecfilt);
     746      gfits_convert_SecFiltPanstarrs (tmpSecFilt, sizeof(SecFiltPanstarrs), Nsecfilt);
     747      nitems = fwrite (tmpSecFilt, sizeof(SecFiltPanstarrs), Nsecfilt, f);
     748      free (tmpSecFilt);
     749      if (nitems != Nsecfilt) {
     750        fprintf (stderr, "failed to write secfilts (%d vs %d)\n", nitems, Nsecfilt);
     751        return (FALSE);
     752      }
     753      break; }
     754# endif
    615755    default:
    616756      fprintf (stderr, "error writing secfilts\n");

  • trunk/Ohana/src/libdvo/src/dvo_catalog_split.c

    r8456 r12332  
    88  Matrix matrix;
    99  FTable ftable;
     10  SecFilt *primary;
    1011  Catalog *measure, *missing, *secfilt;
    1112
    … …  
    5455      return (FALSE);
    5556    }
    56     catalog[0].average = FtableToAverage (&ftable, &catalog[0].Naverage, &catalog[0].catformat);
     57    /* old versions of DVO stored one of the average magnitudes in Average. we save this if needed */
     58    catalog[0].average = FtableToAverage (&ftable, &catalog[0].Naverage, &catalog[0].catformat, &primary);
    5759    if (Naverage != catalog[0].Naverage) {
    5860      fprintf (stderr, "Warning: mismatch between Naverage in PHU and Table headers (%d vs %d)\n", Naverage, catalog[0].Naverage);
    … …  
    240242      fprintf (stderr, "Warning: mismatch between Nsecfilt items in PHU and Table headers (%d vs %d)\n", Nexpect, Nitems);
    241243    }
     244
     245    /* if primary is defined, we were supplied with one additional average magnitude from Average
     246       we need to interleave these magnitudes with the secfilt entries just loaded */
     247    if (primary != NULL) {
     248      int Ntmpfilt, Ntotal, i, j;
     249      SecFilt *tmpfilt;
     250      tmpfilt  = catalog[0].secfilt;
     251      Ntmpfilt = catalog[0].Nsecfilt;
     252      Nsecfilt = catalog[0].Nsecfilt + 1;
     253      Ntotal = Nsecfilt * catalog[0].Naverage;
     254      ALLOCATE (catalog[0].secfilt, SecFilt, Ntotal);
     255      for (i = 0; i < catalog[0].Naverage; i++) {
     256        catalog[0].secfilt[i*Nsecfilt + 0] = primary[i];
     257        for (j = 0; j < Ntmpfilt; j++) {
     258          catalog[0].secfilt[i*Nsecfilt + j + 1] = tmpfilt[i*Ntmpfilt + j];
     259        }
     260      }         
     261      catalog[0].Nsecfilt = Nsecfilt;
     262      free (primary);
     263    }
     264
     265
    242266    gfits_free_header (&header);
    243267    gfits_free_matrix (&matrix);
    244   }
     268  } else {
     269    if (primary != NULL) free (primary);
     270  }
     271
    245272  catalog[0].secfilt_catalog = secfilt;
    246273
    … …  
    254281
    255282/* save_catalog_split writes complete new files from scratch */
    256 
    257283int dvo_catalog_save_split (Catalog *catalog, char VERBOSE) {
    258284
    … …  
    261287  Header header;
    262288  FTable ftable;
    263   Catalog *measure, *missing, *secfilt;
     289  Catalog *catfile;
     290  SecFilt *primary, *secfilt;
     291  int i, j, Nsecfilt, Nallfilt, Ntotal;
    264292
    265293  ftable.header = &header;
    … …  
    289317  /* in split mode, we can save only part of the data */
    290318
     319  /* for the appropriate types, pull out the first secfilt and pass to AverageToFtable as primary */
     320  if ((catalog[0].catformat == DVO_FORMAT_ELIXIR) || // special case for ELIXIR
     321      (catalog[0].catformat == DVO_FORMAT_LONEOS)) { // special case for LONEOS
     322    if (catalog[0].secfilt == NULL) {       
     323      fprintf (stderr, "missing secfilt, cannot build output averages (dvo_catalog_split.c:544)\n");
     324      exit (1);
     325    }
     326    secfilt = catalog[0].secfilt;
     327
     328    Nallfilt = catalog[0].Nsecfilt;
     329    Nsecfilt = catalog[0].Nsecfilt - 1;
     330    Ntotal = Nsecfilt * catalog[0].Naverage;
     331    ALLOCATE (primary, SecFilt, catalog[0].Naverage);
     332    ALLOCATE (secfilt, SecFilt, Ntotal);
     333
     334    for (i = 0; i < catalog[0].Naverage; i++) {
     335      primary[i] = secfilt[i*Nallfilt + 0];
     336      for (j = 0; j < Nsecfilt; j++) {
     337        secfilt[i*Nsecfilt + j] = catalog[0].secfilt[i*Nallfilt + j + 1];
     338      }
     339    }           
     340  } else {
     341    primary = NULL;
     342    secfilt = catalog[0].secfilt;
     343    Nsecfilt = catalog[0].Nsecfilt;
     344  }
     345
    291346  /*** Average Table ***/
    292347
    … …  
    303358
    304359    /* write out Average table (convert to FITS table format) */
    305     AverageToFtable (&ftable, catalog[0].average, catalog[0].Naverage, catalog[0].catformat);
     360    AverageToFtable (&ftable, catalog[0].average, catalog[0].Naverage, catalog[0].catformat, primary);
    306361    if (!gfits_fwrite_Theader (catalog[0].f, &header)) {
    307362      fprintf (stderr, "can't write table header");
    … …  
    317372
    318373  /*** Measure Table ***/
    319 
    320374  if (catalog[0].measure != NULL) {
    321375
    322     measure = catalog[0].measure_catalog;
     376    /* catalog file data is stored in separate structure */
     377    catfile = catalog[0].measure_catalog;
    323378
    324379    /* XXX EAM : warn about this condition; add code to handle? */
    … …  
    329384
    330385    /* rewind file pointers and truncate (file is still open) */
    331     fseek (measure[0].f, 0, SEEK_SET);
    332     ftruncate (fileno (measure[0].f), 0);
     386    fseek (catfile[0].f, 0, SEEK_SET);
     387    ftruncate (fileno (catfile[0].f), 0);
    333388
    334389    /* write table PHU header */
    335     if (!gfits_fwrite_header  (measure[0].f, &measure[0].header)) {
     390    if (!gfits_fwrite_header  (catfile[0].f, &catfile[0].header)) {
    336391      fprintf (stderr, "can't write primary header");
    337392      return (FALSE);
    … …  
    339394
    340395    /* this is probably a NOP, do I have to keep it in? */
    341     gfits_create_matrix (&measure[0].header, &matrix);
    342     if (!gfits_fwrite_matrix  (measure[0].f, &matrix)) {
     396    gfits_create_matrix (&catfile[0].header, &matrix);
     397    if (!gfits_fwrite_matrix  (catfile[0].f, &matrix)) {
    343398      fprintf (stderr, "can't write primary matrix");
    344399      return (FALSE);
    … …  
    348403    /* write out Measure table (convert to FITS table format) */
    349404    MeasureToFtable (&ftable, catalog[0].measure, catalog[0].Nmeasure, catalog[0].catformat);
    350     if (!gfits_fwrite_Theader (measure[0].f, &header)) {
     405    if (!gfits_fwrite_Theader (catfile[0].f, &header)) {
    351406      fprintf (stderr, "can't write table header");
    352407      return (FALSE);
    353408    }
    354     if (!gfits_fwrite_table (measure[0].f, &ftable)) {
     409    if (!gfits_fwrite_table (catfile[0].f, &ftable)) {
    355410      fprintf (stderr, "can't write table data");
    356411      return (FALSE);
    … …  
    361416
    362417  /*** Missing Table ***/
    363 
    364418  if (catalog[0].missing != NULL) {
    365419
    366     missing = catalog[0].missing_catalog;
     420    /* catalog data is stored in separate catalog */
     421    catfile = catalog[0].missing_catalog;
    367422
    368423    /* rewind file pointers and truncate (file is still open) */
    369     fseek (missing[0].f, 0, SEEK_SET);
    370     ftruncate (fileno (missing[0].f), 0);
     424    fseek (catfile[0].f, 0, SEEK_SET);
     425    ftruncate (fileno (catfile[0].f), 0);
    371426
    372427    /* write table PHU header */
    373     if (!gfits_fwrite_header  (missing[0].f, &missing[0].header)) {
     428    if (!gfits_fwrite_header  (catfile[0].f, &catfile[0].header)) {
    374429      fprintf (stderr, "can't write primary header");
    375430      return (FALSE);
    … …  
    377432
    378433    /* this is probably a NOP, do I have to keep it in? */
    379     gfits_create_matrix (&missing[0].header, &matrix);
    380     if (!gfits_fwrite_matrix  (missing[0].f, &matrix)) {
     434    gfits_create_matrix (&catfile[0].header, &matrix);
     435    if (!gfits_fwrite_matrix  (catfile[0].f, &matrix)) {
    381436      fprintf (stderr, "can't write primary matrix");
    382437      return (FALSE);
    … …  
    386441    /* write out Missing table (convert to FITS table format) */
    387442    gfits_table_set_Missing (&ftable, catalog[0].missing, catalog[0].Nmissing);
    388     if (!gfits_fwrite_Theader (missing[0].f, &header)) {
     443    if (!gfits_fwrite_Theader (catfile[0].f, &header)) {
    389444      fprintf (stderr, "can't write table header");
    390445      return (FALSE);
    391446    }
    392     if (!gfits_fwrite_table (missing[0].f, &ftable)) {
     447    if (!gfits_fwrite_table (catfile[0].f, &ftable)) {
    393448      fprintf (stderr, "can't write table data");
    394449      return (FALSE);
    … …  
    399454
    400455  /*** Secfilt Table ***/
    401 
    402456  if (catalog[0].secfilt != NULL) {
    403457
    404     secfilt = catalog[0].secfilt_catalog;
     458    /* catalog file data is stored in a separate catalog structure */
     459    catfile = catalog[0].secfilt_catalog;
    405460
    406461    /* rewind file pointers and truncate (file is still open) */
    407     fseek (secfilt[0].f, 0, SEEK_SET);
    408     ftruncate (fileno (secfilt[0].f), 0);
     462    fseek (catfile[0].f, 0, SEEK_SET);
     463    ftruncate (fileno (catfile[0].f), 0);
    409464
    410465    /* write table PHU header */
    411     if (!gfits_fwrite_header  (secfilt[0].f, &secfilt[0].header)) {
     466    if (!gfits_fwrite_header  (catfile[0].f, &catfile[0].header)) {
    412467      fprintf (stderr, "can't write primary header");
    413468      return (FALSE);
    … …  
    415470
    416471    /* this is probably a NOP, do I have to keep it in? */
    417     gfits_create_matrix (&secfilt[0].header, &matrix);
    418     if (!gfits_fwrite_matrix  (secfilt[0].f, &matrix)) {
     472    gfits_create_matrix (&catfile[0].header, &matrix);
     473    if (!gfits_fwrite_matrix  (catfile[0].f, &matrix)) {
    419474      fprintf (stderr, "can't write primary matrix");
    420475      return (FALSE);
    … …  
    424479    /* write out SecFilt table (convert to FITS table format) */
    425480    Nitems = catalog[0].Naverage * catalog[0].Nsecfilt;
    426     SecFiltToFtable (&ftable, catalog[0].secfilt, Nitems, catalog[0].catformat);
    427     if (!gfits_fwrite_Theader (secfilt[0].f, &header)) {
     481    SecFiltToFtable (&ftable, secfilt, Nitems, catalog[0].catformat);
     482    if (!gfits_fwrite_Theader (catfile[0].f, &header)) {
    428483      fprintf (stderr, "can't write table header");
    429484      return (FALSE);
    430485    }
    431     if (!gfits_fwrite_table (secfilt[0].f, &ftable)) {
     486    if (!gfits_fwrite_table (catfile[0].f, &ftable)) {
    432487      fprintf (stderr, "can't write table data");
    433488      return (FALSE);
    … …  
    435490    gfits_free_table (&ftable);
    436491    gfits_free_header (&header);
     492  }
     493
     494  /* free temp storage */
     495  if (primary != NULL) {
     496    free (primary);
     497    free (secfilt);
    437498  }
    438499
    … …  
    453514  FTable ftable;
    454515  VTable vtable;
    455   Catalog *measure, *missing, *secfilt;
     516  Catalog *catfile;
     517  SecFilt *primary, *secfilt;
     518  int j, Nsecfilt, Nallfilt, Ntotal;
    456519
    457520  ftable.header = &header;
    … …  
    480543  }
    481544
     545  /** for the appropriate types, pull out the first secfilt and pass to AverageToFtable as primary **/
     546  if ((catalog[0].catformat == DVO_FORMAT_ELIXIR) || // special case for ELIXIR
     547      (catalog[0].catformat == DVO_FORMAT_LONEOS)) { // special case for LONEOS
     548    if (catalog[0].secfilt == NULL) {
     549      fprintf (stderr, "missing secfilt, cannot build output averages (dvo_catalog_split.c:544)\n");
     550      exit (1);
     551    }
     552    secfilt = catalog[0].secfilt;
     553
     554    Nallfilt = catalog[0].Nsecfilt;
     555    Nsecfilt = catalog[0].Nsecfilt - 1;
     556    Ntotal = Nsecfilt * catalog[0].Naverage;
     557    ALLOCATE (primary, SecFilt, catalog[0].Naverage);
     558    ALLOCATE (secfilt, SecFilt, Ntotal);
     559
     560    for (i = 0; i < catalog[0].Naverage; i++) {
     561      primary[i] = secfilt[i*Nallfilt + 0];
     562      for (j = 0; j < Nsecfilt; j++) {
     563        secfilt[i*Nsecfilt + j] = catalog[0].secfilt[i*Nallfilt + j + 1];
     564      }
     565    }           
     566  } else {
     567    primary = NULL;
     568    secfilt = catalog[0].secfilt;
     569    Nsecfilt = catalog[0].Nsecfilt;
     570  }
     571
    482572  /*** Average Table ***/
    483 
    484573  if (catalog[0].average != NULL) {
    485574
    … …  
    492581
    493582    /* write out Average table (convert to FITS table format) */
    494     AverageToFtable (&ftable, catalog[0].average, catalog[0].Naverage, catalog[0].catformat);
     583    AverageToFtable (&ftable, catalog[0].average, catalog[0].Naverage, catalog[0].catformat, primary);
    495584    /* convert only output rows to vtable */
    496585    gfits_table_to_vtable (&ftable, &vtable, catalog[0].Nave_disk, Nout);
    … …  
    510599
    511600  /*** Measure Table ***/
    512 
    513601  if (catalog[0].measure != NULL) {
    514602
    515     measure = catalog[0].measure_catalog;
     603    catfile = catalog[0].measure_catalog;
    516604
    517605    /* skip past PHU header and matrix */
    518     Nskip = measure[0].header.size + gfits_matrix_size (&measure[0].header);
    519     fseek (measure[0].f, Nskip, SEEK_SET);
     606    Nskip = catfile[0].header.size + gfits_matrix_size (&catfile[0].header);
     607    fseek (catfile[0].f, Nskip, SEEK_SET);
    520608
    521609    Ndisk  = catalog[0].Nmeas_disk;
    … …  
    547635    vtable.pad = vtable.size - Nx*Ny;
    548636
    549     if (!gfits_fwrite_Theader (measure[0].f, &header)) {
     637    if (!gfits_fwrite_Theader (catfile[0].f, &header)) {
    550638      fprintf (stderr, "can't write table header");
    551639      return (FALSE);
    552640    }
    553     if (!gfits_fwrite_vtable (measure[0].f, &vtable)) {
     641    if (!gfits_fwrite_vtable (catfile[0].f, &vtable)) {
    554642      fprintf (stderr, "can't write table data");
    555643      return (FALSE);
    … …  
    566654  if (catalog[0].missing != NULL) {
    567655
    568     missing = catalog[0].missing_catalog;
     656    catfile = catalog[0].missing_catalog;
    569657
    570658    /* rewind file pointers and truncate (file is still open) */
    571     fseek (missing[0].f, 0, SEEK_SET);
    572     ftruncate (fileno (missing[0].f), 0);
     659    fseek (catfile[0].f, 0, SEEK_SET);
     660    ftruncate (fileno (catfile[0].f), 0);
    573661
    574662    /* write table PHU header */
    575     if (!gfits_fwrite_header  (missing[0].f, &missing[0].header)) {
     663    if (!gfits_fwrite_header  (catfile[0].f, &catfile[0].header)) {
    576664      fprintf (stderr, "can't write primary header");
    577665      return (FALSE);
    … …  
    579667
    580668    /* this is probably a NOP, do I have to keep it in? */
    581     gfits_create_matrix (&missing[0].header, &matrix);
    582     if (!gfits_fwrite_matrix  (missing[0].f, &matrix)) {
     669    gfits_create_matrix (&catfile[0].header, &matrix);
     670    if (!gfits_fwrite_matrix  (catfile[0].f, &matrix)) {
    583671      fprintf (stderr, "can't write primary matrix");
    584672      return (FALSE);
    … …  
    588676    /* write out Missing table (convert to FITS table format) */
    589677    gfits_table_set_Missing (&ftable, catalog[0].missing, catalog[0].Nmissing);
    590     if (!gfits_fwrite_Theader (missing[0].f, &header)) {
     678    if (!gfits_fwrite_Theader (catfile[0].f, &header)) {
    591679      fprintf (stderr, "can't write table header");
    592680      return (FALSE);
    593681    }
    594     if (!gfits_fwrite_table (missing[0].f, &ftable)) {
     682    if (!gfits_fwrite_table (catfile[0].f, &ftable)) {
    595683      fprintf (stderr, "can't write table data");
    596684      return (FALSE);
    … …  
    601689
    602690  /*** Secfilt Table ***/
    603 
    604691  if (catalog[0].secfilt != NULL) {
    605692
    606     secfilt = catalog[0].secfilt_catalog;
     693    catfile = catalog[0].secfilt_catalog;
    607694
    608695    /* skip past PHU header and matrix */
    609     Nskip = secfilt[0].header.size + gfits_matrix_size (&secfilt[0].header);
    610     fseek (secfilt[0].f, Nskip, SEEK_SET);
     696    Nskip = catfile[0].header.size + gfits_matrix_size (&catfile[0].header);
     697    fseek (catfile[0].f, Nskip, SEEK_SET);
    611698
    612699    /* how many lines to write out? */
    … …  
    616703    /* convert to output format FITS table */
    617704    Nitems = catalog[0].Naverage * catalog[0].Nsecfilt;
    618     SecFiltToFtable (&ftable, catalog[0].secfilt, Nitems, catalog[0].catformat);
     705    SecFiltToFtable (&ftable, secfilt, Nitems, catalog[0].catformat);
    619706    /* convert only output rows to vtable */
    620707    gfits_table_to_vtable (&ftable, &vtable, Ndisk, Nout);
    621708
    622     if (!gfits_fwrite_Theader (secfilt[0].f, &header)) {
     709    if (!gfits_fwrite_Theader (catfile[0].f, &header)) {
    623710      fprintf (stderr, "can't write table header");
    624711      return (FALSE);
    625712    }
    626     if (!gfits_fwrite_vtable (secfilt[0].f, &vtable)) {
     713    if (!gfits_fwrite_vtable (catfile[0].f, &vtable)) {
    627714      fprintf (stderr, "can't write table data");
    628715      return (FALSE);
    … …  
    631718    gfits_free_table (&ftable);
    632719    gfits_free_header (&header);
     720  }
     721
     722  /* free temp storage */
     723  if (primary != NULL) {
     724    free (primary);
     725    free (secfilt);
    633726  }
    634727

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

    r8456 r12332  
    1313/*** Average / FTable conversion functions ***/
    1414
    15 Average *FtableToAverage (FTable *ftable, int *Naverage, int *format) {
     15Average *FtableToAverage (FTable *ftable, int *Naverage, int *format, SecFilt **primary) {
    1616
    1717  Average *average;
    1818  char extname[80];
     19
     20  /* in the Elixir and Loneos cases, we are supplied with an average magnitude in Average
     21     in these cases, save these values in primary; otherwise set primary to NULL */
     22  *primary = NULL;
    1923
    2024  /* convert to the internal format */
    … …  
    3135    AverageElixir *tmpAverage;
    3236    tmpAverage = gfits_table_get_AverageElixir (ftable, Naverage, NULL);
    33     average = AverageElixirToInternal (tmpAverage, *Naverage);
     37    average = AverageElixirToInternal (tmpAverage, *Naverage, primary);
    3438    free (tmpAverage);
    3539    *format = DVO_FORMAT_ELIXIR;
    … …  
    3943    AverageLoneos *tmpAverage;
    4044    tmpAverage = gfits_table_get_AverageLoneos (ftable, Naverage, NULL);
    41     average = AverageLoneosToInternal (tmpAverage, *Naverage);
     45    average = AverageLoneosToInternal (tmpAverage, *Naverage, primary);
    4246    free (tmpAverage);
    4347    *format = DVO_FORMAT_LONEOS;
    4448    return (average);
    4549  }
     50  if (!strcmp (extname, "DVO_AVERAGE_PANSTARRS_DEV_0")) {
     51    AveragePanstarrs_DEV_0 *tmpAverage;
     52    tmpAverage = gfits_table_get_AveragePanstarrs_DEV_0 (ftable, Naverage, NULL);
     53    average = AveragePanstarrs_DEV_0_ToInternal (tmpAverage, *Naverage);
     54    free (tmpAverage);
     55    *format = DVO_FORMAT_PANSTARRS_DEV_0;
     56    return (average);
     57  }
     58/* disable the new and minimally-used versions for now. 
     59   put them back in after dev work is further along
     60   OR replace with other output formats */
     61# if 0
    4662  if (!strcmp (extname, "DVO_AVERAGE_PANSTARRS")) {
    4763    AveragePanstarrs *tmpAverage;
    … …  
    6076    return (average);
    6177  }
     78# endif
    6279
    6380  fprintf (stderr, "table format unknown: %s\n", extname);
    … …  
    6784}
    6885
    69 int AverageToFtable (FTable *ftable, Average *average, int Naverage, int format) {
    70 
    71   AverageElixir *tmpAverageElixir;
    72   AverageLoneos *tmpAverageLoneos ;
    73   AveragePanstarrs *tmpAveragePanstarrs;
    74   AveragePMtest *tmpAveragePMtest;
     86int AverageToFtable (FTable *ftable, Average *average, int Naverage, int format, SecFilt *primary) {
     87
    7588
    7689  /* convert from the internal format */
    7790  switch (format) {
    78     case DVO_FORMAT_INTERNAL:
     91    case DVO_FORMAT_INTERNAL: {
    7992      gfits_table_set_Average (ftable, average, Naverage);
    80       break;
    81     case DVO_FORMAT_ELIXIR:
    82       tmpAverageElixir = AverageInternalToElixir (average, Naverage);
    83       gfits_table_set_AverageElixir (ftable, tmpAverageElixir, Naverage);
    84       free (tmpAverageElixir);
    85       break;
    86     case DVO_FORMAT_LONEOS:
    87       tmpAverageLoneos  = AverageInternalToLoneos (average, Naverage);
    88       gfits_table_set_AverageLoneos (ftable, tmpAverageLoneos , Naverage);
    89       free (tmpAverageLoneos );
    90       break;
    91     case DVO_FORMAT_PANSTARRS:
    92       tmpAveragePanstarrs = AverageInternalToPanstarrs (average, Naverage);
    93       gfits_table_set_AveragePanstarrs (ftable, tmpAveragePanstarrs, Naverage);
    94       free (tmpAveragePanstarrs);
    95       break;
    96     case DVO_FORMAT_PMTEST:
    97       tmpAveragePMtest = AverageInternalToPMtest (average, Naverage);
    98       gfits_table_set_AveragePMtest (ftable, tmpAveragePMtest, Naverage);
    99       free (tmpAveragePMtest);
    100       break;
     93      break; }
     94    case DVO_FORMAT_ELIXIR: {
     95      AverageElixir *tmpAverage;
     96      tmpAverage = AverageInternalToElixir (average, Naverage, primary);
     97      gfits_table_set_AverageElixir (ftable, tmpAverage, Naverage);
     98      free (tmpAverage);
     99      break; }
     100    case DVO_FORMAT_LONEOS: {
     101      AverageLoneos *tmpAverage ;
     102      tmpAverage  = AverageInternalToLoneos (average, Naverage, primary);
     103      gfits_table_set_AverageLoneos (ftable, tmpAverage, Naverage);
     104      free (tmpAverage );
     105      break; }
     106    case DVO_FORMAT_PANSTARRS_DEV_0: {
     107      AveragePanstarrs_DEV_0 *tmpAverage;
     108      tmpAverage = AverageInternalToPanstarrs_DEV_0 (average, Naverage);
     109      gfits_table_set_AveragePanstarrs_DEV_0 (ftable, tmpAverage, Naverage);
     110      free (tmpAverage);
     111      break; }
     112# if 0
     113    case DVO_FORMAT_PANSTARRS: {
     114      AveragePanstarrs *tmpAverage;
     115      tmpAverage = AverageInternalToPanstarrs (average, Naverage);
     116      gfits_table_set_AveragePanstarrs (ftable, tmpAverage, Naverage);
     117      free (tmpAverage);
     118      break; }
     119    case DVO_FORMAT_PMTEST: {
     120      AveragePMtest *tmpAverage;
     121      tmpAverage = AverageInternalToPMtest (average, Naverage);
     122      gfits_table_set_AveragePMtest (ftable, tmpAverage, Naverage);
     123      free (tmpAverage);
     124      break; }
     125# endif
    101126    default:
    102127      fprintf (stderr, "table format unknown (average)\n");
    … …  
    139164    return (measure);
    140165  }
     166  if (!strcmp (extname, "DVO_MEASURE_PANSTARRS_DEV_0")) {
     167    MeasurePanstarrs_DEV_0 *tmpMeasure;
     168    tmpMeasure = gfits_table_get_MeasurePanstarrs_DEV_0 (ftable, Nmeasure, NULL);
     169    measure = MeasurePanstarrs_DEV_0_ToInternal (tmpMeasure, *Nmeasure);
     170    free (tmpMeasure);
     171    *format = DVO_FORMAT_PANSTARRS_DEV_0;
     172    return (measure);
     173  }
     174# if 0
    141175  if (!strcmp (extname, "DVO_MEASURE_PANSTARRS") || !strcmp (extname, "DVO_MEASURE_PMTEST")) {
    142176    MeasurePanstarrs *tmpMeasure;
    … …  
    147181    return (measure);
    148182  }
     183# endif
    149184
    150185  fprintf (stderr, "table format unknown: %s\n", extname);
    … …  
    156191int MeasureToFtable (FTable *ftable, Measure *measure, int Nmeasure, int format) {
    157192
    158   MeasureElixir *tmpMeasureElixir;
    159   MeasureLoneos *tmpMeasureLoneos;
    160   MeasurePanstarrs *tmpMeasurePanstarrs;
    161193
    162194  /* convert from the internal format */
    163195  switch (format) {
    164     case DVO_FORMAT_INTERNAL:
     196    case DVO_FORMAT_INTERNAL: {
    165197      gfits_table_set_Measure (ftable, measure, Nmeasure);
    166       break;
    167     case DVO_FORMAT_ELIXIR:
    168       tmpMeasureElixir = MeasureInternalToElixir (measure, Nmeasure);
    169       gfits_table_set_MeasureElixir (ftable, tmpMeasureElixir, Nmeasure);
    170       free (tmpMeasureElixir);
    171       break;
    172     case DVO_FORMAT_LONEOS:
    173       tmpMeasureLoneos = MeasureInternalToLoneos (measure, Nmeasure);
    174       gfits_table_set_MeasureLoneos (ftable, tmpMeasureLoneos, Nmeasure);
    175       free (tmpMeasureLoneos);
    176       break;
    177     case DVO_FORMAT_PANSTARRS:
    178     case DVO_FORMAT_PMTEST:
    179       tmpMeasurePanstarrs = MeasureInternalToPanstarrs (measure, Nmeasure);
    180       gfits_table_set_MeasurePanstarrs (ftable, tmpMeasurePanstarrs, Nmeasure);
    181       free (tmpMeasurePanstarrs);
    182       break;
     198      break; }
     199    case DVO_FORMAT_ELIXIR: {
     200      MeasureElixir *tmpMeasure;
     201      tmpMeasure = MeasureInternalToElixir (measure, Nmeasure);
     202      gfits_table_set_MeasureElixir (ftable, tmpMeasure, Nmeasure);
     203      free (tmpMeasure);
     204      break; }
     205    case DVO_FORMAT_LONEOS: {
     206      MeasureLoneos *tmpMeasure;
     207      tmpMeasure = MeasureInternalToLoneos (measure, Nmeasure);
     208      gfits_table_set_MeasureLoneos (ftable, tmpMeasure, Nmeasure);
     209      free (tmpMeasure);
     210      break; }
     211    case DVO_FORMAT_PANSTARRS_DEV_0: {
     212      MeasurePanstarrs_DEV_0 *tmpMeasure;
     213      tmpMeasure = MeasureInternalToPanstarrs_DEV_0 (measure, Nmeasure);
     214      gfits_table_set_MeasurePanstarrs_DEV_0 (ftable, tmpMeasure, Nmeasure);
     215      free (tmpMeasure);
     216      break; }
     217# if 0
     218    case DVO_FORMAT_PANSTARRS: {
     219      MeasurePanstarrs *tmpMeasure;
     220      tmpMeasure = MeasureInternalToPanstarrs (measure, Nmeasure);
     221      gfits_table_set_MeasurePanstarrs (ftable, tmpMeasure, Nmeasure);
     222      free (tmpMeasure);
     223      break; }
     224# endif
    183225    default:
    184226      fprintf (stderr, "table format unknown (measure)\n");
    … …  
    221263    return (secfilt);
    222264  }
     265  if (!strcmp (extname, "DVO_SECFILT_PANSTARRS_DEV_0")) {
     266    SecFiltPanstarrs_DEV_0 *tmpSecFilt;
     267    tmpSecFilt = gfits_table_get_SecFiltPanstarrs_DEV_0 (ftable, Nsecfilt, NULL);
     268    secfilt = SecFiltPanstarrs_DEV_0_ToInternal (tmpSecFilt, *Nsecfilt);
     269    free (tmpSecFilt);
     270    *format = DVO_FORMAT_PANSTARRS_DEV_0;
     271    return (secfilt);
     272  }
     273# if 0
    223274  if (!strcmp (extname, "DVO_SECFILT_PANSTARRS") || !strcmp (extname, "DVO_SECFILT_PMTEST")) {
    224275    SecFiltPanstarrs *tmpSecFilt;
    … …  
    229280    return (secfilt);
    230281  }
     282# endif
    231283
    232284  fprintf (stderr, "table format unknown: %s\n", extname);
    … …  
    238290int SecFiltToFtable (FTable *ftable, SecFilt *secfilt, int Nsecfilt, int format) {
    239291
    240   SecFiltElixir *tmpSecFiltElixir;
    241   SecFiltLoneos *tmpSecFiltLoneos;
    242   SecFiltPanstarrs *tmpSecFiltPanstarrs;
    243 
    244292  /* convert from the internal format */
    245293  switch (format) {
    246     case DVO_FORMAT_INTERNAL:
     294    case DVO_FORMAT_INTERNAL: {
    247295      gfits_table_set_SecFilt (ftable, secfilt, Nsecfilt);
    248       break;
    249     case DVO_FORMAT_ELIXIR:
    250       tmpSecFiltElixir = SecFiltInternalToElixir (secfilt, Nsecfilt);
    251       gfits_table_set_SecFiltElixir (ftable, tmpSecFiltElixir, Nsecfilt);
    252       free (tmpSecFiltElixir);
    253       break;
    254     case DVO_FORMAT_LONEOS:
    255       tmpSecFiltLoneos = SecFiltInternalToLoneos (secfilt, Nsecfilt);
    256       gfits_table_set_SecFiltLoneos (ftable, tmpSecFiltLoneos, Nsecfilt);
    257       free (tmpSecFiltLoneos);
    258       break;
    259     case DVO_FORMAT_PANSTARRS:
    260     case DVO_FORMAT_PMTEST:
    261       tmpSecFiltPanstarrs = SecFiltInternalToPanstarrs (secfilt, Nsecfilt);
    262       gfits_table_set_SecFiltPanstarrs (ftable, tmpSecFiltPanstarrs, Nsecfilt);
    263       free (tmpSecFiltPanstarrs);
    264       break;
     296      break; }
     297    case DVO_FORMAT_ELIXIR: {
     298      SecFiltElixir *tmpSecFilt;
     299      tmpSecFilt = SecFiltInternalToElixir (secfilt, Nsecfilt);
     300      gfits_table_set_SecFiltElixir (ftable, tmpSecFilt, Nsecfilt);
     301      free (tmpSecFilt);
     302      break; }
     303    case DVO_FORMAT_LONEOS: {
     304      SecFiltLoneos *tmpSecFilt;
     305      tmpSecFilt = SecFiltInternalToLoneos (secfilt, Nsecfilt);
     306      gfits_table_set_SecFiltLoneos (ftable, tmpSecFilt, Nsecfilt);
     307      free (tmpSecFilt);
     308      break; }
     309    case DVO_FORMAT_PANSTARRS_DEV_0: {
     310      SecFiltPanstarrs_DEV_0 *tmpSecFilt;
     311      tmpSecFilt = SecFiltInternalToPanstarrs_DEV_0 (secfilt, Nsecfilt);
     312      gfits_table_set_SecFiltPanstarrs_DEV_0 (ftable, tmpSecFilt, Nsecfilt);
     313      free (tmpSecFilt);
     314      break; }
     315# if 0
     316    case DVO_FORMAT_PANSTARRS: {
     317      SecFiltPanstarrs *tmpSecFilt;
     318      tmpSecFilt = SecFiltInternalToPanstarrs (secfilt, Nsecfilt);
     319      gfits_table_set_SecFiltPanstarrs (ftable, tmpSecFilt, Nsecfilt);
     320      free (tmpSecFilt);
     321      break; }
     322# endif
    265323    default:
    266324      fprintf (stderr, "table format unknown (secfilt)\n");
    … …  
    278336
    279337  /* extname may be set from outside if the source is RAW not MEF */
    280   if (*format == DVO_FORMAT_ELIXIR) {
     338  if (*format == DVO_FORMAT_ELIXIR) {             // special case for ELIXIR
    281339    ImageElixir *tmpimage;
    282340    tmpimage = gfits_table_get_ImageElixir (ftable, &Nimage, NULL);
    … …  
    313371    goto set_header;
    314372  }
     373  if (!strcmp (extname, "DVO_IMAGE_PANSTARRS_DEV_0")) {
     374    ImagePanstarrs_DEV_0 *tmpimage;
     375    *format = DVO_FORMAT_PANSTARRS_DEV_0;
     376    tmpimage = gfits_table_get_ImagePanstarrs_DEV_0 (ftable, &Nimage, NULL);
     377    ftable[0].buffer = (char *) ImagePanstarrs_DEV_0_ToInternal (tmpimage, Nimage);
     378    free (tmpimage);
     379    goto set_header;
     380  }
     381# if 0
    315382  if (!strcmp (extname, "DVO_IMAGE_PANSTARRS") || !strcmp (extname, "DVO_IMAGE_PMTEST")) {
    316383    ImagePanstarrs *tmpimage;
    … …  
    321388    goto set_header;
    322389  }
     390# endif
    323391  fprintf (stderr, "table format unknown: %s\n", extname);
    324392  return (FALSE);
    … …  
    336404
    337405  int Nimage;
    338   ImageElixir *tmpImageElixir;
    339   ImageLoneos *tmpImageLoneos;
    340   ImagePanstarrs *tmpImagePanstarrs;
    341406
    342407  Nimage = theader[0].Naxis[1];
    … …  
    344409  /* convert from the internal format */
    345410  switch (format) {
    346     case DVO_FORMAT_INTERNAL:
     411    case DVO_FORMAT_INTERNAL: {
    347412      gfits_convert_Image ((Image *) ftable[0].buffer, sizeof(Image), Nimage);
    348       break;
    349     case DVO_FORMAT_ELIXIR:
    350       tmpImageElixir = ImageInternalToElixir ((Image *) ftable[0].buffer, Nimage);
     413      break; }
     414    case DVO_FORMAT_ELIXIR: {
     415      ImageElixir *tmpImage;
     416      tmpImage = ImageInternalToElixir ((Image *) ftable[0].buffer, Nimage);
    351417      free (ftable[0].buffer);
    352       gfits_table_set_ImageElixir (ftable, tmpImageElixir, Nimage);
    353       free (tmpImageElixir);
    354       break;
    355     case DVO_FORMAT_LONEOS:
    356       tmpImageLoneos = ImageInternalToLoneos ((Image *) ftable[0].buffer, Nimage);
     418      gfits_table_set_ImageElixir (ftable, tmpImage, Nimage);
     419      free (tmpImage);
     420      break; }
     421    case DVO_FORMAT_LONEOS: {
     422      ImageLoneos *tmpImage;
     423      tmpImage = ImageInternalToLoneos ((Image *) ftable[0].buffer, Nimage);
    357424      free (ftable[0].buffer);
    358       gfits_table_set_ImageLoneos (ftable, tmpImageLoneos, Nimage);
    359       free (tmpImageLoneos);
    360       break;
    361     case DVO_FORMAT_PANSTARRS:
    362     case DVO_FORMAT_PMTEST:
    363       tmpImagePanstarrs = ImageInternalToPanstarrs ((Image *) ftable[0].buffer, Nimage);
     425      gfits_table_set_ImageLoneos (ftable, tmpImage, Nimage);
     426      free (tmpImage);
     427      break; }
     428    case DVO_FORMAT_PANSTARRS_DEV_0: {
     429      ImagePanstarrs_DEV_0 *tmpImage;
     430      tmpImage = ImageInternalToPanstarrs_DEV_0 ((Image *) ftable[0].buffer, Nimage);
    364431      free (ftable[0].buffer);
    365       gfits_table_set_ImagePanstarrs (ftable, tmpImagePanstarrs, Nimage);
    366       free (tmpImagePanstarrs);
    367       break;
     432      gfits_table_set_ImagePanstarrs_DEV_0 (ftable, tmpImage, Nimage);
     433      free (tmpImage);
     434      break; }
     435# if 0
     436    case DVO_FORMAT_PANSTARRS: {
     437      ImagePanstarrs *tmpImage;
     438      tmpImage = ImageInternalToPanstarrs ((Image *) ftable[0].buffer, Nimage);
     439      free (ftable[0].buffer);
     440      gfits_table_set_ImagePanstarrs (ftable, tmpImage, Nimage);
     441      free (tmpImage);
     442      break; }
     443# endif
    368444    default:
    369445      fprintf (stderr, "table format unknown (image ftable)\n");
    … …  
    375451int ImageToVtable (VTable *vtable, Header *theader, int format) {
    376452
    377   ImageElixir *tmpImageElixir;
    378   ImageLoneos *tmpImageLoneos;
    379   ImagePanstarrs *tmpImagePanstarrs;
    380453  int i, Nrow, Nimage;
    381454
    … …  
    384457  /* convert from the internal format */
    385458  switch (format) {
    386     case DVO_FORMAT_INTERNAL:
     459    case DVO_FORMAT_INTERNAL: {
    387460      for (i = 0; i < Nrow; i++) {
    388461        gfits_convert_Image ((Image *) vtable[0].buffer[i], sizeof(Image), 1);
    389462      }
    390       return (TRUE);
    391     case DVO_FORMAT_ELIXIR:
     463      return (TRUE); }
     464    case DVO_FORMAT_ELIXIR: {
     465      ImageElixir *tmpImage;
    392466      /* convert table rows from internal to external format */
    393467      for (i = 0; i < Nrow; i++) {
    394         tmpImageElixir = ImageInternalToElixir ((Image *) vtable[0].buffer[i], 1);
    395         gfits_convert_ImageElixir (tmpImageElixir, sizeof(ImageElixir), 1);
     468        tmpImage = ImageInternalToElixir ((Image *) vtable[0].buffer[i], 1);
     469        gfits_convert_ImageElixir (tmpImage, sizeof(ImageElixir), 1);
    396470        free (vtable[0].buffer[i]);
    397         vtable[0].buffer[i] = (char *) tmpImageElixir;
     471        vtable[0].buffer[i] = (char *) tmpImage;
    398472      }
    399473
    … …  
    407481      theader[0].Naxis[1] = Nimage;
    408482      vtable[0].size = gfits_matrix_size (theader);
    409       return (TRUE);
    410     case DVO_FORMAT_LONEOS:
     483      return (TRUE); }
     484    case DVO_FORMAT_LONEOS: {
     485      ImageLoneos *tmpImage;
    411486      /* convert table rows from internal to external format */
    412487      for (i = 0; i < Nrow; i++) {
    413         tmpImageLoneos = ImageInternalToLoneos ((Image *) vtable[0].buffer[i], 1);
    414         gfits_convert_ImageLoneos (tmpImageLoneos, sizeof(ImageLoneos), 1);
     488        tmpImage = ImageInternalToLoneos ((Image *) vtable[0].buffer[i], 1);
     489        gfits_convert_ImageLoneos (tmpImage, sizeof(ImageLoneos), 1);
    415490        free (vtable[0].buffer[i]);
    416         vtable[0].buffer[i] = (char *) tmpImageLoneos;
     491        vtable[0].buffer[i] = (char *) tmpImage;
    417492      }
    418493
    … …  
    426501      theader[0].Naxis[1] = Nimage;
    427502      vtable[0].size = gfits_matrix_size (theader);
    428       return (TRUE);
    429     case DVO_FORMAT_PANSTARRS:
    430     case DVO_FORMAT_PMTEST:
     503      return (TRUE); }
     504    case DVO_FORMAT_PANSTARRS_DEV_0: {
     505      ImagePanstarrs_DEV_0 *tmpImage;
    431506      /* convert table rows from internal to external format */
    432507      for (i = 0; i < Nrow; i++) {
    433         tmpImagePanstarrs = ImageInternalToPanstarrs ((Image *) vtable[0].buffer[i], 1);
    434         gfits_convert_ImagePanstarrs (tmpImagePanstarrs, sizeof(ImagePanstarrs), 1);
     508        tmpImage = ImageInternalToPanstarrs_DEV_0 ((Image *) vtable[0].buffer[i], 1);
     509        gfits_convert_ImagePanstarrs_DEV_0 (tmpImage, sizeof(ImagePanstarrs_DEV_0), 1);
    435510        free (vtable[0].buffer[i]);
    436         vtable[0].buffer[i] = (char *) tmpImagePanstarrs;
     511        vtable[0].buffer[i] = (char *) tmpImage;
    437512      }
    438 
     513      /* convert header from old format to new format */
     514      gfits_scan (theader, "NAXIS2", "%d", 1, &Nimage);
     515      gfits_free_header (theader);
     516      gfits_table_mkheader_ImagePanstarrs_DEV_0 (theader);
     517      gfits_modify (theader, "NAXIS2", "%d", 1, Nimage);
     518      theader[0].Naxis[1] = Nimage;
     519      vtable[0].size = gfits_matrix_size (theader);
     520      return (TRUE); }
     521# if 0
     522    case DVO_FORMAT_PANSTARRS: {
     523      ImagePanstarrs *tmpImage;
     524      /* convert table rows from internal to external format */
     525      for (i = 0; i < Nrow; i++) {
     526        tmpImage = ImageInternalToPanstarrs ((Image *) vtable[0].buffer[i], 1);
     527        gfits_convert_ImagePanstarrs (tmpImage, sizeof(ImagePanstarrs), 1);
     528        free (vtable[0].buffer[i]);
     529        vtable[0].buffer[i] = (char *) tmpImage;
     530      }
    439531      /* convert header from old format to new format */
    440532      gfits_scan (theader, "NAXIS2", "%d", 1, &Nimage);
    … …  
    444536      theader[0].Naxis[1] = Nimage;
    445537      vtable[0].size = gfits_matrix_size (theader);
    446       return (TRUE);
     538      return (TRUE); }
     539# endif
    447540    default:
    448541      break;

  • trunk/Ohana/src/libdvo/src/dvo_convert_elixir.c

    r6683 r12332  
    1010
    1111  for (i = 0; i < Nvalues; i++) {
    12     out[i].dR_PS   = in[i].dR * 0.01;
    13     out[i].dD_PS   = in[i].dD * 0.01;
    14     out[i].M_PS    = in[i].M  * 0.001;
    15     out[i].dM_PS   = in[i].dM * 0.001;
    16     out[i].dt_PS      = in[i].dt * 0.001;
    17     out[i].Mcal_PS    = in[i].Mcal * 0.001;
    18     out[i].Mgal_PS    = in[i].Mgal * 0.001;
    19     out[i].airmass_PS = in[i].airmass * 0.001;
     12    out[i].dR       = in[i].dR * 0.01;
     13    out[i].dD       = in[i].dD * 0.01;
     14    out[i].M        = in[i].M  * 0.001;
     15    out[i].dM       = in[i].dM * 0.001;
     16    out[i].dt       = in[i].dt * 0.001;
     17    out[i].Mcal     = in[i].Mcal * 0.001;
     18    out[i].Mgal     = in[i].Mgal * 0.001;
     19    out[i].airmass  = in[i].airmass * 0.001;
     20    out[i].FWx      = in[i].FWx;
     21    out[i].FWy      = in[i].fwy * in[i].FWx * 0.01;
     22    out[i].theta    = in[i].theta*(0x10000 / 0x100);
     23    out[i].dophot   = in[i].dophot;
     24    out[i].photcode = in[i].source;
     25    out[i].t        = in[i].t;
     26    out[i].averef   = in[i].averef;
     27    out[i].flags    = in[i].flags;
     28   
     29    /* these can be determined if needed / desired */
     30    out[i].Xccd     = 0;
     31    out[i].Yccd     = 0;
     32    out[i].dXccd    = 0;
     33    out[i].dYccd    = 0;
     34
     35    /* these do not have a corresponding value */
     36    out[i].stargal  = 0;
     37    out[i].Sky      = 0;
     38    out[i].dSky     = 0;
     39    out[i].qPSF     = 0;
     40
     41    /* XXX add these later */
     42    out[i].detID_hi = 0;
     43    out[i].detID_lo = 0;
     44    out[i].imageID_hi = 0;
     45    out[i].imageID_lo = 0;
     46  }
     47  return (out);
     48}
     49
     50/* convert internal measures to elixir-format measures */
     51MeasureElixir *MeasureInternalToElixir (Measure *in, int Nvalues) {
     52
     53  int i;
     54  MeasureElixir *out;
     55
     56  ALLOCATE (out, MeasureElixir, Nvalues);
     57
     58  for (i = 0; i < Nvalues; i++) {
     59    out[i].dR      = in[i].dR * 100.0;
     60    out[i].dD      = in[i].dD * 100.0;
     61    out[i].M       = in[i].M  * 1000.0;
     62    out[i].dM      = in[i].dM * 1000.0;
     63    out[i].dt      = in[i].dt * 1000.0;
     64    out[i].Mcal    = in[i].Mcal * 1000.0;
     65    out[i].Mgal    = in[i].Mgal * 1000.0;
     66    out[i].airmass = in[i].airmass * 1000.0;
    2067    out[i].FWx     = in[i].FWx;
    21     out[i].FWy     = in[i].fwy * in[i].FWx * 0.01;
    22     out[i].theta   = in[i].theta;
     68    out[i].fwy     = in[i].FWy * 100.0 / in[i].FWx;
     69    out[i].theta   = in[i].theta*(0x100/ 0x10000);
    2370    out[i].dophot  = in[i].dophot;
    24     out[i].source  = in[i].source;
     71    out[i].source  = in[i].photcode;
    2572    out[i].t       = in[i].t;
    2673    out[i].averef  = in[i].averef;
    … …  
    3077}
    3178
    32 /* convert internal measures to elixir-format measures */
    33 MeasureElixir *MeasureInternalToElixir (Measure *in, int Nvalues) {
    34 
    35   int i;
    36   MeasureElixir *out;
    37 
    38   ALLOCATE (out, MeasureElixir, Nvalues);
    39 
    40   for (i = 0; i < Nvalues; i++) {
    41     out[i].dR      = in[i].dR_PS * 100.0;
    42     out[i].dD      = in[i].dD_PS * 100.0;
    43     out[i].M       = in[i].M_PS  * 1000.0;
    44     out[i].dM      = in[i].dM_PS * 1000.0;
    45     out[i].dt      = in[i].dt_PS * 1000.0;
    46     out[i].Mcal    = in[i].Mcal_PS * 1000.0;
    47     out[i].Mgal    = in[i].Mgal_PS * 1000.0;
    48     out[i].airmass = in[i].airmass_PS * 1000.0;
    49     out[i].FWx     = in[i].FWx;
    50     out[i].fwy     = 100.0 * in[i].FWy / in[i].FWx;
    51     out[i].theta   = in[i].theta;
    52     out[i].dophot  = in[i].dophot;
    53     out[i].source  = in[i].source;
    54     out[i].t       = in[i].t;
    55     out[i].averef  = in[i].averef;
    56     out[i].flags   = in[i].flags;
    57   }
    58   return (out);
    59 }
    60 
    6179/* convert elixir-format averages to internal averages */
    62 Average *AverageElixirToInternal (AverageElixir *in, int Nvalues) {
     80Average *AverageElixirToInternal (AverageElixir *in, int Nvalues, SecFilt **primary) {
    6381
    6482  int i;
    … …  
    6684
    6785  ALLOCATE (out, Average, Nvalues);
     86  ALLOCATE (*primary, SecFilt, Nvalues);
    6887
    6988  for (i = 0; i < Nvalues; i++) {
    7089    out[i].R       = in[i].R;     
    7190    out[i].D       = in[i].D;     
    72     out[i].M       = in[i].M  * 0.001;     
    73     out[i].dM      = in[i].dM * 0.001;     
    7491    out[i].Xp      = in[i].Xp;     
    75     out[i].Xm      = in[i].Xm;     
    7692    out[i].Nm      = in[i].Nm;     
    7793    out[i].Nn      = in[i].Nn;     
    … …  
    7995    out[i].offset  = in[i].offset;
    8096    out[i].missing = in[i].missing;
    81     out[i].Xg      = in[i].Xg;
    8297
    8398    /* these don't exist in Elixir */
    … …  
    90105    out[i].P       = 0;
    91106    out[i].dP      = 0;
     107
     108    /* XXX add these later */
     109    out[i].objID_hi = 0;
     110    out[i].objID_lo = 0;
     111
     112    primary[0][i].M  = in[i].M  * 0.001;     
     113    primary[0][i].dM = in[i].dM * 0.001;     
     114    primary[0][i].Xm = in[i].Xm;     
     115    primary[0][i].Ncode = 0;     
     116    primary[0][i].Nused = 0;
     117
     118    // XXX drop this or keep this?
     119    // primary[0][i].Xg = in[i].Xg;
    92120  }
    93121  return (out);
    … …  
    95123
    96124/* convert internal averages to elixir-format averages */
    97 AverageElixir *AverageInternalToElixir (Average *in, int Nvalues) {
     125AverageElixir *AverageInternalToElixir (Average *in, int Nvalues, SecFilt *primary) {
    98126
    99127  int i;
    … …  
    105133    out[i].R       = in[i].R;     
    106134    out[i].D       = in[i].D;     
    107     out[i].M       = in[i].M  * 1000.0;     
    108     out[i].dM      = in[i].dM * 1000.0;
    109135    out[i].Xp      = in[i].Xp;     
    110     out[i].Xm      = in[i].Xm;     
    111136    out[i].Nm      = in[i].Nm;     
    112137    out[i].Nn      = in[i].Nn;     
    … …  
    114139    out[i].offset  = in[i].offset;
    115140    out[i].missing = in[i].missing;
    116     out[i].Xg      = in[i].Xg;
     141
     142    out[i].M       = primary[i].M  * 1000.0;     
     143    out[i].dM      = primary[i].dM * 1000.0;
     144    out[i].Xm      = primary[i].Xm;     
     145    // out[i].Xg      = in[i].Xg;
    117146  }
    118147  return (out);
    … …  
    128157
    129158  for (i = 0; i < Nvalues; i++) {
    130     out[i].M_PS    = in[i].M  * 0.001;     
    131     out[i].dM_PS   = in[i].dM * 0.001;     
    132     out[i].Xm      = in[i].Xm;     
     159    out[i].M     = in[i].M  * 0.001;     
     160    out[i].dM    = in[i].dM * 0.001;     
     161    out[i].Xm    = in[i].Xm;     
     162    out[i].Ncode = 0;
     163    out[i].Nused = 0;
    133164  }
    134165  return (out);
    … …  
    144175
    145176  for (i = 0; i < Nvalues; i++) {
    146     out[i].M       = in[i].M_PS  * 1000.0;     
    147     out[i].dM      = in[i].dM_PS * 1000.0;
     177    out[i].M       = in[i].M  * 1000.0;     
     178    out[i].dM      = in[i].dM * 1000.0;
    148179    out[i].Xm      = in[i].Xm;     
    149180  }
    … …  
    166197    out[i].tzero            = in[i].tzero;
    167198    out[i].nstar            = in[i].nstar;
    168     out[i].secz_PS          = in[i].secz * 0.001;
     199    out[i].secz             = in[i].secz * 0.001;
    169200    out[i].NX               = in[i].NX;
    170201    out[i].NY               = in[i].NY;
    171     out[i].apmifit_PS       = in[i].apmifit * 0.001;
    172     out[i].dapmifit_PS      = in[i].dapmifit * 0.001;
    173     out[i].Mcal_PS          = in[i].Mcal * 0.001;
    174     out[i].dMcal_PS         = in[i].dMcal * 0.001;
     202    out[i].apmifit          = in[i].apmifit * 0.001;
     203    out[i].dapmifit         = in[i].dapmifit * 0.001;
     204    out[i].Mcal             = in[i].Mcal * 0.001;
     205    out[i].dMcal            = in[i].dMcal * 0.001;
    175206    out[i].Xm               = in[i].Xm;
    176     out[i].source           = in[i].source;
     207    out[i].photcode         = in[i].source;
    177208    out[i].exptime          = in[i].exptime;
    178209    out[i].detection_limit  = in[i].detection_limit;
    … …  
    199230    out[i].Mxyyy            = in[i].Mxyyy;
    200231    out[i].Myyyy            = in[i].Myyyy;
     232
     233    /* XXX add these later */
     234    out[i].imageID_hi = 0;
     235    out[i].imageID_lo = 0;
    201236  }
    202237  return (out);
    … …  
    218253    out[i].tzero            = in[i].tzero;
    219254    out[i].nstar            = in[i].nstar;
    220     out[i].secz             = in[i].secz_PS * 1000.0;
     255    out[i].secz             = in[i].secz * 1000.0;
    221256    out[i].NX               = in[i].NX;
    222257    out[i].NY               = in[i].NY;
    223     out[i].apmifit          = in[i].apmifit_PS * 1000.0;
    224     out[i].dapmifit         = in[i].dapmifit_PS * 1000.0;
    225     out[i].Mcal             = in[i].Mcal_PS * 1000.0;
    226     out[i].dMcal            = in[i].dMcal_PS * 1000.0;
     258    out[i].apmifit          = in[i].apmifit * 1000.0;
     259    out[i].dapmifit         = in[i].dapmifit * 1000.0;
     260    out[i].Mcal             = in[i].Mcal * 1000.0;
     261    out[i].dMcal            = in[i].dMcal * 1000.0;
    227262    out[i].Xm               = in[i].Xm;
    228     out[i].source           = in[i].source;
     263    out[i].source           = in[i].photcode;
    229264    out[i].exptime          = in[i].exptime;
    230265    out[i].detection_limit  = in[i].detection_limit;

  • trunk/Ohana/src/libdvo/src/dvo_convert_loneos.c

    r6683 r12332  
    1010
    1111  for (i = 0; i < Nvalues; i++) {
    12     out[i].dR_PS   = in[i].dR * 0.01;
    13     out[i].dD_PS   = in[i].dD * 0.01;
    14     out[i].M_PS    = in[i].M  * 0.001;
    15     out[i].dM_PS   = in[i].dM * 0.001;
    16     out[i].Mcal_PS = in[i].Mcal * 0.001;
     12    out[i].dR   = in[i].dR * 0.01;
     13    out[i].dD   = in[i].dD * 0.01;
     14    out[i].M    = in[i].M  * 0.001;
     15    out[i].dM   = in[i].dM * 0.001;
     16    out[i].Mcal = in[i].Mcal * 0.001;
    1717    out[i].dophot  = in[i].dophot;
    18     out[i].source  = in[i].source;
     18    out[i].photcode  = in[i].source;
    1919    out[i].t       = in[i].t;
    2020
    … …  
    2424
    2525    /* these values don't exist in the Loneos format */
    26     out[i].Mgal_PS    = in[i].M;
    27     out[i].dt_PS      = 0;
    28     out[i].airmass_PS = 0;
     26    out[i].Mgal    = in[i].M;
     27    out[i].dt      = 0;
     28    out[i].airmass = 0;
    2929    out[i].FWx        = 0;
    3030    out[i].FWy        = 0;
    3131    out[i].theta      = 0;
     32    out[i].stargal  = 0;
     33    out[i].Sky      = 0;
     34    out[i].dSky     = 0;
     35    out[i].qPSF     = 0;
     36
     37    /* these can be determined if needed / desired */
     38    out[i].Xccd     = 0;
     39    out[i].Yccd     = 0;
     40    out[i].dXccd    = 0;
     41    out[i].dYccd    = 0;
     42
     43    /* XXX add these later */
     44    out[i].detID_hi = 0;
     45    out[i].detID_lo = 0;
     46    out[i].imageID_hi = 0;
     47    out[i].imageID_lo = 0;
    3248  }
    3349  return (out);
    … …  
    4359
    4460  for (i = 0; i < Nvalues; i++) {
    45     out[i].dR     = in[i].dR_PS * 100.0;
    46     out[i].dD     = in[i].dD_PS * 100.0;
    47     out[i].M      = in[i].M_PS  * 1000.0;
    48     out[i].dM     = in[i].dM_PS * 1000.0;
    49     out[i].Mcal   = in[i].Mcal_PS * 1000.0;
     61    out[i].dR     = in[i].dR * 100.0;
     62    out[i].dD     = in[i].dD * 100.0;
     63    out[i].M      = in[i].M  * 1000.0;
     64    out[i].dM     = in[i].dM * 1000.0;
     65    out[i].Mcal   = in[i].Mcal * 1000.0;
    5066    out[i].dophot = in[i].dophot;
    51     out[i].source = in[i].source;
     67    out[i].source = in[i].photcode;
    5268    out[i].t      = in[i].t;
    5369
    … …  
    5975
    6076/* convert loneos-format averages to internal averages */
    61 Average *AverageLoneosToInternal (AverageLoneos *in, int Nvalues) {
     77Average *AverageLoneosToInternal (AverageLoneos *in, int Nvalues, SecFilt **primary) {
    6278
    6379  int i;
    … …  
    6581
    6682  ALLOCATE (out, Average, Nvalues);
     83  ALLOCATE (*primary, SecFilt, Nvalues);
    6784
    6885  for (i = 0; i < Nvalues; i++) {
    6986    out[i].R       = in[i].R;     
    7087    out[i].D       = in[i].D;     
    71     out[i].M       = in[i].M * 0.001;     
    7288    out[i].Xp      = in[i].Xp;     
    73     out[i].Xm      = in[i].Xm;     
    7489    out[i].Nm      = in[i].Nm;     
    7590    out[i].Nn      = in[i].Nn;     
    … …  
    87102    out[i].P       = 0;
    88103    out[i].dP      = 0;
    89     out[i].dM      = 0xffff;
    90     out[i].Xg      = 0xffff;
     104
     105    /* XXX add these later */
     106    out[i].objID_hi = 0;
     107    out[i].objID_lo = 0;
     108
     109    primary[0][i].M  = in[i].M  * 0.001;     
     110    primary[0][i].Xm = in[i].Xm;     
     111    primary[0][i].dM = 0xffff;
     112    primary[0][i].Ncode = 0;     
     113    primary[0][i].Nused = 0;
     114
     115    // XXX drop this or keep this?
     116    // primary[0][i].Xg = in[i].Xg;
    91117  }
    92118  return (out);
    … …  
    94120
    95121/* convert internal averages to loneos-format averages */
    96 AverageLoneos *AverageInternalToLoneos (Average *in, int Nvalues) {
     122AverageLoneos *AverageInternalToLoneos (Average *in, int Nvalues, SecFilt *primary) {
    97123
    98124  int i;
    … …  
    104130    out[i].R       = in[i].R;     
    105131    out[i].D       = in[i].D;     
    106     out[i].M       = in[i].M * 1000.0;     
    107132    out[i].Xp      = in[i].Xp;     
    108     out[i].Xm      = in[i].Xm;     
    109133    out[i].Nm      = in[i].Nm;     
    110134    out[i].Nn      = in[i].Nn;     
    … …  
    112136    out[i].offset  = in[i].offset;
    113137    out[i].missing = in[i].missing;
     138
     139    out[i].M       = primary[i].M * 1000.0;     
     140    out[i].Xm      = primary[i].Xm;     
    114141  }
    115142  return (out);
    … …  
    125152
    126153  for (i = 0; i < Nvalues; i++) {
    127     out[i].M_PS  = in[i].M*0.001;     
    128     out[i].dM_PS = 0xffff;
     154    out[i].M     = in[i].M*0.001;     
    129155    out[i].Xm    = in[i].Xm;     
     156    out[i].dM    = 0xffff;
     157    out[i].Ncode = 0;
     158    out[i].Nused = 0;
    130159  }
    131160  return (out);
    … …  
    141170
    142171  for (i = 0; i < Nvalues; i++) {
    143     out[i].M    = in[i].M_PS*1000.0;     
     172    out[i].M    = in[i].M*1000.0;     
    144173    out[i].Xm   = in[i].Xm;     
    145174  }
    … …  
    162191    out[i].tzero            = in[i].tzero;
    163192    out[i].nstar            = in[i].nstar;
    164     out[i].secz_PS          = in[i].secz * 0.001;
     193    out[i].secz             = in[i].secz * 0.001;
    165194    out[i].NX               = in[i].NX;
    166195    out[i].NY               = in[i].NY;
    167     out[i].apmifit_PS       = in[i].apmifit * 0.001;
    168     out[i].dapmifit_PS      = in[i].dapmifit * 0.001;
    169     out[i].Mcal_PS          = in[i].Mcal * 0.001;
    170     out[i].dMcal_PS         = in[i].dMcal * 0.001;
     196    out[i].apmifit          = in[i].apmifit * 0.001;
     197    out[i].dapmifit         = in[i].dapmifit * 0.001;
     198    out[i].Mcal     = in[i].Mcal * 0.001;
     199    out[i].dMcal            = in[i].dMcal * 0.001;
    171200    out[i].Xm               = in[i].Xm;
    172     out[i].source           = in[i].source;
     201    out[i].photcode         = in[i].source;
    173202    out[i].exptime          = in[i].exptime;
    174203    out[i].detection_limit  = in[i].detection_limit;
    … …  
    195224    out[i].Mxyyy            = in[i].Mxyyy;
    196225    out[i].Myyyy            = in[i].Myyyy;
     226
     227    /* XXX add these later */
     228    out[i].imageID_hi = 0;
     229    out[i].imageID_lo = 0;
    197230  }
    198231  return (out);
    … …  
    214247    out[i].tzero            = in[i].tzero;
    215248    out[i].nstar            = in[i].nstar;
    216     out[i].secz             = in[i].secz_PS * 1000.0;
     249    out[i].secz             = in[i].secz * 1000.0;
    217250    out[i].NX               = in[i].NX;
    218251    out[i].NY               = in[i].NY;
    219     out[i].apmifit          = in[i].apmifit_PS * 1000.0;
    220     out[i].dapmifit         = in[i].dapmifit_PS * 1000.0;
    221     out[i].Mcal             = in[i].Mcal_PS * 1000.0;
    222     out[i].dMcal            = in[i].dMcal_PS * 1000.0;
     252    out[i].apmifit          = in[i].apmifit * 1000.0;
     253    out[i].dapmifit         = in[i].dapmifit * 1000.0;
     254    out[i].Mcal             = in[i].Mcal * 1000.0;
     255    out[i].dMcal            = in[i].dMcal * 1000.0;
    223256    out[i].Xm               = in[i].Xm;
    224     out[i].source           = in[i].source;
     257    out[i].source           = in[i].photcode;
    225258    out[i].exptime          = in[i].exptime;
    226259    out[i].detection_limit  = in[i].detection_limit;

  • trunk/Ohana/src/libdvo/src/dvo_convert_panstarrs.c

    r6683 r12332  
    11# include <dvo.h>
    22
    3 /*** note that these structures are identical ***/
     3/*** XXX is this format actually used by anyone?? ***/
    44
    55/* convert panstarrs-format measures to internal measures */
    … …  
    1212
    1313  for (i = 0; i < Nvalues; i++) {
    14     out[i].dR_PS      = in[i].dR;
    15     out[i].dD_PS      = in[i].dD;
    16     out[i].M_PS       = in[i].M;
    17     out[i].dM_PS      = in[i].dM;
    18     out[i].Mcal_PS    = in[i].Mcal;
    19     out[i].Mgal_PS    = in[i].Mgal;
    20     out[i].airmass_PS = in[i].airmass;
    21     out[i].dt_PS      = in[i].dt;
     14    out[i].dR         = in[i].dR;
     15    out[i].dD         = in[i].dD;
     16    out[i].M          = in[i].M;
     17    out[i].dM         = in[i].dM;
     18    out[i].Mcal       = in[i].Mcal;
     19    out[i].Mgal       = in[i].Mgal;
     20    out[i].airmass    = in[i].airmass;
     21    out[i].dt         = in[i].dt;
    2222    out[i].FWx        = in[i].FWx;
    2323    out[i].FWy        = in[i].FWy;
    2424    out[i].theta      = in[i].theta;
    2525    out[i].dophot     = in[i].dophot;
    26     out[i].source     = in[i].source;
     26    out[i].photcode   = in[i].source;
    2727    out[i].t          = in[i].t;
    2828    out[i].averef     = in[i].averef;
    2929    out[i].flags      = in[i].flags;
     30   
     31    /* these can be determined if needed / desired */
     32    out[i].Xccd     = 0;
     33    out[i].Yccd     = 0;
     34    out[i].dXccd    = 0;
     35    out[i].dYccd    = 0;
     36
     37    /* these do not have a corresponding value */
     38    out[i].stargal  = 0;
     39    out[i].Sky      = 0;
     40    out[i].dSky     = 0;
     41    out[i].qPSF     = 0;
     42
     43    /* XXX add these later */
     44    out[i].detID_hi = 0;
     45    out[i].detID_lo = 0;
     46    out[i].imageID_hi = 0;
     47    out[i].imageID_lo = 0;
    3048  }
    3149  return (out);
    … …  
    4159
    4260  for (i = 0; i < Nvalues; i++) {
    43     out[i].dR      = in[i].dR_PS;
    44     out[i].dD      = in[i].dD_PS;
    45     out[i].M       = in[i].M_PS;
    46     out[i].dM      = in[i].dM_PS;
    47     out[i].Mcal    = in[i].Mcal_PS;
    48     out[i].Mgal    = in[i].Mgal_PS;
    49     out[i].airmass = in[i].airmass_PS;
    50     out[i].dt      = in[i].dt_PS;
     61    out[i].dR      = in[i].dR;
     62    out[i].dD      = in[i].dD;
     63    out[i].M       = in[i].M;
     64    out[i].dM      = in[i].dM;
     65    out[i].Mcal    = in[i].Mcal;
     66    out[i].Mgal    = in[i].Mgal;
     67    out[i].airmass = in[i].airmass;
     68    out[i].dt      = in[i].dt;
    5169    out[i].FWx     = in[i].FWx;
    5270    out[i].FWy     = in[i].FWy;
    5371    out[i].theta   = in[i].theta;
    5472    out[i].dophot  = in[i].dophot;
    55     out[i].source  = in[i].source;
     73    out[i].source  = in[i].photcode;
    5674    out[i].t       = in[i].t;
    5775    out[i].averef  = in[i].averef;
    … …  
    92110    out[i].P       = 0;
    93111    out[i].dP      = 0;
     112
     113    /* XXX add these later */
     114    out[i].objID_hi = 0;
     115    out[i].objID_lo = 0;
    94116  }
    95117  return (out);
    … …  
    130152
    131153  for (i = 0; i < Nvalues; i++) {
    132     out[i].M_PS    = in[i].M;     
    133     out[i].dM_PS   = in[i].dM;     
    134     out[i].Xm      = in[i].Xm;     
    135   }
     154    out[i].M    = in[i].M;     
     155    out[i].dM   = in[i].dM;     
     156    out[i].Xm      = in[i].Xm;     
     157     out[i].Ncode = 0;
     158    out[i].Nused = 0;
     159 }
    136160  return (out);
    137161}
    … …  
    146170
    147171  for (i = 0; i < Nvalues; i++) {
    148     out[i].M       = in[i].M_PS;     
    149     out[i].dM      = in[i].dM_PS;
     172    out[i].M       = in[i].M;     
     173    out[i].dM      = in[i].dM;
    150174    out[i].Xm      = in[i].Xm;     
    151175  }
    … …  
    168192    out[i].tzero            = in[i].tzero;
    169193    out[i].nstar            = in[i].nstar;
    170     out[i].secz_PS                  = in[i].secz;
     194    out[i].secz             = in[i].secz;
    171195    out[i].NX               = in[i].NX;
    172196    out[i].NY               = in[i].NY;
    173     out[i].apmifit_PS       = in[i].apmifit;
    174     out[i].dapmifit_PS      = in[i].dapmifit;
    175     out[i].Mcal_PS                  = in[i].Mcal;
    176     out[i].dMcal_PS         = in[i].dMcal;
     197    out[i].apmifit          = in[i].apmifit;
     198    out[i].dapmifit         = in[i].dapmifit;
     199    out[i].Mcal             = in[i].Mcal;
     200    out[i].dMcal            = in[i].dMcal;
    177201    out[i].Xm               = in[i].Xm;
    178     out[i].source           = in[i].source;
     202    out[i].photcode         = in[i].source;
    179203    out[i].exptime          = in[i].exptime;
    180204    out[i].detection_limit  = in[i].detection_limit;
    … …  
    201225    out[i].Mxyyy            = in[i].Mxyyy;
    202226    out[i].Myyyy            = in[i].Myyyy;
     227
     228    /* XXX add these later */
     229    out[i].imageID_hi = 0;
     230    out[i].imageID_lo = 0;
    203231  }
    204232  return (out);
    … …  
    220248    out[i].tzero            = in[i].tzero;
    221249    out[i].nstar            = in[i].nstar;
    222     out[i].secz             = in[i].secz_PS;
     250    out[i].secz             = in[i].secz;
    223251    out[i].NX               = in[i].NX;
    224252    out[i].NY               = in[i].NY;
    225     out[i].apmifit          = in[i].apmifit_PS;
    226     out[i].dapmifit         = in[i].dapmifit_PS;
    227     out[i].Mcal             = in[i].Mcal_PS;
    228     out[i].dMcal            = in[i].dMcal_PS;
     253    out[i].apmifit          = in[i].apmifit;
     254    out[i].dapmifit         = in[i].dapmifit;
     255    out[i].Mcal             = in[i].Mcal;
     256    out[i].dMcal            = in[i].dMcal;
    229257    out[i].Xm               = in[i].Xm;
    230     out[i].source           = in[i].source;
     258    out[i].source           = in[i].photcode;
    231259    out[i].exptime          = in[i].exptime;
    232260    out[i].detection_limit  = in[i].detection_limit;

  • trunk/Ohana/src/libdvo/src/dvo_convert_pmtest.c

    r6683 r12332  
    11# include <dvo.h>
     2
     3/* convert elixir-format measures to internal measures */
     4Measure *MeasureElixirToInternal (MeasureElixir *in, int Nvalues) {
     5
     6  int i;
     7  Measure *out;
     8
     9  ALLOCATE (out, Measure, Nvalues);
     10
     11  for (i = 0; i < Nvalues; i++) {
     12    out[i].dR         = in[i].dR;
     13    out[i].dD         = in[i].dD;
     14    out[i].M          = in[i].M;
     15    out[i].dM         = in[i].dM;
     16    out[i].dt         = in[i].dt;
     17    out[i].Mcal       = in[i].Mcal;
     18    out[i].Mgal       = in[i].Mgal;
     19    out[i].airmass    = in[i].airmass;
     20    out[i].FWx        = in[i].FWx;
     21    out[i].FWy        = in[i].FWy;
     22    out[i].theta      = in[i].theta;
     23    out[i].dophot     = in[i].dophot;
     24    out[i].photcode   = in[i].source;
     25    out[i].t          = in[i].t;
     26    out[i].averef     = in[i].averef;
     27    out[i].flags      = in[i].flags;
     28
     29    out[i].Xccd       = in[i].Xccd;
     30    out[i].Yccd       = in[i].Yccd;
     31    out[i].dXccd      = in[i].dXccd;
     32    out[i].dYccd      = in[i].dYccd;
     33                                           
     34    out[i].stargal    = in[i].stargal;
     35    out[i].Sky        = in[i].Sky;
     36    out[i].dSky       = in[i].dSky;
     37    out[i].qPSF       = in[i].qPSF;
     38                                           
     39    out[i].detID_hi   = in[i].detID_hi;
     40    out[i].detID_lo   = in[i].detID_lo;
     41    out[i].imageID_hi = in[i].imageID_hi;
     42    out[i].imageID_lo = in[i].imageID_lo;
     43  }
     44  return (out);
     45}
     46
     47/* convert internal measures to elixir-format measures */
     48MeasureElixir *MeasureInternalToElixir (Measure *in, int Nvalues) {
     49
     50  int i;
     51  MeasureElixir *out;
     52
     53  ALLOCATE (out, MeasureElixir, Nvalues);
     54
     55  for (i = 0; i < Nvalues; i++) {
     56    out[i].dR         = in[i].dR;
     57    out[i].dD         = in[i].dD;
     58    out[i].M          = in[i].M;
     59    out[i].dM         = in[i].dM;
     60    out[i].dt         = in[i].dt;
     61    out[i].Mcal       = in[i].Mcal;
     62    out[i].Mgal       = in[i].Mgal;
     63    out[i].airmass    = in[i].airmass;
     64    out[i].FWx        = in[i].FWx;
     65    out[i].FWy        = in[i].FWy;
     66    out[i].theta      = in[i].theta;
     67    out[i].dophot     = in[i].dophot;
     68    out[i].photcode   = in[i].source;
     69    out[i].t          = in[i].t;
     70    out[i].averef     = in[i].averef;
     71    out[i].flags      = in[i].flags;
     72
     73    out[i].Xccd       = in[i].Xccd;
     74    out[i].Yccd       = in[i].Yccd;
     75    out[i].dXccd      = in[i].dXccd;
     76    out[i].dYccd      = in[i].dYccd;
     77                                           
     78    out[i].stargal    = in[i].stargal;
     79    out[i].Sky        = in[i].Sky;
     80    out[i].dSky       = in[i].dSky;
     81    out[i].qPSF       = in[i].qPSF;
     82                                           
     83    out[i].detID_hi   = in[i].detID_hi;
     84    out[i].detID_lo   = in[i].detID_lo;
     85    out[i].imageID_hi = in[i].imageID_hi;
     86    out[i].imageID_lo = in[i].imageID_lo;
     87  }
     88  return (out);
     89}
    290
    391/* convert panstarrs-format averages to internal averages */

  • trunk/Ohana/src/libdvo/src/dvo_image.c

    r9632 r12332  
    187187  gfits_modify (&db[0].header, "ZERO_PT", "%lf", 1, ZeroPoint);
    188188
    189   if (db[0].format == DVO_FORMAT_INTERNAL)  gfits_modify (&db[0].header, "FORMAT", "%s", 1, "INTERNAL");
    190   if (db[0].format == DVO_FORMAT_LONEOS)    gfits_modify (&db[0].header, "FORMAT", "%s", 1, "LONEOS");
    191   if (db[0].format == DVO_FORMAT_ELIXIR)    gfits_modify (&db[0].header, "FORMAT", "%s", 1, "ELIXIR");
    192   if (db[0].format == DVO_FORMAT_PANSTARRS) gfits_modify (&db[0].header, "FORMAT", "%s", 1, "PANSTARRS");
    193   if (db[0].format == DVO_FORMAT_PMTEST)    gfits_modify (&db[0].header, "FORMAT", "%s", 1, "PMTEST");
     189  if (db[0].format == DVO_FORMAT_INTERNAL)        gfits_modify (&db[0].header, "FORMAT", "%s", 1, "INTERNAL");
     190  if (db[0].format == DVO_FORMAT_LONEOS)          gfits_modify (&db[0].header, "FORMAT", "%s", 1, "LONEOS");
     191  if (db[0].format == DVO_FORMAT_ELIXIR)          gfits_modify (&db[0].header, "FORMAT", "%s", 1, "ELIXIR");
     192  if (db[0].format == DVO_FORMAT_PANSTARRS_DEV_0) gfits_modify (&db[0].header, "FORMAT", "%s", 1, "PANSTARRS_DEV_0");
     193  // if (db[0].format == DVO_FORMAT_PANSTARRS)    gfits_modify (&db[0].header, "FORMAT", "%s", 1, "PANSTARRS");
     194  // if (db[0].format == DVO_FORMAT_PMTEST)       gfits_modify (&db[0].header, "FORMAT", "%s", 1, "PMTEST");
    194195 
    195196  return;

  • trunk/Ohana/src/libdvo/src/dvo_image_raw.c

    r7080 r12332  
    2020  db[0].format = DVO_FORMAT_UNDEF;
    2121  if (gfits_scan (&db[0].header, "FORMAT",  "%s", 1, format)) {
    22     if (!strcmp (format, "INTERNAL")) db[0].format = DVO_FORMAT_INTERNAL;
    23     if (!strcmp (format, "LONEOS")) db[0].format = DVO_FORMAT_LONEOS;
    24     if (!strcmp (format, "ELIXIR")) db[0].format = DVO_FORMAT_ELIXIR;
    25     if (!strcmp (format, "PANSTARRS")) db[0].format = DVO_FORMAT_PANSTARRS;
    26     if (!strcmp (format, "PMTEST")) db[0].format = DVO_FORMAT_PANSTARRS;
     22    db[0].format = dvo_catalog_catformat (format);
    2723    if (db[0].format != DVO_FORMAT_UNDEF) goto got_format;
    2824  }
    2925  if (gfits_scan (&db[0].header, "TELESCOP",  "%s", 1, telescope)) {
    3026    if (!strncmp (telescope, "LONEOS", strlen("LONEOS"))) {
    31       db[0].format = DVO_FORMAT_LONEOS;
     27      db[0].format = DVO_FORMAT_LONEOS; // special case for LONEOS
    3228      goto got_format;
    3329    }
    3430    if (!strncmp (telescope, "1.3m McGraw-Hill", strlen("1.3m McGraw-Hill"))) {
    35       db[0].format = DVO_FORMAT_ELIXIR;
     31      db[0].format = DVO_FORMAT_ELIXIR; // special case for ELIXIR
    3632      goto got_format;
    3733    }
    … …  
    5147  /* get datatype size */
    5248  ImageSize = 0;
    53   if (db[0].format == DVO_FORMAT_INTERNAL)  ImageSize = sizeof(Image);
    54   if (db[0].format == DVO_FORMAT_LONEOS)    ImageSize = sizeof(ImageLoneos);
    55   if (db[0].format == DVO_FORMAT_ELIXIR)    ImageSize = sizeof(ImageElixir);
    56   if (db[0].format == DVO_FORMAT_PANSTARRS) ImageSize = sizeof(ImagePanstarrs);
     49  if (db[0].format == DVO_FORMAT_INTERNAL)        ImageSize = sizeof(Image);
     50  if (db[0].format == DVO_FORMAT_LONEOS)          ImageSize = sizeof(ImageLoneos);
     51  if (db[0].format == DVO_FORMAT_ELIXIR)          ImageSize = sizeof(ImageElixir);
     52  if (db[0].format == DVO_FORMAT_PANSTARRS)       ImageSize = sizeof(ImagePanstarrs);
     53  if (db[0].format == DVO_FORMAT_PANSTARRS_DEV_0) ImageSize = sizeof(ImagePanstarrs_DEV_0);
    5754
    5855  /* check that filesize makes sense */
    … …  
    7269  db[0].ftable.header = &db[0].theader;
    7370
    74   if (db[0].format == DVO_FORMAT_INTERNAL)  gfits_table_mkheader_Image (&db[0].theader);
    75   if (db[0].format == DVO_FORMAT_LONEOS)    gfits_table_mkheader_ImageLoneos (&db[0].theader);
    76   if (db[0].format == DVO_FORMAT_ELIXIR)    gfits_table_mkheader_ImageElixir (&db[0].theader);
    77   if (db[0].format == DVO_FORMAT_PANSTARRS) gfits_table_mkheader_ImagePanstarrs (&db[0].theader);
     71  if (db[0].format == DVO_FORMAT_INTERNAL)        gfits_table_mkheader_Image (&db[0].theader);
     72  if (db[0].format == DVO_FORMAT_LONEOS)          gfits_table_mkheader_ImageLoneos (&db[0].theader);
     73  if (db[0].format == DVO_FORMAT_ELIXIR)          gfits_table_mkheader_ImageElixir (&db[0].theader);
     74  if (db[0].format == DVO_FORMAT_PANSTARRS)       gfits_table_mkheader_ImagePanstarrs (&db[0].theader);
     75  if (db[0].format == DVO_FORMAT_PANSTARRS_DEV_0) gfits_table_mkheader_ImagePanstarrs_DEV_0 (&db[0].theader);
    7876   
    7977  /* read data from file */

  • trunk/Ohana/src/libdvo/src/photfits.c

    r5241 r12332  
    6161  switch (image[0].order) {
    6262  case 0:
    63     c[0] = image[0].Mcal_PS;
    64     return;
    65   case 1:
    66     c[0] = image[0].Mcal_PS;
     63    c[0] = image[0].Mcal;
     64    return;
     65  case 1:
     66    c[0] = image[0].Mcal;
    6767    c[1] = getMi (image[0].Mx);
    6868    c[2] = getMi (image[0].My);
    6969    return;
    7070  case 2:
    71     c[0] = image[0].Mcal_PS;
     71    c[0] = image[0].Mcal;
    7272    c[1] = getMi (image[0].Mx);
    7373    c[2] = getMi (image[0].Mxx);
    … …  
    7777    return;
    7878  case 3:
    79     c[0] = image[0].Mcal_PS;
     79    c[0] = image[0].Mcal;
    8080    c[1] = getMi (image[0].Mx);
    8181    c[2] = getMi (image[0].Mxx);
    … …  
    8989    return;
    9090  case 4:
    91     c[0] = image[0].Mcal_PS;
     91    c[0] = image[0].Mcal;
    9292    c[1] = getMi (image[0].Mx);
    9393    c[2] = getMi (image[0].Mxx);
    … …  
    117117  switch (order) {
    118118  case 0:
    119     image[0].Mcal_PS = c[0];
    120     return;
    121   case 1:
    122     image[0].Mcal_PS = c[0];
     119    image[0].Mcal = c[0];
     120    return;
     121  case 1:
     122    image[0].Mcal = c[0];
    123123    image[0].Mx    = putMi(c[1]);
    124124    image[0].My    = putMi(c[2]);
    125125    return;
    126126  case 2:
    127     image[0].Mcal_PS = c[0];
     127    image[0].Mcal = c[0];
    128128    image[0].Mx    = putMi(c[1]);
    129129    image[0].Mxx   = putMi(c[2]);
    … …  
    133133    return;
    134134  case 3:
    135     image[0].Mcal_PS = c[0];
     135    image[0].Mcal = c[0];
    136136    image[0].Mx    = putMi(c[1]);
    137137    image[0].Mxx   = putMi(c[2]);
    … …  
    145145    return;
    146146  case 4:
    147     image[0].Mcal_PS = c[0];
     147    image[0].Mcal = c[0];
    148148    image[0].Mx    = putMi(c[1]);
    149149    image[0].Mxx   = putMi(c[2]);
    … …  
    162162    return;
    163163  default:
    164     image[0].Mcal_PS = 0.0;
     164    image[0].Mcal = 0.0;
    165165    image[0].order = 0;
    166166    return;

  • trunk/Ohana/src/libdvo/src/skyregion_gsc.c

    r8386 r12332  
    209209  SkyRegion *regions;
    210210  SkyRegion tempregion;
    211   char **filename;
    212   char *tempfile;
     211  char *tempfile = NULL;
     212  char **filename = NULL;
    213213 
    214214  N = table[0].Nregions;
Note: See TracChangeset for help on using the changeset viewer.