Changeset 26879

Timestamp:

Feb 10, 2010, 4:24:46 PM (16 years ago)

Author:

eugene

Message:

updates from trunk

Location:

branches/eam_branches/20091201/psModules/src

Files:

• astrom/pmAstrometryWCS.c (modified) (7 diffs)
• camera/pmFPA.c (modified) (1 diff)
• camera/pmReadoutFake.c (modified) (3 diffs)
• camera/pmReadoutFake.h (modified) (1 diff)
• config/pmConfig.c (modified) (3 diffs)
• config/pmConfigCamera.c (modified) (7 diffs)
• config/pmConfigRun.c (modified) (1 diff)
• objects/pmSourceGroups.c (modified) (1 diff)
• objects/pmSourceIO.c (modified) (1 diff)

branches/eam_branches/20091201/psModules/src/astrom/pmAstrometryWCS.c

@@ -378 +378 @@
     // XXX make it optional to write out CDi_j terms, or other versions
     // apply CDELT1,2 (degrees / pixel) to yield PCi,j terms of order unity
-    if (!(wcs->wcsCDkeys)) {
+    if (!wcs->wcsCDkeys) { 
 
       double cdelt1 = wcs->cdelt1;
@@ -419 +419 @@
         psMetadataRemoveKey(header, "CD2_2");
       }
-    }
-    if (wcs->wcsCDkeys) {
+    } else {
 
       psMetadataAddF64 (header, PS_LIST_TAIL, "CD1_1", PS_META_REPLACE, "", wcs->trans->x->coeff[1][0]);
@@ -845 +844 @@
     int k=0;
     for (int j=0; j<nSamples; j++) {
-        double y = j * deltaY / nSamples;
+        double y = bounds->y0 + (j * deltaY / nSamples);
         for (int i=0; i<nSamples; i++) {
             psPlane *s = psPlaneAlloc();
-            s->x = i * deltaX / nSamples;
+            s->x = bounds->x0 + (i * deltaX / nSamples);
             s->y = y;
             psArraySet(src, k, s);
             psPlane *d = psPlaneTransformApply(NULL, trans, s);
             psArraySet(dst, k, d);
-            psFree(s);
+            psFree(s);  // drop our refs to s and d
             psFree(d);
             ++k;
@@ -869 +868 @@
     // compare the computed coordintes from this transform with the original
     psPlane *new = psPlaneAlloc();
+    printf("   i     chip_x  fpa_x     fpa_x_fit     dx         chip_y    fpa_y     fpa_y_fit     dy     dx > 0.5 || dy > 0.5\n");
     for (int i=0; i<psArrayLength(dst); i++) {
         psPlane *d = (psPlane *) psArrayGet(dst, i);
@@ -875 +875 @@
         new = psPlaneTransformApply(new, newTrans, s);
 
-        printf("%4d %f %f\n", i, 100.*(new->x - d->x)/d->x, 100.*(new->y - d->y)/d->y);
+        double xerr = new->x - d->x;
+        double yerr = new->y - d->y;
+        bool bigerr = (fabs(xerr) > .5) || (fabs(yerr) > .5);
+        printf("%4d %9.2f %9.2f %9.2f %9.2f     %9.2f %9.2f %9.2f %9.2f   %s\n"
+        , i, s->x, new->x, d->x, xerr, s->y, new->y, d->y, yerr, bigerr ? "BIGERR" : "");
     }
     psFree(new);
@@ -891 +895 @@
     psRegion    *chipBounds = pmChipPixels(chip);
 
-    psPlaneTransform *newToFPA = linearFitToTransform(chip->toFPA, chipBounds);
+#ifdef TESTING_CAMRUN_14728
+    chipBounds->y0 = 1874.;
+    chipBounds->x1 = 2387.;
+#endif
+
+    // First combine the chip to FPA and FPA to TPA into a single transformation
+    psPlaneTransform *chipToTPA = psPlaneTransformCombine(NULL, chip->toFPA, fpa->toTPA, *chipBounds, 50);
+    if (!chipToTPA) {
+        psFree(chipBounds);
+        psError(PS_ERR_UNKNOWN, false, "failed to create chipToTPA");
+        return false;
+    }
+
+    // Next do a linear fit
+    psPlaneTransform *newToFPA = linearFitToTransform(chipToTPA, chipBounds);
+    psFree(chipToTPA);
     if (!newToFPA) {
         psFree(chipBounds);
-        psError(PS_ERR_UNKNOWN, false, "linear fit for toFPA failed");
-        return false;
-    }
+        psError(PS_ERR_UNKNOWN, false, "linear fit of chip to TPA transform failed");
+        return false;
+    }
+
+    psPlaneTransform *newFromFPA = psPlaneTransformInvert(NULL, newToFPA, *chipBounds, 50);
+    psFree(chipBounds);
+    if (!newFromFPA) {
+        psFree(newToFPA);
+        psError(PS_ERR_UNKNOWN, false, "inversion of fit of chip to TPA transform failed");
+        return false;
+    }
+
+    // Success. Now set the fpa's toTPA and fromTPA to identity and replace the chip's transforms.
+
+    psPlaneTransform *newToTPA   = psPlaneTransformIdentity(1);
+    psFree(fpa->toTPA);
+    fpa->toTPA = newToTPA;
+
+    psPlaneTransform *newFromTPA = psPlaneTransformIdentity(1);
+    psFree(fpa->fromTPA);
+    fpa->fromTPA = newFromTPA;
 
     psFree(chip->toFPA);
@@ -902 +939 @@
 
     psFree(chip->fromFPA);
-    chip->fromFPA = psPlaneTransformInvert(NULL, chip->toFPA, *chipBounds, 50);
-    if (!chip->fromFPA) {
-        psError(PS_ERR_UNKNOWN, false, "failed to invert linear fit for toFPA");
-        return false;
-    }
-
-    psPlane *chip0 = psPlaneAlloc();
-    chip0->x = 0;
-    chip0->y = 0;
-    psPlane *chip1 = psPlaneAlloc();
-    chip1->x = chipBounds->x1;
-    chip1->y = chipBounds->y1;
-
-    // compute bounding region for fpa
-    psPlane *fpa0 = psPlaneTransformApply(NULL, newToFPA, chip0);
-    psPlane *fpa1 = psPlaneTransformApply(NULL, newToFPA, chip1);
-
-    psRegion *fpaBounds = psRegionAlloc(fpa0->x, fpa1->x, fpa0->y, fpa1->y);
-    psFree(chip0);
-    psFree(chip1);
-    psFree(fpa0);
-    psFree(fpa1);
-
-    psPlaneTransform *newToTPA = linearFitToTransform(fpa->toTPA, fpaBounds);
-    if (!newToTPA) {
-        psError(PS_ERR_UNKNOWN, false, "failed to perform linear fit to toTPA");
-        psFree(fpaBounds);
-        return false;
-    }
-    psFree(fpa->toTPA);
-    fpa->toTPA = newToTPA;
-
-    // XXX: is this region ok?
-    psFree(fpa->fromTPA);
-    fpa->fromTPA = psPlaneTransformInvert(NULL, fpa->toTPA, *fpaBounds, 50);
-    if (!fpa->fromTPA) {
-        psError(PS_ERR_UNKNOWN, false, "failed to invert linear fit to toTPA");
-        return false;
-    }
-
+    chip->fromFPA = newFromFPA;
+
+    // Finally change the type for the projection.
     fpa->toSky->type = PS_PROJ_TAN;
-
-    psFree(chipBounds);
-    psFree(fpaBounds);
 
     return true;

branches/eam_branches/20091201/psModules/src/camera/pmFPA.c

@@ -378 +378 @@
     tmpFPA->toTPA = NULL;
     tmpFPA->toSky = NULL;
+    tmpFPA->wcsCDkeys = false;
 
     tmpFPA->analysis = psMetadataAlloc();

branches/eam_branches/20091201/psModules/src/camera/pmReadoutFake.c

@@ -23 +23 @@
 #include "pmSourceUtils.h"
 #include "pmModelUtils.h"
+#include "pmSourceGroups.h"
 
 #include "pmReadoutFake.h"
 
-#define MODEL_TYPE "PS_MODEL_RGAUSS"    // Type of model to use
 #define MAX_AXIS_RATIO 20.0             // Maximum axis ratio for PSF model
 #define MODEL_MASK (PM_MODEL_STATUS_NONCONVERGE | PM_MODEL_STATUS_OFFIMAGE | \
                     PM_MODEL_STATUS_BADARGS | PM_MODEL_STATUS_LIMITS) // Mask to apply to models
+
+
+static bool threaded = false;           // Running threaded?
+
+
 
 
@@ -47 +52 @@
     }
     return pmPSF_AxesToModel(params, axes);
