IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 31272


Ignore:
Timestamp:
Apr 12, 2011, 6:06:39 AM (15 years ago)
Author:
eugene
Message:

fix the multifilter analysis

Location:
branches/eam_branches/ipp-20110404/Ohana/src/relphot
Files:
1 added
11 edited

Legend:

Unmodified
Added
Removed

  • branches/eam_branches/ipp-20110404/Ohana/src/relphot/include/relphot.h

    r31262 r31272  
    1111  unsigned int start;
    1212  unsigned int stop;
     13  short photcode;
    1314  float Mcal;
    1415  float dMcal;
    … …  
    218219StatType      statsMosaicX        PROTO((Catalog *catalog));
    219220StatType      statsMosaicdM       PROTO((Catalog *catalog));
    220 StatType      statsStarN          PROTO((Catalog *catalog, int Ncatalog, int seccode));
     221StatType      statsStarN          PROTO((Catalog *catalog, int Ncatalog, int Nsec, int seccode));
    221222StatType      statsStarS          PROTO((Catalog *catalog, int Ncatalog, int Nsec));
    222223StatType      statsStarX          PROTO((Catalog *catalog, int Ncatalog, int Nsec));

  • branches/eam_branches/ipp-20110404/Ohana/src/relphot/src/GridOps.c

    r31261 r31272  
    348348  // sums for each star which touches as cell on both bases.
    349349
     350  int Nsecfilt = GetPhotcodeNsecfilt ();
     351  int thisCode = photcodes[0][0].code;
     352  int Nsec = GetPhotcodeNsec(thisCode);
     353
    350354  for (i = 0; i < Ngrid; i++) {
    351355   
    … …  
    369373
    370374      // skip stars marked as BAD
    371       if (catalog[c].average[n].flags & STAR_BAD) {
     375      if (catalog[c].secfilt[n*Nsecfilt+Nsec].flags & STAR_BAD) {
    372376        Nrel ++;
    373377        continue;

  • branches/eam_branches/ipp-20110404/Ohana/src/relphot/src/ImageOps.c

    r31261 r31272  
    134134  int i, ecode, Ns, found;
    135135 
     136  int Nmatch = 0;
    136137 for (i = 0; i < Ncatalog; i++) {
    137138    for (j = 0; j < catalog[i].Nmeasure; j++) {
    … …  
    143144      if (!found) continue;
    144145      matchImage (catalog, j, i);
    145     }
    146   }
     146      Nmatch ++;
     147    }
     148  }
     149  fprintf (stderr, "matched %d detections to images\n", Nmatch);
    147150}
    148151

  • branches/eam_branches/ipp-20110404/Ohana/src/relphot/src/MosaicOps.c

    r31261 r31272  
    8686    mosaic[Nmosaic].flags  = image[i].flags;
    8787    mosaic[Nmosaic].secz  = image[i].secz;
     88    mosaic[Nmosaic].photcode = GetPhotcodeEquivCodebyCode (image[i].photcode);
    8889
    8990    /* add image to mosaic image list */
    … …  
    267268  if (!MOSAIC_ZEROPT) return (FALSE);
    268269
     270  int Nmatch = 0;
    269271  for (i = 0; i < Ncatalog; i++) {
    270272    for (j = 0; j < catalog[i].Nmeasure; j++) {
    … …  
    280282      if (!found) continue;
    281283      matchMosaics (catalog, j, i);
    282     }
    283   }
     284      Nmatch ++;
     285    }
     286  }
     287  fprintf (stderr, "matched %d detections to mosaics\n", Nmatch);
    284288  return (TRUE);
    285289}
    … …  
    507511int rationalize_mosaics (Catalog *catalog, int Ncatalog) {
    508512
    509   double *imageOffset, *starOffset;
    510   int *starNcount;
     513  double *imageOffset, **starOffset;
     514  int **starNcount, *seclist;
    511515  int **Slist, *NSlist, *NSLIST;
    512   int i, j, k, m, nMos;
     516  int i, j, k, m, nMos, Ns, found;
    513517
    514518  off_t Nimage;
    … …  
    528532  ALLOCATE (NSlist, int,   Nmosaic); // number of stars on mosaic
    529533  ALLOCATE (NSLIST, int,   Nmosaic); // number of Slist entries allocated
     534  memset (Slist, 0, Nmosaic*sizeof(int *));
    530535
    531536  // find the images / mosaics with negative clouds and save their offset
    … …  
    552557  }
    553558
    554   // allocate an array for star offset
     559  int Nsecfilt = GetPhotcodeNsecfilt ();
     560  ALLOCATE (seclist, int, Nphotcodes);
     561  for (Ns = 0; Ns < Nphotcodes; Ns ++) {
     562    int thisCode = photcodes[Ns][0].code;
     563    seclist[Ns] = GetPhotcodeNsec(thisCode);
     564  }
     565
     566  // allocate an array for star offsets
    555567  int Nstars = 0;
    556568  int NSTARS = 1000;
    557   ALLOCATE (starOffset, double, NSTARS);
    558   ALLOCATE (starNcount, int,    NSTARS);
     569  ALLOCATE (starOffset, double *, NSTARS);
     570  ALLOCATE (starNcount, int *,    NSTARS);
     571  memset (starOffset, 0, NSTARS*sizeof(double *));
     572  memset (starNcount, 0, NSTARS*sizeof(int *));
    559573
    560574  // find the mean offset for each star
    561575  for (i = 0; i < Ncatalog; i++) {
    562576    for (j = 0; j < catalog[i].Naverage; j++) {
    563       starOffset[Nstars] = 0.0;
    564       starNcount[Nstars] = 0;
    565 
    566       // skip bad stars
    567       if (catalog[i].average[j].flags & STAR_BAD) continue; 
     577      ALLOCATE (starOffset[Nstars], double, Nphotcodes);
     578      ALLOCATE (starNcount[Nstars], int,    Nphotcodes);
     579      memset (starOffset[Nstars], 0, Nphotcodes*sizeof(double));
     580      memset (starNcount[Nstars], 0, Nphotcodes*sizeof(int));
     581     
    568582      m = catalog[i].average[j].measureOffset;
    569583
    … …  
    573587        // skip unused measurements
    574588        if (catalog[i].measure[m].dbFlags & MEAS_BAD) continue;
     589
     590        // skip unused measurements
     591        int Nsec;
     592        int ecode = GetPhotcodeEquivCodebyCode (catalog[i].measure[m].photcode);
     593        found = FALSE;
     594        for (Ns = 0; !found && (Ns < Nphotcodes); Ns ++) {
     595          if (ecode == photcodes[Ns][0].code) {
     596            found = TRUE;
     597            break;
     598          }
     599        }
     600        if (!found) continue;
     601        Nsec = seclist[Ns];
     602
     603        // bad stars for this secfilt
     604        if (catalog[i].secfilt[Nsecfilt*j+Nsec].flags & STAR_BAD) continue; 
    575605
    576606        // skip REF measurements (not tied to an image)
    … …  
    581611        if (nMos == -1) continue;
    582612
     613        if (mosaic[nMos].photcode != ecode) {
     614          fprintf (stderr, "*");
     615        }
     616
     617        assert (Ns >= 0);
     618        assert (Ns < Nphotcodes);
     619
    583620        // accumulate the offsets from the negative cloud images (others have 0.0 value)
    584         starOffset[Nstars] += imageOffset[nMos];
    585         starNcount[Nstars] ++;
     621        starOffset[Nstars][Ns] += imageOffset[nMos];
     622        starNcount[Nstars][Ns] ++;
    586623       
    587624        // record the mosaic->star reference
    … …  
    596633      if (Nstars == NSTARS) {
    597634        NSTARS += 1000;
    598         REALLOCATE (starOffset, double, NSTARS);
    599         REALLOCATE (starNcount, int,    NSTARS);
     635        REALLOCATE (starOffset, double *, NSTARS);
     636        REALLOCATE (starNcount, int *,    NSTARS);
     637        memset (&starOffset[NSTARS-1000], 0, 1000*sizeof(double *));
     638        memset (&starNcount[NSTARS-1000], 0, 1000*sizeof(int *));
    600639      }
    601640    }
    … …  
    604643  // find the mean offset of the images without negative clouds
    605644  for (i = 0; i < Nmosaic; i++) {
     645
     646    found = FALSE;
     647    for (Ns = 0; !found && (Ns < Nphotcodes); Ns ++) {
     648      if (mosaic[i].photcode == photcodes[Ns][0].code) {
     649        found = TRUE;
     650        break;
     651      }
     652    }
     653    if (!found) {
     654      fprintf (stderr, "invalid photcode for mosaic?\n");
     655      abort();
     656    }
    606657
    607658    // a negative cloud image (cloud: Mcal > 0; anti-clouds: Mcal < 0; imageOffset = -Mcal)
    … …  
    614665    for (j = 0; j < NSlist[i]; j++) {
    615666      Nstars = Slist[i][j];
    616       if (starNcount[Nstars] > 1) {
    617         dM += (starOffset[Nstars] / starNcount[Nstars]);
     667      if (starNcount[Nstars][Ns] > 1) {
     668        dM += (starOffset[Nstars][Ns] / starNcount[Nstars][Ns]);
    618669      }
    619670    }
    … …  
    631682    mosaic[i].Mcal += imageOffset[i];
    632683  }
     684
     685  for (i = 0; i < Nstars; i++) {
     686    free (starOffset[i]);
     687    free (starNcount[i]);
     688  }
     689  free (starOffset);
     690  free (starNcount);
    633691
    634692  for (i = 0; i < Nmosaic; i++){
    … …  
    638696  free (NSLIST);
    639697  free (imageOffset);
    640 
     698  free (seclist);
    641699  return (TRUE);
    642700}

  • branches/eam_branches/ipp-20110404/Ohana/src/relphot/src/StarOps.c

    r31262 r31272  
    2929float getMrel (Catalog *catalog, off_t meas, int cat) {
    3030
    31   int Nsec, Nsecfilt, code;
     31  int Nsec, Nsecfilt, photcode;
    3232  int ave;
    3333  float value;
    3434
    3535  ave = catalog[cat].measure[meas].averef;
    36   code = catalog[cat].measure[meas].photcode;
    37 
    38   // XXX DEP : this should use a flag associated with secfilt
    39   if (catalog[cat].average[ave].flags & STAR_BAD) return (NAN); 
     36  photcode = catalog[cat].measure[meas].photcode;
     37
     38  int ecode = GetPhotcodeEquivCodebyCode (photcode);
     39  Nsec = GetPhotcodeNsec(ecode);
     40  Nsecfilt = GetPhotcodeNsecfilt ();
     41
     42  // is this star OK?
     43  if (catalog[cat].secfilt[Nsecfilt*ave+Nsec].flags & STAR_BAD) return (NAN); 
    4044 
    41   Nsec = GetPhotcodeNsec(code);
    42   Nsecfilt = GetPhotcodeNsecfilt ();
    43 
    4445  value = catalog[cat].secfilt[Nsecfilt*ave+Nsec].M;
    4546  return (value);
    … …  
    5253  float Msys, Mcal, Mmos, Mgrid;
    5354  StatType stats;
    54   int Nsec, Nsecfilt, ecode;
    55 
    56   Nsecfilt = GetPhotcodeNsecfilt ();
     55
     56  int Nsecfilt = GetPhotcodeNsecfilt ();
    5757  Nfew = Nsys = Nbad = Ncal = Nmos = Ngrid = 0;
    5858
    … …  
    6464
    6565        int thisCode = photcodes[Ns][0].code;
    66         Nsec = GetPhotcodeNsec(thisCode);
     66        int Nsec = GetPhotcodeNsec(thisCode);
    6767
    6868        /* calculate the average value for a single star */
    69         // XXX this flag should be set by secfilt, not average
    70         if (catalog[i].average[j].flags & STAR_BAD) continue; 
     69
     70        // skip bad stars
     71        if (catalog[i].secfilt[Nsecfilt*j+Nsec].flags & STAR_BAD) continue;
    7172        m = catalog[i].average[j].measureOffset;
    7273
    … …  
    7475        for (k = 0; k < catalog[i].average[j].Nmeasure; k++, m++) {
    7576          // skip measurements that do not match the current photcode
    76           ecode = GetPhotcodeEquivCodebyCode (catalog[i].measure[m].photcode);
     77          int ecode = GetPhotcodeEquivCodebyCode (catalog[i].measure[m].photcode);
    7778          if (ecode != thisCode) { continue; }
    7879
    … …  
    123124
    124125        // when performing the grid analysis, STAR_TOOFEW will be set to 1;
    125         // XXX DEP this makes no sense: need a separate flag for each secfilt
    126126        if (N <= STAR_TOOFEW) { /* too few measurements */
    127           catalog[i].average[j].flags |= ID_STAR_FEW;
     127          catalog[i].secfilt[Nsecfilt*j+Nsec].flags |= ID_STAR_FEW;
    128128          Nfew ++;
    129129        } else {
    130           catalog[i].average[j].flags &= ~ID_STAR_FEW;
     130          catalog[i].secfilt[Nsecfilt*j+Nsec].flags &= ~ID_STAR_FEW;
    131131        }       
    132132
    … …  
    408408    for (i = Ntot = 0; i < Ncatalog; i++) {
    409409      for (j = 0; j < catalog[i].Naverage; j++) {
    410         if (catalog[i].average[j].flags & STAR_BAD) continue;
     410        if ( catalog[i].secfilt[Nsecfilt*j+Nsec].flags & STAR_BAD ) continue;
    411411        Xm = catalog[i].secfilt[Nsecfilt*j+Nsec].Xm;
    412412        if (Xm == -1) continue;
    … …  
    434434        mark = (dM > MaxScatter) || (Xm == NAN_S_SHORT) || (Chisq > MaxChisq);
    435435        if (mark) {
    436           catalog[i].average[j].flags |= ID_STAR_POOR;
     436          catalog[i].secfilt[Nsecfilt*j+Nsec].flags |= ID_STAR_POOR;
    437437          Ndel ++;
    438438        } else {
    439           catalog[i].average[j].flags &= ~ID_STAR_POOR;
     439          catalog[i].secfilt[Nsecfilt*j+Nsec].flags &= ~ID_STAR_POOR;
    440440        }
    441441        Nave ++;
    … …  
    492492
    493493        int thisCode = photcodes[Ns][0].code;
    494 
     494        int Nsec = GetPhotcodeNsec(thisCode);
     495       
    495496        /* skip bad stars to prevent them from becoming good (on inner sample) */
    496         if (catalog[i].average[j].flags & STAR_BAD) continue; 
     497        if (catalog[i].secfilt[Nsecfilt*j+Nsec].flags & STAR_BAD) continue; 
    497498
    498499        /* accumulate list of valid measurements */
    … …  
    582583}
    583584
    584 StatType statsStarN (Catalog *catalog, int Ncatalog, int seccode) {
     585StatType statsStarN (Catalog *catalog, int Ncatalog, int Nsec, int seccode) {
    585586
    586587  off_t j, k, m, Ntot;
    … …  
    589590  float Mcal, Mmos, Mgrid;
    590591  StatType stats;
     592  int N1, N2, N3, N4, N0;
     593  N1 = N2 = N3 = N4 = N0 = 0;
     594
     595  int Nsecfilt = GetPhotcodeNsecfilt ();
    591596
    592597  Ntot = 0;
    … …  
    603608
    604609      /* calculate the average value for a single star */
    605       if (catalog[i].average[j].flags & STAR_BAD) continue; 
     610      if (catalog[i].secfilt[Nsecfilt*j+Nsec].flags & STAR_BAD) { N1++; continue;  }
    606611      m = catalog[i].average[j].measureOffset;
    607 
    608       int ecode = GetPhotcodeEquivCodebyCode (catalog[i].measure[m].photcode);
    609       if (ecode == seccode) continue;
    610612
    611613      N = 0;
    612614      for (k = 0; k < catalog[i].average[j].Nmeasure; k++, m++) {
     615        int ecode = GetPhotcodeEquivCodebyCode (catalog[i].measure[m].photcode);
     616        if (ecode != seccode) { N0++; continue;}
    613617        Mcal = getMcal  (m, i);
    614         if (isnan(Mcal)) continue;
     618        if (isnan(Mcal)) { N2++; continue;}
    615619        Mmos = getMmos  (m, i);
    616         if (isnan(Mmos)) continue;
     620        if (isnan(Mmos)) { N3++; continue; }
    617621        Mgrid = getMgrid (m, i);
    618         if (isnan(Mgrid)) continue;
     622        if (isnan(Mgrid)) { N4++; continue;}
    619623        N++;
    620624      }
    … …  
    626630  }
    627631
     632  fprintf (stderr, "N1: %d, N2: %d, N3: %d, N4: %d, N0: %d\n", N1, N2, N3, N4, N0);
    628633  liststats (list, dlist, n, &stats);
    629634  free (list);
    … …  
    655660
    656661      /* calculate the average value for a single star */
    657       if (catalog[i].average[j].flags & STAR_BAD) continue; 
     662      if (catalog[i].secfilt[Nsecfilt*j+Nsec].flags & STAR_BAD) continue; 
    658663       
    659664      Xm = catalog[i].secfilt[Nsecfilt*j+Nsec].Xm;
    … …  
    694699
    695700      /* calculate the average value for a single star */
    696       if (catalog[i].average[j].flags & STAR_BAD) continue; 
     701      if (catalog[i].secfilt[Nsecfilt*j+Nsec].flags & STAR_BAD) continue; 
    697702
    698703      dM = catalog[i].secfilt[Nsecfilt*j+Nsec].dM;
    … …  
    733738    for (i = 0; i < Ncatalog; i++) {
    734739      for (j = 0; j < catalog[i].Naverage; j++) {
    735         if (catalog[i].average[j].flags & STAR_BAD) continue; 
     740        if (catalog[i].secfilt[Nsecfilt*j+Nsec].flags & STAR_BAD) continue; 
    736741        dMrel = catalog[i].secfilt[Nsecfilt*j+Nsec].dM;
    737742        bin = dMrel / 0.00025;
    … …  
    773778    for (i = 0; i < Ncatalog; i++) {
    774779      for (j = 0; j < catalog[i].Naverage; j++) {
    775         if (catalog[i].average[j].flags & STAR_BAD) continue;
     780        if (catalog[i].secfilt[Nsecfilt*j+Nsec].flags & STAR_BAD) continue;
    776781        xlist[N] = catalog[i].secfilt[Nsecfilt*j+Nsec].M;
    777782        value    = catalog[i].secfilt[Nsecfilt*j+Nsec].Xm;

  • branches/eam_branches/ipp-20110404/Ohana/src/relphot/src/bcatalog.c

    r31261 r31272  
    4545        subcatalog[0].secfilt[Nsecfilt*Naverage+Nsec].M  = NAN;
    4646        subcatalog[0].secfilt[Nsecfilt*Naverage+Nsec].dM = NAN;
    47         subcatalog[0].average[Naverage].flags &= ~ID_STAR_FEW;
    48         subcatalog[0].average[Naverage].flags &= ~ID_STAR_POOR;
     47        subcatalog[0].secfilt[Nsecfilt*Naverage+Nsec].flags &= ~ID_STAR_FEW;
     48        subcatalog[0].secfilt[Nsecfilt*Naverage+Nsec].flags &= ~ID_STAR_POOR;
    4949      }
    5050    }
    … …  
    7575
    7676      /* select measurements by quality */
    77       // XXX ignore this criterion for REF measurements?
    78       // XXX chnage this to select by bitflags
    7977      if (DophotSelect && ((catalog[0].measure[offset].photFlags >> 16) != DophotValue)) { Ndophot ++; continue; }
    8078

  • branches/eam_branches/ipp-20110404/Ohana/src/relphot/src/global_stats.c

    r31262 r31272  
    77  initstats ("MEAN");
    88
     9  fprintf (stderr, "\n");
    910  fprintf (stderr, "STATS            median     mean    sigma      min      max   Nmeas\n");
    1011
    … …  
    1617    int seccode = photcodes[Ns][0].code;
    1718
    18     stN = statsStarN (catalog, Ncatalog, seccode);
     19    stN = statsStarN (catalog, Ncatalog, Nsec, seccode);
    1920    stX = statsStarX (catalog, Ncatalog, Nsec);
    2021    stS = statsStarS (catalog, Ncatalog, Nsec);
    2122 
    2223    fprintf (stderr, "   --- stats for %s ---\n", photcodes[Ns][0].name);
    23     fprintf (stderr, "meas / image:   %7.0f  %7.0f  %7.0f  %7.0f  %7.0f  %6d\n",   imN.median, imN.mean, imN.sigma, imN.min, imN.max, imN.Nmeas);
    24     fprintf (stderr, "meas / mosaic:  %7.0f  %7.0f  %7.0f  %7.0f  %7.0f  %6d\n",   msN.median, msN.mean, msN.sigma, msN.min, msN.max, msN.Nmeas);
    2524    fprintf (stderr, "meas / star:    %7.0f  %7.1f  %7.1f  %7.0f  %7.0f  %6d\n",   stN.median, stN.mean, stN.sigma, stN.min, stN.max, stN.Nmeas);
     25    fprintf (stderr, "dMrel star:     %7.4f  %7.4f  %7.4f  %7.4f  %7.4f  %6d\n", stS.median, stS.mean, stS.sigma, stS.min, stS.max, stS.Nmeas);
     26    fprintf (stderr, "chisq star:     %7.1f  %7.1f  %7.1f  %7.1f  %7.1f  %6d\n",   stX.median, stX.mean, stX.sigma, stX.min, stX.max, stX.Nmeas);
    2627  }
    2728 
    … …  
    3637  msX = statsMosaicX (catalog);
    3738 
    38   fprintf (stderr, "chisq image:    %7.1f  %7.1f  %7.1f  %7.1f  %7.1f  %6d\n",   imX.median, imX.mean, imX.sigma, imX.min, imX.max, imX.Nmeas);
    39   fprintf (stderr, "chisq mosaic:   %7.1f  %7.1f  %7.1f  %7.1f  %7.1f  %6d\n",   msX.median, msX.mean, msX.sigma, msX.min, msX.max, msX.Nmeas);
    40   fprintf (stderr, "chisq star:     %7.1f  %7.1f  %7.1f  %7.1f  %7.1f  %6d\n",   stX.median, stX.mean, stX.sigma, stX.min, stX.max, stX.Nmeas);
    41  
     39  fprintf (stderr, "meas / image:   %7.0f  %7.0f  %7.0f  %7.0f  %7.0f  %6d\n",   imN.median, imN.mean, imN.sigma, imN.min, imN.max, imN.Nmeas);
    4240  fprintf (stderr, "Mcal image:     %7.4f  %7.4f  %7.4f  %7.4f  %7.4f  %6d\n",   imM.median, imM.mean, imM.sigma, imM.min, imM.max, imM.Nmeas);
    4341  fprintf (stderr, "dMcal image:    %7.4f  %7.4f  %7.4f  %7.4f  %7.4f  %6d\n",   imD.median, imD.mean, imD.sigma, imD.min, imD.max, imD.Nmeas);
    44  
     42  fprintf (stderr, "chisq image:    %7.1f  %7.1f  %7.1f  %7.1f  %7.1f  %6d\n",   imX.median, imX.mean, imX.sigma, imX.min, imX.max, imX.Nmeas);
     43
     44  fprintf (stderr, "meas / mosaic:  %7.0f  %7.0f  %7.0f  %7.0f  %7.0f  %6d\n",   msN.median, msN.mean, msN.sigma, msN.min, msN.max, msN.Nmeas);
    4545  fprintf (stderr, "Mcal mosaic:    %7.4f  %7.4f  %7.4f  %7.4f  %7.4f  %6d\n",   msM.median, msM.mean, msM.sigma, msM.min, msM.max, msM.Nmeas);
    4646  fprintf (stderr, "dMcal mosaic:   %7.4f  %7.4f  %7.4f  %7.4f  %7.4f  %6d\n",   msD.median, msD.mean, msD.sigma, msD.min, msD.max, msD.Nmeas);
     47  fprintf (stderr, "chisq mosaic:   %7.1f  %7.1f  %7.1f  %7.1f  %7.1f  %6d\n",   msX.median, msX.mean, msX.sigma, msX.min, msX.max, msX.Nmeas);
    4748 
    48   fprintf (stderr, "dMrel star:     %7.4f  %7.4f  %7.4f  %7.4f  %7.4f  %6d\n\n", stS.median, stS.mean, stS.sigma, stS.min, stS.max, stS.Nmeas);
    4949
    5050  initstats (STATMODE);

  • branches/eam_branches/ipp-20110404/Ohana/src/relphot/src/plot_scatter.c

    r31261 r31272  
    3131
    3232            /* calculate the average value for a single star */
    33             if (catalog[i].average[j].flags & STAR_BAD) continue; 
     33            if (catalog[i].secfilt[Nsecfilt*j+Nsec].flags & STAR_BAD) continue; 
    3434            m = catalog[i].average[j].measureOffset;
    3535

  • branches/eam_branches/ipp-20110404/Ohana/src/relphot/src/relphot.c

    r31260 r31272  
    8282
    8383  setExclusions (catalog, Ncatalog);
     84
     85  global_stats (catalog, Ncatalog);
    8486
    8587  if (PLOTSTUFF) {

  • branches/eam_branches/ipp-20110404/Ohana/src/relphot/src/relphot_objects.c

    r31259 r31272  
    33int relphot_objects () {
    44
    5   off_t i, j, k, m;
     5  off_t i, j, k;
    66  int Nsecfilt;
    77
    … …  
    5151          catalog.secfilt[j*Nsecfilt + k].Ncode = 0;
    5252          catalog.secfilt[j*Nsecfilt + k].Nused = 0;
    53         }
    54         m = catalog.average[j].measureOffset;
    55         for (k = 0; k < catalog.average[j].Nmeasure; k++) {
    56             // catalog.measure[m+k].dbFlags = 0;
    57             // catalog.measure[m+k].Mcal = 0;
     53          // XXX reset the photometry flags for secfilt entries?
    5854        }
    5955      }

  • branches/eam_branches/ipp-20110404/Ohana/src/relphot/src/setMrelFinal.c

    r31261 r31272  
    6262  setMcalOutput (catalog, 1);
    6363
     64  int Nsecfilt = GetPhotcodeNsecfilt ();
     65
    6466  /* clear ID_STAR_POOR, ID_STAR_FEW, ID_MEAS_NOCAL values before writing ??? */
    6567  for (i = 0; i < catalog[0].Naverage; i++) {
    6668    catalog[0].average[i].flags &= ~ID_STAR_FEW;
    6769    catalog[0].average[i].flags &= ~ID_STAR_POOR;
     70    for (j = 0; j < Nsecfilt; j++) {
     71        catalog[0].secfilt[i*Nsecfilt+j].flags &= ~ID_STAR_FEW;
     72        catalog[0].secfilt[i*Nsecfilt+j].flags &= ~ID_STAR_POOR;
     73    }
    6874    m = catalog[0].average[i].measureOffset;
    6975    for (j = 0; j < catalog[0].average[i].Nmeasure; j++, m++) {
Note: See TracChangeset for help on using the changeset viewer.