Changeset 36533

Timestamp:

Feb 18, 2014, 2:50:41 PM (12 years ago)

Author:

eugene

Message:

merge from trunk

Location:

branches/eam_branches/ipp-20140206/Ohana/src/libdvo

Files:

• include/dvo.h (modified) (2 diffs)
• src/dbExtractAverages.c (modified) (1 diff)
• src/dvo_convert.c (modified) (1 diff)
• src/dvo_convert_PS1_V4.c (modified) (1 diff)
• src/dvo_photcode_ops.c (modified) (1 diff)

branches/eam_branches/ipp-20140206/Ohana/src/libdvo/include/dvo.h

@@ -445 +445 @@
 } MeasureTiny;
 
+/** STRUCT DEFINITION **/
+typedef struct {
+  double           R;                    // RA (decimal degrees )
+  double           D;                    // DEC (decimal degrees )
+  float            dR;                   // RA error (arcsec)
+  float            dD;                   // DEC error (arcsec)
+  float            uR;                   // RA*cos(D) proper-motion (arcsec/year)
+  float            uD;                   // DEC proper-motion (arcsec/year)
+  float            duR;                  // RA*cos(D) p-m error (arcsec/year)
+  float            duD;                  // DEC p-m error (arcsec/year)
+  float            P;                    // parallax (arcsec)
+  float            dP;                   // parallax error (arcsec)
+  float            ChiSqAve;             // astrometry analysis chisq
+  float            ChiSqPM;              // astrometry analysis chisq
+  float            ChiSqPar;             // astrometry analysis chisq
+  int              Tmean;                // mean epoch (PM,PAR ref) (unix time seconds)
+  int              Trange;               // mean epoch (PM,PAR ref) (unix time seconds)
+  float            Xp;                   // unused
+  unsigned short   Npos;                 // number of detections used for astrometry
+  unsigned short   Nmeasure;             // number of psf measurements
+  unsigned short   Nmissing;             // number of missings
+  unsigned short   Nextend;              // number of extended measurements
+  uint32_t         measureOffset;        // offset to first psf measurement
+  uint32_t         missingOffset;        // offset to first missing obs
+  uint32_t         extendOffset;         // offset to first extended measurement
+  uint32_t         flags;                // average object flags (star; ghost; etc)
+  uint32_t         photFlagsUpper;       // upper bit of 2 bit summary of per-measure photflags
+  uint32_t         photFlagsLower;       // lower bit of 2 bit summary of per-measure photflags
+  unsigned int     objID;                // unique ID for object in table
+  unsigned int     catID;                // unique ID for table in which object was first realized
+  uint64_t         extID;                // external ID for object (eg PSPS objID)
+} Average_PS1_V4alt;
+
+Average_PS1_V4alt *gfits_table_get_Average_PS1_V4alt (FTable *table, off_t *Ndata, char *swapped);
+Average *Average_PS1_V4alt_ToInternal (Average_PS1_V4alt *in, off_t Nvalues);
 
 /** STRUCT DEFINITION **/
@@ -625 +660 @@
 
 float PhotAperInst (Measure *measure);
+float PhotAperAve (PhotCode *code, Average *average, SecFilt *secfilt);
 float PhotKronInst (Measure *measure);
 float PhotKronAve (PhotCode *code, Average *average, SecFilt *secfilt);

branches/eam_branches/ipp-20140206/Ohana/src/libdvo/src/dbExtractAverages.c

@@ -243 +243 @@
           break;
 
+        case MAG_APER:
+          value.Flt = PhotAperAve (field->photcode, average, secfilt);
+          break;
+
         case MAG_KRON:
           value.Flt = PhotKronAve (field->photcode, average, secfilt);

branches/eam_branches/ipp-20140206/Ohana/src/libdvo/src/dvo_convert.c

@@ -63 +63 @@
     fprintf (stderr, "EXTNAME missing for average table\n");
     return (FALSE);
+  }
+
+  // block to convert broken tables (PS1_V4 made before the Xfix addition)
+  if (!strcmp (extname, "DVO_AVERAGE_PS1_V4") && (ftable[0].header[0].Naxis[0] == 120)) {
+    Average_PS1_V4alt *tmpAverage;
+    tmpAverage = gfits_table_get_Average_PS1_V4alt (ftable, Naverage, NULL);
+    if (!tmpAverage) {
+      fprintf (stderr, "ERROR: failed to read averages\n");
+      exit (2);
+    }
+    average = Average_PS1_V4alt_ToInternal (tmpAverage, *Naverage);
+    free (tmpAverage);
+    *format = DVO_FORMAT_PS1_V4;
+    return (average); 
   }
 

branches/eam_branches/ipp-20140206/Ohana/src/libdvo/src/dvo_convert_PS1_V4.c

@@ -647 +647 @@
 }
 
