IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 36910


Ignore:
Timestamp:
Jun 19, 2014, 8:11:39 AM (12 years ago)
Author:
eugene
Message:

rework dvo db photcode-related selection logic: allow fields of the form mag:psf:inst or g:ave:psf:stk, with arbitrary combinations; PhotInst, etc, now take options for mag class, etc

Location:
branches/eam_branches/ipp-20140610/Ohana/src
Files:
1 added
32 edited

Legend:

Unmodified
Added
Removed

  • branches/eam_branches/ipp-20140610/Ohana/src/addstar/src/find_matches.c

    r36904 r36910  
    202202      if (Nsec > -1) {
    203203        if (isnan(catalog[0].secfilt[n*Nsecfilt+Nsec].M)) {
    204           catalog[0].secfilt[n*Nsecfilt+Nsec].M = PhotCat (&catalog[0].measure[Nmeas]);
     204          catalog[0].secfilt[n*Nsecfilt+Nsec].M = PhotCat (&catalog[0].measure[Nmeas], MAG_CLASS_PSF);
    205205        }
    206206      }
    … …  
    290290      /* in UPDATE mode, this value is not saved; use relphot to recalculate */
    291291      if (Nsec > -1) {
    292         catalog[0].secfilt[Nave*Nsecfilt+Nsec].M = PhotCat (&catalog[0].measure[Nmeas]);
     292        catalog[0].secfilt[Nave*Nsecfilt+Nsec].M = PhotCat (&catalog[0].measure[Nmeas], MAG_CLASS_PSF);
    293293      }
    294294

  • branches/eam_branches/ipp-20140610/Ohana/src/addstar/src/find_matches_closest.c

    r36904 r36910  
    230230    if (Nsec > -1) {
    231231      if (isnan(catalog[0].secfilt[n*Nsecfilt+Nsec].M)) {
    232         catalog[0].secfilt[n*Nsecfilt+Nsec].M = PhotCat (&catalog[0].measure[Nmeas]);
     232        catalog[0].secfilt[n*Nsecfilt+Nsec].M = PhotCat (&catalog[0].measure[Nmeas], MAG_CLASS_PSF);
    233233      }
    234234    }
    … …  
    298298        /* in UPDATE mode, this value is not saved; use relphot to recalculate */
    299299        if (Nsec > -1) {
    300             catalog[0].secfilt[Nave*Nsecfilt+Nsec].M = PhotCat (&catalog[0].measure[Nmeas]);
     300            catalog[0].secfilt[Nave*Nsecfilt+Nsec].M = PhotCat (&catalog[0].measure[Nmeas], MAG_CLASS_PSF);
    301301        }
    302302

  • branches/eam_branches/ipp-20140610/Ohana/src/getstar/src/select_by_region.c

    r35066 r36910  
    7373        for (m = 0; m < catalog[0].average[i].Nmeasure; m++) {
    7474          if (catalog[0].measure[offset + m].photcode == code) {
    75             mag = PhotRel (&catalog[0].measure[offset + m], &catalog[0].average[i], &catalog[0].secfilt[i*Nsecfilt]);
     75            mag = PhotRel (&catalog[0].measure[offset + m], &catalog[0].average[i], &catalog[0].secfilt[i*Nsecfilt], MAG_CLASS_PSF);
    7676            break;
    7777          }
    … …  
    126126        for (m = 0; m < catalog[0].average[i].Nmeasure; m++) {
    127127          if (catalog[0].measure[offset + m].photcode == code) {
    128             mag = PhotRel (&catalog[0].measure[offset + m], &catalog[0].average[i], &catalog[0].secfilt[i*Nsecfilt]);
     128            mag = PhotRel (&catalog[0].measure[offset + m], &catalog[0].average[i], &catalog[0].secfilt[i*Nsecfilt], MAG_CLASS_PSF);
    129129            break;
    130130          }

  • branches/eam_branches/ipp-20140610/Ohana/src/getstar/src/write_getstar_ps1_dev_0.c

    r21508 r36910  
    6161      for (m = 0; m < average[i].Nmeasure; m++) {
    6262        if (measure[offset + m].photcode == code_c0) {
    63           output[i].mag = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt]);
     63          output[i].mag = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt], MAG_CLASS_PSF);
    6464          break;
    6565        }
    … …  
    7575      for (m = 0; m < average[i].Nmeasure; m++) {
    7676        if (measure[offset + m].photcode == code_c1) {
    77           output[i].c1 = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt]);
     77          output[i].c1 = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt], MAG_CLASS_PSF);
    7878          break;
    7979        }
    … …  
    8989      for (m = 0; m < average[i].Nmeasure; m++) {
    9090        if (measure[offset + m].photcode == code_c2) {
    91           output[i].c2 = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt]);
     91          output[i].c2 = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt], MAG_CLASS_PSF);
    9292          break;
    9393        }

  • branches/eam_branches/ipp-20140610/Ohana/src/getstar/src/write_getstar_ps1_dev_1.c

    r21508 r36910  
    6464      for (m = 0; m < average[i].Nmeasure; m++) {
    6565        if (measure[offset + m].photcode == code_c0) {
    66           output[i].mag = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt]);
     66          output[i].mag = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt], MAG_CLASS_PSF);
    6767          break;
    6868        }
    … …  
    7878      for (m = 0; m < average[i].Nmeasure; m++) {
    7979        if (measure[offset + m].photcode == code_c1) {
    80           output[i].c1 = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt]);
     80          output[i].c1 = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt], MAG_CLASS_PSF);
    8181          break;
    8282        }
    … …  
    9292      for (m = 0; m < average[i].Nmeasure; m++) {
    9393        if (measure[offset + m].photcode == code_c2) {
    94           output[i].c2 = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt]);
     94          output[i].c2 = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt], MAG_CLASS_PSF);
    9595          break;
    9696        }

  • branches/eam_branches/ipp-20140610/Ohana/src/getstar/src/write_getstar_ps1_dev_2.c

    r21508 r36910  
    7070      for (m = 0; m < average[i].Nmeasure; m++) {
    7171        if (measure[offset + m].photcode == code_c0) {
    72           output[i].mag = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt]);
     72          output[i].mag = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt], MAG_CLASS_PSF);
    7373          break;
    7474        }
    … …  
    8484      for (m = 0; m < average[i].Nmeasure; m++) {
    8585        if (measure[offset + m].photcode == code_c1) {
    86           output[i].c1 = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt]);
     86          output[i].c1 = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt], MAG_CLASS_PSF);
    8787          break;
    8888        }
    … …  
    9898      for (m = 0; m < average[i].Nmeasure; m++) {
    9999        if (measure[offset + m].photcode == code_c2) {
    100           output[i].c2 = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt]);
     100          output[i].c2 = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt], MAG_CLASS_PSF);
    101101          break;
    102102        }

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

    r36908 r36910  
    690690int PhotColor (Average *average, SecFilt *secfilt, Measure *measure, int c1, int c2, double *color);
    691691
    692 float PhotInstTiny (MeasureTiny *measure);
    693 float PhotCatTiny (MeasureTiny *measure);
    694 float PhotAperTiny (MeasureTiny *measure);
    695 float PhotSysTiny (MeasureTiny *measure, AverageTiny *average, SecFilt *secfilt);
    696 float PhotRelTiny (MeasureTiny *measure, AverageTiny *average, SecFilt *secfilt);
    697 float PhotCalTiny (MeasureTiny *thisone, AverageTiny *average, SecFilt *secfilt, MeasureTiny *measure, PhotCode *code);
    698 float PhotAveTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt);
    699 float PhotRefTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt, MeasureTiny *measure);
     692float PhotInstTiny (MeasureTiny *measure, dvoMagClassType class);
     693float PhotCatTiny (MeasureTiny *measure, dvoMagClassType class);
     694float PhotSysTiny (MeasureTiny *measure, AverageTiny *average, SecFilt *secfilt, dvoMagClassType class);
     695float PhotRelTiny (MeasureTiny *measure, AverageTiny *average, SecFilt *secfilt, dvoMagClassType class);
     696float PhotCalTiny (MeasureTiny *thisone, AverageTiny *average, SecFilt *secfilt, MeasureTiny *measure, PhotCode *code, dvoMagClassType class);
     697
     698float PhotAveTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt, dvoMagClassType class, dvoMagSourceType source);
     699float PhotRefTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt, MeasureTiny *measure, dvoMagClassType class, dvoMagSourceType source);
     700
    700701float PhotXmTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt);
    701702float PhotdMTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt);

  • branches/eam_branches/ipp-20140610/Ohana/src/libdvo/src/dbExtractMeasures.c

    r36908 r36910  
    103103      PhotCode *myEquiv = GetPhotcodeEquivbyCode (measure[0].photcode);
    104104
    105       // if we request mag:ave, use equiv for photcode
     105      // if we request mag:ave, use equiv for photcode (ie a given measure, say GPC1.g.XY01, will return g for mag:ave)
    106106      if  (field->photcode->type == PHOT_MAG) {
    107107        equiv = myEquiv;

  • branches/eam_branches/ipp-20140610/Ohana/src/libdvo/src/dvo_photcode_ops.c

    r36908 r36910  
    615615
    616616/* color term may not use DEP magnitude */
     617// currently only returns the PSF color
    617618float PhotColorForCode (Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code) {
    618619
    … …  
    834835
    835836/******** alternate photometry conversion functions using MeasureTiny and AverageTiny *********/
    836 float PhotInstTiny (MeasureTiny *measure) {
    837 
    838   int Np;
    839   float M;
    840 
    841   Np = photcodes[0].hashcode[measure[0].photcode];
     837float PhotInstTiny (MeasureTiny *measure, dvoMagClassType class) {
     838
     839  int Np = photcodes[0].hashcode[measure[0].photcode];
    842840  if (Np == -1) return (NAN);
    843 
    844   if (photcodes[0].code[Np].type == PHOT_REF) {
    845     M = measure[0].M;
    846     return (M);
    847   }
    848 
    849   M = measure[0].M - measure[0].dt - ZERO_POINT;
    850          
    851   return (M);
    852 
    853 }
    854 
    855 float PhotCatTiny (MeasureTiny *measure) {
    856 
    857   int Np;
    858   float Mcat;
    859   PhotCode *code;
    860 
    861   Np = photcodes[0].hashcode[measure[0].photcode];
     841  PhotCode *code = &photcodes[0].code[Np];
     842
     843  float Mraw = NAN;
     844  switch (class) {
     845    case MAG_CLASS_PSF:
     846      Mraw = measure[0].M;
     847      break;
     848    case MAG_CLASS_KRON:
     849      // Mraw = measure[0].Mkron;
     850      break;
     851    case MAG_CLASS_APER:
     852      // Mraw = measure[0].Map;
     853      break;
     854    default:
     855      break;
     856  }
     857  if (code->type == PHOT_REF) {
     858    return (Mraw);
     859  }
     860  float Minst = Mraw - measure[0].dt - ZERO_POINT;
     861
     862  return (Minst);
     863}
     864
     865float PhotCatTiny (MeasureTiny *measure, dvoMagClassType class) {
     866
     867  int Np = photcodes[0].hashcode[measure[0].photcode];
    862868  if (Np == -1) return (NAN);
    863 
    864   if (photcodes[0].code[Np].type == PHOT_REF) {
    865     Mcat = measure[0].M;
    866     return (Mcat);
    867   }
    868   code = &photcodes[0].code[Np];
    869   Mcat = measure[0].M - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
     869  PhotCode *code = &photcodes[0].code[Np];
     870
     871  float Mraw = NAN;
     872  switch (class) {
     873    case MAG_CLASS_PSF:
     874      Mraw = measure[0].M;
     875      break;
     876    case MAG_CLASS_KRON:
     877      // Mraw = measure[0].Mkron;
     878      break;
     879    case MAG_CLASS_APER:
     880      // Mraw = measure[0].Map;
     881      break;
     882    default:
     883      break;
     884  }
     885  if (code->type == PHOT_REF) {
     886    return (Mraw);
     887  }
     888
     889  float Mcat = Mraw - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
    870890 
    871891  return (Mcat);
    872892}
    873893
    874 # if (0)
    875 float PhotAperTiny (MeasureTiny *measure) {
    876 
    877   int Np;
    878   float Mcat;
    879   PhotCode *code;
    880 
    881   Np = photcodes[0].hashcode[measure[0].photcode];
     894float PhotSysTiny (MeasureTiny *measure, AverageTiny *average, SecFilt *secfilt, dvoMagClassType class) {
     895
     896  int Np = photcodes[0].hashcode[measure[0].photcode];
    882897  if (Np == -1) return (NAN);
    883 
    884   if (photcodes[0].code[Np].type == PHOT_REF) {
    885     Mcat = measure[0].Map;
    886     return (Mcat);
    887   }
    888   code = &photcodes[0].code[Np];
    889   Mcat = measure[0].Map - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
    890  
    891   return (Mcat);
    892 }
    893 # endif
    894 
    895 float PhotSysTiny (MeasureTiny *measure, AverageTiny *average, SecFilt *secfilt) {
    896 
    897   int i, Np;
    898   float Mcat, Mcol, Msys, mc, Mc;
    899   PhotCode *code;
    900 
    901   Np = photcodes[0].hashcode[measure[0].photcode];
    902   if (Np == -1) return (NAN);
    903 
    904   if (photcodes[0].code[Np].type == PHOT_REF) {
    905     Msys = measure[0].M;
    906     return (Msys);
    907   }
    908   code = &photcodes[0].code[Np];
    909   Mcat = measure[0].M - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
     898  PhotCode *code = &photcodes[0].code[Np];
     899
     900  float Mraw = NAN;
     901  switch (class) {
     902    case MAG_CLASS_PSF:
     903      Mraw = measure[0].M;
     904      break;
     905    case MAG_CLASS_KRON:
     906      // Mraw = measure[0].Mkron;
     907      break;
     908    case MAG_CLASS_APER:
     909      // Mraw = measure[0].Map;
     910      break;
     911    default:
     912      break;
     913  }
     914  if (code->type == PHOT_REF) {
     915    return (Mraw);
     916  }
     917  float Mcat = Mraw - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
    910918
    911919  /* for DEP, color must be made of PRI/SEC */
    912   mc = PhotColorForCodeTiny (average, secfilt, NULL, code);
     920  float mc = PhotColorForCodeTiny (average, secfilt, NULL, code);
    913921  if (isnan(mc)) return (Mcat);
    914   mc = mc - SCALE*code[0].dX;
    915 
    916   Mc = mc;
    917   Mcol = 0;
     922  mc -= SCALE*code[0].dX;
     923
     924  int i = 0;
     925  double Mc = mc;
     926  float Mcol = 0;
    918927  for (i = 0; i < code[0].Nc; i++) {
    919928    Mcol += code[0].X[i]*Mc;
    920929    Mc *= mc;
    921930  }
    922   Msys = Mcat + Mcol;
     931  float Msys = Mcat + Mcol;
    923932  return (Msys);
    924933}
    925934
    926 float PhotRelTiny (MeasureTiny *measure, AverageTiny *average, SecFilt *secfilt) {
    927 
    928   int i, Np;
    929   float Mcat, Mcol, Mrel, mc, Mc;
    930   PhotCode *code;
    931 
    932   Np = photcodes[0].hashcode[measure[0].photcode];
     935float PhotRelTiny (MeasureTiny *measure, AverageTiny *average, SecFilt *secfilt, dvoMagClassType class) {
     936
     937  int Np = photcodes[0].hashcode[measure[0].photcode];
    933938  if (Np == -1) return (NAN);
    934 
    935   if (photcodes[0].code[Np].type == PHOT_REF) {
    936     Mcat = measure[0].M;
    937     return (Mcat);
    938   }
    939   code = &photcodes[0].code[Np];
    940   Mrel = measure[0].M - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C - measure[0].Mcal;
     939  PhotCode *code = &photcodes[0].code[Np];
     940
     941  float Mraw = NAN;
     942  switch (class) {
     943    case MAG_CLASS_PSF:
     944      Mraw = measure[0].M;
     945      break;
     946    case MAG_CLASS_KRON:
     947      // Mraw = measure[0].Mkron;
     948      break;
     949    case MAG_CLASS_APER:
     950      // Mraw = measure[0].Map;
     951      break;
     952    default:
     953      break;
     954  }
     955  if (code->type == PHOT_REF) {
     956    return (Mraw);
     957  }
     958  float Mcat = Mraw - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C - measure[0].Mcal;
    941959
    942960  /* for DEP, color must be made of PRI/SEC */
    943   mc = PhotColorForCodeTiny (average, secfilt, NULL, code);
    944   if (isnan(mc)) return (Mrel);
    945   mc = mc - SCALE*code[0].dX;
    946 
    947   Mc = mc;
    948   Mcol = 0;
     961  float mc = PhotColorForCodeTiny (average, secfilt, NULL, code);
     962  if (isnan(mc)) return (Mcat);
     963  mc -= SCALE*code[0].dX;
     964
     965  double Mc = mc;
     966  float Mcol = 0;
     967  int i = 0;
     968  for (i = 0; i < code[0].Nc; i++) {
     969    Mcol += code[0].X[i]*Mc;
     970    Mc *= mc;
     971  }
     972  float Mrel = Mcat + Mcol;
     973  return (Mrel);
     974}
     975
     976/* return calibrated magnitude from measure for given photcode */
     977float PhotCalTiny (MeasureTiny *thisone, AverageTiny *average, SecFilt *secfilt, MeasureTiny *measure, PhotCode *code, dvoMagClassType class) {
     978
     979  int i;
     980
     981  if (code == NULL) return NAN;
     982
     983  /* code must be the matching PRI/SEC code for this measurement or an equivalent ALT */
     984  int Np = photcodes[0].hashcode[thisone[0].photcode];
     985  if (Np == -1) return (NAN);
     986  PhotCode *myCode = &photcodes[0].code[Np];
     987
     988  if (code->code != myCode->equiv) return (NAN);
     989
     990  // if we are REF type, just get the right version and return
     991  if (myCode->type == PHOT_REF) {
     992    float Mraw = NAN;
     993    switch (class) {
     994      case MAG_CLASS_PSF:
     995        Mraw = thisone[0].M;
     996        break;
     997      case MAG_CLASS_KRON:
     998        // Mraw = thisone[0].Mkron;
     999        break;
     1000      case MAG_CLASS_APER:
     1001        // Mraw = thisone[0].Map;
     1002        break;
     1003      default:
     1004        break;
     1005    }
     1006    return (Mraw);
     1007  }
     1008
     1009  float Mcal = PhotRelTiny (thisone, average, secfilt, class) + SCALE*code[0].C;
     1010
     1011  float mc = PhotColorForCodeTiny (average, secfilt, measure, code);
     1012  if (isnan(mc)) return (Mcal);
     1013  mc -= SCALE*code[0].dX;
     1014
     1015  double Mc = mc;
     1016  float Mcol = 0;
     1017  for (i = 0; i < code[0].Nc; i++) {
     1018    Mcol += code[0].X[i]*Mc;
     1019    Mc *= mc;
     1020  }
     1021  Mcal += Mcol;
     1022  return (Mcal);
     1023}
     1024
     1025/***/
     1026float PhotAveTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt, dvoMagClassType class, dvoMagSourceType source) {
     1027
     1028  if (code == NULL) return NAN;
     1029
     1030  int Ns = photcodes[0].hashNsec[code[0].code];
     1031  if (Ns == -1) return (NAN);
     1032
     1033  float Mave = NAN;
     1034  switch (source) {
     1035    case MAG_SRC_CHP:
     1036      switch (class) {
     1037        case MAG_CLASS_PSF:
     1038          Mave = secfilt[Ns].M;
     1039          break;
     1040        case MAG_CLASS_KRON:
     1041          Mave = secfilt[Ns].Mkron;
     1042          break;
     1043        case MAG_CLASS_APER:
     1044          Mave = secfilt[Ns].Map;
     1045          break;
     1046        default:
     1047          break;
     1048      }
     1049      break;
     1050    case MAG_SRC_WRP:
     1051      switch (class) {
     1052        case MAG_CLASS_PSF:
     1053          Mave = secfilt[Ns].MpsfWrp;
     1054          break;
     1055        case MAG_CLASS_KRON:
     1056          Mave = secfilt[Ns].MkronWrp;
     1057          break;
     1058        case MAG_CLASS_APER:
     1059          Mave = secfilt[Ns].MapWrp;
     1060          break;
     1061        default:
     1062          break;
     1063      }
     1064      break;
     1065    case MAG_SRC_STK:
     1066      switch (class) {
     1067        case MAG_CLASS_PSF:
     1068          Mave = secfilt[Ns].MpsfStk;
     1069          break;
     1070        case MAG_CLASS_KRON:
     1071          Mave = secfilt[Ns].MkronStk;
     1072          break;
     1073        case MAG_CLASS_APER:
     1074          Mave = secfilt[Ns].MapStk;
     1075          break;
     1076        default:
     1077          break;
     1078      }
     1079      break;
     1080    default:
     1081      break;
     1082  }
     1083  return (Mave);
     1084}
     1085
     1086/* return calibrated magnitude from average/secfilt for given photcode */
     1087float PhotRefTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt, MeasureTiny *measure, dvoMagClassType class, dvoMagSourceType source) {
     1088
     1089  int i;
     1090
     1091  float Mave = PhotAveTiny (code, average, secfilt, class, source);
     1092  if (isnan(Mave)) return NAN;
     1093
     1094  // correct for relative zero-point
     1095  float Mref = Mave + SCALE*code[0].C;
     1096
     1097  float mc = PhotColorForCodeTiny (average, secfilt, measure, code);
     1098  if (isnan(mc)) return (Mref);
     1099  mc -= SCALE*code[0].dX;
     1100
     1101  // correct for color terms
     1102  double Mc = mc;
     1103  float Mcol = 0;
    9491104  for (i = 0; i < code[0].Nc; i++) {
    9501105    Mcol += code[0].X[i]*Mc;
    9511106    Mc *= mc;    /* the 0.001 is needed for higher order terms to keep the units mag = mag^n */
    9521107  }
    953   Mrel += Mcol;
    954   return (Mrel);
    955 }
    956 
    957 /* return calibrated magnitude from measure for given photcode */
    958 float PhotCalTiny (MeasureTiny *thisone, AverageTiny *average, SecFilt *secfilt, MeasureTiny *measure, PhotCode *code) {
    959 
    960   int i, Np;
    961   float Mcal, Mrel, Mcol, mc, Mc;
    962 
    963   if (code == NULL) return NAN;
    964 
    965   /* code must be the matching PRI/SEC code for this measurement or an equivalent ALT */
    966   Np = photcodes[0].hashcode[thisone[0].photcode];
    967   if (Np == -1) return (NAN);
    968 
    969   if (photcodes[0].code[Np].type == PHOT_REF) {
    970     Mrel = thisone[0].M;
    971     return (Mrel);
    972   }
    973   if (code[0].code != photcodes[0].code[Np].equiv) return (NAN);
    974 
    975   Mcal = PhotRelTiny (thisone, average, secfilt) + SCALE*code[0].C;
    976 
    977   mc = PhotColorForCodeTiny (average, secfilt, measure, code);
    978   if (isnan(mc)) return (Mcal);
    979   mc = mc - SCALE*code[0].dX;
    980 
    981   Mc = mc;
    982   Mcol = 0;
    983   for (i = 0; i < code[0].Nc; i++) {
    984     Mcol += code[0].X[i]*Mc;
    985     Mc *= mc;
    986   }
    987   Mcal += Mcol;
    988   return (Mcal);
     1108  Mref += Mcol;
     1109  return (Mref);
    9891110}
    9901111
    … …  
    10371158  mc = (isnan(m1) || isnan(m2)) ? NAN : (m1 - m2);
    10381159  return (mc);
    1039 }
    1040 
    1041 /* return calibrated magnitude from average/secfilt for given photcode */
    1042 float PhotRefTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt, MeasureTiny *measure) {
    1043 
    1044   int i, Ns;
    1045   float Mave, Mref, Mcol, mc;
    1046   double Mc;
    1047 
    1048   if (code == NULL) return NAN;
    1049 
    1050   Ns = photcodes[0].hashNsec[code[0].code];
    1051   Mave = (Ns == -1) ? NAN : secfilt[Ns].M;
    1052   Mref = Mave + SCALE*code[0].C;
    1053 
    1054   mc = PhotColorForCodeTiny (average, secfilt, measure, code);
    1055   if (isnan(mc)) return (Mref);
    1056   mc = mc - SCALE*code[0].dX;
    1057 
    1058   Mc = mc;
    1059   Mcol = 0;
    1060   for (i = 0; i < code[0].Nc; i++) {
    1061     Mcol += code[0].X[i]*Mc;
    1062     Mc *= mc;    /* the 0.001 is needed for higher order terms to keep the units mag = mag^n */
    1063   }
    1064   Mref += Mcol;
    1065   return (Mref);
    1066 }
    1067 
    1068 /***/
    1069 float PhotAveTiny (PhotCode *code, AverageTiny *average, SecFilt *secfilt) {
    1070 
    1071   int Ns;
    1072   float Mave;
    1073 
    1074   if (code == NULL) return NAN;
    1075 
    1076   Ns = photcodes[0].hashNsec[code[0].code];
    1077   Mave = (Ns == -1) ? NAN : secfilt[Ns].M;
    1078   return (Mave);
    10791160}
    10801161

  • branches/eam_branches/ipp-20140610/Ohana/src/opihi/dvo/Makefile

    r36905 r36910  
    2525$(SRC)/dvo_host_utils.$(ARCH).o         \
    2626$(SRC)/region_list.$(ARCH).o            \
    27 $(SRC)/find_matches.$(ARCH).o           \
    28 $(SRC)/photometry.$(ARCH).o             
     27$(SRC)/photcode_ops.$(ARCH).o           \
     28$(SRC)/find_matches.$(ARCH).o           
     29
     30# $(SRC)/photometry.$(ARCH).o             
     31
     32broken = \
     33$(SRC)/calextract.$(ARCH).o             \
     34$(SRC)/calmextract.$(ARCH).o            \
     35$(SRC)/ccd.$(ARCH).o                    \
     36$(SRC)/cmd.$(ARCH).o                    \
     37$(SRC)/dmagaves.$(ARCH).o               \
     38$(SRC)/dmagmeas.$(ARCH).o               \
     39$(SRC)/dmags.$(ARCH).o                  \
     40$(SRC)/ddmags.$(ARCH).o         \
     41$(SRC)/fitcolors.$(ARCH).o
    2942
    3043cmds = \
    … …  
    3245$(SRC)/avmatch.$(ARCH).o                \
    3346$(SRC)/badimages.$(ARCH).o              \
    34 $(SRC)/calextract.$(ARCH).o             \
    35 $(SRC)/calmextract.$(ARCH).o            \
    3647$(SRC)/catdir.$(ARCH).o                 \
    37 $(SRC)/ccd.$(ARCH).o                    \
    3848$(SRC)/cmatch.$(ARCH).o         \
    39 $(SRC)/cmd.$(ARCH).o                    \
    4049$(SRC)/cmpload.$(ARCH).o                \
    4150$(SRC)/cmpread.$(ARCH).o                \
    4251$(SRC)/coordimage.$(ARCH).o             \
    4352$(SRC)/coordmosaic.$(ARCH).o            \
    44 $(SRC)/ddmags.$(ARCH).o         \
    4553$(SRC)/detrend.$(ARCH).o                \
    46 $(SRC)/dmagaves.$(ARCH).o               \
    47 $(SRC)/dmagmeas.$(ARCH).o               \
    48 $(SRC)/dmags.$(ARCH).o                  \
    4954$(SRC)/dmt.$(ARCH).o                    \
    5055$(SRC)/elixir.$(ARCH).o                \
    51 $(SRC)/fitcolors.$(ARCH).o             \
    5256$(SRC)/fitsed.$(ARCH).o                \
    5357$(SRC)/gcat.$(ARCH).o                   \

  • branches/eam_branches/ipp-20140610/Ohana/src/opihi/dvo/avextract.c

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

  • branches/eam_branches/ipp-20140610/Ohana/src/opihi/dvo/avmatch.c

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

  • branches/eam_branches/ipp-20140610/Ohana/src/opihi/dvo/fitsed.c

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

  • branches/eam_branches/ipp-20140610/Ohana/src/opihi/dvo/gstar.c

    r36905 r36910  
    374374          int Nv = index[j];
    375375
    376           Mcat = PhotCat (&catalog.measure[Nv]);
     376          Mcat = PhotCat (&catalog.measure[Nv], MAG_CLASS_PSF);
    377377          if (INST) {
    378             Mrel = PhotInst (&catalog.measure[Nv]);
     378            Mrel = PhotInst (&catalog.measure[Nv], MAG_CLASS_PSF);
    379379          } else {
    380             Mrel = PhotRel (&catalog.measure[Nv], &catalog.average[k], &catalog.secfilt[k*Nsecfilt]);
     380            Mrel = PhotRel (&catalog.measure[Nv], &catalog.average[k], &catalog.secfilt[k*Nsecfilt], MAG_CLASS_PSF);
    381381          }
    382382

  • branches/eam_branches/ipp-20140610/Ohana/src/opihi/dvo/init.c

    r36833 r36910  
    6666  {1, "avmatch",     avmatch,      "extract average data values matched to RA,DEC points"},
    6767  {1, "badimages",   badimages,    "look for images with anomalous astrometry"},
    68   {1, "calextract",  calextract,   "extract photometry calibration"},
    69   {1, "calmextract", calmextract,  "extract photometry calibration"},
     68//  {1, "calextract",  calextract,   "extract photometry calibration"},
     69//  {1, "calmextract", calmextract,  "extract photometry calibration"},
    7070  {1, "catdir",      catdir_define,"re-define CATDIR"},
    71   {1, "ccd",         ccd,          "plot color-color diagram"},
     71//  {1, "ccd",         ccd,          "plot color-color diagram"},
    7272  {1, "cmatch",      cmatch,       "match two catalogs"},
    73   {1, "cmd",         cmd,          "plot cmd of stars in current region"},
     73//  {1, "cmd",         cmd,          "plot cmd of stars in current region"},
    7474  {1, "cmpload",     cmpload,      "load cmp file into ?"},
    7575  {1, "cmpread",     cmpread,      "read data from cmp format files"},
    … …  
    7777  {1, "coordmosaic", coordmosaic,  "generate a map of the distortion"},
    7878  {1, "psastro_model", psastro_model, "save psastro-format astrometry model"},
    79   {1, "ddmags",      ddmags,       "plot magnitude differences"},
     79//  {1, "ddmags",      ddmags,       "plot magnitude differences"},
    8080  {1, "detrend",     detrend,      "extract from detrend database?"},
    81   {1, "dmagaves",    dmagaves,     "foo"},
    82   {1, "dmagmeas",    dmagmeas,     "foo"},
    83   {1, "dmags",       dmags,        "plot differential magnitudes between filters"},
     81//  {1, "dmagaves",    dmagaves,     "foo"},
     82//  {1, "dmagmeas",    dmagmeas,     "foo"},
     83//  {1, "dmags",       dmags,        "plot differential magnitudes between filters"},
    8484  {1, "dmt",         dmt,          "plot mag scatter"},
    8585  {1, "elixir",      elixir,       "talk to elixir"},
    86   {1, "fitcolors",   fitcolors,    "fit chip-to-chip color terms"},
     86//  {1, "fitcolors",   fitcolors,    "fit chip-to-chip color terms"},
    8787  {1, "fitsed",      fitsed,       "fit stellar SEDs to objects"},
    8888  {1, "gcat",        gcat,         "get catalog at location"},

  • branches/eam_branches/ipp-20140610/Ohana/src/opihi/dvo/lcurve.c

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

  • branches/eam_branches/ipp-20140610/Ohana/src/opihi/dvo/lightcurve.c

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

  • branches/eam_branches/ipp-20140610/Ohana/src/opihi/dvo/photometry.c

    r36905 r36910  
    4141  }
    4242
     43# if (0)
    4344/* selection criteria */
    4445/* selections based on Measure quantities */
    … …  
    7879static time_t TimeReference;
    7980static int TimeFormat;
    80 
     81# endif
     82
     83# if (0)
    8184int GetTimeSelection (time_t *tz, time_t *te) {
    8285  *tz = tzero;
    … …  
    298301  return;
    299302}
    300 
    301 /* (re)load photcodes from photcode table */
    302 int InitPhotcodes () {
    303 
    304   double ZERO_POINT;
    305   char MasterPhotcodeFile[256];
    306   char CatdirPhotcodeFile[256];
    307   char *catdir;
    308 
    309   if (VarConfig ("ZERO_PT", "%lf", &ZERO_POINT) == (char *) NULL) {
    310     gprint (GP_ERR, "ZERO_PT undefined in config\n");
    311     return (FALSE);
    312   }
    313   SetZeroPoint (ZERO_POINT);
    314 
    315   catdir = GetCATDIR();
    316   if (catdir == NULL) {
    317     CatdirPhotcodeFile[0] = 0;
    318   } else {
    319     sprintf (CatdirPhotcodeFile, "%s/Photcodes.dat", catdir);
    320   }
    321 
    322   if (VarConfig ("PHOTCODE_FILE", "%s", MasterPhotcodeFile) == (char *) NULL) {
    323     gprint (GP_ERR, "PHOTCODE_FILE undefined in config\n");
    324     return (FALSE);
    325   }
    326 
    327   // XXX now that DVO does not allow write access, we can drop the MasterPhotcodeFile
    328   if (!LoadPhotcodes (CatdirPhotcodeFile, MasterPhotcodeFile, FALSE)) {
    329     gprint (GP_ERR, "error loading photcode table %s or master file %s\n", CatdirPhotcodeFile, MasterPhotcodeFile);
    330     return (FALSE);
    331   }
    332   return (TRUE);
    333 }
    334 
     303# endif
     304
     305# if (0)
    335306int ListPhotSelections () {
    336307
    … …  
    11211092  return (list);
    11221093}
    1123 
     1094# endif
     1095
     1096# if (0)
    11241097double GetMeasure (int param, Average *average, Measure *measure, double mag) {
    11251098
    … …  
    12141187  return (value);
    12151188}
     1189# endif
    12161190
    12171191/** the mosaic entries do not use the registered mosaic found

  • branches/eam_branches/ipp-20140610/Ohana/src/opihi/dvo/pmeasure.c

    r36905 r36910  
    203203        if (TimeSelect && (catalog.measure[m+k].t > tzero + trange)) continue;
    204204        if ((PhotcodeClip != -1) && (catalog.measure[m+k].photcode != PhotcodeClip)) continue;
    205         mag = PhotCat (&catalog.measure[m+k]);
     205        mag = PhotCat (&catalog.measure[m+k], MAG_CLASS_PSF);
    206206        Zvec[Npts] = MIN (1.0, MAX (0.01, (mag - Mz) / Mr));
    207207        if (LimExclude && (Zvec[Npts] > 0.99)) continue;

  • branches/eam_branches/ipp-20140610/Ohana/src/opihi/dvo/subpix.c

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

  • branches/eam_branches/ipp-20140610/Ohana/src/opihi/include/dvoshell.h

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

  • branches/eam_branches/ipp-20140610/Ohana/src/photdbc/src/make_subcatalog.c

    r36833 r36910  
    123123      // select measurements by mag limit -- drop exactly this measurement 
    124124      if (ExcludeByInstMag) {
    125         mag = PhotInst (&catalog[0].measure[offset]);
     125        mag = PhotInst (&catalog[0].measure[offset], MAG_CLASS_PSF);
    126126        if (mag < INST_MAG_MIN) continue;
    127127        if (mag > INST_MAG_MAX) continue;
    … …  
    135135      // check measurements for this object -- drop object if no measurements pass
    136136      if (ExcludeByMaxMinMag) {
    137         mag = PhotSys (&catalog[0].measure[offset], &catalog[0].average[i], &catalog[0].secfilt[i*Nsecfilt]);
     137        mag = PhotSys (&catalog[0].measure[offset], &catalog[0].average[i], &catalog[0].secfilt[i*Nsecfilt], MAG_CLASS_PSF);
    138138        minMag = MIN (minMag, mag);
    139139      }

  • branches/eam_branches/ipp-20140610/Ohana/src/relastro/src/ImageOps.c

    r36905 r36910  
    11201120  /* select measurements by mag limit */
    11211121  if (ImagSelect) {
    1122     mag = PhotInstTiny (measure);
     1122    mag = PhotInstTiny (measure, MAG_CLASS_PSF);
    11231123    if (mag < ImagMin || mag > ImagMax) return FALSE;
    11241124  }
    … …  
    11871187  /* select measurements by mag limit */
    11881188  if (ImagSelect) {
    1189     mag = PhotInst (measure);
     1189    mag = PhotInst (measure, MAG_CLASS_PSF);
    11901190    if (mag < ImagMin || mag > ImagMax) return FALSE;
    11911191  }

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

    r34088 r36910  
    414414        // select the color- and airmass-corrected observed magnitude for this star
    415415        // XXX need to be able to turn off the color-correction until initial average mags are found
    416         Msys = PhotCatTiny (&catalog[c].measureT[m]);
     416        Msys = PhotCatTiny (&catalog[c].measureT[m], MAG_CLASS_PSF);
    417417        if (isnan(Msys)) {
    418418          Nsys++;
    … …  
    573573     
    574574      n = catalog[c].measureT[m].averef;
    575       Msys = PhotSysTiny (&catalog[c].measureT[m], &catalog[c].averageT[n], &catalog[c].secfilt[n*Nsecfilt]);
     575      Msys = PhotSysTiny (&catalog[c].measureT[m], &catalog[c].averageT[n], &catalog[c].secfilt[n*Nsecfilt], MAG_CLASS_PSF);
    576576      if (isnan(Msys)) {
    577577        Nsys++;
    … …  
    651651
    652652      n = catalog[c].measureT[m].averef;
    653       Msys = PhotSysTiny (&catalog[c].measureT[m], &catalog[c].averageT[n], &catalog[c].secfilt[n*Nsecfilt]);
     653      Msys = PhotSysTiny (&catalog[c].measureT[m], &catalog[c].averageT[n], &catalog[c].secfilt[n*Nsecfilt], MAG_CLASS_PSF);
    654654
    655655      xlist[N] = Xmeas[c][m];

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

    r36630 r36910  
    608608
    609609      n = catalog[c].measureT[m].averef;
    610       Msys = PhotSysTiny (&catalog[c].measureT[m], &catalog[c].averageT[n], &catalog[c].secfilt[n*Nsecfilt]);
     610      Msys = PhotSysTiny (&catalog[c].measureT[m], &catalog[c].averageT[n], &catalog[c].secfilt[n*Nsecfilt], MAG_CLASS_PSF);
    611611      if (isnan(Msys)) {
    612612        Nsys++;

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

    r36903 r36910  
    11271127
    11281128      off_t n = catalog[c].measureT[m].averef;
    1129       Msys = PhotSysTiny (&catalog[c].measureT[m], &catalog[c].averageT[n], &catalog[c].secfilt[n*Nsecfilt]);
     1129      Msys = PhotSysTiny (&catalog[c].measureT[m], &catalog[c].averageT[n], &catalog[c].secfilt[n*Nsecfilt], MAG_CLASS_PSF);
    11301130
    11311131      float delta = Msys - Mrel - Mcal - Mgrid + Mflat;
    … …  
    11641164
    11651165    off_t n = catalog[c].measureT[m].averef;
    1166     Msys = PhotSysTiny (&catalog[c].measureT[m], &catalog[c].averageT[n], &catalog[c].secfilt[n*Nsecfilt]);
     1166    Msys = PhotSysTiny (&catalog[c].measureT[m], &catalog[c].averageT[n], &catalog[c].secfilt[n*Nsecfilt], MAG_CLASS_PSF);
    11671167    if (isnan(Msys)) {
    11681168      info->Nsys++;

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

    r36630 r36910  
    467467
    468468        // skip some absurd values NAN, < 0.0, > 30.0
    469         Msys = PhotSysTiny (&catalog[Nc].measureT[m], &catalog[Nc].averageT[j], &catalog[Nc].secfilt[j*Nsecfilt]);
     469        Msys = PhotSysTiny (&catalog[Nc].measureT[m], &catalog[Nc].averageT[j], &catalog[Nc].secfilt[j*Nsecfilt], MAG_CLASS_PSF);
    470470        if (isnan(Msys)) SKIP_THIS_MEAS(Nsys);
    471471        if (Msys <  0.0) SKIP_THIS_MEAS(Nsys);
    … …  
    10931093          if (isnan(Mgrid)) { Ngrid ++; continue; }
    10941094
    1095           Msys = PhotSysTiny (&catalog[i].measureT[m], &catalog[i].averageT[j], &catalog[i].secfilt[j*Nsecfilt]);
     1095          Msys = PhotSysTiny (&catalog[i].measureT[m], &catalog[i].averageT[j], &catalog[i].secfilt[j*Nsecfilt], MAG_CLASS_PSF);
    10961096          list[N] = Msys - Mcal - Mmos - Mgrid;
    10971097          dlist[N] = MAX (catalog[i].measureT[m].dM, MIN_ERROR);
    … …  
    11381138          if (isnan(Mgrid)) continue;
    11391139
    1140           Msys = PhotSysTiny (&catalog[i].measureT[m], &catalog[i].averageT[j], &catalog[i].secfilt[j*Nsecfilt]);
     1140          Msys = PhotSysTiny (&catalog[i].measureT[m], &catalog[i].averageT[j], &catalog[i].secfilt[j*Nsecfilt], MAG_CLASS_PSF);
    11411141          list[N] = Msys - Mcal - Mmos - Mgrid;
    11421142          dlist[N] = MAX (catalog[i].measureT[m].dM, MIN_ERROR);

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

    r36903 r36910  
    143143
    144144      /* select measurements by mag limit */
    145       mag = PhotCat (&catalog[0].measure[offset]);
     145      mag = PhotCat (&catalog[0].measure[offset], MAG_CLASS_PSF);
    146146      if (mag > MAG_LIM) { Nmag ++; continue; }
    147147
    … …  
    151151      /* select measurements by mag limit */
    152152      if (ImagSelect) {
    153         mag = PhotInst (&catalog[0].measure[offset]);
     153        mag = PhotInst (&catalog[0].measure[offset], MAG_CLASS_PSF);
    154154        if (mag < ImagMin) { Nimag ++; continue; }
    155155        if (mag > ImagMax) { Nimag ++; continue; }

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

    r35759 r36910  
    5151
    5252                xlist[N] = Mrel;
    53                 ylist[N] = PhotSysTiny (&catalog[i].measureT[m], &catalog[i].averageT[j], &catalog[i].secfilt[j*Nsecfilt]) - Mcal - Mmos - Mgrid - Mrel;
    54                 ilist[N] = PhotInstTiny (&catalog[i].measureT[m]);
     53                ylist[N] = PhotSysTiny (&catalog[i].measureT[m], &catalog[i].averageT[j], &catalog[i].secfilt[j*Nsecfilt], MAG_CLASS_PSF) - Mcal - Mmos - Mgrid - Mrel;
     54                ilist[N] = PhotInstTiny (&catalog[i].measureT[m], MAG_CLASS_PSF);
    5555                N++;
    5656            }

  • branches/eam_branches/ipp-20140610/Ohana/src/relphot/src/setMrelCatalog.c

    r36903 r36910  
    166166
    167167      // skip some absurd values NAN, < 0.0, > 30.0
    168       Msys = PhotSysTiny (&measureT[k], &averageT[0], &secfilt[0]);
     168      Msys = PhotSysTiny (&measureT[k], &averageT[0], &secfilt[0], MAG_CLASS_PSF);
    169169      if (isnan(Msys)) SKIP_THIS_MEAS(Nsys);
    170170      if (Msys <  0.0) SKIP_THIS_MEAS(Nsys);
    … …  
    255255
    256256        // Map (Maplist) and Mkron (Mkronlist,dkronlist) are used to calculate mean mags per filter
    257         float Map = PhotAperCat (&measure[k]);
     257        float Map = PhotCat (&measure[k], MAG_CLASS_APER);
    258258        if (!isnan(Map)) {
    259259            Maplist[Nap] = Map - Mcal - Mmos - Mgrid;
    … …  
    263263        }
    264264
    265         float Mkron = PhotKronCat (&measure[k]);
     265        float Mkron = PhotCat (&measure[k], MAG_CLASS_KRON);
    266266        if (!isnan(Mkron)) {
    267267          Mkronlist[Nkron] = Mkron - Mcal - Mmos - Mgrid;
    … …  
    493493      if (isnan(Mgrid)) SKIP_THIS_MEAS_STACK(Ngrid);
    494494
    495       Msys = PhotSys (&measure[k], &average[0], &secfilt[0]);
     495      Msys = PhotSys (&measure[k], &average[0], &secfilt[0], MAG_CLASS_PSF);
    496496      if (isnan(Msys)) SKIP_THIS_MEAS_STACK(Nsys);
    497497

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

    r35759 r36910  
    229229        if ((pass < 4) && ImagSelect) {
    230230          if (Nim > -1) {
    231             mag = PhotInst (&catalog[0].measure[m]);
     231            mag = PhotInst (&catalog[0].measure[m], MAG_CLASS_PSF);
    232232            if (mag < ImagMin) goto skip;
    233233            if (mag > ImagMax) goto skip;

  • branches/eam_branches/ipp-20140610/Ohana/src/uniphot/src/update_catalog_setastrom.c

    r35103 r36910  
    7676    // correction may be Minst or Minst + 5.0*log(fwhm
    7777    float fwhm_maj = FromShortPixels(measure[0].FWx);
    78     float Minst = PhotInst (measure);
     78    float Minst = PhotInst (measure, MAG_CLASS_PSF);
    7979    float MinstSB = Minst + 5.0*log10(fwhm_maj);
    8080
Note: See TracChangeset for help on using the changeset viewer.