IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 9730 for trunk/psModules


Ignore:
Timestamp:
Oct 24, 2006, 12:55:05 PM (20 years ago)
Author:
Paul Price
Message:

Following today's meeting, we agreed that psVectorAlloc (and therefore
psArrayAlloc also) shall set the number of elements in use to equal the
number of elements allocated. We introduce new functions,
psVectorAllocEmpty and psArrayAllocEmpty, that allocate a vector and set
the length to zero.

Location:
trunk/psModules/src
Files:
29 edited

Legend:

Unmodified
Added
Removed

  • trunk/psModules/src/astrom/pmAstrometryDistortion.c

    r8815 r9730  
    77*  @author EAM, IfA
    88*
    9 *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
    10 *  @date $Date: 2006-09-15 09:49:01 $
     9*  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
     10*  @date $Date: 2006-10-24 22:55:04 $
    1111*
    1212*  Copyright 2006 Institute for Astronomy, University of Hawaii
    … …  
    5454
    5555    if (grads == NULL) {
    56         grads = psArrayAlloc (100);
     56        grads = psArrayAllocEmpty (100);
    5757    }
    5858
    … …  
    7676            int Ymax = Ymin + DY;
    7777
    78             psVector *L  = psVectorAlloc (100, PS_TYPE_F32);
    79             psVector *M  = psVectorAlloc (100, PS_TYPE_F32);
    80             psVector *dP = psVectorAlloc (100, PS_TYPE_F32);
    81             psVector *dQ = psVectorAlloc (100, PS_TYPE_F32);
     78            psVector *L  = psVectorAllocEmpty (100, PS_TYPE_F32);
     79            psVector *M  = psVectorAllocEmpty (100, PS_TYPE_F32);
     80            psVector *dP = psVectorAllocEmpty (100, PS_TYPE_F32);
     81            psVector *dQ = psVectorAllocEmpty (100, PS_TYPE_F32);
    8282            int Npts = 0;
    8383
    … …  
    121121            psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_MEDIAN | PS_STAT_SAMPLE_STDEV);
    122122            psVector *mask = psVectorAlloc (Npts, PS_TYPE_MASK);
    123             mask->n = Npts;
    124123            psVectorInit (mask, 0);
    125124
    … …  
    175174        M->data.F32[i] = grad->FP.y;
    176175    }
    177     dPdL->n = dQdL->n = dPdM->n = dQdM->n = grads->n;
    178     L->n = M->n = grads->n;
    179176
    180177    psStats *stats = psStatsAlloc (PS_STAT_SAMPLE_MEDIAN | PS_STAT_SAMPLE_STDEV);
    181178    psVector *mask = psVectorAlloc (grads->n, PS_TYPE_MASK);
    182     mask->n = grads->n;
    183179    psVectorInit (mask, 0);
    184180

  • trunk/psModules/src/astrom/pmAstrometryObjects.c

    r9639 r9730  
    88*  @author EAM, IfA
    99*
    10 *  @version $Revision: 1.17 $ $Name: not supported by cvs2svn $
    11 *  @date $Date: 2006-10-19 02:56:40 $
     10*  @version $Revision: 1.18 $ $Name: not supported by cvs2svn $
     11*  @date $Date: 2006-10-24 22:55:04 $
    1212*
    1313*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    7676                            const double RADIUS) // matching radius
    7777{
    78     psArray *matches = psArrayAlloc(x1->n);
    79     matches->n = 0;
     78    psArray *matches = psArrayAllocEmpty(x1->n);
    8079
    8180    const double RADIUS_SQR = PS_SQR(RADIUS);
    … …  
    144143    /* sort both lists by X coord; st1 first */ \
    145144    psVector *x1 = psVectorAlloc(st1->n, PS_TYPE_F64); \
    146     \
    147     x1->n = x1->nalloc; \
    148145    for (int i = 0; i < st1->n; i++) { \
    149146        x1->data.F64[i] = ((pmAstromObj *)st1->data[i])->MEMBER->x; \
    … …  
    153150    \
    154151    psVector *y1 = psVectorAlloc(st1->n, PS_TYPE_F64); \
    155     y1->n = y1->nalloc; \
    156152    for (int i = 0; i < st1->n; i++) { \
    157153        x1->data.F64[i] = ((pmAstromObj *)st1->data[sorted1->data.S32[i]])->MEMBER->x; \
    … …  
    161157    /* now st2 */ \
    162158    psVector *x2 = psVectorAlloc(st2->n, PS_TYPE_F64); \
    163     x2->n = x2->nalloc; \
    164159    for (int i = 0; i < st2->n; i++) { \
    165160        x2->data.F64[i] = ((pmAstromObj *)st2->data[i])->MEMBER->x; \
    … …  
    168163    \
    169164    psVector *y2 = psVectorAlloc(st2->n, PS_TYPE_F64); \
    170     y2->n = y2->nalloc; \
    171165    for (int i = 0; i < st2->n; i++) { \
    172166        x2->data.F64[i] = ((pmAstromObj *)st2->data[sorted2->data.S32[i]])->MEMBER->x; \
    … …  
    236230    psVector *y = psVectorAlloc (match->n, PS_TYPE_F32);
    237231    psVector *wt = psVectorAlloc (match->n, PS_TYPE_F32);
    238     X->n = X->nalloc;
    239     Y->n = Y->nalloc;
    240     x->n = x->nalloc;
    241     y->n = y->nalloc;
    242     wt->n = wt->nalloc;
    243232    // take the matched stars, first fit
    244233    for (int i = 0; i < match->n; i++) {
    … …  
    259248    // constant errors
    260249    psVector *mask = psVectorAlloc (match->n, PS_TYPE_U8);
    261     mask->n = match->n;
    262250    psVectorInit (mask, 0);
    263251
    … …  
    352340
    353341    psArray *new = psArrayAlloc (old->n);
    354     new->n = new->nalloc;
    355342    double cs = cos(angle);
    356343    double sn = sin(angle);
    … …  
    659646    // sort the NP values and choose
    660647    psVector *listNP = psVectorAlloc (nPix*nPix, PS_TYPE_U32);
    661     listNP->n = nPix*nPix;
    662648    int n = 0;
    663649    for (int i = 0; i < nPix; i++) {
    … …  
    780766    psVector *xHist = psVectorAlloc (nBin, PS_TYPE_F32);
    781767    psVector *yHist = psVectorAlloc (nBin, PS_TYPE_F32);
    782     xHist->n = yHist->n = nBin;
    783768    psVectorInit (xHist, 0);
    784769    psVectorInit (yHist, 0);

  • trunk/psModules/src/camera/pmFPAConstruct.c

    r9701 r9730  
    6161    *second = psArrayAlloc(values->n);
    6262    *third = psArrayAlloc(values->n);
    63     (*first)->n = (*second)->n = (*third)->n = values->n;
    6463    int num = 0;
    6564    psListIterator *valuesIter = psListIteratorAlloc(values, PS_LIST_HEAD, false); // Iterator for values

  • trunk/psModules/src/camera/pmFPAMaskWeight.c

    r9594 r9730  
    2929    if (!masks) {
    3030        masks = psArrayAlloc(images->n);
    31         masks->n = images->n;
    3231        hdu->masks = masks;
    3332    }
    … …  
    5655    if (!weights) {
    5756        weights = psArrayAlloc(images->n);
    58         weights->n = images->n;
    5957        hdu->weights = weights;
    6058    }

  • trunk/psModules/src/camera/pmHDUGenerate.c

    r9603 r9730  
    294294    // Generate the HDU
    295295    hdu->images = psArrayAlloc(numReadouts);
    296     hdu->images->n = numReadouts;
    297296    for (int i = 0; i < numReadouts; i++) {
    298297        psImage *image = psImageAlloc(xSize, ySize, type);

  • trunk/psModules/src/concepts/pmConceptsWrite.c

    r9572 r9730  
    5151        }
    5252        psVector *match = psVectorAlloc(cList->n, PS_TYPE_U8); // Array indicating which values match
    53         match->n = cList->n;
    5453        psVectorInit(match, 0);
    5554        psListIterator *cIter = psListIteratorAlloc(cList, PS_LIST_HEAD, false); // compare iterator

  • trunk/psModules/src/config/pmConfig.c

    r9591 r9730  
    44 *  @author EAM (IfA)
    55 *
    6  *  @version $Revision: 1.49 $ $Name: not supported by cvs2svn $
    7  *  @date $Date: 2006-10-17 01:25:22 $
     6 *  @version $Revision: 1.50 $ $Name: not supported by cvs2svn $
     7 *  @date $Date: 2006-10-24 22:55:05 $
    88 *
    99 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    883883
    884884    // we load all input files onto a psArray, to be parsed later
    885     psArray *input = psArrayAlloc (16);
    886     input->n = 0;
     885    psArray *input = psArrayAllocEmpty(16);
    887886
    888887    // load the list of filenames the supplied file

  • trunk/psModules/src/detrend/pmFlatNormalize.c

    r9614 r9730  
    3232        } else {
    3333            *expFluxesPtr = psVectorAlloc(numExps, PS_TYPE_F32);
    34             (*expFluxesPtr)->n = numExps;
    3534        }
    3635        expFluxes = psMemIncrRefCounter(*expFluxesPtr);
    3736    } else {
    3837        expFluxes = psVectorAlloc(numExps, PS_TYPE_F32);
    39         expFluxes->n = numExps;
    4038    }
    4139
    … …  
    4745        } else {
    4846            *chipGainsPtr = psVectorAlloc(numChips, PS_TYPE_F32);
    49             (*chipGainsPtr)->n = numChips;
    5047            psVectorInit(*chipGainsPtr, 1.0);
    5148        }
    … …  
    5350    } else {
    5451        chipGains = psVectorAlloc(numChips, PS_TYPE_F32);
    55         chipGains->n = numChips;
    5652        psVectorInit(chipGains, 1.0);
    5753    }
    … …  
    6258    psImageInit(fluxMask, 0);
    6359    psVector *gainMask = psVectorAlloc(numChips, PS_TYPE_U8); // Mask for bad gains
    64     gainMask->n = numChips;
    6560    psVectorInit(gainMask, 0);
    6661    psVector *expMask = psVectorAlloc(numExps, PS_TYPE_U8); // Mask for bad exposures
    67     expMask->n = numExps;
    6862    psVectorInit(expMask, 0);
    6963    for (int i = 0; i < numChips; i++) {

  • trunk/psModules/src/detrend/pmFringeStats.c

    r9615 r9730  
    133133
    134134    psArray *table = psArrayAlloc(numRows); // The table
    135     table->n = numRows;
    136135    // Translate the vectors into the required format for psFitsWriteTable()
    137136    for (long i = 0; i < numRows; i++) {
    … …  
    205204    psVector *y = psVectorAlloc(numRows, PS_TYPE_F32); // y position
    206205    psVector *mask = psVectorAlloc(numRows, PS_TYPE_U8); // mask
    207     x->n = y->n = mask->n = numRows;
    208206    regions->x = x;
    209207    regions->y = y;
    … …  
    253251    stats->f = psVectorAlloc(numRegions, PS_TYPE_F32);
    254252    stats->df = psVectorAlloc(numRegions, PS_TYPE_F32);
    255     stats->f->n = stats->df->n = numRegions;
    256253
    257254    return stats;
    … …  
    365362    // Vectors: f, df
    366363    psArray *table = psArrayAlloc(numRows); // The table
    367     table->n = numRows;
    368364    // Translate the vectors into the required format for psFitsWriteTable()
    369365    for (long i = 0; i < numRows; i++) {
    … …  
    527523    scale->coeff = psVectorAlloc(nFringeFrames + 1, PS_TYPE_F32);
    528524    scale->coeffErr = psVectorAlloc(nFringeFrames + 1, PS_TYPE_F32);
    529     scale->coeff->n = nFringeFrames + 1;
    530     scale->coeff->n = nFringeFrames + 1;
    531525
    532526    return scale;
    … …  
    551545    psImage *A = psImageAlloc(numCoeffs, numCoeffs, PS_TYPE_F64); // The least-squares matrix
    552546    psVector *B = psVectorAlloc(numCoeffs, PS_TYPE_F64); // The least-squares vector
    553     B->n = numCoeffs;
    554547
    555548    // Generate the least-squares matrix and vector
    … …  
    718711    if (!regions->mask) {
    719712        regions->mask = psVectorAlloc(numRegions, PS_TYPE_U8);
    720         regions->mask->n = numRegions;
    721713        psVectorInit(regions->mask, 0);
    722714    }
    … …  
    725717    unsigned int numClipped = 0;        // Total number clipped
    726718    psVector *diff = psVectorAlloc(numRegions, PS_TYPE_F32); // The differences between obs. and pred.
    727     diff->n = numRegions;
    728719
    729720    pmFringeScale *scale = pmFringeScaleAlloc(fringes->n); // The fringe scales

  • trunk/psModules/src/detrend/pmShutterCorrection.c

    r9618 r9730  
    104104    psVector *tmpX = psVectorAlloc(2, PS_TYPE_F32);
    105105    psVector *tmpY = psVectorAlloc(2, PS_TYPE_F32);
    106     tmpX->n = tmpY->n = 2;
    107106
    108107    long index;
    … …  
    210209    psVector *x = psVectorAlloc(exptime->n, PS_TYPE_F32);
    211210    psVector *y = psVectorAlloc(exptime->n, PS_TYPE_F32);
    212     x->n = y->n = exptime->n;
    213211
    214212    for (long i = 0; i < exptime->n; i++) {
    … …  
    301299    params->data.F32[1] = guess->offset;
    302300    params->data.F32[2] = guess->offref;
    303     params->n = 3;
    304301
    305302    // XXX for the moment, don't set any constraints
    … …  
    317314    // construct the coordinate and value entries (y is counts)
    318315    psArray *x = psArrayAlloc(exptime->n); // Coordinates
    319     x->n = exptime->n;
    320316
    321317    for (long i = 0; i < exptime->n; i++) {
    322318        psVector *coord = psVectorAlloc(1, PS_TYPE_F32);
    323         coord->n = 1;
    324319        coord->data.F32[0] = exptime->data.F32[i];
    325320        x->data[i] = coord;
    … …  
    371366    psRegion refRegion;                 // Reference region
    372367    psVector *refs = psVectorAlloc(num, PS_TYPE_F32); // Reference measurements
    373     refs->n = num;
    374368    psVectorInit(refs, 0);
    375369    psArray *regions = psArrayAlloc(MEASURE_SAMPLES); // Array of sample regions, made on each image
    376     regions->n = MEASURE_SAMPLES;
    377370    psImage *samplesMean = psImageAlloc(num, MEASURE_SAMPLES, PS_TYPE_F32); // Measurements for each file
    378371    psImage *samplesStdev = psImageAlloc(num, MEASURE_SAMPLES, PS_TYPE_F32); // Errors for each file
    … …  
    505498    psImage *pattern = psImageAlloc(numCols, numRows, PS_TYPE_F32); // Illumination pattern
    506499    psVector *mask = psVectorAlloc(num, PS_TYPE_U8); // Mask for each image
    507     mask->n = num;
    508500    psVectorInit(mask, 0);
    509501    psTrace("psModules.detrend", 2, "Performing linear fit on individual pixels...\n");

  • trunk/psModules/src/detrend/pmSubtractBias.c

    r9619 r9730  
    129129    psVector *ordinate = psVectorAlloc(pixels->n, PS_TYPE_F32); // Ordinate
    130130    psVector *mask = psVectorAlloc(pixels->n, PS_TYPE_U8); // Mask for fitting
    131     reduced->n = ordinate->n = mask->n = pixels->n;
    132131
    133132    for (int i = 0; i < pixels->n; i++) {
    … …  
    268267                // The read direction is rows
    269268                psArray *pixels = psArrayAlloc(image->numRows); // Array of vectors containing pixels
    270                 pixels->n = image->numRows;
    271269                for (int i = 0; i < pixels->n; i++) {
    272270                    psVector *values = psVectorAlloc(0, PS_TYPE_F32);
    … …  
    312310                // The read direction is columns
    313311                psArray *pixels = psArrayAlloc(image->numCols); // Array of vectors containing pixels
    314                 pixels->n = image->numCols;
    315312                for (int i = 0; i < pixels->n; i++) {
    316313                    psVector *values = psVectorAlloc(0, PS_TYPE_F32);

  • trunk/psModules/src/detrend/pmSubtractSky.c

    r9541 r9730  
    66 *  @author GLG, MHPCC
    77 *
    8  *  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2006-10-13 22:11:02 $
     8 *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2006-10-24 22:55:05 $
    1010 *
    1111 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    345345    psImage *Aout = psImageAlloc(localPolyTerms, localPolyTerms, PS_TYPE_F64);
    346346    psVector *B = psVectorAlloc(localPolyTerms, PS_TYPE_F64);
    347     B->n = B->nalloc;
    348347    psVector *outPerm = NULL;
    349348
    … …  
    412411    PS_ASSERT_IMAGE_NON_EMPTY(Aout, NULL);
    413412    psVector *C = psVectorAlloc(localPolyTerms, PS_TYPE_F64);
    414     C->n = C->nalloc;
    415413    psMatrixLUSolve(C, Aout, B, outPerm);
    416414

  • trunk/psModules/src/imcombine/pmImageCombine.c

    r8815 r9730  
    88 *  @author GLG, MHPCC
    99 *
    10  *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
    11  *  @date $Date: 2006-09-15 09:49:01 $
     10 *  @version $Revision: 1.9 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2006-10-24 22:55:05 $
    1212 *
    1313 *  XXX: pmRejectPixels() has a known bug with the pmImageTransform() call.
    … …  
    122122    if (*questionablePixels == NULL) {
    123123        *questionablePixels = psArrayAlloc(numImages);
    124         (*questionablePixels)->n = numImages;
    125124    } else if ((*questionablePixels)->n != numImages) {
    126125        *questionablePixels = psArrayRealloc(*questionablePixels, numImages);
    … …  
    137136    psVector *qpPtr = psVectorAlloc(numImages, PS_TYPE_S32);
    138137    psVectorInit(qpPtr, 0);
    139     qpPtr->n = numImages;
    140138    //
    141139    // Allocate the necessary psVectors for the call to psVectorStats().
    … …  
    144142    //
    145143    psVector *pixelData = psVectorAlloc(numImages, PS_TYPE_F32);
    146     pixelData->n = pixelData->nalloc;
    147144    psVector *pixelMask = NULL;
    148145    if (masks != NULL) {
    149146        pixelMask = psVectorAlloc(numImages, PS_TYPE_U8);
    150147        psVectorInit(pixelMask, 0);
    151         pixelMask->n = numImages;
    152148    }
    153149
    … …  
    156152        pixelErrors = psVectorAlloc(numImages, PS_TYPE_F32);
    157153        psVectorInit(pixelErrors, 1.0);
    158         pixelErrors->n = numImages;
    159154    }
    160155
    … …  
    320315    psVector *pixels = psVectorAlloc(8, PS_TYPE_F32); // Array of pixels
    321316    psVector *mask = psVectorAlloc(8, PS_TYPE_U8); // Corresponding mask
    322     pixels->n = 8;
    323     mask->n = 8;
    324317
    325318    // Get limits
    … …  
    538531    //
    539532    psArray *rejects = psArrayAlloc(numImages);
    540     rejects->n = numImages;
    541533    for (psS32 im = 0 ; im < numImages ; im++) {
    542534        rejects->data[im] = (psPtr *) psPixelsAlloc(PS_REJECT_PIXEL_INITIAL_PIXEL_LIST_LENGTH);
    … …  
    550542    psVector *rPtr = psVectorAlloc(numImages, PS_TYPE_S32);
    551543    psVectorInit(rPtr, 0);
    552     rPtr->n = numImages;
    553544
    554545    psS32 numCols = ((psImage *) images->data[0])->numCols;

  • trunk/psModules/src/imcombine/pmImageSubtract.c

    r8815 r9730  
    77 *  @author GLG, MHPCC
    88 *
    9  *  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2006-09-15 09:49:01 $
     9 *  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2006-10-24 22:55:05 $
    1111 *
    1212 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    122122    tmp->u = psVectorAlloc(nBF, PS_TYPE_F32);
    123123    tmp->v = psVectorAlloc(nBF, PS_TYPE_F32);
    124     tmp->u->n = tmp->u->nalloc;
    125     tmp->v->n = tmp->v->nalloc;
    126124    tmp->sigma = NULL;
    127125    tmp->xOrder = psVectorAlloc(nBF, PS_TYPE_F32);
    128     tmp->xOrder->n = tmp->xOrder->nalloc;
    129126    tmp->yOrder = psVectorAlloc(nBF, PS_TYPE_F32);
    130     tmp->yOrder->n = tmp->yOrder->nalloc;
    131127    tmp->subIndex = 0;
    132128    tmp->preCalc = NULL;
    … …  
    223219    tmp->u = psVectorAlloc(nBF, PS_TYPE_F32);
    224220    tmp->v = psVectorAlloc(nBF, PS_TYPE_F32);
    225     tmp->u->n = tmp->u->nalloc;
    226     tmp->v->n = tmp->v->nalloc;
    227221    tmp->sigma = psVectorAlloc(nBF, PS_TYPE_F32);
    228222    tmp->xOrder = psVectorAlloc(nBF, PS_TYPE_F32);
    … …  
    232226    tmp->spatialOrder = spatialOrder;
    233227    tmp->preCalc = psArrayAlloc(nBF);
    234     tmp->u->n = tmp->u->nalloc;
    235     tmp->v->n = tmp->v->nalloc;
    236     tmp->sigma->n = tmp->sigma->nalloc;
    237     tmp->xOrder->n = tmp->xOrder->nalloc;
    238     tmp->yOrder->n = tmp->yOrder->nalloc;
    239     tmp->preCalc->n = tmp->preCalc->nalloc;
    240228
    241229    //
    … …  
    367355    } else {
    368356        stamps = (psArray *) psArrayAlloc(xNum * yNum);
    369         stamps->n = stamps->nalloc;
    370357        for (psS32 s = 0 ; s < (xNum * yNum) ; s++) {
    371358            stamps->data[s] = (psPtr *) p_pmStampAlloc(PM_STAMP_REJECTED);
    … …  
    826813            if (stampVector == NULL) {
    827814                stampVector = psVectorAlloc(numSolveParams, PS_TYPE_F64);
    828                 stampVector->n = stampVector->nalloc;
    829815                stamp->vector = stampVector;
    830816            } else {
    … …  
    10451031    } else {
    10461032        solution = psVectorAlloc(size, PS_TYPE_F64);
    1047         solution->n = solution->nalloc;
    10481033    }
    10491034
    … …  
    10571042    psImage *sumMatrix = psImageAlloc(size, size, PS_TYPE_F64);
    10581043    psVector *sumVector = psVectorAlloc(size, PS_TYPE_F64);
    1059     sumVector->n = sumVector->nalloc;
    10601044    psVectorInit(sumVector, 0.0);
    10611045    psImageInit(sumMatrix, 0.0);
    … …  
    11501134    } else {
    11511135        deviations = psVectorAlloc(stamps->n, PS_TYPE_F32);
    1152         deviations->n = deviations->nalloc;
    11531136        // XXX: Probably not necessary.
    11541137        psVectorInit(deviations, 0.0);

  • trunk/psModules/src/imcombine/pmReadoutCombine.c

    r9611 r9730  
    201201
    202202    psVector *pixels = psVectorAlloc(inputs->n, PS_TYPE_F32); // Stack of pixels
    203     pixels->n = inputs->n;
    204203    psF32 *pixelsData = pixels->data.F32; // Dereference pixels
    205204
    206205    psVector *mask   = psVectorAlloc(inputs->n, PS_TYPE_U8); // Mask for stack
    207     mask->n = inputs->n;
    208206    psU8 *maskData = mask->data.U8;     // Dereference mask
    209207
    … …  
    212210    if (haveWeights) {
    213211        weights = psVectorAlloc(inputs->n, PS_TYPE_F32); // Stack of weights
    214         weights->n = inputs->n;
    215212        weightsData = weights->data.F32;
    216213    }

  • trunk/psModules/src/objects/models/pmModel_GAUSS.c

    r9675 r9730  
    4545    *params_min = psVectorAlloc (7, PS_TYPE_F32);
    4646    *params_max = psVectorAlloc (7, PS_TYPE_F32);
    47     (*beta_lim)->n = (*beta_lim)->nalloc;
    48     (*params_min)->n = (*params_min)->nalloc;
    49     (*params_max)->n = (*params_max)->nalloc;
    5047
    5148    beta_lim[0][0].data.F32[PM_PAR_SKY] = 1000;

  • trunk/psModules/src/objects/models/pmModel_PGAUSS.c

    r9621 r9730  
    4848    *params_min = psVectorAlloc (7, PS_TYPE_F32);
    4949    *params_max = psVectorAlloc (7, PS_TYPE_F32);
    50     (*beta_lim)->n = (*beta_lim)->nalloc;
    51     (*params_min)->n = (*params_min)->nalloc;
    52     (*params_max)->n = (*params_max)->nalloc;
    5350
    5451    beta_lim[0][0].data.F32[0] = 1000;

  • trunk/psModules/src/objects/models/pmModel_QGAUSS.c

    r9676 r9730  
    6363    *params_min = psVectorAlloc (8, PS_TYPE_F32);
    6464    *params_max = psVectorAlloc (8, PS_TYPE_F32);
    65     (*beta_lim)->n = (*beta_lim)->nalloc;
    66     (*params_min)->n = (*params_min)->nalloc;
    67     (*params_max)->n = (*params_max)->nalloc;
    6865
    6966    beta_lim[0][0].data.F32[PM_PAR_SKY] = 1000;

  • trunk/psModules/src/objects/models/pmModel_SGAUSS.c

    r9621 r9730  
    6767    *params_min = psVectorAlloc (9, PS_TYPE_F32);
    6868    *params_max = psVectorAlloc (9, PS_TYPE_F32);
    69     (*beta_lim)->n = (*beta_lim)->nalloc;
    70     (*params_min)->n = (*params_min)->nalloc;
    71     (*params_max)->n = (*params_max)->nalloc;
    7269
    7370    beta_lim[0][0].data.F32[0] = 1000;

  • trunk/psModules/src/objects/pmGrowthCurve.c

    r8886 r9730  
    55 *  @author EAM, IfA
    66 *
    7  *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
    8  *  @date $Date: 2006-09-22 21:35:34 $
     7 *  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
     8 *  @date $Date: 2006-10-24 22:55:05 $
    99 *
    1010 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    4040    growth->radius = psVectorCreate (NULL, minRadius, maxRadius, 1.0, PS_TYPE_F32);
    4141    growth->apMag  = psVectorAlloc (growth->radius->n, PS_TYPE_F32);
    42     growth->apMag->n = growth->radius->n;
    4342
    4443    // XXX may want to extend this to allow for a different refRadius;

  • trunk/psModules/src/objects/pmModel.c

    r9559 r9730  
    66 *  @author EAM, IfA
    77 *
    8  *  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2006-10-14 00:53:23 $
     8 *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2006-10-24 22:55:05 $
    1010 *
    1111 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    6666    tmp->params  = psVectorAlloc(Nparams, PS_TYPE_F32);
    6767    tmp->dparams = psVectorAlloc(Nparams, PS_TYPE_F32);
    68     tmp->params->n = tmp->dparams->n = Nparams;
    6968
    7069    for (psS32 i = 0; i < tmp->params->n; i++) {
    … …  
    117116    x->data.F32[0] = (psF32) (col + image->col0);
    118117    x->data.F32[1] = (psF32) (row + image->row0);
    119     x->n = 2;
    120118    psF32 tmpF;
    121119    pmModelFunc modelFunc;
    … …  
    143141
    144142    psVector *x = psVectorAlloc(2, PS_TYPE_F32);
    145     x->n = 2;
    146143    psVector *params = model->params;
    147144    pmModelFunc modelFunc = pmModelFunc_GetFunction (model->type);

  • trunk/psModules/src/objects/pmPSF.c

    r9562 r9730  
    66 *  @author EAM, IfA
    77 *
    8  *  @version $Revision: 1.10 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2006-10-14 00:55:43 $
     8 *  @version $Revision: 1.11 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2006-10-24 22:55:05 $
    1010 *
    1111 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    121121
    122122    psf->params = psArrayAlloc(Nparams - 4);
    123     psf->params->n = psf->params->nalloc;
    124123
    125124    // the order of the PSF parameter (X,Y) fits is determined by the
    … …  
    166165    psVector *z  = psVectorAlloc (models->n, PS_TYPE_F64);
    167166    psVector *dz = psVectorAlloc (models->n, PS_TYPE_F64);
    168     x->n = x->nalloc;
    169     y->n = y->nalloc;
    170     z->n = z->nalloc;
    171     dz->n = dz->nalloc;
    172167
    173168    for (int i = 0; i < models->n; i++) {
    … …  
    258253
    259254/***********************************************
    260  * this function masks the psf.ApTrend polynomial 
     255 * this function masks the psf.ApTrend polynomial
    261256 * to enable the specific subset of the coefficients
    262257 **********************************************/

  • trunk/psModules/src/objects/pmPSFtry.c

    r9594 r9730  
    55 *  @author EAM, IfA
    66 *
    7  *  @version $Revision: 1.20 $ $Name: not supported by cvs2svn $
    8  *  @date $Date: 2006-10-17 02:21:03 $
     7 *  @version $Revision: 1.21 $ $Name: not supported by cvs2svn $
     8 *  @date $Date: 2006-10-24 22:55:05 $
    99 *
    1010 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    7171    test->fitMag   = psVectorAlloc (sources->n, PS_TYPE_F64);
    7272    test->mask     = psVectorAlloc (sources->n, PS_TYPE_U8);
    73     test->metric->n = test->fitMag->n = test->mask->n = sources->n;
    74     test->modelEXT->n = test->modelPSF->n = sources->n;
    7573
    7674    for (int i = 0; i < test->modelEXT->n; i++) {
    … …  
    196194    psVector *chisq = psVectorAlloc (psfTry->sources->n, PS_TYPE_F64);
    197195    psVector *mask  = psVectorAlloc (psfTry->sources->n, PS_TYPE_MASK);
    198     flux->n = mask->n = chisq->n = psfTry->sources->n;
    199196
    200197    // write sources with models first
    … …  
    256253    // r2rflux = radius^2 * ten(0.4*fitMag);
    257254    psVector *r2rflux = psVectorAlloc (psfTry->sources->n, PS_TYPE_F64);
    258     r2rflux->n = psfTry->sources->n;
    259255
    260256    for (int i = 0; i < psfTry->sources->n; i++) {

  • trunk/psModules/src/objects/pmPeaks.c

    r8815 r9730  
    66 *  @author EAM, IfA: significant modifications.
    77 *
    8  *  @version $Revision: 1.9 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2006-09-15 09:49:01 $
     8 *  @version $Revision: 1.10 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2006-10-24 22:55:05 $
    1010 *
    1111 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    4040
    4141    if (list == NULL) {
    42         list = psArrayAlloc(100);
    43         list->n = 0;
     42        list = psArrayAllocEmpty(100);
    4443    }
    4544    psArrayAdd(list, 100, tmpPeak);
    … …  
    6968        tmpVector->data.F32[col] = image->data.F32[row][col];
    7069    }
    71     tmpVector->n = image->numCols;
    7270    psTrace("psModules.objects", 4, "---- %s() end ----\n", __func__);
    7371    return(tmpVector);
    … …  
    194192    if (n == 1) {
    195193        psVector *tmpVector = NULL;
    196         ;
    197194        if (vector->data.F32[0] > threshold) {
    198195            tmpVector = psVectorAlloc(1, PS_TYPE_U32);
    199196            tmpVector->data.U32[0] = 0;
    200             tmpVector->n = 1;
    201197        } else {
    202198            tmpVector = psVectorAlloc(0, PS_TYPE_U32);
    … …  
    238234    //
    239235    psVector *tmpVector = psVectorAlloc(count, PS_TYPE_U32);
    240     tmpVector->n = count;
    241236    count = 0;
    242237
    … …  
    544539    PS_ASSERT_PTR_NON_NULL(peaks, NULL);
    545540
    546     psArray *output = psArrayAlloc (200);
    547     output->n = 0;
     541    psArray *output = psArrayAllocEmpty (200);
    548542
    549543    psTrace (".pmObjects.pmCullPeaks", 3, "list size is %ld\n", peaks->n);

  • trunk/psModules/src/objects/pmSource.c

    r9651 r9730  
    66 *  @author EAM, IfA: significant modifications.
    77 *
    8  *  @version $Revision: 1.14 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2006-10-19 21:10:08 $
     8 *  @version $Revision: 1.15 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2006-10-24 22:55:05 $
    1010 *
    1111 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    294294        maxSy = clump->y * SCALE + 0.2;
    295295
    296         tmpSx = psVectorAlloc (sources->n, PS_TYPE_F32);
    297         tmpSy = psVectorAlloc (sources->n, PS_TYPE_F32);
    298         tmpSx->n = 0;
    299         tmpSy->n = 0;
     296        tmpSx = psVectorAllocEmpty (sources->n, PS_TYPE_F32);
     297        tmpSy = psVectorAllocEmpty (sources->n, PS_TYPE_F32);
    300298
    301299        // XXX clip sources based on flux?
    … …  
    375373
    376374    // report stats on S/N values for star-like objects
    377     psVector *starsn = psVectorAlloc (sources->n, PS_TYPE_F32);
    378     starsn->n = 0;
     375    psVector *starsn = psVectorAllocEmpty (sources->n, PS_TYPE_F32);
    379376
    380377    // check return status value (do these exist?)

  • trunk/psModules/src/objects/pmSourceContour.c

    r8815 r9730  
    66 *  @author EAM, IfA: significant modifications.
    77 *
    8  *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2006-09-15 09:49:01 $
     8 *  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2006-10-24 22:55:05 $
    1010 *
    1111 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    240240
    241241    // Allocate data for x/y pairs.
    242     psVector *xVec = psVectorAlloc(100, PS_TYPE_F32);
    243     psVector *yVec = psVectorAlloc(100, PS_TYPE_F32);
     242    psVector *xVec = psVectorAllocEmpty(100, PS_TYPE_F32);
     243    psVector *yVec = psVectorAllocEmpty(100, PS_TYPE_F32);
    244244
    245245    // First row: find the left and right end-points
    … …  
    327327    // fprintf (stderr, "done\n");
    328328    psArray *tmpArray = psArrayAlloc(2);
    329     tmpArray->n = 2;
    330329
    331330    tmpArray->data[0] = (psPtr *) xVec;
    … …  
    338337    pmSourceContour(src, img, level, mode): For an input subImage, and model, this
    339338    routine returns a psArray of coordinates that evaluate to the specified level.
    340     
     339 
    341340    XXX: Probably should remove the "image" argument.
    342341    XXX: What type should the output coordinate vectors consist of?  col,row?
    … …  
    366365    psVector *xVec = psVectorAlloc(2 * source->pixels->numRows, PS_TYPE_F32);
    367366    psVector *yVec = psVectorAlloc(2 * source->pixels->numRows, PS_TYPE_F32);
    368     xVec->n = yVec->n = 2 * source->pixels->numRows;
    369367
    370368    //
    … …  
    447445    //
    448446    psArray *tmpArray = psArrayAlloc(2);
    449     tmpArray->n = 2;
    450447
    451448    tmpArray->data[0] = (psPtr *) yVec;

  • trunk/psModules/src/objects/pmSourceFitModel.c

    r9541 r9730  
    66 *  @author GLG, MHPCC
    77 *
    8  *  @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2006-10-13 22:11:02 $
     8 *  @version $Revision: 1.13 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2006-10-24 22:55:05 $
    1010 *
    1111 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    7878
    7979    // construct the coordinate and value entries
    80     psArray *x = psArrayAlloc(nPix);
    81     psVector *y = psVectorAlloc(nPix, PS_TYPE_F32);
    82     psVector *yErr = psVectorAlloc(nPix, PS_TYPE_F32);
     80    psArray *x = psArrayAllocEmpty(nPix);
     81    psVector *y = psVectorAllocEmpty(nPix, PS_TYPE_F32);
     82    psVector *yErr = psVectorAllocEmpty(nPix, PS_TYPE_F32);
    8383
    8484    nPix = 0;
    … …  
    9595
    9696            psVector *coord = psVectorAlloc(2, PS_TYPE_F32);
    97             coord->n = 2;
    9897
    9998            // Convert i/j to image space:
    … …  
    128127    // set parameter mask based on fitting mode
    129128    paramMask = psVectorAlloc (params->n, PS_TYPE_U8);
    130     paramMask->n = params->n;
    131129    psVectorInit (paramMask, 1);
    132130
    … …  
    208206    if (paramMask != NULL) {
    209207        psVector *delta = psVectorAlloc (params->n, PS_TYPE_F64);
    210         delta->n = params->n;
    211208        psMinimizeGaussNewtonDelta(delta, params, NULL, x, y, yErr, modelFunc);
    212209        for (int i = 0; i < dparams->n; i++) {
    … …  
    272269    onePar = psVectorAlloc (nPar, PS_DATA_F32);
    273270    oneDeriv = psVectorAlloc (nPar, PS_DATA_F32);
    274     onePar->n = oneDeriv->n = nPar;
    275271
    276272    return true;
    … …  
    357353    psVector *params = psVectorAlloc (nSrc*nPar + 1, PS_TYPE_F32);
    358354    psVector *dparams = psVectorAlloc (nSrc*nPar + 1, PS_TYPE_F32);
    359     params->n = params->nalloc;
    360     dparams->n = dparams->nalloc;
    361355
    362356    pmModelLimits modelLimits = pmModelLimits_GetFunction (model->type);
    … …  
    373367    constrain->paramMask = psVectorAlloc (nSrc*nPar + 1, PS_TYPE_U8);
    374368    constrain->paramDelta = psVectorAlloc (nSrc*nPar + 1, PS_TYPE_F32);
    375     constrain->paramMin->n = constrain->paramMin->nalloc;
    376     constrain->paramMax->n = constrain->paramMax->nalloc;
    377     constrain->paramMask->n = constrain->paramMask->nalloc;
    378     constrain->paramDelta->n = constrain->paramDelta->nalloc;
    379369
    380370    // set the parameter guesses and constraints for the multiple models
    … …  
    459449
    460450    // construct the coordinate and value entries
    461     psArray *x = psArrayAlloc(nPix);
    462     psVector *y = psVectorAlloc(nPix, PS_TYPE_F32);
    463     psVector *yErr = psVectorAlloc(nPix, PS_TYPE_F32);
     451    psArray *x = psArrayAllocEmpty(nPix);
     452    psVector *y = psVectorAllocEmpty(nPix, PS_TYPE_F32);
     453    psVector *yErr = psVectorAllocEmpty(nPix, PS_TYPE_F32);
    464454
    465455    nPix = 0;
    … …  
    475465            }
    476466            psVector *coord = psVectorAlloc(2, PS_TYPE_F32);
    477             coord->n = 2;
    478467
    479468            // Convert i/j to image space:
    … …  
    534523    if (constrain->paramMask != NULL) {
    535524        psVector *delta = psVectorAlloc (params->n, PS_TYPE_F64);
    536         delta->n = params->n;
    537525        psMinimizeGaussNewtonDelta(delta, params, NULL, x, y, yErr, pmModelFitSet);
    538526        for (int i = 0; i < dparams->n; i++) {

  • trunk/psModules/src/objects/pmSourceIO_CMF.c

    r9653 r9730  
    33 *  @author EAM, IfA
    44 *
    5  *  @version $Revision: 1.11 $ $Name: not supported by cvs2svn $
    6  *  @date $Date: 2006-10-19 21:16:49 $
     5 *  @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
     6 *  @date $Date: 2006-10-24 22:55:05 $
    77 *
    88 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    5050    float ZERO_POINT = psMetadataLookupF32 (&status, header, "ZERO_PT");
    5151
    52     table = psArrayAlloc (sources->n);
    53     table->n = 0;
     52    table = psArrayAllocEmpty (sources->n);
    5453
    5554    for (i = 0; i < sources->n; i++) {
    … …  
    130129
    131130    psArray *sources = psArrayAlloc (table->n);
    132     sources->n = table->n;
    133131
    134132    // convert the table to the pmSource entries

  • trunk/psModules/src/objects/pmSourcePhotometry.c

    r9594 r9730  
    33 *  @author EAM, IfA; GLG, MHPCC
    44 *
    5  *  @version $Revision: 1.11 $ $Name: not supported by cvs2svn $
    6  *  @date $Date: 2006-10-17 02:21:03 $
     5 *  @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
     6 *  @date $Date: 2006-10-24 22:55:05 $
    77 *
    88 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    241241    pmModelFunc modelFunc = pmModelFunc_GetFunction (model->type);
    242242    psVector *coord = psVectorAlloc(2, PS_TYPE_F32);
    243     coord->n = 2;
    244243
    245244    psVector *params = model->params;
Note: See TracChangeset for help on using the changeset viewer.