+// 'primary' is needed to conform with the API for Loneos and Elixir, but is not used
+Average *Average_PS1_V4alt_ToInternal (Average_PS1_V4alt *in, off_t Nvalues) {
+
+  off_t i;
+  Average *out;
+
+  ALLOCATE_ZERO (out, Average, Nvalues);
+
+  for (i = 0; i < Nvalues; i++) {
+    dvo_average_init (&out[i]);
+
+    out[i].R             = in[i].R;      
+    out[i].D             = in[i].D;      
+    out[i].dR            = in[i].dR;
+    out[i].dD            = in[i].dD;
+    out[i].uR            = in[i].uR;
+    out[i].uD            = in[i].uD;
+    out[i].duR           = in[i].duR;
+    out[i].duD           = in[i].duD;
+    out[i].P             = in[i].P;
+    out[i].dP            = in[i].dP;
+    out[i].ChiSqAve      = in[i].ChiSqAve;     
+    out[i].ChiSqPM       = in[i].ChiSqPM;     
+    out[i].ChiSqPar      = in[i].ChiSqPar;     
+    out[i].Tmean         = in[i].Tmean;     
+    out[i].Trange        = in[i].Trange;     
+    out[i].Npos          = in[i].Npos;     
+    out[i].Nmeasure      = in[i].Nmeasure;     
+    out[i].Nmissing      = in[i].Nmissing;     
+    out[i].Nextend       = in[i].Nextend;     
+    out[i].measureOffset = in[i].measureOffset; 
+    out[i].missingOffset = in[i].missingOffset;
+    out[i].extendOffset  = in[i].extendOffset;
+    out[i].flags         = in[i].flags;   
+    out[i].photFlagsUpper = in[i].photFlagsUpper;   
+    out[i].photFlagsLower = in[i].photFlagsLower;   
+    out[i].objID         = in[i].objID;
+    out[i].catID         = in[i].catID;
+    out[i].extID         = in[i].extID;
+  }
+  return (out);
+}
+
+/******/
+
+int gfits_convert_Average_PS1_V4alt (Average_PS1_V4alt *data, off_t size, off_t nitems) {
+
+  off_t i;
+  unsigned char *byte, tmp;
+
+  if (size != 120) { 
+    fprintf (stderr, "WARNING: mismatch in data types Average_PS1_V4alt: "OFF_T_FMT" vs %d\n",  size,  120);
+    return (FALSE);
+  }
+
+  /* provide initial values to avoid compiler warnings for non-BYTE_SWAP arch */
+  i = tmp = 0;
+  byte = NULL;
+
+# ifdef BYTE_SWAP
+  byte = (unsigned char *) data;
+  for (i = 0; i < nitems; i++, byte += 129) {
+    /** BYTE SWAP **/
+    SWAP_DBLE (0); // RA
+    SWAP_DBLE (8); // DEC
+    SWAP_WORD (16); // RA_ERR
+    SWAP_WORD (20); // DEC_ERR
+    SWAP_WORD (24); // U_RA
+    SWAP_WORD (28); // U_DEC
+    SWAP_WORD (32); // V_RA_ERR
+    SWAP_WORD (36); // V_DEC_ERR
+    SWAP_WORD (40); // PAR
+    SWAP_WORD (44); // PAR_ERR
+    SWAP_WORD (48); // CHISQ_POS
+    SWAP_WORD (52); // CHISQ_PM
+    SWAP_WORD (56); // CHISQ_PAP
+    SWAP_WORD (60); // MEAN_EPOCH
+    SWAP_WORD (64); // TIME_RANGE
+    SWAP_WORD (68); // SIGMA
+    SWAP_BYTE (72); // NUMBER_POS
+    SWAP_BYTE (74); // NMEASURE
+    SWAP_BYTE (76); // NMISSING
+    SWAP_BYTE (78); // NEXTEND
+    SWAP_WORD (80); // OFF_MEASURE
+    SWAP_WORD (84); // OFF_MISSING
+    SWAP_WORD (88); // OFF_EXTEND
+    SWAP_WORD (92); // FLAGS
+    SWAP_WORD (96); // PHOTFLAGS_U
+    SWAP_WORD (100); // PHOTFLAGS_L
+    SWAP_WORD (104); // OBJ_ID
+    SWAP_WORD (108); // CAT_ID
+    SWAP_DBLE (112); // EXT_ID
+  }
+# endif  
+
+  return (TRUE);
+} 
+
+/*** add test of EXTNAME and header-defined columns? ***/
+/* return internal structure representation */
+Average_PS1_V4alt *gfits_table_get_Average_PS1_V4alt (FTable *ftable, off_t *Ndata, char *swapped) {
+
+  int Ncols;
+  Average_PS1_V4alt *data;
+
+  Ncols = ftable[0].header[0].Naxis[0];
+  if (Ncols != 120) {
+    fprintf (stderr, "ERROR: mis-match in table size: width is %d but should be %d bytes\n", Ncols, 176);
+    return NULL;
+  }
+
+  *Ndata = ftable[0].header[0].Naxis[1];
+  data = (Average_PS1_V4alt *) ftable[0].buffer;
+  if ((swapped == NULL) || (*swapped == FALSE)) {
+    if (!gfits_convert_Average_PS1_V4alt (data, sizeof (Average_PS1_V4alt), *Ndata)) {
+      return NULL;
+    }
+    gfits_table_scale_data (ftable);
+    if (swapped != NULL) *swapped = TRUE;
+  }
+  return (data);
+}
+

branches/eam_branches/ipp-20140206/Ohana/src/libdvo/src/dvo_photcode_ops.c

@@ -561 +561 @@
 }
 
+float PhotAperAve (PhotCode *code, Average *average, SecFilt *secfilt) {
+
+  int Ns;
+  float Maper;
+
+  if (code == NULL) return NAN;
+
+  Ns = photcodes[0].hashNsec[code[0].code];
+  Maper = (Ns == -1) ? NAN : secfilt[Ns].Map;
+  return (Maper);
+}
+
 float PhotKronAve (PhotCode *code, Average *average, SecFilt *secfilt) {