Changeset 4820 for trunk/archive/scripts/src/phase2/papPhase2.c

Timestamp:

Aug 18, 2005, 3:06:11 PM (21 years ago)

Author:

Paul Price

Message:

Constructing FPAs OK.

File:

• trunk/archive/scripts/src/phase2/papPhase2.c (modified) (26 diffs)

trunk/archive/scripts/src/phase2/papPhase2.c

@@ -1 +1 @@
 #include <stdio.h>
+#include <string.h>
+
 #include "pslib.h"
 #include "psAdditionals.h"
+
+#include "pmSubtractBias.h"
+
+#include "pmFPA.h"
+#include "pmConfig.h"
+#include "pmFPAConstruct.h"
 
 // Phase 2 needs to:
@@ -25 +33 @@
 // 
 // Most are self-explanatory.  "-chip" says "only work on this particular chip".
+
+
+#define RECIPE "PHASE2"                 // Name of the recipe to use
 
 static psMemoryId memPrintAlloc(const psMemBlock *mb)
@@ -44 +55 @@
     return 0;
 }
+static void memPrint(const psPtr ptr)
+{
+    psMemBlock *mb = ((psMemBlock*)ptr) - 1;
+    printf("Memory block %lld (%lld):\n"
+           "\tFile %s, line %d, size %d\n"
+           "\tPosts: %x %x %x\n",
+           mb->id, mb->refCounter, mb->file, mb->lineno, mb->userMemorySize, mb->startblock, mb->endblock,
+           *(void**)((int8_t *)(mb + 1) + mb->userMemorySize));
+}
 
 int main(int argc, char *argv[])
 {
-    psMemAllocateCallbackSetID(71);
-    psMemFreeCallbackSetID(71);
+#if 0
+    // Hunting memory leaks
+    psMemAllocateCallbackSetID(3539);
+    psMemFreeCallbackSetID(3539);
     psMemAllocateCallbackSet(memPrintAlloc);
     psMemFreeCallbackSet(memPrintFree);
-
-    psTraceSetLevel("psArgumentParse", 10);
+#endif
+
+//    psTraceSetLevel(".", 10);
 
     // Parse the configurations
@@ -58 +81 @@
     psMetadata *camera = NULL;          // Camera configuration
     psMetadata *recipe = NULL;          // Recipe configuration
-
-#if 0
-    if (! pmConfigRead(&site, &camera, &recipe, &argc, argv, "moduleName")) {
-        psErrorStackPrint("Can't find site configuration!\n");
+    if (! pmConfigRead(&site, &camera, &recipe, &argc, argv, RECIPE)) {
+        psErrorStackPrint(stderr, "Can't find site configuration!\n");
         exit(EXIT_FAILURE);
     }
-#endif
 
     // Parse other command-line arguments
@@ -73 +93 @@
     psMetadataAddStr(arguments, PS_LIST_TAIL, "-mask", "Name of the mask image", "");
     psMetadataAddS32(arguments, PS_LIST_TAIL, "-chip", "Chip number to process (if positive)", -1);
-
-    psMetadataAdd(arguments, PS_LIST_TAIL, "-string", PS_META_STR, "Test string", "SomeString");
-    psMetadataAdd(arguments, PS_LIST_TAIL, "-bool", PS_META_BOOL, "Test bool", false);
-#if 1
-    psMetadataAdd(arguments, PS_LIST_TAIL, "-int", PS_META_S32 | PS_META_DUPLICATE_OK, "Test integer 1", 1);
-    psMetadataAdd(arguments, PS_LIST_TAIL, "-int", PS_META_S32 | PS_META_DUPLICATE_OK, "Test integer 2", 2);
-    psMetadataAdd(arguments, PS_LIST_TAIL, "-int", PS_META_S32 | PS_META_DUPLICATE_OK, "Test integer 3", 3);
-#endif
-    psMetadataAdd(arguments, PS_LIST_TAIL, "-float", PS_META_F32, "Test float", 1.234567);
-
     if (! psArgumentParse(arguments, &argc, argv) || argc != 3) {
         printf("\nPan-STARRS Phase 2 processing\n\n");
@@ -92 +102 @@
     const char *inputName = argv[1];    // Name of input image
     const char *outputName = argv[2];   // Name of output image
-
-    printf("Success: %s %s\n", inputName, outputName);
-
     const char *biasName = psMetadataLookupString(NULL, arguments, "-bias"); // Name of bias image
     const char *darkName = psMetadataLookupString(NULL, arguments, "-dark"); // Name of dark image
@@ -100 +107 @@
     const char *maskName = psMetadataLookupString(NULL, arguments, "-mask"); // Name of mask image
     const int chipNum = psMetadataLookupS32(NULL, arguments, "-chip"); // Chip number to work on
+    printf("Input: %s\nOutput: %s\n", inputName, outputName);
     printf("Bias: %s\n", biasName);
     printf("Dark: %s\n", darkName);
@@ -105 +113 @@
     printf("Mask: %s\n", maskName);
     printf("Chip: %d\n", chipNum);
-
-    // For testing
-    psString string = psMetadataLookupString(NULL, arguments, "-string");
-    float floating = psMetadataLookupF32(NULL, arguments, "-float");
-    bool mdok = false;
-    bool boolean = psMetadataLookupBool(&mdok, arguments, "-bool");
-    if (!mdok) printf("Urgh!\n");
-    printf("String: %s\n", string);
-    printf("Float: %f\n", floating);
-    printf("Boolean: %d\n", boolean);
+    psFree(arguments);
+
+    // Open the input
+#ifdef PRODUCTION
+    psFits *inputFile = psFitsOpen(inputName, "r"); // File handle for FITS file
+#else
+    psFits *inputFile = psFitsAlloc(inputName); // File handle for FITS file
+#endif
+    if (! inputFile) {
+        psErrorStackPrint(stderr, "Can't open input image: %s\n", inputName);
+        exit(EXIT_FAILURE);
+    }
+    psMetadata *header = psFitsReadHeader(NULL, inputFile); // FITS header
+#if PRODUCTION
+    psDB *database = pmConfigDB(site);  // Database handle
+#else
+    psDB *database = NULL;              // Database handle
+#endif
 
 #if 0
-    psMetadataItem *intItem = psMetadataLookup(arguments, "-int");
-    if (intItem->type == PS_META_MULTI) {
-        psList *intMulti = intItem->data.V;
-        psListIterator *intIter = psListIteratorAlloc(intMulti, PS_LIST_HEAD, false);
-        psMetadataItem *intMultiItem = NULL;
-        while (intMultiItem = psListGetAndIncrement(intIter)) {
-            printf("Integer: %d\n", intMultiItem->data.S32);
-        }
-        psFree(intIter);
-    }
-#endif
-
-
-
-
-
-#if 0
-    // Open the input
-    psFits *inputFile = psFitsOpen(inputName, "r"); // File handle for FITS file
-    if (! inputFile) {
-        psErrorStackPrint("Can't open input image: %s\n", inputName);
-        exit(EXIT_FAILURE);
-    }
-    psMetadata *header = psFitsReadHeader(NULL, inputFile); // FITS header
-    psDB *database = pmConfigDB(site);  // Database handle
-
     // Open the output and output mask
     // We do it here so that we don't process the whole lot and then find out we can't open the output file
+#ifdef PRODUCTION
     psFits *outputFile = psFitsOpen(outputName, "w");
+#else
+    psFits *outputFile = psFitsAlloc(outputName);
+#endif
     if (! outputFile) {
-        psErrorStackPrint("Can't open output image: %s\n", outputName);
+        psErrorStackPrint(stderr, "Can't open output image: %s\n", outputName);
         exit(EXIT_FAILURE);
     }
     psString outputMaskName = psStringCopy(outputName);
-    (void)psStringAppend(outputMaskName, ".mask");
-    psFits *outputMaskFile = psFits(outputMaskName, "w");
+    (void)psStringAppend(&outputMaskName, ".mask");
+#ifdef PRODUCTION
+    psFits *outputMaskFile = psFitsOpen(outputMaskName, "w");
+#else
+    psFits *outputMaskFile = psFitsAlloc(outputMaskName);
+#endif
     if (! outputMaskFile) {
-        psErrorStackPrint("Can't open output mask image: %s\n", outputMaskName);
+        psErrorStackPrint(stderr, "Can't open output mask image: %s\n", outputMaskName);
         exit(EXIT_FAILURE);
     }
     psFree(outputMaskName);
+#endif
+
         
     // Get camera configuration from header if not already defined
@@ -163 +163 @@
         camera = pmConfigCameraFromHeader(site, header);
         if (! camera) {
-            psErrorStackPrint("Can't find camera configuration!\n");
-            exit(EXIT_FAILURE);
-        }
-    } else if (! pmConfigValidateCamera(camera, inputHeader)) {
-        psError("phase2", true, "%s does not seem to be from the camera.\n", inputName);
+            psErrorStackPrint(stderr, "Can't find camera configuration!\n");
+            exit(EXIT_FAILURE);
+        }
+   } else if (! pmConfigValidateCamera(camera, header)) {
+        psError(PS_ERR_IO, true, "%s does not seem to be from the camera.\n", inputName);
         exit(EXIT_FAILURE);
     }
-    if (! recipe && !(recipe = pmConfigRecipeFromCamera(camera, "moduleName"))) {
-        psErrorStackPrint("Can't find recipe configuration!\n");
+    if (! recipe && !(recipe = pmConfigRecipeFromCamera(camera, RECIPE))) {
+        psErrorStackPrint(stderr, "Can't find recipe configuration!\n");
         exit(EXIT_FAILURE);
     }
 
     // Construct camera in preparation for reading
-    pmFPA *input = pmFPAConstruct(camera, db);
-    pmFPA *mask = pmFPAConstruct(camera, db);
-    pmFPA *bias = pmFPAConstruct(camera, db);
-    pmFPA *dark = pmFPAConstruct(camera, db);
-    pmFPA *flat = pmFPAConstruct(camera, db);
+    pmFPA *input = pmFPAConstruct(camera, database);
+    pmFPA *mask = pmFPAConstruct(camera, database);
+    pmFPA *bias = pmFPAConstruct(camera, database);
+    pmFPA *dark = pmFPAConstruct(camera, database);
+    pmFPA *flat = pmFPAConstruct(camera, database);
 
     // Set various tasks
@@ -236 +236 @@
                      " assuming NONE.\n", mode);
         }