+}
+
+/// Generate fake sources on a readout
+static bool readoutFake(pmReadout *readout, // Readout of interest
+                        const pmSourceGroups *groups, // Source groups
+                        const psVector *x,        // x coordinates
+                        const psVector *y,        // y coordinates
+                        const psVector *mag,      // Magnitudes
+                        const psVector *xOffset,  // Offsets in x
+                        const psVector *yOffset,  // Offsets in y
+                        const pmPSF *psf,         // PSF
+                        float minFlux,            // Minimum flux
+                        float radius,             // Minimum radius
+                        bool circularise,         // Circularise PSF?
+                        bool normalisePeak,       // Normalise sources for peak?
+                        int groupIndex,           // Group index
+                        int cellIndex             // Cell index
+                        )
+{
+    psArray *cells = groups->groups->data[groupIndex]; // Cells in group
+    psVector *cellSources = cells->data[cellIndex];    // Sources in cell
+
+    for (int i = 0; i < cellSources->n; i++) {
+        int index = cellSources->data.S32[i];                       // Index for source of interest
+        float flux = powf(10.0, -0.4 * mag->data.F32[index]);       // Flux of source
+        float xSrc = x->data.F32[index], ySrc = y->data.F32[index]; // Coordinates of source
+
+        if (normalisePeak) {
+            // Normalise flux
+            pmModel *normModel = pmModelFromPSFforXY(psf, xSrc, ySrc, 1.0); // Model for normalisation
+            if (!normModel || (normModel->flags & MODEL_MASK)) {
+                psFree(normModel);
+                continue;
+            }
+            // check that all params are valid:
+            bool validParams = true;
+            for (int j = 0; validParams && (j < normModel->params->n); j++) {
+                switch (j) {
+                  case PM_PAR_SKY:
+                  case PM_PAR_I0:
+                  case PM_PAR_XPOS:
+                  case PM_PAR_YPOS:
+                    continue;
+                  default:
+                    if (!isfinite(normModel->params->data.F32[j])) {
+                        validParams = false;
+                    }
+                }
+            }
+            if (!validParams) {
+                psFree(normModel);
+                continue;
+            }
+            if (circularise && !circulariseModel(normModel)) {
+                psError(PS_ERR_UNKNOWN, false, "Unable to circularise PSF model.");
+                psFree(normModel);
+                return false;
+            }
+
+            flux /= normModel->modelFlux(normModel->params);
+            psFree(normModel);
+        }
+
+        pmModel *fakeModel = pmModelFromPSFforXY(psf, xSrc, ySrc, flux);
+        if (!fakeModel || (fakeModel->flags & MODEL_MASK)) {
+            psFree(fakeModel);
+            continue;
+        }
+        // check that all params are valid:
+        bool validParams = true;
+        for (int j = 0; validParams && (j < fakeModel->params->n); j++) {
+            switch (j) {
+              case PM_PAR_SKY:
+              case PM_PAR_I0:
+              case PM_PAR_XPOS:
+              case PM_PAR_YPOS:
+                continue;
+              default:
+                if (!isfinite(fakeModel->params->data.F32[j])) {
+                    validParams = false;
+                }
+            }
+        }
+        if (!validParams) {
+            psFree(fakeModel);
+            continue;
+        }
+        if (circularise && !circulariseModel(fakeModel)) {
+            psError(PS_ERR_UNKNOWN, false, "Unable to circularise PSF model.");
+            psFree(fakeModel);
+            return false;
+        }
+
+        psTrace("psModules.camera", 10, "Adding source at %f,%f with flux %f\n",
+                fakeModel->params->data.F32[PM_PAR_XPOS], fakeModel->params->data.F32[PM_PAR_YPOS],
+                fakeModel->params->data.F32[PM_PAR_I0]);
+
+        pmSource *fakeSource = pmSourceAlloc(); // Fake source to generate
+        fakeSource->peak = pmPeakAlloc(xSrc, ySrc, fakeModel->params->data.F32[PM_PAR_I0], PM_PEAK_LONE);
+        float fakeRadius = 1.0;         // Radius of fake source
+        if (isfinite(minFlux)) {
+            fakeRadius = PS_MAX(fakeRadius, fakeModel->modelRadius(fakeModel->params, minFlux));
+        }
+        if (radius > 0) {
+            fakeRadius = PS_MAX(fakeRadius, radius);
+        }
+
+        if (xOffset) {
+            if (!pmSourceDefinePixels(fakeSource, readout, xSrc + xOffset->data.S32[index],
+                                      ySrc + yOffset->data.S32[index], fakeRadius)) {
+                psErrorClear();
+                continue;
+            }
+            if (!pmModelAddWithOffset(fakeSource->pixels, NULL, fakeModel, PM_MODEL_OP_FULL, 0,
+                                      xOffset->data.S32[index], yOffset->data.S32[index])) {
+                psErrorClear();
+                continue;
+            }
+        } else {
+            if (!pmSourceDefinePixels(fakeSource, readout, xSrc, ySrc, fakeRadius)) {
+                psErrorClear();
+                continue;
+            }
+            if (!pmModelAdd(fakeSource->pixels, NULL, fakeModel, PM_MODEL_OP_FULL, 0)) {
+                psErrorClear();
+                continue;
+            }
+        }
+        psFree(fakeSource);
+        psFree(fakeModel);
+    }
+
+    return true;
+}
+
+/// Thread job for readoutFake()
+static bool readoutFakeThread(psThreadJob *job)
+{
+    PS_ASSERT_THREAD_JOB_NON_NULL(job, false);
+
+    psArray *args = job->args;          // Arguments
+
+    pmReadout *readout = args->data[0];     // Readout of interest
+    const pmSourceGroups *groups = args->data[1]; // Source groups
+    const psVector *x = args->data[2];        // x coordinates
+    const psVector *y = args->data[3];        // y coordinates
+    const psVector *mag = args->data[4];      // Magnitudes
+    const psVector *xOffset = args->data[5];  // Offsets in x
+    const psVector *yOffset = args->data[6];  // Offsets in y
+    const pmPSF *psf = args->data[7];         // PSF
+    float minFlux = PS_SCALAR_VALUE(args->data[8], F32); // Minimum flux
+    float radius = PS_SCALAR_VALUE(args->data[9], F32);  // Minimum radius
+    bool circularise = PS_SCALAR_VALUE(args->data[10], U8); // Circularise PSF?
+    bool normalisePeak = PS_SCALAR_VALUE(args->data[11], U8); // Normalise for peak?
+    int groupIndex = PS_SCALAR_VALUE(args->data[12], S32); // Group index
+    int cellIndex = PS_SCALAR_VALUE(args->data[13], S32);  // Cell index
+
+    return readoutFake(readout, groups, x, y, mag, xOffset, yOffset, psf, minFlux, radius, circularise,
+                       normalisePeak, groupIndex, cellIndex);
+}
+
+
+bool pmReadoutFakeThreads(bool new)
+{
+    bool old = threaded;                // Old status, to return
+
+    if (!old && new) {
+        threaded = true;
+
+        {
+            psThreadTask *task = psThreadTaskAlloc("PSMODULES_READOUT_FAKE", 14);
+            task->function = &readoutFakeThread;
+            psThreadTaskAdd(task);
+            psFree(task);
+        }
+
+    } else if (old && !new) {
+        threaded = false;
+        psThreadTaskRemove("PSMODULES_READOUT_FAKE");
+    }
+
+    return old;
 }
 
