Changeset 39926 for trunk/Ohana/src/dvomerge/src/build_links.c

Timestamp:

Jan 6, 2017, 11:30:10 AM (10 years ago)

Author:

eugene

Message:

merging changes from czw dev branch (compare with r39924)

Location:

trunk

Files:

• . (modified) (1 prop)
• Ohana (modified) (1 prop)
• Ohana/src/dvomerge/src/build_links.c (modified) (54 diffs)

trunk/Ohana/src/dvomerge/src/build_links.c

@@ -15 +15 @@
 data: they refer to the sequence number in the data blocks.
 
-next_meas is a list of the equivalent sequence of the measure block as if it were sorted.
+next_measure is a list of the equivalent sequence of the measure block as if it were sorted.
 
 to find the sequence of measurements for a given average:
 n_0 = average->measureOffset
-n_1 = next_meas[n_0]
-n_i = next_meas[n_i-1]
+n_1 = next_measure[n_0]
+n_i = next_measure[n_i-1]
 
 */
@@ -31 +31 @@
 
   off_t i, j, N;
-  off_t *next_meas;
+  off_t *next_measure;
 
   if (!measure) return NULL;
@@ -38 +38 @@
   N = 0;
 
-  ALLOCATE (next_meas, off_t, Nmeasure);
+  ALLOCATE (next_measure, off_t, Nmeasure);
   for (i = 0; i < Naverage; i++) {
     if (!average[i].Nmeasure) continue;
@@ -45 +45 @@
     for (j = 0; j < average[i].Nmeasure - 1; j++, N++) {
       myAssert (measure[m+j+1].averef == i, "not sorted");
-      next_meas[N] = N + 1;
+      next_measure[N] = N + 1;
       if (N >= Nmeasure) {
         fprintf (stderr, "WARNING: N out of bounds (1)\n");
       }
     }
-    next_meas[N] = -1;
+    next_measure[N] = -1;
     if (N >= Nmeasure) {
       fprintf (stderr, "WARNING: N out of bounds (2)\n");
@@ -61 +61 @@
     N++;
   }
-  return (next_meas);
+  return (next_measure);
 }
 
@@ -74 +74 @@
 
   off_t i, m, k, Nm, averef;
-  off_t *next_meas;
-
-  ALLOCATE (next_meas, off_t, Nmeasure);
+  off_t *next_measure;
+
+  ALLOCATE (next_measure, off_t, Nmeasure);
 
   /* reset the Nm, offset values for average */
@@ -87 +87 @@
     averef = measure[Nm].averef;
     m = average[averef].measureOffset;  
-    next_meas[Nm] = -1;
+    next_measure[Nm] = -1;
 
     if (m == -1) { /* no links yet for source */
@@ -95 +95 @@
     }
 
