IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 41510


Ignore:
Timestamp:
Mar 3, 2021, 3:05:40 PM (5 years ago)
Author:
eugene
Message:

plug various leaks

Location:
trunk/pswarp/src
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/pswarp/src/pswarpCleanup.c

    r37053 r41510  
    1414// Lists of file rules which we may need to save here
    1515static char *outputFiles[] = {
    16   "PSWARP.OUTPUT",
    17   "PSWARP.OUTPUT.MASK",
    18   "PSWARP.OUTPUT.VARIANCE",
    19   "PSWARP.OUTPUT.BKGMODEL",
    20   "PSWARP.OUTPUT.SOURCES",
    21   "PSPHOT.OUTPUT",
    22   "PSPHOT.RESID",
    23   "PSPHOT.BACKMDL",
    24   "PSPHOT.BACKMDL.STDEV",
    25   "PSPHOT.BACKGND",
    26   "PSPHOT.BACKSUB",
    27   "PSPHOT.PSF.SAVE",
    28   "SOURCE.PLOT.MOMENTS",
    29   "SOURCE.PLOT.PSFMODEL",
    30   "SOURCE.PLOT.APRESID",
    31   NULL
     16    "PSWARP.OUTPUT",
     17    "PSWARP.OUTPUT.MASK",
     18    "PSWARP.OUTPUT.VARIANCE",
     19    "PSWARP.OUTPUT.BKGMODEL",
     20    "PSWARP.OUTPUT.SOURCES",
     21    "PSPHOT.OUTPUT",
     22    "PSPHOT.RESID",
     23    "PSPHOT.BACKMDL",
     24    "PSPHOT.BACKMDL.STDEV",
     25    "PSPHOT.BACKGND",
     26    "PSPHOT.BACKSUB",
     27    "PSPHOT.PSF.SAVE",
     28    "SOURCE.PLOT.MOMENTS",
     29    "SOURCE.PLOT.PSFMODEL",
     30    "SOURCE.PLOT.APRESID",
     31    NULL
    3232};
    3333
    … …  
    5353        psError(psErrorCodeLast(), false, "Unable to read files.");
    5454        pmFPAfileFreeSetStrict(false);
     55        psFree(view);
    5556        goto DONE;
    5657    }
    … …  
    6364            psError(psErrorCodeLast(), false, "Unable to read files.");
    6465            pmFPAfileFreeSetStrict(false);
     66            psFree(view);
    6567            goto DONE;
    6668        }
    … …  
    7375                psError(psErrorCodeLast(), false, "Unable to read files.");
    7476                pmFPAfileFreeSetStrict(false);
     77                psFree(view);
    7578                goto DONE;
    7679            }
    … …  
    7982            psError(psErrorCodeLast(), false, "Unable to write files.");
    8083            pmFPAfileFreeSetStrict(false);
     84            psFree(view);
    8185            goto DONE;
    8286        }
    … …  
    8589        psError(psErrorCodeLast(), false, "Unable to write files.");
    8690        pmFPAfileFreeSetStrict(false);
     91        psFree(view);
    8792        goto DONE;
    8893    }
    … …  
    116121    psLibFinalize();
    117122
     123    psMemBlock **memblocks;
     124    int Nleaks = psMemCheckLeaks (0, &memblocks, stderr, false);
     125    fprintf (stderr, "Found %d leaks at %s\n", Nleaks, "ppImage");
     126
    118127DONE:
    119128    exitValue = pswarpExitCode(exitValue);

  • trunk/pswarp/src/pswarpDefineLayout.c

    r35684 r41510  
    8282        pswarpBounds *srcBounds = pswarpMakeBounds (input->fpa, frame);
    8383        pswarpBounds *tgtBounds = pswarpMakeBounds (skycell->fpa, frame);
     84
     85        psFree (frame);
    8486
    8587        // find the output (tgt) chips which overlap the input (src) chips

  • trunk/pswarp/src/pswarpLoop.c

    r41396 r41510  
    221221        }
    222222    }
     223    psFree (view);
    223224    return true;
    224225}

  • trunk/pswarp/src/pswarpLoopBackground.c

    r40354 r41510  
    5555    if (!status) {
    5656        psError(PSWARP_ERR_DATA, true, "number of inputs is not defined (programming error)");
     57        psFree (view);
    5758        return false;
    5859    }
    … …  
    9091        pmFPAviewReset (view);
    9192
    92         pmFPAview *view = pmFPAviewAlloc(0);
    93         if (!pmFPAfileIOChecks(config, view, PM_FPA_BEFORE)) {
     93        pmFPAview *viewT2 = pmFPAviewAlloc(0);
     94        if (!pmFPAfileIOChecks(config, viewT2, PM_FPA_BEFORE)) {
    9495            psError(psErrorCodeLast(), false, "Unable to read files.");
     96            psFree (viewT2);
    9597            goto FAIL;
    9698        }
    9799
    98100        pmChip *chip;
    99         while ((chip = pmFPAviewNextChip (view, input->fpa, 1)) != NULL) {
     101        while ((chip = pmFPAviewNextChip (viewT2, input->fpa, 1)) != NULL) {
    100102            if (!chip->process || !chip->file_exists) { continue; }
    101             if (!pmFPAfileIOChecks(config, view, PM_FPA_BEFORE)) {
     103            if (!pmFPAfileIOChecks(config, viewT2, PM_FPA_BEFORE)) {
    102104                psError(psErrorCodeLast(), false, "Unable to read files.");
     105                psFree (viewT2);
    103106                goto FAIL;
    104107            }
    … …  
    107110            double xBin = NAN;
    108111            double yBin = NAN;
    109             pswarpGetInputScales (&xBin, &yBin, config, view, chip);
     112            pswarpGetInputScales (&xBin, &yBin, config, viewT2, chip);
    110113            double fluxRatio = xBin * yBin / (float) (xGrid * yGrid);
    111114           
    112             if (!pswarpModifyChipAstrom (config, view, chip, astrom, bilevelAstrometry, xBin, yBin)) {
     115            if (!pswarpModifyChipAstrom (config, viewT2, chip, astrom, bilevelAstrometry, xBin, yBin)) {
    113116                psError(psErrorCodeLast(), false, "failed to set BKGMODEL astrometry.");
     117                psFree (viewT2);
    114118                goto FAIL;
    115119            }
    116120
    117121            pmCell *cell;
    118             while ((cell = pmFPAviewNextCell (view, input->fpa, 1)) != NULL) {
    119                 psTrace ("pswarp", 4, "ACell %d: %x %x %d\n", view->cell, cell->file_exists, cell->process,psErrorCodeLast());
     122            while ((cell = pmFPAviewNextCell (viewT2, input->fpa, 1)) != NULL) {
     123                psTrace ("pswarp", 4, "ACell %d: %x %x %d\n", viewT2->cell, cell->file_exists, cell->process,psErrorCodeLast());
    120124                if (!cell->process || !cell->file_exists) { continue; }
    121                 if (!pmFPAfileIOChecks (config, view, PM_FPA_BEFORE)) {
     125                if (!pmFPAfileIOChecks (config, viewT2, PM_FPA_BEFORE)) {
    122126                    psError(psErrorCodeLast(), false, "Unable to read files.");
     127                    psFree (viewT2);
    123128                    goto FAIL;
    124129                }
    … …  
    126131                // process each of the readouts
    127132                pmReadout *readout;
    128                 while ((readout = pmFPAviewNextReadout(view, input->fpa, 1)) != NULL) {
    129                     if (!pmFPAfileIOChecks(config, view, PM_FPA_BEFORE)) {
     133                while ((readout = pmFPAviewNextReadout(viewT2, input->fpa, 1)) != NULL) {
     134                    if (!pmFPAfileIOChecks(config, viewT2, PM_FPA_BEFORE)) {
    130135                        psError(psErrorCodeLast(), false, "Unable to read files.");
     136                        psFree (viewT2);
    131137                        goto FAIL;
    132138                    }
    … …  
    136142
    137143                    if (astrom != input) {
    138                       pmReadout *astromRO = pmFPAviewThisReadout(view, astrom->fpa); // Readout for astrometry
    139                       if ((!refcat)&&(astromRO)) {
    140                         if ((astromRO->parent->parent->hdu->header)&&(output->fpa->analysis)) {
    141                           psMetadataItem *refItem = psMetadataLookup(astromRO->parent->parent->hdu->header, "PSREFCAT");
    142                           if (refItem) {
    143                             refcat = psMetadataLookupStr(NULL, astromRO->parent->parent->hdu->header, "PSREFCAT");
    144                             psMetadataAddStr(output->fpa->analysis, PS_LIST_TAIL, "REFERENCE_CATALOG", PS_META_REPLACE,
    145                                              "Reference catalog used for calibration.", refcat);
    146                           }
     144                        pmReadout *astromRO = pmFPAviewThisReadout(viewT2, astrom->fpa); // Readout for astrometry
     145                        if ((!refcat)&&(astromRO)) {
     146                            if ((astromRO->parent->parent->hdu->header)&&(output->fpa->analysis)) {
     147                                psMetadataItem *refItem = psMetadataLookup(astromRO->parent->parent->hdu->header, "PSREFCAT");
     148                                if (refItem) {
     149                                    refcat = psMetadataLookupStr(NULL, astromRO->parent->parent->hdu->header, "PSREFCAT");
     150                                    psMetadataAddStr(output->fpa->analysis, PS_LIST_TAIL, "REFERENCE_CATALOG", PS_META_REPLACE,
     151                                                     "Reference catalog used for calibration.", refcat);
     152                                }
     153                            }
    147154                        }
    148                       }
    149155                    }
    150156                   
    … …  
    159165                    pswarpTransformToTarget (output->fpa, readout, config, true);
    160166
    161                     if (!pmFPAfileIOChecks (config, view, PM_FPA_AFTER)) { // Readout
     167                    if (!pmFPAfileIOChecks (config, viewT2, PM_FPA_AFTER)) { // Readout
    162168                        psError(psErrorCodeLast(), false, "Unable to close files.");
     169                        psFree (viewT2);
    163170                        goto FAIL;
    164171                    }
    165172                }
    166173
    167                 if (!pmFPAfileIOChecks (config, view, PM_FPA_AFTER)) { // Cell
     174                if (!pmFPAfileIOChecks (config, viewT2, PM_FPA_AFTER)) { // Cell
    168175                    psError(psErrorCodeLast(), false, "Unable to close files.");
     176                    psFree (viewT2);
    169177                    goto FAIL;
    170178                }
    171179            }
    172180
    173             if (!pmFPAfileIOChecks (config, view, PM_FPA_AFTER)) { // Chip
     181            if (!pmFPAfileIOChecks (config, viewT2, PM_FPA_AFTER)) { // Chip
    174182                psError(psErrorCodeLast(), false, "Unable to close files.");
     183                psFree (viewT2);
    175184                goto FAIL;
    176185            }
    177186        }
    178187
    179         if (!pmFPAfileIOChecks (config, view, PM_FPA_AFTER)) { // FPA
     188        if (!pmFPAfileIOChecks (config, viewT2, PM_FPA_AFTER)) { // FPA
    180189            psError(psErrorCodeLast(), false, "Unable to close files.");
     190            psFree (viewT2);
    181191            goto FAIL;
    182192        }
    … …  
    184194        if (!pswarpUpdateMetadata (output->fpa, skycell->fpa, input->fpa, astrom->fpa, config, false)) {
    185195            psError(psErrorCodeLast(), false, "problem generating statistics.");
     196            psFree (viewT2);
    186197            goto FAIL;
    187198        }
     199        psFree (viewT2);
    188200    }
    189201

  • trunk/pswarp/src/pswarpTransformReadout.c

    r41382 r41510  
    118118    psAssert (yGridMax < grid->nYpts, "yGridMax too big\n");
    119119
    120     // fprintf (stderr, "warp %d,%d - %d,%d\n", xGridMin, yGridMin, xGridMax, yGridMax);
     120    fprintf (stderr, "warp %d,%d - %d,%d\n", xGridMin, yGridMin, xGridMax, yGridMax);
    121121
    122122    // create jobs and supply them to the threads

  • trunk/pswarp/src/pswarpUpdateMetadata.c

    r40354 r41510  
    2323
    2424    if ((output)&&(output->analysis)) {   
    25       psMetadataItem *refItem = psMetadataLookup(output->analysis, "REFERENCE_CATALOG");
    26       if (refItem) {
    27         refcat = psMetadataLookupStr (NULL, output->analysis, "REFERENCE_CATALOG");
    28       }
     25        psMetadataItem *refItem = psMetadataLookup(output->analysis, "REFERENCE_CATALOG");
     26        if (refItem) {
     27            refcat = psMetadataLookupStr (NULL, output->analysis, "REFERENCE_CATALOG");
     28        }
    2929    }
    3030    pmChip *chip;
    … …  
    4747            pmReadout *readout;
    4848            while ((readout = pmFPAviewNextReadout(view, output, 1)) != NULL) {
    49               // skip empty output readouts
     49                // skip empty output readouts
    5050                if (!readout->data_exists) continue;
    5151   
    … …  
    5757                    psArray *covars = psListToArray(covariances); // Array of covariance matrices
    5858                    if (covars->n) {
    59                       psKernel *covar = psImageCovarianceAverage(covars);
    60                       psMetadataRemoveKey(readout->analysis, PSWARP_ANALYSIS_COVARIANCES);
     59                        psKernel *covar = psImageCovarianceAverage(covars);
     60                        psMetadataRemoveKey(readout->analysis, PSWARP_ANALYSIS_COVARIANCES);
    6161
    62                       // Correct covariance matrix scale for the mean (square root of the) Jacobian
    63                       double jacobian = psMetadataLookupF64(NULL, readout->analysis, PSWARP_ANALYSIS_JACOBIAN); // Jacobian
    64                       int goodPixels = psMetadataLookupS32(NULL, readout->analysis, PSWARP_ANALYSIS_GOODPIX);   // Good pixels
    65                       jacobian /= goodPixels;
    66                       readout->covariance = psImageCovarianceScale(covar, jacobian);
    67                       psFree(covar);
     62                        // Correct covariance matrix scale for the mean (square root of the) Jacobian
     63                        double jacobian = psMetadataLookupF64(NULL, readout->analysis, PSWARP_ANALYSIS_JACOBIAN); // Jacobian
     64                        int goodPixels = psMetadataLookupS32(NULL, readout->analysis, PSWARP_ANALYSIS_GOODPIX);   // Good pixels
     65                        jacobian /= goodPixels;
     66                        readout->covariance = psImageCovarianceScale(covar, jacobian);
     67                        psFree(covar);
    6868
    69                       if (readout->variance) {
    70                         psImageCovarianceTransfer(readout->variance, readout->covariance);
    71                       }
     69                        if (readout->variance) {
     70                            psImageCovarianceTransfer(readout->variance, readout->covariance);
     71                        }
    7272
    73                       psFree(covars);
     73                        psFree(covars);
    7474                    }
    7575                }
    … …  
    9494                psArray *chipnames = psMetadataLookupPtr(&status, readout->analysis, PSWARP_ANALYSIS_CHIPNAMES);
    9595                for (int i = 0; chipnames && (i < chipnames->n); i++) {
    96                   psStringAppend (&keyword, "SRC_%04d", i);
    97                   psMetadataAddStr(hdu->header, PS_LIST_TAIL, keyword, PS_META_REPLACE, "input image", chipnames->data[i]);
    98                   psFree (keyword);
     96                    psStringAppend (&keyword, "SRC_%04d", i);
     97                    psMetadataAddStr(hdu->header, PS_LIST_TAIL, keyword, PS_META_REPLACE, "input image", chipnames->data[i]);
     98                    psFree (keyword);
    9999                }
    100100
    … …  
    102102                psArray *chipRegions = psMetadataLookupPtr(&status, readout->analysis, PSWARP_ANALYSIS_CHIPREGIONS);
    103103                for (int i = 0; chipRegions && (i < chipRegions->n); i++) {
    104                   psStringAppend (&keyword, "SEC_%04d", i);
    105                   psMetadataAddStr(hdu->header, PS_LIST_TAIL, keyword, PS_META_REPLACE, "input image", chipRegions->data[i]);
    106                   psFree (keyword);
     104                    psStringAppend (&keyword, "SEC_%04d", i);
     105                    psMetadataAddStr(hdu->header, PS_LIST_TAIL, keyword, PS_META_REPLACE, "input image", chipRegions->data[i]);
     106                    psFree (keyword);
    107107                }
    108108
    … …  
    110110                psArray *backmaps  = psMetadataLookupPtr(&status, readout->analysis, PSWARP_ANALYSIS_BACKMAPS); //
    111111                for (int i = 0; backmaps && (i < backmaps->n); i++) {
    112                   psPlaneTransform *map = backmaps->data[i];             
    113                   psStringAppend (&keyword, "MPX_%04d", i);
    114                   psStringAppend (&mapstring, "[%8.2f,%8.4f,%8.4f]", map->x->coeff[0][0], map->x->coeff[1][0], map->x->coeff[0][1]);
    115                   psMetadataAddStr(hdu->header, PS_LIST_TAIL, keyword, PS_META_REPLACE, "warp to image map", mapstring);
    116                   psFree (keyword);
    117                   psFree (mapstring);
    118                   psStringAppend (&keyword, "MPY_%04d", i);
    119                   psStringAppend (&mapstring, "[%8.2f,%8.4f,%8.4f]", map->y->coeff[0][0], map->y->coeff[1][0], map->y->coeff[0][1]);
    120                   psMetadataAddStr(hdu->header, PS_LIST_TAIL, keyword, PS_META_REPLACE, "warp to image map", mapstring);
    121                   psFree (keyword);
    122                   psFree (mapstring);
     112                    psPlaneTransform *map = backmaps->data[i];           
     113                    psStringAppend (&keyword, "MPX_%04d", i);
     114                    psStringAppend (&mapstring, "[%8.2f,%8.4f,%8.4f]", map->x->coeff[0][0], map->x->coeff[1][0], map->x->coeff[0][1]);
     115                    psMetadataAddStr(hdu->header, PS_LIST_TAIL, keyword, PS_META_REPLACE, "warp to image map", mapstring);
     116                    psFree (keyword);
     117                    psFree (mapstring);
     118                    psStringAppend (&keyword, "MPY_%04d", i);
     119                    psStringAppend (&mapstring, "[%8.2f,%8.4f,%8.4f]", map->y->coeff[0][0], map->y->coeff[1][0], map->y->coeff[0][1]);
     120                    psMetadataAddStr(hdu->header, PS_LIST_TAIL, keyword, PS_META_REPLACE, "warp to image map", mapstring);
     121                    psFree (keyword);
     122                    psFree (mapstring);
    123123                }
    124124            }
    … …  
    164164    if (!psMetadataCopy(output->concepts, input->concepts)) {
    165165        psError(psErrorCodeLast(), false, "Unable to copy FPA concepts from input to output.");
     166        psFree(view);
    166167        return false;
    167168    }
    … …  
    174175
    175176    if (refcat) {
    176       if ((output)&&(output->hdu)&&(output->hdu->header)) {
    177         psMetadataAddStr(output->hdu->header, PS_LIST_TAIL, "PSREFCAT", PS_META_REPLACE,
    178                          "Reference catalog used for calibration", refcat);
    179       }
     177        if ((output)&&(output->hdu)&&(output->hdu->header)) {
     178            psMetadataAddStr(output->hdu->header, PS_LIST_TAIL, "PSREFCAT", PS_META_REPLACE,
     179                             "Reference catalog used for calibration", refcat);
     180        }
    180181    }
    181182   
    … …  
    193194    }
    194195
     196    psFree(view);
    195197    return true;
    196198}
Note: See TracChangeset for help on using the changeset viewer.