IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 12011


Ignore:
Timestamp:
Feb 23, 2007, 8:04:18 AM (19 years ago)
Author:
eugene
Message:

moved all average magnitude values to secfilt

Location:
branches/dvo-mods-2007-02/Ohana/src/libdvo
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • branches/dvo-mods-2007-02/Ohana/src/libdvo/include/dvo.h

    r10931 r12011  
    232232float PhotdM (PhotCode *code, Average *average, SecFilt *secfilt);
    233233
    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);
     234float PhotColorForCode (Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code);
    248235int PhotColor (Average *average, SecFilt *secfilt, Measure *measure, int c1, int c2, double *color);
    249236
    … …  
    297284
    298285/*** conversion functions / I/O conversions ***/
    299 Average *ReadRawAverage (FILE *f, int Naverage, int format);
     286Average *ReadRawAverage (FILE *f, int Naverage, int format, SecFilt **primary);
    300287Measure *ReadRawMeasure (FILE *f, int Nmeasure, int format);
    301288SecFilt *ReadRawSecFilt (FILE *f, int Nsecfilt, int format);
    302 int WriteRawAverage (FILE *f, Average *average, int Naverage, int format);
     289int WriteRawAverage (FILE *f, Average *average, int Naverage, int format, SecFilt *primary);
    303290int WriteRawMeasure (FILE *f, Measure *measure, int Nmeasure, int format);
    304291int WriteRawSecFilt (FILE *f, SecFilt *secfilt, int Nsecfilt, int format);
    305292
    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 
     293Average *FtableToAverage (FTable *ftable, int *Naverage, int *format, SecFilt **primary);
    316294Measure *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 
    324295SecFilt *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);
     296int FtableToImage (FTable *ftable, Header *theader, int *format);
     297
     298int AverageToFtable (FTable *ftable, Average *average, int Naverage, int format, SecFilt *primary);
    333299int MeasureToFtable (FTable *ftable, Measure *measure, int Nmeasure, int format);
    334300int SecFiltToFtable (FTable *ftable, SecFilt *secfilt, int Nsecfilt, int format);
     301int ImageToFtable (FTable *ftable, Header *theader, int format);
     302int ImageToVtable (VTable *vtable, Header *theader, int format);
     303
     304Image            *ImageElixirToInternal (ImageElixir *in, int Nvalues);
     305Image            *ImageLoneosToInternal (ImageLoneos *in, int Nvalues);
     306Image            *ImagePanstarrsToInternal (ImagePanstarrs *in, int Nvalues);
     307
     308ImageElixir      *ImageInternalToElixir (Image *in, int Nvalues);
     309ImageLoneos      *ImageInternalToLoneos (Image *in, int Nvalues);
     310ImagePanstarrs   *ImageInternalToPanstarrs (Image *in, int Nvalues);
     311
     312Average          *AverageLoneosToInternal (AverageLoneos *in, int Nvalues, SecFilt **primary);
     313Average          *AverageElixirToInternal (AverageElixir *in, int Nvalues, SecFilt **primary);
     314Average          *AveragePMtestToInternal (AveragePMtest *in, int Nvalues);
     315Average          *AveragePanstarrsToInternal (AveragePanstarrs *in, int Nvalues);
     316
     317AverageLoneos    *AverageInternalToLoneos (Average *in, int Nvalues, SecFilt *primary);
     318AverageElixir    *AverageInternalToElixir (Average *in, int Nvalues, SecFilt *primary);
     319AveragePMtest    *AverageInternalToPMtest (Average *in, int Nvalues);
     320AveragePanstarrs *AverageInternalToPanstarrs (Average *in, int Nvalues);
     321
     322Measure          *MeasureLoneosToInternal (MeasureLoneos *in, int Nvalues);
     323Measure          *MeasureElixirToInternal (MeasureElixir *in, int Nvalues);
     324Measure          *MeasurePanstarrsToInternal (MeasurePanstarrs *in, int Nvalues);
     325
     326MeasureLoneos    *MeasureInternalToLoneos (Measure *in, int Nvalues);
     327MeasureElixir    *MeasureInternalToElixir (Measure *in, int Nvalues);
     328MeasurePanstarrs *MeasureInternalToPanstarrs (Measure *in, int Nvalues);
     329
     330SecFilt          *SecFiltLoneosToInternal (SecFiltLoneos *in, int Nvalues);
     331SecFilt          *SecFiltElixirToInternal (SecFiltElixir *in, int Nvalues);
     332SecFilt          *SecFiltPanstarrsToInternal (SecFiltPanstarrs *in, int Nvalues);
     333
     334SecFiltLoneos    *SecFiltInternalToLoneos (SecFilt *in, int Nvalues);
     335SecFiltElixir    *SecFiltInternalToElixir (SecFilt *in, int Nvalues);
     336SecFiltPanstarrs *SecFiltInternalToPanstarrs (SecFilt *in, int Nvalues);
    335337
    336338/*** DVO image db I/O Functions ***/
    … …  
    345347int dvo_image_addrows (FITS_DB *db, Image *new, int Nnew);
    346348void 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);
    357349
    358350/* skyregion APIs */

  • branches/dvo-mods-2007-02/Ohana/src/libdvo/src/LoadPhotcodes.c

    r12008 r12011  
    33# define NCTERMS 4
    44# define F 0.001
    5 # define NO_MAG 100.0
     5/* # define NO_MAG 100.0 */
    66
    77static PhotCodeData *photcodes = NULL;
    … …  
    380380}
    381381
    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 
    485382/******** internal photometry conversions (keeps values in short int millimags) *********/
    486383float PhotInst (Measure *measure) {
    … …  
    539436
    540437  /* for DEP, color must be made of PRI/SEC */
    541   mc = iPhotColor (average, secfilt, NULL, code);
     438  mc = PhotColorForCode (average, secfilt, NULL, code);
    542439  if (mc == NO_MAG) return (Mcat);
    543440  mc = mc - F*code[0].dX;
    … …  
    570467
    571468  /* for DEP, color must be made of PRI/SEC */
    572   mc = iPhotColor (average, secfilt, NULL, code);
     469  mc = PhotColorForCode (average, secfilt, NULL, code);
    573470  if (mc == NO_MAG) return (Mrel);
    574471  mc = mc - F*code[0].dX;
    … …  
    606503  Mcal = PhotRel (thisone, average, secfilt) + F*code[0].C;
    607504
    608   mc = iPhotColor (average, secfilt, measure, code);
     505  mc = PhotColorForCode (average, secfilt, measure, code);
    609506  if (mc == NO_MAG) return (Mcal);
    610507  mc = mc - F*code[0].dX;
    … …  
    621518
    622519/* color term may not use DEP magnitude */
    623 float iPhotColor (Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code) {
     520float PhotColorForCode (Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code) {
    624521
    625522  int i, Ns1, Ns2, Ns;
    … …  
    633530    Ns2 = photcodes[0].hashNsec[code[0].c2];
    634531 
    635     m1 = (Ns1 == -1) ? average[0].M : secfilt[Ns1].M;
    636     m2 = (Ns2 == -1) ? average[0].M : secfilt[Ns2].M;
     532    m1 = (Ns1 == -1) ? NO_MAG : secfilt[Ns1].M;
     533    m2 = (Ns2 == -1) ? NO_MAG : secfilt[Ns2].M;
    637534    mc = ((m1 == NO_MAG) || (m2 == NO_MAG)) ? NO_MAG : (m1 - m2);
    638535    return (mc);
    … …  
    650547  } else {
    651548    Ns = photcodes[0].hashNsec[color[0].code];
    652     m1 = (Ns == -1) ? average[0].M : secfilt[Ns].M;
     549    m1 = (Ns == -1) ? NO_MAG : secfilt[Ns].M;
    653550  }     
    654551
    … …  
    664561  } else {
    665562    Ns = photcodes[0].hashNsec[color[0].code];
    666     m2 = (Ns == -1) ? average[0].M : secfilt[Ns].M;
     563    m2 = (Ns == -1) ? NO_MAG : secfilt[Ns].M;
    667564  }     
    668565  mc = ((m1 == NO_MAG) || (m2 == NO_MAG)) ? NO_MAG : (m1 - m2);
    … …  
    678575
    679576  Ns = photcodes[0].hashNsec[code[0].code];
    680   Mave = (Ns == -1) ? average[0].M : secfilt[Ns].M;
     577  Mave = (Ns == -1) ? NO_MAG : secfilt[Ns].M;
    681578  Mref = Mave + F*code[0].C;
    682579
    683   mc = iPhotColor (average, secfilt, measure, code);
     580  mc = PhotColorForCode (average, secfilt, measure, code);
    684581  if (mc == NO_MAG) return (Mref);
    685582  mc = mc - F*code[0].dX;
    … …  
    702599
    703600  Ns = photcodes[0].hashNsec[code[0].code];
    704   Mave = (Ns == -1) ? average[0].M : secfilt[Ns].M;
     601  Mave = (Ns == -1) ? NO_MAG : secfilt[Ns].M;
    705602  return (Mave);
    706603}
    707604
    708 /*** note that this is NOT a wrapper around iPhotdM ***/
    709605float PhotdM (PhotCode *code, Average *average, SecFilt *secfilt) {
    710606
    … …  
    713609
    714610  Ns = photcodes[0].hashNsec[code[0].code];
    715   dM  = (Ns == -1) ? average[0].dM : secfilt[Ns].dM;
     611  dM  = (Ns == -1) ? NO_MAG : secfilt[Ns].dM;
    716612  return (dM);
    717613}
    718614
    719 /*** note that this is NOT a wrapper around iPhotXm ***/
    720615float PhotXm (PhotCode *code, Average *average, SecFilt *secfilt) {
    721616
    … …  
    725620
    726621  Ns = photcodes[0].hashNsec[code[0].code];
    727   Mi = (Ns == -1) ? average[0].Xm : secfilt[Ns].Xm;
     622  Mi = (Ns == -1) ? NO_MAG : secfilt[Ns].Xm;
    728623  Xm = (Mi == NO_MAG) ? -1.0 : pow (10.0, 0.01*Mi);
    729624  return (Xm);
    … …  
    749644  } else {
    750645    Ns = photcodes[0].hashNsec[code[0].code];
    751     M1 = (Ns == -1) ? average[0].M : secfilt[Ns].M;
     646    M1 = (Ns == -1) ? NO_MAG : secfilt[Ns].M;
    752647  }     
    753648
    … …  
    765660  } else {
    766661    Ns = photcodes[0].hashNsec[code[0].code];
    767     M2 = (Ns == -1) ? average[0].M : secfilt[Ns].M;
     662    M2 = (Ns == -1) ? NO_MAG : secfilt[Ns].M;
    768663  }     
    769664 

  • branches/dvo-mods-2007-02/Ohana/src/libdvo/src/dvo_catalog_mef.c

    r8328 r12011  
    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) || (catalog[0].catformat == DVO_FORMAT_LONEOS)) {
     201    Nallfilt = catalog[0].Nsecfilt;
     202    Nsecfilt = catalog[0].Nsecfilt - 1;
     203    Ntotal = Nsecfilt * catalog[0].Naverage;
     204    ALLOCATE (primary, SecFilt, catalog[0].Naverage);
     205    ALLOCATE (secfilt, SecFilt, Ntotal);
     206
     207    for (i = 0; i < catalog[0].Naverage; i++) {
     208      primary[i] = catalog[0].secfilt[i*Nallfilt + 0];
     209      for (j = 0; j < Nsecfilt; j++) {
     210        secfilt[i*Nsecfilt + j] = catalog[0].secfilt[i*Nallfilt + j + 1];
     211      }
     212    }           
     213  } else {
     214    primary = NULL;
     215    secfilt = catalog[0].secfilt;
     216    Nsecfilt = catalog[0].Nsecfilt;
     217  }
     218
    173219  /* write out Average table (convert to FITS table format) */
    174   AverageToFtable (&ftable, catalog[0].average, catalog[0].Naverage, catalog[0].catformat);
     220  AverageToFtable (&ftable, catalog[0].average, catalog[0].Naverage, catalog[0].catformat, primary);
    175221  if (!gfits_fwrite_Theader (catalog[0].f, &header)) {
    176222    fprintf (stderr, "can't write table header");
    … …  
    211257
    212258  /* 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);
     259  Nitems = catalog[0].Naverage * Nsecfilt;
     260  SecFiltToFtable (&ftable, secfilt, Nitems, catalog[0].catformat);
     261  if (!gfits_fwrite_Theader (catalog[0].f, &header)) {
     262    fprintf (stderr, "can't write table header");
     263    return (FALSE);
     264  }
     265  if (!gfits_fwrite_table (catalog[0].f, &ftable)) {
     266    fprintf (stderr, "can't write table data");
     267    return (FALSE);
     268  }
     269  gfits_free_table (&ftable);
     270  gfits_free_header (&header);
     271
     272  /* free temp storage */
     273  if (primary != NULL) {
     274    free (primary);
     275    free (secfilt);
     276  }
    225277
    226278  return (TRUE);
    … …  
    228280
    229281/*
    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
     282  catalog data is:
     283  header (bitpix == 8)
     284  matrix (empty)
     285  average header
     286  average table
     287  measure header
     288  measure table
     289  missing header
     290  missing table
     291  secfilt header
     292  secfilt table
    241293*/
    242294   

  • branches/dvo-mods-2007-02/Ohana/src/libdvo/src/dvo_catalog_raw.c

    r12008 r12011  
    1212  struct stat filestatus;
    1313  char format[80], telescope[80];
     14  SecFilt *primary;
    1415
    1516  f = catalog[0].f;
    … …  
    122123
    123124  /* read and convert the averages (use a macro to clean this up?) */
     125  /* old versions of DVO stored one of the average magnitudes in Average. we save this if needed */
    124126  if (catalog[0].catflags & LOAD_AVES) {
    125     catalog[0].average = ReadRawAverage (catalog[0].f, catalog[0].Naverage, catalog[0].catformat);
     127    catalog[0].average = ReadRawAverage (catalog[0].f, catalog[0].Naverage, catalog[0].catformat, &primary);
    126128  } else {
    127129    /* skip over averages */
    … …  
    159161    Nitems = catalog[0].Naverage * catalog[0].Nsecfilt;
    160162    catalog[0].secfilt = ReadRawSecFilt (catalog[0].f, Nitems, catalog[0].catformat);
     163
     164    /* if primary is defined, we were supplied with one additional average magnitude from Average
     165       we need to interleave these magnitudes with the secfilt entries just loaded */
     166    if (primary != NULL) {
     167      int Ntmpfilt, Nsecfilt, Ntotal, i, j;
     168      SecFilt *tmpfilt;
     169      tmpfilt  = catalog[0].secfilt;
     170      Ntmpfilt = catalog[0].Nsecfilt;
     171      Nsecfilt = catalog[0].Nsecfilt + 1;
     172      Ntotal = Nsecfilt * catalog[0].Naverage;
     173      ALLOCATE (catalog[0].secfilt, SecFilt, Ntotal);
     174      for (i = 0; i < catalog[0].Naverage; i++) {
     175        catalog[0].secfilt[i*Nsecfilt + 0] = primary[i];
     176        for (j = 0; j < Ntmpfilt; j++) {
     177          catalog[0].secfilt[i*Nsecfilt + j + 1] = tmpfilt[i*Ntmpfilt + j];
     178        }
     179      }         
     180      catalog[0].Nsecfilt = Nsecfilt;
     181      free (primary);
     182    }
     183
    161184  } else {
    162185    /* skip over secfilts */
    163186    Nskip = catalog[0].Nsecfilt * catalog[0].Naverage * SecFiltSize;
    164187    fseek (f, Nskip, SEEK_CUR);
     188    if (primary != NULL) free (primary);
    165189  }
    166190
    … …  
    196220  int Nitems, nitems;
    197221  FILE *f;
     222  SecFilt *primary;
     223  SecFilt *secfilt;
     224  int i, j, Nsecfilt, Nallfilt, Ntotal;
    198225
    199226  if (catalog[0].Naverage == 0) {
    … …  
    227254  }
    228255
     256  /* for the appropriate types, pull out the first secfilt and pass to WriteRawAverage as primary */
     257  if ((catalog[0].catformat == DVO_FORMAT_ELIXIR) || (catalog[0].catformat == DVO_FORMAT_LONEOS)) {
     258    Nallfilt = catalog[0].Nsecfilt;
     259    Nsecfilt = catalog[0].Nsecfilt - 1;
     260    Ntotal = Nsecfilt * catalog[0].Naverage;
     261    ALLOCATE (primary, SecFilt, catalog[0].Naverage);
     262    ALLOCATE (secfilt, SecFilt, Ntotal);
     263
     264    for (i = 0; i < catalog[0].Naverage; i++) {
     265      primary[i] = catalog[0].secfilt[i*Nallfilt + 0];
     266      for (j = 0; j < Nsecfilt; j++) {
     267        secfilt[i*Nsecfilt + j] = catalog[0].secfilt[i*Nallfilt + j + 1];
     268      }
     269    }           
     270  } else {
     271    primary = NULL;
     272    secfilt = catalog[0].secfilt;
     273    Nsecfilt = catalog[0].Nsecfilt;
     274  }
     275
    229276  /* write averages and measures */
    230   WriteRawAverage (f, catalog[0].average, catalog[0].Naverage, catalog[0].catformat);
     277  WriteRawAverage (f, catalog[0].average, catalog[0].Naverage, catalog[0].catformat, primary);
    231278  WriteRawMeasure (f, catalog[0].measure, catalog[0].Nmeasure, catalog[0].catformat);
    232279
    … …  
    242289  Nitems = catalog[0].Naverage * catalog[0].Nsecfilt;
    243290  WriteRawSecFilt (f, catalog[0].secfilt, Nitems, catalog[0].catformat);
     291
     292  /* free temp storage */
     293  if (primary != NULL) {
     294    free (primary);
     295    free (secfilt);
     296  }
     297
    244298  return (TRUE);
    245299}
    … …  
    252306/** Average / Raw Table conversions **/
    253307
    254 Average *ReadRawAverage (FILE *f, int Naverage, int format) {
     308Average *ReadRawAverage (FILE *f, int Naverage, int format, SecFilt **primary) {
    255309
    256310  int nitems;
    … …  
    261315  // AveragePMtest *tmpAveragePMtest;
    262316
     317  /* in the ELIXIR and LONEOS cases, we are supplied with an average magnitude in Average
     318     in these cases, save these values in primary; otherwise set primary to NULL */
     319  *primary = NULL;
     320
    263321  switch (format) {
    264322    case DVO_FORMAT_INTERNAL:
    … …  
    279337      }
    280338      gfits_convert_AverageElixir (tmpAverageElixir, sizeof(AverageElixir), Naverage);
    281       average = AverageElixirToInternal (tmpAverageElixir, Naverage);
     339      average = AverageElixirToInternal (tmpAverageElixir, Naverage, primary);
    282340      free (tmpAverageElixir);
    283341      break;
    … …  
    290348      }
    291349      gfits_convert_AverageLoneos (tmpAverageLoneos, sizeof(AverageLoneos), Naverage);
    292       average = AverageLoneosToInternal (tmpAverageLoneos, Naverage);
     350      average = AverageLoneosToInternal (tmpAverageLoneos, Naverage, primary);
    293351      free (tmpAverageLoneos);
    294352      break;
    … …  
    326384/* accepts and converts internal average formats and outputs
    327385   raw data in the specified format */
    328 int WriteRawAverage (FILE *f, Average *average, int Naverage, int format) {
     386int WriteRawAverage (FILE *f, Average *average, int Naverage, int format, SecFilt *primary) {
    329387
    330388  int nitems;
    … …  
    344402      break;
    345403    case DVO_FORMAT_ELIXIR:
    346       tmpAverageElixir = AverageInternalToElixir (average, Naverage);
     404      tmpAverageElixir = AverageInternalToElixir (average, Naverage, primary);
    347405      gfits_convert_AverageElixir (tmpAverageElixir, sizeof(AverageElixir), Naverage);
    348406      nitems = fwrite (tmpAverageElixir, sizeof(AverageElixir), Naverage, f);
    … …  
    354412      break;
    355413    case DVO_FORMAT_LONEOS:
    356       tmpAverageLoneos = AverageInternalToLoneos (average, Naverage);
     414      tmpAverageLoneos = AverageInternalToLoneos (average, Naverage, primary);
    357415      gfits_convert_AverageLoneos (tmpAverageLoneos, sizeof(AverageLoneos), Naverage);
    358416      nitems = fwrite (tmpAverageLoneos, sizeof(AverageLoneos), Naverage, f);

  • branches/dvo-mods-2007-02/Ohana/src/libdvo/src/dvo_catalog_split.c

    r8456 r12011  
    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) || (catalog[0].catformat == DVO_FORMAT_LONEOS)) {
     321    if (catalog[0].secfilt == NULL) {       
     322      fprintf (stderr, "missing secfilt, cannot build output averages (dvo_catalog_split.c:544)\n");
     323      exit (1);
     324    }
     325    secfilt = catalog[0].secfilt;
     326
     327    Nallfilt = catalog[0].Nsecfilt;
     328    Nsecfilt = catalog[0].Nsecfilt - 1;
     329    Ntotal = Nsecfilt * catalog[0].Naverage;
     330    ALLOCATE (primary, SecFilt, catalog[0].Naverage);
     331    ALLOCATE (secfilt, SecFilt, Ntotal);
     332
     333    for (i = 0; i < catalog[0].Naverage; i++) {
     334      primary[i] = secfilt[i*Nallfilt + 0];
     335      for (j = 0; j < Nsecfilt; j++) {
     336        secfilt[i*Nsecfilt + j] = catalog[0].secfilt[i*Nallfilt + j + 1];
     337      }
     338    }           
     339  } else {
     340    primary = NULL;
     341    secfilt = catalog[0].secfilt;
     342    Nsecfilt = catalog[0].Nsecfilt;
     343  }
     344
    291345  /*** Average Table ***/
    292346
    … …  
    303357
    304358    /* write out Average table (convert to FITS table format) */
    305     AverageToFtable (&ftable, catalog[0].average, catalog[0].Naverage, catalog[0].catformat);
     359    AverageToFtable (&ftable, catalog[0].average, catalog[0].Naverage, catalog[0].catformat, primary);
    306360    if (!gfits_fwrite_Theader (catalog[0].f, &header)) {
    307361      fprintf (stderr, "can't write table header");
    … …  
    317371
    318372  /*** Measure Table ***/
    319 
    320373  if (catalog[0].measure != NULL) {
    321374
    322     measure = catalog[0].measure_catalog;
     375    /* catalog file data is stored in separate structure */
     376    catfile = catalog[0].measure_catalog;
    323377
    324378    /* XXX EAM : warn about this condition; add code to handle? */
    … …  
    329383
    330384    /* rewind file pointers and truncate (file is still open) */
    331     fseek (measure[0].f, 0, SEEK_SET);
    332     ftruncate (fileno (measure[0].f), 0);
     385    fseek (catfile[0].f, 0, SEEK_SET);
     386    ftruncate (fileno (catfile[0].f), 0);
    333387
    334388    /* write table PHU header */
    335     if (!gfits_fwrite_header  (measure[0].f, &measure[0].header)) {
     389    if (!gfits_fwrite_header  (catfile[0].f, &catfile[0].header)) {
    336390      fprintf (stderr, "can't write primary header");
    337391      return (FALSE);
    … …  
    339393
    340394    /* 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)) {
     395    gfits_create_matrix (&catfile[0].header, &matrix);
     396    if (!gfits_fwrite_matrix  (catfile[0].f, &matrix)) {
    343397      fprintf (stderr, "can't write primary matrix");
    344398      return (FALSE);
    … …  
    348402    /* write out Measure table (convert to FITS table format) */
    349403    MeasureToFtable (&ftable, catalog[0].measure, catalog[0].Nmeasure, catalog[0].catformat);
    350     if (!gfits_fwrite_Theader (measure[0].f, &header)) {
     404    if (!gfits_fwrite_Theader (catfile[0].f, &header)) {
    351405      fprintf (stderr, "can't write table header");
    352406      return (FALSE);
    353407    }
    354     if (!gfits_fwrite_table (measure[0].f, &ftable)) {
     408    if (!gfits_fwrite_table (catfile[0].f, &ftable)) {
    355409      fprintf (stderr, "can't write table data");
    356410      return (FALSE);
    … …  
    361415
    362416  /*** Missing Table ***/
    363 
    364417  if (catalog[0].missing != NULL) {
    365418
    366     missing = catalog[0].missing_catalog;
     419    /* catalog data is stored in separate catalog */
     420    catfile = catalog[0].missing_catalog;
    367421
    368422    /* rewind file pointers and truncate (file is still open) */
    369     fseek (missing[0].f, 0, SEEK_SET);
    370     ftruncate (fileno (missing[0].f), 0);
     423    fseek (catfile[0].f, 0, SEEK_SET);
     424    ftruncate (fileno (catfile[0].f), 0);
    371425
    372426    /* write table PHU header */
    373     if (!gfits_fwrite_header  (missing[0].f, &missing[0].header)) {
     427    if (!gfits_fwrite_header  (catfile[0].f, &catfile[0].header)) {
    374428      fprintf (stderr, "can't write primary header");
    375429      return (FALSE);
    … …  
    377431
    378432    /* 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)) {
     433    gfits_create_matrix (&catfile[0].header, &matrix);
     434    if (!gfits_fwrite_matrix  (catfile[0].f, &matrix)) {
    381435      fprintf (stderr, "can't write primary matrix");
    382436      return (FALSE);
    … …  
    386440    /* write out Missing table (convert to FITS table format) */
    387441    gfits_table_set_Missing (&ftable, catalog[0].missing, catalog[0].Nmissing);
    388     if (!gfits_fwrite_Theader (missing[0].f, &header)) {
     442    if (!gfits_fwrite_Theader (catfile[0].f, &header)) {
    389443      fprintf (stderr, "can't write table header");
    390444      return (FALSE);
    391445    }
    392     if (!gfits_fwrite_table (missing[0].f, &ftable)) {
     446    if (!gfits_fwrite_table (catfile[0].f, &ftable)) {
    393447      fprintf (stderr, "can't write table data");
    394448      return (FALSE);
    … …  
    399453
    400454  /*** Secfilt Table ***/
    401 
    402455  if (catalog[0].secfilt != NULL) {
    403456
    404     secfilt = catalog[0].secfilt_catalog;
     457    /* catalog file data is stored in a separate catalog structure */
     458    catfile = catalog[0].secfilt_catalog;
    405459
    406460    /* rewind file pointers and truncate (file is still open) */
    407     fseek (secfilt[0].f, 0, SEEK_SET);
    408     ftruncate (fileno (secfilt[0].f), 0);
     461    fseek (catfile[0].f, 0, SEEK_SET);
     462    ftruncate (fileno (catfile[0].f), 0);
    409463
    410464    /* write table PHU header */
    411     if (!gfits_fwrite_header  (secfilt[0].f, &secfilt[0].header)) {
     465    if (!gfits_fwrite_header  (catfile[0].f, &catfile[0].header)) {
    412466      fprintf (stderr, "can't write primary header");
    413467      return (FALSE);
    … …  
    415469
    416470    /* 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)) {
     471    gfits_create_matrix (&catfile[0].header, &matrix);
     472    if (!gfits_fwrite_matrix  (catfile[0].f, &matrix)) {
    419473      fprintf (stderr, "can't write primary matrix");
    420474      return (FALSE);
    … …  
    424478    /* write out SecFilt table (convert to FITS table format) */
    425479    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)) {
     480    SecFiltToFtable (&ftable, secfilt, Nitems, catalog[0].catformat);
     481    if (!gfits_fwrite_Theader (catfile[0].f, &header)) {
    428482      fprintf (stderr, "can't write table header");
    429483      return (FALSE);
    430484    }
    431     if (!gfits_fwrite_table (secfilt[0].f, &ftable)) {
     485    if (!gfits_fwrite_table (catfile[0].f, &ftable)) {
    432486      fprintf (stderr, "can't write table data");
    433487      return (FALSE);
    … …  
    435489    gfits_free_table (&ftable);
    436490    gfits_free_header (&header);
     491  }
     492
     493  /* free temp storage */
     494  if (primary != NULL) {
     495    free (primary);
     496    free (secfilt);
    437497  }
    438498
    … …  
    453513  FTable ftable;
    454514  VTable vtable;
    455   Catalog *measure, *missing, *secfilt;
     515  Catalog *catfile;
     516  SecFilt *primary, *secfilt;
     517  int j, Nsecfilt, Nallfilt, Ntotal;
    456518
    457519  ftable.header = &header;
    … …  
    480542  }
    481543
     544  /** for the appropriate types, pull out the first secfilt and pass to AverageToFtable as primary **/
     545  if ((catalog[0].catformat == DVO_FORMAT_ELIXIR) || (catalog[0].catformat == DVO_FORMAT_LONEOS)) {
     546    if (catalog[0].secfilt == NULL) {
     547      fprintf (stderr, "missing secfilt, cannot build output averages (dvo_catalog_split.c:544)\n");
     548      exit (1);
     549    }
     550    secfilt = catalog[0].secfilt;
     551
     552    Nallfilt = catalog[0].Nsecfilt;
     553    Nsecfilt = catalog[0].Nsecfilt - 1;
     554    Ntotal = Nsecfilt * catalog[0].Naverage;
     555    ALLOCATE (primary, SecFilt, catalog[0].Naverage);
     556    ALLOCATE (secfilt, SecFilt, Ntotal);
     557
     558    for (i = 0; i < catalog[0].Naverage; i++) {
     559      primary[i] = secfilt[i*Nallfilt + 0];
     560      for (j = 0; j < Nsecfilt; j++) {
     561        secfilt[i*Nsecfilt + j] = catalog[0].secfilt[i*Nallfilt + j + 1];
     562      }
     563    }           
     564  } else {
     565    primary = NULL;
     566    secfilt = catalog[0].secfilt;
     567    Nsecfilt = catalog[0].Nsecfilt;
     568  }
     569
    482570  /*** Average Table ***/
    483 
    484571  if (catalog[0].average != NULL) {
    485572
    … …  
    492579
    493580    /* write out Average table (convert to FITS table format) */
    494     AverageToFtable (&ftable, catalog[0].average, catalog[0].Naverage, catalog[0].catformat);
     581    AverageToFtable (&ftable, catalog[0].average, catalog[0].Naverage, catalog[0].catformat, primary);
    495582    /* convert only output rows to vtable */
    496583    gfits_table_to_vtable (&ftable, &vtable, catalog[0].Nave_disk, Nout);
    … …  
    510597
    511598  /*** Measure Table ***/
    512 
    513599  if (catalog[0].measure != NULL) {
    514600
    515     measure = catalog[0].measure_catalog;
     601    catfile = catalog[0].measure_catalog;
    516602
    517603    /* 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);
     604    Nskip = catfile[0].header.size + gfits_matrix_size (&catfile[0].header);
     605    fseek (catfile[0].f, Nskip, SEEK_SET);
    520606
    521607    Ndisk  = catalog[0].Nmeas_disk;
    … …  
    547633    vtable.pad = vtable.size - Nx*Ny;
    548634
    549     if (!gfits_fwrite_Theader (measure[0].f, &header)) {
     635    if (!gfits_fwrite_Theader (catfile[0].f, &header)) {
    550636      fprintf (stderr, "can't write table header");
    551637      return (FALSE);
    552638    }
    553     if (!gfits_fwrite_vtable (measure[0].f, &vtable)) {
     639    if (!gfits_fwrite_vtable (catfile[0].f, &vtable)) {
    554640      fprintf (stderr, "can't write table data");
    555641      return (FALSE);
    … …  
    566652  if (catalog[0].missing != NULL) {
    567653
    568     missing = catalog[0].missing_catalog;
     654    catfile = catalog[0].missing_catalog;
    569655
    570656    /* rewind file pointers and truncate (file is still open) */
    571     fseek (missing[0].f, 0, SEEK_SET);
    572     ftruncate (fileno (missing[0].f), 0);
     657    fseek (catfile[0].f, 0, SEEK_SET);
     658    ftruncate (fileno (catfile[0].f), 0);
    573659
    574660    /* write table PHU header */
    575     if (!gfits_fwrite_header  (missing[0].f, &missing[0].header)) {
     661    if (!gfits_fwrite_header  (catfile[0].f, &catfile[0].header)) {
    576662      fprintf (stderr, "can't write primary header");
    577663      return (FALSE);
    … …  
    579665
    580666    /* 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)) {
     667    gfits_create_matrix (&catfile[0].header, &matrix);
     668    if (!gfits_fwrite_matrix  (catfile[0].f, &matrix)) {
    583669      fprintf (stderr, "can't write primary matrix");
    584670      return (FALSE);
    … …  
    588674    /* write out Missing table (convert to FITS table format) */
    589675    gfits_table_set_Missing (&ftable, catalog[0].missing, catalog[0].Nmissing);
    590     if (!gfits_fwrite_Theader (missing[0].f, &header)) {
     676    if (!gfits_fwrite_Theader (catfile[0].f, &header)) {
    591677      fprintf (stderr, "can't write table header");
    592678      return (FALSE);
    593679    }
    594     if (!gfits_fwrite_table (missing[0].f, &ftable)) {
     680    if (!gfits_fwrite_table (catfile[0].f, &ftable)) {
    595681      fprintf (stderr, "can't write table data");
    596682      return (FALSE);
    … …  
    601687
    602688  /*** Secfilt Table ***/
    603 
    604689  if (catalog[0].secfilt != NULL) {
    605690
    606     secfilt = catalog[0].secfilt_catalog;
     691    catfile = catalog[0].secfilt_catalog;
    607692
    608693    /* 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);
     694    Nskip = catfile[0].header.size + gfits_matrix_size (&catfile[0].header);
     695    fseek (catfile[0].f, Nskip, SEEK_SET);
    611696
    612697    /* how many lines to write out? */
    … …  
    616701    /* convert to output format FITS table */
    617702    Nitems = catalog[0].Naverage * catalog[0].Nsecfilt;
    618     SecFiltToFtable (&ftable, catalog[0].secfilt, Nitems, catalog[0].catformat);
     703    SecFiltToFtable (&ftable, secfilt, Nitems, catalog[0].catformat);
    619704    /* convert only output rows to vtable */
    620705    gfits_table_to_vtable (&ftable, &vtable, Ndisk, Nout);
    621706
    622     if (!gfits_fwrite_Theader (secfilt[0].f, &header)) {
     707    if (!gfits_fwrite_Theader (catfile[0].f, &header)) {
    623708      fprintf (stderr, "can't write table header");
    624709      return (FALSE);
    625710    }
    626     if (!gfits_fwrite_vtable (secfilt[0].f, &vtable)) {
     711    if (!gfits_fwrite_vtable (catfile[0].f, &vtable)) {
    627712      fprintf (stderr, "can't write table data");
    628713      return (FALSE);
    … …  
    631716    gfits_free_table (&ftable);
    632717    gfits_free_header (&header);
     718  }
     719
     720  /* free temp storage */
     721  if (primary != NULL) {
     722    free (primary);
     723    free (secfilt);
    633724  }
    634725

  • branches/dvo-mods-2007-02/Ohana/src/libdvo/src/dvo_convert.c

    r12008 r12011  
    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;
    … …  
    7276}
    7377
    74 int AverageToFtable (FTable *ftable, Average *average, int Naverage, int format) {
     78int AverageToFtable (FTable *ftable, Average *average, int Naverage, int format, SecFilt *primary) {
    7579
    7680  AverageElixir *tmpAverageElixir;
    … …  
    8589      break;
    8690    case DVO_FORMAT_ELIXIR:
    87       tmpAverageElixir = AverageInternalToElixir (average, Naverage);
     91      tmpAverageElixir = AverageInternalToElixir (average, Naverage, primary);
    8892      gfits_table_set_AverageElixir (ftable, tmpAverageElixir, Naverage);
    8993      free (tmpAverageElixir);
    9094      break;
    9195    case DVO_FORMAT_LONEOS:
    92       tmpAverageLoneos  = AverageInternalToLoneos (average, Naverage);
    93       gfits_table_set_AverageLoneos (ftable, tmpAverageLoneos , Naverage);
     96      tmpAverageLoneos  = AverageInternalToLoneos (average, Naverage, primary);
     97      gfits_table_set_AverageLoneos (ftable, tmpAverageLoneos, Naverage);
    9498      free (tmpAverageLoneos );
    9599      break;

  • branches/dvo-mods-2007-02/Ohana/src/libdvo/src/dvo_convert_elixir.c

    r12008 r12011  
    7878
    7979/* convert elixir-format averages to internal averages */
    80 Average *AverageElixirToInternal (AverageElixir *in, int Nvalues) {
     80Average *AverageElixirToInternal (AverageElixir *in, int Nvalues, SecFilt **primary) {
    8181
    8282  int i;
    … …  
    8484
    8585  ALLOCATE (out, Average, Nvalues);
     86  ALLOCATE (*primary, SecFilt, Nvalues);
    8687
    8788  for (i = 0; i < Nvalues; i++) {
    8889    out[i].R       = in[i].R;     
    8990    out[i].D       = in[i].D;     
    90     out[i].M       = in[i].M  * 0.001;     
    91     out[i].dM      = in[i].dM * 0.001;     
    9291    out[i].Xp      = in[i].Xp;     
    93     out[i].Xm      = in[i].Xm;     
    9492    out[i].Nm      = in[i].Nm;     
    9593    out[i].Nn      = in[i].Nn;     
    … …  
    9795    out[i].offset  = in[i].offset;
    9896    out[i].missing = in[i].missing;
    99     out[i].Xg      = in[i].Xg;
    10097
    10198    /* these don't exist in Elixir */
    … …  
    112109    out[i].objID_hi = 0;
    113110    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;
    114120  }
    115121  return (out);
    … …  
    117123
    118124/* convert internal averages to elixir-format averages */
    119 AverageElixir *AverageInternalToElixir (Average *in, int Nvalues) {
     125AverageElixir *AverageInternalToElixir (Average *in, int Nvalues, SecFilt *primary) {
    120126
    121127  int i;
    … …  
    127133    out[i].R       = in[i].R;     
    128134    out[i].D       = in[i].D;     
    129     out[i].M       = in[i].M  * 1000.0;     
    130     out[i].dM      = in[i].dM * 1000.0;
    131135    out[i].Xp      = in[i].Xp;     
    132     out[i].Xm      = in[i].Xm;     
    133136    out[i].Nm      = in[i].Nm;     
    134137    out[i].Nn      = in[i].Nn;     
    … …  
    136139    out[i].offset  = in[i].offset;
    137140    out[i].missing = in[i].missing;
    138     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;
    139146  }
    140147  return (out);

  • branches/dvo-mods-2007-02/Ohana/src/libdvo/src/dvo_convert_loneos.c

    r12008 r12011  
    7575
    7676/* convert loneos-format averages to internal averages */
    77 Average *AverageLoneosToInternal (AverageLoneos *in, int Nvalues) {
     77Average *AverageLoneosToInternal (AverageLoneos *in, int Nvalues, SecFilt **primary) {
    7878
    7979  int i;
    … …  
    8181
    8282  ALLOCATE (out, Average, Nvalues);
     83  ALLOCATE (*primary, SecFilt, Nvalues);
    8384
    8485  for (i = 0; i < Nvalues; i++) {
    8586    out[i].R       = in[i].R;     
    8687    out[i].D       = in[i].D;     
    87     out[i].M       = in[i].M * 0.001;     
    8888    out[i].Xp      = in[i].Xp;     
    89     out[i].Xm      = in[i].Xm;     
    9089    out[i].Nm      = in[i].Nm;     
    9190    out[i].Nn      = in[i].Nn;     
    … …  
    103102    out[i].P       = 0;
    104103    out[i].dP      = 0;
    105     out[i].dM      = 0xffff;
    106     out[i].Xg      = 0xffff;
    107104
    108105    /* XXX add these later */
    109106    out[i].objID_hi = 0;
    110107    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;
    111117  }
    112118  return (out);
    … …  
    114120
    115121/* convert internal averages to loneos-format averages */
    116 AverageLoneos *AverageInternalToLoneos (Average *in, int Nvalues) {
     122AverageLoneos *AverageInternalToLoneos (Average *in, int Nvalues, SecFilt *primary) {
    117123
    118124  int i;
    … …  
    124130    out[i].R       = in[i].R;     
    125131    out[i].D       = in[i].D;     
    126     out[i].M       = in[i].M * 1000.0;     
    127132    out[i].Xp      = in[i].Xp;     
    128     out[i].Xm      = in[i].Xm;     
    129133    out[i].Nm      = in[i].Nm;     
    130134    out[i].Nn      = in[i].Nn;     
    … …  
    132136    out[i].offset  = in[i].offset;
    133137    out[i].missing = in[i].missing;
     138
     139    out[i].M       = primary[i].M * 1000.0;     
     140    out[i].Xm      = primary[i].Xm;     
    134141  }
    135142  return (out);
Note: See TracChangeset for help on using the changeset viewer.