-        psFree(mode);
         psString fit = psMetadataLookupString(NULL, recipe, "OVERSCAN.FIT");
         if (strcasecmp(fit, "POLYNOMIAL") == 0) {
@@ -246 +245 @@
                      " assuming NONE.\n", fit);
         }
-        psFree(fit);
         overscanBins = psMetadataLookupS32(NULL, recipe, "OVERSCAN.BIN");
         if (overscanBins <= 0) {
-            psErrorStackPrint("OVERSCAN.BIN (%d) is non-positive --- assuming 1.\n", overscanBins);
+            psErrorStackPrint(stderr, "OVERSCAN.BIN (%d) is non-positive --- assuming 1.\n", overscanBins);
             overscanBins = 1;
         }
@@ -258 +256 @@
             overscanStats = psStatsAlloc(PS_STAT_SAMPLE_MEDIAN);
         } else {
-            psErrorStackPrint("OVERSCAN.STAT (%s) is not one of MEAN, MEDIAN: assuming MEAN\n", stat);
+            psErrorStackPrint(stderr, "OVERSCAN.STAT (%s) is not one of MEAN, MEDIAN: assuming MEAN\n", stat);
             overscanStats = psStatsAlloc(PS_STAT_SAMPLE_MEAN);      
         }
@@ -270 +268 @@
         }
     }
