Index: /branches/eam_branches/ipp-20140206/Ohana/src/libdvo/include/dvo.h
===================================================================
--- /branches/eam_branches/ipp-20140206/Ohana/src/libdvo/include/dvo.h	(revision 36588)
+++ /branches/eam_branches/ipp-20140206/Ohana/src/libdvo/include/dvo.h	(revision 36589)
@@ -662,6 +662,4 @@
 float PhotInst (Measure *measure);
 float PhotCat (Measure *measure);
-float PhotAper (Measure *measure);
-float PhotKron (Measure *measure);
 float PhotSys (Measure *measure, Average *average, SecFilt *secfilt);
 float PhotRel (Measure *measure, Average *average, SecFilt *secfilt);
@@ -669,12 +667,24 @@
 float PhotAve (PhotCode *code, Average *average, SecFilt *secfilt);
 float PhotRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure);
+float PhotAveErr (PhotCode *code, Average *average, SecFilt *secfilt);
+
+float PhotAperInst (Measure *measure);
+float PhotAperCat (Measure *measure);
+float PhotAperSys (Measure *measure, Average *average, SecFilt *secfilt);
+float PhotAperRel (Measure *measure, Average *average, SecFilt *secfilt);
+float PhotAperCal (Measure *thisone, Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code);
+float PhotAperAve (PhotCode *code, Average *average, SecFilt *secfilt);
+float PhotAperRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure);
+
+float PhotKronInst (Measure *measure);
+float PhotKronCat (Measure *measure);
+float PhotKronSys (Measure *measure, Average *average, SecFilt *secfilt);
+float PhotKronRel (Measure *measure, Average *average, SecFilt *secfilt);
+float PhotKronCal (Measure *thisone, Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code);
+float PhotKronAve (PhotCode *code, Average *average, SecFilt *secfilt);
+float PhotKronRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure);
+float PhotKronAveErr (PhotCode *code, Average *average, SecFilt *secfilt);
+
 float PhotXm (PhotCode *code, Average *average, SecFilt *secfilt);
-float PhotdM (PhotCode *code, Average *average, SecFilt *secfilt);
-
-float PhotAperInst (Measure *measure);
-float PhotAperAve (PhotCode *code, Average *average, SecFilt *secfilt);
-float PhotKronInst (Measure *measure);
-float PhotKronAve (PhotCode *code, Average *average, SecFilt *secfilt);
-float PhotKronAveErr (PhotCode *code, Average *average, SecFilt *secfilt);
 
 float PhotZeroPoint (Measure *measure, Average *average, SecFilt *secfilt);
Index: /branches/eam_branches/ipp-20140206/Ohana/src/libdvo/include/dvodb.h
===================================================================
--- /branches/eam_branches/ipp-20140206/Ohana/src/libdvo/include/dvodb.h	(revision 36588)
+++ /branches/eam_branches/ipp-20140206/Ohana/src/libdvo/include/dvodb.h	(revision 36589)
@@ -23,31 +23,60 @@
 /* magnitude types */
 enum {MAG_NONE, 
-      MAG_INST, 
-      MAG_CAT, 
-      MAG_APER, 
-      MAG_APER_INST, 
-      MAG_KRON, 
-      MAG_KRON_INST, 
-      MAG_KRON_ERR, 
-      MAG_SYS, 
-      MAG_REL, 
-      MAG_CAL, 
+
+      // these magnitude types are from the measurement table (or derived therein)
+      // the following imply PSF magnitudes:
+      MAG_INST, // -2.5*log(DN) [ie, not DN/sec]
+      MAG_CAT,  // MAG_INST + 2.5*log(exptime) + C_lambda + K_lambda*(airmass - 1)
+      MAG_SYS,  // MAG_CAT + \sum_i A_i * (color_i - color_o) [color correction for measure photcode]
+      MAG_REL,  // MAG_SYS - Mcal [specific zero point for image]
+      MAG_CAL,  // MAG_REL + \sum_i A_i * (color_i - color_o) [color correction for average photcode]
+      MAG_ERR,  // error on PSF MAG
+
+      // the following imply APERTURE magnitudes:
+      MAG_APER_INST, // -2.5*log(DN) [ie, not DN/sec]
+      MAG_APER_CAT,  // MAG_APER_INST + 2.5*log(exptime) + C_lambda + K_lambda*(airmass - 1)
+      MAG_APER_SYS,  // MAG_APER_CAT + \sum_i A_i * (color_i - color_o) [color correction for measure photcode]
+      MAG_APER_REL,  // MAG_APER_SYS - Mcal [specific zero point for image]
+      MAG_APER_CAL,  // MAG_APER_REL + \sum_i A_i * (color_i - color_o) [color correction for average photcode]
+      MAG_APER_ERR,  // error on APER MAG (if known, else psf error)
+      MAG_APER,      // in mextract -> MAG_APER_REL, in avextract -> MAG_APER_AVE
+
+      // the following imply KRON magnitudes:
+      MAG_KRON_INST, // -2.5*log(DN) [ie, not DN/sec]
+      MAG_KRON_CAT,  // MAG_KRON_INST + 2.5*log(exptime) + C_lambda + K_lambda*(airmass - 1)
+      MAG_KRON_SYS,  // MAG_KRON_CAT + \sum_i A_i * (color_i - color_o) [color correction for measure photcode]
+      MAG_KRON_REL,  // MAG_KRON_SYS - Mcal [specific zero point for image]
+      MAG_KRON_CAL,  // MAG_KRON_REL + \sum_i A_i * (color_i - color_o) [color correction for average photcode]
+      MAG_KRON_ERR,  // error on KRON MAG
+      MAG_KRON,      // in mextract -> MAG_KRON_REL, in avextract -> MAG_KRON_AVE
+
+      // these magnitude types are from the average (secfilt) table:
+      // the following imply PSF magnitudes (or fluxes)
       MAG_AVE, 
       MAG_REF, 
-      MAG_ERR, 
       MAG_STDEV, 
       MAG_AVE_ERR, 
+      MAG_CHISQ,
+      MAG_20, 
+      MAG_80, 
+      MAG_FLUX_PSF,
+      MAG_FLUX_PSF_ERR,
+
+      // the following imply APERTURE magnitudes:
+      MAG_APER_AVE,
+      MAG_APER_REF,
+
+      // the following imply KRON magnitudes or fluxes:
+      MAG_KRON_AVE,
+      MAG_KRON_REF,
+      MAG_FLUX_KRON,
+      MAG_FLUX_KRON_ERR,
+
+      // other secfilt fields of interest
       MAG_PHOT_FLAGS, 
-      MAG_CHISQ,
       MAG_NCODE,
       MAG_NPHOT,
-      MAG_20, 
-      MAG_80, 
       MAG_UC_DIST, 
       MAG_STACK_DET_ID, 
-      MAG_FLUX_PSF,
-      MAG_FLUX_PSF_ERR,
-      MAG_FLUX_KRON,
-      MAG_FLUX_KRON_ERR,
 };
 
