IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Sep 19, 2014, 4:05:27 PM (12 years ago)
Author:
eugene
Message:

merge changes from trunk

Location:
branches/eam_branches/ps2-tc3-20130727
Files:
29 edited
4 copied

Legend:

Unmodified
Added
Removed

  • branches/eam_branches/ps2-tc3-20130727

  • branches/eam_branches/ps2-tc3-20130727/Ohana

  • branches/eam_branches/ps2-tc3-20130727/Ohana/src/opihi/cmd.astro/cplot.c

    r34613 r37403  
    44 
    55  double ra_prev = 0;
    6   int i, kapa, Npts, status, leftside;
     6  int i, kapa, Npts, status, leftside, valid, size;
    77  opihi_flt *x, *y, *r, *d, Rmin, Rmax, Rmid;
    88  Vector Xvec, Yvec, *xvec, *yvec;
    … …  
    1111  if (!style_args (&graphmode, &argc, argv, &kapa)) return FALSE;
    1212
    13   if (argc != 3) {
     13  valid  = (argc == 3);
     14  valid |= (argc > 4) && !strcmp (argv[3], "where");
     15  if (!valid) {
    1416    gprint (GP_ERR, "USAGE: cplot <ra> <dec> [style]\n");
     17    gprint (GP_ERR, "   OR: cplot <ra> <dec> [style] where (condition)\n");
    1518    return (FALSE);
    1619  }
    … …  
    3235  }
    3336
     37  // tvec is used for logical test (truth vector)
     38  Vector *tvec = NULL;
     39  if (argc > 4) {
     40    char *out = dvomath (argc - 4, &argv[4], &size, 1);
     41    if (out == NULL) {
     42      print_error ();
     43      return FALSE;
     44    }
     45    if ((tvec = SelectVector (out, OLDVECTOR, TRUE)) == NULL) {
     46      gprint (GP_ERR, " invalid logic result\n");
     47      DeleteNamedVector (out);
     48      free (out);
     49      return (FALSE);
     50    }
     51  }
     52
     53  if (tvec && tvec[0].Nelements != yvec[0].Nelements) {
     54    gprint (GP_ERR, "logic test vector not the same length as data vectors\n");
     55    DeleteVector (tvec);
     56    return (FALSE);
     57  }
     58
    3459  SetVector (&Xvec, OPIHI_FLT, xvec[0].Nelements);
    3560  SetVector (&Yvec, OPIHI_FLT, xvec[0].Nelements);
    … …  
    4267  Npts = 0;
    4368  for (i = 0; i < Xvec.Nelements; i++, r++, d++) {
     69    if (tvec) {
     70      int skip = (tvec->type == OPIHI_FLT) ? (tvec->elements.Flt[i] == 0.0) : (tvec->elements.Int[i] == 0.0);
     71      if (skip) continue;
     72    }
     73
    4474    double ra = ohana_normalize_angle (*r);
    4575    while (ra < Rmin) ra += 360.0;
    … …  
    88118  free (Yvec.elements.Ptr);
    89119   
     120  if (tvec) DeleteVector (tvec);
     121
    90122  return (TRUE);
    91123}

  • branches/eam_branches/ps2-tc3-20130727/Ohana/src/opihi/cmd.basic/Makefile

    r35237 r37403  
    5555$(SRC)/substr.$(ARCH).o     \
    5656$(SRC)/strhash.$(ARCH).o     \
     57$(SRC)/strmatch.$(ARCH).o     \
    5758$(SRC)/strpop.$(ARCH).o     \
    5859$(SRC)/strsub.$(ARCH).o     \

  • branches/eam_branches/ps2-tc3-20130727/Ohana/src/opihi/cmd.basic/init.c

    r35237 r37403  
    4040int fprintf_opihi   PROTO((int, char **));
    4141int strlen_func     PROTO((int, char **));
     42int strmatch        PROTO((int, char **));
    4243int substr_func     PROTO((int, char **));
    4344int strpop          PROTO((int, char **));
    … …  
    9798  {1, "strpop",        strpop,             "pop a string"},
    9899  {1, "strsub",        strsub,             "replace instances of a key in a string"},
     100  {1, "strmatch",      strmatch,           "string length"},
    99101  {1, "wait",          wait_func,          "wait until return is typed"},
    100102  {1, "which",         which,              "show command *"}

  • branches/eam_branches/ps2-tc3-20130727/Ohana/src/opihi/cmd.basic/list.c

    r36680 r37403  
    22# define D_NLINES 100
    33static char prompt[] = ">> ";
    4 
    5 static int set_list_varname (char *line, char *base, int N, int excelStyle);
    64
    75int list (int argc, char **argv) {
    … …  
    311309  return (TRUE);
    312310}
    313 
    314 static int set_list_varname (char *line, char *base, int N, int excelStyle) {
    315 
    316   int i;
    317    
    318   // A-Z correspond to 0 - 25
    319 
    320   if (excelStyle) {
    321     float f = log(26.0);
    322     float g = (N == 0) ? 0.0 : log(1.0*N);
    323     int Ndigit = (int) (g / f) + 1;
    324     if (Ndigit > 10) {
    325       sprintf (line, "%s:ZZZZZZZZZZ", base);
    326       return FALSE;
    327     }
    328     char name[12];
    329     memset (name, 0, 12);
    330     for (i = 0; i < Ndigit; i++) {
    331       float Npow = Ndigit - i - 1;
    332       float g = pow(26.0, Npow);
    333       int V = (int) (N / g);
    334       name[i] = (Npow == 0.0) ? 'A' + V : 'A' + V - 1;
    335       N -= V * g;
    336     }
    337     sprintf (line, "%s:%s", base, name);
    338   } else {
    339     sprintf (line, "%s:%d", base, N);
    340   }
    341   return TRUE;
    342 }

  • branches/eam_branches/ps2-tc3-20130727/Ohana/src/opihi/cmd.data/Makefile

    r36680 r37403  
    9898$(SRC)/point.$(ARCH).o          \
    9999$(SRC)/ps.$(ARCH).o             \
     100$(SRC)/print_vectors.$(ARCH).o  \
    100101$(SRC)/queuedelete.$(ARCH).o    \
    101102$(SRC)/queuedrop.$(ARCH).o      \

  • branches/eam_branches/ps2-tc3-20130727/Ohana/src/opihi/cmd.data/init.c

    r36680 r37403  
    8787int point            PROTO((int, char **));
    8888int ps               PROTO((int, char **));
     89int print_vectors    PROTO((int, char **));
    8990int queuelist        PROTO((int, char **));
    9091int queueload        PROTO((int, char **));
    … …  
    250251  {1, "ppm",          jpeg,             "convert display graphic to PPM"},
    251252  {1, "ps",           ps,               "convert display to PostScript"},
     253  {1, "print_vectors", print_vectors,   "print a set of vectors"},
    252254  {1, "queuedelete",  queuedelete,      "delete a queue"},
    253255  {1, "queuedrop",    queuedrop,        "drop values from queue matching a key"},

  • branches/eam_branches/ps2-tc3-20130727/Ohana/src/opihi/cmd.data/read_vectors.c

    r36680 r37403  
    33FILE *f = (FILE *) NULL;
    44char filename[2048];
     5
     6void read_vectors_cleanup ();
    57
    68int datafile (int argc, char **argv) {
    … …  
    2325// vector types
    2426enum {COLTYPE_NONE, COLTYPE_FLT, COLTYPE_INT, COLTYPE_TIME, COLTYPE_CHAR};
    25 static int FITS_TRANSPOSE;
     27
     28static int      Nvec     = 0;
     29static Vector **vec      = NULL;
     30static char   **listname = NULL;
     31static int     *col      = NULL;
     32static int     *coltype  = NULL;
     33static char    *buffer   = NULL;
    2634
    2735int read_vectors (int argc, char **argv) {
    … …  
    2937  int TimeFormat;
    3038  time_t TimeReference;
    31   int i, j, Nskip, Narg, Nvec, *col, IsCSV, VERBOSE;
    32   int Nbytes, Nstart, NELEM, Nelem, nread, *coltype;
     39  int i, j, Nskip, Narg, IsCSV, VERBOSE;
     40  int Nbytes, Nstart, NELEM, Nelem, nread;
    3341  char *colstr, *c0, *c1, *extname;
    34   Vector **vec;
    35 
    36   char *buffer = NULL;
    37 
    38   FITS_TRANSPOSE = FALSE;
    39   if ((Narg = get_argument (argc, argv, "-transpose"))) {
    40     remove_argument (Narg, &argc, argv);
    41     FITS_TRANSPOSE = TRUE;
    42   }
     42  char varname[1024];  // used as a buffer for the names of string fields
    4343
    4444  /* auto-sense table type */
    … …  
    8888
    8989  Nvec = (argc - 1) / 2;
     90  ALLOCATE (listname, char *, Nvec);
    9091  ALLOCATE (vec, Vector *, Nvec);
    9192  ALLOCATE (col, int, Nvec);
    9293  ALLOCATE (coltype, int, Nvec);
     94  for (i = 0; i < Nvec; i++) {
     95    listname[i] = NULL;
     96    vec[i] = NULL;
     97  }
    9398
    9499  for (i = 0; i < Nvec; i++) {
    … …  
    115120    }
    116121
    117     if ((vec[i] = SelectVector (argv[2*i + 1], ANYVECTOR, TRUE)) == NULL) {
    118       gprint (GP_ERR, "USAGE: read name N name N ...\n");
    119       free (vec);
    120       free (col);
    121       return (FALSE);   
     122    if (coltype[i] == COLTYPE_CHAR) {
     123      listname[i] = strcreate (argv[2*i + 1]);
     124    } else {
     125      if ((vec[i] = SelectVector (argv[2*i + 1], ANYVECTOR, TRUE)) == NULL) {
     126        gprint (GP_ERR, "USAGE: read name N name N ...\n");
     127        read_vectors_cleanup();
     128        return (FALSE);   
     129      }
    122130    }
    123131
    … …  
    144152    bad_colname:
    145153      gprint (GP_ERR, "USAGE: read name N name N ...\n");
    146       free (vec);
    147       free (col);
     154      read_vectors_cleanup();
    148155      return (FALSE);   
    149156    }
    … …  
    153160  NELEM = 1000;
    154161  for (i = 0; i < Nvec; i++) {
    155     if ((coltype[i] == COLTYPE_INT) || (coltype[i] == COLTYPE_CHAR)) {
    156       ResetVector (vec[i], OPIHI_INT, NELEM);
    157     } else {
    158       // note that COLTYPE_TIME is a type of float
    159       ResetVector (vec[i], OPIHI_FLT, NELEM);
     162    switch (coltype[i]) {
     163      case COLTYPE_INT:
     164        ResetVector (vec[i], OPIHI_INT, NELEM);
     165        break;
     166      case COLTYPE_FLT:
     167      case COLTYPE_TIME:
     168        // note that COLTYPE_TIME is a type of float
     169        ResetVector (vec[i], OPIHI_FLT, NELEM);
     170        break;
     171      case COLTYPE_CHAR:
     172      default:
     173        break;
    160174    }
    161175  }
    … …  
    166180    if (scan_line_maxlen (f, buffer, 0x10000) == EOF) {
    167181      gprint (GP_ERR, "problem reading file %s\n", filename);
    168       free (vec);
    169       free (col);
     182      read_vectors_cleanup();
    170183      return FALSE;
    171184    }
    … …  
    213226      for (i = 0; i < Nvec; i++) {
    214227        int ivalue;
    215         char cvalue;
    216228        double dvalue;
    217229        time_t tvalue;
    … …  
    224236            break;
    225237          case COLTYPE_CHAR:
    226             readStatus = IsCSV ? charparse_csv (&cvalue, col[i], c0) : charparse (&cvalue, col[i], c0);
    227             vec[i][0].elements.Int[Nelem] = readStatus ? cvalue : 0;
    228             break;
     238            {
     239              // I need to get an isolated word in 'value' with the string value of this field
     240              char *ptr = IsCSV ? ptrparse_csv (col[i], c0) : ptrparse (col[i], c0);
     241              char *value = NULL;
     242              if (IsCSV) {
     243                char *end = parse_nextword_csv (ptr);
     244                if (end) {
     245                  value = end ? strncreate (ptr, end - ptr) : strcreate (ptr);
     246                }
     247              } else {
     248                value = thisword(ptr);
     249              }
     250              set_list_varname (varname, listname[i], Nelem, FALSE);
     251              set_str_variable (varname, value);
     252              free (value);
     253              break;
     254            }
    229255          case COLTYPE_FLT:
    230256            readStatus = IsCSV ? dparse_csv (&dvalue, col[i], c0) : dparse (&dvalue, col[i], c0);
    … …  
    256282        NELEM += 1000;
    257283        for (i = 0; i < Nvec; i++) {
    258           if (coltype[i] == COLTYPE_INT) {
    259             REALLOCATE (vec[i][0].elements.Int, opihi_int, NELEM);
    260           } else {
    261             REALLOCATE (vec[i][0].elements.Flt, opihi_flt, NELEM);
     284          switch (coltype[i]) {
     285            case COLTYPE_INT:
     286              ResetVector (vec[i], OPIHI_INT, NELEM);
     287              break;
     288            case COLTYPE_FLT:
     289            case COLTYPE_TIME:
     290              ResetVector (vec[i], OPIHI_FLT, NELEM);
     291              break;
     292            case COLTYPE_CHAR:
     293            default:
     294              break;
    262295          }
    263296        }
    … …  
    266299    }
    267300  }
     301  // set the final vector / list length
    268302  for (i = 0; i < Nvec; i++) {
    269     if (coltype[i] == COLTYPE_INT) {
    270       REALLOCATE (vec[i][0].elements.Int, opihi_int, MAX (Nelem,1));
    271     } else {
    272       REALLOCATE (vec[i][0].elements.Flt, opihi_flt, MAX (Nelem,1));
    273     }
    274     vec[i][0].Nelements = Nelem;
    275   }
    276  
    277   free (vec);
    278   free (col);
    279   if (buffer) free (buffer);
     303    switch (coltype[i]) {
     304      case COLTYPE_INT:
     305        ResetVector (vec[i], OPIHI_INT, Nelem);
     306        break;
     307      case COLTYPE_FLT:
     308      case COLTYPE_TIME:
     309        ResetVector (vec[i], OPIHI_FLT, Nelem);
     310        break;
     311      case COLTYPE_CHAR:
     312        sprintf (varname, "%s:n", listname[i]);
     313        set_int_variable (varname, Nelem);
     314        break;
     315      default:
     316        break;
     317    }
     318  }
     319  read_vectors_cleanup();
    280320  return (TRUE);
    281 
    282321}
    283322
    284 # define ESCAPE(MSG) { \
    285   gprint (GP_ERR, "%s\n", MSG); \
     323# define ESCAPE(...) {          \
     324  gprint (GP_ERR, __VA_ARGS__); \
    286325  if (CCDKeyword != NULL) free (CCDKeyword); \
    287326  gfits_free_table  (&table); \
    … …  
    292331
    293332  off_t Nbytes;
    294   int i, j, k, N, Nextend, Ny, Binary, vecType, padIfShort;
     333  int i, j, N, Nextend, Ny, Binary, vecType, padIfShort;
    295334  char type[16], ID[80], *CCDKeyword;
    296335  FTable table;
    297336  Header header;
    298337  Vector **vec;
     338  int FITS_TRANSPOSE;
    299339
    300340  table.buffer = NULL;
    301341  header.buffer = NULL;
     342
     343  FITS_TRANSPOSE = FALSE;
     344  if ((N = get_argument (argc, argv, "-transpose"))) {
     345    remove_argument (N, &argc, argv);
     346    FITS_TRANSPOSE = TRUE;
     347  }
    302348
    303349  CCDKeyword = NULL;
    … …  
    328374  // }
    329375
    330   if (argc < 2) ESCAPE ("USAGE: read -fits extension [-extnum] [-keyword key] name name ...");
    331 
    332   if (f == NULL) ESCAPE ("file not found");
     376  if (argc < 2) ESCAPE ("USAGE: read -fits extension [-extnum] [-keyword key] name name ...\n");
     377
     378  if (f == NULL) ESCAPE ("file not found\n");
    333379  fseeko (f, 0LL, SEEK_SET);
    334380  table.header = &header;
    … …  
    338384    // first extension is PHU, cannot be a table.
    339385    // Nextend counts from 0 for first extension
    340     if (!gfits_load_header (f, &header)) ESCAPE ("error reading primary header for file");
     386    if (!gfits_load_header (f, &header)) ESCAPE ("error reading primary header for file\n");
    341387    Nbytes = gfits_data_size (&header);
    342388    fseeko (f, Nbytes, SEEK_CUR);
    … …  
    344390
    345391    for (i = 0; i < Nextend; i++) {
    346       if (!gfits_load_header (f, &header)) ESCAPE ("extension not found");
     392      if (!gfits_load_header (f, &header)) ESCAPE ("extension %d not found\n", i);
    347393      Nbytes = gfits_data_size (&header);
    348394      /* skip the prior data buffers */
    … …  
    350396      gfits_free_header (&header);
    351397    }
    352     if (!gfits_load_header (f, &header)) ESCAPE ("error reading header for extension");
    353     if (!gfits_fread_ftable_data (f, &table, padIfShort)) ESCAPE ("error reading table for extension");
     398    if (!gfits_load_header (f, &header)) ESCAPE ("error reading header for extension %d\n", Nextend);
     399    if (!gfits_fread_ftable_data (f, &table, padIfShort)) ESCAPE ("error reading table for extension %d\n", Nextend);
    354400
    355401  } else {
    … …  
    382428        continue;
    383429      }
    384       if (!gfits_fread_ftable_data (f, &table, padIfShort)) ESCAPE ("error reading table for extension");
     430      if (!gfits_fread_ftable_data (f, &table, padIfShort)) ESCAPE ("error reading table for extension\n");
    385431      break;
    386432    }
    … …  
    391437  gfits_scan (&header, "XTENSION", "%s", 1, type);
    392438  if (strcmp (type, "BINTABLE") && strcmp (type, "TABLE")) {
    393     ESCAPE ("specified extension is not a table\n");
     439    ESCAPE ("specified extension %s is not a table\n", type);
    394440  }
    395441  Binary = !strcmp (type, "BINTABLE");
    … …  
    418464       
    419465    if (!FITS_TRANSPOSE) {
     466      // read string column into a list rather than a vector
     467      if (!strcmp (type, "char")) {
     468        char *fieldName = argv[i];
     469        char *Ptr = data;
     470        char varname[1024];  // used as a buffer for the names of string fields
     471        for (j = 0; j < Ny; j++) {
     472          set_list_varname (varname, fieldName, j, FALSE);
     473          char *value = strncreate (&Ptr[j*Nval], Nval);
     474          // replace instances of $ with _
     475          char *p = strchr (value, '$');
     476          while (p) {
     477            *p = '_';
     478            p = strchr (p, '$');
     479          }
     480          set_str_variable (varname, value);
     481          free (value);
     482        }
     483        sprintf (varname, "%s:n", fieldName);
     484        set_int_variable (varname, Ny);
     485        continue;
     486      }
     487
    420488      // define the multifield vector names (Nval vectors x Ny elements)
    421489      ALLOCATE (vec, Vector *, Nval);
    … …  
    429497      }
    430498
    431       if (!strcmp (type, "char")) {
    432         char *Ptr = data;
    433         for (j = 0; j < Ny; j++) {
    434           for (k = 0; k < Nval; k++, Ptr++) {
    435             vec[k][0].elements.Int[j] = *Ptr;
    436           }
    437         }
    438       }
    439       if (!strcmp (type, "short")) {
    440         short *Ptr = data;
    441         for (j = 0; j < Ny; j++) {
    442           for (k = 0; k < Nval; k++, Ptr++) {
    443             vec[k][0].elements.Int[j] = *Ptr;
    444           }
    445         }
    446       }
    447       if (!strcmp (type, "int")) {
    448         int *Ptr = data;
    449         for (j = 0; j < Ny; j++) {
    450           for (k = 0; k < Nval; k++, Ptr++) {
    451             vec[k][0].elements.Int[j] = *Ptr;
    452           }
    453         }
    454       }
    455       if (!strcmp (type, "int64_t")) {
    456         int64_t *Ptr = data;
    457         for (j = 0; j < Ny; j++) {
    458           for (k = 0; k < Nval; k++, Ptr++) {
    459             vec[k][0].elements.Int[j] = *Ptr;
    460           }
    461         }
    462       }
    463       if (!strcmp (type, "float")) {
    464         float *Ptr = data;
    465         for (j = 0; j < Ny; j++) {
    466           for (k = 0; k < Nval; k++, Ptr++) {
    467             vec[k][0].elements.Flt[j] = *Ptr;
    468           }
    469         }
    470       }
    471       if (!strcmp (type, "double")) {
    472         double *Ptr = data;
    473         for (j = 0; j < Ny; j++) {
    474           for (k = 0; k < Nval; k++, Ptr++) {
    475             vec[k][0].elements.Flt[j] = *Ptr;
    476           }
    477         }
    478       }
     499      if (!VectorAssignData (vec, type, data, Ny, Nval)) ESCAPE ("bad column type %s", type);
     500
    479501    } else {
    480502      // define the multifield vector names (Ny vectors x Nval elements)
    … …  
    489511      }
    490512
    491       if (!strcmp (type, "char")) {
    492         char *Ptr = data;
    493         for (j = 0; j < Ny; j++) {
    494           for (k = 0; k < Nval; k++, Ptr++) {
    495             vec[j][0].elements.Int[k] = *Ptr;
    496           }
    497         }
    498       }
    499       if (!strcmp (type, "short")) {
    500         short *Ptr = data;
    501         for (j = 0; j < Ny; j++) {
    502           for (k = 0; k < Nval; k++, Ptr++) {
    503             vec[j][0].elements.Int[k] = *Ptr;
    504           }
    505         }
    506       }
    507       if (!strcmp (type, "int")) {
    508         int *Ptr = data;
    509         for (j = 0; j < Ny; j++) {
    510           for (k = 0; k < Nval; k++, Ptr++) {
    511             vec[j][0].elements.Int[k] = *Ptr;
    512           }
    513         }
    514       }
    515       if (!strcmp (type, "int64_t")) {
    516         int64_t *Ptr = data;
    517         for (j = 0; j < Ny; j++) {
    518           for (k = 0; k < Nval; k++, Ptr++) {
    519             vec[j][0].elements.Int[k] = *Ptr;
    520           }
    521         }
    522       }
    523       if (!strcmp (type, "float")) {
    524         float *Ptr = data;
    525         for (j = 0; j < Ny; j++) {
    526           for (k = 0; k < Nval; k++, Ptr++) {
    527             vec[j][0].elements.Flt[k] = *Ptr;
    528           }
    529         }
    530       }
    531       if (!strcmp (type, "double")) {
    532         double *Ptr = data;
    533         for (j = 0; j < Ny; j++) {
    534           for (k = 0; k < Nval; k++, Ptr++) {
    535             vec[j][0].elements.Flt[k] = *Ptr;
    536           }
    537         }
    538       }
     513      if (!VectorAssignDataTranspose (vec, type, data, Ny, Nval)) ESCAPE ("bad column type %s", type);
    539514    }
    540515    free (data);
    … …  
    546521  return (TRUE);
    547522}
     523
     524void read_vectors_cleanup () {
     525
     526  int i;
     527
     528  if (col) free (col);
     529  if (coltype) free (coltype);
     530  if (buffer) free (buffer);
     531  if (listname) {
     532    for (i = 0; i < Nvec; i++) {
     533      if (listname[i]) free (listname[i]);
     534    }
     535    free (listname);
     536  }
     537  if (vec) free (vec);
     538}

  • branches/eam_branches/ps2-tc3-20130727/Ohana/src/opihi/dvo/Makefile

    r36680 r37403  
    2525$(SRC)/dvo_host_utils.$(ARCH).o         \
    2626$(SRC)/region_list.$(ARCH).o            \
    27 $(SRC)/find_matches.$(ARCH).o           \
    28 $(SRC)/photometry.$(ARCH).o             
     27$(SRC)/photcode_ops.$(ARCH).o           \
     28$(SRC)/find_matches.$(ARCH).o           
     29
     30# $(SRC)/photometry.$(ARCH).o             
     31
     32broken = \
     33$(SRC)/calextract.$(ARCH).o             \
     34$(SRC)/calmextract.$(ARCH).o            \
     35$(SRC)/ccd.$(ARCH).o                    \
     36$(SRC)/cmd.$(ARCH).o                    \
     37$(SRC)/dmagaves.$(ARCH).o               \
     38$(SRC)/dmagmeas.$(ARCH).o               \
     39$(SRC)/dmags.$(ARCH).o                  \
     40$(SRC)/ddmags.$(ARCH).o         \
     41$(SRC)/fitcolors.$(ARCH).o
    2942
    3043cmds = \
    … …  
    3245$(SRC)/avmatch.$(ARCH).o                \
    3346$(SRC)/badimages.$(ARCH).o              \
    34 $(SRC)/calextract.$(ARCH).o             \
    35 $(SRC)/calmextract.$(ARCH).o            \
    3647$(SRC)/catdir.$(ARCH).o                 \
    37 $(SRC)/ccd.$(ARCH).o                    \
    3848$(SRC)/cmatch.$(ARCH).o         \
    39 $(SRC)/cmd.$(ARCH).o                    \
    4049$(SRC)/cmpload.$(ARCH).o                \
    4150$(SRC)/cmpread.$(ARCH).o                \
    4251$(SRC)/coordimage.$(ARCH).o             \
    43 $(SRC)/ddmags.$(ARCH).o         \
     52$(SRC)/coordmosaic.$(ARCH).o            \
    4453$(SRC)/detrend.$(ARCH).o                \
    45 $(SRC)/dmagaves.$(ARCH).o               \
    46 $(SRC)/dmagmeas.$(ARCH).o               \
    47 $(SRC)/dmags.$(ARCH).o                  \
    4854$(SRC)/dmt.$(ARCH).o                    \
    4955$(SRC)/elixir.$(ARCH).o                \
    50 $(SRC)/fitcolors.$(ARCH).o             \
    5156$(SRC)/fitsed.$(ARCH).o                \
    5257$(SRC)/gcat.$(ARCH).o                   \

  • branches/eam_branches/ps2-tc3-20130727/Ohana/src/opihi/dvo/avextract.c

    r35416 r37403  
    166166  needMeasures = FALSE;
    167167  for (i = 0; !needMeasures && (i < Nfields); i++) {
    168     if (fields[i].magMode == MAG_NONE) continue;
    169     if (fields[i].photcode == NULL) continue; // assert this?
     168    if (fields[i].photcode == NULL) continue; // non-measure fields do not have a photcode
    170169    if (fields[i].photcode[0].type == PHOT_REF) needMeasures = TRUE;
    171170    if (fields[i].photcode[0].type == PHOT_DEP) needMeasures = TRUE;

  • branches/eam_branches/ps2-tc3-20130727/Ohana/src/opihi/dvo/avmatch.c

    r36680 r37403  
    152152  int needMeasures = FALSE;
    153153  for (i = 0; !needMeasures && (i < Nfields); i++) {
    154     if (fields[i].magMode == MAG_NONE) continue;
    155154    if (fields[i].photcode == NULL) continue; // assert this?
    156155    if (fields[i].photcode[0].type == PHOT_REF) needMeasures = TRUE;

  • branches/eam_branches/ps2-tc3-20130727/Ohana/src/opihi/dvo/fitsed.c

    r34088 r37403  
    8383  /* interpret command-line options */
    8484  if ((selection = SetRegionSelection (&argc, argv)) == NULL) goto escape;
    85   if (!SetPhotSelections (&argc, argv, 4)) goto usage;
     85  // if (!SetPhotSelections (&argc, argv, 4)) goto usage;
    8686
    8787  PLOT = FALSE;

  • branches/eam_branches/ps2-tc3-20130727/Ohana/src/opihi/dvo/gstar.c

    r35109 r37403  
    1515  GSTAR_UCDIST,
    1616  GSTAR_AVE_AP_MAG,
    17   GSTAR_AVE_MAG_20,
    18   GSTAR_AVE_MAG_80,
     17  GSTAR_AVE_MAG_MIN,
     18  GSTAR_AVE_MAG_MAX,
    1919  GSTAR_AVE_KRON_MAG,
    2020  GSTAR_AVE_KRON_MAG_ERR,
    … …  
    2323  GSTAR_STACK_FLUX_KRON,
    2424  GSTAR_STACK_FLUX_KRON_ERR,
     25  GSTAR_STACK_FLUX_APER,
     26  GSTAR_STACK_FLUX_APER_ERR,
     27  GSTAR_WARP_FLUX_PSF,
     28  GSTAR_WARP_FLUX_PSF_ERR,
     29  GSTAR_WARP_FLUX_KRON,
     30  GSTAR_WARP_FLUX_KRON_ERR,
     31  GSTAR_WARP_FLUX_APER,
     32  GSTAR_WARP_FLUX_APER_ERR,
     33  GSTAR_STACK_MAG_PSF,
     34  GSTAR_STACK_MAG_PSF_ERR,
     35  GSTAR_STACK_MAG_KRON,
     36  GSTAR_STACK_MAG_KRON_ERR,
     37  GSTAR_STACK_MAG_APER,
     38  GSTAR_STACK_MAG_APER_ERR,
     39  GSTAR_WARP_MAG_PSF,
     40  GSTAR_WARP_MAG_PSF_ERR,
     41  GSTAR_WARP_MAG_KRON,
     42  GSTAR_WARP_MAG_KRON_ERR,
     43  GSTAR_WARP_MAG_APER,
     44  GSTAR_WARP_MAG_APER_ERR,
    2545} GSTAR_SECF_CODES;
    2646
    … …  
    3151void sort_index_float (float *X, int *IDX, int N) {
    3252
    33 # define SWAPFUNC(A,B){ float tmp; int itmp;    \
    34   tmp = X[A]; X[A] = X[B]; X[B] = tmp; \
    35   itmp = IDX[A]; IDX[A] = IDX[B]; IDX[B] = itmp; \
    36 }
     53# define SWAPFUNC(A,B){ float tmp; int itmp;            \
     54    tmp = X[A]; X[A] = X[B]; X[B] = tmp;                \
     55    itmp = IDX[A]; IDX[A] = IDX[B]; IDX[B] = itmp;      \
     56  }
    3757# define COMPARE(A,B)(X[A] < X[B])
    3858
    … …  
    5272  off_t i, Nstars, *N1;
    5373  off_t j, k, m, N, Nlo, Nhi;
    54   int Nsecfilt, NPTS, QUIET, FULL_OUTPUT, STACK_OUTPUT, INST, SHOW_MASKS;
     74  int Nsecfilt, NPTS, QUIET, INST, SHOW_MASKS;
    5575  int found, GetMeasures;
    5676  int SaveVectors;
    … …  
    109129  }
    110130
    111   FULL_OUTPUT = FALSE;
     131  int FULL_OUTPUT = FALSE;
    112132  if ((N = get_argument (argc, argv, "-full"))) {
    113133    FULL_OUTPUT = TRUE;
    … …  
    115135  }
    116136
    117   STACK_OUTPUT = FALSE;
    118   if ((N = get_argument (argc, argv, "-stack"))) {
     137  int STACK_OUTPUT = FALSE;
     138  if ((N = get_argument (argc, argv, "+stack"))) {
    119139    STACK_OUTPUT = TRUE;
     140    remove_argument (N, &argc, argv);
     141  }
     142
     143  int EXTRA_OUTPUT = FALSE;
     144  if ((N = get_argument (argc, argv, "+extras"))) {
     145    EXTRA_OUTPUT = TRUE;
     146    remove_argument (N, &argc, argv);
     147  }
     148
     149  int WARP_OUTPUT = FALSE;
     150  if ((N = get_argument (argc, argv, "+warp"))) {
     151    WARP_OUTPUT = TRUE;
     152    remove_argument (N, &argc, argv);
     153  }
     154
     155  int FLUX_OUTPUT = FALSE;
     156  if ((N = get_argument (argc, argv, "+flux"))) {
     157    FLUX_OUTPUT = TRUE;
     158    remove_argument (N, &argc, argv);
     159  }
     160
     161  int MAG_OUTPUT = TRUE;
     162  if ((N = get_argument (argc, argv, "-mag"))) {
     163    MAG_OUTPUT = FALSE;
     164    remove_argument (N, &argc, argv);
     165  }
     166
     167  int KRON_OUTPUT = FALSE;
     168  if ((N = get_argument (argc, argv, "+kron"))) {
     169    KRON_OUTPUT = TRUE;
     170    remove_argument (N, &argc, argv);
     171  }
     172
     173  int APER_OUTPUT = FALSE;
     174  if ((N = get_argument (argc, argv, "+aper"))) {
     175    APER_OUTPUT = TRUE;
    120176    remove_argument (N, &argc, argv);
    121177  }
    … …  
    185241  // an error exit status here is a significant error
    186242  if (!dvo_catalog_open (&catalog, NULL, FALSE, "r")) {
    187       fprintf (stderr, "ERROR: failure to open catalog file %s\n", catalog.filename);
    188       exit (2);
     243    fprintf (stderr, "ERROR: failure to open catalog file %s\n", catalog.filename);
     244    exit (2);
    189245  }
    190246  dvo_catalog_unlock (&catalog);
    … …  
    248304      k = N1[i];
    249305      if (!QUIET) {
    250         gprint (GP_LOG, "star: "OFF_T_FMT"\n",  i);
     306        gprint (GP_LOG, "star: "OFF_T_FMT"\n",  k);
    251307        gprint (GP_LOG, "%11.7f ", catalog.average[k].R);
    252308        gprint (GP_LOG, "%11.7f ", catalog.average[k].D);
    … …  
    259315       
    260316        if (FULL_OUTPUT) {
    261             gprint (GP_LOG, "%f ",     catalog.average[k].dR);
    262             gprint (GP_LOG, "%f ",     catalog.average[k].dD);
    263             gprint (GP_LOG, "%f ",     catalog.average[k].uR);
    264             gprint (GP_LOG, "%f ",     catalog.average[k].uD);
    265             gprint (GP_LOG, "%f ",     catalog.average[k].duR);
    266             gprint (GP_LOG, "%f ",     catalog.average[k].duD);
    267             gprint (GP_LOG, "%f ",     catalog.average[k].P);
    268             gprint (GP_LOG, "%f   ",     catalog.average[k].dP);
    269 
    270             gprint (GP_LOG, "%f   ",     catalog.average[k].ChiSqPM);
    271             gprint (GP_LOG, "%f   ",     catalog.average[k].ChiSqPar);
    272 
    273             date = ohana_sec_to_date (catalog.average[k].Tmean);
    274             gprint (GP_LOG, "%20s ",     date);
    275             gprint (GP_LOG, "%f   ",     catalog.average[k].Trange / 86400.0);
     317          gprint (GP_LOG, "%f ",     catalog.average[k].dR);
     318          gprint (GP_LOG, "%f ",     catalog.average[k].dD);
     319          gprint (GP_LOG, "%f ",     catalog.average[k].uR);
     320          gprint (GP_LOG, "%f ",     catalog.average[k].uD);
     321          gprint (GP_LOG, "%f ",     catalog.average[k].duR);
     322          gprint (GP_LOG, "%f ",     catalog.average[k].duD);
     323          gprint (GP_LOG, "%f ",     catalog.average[k].P);
     324          gprint (GP_LOG, "%f   ",     catalog.average[k].dP);
     325
     326          gprint (GP_LOG, "%f   ",     catalog.average[k].ChiSqPM);
     327          gprint (GP_LOG, "%f   ",     catalog.average[k].ChiSqPar);
     328
     329          date = ohana_sec_to_date (catalog.average[k].Tmean);
     330          gprint (GP_LOG, "%20s ",     date);
     331          gprint (GP_LOG, "%f   ",     catalog.average[k].Trange / 86400.0);
    276332        }
    277333
    278         gprint (GP_LOG, "\n");
     334        gprint (GP_LOG, "\n\n");
    279335     
    280336        /* filter names */
     337        gprint (GP_LOG, "filter     : ");
    281338        for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_FILTER_NAMES);
    282339        gprint (GP_LOG, "\n");
    283340
    284341        /* average mags */
     342        gprint (GP_LOG, "chp_psf_ave: ");
    285343        for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_MAG);
    286344        gprint (GP_LOG, "\n");
    287345
    288346        /* average mag errors */
     347        gprint (GP_LOG, "chp_psf_err: ");
    289348        for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_MAG_ERR);
    290349        gprint (GP_LOG, "\n");
    291350
    292351        /* average mag chisq */
     352        gprint (GP_LOG, "chp_psf_chi: ");
    293353        for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_MAG_CHISQ);
    294354        gprint (GP_LOG, "\n");
    295355
    296         if (FULL_OUTPUT) {
     356       
     357        if (APER_OUTPUT) {
    297358          /* Map */
     359          gprint (GP_LOG, "chp_ap__ave: ");
    298360          for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_AP_MAG);
    299361          gprint (GP_LOG, "\n");
    300 
     362        }
     363
     364        if (KRON_OUTPUT) {
    301365          /* Mkron */
     366          gprint (GP_LOG, "chp_krn_ave: ");
    302367          for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_KRON_MAG);
    303368          gprint (GP_LOG, "\n");
    304369
    305370          /* dMkron */
     371          gprint (GP_LOG, "chp_krn_err: ");
    306372          for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_KRON_MAG_ERR);
    307373          gprint (GP_LOG, "\n");
    308 
    309           /* M_20 */
    310           for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_MAG_20);
    311           gprint (GP_LOG, "\n");
    312 
    313           /* M_80 */
    314           for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_MAG_80);;
     374        }
     375
     376        if (EXTRA_OUTPUT) {
     377          /* Mmin */
     378          gprint (GP_LOG, "chp_psf_min: ");
     379          for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_MAG_MIN);
     380          gprint (GP_LOG, "\n");
     381
     382          /* Mmax */
     383          gprint (GP_LOG, "chp_psf_max: ");
     384          for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_MAG_MAX);;
    315385          gprint (GP_LOG, "\n");
    316386
    317387          /* UCDIST */
     388          gprint (GP_LOG, "ubercal_dst: ");
    318389          for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_UCDIST);;
    319390          gprint (GP_LOG, "\n");
    320391
    321392          /* secfilt flags */
     393          gprint (GP_LOG, "filtflags:   ");
    322394          for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_SECF_FLAGS);
    323395          gprint (GP_LOG, "\n");
    324 
    325396        }
    326         if (STACK_OUTPUT) {
     397        if (STACK_OUTPUT && MAG_OUTPUT) {
    327398          /* FluxPSF */
     399          gprint (GP_LOG, "stk_psf_ave: ");
     400          for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_MAG_PSF);
     401          gprint (GP_LOG, "\n");
     402 
     403          /* dFluxPSF */
     404          gprint (GP_LOG, "stk_psf_err: ");
     405          for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_MAG_PSF_ERR);
     406          gprint (GP_LOG, "\n");
     407 
     408          if (KRON_OUTPUT) {
     409            /* MagKron */
     410            gprint (GP_LOG, "stk_krn_ave: ");
     411            for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_MAG_KRON);
     412            gprint (GP_LOG, "\n");
     413 
     414            /* dMagKron */
     415            gprint (GP_LOG, "stk_krn_err: ");
     416            for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_MAG_KRON_ERR);
     417            gprint (GP_LOG, "\n");
     418          }
     419
     420          if (APER_OUTPUT) {
     421            /* MagAper */
     422            gprint (GP_LOG, "stk_ap__ave: ");
     423            for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_MAG_APER);
     424            gprint (GP_LOG, "\n");
     425 
     426            /* dMagAper */
     427            gprint (GP_LOG, "stk_ap__err: ");
     428            for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_MAG_APER_ERR);
     429            gprint (GP_LOG, "\n");
     430          }
     431        }
     432        if (WARP_OUTPUT && MAG_OUTPUT) {
     433          /* FluxPSF */
     434          gprint (GP_LOG, "wrp_psf_ave: ");
     435          for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_MAG_PSF);
     436          gprint (GP_LOG, "\n");
     437 
     438          /* dFluxPSF */
     439          gprint (GP_LOG, "wrp_psf_err: ");
     440          for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_MAG_PSF_ERR);
     441          gprint (GP_LOG, "\n");
     442 
     443          if (KRON_OUTPUT) {
     444            /* MagKron */
     445            gprint (GP_LOG, "wrp_krn_ave: ");
     446            for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_MAG_KRON);
     447            gprint (GP_LOG, "\n");
     448 
     449            /* dMagKron */
     450            gprint (GP_LOG, "wrp_krn_err: ");
     451            for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_MAG_KRON_ERR);
     452            gprint (GP_LOG, "\n");
     453
     454          }
     455
     456          if (APER_OUTPUT) {
     457            /* MagAper */
     458            gprint (GP_LOG, "wrp_ap__ave: ");
     459            for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_MAG_APER);
     460            gprint (GP_LOG, "\n");
     461 
     462            /* dMagAper */
     463            gprint (GP_LOG, "wrp_ap__err: ");
     464            for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_MAG_APER_ERR);
     465            gprint (GP_LOG, "\n");
     466          }
     467        }
     468        if (STACK_OUTPUT && FLUX_OUTPUT) {
     469          /* FluxPSF */
     470          gprint (GP_LOG, "stk_psf_ave: ");
    328471          for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_FLUX_PSF);
    329472          gprint (GP_LOG, "\n");
    330 
     473 
    331474          /* dFluxPSF */
     475          gprint (GP_LOG, "stk_psf_err: ");
    332476          for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_FLUX_PSF_ERR);
    333477          gprint (GP_LOG, "\n");
    334 
    335           /* FluxKron */
    336           for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_FLUX_KRON);
    337           gprint (GP_LOG, "\n");
    338 
    339           /* dFluxKron */
    340           for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_FLUX_KRON_ERR);
    341           gprint (GP_LOG, "\n");
    342 
     478 
     479          if (KRON_OUTPUT) {
     480            /* FluxKron */
     481            gprint (GP_LOG, "stk_krn_ave: ");
     482            for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_FLUX_KRON);
     483            gprint (GP_LOG, "\n");
     484 
     485            /* dFluxKron */
     486            gprint (GP_LOG, "stk_krn_err: ");
     487            for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_FLUX_KRON_ERR);
     488            gprint (GP_LOG, "\n");
     489          }
     490
     491          if (APER_OUTPUT) {
     492            /* FluxAper */
     493            gprint (GP_LOG, "stk_ap_ave: ");
     494            for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_FLUX_APER);
     495            gprint (GP_LOG, "\n");
     496 
     497            /* dFluxAper */
     498            gprint (GP_LOG, "stk_ap_err: ");
     499            for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_STACK_FLUX_APER_ERR);
     500            gprint (GP_LOG, "\n");
     501          }
    343502        }
    344       }
     503        if (WARP_OUTPUT && FLUX_OUTPUT) {
     504          /* FluxPSF */
     505          gprint (GP_LOG, "wrp_psf_ave: ");
     506          for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_FLUX_PSF);
     507          gprint (GP_LOG, "\n");
     508 
     509          /* dFluxPSF */
     510          gprint (GP_LOG, "wrp_psf_ave: ");
     511          for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_FLUX_PSF_ERR);
     512          gprint (GP_LOG, "\n");
     513 
     514          if (KRON_OUTPUT) {
     515            /* FluxKron */
     516            gprint (GP_LOG, "wrp_krn_ave: ");
     517            for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_FLUX_KRON);
     518            gprint (GP_LOG, "\n");
     519 
     520            /* dFluxKron */
     521            gprint (GP_LOG, "wrp_krn_err: ");
     522            for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_FLUX_KRON_ERR);
     523            gprint (GP_LOG, "\n");
     524          }
     525
     526          if (APER_OUTPUT) {
     527            /* FluxAper */
     528            gprint (GP_LOG, "wrp_ap__ave: ");
     529            for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_FLUX_APER);
     530            gprint (GP_LOG, "\n");
     531 
     532            /* dFluxAper */
     533            gprint (GP_LOG, "wrp_ap__err: ");
     534            for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_WARP_FLUX_APER_ERR);
     535            gprint (GP_LOG, "\n");
     536          }
     537        }
     538      }
     539      gprint (GP_LOG, "\n");
     540     
    345541      if (GetMeasures || SaveVectors) {
    346542
    … …  
    374570          int Nv = index[j];
    375571
    376           Mcat = PhotCat (&catalog.measure[Nv]);
     572          Mcat = PhotCat (&catalog.measure[Nv], MAG_CLASS_PSF);
    377573          if (INST) {
    378             Mrel = PhotInst (&catalog.measure[Nv]);
     574            Mrel = PhotInst (&catalog.measure[Nv], MAG_CLASS_PSF);
    379575          } else {
    380             Mrel = PhotRel (&catalog.measure[Nv], &catalog.average[k], &catalog.secfilt[k*Nsecfilt]);
    381           }
     576            Mrel = PhotRel (&catalog.measure[Nv], &catalog.average[k], &catalog.secfilt[k*Nsecfilt], MAG_CLASS_PSF);
     577          }
     578
     579          float dRoff = dvoOffsetR(&catalog.measure[Nv], &catalog.average[k]);
     580          float dDoff = dvoOffsetD(&catalog.measure[Nv], &catalog.average[k]);
    382581
    383582          if (GetMeasures && !QUIET) {
    … …  
    387586            gprint (GP_LOG, "%6.3f  ", catalog.measure[Nv].dM);
    388587            gprint (GP_LOG, "%20s  ",  date);
    389             gprint (GP_LOG, "%7.4f ",  catalog.measure[Nv].dR);
    390             gprint (GP_LOG, "%7.4f ",  catalog.measure[Nv].dD);
     588           
     589            gprint (GP_LOG, "%7.4f ",  dRoff);
     590            gprint (GP_LOG, "%7.4f ",  dDoff);
    391591            gprint (GP_LOG, "0x%08x ", catalog.measure[Nv].photFlags);
    392592            gprint (GP_LOG, "0x%08x ", catalog.measure[Nv].dbFlags);
    … …  
    409609
    410610            if (FULL_OUTPUT) {
    411                 gprint (GP_LOG, "%6.3f ", catalog.measure[Nv].Mcal);
    412                 gprint (GP_LOG, "%6.3f ", catalog.measure[Nv].Map);
    413                 gprint (GP_LOG, "%6.3f ", catalog.measure[Nv].Mkron);
    414                 gprint (GP_LOG, "%6.3f ", catalog.measure[Nv].dMkron);
    415                 gprint (GP_LOG, "%5.1f ", pow(10.0, 0.4*catalog.measure[Nv].dt));
    416                 gprint (GP_LOG, "%5.3f ", catalog.measure[Nv].airmass);
    417                 gprint (GP_LOG, "%6.1f ", catalog.measure[Nv].az);
    418                 gprint (GP_LOG, "%6.1f ", catalog.measure[Nv].Xccd);
    419                 gprint (GP_LOG, "%6.1f ", catalog.measure[Nv].Yccd);
    420                 gprint (GP_LOG, "%3.1f ", FromShortPixels(catalog.measure[Nv].dXccd));
    421                 gprint (GP_LOG, "%3.1f ", FromShortPixels(catalog.measure[Nv].dYccd));
    422                 gprint (GP_LOG, "%6.1f ", catalog.measure[Nv].Sky);
    423                 gprint (GP_LOG, "%5.1f ", catalog.measure[Nv].dSky);
    424                 gprint (GP_LOG, "%8d ", catalog.measure[Nv].averef);
    425                 gprint (GP_LOG, "0x%08x ", catalog.measure[Nv].detID);
    426                 gprint (GP_LOG, "0x%08x ", catalog.measure[Nv].imageID);
    427                 gprint (GP_LOG, "%.3f ", catalog.measure[Nv].psfQF);
    428                 gprint (GP_LOG, "%.1f ", catalog.measure[Nv].psfChisq);
    429                 gprint (GP_LOG, "%.1f ", catalog.measure[Nv].crNsigma);
    430                 gprint (GP_LOG, "%.1f ", catalog.measure[Nv].extNsigma);
    431                 gprint (GP_LOG, "%.1f ", FromShortDegrees(catalog.measure[Nv].theta));
     611              gprint (GP_LOG, "%6.3f ", catalog.measure[Nv].Mcal);
     612              gprint (GP_LOG, "%6.3f ", catalog.measure[Nv].Map);
     613              gprint (GP_LOG, "%6.3f ", catalog.measure[Nv].Mkron);
     614              gprint (GP_LOG, "%6.3f ", catalog.measure[Nv].dMkron);
     615              gprint (GP_LOG, "%5.1f ", pow(10.0, 0.4*catalog.measure[Nv].dt));
     616              gprint (GP_LOG, "%5.3f ", catalog.measure[Nv].airmass);
     617              gprint (GP_LOG, "%6.1f ", catalog.measure[Nv].az);
     618              gprint (GP_LOG, "%6.1f ", catalog.measure[Nv].Xccd);
     619              gprint (GP_LOG, "%6.1f ", catalog.measure[Nv].Yccd);
     620              gprint (GP_LOG, "%3.1f ", FromShortPixels(catalog.measure[Nv].dXccd));
     621              gprint (GP_LOG, "%3.1f ", FromShortPixels(catalog.measure[Nv].dYccd));
     622              gprint (GP_LOG, "%6.1f ", catalog.measure[Nv].Sky);
     623              gprint (GP_LOG, "%5.1f ", catalog.measure[Nv].dSky);
     624              gprint (GP_LOG, "%8d ", catalog.measure[Nv].averef);
     625              gprint (GP_LOG, "0x%08x ", catalog.measure[Nv].detID);
     626              gprint (GP_LOG, "0x%08x ", catalog.measure[Nv].imageID);
     627              gprint (GP_LOG, "%5.3f ", catalog.measure[Nv].psfQF);
     628              gprint (GP_LOG, "%7.1f ", catalog.measure[Nv].psfChisq);
     629              // gprint (GP_LOG, "%3.1f ", catalog.measure[Nv].crNsigma);
     630              gprint (GP_LOG, "%4.1f ", catalog.measure[Nv].extNsigma);
     631              gprint (GP_LOG, "%5.1f ", FromShortDegrees(catalog.measure[Nv].theta));
    432632            }
    433             if (STACK_OUTPUT) {
    434                 gprint (GP_LOG, "%10.3e ", catalog.measure[Nv].FluxPSF);
    435                 gprint (GP_LOG, "%10.3e ", catalog.measure[Nv].dFluxPSF);
    436                 gprint (GP_LOG, "%10.3e ", catalog.measure[Nv].FluxKron);
    437                 gprint (GP_LOG, "%10.3e ", catalog.measure[Nv].dFluxKron);
     633            if (FLUX_OUTPUT) {
     634              gprint (GP_LOG, "%10.3e ", catalog.measure[Nv].FluxPSF);
     635              gprint (GP_LOG, "%10.3e ", catalog.measure[Nv].dFluxPSF);
     636              gprint (GP_LOG, "%10.3e ", catalog.measure[Nv].FluxKron);
     637              gprint (GP_LOG, "%10.3e ", catalog.measure[Nv].dFluxKron);
    438638            }
    439639            gprint (GP_LOG, "\n");
    … …  
    447647            vec3[0].elements.Flt[N] = catalog.measure[Nv].airmass;
    448648            vec4[0].elements.Flt[N] = catalog.measure[Nv].photcode;
    449             vec5[0].elements.Flt[N] = catalog.measure[Nv].dR;
    450             vec6[0].elements.Flt[N] = catalog.measure[Nv].dD;
     649            vec5[0].elements.Flt[N] = dRoff;
     650            vec6[0].elements.Flt[N] = dDoff;
    451651            N ++;
    452652            if (N == NPTS - 1) {
    … …  
    543743
    544744  switch (type) {
    545     case GSTAR_AVE_MAG: /* average mags */
    546       if (seq == -1) {
    547         print_double (NAN);
    548       } else {
    549         print_double (secfilt[seq].M);
    550       }
    551       break;
    552 
    553     case GSTAR_AVE_MAG_ERR: /* average mags errors */
    554       if (seq == -1) {
    555         print_double (NAN);
    556       } else {
    557         print_double (secfilt[seq].dM);
     745    case GSTAR_AVE_MAG_MIN: /* average ap mags */
     746      if (seq == -1) {
     747        print_double (NAN);
     748      } else {
     749        print_double (secfilt[seq].Mmin);
     750      }
     751      break;
     752
     753    case GSTAR_AVE_MAG_MAX: /* average ap mags */
     754      if (seq == -1) {
     755        print_double (NAN);
     756      } else {
     757        print_double (secfilt[seq].Mmax);
    558758      }
    559759      break;
    … …  
    561761    case GSTAR_AVE_MAG_CHISQ: /* average mag chisq */
    562762      if (seq == -1) {
    563         print_short (NAN_S_SHORT, NAN_S_SHORT);
    564       } else {
    565         print_short (pow (10.0, 0.01*secfilt[seq].Xm), secfilt[seq].Xm);
     763        print_double (NAN);
     764      } else {
     765        print_double (secfilt[seq].Mchisq);
    566766      }
    567767      break;
    … …  
    588788      break;
    589789
     790      /*** CHIP : MAG ***/
     791
     792    case GSTAR_AVE_MAG: /* average mags */
     793      if (seq == -1) {
     794        print_double (NAN);
     795      } else {
     796        print_double (secfilt[seq].M);
     797      }
     798      break;
     799
     800    case GSTAR_AVE_MAG_ERR: /* average mags errors */
     801      if (seq == -1) {
     802        print_double (NAN);
     803      } else {
     804        print_double (secfilt[seq].dM);
     805      }
     806      break;
     807
    590808    case GSTAR_AVE_AP_MAG: /* average ap mags */
    591809      if (seq == -1) {
    … …  
    596814      break;
    597815
    598     case GSTAR_AVE_MAG_20: /* average ap mags */
    599       if (seq == -1) {
    600         print_double (NAN);
    601       } else {
    602         print_short (0.001*secfilt[seq].M_20, secfilt[seq].M_20);
    603       }
    604       break;
    605 
    606     case GSTAR_AVE_MAG_80: /* average ap mags */
    607       if (seq == -1) {
    608         print_double (NAN);
    609       } else {
    610         print_short (0.001*secfilt[seq].M_80, secfilt[seq].M_80);
    611       }
    612       break;
    613 
    614816    case GSTAR_AVE_KRON_MAG: /* average ap mags */
    615817      if (seq == -1) {
    … …  
    628830      break;
    629831
     832      /******************* STACK : FLUX **********************/
     833
    630834    case GSTAR_STACK_FLUX_PSF: /* average ap mags */
    631835      if (seq == -1) {
    632836        print_double (NAN);
    633837      } else {
    634         print_double_exp (secfilt[seq].FluxPSF);
     838        print_double_exp (secfilt[seq].FpsfStk);
    635839      }
    636840      break;
    … …  
    640844        print_double (NAN);
    641845      } else {
    642         print_double_exp (secfilt[seq].dFluxPSF);
     846        print_double_exp (secfilt[seq].dFpsfStk);
    643847      }
    644848      break;
    … …  
    648852        print_double (NAN);
    649853      } else {
    650         print_double_exp (secfilt[seq].FluxKron);
     854        print_double_exp (secfilt[seq].FkronStk);
    651855      }
    652856      break;
    … …  
    656860        print_double (NAN);
    657861      } else {
    658         print_double_exp (secfilt[seq].dFluxKron);
     862        print_double_exp (secfilt[seq].dFkronStk);
     863      }
     864      break;
     865
     866    case GSTAR_STACK_FLUX_APER: /* average ap mags */
     867      if (seq == -1) {
     868        print_double (NAN);
     869      } else {
     870        print_double_exp (secfilt[seq].FapStk);
     871      }
     872      break;
     873
     874    case GSTAR_STACK_FLUX_APER_ERR: /* average ap mags */
     875      if (seq == -1) {
     876        print_double (NAN);
     877      } else {
     878        print_double_exp (secfilt[seq].dFapStk);
     879      }
     880      break;
     881
     882      /******************* STACK : MAG **********************/
     883
     884    case GSTAR_STACK_MAG_PSF: /* average ap mags */
     885      if (seq == -1) {
     886        print_double (NAN);
     887      } else {
     888        print_double (secfilt[seq].MpsfStk);
     889      }
     890      break;
     891
     892    case GSTAR_STACK_MAG_PSF_ERR: /* average ap mags */
     893      if (seq == -1) {
     894        print_double (NAN);
     895      } else {
     896        print_double (secfilt[seq].dFpsfStk / secfilt[seq].FpsfStk);
     897      }
     898      break;
     899
     900    case GSTAR_STACK_MAG_KRON: /* average ap mags */
     901      if (seq == -1) {
     902        print_double (NAN);
     903      } else {
     904        print_double (secfilt[seq].MkronStk);
     905      }
     906      break;
     907
     908    case GSTAR_STACK_MAG_KRON_ERR: /* average ap mags */
     909      if (seq == -1) {
     910        print_double (NAN);
     911      } else {
     912        print_double (secfilt[seq].dFkronStk / secfilt[seq].FkronStk);
     913      }
     914      break;
     915
     916    case GSTAR_STACK_MAG_APER: /* average ap mags */
     917      if (seq == -1) {
     918        print_double (NAN);
     919      } else {
     920        print_double (secfilt[seq].MapStk);
     921      }
     922      break;
     923
     924    case GSTAR_STACK_MAG_APER_ERR: /* average ap mags */
     925      if (seq == -1) {
     926        print_double (NAN);
     927      } else {
     928        print_double (secfilt[seq].dFapStk / secfilt[seq].FapStk);
     929      }
     930      break;
     931
     932      /******************* WARP : FLUX **********************/
     933
     934    case GSTAR_WARP_FLUX_PSF: /* average ap mags */
     935      if (seq == -1) {
     936        print_double (NAN);
     937      } else {
     938        print_double_exp (secfilt[seq].FpsfWrp);
     939      }
     940      break;
     941
     942    case GSTAR_WARP_FLUX_PSF_ERR: /* average ap mags */
     943      if (seq == -1) {
     944        print_double (NAN);
     945      } else {
     946        print_double_exp (secfilt[seq].dFpsfWrp);
     947      }
     948      break;
     949
     950    case GSTAR_WARP_FLUX_KRON: /* average ap mags */
     951      if (seq == -1) {
     952        print_double (NAN);
     953      } else {
     954        print_double_exp (secfilt[seq].FkronWrp);
     955      }
     956      break;
     957
     958    case GSTAR_WARP_FLUX_KRON_ERR: /* average ap mags */
     959      if (seq == -1) {
     960        print_double (NAN);
     961      } else {
     962        print_double_exp (secfilt[seq].dFkronWrp);
     963      }
     964      break;
     965
     966    case GSTAR_WARP_FLUX_APER: /* average ap mags */
     967      if (seq == -1) {
     968        print_double (NAN);
     969      } else {
     970        print_double_exp (secfilt[seq].FapWrp);
     971      }
     972      break;
     973
     974    case GSTAR_WARP_FLUX_APER_ERR: /* average ap mags */
     975      if (seq == -1) {
     976        print_double (NAN);
     977      } else {
     978        print_double_exp (secfilt[seq].dFapWrp);
     979      }
     980      break;
     981
     982      /******************* WARP : MAG **********************/
     983
     984    case GSTAR_WARP_MAG_PSF: /* average ap mags */
     985      if (seq == -1) {
     986        print_double (NAN);
     987      } else {
     988        print_double (secfilt[seq].MpsfWrp);
     989      }
     990      break;
     991
     992    case GSTAR_WARP_MAG_PSF_ERR: /* average ap mags */
     993      if (seq == -1) {
     994        print_double (NAN);
     995      } else {
     996        print_double (secfilt[seq].dFpsfWrp / secfilt[seq].FpsfWrp);
     997      }
     998      break;
     999
     1000    case GSTAR_WARP_MAG_KRON: /* average ap mags */
     1001      if (seq == -1) {
     1002        print_double (NAN);
     1003      } else {
     1004        print_double (secfilt[seq].MkronWrp);
     1005      }
     1006      break;
     1007
     1008    case GSTAR_WARP_MAG_KRON_ERR: /* average ap mags */
     1009      if (seq == -1) {
     1010        print_double (NAN);
     1011      } else {
     1012        print_double (secfilt[seq].dFkronWrp / secfilt[seq].FkronWrp);
     1013      }
     1014      break;
     1015
     1016    case GSTAR_WARP_MAG_APER: /* average ap mags */
     1017      if (seq == -1) {
     1018        print_double (NAN);
     1019      } else {
     1020        print_double (secfilt[seq].MapWrp);
     1021      }
     1022      break;
     1023
     1024    case GSTAR_WARP_MAG_APER_ERR: /* average ap mags */
     1025      if (seq == -1) {
     1026        print_double (NAN);
     1027      } else {
     1028        print_double (secfilt[seq].dFapWrp / secfilt[seq].FapWrp);
    6591029      }
    6601030      break;

  • branches/eam_branches/ps2-tc3-20130727/Ohana/src/opihi/dvo/hosts.c

    r36680 r37403  
    33# define DVO_MAX_PATH 1024
    44
    5 enum {TEMP_NONE, TEMP_DVO_RESULTS, TEMP_DVO_LOG, TEMP_RELASTRO_CATALOG, TEMP_RELPHOT_CATALOG, TEMP_RELPHOT_LOG, TEMP_DVOPSPS_DET, TEMP_FIXSTKIDS_RESULTS};
     5enum {TEMP_NONE, TEMP_DVO_RESULTS, TEMP_DVO_LOG,
     6      TEMP_RELASTRO_CATALOG, TEMP_RELPHOT_CATALOG, TEMP_RELPHOT_LOG, TEMP_DVOPSPS_DET, TEMP_FIXSTKIDS_RESULTS,
     7      TEMP_RELASTRO_CAT_FULL, TEMP_RELPHOT_CAT_FULL, TEMP_CHECKASTRO_CAT_FULL,
     8};
    69
    710// functions to manage the remote hosts
    … …  
    7174      if (!strcasecmp(argv[N], "dvo.results"))       TEMP_TYPE = TEMP_DVO_RESULTS;
    7275      if (!strcasecmp(argv[N], "dvo.log"))           TEMP_TYPE = TEMP_DVO_LOG;
    73       if (!strcasecmp(argv[N], "relastro.catalog"))   TEMP_TYPE = TEMP_RELASTRO_CATALOG;
     76      if (!strcasecmp(argv[N], "relastro.catalog"))  TEMP_TYPE = TEMP_RELASTRO_CATALOG;
    7477      if (!strcasecmp(argv[N], "relphot.catalog"))   TEMP_TYPE = TEMP_RELPHOT_CATALOG;
     78      if (!strcasecmp(argv[N], "relastro.catfull"))  TEMP_TYPE = TEMP_RELASTRO_CAT_FULL;
     79      if (!strcasecmp(argv[N], "checkastro.catfull"))TEMP_TYPE = TEMP_CHECKASTRO_CAT_FULL;
     80      if (!strcasecmp(argv[N], "relphot.catfull"))   TEMP_TYPE = TEMP_RELPHOT_CAT_FULL;
    7581      if (!strcasecmp(argv[N], "relphot.log"))       TEMP_TYPE = TEMP_RELPHOT_LOG;
    7682      if (!strcasecmp(argv[N], "dvopsps.det"))       TEMP_TYPE = TEMP_DVOPSPS_DET;
    … …  
    7884      if (TEMP_TYPE == TEMP_NONE) {
    7985        gprint (GP_ERR, "USAGE: hosts purge-temp [-type (type)]\n");
    80         gprint (GP_ERR, "  allowed types dvo.results, dvo.log, relphot.results, relphot.log]\n");
     86        gprint (GP_ERR, "  allowed types dvo.results, dvo.log, relphot.catalog, relphot.log, relphot.catfull, relastro.catalog, relastro.catfull, checkastro.catfull, dvopsps.det, fixstkids.results]\n");
    8187        return FALSE;
    8288      }
    … …  
    118124        if (TEMP_TYPE == TEMP_RELPHOT_CATALOG)   snprintf (name, DVO_MAX_PATH, "%s/relphot.catalog.subset.dat", table->hosts[i].pathname);
    119125        if (TEMP_TYPE == TEMP_RELPHOT_LOG)       snprintf (name, DVO_MAX_PATH, "%s/log.rlpc.*", table->hosts[i].pathname);
     126        if (TEMP_TYPE == TEMP_RELASTRO_CAT_FULL) snprintf (name, DVO_MAX_PATH, "%s/relastro.catalog.?????.?????.dat", table->hosts[i].pathname);
     127        if (TEMP_TYPE == TEMP_CHECKASTRO_CAT_FULL) snprintf (name, DVO_MAX_PATH, "%s/checkastro.catalog.?????.?????.dat", table->hosts[i].pathname);
     128        if (TEMP_TYPE == TEMP_RELPHOT_CAT_FULL)  snprintf (name, DVO_MAX_PATH, "%s/relphot.catalog.?????.?????.dat", table->hosts[i].pathname);
    120129        if (TEMP_TYPE == TEMP_DVOPSPS_DET)       snprintf (name, DVO_MAX_PATH, "%s/dvopsps.*.det.dat", table->hosts[i].pathname);
    121130        if (TEMP_TYPE == TEMP_FIXSTKIDS_RESULTS) snprintf (name, DVO_MAX_PATH, "%s/fixstkids.results.*.dat", table->hosts[i].pathname);
    … …  
    126135        if (TEMP_TYPE == TEMP_RELPHOT_CATALOG)   snprintf (name, DVO_MAX_PATH, "%s/relphot.catalog.subset.dat", table->hosts[i].pathname);
    127136        if (TEMP_TYPE == TEMP_RELPHOT_LOG)       snprintf (name, DVO_MAX_PATH, "%s/log.rlpc.*", table->hosts[i].pathname);
     137        if (TEMP_TYPE == TEMP_RELASTRO_CAT_FULL) snprintf (name, DVO_MAX_PATH, "%s/relastro.catalog.%05d.?????.dat", table->hosts[i].pathname, PID);
     138        if (TEMP_TYPE == TEMP_CHECKASTRO_CAT_FULL) snprintf (name, DVO_MAX_PATH, "%s/checkastro.catalog.%05d.?????.dat", table->hosts[i].pathname, PID);
     139        if (TEMP_TYPE == TEMP_RELPHOT_CAT_FULL)  snprintf (name, DVO_MAX_PATH, "%s/relphot.catalog.%05d.?????.dat", table->hosts[i].pathname, PID);
    128140        if (TEMP_TYPE == TEMP_DVOPSPS_DET)       snprintf (name, DVO_MAX_PATH, "%s/dvopsps.%05d.*.det.dat", table->hosts[i].pathname, PID);
    129141        if (TEMP_TYPE == TEMP_FIXSTKIDS_RESULTS) snprintf (name, DVO_MAX_PATH, "%s/fixstkids.results.%05d.*.dat", table->hosts[i].pathname, PID);

  • branches/eam_branches/ps2-tc3-20130727/Ohana/src/opihi/dvo/imdata.c

    r34088 r37403  
    33int imdata (int argc, char **argv) {
    44 
    5   off_t i, j, k, n, I;
     5  off_t i, j, k, I;
    66  int N, NPTS, found, mode, TimeSelect, TimeFormat;
    77  off_t Nregions, NREGIONS;
    … …  
    152152        for (i = 0; i < catalog.Nmeasure; i++) {
    153153          if ((catalog.measure[i].t < start) || (catalog.measure[i].t > stop)) continue;
    154           n = catalog.measure[i].averef;
    155           vec[0].elements.Flt[N] = catalog.average[n].R - catalog.measure[i].dR / 3600.0;
     154          vec[0].elements.Flt[N] = catalog.measure[i].R;
    156155          N++;
    157156          CHECK_REALLOCATE (vec[0].elements.Flt, opihi_flt, NPTS, N, 1000);
    … …  
    161160        for (i = 0; i < catalog.Nmeasure; i++) {
    162161          if ((catalog.measure[i].t < start) || (catalog.measure[i].t > stop)) continue;
    163           n = catalog.measure[i].averef;
    164           vec[0].elements.Flt[N] = catalog.average[n].D - catalog.measure[i].dD / 3600.0;
     162          vec[0].elements.Flt[N] = catalog.measure[i].D;
    165163          N++;
    166164          CHECK_REALLOCATE (vec[0].elements.Flt, opihi_flt, NPTS, N, 1000);
    … …  
    194192        for (i = 0; i < catalog.Nmeasure; i++) {
    195193          if ((catalog.measure[i].t < start) || (catalog.measure[i].t > stop)) continue;
    196           n = catalog.measure[i].averef;
     194          //n = catalog.measure[i].averef;
    197195          // vec[0].elements.Flt[N] = catalog.average[n].M;
    198196          N++;

  • branches/eam_branches/ps2-tc3-20130727/Ohana/src/opihi/dvo/imextract.c

    r34088 r37403  
    185185    gprint (GP_ERR, "  Mcal : photometry calibration (mags)\n");
    186186    gprint (GP_ERR, "  dMcal : photometry calibration error (mags)\n");
    187     gprint (GP_ERR, "  Xm : chisq of photometry calibration\n");
     187    gprint (GP_ERR, "  Mchisq : chisq of photometry calibration\n");
    188188    gprint (GP_ERR, "  photcode : numeric photcode value for image\n");
    189189    gprint (GP_ERR, "  exptime : exposure duration (seconds)\n");

  • branches/eam_branches/ps2-tc3-20130727/Ohana/src/opihi/dvo/init.c

    r36680 r37403  
    1414int cmpread         PROTO((int, char **));
    1515int coordimage      PROTO((int, char **));
     16int coordmosaic     PROTO((int, char **));
     17int psastro_model   PROTO((int, char **));
    1618int ddmags          PROTO((int, char **));
    1719int detrend         PROTO((int, char **));
    … …  
    6466  {1, "avmatch",     avmatch,      "extract average data values matched to RA,DEC points"},
    6567  {1, "badimages",   badimages,    "look for images with anomalous astrometry"},
    66   {1, "calextract",  calextract,   "extract photometry calibration"},
    67   {1, "calmextract", calmextract,  "extract photometry calibration"},
     68//  {1, "calextract",  calextract,   "extract photometry calibration"},
     69//  {1, "calmextract", calmextract,  "extract photometry calibration"},
    6870  {1, "catdir",      catdir_define,"re-define CATDIR"},
    69   {1, "ccd",         ccd,          "plot color-color diagram"},
     71//  {1, "ccd",         ccd,          "plot color-color diagram"},
    7072  {1, "cmatch",      cmatch,       "match two catalogs"},
    71   {1, "cmd",         cmd,          "plot cmd of stars in current region"},
     73//  {1, "cmd",         cmd,          "plot cmd of stars in current region"},
    7274  {1, "cmpload",     cmpload,      "load cmp file into ?"},
    7375  {1, "cmpread",     cmpread,      "read data from cmp format files"},
    7476  {1, "coordimage",  coordimage,   "generate a map of the transformation residuals"},
    75   {1, "ddmags",      ddmags,       "plot magnitude differences"},
     77  {1, "coordmosaic", coordmosaic,  "generate a map of the distortion"},
     78  {1, "psastro_model", psastro_model, "save psastro-format astrometry model"},
     79//  {1, "ddmags",      ddmags,       "plot magnitude differences"},
    7680  {1, "detrend",     detrend,      "extract from detrend database?"},
    77   {1, "dmagaves",    dmagaves,     "foo"},
    78   {1, "dmagmeas",    dmagmeas,     "foo"},
    79   {1, "dmags",       dmags,        "plot differential magnitudes between filters"},
     81//  {1, "dmagaves",    dmagaves,     "foo"},
     82//  {1, "dmagmeas",    dmagmeas,     "foo"},
     83//  {1, "dmags",       dmags,        "plot differential magnitudes between filters"},
    8084  {1, "dmt",         dmt,          "plot mag scatter"},
    8185  {1, "elixir",      elixir,       "talk to elixir"},
    82   {1, "fitcolors",   fitcolors,    "fit chip-to-chip color terms"},
     86//  {1, "fitcolors",   fitcolors,    "fit chip-to-chip color terms"},
    8387  {1, "fitsed",      fitsed,       "fit stellar SEDs to objects"},
    8488  {1, "gcat",        gcat,         "get catalog at location"},

  • branches/eam_branches/ps2-tc3-20130727/Ohana/src/opihi/dvo/lcurve.c

    r34584 r37403  
    129129        if (ErrorBars) dYvec.elements.Flt[N] = catalog.measure[m].dM;
    130130        Xvec.elements.Flt[N] = TimeValue (catalog.measure[m].t, TimeReference, TimeFormat);
    131         Yvec.elements.Flt[N] = PhotCat (&catalog.measure[m]);
     131        Yvec.elements.Flt[N] = PhotCat (&catalog.measure[m], MAG_CLASS_PSF);
    132132        /**** need to use PhotRel optionally here ****/
    133133        N++;

  • branches/eam_branches/ps2-tc3-20130727/Ohana/src/opihi/dvo/lightcurve.c

    r27435 r37403  
    121121        dmvec[0].elements.Flt[N] = catalog.measure[m].dM;
    122122        if (RELPHOT) {
    123           mvec[0].elements.Flt[N] = PhotCat (&catalog.measure[m]);
     123          mvec[0].elements.Flt[N] = PhotCat (&catalog.measure[m], MAG_CLASS_PSF);
    124124        } else {
    125           mvec[0].elements.Flt[N] = PhotRel (&catalog.measure[m], &catalog.average[k], &catalog.secfilt[k*Nsecfilt]);
     125          mvec[0].elements.Flt[N] = PhotRel (&catalog.measure[m], &catalog.average[k], &catalog.secfilt[k*Nsecfilt], MAG_CLASS_PSF);
    126126        }
    127127        N++;

  • branches/eam_branches/ps2-tc3-20130727/Ohana/src/opihi/dvo/photometry.c

    r36680 r37403  
    4141  }
    4242
     43# if (0)
    4344/* selection criteria */
    4445/* selections based on Measure quantities */
    … …  
    7879static time_t TimeReference;
    7980static int TimeFormat;
    80 
     81# endif
     82
     83# if (0)
    8184int GetTimeSelection (time_t *tz, time_t *te) {
    8285  *tz = tzero;
    … …  
    298301  return;
    299302}
    300 
    301 /* (re)load photcodes from photcode table */
    302 int InitPhotcodes () {
    303 
    304   double ZERO_POINT;
    305   char MasterPhotcodeFile[256];
    306   char CatdirPhotcodeFile[256];
    307   char *catdir;
    308 
    309   if (VarConfig ("ZERO_PT", "%lf", &ZERO_POINT) == (char *) NULL) {
    310     gprint (GP_ERR, "ZERO_PT undefined in config\n");
    311     return (FALSE);
    312   }
    313   SetZeroPoint (ZERO_POINT);
    314 
    315   catdir = GetCATDIR();
    316   if (catdir == NULL) {
    317     CatdirPhotcodeFile[0] = 0;
    318   } else {
    319     sprintf (CatdirPhotcodeFile, "%s/Photcodes.dat", catdir);
    320   }
    321 
    322   if (VarConfig ("PHOTCODE_FILE", "%s", MasterPhotcodeFile) == (char *) NULL) {
    323     gprint (GP_ERR, "PHOTCODE_FILE undefined in config\n");
    324     return (FALSE);
    325   }
    326 
    327   // XXX now that DVO does not allow write access, we can drop the MasterPhotcodeFile
    328   if (!LoadPhotcodes (CatdirPhotcodeFile, MasterPhotcodeFile, FALSE)) {
    329     gprint (GP_ERR, "error loading photcode table %s or master file %s\n", CatdirPhotcodeFile, MasterPhotcodeFile);
    330     return (FALSE);
    331   }
    332   return (TRUE);
    333 }
    334 
     303# endif
     304
     305# if (0)
    335306int ListPhotSelections () {
    336307
    … …  
    11211092  return (list);
    11221093}
    1123 
     1094# endif
     1095
     1096# if (0)
    11241097double GetMeasure (int param, Average *average, Measure *measure, double mag) {
    11251098
    … …  
    11351108      break;
    11361109    case MEAS_RA: /* OK */
    1137       value = average[0].R - measure[0].dR / 3600.0;
     1110      value = measure[0].R;
    11381111      break;
    11391112    case MEAS_DEC: /* OK */
    1140       value = average[0].D - measure[0].dD / 3600.0;
     1113      value = measure[0].D;
    11411114      break;
    11421115    case MEAS_DOPHOT: /* OK */
    … …  
    11561129      break;
    11571130    case MEAS_RA_OFFSET: /* OK */
    1158       value = measure[0].dR;
     1131      value = dvoOffsetR(measure, average);
    11591132      break;
    11601133    case MEAS_DEC_OFFSET: /* OK */
    1161       value = measure[0].dD;
     1134      value = dvoOffsetD(measure, average);
    11621135      break;
    11631136    case MEAS_FWHM: /* OK */
    … …  
    11721145      value = measure[0].Xccd;
    11731146# else
    1174       ra  = average[0].R - measure[0].dR / 3600.0;
    1175       dec = average[0].D - measure[0].dD / 3600.0;
     1147      ra  = measure[0].R;
     1148      dec = measure[0].D;
    11761149      image = MatchImageDVO (measure[0].t, measure[0].photcode, measure[0].imageID);
    11771150      if (image == NULL) break;
    … …  
    11851158      value = measure[0].Yccd;
    11861159# else
    1187       ra  = average[0].R - measure[0].dR / 3600.0;
    1188       dec = average[0].D - measure[0].dD / 3600.0;
     1160      ra  = measure[0].R;
     1161      dec = measure[0].D;
    11891162      image = MatchImageDVO (measure[0].t, measure[0].photcode, measure[0].imageID);
    11901163      if (image == NULL) break;
    … …  
    11951168# if 0
    11961169    case MEAS_XMOSAIC: /* OK */
    1197       ra  = average[0].R - measure[0].dR / 3600.0;
    1198       dec = average[0].D - measure[0].dD / 3600.0;
     1170      ra  = measure[0].R;
     1171      dec = measure[0].D;
    11991172      mosaic = MatchMosaic (measure[0].t, measure[0].photcode); // XXX not used anymore
    12001173      if (mosaic == NULL) break;
    … …  
    12031176      break;
    12041177    case MEAS_YMOSAIC: /* OK */
    1205       ra  = average[0].R - measure[0].dR / 3600.0;
    1206       dec = average[0].D - measure[0].dD / 3600.0;
     1178      ra  = measure[0].R;
     1179      dec = measure[0].D;
    12071180      mosaic = MatchMosaic (measure[0].t, measure[0].photcode); // XXX not used anymore
    12081181      if (mosaic == NULL) break;
    … …  
    12141187  return (value);
    12151188}
     1189# endif
    12161190
    12171191/** the mosaic entries do not use the registered mosaic found

  • branches/eam_branches/ps2-tc3-20130727/Ohana/src/opihi/dvo/pmeasure.c

    r34088 r37403  
    203203        if (TimeSelect && (catalog.measure[m+k].t > tzero + trange)) continue;
    204204        if ((PhotcodeClip != -1) && (catalog.measure[m+k].photcode != PhotcodeClip)) continue;
    205         mag = PhotCat (&catalog.measure[m+k]);
     205        mag = PhotCat (&catalog.measure[m+k], MAG_CLASS_PSF);
    206206        Zvec[Npts] = MIN (1.0, MAX (0.01, (mag - Mz) / Mr));
    207207        if (LimExclude && (Zvec[Npts] > 0.99)) continue;
    208208        if (Zvec[Npts] < 0.011) continue;
    209         R = catalog.average[i].R - catalog.measure[m+k].dR/3600.0;
    210         D = catalog.average[i].D - catalog.measure[m+k].dD/3600.0;
     209        R = catalog.measure[m+k].R;
     210        D = catalog.measure[m+k].D;
    211211        // XXX drop this check
    212212        if ((R < Rmin) || (R > Rmax) || (D < -90.0) || (D > 90.0)) {
    213213          char *date;
    214214          date = ohana_sec_to_date (catalog.measure[m+k].t);
    215           gprint (GP_LOG, "out: %f, %f : %s : (%f, %f) + (%f, %f)\n", R, D, date, catalog.average[i].R, catalog.average[i].D, catalog.measure[m+k].dR/3600.0, catalog.measure[m+k].dD/3600.0);
     215          gprint (GP_LOG, "out: %f, %f : %s : (%f, %f) + (%f, %f)\n", R, D, date, catalog.average[i].R, catalog.average[i].D, catalog.measure[m+k].R, catalog.measure[m+k].D);
    216216          free (date);
    217217        }

  • branches/eam_branches/ps2-tc3-20130727/Ohana/src/opihi/dvo/subpix.c

    r31635 r37403  
    138138    for (j = 0; j < Nmeasure; j++) {
    139139      if (measure[j].t == Timage) {
    140         Mabs = PhotCat (&measure[j]);
     140        Mabs = PhotCat (&measure[j], MAG_CLASS_PSF);
    141141        RD_to_XY (&X, &Y, Ra, Dec, &image[I].coords);
    142142        t = TimeValue (measure[j].t, TimeReference, TimeFormat);

  • branches/eam_branches/ps2-tc3-20130727/Ohana/src/opihi/include/dvomath.h

    r36680 r37403  
    170170Vector      **ReadVectorTableFITS   PROTO((char *filename, char *extname, int *Nvec));
    171171
     172int           VectorAssignData          PROTO((Vector **vec, char *type, void *data, int Nrows, int Nval));
     173int           VectorAssignDataTranspose PROTO((Vector **vec, char *type, void *data, int Nrows, int Nval));
     174
    172175/* buffer handling */
    173176Buffer       *InitBuffer            PROTO((void));

  • branches/eam_branches/ps2-tc3-20130727/Ohana/src/opihi/include/dvoshell.h

    r35416 r37403  
    9090int           wordhash              PROTO((char *word));
    9191
    92 int          GetMagMode             PROTO((char *string));
    93 PhotCode    *ParsePhotcodeField     PROTO((char *field, int *mode, int def));
    94 int          ParseMeasureField      PROTO((dbField *field, char *fieldName));
    95 int          ParseAverageField      PROTO((dbField *field, char *fieldName));
    96 int          ParseImageField        PROTO((dbField *field, char *fieldName));
    97 
    98 dbValue      dbExtractMeasures      PROTO((Average *average, SecFilt *secfilt, Measure *measure, dbField *field));
    99 dbValue      dbExtractImages        PROTO((Image *image, off_t Nimage, off_t N, dbField *field));
    100 
    10192int          HostTableLaunchJobs    PROTO((SkyList *sky, HostTable *table, char *basecmd, char *options, int VERBOSE));
    10293int          HostTableParallelOps   PROTO((SkyList *sky, int argc, char **argv, char *ResultFile, int ReadVectors, int Nelements, int VERBOSE));

  • branches/eam_branches/ps2-tc3-20130727/Ohana/src/opihi/include/shell.h

    r33662 r37403  
    166166// wrap readline in ohana mem functions:
    167167char         *opihi_readline            PROTO((char *prompt));
     168
     169int set_list_varname (char *line, char *base, int N, int excelStyle);
    168170
    169171/* gprint functions */

  • branches/eam_branches/ps2-tc3-20130727/Ohana/src/opihi/lib.shell/VectorIO.c

    r35109 r37403  
    134134  FTable ftable;
    135135
    136   int i, j, k;
     136  int i, j;
    137137  FILE *f = NULL;
    138138
    … …  
    202202    assert (status);
    203203
    204 # define ASSIGN_DATA(TYPE,OPTYPE) \
    205     /* assign the data to the actual vector */ \
    206     if (!strcmp (type, #TYPE)) { \
    207       TYPE *Ptr = data;     \
    208       for (k = 0; k < Nrows; k++) { \
    209         for (j = 0; j < Nval; j++, Ptr++) { \
    210           vec[Nvec + j][0].elements.OPTYPE[k] = *Ptr; \
    211         } } }
    212 
    213     // assign the data to the actual vector
    214     ASSIGN_DATA(char,    Int);
    215     ASSIGN_DATA(short,   Int);
    216     ASSIGN_DATA(int,     Int);
    217     ASSIGN_DATA(int64_t, Int);
    218     ASSIGN_DATA(float,   Flt);
    219     ASSIGN_DATA(double,  Flt);
     204    if (!VectorAssignData(&vec[Nvec], type, data, Nrows, Nval)) {
     205      // free unneeded things
     206      gprint (GP_ERR, "trouble parsing data block type %s\n", type);
     207      return (NULL);
     208    }
    220209
    221210    free (data);
    … …  
    241230//  return (FALSE);
    242231}
     232
     233# define ASSIGN_DATA(TYPE,DTYPE,OPTYPE)        \
     234    /* assign the data to the actual vector */ \
     235    if (!strcmp (type, #TYPE)) { \
     236      DTYPE *Ptr = data;                    \
     237      for (k = 0; k < Nrows; k++) { \
     238        for (j = 0; j < Nval; j++, Ptr++) { \
     239          vec[j][0].elements.OPTYPE[k] = *Ptr; \
     240          } } return TRUE; }
     241
     242int VectorAssignData (Vector **vec, char *type, void *data, int Nrows, int Nval) {
     243
     244  int j, k;
     245
     246  // assign the data to the actual vector
     247  ASSIGN_DATA(byte,    char,    Int);
     248  ASSIGN_DATA(char,    char,    Int);
     249  ASSIGN_DATA(short,   short,   Int);
     250  ASSIGN_DATA(int,     int,     Int);
     251  ASSIGN_DATA(int64_t, int64_t, Int);
     252  ASSIGN_DATA(float,   float,   Flt);
     253  ASSIGN_DATA(double,  double,  Flt);
     254
     255  return FALSE;
     256}
     257
     258# define ASSIGN_DATA_TRANSPOSE(TYPE,DTYPE,OPTYPE)       \
     259    /* assign the data to the actual vector */ \
     260    if (!strcmp (type, #TYPE)) { \
     261      DTYPE *Ptr = data;                    \
     262      for (k = 0; k < Nrows; k++) { \
     263        for (j = 0; j < Nval; j++, Ptr++) { \
     264          vec[k][0].elements.OPTYPE[j] = *Ptr; \
     265          } } return TRUE; }
     266
     267int VectorAssignDataTranspose (Vector **vec, char *type, void *data, int Nrows, int Nval) {
     268
     269  int j, k;
     270
     271  // assign the data to the actual vector
     272  ASSIGN_DATA_TRANSPOSE(byte,    char,    Int);
     273  ASSIGN_DATA_TRANSPOSE(char,    char,    Int);
     274  ASSIGN_DATA_TRANSPOSE(short,   short,   Int);
     275  ASSIGN_DATA_TRANSPOSE(int,     int,     Int);
     276  ASSIGN_DATA_TRANSPOSE(int64_t, int64_t, Int);
     277  ASSIGN_DATA_TRANSPOSE(float,   float,   Flt);
     278  ASSIGN_DATA_TRANSPOSE(double,  double,  Flt);
     279
     280  return FALSE;
     281}

  • branches/eam_branches/ps2-tc3-20130727/Ohana/src/opihi/lib.shell/string.c

    r33662 r37403  
    322322}
    323323
     324int set_list_varname (char *line, char *base, int N, int excelStyle) {
     325
     326  int i;
     327   
     328  // A-Z correspond to 0 - 25
     329
     330  if (excelStyle) {
     331    float f = log(26.0);
     332    float g = (N == 0) ? 0.0 : log(1.0*N);
     333    int Ndigit = (int) (g / f) + 1;
     334    if (Ndigit > 10) {
     335      sprintf (line, "%s:ZZZZZZZZZZ", base);
     336      return FALSE;
     337    }
     338    char name[12];
     339    memset (name, 0, 12);
     340    for (i = 0; i < Ndigit; i++) {
     341      float Npow = Ndigit - i - 1;
     342      float g = pow(26.0, Npow);
     343      int V = (int) (N / g);
     344      name[i] = (Npow == 0.0) ? 'A' + V : 'A' + V - 1;
     345      N -= V * g;
     346    }
     347    sprintf (line, "%s:%s", base, name);
     348  } else {
     349    sprintf (line, "%s:%d", base, N);
     350  }
     351  return TRUE;
     352}

  • branches/eam_branches/ps2-tc3-20130727/Ohana/src/opihi/pcontrol/PclientCommand.c

    r27435 r37403  
    2525    return (PCLIENT_DOWN);
    2626  }
    27  
     27
    2828  // prepare host to accept response
    2929  host[0].response_state = response_state;
    … …  
    3535  return (PCLIENT_GOOD);
    3636}
    37  
     37
    3838// check for response; message must end with specified string.
    3939// accumulate the response in the buffer
    … …  
    4747  ASSERT (response != NULL, "response missing");
    4848  ASSERT (buffer != NULL, "buffer missing");
     49
     50  // INITTIME;
    4951
    5052  /* avoid blocking very long on read, test every 100 usec, up to 0.1 sec */
    … …  
    6668    return (PCLIENT_DOWN);
    6769  }
    68   if (line == NULL) return (PCLIENT_HUNG);
    69   if (status == -1) return (PCLIENT_HUNG);
     70  if (line == NULL) {
     71      // MARKTIME ("-- client hung (line NULL): %s : %f sec\n", host[0].hostname, dtime);
     72      return (PCLIENT_HUNG);
     73  }
     74  if (status == -1) {
     75      // MARKTIME ("-- client hung (status -1): %s : %f sec\n", host[0].hostname, dtime);
     76      return (PCLIENT_HUNG);
     77  }
    7078
    7179  // fprintf (stderr, "response: %s\n", buffer[0].buffer);
    … …  
    7583
    7684/* memstr returns a view, not an allocated string : don't free */
    77 /* ReadtoIOBuffer returns : 
     85/* ReadtoIOBuffer returns :
    7886    0 - pipe closed
    7987   -1 - no more data in pipe, data not ready
Note: See TracChangeset for help on using the changeset viewer.