-         
+
+#if 0
     // Chip selection
     if (chipNum >= 0) {
@@ -276 +275 @@
             ! pmFPASelectChip(dark, chipNum) || ! pmFPASelectChip(flat, chipNum) ||
             ! pmFPASelectChip(mask, chipNum)) {
-            psErrorStackPrint("Chip number %d doesn't exist in camera.\n", chipNum);
+            psErrorStackPrint(stderr, "Chip number %d doesn't exist in camera.\n", chipNum);
             exit(EXIT_FAILURE);
         }
@@ -284 +283 @@
     // Read in the input pixels
     if (! pmFPARead(input, inputFile)) {
-        psErrorStackPrint("Unable to populate camera from FITS file: %s\n", inputName);
+        psErrorStackPrint(stderr, "Unable to populate camera from FITS file: %s\n", inputName);
         exit(EXIT_FAILURE);
     }
+#ifdef PRODUCTION
     psFitsClose(inputFile);
+#else
+    psFree(inputFile);
+#endif
+
 
     // Load the calibration frames, if required
@@ -299 +303 @@
         psFree(biasHeader);
         if (! pmFPARead(bias, biasFile)) {
-            psErrorStackPrint("Unable to populate bias camera from fits FITS: %s\n", biasName);
+            psErrorStackPrint(stderr, "Unable to populate bias camera from fits FITS: %s\n", biasName);
             exit(EXIT_FAILURE);
         }
@@ -314 +318 @@
         psFree(darkHeader);
         if (! pmFPARead(dark, darkFile)) {
-            psErrorStackPrint("Unable to populate dark camera from fits FITS: %s\n", darkName);
+            psErrorStackPrint(stderr, "Unable to populate dark camera from fits FITS: %s\n", darkName);
             exit(EXIT_FAILURE);
         }