Index: /branches/eam_branches/ipp-20140206/Ohana/src/libdvo/src/dbExtractAverages.c
===================================================================
--- /branches/eam_branches/ipp-20140206/Ohana/src/libdvo/src/dbExtractAverages.c	(revision 36588)
+++ /branches/eam_branches/ipp-20140206/Ohana/src/libdvo/src/dbExtractAverages.c	(revision 36589)
@@ -211,5 +211,5 @@
 	    }
 	  } else {
-	    value.Flt = PhotdM (field->photcode, average, secfilt);
+	    value.Flt = PhotAveErr (field->photcode, average, secfilt);
 	  }
 	  break;
@@ -244,9 +244,19 @@
 
 	case MAG_APER:
+	case MAG_APER_AVE:
 	  value.Flt = PhotAperAve (field->photcode, average, secfilt);
 	  break;
 
+	case MAG_APER_REF:
+	  value.Flt = PhotAperRef (field->photcode, average, secfilt, measure);
+	  break;
+
 	case MAG_KRON:
+	case MAG_KRON_AVE:
 	  value.Flt = PhotKronAve (field->photcode, average, secfilt);
+	  break;
+
+	case MAG_KRON_REF:
+	  value.Flt = PhotKronRef (field->photcode, average, secfilt, measure);
 	  break;
 
@@ -283,5 +293,5 @@
       break;
     case AVE_dMAG:
-      value.Flt = PhotdM (field->photcode, average, secfilt);
+      value.Flt = PhotAveErr (field->photcode, average, secfilt);
       break;
     case AVE_Xm:
Index: /branches/eam_branches/ipp-20140206/Ohana/src/libdvo/src/dbExtractMeasures.c
===================================================================
--- /branches/eam_branches/ipp-20140206/Ohana/src/libdvo/src/dbExtractMeasures.c	(revision 36588)
+++ /branches/eam_branches/ipp-20140206/Ohana/src/libdvo/src/dbExtractMeasures.c	(revision 36589)
@@ -123,10 +123,20 @@
 	  case MAG_REL:
 	  case MAG_CAL:
-	  case MAG_APER:
+	  case MAG_ERR:
+
 	  case MAG_APER_INST:
-	  case MAG_KRON:
+	  case MAG_APER_CAT:
+	  case MAG_APER_SYS:
+	  case MAG_APER_REL:
+	  case MAG_APER_CAL:
+	  case MAG_APER_ERR:
+
 	  case MAG_KRON_INST:
+	  case MAG_KRON_CAT:
+	  case MAG_KRON_SYS:
+	  case MAG_KRON_REL:
+	  case MAG_KRON_CAL:
 	  case MAG_KRON_ERR:
-	  case MAG_ERR:
+
 	  case MAG_PHOT_FLAGS:
 	    equiv = myEquiv;
@@ -137,12 +147,23 @@
 	  case MAG_AVE:
 	  case MAG_REF:
+	  case MAG_STDEV:
+	  case MAG_AVE_ERR:
 	  case MAG_CHISQ:
-	  case MAG_AVE_ERR:
+	  case MAG_FLUX_PSF:
+	  case MAG_FLUX_PSF_ERR:
+
+	  case MAG_APER_AVE:
+
+	  case MAG_KRON_AVE:
+	  case MAG_FLUX_KRON:
+	  case MAG_FLUX_KRON_ERR:
+
+	  case MAG_20:
+	  case MAG_80:
+	  case MAG_UC_DIST:
+	  case MAG_STACK_DET_ID:
+
 	  case MAG_NCODE:
 	  case MAG_NPHOT:
-	  case MAG_FLUX_PSF:
-	  case MAG_FLUX_PSF_ERR:
-	  case MAG_FLUX_KRON:
-	  case MAG_FLUX_KRON_ERR:
 	    equiv = field->photcode;
 	    goto valid_photcode;
@@ -178,40 +199,71 @@
 	  value.Flt = PhotRef  (equiv, average, secfilt, measure); 
 	  break;
-	case MAG_APER:
-	  value.Flt = PhotAper (measure); 
-	  break;
+	case MAG_ERR:
+	  value.Flt = measure[0].dM;
+	  break;
+	case MAG_AVE_ERR:
+	  value.Flt = PhotAveErr  (equiv, average, secfilt); 
+	  break;
+
 	case MAG_APER_INST:
 	  value.Flt = PhotAperInst (measure); 
 	  break;
-	case MAG_KRON:
-	  value.Flt = PhotKron (measure); 
-	  break;
+	case MAG_APER_CAT:
+	  value.Flt = PhotAperCat (measure); 
+	  break;
+	case MAG_APER_SYS:
+	  value.Flt = PhotAperSys (measure, average, secfilt); 
+	  break;
+	case MAG_APER:
+	case MAG_APER_REL:
+	  value.Flt = PhotAperRel (measure, average, secfilt); 
+	  break;
+	case MAG_APER_CAL:
+	  value.Flt = PhotAperCal (measure, average, secfilt, measure, equiv); 
+	  break;
+	case MAG_APER_AVE:
+	  value.Flt = PhotAperAve (equiv, average, secfilt);
+	  break;
+	case MAG_APER_REF:
+	  value.Flt = PhotAperRef (equiv, average, secfilt, measure); 
+	  break;
+	case MAG_APER_ERR:
+	  value.Flt = measure[0].dM;
+	  break;
+
 	case MAG_KRON_INST:
 	  value.Flt = PhotKronInst (measure); 
 	  break;
+	case MAG_KRON_CAT:
+	  value.Flt = PhotKronCat (measure); 
+	  break;
+	case MAG_KRON_SYS:
+	  value.Flt = PhotKronSys (measure, average, secfilt); 
+	  break;
+	case MAG_KRON:
+	case MAG_KRON_REL:
+	  value.Flt = PhotKronRel (measure, average, secfilt); 
+	  break;
+	case MAG_KRON_CAL:
+	  value.Flt = PhotKronCal (measure, average, secfilt, measure, equiv); 
+	  break;
+	case MAG_KRON_AVE:
+	  value.Flt = PhotKronAve (equiv, average, secfilt);
+	  break;
+	case MAG_KRON_REF:
+	  value.Flt = PhotKronRef (equiv, average, secfilt, measure); 
+	  break;
 	case MAG_KRON_ERR:
-	  value.Flt = measure[0].dMkron; 
-	  break;
-	case MAG_ERR:
-	  value.Flt = measure[0].dM;
-	  break;
-	case MAG_AVE_ERR:
-	  value.Flt = PhotdM  (equiv, average, secfilt); 
-	  break;
+	  value.Flt = measure[0].dMkron;
+	  break;
+
 	case MAG_PHOT_FLAGS:
 	  if ((field->photcode->type == PHOT_REF) || (field->photcode->type == PHOT_DEP)) {
 	    value.Int = measure[0].photFlags;
-	  } else {
-	    value.Int = 0;
 	  }
 	  break;
-	case MAG_CHISQ:
-	  value.Flt = PhotXm  (equiv, average, secfilt); 
-	  break;
+
 	case MAG_NCODE:
-	  if (equiv == NULL) {
-	    value.Int = 0;
-	    break;
-	  }
+	  if (equiv == NULL) break;
 	  Nsec = GetPhotcodeNsec (equiv->code);
 	  if (Nsec == -1) break;
@@ -219,12 +271,26 @@
 	  break;
 	case MAG_NPHOT:
-	  if (equiv == NULL) {
-	    value.Int = 0;
-	    break;
-	  }
+	  if (equiv == NULL) break;
 	  Nsec = GetPhotcodeNsec (equiv->code);
 	  if (Nsec == -1) break;
 	  value.Int = secfilt[Nsec].Nused;
 	  break;
+
+	case MAG_CHISQ:
+	  value.Flt = PhotXm (equiv, average, secfilt); 
+	  break;
+	case MAG_STDEV:
+	  value.Flt = PhotMstdev (equiv, average, secfilt);
+	  break;
+	case MAG_20:
+	  value.Flt = PhotM20 (equiv, average, secfilt);
+	  break;
+	case MAG_80:
+	  value.Flt = PhotM80 (equiv, average, secfilt);
+	  break;
+	case MAG_UC_DIST:
+	  value.Flt = PhotUCdist (equiv, average, secfilt); 
+	  break;
+
 	case MAG_FLUX_PSF:
 	  value.Flt = PhotAveFluxPSF (field->photcode, average, secfilt);