@@ -86 +273 @@
     psImageInit(readout->image, 0);
 
-    for (long i = 0; i < numSources; i++) {
-        float flux = powf(10.0, -0.4 * mag->data.F32[i]); // Flux of source
-        float xSrc = x->data.F32[i], ySrc = y->data.F32[i]; // Coordinates of source
-
-        if (normalisePeak) {
-            // Normalise flux
-            pmModel *normModel = pmModelFromPSFforXY(psf, xSrc, ySrc, 1.0); // Model for normalisation
-            if (!normModel || (normModel->flags & MODEL_MASK)) {
-                psFree(normModel);
-                continue;
-            }
-            // check that all params are valid:
-            bool validParams = true;
-            for (int n = 0; validParams && (n < normModel->params->n); n++) {
-                if (n == PM_PAR_SKY) continue;
-                if (n == PM_PAR_I0) continue;
-                if (n == PM_PAR_XPOS) continue;
-                if (n == PM_PAR_YPOS) continue;
-                if (!isfinite(normModel->params->data.F32[n])) validParams = false;
-            }
-            if (!validParams) {
-                psFree(normModel);
-                continue;
-            }           
-            if (circularise && !circulariseModel(normModel)) {
-                psError(PS_ERR_UNKNOWN, false, "Unable to circularise PSF model.");
-                psFree(normModel);
+    int numThreads = threaded ? psThreadPoolSize() : 0; // Number of threads
+    pmSourceGroups *groups = pmSourceGroupsFromVectors(readout, x, y, numThreads); // Groups of sources
+    if (!groups) {
+        psError(PS_ERR_UNKNOWN, false, "Unable to generate source groups");
+        return false;
+    }
+
+    if (threaded) {
+        for (int i = 0; i < groups->groups->n; i++) {
+            psArray *cells = groups->groups->data[i]; // Cell with sources
+            for (int j = 0; j < cells->n; j++) {
+                psThreadJob *job = psThreadJobAlloc("PSMODULES_READOUT_FAKE");
+                psArray *args = job->args;
+                psArrayAdd(args, 1, readout);
+                psArrayAdd(args, 1, groups);
+                // Casting away const to add to array
+                psArrayAdd(args, 1, (psVector*)x);
+                psArrayAdd(args, 1, (psVector*)y);
+                psArrayAdd(args, 1, (psVector*)mag);
+                psArrayAdd(args, 1, (psVector*)xOffset);
+                psArrayAdd(args, 1, (psVector*)yOffset);
+                psArrayAdd(args, 1, (pmPSF*)psf);
+                PS_ARRAY_ADD_SCALAR(args, minFlux, PS_TYPE_F32);
+                PS_ARRAY_ADD_SCALAR(args, radius, PS_TYPE_S32);
+                PS_ARRAY_ADD_SCALAR(args, circularise, PS_TYPE_U8);
+                PS_ARRAY_ADD_SCALAR(args, normalisePeak, PS_TYPE_U8);
+                PS_ARRAY_ADD_SCALAR(args, i, PS_TYPE_S32);
+                PS_ARRAY_ADD_SCALAR(args, j, PS_TYPE_S32);
+
+                if (!psThreadJobAddPending(job)) {
+                    psFree(job);
+                    psFree(groups);
+                    return false;
+                }
+                psFree(job);
+            }
+            if (!psThreadPoolWait(true)) {
+                psError(PS_ERR_UNKNOWN, false, "Error waiting for threads.");
+                psFree(groups);
                 return false;
             }
-
-            flux /= normModel->modelFlux(normModel->params);
-            psFree(normModel);
-        }
-
-        pmModel *fakeModel = pmModelFromPSFforXY(psf, xSrc, ySrc, flux);
-        if (!fakeModel || (fakeModel->flags & MODEL_MASK)) {
-            psFree(fakeModel);
-            continue;
-        }
-        // check that all params are valid:
-        bool validParams = true;
-        for (int n = 0; validParams && (n < fakeModel->params->n); n++) {
-            if (n == PM_PAR_SKY) continue;
-            if (n == PM_PAR_I0) continue;
-            if (n == PM_PAR_XPOS) continue;
-            if (n == PM_PAR_YPOS) continue;
-            if (!isfinite(fakeModel->params->data.F32[n])) validParams = false;
-        }
-        if (!validParams) {
-            psFree(fakeModel);
-            continue;
-        }               
-        if (circularise && !circulariseModel(fakeModel)) {
-            psError(PS_ERR_UNKNOWN, false, "Unable to circularise PSF model.");
-            psFree(fakeModel);
-            return false;
-        }
-
-        psTrace("psModules.camera", 10, "Adding source at %f,%f with flux %f\n",
-                fakeModel->params->data.F32[PM_PAR_XPOS], fakeModel->params->data.F32[PM_PAR_YPOS],
-                fakeModel->params->data.F32[PM_PAR_I0]);
-
-        pmSource *fakeSource = pmSourceAlloc(); // Fake source to generate
-        fakeSource->peak = pmPeakAlloc(xSrc, ySrc, fakeModel->params->data.F32[PM_PAR_I0], PM_PEAK_LONE);
-        float fakeRadius = 1.0;         // Radius of fake source
-        if (isfinite(minFlux)) {
-            fakeRadius = PS_MAX(fakeRadius, fakeModel->modelRadius(fakeModel->params, minFlux));
-        }
-        if (radius > 0) {
-            fakeRadius = PS_MAX(fakeRadius, radius);
-        }
-
-        if (xOffset) {
-            if (!pmSourceDefinePixels(fakeSource, readout, xSrc + xOffset->data.S32[i],
-                                      ySrc + yOffset->data.S32[i], fakeRadius)) {
-                psErrorClear();
-                continue;
-            }
-            if (!pmModelAddWithOffset(fakeSource->pixels, NULL, fakeModel, PM_MODEL_OP_FULL, 0,
-                                      xOffset->data.S32[i], yOffset->data.S32[i])) {
-                psErrorClear();
-                continue;
-            }
-        } else {
-            if (!pmSourceDefinePixels(fakeSource, readout, xSrc, ySrc, fakeRadius)) {
-                psErrorClear();
-                continue;
-            }
-            if (!pmModelAdd(fakeSource->pixels, NULL, fakeModel, PM_MODEL_OP_FULL, 0)) {
-                psErrorClear();
-                continue;
-            }
-        }
-        psFree(fakeSource);
-        psFree(fakeModel);
+        }
+    } else if (!readoutFake(readout, groups, x, y, mag, xOffset, yOffset, psf, minFlux, radius, circularise,
+                            normalisePeak, 0, 0)) {
+        psError(PS_ERR_UNKNOWN, false, "Unable to generate fake sources on readout");
+        psFree(groups);
+        return false;
+    }
+
+    psFree(groups);
+
+// Set a concept value
+#define CONCEPT_SET_S32(CONCEPTS, NAME, OLD, NEW) { \
+        psMetadataItem *item = psMetadataLookup(CONCEPTS, NAME); \
+        psAssert(item->type == PS_TYPE_S32, "Incorrect type: %x", item->type); \
+        if (item->data.S32 == OLD) { \
+            item->data.S32 = NEW; \
+        } \
+    }
+
+    if (readout->parent) {
+        CONCEPT_SET_S32(readout->parent->concepts, "CELL.XPARITY", 0, 1);
+        CONCEPT_SET_S32(readout->parent->concepts, "CELL.YPARITY", 0, 1);
+        CONCEPT_SET_S32(readout->parent->concepts, "CELL.XBIN", 0, 1);
+        CONCEPT_SET_S32(readout->parent->concepts, "CELL.YBIN", 0, 1);
     }
 
     return true;
+
 }
 

