IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 42094


Ignore:
Timestamp:
Feb 28, 2022, 3:01:31 PM (4 years ago)
Author:
eugene
Message:

some cleanup of ppStackFiles: JPEG1 & JPEG2 are not part of the "convolved" output: they are activated explicitly in ppStackJPEGs.c; add option to generate stacks using the pmStackCombineByPercent method; trap failures in the ppStackReadout threads; fix normalization for both convolved and unconvolved versions (was inconsistent in ppStackLoop)

Location:
trunk/ppStack
Files:
20 edited
2 copied

Legend:

Unmodified
Added
Removed

  • trunk/ppStack

  • trunk/ppStack/src/Makefile.am

    r38034 r42094  
    2929        ppStackPrepare.c        \
    3030        ppStackConvolve.c       \
     31        ppStackLoopByPercent.c  \
     32        ppStackCombinePercent.c \
    3133        ppStackCombinePrepare.c \
    3234        ppStackCombineInitial.c \

  • trunk/ppStack/src/ppStack.h

    r36855 r42094  
    115115bool ppStackReadoutFinalThread(psThreadJob *job // Job to process
    116116    );
     117
     118// Thread entry point for ppStackReadoutPercent
     119bool ppStackReadoutPercentThread(psThreadJob *job);
     120
     121bool ppStackReadoutPercent(const pmConfig *config,
     122                           pmReadout *outRO,
     123                           pmReadout *expRO,
     124                           const psArray *readouts,
     125                           const psVector *mask,
     126                           const psVector *weightings,
     127                           const psVector *exposures,
     128                           const psVector *addVariance);
     129
    117130// Perform median stacking for background
    118131bool ppStackCombineBackground(ppStackThreadData *stack, ppStackOptions *options, pmConfig *config);

  • trunk/ppStack/src/ppStackArguments.c

    r34800 r42094  
    197197    }
    198198
    199     // stack-type : used to define the stack for PSPS
     199    // stack-type : used to define the stack for PSPS (added as metadata to header key STK_TYPE)
    200200    if ((argNum = psArgumentGet (argc, argv, "-stack-type"))) {
    201201        if (argc <= argNum+1) {

  • trunk/ppStack/src/ppStackCombineFinal.c

    r36855 r42094  
    22
    33// This is the doomsday switch.
    4 // #define TESTING                         // Enable test output
     4// # define TESTING                         // Enable test output
    55
    66//MEH -- adhoc addition to blank mask border of final stack since rejection different/none on order of KERNEL.SIZE with overlap in CombineInitial

  • trunk/ppStack/src/ppStackCombineInitial.c

    r33093 r42094  
    99    psAssert(options, "Require options");
    1010    psAssert(config, "Require configuration");
    11 
    12 /*     if (!options->convolve) { */
    13 /*         // No need to do initial combination when we haven't convolved */
    14 /*         // XXX either allocate inspect and rejected here, or do not require them downstream */
    15 /*         return true; */
    16 /*     } */
    1711
    1812    psTimerStart("PPSTACK_INITIAL");

  • trunk/ppStack/src/ppStackCombinePrepare.c

    r34859 r42094  
    3131      options->expRO = pmReadoutAlloc(expCell); //Output readout
    3232    }
    33 /*     else { */
    34 /*       options->expRO = NULL; */
    35 /*     } */
     33
    3634    int bkg_r0 = 0,bkg_c0 = 0;
    3735    int bkg_nC = 0,bkg_nR = 0;
    … …  
    5351     
    5452      options->bkgRO = pmReadoutAlloc(bkgCell); // BKG readout
    55       //      if (!pmHDUGenerateForFPA(options->bkgRO->parent->parent->parent)) {
    5653      options->bkgRO->parent->parent->parent->hdu = pmHDUAlloc(NULL);
     54
    5755      if (!options->bkgRO->parent->parent->parent->hdu) {
    5856        fprintf(stderr,"failed to generate a HDU for this thing.\n");
    … …  
    6866                                                                        ro->parent->parent->parent->concepts);
    6967
    70     }
    71     else {
     68    } else {
    7269      options->bkgRO = NULL;
    7370    }
    … …  
    9794        return false;
    9895      }
    99      
    100 
    101      
    10296    }
    10397

  • trunk/ppStack/src/ppStackFiles.c

    r34800 r42094  
    11#include "ppStack.h"
     2# define DEBUG 0
    23
    34// Here follows lists of files for activation/deactivation at various stages.  Each must be NULL-terminated.
    … …  
    2829static char *filesStack[] = { "PPSTACK.OUTPUT", "PPSTACK.OUTPUT.MASK", "PPSTACK.OUTPUT.VARIANCE",
    2930                              "PPSTACK.OUTPUT.EXP", "PPSTACK.OUTPUT.EXPNUM", "PPSTACK.OUTPUT.EXPWT",
    30                               "PPSTACK.OUTPUT.JPEG1", "PPSTACK.OUTPUT.JPEG2",
    3131                              "PPSTACK.OUTPUT.BKGMODEL",
    3232                              NULL };
    … …  
    4545{
    4646    switch (list) {
    47       case PPSTACK_FILES_NONE:     return filesNOP;
    48       case PPSTACK_FILES_PREPARE:  return filesPrepare;
    49       case PPSTACK_FILES_TARGET:   return filesTarget;
    50       case PPSTACK_FILES_CONVOLVE: return filesConvolve;
    51       case PPSTACK_FILES_STACK:    return filesStack;
    52       case PPSTACK_FILES_UNCONV:   return filesUnconv;
    53       case PPSTACK_FILES_PHOT:     return filesPhot;
    54     case PPSTACK_FILES_BKG:        return filesBkg;
    55     case PPSTACK_FILES_MEDIAN_IN:        return filesMedianIn;
    56     case PPSTACK_FILES_MEDIAN_OUT:        return filesMedianOut;
     47      case PPSTACK_FILES_NONE:       return filesNOP;
     48      case PPSTACK_FILES_PREPARE:    return filesPrepare;
     49      case PPSTACK_FILES_TARGET:     return filesTarget;
     50      case PPSTACK_FILES_CONVOLVE:   return filesConvolve;
     51      case PPSTACK_FILES_STACK:      return filesStack;
     52      case PPSTACK_FILES_UNCONV:     return filesUnconv;
     53      case PPSTACK_FILES_PHOT:       return filesPhot;
     54      case PPSTACK_FILES_BKG:        return filesBkg;
     55      case PPSTACK_FILES_MEDIAN_IN:  return filesMedianIn;
     56      case PPSTACK_FILES_MEDIAN_OUT: return filesMedianOut;
    5757      default:
    5858        psAbort("Unrecognised file list: %x", list);
    … …  
    9999    char **files = stackFiles(list);    // Files to turn on/off
    100100    for (int i = 0; files[i] != NULL; i++) {
     101        if (DEBUG) {
     102            if (state) {
     103                fprintf (stderr, "activate %s\n", files[i]);
     104            } else {
     105                fprintf (stderr, "deativate %s\n", files[i]);
     106            }
     107        }
    101108        pmFPAfileActivate(config->files, state, files[i]);
    102109    }

  • trunk/ppStack/src/ppStackJPEGs.c

    r30620 r42094  
    3333    psFree(ro2);
    3434
     35    pmFPAfileActivate(config->files, true, "PPSTACK.OUTPUT.JPEG1");
     36    pmFPAfileActivate(config->files, true, "PPSTACK.OUTPUT.JPEG2");
     37
    3538    return true;
    3639}

  • trunk/ppStack/src/ppStackLoop.c

    r41529 r42094  
    3131    ppStackMemDump("prepare");
    3232    if (options->quality) return true; // Can't do anything else
     33
     34    // if we want to skip the rejection steps, and instead use a percentile clipping:
     35    if (options->clipPercent) {
     36      bool result = ppStackLoopByPercent (config, options);
     37      return result;
     38    }
    3339
    3440    // Convolve inputs
    … …  
    8894        pmCellFreeData(options->cells->data[i]);
    8995    }
    90     //MEH -- must uncomment back out -- unclear is should be moved after pixel rejection
     96    // MEH -- must uncomment back out -- unclear is should be moved after pixel rejection
    9197    psFree(stack);
    9298
    … …  
    126132        return false;
    127133      }
    128     }
    129     else {
     134    } else {
    130135      // Since we haven't convolved, I believe we do need to normalize here.
    131       //MEH -- see below for comment on ppStackCombineFinal and bscaleOffset
    132       if (!ppStackCombineFinal(stack, options->convCovars, options, config, false, true, true, true)) {
     136      // MEH -- see below for comment on ppStackCombineFinal and bscaleOffset
     137      // last 4 parameters are: safe, normalize, grow, bscaleoffset
     138      // EAM : looks like we do NOT need to normalize here eithr because ppStackConvolve is still called and
     139      // the inputs are normalized
     140      if (!ppStackCombineFinal(stack, options->convCovars, options, config, false, false, true, true)) {
    133141        psError(psErrorCodeLast(), false, "Unable to perform final combination.");
    134142        psFree(stack);
    … …  
    154162      return false;
    155163    }
    156     ppStackFileActivation(config,PPSTACK_FILES_BKG ,false);   
     164    ppStackFileActivation(config, PPSTACK_FILES_BKG, false);   
     165
    157166    // Photometry
    158167    psTrace("ppStack", 1, "Photometering stacked image....\n");
    … …  
    184193        return false;
    185194    }
    186     //MEH -- also must uncomment back out..
     195    // MEH -- also must uncomment back out..
    187196    psFree(stack);
    188197    psLogMsg("ppStack", PS_LOG_INFO, "Stage 7: Cleanup, WCS & JPEGS: %f sec", psTimerClear("PPSTACK_STEPS"));

  • trunk/ppStack/src/ppStackLoop.h

    r36855 r42094  
    77    ppStackOptions *options             // Options for stacking
    88    );
     9
    910// Median only loop.
    1011bool ppStackMedianLoop(
    … …  
    1213    ppStackOptions *options             // Options for stacking
    1314    );
     15
     16// stack by percentile range
     17bool ppStackLoopByPercent(
     18  pmConfig *config,
     19  ppStackOptions *options
     20  );
    1421
    1522// Setup
    … …  
    9299
    93100
     101bool ppStackCombinePercent(ppStackThreadData *stack, ppStackOptions *options, pmConfig *config);
     102
    94103bool ppStackUpdateHeader(ppStackThreadData *stack, ppStackOptions *options, pmConfig *config);
    95104bool ppStackJPEGs(ppStackThreadData *stack, ppStackOptions *options, pmConfig *config);

  • trunk/ppStack/src/ppStackMatch.c

    r36364 r42094  
    524524        psFree(conv);
    525525    } else {
     526        // this branch is done if options->convolve is FALSE
    526527        // Match the normalisation
    527528        float norm = powf(10.0, -0.4 * options->norm->data.F32[index]); // Normalisation

  • trunk/ppStack/src/ppStackOptions.c

    r36855 r42094  
    5656    options->num = 0;
    5757    options->quality = 0;
     58
     59    options->clipPercent = false;
     60
    5861    options->psf = NULL;
    5962    options->sumExposure = NAN;

  • trunk/ppStack/src/ppStackOptions.h

    r36855 r42094  
    1616    int num;                            // Number of inputs
    1717    int quality;                        // Bad data quality flag
     18
     19    bool clipPercent;                   // use percentile range to clip?
     20
    1821    // Prepare
    1922    pmPSF *psf;                         // Target PSF

  • trunk/ppStack/src/ppStackPhotometry.c

    r33702 r42094  
    1919    ppStackFileActivation(config, PPSTACK_FILES_PHOT, true);
    2020    pmFPAview *photView = ppStackFilesIterateDown(config); // View to readout
    21     ppStackFileActivation(config, PPSTACK_FILES_STACK, true);
     21
     22    ppStackFileList stackFiles = options->convolve ? PPSTACK_FILES_STACK : PPSTACK_FILES_UNCONV;
     23    ppStackFileActivation(config, stackFiles, true);
    2224
    2325    pmFPAfile *photFile = psMetadataLookupPtr(NULL, config->files, "PSPHOT.INPUT"); // File for photometry
    … …  
    5759    // psphotSetNFrames
    5860    pmReadout *photRO = pmFPAviewThisReadout(photView, photFile->fpa);
    59     if (photRO && options->expRO->mask) {
     61    if (photRO && options->expRO && options->expRO->mask) {
    6062        psMetadataAddImage(photRO->analysis, PS_LIST_TAIL, "EXPNUM", PS_META_REPLACE, "EXPNUM image", options->expRO->mask);
    6163    }

  • trunk/ppStack/src/ppStackReadout.c

    r36886 r42094  
    1919                                         weightings, exposures, addVariance);
    2020    thread->busy = false;
     21
     22    thread->status = job->results ? PPSTACK_THREAD_SUCCESS : PPSTACK_THREAD_FAILURE;
     23
     24    psAssert(job->results, "Stacking failed.");
    2125
    2226    return job->results ? true : false;
    … …  
    4852    thread->busy = false;
    4953
     54    thread->status = status ? PPSTACK_THREAD_SUCCESS : PPSTACK_THREAD_FAILURE;
     55
    5056    psAssert(status, "Stacking failed.");
    5157
    … …  
    5359}
    5460
     61bool ppStackReadoutPercentThread(psThreadJob *job)
     62{
     63    PS_ASSERT_THREAD_JOB_NON_NULL(job, false);
     64
     65    psArray *args = job->args;          // Arguments
     66    ppStackThread *thread = args->data[0]; // Thread
     67    ppStackOptions *options = args->data[1]; // Options
     68    pmConfig *config = args->data[2];   // Configuration
     69
     70    pmReadout *outRO = options->outRO;  // Output readout
     71    pmReadout *expRO = options->expRO;  // Expmap readout
     72    psVector *mask = options->inputMask; // Mask for inputs
     73    psVector *weightings = options->weightings; // Weightings (1/noise^2) for each image
     74    psVector *exposures = options->exposures;   // Exposure times for each image
     75    psVector *addVariance = options->matchChi2; // Additional variance when rejecting
     76
     77    // fprintf (stderr, "start thread %d : scan range %d - %d\n", thread->entry, thread->firstScan, thread->lastScan);
     78
     79    bool status = ppStackReadoutPercent(config, outRO, expRO, thread->readouts, mask, weightings, exposures, addVariance);
     80
     81    thread->busy = false;
     82
     83    thread->status = status ? PPSTACK_THREAD_SUCCESS : PPSTACK_THREAD_FAILURE;
     84
     85    // fprintf (stderr, "finished thread %d, status %d : scan range %d - %d\n", thread->entry, thread->status, thread->firstScan, thread->lastScan);
     86
     87    psAssert(status, "Stacking failed.");
     88
     89    return status;
     90}
     91
     92////////////////////////////////////
    5593
    5694bool ppStackInspect(psThreadJob *job)
    … …  
    145183
    146184    int num = readouts->n;              // Number of inputs
    147     psArray *stack = psArrayAlloc(num); // Array for stacking
     185    psArray *stackData = psArrayAlloc(num); // Array of data to be stacked
    148186
    149187    for (int i = 0; i < num; i++) {
    … …  
    160198        }
    161199
    162         stack->data[i] = pmStackDataAlloc(ro, weightings->data.F32[i], exposures->data.F32[i],
     200        // stackData is an array of pmStackData structures
     201        stackData->data[i] = pmStackDataAlloc(ro, weightings->data.F32[i], exposures->data.F32[i],
    163202                                          addVariance->data.F32[i]);
    164203    }
    165204
    166     if (!pmStackCombine(outRO, NULL, stack, maskBad, maskSuspect, maskBlank, kernelSize, iter,
     205    if (!pmStackCombine(outRO, NULL, stackData, maskBad, maskSuspect, maskBlank, kernelSize, iter,
    167206                        combineRej, combineSys, combineDiscard, useVariance, safe, nminpix, false)) {
    168207        psError(PS_ERR_UNKNOWN, false, "Unable to combine input readouts with rejection.");
    169         psFree(stack);
     208        psFree(stackData);
     209       
     210        // XXX EAM : if pmStackCombine fails above this return will cause the thread to block.
     211        // The failure status results in a psThread.fault.  the psThreadLauncher function, which
     212        // each background thread runs as a loop, will sleep until the fault is cleared externally
     213        // by the handler.  psThreadPoolWait() catches, counts, and clears these faults, but
     214        // ppStackThreadRead does not. 
    170215        return false;
    171216    }
    … …  
    175220    psArray *reject = psArrayAlloc(num);  // List of pixels rejected
    176221    for (int i = 0; i < num; i++) {
    177         pmStackData *data = stack->data[i]; // Data for this image
     222        pmStackData *data = stackData->data[i]; // Data for this image
    178223        if (!data) {
    179224            continue;
    … …  
    186231        reject->data[i] = psMemIncrRefCounter(data->reject);
    187232    }
    188     psFree(stack);
     233    psFree(stackData);
    189234
    190235    //MEH change to trace
    … …  
    247292
    248293    int num = readouts->n;              // Number of inputs
    249     psArray *stack = psArrayAlloc(num); // Array for stacking
     294    psArray *stackData = psArrayAlloc(num); // Array of data to be stacked
    250295
    251296    // We have rejection from a previous combination: combine without flagging pixels to inspect
    … …  
    272317                                             addVariance ? addVariance->data.F32[i] : NAN);
    273318        data->reject = rejected ? psMemIncrRefCounter(rejected->data[i]) : NULL;
    274         stack->data[i] = data;
     319        stackData->data[i] = data;
    275320
    276321        //MEH -- apply bscale offset before norm   
    … …  
    288333    }
    289334
    290     if (!pmStackCombine(outRO, expRO, stack, maskBad, maskSuspect, maskBlank, 0, iter, combineRej,
     335    if (!pmStackCombine(outRO, expRO, stackData, maskBad, maskSuspect, maskBlank, 0, iter, combineRej,
    291336                        combineSys, combineDiscard, useVariance, safe, nminpix, rejected)) {
    292337        psError(PS_ERR_UNKNOWN, false, "Unable to combine input readouts.");
    293         psFree(stack);
     338        psFree(stackData);
    294339        return false;
    295340    }
    … …  
    307352    expChip->data_exists = true;
    308353
    309     psFree(stack);
     354    psFree(stackData);
    310355
    311356    //MEH change to trace
    … …  
    316361    return true;
    317362}
     363
     364// NOTE: expRO is allowed to be NULL
     365bool ppStackReadoutPercent(const pmConfig *config, pmReadout *outRO, pmReadout *expRO, const psArray *readouts,
     366                               const psVector *mask, const psVector *weightings, const psVector *exposures,
     367                               const psVector *addVariance)
     368{
     369    assert(config);
     370    assert(outRO);
     371    assert(readouts);
     372    assert(mask && mask->n == readouts->n && mask->type.type == PS_TYPE_VECTOR_MASK);
     373    assert(weightings && weightings->n == readouts->n && weightings->type.type == PS_TYPE_F32);
     374    assert(addVariance && addVariance->n == readouts->n && addVariance->type.type == PS_TYPE_F32);
     375    static int sectionNum = 0;          // Section number; for debugging outputs
     376
     377    // fprintf (stderr, "starting ReadoutPercent, %d\n", sectionNum);
     378
     379    // Get the recipe values
     380    psMetadata *recipe = psMetadataLookupMetadata(NULL, config->recipes, PPSTACK_RECIPE); // ppStack recipe
     381    psAssert(recipe, "We've thrown an error on this before.");
     382
     383    bool mdok;                          // Status of MD lookup
     384    psF64 rejectFraction = psMetadataLookupF32(&mdok, recipe, "COMBINE.REJECT.FRACTION"); // fraction of outliers to reject
     385
     386    char defaultBlankStr[16] = "BLANK";
     387
     388    psString maskBadStr     = psMetadataLookupStr(&mdok, recipe, "MASK.VAL"); // Name of bits to mask for bad
     389    psString maskSuspectStr = psMetadataLookupStr(&mdok, recipe, "MASK.SUSPECT"); // Name of suspect mask bits
     390    psString maskBlankStr   = psMetadataLookupStr(&mdok, recipe, "MASK.BLANK"); // Name of bits to set for empty pixels
     391    if (!maskBlankStr) {
     392      maskBlankStr = psMetadataLookupStr(&mdok, recipe, "MASK.BAD"); // Old name for MASK.BLANK
     393    }
     394    if (!maskBlankStr) {
     395      maskBlankStr = defaultBlankStr; // this is statically allocated above
     396    }
     397
     398    psImageMaskType maskBad     = pmConfigMaskGet(maskBadStr, config); // Bits to mask for bad pixels
     399    psImageMaskType maskSuspect = pmConfigMaskGet(maskSuspectStr, config); // Suspect bits
     400    psImageMaskType maskBlank   = pmConfigMaskGet(maskBlankStr, config); // Bits to mask for bad pixels
     401
     402    int num = readouts->n;              // Number of inputs
     403    psArray *stackData = psArrayAlloc(num); // Array of data to be stacked
     404
     405    for (int i = 0; i < num; i++) {
     406        stackData->data[i] = NULL;
     407
     408        pmReadout *ro = readouts->data[i];
     409        if (!ro || mask->data.PS_TYPE_VECTOR_MASK_DATA[i]) {
     410            // Bad image
     411            continue;
     412        }
     413
     414        // Ensure there is a mask, or pmStackCombine will complain
     415        if (!ro->mask) {
     416            ro->mask = psImageAlloc(ro->image->numCols, ro->image->numRows, PS_TYPE_IMAGE_MASK);
     417            psImageInit(ro->mask, 0);
     418        }
     419
     420        stackData->data[i] = pmStackDataAlloc(ro, weightings->data.F32[i], exposures->data.F32[i],
     421                                              addVariance->data.F32[i]);
     422    }
     423
     424    if (!pmStackCombineByPercentile(outRO, expRO, stackData, rejectFraction, maskBad, maskSuspect, maskBlank)) {
     425        psError(PS_ERR_UNKNOWN, false, "Unable to combine input readouts with rejection.");
     426        psFree(stackData);
     427        return false;
     428    }
     429
     430    outRO->data_exists = true;                 // output readout
     431    outRO->parent->data_exists = true;         // output cell
     432    outRO->parent->parent->data_exists = true; // output chip
     433
     434    if (expRO) {
     435      expRO->data_exists = true;                 // expmap readout
     436      expRO->parent->data_exists = true;               // expmap cell   
     437      expRO->parent->parent->data_exists = true; // expmap chip
     438    }
     439     
     440    psFree(stackData);
     441    sectionNum++;
     442
     443    return true;
     444}
     445
     446

  • trunk/ppStack/src/ppStackSetup.c

    r35167 r42094  
    1818    options->convolve = psMetadataLookupBool(NULL, recipe, "CONVOLVE"); // Convolve images?
    1919    options->doBackground = psMetadataLookupBool(NULL, recipe, "BACKGROUND.MODEL");
     20
     21    options->clipPercent  = psMetadataLookupBool(NULL, recipe, "COMBINE.PERCENT"); // use percentile range to clip?
    2022
    2123    if (!psMetadataLookupBool(NULL, config->arguments, "HAVE.PSF")) {

  • trunk/ppStack/src/ppStackSources.c

    r41529 r42094  
    341341            options->norm = psVectorAlloc(num, PS_TYPE_F32);
    342342            for (int i = 0; i < num; i++) {
    343               if (!isfinite(trans->data.F32[i])) {
    344                 continue;
    345               }
     343                if (!isfinite(trans->data.F32[i])) {
     344                    psLogMsg("ppStack", PS_LOG_INFO, "Non-finite transparency, skipping correction for image %d: %f mag (%f) (with inputMask value %d)\n",
     345                             i, NAN, trans->data.F32[i], inputMask->data.U8[i]);
     346                    continue;
     347                }
    346348                psArray *sources = sourceLists->data[i]; // Sources of interest
    347349                float magCorr = zp->data.F32[i] - trans->data.F32[i] - 2.5*log10(options->sumExposure) - airmassTerm * airmassTarget;

  • trunk/ppStack/src/ppStackThread.c

    r36855 r42094  
    1919    thread->firstScan = 0;
    2020    thread->lastScan = 0;
     21    thread->entry = -1; // this gets assigned after allocation
     22    thread->status = PPSTACK_THREAD_NEW;
    2123    return thread;
    2224}
    … …  
    124126            readouts->data[j] = ro;
    125127        }
    126         threads->data[i] = ppStackThreadAlloc(readouts);
     128        ppStackThread *thread = ppStackThreadAlloc(readouts);
     129        thread->entry = i;
     130        threads->data[i] = thread;
    127131        psFree(readouts);               // Drop reference
    128132    }
    … …  
    157161    while (true) {
    158162        // check for any groups which can read data
     163        // NOTE: threads->n is set (in ppStackThreadDataSetup) to be 1 more than the argument to -threads
    159164        for (int j = 0; j < threads->n; j++) {
    160165            ppStackThread *thread = threads->data[j];
     166            // fprintf (stderr, "grab thread %d, scan: %d - %d : busy: %d read: %d status: %d\n", thread->entry, thread->firstScan, thread->lastScan, thread->busy, thread->read, thread->status);
    161167            if (thread->read) {
    162168                continue;
    … …  
    166172            thread->lastScan = stack->lastScan + rows;
    167173            stack->lastScan = thread->lastScan;
     174            thread->status = PPSTACK_THREAD_READ;
    168175
    169176            psArray *readouts = thread->readouts;
    … …  
    172179
    173180            psTrace("ppStack", 2, "Reading data for chunk %d into group %d....\n", numChunk, j);
     181            // fprintf (stderr, "Reading data for chunk %d into group %d (thread %d, scan: %d - %d)....\n", numChunk, j, thread->entry, thread->firstScan, thread->lastScan);
    174182            for (int i = 0; i < readouts->n; i++) {
    175183                pmReadout *ro = readouts->data[i]; // Input readout
    … …  
    178186                }
    179187
     188                // fprintf (stderr, "read data for readout %d\n", i);
     189
    180190                // override the recorded last scan
    181                 ro->thisImageScan  = thread->firstScan;
     191                ro->thisImageScan    = thread->firstScan;
    182192                ro->thisVarianceScan = thread->firstScan;
    183                 ro->thisMaskScan   = thread->firstScan;
    184                 ro->lastImageScan  = thread->lastScan;
    185                 ro->lastMaskScan   = thread->lastScan;
     193                ro->thisMaskScan     = thread->firstScan;
     194                ro->lastImageScan    = thread->lastScan;
     195                ro->lastMaskScan     = thread->lastScan;
    186196                ro->lastVarianceScan = thread->lastScan;
    187                 ro->forceScan      = true;
    188 
    189                 psFits *imageFits  = stack->imageFits->data[i]; // FITS file for image
    190                 psFits *maskFits   = stack->maskFits->data[i]; // FITS file for mask
     197                ro->forceScan        = true;
     198
     199                psFits *imageFits    = stack->imageFits->data[i]; // FITS file for image
     200                psFits *maskFits     = stack->maskFits->data[i]; // FITS file for mask
    191201                psFits *varianceFits = stack->varianceFits->data[i]; // FITS file for variance
    192202
    … …  
    232242
    233243            thread->read = thread->busy = true;
     244            thread->status = PPSTACK_THREAD_RUN;
    234245            return thread;
    235246        }
    … …  
    239250        for (int j = 0; j < threads->n; j++) {
    240251            ppStackThread *thread = threads->data[j];
     252            // fprintf (stderr, "test thread %d, scan: %d - %d : busy: %d, read: %d, status: %d\n", thread->entry, thread->firstScan, thread->lastScan, thread->busy, thread->read, thread->status);
     253
    241254            if (thread->busy) {
    242255                continue;
    243256            }
     257            thread->status = PPSTACK_THREAD_NEW;
    244258            thread->read = false;
    245259            wait = false;
    … …  
    283297    }
    284298
     299    {
     300        psThreadTask *task = psThreadTaskAlloc("PPSTACK_PERCENT_COMBINE", 3);
     301        task->function = &ppStackReadoutPercentThread;
     302        psThreadTaskAdd(task);
     303        psFree(task);
     304    }
    285305    return;
    286306}

  • trunk/ppStack/src/ppStackThread.h

    r34800 r42094  
    1111    int firstScan;                      // First row of the chunk to be read for this group
    1212    int lastScan;                       // Last row of the chunk to be read for this group
     13    int entry;                          // thread number for tracking progress
     14    int status;                         // thread number for tracking progress
    1315} ppStackThread;
    1416
    … …  
    4749
    4850
     51enum {PPSTACK_THREAD_NEW, PPSTACK_THREAD_READ, PPSTACK_THREAD_RUN, PPSTACK_THREAD_SUCCESS, PPSTACK_THREAD_FAILURE};
     52
     53
    4954#endif
Note: See TracChangeset for help on using the changeset viewer.