Index: /branches/eam_branches/ipp-20140206/Ohana/src/libdvo/src/dbFields.c
===================================================================
--- /branches/eam_branches/ipp-20140206/Ohana/src/libdvo/src/dbFields.c	(revision 36588)
+++ /branches/eam_branches/ipp-20140206/Ohana/src/libdvo/src/dbFields.c	(revision 36589)
@@ -30,4 +30,5 @@
 int GetMagMode (char *string) {
 
+  // these all imply PSF mags:
   if (!strcasecmp (string, "inst"))        return (MAG_INST);
   if (!strcasecmp (string, "cat"))         return (MAG_CAT);
@@ -37,14 +38,45 @@
   if (!strcasecmp (string, "ave"))         return (MAG_AVE);
   if (!strcasecmp (string, "ref"))         return (MAG_REF);
+  if (!strcasecmp (string, "err"))         return (MAG_ERR);
+  if (!strcasecmp (string, "aveerr"))      return (MAG_AVE_ERR);
+
+  // these are explicit PSF mags:
+  if (!strcasecmp (string, "psf_inst"))    return (MAG_INST);
+  if (!strcasecmp (string, "psf_cat"))     return (MAG_CAT);
+  if (!strcasecmp (string, "psf_sys"))     return (MAG_SYS);
+  if (!strcasecmp (string, "psf_rel"))     return (MAG_REL);
+  if (!strcasecmp (string, "psf_cal"))     return (MAG_CAL);
+  if (!strcasecmp (string, "psf_ave"))     return (MAG_AVE);
+  if (!strcasecmp (string, "psf_ref"))     return (MAG_REF);
+  if (!strcasecmp (string, "psf_err"))     return (MAG_ERR);
+  if (!strcasecmp (string, "psf_aveerr"))  return (MAG_AVE_ERR);
+
+  // these are aper mags:
   if (!strcasecmp (string, "ap"))          return (MAG_APER);
   if (!strcasecmp (string, "aper"))        return (MAG_APER);
   if (!strcasecmp (string, "aperinst"))    return (MAG_APER_INST);
   if (!strcasecmp (string, "aper_inst"))   return (MAG_APER_INST);
+  if (!strcasecmp (string, "aper_cat"))    return (MAG_APER_CAT);
+  if (!strcasecmp (string, "aper_sys"))    return (MAG_APER_SYS);
+  if (!strcasecmp (string, "aper_rel"))    return (MAG_APER_REL);
+  if (!strcasecmp (string, "aper_cal"))    return (MAG_APER_CAL);
+  if (!strcasecmp (string, "aper_ave"))    return (MAG_APER_AVE);
+  if (!strcasecmp (string, "aper_ref"))    return (MAG_APER_REF);
+  if (!strcasecmp (string, "aper_err"))    return (MAG_APER_ERR);
+
+  // these are kron mags:
   if (!strcasecmp (string, "kron"))        return (MAG_KRON);
+  if (!strcasecmp (string, "kron_inst"))   return (MAG_KRON_INST);
+  if (!strcasecmp (string, "kron_cat"))    return (MAG_KRON_CAT);
+  if (!strcasecmp (string, "kron_sys"))    return (MAG_KRON_SYS);
+  if (!strcasecmp (string, "kron_rel"))    return (MAG_KRON_REL);
+  if (!strcasecmp (string, "kron_cal"))    return (MAG_KRON_CAL);
+  if (!strcasecmp (string, "kron_ave"))    return (MAG_KRON_AVE);
+  if (!strcasecmp (string, "kron_ref"))    return (MAG_KRON_REF);
+  if (!strcasecmp (string, "kron_err"))    return (MAG_KRON_ERR);
   if (!strcasecmp (string, "kroninst"))    return (MAG_KRON_INST);
-  if (!strcasecmp (string, "kron_inst"))   return (MAG_KRON_INST);
   if (!strcasecmp (string, "kronerr"))     return (MAG_KRON_ERR);
-  if (!strcasecmp (string, "err"))         return (MAG_ERR);
-  if (!strcasecmp (string, "aveerr"))      return (MAG_AVE_ERR);
+
+  // other fields:
   if (!strcasecmp (string, "photflags"))   return (MAG_PHOT_FLAGS);
   if (!strcasecmp (string, "flags"))       return (MAG_PHOT_FLAGS);
Index: /branches/eam_branches/ipp-20140206/Ohana/src/libdvo/src/dvo_photcode_ops.c
===================================================================
--- /branches/eam_branches/ipp-20140206/Ohana/src/libdvo/src/dvo_photcode_ops.c	(revision 36588)
+++ /branches/eam_branches/ipp-20140206/Ohana/src/libdvo/src/dvo_photcode_ops.c	(revision 36589)
@@ -260,76 +260,4 @@
 }
 
