IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 14986


Ignore:
Timestamp:
Sep 22, 2007, 3:47:28 AM (19 years ago)
Author:
eugene
Message:

fix compilation issues re pmTrend for psf parameters

Location:
branches/eam_branch_20070921
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • branches/eam_branch_20070921/psModules/src/objects/pmPSF.c

    r14980 r14986  
    66 *  @author EAM, IfA
    77 *
    8  *  @version $Revision: 1.28.2.3 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2007-09-22 02:20:11 $
     8 *  @version $Revision: 1.28.2.4 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2007-09-22 13:47:28 $
    1010 *
    1111 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    6767    options->psfTrendNy    = 0;
    6868
    69     options->poissonErrors = false;
     69    options->poissonErrorsPhotLMM = true;
     70    options->poissonErrorsPhotLin = false;
     71    options->poissonErrorsParams  = true;
     72
     73    return options;
    7074}
    7175
    … …  
    115119    psf->nPSFstars  = 0;
    116120    psf->nApResid   = 0;
    117     psf->poissonErrors = options->poissonErrors;
     121
     122    psf->poissonErrorsPhotLMM = options->poissonErrorsPhotLMM;
     123    psf->poissonErrorsPhotLin = options->poissonErrorsPhotLin;
     124    psf->poissonErrorsParams = options->poissonErrorsParams;
    118125
    119126    // the ApTrend components are (x, y).  It may be represented with a polynomial or with a
    … …  
    128135    psf->FluxScale = NULL;
    129136
    130     if (psf->poissonErrors) {
     137    if (psf->poissonErrorsPhotLMM) {
    131138        psf->ChiTrend = psPolynomial1DAlloc (PS_POLYNOMIAL_ORD, 1);
    132139    } else {
    … …  
    140147    psf->residuals = NULL;
    141148
    142     Nparams = pmModelClassParameterCount (type);
     149    Nparams = pmModelClassParameterCount (options->type);
    143150    if (!Nparams) {
    144151        psError(PS_ERR_UNKNOWN, true, "Undefined pmModelType");
    … …  
    156163    // are left as NULL.  these are selected by testing for them by the named values (
    157164    // PM_PAR_XPOS, etc)
     165
     166    psf->Nx = options->image->numCols;
     167    psf->Ny = options->image->numRows;
    158168
    159169    // define the parameter trends
    … …  
    293303
    294304// generate a psf model of the requested type, with fixed shape
    295 // XXX update this.
    296305pmPSF *pmPSFBuildSimple (char *typeName, float sxx, float syy, float sxy, ...)
    297306{
    … …  
    300309    va_start(ap, sxy);
    301310
    302     pmModelType type = pmModelClassGetType (typeName);
    303     psPolynomial2D *psfTrend = psPolynomial2DAlloc (PS_POLYNOMIAL_ORD, 0, 0);
    304     pmPSF *psf = pmPSFAlloc (type, true, psfTrend);
     311    pmPSFOptions *options = pmPSFOptionsAlloc ();
     312    options->type = pmModelClassGetType (typeName);
     313    options->psfTrendMode = PM_TREND_POLY_ORD;
     314    options->psfTrendNx = 0;
     315    options->psfTrendNy = 0;
     316
     317    pmPSF *psf = pmPSFAlloc (options);
    305318
    306319    psVector *par = psVectorAlloc (psf->params->n, PS_TYPE_F32);
    … …  
    311324    psEllipsePol pol = pmPSF_ModelToFit(par->data.F32);
    312325
     326    pmTrend2D *trend = NULL;
     327
    313328    // set the psf shape parameters
    314     psPolynomial2D *poly = NULL;
    315     poly = psf->params->data[PM_PAR_E0];
    316     poly->coeff[0][0] = pol.e0;
    317 
    318     poly = psf->params->data[PM_PAR_E1];
    319     poly->coeff[0][0] = pol.e1;
    320 
    321     poly = psf->params->data[PM_PAR_E2];
    322     poly->coeff[0][0] = pol.e2;
     329    trend = psf->params->data[PM_PAR_E0];
     330    trend->poly->coeff[0][0] = pol.e0;
     331
     332    trend = psf->params->data[PM_PAR_E1];
     333    trend->poly->coeff[0][0] = pol.e1;
     334
     335    trend = psf->params->data[PM_PAR_E2];
     336    trend->poly->coeff[0][0] = pol.e2;
    323337
    324338    for (int i = PM_PAR_SXY + 1; i < psf->params->n; i++) {
    325         poly = psf->params->data[i];
    326         poly->coeff[0][0] = (psF32)va_arg(ap, psF64);
     339        trend = psf->params->data[i];
     340        trend->poly->coeff[0][0] = (psF32)va_arg(ap, psF64);
    327341    }
    328342    va_end(ap);
    329343
    330344    psFree (par);
    331     psFree (psfTrend);
     345    psFree (options);
    332346    return psf;
    333347}

  • branches/eam_branch_20070921/psModules/src/objects/pmPSF.h

    r14980 r14986  
    66 * @author EAM, IfA
    77 *
    8  * @version $Revision: 1.16.2.2 $ $Name: not supported by cvs2svn $
    9  * @date $Date: 2007-09-22 02:20:11 $
     8 * @version $Revision: 1.16.2.3 $ $Name: not supported by cvs2svn $
     9 * @date $Date: 2007-09-22 13:47:28 $
    1010 * Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    1111 */
    … …  
    4747    int nPSFstars;                      ///< number of stars used to measure PSF
    4848    int nApResid;                       ///< number of stars used to measure ApResid
    49     bool poissonErrors;
     49    int Nx, Ny;                         ///< reference image dimensions
     50    bool poissonErrorsPhotLMM;          ///< use poission errors for non-linear model fitting
     51    bool poissonErrorsPhotLin;          ///< use poission errors for linear model fitting
     52    bool poissonErrorsParams;           ///< use poission errors for model parameter fitting
    5053    pmGrowthCurve *growth;              ///< apMag vs Radius
    5154    pmResiduals *residuals;             ///< normalized residual image (no spatial variation)
    … …  
    6063    int           psfTrendNx;
    6164    int           psfTrendNy;
    62     bool          poissonErrors;
     65    bool          poissonErrorsPhotLMM; ///< use poission errors for non-linear model fitting
     66    bool          poissonErrorsPhotLin; ///< use poission errors for linear model fitting
     67    bool          poissonErrorsParams; ///< use poission errors for model parameter fitting
     68    float         radius;
     69   
    6370} pmPSFOptions;
    6471
    … …  
    7279 *
    7380 */
    74 pmPSF *pmPSFAlloc(
    75     pmModelType type,     // type of model for PSF
    76     bool poissonErrors,
    77     psPolynomial2D *psfTrendMask
    78 );
     81pmPSF *pmPSFAlloc (pmPSFOptions *options);
     82pmPSFOptions *pmPSFOptionsAlloc ();
    7983
    8084double pmPSF_SXYfromModel (psF32 *modelPar);

  • branches/eam_branch_20070921/psModules/src/objects/pmPSF_IO.c

    r14980 r14986  
    66 *  @author EAM, IfA
    77 *
    8  *  @version $Revision: 1.22.2.2 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2007-09-22 02:20:11 $
     8 *  @version $Revision: 1.22.2.3 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2007-09-22 13:47:28 $
    1010 *
    1111 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    246246
    247247    // write the PSF model parameters in a FITS table
    248     assert (psf->psfTrendMode != PM_TREND_NONE);
    249248    {
    250249        // we need to write a header for the table,
    … …  
    254253        psMetadataAddStr (header, PS_LIST_TAIL, "PSF_NAME", 0, "PSF model name", modelName);
    255254
    256         psMetadataAddBool (header, PS_LIST_TAIL, "POISSON",  0, "Use Poisson errors in fits?", psf->poissonErrors);
     255        psMetadataAddBool (header, PS_LIST_TAIL, "ERR_LMM",  0, "Use Poisson errors in fits?", psf->poissonErrorsPhotLMM);
     256        psMetadataAddBool (header, PS_LIST_TAIL, "ERR_LIN",  0, "Use Poisson errors in fits?", psf->poissonErrorsPhotLin);
     257        psMetadataAddBool (header, PS_LIST_TAIL, "ERR_PAR",  0, "Use Poisson errors in fits?", psf->poissonErrorsParams);
    257258
    258259        int nPar = pmModelClassParameterCount (psf->type)    ;
    259260        psMetadataAdd (header, PS_LIST_TAIL, "PSF_NPAR", PS_DATA_S32, "PSF model parameter count", nPar);
     261
     262        psMetadataAddS32 (header, PS_LIST_TAIL, "IMAXIS1", 0, "Image X Size", psf->Nx);
     263        psMetadataAddS32 (header, PS_LIST_TAIL, "IMAXIS2", 0, "Image Y Size", psf->Ny);
    260264
    261265        // save the dimensions of each parameter
    262266        for (int i = 0; i < nPar; i++) {
    263267            char name[9];
    264             psPolynomial2D *poly = psf->params->data[i];
    265             if (poly == NULL) continue;
     268            int nX, nY;
     269
     270            pmTrend2D *trend = psf->params->data[i];
     271            if (trend == NULL) continue;
     272
     273            if (trend->mode == PM_TREND_MAP) {
     274              nX = trend->map->map->numCols;
     275              nY = trend->map->map->numRows;
     276            } else {
     277              nX = trend->poly->nX;
     278              nY = trend->poly->nY;
     279            }
    266280            snprintf (name, 9, "PAR%02d_NX", i);
    267             psMetadataAddS32 (header, PS_LIST_TAIL, name, 0, "", poly->nX);
     281            psMetadataAddS32 (header, PS_LIST_TAIL, name, 0, "", nX);
    268282            snprintf (name, 9, "PAR%02d_NY", i);
    269             psMetadataAddS32 (header, PS_LIST_TAIL, name, 0, "", poly->nY);
    270         }
    271 
    272         char *modeName = pmTrend2DModeToString(trend->mode);
     283            psMetadataAddS32 (header, PS_LIST_TAIL, name, 0, "", nY);
     284            snprintf (name, 9, "PAR%02d_MD", i);
     285            char *modeName = pmTrend2DModeToString (trend->mode);
     286            psMetadataAddStr (header, PS_LIST_TAIL, name, 0, "", modeName);
     287            psFree (modeName);
     288        }
    273289
    274290        // other required information describing the PSF
    … …  
    277293        psMetadataAddF32 (header, PS_LIST_TAIL, "CHISQ",    0, "chi-square for fit", psf->chisq);
    278294        psMetadataAddS32 (header, PS_LIST_TAIL, "NSTARS",   0, "number of stars used to measure PSF", psf->nPSFstars);
    279         psMetadataAddStr (header, PS_LIST_TAIL, "MODE",     0, "", modeName);
    280         psFree (modeName);
    281295
    282296        // XXX can we drop this now?
    … …  
    536550    if (!header) psAbort("cannot read table header");
    537551
     552    pmPSFOptions *options = pmPSFOptionsAlloc();
     553
    538554    // load the PSF model parameters from the FITS table
    539555    char *modelName = psMetadataLookupStr (&status, header, "PSF_NAME");
    540     pmModelType type = pmModelClassGetType (modelName);
    541     if (type == -1) {
     556    options->type = pmModelClassGetType (modelName);
     557    if (options->type == -1) {
    542558        psError(PS_ERR_UNKNOWN, true, "invalid model name %s in psf file %s", modelName, file->filename);
    543559        return false;
    544560    }
    545561
    546     bool poissonErrors = psMetadataLookupBool (&status, header, "POISSON");
     562    options->poissonErrorsPhotLMM = psMetadataLookupBool (&status, header, "ERR_LMM");
     563    options->poissonErrorsPhotLin = psMetadataLookupBool (&status, header, "ERR_LIN");
     564    options->poissonErrorsParams  = psMetadataLookupBool (&status, header, "ERR_PAR");
     565
     566    // XXX this is a bit ad-hoc: determine the PSF trend mode by looking at one of the parameters
     567    // this could allow the psf model to use different trend modes for different parameters, but we
     568    // would need to change the alloc somewhat
    547569
    548570    // we determine the PSF parameter polynomials from the MD-defined polynomials
    549     pmPSF *psf = pmPSFAlloc (type, poissonErrors, NULL);
     571    pmPSF *psf = pmPSFAlloc (options);
    550572
    551573    // check the number of expected parameters
    … …  
    554576        psAbort("mismatch model par count");
    555577
    556     // load the dimensions of each parameter
     578    int nXimage = psMetadataLookupS32 (&status, header, "IMAXIS1");
     579    int nYimage = psMetadataLookupS32 (&status, header, "IMAXIS2");
     580    // XXX don't require this to exist?  0,0 if not defined?
     581
     582    // load the trend mode and dimensions of each parameter
    557583    for (int i = 0; i < nPar; i++) {
    558584        char name[9];
    … …  
    572598            return false;
    573599        }
    574         // XXX allocate pmTrend2d based on the values here
    575         psf->params->data[i] = psPolynomial2DAlloc (PS_POLYNOMIAL_ORD, nXorder, nYorder);
     600        pmTrend2DMode psfTrendMode = pmTrend2DModeFromString (modeName);
     601        // XXX default to POLY_ORD if not defined?
     602
     603        psf->params->data[i] = pmTrend2DFieldAlloc (psfTrendMode, nXimage, nYimage, nXorder, nYorder, NULL);
    576604    }
    577605
    … …  
    584612    // XXX can we drop this now?
    585613    psf->skyBias   = psMetadataLookupF32 (&status, header, "SKY_BIAS");
    586 
    587     char *modeName = psMetadataLookupStr (&status, header, "MODE");
    588     trend->mode = pmTrend2DModeToString(modeName);
    589614
    590615    // read the raw table data
    … …  
    608633            psImageMap *map = trend->map;
    609634            map->map->data.F32[yPow][xPow]    = psMetadataLookupF32 (&status, row, "VALUE");
    610             map->error->data.F32[yPow][xPow]    = psMetadataLookupF32 (&status, row, "ERROR");
    611             // poly->mask[xPow][yPow]     = psMetadataLookupU8  (&status, row, "MASK");
     635            map->error->data.F32[yPow][xPow]  = psMetadataLookupF32 (&status, row, "ERROR");
    612636        } else {
    613637            psPolynomial2D *poly = trend->poly;
    … …  
    666690
    667691// create a psMetadata representation (human-readable) of a psf model
    668 // XXX drop this function?
    669 psMetadata *pmPSFtoMetadata (psMetadata *metadata, pmPSF *psf)
    670 {
    671 
    672     if (metadata == NULL) {
    673         metadata = psMetadataAlloc ();
    674     }
    675 
    676     char *modelName = pmModelClassGetName (psf->type);
    677     psMetadataAdd (metadata, PS_LIST_TAIL, "PSF_MODEL_NAME", PS_DATA_STRING, "PSF model name", modelName);
    678 
    679     int nPar = pmModelClassParameterCount (psf->type)    ;
    680     psMetadataAdd (metadata, PS_LIST_TAIL, "PSF_MODEL_NPAR", PS_DATA_S32, "PSF model parameter count", nPar);
    681 
    682     for (int i = 0; i < nPar; i++) {
    683         psPolynomial2D *poly = psf->params->data[i];
    684         if (poly == NULL)
    685             continue;
    686         psPolynomial2DtoMetadata (metadata, poly, "PSF_PAR%02d", i);
    687     }
    688 
    689     // XXX fix this
    690     psWarning ("APTREND is currently missing");
    691     // psPolynomial4DtoMetadata (metadata, psf->ApTrend, "APTREND");
    692 
    693     psMetadataAdd (metadata, PS_LIST_TAIL, "PSF_AP_RESID", PS_DATA_F32, "aperture residual", psf->ApResid);
    694     psMetadataAdd (metadata, PS_LIST_TAIL, "PSF_dAP_RESID", PS_DATA_F32, "aperture residual scatter", psf->dApResid);
    695     psMetadataAdd (metadata, PS_LIST_TAIL, "PSF_SKY_BIAS", PS_DATA_F32, "sky bias level", psf->skyBias);
    696 
    697     psMetadataAdd (metadata, PS_LIST_TAIL, "PSF_CHISQ", PS_DATA_F32, "chi-square for fit", psf->chisq);
    698     psMetadataAdd (metadata, PS_LIST_TAIL, "PSF_NSTARS", PS_DATA_S32, "number of stars used to measure PSF", psf->nPSFstars);
    699     psMetadataAdd (metadata, PS_LIST_TAIL, "PSF_POISSON_ERRORS", PS_DATA_BOOL, "Poisson errors for fits", psf->poissonErrors);
    700 
    701     return metadata;
    702 }
    703 
    704 // parse a psMetadata representation (human-readable) of a psf model
    705 // XXX drop this function?
    706 pmPSF *pmPSFfromMetadata (psMetadata *metadata)
    707 {
    708 
    709     bool status;
    710     char keyword[80];
    711 
    712     char *modelName = psMetadataLookupPtr (&status, metadata, "PSF_MODEL_NAME");
    713     pmModelType type = pmModelClassGetType (modelName);
    714 
    715     bool poissonErrors = psMetadataLookupPtr (&status, metadata, "PSF_POISSON_ERRORS");
    716     if (!status)
    717         poissonErrors = true;
    718 
    719     // we determine the PSF parameter polynomials from the MD-defined polynomials
    720     pmPSF *psf = pmPSFAlloc (type, poissonErrors, NULL);
    721 
    722     int nPar = psMetadataLookupS32 (&status, metadata, "PSF_MODEL_NPAR");
    723     if (nPar != pmModelClassParameterCount (psf->type))
    724         psAbort("mismatch model par count");
    725 
    726     // un-fitted terms, not in the Metadata, are left NULL
    727     // XXX add a double-check of the expected number?
    728     for (int i = 0; i < nPar; i++) {
    729         sprintf (keyword, "PSF_PAR%02d", i);
    730         psMetadata *folder = psMetadataLookupPtr (&status, metadata, keyword);
    731         if (!status)
    732             continue;
    733         psPolynomial2D *poly = psPolynomial2DfromMetadata (folder);
    734         psFree (psf->params->data[i]);
    735         psf->params->data[i] = poly;
    736     }
    737 
    738     // load the APTREND data
    739     // XXX fix this to work with pmTrend2D
    740     psWarning ("APTREND is not being read");
    741     # if (0)
    742     sprintf (keyword, "APTREND");
    743     psMetadata *folder = psMetadataLookupPtr (&status, metadata, keyword);
    744     psPolynomial4D *poly = psPolynomial4DfromMetadata (folder);
    745     psFree (psf->ApTrend);
    746     psf->ApTrend = poly;
    747     # endif
    748 
    749     psf->ApResid = psMetadataLookupF32 (&status, metadata, "PSF_AP_RESID");
    750     psf->dApResid = psMetadataLookupF32 (&status, metadata, "PSF_dAP_RESID");
    751     psf->skyBias = psMetadataLookupF32 (&status, metadata, "PSF_SKY_BIAS");
    752 
    753     psf->chisq = psMetadataLookupF32 (&status, metadata, "PSF_CHISQ");
    754     psf->nPSFstars = psMetadataLookupS32 (&status, metadata, "PSF_NSTARS");
    755 
    756     psFree (metadata);
    757     return (psf);
    758 }
     692// XXX pmPSF to/from Metadata functions were defined for 1.22 and earlier, but were dropped

  • branches/eam_branch_20070921/psModules/src/objects/pmPSF_IO.h

    r14652 r14986  
    66 * @author EAM, IfA
    77 *
    8  * @version $Revision: 1.9 $ $Name: not supported by cvs2svn $
    9  * @date $Date: 2007-08-24 00:11:02 $
     8 * @version $Revision: 1.9.4.1 $ $Name: not supported by cvs2svn $
     9 * @date $Date: 2007-09-22 13:47:28 $
    1010 * Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    1111 */
    … …  
    3333bool pmPSFmodelCheckDataStatusForChip (const pmChip *chip);
    3434
    35 psMetadata *pmPSFtoMetadata (psMetadata *metadata, pmPSF *psf);
    36 pmPSF *pmPSFfromMetadata (psMetadata *metadata);
    37 
    3835/// @}
    3936# endif

  • branches/eam_branch_20070921/psModules/src/objects/pmPSFtry.c

    r14980 r14986  
    55 *  @author EAM, IfA
    66 *
    7  *  @version $Revision: 1.45.2.2 $ $Name: not supported by cvs2svn $
    8  *  @date $Date: 2007-09-22 02:20:11 $
     7 *  @version $Revision: 1.45.2.3 $ $Name: not supported by cvs2svn $
     8 *  @date $Date: 2007-09-22 13:47:28 $
    99 *
    1010 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    139139
    140140    // stage 2: construct a psf (pmPSF) from this collection of model fits
    141     // XXX take 'applyWeights' from the psf options?
    142     if (!pmPSFFromPSFtry (psfTry, options->applyWeights)) {
     141    if (!pmPSFFromPSFtry (psfTry)) {
    143142        psError(PS_ERR_UNKNOWN, false, "failed to construct a psf model from collection of sources");
    144143        psFree(psfTry);
    … …  
    339338/*****************************************************************************
    340339pmPSFFromPSFtry (psfTry): build a PSF model from a collection of
    341 source->modelEXT entires.  The PSF ignores the first 4 (independent) model
     340source->modelEXT entries.  The PSF ignores the first 4 (independent) model
    342341parameters and constructs a polynomial fit to the remaining as a function of
    343342image coordinate.
    … …  
    345344Note: some of the array entries may be NULL (failed fits); ignore them.
    346345 *****************************************************************************/
    347 bool pmPSFFromPSFtry (pmPSFtry *psfTry, bool applyWeight)
     346bool pmPSFFromPSFtry (pmPSFtry *psfTry)
    348347{
    349348    pmPSF *psf = psfTry->psf;
    … …  
    355354
    356355    psVector *dz = NULL;
    357     if (applyWeight) {
     356    if (psf->poissonErrorsParams) {
    358357        dz = psVectorAlloc (psfTry->sources->n, PS_TYPE_F32);
    359358    }
    … …  
    420419    if (psTraceGetLevel("psModules.objects") >= 4) {
    421420        FILE *f = fopen ("pol.dat", "w");
    422         fprintf (f, "x y  :  e0obs e1obs e2obs  : e0fit e1fit e2fit : mask\n",
     421        fprintf (f, "# x y  :  e0obs e1obs e2obs  : e0fit e1fit e2fit : mask\n");
    423422        for (int i = 0; i < e0->n; i++) {
    424423            fprintf (f, "%f %f  :  %f %f %f  : %f %f %f  : %d\n",
    … …  
    462461        // fit the collection of measured parameters to the PSF 2D model
    463462        // the mask is carried from previous steps and updated with this operation
    464         // the weight is either the flux error or NULL, depending on 'applyWeights'
     463        // the weight is either the flux error or NULL, depending on 'psf->poissonErrorParams'
    465464        if (!pmTrend2DFit (psf->params->data[i], psfTry->mask, 0xff, x, y, e0, NULL)) {
    466465            psError(PS_ERR_UNKNOWN, false, "failed to build psf model for parameter %d", i);
    467             psFree(stats);
    468466            psFree(x);
    469467            psFree(y);
    … …  
    502500    }
    503501
    504     psFree (stats);
    505502    psFree (x);
    506503    psFree (y);

  • branches/eam_branch_20070921/psModules/src/objects/pmPSFtry.h

    r14505 r14986  
    66 * @author EAM, IfA
    77 *
    8  * @version $Revision: 1.14 $ $Name: not supported by cvs2svn $
    9  * @date $Date: 2007-08-15 20:21:18 $
     8 * @version $Revision: 1.14.6.1 $ $Name: not supported by cvs2svn $
     9 * @date $Date: 2007-09-22 13:47:28 $
    1010 * Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    1111 */
    … …  
    7878 *
    7979 */
    80 pmPSFtry *pmPSFtryAlloc (psArray *sources, char *modelName, bool poissonErrors, psPolynomial2D *psfTrendMask);
     80pmPSFtry *pmPSFtryAlloc (psArray *sources, pmPSFOptions *options);
    8181
    8282/** pmPSFtryModel()
    … …  
    8787 *
    8888 */
    89 pmPSFtry *pmPSFtryModel (psArray *sources, char *modelName, float RADIUS, bool poissonErrors, psPolynomial2D *psfTrendMask, bool applyWeights, psMaskType maskVal, psMaskType mark);
     89pmPSFtry *pmPSFtryModel (psArray *sources, char *modelName, pmPSFOptions *options, psMaskType maskVal, psMaskType mark);
    9090
    9191/** pmPSFtryMetric()
    … …  
    123123 *
    124124 */
    125 bool pmPSFFromPSFtry (pmPSFtry *psfTry, bool applyWeights);
     125bool pmPSFFromPSFtry (pmPSFtry *psfTry);
    126126
    127127/// @}

  • branches/eam_branch_20070921/psModules/src/objects/pmTrend2D.c

    r14980 r14986  
    33 *  @author EAM, IfA
    44 *
    5  *  @version $Revision: 1.2.2.2 $ $Name: not supported by cvs2svn $
    6  *  @date $Date: 2007-09-22 02:20:11 $
     5 *  @version $Revision: 1.2.2.3 $ $Name: not supported by cvs2svn $
     6 *  @date $Date: 2007-09-22 13:47:28 $
    77 *
    88 *  Copyright 2004 Institute for Astronomy, University of Hawaii
    … …  
    1414#endif
    1515
     16# include <strings.h>
    1617# include <pslib.h>
    1718# include "pmTrend2D.h"
    … …  
    8586        for (int nx = 0; nx < trend->poly->nX + 1; nx++) {
    8687            for (int ny = 0; ny < trend->poly->nY + 1; ny++) {
    87                 trend->poly->mask[nx][ny] = XXX;
     88                if (nx + ny >= PS_MAX (trend->poly->nX, trend->poly->nY) + 1) {
     89                    trend->poly->mask[nx][ny] = 1;
     90                } else {
     91                    trend->poly->mask[nx][ny] = 0;
     92                }
    8893            }
    8994        }
    … …  
    181186
    182187psString pmTrend2DModeToString (pmTrend2DMode mode) {
     188   
     189    psString name;
    183190
    184191    switch (mode) {
    185192      case PM_TREND_NONE:
    186         psString name = psStringCopy ("NONE");
    187         break;
    188       case PM_TREND_POLY_ORD:
    189         psString name = psStringCopy ("POLY_ORD");
    190         break;
    191       case PM_TREND_POLY_CHEB:
    192         psString name = psStringCopy ("POLY_CHEB");
    193         break;
    194       case PM_TREND_MAP:
    195         psString name = psStringCopy ("MAP");
     193        name = psStringCopy ("NONE");
     194        break;
     195      case PM_TREND_POLY_ORD:
     196        name = psStringCopy ("POLY_ORD");
     197        break;
     198      case PM_TREND_POLY_CHEB:
     199        name = psStringCopy ("POLY_CHEB");
     200        break;
     201      case PM_TREND_MAP:
     202        name = psStringCopy ("MAP");
    196203        break;
    197204      default:

  • branches/eam_branch_20070921/psModules/test/camera/Makefile.am

    r14551 r14986  
    1111        $(PSMODULES_LIBS)
    1212
    13 TEST_PROGS = \
    14         tap_pmFPAReadWrite
     13TEST_PROGS =
    1514
    1615if BUILD_TESTS

  • branches/eam_branch_20070921/psphot/doc/psfmodel.txt

    r14970 r14986  
     1
     22007.09.21
     3
     4  there are three places where we can choose to use errors in the fits or not:
     5
     6  * non-linear fitting of the models to the pixel flux distribution (poissonErrorsPhotLMM)
     7  * linear fitting of the models to the pixel flux distribution (poissonErrorsPhotLin)
     8  * fitting of the 2D variations in the psf parameters (poissonErrorsParams)
     9  * fitting of the 2D variations in the aperture residuals
    110
    2112007.09.20

  • branches/eam_branch_20070921/psphot/src/psphotChoosePSF.c

    r14980 r14986  
    2727
    2828    // use poissonian errors or local-sky errors
    29     options->poissonErrorsPhotom = psMetadataLookupBool (&status, recipe, "POISSON.ERRORS.PHOTOM");
     29    options->poissonErrorsPhotLMM = psMetadataLookupBool (&status, recipe, "POISSON.ERRORS.PHOT.LMM");
     30    assert (status);
     31
     32    // use poissonian errors or local-sky errors
     33    options->poissonErrorsPhotLin = psMetadataLookupBool (&status, recipe, "POISSON.ERRORS.PHOT.LIN");
    3034    assert (status);
    3135
    … …  
    5256    options->image = psMemIncrRefCounter (readout->image);
    5357
    54     pmSourceFitModelInit (15, 0.01, PS_SQR(SKY_SIG), options->poissonErrorsPhotom);
     58    pmSourceFitModelInit (15, 0.01, PS_SQR(SKY_SIG), options->poissonErrorsPhotLMM);
    5559
    5660    psArray *stars = psArrayAllocEmpty (sources->n);
    … …  
    235239            // use pmModelSub because modelFlux has not been generated
    236240            assert (source->maskObj);
    237             psImageKeepCircle (source->maskObj, x, y, RADIUS, "OR", PM_MASK_MARK);
     241            psImageKeepCircle (source->maskObj, x, y, options->radius, "OR", PM_MASK_MARK);
    238242            pmModelSub (source->pixels, source->maskObj, source->modelPSF, PM_MODEL_OP_FULL, maskVal);
    239             psImageKeepCircle (source->maskObj, x, y, RADIUS, "AND", PS_NOT_U8(PM_MASK_MARK));
     243            psImageKeepCircle (source->maskObj, x, y, options->radius, "AND", PS_NOT_U8(PM_MASK_MARK));
    240244        }
    241245
Note: See TracChangeset for help on using the changeset viewer.