IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 21444


Ignore:
Timestamp:
Feb 11, 2009, 6:39:57 PM (17 years ago)
Author:
eugene
Message:

working on the new PS1_V1 CMF and DVO formats; removing autocode type Stars; using Average and Measure in addstar to carry new detection info (replacing autocode Stars)

Location:
branches/eam_branch_20090208/Ohana/src
Files:
4 added
3 deleted
54 edited

Legend:

Unmodified
Added
Removed

  • branches/eam_branch_20090208/Ohana/src/addstar/Makefile

    r20936 r21444  
    2727mkcmf       : $(BIN)/mkcmf.$(ARCH)
    2828
    29 all: addstar addstarc addstard addstart sedstar load2mass skycells
     29all: addstar sedstar load2mass skycells
     30
     31# I need to fix the client/server version of addstar now that I have dropped Stars
     32# as an autocode type and have converted to carrying average and measure
     33# all: addstar addstarc addstard addstart sedstar load2mass skycells
    3034
    3135ADDSTAR = \
    … …  
    4852$(SRC)/find_matches_refstars.$(ARCH).o \
    4953$(SRC)/find_subset.$(ARCH).o \
    50 $(SRC)/get2mass.$(ARCH).o \
    51 $(SRC)/get2mass_as.$(ARCH).o \
    52 $(SRC)/get2mass_as_raw.$(ARCH).o \
    53 $(SRC)/get2mass_dr2.$(ARCH).o \
    54 $(SRC)/get2mass_ops.$(ARCH).o \
    5554$(SRC)/getgsc.$(ARCH).o \
    5655$(SRC)/gettycho.$(ARCH).o \
    … …  
    7170$(SRC)/replace_match.$(ARCH).o \
    7271$(SRC)/resort_catalog.$(ARCH).o \
     72$(SRC)/StarOps.$(ARCH).o \
    7373$(SRC)/ReadStarsFITS.$(ARCH).o \
    7474$(SRC)/ReadStarsTEXT.$(ARCH).o \
    … …  
    106106$(SRC)/find_matches_refstars.$(ARCH).o \
    107107$(SRC)/find_subset.$(ARCH).o \
    108 $(SRC)/get2mass.$(ARCH).o \
    109 $(SRC)/get2mass_as.$(ARCH).o \
    110 $(SRC)/get2mass_as_raw.$(ARCH).o \
    111 $(SRC)/get2mass_dr2.$(ARCH).o \
    112 $(SRC)/get2mass_ops.$(ARCH).o \
    113108$(SRC)/getgsc.$(ARCH).o \
    114109$(SRC)/gettycho.$(ARCH).o \
    … …  
    141136$(SRC)/find_matches_refstars.$(ARCH).o \
    142137$(SRC)/find_subset.$(ARCH).o \
    143 $(SRC)/get2mass.$(ARCH).o \
    144 $(SRC)/get2mass_as.$(ARCH).o \
    145 $(SRC)/get2mass_as_raw.$(ARCH).o \
    146 $(SRC)/get2mass_dr2.$(ARCH).o \
    147 $(SRC)/get2mass_ops.$(ARCH).o \
    148138$(SRC)/getgsc.$(ARCH).o \
    149139$(SRC)/getusno.$(ARCH).o \
    … …  
    209199$(SRC)/replace_match.$(ARCH).o \
    210200$(SRC)/update_coords.$(ARCH).o \
     201$(SRC)/StarOps.$(ARCH).o \
    211202$(SRC)/ConfigInit.$(ARCH).o \
    212203$(SRC)/Shutdown.$(ARCH).o \
    … …  
    252243$(BIN)/mkcmf.$(ARCH)       : $(MKCMF)
    253244
    254 INSTALL = addstar addstarc addstard addstart sedstar load2mass skycells mkcmf
     245INSTALL = addstar sedstar load2mass skycells mkcmf
     246
     247# I need to fix the client/server version of addstar now that I have dropped Stars
     248# as an autocode type and have converted to carrying average and measure
     249# all: addstar addstarc addstard addstart sedstar load2mass skycells
     250# INSTALL = addstar addstarc addstard addstart sedstar load2mass skycells mkcmf
    255251
    256252# dependancy rules for binary code #########################

  • branches/eam_branch_20090208/Ohana/src/addstar/doc/notes.txt

    r21408 r21444  
     1
     22009.02.11
     3
     4  updating DVO tables with more fields: cleaning up the conversions
     5  from external formats to the DVO internal formats:  I am changing
     6  the APIs to convert directly to the Measure structure, including
     7  conversion functions for the compressed fields (ie, pixels carried
     8  as short).
     9
     10  A few remaining issues:
     11
     12  * t_msec : I've added a field to carry the fractional seconds, but
     13    nothing is yet setting this value, and the query functions do not
     14    use this value.
     15
     16  * various fields are reported in either arcseconds or pixels (eg,
     17    FWHMx, moments, error in centroid).  These are currently not very
     18    consistent, and should be tightened up...
     19
     20    ** if we store these values in pixels, then cameras with a wide
     21       range of plate scales (GPC1 << SkyProbe << AllSky) will all fit
     22       in field with a small dynamic range; since we also provide the
     23       plate scale (as a float), conversions are easy:
     24       GPC1     : 0.26 arcsec / pixel
     25       SkyProbe : 4.5 arcsec / pixel
     26       AllSky   : 3600.0 arcsec / pixel
    127
    2282008.10.11

  • branches/eam_branch_20090208/Ohana/src/addstar/include/addstar.h

    r21153 r21444  
    2828    fprintf (stderr, "ERROR:  photcode %s not found in photcode table\n", NAME); \
    2929    exit (0); }
     30
     31typedef struct {
     32  char *exthead;
     33  char *extdata;
     34  char *exttype;
     35  int extnum_head;
     36  int extnum_data;
     37} HeaderSet;
     38
     39typedef struct {
     40  Average average;
     41  Measure measure;
     42  int found;
     43} Stars;
    3044
    3145typedef struct {
    … …  
    3953  char *refcat;
    4054} DVO_DATA;
    41 
    42 typedef struct {
    43   char *exthead;
    44   char *extdata;
    45   char *exttype;
    46   int extnum_head;
    47   int extnum_data;
    48 } HeaderSet;
    4955
    5056typedef struct sockaddr_in SockAddress;
    … …  
    9298/* these globals modify the behavior of gstars (KEEP) */
    9399double  SNLIMIT;
     100int     PHOTFLAG_EXCLUDE;
    94101int     ACCEPT_ASTROM;  // accept even bad astrometry solutions (NASTRO == 0)
    95102int     ACCEPT_MOTION;  // accept reference proper motion measurements
    … …  
    137144/*** addstar prototypes ***/
    138145
     146AddstarClientOptions ConfigInit   PROTO((int *argc, char **argv));
     147AddstarClientOptions args         PROTO((int argc, char **argv, AddstarClientOptions options));
     148
    139149void       AddToCalibration       PROTO((Average *average, SecFilt *secfilt, Measure *measure, Measure *new, int *next, int Nstar));
    140 AddstarClientOptions ConfigInit   PROTO((int *argc, char **argv));
    141150void       FindCalibration        PROTO((Image *image));
    142151FILE      *GetDB                  PROTO((int *state));
    … …  
    145154void       SetProtect             PROTO((int mode));
    146155int        SetSignals             PROTO((void));
    147 int        Shutdown               PROTO((char *message, ...); )
     156int        Shutdown               PROTO((char *message, ...));
    148157void       TrapSignal             PROTO((int sig));
    149158float      airmass                PROTO((float secz_image, double ra, double dec, double st, double latitude));
     159float      azimuth                PROTO((double ha, double dec, double latitude));
    150160void       SetAirmassQuality      PROTO((int quality));
    151161SkyTable  *SkyTableFromTychoIndex PROTO((char *filename, int VERBOSE));
    152 AddstarClientOptions args         PROTO((int argc, char **argv, AddstarClientOptions options));
    153162void       check_permissions      PROTO((char *basefile));
    154163int        dump_rawstars          PROTO((Stars *stars, int Nstars));
    155164int        edge_check             PROTO((double *x1, double *y1, double *x2, double *y2));
    156165Image     *fakeimage              PROTO((char *rootname, int *Nimage, int photcode));
     166
    157167int        find_matches           PROTO((SkyRegion *region, Stars *stars, int Nstars, Catalog *catalog, AddstarClientOptions options));
    158168int        find_matches_closest   PROTO((SkyRegion *region, Stars *stars, int Nstars, Catalog *catalog, AddstarClientOptions options));
    159169int        find_matches_refstars  PROTO((SkyRegion *region, Stars **stars, int Nstars, Catalog *catalog, AddstarClientOptions options));
     170
    160171Stars    **find_subset            PROTO((SkyRegion *region, Stars *stars, int Nstars, int *NSTARS));
    161172int        gcatalog               PROTO((Catalog *catalog));
    162173Stars     *get2mass               PROTO((SkyRegion *patch, int photcode, int mode, int *NSTARS));
    163174double     get_subpix             PROTO((double x, double y));
     175
     176Stars     *greference             PROTO((char *Refcat, SkyRegion *catstats, int photcode, int *nstars));
    164177Stars     *getgsc                 PROTO((SkyRegion *patch, int *NSTARS));
    165178Stars     *gettycho               PROTO((SkyRegion *catstats, int photcode, int *Nstars));
    166179Stars     *getusno                PROTO((SkyRegion *catstats, int photcode, int *Nstars));
    167180Stars     *getusnob               PROTO((SkyRegion *catstats, int photcode, int *Nstars));
    168 Image     *gimages                PROTO((FITS_DB *db, Image *image, Coords *mosaic, int *Npimage));
    169 Stars     *grefcat                PROTO((char *Refcat, SkyRegion *catstats, int photcode, int *nstars));
     181
     182// load text-based stars (REF only in the sense of REF photcodes)
    170183Stars     *grefstars              PROTO((char *file, int photcode, int *Nstars));
    171184
    … …  
    249262Stars     *Convert_PS1_DEV_0      PROTO((FTable *table, int *nstars));
    250263Stars     *Convert_PS1_DEV_1      PROTO((FTable *table, int *nstars));
     264Stars     *Convert_PS1_V1         PROTO((FTable *table, int *nstars));
     265
     266int        InitStar               PROTO((Stars *star));
     267short      ShortPixels            PROTO((float pixels));
     268short      ShortDegree            PROTO((float degrees));
    251269
    252270int args_skycells (int argc, char **argv);

  • branches/eam_branch_20090208/Ohana/src/addstar/src/ConfigInit.c

    r20936 r21444  
    3939  ScanConfig (config, "MIN_SN_FSTAT",           "%lf", 0, &SNLIMIT);
    4040  ScanConfig (config, "ADDSTAR_SNLIMIT",        "%lf", 0, &SNLIMIT);
     41
     42  /* exclude stars with bits that match the given photFlags bits */
     43  PHOTFLAG_EXCLUDE = 0;
     44  ScanConfig (config, "ADDSTAR_PHOTFLAG_EXCLUDE", "%d", 0, &PHOTFLAG_EXCLUDE);
    4145
    4246  MAX_CERROR = 0.5; // arcseconds

  • branches/eam_branch_20090208/Ohana/src/addstar/src/FilterStars.c

    r21419 r21444  
    11# include "addstar.h"
     2# define EXTERNAL_ID FALSE
    23
     4/* exclude some detections based on various filter options:
     5 * *** S/N limit
     6 * *** Acceptable window on detector
     7 * *** bad photFlags
     8 */
     9
     10// the imageID supplied here is the sequence **within this set**
     11// this value is updated based on the image table later
    312Stars *FilterStars (Stars *instars, Image *image, unsigned int imageID) {
    413
    … …  
    1928  ALLOCATE (stars, Stars, image[0].nstar);
    2029  for (N = j = 0; j < image[0].nstar; j++) {
     30
    2131    /* allow for some dynamic filtering of star list */
    22     if (SNLIMIT && instars[j].dM > SNLIMIT) continue;
    23     if (XMAX && (instars[j].Xccd > XMAX)) continue;
    24     if (XMIN && (instars[j].Xccd < XMIN)) continue;
    25     if (YMAX && (instars[j].Yccd > YMAX)) continue;
    26     if (YMIN && (instars[j].Yccd < YMIN)) continue;
     32    if (SNLIMIT && instars[j].measure.dM > SNLIMIT) continue;
     33    if (XMAX && (instars[j].measure.Xccd > XMAX)) continue;
     34    if (XMIN && (instars[j].measure.Xccd < XMIN)) continue;
     35    if (YMAX && (instars[j].measure.Yccd > YMAX)) continue;
     36    if (YMIN && (instars[j].measure.Yccd < YMIN)) continue;
     37    if (PHOTFLAG_EXCLUDE && (instars[j].measure.photFlags & PHOTFLAG_EXCLUDE)) continue;
     38
    2739    stars[N] = instars[j];
    2840
    29     XY_to_RD (&stars[N].R, &stars[N].D, stars[N].Xccd, stars[N].Yccd, &image[0].coords);
    30     stars[N].R = ohana_normalize_angle (stars[N].R);
    31     stars[N].found = -1;
    32     stars[N].photcode = image[0].photcode;
     41    XY_to_RD (&stars[N].average.R, &stars[N].average.D, stars[N].measure.Xccd, stars[N].measure.Yccd, &image[0].coords);
     42    stars[N].average.R = ohana_normalize_angle (stars[N].average.R);
    3343
    34     RMIN = MIN (RMIN, stars[N].R);
    35     RMAX = MAX (RMAX, stars[N].R);
    36     DMIN = MIN (DMIN, stars[N].D);
    37     DMAX = MAX (DMAX, stars[N].D);
     44    stars[N].measure.photcode = image[0].photcode;
     45
     46    // determine the full coverage of this set of measurements
     47    RMIN = MIN (RMIN, stars[N].average.R);
     48    RMAX = MAX (RMAX, stars[N].average.R);
     49    DMIN = MIN (DMIN, stars[N].average.D);
     50    DMAX = MAX (DMAX, stars[N].average.D);
     51
    3852    /** additional quantities to supply to Stars based on the image data **/
    3953
    40     /* calculate accurate per-star airmass */
    41     stars[N].airmass = airmass (image[0].secz, stars[N].R, stars[N].D, image[0].sidtime, image[0].latitude);
    42     stars[N].Mcal    = image[0].Mcal;
    43     stars[N].t       = image[0].tzero + 1e-4*stars[N].Yccd*image[0].trate;  /* trate is in 0.1 msec / row */
    44     stars[N].dt      = MTIME;
     54    /* calculate accurate per-star airmass and azimuth */
     55    stars[N].measure.airmass = airmass (image[0].secz, stars[N].average.R, stars[N].average.D, image[0].sidtime, image[0].latitude);
     56    stars[N].measure.az      = azimuth (image[0].sidtime - stars[N].average.R, stars[N].average.D, image[0].latitude);
     57    stars[N].measure.Mcal    = image[0].Mcal;
     58    stars[N].measure.t       = image[0].tzero + 1e-4*stars[N].measure.Yccd*image[0].trate;  /* trate is in 0.1 msec / row */
     59    stars[N].measure.dt      = MTIME;
    4560
    46     if ((stars[N].M > 25.0) && (stars[N].M < 32.0)) {
     61    // watch out for any strange values:
     62    if ((stars[N].measure.M > 25.0) && (stars[N].measure.M < 32.0)) {
    4763      fprintf (stderr, "*");
    4864    }
    49 
    5065    // stars->M is either NAN or a valid inst magnitude
    5166    // stars->dM is either NAN or a valid error
    … …  
    5469    dMx = 0.0;
    5570    if (SUBPIX) {
    56       dMs = get_subpix (stars[N].Xccd, stars[N].Yccd);
    57       dMx = scat_subpix (stars[N].Xccd, stars[N].Yccd);
    58       if (!isnan(stars[N].dM)) {
    59         stars[N].dM = hypot (stars[N].dM, dMx);
     71      dMs =  get_subpix (stars[N].measure.Xccd, stars[N].measure.Yccd);
     72      dMx = scat_subpix (stars[N].measure.Xccd, stars[N].measure.Yccd);
     73      if (!isnan(stars[N].measure.dM)) {
     74        stars[N].measure.dM = hypot (stars[N].measure.dM, dMx);
    6075      }
    6176    }
    6277
    63     if (!isnan(stars[N].M)) {
    64       stars[N].M += MTIME - dMs;
     78    if (!isnan(stars[N].measure.M)) {
     79      stars[N].measure.M  += MTIME - dMs;
    6580    }
    66     if (!isnan(stars[N].Map)) {
    67       stars[N].Map += MTIME - dMs;
     81    if (!isnan(stars[N].measure.Map)) {
     82      stars[N].measure.Map += MTIME - dMs;
    6883    }
    6984   
    70     // XXX currently, this ID is internal only;
    71     // should we use the psphot / other external ID, if available?
    72     stars[N].detID = N; // sequence number within image
    73     stars[N].imageID = imageID; // does this need to be updated?
     85    // the external ID is supplied, but do we trust it?
     86    if (!EXTERNAL_ID) {
     87      stars[N].measure.detID = N; // sequence number within image
     88    }
     89
     90# if (0)
     91    if (PSPS_ID) {
     92      double mjd;
     93      mjd = ohana_sec_to_mjd (image[0].tzero);
     94      // XXX this is clearly wrong : what does PSPS want?
     95      stars[N].measure.extID = PSPS_create_detectid (mjd, imageID);
     96    }
     97# endif
     98
     99    stars[N].measure.imageID = imageID; // this value is update in UpdateImageIDs
    74100
    75101    N ++;

  • branches/eam_branch_20090208/Ohana/src/addstar/src/GetFileMode.c

    r21408 r21444  
    77  int Naxis;
    88  int simple, extend, haveNaxis, haveCTYPE;
     9  int tmp, havePHOT_VER, haveTARG_VER;
    910
    1011  gfits_scan (header, "SIMPLE", "%t", 1, &simple);
    … …  
    1415  gfits_scan (header, "EXTEND", "%t", 1, &extend);
    1516   
    16 {
    17     int tmp, havePHOT_VER, haveTARG_VER;
    18 
    19     // SDSS tsObj files have a version number for the PHOTO and
    20     // TS (target selection) pipelines present as header keywords
    21     havePHOT_VER = gfits_scan (header, "PHOT_VER", "%s", 1, &tmp);
    22     haveTARG_VER = gfits_scan (header, "TARG_VER", "%s", 1, &tmp);
    23     if (havePHOT_VER && haveTARG_VER) return SDSS_OBJ;
    24 }
     17  // SDSS tsObj files have a version number for the PHOTO and
     18  // TS (target selection) pipelines present as header keywords
     19  havePHOT_VER = gfits_scan (header, "PHOT_VER", "%s", 1, &tmp);
     20  haveTARG_VER = gfits_scan (header, "TARG_VER", "%s", 1, &tmp);
     21  if (havePHOT_VER && haveTARG_VER) return SDSS_OBJ;
    2522
    2623  if ((Naxis == 2) || TEXTMODE || !simple) {

  • branches/eam_branch_20090208/Ohana/src/addstar/src/LoadData.c

    r21408 r21444  
    4141    // I need to detect them here and load them with ReadStarsTEXT instead of calling the code
    4242    // below.
     43    // inStars = ReadStarsFITS (f, headers[Nhead], headers[Ndata], &images[0][Nvalid].nstar);
    4344
    4445    // XXX use something to set the chip name? EXTNAME?

  • branches/eam_branch_20090208/Ohana/src/addstar/src/LoadDataPMM.c

    r21419 r21444  
    8282
    8383    for (i = 0; i < Nline; i++) {
    84       // fscanf (f, "%lf %lf %lf", &ra, &dec, &mag) != EOF) {
    85 
    8684      dparse (&ra,  1, &buffer[i*NBYTE_ASC_TABLE]);
    8785      dparse (&dec, 2, &buffer[i*NBYTE_ASC_TABLE]);
    8886      dparse (&mag, 3, &buffer[i*NBYTE_ASC_TABLE]);
    8987
    90       memset (&inStars[Ninstars], 0, sizeof(Stars));
     88      InitStar (&inStars[Ninstars]);
    9189
    9290      if (ra > 180) {
    … …  
    10098      maxD = MAX(maxD, dec);
    10199
    102       inStars[Ninstars].M       = mag - ZeroPoint + ZeroPt;
    103       inStars[Ninstars].R       = ra;
    104       inStars[Ninstars].D       = dec;
    105       inStars[Ninstars].t       = images[0][0].tzero;
    106       inStars[Ninstars].dt      = images[0][0].exptime;
    107       inStars[Ninstars].photcode    = code;
    108       inStars[Ninstars].airmass = airmass;
    109       inStars[Ninstars].az      = az;
    110       inStars[Ninstars].found   = -1; // found starts at -1 == not yet found
     100      inStars[Ninstars].average.R        = ra;
     101      inStars[Ninstars].average.D        = dec;
     102
     103      inStars[Ninstars].measure.M        = mag - ZeroPoint + ZeroPt;
     104      inStars[Ninstars].measure.t        = images[0][0].tzero;
     105      inStars[Ninstars].measure.dt       = images[0][0].exptime;
     106      inStars[Ninstars].measure.photcode = code;
     107      inStars[Ninstars].measure.airmass  = airmass;
     108      inStars[Ninstars].measure.az       = az;
     109
    111110      Ninstars++;
    112111      CHECK_REALLOCATE (inStars, Stars, NINSTARS, Ninstars, 10000);

  • branches/eam_branch_20090208/Ohana/src/addstar/src/LoadStars.c

    r16973 r21444  
    6363    }
    6464
     65    // load PMM data if specified (these are not stored as FITS-tables)
    6566    if (PMM_CCD_TABLE != NULL) {
    6667      LoadDataPMM (f, file[i], images, Nimages, &stars, Nstars);
    … …  
    6869    }
    6970
     71    // otherwise, we have FITS-table files: parse their headers to determine the contents
    7072    headers = LoadHeaders (f, &mode, &Nheaders);
    7173    headerSets = MatchHeaders (&extsize, &NheaderSets, mode, headers, Nheaders);
    … …  
    8688    }
    8789
     90    // if these are SDSS data, load with SDSS-specific wrapper
    8891    if (headerSets[0].exttype && !strcmp (headerSets[0].exttype, "SDSS_OBJ")) {
    8992      LoadDataSDSS (f, file[i], images, Nimages, &stars, Nstars, headers, extsize, headerSets, NheaderSets);

  • branches/eam_branch_20090208/Ohana/src/addstar/src/MatchHeaders.c

    r16810 r21444  
    5151    if (!strcmp (exttype, "PS1_DEV_0")) goto keep;
    5252    if (!strcmp (exttype, "PS1_DEV_1")) goto keep;
     53    if (!strcmp (exttype, "PS1_V1")) goto keep;
    5354    continue;
    5455

  • branches/eam_branch_20090208/Ohana/src/addstar/src/PSPS_IDs.c

    r21419 r21444  
     1# include "addstar.h"
    12
    2 create_detectid(double tobs, int ccdid, int runid, uint64 *detectid)
    3 {
    4    double floor();
    5    double diff, t0 = 51544.5;
    6    char string[19];
    7    int itmp;
    8    uint64 utmp;
     3uint64_7 PSPS_create_detectID (double MJDobs, int imageID) {
    94
    10    diff = floor( 100000. * (tobs - t0) );
    11    itmp = diff;
    12    utmp = 1000000000*((uint64) itmp) + 10000000 * ((uint64) ccdid) +
    13             ((uint64) runid);
    14    *detectid = utmp;
     5  // MJD has a PS lifetime range of : 3288 (2009/01/01) to 9132 (2025/01/01) (< 2^14)
     6
     7  static double t0 = 51544.5; // MJD @ 2000/01/01,12:00:00
     8
     9  uint64_t iTime;
     10  uint64_t detectID;
     11
     12  iTime = floor(tobs - t0);
     13
     14  // iTime takes the upper 16 bits, imageID can take up to lower 48 bits
     15  detectID = (iTime << 48) | imageID;
     16
     17  return detectID;
    1518}
    1619
     20uint64_t PSPS_create_objID (double ra, double dec) {
    1721
     22  static double zh = 0.0083333; // zone height = 30 arcsec
    1823
    19 create_objid(double ra, double dec, uint64 *objid)
    20 {
    21    uint64 part1, part2, part3;
    22    double zid, zresid;
    23    int izone;
    24    double zh = 0.0083333, floor();
     24  uint64_t objID;
     25  uint64_t part1, part2, part3;
    2526
    26    zid = (dec + 90.) / zh;
    27    izone = (int) floor(zid);
    28    zresid = zid -  ((float) izone);
    29    part1 = (uint64)( izone  * 10000000000000) ;
    30    part2 = ((uint64)(ra * 1000000.)) * 10000 ;
    31    part3 = (int) (zresid * 10000.0) ;
    32    *objid = part1 + part2 + part3;
     27  double zid, zresid;
     28  int izone;
     29
     30  zid = (dec + 90.0) / zh; // 0 - 180*60*2 = 21600 (< 15 bits)
     31  izone = (int) floor(zid);
     32  zresid = zid -  ((float) izone); // 0 - 1.0
     33  part1 = (uint64_t)( izone  * 10000000000000) ;
     34  part2 = ((uint64_t)(ra * 1 000 000.)) * 10000 ; // 0 - 360.0*1e6 = 3.6e8 (< 29 bits)
     35  part3 = (int) (zresid * 10000.0) ; // 0 - 10000 (1 bit == 30/10000 arcsec = 0.003 arcsec) (< 14 bits)
     36
     37  objID = part1 + part2 + part3;
     38
     39  return objID;
    3340}
     41
     42uint64_t PSPS_create_objID_eam (double ra, double dec) {
     43
     44  static double zh = 0.0083333; // zone height = 30 arcsec
     45
     46  uint64_t objID;
     47  uint64_t part1, part2, part3;
     48
     49  double zid, zresid;
     50  int izone, ira;
     51
     52  zid = (dec + 90.0) / zh; // 0 - 180*60*2 = 21600 (< 15 bits)
     53  izone = (int) floor(zid);
     54  zresid = zid -  ((float) izone); // 0 - 1.0
     55
     56  ira = ra * 1 000 000; // 0 - 360.0*1e6 = 3.6e8 (< 29 bits)
     57
     58  part1 = (izone << 48);
     59  part2 = (ira << 16);
     60  part3 = (int) (zresid * 10000.0) ; // 0 - 10000 (1 bit == 30/10000 arcsec = 0.003 arcsec) (< 14 bits)
     61
     62  objID = part1 | part2 | part3;
     63
     64  return objID;
     65}
     66
     67// part1 : 15 bits
     68// part2 : 29 bits
     69// part3 : 14 bits
     70// 15 + 14 + 29 bits = 58 bits...
     71

  • branches/eam_branch_20090208/Ohana/src/addstar/src/ReadStarsFITS.c

    r21419 r21444  
    4040    stars = Convert_PS1_DEV_1 (&table, &Nstars);
    4141  }
     42  if (!strcmp (type, "CMF_PS1_V1")) {
     43    stars = Convert_PS1_V1 (&table, &Nstars);
     44  }
    4245  if (stars == NULL) {
    4346    fprintf (stderr, "ERROR: invalid table type %s\n", type);
    … …  
    6265  ZeroPt = GetZeroPoint();
    6366
    64   /* XXX we need to check at least the size of the loaded table */
    65   // XXX use memset to zero-out the elements before setting
    66 
    67   ALLOCATE (stars, Stars, Nstars);
    68   for (i = 0; i < Nstars; i++) {
    69     stars[i].Xccd   = smpdata[i].X;
    70     stars[i].Yccd   = smpdata[i].Y;
     67  ALLOCATE (stars, Stars, Nstars);
     68  for (i = 0; i < Nstars; i++) {
     69    InitStar (&stars[i]);
     70
     71    stars[i].measure.Xccd      = smpdata[i].X;
     72    stars[i].measure.Yccd      = smpdata[i].Y;
    7173
    7274    if ((smpdata[i].M >= ZeroPt) || isnan(smpdata[i].M)) {
    73       stars[i].M    = NAN;
    74       stars[i].Map  = NAN;
    75     } else {
    76       stars[i].M    = smpdata[i].M;
    77       stars[i].Map  = smpdata[i].M;
    78     }
    79 
    80     stars[i].dM     = smpdata[i].dM*0.001;
    81 
    82     // the dophot type information get pushed into the upper 2 bytes of photFlags
    83     stars[i].photFlags = (smpdata[i].dophot << 16);
    84 
    85     stars[i].fx     = smpdata[i].fx;
    86     stars[i].fy     = smpdata[i].fy;
    87     stars[i].df     = smpdata[i].df;
     75      stars[i].measure.M       = NAN;
     76      stars[i].measure.Map     = NAN;
     77    } else {
     78      stars[i].measure.M       = smpdata[i].M;
     79      stars[i].measure.Map     = smpdata[i].M;
     80    }
     81
     82    stars[i].measure.dM        = smpdata[i].dM*0.001;
     83
     84    // the dophot type information gets pushed into the upper 2 bytes of photFlags
     85    stars[i].measure.photFlags = (smpdata[i].dophot << 16);
     86
     87    stars[i].measure.FWx       = ShortPixels (smpdata[i].fx);
     88    stars[i].measure.FWy       = ShortPixels (smpdata[i].fy);
     89    stars[i].measure.theta     = ShortDegree (smpdata[i].df);
    8890  }   
    8991  *nstars = Nstars;
    … …  
    103105  ALLOCATE (stars, Stars, Nstars);
    104106  for (i = 0; i < Nstars; i++) {
    105     stars[i].Xccd    = ps1data[i].X;
    106     stars[i].Yccd    = ps1data[i].Y;
    107     stars[i].dXccd   = ps1data[i].dX;
    108     stars[i].dYccd   = ps1data[i].dY;
     107    InitStar (&stars[i]);
     108    stars[i].measure.Xccd     = ps1data[i].X;
     109    stars[i].measure.Yccd     = ps1data[i].Y;
     110
     111    stars[i].measure.dXccd    = ShortPixels(ps1data[i].dX);
     112    stars[i].measure.dYccd    = ShortPixels(ps1data[i].dY);
     113   
    109114    if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) {
    110       stars[i].M     = NAN;
    111     } else {
    112       stars[i].M     = ps1data[i].M + ZeroPt;
    113     }
    114     stars[i].dM      = ps1data[i].dM;
    115     stars[i].Mpeak   = ps1data[i].Mpeak;
    116 
    117     stars[i].Sky     = ps1data[i].sky;
    118     stars[i].dSky    = ps1data[i].dSky;
    119 
    120     stars[i].fx      = ps1data[i].fx;
    121     stars[i].fy      = ps1data[i].fy;
    122     stars[i].df      = ps1data[i].df;
    123 
    124     stars[i].psfChisq = ps1data[i].psfChisq;
    125     stars[i].psfQual  = ps1data[i].psfQual;
    126 
    127     stars[i].detID   = ps1data[i].detID;
    128 
    129     /* these are set elsewhere */
    130     stars[i].R       = 0.0;
    131     stars[i].D       = 0.0;
    132     stars[i].dR      = 0.0;
    133     stars[i].dD      = 0.0;
    134 
    135     stars[i].uR      = 0.0;
    136     stars[i].uD      = 0.0;
    137     stars[i].duR     = 0.0;
    138     stars[i].duD     = 0.0;
    139 
    140     stars[i].P       = 0.0;
    141     stars[i].dP      = 0.0;
    142 
    143     stars[i].Mcal    = 0;
    144     stars[i].t       = 0;
    145     stars[i].dt      = 0;
    146     stars[i].airmass = 0;
    147     stars[i].photcode    = 0;
    148     stars[i].found   = 0;
    149 
    150     /* these are not used */
    151     stars[i].Map     = NAN;
     115      stars[i].measure.M      = NAN;
     116    } else {
     117      stars[i].measure.M      = ps1data[i].M + ZeroPt;
     118    }
     119    stars[i].measure.Map      = NAN;
     120    stars[i].measure.dM       = ps1data[i].dM;
     121    stars[i].measure.Sky      = ps1data[i].sky;
     122    stars[i].measure.dSky     = ps1data[i].dSky;
     123
     124    stars[i].measure.FWx      = ShortPixels(ps1data[i].fx);
     125    stars[i].measure.FWy      = ShortPixels(ps1data[i].fy);
     126    stars[i].measure.theta    = ShortDegree(ps1data[i].df);
     127
     128    stars[i].measure.psfChisq = ps1data[i].psfChisq;
     129    stars[i].measure.psfQual  = ps1data[i].psfQual;
     130
     131    stars[i].measure.detID    = ps1data[i].detID;
    152132  }   
    153133  *nstars = Nstars;
    … …  
    169149  ALLOCATE (stars, Stars, Nstars);
    170150  for (i = 0; i < Nstars; i++) {
    171     stars[i].Xccd       = ps1data[i].X;
    172     stars[i].Yccd       = ps1data[i].Y;
    173     stars[i].dXccd      = ps1data[i].dX;
    174     stars[i].dYccd      = ps1data[i].dY;
     151    InitStar (&stars[i]);
     152    stars[i].measure.Xccd       = ps1data[i].X;
     153    stars[i].measure.Yccd       = ps1data[i].Y;
     154
     155    stars[i].measure.dXccd      = ShortPixels(ps1data[i].dX);
     156    stars[i].measure.dYccd      = ShortPixels(ps1data[i].dY);
     157
    175158    if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) {
    176         stars[i].M   = NAN;
    177     } else {
    178         stars[i].M   = ps1data[i].M + ZeroPt;
    179     }
    180     stars[i].dM      = ps1data[i].dM;
    181     stars[i].Mpeak   = ps1data[i].Mpeak;
    182 
    183     stars[i].Sky     = ps1data[i].sky;
    184     stars[i].dSky    = ps1data[i].dSky;
    185 
    186     stars[i].fx      = ps1data[i].fx;
    187     stars[i].fy      = ps1data[i].fy;
    188     stars[i].df      = ps1data[i].df;
    189 
    190     stars[i].psfChisq  = ps1data[i].psfChisq;
    191     stars[i].psfQual   = ps1data[i].psfQual;
    192     stars[i].crNsigma  = ps1data[i].crNsigma;
    193     stars[i].extNsigma = ps1data[i].extNsigma;
    194 
    195     stars[i].detID     = ps1data[i].detID;
    196     stars[i].photFlags     = ps1data[i].flags;
    197 
    198     // XXX not defined anyway
    199     // stars[i].stargal   = ps1data[i].stargal;
    200 
    201     /* these are set elsewhere */
    202     stars[i].R       = 0.0;
    203     stars[i].D       = 0.0;
    204     stars[i].dR      = 0.0;
    205     stars[i].dD      = 0.0;
    206 
    207     stars[i].uR      = 0.0;
    208     stars[i].uD      = 0.0;
    209     stars[i].duR     = 0.0;
    210     stars[i].duD     = 0.0;
    211 
    212     stars[i].P       = 0.0;
    213     stars[i].dP      = 0.0;
    214 
    215     stars[i].Mcal    = 0;
    216     stars[i].t       = 0;
    217     stars[i].dt      = 0;
    218     stars[i].airmass = 0;
    219     stars[i].az      = 0;
    220     stars[i].photcode    = 0;
    221     stars[i].found   = 0;
    222 
    223     /* these are not used */
    224     stars[i].Map     = NAN;
    225   }   
    226   *nstars = Nstars;
    227   return (stars);
    228 }
     159        stars[i].measure.M      = NAN;
     160    } else {
     161        stars[i].measure.M      = ps1data[i].M + ZeroPt;
     162    }
     163    stars[i].measure.Map        = NAN;
     164    stars[i].measure.dM         = ps1data[i].dM;
     165    stars[i].measure.Sky        = ps1data[i].sky;
     166    stars[i].measure.dSky       = ps1data[i].dSky;
     167
     168    stars[i].measure.FWx        = ShortPixels(ps1data[i].fx);
     169    stars[i].measure.FWy        = ShortPixels(ps1data[i].fy);
     170    stars[i].measure.theta      = ShortDegree(ps1data[i].df);
     171
     172    stars[i].measure.psfChisq   = ps1data[i].psfChisq;
     173    stars[i].measure.psfQual    = ps1data[i].psfQual;
     174    stars[i].measure.crNsigma   = ps1data[i].crNsigma;
     175    stars[i].measure.extNsigma  = ps1data[i].extNsigma;
     176
     177    stars[i].measure.detID      = ps1data[i].detID;
     178    stars[i].measure.photFlags  = ps1data[i].flags;
     179  }   
     180  *nstars = Nstars;
     181  return (stars);
     182}
     183
     184Stars *Convert_PS1_V1 (FTable *table, int *nstars) {
     185
     186  int i, Nstars;
     187  double ZeroPt;
     188  Stars *stars;
     189  CMF_PS1_V1 *ps1data;
     190
     191  ps1data = gfits_table_get_CMF_PS1_V1 (table, &Nstars, NULL);
     192  ZeroPt = GetZeroPoint();
     193
     194  ALLOCATE (stars, Stars, Nstars);
     195  for (i = 0; i < Nstars; i++) {
     196    InitStar (&stars[i]);
     197    stars[i].measure.Xccd       = ps1data[i].X;
     198    stars[i].measure.Yccd       = ps1data[i].Y;
     199    stars[i].measure.dXccd      = ShortPixels(ps1data[i].dX);
     200    stars[i].measure.dYccd      = ShortPixels(ps1data[i].dY);
     201
     202    stars[i].measure.posangle   = ShortDegree(ps1data[i].posangle);
     203    stars[i].measure.pltscale   = ps1data[i].pltscale;
     204
     205    if ((ps1data[i].M >= 0.0) || isnan(ps1data[i].M)) {
     206        stars[i].measure.M      = NAN;
     207    } else {
     208        stars[i].measure.M      = ps1data[i].M + ZeroPt;
     209    }
     210    stars[i].measure.dM         = ps1data[i].dM;
     211    stars[i].measure.dMcal      = ps1data[i].dMcal;
     212    stars[i].measure.Map        = ps1data[i].Map;
     213                       
     214    stars[i].measure.Sky        = ps1data[i].sky;
     215    stars[i].measure.dSky       = ps1data[i].dSky;
     216                       
     217    stars[i].measure.psfChisq   = ps1data[i].psfChisq;
     218    stars[i].measure.psfQual    = ps1data[i].psfQual;
     219    stars[i].measure.psfNdof    = ps1data[i].psfNdof;
     220    stars[i].measure.psfNpix    = ps1data[i].psfNpix;
     221    stars[i].measure.crNsigma   = ps1data[i].crNsigma;
     222    stars[i].measure.extNsigma  = ps1data[i].extNsigma;
     223
     224    stars[i].measure.FWx        = ShortPixels(ps1data[i].fx);
     225    stars[i].measure.FWy        = ShortPixels(ps1data[i].fy);
     226    stars[i].measure.theta      = ShortDegree(ps1data[i].df);
     227
     228    stars[i].measure.Mxx        = ShortPixels(ps1data[i].Mxx);
     229    stars[i].measure.Mxy        = ShortPixels(ps1data[i].Mxy);
     230    stars[i].measure.Myy        = ShortPixels(ps1data[i].Myy);
     231                       
     232    stars[i].measure.photFlags  = ps1data[i].flags;
     233
     234    // this is may optionally be replaced by the internal sequence (see FilterStars.c)
     235    stars[i].measure.detID      = ps1data[i].detID;
     236
     237    // the Average fields and the following Measure fields are set in FilterStars after
     238    // the image metadata is in hand:  dR, dD, Mcal, dt, airmass, az, t, imageID, extID,
     239    // averef is set in find_matches, dbFlags is zero on ingest.
     240
     241    // the following fields are currently not being set anywhere: t_msec
     242  }   
     243  *nstars = Nstars;
     244  return (stars);
     245}

  • branches/eam_branch_20090208/Ohana/src/addstar/src/ReadStarsSDSS.c

    r21419 r21444  
    140140    for (j = 0; j < NFILTER; j++) {
    141141      N = NFILTER*i + j;
    142       stars[N].Xccd      = colc[N];
    143       stars[N].Yccd      = rowc[N];
    144       stars[N].dXccd     = colcErr[N];
    145       stars[N].dYccd     = rowcErr[N];
    146       stars[N].M         = psfCounts[N] + ZeroPt - zeropt[j];
    147       stars[N].dM        = psfCountsErr[N];
    148       stars[N].Map       = fiberCounts[N] + ZeroPt - zeropt[j];
    149       stars[N].Mpeak     = NAN;
    150       stars[N].Sky       = sky[N]; // adjust this to counts?
    151       stars[N].dSky      = skyErr[N];
    152       stars[N].fx        = seeing[j]; // reported in arcsec?
    153       stars[N].fy        = seeing[j];
    154       stars[N].df        = 0.0;
    155       stars[N].psfChisq  = prob_psf[N]; // XXX not really the correct value...
    156       stars[N].psfQual   = 0.0;
    157       stars[N].crNsigma  = 0.0;
    158       stars[N].extNsigma = 0.0;
    159       stars[N].detID     = N;
    160       stars[N].R         = ra[i] + dCOS(dec[i]) * offsetRa[N] / 3600.0;
    161       stars[N].D         = dec[i] + offsetDec[N] / 3600.0;
    162       stars[N].dR        = NAN;
    163       stars[N].dD        = NAN;
    164       stars[N].uR        = 0.0; // I don't trust the SDSS proper motions
    165       stars[N].uD        = 0.0; // I don't trust the SDSS proper motions
    166       stars[N].duR       = 0.0;
    167       stars[N].duD       = 0.0;
    168       stars[N].P         = 0.0;
    169       stars[N].dP        = 0.0;
    170       stars[N].Mcal      = 0.0;
    171       stars[N].t         = tzero[j] + clockRate*rowc[N]; // time since row 0
    172       stars[N].dt        = 53.907456; // is this 2048*clockRate ?
     142      InitStar (&stars[N]);
     143     
     144      // any values not explicitly set are left at 0.0
     145      stars[N].average.R         = ra[i] + dCOS(dec[i]) * offsetRa[N] / 3600.0;
     146      stars[N].average.D         = dec[i] + offsetDec[N] / 3600.0;
     147      stars[N].average.dR        = NAN;
     148      stars[N].average.dD        = NAN;
     149
     150      stars[N].measure.Xccd      = colc[N];
     151      stars[N].measure.Yccd      = rowc[N];
     152      stars[N].measure.dXccd     = ShortPixels(colcErr[N]);
     153      stars[N].measure.dYccd     = ShortPixels(rowcErr[N]);
     154      stars[N].measure.M         = psfCounts[N] + ZeroPt - zeropt[j];
     155      stars[N].measure.dM        = psfCountsErr[N];
     156      stars[N].measure.Map       = fiberCounts[N] + ZeroPt - zeropt[j];
     157      stars[N].measure.Sky       = sky[N]; // adjust this to counts?
     158      stars[N].measure.dSky      = skyErr[N];
     159      stars[N].measure.FWx       = ShortPixels(seeing[j]); // reported in arcsec?
     160      stars[N].measure.FWy       = ShortPixels(seeing[j]);
     161      stars[N].measure.psfChisq  = prob_psf[N]; // XXX not really the correct value...
     162      stars[N].measure.detID     = N;
     163      stars[N].measure.t         = tzero[j] + clockRate*rowc[N]; // time since row 0
     164      stars[N].measure.dt        = 53.907456; // is this 2048*clockRate ?
    173165
    174166      SetSDSSFlags (&stars[N], flags[N], flags2[N]);
    … …  
    182174      double Latitude = 32.7803611755; // degrees
    183175
    184       jd = ohana_sec_to_jd (stars[N].t);
     176      jd = ohana_sec_to_jd (stars[N].measure.t);
    185177      sidtime  = 15.0*ohana_lst (jd, Longitude); // sidtime in degrees
    186       altaz (&alt, &az, sidtime - stars[N].R, stars[N].D, Latitude);
    187 
    188       stars[N].airmass   = 1.0 / dCOS(90.0 - alt);
    189       stars[N].az        = az;
    190 
    191       stars[N].photcode  = photcode[j];
    192       stars[N].found     = -1;
     178      altaz (&alt, &az, sidtime - stars[N].average.R, stars[N].average.D, Latitude);
     179
     180      stars[N].measure.airmass   = 1.0 / dCOS(90.0 - alt);
     181      stars[N].measure.az        = az;
     182      stars[N].measure.photcode  = photcode[j];
    193183    }
    194184  }   
    … …  
    201191    strcpy (images[N].coords.ctype, "RA---TAN");
    202192   
    203     images[N].coords.crval1 = stars[0].R;
    204     images[N].coords.crval2 = stars[0].D;
     193    images[N].coords.crval1 = stars[0].average.R;
     194    images[N].coords.crval2 = stars[0].average.D;
    205195   
    206     images[N].coords.crpix1 = stars[0].Xccd;
    207     images[N].coords.crpix2 = stars[0].Yccd;
     196    images[N].coords.crpix1 = stars[0].measure.Xccd;
     197    images[N].coords.crpix2 = stars[0].measure.Yccd;
    208198    images[N].coords.cdelt1 = images[N].coords.cdelt2 = 0.4 / 3600.0;
    209199
    … …  
    250240
    251241    images[N].trate = clockRate * 1e-4;
    252     images[N].secz = stars[0].airmass;
     242    images[N].secz = stars[0].measure.airmass;
    253243    images[N].ccdnum = camcol;
    254244
    … …  
    296286
    297287  // XXX this is wrong, need to roll left to set the correct bit
    298   if (flags1 & 0x00000002) star[0].photFlags |= 0x0001; // BRIGHT            - 1  1
    299   if (flags1 & 0x00000004) star[0].photFlags |= 0x0002; // EDGE              - 1  2
    300   if (flags1 & 0x00000008) star[0].photFlags |= 0x0004; // BLENDED           - 1  3
    301   if (flags1 & 0x00000010) star[0].photFlags |= 0x0008; // CHILD             - 1  4
    302   if (flags1 & 0x00000020) star[0].photFlags |= 0x0010; // PEAKCENTER        - 1  5
    303   if (flags1 & 0x00000040) star[0].photFlags |= 0x0020; // NODEBLEND         - 1  6
    304   if (flags1 & 0x00040000) star[0].photFlags |= 0x0040; // SATUR             - 1 18
    305   if (flags1 & 0x00080000) star[0].photFlags |= 0x0080; // NOTCHECKED        - 1 19
    306   if (flags1 & 0x10000000) star[0].photFlags |= 0x0100; // BINNED1           - 1 28
    307   if (flags1 & 0x20000000) star[0].photFlags |= 0x0200; // BINNED2           - 1 29
    308   if (flags1 & 0x40000000) star[0].photFlags |= 0x0400; // BINNED4           - 1 30
    309   if (flags2 & 0x00000040) star[0].photFlags |= 0x0800; // LOCAL_EDGE        - 2  7
    310   if (flags2 & 0x00000800) star[0].photFlags |= 0x1000; // INTERP_CENTER     - 2 12
    311   if (flags2 & 0x00002000) star[0].photFlags |= 0x2000; // DEBLEND_NOPEAK    - 2 14
    312   if (flags2 & 0x02000000) star[0].photFlags |= 0x4000; // NOTCHECKED_CENTER - 2 26
     288  if (flags1 & 0x00000002) star[0].measure.photFlags |= 0x0001; // BRIGHT            - 1  1
     289  if (flags1 & 0x00000004) star[0].measure.photFlags |= 0x0002; // EDGE              - 1  2
     290  if (flags1 & 0x00000008) star[0].measure.photFlags |= 0x0004; // BLENDED           - 1  3
     291  if (flags1 & 0x00000010) star[0].measure.photFlags |= 0x0008; // CHILD             - 1  4
     292  if (flags1 & 0x00000020) star[0].measure.photFlags |= 0x0010; // PEAKCENTER        - 1  5
     293  if (flags1 & 0x00000040) star[0].measure.photFlags |= 0x0020; // NODEBLEND         - 1  6
     294  if (flags1 & 0x00040000) star[0].measure.photFlags |= 0x0040; // SATUR             - 1 18
     295  if (flags1 & 0x00080000) star[0].measure.photFlags |= 0x0080; // NOTCHECKED        - 1 19
     296  if (flags1 & 0x10000000) star[0].measure.photFlags |= 0x0100; // BINNED1           - 1 28
     297  if (flags1 & 0x20000000) star[0].measure.photFlags |= 0x0200; // BINNED2           - 1 29
     298  if (flags1 & 0x40000000) star[0].measure.photFlags |= 0x0400; // BINNED4           - 1 30
     299  if (flags2 & 0x00000040) star[0].measure.photFlags |= 0x0800; // LOCAL_EDGE        - 2  7
     300  if (flags2 & 0x00000800) star[0].measure.photFlags |= 0x1000; // INTERP_CENTER     - 2 12
     301  if (flags2 & 0x00002000) star[0].measure.photFlags |= 0x2000; // DEBLEND_NOPEAK    - 2 14
     302  if (flags2 & 0x02000000) star[0].measure.photFlags |= 0x4000; // NOTCHECKED_CENTER - 2 26
    313303  return (TRUE);
    314304

  • branches/eam_branch_20090208/Ohana/src/addstar/src/ReadStarsTEXT.c

    r21419 r21444  
    99  int done, itmp;
    1010  char *buffer, *c, *c2;
    11   double tmp;
     11  double tmp, fx, fy, df;
    1212  double ZeroPt;
    1313  Stars *stars;
    … …  
    6666    Nextra = nbytes % BYTES_STAR;
    6767    for (j = 0; (j < Ninstar) && (N < *nstars); j++, N++) {
    68       dparse (&stars[N].Xccd,  1, &buffer[j*BYTES_STAR]);
    69       dparse (&stars[N].Yccd,  2, &buffer[j*BYTES_STAR]);
    70       dparse (&stars[N].M,  3, &buffer[j*BYTES_STAR]);
    71       if ((stars[N].M > ZeroPt) || isnan(stars[N].M)) {
    72         stars[N].M = NAN;
     68      InitStar (&stars[N]);
     69      fparse (&stars[N].measure.Xccd,  1, &buffer[j*BYTES_STAR]);
     70      fparse (&stars[N].measure.Yccd,  2, &buffer[j*BYTES_STAR]);
     71      fparse (&stars[N].measure.M,  3, &buffer[j*BYTES_STAR]);
     72      if ((stars[N].measure.M > ZeroPt) || isnan(stars[N].measure.M)) {
     73        stars[N].measure.M = NAN;
    7374      }
    7475
    7576      /* cmp files carry dM in millimags */
    7677      dparse (&tmp, 4, &buffer[j*BYTES_STAR]);
    77       stars[N].dM = 0.001*tmp;
     78      stars[N].measure.dM = 0.001*tmp;
    7879
    7980      // the dophot type information get pushed into the upper 2 bytes of photFlags
    8081      dparse (&tmp,         5, &buffer[j*BYTES_STAR]);
    8182      itmp = tmp;
    82       stars[N].photFlags = (itmp << 16);
     83      stars[N].measure.photFlags = (itmp << 16);
    8384
    8485      // XXX I've removed the Mgal field from the measure.d table, and am using Map
    … …  
    8990
    9091      // dparse (&stars[N].Mgal, 7, &buffer[j*BYTES_STAR]);
    91       dparse (&stars[N].Map,  8, &buffer[j*BYTES_STAR]);
    92       dparse (&stars[N].fx,   9, &buffer[j*BYTES_STAR]);
    93       dparse (&stars[N].fy,  10, &buffer[j*BYTES_STAR]);
    94       dparse (&stars[N].df,  11, &buffer[j*BYTES_STAR]);
     92      fparse (&stars[N].measure.Map,  8, &buffer[j*BYTES_STAR]);
     93      dparse (&fx,   9, &buffer[j*BYTES_STAR]);
     94      dparse (&fy,  10, &buffer[j*BYTES_STAR]);
     95      dparse (&df,  11, &buffer[j*BYTES_STAR]);
     96
     97      stars[N].measure.FWx   = ShortPixels (fx);
     98      stars[N].measure.FWy   = ShortPixels (fy);
     99      stars[N].measure.theta = ShortDegree (df);
    95100    }
    96101  }

  • branches/eam_branch_20090208/Ohana/src/addstar/src/SkyListForStars.c

    r16040 r21444  
    11# include "addstar.h"
     2
     3void sort_stars_ra (Stars *stars, int N) {
     4
     5# define SWAPFUNC(A,B){ Stars tmp; tmp = stars[A]; stars[A] = stars[B]; stars[B] = tmp; }
     6# define COMPARE(A,B)(stars[A].average.R < stars[B].average.R)
     7
     8  OHANA_SORT (N, COMPARE, SWAPFUNC);
     9
     10# undef SWAPFUNC
     11# undef COMPARE
     12
     13}
    214
    315SkyList *SkyListForStars (SkyTable *table, int depth, Stars *stars, int Nstars) {
    … …  
    1729  sort_stars_ra (stars, Nstars); /* sort by RA */
    1830  for (i = 0; i < Nstars; i++) {
    19     if (stars[i].found) continue;
    20     here = SkyRegionByPoint (table, depth, stars[i].R, stars[i].D);
    21     stars[i].found = TRUE;
     31    if (stars[i].found == -2) continue;
     32    here = SkyRegionByPoint (table, depth, stars[i].average.R, stars[i].average.D);
     33    stars[i].found = -2;
    2234    /* search forward for all contained stars */
    2335    for (j = i; j < Nstars; j++) {
    24       if (stars[j].R >= here[0].regions[0][0].Rmax) break;
    25       if (stars[j].R <  here[0].regions[0][0].Rmin) break;
    26       if (stars[j].D <  here[0].regions[0][0].Dmin) continue;
    27       if (stars[j].D >= here[0].regions[0][0].Dmax) continue;
    28       stars[j].found = TRUE;
     36      if (stars[j].average.R >= here[0].regions[0][0].Rmax) break;
     37      if (stars[j].average.R <  here[0].regions[0][0].Rmin) break;
     38      if (stars[j].average.D <  here[0].regions[0][0].Dmin) continue;
     39      if (stars[j].average.D >= here[0].regions[0][0].Dmax) continue;
     40      stars[j].found = -2;
    2941    }
    3042    list[0].regions[Nr] = here[0].regions[0];

  • branches/eam_branch_20090208/Ohana/src/addstar/src/UpdateImageIDs.c

    r20182 r21444  
    4343
    4444  for (i = 0; i < Nstars; i++) {
    45     stars[i].imageID += imageID;
     45    stars[i].measure.imageID += imageID;
    4646  }
    4747
    4848  imageID += Nimages;
    4949  status = gfits_modify (&db.header, "IMAGEID", "%u", 1, imageID);
    50  
    5150
    5251  if (isEmpty) {

  • branches/eam_branch_20090208/Ohana/src/addstar/src/addstar.c

    r18721 r21444  
    135135        break;
    136136      case M_REFCAT:
    137         stars = grefcat (argv[1], skylist[0].regions[i], options.photcode, &Nstars);
     137        stars = greference (argv[1], skylist[0].regions[i], options.photcode, &Nstars);
    138138      case M_REFLIST:
    139139        subset = find_subset (skylist[0].regions[i], stars, Nstars, &Nsubset);

  • branches/eam_branch_20090208/Ohana/src/addstar/src/airmass.c

    r8642 r21444  
    11# include "addstar.h"
    22
    3 static int AirmassQuality = FALSE;
     3static int AirmassQuality = TRUE;
    44
    55void SetAirmassQuality (int quality) {
    … …  
    2525  return (secz);
    2626}
     27
     28// ha/dec -> az
     29float azimuth (double ha, double dec, double latitude) {
     30
     31  double rdec, rlat, rha;
     32  double sinh, cosh;
     33  float az;
     34
     35  rdec = RAD_DEG*dec;
     36  rha = RAD_DEG*ha;
     37  rlat = RAD_DEG*latitude;
     38
     39  sinh = - cos (rdec) * sin (rha);
     40  cosh =   sin (rdec) * cos (rlat) - cos (rdec) * cos (rha) * sin (rlat);
     41
     42  az = DEG_RAD * atan2 (sinh, cosh);
     43
     44  return az;
     45}

  • branches/eam_branch_20090208/Ohana/src/addstar/src/args.c

    r20183 r21444  
    2828    remove_argument (N, &argc, argv);
    2929  }
     30  if ((N = get_argument (argc, argv, "-resort"))) {
     31    options.mode = M_RESORT;
     32    remove_argument (N, &argc, argv);
     33  }
    3034  if ((N = get_argument (argc, argv, "-fakeimage"))) {
    3135    options.mode = M_FAKEIMAGE;
    … …  
    3640    remove_argument (N, &argc, argv);
    3741    FAKE_THETA = atof (argv[N]);
    38     remove_argument (N, &argc, argv);
    39   }
    40   if ((N = get_argument (argc, argv, "-resort"))) {
    41     options.mode = M_RESORT;
    4242    remove_argument (N, &argc, argv);
    4343  }
    … …  
    221221  /*** optional situations ***/
    222222  /* choose high quality airmass vs low quality airmass (per-star vs per-image) */
    223   QUALITY_AIRMASS = FALSE;
     223  QUALITY_AIRMASS = TRUE;
    224224  if ((N = get_argument (argc, argv, "-quality-airmass"))) {
    225225    remove_argument (N, &argc, argv);
    226226    QUALITY_AIRMASS = TRUE;
     227  }
     228  if ((N = get_argument (argc, argv, "-quick-airmass"))) {
     229    remove_argument (N, &argc, argv);
     230    QUALITY_AIRMASS = FALSE;
    227231  }
    228232  /* choose high quality airmass vs low quality airmass (per-star vs per-image) */
    … …  
    310314
    311315  fprintf (stderr, "USAGE: addstar (filename)\n");
     316  fprintf (stderr, "USAGE: addstar -list (filename)\n");
    312317  fprintf (stderr, "USAGE: addstar -cat (catalog)\n");
    313318  fprintf (stderr, "USAGE: addstar -ref (filename)\n");
    314319  fprintf (stderr, "USAGE: addstar -fakeimage (ra) (dec) (theta) (name)\n");
    315320  fprintf (stderr, "USAGE: addstar -resort (SkyRegion)\n");
     321  fprintf (stderr, "USAGE: addstar -ppm (filename)\n");
    316322  exit (2);
    317323}
    … …  
    322328  fprintf (stderr, "  addstar (filename)\n");
    323329  fprintf (stderr, "     add specified image (cmp format) to database\n\n");
     330  fprintf (stderr, "  addstar -list (filename)\n");
     331  fprintf (stderr, "     add list of images (cmp format) to database\n\n");
    324332  fprintf (stderr, "  addstar -ref (filename)");
    325333  fprintf (stderr, "     add ASCII data (ra dec mag dmag) to database\n\n");
    … …  
    328336  fprintf (stderr, "  addstar -resort (SkyRegion)");
    329337  fprintf (stderr, "     perform measure sorting for the specified catalog\n\n");
     338  fprintf (stderr, "  addstar -fakeimage (ra) (dec) (theta) (name)");
     339  fprintf (stderr, "     insert a fake image in the db\n\n");
     340  fprintf (stderr, "  addstar -pmm (filename)");
     341  fprintf (stderr, "     insert pmm table into database\n\n");
    330342
    331343  fprintf (stderr, "  optional flags:\n");
    … …  
    340352  fprintf (stderr, "  -missed                     : skipped 'missed' entries\n");
    341353  fprintf (stderr, "  -replace                    : replace time/photcode measurements (no duplication)\n");
    342   fprintf (stderr, "  -closest                    : use closest-star algorith\n");
     354  fprintf (stderr, "  -closest                    : use closest-star algorith (default)\n");
     355  fprintf (stderr, "  -all-matches                : use all-matches algorith\n");
    343356  fprintf (stderr, "  -nosort                     : don't re-sort the measure entries (improves speed)\n");
    344357  fprintf (stderr, "  -update                     : only update the new rows (forces -nosort)\n");
     358  fprintf (stderr, "  -force-sort                 : \n");
    345359  fprintf (stderr, "  -image                      : only insert image data\n");
    346360  fprintf (stderr, "  -cal                        : perform zero-point calibration\n");
     361  fprintf (stderr, "  -excal                      : apply supplied zero-point calibration\n");
     362  fprintf (stderr, "  -incal                      : perform zero-point calibration\n");
     363  fprintf (stderr, "  -quality-airmass            : use per-star airmass values (default)\n");
     364  fprintf (stderr, "  -quick-airmass              : use per-image airmass values\n");
     365  fprintf (stderr, "  -subpix                     : apply subpixel corrections\n");
    347366  fprintf (stderr, "  -skyprobe                   : specify skyprobe mode\n");
     367  fprintf (stderr, "  -2massquality               : define 2MASS quality flags to keep\n");
    348368  fprintf (stderr, "  -accept                     : accept bad astrometry from header\n");
    349369  fprintf (stderr, "  -accept-astrom              : accept bad astrometry from header\n");
    350370  fprintf (stderr, "  -accept-motion              : accept proper-motion data from reference\n");
     371  fprintf (stderr, "  -accept-time                : use TZERO supplied in header\n");
     372  fprintf (stderr, "  -no-stars                   : skip the stars\n");
    351373  fprintf (stderr, "  -force                      : force read of database with inconsistent info\n");
     374  fprintf (stderr, "  -textmode                   : force textmode for file (ignore header clues)\n");
    352375  fprintf (stderr, "  -v                          : verbose mode\n");
    353376  fprintf (stderr, "  -dump (mode)                : output test data. Currently supported values for mode are: 'rawdata', 'cal'.\n");

  • branches/eam_branch_20090208/Ohana/src/addstar/src/dump.c

    r21419 r21444  
    1111    fprintf (f, "%4d  %10.6f %10.6f  %8.2f %8.2f  %7.2f %7.2f\n",
    1212             i,
    13              stars[i].R, stars[i].D,
    14              stars[i].Xccd, stars[i].Yccd,
    15              stars[i].M, stars[i].dM);
     13             stars[i].average.R, stars[i].average.D,
     14             stars[i].measure.Xccd, stars[i].measure.Yccd,
     15             stars[i].measure.M, stars[i].measure.dM);
    1616  }
    1717

  • branches/eam_branch_20090208/Ohana/src/addstar/src/find_matches.c

    r21419 r21444  
    6262  strcpy (tcoords.ctype, "RA---ARC");
    6363
    64   /* build spatial index (RA sort) */
     64  /* build spatial index (RA sort) referencing input array sequence */
    6565  Nstars = 0;
    6666  for (i = 0; i < NstarsIn; i++) {
    67     status = RD_to_XY (&X1[Nstars], &Y1[Nstars], stars[i].R, stars[i].D, &tcoords);
     67    status = RD_to_XY (&X1[Nstars], &Y1[Nstars], stars[i].average.R, stars[i].average.D, &tcoords);
    6868    if (!status) continue;
    6969    N1[Nstars] = i;
    … …  
    104104  /** find matched stars **/
    105105  for (i = j = 0; (i < Nstars) && (j < Nave); ) {
    106         if (!finite(X1[i]) || !finite(Y1[i])) {
     106    if (!finite(X1[i]) || !finite(Y1[i])) {
    107107      i++;
    108108      continue;
    … …  
    147147
    148148      /** add measurements for this star **/
    149       /** dR,dD now represent arcsec **/
    150       catalog[0].measure[Nmeas].dR       = 3600.0*(catalog[0].average[n].R - stars[N].R);
     149
     150      // set the new measurements
     151      catalog[0].measure[Nmeas]          = stars[N].measure;
     152
     153      // the following measure elements cannot be set until here:
     154      catalog[0].measure[Nmeas].dR       = 3600.0*(catalog[0].average[n].R - stars[N].average.R);
     155      catalog[0].measure[Nmeas].dD       = 3600.0*(catalog[0].average[n].D - stars[N].average.D);
     156      catalog[0].measure[Nmeas].dbFlags  = 0;
     157      catalog[0].measure[Nmeas].averef   = n; // this must be an absolute sequence number, if partial average is loaded
     158
     159      // rationalize dR:
    151160      if (catalog[0].measure[Nmeas].dR > +180.0*3600.0) {
    152161          // average on high end of boundary, move star up
    153           stars[N].R += 360.0;
    154           catalog[0].measure[Nmeas].dR = 3600.0*(catalog[0].average[n].R - stars[N].R);
     162          stars[N].average.R += 360.0;
     163          catalog[0].measure[Nmeas].dR = 3600.0*(catalog[0].average[n].R - stars[N].average.R);
    155164      }
    156165      if (catalog[0].measure[Nmeas].dR < -180.0*3600.0) {
    157166          // average on low end of boundary, move star down
    158           stars[N].R -= 360.0;
    159           catalog[0].measure[Nmeas].dR = 3600.0*(catalog[0].average[n].R - stars[N].R);
     167          stars[N].average.R -= 360.0;
     168          catalog[0].measure[Nmeas].dR = 3600.0*(catalog[0].average[n].R - stars[N].average.R);
    160169      }
    161170      if (fabs(catalog[0].measure[Nmeas].dR) > 10*RADIUS) {
    162171          fprintf (stderr, "error: %10.6f,%10.6f vs %10.6f,%10.6f (%f,%f vs %f,%f)\n",
    163172                   catalog[0].average[n].R, catalog[0].average[n].D,
    164                    stars[N].R, stars[N].D,
     173                   stars[N].average.R, stars[N].average.D,
    165174                   X1[i], X2[J],
    166175                   Y1[i], Y2[J]);
    167176      }
    168       catalog[0].measure[Nmeas].dD       = 3600.0*(catalog[0].average[n].D - stars[N].D);
    169 
    170       catalog[0].measure[Nmeas].Xccd     = stars[N].Xccd;
    171       catalog[0].measure[Nmeas].Yccd     = stars[N].Yccd;
    172 
    173       catalog[0].measure[Nmeas].M        = stars[N].M;
    174       catalog[0].measure[Nmeas].dM       = stars[N].dM;  /* error in input files stored in thousandths of mag */
    175       catalog[0].measure[Nmeas].Mcal     = stars[N].Mcal;
    176       catalog[0].measure[Nmeas].t        = stars[N].t;
    177       catalog[0].measure[Nmeas].photcode = stars[N].photcode;
    178       catalog[0].measure[Nmeas].dt       = stars[N].dt;
    179       catalog[0].measure[Nmeas].airmass  = stars[N].airmass;
    180 
    181       catalog[0].measure[Nmeas].photFlags = stars[N].photFlags;
    182       catalog[0].measure[Nmeas].psfQual   = stars[N].psfQual;
    183       catalog[0].measure[Nmeas].psfChisq  = stars[N].psfChisq;
    184       catalog[0].measure[Nmeas].crNsigma  = stars[N].crNsigma;
    185       catalog[0].measure[Nmeas].extNsigma = stars[N].extNsigma;
    186       catalog[0].measure[Nmeas].Sky       = stars[N].Sky;
    187       catalog[0].measure[Nmeas].dSky      = stars[N].dSky;
    188 
    189       catalog[0].measure[Nmeas].stargal   = 0; // XXX not yet set
    190 
    191       catalog[0].measure[Nmeas].detID     = stars[N].detID;
    192       catalog[0].measure[Nmeas].imageID   = stars[N].imageID;
    193 
    194       catalog[0].measure[Nmeas].dXccd     = stars[N].dXccd;
    195       catalog[0].measure[Nmeas].dYccd     = stars[N].dYccd;
    196 
    197       catalog[0].measure[Nmeas].Map      = stars[N].Map;
    198       catalog[0].measure[Nmeas].FWx      = 100*stars[N].fx;
    199       catalog[0].measure[Nmeas].FWy      = 100*stars[N].fy;
    200       catalog[0].measure[Nmeas].theta    = (0xffff/360.0)*stars[N].df;
    201        
    202       catalog[0].measure[Nmeas].dbFlags  = 0;
    203       catalog[0].measure[Nmeas].averef   = n;              /* this must be an absolute sequence number, if partial average is loaded */
    204177
    205178      /* adds the measurement to the calibration if appropriate color terms are found */
    … …  
    266239    N = N1[i];
    267240    if (stars[N].found >= 0) continue;
    268     if (!IN_REGION (stars[N].R, stars[N].D)) continue;
    269 
    270     catalog[0].average[Nave].R             = stars[N].R;
    271     catalog[0].average[Nave].D             = stars[N].D;
    272     catalog[0].average[Nave].Xp            = 0;
     241    if (!IN_REGION (stars[N].average.R, stars[N].average.D)) continue;
     242
     243    catalog[0].average[Nave].R             = stars[N].average.R;
     244    catalog[0].average[Nave].D             = stars[N].average.D;
     245    catalog[0].average[Nave].dR            = 0;
     246    catalog[0].average[Nave].dD            = 0;
     247
    273248    catalog[0].average[Nave].Nmeasure      = 1;
    274249    catalog[0].average[Nave].Nmissing      = 0;
     250    catalog[0].average[Nave].Nextend       = 0;
     251
    275252    catalog[0].average[Nave].measureOffset = Nmeas;
    276253    catalog[0].average[Nave].missingOffset = -1;
     254    catalog[0].average[Nave].extendOffset  = -1;
     255
     256    catalog[0].average[Nave].uR            = 0;
     257    catalog[0].average[Nave].uD            = 0;
     258    catalog[0].average[Nave].duR           = 0;
     259    catalog[0].average[Nave].duD           = 0;
     260    catalog[0].average[Nave].P             = 0;
     261    catalog[0].average[Nave].dP            = 0;
     262
     263    catalog[0].average[Nave].Xp            = 0;
     264    catalog[0].average[Nave].ChiSq         = 0.0;
     265    catalog[0].average[Nave].Npos          = 0;
     266
     267    catalog[0].average[Nave].objID         = objID;
     268    catalog[0].average[Nave].catID         = catID;
    277269    catalog[0].average[Nave].flags         = 0;
    278270
    279     catalog[0].average[Nave].dR        = 0;
    280     catalog[0].average[Nave].dD        = 0;
    281     catalog[0].average[Nave].uR        = 0;
    282     catalog[0].average[Nave].uD        = 0;
    283     catalog[0].average[Nave].duR       = 0;
    284     catalog[0].average[Nave].duD       = 0;
    285     catalog[0].average[Nave].P         = 0;
    286     catalog[0].average[Nave].dP        = 0;
    287 
    288     catalog[0].average[Nave].objID     = objID;
    289     catalog[0].average[Nave].catID     = catID;
    290271    objID ++;
    291272
    292273    for (j = 0; j < Nsecfilt; j++) {
    293       catalog[0].secfilt[Nave*Nsecfilt+j].M  = NAN;
    294       catalog[0].secfilt[Nave*Nsecfilt+j].dM = NAN;
    295       catalog[0].secfilt[Nave*Nsecfilt+j].Xm = NAN_S_SHORT;
    296     }
    297 
    298     catalog[0].measure[Nmeas].Xccd     = stars[N].Xccd;
    299     catalog[0].measure[Nmeas].Yccd     = stars[N].Yccd;
    300 
     274      catalog[0].secfilt[Nave*Nsecfilt+j].M     = NAN;
     275      catalog[0].secfilt[Nave*Nsecfilt+j].dM    = NAN;
     276      catalog[0].secfilt[Nave*Nsecfilt+j].Xm    = NAN_S_SHORT;
     277      catalog[0].secfilt[Nave*Nsecfilt+j].M_20  = NAN_S_SHORT;
     278      catalog[0].secfilt[Nave*Nsecfilt+j].M_80  = NAN_S_SHORT;
     279      catalog[0].secfilt[Nave*Nsecfilt+j].Ncode = 0;
     280      catalog[0].secfilt[Nave*Nsecfilt+j].Nused = 0;
     281    }
     282
     283    // supply the measurments from this detection
     284    catalog[0].measure[Nmeas]           = stars[N].measure;
     285
     286    // the following measure elements cannot be set until here:
    301287    catalog[0].measure[Nmeas].dR        = 0.0;
    302288    catalog[0].measure[Nmeas].dD        = 0.0;
    303     catalog[0].measure[Nmeas].M         = stars[N].M;
    304     catalog[0].measure[Nmeas].dM        = stars[N].dM;
    305     catalog[0].measure[Nmeas].Mcal      = stars[N].Mcal;
    306     catalog[0].measure[Nmeas].t         = stars[N].t;
    307     catalog[0].measure[Nmeas].photcode  = stars[N].photcode;
    308     catalog[0].measure[Nmeas].dt        = stars[N].dt;
    309     catalog[0].measure[Nmeas].airmass   = stars[N].airmass;
    310 
    311     catalog[0].measure[Nmeas].photFlags = stars[N].photFlags;
    312     catalog[0].measure[Nmeas].psfQual   = stars[N].psfQual;
    313     catalog[0].measure[Nmeas].psfChisq  = stars[N].psfChisq;
    314     catalog[0].measure[Nmeas].crNsigma  = stars[N].crNsigma;
    315     catalog[0].measure[Nmeas].extNsigma = stars[N].extNsigma;
    316     catalog[0].measure[Nmeas].Sky       = stars[N].Sky;
    317     catalog[0].measure[Nmeas].dSky      = stars[N].dSky;
    318 
    319     catalog[0].measure[Nmeas].detID     = stars[N].detID;
    320     catalog[0].measure[Nmeas].imageID   = stars[N].imageID;
    321 
    322     catalog[0].measure[Nmeas].dXccd     = stars[N].dXccd;
    323     catalog[0].measure[Nmeas].dYccd     = stars[N].dYccd;
    324 
    325     catalog[0].measure[Nmeas].Map       = stars[N].Map;
    326     catalog[0].measure[Nmeas].FWx       = 100*stars[N].fx;
    327     catalog[0].measure[Nmeas].FWy       = 100*stars[N].fy;
    328     catalog[0].measure[Nmeas].theta     = (0xffff/360.0)*stars[N].df;
    329 
    330     catalog[0].measure[Nmeas].stargal   = 0; // XXX not yet set
    331 
    332289    catalog[0].measure[Nmeas].dbFlags   = 0;
    333     catalog[0].measure[Nmeas].averef    = Nave;           /* XXX EAM : must be absolute Nave if partial read */
    334 
    335     /* XXX replace df here with theta, right? */
     290    catalog[0].measure[Nmeas].averef    = Nave; // XXX EAM : must be absolute Nave if partial read
    336291
    337292    /* set the average magnitude if not already set and the photcode.equiv is not 0 */

  • branches/eam_branch_20090208/Ohana/src/addstar/src/find_matches_closest.c

    r21419 r21444  
    77  double *X1, *Y1, *X2, *Y2;
    88  double dX, dY, dR;
    9   int *N1, *N2,  *next_meas, *next_miss;
    10   int Nave, NAVE, Nmeas, NMEAS, Nmiss, NMISS, Nmatch;
     9  int *N1, *N2,  *next_meas;
     10  int Nave, NAVE, Nmeas, NMEAS, Nmatch;
    1111  int Nsecfilt, Nsec;
    1212  unsigned int objID, catID;
    … …  
    3737  Nmatch = 0;
    3838  NMEAS = Nmeas = catalog[0].Nmeasure;
    39   NMISS = Nmiss = catalog[0].Nmissing;
    4039
    4140  // current max obj ID for this catalog
    … …  
    6665  Nstars = 0;
    6766  for (i = 0; i < NstarsIn; i++) {
    68     status = RD_to_XY (&X1[Nstars], &Y1[Nstars], stars[i].R, stars[i].D, &tcoords);
     67    status = RD_to_XY (&X1[Nstars], &Y1[Nstars], stars[i].average.R, stars[i].average.D, &tcoords);
    6968    if (!status) continue;
    7069    N1[Nstars] = i;
    … …  
    9291  if (Nave > 1) sort_coords_index (X2, Y2, N2, Nave);
    9392
    94   /* set up pointers for linked list of measure, missing */
     93  /* set up pointers for linked list of measure */
    9594  if (catalog[0].sorted && (catalog[0].Nmeasure == catalog[0].Nmeas_disk)) {
    9695    // this version is only valid if we have done a full catalog load, and if the catalog
    … …  
    10099    next_meas = build_measure_links (catalog[0].average, Nave, catalog[0].measure, Nmeas);
    101100  }   
    102   next_miss = init_missing_links (catalog[0].average, Nave, catalog[0].missing, Nmiss);
    103   /* missing MUST be written 'sorted', or not at all */
    104101
    105102  /* choose a radius for matches */
    … …  
    167164       
    168165    /** add measurements for this star **/
     166
     167    // set the new measurements
     168    catalog[0].measure[Nmeas]          = stars[N].measure;
     169
    169170    /** dR,dD now represent arcsec **/
    170     catalog[0].measure[Nmeas].dR       = 3600.0*(catalog[0].average[n].R - stars[N].R);
     171    catalog[0].measure[Nmeas].dR       = 3600.0*(catalog[0].average[n].R - stars[N].average.R);
     172    catalog[0].measure[Nmeas].dD       = 3600.0*(catalog[0].average[n].D - stars[N].average.D);
     173    catalog[0].measure[Nmeas].dbFlags  = 0;
     174    catalog[0].measure[Nmeas].averef   = n;
     175
     176    // rationalize dR
    171177    if (catalog[0].measure[Nmeas].dR > +180.0*3600.0) {
    172178      // average on high end of boundary, move star up
    173       stars[N].R += 360.0;
    174       catalog[0].measure[Nmeas].dR = 3600.0*(catalog[0].average[n].R - stars[N].R);
     179      stars[N].average.R += 360.0;
     180      catalog[0].measure[Nmeas].dR = 3600.0*(catalog[0].average[n].R - stars[N].average.R);
    175181    }
    176182    if (catalog[0].measure[Nmeas].dR < -180.0*3600.0) {
    177183      // average on low end of boundary, move star down
    178       stars[N].R -= 360.0;
    179       catalog[0].measure[Nmeas].dR = 3600.0*(catalog[0].average[n].R - stars[N].R);
     184      stars[N].average.R -= 360.0;
     185      catalog[0].measure[Nmeas].dR = 3600.0*(catalog[0].average[n].R - stars[N].average.R);
    180186    }
    181187    if (fabs(catalog[0].measure[Nmeas].dR) > 10*RADIUS) {
    182188      fprintf (stderr, "error: %10.6f,%10.6f vs %10.6f,%10.6f (%f,%f vs %f,%f)\n",
    183189               catalog[0].average[n].R, catalog[0].average[n].D,
    184                stars[N].R, stars[N].D,
     190               stars[N].average.R, stars[N].average.D,
    185191               X1[i], X2[Jmin],
    186192               Y1[i], Y2[Jmin]);
    187193    }
    188     catalog[0].measure[Nmeas].dD       = 3600.0*(catalog[0].average[n].D - stars[N].D);
    189 
    190     catalog[0].measure[Nmeas].Xccd     = stars[N].Xccd;
    191     catalog[0].measure[Nmeas].Yccd     = stars[N].Yccd;
    192 
    193     catalog[0].measure[Nmeas].M        = stars[N].M;
    194     catalog[0].measure[Nmeas].dM       = stars[N].dM;  /* error in input files stored in thousandths of mag */
    195     catalog[0].measure[Nmeas].Mcal     = stars[N].Mcal;
    196     catalog[0].measure[Nmeas].t        = stars[N].t;
    197     catalog[0].measure[Nmeas].photcode = stars[N].photcode;
    198     catalog[0].measure[Nmeas].dt       = stars[N].dt;
    199     catalog[0].measure[Nmeas].airmass  = stars[N].airmass;
    200 
    201     catalog[0].measure[Nmeas].photFlags = stars[N].photFlags;
    202     catalog[0].measure[Nmeas].psfQual   = stars[N].psfQual;
    203     catalog[0].measure[Nmeas].psfChisq  = stars[N].psfChisq;
    204     catalog[0].measure[Nmeas].crNsigma  = stars[N].crNsigma;
    205     catalog[0].measure[Nmeas].extNsigma = stars[N].extNsigma;
    206     catalog[0].measure[Nmeas].Sky       = stars[N].Sky;
    207     catalog[0].measure[Nmeas].dSky      = stars[N].dSky;
    208 
    209     catalog[0].measure[Nmeas].detID     = stars[N].detID;
    210     catalog[0].measure[Nmeas].imageID   = stars[N].imageID;
    211 
    212     catalog[0].measure[Nmeas].dXccd     = stars[N].dXccd;
    213     catalog[0].measure[Nmeas].dYccd     = stars[N].dYccd;
    214 
    215     catalog[0].measure[Nmeas].Map       = stars[N].Map;
    216 
    217     // XXX saturate range for FWx, FWy, theta
    218     // XXX convert to unsigned int for these...
    219     catalog[0].measure[Nmeas].FWx      = 100*stars[N].fx;
    220     catalog[0].measure[Nmeas].FWy      = 100*stars[N].fy;
    221     catalog[0].measure[Nmeas].theta    = (0xffff/360.0)*stars[N].df;
    222        
    223     catalog[0].measure[Nmeas].stargal   = 0;
    224 
    225     catalog[0].measure[Nmeas].dbFlags  = 0;
    226     catalog[0].measure[Nmeas].averef   = n;
     194
     195
     196    /* adds the measurement to the calibration if appropriate color terms are found */
     197    /* we call this before (optionally) setting the average magnitude to avoid auto-correlations */
     198    if (options.calibrate) {
     199      AddToCalibration (&catalog[0].average[n], &catalog[0].secfilt[n*Nsecfilt], catalog[0].measure, &catalog[0].measure[Nmeas], next_meas, N);
     200    }
    227201
    228202    /* set the average magnitude if not already set and the photcode.equiv is not 0 */
    … …  
    232206        catalog[0].secfilt[n*Nsecfilt+Nsec].M = PhotCat (&catalog[0].measure[Nmeas]);
    233207      }
    234     }
    235 
    236     /* adds the measurement to the calibration if appropriate color terms are found */
    237     if (options.calibrate) {
    238       AddToCalibration (&catalog[0].average[n], &catalog[0].secfilt[n*Nsecfilt], catalog[0].measure, &catalog[0].measure[Nmeas], next_meas, N);
    239208    }
    240209
    … …  
    268237    N = N1[i];
    269238    if (stars[N].found >= 0) continue;
    270     if (!IN_REGION (stars[N].R, stars[N].D)) continue;
    271 
    272     catalog[0].average[Nave].R             = stars[N].R;
    273     catalog[0].average[Nave].D             = stars[N].D;
    274     catalog[0].average[Nave].Xp            = 0;
     239    if (!IN_REGION (stars[N].average.R, stars[N].average.D)) continue;
     240
     241    catalog[0].average[Nave].R             = stars[N].average.R;
     242    catalog[0].average[Nave].D             = stars[N].average.D;
     243    catalog[0].average[Nave].dR            = 0;
     244    catalog[0].average[Nave].dD            = 0;
     245
    275246    catalog[0].average[Nave].Nmeasure      = 1;
    276247    catalog[0].average[Nave].Nmissing      = 0;
     248    catalog[0].average[Nave].Nextend       = 0;
     249
    277250    catalog[0].average[Nave].measureOffset = Nmeas;
    278251    catalog[0].average[Nave].missingOffset = -1;
     252    catalog[0].average[Nave].extendOffset  = -1;
     253
     254    catalog[0].average[Nave].uR            = 0;
     255    catalog[0].average[Nave].uD            = 0;
     256    catalog[0].average[Nave].duR           = 0;
     257    catalog[0].average[Nave].duD           = 0;
     258    catalog[0].average[Nave].P             = 0;
     259    catalog[0].average[Nave].dP            = 0;
     260
     261    catalog[0].average[Nave].Xp            = 0;
     262    catalog[0].average[Nave].ChiSq         = 0.0;
     263    catalog[0].average[Nave].Npos          = 0;
     264
     265    catalog[0].average[Nave].objID         = objID;
     266    catalog[0].average[Nave].catID         = catID;
    279267    catalog[0].average[Nave].flags         = 0;
    280268
    281     catalog[0].average[Nave].dR        = 0;
    282     catalog[0].average[Nave].dD        = 0;
    283     catalog[0].average[Nave].uR        = 0;
    284     catalog[0].average[Nave].uD        = 0;
    285     catalog[0].average[Nave].duR       = 0;
    286     catalog[0].average[Nave].duD       = 0;
    287     catalog[0].average[Nave].P         = 0;
    288     catalog[0].average[Nave].dP        = 0;
    289 
    290     catalog[0].average[Nave].objID     = objID;
    291     catalog[0].average[Nave].catID     = catID;
    292269    objID ++;
    293270
    … …  
    296273      catalog[0].secfilt[Nave*Nsecfilt+j].dM = NAN;
    297274      catalog[0].secfilt[Nave*Nsecfilt+j].Xm = NAN_S_SHORT;
    298     }
    299 
    300     catalog[0].measure[Nmeas].Xccd     = stars[N].Xccd;
    301     catalog[0].measure[Nmeas].Yccd     = stars[N].Yccd;
    302 
     275      catalog[0].secfilt[Nave*Nsecfilt+j].M_20  = NAN_S_SHORT;
     276      catalog[0].secfilt[Nave*Nsecfilt+j].M_80  = NAN_S_SHORT;
     277      catalog[0].secfilt[Nave*Nsecfilt+j].Ncode = 0;
     278      catalog[0].secfilt[Nave*Nsecfilt+j].Nused = 0;
     279    }
     280
     281    // supply the measurments from this detection
     282    catalog[0].measure[Nmeas]           = stars[N].measure;
     283
     284    // the following measure elements cannot be set until here:
    303285    catalog[0].measure[Nmeas].dR       = 0.0;
    304286    catalog[0].measure[Nmeas].dD       = 0.0;
    305     catalog[0].measure[Nmeas].M        = stars[N].M;
    306     catalog[0].measure[Nmeas].dM       = stars[N].dM;
    307     catalog[0].measure[Nmeas].Mcal     = stars[N].Mcal;
    308     catalog[0].measure[Nmeas].t        = stars[N].t;
    309     catalog[0].measure[Nmeas].photcode = stars[N].photcode;
    310     catalog[0].measure[Nmeas].dt       = stars[N].dt;
    311     catalog[0].measure[Nmeas].airmass  = stars[N].airmass;
    312 
    313     catalog[0].measure[Nmeas].photFlags = stars[N].photFlags;
    314     catalog[0].measure[Nmeas].psfQual   = stars[N].psfQual;
    315     catalog[0].measure[Nmeas].psfChisq  = stars[N].psfChisq;
    316     catalog[0].measure[Nmeas].crNsigma  = stars[N].crNsigma;
    317     catalog[0].measure[Nmeas].extNsigma = stars[N].extNsigma;
    318     catalog[0].measure[Nmeas].Sky       = stars[N].Sky;
    319     catalog[0].measure[Nmeas].dSky      = stars[N].dSky;
    320 
    321     catalog[0].measure[Nmeas].stargal   = 0;
    322 
    323     catalog[0].measure[Nmeas].detID     = stars[N].detID;
    324     catalog[0].measure[Nmeas].imageID   = stars[N].imageID;
    325 
    326     catalog[0].measure[Nmeas].dXccd     = stars[N].dXccd;
    327     catalog[0].measure[Nmeas].dYccd     = stars[N].dYccd;
    328 
    329     catalog[0].measure[Nmeas].Map      = stars[N].Map;
    330     catalog[0].measure[Nmeas].FWx      = 100*stars[N].fx;
    331     catalog[0].measure[Nmeas].FWy      = 100*stars[N].fy;
    332     catalog[0].measure[Nmeas].theta    = (0xffff/360.0)*stars[N].df;
    333 
    334287    catalog[0].measure[Nmeas].dbFlags  = 0;
    335288    catalog[0].measure[Nmeas].averef   = Nave;

  • branches/eam_branch_20090208/Ohana/src/addstar/src/find_matches_refstars.c

    r21419 r21444  
    6969 
    7070  for (i = 0; i < Nstars; i++) {
    71     RD_to_XY (&X1[i], &Y1[i], stars[i][0].R, stars[i][0].D, &tcoords);
     71    RD_to_XY (&X1[i], &Y1[i], stars[i][0].average.R, stars[i][0].average.D, &tcoords);
    7272    N1[i] = i;
    7373  }
    … …  
    134134      /* find last measurement of this star */
    135135      for (k = 0; k < catalog[0].average[n].Nmeasure - 1; k++) m = next[m];
     136
    136137      /* set up references */
    137138      next[Nmeas] = next[m];
    138139      next[m] = Nmeas;
     140
    139141      /* last just was moved */
    140142      if (next[Nmeas] == -1) last = Nmeas;
    141143       
    142144      /** add measurements for this star **/
     145
     146      // set the new measurements
     147      catalog[0].measure[Nmeas]          = stars[N][0].measure;
     148
    143149      /** *** dR,dD now in arcsec *** **/
    144       catalog[0].measure[Nmeas].dR       = 3600.0*(catalog[0].average[n].R - stars[N][0].R);
    145       catalog[0].measure[Nmeas].dD       = 3600.0*(catalog[0].average[n].D - stars[N][0].D);
    146       catalog[0].measure[Nmeas].M        = stars[N][0].M;
    147       catalog[0].measure[Nmeas].dM       = stars[N][0].dM;
    148       catalog[0].measure[Nmeas].Mcal     = 0;
    149       catalog[0].measure[Nmeas].t        = (TIMEREF == 0) ? stars[N][0].t : TIMEREF; /** careful : time_t vs e_time **/
     150      catalog[0].measure[Nmeas].dR       = 3600.0*(catalog[0].average[n].R - stars[N][0].average.R);
     151      catalog[0].measure[Nmeas].dD       = 3600.0*(catalog[0].average[n].D - stars[N][0].average.D);
     152
     153      // rationalize dR:
     154      if (catalog[0].measure[Nmeas].dR > +180.0*3600.0) {
     155          // average on high end of boundary, move star up
     156          stars[N][0].average.R += 360.0;
     157          catalog[0].measure[Nmeas].dR = 3600.0*(catalog[0].average[n].R - stars[N][0].average.R);
     158      }
     159      if (catalog[0].measure[Nmeas].dR < -180.0*3600.0) {
     160          // average on low end of boundary, move star down
     161          stars[N][0].average.R -= 360.0;
     162          catalog[0].measure[Nmeas].dR = 3600.0*(catalog[0].average[n].R - stars[N][0].average.R);
     163      }
     164
    150165      catalog[0].measure[Nmeas].averef   = n;
    151       catalog[0].measure[Nmeas].photcode = stars[N][0].photcode;
    152166      catalog[0].measure[Nmeas].dbFlags  = 0;
    153       catalog[0].measure[Nmeas].dt       = 0xffff;
    154 
    155       catalog[0].measure[Nmeas].Map      = NAN;
    156       catalog[0].measure[Nmeas].airmass  = 0;
    157       catalog[0].measure[Nmeas].FWx      = stars[N][0].fx; // XXX make sure these are zero'ed as needed
    158       catalog[0].measure[Nmeas].FWy      = stars[N][0].fy; // XXX make sure these are zero'ed as needed
    159       catalog[0].measure[Nmeas].theta    = stars[N][0].df; // XXX make sure these are zero'ed as needed
    160        
    161       catalog[0].measure[Nmeas].photFlags = stars[N][0].photFlags; // XXX make sure these are zero'ed as needed
    162       catalog[0].measure[Nmeas].psfQual   = 0;
    163       catalog[0].measure[Nmeas].psfChisq  = 0;
    164       catalog[0].measure[Nmeas].crNsigma  = 0;
    165       catalog[0].measure[Nmeas].extNsigma = 0;
    166       catalog[0].measure[Nmeas].Sky       = 0;
    167       catalog[0].measure[Nmeas].dSky      = 0;
    168 
    169       catalog[0].measure[Nmeas].stargal   = 0; // XXX not yet set
    170 
    171       catalog[0].measure[Nmeas].detID     = 0;
    172       catalog[0].measure[Nmeas].imageID   = 0;
    173 
    174       catalog[0].measure[Nmeas].dXccd     = 0;
    175       catalog[0].measure[Nmeas].dYccd     = 0;
    176 
    177       catalog[0].measure[Nmeas].Xccd     = stars[N][0].Xccd; // XXX make sure these are zero'ed as needed
    178       catalog[0].measure[Nmeas].Yccd     = stars[N][0].Yccd; // XXX make sure these are zero'ed as needed
     167
     168      catalog[0].measure[Nmeas].t        = (TIMEREF == 0) ? stars[N][0].measure.t      : TIMEREF; /** careful : time_t vs e_time **/
     169      catalog[0].measure[Nmeas].t_msec   = (TIMEREF == 0) ? stars[N][0].measure.t_msec : TIMEREF; /** careful : time_t vs e_time **/
    179170
    180171      if (ACCEPT_MOTION) {
    181         catalog[0].average[n].uR         = stars[N][0].uR;
    182         catalog[0].average[n].uD         = stars[N][0].uD;
    183         catalog[0].average[n].duR        = stars[N][0].duR;
    184         catalog[0].average[n].duD        = stars[N][0].duD;
    185         catalog[0].average[n].P          = stars[N][0].P;
    186         catalog[0].average[n].dP         = stars[N][0].dP;
     172        catalog[0].average[n].uR         = stars[N][0].average.uR;
     173        catalog[0].average[n].uD         = stars[N][0].average.uD;
     174        catalog[0].average[n].duR        = stars[N][0].average.duR;
     175        catalog[0].average[n].duD        = stars[N][0].average.duD;
     176        catalog[0].average[n].P          = stars[N][0].average.P;
     177        catalog[0].average[n].dP         = stars[N][0].average.dP;
    187178      }
    188179
    … …  
    232223  for (i = 0; (i < Nstars) && !options.only_match; i+=NREFSTAR_GROUP) {
    233224    N = N1[i];
    234     if (stars[N][0].found >= 0) continue;
    235 
    236     catalog[0].average[Nave].R             = stars[N][0].R;
    237     catalog[0].average[Nave].D             = stars[N][0].D;
    238     catalog[0].average[Nave].Xp            = 0;
     225    if (stars[N][0].found > -1) continue;
     226
     227    catalog[0].average[Nave].R             = stars[N][0].average.R;
     228    catalog[0].average[Nave].D             = stars[N][0].average.D;
     229
    239230    catalog[0].average[Nave].Nmeasure      = NREFSTAR_GROUP;
    240231    catalog[0].average[Nave].Nmissing      = 0;
     232    catalog[0].average[Nave].Nextend       = 0;
     233
    241234    catalog[0].average[Nave].measureOffset = Nmeas;
    242235    catalog[0].average[Nave].missingOffset = -1;
    243     catalog[0].average[Nave].flags         = 0;
     236    catalog[0].average[Nave].extendOffset  = -1;
    244237
    245238    if (ACCEPT_MOTION) {
    246       catalog[0].average[Nave].dR    = stars[N][0].dR;
    247       catalog[0].average[Nave].dD    = stars[N][0].dD;
    248       catalog[0].average[Nave].uR    = stars[N][0].uR;
    249       catalog[0].average[Nave].uD    = stars[N][0].uD;
    250       catalog[0].average[Nave].duR   = stars[N][0].duR;
    251       catalog[0].average[Nave].duD   = stars[N][0].duD;
    252       catalog[0].average[Nave].P     = stars[N][0].P;
    253       catalog[0].average[Nave].dP    = stars[N][0].dP;
     239      catalog[0].average[Nave].dR          = stars[N][0].average.dR;
     240      catalog[0].average[Nave].dD          = stars[N][0].average.dD;
     241      catalog[0].average[Nave].uR          = stars[N][0].average.uR;
     242      catalog[0].average[Nave].uD          = stars[N][0].average.uD;
     243      catalog[0].average[Nave].duR         = stars[N][0].average.duR;
     244      catalog[0].average[Nave].duD         = stars[N][0].average.duD;
     245      catalog[0].average[Nave].P           = stars[N][0].average.P;
     246      catalog[0].average[Nave].dP          = stars[N][0].average.dP;
    254247    } else {
    255       catalog[0].average[Nave].dR    = 0;
    256       catalog[0].average[Nave].dD    = 0;
    257       catalog[0].average[Nave].uR    = 0;
    258       catalog[0].average[Nave].uD    = 0;
    259       catalog[0].average[Nave].duR   = 0;
    260       catalog[0].average[Nave].duD   = 0;
    261       catalog[0].average[Nave].P     = 0;
    262       catalog[0].average[Nave].dP    = 0;
    263     }
    264 
    265     catalog[0].average[Nave].objID     = objID;
    266     catalog[0].average[Nave].catID     = catID;
     248      catalog[0].average[Nave].dR          = 0;
     249      catalog[0].average[Nave].dD          = 0;
     250      catalog[0].average[Nave].uR          = 0;
     251      catalog[0].average[Nave].uD          = 0;
     252      catalog[0].average[Nave].duR         = 0;
     253      catalog[0].average[Nave].duD         = 0;
     254      catalog[0].average[Nave].P           = 0;
     255      catalog[0].average[Nave].dP          = 0;
     256      catalog[0].average[Nave].Xp          = 0;
     257    }
     258
     259    catalog[0].average[Nave].Xp            = 0;
     260    catalog[0].average[Nave].ChiSq         = 0.0;
     261    catalog[0].average[Nave].Npos          = 0;
     262
     263    catalog[0].average[Nave].objID         = objID;
     264    catalog[0].average[Nave].catID         = catID;
     265    catalog[0].average[Nave].flags         = 0;
     266
    267267    objID ++;
    268268
    269269    for (j = 0; j < Nsecfilt; j++) {
    270       catalog[0].secfilt[Nave*Nsecfilt+j].M  = NAN;
    271       catalog[0].secfilt[Nave*Nsecfilt+j].dM = NAN;
    272       catalog[0].secfilt[Nave*Nsecfilt+j].Xm = NAN_S_SHORT;
     270      catalog[0].secfilt[Nave*Nsecfilt+j].M     = NAN;
     271      catalog[0].secfilt[Nave*Nsecfilt+j].dM    = NAN;
     272      catalog[0].secfilt[Nave*Nsecfilt+j].Xm    = NAN_S_SHORT;
     273      catalog[0].secfilt[Nave*Nsecfilt+j].M_20  = NAN_S_SHORT;
     274      catalog[0].secfilt[Nave*Nsecfilt+j].M_80  = NAN_S_SHORT;
     275      catalog[0].secfilt[Nave*Nsecfilt+j].Ncode = 0;
     276      catalog[0].secfilt[Nave*Nsecfilt+j].Nused = 0;
    273277    }
    274278
    275279    for (j = 0; j < NREFSTAR_GROUP; j++) {
    276280      N = N1[i + j];
     281
     282      catalog[0].measure[Nmeas]          = stars[N][0].measure;
     283
    277284      catalog[0].measure[Nmeas].dR       = 0.0;
    278285      catalog[0].measure[Nmeas].dD       = 0.0;
    279       catalog[0].measure[Nmeas].M        = stars[N][0].M;
    280       catalog[0].measure[Nmeas].dM       = stars[N][0].dM;
    281       catalog[0].measure[Nmeas].Mcal     = 0;
    282       catalog[0].measure[Nmeas].t        = (stars[N][0].t == 0) ? TIMEREF : stars[N][0].t; /** careful : time_t vs e_time **/
     286
     287      catalog[0].measure[Nmeas].t        = (stars[N][0].measure.t == 0) ? TIMEREF : stars[N][0].measure.t;      /** careful : time_t vs e_time **/
     288      catalog[0].measure[Nmeas].t_msec   = (stars[N][0].measure.t == 0) ?       0 : stars[N][0].measure.t_msec; /** careful : time_t vs e_time **/
     289      catalog[0].measure[Nmeas].dbFlags  = 0;
    283290      catalog[0].measure[Nmeas].averef   = Nave;
    284       catalog[0].measure[Nmeas].photcode = stars[N][0].photcode;
    285       catalog[0].measure[Nmeas].dbFlags  = 0;
    286       catalog[0].measure[Nmeas].dt       = 0xffff;
    287 
    288       catalog[0].measure[Nmeas].photFlags = stars[N][0].photFlags; // XXX make sure these are zero'ed as needed
    289       catalog[0].measure[Nmeas].psfQual   = 0;
    290       catalog[0].measure[Nmeas].psfChisq  = 0;
    291       catalog[0].measure[Nmeas].crNsigma  = 0;
    292       catalog[0].measure[Nmeas].extNsigma = 0;
    293       catalog[0].measure[Nmeas].Sky       = 0;
    294       catalog[0].measure[Nmeas].dSky      = 0;
    295 
    296       catalog[0].measure[Nmeas].stargal   = 0; // XXX not yet set
    297 
    298       catalog[0].measure[Nmeas].detID     = 0;
    299       catalog[0].measure[Nmeas].imageID   = 0;
    300 
    301       catalog[0].measure[Nmeas].dXccd     = 0;
    302       catalog[0].measure[Nmeas].dYccd     = 0;
    303 
    304       catalog[0].measure[Nmeas].Xccd     = stars[N][0].Xccd; // XXX make sure these are zero'ed as needed
    305       catalog[0].measure[Nmeas].Yccd     = stars[N][0].Yccd; // XXX make sure these are zero'ed as needed
    306 
    307       catalog[0].measure[Nmeas].airmass  = 0;
    308       catalog[0].measure[Nmeas].Map      = NAN;
    309       catalog[0].measure[Nmeas].FWx      = stars[N][0].fx; // XXX make sure these are zero'ed as needed
    310       catalog[0].measure[Nmeas].FWy      = stars[N][0].fy; // XXX make sure these are zero'ed as needed
    311       catalog[0].measure[Nmeas].theta    = stars[N][0].df; // XXX make sure these are zero'ed as needed
    312 
    313       catalog[0].measure[Nmeas].Xccd     = 0.0;
    314       catalog[0].measure[Nmeas].Yccd     = 0.0;
    315291
    316292      stars[N][0].found = Nmeas;

  • branches/eam_branch_20090208/Ohana/src/addstar/src/find_subset.c

    r5443 r21444  
    2020  /* find stars within ra,dec region */
    2121  for (i = N = 0; i < Nstars; i++) {
    22     if (stars[i].R <  RA0)  continue;
    23     if (stars[i].R >= RA1)  continue;
    24     if (stars[i].D <  DEC0) continue;
    25     if (stars[i].D >= DEC1) continue;
     22    if (stars[i].average.R <  RA0)  continue;
     23    if (stars[i].average.R >= RA1)  continue;
     24    if (stars[i].average.D <  DEC0) continue;
     25    if (stars[i].average.D >= DEC1) continue;
    2626
    2727    subset[N] = &stars[i];

  • branches/eam_branch_20090208/Ohana/src/addstar/src/get2mass_full.c

    r21419 r21444  
    1515  ptr = next2MASSfield (ptr); // dec (assumed to be already set)
    1616  ptr = next2MASSfield (ptr); // err_maj
    17   star[0][0].fx = strtod (ptr, NULL);
     17  star[0][0].measure.FWx = ShortPixels(strtod (ptr, NULL));
    1818  ptr = next2MASSfield (ptr); // err_min
    19   star[0][0].fy = strtod (ptr, NULL);
     19  star[0][0].measure.FWy = ShortPixels(strtod (ptr, NULL));
    2020  ptr = next2MASSfield (ptr); // err_ang
    21   star[0][0].df = strtod (ptr, NULL);
    22 
    23   star[2][0].fx = star[2][0].fx = star[0][0].fx;
    24   star[2][0].fy = star[2][0].fy = star[0][0].fy;
    25   star[2][0].df = star[2][0].df = star[0][0].df;
     21  star[0][0].measure.theta = ShortPixels(strtod (ptr, NULL));
     22
     23  star[2][0].measure.FWx   = star[2][0].measure.FWx   = star[0][0].measure.FWx;
     24  star[2][0].measure.FWy   = star[2][0].measure.FWy   = star[0][0].measure.FWy;
     25  star[2][0].measure.theta = star[2][0].measure.theta = star[0][0].measure.theta;
    2626
    2727  ptr = next2MASSfield (ptr); // designation (skip)
    2828
    2929  ptr = next2MASSfield (ptr); // j_m
    30   star[0][0].M  = strtod (ptr, NULL);
     30  star[0][0].measure.M  = strtod (ptr, NULL);
    3131  ptr = next2MASSfield (ptr); // j_cmsig
    32   star[0][0].dM = strtod (ptr, NULL);
     32  star[0][0].measure.dM = strtod (ptr, NULL);
    3333  ptr = next2MASSfield (ptr); // j_msigcom
    3434  dMfull = strtod (ptr, NULL);
    35   star[0][0].dMcal = sqrt (SQ(dMfull) - SQ(star[0][0].dM));
     35  star[0][0].measure.dMcal = sqrt (SQ(dMfull) - SQ(star[0][0].measure.dM));
    3636  ptr = next2MASSfield (ptr); // j_snr (skip)
    3737
    3838  ptr = next2MASSfield (ptr); // h_m
    39   star[1][0].M  = strtod (ptr, NULL);
     39  star[1][0].measure.M  = strtod (ptr, NULL);
    4040  ptr = next2MASSfield (ptr); // h_cmsig
    41   star[1][0].dM = strtod (ptr, NULL);
     41  star[1][0].measure.dM = strtod (ptr, NULL);
    4242  ptr = next2MASSfield (ptr); // h_msigcom
    4343  dMfull = strtod (ptr, NULL);
    44   star[1][0].dMcal = sqrt (SQ(dMfull) - SQ(star[1][0].dM));
     44  star[1][0].measure.dMcal = sqrt (SQ(dMfull) - SQ(star[1][0].measure.dM));
    4545  ptr = next2MASSfield (ptr); // h_snr (skip)
    4646
    4747  ptr = next2MASSfield (ptr); // k_m
    48   star[2][0].M  = strtod (ptr, NULL);
     48  star[2][0].measure.M  = strtod (ptr, NULL);
    4949  ptr = next2MASSfield (ptr); // k_cmsig
    50   star[2][0].dM = strtod (ptr, NULL);
     50  star[2][0].measure.dM = strtod (ptr, NULL);
    5151  ptr = next2MASSfield (ptr); // k_msigcom
    5252  dMfull = strtod (ptr, NULL);
    53   star[2][0].dMcal = sqrt (SQ(dMfull) - SQ(star[2][0].dM));
     53  star[2][0].measure.dMcal = sqrt (SQ(dMfull) - SQ(star[2][0].measure.dM));
    5454  ptr = next2MASSfield (ptr); // k_snr (skip)
    5555
    56   star[2][0].photFlags = star[1][0].photFlags = star[0][0].photFlags = 0;
     56  star[2][0].measure.photFlags = star[1][0].measure.photFlags = star[0][0].measure.photFlags = 0;
    5757
    5858  ptr = next2MASSfield (ptr); // ph_qual
    … …  
    9999
    100100  ptr = next2MASSfield (ptr); // x_scan
    101   star[0][0].Xccd = strtod (ptr, NULL);
    102   star[2][0].Xccd = star[1][0].Xccd = star[0][0].Xccd;
     101  star[0][0].measure.Xccd = strtod (ptr, NULL);
     102  star[2][0].measure.Xccd = star[1][0].measure.Xccd = star[0][0].measure.Xccd;
    103103
    104104  ptr = next2MASSfield (ptr); // jdate (julian date)
    105105  jd = strtod (ptr, NULL);
    106   star[0][0].t = ohana_jd_to_sec (jd);
    107   star[2][0].t = star[1][0].t = star[0][0].t;
     106  star[0][0].measure.t = ohana_jd_to_sec (jd);
     107  star[2][0].measure.t = star[1][0].measure.t = star[0][0].measure.t;
    108108
    109109  ptr = next2MASSfield (ptr); // j_psfchi
    110   star[0][0].psfChisq = strtod (ptr, NULL);
     110  star[0][0].measure.psfChisq = strtod (ptr, NULL);
    111111  ptr = next2MASSfield (ptr); // h_psfchi
    112   star[1][0].psfChisq = strtod (ptr, NULL);
     112  star[1][0].measure.psfChisq = strtod (ptr, NULL);
    113113  ptr = next2MASSfield (ptr); // k_psfchi
    114   star[2][0].psfChisq = strtod (ptr, NULL);
     114  star[2][0].measure.psfChisq = strtod (ptr, NULL);
    115115
    116116  ptr = next2MASSfield (ptr); // j_m_stdap
    117   star[0][0].Map = strtod (ptr, NULL);
     117  star[0][0].measure.Map = strtod (ptr, NULL);
    118118  ptr = next2MASSfield (ptr); // j_msig_stdap (skip?)
    119119
    120120  ptr = next2MASSfield (ptr); // h_m_stdap
    121   star[1][0].Map = strtod (ptr, NULL);
     121  star[1][0].measure.Map = strtod (ptr, NULL);
    122122  ptr = next2MASSfield (ptr); // h_msig_stdap (skip?)
    123123
    124124  ptr = next2MASSfield (ptr); // k_m_stdap
    125   star[2][0].Map = strtod (ptr, NULL);
     125  star[2][0].measure.Map = strtod (ptr, NULL);
    126126  ptr = next2MASSfield (ptr); // k_msig_stdap (skip?)
    127127
    … …  
    140140  set2MASS_use_flag (star[2], ptr[0]);
    141141
    142   star[0][0].photcode  = TM_J;
    143   star[0][0].found = -1;
    144   star[0][0].detID   = 0;
    145   star[0][0].imageID = 0;
    146 
    147   star[1][0].photcode  = TM_H;
    148   star[1][0].found = -1;
    149   star[1][0].detID   = 0;
    150   star[1][0].imageID = 0;
    151 
    152   star[2][0].photcode  = TM_K;
    153   star[2][0].found = -1;
    154   star[2][0].detID   = 0;
    155   star[2][0].imageID = 0;
     142  star[0][0].measure.photcode  = TM_J;
     143  star[0][0].measure.detID   = 0;
     144  star[0][0].measure.imageID = 0;
     145
     146  star[1][0].measure.photcode  = TM_H;
     147  star[1][0].measure.detID   = 0;
     148  star[1][0].measure.imageID = 0;
     149
     150  star[2][0].measure.photcode  = TM_K;
     151  star[2][0].measure.detID   = 0;
     152  star[2][0].measure.imageID = 0;
    156153
    157154  return TRUE;
    … …  
    174171
    175172  switch (qual) {
    176     case 'X': star[0].photFlags |= 0x0000; break;
    177     case 'U': star[0].photFlags |= 0x0001; break;
    178     case 'F': star[0].photFlags |= 0x0002; break;
    179     case 'E': star[0].photFlags |= 0x0003; break;
    180     case 'A': star[0].photFlags |= 0x0004; break;
    181     case 'B': star[0].photFlags |= 0x0005; break;
    182     case 'C': star[0].photFlags |= 0x0006; break;
    183     case 'D': star[0].photFlags |= 0x0007; break;
     173    case 'X': star[0].measure.photFlags |= 0x0000; break;
     174    case 'U': star[0].measure.photFlags |= 0x0001; break;
     175    case 'F': star[0].measure.photFlags |= 0x0002; break;
     176    case 'E': star[0].measure.photFlags |= 0x0003; break;
     177    case 'A': star[0].measure.photFlags |= 0x0004; break;
     178    case 'B': star[0].measure.photFlags |= 0x0005; break;
     179    case 'C': star[0].measure.photFlags |= 0x0006; break;
     180    case 'D': star[0].measure.photFlags |= 0x0007; break;
    184181    default:
    185182      fprintf (stderr, "error!\n");
    … …  
    192189
    193190  switch (qual) {
    194     case '0': star[0].photFlags |= 0x0000; break;
    195     case '1': star[0].photFlags |= 0x0010; break;
    196     case '2': star[0].photFlags |= 0x0020; break;
    197     case '3': star[0].photFlags |= 0x0030; break;
    198     case '4': star[0].photFlags |= 0x0040; break;
    199     case '6': star[0].photFlags |= 0x0050; break;
    200     case '9': star[0].photFlags |= 0x0060; break;
     191    case '0': star[0].measure.photFlags |= 0x0000; break;
     192    case '1': star[0].measure.photFlags |= 0x0010; break;
     193    case '2': star[0].measure.photFlags |= 0x0020; break;
     194    case '3': star[0].measure.photFlags |= 0x0030; break;
     195    case '4': star[0].measure.photFlags |= 0x0040; break;
     196    case '6': star[0].measure.photFlags |= 0x0050; break;
     197    case '9': star[0].measure.photFlags |= 0x0060; break;
    201198    default:
    202199      fprintf (stderr, "error!\n");
    … …  
    209206
    210207  switch (qual) {
    211     case 'p': star[0].photFlags |= 0x0000; break;
    212     case 'c': star[0].photFlags |= 0x0100; break;
    213     case 'd': star[0].photFlags |= 0x0200; break;
    214     case 's': star[0].photFlags |= 0x0300; break;
    215     case 'b': star[0].photFlags |= 0x0400; break;
    216     case '0': star[0].photFlags |= 0x0500; break;
     208    case 'p': star[0].measure.photFlags |= 0x0000; break;
     209    case 'c': star[0].measure.photFlags |= 0x0100; break;
     210    case 'd': star[0].measure.photFlags |= 0x0200; break;
     211    case 's': star[0].measure.photFlags |= 0x0300; break;
     212    case 'b': star[0].measure.photFlags |= 0x0400; break;
     213    case '0': star[0].measure.photFlags |= 0x0500; break;
    217214    default:
    218215      fprintf (stderr, "error!\n");
    … …  
    225222
    226223  switch (qual) {
    227     case '0': star[0].photFlags &= ~0x0008; break;
    228     case '1': star[0].photFlags &= ~0x0008; break;
    229     default:  star[0].photFlags |=  0x0008; break;
     224    case '0': star[0].measure.photFlags &= ~0x0008; break;
     225    case '1': star[0].measure.photFlags &= ~0x0008; break;
     226    default:  star[0].measure.photFlags |=  0x0008; break;
    230227  }     
    231228  return (TRUE);
    … …  
    235232
    236233  switch (qual) {
    237     case '0': star[0].photFlags &= ~0x0080; break;
    238     case '1': star[0].photFlags &= ~0x0080; break;
     234    case '0': star[0].measure.photFlags &= ~0x0080; break;
     235    case '1': star[0].measure.photFlags &= ~0x0080; break;
    239236    default: 
    240       star[0].photFlags |= 0x0080;
    241       star[0].extNsigma = 100.0;
     237      star[0].measure.photFlags |= 0x0080;
     238      star[0].measure.extNsigma = 100.0;
    242239      break;
    243240  }     
    … …  
    248245
    249246  switch (qual) {
    250     case '0': star[0].photFlags &= ~0x0800; break;
    251     case '1': star[0].photFlags &= ~0x0800; break;
    252     default:  star[0].photFlags |=  0x0800; break;
     247    case '0': star[0].measure.photFlags &= ~0x0800; break;
     248    case '1': star[0].measure.photFlags &= ~0x0800; break;
     249    default:  star[0].measure.photFlags |=  0x0800; break;
    253250  }     
    254251  return (TRUE);
    … …  
    258255
    259256  switch (qual) {
    260     case '0': star[0].photFlags &= ~0x1000; break;
    261     case '1': star[0].photFlags &= ~0x1000; break;
    262     default:  star[0].photFlags |=  0x1000; break;
     257    case '0': star[0].measure.photFlags &= ~0x1000; break;
     258    case '1': star[0].measure.photFlags &= ~0x1000; break;
     259    default:  star[0].measure.photFlags |=  0x1000; break;
    263260  }     
    264261  return (TRUE);
    … …  
    268265
    269266  switch (qual) {
    270     case '0': star[0].photFlags &= ~0x2000; break;
    271     case '1': star[0].photFlags |=  0x2000; break;
     267    case '0': star[0].measure.photFlags &= ~0x2000; break;
     268    case '1': star[0].measure.photFlags |=  0x2000; break;
    272269    default:  abort();
    273270  }     

  • branches/eam_branch_20090208/Ohana/src/addstar/src/get2mass_ops.c

    r21419 r21444  
    4242  double M, dM;
    4343  e_time time;
     44
     45  InitStar (star);
    4446
    4547  ptr = skipNbounds (line, '|', FilterSkip, Nmax);
    … …  
    5759  }
    5860
    59   star[0].M        = M;
    60   star[0].dM       = dM;
    61   star[0].photcode = Photcode;
    62   star[0].t        = time;
    63   star[0].found    = -1;
    64   star[0].detID    = 0;
    65   star[0].imageID  = 0;
     61  star[0].measure.M        = M;
     62  star[0].measure.dM       = dM;
     63  star[0].measure.photcode = Photcode;
     64  star[0].measure.t        = time;
     65  star[0].measure.detID    = 0;
     66  star[0].measure.imageID  = 0;
    6667
    6768  return TRUE;
    … …  
    107108  // how many bits are being used for the 2mass flags; can we just set photFlags based on them?
    108109
    109   star[0].M         = J;
    110   star[0].dM        = dJ;
    111   star[0].photcode  = TM_J;
    112   star[0].t         = time;
    113   star[0].found     = -1;
    114   star[0].detID     = 0;
    115   star[0].imageID   = 0;
    116 
    117   star[1].M         = H;
    118   star[1].dM        = dH;
    119   star[1].photcode  = TM_H;
    120   star[1].t         = time;
    121   star[1].found     = -1;
    122   star[1].detID     = 0;
    123   star[1].imageID   = 0;
    124 
    125   star[2].M         = K;
    126   star[2].dM        = dK;
    127   star[2].photcode  = TM_K;
    128   star[2].t         = time;
    129   star[2].found     = -1;
    130   star[2].detID     = 0;
    131   star[2].imageID   = 0;
     110  star[0].measure.M         = J;
     111  star[0].measure.dM        = dJ;
     112  star[0].measure.photcode  = TM_J;
     113  star[0].measure.t         = time;
     114  star[0].measure.detID     = 0;
     115  star[0].measure.imageID   = 0;
     116
     117  star[1].measure.M         = H;
     118  star[1].measure.dM        = dH;
     119  star[1].measure.photcode  = TM_H;
     120  star[1].measure.t         = time;
     121  star[1].measure.detID     = 0;
     122  star[1].measure.imageID   = 0;
     123
     124  star[2].measure.M         = K;
     125  star[2].measure.dM        = dK;
     126  star[2].measure.photcode  = TM_K;
     127  star[2].measure.t         = time;
     128  star[2].measure.detID     = 0;
     129  star[2].measure.imageID   = 0;
    132130
    133131  return TRUE;

  • branches/eam_branch_20090208/Ohana/src/addstar/src/getgsc.c

    r21419 r21444  
    6767    Nline = nbytes / BYTES_STAR;
    6868    for (i = 0; i < Nline; i++) {
     69
     70      InitStar (&stars[Nstars]);
     71
    6972      Nbyte = i*BYTES_STAR;
    70       dparse (&stars[Nstars].R, 1, &buffer[Nbyte]);
    71       dparse (&stars[Nstars].D, 2, &buffer[Nbyte]);
    72       if (stars[Nstars].R < UserPatch.Rmin) continue;
    73       if (stars[Nstars].R > UserPatch.Rmax) continue;
    74       if (stars[Nstars].D < UserPatch.Dmin) continue;
    75       if (stars[Nstars].D > UserPatch.Dmax) continue;
     73      dparse (&stars[Nstars].average.R, 1, &buffer[Nbyte]);
     74      dparse (&stars[Nstars].average.D, 2, &buffer[Nbyte]);
    7675
    77       dparse (&stars[Nstars].M, 3, &buffer[Nbyte]);
    78       stars[Nstars].dM        = NAN;
    79       stars[Nstars].t         = 0;
    80       stars[Nstars].photcode  = GSC_M;
    81       stars[Nstars].found     = -1;
     76      if (stars[Nstars].average.R < UserPatch.Rmin) continue;
     77      if (stars[Nstars].average.R > UserPatch.Rmax) continue;
     78      if (stars[Nstars].average.D < UserPatch.Dmin) continue;
     79      if (stars[Nstars].average.D > UserPatch.Dmax) continue;
    8280
    83       stars[Nstars].detID   = 0;
    84       stars[Nstars].imageID = 0;
    85 
    86       stars[Nstars].Xccd  = 0;
    87       stars[Nstars].Yccd  = 0;
    88       stars[Nstars].fx = 0;
    89       stars[Nstars].fy = 0;
    90       stars[Nstars].df = 0;
     81      fparse (&stars[Nstars].measure.M, 3, &buffer[Nbyte]);
     82      stars[Nstars].measure.dM        = NAN;
     83      stars[Nstars].measure.photcode  = GSC_M;
     84      stars[Nstars].measure.t         = 0;
    9185
    9286      Nstars ++;

  • branches/eam_branch_20090208/Ohana/src/addstar/src/gettycho.c

    r21419 r21444  
    6969
    7070      for (j = 0; j < nitems; j++) {
     71
    7172        line = &buffer[j*NBYTE];
    72         stars[Ntycho].R = atof (&line[15]);
    73         stars[Ntycho].D = atof (&line[28]);
    7473
    75         if (stars[Ntycho].R < region[0].Rmin) goto next_section;
    76         if (stars[Ntycho].R > region[0].Rmax) goto next_section;
    77         if (stars[Ntycho].D < region[0].Dmin) goto next_section;
    78         if (stars[Ntycho].D > region[0].Dmax) goto next_section;
     74        InitStar (&stars[Ntycho]);
    7975
    80         if (stars[Ntycho].R < UserPatch.Rmin) continue;
    81         if (stars[Ntycho].R > UserPatch.Rmax) continue;
    82         if (stars[Ntycho].D < UserPatch.Dmin) continue;
    83         if (stars[Ntycho].D > UserPatch.Dmax) continue;
     76        stars[Ntycho].average.R = atof (&line[15]);
     77        stars[Ntycho].average.D = atof (&line[28]);
    8478
    85         stars[Ntycho].dR  = 1000 * atof (&line[57]);
    86         stars[Ntycho].dD  = 1000 * atof (&line[64]);
     79        if (stars[Ntycho].average.R < region[0].Rmin) goto next_section;
     80        if (stars[Ntycho].average.R > region[0].Rmax) goto next_section;
     81        if (stars[Ntycho].average.D < region[0].Dmin) goto next_section;
     82        if (stars[Ntycho].average.D > region[0].Dmax) goto next_section;
     83
     84        if (stars[Ntycho].average.R < UserPatch.Rmin) continue;
     85        if (stars[Ntycho].average.R > UserPatch.Rmax) continue;
     86        if (stars[Ntycho].average.D < UserPatch.Dmin) continue;
     87        if (stars[Ntycho].average.D > UserPatch.Dmax) continue;
     88
     89        stars[Ntycho].average.dR  = 1000 * atof (&line[57]);
     90        stars[Ntycho].average.dD  = 1000 * atof (&line[64]);
    8791
    8892        /* XXX : we need to apply uR,uD to R,D to advance to 2000.0 */
    89         stars[Ntycho].uR  = atof (&line[41]);
    90         stars[Ntycho].uD  = atof (&line[49]);
     93        stars[Ntycho].average.uR  = atof (&line[41]);
     94        stars[Ntycho].average.uD  = atof (&line[49]);
    9195
    92         stars[Ntycho].duR = atof (&line[69]);
    93         stars[Ntycho].duD = atof (&line[75]);
    94        
    95         stars[Ntycho].P   = 0;
    96         stars[Ntycho].dP  = 0;
    97 
    98         stars[Ntycho].detID   = 0;
    99         stars[Ntycho].imageID = 0;
     96        stars[Ntycho].average.duR = atof (&line[69]);
     97        stars[Ntycho].average.duD = atof (&line[75]);
    10098
    10199        /* Tycho uses J2000 equinox and 1991.25 epoch for coordinates */
    102100        /* the magnitudes have no temporal information */
    103         stars[Ntycho].t   = TychoEpoch;
    104         stars[Ntycho].found = -1;
    105      
    106         stars[Ntycho].Xccd  = 0;
    107         stars[Ntycho].Yccd  = 0;
    108         stars[Ntycho].fx = 0;
    109         stars[Ntycho].fy = 0;
    110         stars[Ntycho].df = 0;
     101        stars[Ntycho].measure.t   = TychoEpoch;
    111102
    112103        /* one pass of addstar does either r or b */
    113104        if (photcode == TYCHO_B) {
    114           stars[Ntycho].M    = atof (&line[110]);
    115           stars[Ntycho].dM    = atof (&line[117]);
    116           stars[Ntycho].photcode = TYCHO_B;
     105          stars[Ntycho].measure.M        = atof (&line[110]);
     106          stars[Ntycho].measure.dM      = atof (&line[117]);
     107          stars[Ntycho].measure.photcode = TYCHO_B;
    117108        } else {
    118           stars[Ntycho].M    = atof (&line[123]);
    119           stars[Ntycho].dM    = atof (&line[130]);
    120           stars[Ntycho].photcode = TYCHO_V;
     109          stars[Ntycho].measure.M        = atof (&line[123]);
     110          stars[Ntycho].measure.dM      = atof (&line[130]);
     111          stars[Ntycho].measure.photcode = TYCHO_V;
    121112        }       
    122113     

  • branches/eam_branch_20090208/Ohana/src/addstar/src/getusno.c

    r21419 r21444  
    110110      if (buf[1] > iDEC1) continue;
    111111
    112       memset (&stars[Nusno], 0, sizeof(Stars));
    113       stars[Nusno].R     = buf[0]/360000.0;
    114       stars[Nusno].D     = buf[1]/360000.0 - 90.0;
    115       stars[Nusno].dM    = NAN;
    116       stars[Nusno].t     = 0;
    117       stars[Nusno].found = -1;
     112      InitStar (&stars[Nusno]);
    118113
    119       stars[Nusno].detID   = 0;
    120       stars[Nusno].imageID = 0;
    121 
    122       stars[Nusno].Xccd  = 0;
    123       stars[Nusno].Yccd  = 0;
    124       stars[Nusno].fx = 0;
    125       stars[Nusno].fy = 0;
    126       stars[Nusno].df = 0;
     114      stars[Nusno].average.R     = buf[0]/360000.0;
     115      stars[Nusno].average.D     = buf[1]/360000.0 - 90.0;
     116      stars[Nusno].measure.dM    = NAN;
    127117
    128118      /* one pass of addstar does either r or b */
    129119      if (photcode == USNO_RED) {
    130         stars[Nusno].photcode = USNO_RED;
    131         stars[Nusno].M     = fabs (0.1*(buf[2] - 1000*((int)(buf[2]/1000))));
     120        stars[Nusno].measure.photcode = USNO_RED;
     121        stars[Nusno].measure.M        = fabs (0.1*(buf[2] - 1000*((int)(buf[2]/1000))));
    132122      }
    133123      if (photcode == USNO_BLUE) {     
    134         stars[Nusno].photcode = USNO_BLUE;
    135         stars[Nusno].M     = fabs (0.1*((int)(buf[2] - 1000000*((int)(buf[2]/1000000))) / 1000));
     124        stars[Nusno].measure.photcode = USNO_BLUE;
     125        stars[Nusno].measure.M        = fabs (0.1*((int)(buf[2] - 1000000*((int)(buf[2]/1000000))) / 1000));
    136126      }
    137127      Nusno ++;

  • branches/eam_branch_20090208/Ohana/src/addstar/src/getusnob.c

    r21419 r21444  
    125125      /* USNO coords are reported for J2000 / epoch 2000.0 */
    126126      /* extract the basic stellar data */
    127       memset (&stars[Nusno], 0, sizeof(Stars));
    128       stars[Nusno].R   = buf[0]/360000.0;
    129       stars[Nusno].D   = buf[1]/360000.0 - 90.0;
     127      InitStar (&stars[Nusno]);
     128
     129      stars[Nusno].average.R   = buf[0]/360000.0;
     130      stars[Nusno].average.D   = buf[1]/360000.0 - 90.0;
    130131
    131132      /* XXX uR cos(D) or just uR ??? */
    132       stars[Nusno].uR  = 2.0 * ((buf[2]       % 10000) - 5000);
    133       stars[Nusno].uD  = 2.0 * ((buf[2]/10000 % 10000) - 5000);
     133      stars[Nusno].average.uR  = 2.0 * ((buf[2]       % 10000) - 5000);
     134      stars[Nusno].average.uD  = 2.0 * ((buf[2]/10000 % 10000) - 5000);
    134135
    135       stars[Nusno].duR = (buf[3]      % 1000);
    136       stars[Nusno].duD = (buf[3]/1000 % 1000);
     136      stars[Nusno].average.duR = (buf[3]      % 1000);
     137      stars[Nusno].average.duD = (buf[3]/1000 % 1000);
    137138
    138       stars[Nusno].dR  = 0.001 * (buf[4]      % 1000);
    139       stars[Nusno].dD  = 0.001 * (buf[4]/1000 % 1000);
     139      stars[Nusno].average.dR  = 0.001 * (buf[4]      % 1000);
     140      stars[Nusno].average.dD  = 0.001 * (buf[4]/1000 % 1000);
    140141
    141       stars[Nusno].P   = 0;
    142       stars[Nusno].dP  = 0;
     142      stars[Nusno].average.P   = 0;
     143      stars[Nusno].average.dP  = 0;
    143144
    144145      /* USNO magnitude errors are reported as a fixed 0.3 mag */
    145       stars[Nusno].dM    = 0.3;
    146       stars[Nusno].found = -1;
    147      
    148       stars[Nusno].detID   = 0;
    149       stars[Nusno].imageID = 0;
    150 
    151       stars[Nusno].Xccd  = 0;
    152       stars[Nusno].Yccd  = 0;
    153       stars[Nusno].fx = 0;
    154       stars[Nusno].fy = 0;
    155       stars[Nusno].df = 0;
     146      stars[Nusno].measure.dM  = 0.3;
    156147
    157148      /* USNO-B uses J2000 equinox and 2000.0 epoch for coordinates */
    158149      /* the magnitudes have no temporal information */
    159       stars[Nusno].t     = USNOepoch;
     150      stars[Nusno].measure.t   = USNOepoch;
    160151
    161152      /* one pass of addstar does r, b, or n */
    … …  
    172163          m2 = 0;
    173164      }
    174       stars[Nusno].photcode = photcode;
     165      stars[Nusno].measure.photcode = photcode;
    175166
    176167      /* if two mags are available, get an average */
    … …  
    180171        mag = (m1) ? m1 : m2;
    181172      }
    182       stars[Nusno].M = (mag == 0.0) ? 32.0 : mag;
     173      stars[Nusno].measure.M = (mag == 0.0) ? 32.0 : mag;
    183174
    184175      Nusno ++;

  • branches/eam_branch_20090208/Ohana/src/addstar/src/greference.c

    r6683 r21444  
    33# define LOAD_DR2    1
    44
    5 Stars *grefcat (char *Refcat, SkyRegion *region, int photcode, int *nstars) {
     5Stars *greference (char *Refcat, SkyRegion *region, int photcode, int *nstars) {
    66
    77  int Nstars;
    … …  
    3636  /* get stars from 2MASS for the given region */
    3737  if (!strcasecmp (Refcat, "2MASS")) {
    38     stars = get2mass (region, photcode, LOAD_ALLSKY, &Nstars);
     38    // stars = get2mass (region, photcode, LOAD_ALLSKY, &Nstars);
     39    fprintf (stderr, "2MASS load via addstar is deprecated: use load2mass\n");
     40    exit (2);
    3941  }
    4042 
    4143  /* get stars from 2MASS for the given region */
    4244  if (!strcasecmp (Refcat, "2MASS-ALLSKY")) {
    43     stars = get2mass (region, photcode, LOAD_ALLSKY, &Nstars);
     45    // stars = get2mass (region, photcode, LOAD_ALLSKY, &Nstars);
     46    fprintf (stderr, "2MASS load via addstar is deprecated: use load2mass\n");
     47    exit (2);
    4448  }
    4549 
    4650  /* get stars from 2MASS for the given region */
    4751  if (!strcasecmp (Refcat, "2MASS-DR2")) {
    48     stars = get2mass (region, photcode, LOAD_DR2, &Nstars);
     52    // stars = get2mass (region, photcode, LOAD_DR2, &Nstars);
     53    fprintf (stderr, "2MASS load via addstar is deprecated: use load2mass\n");
     54    exit (2);
    4955  }
    5056 

  • branches/eam_branch_20090208/Ohana/src/addstar/src/grefstars.c

    r21419 r21444  
    2121    if (line[0] == 0) continue;
    2222    if (line[0] == '#') continue;
    23     dparse (&stars[N].R,  1, line);
    24     dparse (&stars[N].D,  2, line);
    25     dparse (&stars[N].M,  3, line);
    26     dparse (&stars[N].dM, 4, line);
    27     stars[N].R = ohana_normalize_angle (stars[N].R);
    28     stars[N].t = 0;
    29     stars[N].photcode = photcode;
    30     stars[N].found = FALSE;
    31     stars[N].detID   = 0;
    32     stars[N].imageID = 0;
    3323
    34     stars[N].Xccd  = 0;
    35     stars[N].Yccd  = 0;
    36     stars[N].fx = 0;
    37     stars[N].fy = 0;
    38     stars[N].df = 0;
     24    InitStar (&stars[N]);
     25
     26    dparse (&stars[N].average.R,  1, line);
     27    dparse (&stars[N].average.D,  2, line);
     28    stars[N].average.R = ohana_normalize_angle (stars[N].average.R);
     29
     30    fparse (&stars[N].measure.M,  3, line);
     31    fparse (&stars[N].measure.dM, 4, line);
     32
     33    stars[N].measure.photcode = photcode;
    3934
    4035    CHECK_REALLOCATE (stars, Stars, NSTARS, N+1, 100);
    … …  
    4338  return (stars);
    4439}
    45 
    46 /* stars.found is set here to FALSE.
    47    find_match_refstars uses stars.found to identify the seq number of the
    48    star which is found.  it requires an initial value of -1 XXX
    49 */

  • branches/eam_branch_20090208/Ohana/src/addstar/src/load2mass_as_rawdata.c

    r17439 r21444  
    140140        ALLOCATE (stars[Nstars+2], Stars, 1);
    141141
    142         stars[Nstars+0][0].R = tstars[j].R;
    143         stars[Nstars+0][0].D = tstars[j].D;
    144         stars[Nstars+1][0].R = tstars[j].R;
    145         stars[Nstars+1][0].D = tstars[j].D;
    146         stars[Nstars+2][0].R = tstars[j].R;
    147         stars[Nstars+2][0].D = tstars[j].D;
     142        InitStar (stars[Nstars+0]);
     143        InitStar (stars[Nstars+1]);
     144        InitStar (stars[Nstars+2]);
     145
     146        stars[Nstars+0][0].average.R = tstars[j].R;
     147        stars[Nstars+0][0].average.D = tstars[j].D;
     148        stars[Nstars+1][0].average.R = tstars[j].R;
     149        stars[Nstars+1][0].average.D = tstars[j].D;
     150        stars[Nstars+2][0].average.R = tstars[j].R;
     151        stars[Nstars+2][0].average.D = tstars[j].D;
    148152        get2mass_3star_full (&stars[Nstars], &buffer[offset], Nbyte - offset);
    149         // get2mass_star (&stars[Nstars], &buffer[offset], Nbyte - offset);
    150153
    151154        tstars[j].flag = TRUE;

  • branches/eam_branch_20090208/Ohana/src/addstar/src/load2mass_catalog.c

    r21419 r21444  
    2020    // XXX for now, the output objects will have limited astrometric interpretation...
    2121    // XXX every 3 stars represents 3 measurements and 1 average
    22     catalog[0].average[Nave].R     = stars[i].R;
    23     catalog[0].average[Nave].D     = stars[i].D;
     22    catalog[0].average[Nave].R     = stars[i].average.R;
     23    catalog[0].average[Nave].D     = stars[i].average.D;
    2424    catalog[0].average[Nave].dR    = 0;
    2525    catalog[0].average[Nave].dD    = 0;
    … …  
    4040
    4141    for (j = 0; j < Nsec; j++) {
    42       catalog[0].secfilt[Nave*Nsec+j].M  = NAN;
    43       catalog[0].secfilt[Nave*Nsec+j].dM = NAN;
    44       catalog[0].secfilt[Nave*Nsec+j].Xm = NAN_S_SHORT;
     42      catalog[0].secfilt[Nave*Nsec+j].M     = NAN;
     43      catalog[0].secfilt[Nave*Nsec+j].dM    = NAN;
     44      catalog[0].secfilt[Nave*Nsec+j].Xm    = NAN_S_SHORT;
     45      catalog[0].secfilt[Nave*Nsec+j].M_20  = NAN_S_SHORT;
     46      catalog[0].secfilt[Nave*Nsec+j].M_80  = NAN_S_SHORT;
     47      catalog[0].secfilt[Nave*Nsec+j].Ncode = 0;
     48      catalog[0].secfilt[Nave*Nsec+j].Nused = 0;
    4549    }
    4650
    4751    // we now have the min chisq row. use this to supply the other filter values....
    4852    for (j = 0; j < 3; j++) {
     53      catalog[0].measure[Nmeas]           = stars[i+j].measure;
     54
    4955      catalog[0].measure[Nmeas].dR        = 0.0;
    5056      catalog[0].measure[Nmeas].dD        = 0.0;
    51       catalog[0].measure[Nmeas].Xccd      = stars[i+j].Xccd;
    52       catalog[0].measure[Nmeas].Yccd      = stars[i+j].Yccd;
    53       catalog[0].measure[Nmeas].dXccd     = 0.0;
    54       catalog[0].measure[Nmeas].dYccd     = 0.0;
    55       catalog[0].measure[Nmeas].M         = stars[i+j].M;
    56       catalog[0].measure[Nmeas].dM        = stars[i+j].dM;
    57       catalog[0].measure[Nmeas].Mcal      = 0;
    58       catalog[0].measure[Nmeas].dMcal     = stars[i+j].dMcal;
    59       catalog[0].measure[Nmeas].t         = stars[i+j].t;
    60       catalog[0].measure[Nmeas].averef    = Nave;
    61       catalog[0].measure[Nmeas].photcode  = stars[i+j].photcode;
    62       catalog[0].measure[Nmeas].photFlags = stars[i+j].photFlags;
    63       catalog[0].measure[Nmeas].dbFlags   = 0;
    64       catalog[0].measure[Nmeas].dt        = 0xffff;
    65                                          
    66       catalog[0].measure[Nmeas].airmass   = 0;
    67       catalog[0].measure[Nmeas].FWx       = stars[i+j].fx;
    68       catalog[0].measure[Nmeas].FWy       = stars[i+j].fy;
    69       catalog[0].measure[Nmeas].theta     = stars[i+j].df;
     57      catalog[0].measure[Nmeas].dt        = NAN_S_SHORT;
     58
     59      // XXX what about averef?
    7060
    7161      catalog[0].average[Nave].Nmeasure++;

  • branches/eam_branch_20090208/Ohana/src/addstar/src/replace_match.c

    r21419 r21444  
    77  /* search for entry and replace values M, dM, R, D */
    88  for (i = 0; i < average[0].Nmeasure; i++) {
    9     if (measure[i].photcode != star[0].photcode) continue;
    10     measure[i].dR = 3600.0*(average[0].R - star[0].R);
    11     measure[i].dD = 3600.0*(average[0].D - star[0].D);
    12     measure[i].M  = star[0].M;
    13     measure[i].dM = star[0].dM;
     9    if (measure[i].photcode != star[0].measure.photcode) continue;
     10    measure[i].dR = 3600.0*(average[0].R - star[0].average.R);
     11    measure[i].dD = 3600.0*(average[0].D - star[0].average.D);
     12    measure[i].M  = star[0].measure.M;
     13    measure[i].dM = star[0].measure.dM;
    1414    star[0].found = average[0].measureOffset + i;
    1515    return (TRUE);

  • branches/eam_branch_20090208/Ohana/src/libautocode/Makefile.Targets

    r21418 r21444  
    4545$(ASRC)/photreg.$(ARCH).o \
    4646$(ASRC)/photreg-old.$(ARCH).o \
    47 $(ASRC)/ps1_dev_0.$(ARCH).o \
    48 $(ASRC)/ps1_dev_1.$(ARCH).o \
    49 $(ASRC)/smpdata.$(ARCH).o \
     47$(ASRC)/cmf-ps1-dev-0.$(ARCH).o \
     48$(ASRC)/cmf-ps1-dev-1.$(ARCH).o \
     49$(ASRC)/cmf-ps1-v1.$(ARCH).o \
     50$(ASRC)/cmf-smpdata.$(ARCH).o \
    5051$(ASRC)/getstar-ps1-dev-0.$(ARCH).o \
    5152$(ASRC)/getstar-ps1-dev-1.$(ARCH).o \
    … …  
    5354$(ASRC)/spectrum.$(ARCH).o \
    5455$(ASRC)/spectrum-ascii.$(ARCH).o \
    55 $(ASRC)/Stars.$(ARCH).o \
    5656$(ASRC)/GSCRegion.$(ARCH).o \
    5757$(ASRC)/AddstarClientOptions.$(ARCH).o \
    … …  
    104104$(AINC)/photreg.h \
    105105$(AINC)/photreg-old.h \
    106 $(AINC)/ps1_dev_0.h \
    107 $(AINC)/ps1_dev_1.h \
     106$(AINC)/cmf-ps1-dev-0.h \
     107$(AINC)/cmf-ps1-dev-1.h \
     108$(AINC)/cmf-ps1-v1.h \
     109$(AINC)/cmf-smpdata.h \
    108110$(AINC)/getstar-ps1-dev-0.h \
    109111$(AINC)/getstar-ps1-dev-1.h \
    110112$(AINC)/getstar-ps1-dev-2.h \
    111 $(AINC)/smpdata.h \
    112113$(AINC)/spectrum.h \
    113114$(AINC)/spectrum-ascii.h \
    114 $(AINC)/Stars.h \
    115115$(AINC)/GSCRegion.h \
    116116$(AINC)/AddstarClientOptions.h \
    117117$(AINC)/SkyRegion.h
     118
     119# $(ASRC)/Stars.$(ARCH).o
     120# $(AINC)/Stars.h
     121

  • branches/eam_branch_20090208/Ohana/src/libautocode/def/Stars.d

    r21417 r21444  
    22EXTNAME STARS
    33TYPE    BINTABLE
    4 SIZE    248
     4SIZE    278
    55
    6 FIELD     Xccd,             X,          double,    x coordinate on image,            pixels
    7 FIELD     Yccd,             Y,          double,    y coordinate on image,            pixels
    8 FIELD     dXccd,            dX,         double,    x coordinate error,               pixels
    9 FIELD     dYccd,            dY,         double,    y coordinate error,               pixels
     6* FIELD     Xccd,             X,          double,    x coordinate on image,          pixels
     7* FIELD     Yccd,             Y,          double,    y coordinate on image,          pixels
     8* FIELD     dXccd,            dX,         double,    x coordinate error,                     pixels
     9* FIELD     dYccd,            dY,         double,    y coordinate error,             pixels
     10* FIELD     posangle,         POSANGLE,   float
     11* FIELD     pltscale,         PLTSCALE,   float
    1012FIELD     R,                R,          double,    ra coordinate on sky,             decimal degrees
    1113FIELD     D,                D,          double,    dec coordinate on sky,            decimal degrees
    … …  
    1820FIELD     P,                PAR,        double,    parallax,                         milliarcsec
    1921FIELD     dP,               PAR_ERR,    double,    parallax error,                   milliarcsec
    20 FIELD     M,                M,          double,    instrumental mag
    21 FIELD     dM,               DM,         double,    error on mag
    22 FIELD     dMcal,            DMCAL,      double,    systematic error on mag
    23 FIELD     Sky,              SKY,        double,    local sky counts
    24 FIELD     dSky,             dSKY,       double,    local sky error counts
    25 FIELD     fx,               FX,         double,    object FWHM x-dir,                pixels?
    26 FIELD     fy,               FY,         double,    object FWHM y-dir,                pixels?
    27 FIELD     df,               DF,         double,    object position angle,            degrees
    28 FIELD     Map,              MAP,        double,    alternative (aperture) magnitude
     22
     23* FIELD     M,                M,          double,    instrumental mag
     24* FIELD     dM,               DM,         double,    error on mag
     25* FIELD     dMcal,            DMCAL,      double,    systematic error on mag
     26* FIELD     Sky,              SKY,        double,    local sky counts
     27* FIELD     dSky,             dSKY,       double,    local sky error counts
     28* FIELD     fx,               FX,         double,    object FWHM x-dir,              pixels?
     29* FIELD     fy,               FY,         double,    object FWHM y-dir,              pixels?
     30* FIELD     df,               DF,         double,    object position angle,          degrees
     31* FIELD     Mcal,             MCAL,       float,     image cal magnitude
     32* FIELD     Map,              MAP,        double,    alternative (aperture) magnitude
    2933FIELD     Mpeak,            MPEAK,      double,    alternative (peak) magnitude
    30 FIELD     detID,            ID,         int,       detection identifier
    31 FIELD     imageID,          IMAGE_ID,   int,       image identifier
     34* FIELD     detID,            ID,         int,       detection identifier
     35* FIELD     imageID,          IMAGE_ID,   int,       image identifier
    3236FIELD     found,            FOUND,      int,       found in database catalog?
    33 FIELD     t,                T,          e_time,    date/time of exposure (UNIX)
    34 FIELD     dt,               EXPTIME,    float,     exposure time,                    2.5*log(exptime)
    35 FIELD     psfChisq,         PSF_CHISQ,  float
    36 FIELD     crNsigma,         CR_NSIGMA,  float
    37 FIELD     extNsigma,        EXT_NSIGMA, float
    38 FIELD     psfQual,          PSF_QUAL,   float
    39 FIELD     Mcal,             MCAL,       float,     image cal mag,                    mag
    40 FIELD     airmass,          AIRMASS,    float,     (airmass - 1),                    airmass
    41 FIELD     az,               AZ,         float,     azimuth
    42 FIELD     photcode,         CODE,       short
    43 FIELD     nFrames,          N_FRAMES,   short
    44 FIELD     photFlags,        FLAGS,      short
     37* FIELD     t,                T,          e_time,    date/time of exposure (UNIX)
     38* FIELD     t_msec,           T_MSEC,     short,     milliseconds of exposure
     39* FIELD     dt,               EXPTIME,    float,     exposure time,                    2.5*log(exptime)
     40* FIELD     psfQual,          PSF_QUAL,   float
     41* FIELD     psfChisq,         PSF_CHISQ,  float
     42* FIELD     psfNdof,          PSF_NDOF,   int
     43* FIELD     psfNpix,          PSF_NPIX,   int
     44* FIELD     crNsigma,         CR_NSIGMA,  float
     45* FIELD     extNsigma,        EXT_NSIGMA, float
     46* FIELD     Mxx,              MOMENTS_XX, float,     second moment
     47* FIELD     Mxy,              MOMENTS_XY, float,     second moment
     48* FIELD     Myy,              MOMENTS_YY, float,     second moment
     49* FIELD     airmass,          AIRMASS,    float,     (airmass - 1),                  airmass
     50* FIELD     az,             AZ,         float,     azimuth
     51* FIELD     photcode,         CODE,       short
     52* FIELD     nFrames,          N_FRAMES,   short
     53* FIELD     photFlags,        FLAGS,      short
    4554FIELD     dummy,            DUMMY,      char[2]
    4655
    … …  
    5665
    5766# XXX I'd like to merge this with Measure, but need to be careful about addstarClient -> addstarServer
     67# XXX extend photFlags to match actual psphot output

  • branches/eam_branch_20090208/Ohana/src/libautocode/def/cmf-ps1-v1.d

    r21418 r21444  
    33EXTNAME CMF_PS1_V1
    44TYPE    BINTABLE
    5 SIZE    72
     5SIZE    120
    66
    77# elements of data structure / FITS table
    88FIELD detID,     IPP_IDET,         unsigned int, detection ID
    9 FIELD X,         X_PSF,            float,    x coord,              pixels
    10 FIELD Y,         Y_PSF,            float,    y coord,              pixels
    11 FIELD dX,        X_PSF_SIG,        float,    x coord error,        pixels
    12 FIELD dY,        Y_PSF_SIG,        float,    y coord error,        pixels
    13 FIELD M,         PSF_INST_MAG,     float,    inst mags,            mags
    14 FIELD dM,        PSF_INST_MAG_SIG, float,    inst mag error,       mags
    15 FIELD Mpeak,     PEAK_FLUX_AS_MAG, float,    inst mag error,       mags
    16 FIELD sky,       SKY,              float,    sky flux,             cnts/sec
    17 FIELD dSky,      SKY_SIG,          float,    sky flux errorf       cnts/sec
     9FIELD X,         X_PSF,            float,    x coord,               pixels
     10FIELD Y,         Y_PSF,            float,    y coord,               pixels
     11FIELD dX,        X_PSF_SIG,        float,    x coord error,         pixels
     12FIELD dY,        Y_PSF_SIG,        float,    y coord error,         pixels
     13FIELD RA,        RA_PSF,           float,    PSF RA coord,          degrees
     14FIELD DEC,       DEC_PSF,          float,    PSF DEC coord,         degrees
     15FIELD posangle,  POSANGLE,         float,    Posangle at source,    degrees
     16FIELD pltscale,  PLTSCALE,         float,    Plate Scale at source, arcsec/pixel
     17FIELD M,         PSF_INST_MAG,     float,    inst mags,             mags
     18FIELD dM,        PSF_INST_MAG_SIG, float,    inst mag error,        mags
     19FIELD Map,       AP_MAG_STANDARD,  float,    standard aperture mag, mags
     20FIELD Mpeak,     PEAK_FLUX_AS_MAG, float,    peak flux as a mag,    mags
     21FIELD Mcalib,    CAL_PSF_MAG,      float,    calibrated psf mag,    mags
     22FIELD dMcal,     CAL_PSF_MAG_SIG,  float,    zero point scatter,    mags
     23FIELD sky,       SKY,              float,    sky flux,              cnts/sec
     24FIELD dSky,      SKY_SIG,          float,    sky flux error,        cnts/sec
    1825FIELD psfChisq,  PSF_CHISQ,        float,    psf fit chisq
    1926FIELD crNsigma,  CR_NSIGMA,        float,    Nsigma deviations from PSF to CF
    2027FIELD extNsigma, EXT_NSIGMA,       float,    Nsigma deviations from PSF to EXT
    21 FIELD fx,        PSF_WIDTH_X,      float,    semi-major,           pixels
    22 FIELD fy,        PSF_WIDTH_Y,      float,    semi-minor,           pixels
    23 FIELD df,        PSF_THETA,        float,    ellipse angle,        degrees
     28FIELD fx,        PSF_MAJOR,        float,    psf fit major axis,    pixels
     29FIELD fy,        PSF_MINOR,        float,    psf fit minor axis,    pixels
     30FIELD df,        PSF_THETA,        float,    ellipse angle,         degrees
    2431FIELD psfQual,   PSF_QF,           float,    quality factor
     32FIELD psfNdof,   PSF_NDOF,         int,      psf degrees of freedom
     33FIELD psfNpix,   PSF_NPIX,         int,      psf number of pixels
     34FIELD Mxx,       MOMENTS_XX,       float,    second moment X,       pixels^2
     35FIELD Mxy,       MOMENTS_XY,       float,    second moment Y,       pixels^2
     36FIELD Myy,       MOMENTS_YY,       float,    second moment XY,      pixels^2
    2537FIELD nFrames,   N_FRAMES,         short,    images overlapping peak
    2638FIELD flags,     FLAGS,            short,    padding
     39
     40# for an object in an image, we have three triplets that tell us about the shape:
     41# second moments: Mxx, Mxy, Myy
     42# model shape parameters: F_major, F_minor, F_theta
     43# centroid errors: sigma_X, sigma_Y, sigma_XY

  • branches/eam_branch_20090208/Ohana/src/libautocode/def/measure-ps1-v1.d

    r21418 r21444  
    22EXTNAME      DVO_MEASURE_PS1_V1
    33TYPE         BINTABLE
    4 SIZE         139
     4SIZE         146
    55DESCRIPTION  DVO Detection Measurement Table
    66
    … …  
    1010FIELD Mcal,           M_CAL,        float,          image cal mag,                mag
    1111FIELD Map,            M_APER,       float,          aperture mag,                 mag
    12 FIELD Map_small,      M_APER_SMALL, float,          small aperture mag,           mag
    1312FIELD dM,             MAG_ERR,      float,          mag error,                    mag
    1413FIELD dMcal,          MAG_CAL_ERR,  float,          systematic calibration error, mag
    … …  
    3938FIELD psfQual,        PSF_QF,       float,          psf coverage/quality factor
    4039FIELD psfChisq,       PSF_CHISQ,    float,          psf fit chisq
     40FIELD psfNdof,        PSF_NDOF,     int,            psf degrees of freedom
     41FIELD psfNpix,        PSF_NPIX,     int,            psf number of pixels
    4142FIELD crNsigma,       CR_NSIGMA,    float,          Nsigma deviation towards CR
    4243FIELD extNsigma,      EXT_NSIGMA,   float,          Nsigma deviation towards EXT
    4344
    4445# model shape parameters
    45 FIELD FWx,            FWHM_MAJOR,   short,          object fwhm major axis,       1/100 of arcsec
    46 FIELD FWy,            FWHM_MINOR,   short,          object fwhm minor axis,       1/100 of arcsec
    47 FIELD theta,          PSF_THETA,    short,          angle wrt ccd X dir,          (0xffff/360) deg
     46FIELD FWx,            FWHM_MAJOR,   short,          object fwhm major axis,         1/100 of pixels
     47FIELD FWy,            FWHM_MINOR,   short,          object fwhm minor axis,         1/100 of pixels
     48FIELD theta,          PSF_THETA,    short,          angle wrt ccd X dir,            (0xffff/360) deg
    4849
    4950# moments
    50 FIELD Mxx,            MXX,          short,          second moments in pixel coords, 1/100 of arcsec
    51 FIELD Mxy,            MXY,          short,          second moments in pixel coords, 1/100 of arcsec
    52 FIELD Myy,            MYY,          short,          second moments in pixel coords, 1/100 of arcsec
     51FIELD Mxx,            MXX,          short,          second moments in pixel coords, 1/100 of pixels
     52FIELD Mxy,            MXY,          short,          second moments in pixel coords, 1/100 of pixels
     53FIELD Myy,            MYY,          short,          second moments in pixel coords, 1/100 of pixels
    5354
    5455# position errors
    55 FIELD dXccd,          X_CCD_ERR,    short,          X coord error on chip,         pixels
    56 FIELD dYccd,          Y_CCD_ERR,    short,          Y coord error on chip,         pixels
    57 FIELD dTccd,          T_CCD_ERR,    short,          position angle chip to sky,    (0xffff/360) deg
     56FIELD dXccd,          X_CCD_ERR,    short,          X coord error on chip,          1/100 of pixels
     57FIELD dYccd,          Y_CCD_ERR,    short,          Y coord error on chip,          1/100 of pixels
     58FIELD posangle,       POSANGLE,     short,          position angle sky to chip,     (0xffff/360) deg
     59FIELD pltscale,       PLTSCALE,     float,          plate scale,                    arcsec/pixel
    5860
    5961FIELD photcode,       PHOTCODE,     unsigned short, photcode
    60 
    6162FIELD dbFlags,        DB_FLAGS,     uint64_t,       flags supplied by analysis in database
    6263FIELD photFlags,      PHOT_FLAGS,   uint64_t,       flags supplied by photometry program
    6364
    64 FIELD stargal,        STAR_GAL,     char,           star-galaxy separator
    65 
    6665# FIELD dummy,          DUMMY,        char[6],        padding

  • branches/eam_branch_20090208/Ohana/src/libautocode/def/measure.d

    r21418 r21444  
    22EXTNAME      DVO_MEASURE
    33TYPE         BINTABLE
    4 SIZE         139
     4SIZE         146
    55DESCRIPTION  DVO Detection Measurement Table
    66
    7 FIELD dR,             D_RA,         float,          RA offset,                    arcsec
    8 FIELD dD,             D_DEC,        float,          DEC offset,                   arcsec
    9 FIELD M,              MAG,          float,          catalog mag,                  mag
    10 FIELD Mcal,           M_CAL,        float,          image cal mag,                mag
    11 FIELD Map,            M_APER,       float,          aperture mag,                 mag
    12 FIELD Map_small,      M_APER_SMALL, float,          small aperture mag,           mag
    13 FIELD dM,             MAG_ERR,      float,          mag error,                    mag
    14 FIELD dMcal,          MAG_CAL_ERR,  float,          systematic calibration error, mag
    15 FIELD dt,             M_TIME,       float,          exposure time,                2.5*log(exptime)
    16 
     7FIELD dR,             D_RA,         float,          RA offset,                      arcsec
     8FIELD dD,             D_DEC,        float,          DEC offset,                     arcsec
     9FIELD M,              MAG,          float,          catalog mag,                    mag
     10FIELD Mcal,           M_CAL,        float,          image cal mag,                  mag
     11FIELD Map,            M_APER,       float,          aperture mag,                   mag
     12FIELD dM,             MAG_ERR,      float,          mag error,                      mag
     13FIELD dMcal,          MAG_CAL_ERR,  float,          systematic calibration error,   mag
     14FIELD dt,             M_TIME,       float,          exposure time,                  2.5*log(exptime)
    1715
    1816# note that with airmass = 1.0 / cos(90 - alt), we have full alt/az representation
    19 FIELD airmass,        AIRMASS,      float,          (airmass - 1),                airmass
     17FIELD airmass,        AIRMASS,      float,          (airmass - 1),                  airmass
    2018FIELD az,             AZ,           float,          telescope azimuth
    2119
    2220# new field elements needed for Pan-STARRS:
    23 FIELD Xccd,           X_CCD,        float,          X coord on chip,               pixels
    24 FIELD Yccd,           Y_CCD,        float,          Y coord on chip,               pixels
     21FIELD Xccd,           X_CCD,        float,          X coord on chip,                pixels
     22FIELD Yccd,           Y_CCD,        float,          Y coord on chip,                pixels
    2523
    2624# could these be packed into fewer bits?
    27 FIELD Sky,            SKY_FLUX,     float,          local estimate of sky flux,    counts/sec
    28 FIELD dSky,           SKY_FLUX_ERR, float,          local estimate of sky flux,    counts/sec
     25FIELD Sky,            SKY_FLUX,     float,          local estimate of sky flux,     counts/sec
     26FIELD dSky,           SKY_FLUX_ERR, float,          local estimate of sky flux,     counts/sec
    2927
    3028FIELD t,              TIME,         int,            time in seconds (UNIX)
    31 FIELD t_msec,         TIME_MSEC,    unsigned short, time fraction of second,       milliseconds
     29FIELD t_msec,         TIME_MSEC,    unsigned short, time fraction of second,        milliseconds
    3230FIELD averef,         AVE_REF,      unsigned int,   reference to average entry     
    3331
    … …  
    4038FIELD psfQual,        PSF_QF,       float,          psf coverage/quality factor
    4139FIELD psfChisq,       PSF_CHISQ,    float,          psf fit chisq
     40FIELD psfNdof,        PSF_NDOF,     int,            psf degrees of freedom
     41FIELD psfNpix,        PSF_NPIX,     int,            psf number of pixels
    4242FIELD crNsigma,       CR_NSIGMA,    float,          Nsigma deviation towards CR
    4343FIELD extNsigma,      EXT_NSIGMA,   float,          Nsigma deviation towards EXT
    4444
    45 FIELD FWx,            FWHM_MAJOR,   short,          object fwhm major axis,       1/100 of arcsec
    46 FIELD FWy,            FWHM_MINOR,   short,          object fwhm minor axis,       1/100 of arcsec
    47 FIELD theta,          PSF_THETA,    short,          angle wrt ccd X dir,          (0xffff/360) deg
     45# model shape parameters
     46FIELD FWx,            FWHM_MAJOR,   short,          object fwhm major axis,         1/100 of pixels
     47FIELD FWy,            FWHM_MINOR,   short,          object fwhm minor axis,         1/100 of pixels
     48FIELD theta,          PSF_THETA,    short,          angle wrt ccd X dir,            (0xffff/360) deg
    4849
    4950# moments
    50 FIELD Mxx,            MXX,          short,          second moments in pixel coords, 1/100 of arcsec
    51 FIELD Mxy,            MXY,          short,          second moments in pixel coords, 1/100 of arcsec
    52 FIELD Myy,            MYY,          short,          second moments in pixel coords, 1/100 of arcsec
     51FIELD Mxx,            MXX,          short,          second moments in pixel coords, 1/100 of pixels^2
     52FIELD Mxy,            MXY,          short,          second moments in pixel coords, 1/100 of pixels^2
     53FIELD Myy,            MYY,          short,          second moments in pixel coords, 1/100 of pixels^2
    5354
    54 # convert this to error in arcsec on load?
    55 FIELD dXccd,          X_CCD_ERR,    short,          X coord error on chip,         pixels
    56 FIELD dYccd,          Y_CCD_ERR,    short,          Y coord error on chip,         pixels
    57 FIELD dTccd,          T_CCD_ERR,    short,          position angle chip to sky,    (0xffff/360) deg
     55# convert this to error in pixels on load?
     56FIELD dXccd,          X_CCD_ERR,    short,          X coord error on chip,          1/100 of pixels
     57FIELD dYccd,          Y_CCD_ERR,    short,          Y coord error on chip,          1/100 of pixels
     58FIELD posangle,       POSANGLE,     short,          position angle sky to chip,     (0xffff/360) deg
     59FIELD pltscale,       PLTSCALE,     float,          plate scale,                    arcsec/pixel
    5860
    5961FIELD photcode,       PHOTCODE,     unsigned short, photcode
    … …  
    6163FIELD photFlags,      PHOT_FLAGS,   uint64_t,       flags supplied by photometry program
    6264
    63 FIELD stargal,        STAR_GAL,     char,           star-galaxy separator
    64 
    65 # *** 20090206 : new fields : t_msec, extID, Mxx, Mxy, Myy, dTccd; deprecated dophot
    66 #                dbFlags, photFlags : uint16_t to uint64_t
     65# *** 20090206 : new fields : t_msec, extID, Mxx, Mxy, Myy, posangle,
     66#                psfNdof, psfNpix, Map_small; deprecated dophot.
     67#                Changed dbFlags, photFlags : uint16_t to uint64_t
    6768
    6869# XXX unsigned int values are probably not being saved in the FITS file correctly: no BZERO, BSCALE

  • branches/eam_branch_20090208/Ohana/src/libdvo/include/dvo.h

    r21418 r21444  
    446446void sort_image_subset (Image *image, int *subset, int N);
    447447void sort_coords_index (double *X, double *Y, int *S, int N);
    448 void sort_stars_ra (Stars *stars, int N);
    449448void sort_regions (SkyRegion *region, int N);
    450449

  • branches/eam_branch_20090208/Ohana/src/libdvo/src/dvo_convert_PS1_DEV_1.c

    r21418 r21444  
    3939    out[i].dbFlags    = in[i].dbFlags;
    4040    out[i].photFlags  = in[i].photFlags;
    41     out[i].stargal    = in[i].stargal;
    4241
    4342    // changed or added for PS1_DEV_2
    … …  
    5251    out[i].Mxy        = 0.0;
    5352    out[i].Myy        = 0.0;
    54     out[i].dTccd      = 0;
    55     out[i].Map_small  = 0;
     53    out[i].posangle   = 0;
     54    out[i].pltscale   = 0;
     55    out[i].psfNdof    = 0;
     56    out[i].psfNpix    = 0;
    5657  }
    5758  return (out);
    … …  
    9394    out[i].dYccd      = in[i].dYccd;
    9495    out[i].dbFlags    = in[i].dbFlags;
    95     out[i].stargal    = in[i].stargal;
    9696
    9797    // changed or added for PS1_DEV_2

  • branches/eam_branch_20090208/Ohana/src/libdvo/src/dvo_convert_PS1_DEV_2.c

    r21418 r21444  
    4040    out[i].dYccd      = in[i].dYccd;
    4141    out[i].dbFlags    = in[i].dbFlags;
    42     out[i].stargal    = in[i].stargal;
    4342
    4443    // changed or added for PS1_V1
    … …  
    4948    out[i].Mxy        = 0.0;
    5049    out[i].Myy        = 0.0;
    51     out[i].dTccd      = 0;
    52     out[i].Map_small  = 0;
     50    out[i].posangle   = 0;
     51    out[i].pltscale   = 0;
     52    out[i].psfNdof    = 0;
     53    out[i].psfNpix    = 0;
    5354  }
    5455  return (out);
    … …  
    9293    out[i].dYccd      = in[i].dYccd;
    9394    out[i].dbFlags    = in[i].dbFlags;
    94     out[i].stargal    = in[i].stargal;
    9595
    9696    // changed or added for PS1_V1

  • branches/eam_branch_20090208/Ohana/src/libdvo/src/dvo_convert_PS1_V1.c

    r21418 r21444  
    1616    out[i].Mcal       = in[i].Mcal;
    1717    out[i].Map        = in[i].Map;
    18     out[i].Map_small  = in[i].Map_small;
    1918    out[i].dM         = in[i].dM;
    2019    out[i].dMcal      = in[i].dMcal;
    … …  
    3433    out[i].psfQual    = in[i].psfQual;
    3534    out[i].psfChisq   = in[i].psfChisq;
     35    out[i].psfNdof    = in[i].psfNdof;
     36    out[i].psfNpix    = in[i].psfNpix;
    3637    out[i].crNsigma   = in[i].crNsigma;
    3738    out[i].extNsigma  = in[i].extNsigma;
    … …  
    4445    out[i].dXccd      = in[i].dXccd;
    4546    out[i].dYccd      = in[i].dYccd;
    46     out[i].dTccd      = in[i].dTccd;
     47    out[i].posangle   = in[i].posangle;
     48    out[i].pltscale   = in[i].pltscale;
    4749    out[i].photcode   = in[i].photcode;
    4850    out[i].dbFlags    = in[i].dbFlags;
    4951    out[i].photFlags  = in[i].photFlags;
    50     out[i].stargal    = in[i].stargal;
    5152  }
    5253  return (out);
    … …  
    6667    out[i].Mcal       = in[i].Mcal;
    6768    out[i].Map        = in[i].Map;
    68     out[i].Map_small  = in[i].Map_small;
    6969    out[i].dM         = in[i].dM;
    7070    out[i].dMcal      = in[i].dMcal;
    … …  
    8484    out[i].psfQual    = in[i].psfQual;
    8585    out[i].psfChisq   = in[i].psfChisq;
     86    out[i].psfNdof    = in[i].psfNdof;
     87    out[i].psfNpix    = in[i].psfNpix;
    8688    out[i].crNsigma   = in[i].crNsigma;
    8789    out[i].extNsigma  = in[i].extNsigma;
    … …  
    9496    out[i].dXccd      = in[i].dXccd;
    9597    out[i].dYccd      = in[i].dYccd;
    96     out[i].dTccd      = in[i].dTccd;
     98    out[i].posangle   = in[i].posangle;
     99    out[i].pltscale   = in[i].pltscale;
    97100    out[i].photcode   = in[i].photcode;
    98101    out[i].dbFlags    = in[i].dbFlags;
    99102    out[i].photFlags  = in[i].photFlags;
    100     out[i].stargal    = in[i].stargal;
    101103  }
    102104  return (out);

  • branches/eam_branch_20090208/Ohana/src/libdvo/src/dvo_convert_elixir.c

    r21418 r21444  
    3333    out[i].dYccd     = 0;
    3434    out[i].az        = 0;
    35     out[i].stargal   = 0;
    3635    out[i].Sky       = 0;
    3736    out[i].dSky      = 0;
    … …  
    5958    out[i].Mxy        = 0.0;
    6059    out[i].Myy        = 0.0;
    61     out[i].dTccd      = 0;
    62     out[i].Map_small  = 0;
     60    out[i].posangle   = 0;
     61    out[i].pltscale   = 0;
     62    out[i].psfNdof    = 0;
     63    out[i].psfNpix    = 0;
    6364  }
    6465  return (out);

  • branches/eam_branch_20090208/Ohana/src/libdvo/src/dvo_convert_loneos.c

    r21418 r21444  
    3737    out[i].dYccd     = 0;
    3838    out[i].az        = 0;
    39     out[i].stargal   = 0;
    4039    out[i].Sky       = 0;
    4140    out[i].dSky      = 0;
    … …  
    6160    out[i].Mxy        = 0.0;
    6261    out[i].Myy        = 0.0;
    63     out[i].dTccd      = 0;
    64     out[i].Map_small  = 0;
     62    out[i].posangle   = 0;
     63    out[i].pltscale   = 0;
     64    out[i].psfNdof    = 0;
     65    out[i].psfNpix    = 0;
    6566  }
    6667  return (out);

  • branches/eam_branch_20090208/Ohana/src/libdvo/src/dvo_convert_panstarrs_DEV_0.c

    r21418 r21444  
    2929    out[i].dXccd      = in[i].dXccd;
    3030    out[i].dYccd      = in[i].dYccd;
    31     out[i].stargal    = in[i].stargal;
    3231    out[i].Sky        = in[i].Sky;
    3332    out[i].dSky       = in[i].dSky;
    … …  
    5655    out[i].Mxy        = 0.0;
    5756    out[i].Myy        = 0.0;
    58     out[i].dTccd      = 0;
    59     out[i].Map_small  = 0;
     57    out[i].posangle   = 0;
     58    out[i].pltscale   = 0;
     59    out[i].psfNdof    = 0;
     60    out[i].psfNpix    = 0;
    6061  }
    6162  return (out);
    … …  
    8990    out[i].dXccd      = in[i].dXccd;
    9091    out[i].dYccd      = in[i].dYccd;
    91     out[i].stargal    = in[i].stargal;
    9292    out[i].Sky        = in[i].Sky;
    9393    out[i].dSky       = in[i].dSky;

  • branches/eam_branch_20090208/Ohana/src/libdvo/src/dvo_convert_panstarrs_DEV_1.c

    r21418 r21444  
    2929    out[i].dXccd      = in[i].dXccd;
    3030    out[i].dYccd      = in[i].dYccd;
    31     out[i].stargal    = in[i].stargal;
    3231    out[i].Sky        = in[i].Sky;
    3332    out[i].dSky       = in[i].dSky;
    … …  
    5655    out[i].Mxy        = 0.0;
    5756    out[i].Myy        = 0.0;
    58     out[i].dTccd      = 0;
    59     out[i].Map_small  = 0;
     57    out[i].posangle   = 0;
     58    out[i].pltscale   = 0;
     59    out[i].psfNdof    = 0;
     60    out[i].psfNpix    = 0;
    6061  }
    6162  return (out);
    … …  
    8990    out[i].dXccd      = in[i].dXccd;
    9091    out[i].dYccd      = in[i].dYccd;
    91     out[i].stargal    = in[i].stargal;
    9292    out[i].Sky        = in[i].Sky;
    9393    out[i].dSky       = in[i].dSky;

  • branches/eam_branch_20090208/Ohana/src/libdvo/src/dvosorts.c

    r16040 r21444  
    4646}
    4747
    48 void sort_stars_ra (Stars *stars, int N) {
    49 
    50 # define SWAPFUNC(A,B){ Stars tmp; tmp = stars[A]; stars[A] = stars[B]; stars[B] = tmp; }
    51 # define COMPARE(A,B)(stars[A].R < stars[B].R)
    52 
    53   OHANA_SORT (N, COMPARE, SWAPFUNC);
    54 
    55 # undef SWAPFUNC
    56 # undef COMPARE
    57 
    58 }
    59 
    6048void sort_regions (SkyRegion *region, int N) {
    6149
    … …  
    7058}
    7159
     60# if (0)
     61// deprecated along with Stars as an autocode type
     62void sort_stars_ra (Stars *stars, int N) {
     63
     64# define SWAPFUNC(A,B){ Stars tmp; tmp = stars[A]; stars[A] = stars[B]; stars[B] = tmp; }
     65# define COMPARE(A,B)(stars[A].R < stars[B].R)
     66
     67  OHANA_SORT (N, COMPARE, SWAPFUNC);
     68
     69# undef SWAPFUNC
     70# undef COMPARE
     71
     72}
     73# endif

  • branches/eam_branch_20090208/Ohana/src/opihi/dvo/dbExtractMeasures.c

    r21419 r21444  
    405405      value.Flt = measure[0].extNsigma;
    406406      break;
    407     case MEAS_STARGAL: /* OK */
    408       value.Flt = measure[0].stargal;
    409       break;
    410407
    411408      // add the star/galaxy sep --

  • branches/eam_branch_20090208/Ohana/src/opihi/dvo/dbFields.c

    r21419 r21444  
    193193  if (!strcasecmp (fieldName, "SKY"))        ESCAPE (MEAS_SKY,            MAG_NONE, OPIHI_FLT);
    194194  if (!strcasecmp (fieldName, "SKY_ERR"))    ESCAPE (MEAS_dSKY,           MAG_NONE, OPIHI_FLT);
    195   if (!strcasecmp (fieldName, "STARGAL"))    ESCAPE (MEAS_STARGAL,        MAG_NONE, OPIHI_FLT);
    196195
    197196  // for words that don't parse, try a photcode

  • branches/eam_branch_20090208/Ohana/src/opihi/dvo/gstar.c

    r21419 r21444  
    240240                gprint (GP_LOG, "%f", 0.01*catalog.measure[m].FWy);
    241241                gprint (GP_LOG, "%f", (360.0/(float)0xffff)*catalog.measure[m].theta);
    242                 gprint (GP_LOG, "%d", catalog.measure[m].stargal);
    243242            }
    244243            gprint (GP_LOG, "\n");

  • branches/eam_branch_20090208/Ohana/src/opihi/include/dvoshell.h

    r21153 r21444  
    106106      MEAS_CR_NSIGMA,
    107107      MEAS_EXT_NSIGMA,
    108       MEAS_STARGAL,
    109108};
    110109

  • branches/eam_branch_20090208/Ohana/src/relphot/src/relphot_objects.c

    r21419 r21444  
    4545        for (k = 0; k < Nsecfilt; k++) {
    4646          catalog.secfilt[j*Nsecfilt + k].M     = NAN;
    47           catalog.secfilt[j*Nsecfilt + k].M_20  = NAN;
    48           catalog.secfilt[j*Nsecfilt + k].M_80  = NAN;
     47          catalog.secfilt[j*Nsecfilt + k].M_20  = NAN_S_SHORT;
     48          catalog.secfilt[j*Nsecfilt + k].M_80  = NAN_S_SHORT;
    4949          catalog.secfilt[j*Nsecfilt + k].dM    = NAN;
    5050          catalog.secfilt[j*Nsecfilt + k].Xm    = NAN_S_SHORT;
Note: See TracChangeset for help on using the changeset viewer.