@@ -329 +333 @@
         psFree(maskHeader);
         if (! pmFPARead(mask, maskFile)) {
-            psErrorStackPrint("Unable to populate mask camera from fits FITS: %s\n", maskName);
+            psErrorStackPrint(stderr, "Unable to populate mask camera from fits FITS: %s\n", maskName);
             exit(EXIT_FAILURE);
         }
@@ -344 +348 @@
         psFree(flatHeader);
         if (! pmFPARead(flat, flatFile)) {
-            psErrorStackPrint("Unable to populate flat camera from fits FITS: %s\n", flatName);
+            psErrorStackPrint(stderr, "Unable to populate flat camera from fits FITS: %s\n", flatName);
             exit(EXIT_FAILURE);
         }
@@ -414 +418 @@
                 darkTime = pmReadoutGetDarkTime(darkReadout);
                 if (darkTime <= 0.0) {
-                    psErrorStackPrint("DARKTIME for dark image (%f) is non-positive.\n", darkTime);
+                    psErrorStackPrint(stderr, "DARKTIME for dark image (%f) is non-positive.\n", darkTime);
                     exit(EXIT_FAILURE);
                 }
@@ -469 +473 @@
                             psLookupTable *table = psLookupTableAlloc(name, "%f %f", 0);
                             if (psLookupTableRead(table) <= 0) {
-                                psErrorStackPrint("Unable to read non-linearity correction file %s --- "
-                                                  "ignored\n", tableName);
+                                psErrorStackPrint(stderr, "Unable to read non-linearity correction file %s "
+                                                  "--- ignored\n", tableName);
                             } else {
                                 (void)pmNonLinearityLookup(inputReadout, table);
@@ -523 +527 @@
                                         psLookupTable *table = psLookupTableAlloc(tableName, "%f %f", 0);
                                         if ((int numLines = psLookupTableRead(table)) <= 0) {
-                                            psErrorStackPrint("Unable to read non-linearity correction "
-                                                              "file %s --- ignored\n", tableName);
+                                            psErrorStackPrint(stderr, "Unable to read non-linearity "
+                                                              "correction file %s --- ignored\n", tableName);
                                         } else {
                                             (void)pmNonLinearityLookup(inputReadout, table);
@@ -553 +557 @@
                     float inputTime = pmReadoutGetDarkTime(inputReadout); // Dark time for input image
                     if (inputTime <= 0) {
-                        psErrorStackPrint("DARKTIME for input image (%f) is non-positive.\n", inputTime);
+                        psErrorStackPrint(stderr, "DARKTIME for input image (%f) is non-positive.\n",
+                                          inputTime);
                         exit(EXIT_FAILURE);
                     }
@@ -583 +588 @@
                         overscanMode = PM_OVERSCAN_COLUMNS;
                     } else {
-                        psErrorStackPrint("CELL.READDIR (%d) is not 1 or 2 --- assuming 1.\n", readdir);
+                        psErrorStackPrint(stderr, "CELL.READDIR (%d) is not 1 or 2 --- assuming 1.\n",
+                                          readdir);
                         overscanMode = PM_OVERSCAN_ROWS;
                     }
@@ -655 +661 @@
     pmFPAWrite(outputFile, input);
     pmFPAWriteMask(outputMaskFile, input);
+#ifdef PRODUCTION
     psFitsClose(outputFile);
     psFitsClose(outputMaskFile);
-
+#else
+    psFree(outputFile);
+    psFree(outputMaskFile);
+#endif
+
+#endif
+
+    psFree(site);
+    psFree(header);
+    psFree(camera);
+    psFree(recipe);
     psFree(input);
     psFree(mask);
@@ -663 +680 @@
     psFree(dark);
     psFree(flat);
-
-#endif
-
-    
+    psFree(overscanStats);
+    psFree(inputFile);
+
+#if 1
     psMemCheckCorruption(true);
-    psFree(arguments);
     psMemBlock **leaks = NULL;          // List of leaks
     int nLeaks = psMemCheckLeaks(0, &leaks, NULL, false); // Number of leaks
     printf("%d leaks found.\n", nLeaks);
+#if 1
     for (int i = 0; i < nLeaks; i++) {
-        printf("Memory leak detection: memBlock %lld\n"
+        printf("Memory leak detection: memBlock %lld (%lld)\n"
                "\tFile %s, line %d, size %d\n",
-               leaks[i]->id, leaks[i]->file, leaks[i]->lineno, leaks[i]->userMemorySize);
-    }
+               leaks[i]->id, leaks[i]->refCounter, leaks[i]->file, leaks[i]->lineno,
+               leaks[i]->userMemorySize);
+    }
+#endif
+#endif
 
 }