IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 4420


Ignore:
Timestamp:
Jun 28, 2005, 2:40:42 PM (21 years ago)
Author:
eugene
Message:

minor dvo updates

Location:
trunk/Ohana/src/opihi
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/Ohana/src/opihi/cmd.astro/imfit-qrgauss.c

    r3144 r4420  
    4444}
    4545
     46float qrgaussTD (float x, float y, float *par, int Npar, float *dpar) {
     47
     48  float X, Y, px, py;
     49  float z, r, q, f;
     50
     51  X = x - par[0];
     52  Y = y - par[1];
     53 
     54  px = par[2]*X;
     55  py = par[3]*Y;
     56
     57  z = 0.5*SQ(px) + 0.5*SQ(py) + par[4]*X*Y;
     58
     59  r = 1.0 / (1 + fpar[0]*z + pow(z,par[7]));
     60  f = par[5]*r + par[6];
     61  q = par[5]*SQ(r)*(fpar[0] + par[7]*pow(z,(par[7]-1)));
     62
     63  if (dpar != NULL) {
     64    dpar[0] = q*(2*px*par[2] + par[4]*Y);
     65    dpar[1] = q*(2*py*par[3] + par[4]*X);
     66    dpar[2] = -2*q*px*X*2;
     67    dpar[3] = -2*q*py*Y*2;
     68    dpar[4] = -q*X*Y;
     69    dpar[5] = +r;
     70    dpar[6] = +1;
     71    dpar[7] = -5*par[5]*SQ(r)*log(z)*pow(z,par[7]);
     72  }
     73  return (f);
     74}
     75
     76
     77# if (0)
    4678/* one component, two slopes: (1 + z^M + z^N)^(-1) -- x, y, sx, sy, sxy, I, sky, sr */
    4779float qrgaussTD (float x, float y, float *par, int Npar, float *dpar) {
    … …  
    76108  return (f);
    77109}
    78 
     110# endif

  • trunk/Ohana/src/opihi/dvo/.dvo

    r2598 r4420  
     1avextract -phothelp

  • trunk/Ohana/src/opihi/dvo/avextract.c

    r3462 r4420  
    5050  if (param == AVE_ZERO) {
    5151    if (!GetPhotcodeInfo (argv[2], &code, &mode)) {
    52       GetAverageParam ("help");
    53       fprintf (stderr, "value may also be a valid photcode\n");
    54       fprintf (stderr, "photcodes or 'mag' may have optional magnitude mode: mag,[Mave, Mref]\n");
     52      GetAverageParamHelp ();
    5553      goto escape;
    5654    }

  • trunk/Ohana/src/opihi/dvo/dmagaves.c

    r3462 r4420  
    4141  if (!GetPhotcodeInfo (argv[1], &code[0], &mode[0])) return (FALSE);
    4242  if (!GetPhotcodeInfo (argv[3], &code[1], &mode[1])) return (FALSE);
    43   if ((param = GetAverageParam (argv[5])) == AVE_ZERO) return (FALSE);
     43  if ((param = GetAverageParam (argv[5])) == AVE_ZERO) {
     44    GetAverageParamHelp ();
     45    return (FALSE);
     46  }
    4447  code[2] = GetPhotcodeEquivbyCode (code[0][0].code);
    4548  mode[2] = mode[0];

  • trunk/Ohana/src/opihi/dvo/photometry.c

    r4027 r4420  
    4848static double iMagMin;
    4949static int FlagSelect, FlagValue;
     50static int TypefracSelect, TypefracType, TypefracSign;
     51static double TypefracValue;
    5052
    5153/* applied to Average quantities */
    … …  
    237239  if (!strcasecmp (parname, "flag"))  param = AVE_FLAG;
    238240  if (!strcasecmp (parname, "type"))  param = AVE_TYPE;
     241  if (!strcasecmp (parname, "typefrac")) {
     242    if (!TypefracType) {
     243      fprintf (stderr, "typefrac needs to specify type to use\n");
     244      return (param);
     245    }
     246    param = AVE_TYPEFRAC;
     247  }
    239248  if (!strcasecmp (parname, "Nphot")) param = AVE_NPHOT;
    240249  if (!strcasecmp (parname, "Ncode")) param = AVE_NCODE;
    241   if (!strcasecmp (parname, "help")) {
    242     fprintf (stderr, "value may be one of the following:\n");
    243     fprintf (stderr, " ra dec dmag Nmeas Nmiss Xm Xp Nphot Ncode flag type\n");
    244   }
    245250  return (param);
     251}
     252
     253void GetAverageParamHelp () {
     254  fprintf (stderr, "value may be one of the following:\n");
     255  fprintf (stderr, " ra dec dmag Nmeas Nmiss Xm Xp Nphot Ncode flag type typefrac\n\n");
     256  fprintf (stderr, "value may also be a valid photcode\n");
     257  fprintf (stderr, "photcodes or 'mag' may have optional magnitude mode: mag,[Mave, Mref]\n");
     258  return;
    246259}
    247260
    … …  
    253266 
    254267  switch (mode) {
    255   case MEAS_XCCD:
    256   case MEAS_YCCD:
    257     break;
    258   case MEAS_XMOSAIC:
    259   case MEAS_YMOSAIC:
    260     /* mosaic defines a frame with 0,0 at the mosaic center, and 1 arcsec / pixel */
    261     mosaic.crpix1 = mosaic.crpix2 = 0.0;
    262     mosaic.cdelt1 = mosaic.cdelt2 = 1.0 / 3600;
    263     mosaic.pc1_1  = mosaic.pc2_2  = 1.0;
    264     mosaic.pc1_2  = mosaic.pc2_1  = 0.0;
    265     mosaic.Npolyterms = 0;
    266     strcpy (mosaic.ctype, "RA---SIN");
    267     break;
    268   default:
    269     return (TRUE);
     268    case MEAS_XCCD:
     269    case MEAS_YCCD:
     270      break;
     271    case MEAS_XMOSAIC:
     272    case MEAS_YMOSAIC:
     273      /* mosaic defines a frame with 0,0 at the mosaic center, and 1 arcsec / pixel */
     274      mosaic.crpix1 = mosaic.crpix2 = 0.0;
     275      mosaic.cdelt1 = mosaic.cdelt2 = 1.0 / 3600;
     276      mosaic.pc1_1  = mosaic.pc2_2  = 1.0;
     277      mosaic.pc1_2  = mosaic.pc2_1  = 0.0;
     278      mosaic.Npolyterms = 0;
     279      strcpy (mosaic.ctype, "RA---SIN");
     280      break;
     281    default:
     282      return (TRUE);
    270283  }
    271284
    … …  
    418431  }
    419432
     433  /* select on measurement type: 1,2,3 (AVERAGE ONLY) */
     434  TypefracType = 0;
     435  if (N = get_argument (*argc, argv, "-usetype")) {
     436    remove_argument (N, argc, argv);
     437    TypefracType = atoi (argv[N]);
     438    remove_argument (N, argc, argv);
     439  }
     440
     441  /* select on measurement type: 1,2,3 (AVERAGE ONLY) */
     442  TypefracSelect = FALSE;
     443  if (N = get_argument (*argc, argv, "-typefrac")) {
     444    remove_argument (N, argc, argv);
     445    TypefracType  = atoi (argv[N]);
     446    remove_argument (N, argc, argv);
     447    TypefracValue = fabs (atof (argv[N]));
     448    TypefracSign = 0;
     449    if (argv[N][0] == '-') TypefracSign = -1;
     450    if (argv[N][0] == '+') TypefracSign = +1;
     451    remove_argument (N, argc, argv);
     452    TypefracSelect = TRUE;
     453  }
     454
    420455  /* select by number of measurements (AVERAGE ONLY) */
    421456  NphotSelect = FALSE;
    … …  
    474509
    475510  /* chisq, fwhm, Nphot, Ncode */
    476   if (!TestAverage (code, average, secfilt, measure)) return (list);
     511  /* if (!TestAverage (code, average, secfilt, measure)) return (list); */
    477512
    478513  /* look for measures */
    … …  
    490525    value = 0;
    491526    switch (param) {
    492     case MEAS_MAG: /* magnitudes are already determined above */
    493       value = M;
    494       break;
    495     case MEAS_RA: /* OK */
    496       value = average[0].R - measure[i].dR / 360000.0;
    497       break;
    498     case MEAS_DEC: /* OK */
    499       value = average[0].D - measure[i].dD / 360000.0;
    500       break;
    501     case MEAS_dMAG: /* OK */
    502       value = 0.001*measure[i].dM;
    503       break;
    504     case MEAS_AIRMASS: /* OK */
    505       value = 0.001*measure[i].airmass;
    506       break;
    507     case MEAS_EXPTIME: /* OK */
    508       value = pow (10.0, measure[i].dt * 0.0004);
    509       break;
    510     case MEAS_PHOTCODE: /* OK */
    511       value = measure[i].source;
    512       break;
    513     case MEAS_TIME: /* OK */
    514       value = TimeValue (measure[i].t, TimeReference, TimeFormat);
    515       break;
    516     case MEAS_dR: /* OK */
    517       value = 0.01*measure[i].dR;
    518       break;
    519     case MEAS_dD: /* OK */
    520       value = 0.01*measure[i].dD;
    521       break;
    522     case MEAS_FWHM: /* OK */
    523       value = 0.01*measure[i].FWx;
    524       break;
    525     case MEAS_DOPHOT: /* OK */
    526       value = measure[i].dophot;
    527       break;
    528     case MEAS_FLAGS: /* ? */
    529       value = measure[i].flags;
    530       break;
    531     case MEAS_XCCD: /* OK */
    532       ra  = average[0].R - measure[i].dR / 360000.0;
    533       dec = average[0].D - measure[i].dD / 360000.0;
    534       m = match_image_subset (image, subset, Nsubset, measure[i].t, measure[i].source);
    535       if (m == -1) break;
    536       if (!FindMosaicForImage (image, Nimage, m)) break;
    537       RD_to_XY (&x, &y, ra, dec, &image[m].coords);
    538       value = x;
    539       break;
    540     case MEAS_YCCD: /* OK */
    541       ra  = average[0].R - measure[i].dR / 360000.0;
    542       dec = average[0].D - measure[i].dD / 360000.0;
    543       m = match_image_subset (image, subset, Nsubset, measure[i].t, measure[i].source);
    544       if (m == -1) break;
    545       if (!FindMosaicForImage (image, Nimage, m)) break;
    546       RD_to_XY (&x, &y, ra, dec, &image[m].coords);
    547       value = y;
    548       break;
    549     case MEAS_XMOSAIC: /* OK */
    550       ra  = average[0].R - measure[i].dR / 360000.0;
    551       dec = average[0].D - measure[i].dD / 360000.0;
    552       m = match_image_subset (image, subset, Nsubset, measure[i].t, measure[i].source);
    553       if (m == -1) break;
    554       /* this should use the mosaic assoicated with the image */
    555       /* the solution here depends on image.coords having crref1,2 set to match the boresite center */
    556       /* XXX set the mosaic.coords to have a unity WRP transformation in which x,y = ra,dec */
    557       mosaic.crval1 = image[m].coords.crval1;
    558       mosaic.crval2 = image[m].coords.crval2;
    559       RD_to_XY (&x, &y, ra, dec, &mosaic);
    560       value = x;
    561       break;
    562     case MEAS_YMOSAIC: /* OK */
    563       ra  = average[0].R - measure[i].dR / 360000.0;
    564       dec = average[0].D - measure[i].dD / 360000.0;
    565       m = match_image_subset (image, subset, Nsubset, measure[i].t, measure[i].source);
    566       if (m == -1) break;
    567       /* same comments as above */
    568       mosaic.crval1 = image[m].coords.crval1;
    569       mosaic.crval2 = image[m].coords.crval2;
    570       RD_to_XY (&x, &y, ra, dec, &mosaic);
    571       value = y;
    572       break;
     527      case MEAS_MAG: /* magnitudes are already determined above */
     528        value = M;
     529        break;
     530      case MEAS_RA: /* OK */
     531        value = average[0].R - measure[i].dR / 360000.0;
     532        break;
     533      case MEAS_DEC: /* OK */
     534        value = average[0].D - measure[i].dD / 360000.0;
     535        break;
     536      case MEAS_dMAG: /* OK */
     537        value = 0.001*measure[i].dM;
     538        break;
     539      case MEAS_AIRMASS: /* OK */
     540        value = 0.001*measure[i].airmass;
     541        break;
     542      case MEAS_EXPTIME: /* OK */
     543        value = pow (10.0, measure[i].dt * 0.0004);
     544        break;
     545      case MEAS_PHOTCODE: /* OK */
     546        value = measure[i].source;
     547        break;
     548      case MEAS_TIME: /* OK */
     549        value = TimeValue (measure[i].t, TimeReference, TimeFormat);
     550        break;
     551      case MEAS_dR: /* OK */
     552        value = 0.01*measure[i].dR;
     553        break;
     554      case MEAS_dD: /* OK */
     555        value = 0.01*measure[i].dD;
     556        break;
     557      case MEAS_FWHM: /* OK */
     558        value = 0.01*measure[i].FWx;
     559        break;
     560      case MEAS_DOPHOT: /* OK */
     561        value = measure[i].dophot;
     562        break;
     563      case MEAS_FLAGS: /* ? */
     564        value = measure[i].flags;
     565        break;
     566      case MEAS_XCCD: /* OK */
     567        ra  = average[0].R - measure[i].dR / 360000.0;
     568        dec = average[0].D - measure[i].dD / 360000.0;
     569        m = match_image_subset (image, subset, Nsubset, measure[i].t, measure[i].source);
     570        if (m == -1) break;
     571        if (!FindMosaicForImage (image, Nimage, m)) break;
     572        RD_to_XY (&x, &y, ra, dec, &image[m].coords);
     573        value = x;
     574        break;
     575      case MEAS_YCCD: /* OK */
     576        ra  = average[0].R - measure[i].dR / 360000.0;
     577        dec = average[0].D - measure[i].dD / 360000.0;
     578        m = match_image_subset (image, subset, Nsubset, measure[i].t, measure[i].source);
     579        if (m == -1) break;
     580        if (!FindMosaicForImage (image, Nimage, m)) break;
     581        RD_to_XY (&x, &y, ra, dec, &image[m].coords);
     582        value = y;
     583        break;
     584      case MEAS_XMOSAIC: /* OK */
     585        ra  = average[0].R - measure[i].dR / 360000.0;
     586        dec = average[0].D - measure[i].dD / 360000.0;
     587        m = match_image_subset (image, subset, Nsubset, measure[i].t, measure[i].source);
     588        if (m == -1) break;
     589        /* this should use the mosaic assoicated with the image */
     590        /* the solution here depends on image.coords having crref1,2 set to match the boresite center */
     591        /* XXX set the mosaic.coords to have a unity WRP transformation in which x,y = ra,dec */
     592        mosaic.crval1 = image[m].coords.crval1;
     593        mosaic.crval2 = image[m].coords.crval2;
     594        RD_to_XY (&x, &y, ra, dec, &mosaic);
     595        value = x;
     596        break;
     597      case MEAS_YMOSAIC: /* OK */
     598        ra  = average[0].R - measure[i].dR / 360000.0;
     599        dec = average[0].D - measure[i].dD / 360000.0;
     600        m = match_image_subset (image, subset, Nsubset, measure[i].t, measure[i].source);
     601        if (m == -1) break;
     602        /* same comments as above */
     603        mosaic.crval1 = image[m].coords.crval1;
     604        mosaic.crval2 = image[m].coords.crval2;
     605        RD_to_XY (&x, &y, ra, dec, &mosaic);
     606        value = y;
     607        break;
    573608    }
    574609    list[Nlist] = value;
    … …  
    582617double ExtractAverages (PhotCode *code, int mode, Average *average, SecFilt *secfilt, Measure *measure, int param) {
    583618
    584   int i, k, Nm, Type;
    585   double fwhm, value, dM;
     619  int i, k, Nm;
     620  double value;
    586621
    587622  value = NO_MAG;
    … …  
    589624  /* need valid code if param is: */
    590625  switch (param) {
    591   case AVE_MAG:
    592   case AVE_dMAG:
    593   case AVE_Xm:
    594   case AVE_TYPE:
    595   case AVE_NCODE:
    596   case AVE_NPHOT:
    597     if (code == NULL) return (NO_MAG);
    598     break;
    599   default:
    600     break;
     626    case AVE_MAG:
     627    case AVE_dMAG:
     628    case AVE_Xm:
     629    case AVE_TYPE:
     630    case AVE_NCODE:
     631    case AVE_NPHOT:
     632      if (code == NULL) return (NO_MAG);
     633      break;
     634    default:
     635      break;
    601636  }
    602637
    … …  
    604639  if (!TestAverage (code, average, secfilt, measure)) return (NO_MAG);
    605640
    606   /* for ErrSelect, check average errors */
    607   if (ErrSelect) {
    608     dM = iPhotdM (code, average, secfilt);
    609     if (dM > ErrValue) return (NO_MAG);
    610   }
    611  
    612   /* for TypeSelect, check on TypeCode for this object */
    613   if (TypeSelect) {
    614     Type = DetermineTypeCode (average, measure, code[0].code);
    615     if (Type != TypeValue) return (NO_MAG);
    616   }
    617 
    618641  /* assign vector values */
    619642  switch (param) {
    620   case AVE_RA:
    621     value = average[0].R;
    622     break;
    623   case AVE_DEC:
    624     value = average[0].D;
    625     break;
    626   case AVE_NMEAS:
    627     value = average[0].Nm;
    628     break;
    629   case AVE_NMISS:
    630     value = average[0].Nn;
    631     break;
    632   case AVE_Xp:
    633     value = 0.01*average[0].Xp;
    634     break;
    635   case AVE_FLAG:
    636     value = average[0].code;
    637     break;
    638   case AVE_MAG:
    639     switch (mode) {
    640     case MAG_AVE:
    641       value = PhotAve  (code, average, secfilt);
    642       break;
    643     case MAG_REF:
    644       value = PhotRef  (code, average, secfilt, measure);
    645       break;
    646     }
    647     break;
    648   case AVE_dMAG:
    649     value = PhotdM (code, average, secfilt);
    650     break;
    651   case AVE_Xm:
    652     value = PhotXm (code, average, secfilt);
    653     break;
    654   case AVE_TYPE:
    655     value = DetermineTypeCode (average, measure, code[0].code);
    656     break;
    657   case AVE_NCODE:
    658     value = 0;
    659     for (i = 0; i < average[0].Nm; i++) {
    660       if (code[0].code != GetPhotcodeEquivCodebyCode (measure[i].source)) continue;
    661       value ++;
    662     }
    663     break;
    664   case AVE_NPHOT:
    665     value = 0;
    666     for (i = 0; i < average[0].Nm; i++) {
    667       if (code[0].code != GetPhotcodeEquivCodebyCode (measure[i].source)) continue;
    668       if (measure[i].flags & (ID_MEAS_POOR | ID_MEAS_SKIP)) continue;
    669       value ++;
    670     }
    671     break;
    672   case AVE_NCRIT:
    673     value = 0;
    674     for (i = 0; i < average[0].Nm; i++) {
    675       if (code[0].code != GetPhotcodeEquivCodebyCode (measure[i].source)) continue;
    676       if (ErrSelect && (measure[i].dM > ErrValue)) continue;
    677       if (FlagSelect && (measure[i].flags != FlagValue)) continue;
    678       if (TypeSelect && (TypeValue != GetMeasureTypeCode (&measure[i]))) continue;
    679       if (iMagSelect && (PhotInst (&measure[i]) < iMagMin)) continue;
    680       value ++;
    681     }
    682     break;
     643    case AVE_RA:
     644      value = average[0].R;
     645      break;
     646    case AVE_DEC:
     647      value = average[0].D;
     648      break;
     649    case AVE_NMEAS:
     650      value = average[0].Nm;
     651      break;
     652    case AVE_NMISS:
     653      value = average[0].Nn;
     654      break;
     655    case AVE_Xp:
     656      value = 0.01*average[0].Xp;
     657      break;
     658    case AVE_FLAG:
     659      value = average[0].code;
     660      break;
     661    case AVE_MAG:
     662      switch (mode) {
     663        case MAG_AVE:
     664          value = PhotAve  (code, average, secfilt);
     665          break;
     666        case MAG_REF:
     667          value = PhotRef  (code, average, secfilt, measure);
     668          break;
     669      }
     670      break;
     671    case AVE_dMAG:
     672      value = PhotdM (code, average, secfilt);
     673      break;
     674    case AVE_Xm:
     675      value = PhotXm (code, average, secfilt);
     676      break;
     677    case AVE_TYPE:
     678      value = DetermineTypeCode (average, measure, code[0].code);
     679      break;
     680    case AVE_TYPEFRAC:
     681      value = DetermineTypefrac (average, measure, code);
     682      break;
     683    case AVE_NCODE:
     684      value = 0;
     685      for (i = 0; i < average[0].Nm; i++) {
     686        if (code[0].code != GetPhotcodeEquivCodebyCode (measure[i].source)) continue;
     687        value ++;
     688      }
     689      break;
     690    case AVE_NPHOT:
     691      value = 0;
     692      for (i = 0; i < average[0].Nm; i++) {
     693        if (code[0].code != GetPhotcodeEquivCodebyCode (measure[i].source)) continue;
     694        if (measure[i].flags & (ID_MEAS_POOR | ID_MEAS_SKIP)) continue;
     695        value ++;
     696      }
     697      break;
     698    case AVE_NCRIT:
     699      value = 0;
     700      for (i = 0; i < average[0].Nm; i++) {
     701        if (code[0].code != GetPhotcodeEquivCodebyCode (measure[i].source)) continue;
     702        if (ErrSelect && (measure[i].dM > ErrValue)) continue;
     703        if (FlagSelect && (measure[i].flags != FlagValue)) continue;
     704        if (TypeSelect && (TypeValue != GetMeasureTypeCode (&measure[i]))) continue;
     705        if (iMagSelect && (PhotInst (&measure[i]) < iMagMin)) continue;
     706        value ++;
     707      }
     708      break;
    683709  }
    684710  return (value);
    685711} 
     712
     713/* return fraction of measures (matching code) which have requested type */
     714double DetermineTypefrac (Average *average, Measure *measure, PhotCode *code) {
     715
     716  double frac;
     717  int k, Nc, Nt;
     718 
     719  Nt = Nc = 0;
     720  for (k = 0; k < average[0].Nm; k++) {
     721    if ((code != NULL) && (code[0].code != GetPhotcodeEquivCodebyCode (measure[k].source))) continue;
     722    Nc ++;
     723    if (measure[k].dophot != TypefracType) continue;
     724    Nt ++;
     725  }
     726  frac = (double) Nt / (double) Nc;
     727  return (frac);
     728}
    686729
    687730/* determine the representative dophot type for this photcode */
    … …  
    704747int GetMeasureTypeCode (Measure *measure) {
    705748  switch (measure[0].dophot) {
    706   case 0:
    707   case 1:
    708   case 2:
    709     return (0);
    710     break;
    711   case 3:
    712   case 4:
    713   case 5:
    714   case 7:
    715   case 9:
    716     return (1);
    717     break;
    718   case 10:
    719   default:
    720     return (2);
     749    case 0:
     750    case 1:
     751    case 2:
     752      return (0);
     753      break;
     754    case 3:
     755    case 4:
     756    case 5:
     757    case 7:
     758    case 9:
     759      return (1);
     760      break;
     761    case 10:
     762    default:
     763      return (2);
    721764  }
    722765  return (2);
    … …  
    744787int TestAverage (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure) {
    745788
    746   int i, Nm;
    747   double value, fwhm;
     789  int i, Nm, Type;
     790  double fwhm, typefrac, dM, Xm;
    748791
    749792  /* exclusions based on average.params  */
    … …  
    751794    /* some average.params need a valid photcode for reference */
    752795    if (code == NULL) return (FALSE);
    753     value = PhotXm (code, average, secfilt);
    754     if (value == -1) return (FALSE);
    755     if (value > ChiLimit) return (FALSE);
     796    Xm = PhotXm (code, average, secfilt);
     797    if (Xm == -1) return (FALSE);
     798    if (Xm > ChiLimit) return (FALSE);
     799  }
     800 
     801  /* for ErrSelect, check average errors */
     802  if (ErrSelect) {
     803    if (code == NULL) return (FALSE);  /* need a valid code */
     804    dM = iPhotdM (code, average, secfilt);
     805    if (dM > ErrValue) return (NO_MAG);
    756806  }
    757807 
    … …  
    762812      fwhm = measure[i].FWx / 100.0;
    763813      switch (FWHMsign) {
    764       case 0:
    765         if (fwhm == FWHMvalue) break;
    766         continue;
    767       case +1:
    768         if (fwhm >= FWHMvalue) break;
    769         continue;
    770       case -1:
    771         if (fwhm <= FWHMvalue) break;
    772         continue;
     814        case 0:
     815          if (fwhm == FWHMvalue) break;
     816          continue;
     817        case +1:
     818          if (fwhm >= FWHMvalue) break;
     819          continue;
     820        case -1:
     821          if (fwhm <= FWHMvalue) break;
     822          continue;
    773823      }
    774824      Nm++;
    … …  
    785835    }
    786836    switch (NcodeSign) {
    787     case 0:
    788       if (Nm == NcodeValue) break;
    789       return (FALSE);
    790     case 1:
    791       if (Nm >= NcodeValue) break;
    792       return (FALSE);
    793     case -1:
    794       if (Nm <= NcodeValue) break;
    795       return (FALSE);
    796     default:
    797       return (FALSE);
     837      case 0:
     838        if (Nm == NcodeValue) break;
     839        return (FALSE);
     840      case 1:
     841        if (Nm >= NcodeValue) break;
     842        return (FALSE);
     843      case -1:
     844        if (Nm <= NcodeValue) break;
     845        return (FALSE);
     846      default:
     847        return (FALSE);
    798848    }
    799849  }
    … …  
    808858    }
    809859    switch (NphotSign) {
    810     case 0:
    811       if (Nm == NphotValue) break;
    812       return (FALSE);
    813     case 1:
    814       if (Nm >= NphotValue) break;
    815       return (FALSE);
    816     case -1:
    817       if (Nm <= NphotValue) break;
    818       return (FALSE);
    819     default:
    820       return (FALSE);
    821     }
    822   }
     860      case 0:
     861        if (Nm == NphotValue) break;
     862        return (FALSE);
     863      case 1:
     864        if (Nm >= NphotValue) break;
     865        return (FALSE);
     866      case -1:
     867        if (Nm <= NphotValue) break;
     868        return (FALSE);
     869      default:
     870        return (FALSE);
     871    }
     872  }
     873
     874  /* for TypeSelect, check on TypeCode for this object */
     875  if (TypeSelect) {
     876    Type = DetermineTypeCode (average, measure, code[0].code);
     877    if (Type != TypeValue) return (FALSE);
     878  }
     879
     880  /* for TypeSelect, check on TypeCode for this object */
     881  if (TypefracSelect) {
     882    typefrac = DetermineTypefrac (average, measure, code);
     883    switch (TypefracSign) {
     884      case 0:
     885        if (typefrac == TypefracValue) break;
     886        return (FALSE);
     887      case +1:
     888        if (typefrac >= TypefracValue) break;
     889        return (FALSE);
     890      case -1:
     891        if (typefrac <= TypefracValue) break;
     892        return (FALSE);
     893      default:
     894        return (FALSE);
     895    }
     896  }
     897
    823898  return (TRUE);
    824899}
    … …  
    10091084      value = 0;
    10101085      switch (param) {
    1011       case MEAS_MAG: /* magnitudes are already determined above */
    1012         value = use_first ? M1 : M2;
    1013         break;
    1014       case MEAS_RA: /* OK */
    1015         value = average[0].R - measure[n].dR / 360000.0;
    1016         break;
    1017       case MEAS_DEC: /* OK */
    1018         value = average[0].D - measure[n].dD / 360000.0;
    1019         break;
    1020       case MEAS_dMAG: /* OK */
    1021         value = 0.001*measure[n].dM;
    1022         break;
    1023       case MEAS_AIRMASS: /* OK */
    1024         value = 0.001*measure[n].airmass;
    1025         break;
    1026       case MEAS_EXPTIME: /* OK */
    1027         value = pow (10.0, measure[n].dt * 0.0004);
    1028         break;
    1029       case MEAS_PHOTCODE: /* OK */
    1030         value = measure[n].source;
    1031         break;
    1032       case MEAS_TIME: /* OK */
    1033         value = TimeValue (measure[n].t, TimeReference, TimeFormat);
    1034         break;
    1035       case MEAS_dR: /* OK */
    1036         value = 0.01*measure[n].dR;
    1037         break;
    1038       case MEAS_dD: /* OK */
    1039         value = 0.01*measure[n].dD;
    1040         break;
    1041       case MEAS_FWHM: /* OK */
    1042         value = 0.01*measure[n].FWx;
    1043         break;
    1044       case MEAS_DOPHOT: /* OK */
    1045         value = measure[n].dophot;
    1046         break;
    1047       case MEAS_FLAGS: /* ? */
    1048         value = measure[n].flags;
    1049         break;
    1050     case MEAS_XCCD: /* OK */
    1051       ra  = average[0].R - measure[n].dR / 360000.0;
    1052       dec = average[0].D - measure[n].dD / 360000.0;
    1053       m = match_image_subset (image, subset, Nsubset, measure[n].t, measure[n].source);
    1054       if (m == -1) break;
    1055       if (!FindMosaicForImage (image, Nimage, m)) break;
    1056       RD_to_XY (&x, &y, ra, dec, &image[m].coords);
    1057       value = x;
    1058       break;
    1059     case MEAS_YCCD: /* OK */
    1060       ra  = average[0].R - measure[n].dR / 360000.0;
    1061       dec = average[0].D - measure[n].dD / 360000.0;
    1062       m = match_image_subset (image, subset, Nsubset, measure[n].t, measure[n].source);
    1063       if (m == -1) break;
    1064       if (!FindMosaicForImage (image, Nimage, m)) break;
    1065       RD_to_XY (&x, &y, ra, dec, &image[m].coords);
    1066       value = y;
    1067       break;
    1068     case MEAS_XMOSAIC: /* OK */
    1069       ra  = average[0].R - measure[n].dR / 360000.0;
    1070       dec = average[0].D - measure[n].dD / 360000.0;
    1071       m = match_image_subset (image, subset, Nsubset, measure[n].t, measure[n].source);
    1072       if (m == -1) break;
    1073       mosaic.crval1 = image[m].coords.crval1;
    1074       mosaic.crval2 = image[m].coords.crval2;
    1075       RD_to_XY (&x, &y, ra, dec, &mosaic);
    1076       value = x;
    1077       break;
    1078     case MEAS_YMOSAIC: /* OK */
    1079       ra  = average[0].R - measure[n].dR / 360000.0;
    1080       dec = average[0].D - measure[n].dD / 360000.0;
    1081       m = match_image_subset (image, subset, Nsubset, measure[n].t, measure[n].source);
    1082       if (m == -1) break;
    1083       mosaic.crval1 = image[m].coords.crval1;
    1084       mosaic.crval2 = image[m].coords.crval2;
    1085       RD_to_XY (&x, &y, ra, dec, &mosaic);
    1086       value = y;
    1087       break;
     1086        case MEAS_MAG: /* magnitudes are already determined above */
     1087          value = use_first ? M1 : M2;
     1088          break;
     1089        case MEAS_RA: /* OK */
     1090          value = average[0].R - measure[n].dR / 360000.0;
     1091          break;
     1092        case MEAS_DEC: /* OK */
     1093          value = average[0].D - measure[n].dD / 360000.0;
     1094          break;
     1095        case MEAS_dMAG: /* OK */
     1096          value = 0.001*measure[n].dM;
     1097          break;
     1098        case MEAS_AIRMASS: /* OK */
     1099          value = 0.001*measure[n].airmass;
     1100          break;
     1101        case MEAS_EXPTIME: /* OK */
     1102          value = pow (10.0, measure[n].dt * 0.0004);
     1103          break;
     1104        case MEAS_PHOTCODE: /* OK */
     1105          value = measure[n].source;
     1106          break;
     1107        case MEAS_TIME: /* OK */
     1108          value = TimeValue (measure[n].t, TimeReference, TimeFormat);
     1109          break;
     1110        case MEAS_dR: /* OK */
     1111          value = 0.01*measure[n].dR;
     1112          break;
     1113        case MEAS_dD: /* OK */
     1114          value = 0.01*measure[n].dD;
     1115          break;
     1116        case MEAS_FWHM: /* OK */
     1117          value = 0.01*measure[n].FWx;
     1118          break;
     1119        case MEAS_DOPHOT: /* OK */
     1120          value = measure[n].dophot;
     1121          break;
     1122        case MEAS_FLAGS: /* ? */
     1123          value = measure[n].flags;
     1124          break;
     1125        case MEAS_XCCD: /* OK */
     1126          ra  = average[0].R - measure[n].dR / 360000.0;
     1127          dec = average[0].D - measure[n].dD / 360000.0;
     1128          m = match_image_subset (image, subset, Nsubset, measure[n].t, measure[n].source);
     1129          if (m == -1) break;
     1130          if (!FindMosaicForImage (image, Nimage, m)) break;
     1131          RD_to_XY (&x, &y, ra, dec, &image[m].coords);
     1132          value = x;
     1133          break;
     1134        case MEAS_YCCD: /* OK */
     1135          ra  = average[0].R - measure[n].dR / 360000.0;
     1136          dec = average[0].D - measure[n].dD / 360000.0;
     1137          m = match_image_subset (image, subset, Nsubset, measure[n].t, measure[n].source);
     1138          if (m == -1) break;
     1139          if (!FindMosaicForImage (image, Nimage, m)) break;
     1140          RD_to_XY (&x, &y, ra, dec, &image[m].coords);
     1141          value = y;
     1142          break;
     1143        case MEAS_XMOSAIC: /* OK */
     1144          ra  = average[0].R - measure[n].dR / 360000.0;
     1145          dec = average[0].D - measure[n].dD / 360000.0;
     1146          m = match_image_subset (image, subset, Nsubset, measure[n].t, measure[n].source);
     1147          if (m == -1) break;
     1148          mosaic.crval1 = image[m].coords.crval1;
     1149          mosaic.crval2 = image[m].coords.crval2;
     1150          RD_to_XY (&x, &y, ra, dec, &mosaic);
     1151          value = x;
     1152          break;
     1153        case MEAS_YMOSAIC: /* OK */
     1154          ra  = average[0].R - measure[n].dR / 360000.0;
     1155          dec = average[0].D - measure[n].dD / 360000.0;
     1156          m = match_image_subset (image, subset, Nsubset, measure[n].t, measure[n].source);
     1157          if (m == -1) break;
     1158          mosaic.crval1 = image[m].coords.crval1;
     1159          mosaic.crval2 = image[m].coords.crval2;
     1160          RD_to_XY (&x, &y, ra, dec, &mosaic);
     1161          value = y;
     1162          break;
    10881163      }
    10891164      list[Nlist] = value;

  • trunk/Ohana/src/opihi/include/dvo1.h

    r3517 r4420  
    1919/* average params */
    2020enum {AVE_ZERO, AVE_RA, AVE_DEC, AVE_MAG, AVE_REF, AVE_dMAG, AVE_Xm, AVE_Xp, AVE_NMEAS,
    21       AVE_NMISS, AVE_TYPE, AVE_NPHOT, AVE_NCODE, AVE_NCRIT, AVE_FLAG};
     21      AVE_NMISS, AVE_TYPE, AVE_NPHOT, AVE_NCODE, AVE_NCRIT, AVE_FLAG, AVE_TYPEFRAC};
    2222
    2323typedef struct {
    … …  
    6060double       *ExtractMeasuresDMag   PROTO((PhotCode **code, int *mode, Average *average, SecFilt *secfilt, Measure *measure, int *nlist));
    6161double       *ExtractMeasuresByDMag PROTO((PhotCode **code, int *mode, int use_first, Average *average, SecFilt *secfilt, Measure *measure, int *nlist, int param));
     62double        DetermineTypefrac     PROTO((Average *average, Measure *measure, PhotCode *code));
     63void          GetAverageParamHelp   PROTO(());
     64
    6265
    6366# endif
Note: See TracChangeset for help on using the changeset viewer.