-float PhotAper (Measure *measure) {
-
-  int Np;
-  float Mcat;
-  PhotCode *code;
-
-  Np = photcodes[0].hashcode[measure[0].photcode];
-  if (Np == -1) return (NAN);
-
-  if (photcodes[0].code[Np].type == PHOT_REF) {
-    Mcat = measure[0].Map;
-    return (Mcat);
-  }
-  code = &photcodes[0].code[Np];
-  Mcat = measure[0].Map - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
-  
-  return (Mcat);
-}
-
-float PhotAperInst (Measure *measure) {
-
-  int Np;
-  float Minst;
-
-  Np = photcodes[0].hashcode[measure[0].photcode];
-  if (Np == -1) return (NAN);
-
-  if (photcodes[0].code[Np].type == PHOT_REF) {
-    Minst = measure[0].Map;
-    return (Minst);
-  }
-  Minst = measure[0].Map - measure[0].dt - ZERO_POINT;
-  
-  return (Minst);
-}
-
-float PhotKron (Measure *measure) {
-
-  int Np;
-  float Mcat;
-  PhotCode *code;
-
-  Np = photcodes[0].hashcode[measure[0].photcode];
-  if (Np == -1) return (NAN);
-
-  if (photcodes[0].code[Np].type == PHOT_REF) {
-    Mcat = measure[0].Mkron;
-    return (Mcat);
-  }
-  code = &photcodes[0].code[Np];
-  Mcat = measure[0].Mkron - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
-  
-  return (Mcat);
-}
-
-float PhotKronInst (Measure *measure) {
-
-  int Np;
-  float Minst;
-
-  Np = photcodes[0].hashcode[measure[0].photcode];
-  if (Np == -1) return (NAN);
-
-  if (photcodes[0].code[Np].type == PHOT_REF) {
-    Minst = measure[0].Mkron;
-    return (Minst);
-  }
-  Minst = measure[0].Mkron - measure[0].dt - ZERO_POINT;
-  
-  return (Minst);
-}
-
 float PhotSys (Measure *measure, Average *average, SecFilt *secfilt) {
 
@@ -363,23 +291,4 @@
 }
 