branches/eam_branches/20091201/psModules/src/camera/pmReadoutFake.h

@@ -12 +12 @@
 #include <pmPSF.h>
 #include <pmSourceMasks.h>
+
+/// Set threading
+///
+/// Returns old threading state
+bool pmReadoutFakeThreads(
+    bool new                            // New threading state
+    );
 
 /// Generate a fake readout from vectors

branches/eam_branches/20091201/psModules/src/config/pmConfig.c

@@ -47 +47 @@
 
 static bool checkPath(const char *filename, bool create, bool trunc);
+static psString resolveConfigFile(const char *name);
 
 bool pmConfigReadParamsSet(bool newReadCameraConfig)
@@ -447 +448 @@
             psWarning("-ipprc command-line switch provided without the required filename --- ignored.\n");
         } else {
-            configFile = psStringCopy(argv[argNum]);
+            configFile = resolveConfigFile(argv[argNum]);
             psArgumentRemove(argNum, argc, argv);
         }
@@ -1834 +1835 @@
     return false;
 }
+
+static psString resolveConfigFile(const char *nameArg)
+{
+    // if config file name is nebulous path resolve it
+    // otherwise just return a copy of the argument
+    if (strncasecmp(nameArg, "neb://", strlen("neb://"))) {
+        return psStringCopy(nameArg);
+    }
+
+#ifdef HAVE_NEBCLIENT
+    char *neb_server = getenv("NEB_SERVER");
+
+    // if env isn't set, check the config system
+    if (!neb_server) {
+        psError(PM_ERR_CONFIG, true, "NEB_SERVER environment variable must be set in order to resolve config file.");
+            return NULL;
+    }
+
+    nebServer *server = nebServerAlloc(neb_server);
+    if (!server) {
+        psError(PM_ERR_SYS, true, "failed to create a nebServer object.");
+        return NULL;
+    }
+
+    char *nebfile = nebFind(server, nameArg);
+    nebServerFree(server);
+    if (!nebfile) {
+        // object does not exist
+        psError(PM_ERR_SYS, true, "failed to resolve nebulous path: %s.", nameArg);
+        return NULL;
+    }
+    // XXX: do I need to free nebfile?
+
+    return psStringCopy(nebfile);
+#else
+    psError(PM_ERR_PROG, true, "psModules was compiled without nebulous support.");
+    return NULL;
+#endif // ifdef HAVE_NEBCLIENT
+}

