IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 32616


Ignore:
Timestamp:
Nov 5, 2011, 2:30:17 PM (15 years ago)
Author:
eugene
Message:

speed up psphotRadialApertures (mostly by avoiding the large mask reallocation); add profile wings to psphotStackReadout

Location:
branches/eam_branches/ipp-20110906/psphot/src
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • branches/eam_branches/ipp-20110906/psphot/src/Makefile.am

    r32606 r32616  
    202202        psphotRadialBins.c             \
    203203        psphotRadialApertures.c        \
    204         psphotRadialAperturesByObject.c \
    205204        psphotPetrosian.c              \
    206205        psphotPetrosianRadialBins.c    \

  • branches/eam_branches/ipp-20110906/psphot/src/psphot.h

    r32606 r32616  
    428428bool psphotRadialAperturesReadout (pmConfig *config, const pmFPAview *view, const char *filerule, int index, psMetadata *recipe, int entry);
    429429bool psphotRadialApertures_Threaded (psThreadJob *job);
    430 bool psphotRadialApertureSource (pmSource *source, psMetadata *recipe, psImageMaskType maskVal, const psVector *radMax, int entry);
     430bool psphotRadialApertureSource (pmSource *source, pmReadout *readout, int entry, psVector *pixRadius2, psVector *pixFlux, psVector *pixVer);
     431// bool psphotRadialApertureSource (pmSource *source, int entry);
    431432
    432433bool psphotExtendedSourceAnalysisByObject (pmConfig *config, psArray *objects, const pmFPAview *view, const char *filerule);

  • branches/eam_branches/ipp-20110906/psphot/src/psphotKronIterate.c

    r32605 r32616  
    192192    float MIN_KRON_RADIUS           = PS_SCALAR_VALUE(job->args->data[6],F32);
    193193
    194     for (int j = 0; j < 5; j++) {
     194    // XXX TEST : set iteration to 1
     195    for (int j = 0; j < 1; j++) {
    195196        for (int i = 0; i < sources->n; i++) {
    196197
    … …  
    209210
    210211            // use S/N to control max window size
    211             float kronSN = source->moments->KronFlux / source->moments->KronFluxErr;
     212            // float kronSN = source->moments->KronFlux / source->moments->KronFluxErr;
    212213
    213214            // maxWindow -> 1.5*RADIUS for kronSN = 5.0, keeping S.B. constant (kronSN ~ flux)
    214215            // (kronSN / maxWindow^2) = (5.0 / (1.5 RADIUS)^2)
    215216            // maxWindow = 1.5 * RADIUS * sqrt(kronSN / 5.0)
    216             float maxWindow = (isfinite(kronSN) && (kronSN > 5.0)) ? 1.5 * RADIUS * sqrt(kronSN / 5.0) : 1.5*RADIUS;
     217            // XXX float maxWindow = (isfinite(kronSN) && (kronSN > 5.0)) ? 1.5 * RADIUS * sqrt(kronSN / 5.0) : 1.5*RADIUS;
    217218
    218219            // iterate to the window radius
    219             float windowRadius = PS_MIN(PS_MAX(RADIUS, 4.0*source->moments->Mrf), maxWindow);
     220            // XXX float windowRadius = PS_MIN(PS_MAX(RADIUS, 4.0*source->moments->Mrf), maxWindow);
     221
     222            // XXX TEST : use a window based on the radial profile numbers: max is skyRadius, min is RADIUS
     223            float maxWindow = source->skyRadius;
     224            float windowRadius = PS_MAX(RADIUS, maxWindow);
    220225
    221226            // re-allocate image, weight, mask arrays for each peak with box big enough to fit BIG_RADIUS

  • branches/eam_branches/ipp-20110906/psphot/src/psphotRadialApertures.c

    r32348 r32616  
    3636}
    3737
     38// these values are used by all threads repeatedly (and are not modified)
     39static psVector *aperRadii = NULL;
     40static psVector *aperRadii2 = NULL;
     41static float outerRadius = NAN;
     42static float SN_LIM = NAN;
     43static psImageMaskType maskVal = 0;
     44
    3845// aperture-like measurements for extended sources
    3946// flux in simple, circular apertures
    … …  
    7582        nThreads = 0;
    7683    }
     84
     85    // aperRadii stores the upper bounds of the annuli
     86    // XXX keep the same name here as for the petrosian / elliptical apertures?
     87    aperRadii = psMetadataLookupPtr (&status, recipe, "RADIAL.ANNULAR.BINS.UPPER");
     88    psAssert (aperRadii, "annular bins (RADIAL.ANNULAR.BINS.UPPER) are not defined in the recipe");
     89    psAssert (aperRadii->n, "no valid annular bins (RADIAL.ANNULAR.BINS.UPPER) are define");
     90
     91    outerRadius = aperRadii->data.F32[aperRadii->n - 1];
     92
     93    // save the R^2 values as well for quicker comparison
     94    aperRadii2 = psVectorAlloc(aperRadii->n, PS_TYPE_F32);
     95    for (int i = 0; i < aperRadii->n; i++) {
     96        aperRadii2->data.F32[i] = PS_SQR(aperRadii->data.F32[i]);
     97    }
     98
     99    // user-defined masks to test for good/bad pixels (build from recipe list if not yet set)
     100    maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
     101    assert (maskVal);
     102
     103    // S/N limit to perform full non-linear fits
     104    SN_LIM = psMetadataLookupF32 (&status, recipe, "RADIAL_APERTURES_SN_LIM");
    77105
    78106    // source analysis is done in S/N order (brightest first)
    … …  
    117145            psArrayAdd(job->args, 1, cells->data[j]); // sources
    118146            psArrayAdd(job->args, 1, AnalysisRegion);
    119             psArrayAdd(job->args, 1, recipe);
    120 
    121147            PS_ARRAY_ADD_SCALAR(job->args, entry,  PS_TYPE_S32);
    122148            PS_ARRAY_ADD_SCALAR(job->args, nEntry, PS_TYPE_S32);
    123 
    124149            PS_ARRAY_ADD_SCALAR(job->args, 0, PS_TYPE_S32); // this is used as a return value for Nradial
    125150
    126 // set this to 0 to run without threading
     151            // set this to 0 to run without threading
    127152# if (1)           
    128153            if (!psThreadJobAddPending(job)) {
    … …  
    138163            }
    139164            psScalar *scalar = NULL;
    140             scalar = job->args->data[6];
     165            scalar = job->args->data[5];
    141166            Nradial += scalar->data.S32;
    142167            psFree(job);
    … …  
    158183            } else {
    159184                psScalar *scalar = NULL;
    160                 scalar = job->args->data[6];
     185                scalar = job->args->data[5];
    161186                Nradial += scalar->data.S32;
    162187            }
    … …  
    166191    psFree (cellGroups);
    167192    psFree(AnalysisRegion);
     193    psFree (aperRadii2);
    168194
    169195    psLogMsg ("psphot", PS_LOG_WARN, "radial source apertures: %f sec for %d objects\n", psTimerMark ("psphot.radial"), Nradial);
    … …  
    173199bool psphotRadialApertures_Threaded (psThreadJob *job) {
    174200
    175     bool status;
    176201    int Nradial = 0;
    177202
    … …  
    180205    psArray *sources        = job->args->data[1];
    181206    psRegion *region        = job->args->data[2];
    182     psMetadata *recipe      = job->args->data[3];
    183 
    184     int entry               = PS_SCALAR_VALUE(job->args->data[4],S32); // which psf-matched image are we working on? (0 == unmatched)
    185     int nEntry              = PS_SCALAR_VALUE(job->args->data[5],S32); // total number of psf-matched images + 1 unmatched
    186 
    187     // radMax stores the upper bounds of the annuli
    188     // XXX keep the same name here as for the petrosian / elliptical apertures?
    189     psVector *radMax = psMetadataLookupPtr (&status, recipe, "RADIAL.ANNULAR.BINS.UPPER");
    190     psAssert (radMax, "annular bins (RADIAL.ANNULAR.BINS.UPPER) are not defined in the recipe");
    191     psAssert (radMax->n, "no valid annular bins (RADIAL.ANNULAR.BINS.UPPER) are define");
    192 
    193     // user-defined masks to test for good/bad pixels (build from recipe list if not yet set)
    194     psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels
    195     assert (maskVal);
    196 
    197     // S/N limit to perform full non-linear fits
    198     float SN_LIM = psMetadataLookupF32 (&status, recipe, "RADIAL_APERTURES_SN_LIM");
    199 
    200     float outerRadius = radMax->data.F32[radMax->n - 1];
     207    int entry               = PS_SCALAR_VALUE(job->args->data[3],S32); // which psf-matched image are we working on? (0 == unmatched)
     208    int nEntry              = PS_SCALAR_VALUE(job->args->data[4],S32); // total number of psf-matched images + 1 unmatched
     209
     210    // storage for the derived pixel values (these are passed into psphotRadialApertureSource)
     211    psVector *pixRadius2 = psVectorAllocEmpty(100, PS_TYPE_F32);
     212    psVector *pixFlux    = psVectorAllocEmpty(100, PS_TYPE_F32);
     213    psVector *pixVar     = psVectorAllocEmpty(100, PS_TYPE_F32);
    201214
    202215    // choose the sources of interest
    … …  
    240253        }
    241254
    242         // we need to change the view for the radial aperture analysis, but we want to recover exactly
    243         // the original view; the following elements get destroyed by pmSourceRedefinePixels so save them:
    244         psImage *oldMaskObj   = psMemIncrRefCounter(source->maskObj);
    245         psImage *oldModelFlux = psMemIncrRefCounter(source->modelFlux);
    246         psImage *oldPSFimage  = psMemIncrRefCounter(source->psfImage);
    247         psRegion oldRegion    = source->region;
    248 
    249255        Nradial ++;
    250256
    251         // force source image to be a bit larger...
    252         pmSourceRedefinePixels (source, readout, source->peak->xf, source->peak->yf, outerRadius + 2);
    253 
    254         if (!psphotRadialApertureSource (source, recipe, maskVal, radMax, entry)) {
     257        if (!psphotRadialApertureSource (source, readout, entry, pixRadius2, pixFlux, pixVar)) {
    255258            psTrace ("psphot", 5, "failed to extract radial profile for source at %7.1f, %7.1f", source->moments->Mx, source->moments->My);
    256259        } else {
    … …  
    258261        }
    259262
    260         pmSourceRedefinePixelsByRegion (source, readout, oldRegion);
    261         psFree(source->maskObj);   source->maskObj   = oldMaskObj;
    262         psFree(source->modelFlux); source->modelFlux = oldModelFlux;
    263         psFree(source->psfImage);  source->psfImage  = oldPSFimage;
    264        
    265263        // re-subtract the object, leave local sky
    266264        pmSourceSub (source, PM_MODEL_OP_FULL, maskVal);
    267265    }
    268     psScalar *scalar = job->args->data[6];
     266    psScalar *scalar = job->args->data[5];
    269267    scalar->data.S32 = Nradial;
     268
     269    psFree (pixRadius2);
     270    psFree (pixFlux);
     271    psFree (pixVar);
    270272
    271273    return true;
    272274}
    273275
    274 bool psphotRadialApertureSource (pmSource *source, psMetadata *recipe, psImageMaskType maskVal, const psVector *aperRadii, int entry) {
    275 
     276bool psphotRadialApertureSource (pmSource *source, pmReadout *readout, int entry, psVector *pixRadius2, psVector *pixFlux, psVector *pixVar) {
     277                                           
    276278    // if we are a child source, save the results to the parent source radial aperture array
    277279    psArray *radialAperSet = source->radialAper;
    … …  
    285287    radialAperSet->data[entry] = radialAper;
    286288
    287     // storage for the derived pixel values
    288     psVector *pixRadius2 = psVectorAllocEmpty(100, PS_TYPE_F32);
    289     psVector *pixFlux    = psVectorAllocEmpty(100, PS_TYPE_F32);
    290     psVector *pixVar     = psVectorAllocEmpty(100, PS_TYPE_F32);
     289    // find the largest aperture of interest (use only apertures with inner radii <=
     290    // source->skyRadius)
     291    int lastAp = aperRadii->n;
     292    for (int i = 0; i < aperRadii->n; i++) {
     293        if (aperRadii->data.F32[i] < source->skyRadius) continue;
     294        lastAp = i + 1;
     295        break;
     296    }
    291297
    292298    // outer-most radius for initial truncation
    293     float Rmax  = aperRadii->data.F32[aperRadii->n - 1];
     299    float Rmax  = aperRadii->data.F32[lastAp - 1];
    294300    float Rmax2 = PS_SQR(Rmax);
    295301
    296     // store the R^2 values for the apertures
    297     psVector *aperRadii2 = psVectorAlloc(aperRadii->n, PS_TYPE_F32);
    298     for (int i = 0; i < aperRadii->n; i++) {
    299         aperRadii2->data.F32[i] = PS_SQR(aperRadii->data.F32[i]);
    300     }
     302    // in this function, the operatins are relative to the full image (readout->image, etc)
    301303
    302304    float xCM = NAN, yCM = NAN;
    303305    if (pmSourcePositionUseMoments(source)) {
    304         xCM = source->moments->Mx - 0.5 - source->pixels->col0; // coord of peak in subimage
    305         yCM = source->moments->My - 0.5 - source->pixels->row0; // coord of peak in subimage
     306        xCM = source->moments->Mx; // index coord of peak in readout
     307        yCM = source->moments->My; // index coord of peak in readout
    306308    } else {
    307         xCM = source->peak->xf - 0.5 - source->pixels->col0; // coord of peak in subimage
    308         yCM = source->peak->yf - 0.5 - source->pixels->row0; // coord of peak in subimage
    309     }
     309        xCM = source->peak->xf; // index coord of peak in readout
     310        yCM = source->peak->yf; // index coord of peak in readout
     311    }
     312
     313    int Nx = readout->image->numCols;
     314    int Ny = readout->image->numRows;
     315
     316    pixRadius2->n = 0;
     317    pixFlux->n = 0;
     318    pixVar->n = 0;
    310319
    311320    // one pass through the pixels to select the valid pixels and calculate R^2
    312     for (int iy = 0; iy < source->pixels->numRows; iy++) {
    313 
    314         float yDiff = iy - yCM;
    315         if (fabs(yDiff) > Rmax) continue;
    316 
    317         float *vPix = source->pixels->data.F32[iy];
    318         float *vWgt = source->variance->data.F32[iy];
    319         psImageMaskType  *vMsk = (source->maskObj == NULL) ? NULL : source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[iy];
    320 
    321         for (int ix = 0; ix < source->pixels->numCols; ix++, vPix++, vWgt++) {
    322 
    323             if (vMsk) {
    324                 if (*vMsk & maskVal) {
    325                     vMsk++;
    326                     continue;
    327                 }
    328                 vMsk++;
    329             }
    330             if (isnan(*vPix)) continue;
    331 
    332             float xDiff = ix - xCM;
    333             if (fabs(xDiff) > Rmax) continue;
     321    for (int iy = -Rmax; iy < Rmax + 1; iy++) {
     322
     323        float yDiff = iy + 0.5 + yCM;  // y-coordinate at this offse
     324        int yPix = (int) yDiff;
     325
     326        if (yPix < 0) continue;
     327        if (yPix > Ny - 1) continue;
     328        if (fabs(iy) > Rmax) continue;
     329
     330        float *vPix = readout->image->data.F32[yPix];
     331        float *vWgt = readout->variance->data.F32[yPix];
     332        psImageMaskType  *vMsk = readout->mask->data.PS_TYPE_IMAGE_MASK_DATA[yPix];
     333
     334        for (int ix = -Rmax; ix < Rmax + 1; ix++) {
     335
     336            float xDiff = ix + 0.5 + xCM;  // x-coordinate at this offse
     337            int xPix = (int) xDiff;
     338           
     339            if (xPix < 0) continue;
     340            if (xPix > Nx - 1) continue;
     341            if (fabs(ix) > Rmax) continue;
     342           
     343            if (vMsk[xPix] & maskVal) continue;
     344            if (isnan(vPix[xPix])) continue;
    334345
    335346            // radius is just a function of (xDiff, yDiff)
    336             float r2  = PS_SQR(xDiff) + PS_SQR(yDiff);
     347            float r2  = PS_SQR(ix) + PS_SQR(iy);
    337348            if (r2 > Rmax2) continue;
    338349
    339350            psVectorAppend(pixRadius2, r2);
    340             psVectorAppend(pixFlux, *vPix);
    341             psVectorAppend(pixVar, *vWgt);
     351            psVectorAppend(pixFlux, vPix[xPix]);
     352            psVectorAppend(pixVar, vWgt[xPix]);
    342353        }
    343354    }
    … …  
    348359    psVector *fill    = psVectorAlloc(aperRadii->n, PS_TYPE_F32); // surface brightness of radial bin
    349360
     361    // init the apertures of interest to 0.0, the rest go to NAN
    350362    psVectorInit (flux,    0.0);
    351363    psVectorInit (fluxStd, 0.0);
    352364    psVectorInit (fluxErr, 0.0);
    353365    psVectorInit (fill,    0.0);
     366    for (int i = lastAp; i < flux->n; i++) {
     367        flux->data.F32[i] = NAN;
     368        fluxStd->data.F32[i] = NAN;
     369        fluxErr->data.F32[i] = NAN;
     370        fill->data.F32[i] = NAN;
     371    }
    354372
    355373    float *rPix2 = pixRadius2->data.F32;
    … …  
    358376        int j = 0;
    359377        float *aRad2 = aperRadii2->data.F32;
    360         for (; (*aRad2 < *rPix2) && (j < aperRadii2->n); j++, aRad2++);
    361         for (; j < aperRadii2->n; j++, aRad2++) {
     378        for (; (*aRad2 < *rPix2) && (j < lastAp); j++, aRad2++);
     379
     380        // XXX I can speed this up by only saving this single aperture
     381        for (; j < lastAp; j++, aRad2++) {
    362382            flux->data.F32[j]    += pixFlux->data.F32[i];
    363383            fluxStd->data.F32[j] += PS_SQR(pixFlux->data.F32[i]);
    … …  
    371391       2) the fractional fill factor (count of valid pixels / effective area of the aperture
    372392       3) the error on the flux within that aperture
    373      */
    374 
    375     for (int i = 0; i < flux->n; i++) {
     393    */
     394
     395    for (int i = 0; i < lastAp; i++) {
    376396        // calculate the total flux for bin 'nOut'
    377397        float Area = M_PI*aperRadii2->data.F32[i];
    … …  
    383403        // XXX report the total flux or the mask-corrected flux?
    384404        // flux->data.F32[i]    = SBmean * Area;
    385         // fluxErr->data.F32[i] = sqrt(fluxErr->data.F32[i]) * Area / nPix;
     405        // fluxErr->data.F32[i] = sqrt(fluxErr->data.F32[i]) * Area / Pinx;
    386406
    387407        fluxErr->data.F32[i] = sqrt(fluxErr->data.F32[i]);
    … …  
    393413    }
    394414   
     415# if (1)
    395416    radialAper->flux = flux;
    396417    radialAper->fluxStdev = fluxStd;
    397418    radialAper->fluxErr = fluxErr;
    398419    radialAper->fill = fill;
    399 
    400     psFree (aperRadii2);
    401     psFree (pixRadius2);
    402     psFree (pixFlux);
    403     psFree (pixVar);
     420# else
     421    // XXX TEST
     422    psFree(flux);
     423    psFree(fluxStd);
     424    psFree(fluxErr);
     425    psFree(fill);
     426# endif
    404427
    405428    return true;
    406429}
     430
     431/*** below is a test to use a sort to speed this up, not very successfully ***/
    407432
    408433static int nCalls = 0;
    … …  
    495520// *** pmSourceRadialProfileSortPair is a utility function for sorting a pair of vectors
    496521# define COMPARE_VECT(A,B) (radius->data.F32[A] < radius->data.F32[B])
    497 # define SWAP_VECT(TYPE,A,B) { \
    498   float tmp; \
    499   if (A != B) { \
    500     tmp = radius->data.F32[A]; \
    501     radius->data.F32[A] = radius->data.F32[B];  \
    502     radius->data.F32[B] = tmp; \
    503     tmp = pixFlux->data.F32[A]; \
    504     pixFlux->data.F32[A] = pixFlux->data.F32[B]; \
    505     pixFlux->data.F32[B] = tmp; \
    506     tmp = pixVar->data.F32[A]; \
    507     pixVar->data.F32[A] = pixVar->data.F32[B]; \
    508     pixVar->data.F32[B] = tmp; \
    509   } \
    510 }
     522# define SWAP_VECT(TYPE,A,B) {                                  \
     523        float tmp;                                              \
     524        if (A != B) {                                           \
     525            tmp = radius->data.F32[A];                          \
     526            radius->data.F32[A] = radius->data.F32[B];          \
     527            radius->data.F32[B] = tmp;                          \
     528            tmp = pixFlux->data.F32[A];                         \
     529            pixFlux->data.F32[A] = pixFlux->data.F32[B];        \
     530            pixFlux->data.F32[B] = tmp;                         \
     531            tmp = pixVar->data.F32[A];                          \
     532            pixVar->data.F32[A] = pixVar->data.F32[B];          \
     533            pixVar->data.F32[B] = tmp;                          \
     534        }                                                       \
     535    }
    511536
    512537bool psphotRadialAperturesSortFlux (psVector *radius, psVector *pixFlux, psVector *pixVar) {

  • branches/eam_branches/ipp-20110906/psphot/src/psphotRadialProfileWings.c

    r32612 r32616  
    132132
    133133// set this to 0 to run without threading
    134 # if (0)
     134# if (1)
    135135            if (!psThreadJobAddPending(job)) {
    136136                psError(PS_ERR_UNKNOWN, false, "Unable to guess model.");
    … …  
    217217
    218218    // psImageMaskType **vMsk = (source->maskObj == NULL) ? NULL : source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA;
     219
     220    // XXX unclear if I should run this analysis on both 1st and 2nd pass for 1st pass objects,
     221    // or just use the 1st pass value.  I think I should just use the 1st pass value, so skip
     222    // any that have already been assigned
     223    if (isfinite(source->skyRadius)) return true;
    219224
    220225    // radii will be MIN_RADIUS to MAX_RADIUS in NN log steps:

  • branches/eam_branches/ipp-20110906/psphot/src/psphotReadout.c

    r32606 r32616  
    308308pass1finish:
    309309
     310    // measure the radial profiles to the sky (only measures new objects)
     311    psphotRadialProfileWings (config, view, filerule);
     312
    310313    // re-measure the kron mags with models subtracted
    311314    // psphotKronMasked(config, view, filerule);

  • branches/eam_branches/ipp-20110906/psphot/src/psphotSetThreads.c

    r32613 r32616  
    5050    psFree(task);
    5151
    52     task = psThreadTaskAlloc("PSPHOT_RADIAL_APERTURES", 7);
     52    task = psThreadTaskAlloc("PSPHOT_RADIAL_APERTURES", 6);
    5353    task->function = &psphotRadialApertures_Threaded;
    5454    psThreadTaskAdd(task);

  • branches/eam_branches/ipp-20110906/psphot/src/psphotSourceSize.c

    r32348 r32616  
    156156
    157157    // XXX fix this (was source->n  - first)
    158     psLogMsg ("psphot.size", PS_LOG_INFO, "measure source sizes for %ld sources: %f sec\n", sources->n, psTimerMark ("psphot.size"));
     158    psLogMsg ("psphot.size", PS_LOG_WARN, "measure source sizes for %ld sources: %f sec\n", sources->n, psTimerMark ("psphot.size"));
    159159
    160160    psphotVisualPlotSourceSize (recipe, readout->analysis, sources);

  • branches/eam_branches/ipp-20110906/psphot/src/psphotStackReadout.c

    r32348 r32616  
    168168    psphotFitSourcesLinear (config, view, STACK_SRC, false);
    169169    psphotStackVisualFilerule(config, view, STACK_SRC);
     170
     171    // measure the radial profiles to the sky
     172    psphotRadialProfileWings (config, view, STACK_SRC);
    170173
    171174    // re-measure the kron mags with models subtracted.  this pass starts with a circular
    … …  
    245248pass1finish:
    246249
     250    // measure the radial profiles to the sky (only measures new objects)
     251    psphotRadialProfileWings (config, view, STACK_SRC);
     252
    247253    // re-measure the kron mags with models subtracted
    248254    // psphotKronMasked(config, view, STACK_SRC);
    … …  
    254260
    255261    psMemDump("psfstats");
     262
     263    // XXX *** NOTE : this should happen above before the last psphotFitSourcesLinear in order
     264    // to generate psf forced photometry for the undetected sources
    256265
    257266    // generate the objects (objects unify the sources from the different images)
    … …  
    281290
    282291    // measure circular, radial apertures (objects sorted by S/N)
    283     // XXX can we just use psphotRadialApertures
    284     // XXX make sure the headers are consistent with this (which PSF convolutions, ie mark 'none')
    285     // psphotRadialAperturesByObject (config, objectsRadial, view, STACK_SRC, nMatchedPSF);
     292    // this forces photometry on the undetected sources from other images
    286293    psphotRadialApertures (config, view, STACK_SRC, 0); // XXX entry 0 == unmatched?
    287294    psMemDump("extmeas");
Note: See TracChangeset for help on using the changeset viewer.