-float PhotZeroPoint (Measure *measure, Average *average, SecFilt *secfilt) {
-
-  int Np;
-  float ZP;
-  PhotCode *code;
-
-  Np = photcodes[0].hashcode[measure[0].photcode];
-  if (Np == -1) return (NAN);
-
-  if (photcodes[0].code[Np].type == PHOT_REF) {
-    ZP = 0.0;
-    return (ZP);
-  }
-  code = &photcodes[0].code[Np];
-  ZP = code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
-
-  return (ZP);
-}
-
 float PhotRel (Measure *measure, Average *average, SecFilt *secfilt) {
 
@@ -445,4 +354,435 @@
   Mcal += Mcol;
   return (Mcal);
+}
+
+/***/
+float PhotAve (PhotCode *code, Average *average, SecFilt *secfilt) {
+
+  int Ns;
+  float Mave;
+
+  if (code == NULL) return NAN;
+
+  Ns = photcodes[0].hashNsec[code[0].code];
+  Mave = (Ns == -1) ? NAN : secfilt[Ns].M;
+  return (Mave);
+}
+
+/* return calibrated magnitude from average/secfilt for given photcode */
+float PhotRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure) {
+
+  int i, Ns;
+  float Mave, Mref, Mcol, mc;
+  double Mc;
+
+  if (code == NULL) return NAN;
+
+  Ns = photcodes[0].hashNsec[code[0].code];
+  Mave = (Ns == -1) ? NAN : secfilt[Ns].M;
+  Mref = Mave + SCALE*code[0].C;
+
+  mc = PhotColorForCode (average, secfilt, measure, code);
+  if (isnan(mc)) return (Mref);
+  mc = mc - SCALE*code[0].dX;
+
+  Mc = mc;
+  Mcol = 0;
+  for (i = 0; i < code[0].Nc; i++) {
+    Mcol += code[0].X[i]*Mc;
+    Mc *= mc;    /* the 0.001 is needed for higher order terms to keep the units mag = mag^n */
+  }
+  Mref += Mcol;
+  return (Mref);
+}
+
+float PhotAveErr (PhotCode *code, Average *average, SecFilt *secfilt) {
+
+  int Ns;
+  float dM;
+
+  if (code == NULL) return NAN;
+
+  Ns = photcodes[0].hashNsec[code[0].code];
+  dM  = (Ns == -1) ? NAN : secfilt[Ns].dM;
+  return (dM);
+}
+
+/************************************** APERTURE-related Magnitudes ***********************************************/
+
+float PhotAperInst (Measure *measure) {
+
+  int Np;
+  float Minst;
+
+  Np = photcodes[0].hashcode[measure[0].photcode];
+  if (Np == -1) return (NAN);
+
+  if (photcodes[0].code[Np].type == PHOT_REF) {
+    Minst = measure[0].Map;
+    return (Minst);
+  }
+  Minst = measure[0].Map - measure[0].dt - ZERO_POINT;
+  
+  return (Minst);
+}
+
+float PhotAperCat (Measure *measure) {
+
+  int Np;
+  float Mcat;
+  PhotCode *code;
+
+  Np = photcodes[0].hashcode[measure[0].photcode];
+  if (Np == -1) return (NAN);
+
+  if (photcodes[0].code[Np].type == PHOT_REF) {
+    Mcat = measure[0].Map;
+    return (Mcat);
+  }
+  code = &photcodes[0].code[Np];
+  Mcat = measure[0].Map - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
+  
+  return (Mcat);
+}
+
+float PhotAperSys (Measure *measure, Average *average, SecFilt *secfilt) {
+
+  int i, Np;
+  float Mcat, Mcol, Msys, mc, Mc;
+  PhotCode *code;
+
+  Np = photcodes[0].hashcode[measure[0].photcode];
+  if (Np == -1) return (NAN);
+
+  if (photcodes[0].code[Np].type == PHOT_REF) {
+    Mcat = measure[0].Map;
+    return (Mcat);
+  }
+  code = &photcodes[0].code[Np];
+  Mcat = measure[0].Map - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
+  
+  /* for DEP, color must be made of PRI/SEC */
+  mc = PhotColorForCode (average, secfilt, NULL, code);
+  if (isnan(mc)) return (Mcat);
+  mc = mc - SCALE*code[0].dX;
+
+  Mc = mc;
+  Mcol = 0;
+  for (i = 0; i < code[0].Nc; i++) {
+    Mcol += code[0].X[i]*Mc;
+    Mc *= mc;
+  }
+  Msys = Mcat + Mcol;
+  return (Msys);
+}
+
+float PhotAperRel (Measure *measure, Average *average, SecFilt *secfilt) {
+
+  int i, Np;
+  float Mcat, Mcol, Mrel, mc, Mc;
+  PhotCode *code;
+
+  Np = photcodes[0].hashcode[measure[0].photcode];
+  if (Np == -1) return (NAN);
+
+  if (photcodes[0].code[Np].type == PHOT_REF) {
+    Mcat = measure[0].Map;
+    return (Mcat);
+  }
+  code = &photcodes[0].code[Np];
+  Mrel = measure[0].Map - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C - measure[0].Mcal;
+
+  /* for DEP, color must be made of PRI/SEC */
+  mc = PhotColorForCode (average, secfilt, NULL, code);
+  if (isnan(mc)) return (Mrel);
+  mc = mc - SCALE*code[0].dX;
+
+  Mc = mc;
+  Mcol = 0;
+  for (i = 0; i < code[0].Nc; i++) {
+    Mcol += code[0].X[i]*Mc;
+    Mc *= mc;    /* the 0.001 is needed for higher order terms to keep the units mag = mag^n */
+  }
+  Mrel += Mcol;
+  return (Mrel);
+}
+
+/* return calibrated magnitude from measure for given photcode */
+float PhotAperCal (Measure *thisone, Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code) {
+
+  int i, Np; 
+  float Mcal, Mrel, Mcol, mc, Mc;
+
+  if (code == NULL) return NAN;
+
+  /* code must be the matching PRI/SEC code for this measurement or an equivalent ALT */
+  Np = photcodes[0].hashcode[thisone[0].photcode];
+  if (Np == -1) return (NAN);
+
+  if (photcodes[0].code[Np].type == PHOT_REF) {
+    Mrel = thisone[0].Map;
+    return (Mrel);
+  }
+  if (code[0].code != photcodes[0].code[Np].equiv) return (NAN);
+
+  Mcal = PhotAperRel (thisone, average, secfilt) + SCALE*code[0].C;
+
+  mc = PhotColorForCode (average, secfilt, measure, code);
+  if (isnan(mc)) return (Mcal);
+  mc = mc - SCALE*code[0].dX;
+
+  Mc = mc;
+  Mcol = 0;
+  for (i = 0; i < code[0].Nc; i++) {
+    Mcol += code[0].X[i]*Mc;
+    Mc *= mc;
+  }
+  Mcal += Mcol;
+  return (Mcal);
+}
+
+float PhotAperAve (PhotCode *code, Average *average, SecFilt *secfilt) {
+
+  int Ns;
+  float Maper;
+
+  if (code == NULL) return NAN;
+
+  Ns = photcodes[0].hashNsec[code[0].code];
+  Maper = (Ns == -1) ? NAN : secfilt[Ns].Map;
+  return (Maper);
+}
+
+/* return calibrated magnitude from average/secfilt for given photcode */
+float PhotAperRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure) {
+
+  int i, Ns;
+  float Mave, Mref, Mcol, mc;
+  double Mc;
+
+  if (code == NULL) return NAN;
+
+  Ns = photcodes[0].hashNsec[code[0].code];
+  Mave = (Ns == -1) ? NAN : secfilt[Ns].Map;
+  Mref = Mave + SCALE*code[0].C;
+
+  mc = PhotColorForCode (average, secfilt, measure, code);
+  if (isnan(mc)) return (Mref);
+  mc = mc - SCALE*code[0].dX;
+
+  Mc = mc;
+  Mcol = 0;
+  for (i = 0; i < code[0].Nc; i++) {
+    Mcol += code[0].X[i]*Mc;
+    Mc *= mc;    /* the 0.001 is needed for higher order terms to keep the units mag = mag^n */
+  }
+  Mref += Mcol;
+  return (Mref);
+}
+
+/************************************** KRON-related Magnitudes ***********************************************/
+
+float PhotKronInst (Measure *measure) {
+
+  int Np;
+  float Minst;
+
+  Np = photcodes[0].hashcode[measure[0].photcode];
+  if (Np == -1) return (NAN);
+
+  if (photcodes[0].code[Np].type == PHOT_REF) {
+    Minst = measure[0].Mkron;
+    return (Minst);
+  }
+  Minst = measure[0].Mkron - measure[0].dt - ZERO_POINT;
+  
+  return (Minst);
+}
+
+float PhotKronCat (Measure *measure) {
+
+  int Np;
+  float Mcat;
+  PhotCode *code;
+
+  Np = photcodes[0].hashcode[measure[0].photcode];
+  if (Np == -1) return (NAN);
+
+  if (photcodes[0].code[Np].type == PHOT_REF) {
+    Mcat = measure[0].Mkron;
+    return (Mcat);
+  }
+  code = &photcodes[0].code[Np];
+  Mcat = measure[0].Mkron - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
+  
+  return (Mcat);
+}
+
+float PhotKronSys (Measure *measure, Average *average, SecFilt *secfilt) {
+
+  int i, Np;
+  float Mcat, Mcol, Msys, mc, Mc;
+  PhotCode *code;
+
+  Np = photcodes[0].hashcode[measure[0].photcode];
+  if (Np == -1) return (NAN);
+
+  if (photcodes[0].code[Np].type == PHOT_REF) {
+    Msys = measure[0].Mkron;
+    return (Msys);
+  }
+  code = &photcodes[0].code[Np];
+  Mcat = measure[0].Mkron - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
+
+  /* for DEP, color must be made of PRI/SEC */
+  mc = PhotColorForCode (average, secfilt, NULL, code);
+  if (isnan(mc)) return (Mcat);
+  mc = mc - SCALE*code[0].dX;
+
+  Mc = mc;
+  Mcol = 0;
+  for (i = 0; i < code[0].Nc; i++) {
+    Mcol += code[0].X[i]*Mc;
+    Mc *= mc;
+  }
+  Msys = Mcat + Mcol;
+  return (Msys);
+}
+
+float PhotKronRel (Measure *measure, Average *average, SecFilt *secfilt) {
+
+  int i, Np;
+  float Mcat, Mcol, Mrel, mc, Mc;
+  PhotCode *code;
+
+  Np = photcodes[0].hashcode[measure[0].photcode];
+  if (Np == -1) return (NAN);
+
+  if (photcodes[0].code[Np].type == PHOT_REF) {
+    Mcat = measure[0].Mkron;
+    return (Mcat);
+  }
+  code = &photcodes[0].code[Np];
+  Mrel = measure[0].Mkron - ZERO_POINT + code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C - measure[0].Mcal;
+
+  /* for DEP, color must be made of PRI/SEC */
+  mc = PhotColorForCode (average, secfilt, NULL, code);
+  if (isnan(mc)) return (Mrel);
+  mc = mc - SCALE*code[0].dX;
+
+  Mc = mc;
+  Mcol = 0;
+  for (i = 0; i < code[0].Nc; i++) {
+    Mcol += code[0].X[i]*Mc;
+    Mc *= mc;    /* the 0.001 is needed for higher order terms to keep the units mag = mag^n */
+  }
+  Mrel += Mcol;
+  return (Mrel);
+}
+
+/* return calibrated magnitude from measure for given photcode */
+float PhotKronCal (Measure *thisone, Average *average, SecFilt *secfilt, Measure *measure, PhotCode *code) {
+
+  int i, Np; 
+  float Mcal, Mrel, Mcol, mc, Mc;
+
+  if (code == NULL) return NAN;
+
+  /* code must be the matching PRI/SEC code for this measurement or an equivalent ALT */
+  Np = photcodes[0].hashcode[thisone[0].photcode];
+  if (Np == -1) return (NAN);
+
+  if (photcodes[0].code[Np].type == PHOT_REF) {
+    Mrel = thisone[0].Mkron;
+    return (Mrel);
+  }
+  if (code[0].code != photcodes[0].code[Np].equiv) return (NAN);
+
+  Mcal = PhotKronRel (thisone, average, secfilt) + SCALE*code[0].C;
+
+  mc = PhotColorForCode (average, secfilt, measure, code);
+  if (isnan(mc)) return (Mcal);
+  mc = mc - SCALE*code[0].dX;
+
+  Mc = mc;
+  Mcol = 0;
+  for (i = 0; i < code[0].Nc; i++) {
+    Mcol += code[0].X[i]*Mc;
+    Mc *= mc;
+  }
+  Mcal += Mcol;
+  return (Mcal);
+}
+
+float PhotKronAve (PhotCode *code, Average *average, SecFilt *secfilt) {
+
+  int Ns;
+  float Mkron;
+
+  if (code == NULL) return NAN;
+
+  Ns = photcodes[0].hashNsec[code[0].code];
+  Mkron = (Ns == -1) ? NAN : secfilt[Ns].Mkron;
+  return (Mkron);
+}
+
+/* return calibrated magnitude from average/secfilt for given photcode */
+float PhotKronRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure) {
+
+  int i, Ns;
+  float Mave, Mref, Mcol, mc;
+  double Mc;
+
+  if (code == NULL) return NAN;
+
+  Ns = photcodes[0].hashNsec[code[0].code];
+  Mave = (Ns == -1) ? NAN : secfilt[Ns].Mkron;
+  Mref = Mave + SCALE*code[0].C;
+
+  mc = PhotColorForCode (average, secfilt, measure, code);
+  if (isnan(mc)) return (Mref);
+  mc = mc - SCALE*code[0].dX;
+
+  Mc = mc;
+  Mcol = 0;
+  for (i = 0; i < code[0].Nc; i++) {
+    Mcol += code[0].X[i]*Mc;
+    Mc *= mc;    /* the 0.001 is needed for higher order terms to keep the units mag = mag^n */
+  }
+  Mref += Mcol;
+  return (Mref);
+}
+
+float PhotKronAveErr (PhotCode *code, Average *average, SecFilt *secfilt) {
+
+  int Ns;
+  float dMkron;
+
+  if (code == NULL) return NAN;
+
+  Ns = photcodes[0].hashNsec[code[0].code];
+  dMkron = (Ns == -1) ? NAN : secfilt[Ns].dMkron;
+  return (dMkron);
+}
+
+/********************* other support functions ********************************/
+
+float PhotZeroPoint (Measure *measure, Average *average, SecFilt *secfilt) {
+
+  int Np;
+  float ZP;
+  PhotCode *code;
+
+  Np = photcodes[0].hashcode[measure[0].photcode];
+  if (Np == -1) return (NAN);
+
+  if (photcodes[0].code[Np].type == PHOT_REF) {
+    ZP = 0.0;
+    return (ZP);
+  }
+  code = &photcodes[0].code[Np];
+  ZP = code[0].K*(measure[0].airmass - 1.000) + SCALE*code[0].C;
+
+  return (ZP);
 }
 