-    for (k = 0; next_meas[m] != -1; k++) {
-      m = next_meas[m];
+    for (k = 0; next_measure[m] != -1; k++) {
+      m = next_measure[m];
       if (m >= Nmeasure) {
         fprintf (stderr, "WARNING: m out of bounds (1)\n");
@@ -103 +103 @@
 
     average[averef].Nmeasure = k + 2;
-    next_meas[m] = Nm;
+    next_measure[m] = Nm;
     if (m >= Nmeasure) {
       fprintf (stderr, "WARNING: m out of bounds (2)\n");
     }
   }
-  return (next_meas);
+  return (next_measure);
 }
 
 /* average[].measureOffset, average[].Nmeasure are valid within an addstar run */
-int add_meas_link (Average *average, off_t *next_meas, off_t Nmeasure, off_t NMEASURE) {
+int add_measure_link (Average *average, off_t *next_measure, off_t Nmeasure, off_t NMEASURE) {
 
   off_t k, m;
 
-  /* if we have trouble, check validity of next_meas[m] : m < Nmeasure */
+  /* if we have trouble, check validity of next_measure[m] : m < Nmeasure */
   m = average[0].measureOffset;  
 
   for (k = 0; k < average[0].Nmeasure - 1; k++)  {
-    m = next_meas[m];
+    m = next_measure[m];
     if (m >= NMEASURE) {
       fprintf (stderr, "WARNING: m out of bounds (3)\n");
@@ -127 +127 @@
 
   /* set up references */
-  next_meas[Nmeasure] = -1;
+  next_measure[Nmeasure] = -1;
   if (Nmeasure >= NMEASURE) {
     fprintf (stderr, "WARNING: Nmeasure out of bounds (1)\n");
@@ -136 +136 @@
     average[0].measureOffset = Nmeasure;
   } else {
-    next_meas[m] = Nmeasure;
+    next_measure[m] = Nmeasure;
     if (m >= NMEASURE) {
       fprintf (stderr, "WARNING: m out of bounds (4)\n");
@@ -145 +145 @@
 }
 
-Measure *sort_measure (Average *average, off_t Naverage, Measure *measure, off_t Nmeasure, off_t *next_meas) {
+Measure *sort_measure (Average *average, off_t Naverage, Measure *measure, off_t Nmeasure, off_t *next_measure) {
 
   off_t i, k, n, np, N;
@@ -169 +169 @@
       tmpmeasure[N].averef = i;
       np = n;
-      n = next_meas[n];
+      n = next_measure[n];
     }
   }
@@ -183 +183 @@
 
   off_t i, j, N;
-  off_t *next_miss;
+  off_t *next_missing;
 
   N = 0;
 
-  ALLOCATE (next_miss, off_t, Nmissing);
+  ALLOCATE (next_missing, off_t, Nmissing);
   for (i = 0; i < Naverage; i++) {
     for (j = 0; j < average[i].Nmissing - 1; j++, N++) {
-      next_miss[N] = N + 1;
+      next_missing[N] = N + 1;
     }
     if (average[i].Nmissing > 0) {
-      next_miss[N] = -1;
+      next_missing[N] = -1;
       if (N >= Nmissing) {
         fprintf (stderr, "overflow in init_missing_links");
@@ -202 +202 @@
 
   }
-  return (next_miss);
-}
-
-int add_miss_link (Average *average, off_t *next_miss, off_t Nmissing) {
+  return (next_missing);
+}
+
+int add_missing_link (Average *average, off_t *next_missing, off_t Nmissing) {
 
   off_t k, m;
@@ -212 +212 @@
   if (average[0].Nmissing < 1) {
     average[0].missingOffset = Nmissing;
-    next_miss[Nmissing] = -1;
+    next_missing[Nmissing] = -1;
     return (TRUE);
   }
 
   m = average[0].missingOffset;  
-  for (k = 0; k < average[0].Nmissing - 1; k++) m = next_miss[m];
+  for (k = 0; k < average[0].Nmissing - 1; k++) m = next_missing[m];
   /* set up references */
-  next_miss[Nmissing] = -1;
-  next_miss[m] = Nmissing;
+  next_missing[Nmissing] = -1;
+  next_missing[m] = Nmissing;
   return (TRUE);
 }
@@ -227 +227 @@
    we must always save the missing table, if it exists */
 
-Missing *sort_missing (Average *average, off_t Naverage, Missing *missing, off_t Nmissing, off_t *next_miss) {
+Missing *sort_missing (Average *average, off_t Naverage, Missing *missing, off_t Nmissing, off_t *next_missing) {
 
   off_t i, k, n, N;
@@ -240 +240 @@
     for (k = 0; k < average[i].Nmissing; k++, N++) {
       tmpmissing[N] = missing[n]; 
-      n = next_miss[n];
+      n = next_missing[n];
     }
   }
@@ -254 +254 @@
 
   off_t i, j, N;
-  off_t *next_lens;
+  off_t *next_lensing;
 
   if (!lensing) return NULL;
@@ -261 +261 @@
   N = 0;
 
-  ALLOCATE (next_lens, off_t, Nlensing);
+  ALLOCATE (next_lensing, off_t, Nlensing);
   for (i = 0; i < Naverage; i++) {
     if (!average[i].Nlensing) continue;
@@ -268 +268 @@
     for (j = 0; j < average[i].Nlensing - 1; j++, N++) {
       myAssert (lensing[m+j+1].averef == i, "not sorted");
-      next_lens[N] = N + 1;
+      next_lensing[N] = N + 1;
       if (N >= Nlensing) {
         fprintf (stderr, "WARNING: N out of bounds (1)\n");
       }
     }
-    next_lens[N] = -1;
+    next_lensing[N] = -1;
     if (N >= Nlensing) {
       fprintf (stderr, "WARNING: N out of bounds (2)\n");
@@ -284 +284 @@
     N++;
   }
-  return (next_lens);
+  return (next_lensing);
 }
 
@@ -297 +297 @@
 
   off_t i, m, k, Nm, averef;
-  off_t *next_lens;
-
-  ALLOCATE (next_lens, off_t, Nlensing);
+  off_t *next_lensing;
+
+  ALLOCATE (next_lensing, off_t, Nlensing);
 
   /* reset the Nm, offset values for average */
@@ -310 +310 @@
     averef = lensing[Nm].averef;
     m = average[averef].lensingOffset;  
-    next_lens[Nm] = -1;
+    next_lensing[Nm] = -1;
 
     if (m == -1) { /* no links yet for source */
@@ -318 +318 @@
     }
 
-    for (k = 0; next_lens[m] != -1; k++) {
-      m = next_lens[m];
+    for (k = 0; next_lensing[m] != -1; k++) {
+      m = next_lensing[m];
       if (m >= Nlensing) {
         fprintf (stderr, "WARNING: m out of bounds (1)\n");
@@ -326 +326 @@
 
     average[averef].Nlensing = k + 2;
-    next_lens[m] = Nm;
+    next_lensing[m] = Nm;
     if (m >= Nlensing) {
       fprintf (stderr, "WARNING: m out of bounds (2)\n");
     }
   }
-  return (next_lens);
+  return (next_lensing);
 }
 
 /* average[].lensingOffset, average[].Nlensing are valid within an addstar run */
-int add_lens_link (Average *average, off_t *next_lens, off_t Nlensing, off_t NLENSING) {
+int add_lensing_link (Average *average, off_t *next_lensing, off_t Nlensing, off_t NLENSING) {
 
   off_t k, m;
 
-  /* if we have trouble, check validity of next_lens[m] : m < Nlensing */
+  /* if we have trouble, check validity of next_lensing[m] : m < Nlensing */
   m = average[0].lensingOffset;  
 
   for (k = 0; k < average[0].Nlensing - 1; k++)  {
-    m = next_lens[m];
+    m = next_lensing[m];
     if (m >= NLENSING) {
       fprintf (stderr, "WARNING: m out of bounds (3)\n");
@@ -350 +350 @@
 
   /* set up references */
-  next_lens[Nlensing] = -1;
+  next_lensing[Nlensing] = -1;
   if (Nlensing >= NLENSING) {
     fprintf (stderr, "WARNING: Nlensing out of bounds (1)\n");
@@ -359 +359 @@
     average[0].lensingOffset = Nlensing;
   } else {
-    next_lens[m] = Nlensing;
+    next_lensing[m] = Nlensing;
     if (m >= NLENSING) {
       fprintf (stderr, "WARNING: m out of bounds (4)\n");
@@ -368 +368 @@
 }
 
-Lensing *sort_lensing (Average *average, off_t Naverage, Lensing *lensing, off_t Nlensing, off_t *next_lens) {
+Lensing *sort_lensing (Average *average, off_t Naverage, Lensing *lensing, off_t Nlensing, off_t *next_lensing) {
 
   off_t i, k, n, np, N;
@@ -392 +392 @@
       tmplensing[N].averef = i;
       np = n;
-      n = next_lens[n];
+      n = next_lensing[n];
     }
   }
   free (lensing);
   return (tmplensing);
+}
+
+/*** Lensobj ****************************************************************************************/
+
+/* build the initial links assuming the table is sorted, 
+   not partial, and has a correct set of average[].lensobjOffset,Nlensobj values */
+off_t *init_lensobj_links (Average *average, off_t Naverage, Lensobj *lensobj, off_t Nlensobj) {
+
+  off_t i, j, N;
+  off_t *next_lensobj;
+
+  if (!lensobj) return NULL;
+  if (SKIP_LENSOBJ) return NULL;
+
+  N = 0;
+
+  ALLOCATE (next_lensobj, off_t, Nlensobj);
+  for (i = 0; i < Naverage; i++) {
+    if (!average[i].Nlensobj) continue;
+    // off_t m = average[i].lensobjOffset;
+    // myAssert (lensobj[m].averef == i, "not sorted");
+    for (j = 0; j < average[i].Nlensobj - 1; j++, N++) {
+      // myAssert (lensobj[m+j+1].averef == i, "not sorted");
+      next_lensobj[N] = N + 1;
+      if (N >= Nlensobj) {
+        fprintf (stderr, "WARNING: N out of bounds (1)\n");
+      }
+    }
+    next_lensobj[N] = -1;
+    if (N >= Nlensobj) {
+      fprintf (stderr, "WARNING: N out of bounds (2)\n");
+    }
+
+    if (N >= Nlensobj) {
+      fprintf (stderr, "overflow in init_lensobj_links\n");
+      abort ();
+    }
+    N++;
+  }
+  return (next_lensobj);
+}
+
+/* construct lensobj links which are valid FOR THIS LOAD
+ * - if we have a full load, we will get links which can
+ *   be used by other programs (eg, relphot, etc)
+ * - if we have a partial load, the links are only valid
+ *   for that partial load
+ */ 
+
+off_t *build_lensobj_links (Average *average, off_t Naverage, Lensobj *lensobj, off_t Nlensobj) {
+
+  fprintf (stderr, "input is not sorted but contains lensobj -- trouble\n");
+  exit (2);
+
+# if (0)
+
+  off_t i, m, k, Nm, averef;
+  off_t *next_lensobj;
+
+  ALLOCATE (next_lensobj, off_t, Nlensobj);
+
+  /* reset the Nm, offset values for average */
+  for (i = 0; i < Naverage; i++) {
+    average[i].lensobjOffset = -1;
+    average[i].Nlensobj     =  0;
+  }
+
+  for (Nm = 0; Nm < Nlensobj; Nm++) {
+    averef = lensobj[Nm].averef;
+    m = average[averef].lensobjOffset;  
+    next_lensobj[Nm] = -1;
+
+    if (m == -1) { /* no links yet for source */
+      average[averef].lensobjOffset = Nm;
+      average[averef].Nlensobj     = 1;
+      continue;
+    }
+
+    for (k = 0; next_lensobj[m] != -1; k++) {
+      m = next_lensobj[m];
+      if (m >= Nlensobj) {
+        fprintf (stderr, "WARNING: m out of bounds (1)\n");
+      }
+    }
+
+    average[averef].Nlensobj = k + 2;
+    next_lensobj[m] = Nm;
+    if (m >= Nlensobj) {
+      fprintf (stderr, "WARNING: m out of bounds (2)\n");
+    }
+  }
+  return (next_lensobj);
+# endif
+}
+
+/* average[].lensobjOffset, average[].Nlensobj are valid within an addstar run */
+int add_lensobj_link (Average *average, off_t *next_lensobj, off_t Nlensobj, off_t NLENSOBJ) {
+
+  off_t k, m;
+
+  /* if we have trouble, check validity of next_lensobj[m] : m < Nlensobj */
+  m = average[0].lensobjOffset;  
+
+  for (k = 0; k < average[0].Nlensobj - 1; k++)  {
+    m = next_lensobj[m];
+    if (m >= NLENSOBJ) {
+      fprintf (stderr, "WARNING: m out of bounds (3)\n");
+    }
+  }
+
+  /* set up references */
+  next_lensobj[Nlensobj] = -1;
+  if (Nlensobj >= NLENSOBJ) {
+    fprintf (stderr, "WARNING: Nlensobj out of bounds (1)\n");
+  }
+
+  // if Nlensobj is 0, m may have been mis-set; add to the end
+  if ((average[0].Nlensobj == 0) || (m == -1)) {
+    average[0].lensobjOffset = Nlensobj;
+  } else {
+    next_lensobj[m] = Nlensobj;
+    if (m >= NLENSOBJ) {
+      fprintf (stderr, "WARNING: m out of bounds (4)\n");
+    }
+  }
+
+  return (TRUE);
+}
+
+Lensobj *sort_lensobj (Average *average, off_t Naverage, Lensobj *lensobj, off_t Nlensobj, off_t *next_lensobj) {
+
+  off_t i, k, n, np, N;
+  Lensobj *tmplensobj;
+
+  /* fix order of Lensobj (memory intensive, but fast) */
+  np = -1;
+  N = 0; 
+  ALLOCATE (tmplensobj, Lensobj, Nlensobj);
+  for (i = 0; i < Naverage; i++) {
+    if (!average[i].Nlensobj) continue;
+    n = average[i].lensobjOffset;
+    average[i].lensobjOffset = N;
+    int myObjID = average[i].objID;
+    for (k = 0; k < average[i].Nlensobj; k++, N++) {
+      if (n == -1) {
+        fprintf (stderr, "entry after %d has a problem\n", (int) np);
+        abort();
+      }
+      tmplensobj[N] = lensobj[n]; 
+      // myAssert (lensobj[n].averef == i, "error in averef");
+      myAssert ((lensobj[n].objID == myObjID) || (lensobj[n].objID == -1), "error in objID?");
+      // tmplensobj[N].averef = i;
+      np = n;
+      n = next_lensobj[n];
+    }
+  }
+  free (lensobj);
+  return (tmplensobj);
 }
 
@@ -406 +564 @@
 
   off_t i, j, N;
-  off_t *next_star;
+  off_t *next_starpar;
 
   if (!starpar) return NULL;
@@ -415 +573 @@
   // NOTE that is we choose DVO_SKIP_STARPAR, catalog.starpar is NULL.
   // this code will let merge_catalogs_old.c do nothing for starpar
-  ALLOCATE (next_star, off_t, Nstarpar);
-  if (!starpar) return next_star;
+  ALLOCATE (next_starpar, off_t, Nstarpar);
+  if (!starpar) return next_starpar;
 
   for (i = 0; i < Naverage; i++) {
@@ -424 +582 @@
     for (j = 0; j < average[i].Nstarpar - 1; j++, N++) {
       myAssert (starpar[m+j+1].averef == i, "not sorted");
-      next_star[N] = N + 1;
+      next_starpar[N] = N + 1;
       if (N >= Nstarpar) {
         fprintf (stderr, "WARNING: N out of bounds (1)\n");
       }
     }
-    next_star[N] = -1;
+    next_starpar[N] = -1;
     if (N >= Nstarpar) {
       fprintf (stderr, "WARNING: N out of bounds (2)\n");
@@ -440 +598 @@
     N++;
   }
-  return (next_star);
+  return (next_starpar);
 }
 
@@ -453 +611 @@
 
   off_t i, m, k, Nm, averef;
-  off_t *next_star;
-
-  ALLOCATE (next_star, off_t, Nstarpar);
-  if (!starpar) return next_star;
+  off_t *next_starpar;
+
+  ALLOCATE (next_starpar, off_t, Nstarpar);
+  if (!starpar) return next_starpar;
 
   /* reset the Nm, offset values for average */
@@ -467 +625 @@
     averef = starpar[Nm].averef;
     m = average[averef].starparOffset;  
-    next_star[Nm] = -1;
+    next_starpar[Nm] = -1;
 
     if (m == -1) { /* no links yet for source */
@@ -475 +633 @@
     }
 
-    for (k = 0; next_star[m] != -1; k++) {
-      m = next_star[m];
+    for (k = 0; next_starpar[m] != -1; k++) {
+      m = next_starpar[m];
       if (m >= Nstarpar) {
         fprintf (stderr, "WARNING: m out of bounds (1)\n");
@@ -483 +641 @@
 
     average[averef].Nstarpar = k + 2;
-    next_star[m] = Nm;
+    next_starpar[m] = Nm;
     if (m >= Nstarpar) {
       fprintf (stderr, "WARNING: m out of bounds (2)\n");
     }
   }
-  return (next_star);
+  return (next_starpar);
 }
 
 /* average[].starparOffset, average[].Nstarpar are valid within an addstar run */
-int add_star_link (Average *average, off_t *next_star, off_t Nstarpar, off_t NSTARPAR) {
+int add_starpar_link (Average *average, off_t *next_starpar, off_t Nstarpar, off_t NSTARPAR) {
 
   off_t k, m;
 
-  /* if we have trouble, check validity of next_star[m] : m < Nstarpar */
+  /* if we have trouble, check validity of next_starpar[m] : m < Nstarpar */
   m = average[0].starparOffset;  
 
   for (k = 0; k < average[0].Nstarpar - 1; k++)  {
-    m = next_star[m];
+    m = next_starpar[m];
     if (m >= NSTARPAR) {
       fprintf (stderr, "WARNING: m out of bounds (3)\n");
@@ -507 +665 @@
 
   /* set up references */
-  next_star[Nstarpar] = -1;
+  next_starpar[Nstarpar] = -1;
   if (Nstarpar >= NSTARPAR) {
     fprintf (stderr, "WARNING: Nstarpar out of bounds (1)\n");
@@ -516 +674 @@
     average[0].starparOffset = Nstarpar;
   } else {
-    next_star[m] = Nstarpar;
+    next_starpar[m] = Nstarpar;
     if (m >= NSTARPAR) {
       fprintf (stderr, "WARNING: m out of bounds (4)\n");
@@ -525 +683 @@
 }
 
-StarPar *sort_starpar (Average *average, off_t Naverage, StarPar *starpar, off_t Nstarpar, off_t *next_star) {
+StarPar *sort_starpar (Average *average, off_t Naverage, StarPar *starpar, off_t Nstarpar, off_t *next_starpar) {
 
   off_t i, k, n, np, N;
@@ -552 +710 @@
       tmpstarpar[N].averef = i;
       np = n;
-      n = next_star[n];
+      n = next_starpar[n];
     }
   }
@@ -566 +724 @@
 
   off_t i, j, N;
-  off_t *next_galp;
+  off_t *next_galphot;
 
   if (galphot) return NULL;
@@ -573 +731 @@
   N = 0;
 
-  ALLOCATE (next_galp, off_t, Ngalphot);
+  ALLOCATE (next_galphot, off_t, Ngalphot);
   for (i = 0; i < Naverage; i++) {
     if (!average[i].Ngalphot) continue;
@@ -580 +738 @@
     for (j = 0; j < average[i].Ngalphot - 1; j++, N++) {
       myAssert (galphot[m+j+1].averef == i, "not sorted");
-      next_galp[N] = N + 1;
+      next_galphot[N] = N + 1;
       if (N >= Ngalphot) {
         fprintf (stderr, "WARNING: N out of bounds (1)\n");
       }
     }
-    next_galp[N] = -1;
+    next_galphot[N] = -1;
     if (N >= Ngalphot) {
       fprintf (stderr, "WARNING: N out of bounds (2)\n");
@@ -596 +754 @@
     N++;
   }
-  return (next_galp);
+  return (next_galphot);
 }
 
@@ -609 +767 @@
 
   off_t i, m, k, Nm, averef;
-  off_t *next_galp;
-
-  ALLOCATE (next_galp, off_t, Ngalphot);
+  off_t *next_galphot;
+
+  ALLOCATE (next_galphot, off_t, Ngalphot);
 
   /* reset the Nm, offset values for average */
@@ -622 +780 @@
     averef = galphot[Nm].averef;
     m = average[averef].galphotOffset;  
-    next_galp[Nm] = -1;
+    next_galphot[Nm] = -1;
 
     if (m == -1) { /* no links yet for source */
@@ -630 +788 @@
     }
 
-    for (k = 0; next_galp[m] != -1; k++) {
-      m = next_galp[m];
+    for (k = 0; next_galphot[m] != -1; k++) {
+      m = next_galphot[m];
       if (m >= Ngalphot) {
         fprintf (stderr, "WARNING: m out of bounds (1)\n");
@@ -638 +796 @@
 
     average[averef].Ngalphot = k + 2;
-    next_galp[m] = Nm;
+    next_galphot[m] = Nm;
     if (m >= Ngalphot) {
       fprintf (stderr, "WARNING: m out of bounds (2)\n");
     }
   }
-  return (next_galp);
+  return (next_galphot);
 }
 
 /* average[].galphotOffset, average[].Ngalphot are valid within an addstar run */
-int add_galp_link (Average *average, off_t *next_galp, off_t Ngalphot, off_t NGALPHOT) {
+int add_galphot_link (Average *average, off_t *next_galphot, off_t Ngalphot, off_t NGALPHOT) {
 
   off_t k, m;
 
-  /* if we have trouble, check validity of next_galp[m] : m < Ngalphot */
+  /* if we have trouble, check validity of next_galphot[m] : m < Ngalphot */
   m = average[0].galphotOffset;  
 
   for (k = 0; k < average[0].Ngalphot - 1; k++)  {
-    m = next_galp[m];
+    m = next_galphot[m];
     if (m >= NGALPHOT) {
       fprintf (stderr, "WARNING: m out of bounds (3)\n");
@@ -662 +820 @@
 
   /* set up references */
-  next_galp[Ngalphot] = -1;
+  next_galphot[Ngalphot] = -1;
   if (Ngalphot >= NGALPHOT) {
     fprintf (stderr, "WARNING: Ngalphot out of bounds (1)\n");
@@ -671 +829 @@
     average[0].galphotOffset = Ngalphot;
   } else {
-    next_galp[m] = Ngalphot;
+    next_galphot[m] = Ngalphot;
     if (m >= NGALPHOT) {
       fprintf (stderr, "WARNING: m out of bounds (4)\n");
@@ -680 +838 @@
 }
 
-GalPhot *sort_galphot (Average *average, off_t Naverage, GalPhot *galphot, off_t Ngalphot, off_t *next_galp) {
+GalPhot *sort_galphot (Average *average, off_t Naverage, GalPhot *galphot, off_t Ngalphot, off_t *next_galphot) {
 
   off_t i, k, n, np, N;
@@ -704 +862 @@
       tmpgalphot[N].averef = i;
       np = n;
-      n = next_galp[n];
+      n = next_galphot[n];
     }
   }