branches/eam_branches/20091201/psModules/src/config/pmConfigCamera.c

@@ -149 +149 @@
     camerasIter = psMetadataIteratorAlloc(new, PS_LIST_HEAD, NULL); // Iterator
     while ((camerasItem = psMetadataGetAndIncrement(camerasIter))) {
-        psMetadataAddItem(cameras, camerasItem, PS_LIST_HEAD, 0);
+        psMetadataAddItem(cameras, camerasItem, PS_LIST_HEAD, PS_META_REPLACE);
     }
     psFree(camerasIter);
@@ -210 +210 @@
 
     // See if the new one is already there
-    psString newName = NULL;       // Name of skycelled camera
-    psStringAppend(&newName, "_%s-SKYCELL", name);
-    if (psMetadataLookup(oldCameras, newName)) {
+    psString newName = pmConfigCameraSkycellName(name); // Name of skycelled camera
+    bool mdok;                       // Status of MD lookup
+    psMetadata *oldCam = psMetadataLookupMetadata(&mdok, oldCameras, newName); // Existing camera configuration
+    if (mdok && oldCam) {
+        // Ensure new camera goes to the head of the metadata, so that it will be recognised first
+        // The old camera doesn't contain the PSMOSAIC header, so it will match anything!
+        psTrace("psModules.config", 6, "Camera configuration for %s exists, so moving to the front.", newName);
+        psMetadataAddMetadata(newCameras, PS_LIST_HEAD, newName, PS_META_REPLACE, NULL, oldCam);
         psFree(newName);
         return true;
@@ -366 +371 @@
     // New camera MUST go to the head of the metadata, so that it will be recognised first
     // The old camera doesn't contain the PSCAMERA and PSFORMAT headers, so it will match anything!
+    psTrace("psModules.config", 6, "Generated new camera configuration for %s.", newName);
     psMetadataAddMetadata(newCameras, PS_LIST_HEAD, newName, PS_META_REPLACE,
                           "Automatically generated", new);
@@ -436 +442 @@
     camerasIter = psMetadataIteratorAlloc(new, PS_LIST_HEAD, NULL); // Iterator
     while ((camerasItem = psMetadataGetAndIncrement(camerasIter))) {
-        psMetadataAddItem(cameras, camerasItem, PS_LIST_HEAD, 0);
+        psMetadataAddItem(cameras, camerasItem, PS_LIST_HEAD, PS_META_REPLACE);
     }
     psFree(camerasIter);
@@ -469 +475 @@
 
     // See if the new one is already there
-    psString newName = NULL;       // Name of mosaicked camera
-    psStringAppend(&newName, "_%s-%s", name, mosaicLevel == PM_FPA_LEVEL_CHIP ? "CHIP" : "FPA");
-    if (psMetadataLookup(oldCameras, newName)) {
+    psString newName = mosaicLevel == PM_FPA_LEVEL_CHIP ? pmConfigCameraChipName(name) :
+        pmConfigCameraFPAName(name); // Name of mosaicked camera
+    bool mdok;                       // Status of MD lookup
+    psMetadata *oldCam = psMetadataLookupMetadata(&mdok, oldCameras, newName); // Existing camera configuration
+    if (mdok && oldCam) {
+        // Ensure new camera goes to the head of the metadata, so that it will be recognised first
+        // The old camera doesn't contain the PSMOSAIC header, so it will match anything!
+        psTrace("psModules.config", 6, "Camera configuration for %s exists, so moving to the front.", newName);
+        psMetadataAddMetadata(newCameras, PS_LIST_HEAD, newName, PS_META_REPLACE, NULL, oldCam);
         psFree(newName);
         return true;
@@ -477 +489 @@
 
     psMetadata *new = psMetadataCopy(NULL, camera); // Copy of the camera description
-    bool mdok;                          // Status of MD lookups
 
     // ** Fix up the contents of the FPA description to match the mosaicked camera **
@@ -849 +860 @@
     // New camera MUST go to the head of the metadata, so that it will be recognised first
     // The old camera doesn't contain the PSMOSAIC header, so it will match anything!
+    psTrace("psModules.config", 6, "Generated new camera configuration for %s.", newName);
     psMetadataAddMetadata(newCameras, PS_LIST_HEAD, newName, PS_META_REPLACE,
                           "Automatically generated", new);

branches/eam_branches/20091201/psModules/src/config/pmConfigRun.c

@@ -160 +160 @@
     psArray *files = configRunFileGet(config, name, "FILES.INPUT"); // Files from RUN metadata
     if (!files) {
-        configRunFileGet(config, name, "FILES.OUTPUT");
+        files = configRunFileGet(config, name, "FILES.OUTPUT");
     }
 

branches/eam_branches/20091201/psModules/src/objects/pmSourceGroups.c

@@ -186 +186 @@
             cellSources->data.S32[i] = i;
         }
+        cellSources->n = numSources;
     } else {
         for (int i = 0; i < numSources; i++) {

branches/eam_branches/20091201/psModules/src/objects/pmSourceIO.c

@@ -960 +960 @@
         if (hdu->header == NULL) {
             // if the IMAGE header does not exist, we have no data for this view
-            if (!psFitsMoveExtName (file->fits, headname)) {
+            if (!psFitsMoveExtNameClean (file->fits, headname)) {
                 readout->data_exists = false;
                 psFree (headname);