@@ -497,56 +837,4 @@
 }
 
-/* return calibrated magnitude from average/secfilt for given photcode */
-float PhotRef (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure) {
-
-  int i, Ns;
-  float Mave, Mref, Mcol, mc;
-  double Mc;
-
-  if (code == NULL) return NAN;
-
-  Ns = photcodes[0].hashNsec[code[0].code];
-  Mave = (Ns == -1) ? NAN : secfilt[Ns].M;
-  Mref = Mave + SCALE*code[0].C;
-
-  mc = PhotColorForCode (average, secfilt, measure, code);
-  if (isnan(mc)) return (Mref);
-  mc = mc - SCALE*code[0].dX;
-
-  Mc = mc;
-  Mcol = 0;
-  for (i = 0; i < code[0].Nc; i++) {
-    Mcol += code[0].X[i]*Mc;
-    Mc *= mc;    /* the 0.001 is needed for higher order terms to keep the units mag = mag^n */
-  }
-  Mref += Mcol;
-  return (Mref);
-}
-
-/***/
-float PhotAve (PhotCode *code, Average *average, SecFilt *secfilt) {
-
-  int Ns;
-  float Mave;
-
-  if (code == NULL) return NAN;
-
-  Ns = photcodes[0].hashNsec[code[0].code];
-  Mave = (Ns == -1) ? NAN : secfilt[Ns].M;
-  return (Mave);
-}
-
-float PhotdM (PhotCode *code, Average *average, SecFilt *secfilt) {
-
-  int Ns;
-  float dM;
-
-  if (code == NULL) return NAN;
-
-  Ns = photcodes[0].hashNsec[code[0].code];
-  dM  = (Ns == -1) ? NAN : secfilt[Ns].dM;
-  return (dM);
-}
-
 float PhotMstdev (PhotCode *code, Average *average, SecFilt *secfilt) {
 
@@ -559,40 +847,4 @@
   Mstdev  = (Ns == -1) ? NAN : 0.001*secfilt[Ns].Mstdev;
   return (Mstdev);
-}
-
-float PhotAperAve (PhotCode *code, Average *average, SecFilt *secfilt) {
-
-  int Ns;
-  float Maper;
-
-  if (code == NULL) return NAN;
-
-  Ns = photcodes[0].hashNsec[code[0].code];
-  Maper = (Ns == -1) ? NAN : secfilt[Ns].Map;
-  return (Maper);
-}
-
-float PhotKronAve (PhotCode *code, Average *average, SecFilt *secfilt) {
-
-  int Ns;
-  float Mkron;
-
-  if (code == NULL) return NAN;
-
-  Ns = photcodes[0].hashNsec[code[0].code];
-  Mkron = (Ns == -1) ? NAN : secfilt[Ns].Mkron;
-  return (Mkron);
-}
-
-float PhotKronAveErr (PhotCode *code, Average *average, SecFilt *secfilt) {
-
-  int Ns;
-  float dMkron;
-
-  if (code == NULL) return NAN;
-
-  Ns = photcodes[0].hashNsec[code[0].code];
-  dMkron = (Ns == -1) ? NAN : secfilt[Ns].dMkron;
-  return (dMkron);
 }