IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Sep 19, 2014, 4:05:27 PM (12 years ago)
Author:
eugene
Message:

merge changes from trunk

Location:
branches/eam_branches/ps2-tc3-20130727
Files:
75 edited
1 copied

Legend:

Unmodified
Added
Removed

  • branches/eam_branches/ps2-tc3-20130727

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects

    • Property svn:ignore

      •  

        old new  
        1515pmSourceIO_CMF_PS1_SV1.c
        1616pmSourceIO_CMF_PS1_SV2.c
         17pmSourceIO_CMF_PS1_SV3.c
         18pmSourceIO_CMF_PS1_SV4.c
        1719pmSourceIO_CMF_PS1_DV1.c
        1820pmSourceIO_CMF_PS1_DV2.c
        1921pmSourceIO_CMF_PS1_DV3.c
         22pmSourceIO_CMF_PS1_DV4.c
        2023

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/Makefile.am

    r36680 r37403  
    5252        pmSourceIO_CMF_PS1_SV1.c \
    5353        pmSourceIO_CMF_PS1_SV2.c \
     54        pmSourceIO_CMF_PS1_SV3.c \
     55        pmSourceIO_CMF_PS1_SV4.c \
    5456        pmSourceIO_CMF_PS1_DV1.c \
    5557        pmSourceIO_CMF_PS1_DV2.c \
    5658        pmSourceIO_CMF_PS1_DV3.c \
     59        pmSourceIO_CMF_PS1_DV4.c \
    5760        pmSourceIO_MatchedRefs.c \
    5861        pmSourcePlots.c \
    … …  
    152155pmSourceIO_CMF_PS1_DV2.c \
    153156pmSourceIO_CMF_PS1_DV3.c \
     157pmSourceIO_CMF_PS1_DV4.c \
    154158pmSourceIO_CMF_PS1_SV1.c \
    155 pmSourceIO_CMF_PS1_SV2.c
     159pmSourceIO_CMF_PS1_SV2.c \
     160pmSourceIO_CMF_PS1_SV3.c \
     161pmSourceIO_CMF_PS1_SV4.c
    156162
    157163pmSourceIO_CMF_PS1_V1.c : pmSourceIO_CMF.c.in mksource.pl
    … …  
    179185        mksource.pl pmSourceIO_CMF.c.in PS1_DV3 pmSourceIO_CMF_PS1_DV3.c
    180186
     187pmSourceIO_CMF_PS1_DV4.c : pmSourceIO_CMF.c.in mksource.pl
     188        mksource.pl pmSourceIO_CMF.c.in PS1_DV4 pmSourceIO_CMF_PS1_DV4.c
     189
    181190pmSourceIO_CMF_PS1_SV1.c : pmSourceIO_CMF.c.in mksource.pl
    182191        mksource.pl pmSourceIO_CMF.c.in PS1_SV1 pmSourceIO_CMF_PS1_SV1.c
    … …  
    185194        mksource.pl pmSourceIO_CMF.c.in PS1_SV2 pmSourceIO_CMF_PS1_SV2.c
    186195
     196pmSourceIO_CMF_PS1_SV3.c : pmSourceIO_CMF.c.in mksource.pl
     197        mksource.pl pmSourceIO_CMF.c.in PS1_SV3 pmSourceIO_CMF_PS1_SV3.c
     198
     199pmSourceIO_CMF_PS1_SV4.c : pmSourceIO_CMF.c.in mksource.pl
     200        mksource.pl pmSourceIO_CMF.c.in PS1_SV4 pmSourceIO_CMF_PS1_SV4.c
     201
    187202# EXTRA_DIST = pmErrorCodes.h.in pmErrorCodes.dat pmErrorCodes.c.in

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/mksource.pl

    r36680 r37403  
    2424                "PS1_DV2", 2,
    2525                "PS1_DV3", 3,
     26                "PS1_DV4", 4,
    2627    );
    2728%cmfmodes_sv = ("PS1_SV1", 1,
    2829                "PS1_SV2", 2,
     30                "PS1_SV3", 3,
     31                "PS1_SV4", 4,
    2932    );
    3033

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/models/pmModel_DEV.c

    r36680 r37403  
    3636#include "pmMoments.h"
    3737#include "pmModelFuncs.h"
     38#include "pmModelClass.h"
    3839#include "pmModel.h"
    3940#include "pmModelUtils.h"
    40 #include "pmModelClass.h"
    4141#include "pmSourceMasks.h"
    4242#include "pmSourceExtendedPars.h"
    … …  
    5959# define PM_MODEL_LIMITS          pmModelLimits_DEV
    6060# define PM_MODEL_RADIUS          pmModelRadius_DEV
     61# define PM_MODEL_SET_FWHM        pmModelSetFWHM_DEV
    6162# define PM_MODEL_FROM_PSF        pmModelFromPSF_DEV
    6263# define PM_MODEL_PARAMS_FROM_PSF pmModelParamsFromPSF_DEV
    … …  
    123124    if (radius <= 1.5) {
    124125        // Nsub ~ 10*index^2 + 1
    125         psEllipseAxes axes = pmPSF_ModelToAxes(PAR, pmModelClassGetType ("PS_MODEL_DEV"));
     126        psEllipseAxes axes = pmPSF_ModelToAxes(PAR, true); // DEV uses Reff
    126127        int Nsub = 2 * ((int)(25 / axes.minor)) + 1;
    127128        Nsub = PS_MIN (Nsub, 121);
    … …  
    336337}
    337338
     339psF64 PM_MODEL_SET_FWHM (const psVector *params, psF64 sigma) {
     340  return (NAN);
     341}
     342
    338343bool PM_MODEL_FROM_PSF (pmModel *modelPSF, pmModel *modelFLT, const pmPSF *psf)
    339344{
    … …  
    357362    // the 2D PSF model fits polarization terms (E0,E1,E2)
    358363    // convert to shape terms (SXX,SYY,SXY)
    359     bool useReff = pmModelUseReff (modelPSF->type);
     364    bool useReff = modelPSF->class->useReff;
    360365    if (!pmPSF_FitToModel (out, 0.1, useReff)) {
    361366        psTrace("psModules.objects", 5, "Failed to fit object at (r,c) = (%.1f,%.1f)", in[PM_PAR_YPOS], in[PM_PAR_XPOS]);
    … …  
    411416    // convert to shape terms (SXX,SYY,SXY)
    412417    // XXX user-defined value for limit?
    413     bool useReff = pmModelUseReff (model->type);
     418    bool useReff = model->class->useReff;
    414419    if (!pmPSF_FitToModel (PAR, 0.1, useReff)) {
    415420        psTrace ("psModules.objects", 3, "Failed to fit object at (r,c) = (%.1f,%.1f)", Xo, Yo);

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/models/pmModel_DEV.h

    r35560 r37403  
    88psF64 pmModelFlux_DEV(const psVector *params);
    99psF64 pmModelRadius_DEV(const psVector *params, psF64 flux);
     10psF64 pmModelSetFWHM_DEV(const psVector *params, psF64 flux);
    1011bool pmModelFromPSF_DEV(pmModel *modelPSF, pmModel *modelFLT, const pmPSF *psf);
    1112bool  pmModelParamsFromPSF_DEV(pmModel *model, const pmPSF *psf, float Xo, float Yo, float Io);

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/models/pmModel_EXP.c

    r36680 r37403  
    3333#include "pmMoments.h"
    3434#include "pmModelFuncs.h"
     35#include "pmModelClass.h"
    3536#include "pmModel.h"
    3637#include "pmModelUtils.h"
    37 #include "pmModelClass.h"
    3838#include "pmSourceMasks.h"
    3939#include "pmSourceExtendedPars.h"
    … …  
    5656# define PM_MODEL_LIMITS          pmModelLimits_EXP
    5757# define PM_MODEL_RADIUS          pmModelRadius_EXP
     58# define PM_MODEL_SET_FWHM        pmModelSetFWHM_EXP
    5859# define PM_MODEL_FROM_PSF        pmModelFromPSF_EXP
    5960# define PM_MODEL_PARAMS_FROM_PSF pmModelParamsFromPSF_EXP
    … …  
    343344}
    344345
     346psF64 PM_MODEL_SET_FWHM (const psVector *params, psF64 sigma) {
     347  return (NAN);
     348}
     349
    345350bool PM_MODEL_FROM_PSF (pmModel *modelPSF, pmModel *modelFLT, const pmPSF *psf)
    346351{
    … …  
    364369    // the 2D PSF model fits polarization terms (E0,E1,E2)
    365370    // convert to shape terms (SXX,SYY,SXY)
    366     bool useReff = pmModelUseReff (modelPSF->type);
     371    bool useReff = modelPSF->class->useReff;
    367372    if (!pmPSF_FitToModel (out, 0.1, useReff)) {
    368373        psTrace("psModules.objects", 5, "Failed to fit object at (r,c) = (%.1f,%.1f)", in[PM_PAR_YPOS], in[PM_PAR_XPOS]);
    … …  
    418423    // convert to shape terms (SXX,SYY,SXY)
    419424    // XXX user-defined value for limit?
    420     bool useReff = pmModelUseReff (model->type);
     425    bool useReff = model->class->useReff;
    421426    if (!pmPSF_FitToModel (PAR, 0.1, useReff)) {
    422427        psTrace ("psModules.objects", 3, "Failed to fit object at (r,c) = (%.1f,%.1f)", Xo, Yo);

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/models/pmModel_EXP.h

    r35560 r37403  
    88psF64 pmModelFlux_EXP(const psVector *params);
    99psF64 pmModelRadius_EXP(const psVector *params, psF64 flux);
     10psF64 pmModelSetFWHM_EXP(const psVector *params, psF64 flux);
    1011bool pmModelFromPSF_EXP(pmModel *modelPSF, pmModel *modelFLT, const pmPSF *psf);
    1112bool  pmModelParamsFromPSF_EXP(pmModel *model, const pmPSF *psf, float Xo, float Yo, float Io);

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/models/pmModel_GAUSS.c

    r36680 r37403  
    3333#include "pmMoments.h"
    3434#include "pmModelFuncs.h"
     35#include "pmModelClass.h"
    3536#include "pmModel.h"
    3637#include "pmModelUtils.h"
    37 #include "pmModelClass.h"
    3838#include "pmSourceMasks.h"
    3939#include "pmSourceExtendedPars.h"
    … …  
    5454# define PM_MODEL_GUESS           pmModelGuess_GAUSS
    5555# define PM_MODEL_LIMITS          pmModelLimits_GAUSS
     56# define PM_MODEL_SET_FWHM        pmModelSetFWHM_GAUSS
    5657# define PM_MODEL_RADIUS          pmModelRadius_GAUSS
    5758# define PM_MODEL_FROM_PSF        pmModelFromPSF_GAUSS
    … …  
    257258}
    258259
     260psF64 PM_MODEL_SET_FWHM (const psVector *params, psF64 sigma) {
     261    return (2.35482004503*sigma);
     262}
     263
    259264// construct the PSF model from the FLT model and the psf
    260265bool PM_MODEL_FROM_PSF (pmModel *modelPSF, pmModel *modelFLT, const pmPSF *psf)
    … …  
    279284    // the 2D PSF model fits polarization terms (E0,E1,E2)
    280285    // convert to shape terms (SXX,SYY,SXY)
    281     bool useReff = pmModelUseReff (modelPSF->type);
     286    bool useReff = modelPSF->class->useReff;
    282287    if (!pmPSF_FitToModel (out, 0.1, useReff)) {
    283288        psTrace ("psModules.objects", 3, "Failed to fit object at (r,c) = (%.1f,%.1f)", in[PM_PAR_YPOS], in[PM_PAR_XPOS]);
    … …  
    331336    // the 2D PSF model fits polarization terms (E0,E1,E2)
    332337    // convert to shape terms (SXX,SYY,SXY)
    333     bool useReff = pmModelUseReff (model->type);
     338    bool useReff = model->class->useReff;
    334339    if (!pmPSF_FitToModel (PAR, 0.1, useReff)) {
    335340        psTrace ("psModules.objects", 3, "Failed to fit object at (r,c) = (%.1f,%.1f)", Xo, Yo);

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/models/pmModel_GAUSS.h

    r35560 r37403  
    88psF64 pmModelFlux_GAUSS(const psVector *params);
    99psF64 pmModelRadius_GAUSS(const psVector *params, psF64 flux);
     10psF64 pmModelSetFWHM_GAUSS(const psVector *params, psF64 flux);
    1011bool pmModelFromPSF_GAUSS(pmModel *modelPSF, pmModel *modelFLT, const pmPSF *psf);
    1112bool  pmModelParamsFromPSF_GAUSS(pmModel *model, const pmPSF *psf, float Xo, float Yo, float Io);

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/models/pmModel_PGAUSS.c

    r36680 r37403  
    3333#include "pmMoments.h"
    3434#include "pmModelFuncs.h"
     35#include "pmModelClass.h"
    3536#include "pmModel.h"
    3637#include "pmModelUtils.h"
    37 #include "pmModelClass.h"
    3838#include "pmSourceMasks.h"
    3939#include "pmSourceExtendedPars.h"
    … …  
    5555# define PM_MODEL_LIMITS          pmModelLimits_PGAUSS
    5656# define PM_MODEL_RADIUS          pmModelRadius_PGAUSS
     57# define PM_MODEL_SET_FWHM        pmModelSetFWHM_PGAUSS
    5758# define PM_MODEL_FROM_PSF        pmModelFromPSF_PGAUSS
    5859# define PM_MODEL_PARAMS_FROM_PSF pmModelParamsFromPSF_PGAUSS
    … …  
    324325}
    325326
     327// scale factor is constant for PGAUSS, I found it with the fwhm.sh script
     328psF64 PM_MODEL_SET_FWHM (const psVector *params, psF64 sigma) {
     329    return (3.0063103*sigma);
     330}
     331
    326332bool PM_MODEL_FROM_PSF (pmModel *modelPSF, pmModel *modelFLT, const pmPSF *psf)
    327333{
    … …  
    344350    // the 2D PSF model fits polarization terms (E0,E1,E2)
    345351    // convert to shape terms (SXX,SYY,SXY)
    346     bool useReff = pmModelUseReff (modelPSF->type);
     352    bool useReff = modelPSF->class->useReff;
    347353    if (!pmPSF_FitToModel (out, 0.1, useReff)) {
    348354        psTrace("psModules.objects", 5, "Failed to fit object at (r,c) = (%.1f,%.1f)", in[PM_PAR_YPOS], in[PM_PAR_XPOS]);
    … …  
    396402    // the 2D PSF model fits polarization terms (E0,E1,E2)
    397403    // convert to shape terms (SXX,SYY,SXY)
    398     bool useReff = pmModelUseReff (model->type);
     404    bool useReff = model->class->useReff;
    399405    if (!pmPSF_FitToModel (PAR, 0.1, useReff)) {
    400406        psTrace ("psModules.objects", 3, "Failed to fit object at (r,c) = (%.1f,%.1f)", Xo, Yo);

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/models/pmModel_PGAUSS.h

    r35560 r37403  
    88psF64 pmModelFlux_PGAUSS(const psVector *params);
    99psF64 pmModelRadius_PGAUSS(const psVector *params, psF64 flux);
     10psF64 pmModelSetFWHM_PGAUSS(const psVector *params, psF64 flux);
    1011bool pmModelFromPSF_PGAUSS(pmModel *modelPSF, pmModel *modelFLT, const pmPSF *psf);
    1112bool  pmModelParamsFromPSF_PGAUSS(pmModel *model, const pmPSF *psf, float Xo, float Yo, float Io);

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/models/pmModel_PS1_V1.c

    r36680 r37403  
    3535#include "pmMoments.h"
    3636#include "pmModelFuncs.h"
     37#include "pmModelClass.h"
    3738#include "pmModel.h"
    3839#include "pmModelUtils.h"
    39 #include "pmModelClass.h"
    4040#include "pmSourceMasks.h"
    4141#include "pmSourceExtendedPars.h"
    … …  
    5757# define PM_MODEL_LIMITS          pmModelLimits_PS1_V1
    5858# define PM_MODEL_RADIUS          pmModelRadius_PS1_V1
     59# define PM_MODEL_SET_FWHM        pmModelSetFWHM_PS1_V1
    5960# define PM_MODEL_FROM_PSF        pmModelFromPSF_PS1_V1
    6061# define PM_MODEL_PARAMS_FROM_PSF pmModelParamsFromPSF_PS1_V1
    … …  
    336337}
    337338
     339// I used the script in models/fwhm.sh to generate the trend of FWHM scaling vs the K value
     340// FWHM = Scale * Sigma (not that PAR[PM_PAR_SXX] = sigma * sqrt(2)
     341//  K : z_hm  : FWHM
     342//  0 : 1.000 : 2.83
     343//  1 : 0.597 : 2.19
     344//  2 : 0.396 : 1.78
     345//  3 : 0.291 : 1.53
     346//  4 : 0.232 : 1.36
     347//  5 : 0.198 : 1.26
     348//  6 : 0.169 : 1.16
     349//  7 : 0.142 : 1.07
     350//  8 : 0.124 : 0.99
     351//  9 : 0.118 : 0.97
     352// 10 : 0.106 : 0.92
     353// 11 : 0.092 : 0.86
     354// 12 : 0.091 : 0.85
     355// 13 : 0.080 : 0.80
     356// 14 : 0.078 : 0.79
     357// 15 : 0.073 : 0.76
     358// 16 : 0.063 : 0.71
     359// 17 : 0.068 : 0.74
     360// 18 : 0.056 : 0.67
     361// 19 : 0.058 : 0.68
     362
     363// static float PS1_V1_Core[] = { 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0};
     364static float PS1_V1_Scale[] = {2.83, 2.19, 1.78, 1.53, 1.36, 1.26, 1.16, 1.07, 0.99, 0.97, 0.92, 0.86, 0.85, 0.80, 0.79, 0.76, 0.71, 0.74, 0.67, 0.68};
     365
     366psF64 PM_MODEL_SET_FWHM (const psVector *params, psF64 sigma) {
     367
     368    psF32 *PAR = params->data.F32;
     369
     370    float core = PAR[PM_PAR_7];
     371
     372    if (!isfinite(core)) return (2.0*M_SQRT2*sigma);
     373
     374    // if PS1_V1_Core is defined as a set of integer steps, so we can simplify:
     375    int binCore = MAX(0, MIN (19, (int)core));
     376
     377    float scale = NAN;
     378    if (binCore == 0) {
     379        scale = (core - binCore + 0) * (PS1_V1_Scale[binCore + 1] - PS1_V1_Scale[binCore + 0]) + PS1_V1_Scale[binCore + 0];
     380    } else {
     381        scale = (core - binCore - 1) * (PS1_V1_Scale[binCore + 0] - PS1_V1_Scale[binCore - 1]) + PS1_V1_Scale[binCore - 1];
     382    }
     383
     384    return (scale * sigma);
     385}
     386
    338387bool PM_MODEL_FROM_PSF (pmModel *modelPSF, pmModel *modelFLT, const pmPSF *psf)
    339388{
    340 
    341389    psF32 *out = modelPSF->params->data.F32;
    342390    psF32 *in  = modelFLT->params->data.F32;
    … …  
    357405    // the 2D PSF model fits polarization terms (E0,E1,E2)
    358406    // convert to shape terms (SXX,SYY,SXY)
    359     bool useReff = pmModelUseReff (modelPSF->type);
     407    bool useReff = modelPSF->class->useReff;
    360408    if (!pmPSF_FitToModel (out, 0.1, useReff)) {
    361409        psTrace("psModules.objects", 5, "Failed to fit object at (r,c) = (%.1f,%.1f)", in[PM_PAR_YPOS], in[PM_PAR_XPOS]);
    … …  
    411459    // convert to shape terms (SXX,SYY,SXY)
    412460    // XXX user-defined value for limit?
    413     bool useReff = pmModelUseReff (model->type);
     461    bool useReff = model->class->useReff;
    414462    if (!pmPSF_FitToModel (PAR, 0.1, useReff)) {
    415463        psTrace ("psModules.objects", 3, "Failed to fit object at (r,c) = (%.1f,%.1f)", Xo, Yo);

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/models/pmModel_PS1_V1.h

    r35560 r37403  
    88psF64 pmModelFlux_PS1_V1(const psVector *params);
    99psF64 pmModelRadius_PS1_V1(const psVector *params, psF64 flux);
     10psF64 pmModelSetFWHM_PS1_V1(const psVector *params, psF64 flux);
    1011bool pmModelFromPSF_PS1_V1(pmModel *modelPSF, pmModel *modelFLT, const pmPSF *psf);
    1112bool  pmModelParamsFromPSF_PS1_V1(pmModel *model, const pmPSF *psf, float Xo, float Yo, float Io);

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/models/pmModel_QGAUSS.c

    r36680 r37403  
    3535#include "pmMoments.h"
    3636#include "pmModelFuncs.h"
     37#include "pmModelClass.h"
    3738#include "pmModel.h"
    3839#include "pmModelUtils.h"
    39 #include "pmModelClass.h"
    4040#include "pmSourceMasks.h"
    4141#include "pmSourceExtendedPars.h"
    … …  
    5757# define PM_MODEL_LIMITS          pmModelLimits_QGAUSS
    5858# define PM_MODEL_RADIUS          pmModelRadius_QGAUSS
     59# define PM_MODEL_SET_FWHM        pmModelSetFWHM_QGAUSS
    5960# define PM_MODEL_FROM_PSF        pmModelFromPSF_QGAUSS
    6061# define PM_MODEL_PARAMS_FROM_PSF pmModelParamsFromPSF_QGAUSS
    … …  
    337338}
    338339
     340// I used the script in models/fwhm.sh to generate the trend of FWHM scaling vs the K value
     341// FWHM = Scale * Sigma (not that PAR[PM_PAR_SXX] = sigma * sqrt(2)
     342//  K : z_hm  : FWHM
     343//  0 : 1.000 : 2.83
     344//  1 : 0.648 : 2.28
     345//  2 : 0.430 : 1.85
     346//  3 : 0.310 : 1.58
     347//  4 : 0.244 : 1.40
     348//  5 : 0.200 : 1.26
     349//  6 : 0.165 : 1.15
     350//  7 : 0.149 : 1.09
     351//  8 : 0.125 : 1.00
     352//  9 : 0.116 : 0.96
     353// 10 : 0.101 : 0.90
     354// 11 : 0.095 : 0.87
     355// 12 : 0.083 : 0.82
     356// 13 : 0.082 : 0.81
     357// 14 : 0.080 : 0.80
     358// 15 : 0.074 : 0.77
     359// 16 : 0.064 : 0.71
     360// 17 : 0.068 : 0.74
     361// 18 : 0.057 : 0.67
     362// 19 : 0.058 : 0.68
     363
     364// static float QGAUSS_Core[] = { 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0};
     365static float QGAUSS_Scale[] = {2.83, 2.28, 1.85, 1.58, 1.40, 1.26, 1.15, 1.09, 1.00, 0.96, 0.90, 0.87, 0.82, 0.81, 0.80, 0.77, 0.71, 0.74, 0.67, 0.68};
     366
     367psF64 PM_MODEL_SET_FWHM (const psVector *params, psF64 sigma) {
     368
     369    psF32 *PAR = params->data.F32;
     370
     371    float core = PAR[PM_PAR_7];
     372
     373    if (!isfinite(core)) return (2.0*M_SQRT2*sigma);
     374
     375    // QGAUSS_Core is defined as a set of integer steps, so we can simplify:
     376    int binCore = MAX(0, MIN (19, (int)core));
     377
     378    float scale = NAN;
     379    if (binCore == 0) {
     380        scale = (core - binCore + 0) * (QGAUSS_Scale[binCore + 1] - QGAUSS_Scale[binCore + 0]) + QGAUSS_Scale[binCore + 0];
     381    } else {
     382        scale = (core - binCore - 1) * (QGAUSS_Scale[binCore + 0] - QGAUSS_Scale[binCore - 1]) + QGAUSS_Scale[binCore - 1];
     383    }
     384
     385    return (scale * sigma);
     386}
     387
    339388bool PM_MODEL_FROM_PSF (pmModel *modelPSF, pmModel *modelFLT, const pmPSF *psf)
    340389{
    … …  
    358407    // the 2D PSF model fits polarization terms (E0,E1,E2)
    359408    // convert to shape terms (SXX,SYY,SXY)
    360     bool useReff = pmModelUseReff (modelPSF->type);
     409    bool useReff = modelPSF->class->useReff;
    361410    if (!pmPSF_FitToModel (out, 0.1, useReff)) {
    362411        psTrace("psModules.objects", 5, "Failed to fit object at (r,c) = (%.1f,%.1f)", in[PM_PAR_YPOS], in[PM_PAR_XPOS]);
    … …  
    416465    // the 2D PSF model fits polarization terms (E0,E1,E2)
    417466    // convert to shape terms (SXX,SYY,SXY)
    418     bool useReff = pmModelUseReff (model->type);
     467    bool useReff = model->class->useReff;
    419468    if (!pmPSF_FitToModel (PAR, 0.1, useReff)) {
    420469        psTrace ("psModules.objects", 3, "Failed to fit object at (r,c) = (%.1f,%.1f)", Xo, Yo);

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/models/pmModel_QGAUSS.h

    r35560 r37403  
    88psF64 pmModelFlux_QGAUSS(const psVector *params);
    99psF64 pmModelRadius_QGAUSS(const psVector *params, psF64 flux);
     10psF64 pmModelSetFWHM_QGAUSS(const psVector *params, psF64 flux);
    1011bool pmModelFromPSF_QGAUSS(pmModel *modelPSF, pmModel *modelFLT, const pmPSF *psf);
    1112bool  pmModelParamsFromPSF_QGAUSS(pmModel *model, const pmPSF *psf, float Xo, float Yo, float Io);

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/models/pmModel_RGAUSS.c

    r36680 r37403  
    3434#include "pmMoments.h"
    3535#include "pmModelFuncs.h"
     36#include "pmModelClass.h"
    3637#include "pmModel.h"
    3738#include "pmModelUtils.h"
    38 #include "pmModelClass.h"
    3939#include "pmSourceMasks.h"
    4040#include "pmSourceExtendedPars.h"
    … …  
    5656# define PM_MODEL_LIMITS          pmModelLimits_RGAUSS
    5757# define PM_MODEL_RADIUS          pmModelRadius_RGAUSS
     58# define PM_MODEL_SET_FWHM        pmModelSetFWHM_RGAUSS
    5859# define PM_MODEL_FROM_PSF        pmModelFromPSF_RGAUSS
    5960# define PM_MODEL_PARAMS_FROM_PSF pmModelParamsFromPSF_RGAUSS
    … …  
    330331}
    331332
     333psF64 PM_MODEL_SET_FWHM (const psVector *params, psF64 sigma) {
     334  return (NAN);
     335}
     336
    332337bool PM_MODEL_FROM_PSF (pmModel *modelPSF, pmModel *modelFLT, const pmPSF *psf)
    333338{
    … …  
    351356    // the 2D PSF model fits polarization terms (E0,E1,E2)
    352357    // convert to shape terms (SXX,SYY,SXY)
    353     bool useReff = pmModelUseReff (modelPSF->type);
     358    bool useReff = modelPSF->class->useReff;
    354359    if (!pmPSF_FitToModel (out, 0.1, useReff)) {
    355360        psTrace("psModules.objects", 5, "Failed to fit object at (r,c) = (%.1f,%.1f)", in[PM_PAR_YPOS], in[PM_PAR_XPOS]);
    … …  
    404409    // the 2D PSF model fits polarization terms (E0,E1,E2)
    405410    // convert to shape terms (SXX,SYY,SXY)
    406     bool useReff = pmModelUseReff (model->type);
     411    bool useReff = model->class->useReff;
    407412    if (!pmPSF_FitToModel (PAR, 0.1, useReff)) {
    408413        psTrace ("psModules.objects", 3, "Failed to fit object at (r,c) = (%.1f,%.1f)", Xo, Yo);

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/models/pmModel_RGAUSS.h

    r35560 r37403  
    88psF64 pmModelFlux_RGAUSS(const psVector *params);
    99psF64 pmModelRadius_RGAUSS(const psVector *params, psF64 flux);
     10psF64 pmModelSetFWHM_RGAUSS(const psVector *params, psF64 flux);
    1011bool pmModelFromPSF_RGAUSS(pmModel *modelPSF, pmModel *modelFLT, const pmPSF *psf);
    1112bool  pmModelParamsFromPSF_RGAUSS(pmModel *model, const pmPSF *psf, float Xo, float Yo, float Io);

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/models/pmModel_SERSIC.c

    r36680 r37403  
    4343#include "pmMoments.h"
    4444#include "pmModelFuncs.h"
     45#include "pmModelClass.h"
    4546#include "pmModel.h"
    4647#include "pmModelUtils.h"
    47 #include "pmModelClass.h"
    4848#include "pmSourceMasks.h"
    4949#include "pmSourceExtendedPars.h"
    … …  
    6666# define PM_MODEL_LIMITS          pmModelLimits_SERSIC
    6767# define PM_MODEL_RADIUS          pmModelRadius_SERSIC
     68# define PM_MODEL_SET_FWHM        pmModelSetFWHM_SERSIC
    6869# define PM_MODEL_FROM_PSF        pmModelFromPSF_SERSIC
    6970# define PM_MODEL_PARAMS_FROM_PSF pmModelParamsFromPSF_SERSIC
    … …  
    124125    if (radius <= 1.5) {
    125126        // Nsub ~ 10*index^2 + 1
    126         psEllipseAxes axes = pmPSF_ModelToAxes(PAR, pmModelClassGetType ("PS_MODEL_SERSIC"));
     127        psEllipseAxes axes = pmPSF_ModelToAxes(PAR, true); // SERSIC model uses Reff
    127128        int Nsub = 2 * ((int)(6.0*Sindex / axes.minor)) + 1;
    128129        Nsub = PS_MIN (Nsub, 121);
    … …  
    357358}
    358359
     360psF64 PM_MODEL_SET_FWHM (const psVector *params, psF64 sigma) {
     361  return (NAN);
     362}
     363
    359364bool PM_MODEL_FROM_PSF (pmModel *modelPSF, pmModel *modelFLT, const pmPSF *psf)
    360365{
    … …  
    378383    // the 2D PSF model fits polarization terms (E0,E1,E2)
    379384    // convert to shape terms (SXX,SYY,SXY)
    380     bool useReff = pmModelUseReff (modelPSF->type);
     385    bool useReff = modelPSF->class->useReff;
    381386    if (!pmPSF_FitToModel (out, 0.1, useReff)) {
    382387        psTrace("psModules.objects", 5, "Failed to fit object at (r,c) = (%.1f,%.1f)", in[PM_PAR_YPOS], in[PM_PAR_XPOS]);
    … …  
    432437    // convert to shape terms (SXX,SYY,SXY)
    433438    // XXX user-defined value for limit?
    434     bool useReff = pmModelUseReff (model->type);
     439    bool useReff = model->class->useReff;
    435440    if (!pmPSF_FitToModel (PAR, 0.1, useReff)) {
    436441        psTrace ("psModules.objects", 3, "Failed to fit object at (r,c) = (%.1f,%.1f)", Xo, Yo);

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/models/pmModel_SERSIC.h

    r35560 r37403  
    88psF64 pmModelFlux_SERSIC(const psVector *params);
    99psF64 pmModelRadius_SERSIC(const psVector *params, psF64 flux);
     10psF64 pmModelSetFWHM_SERSIC(const psVector *params, psF64 flux);
    1011bool pmModelFromPSF_SERSIC(pmModel *modelPSF, pmModel *modelFLT, const pmPSF *psf);
    1112bool  pmModelParamsFromPSF_SERSIC(pmModel *model, const pmPSF *psf, float Xo, float Yo, float Io);

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/models/pmModel_TRAIL.c

    r36680 r37403  
    55 * The meaning of the parameters may thus vary depending on the specifics of the model.
    66 * All models which are used as a PSF representations share a few parameters, for which #
     7#include "pmModelClass.h"
    78 * define names are listed in pmModel.h:
    89
    … …  
    3334#include "pmMoments.h"
    3435#include "pmModelFuncs.h"
     36#include "pmModelClass.h"
    3537#include "pmModel.h"
    3638#include "pmModelUtils.h"
    37 #include "pmModelClass.h"
    3839#include "pmSourceMasks.h"
    3940#include "pmSourceExtendedPars.h"
    … …  
    5556# define PM_MODEL_LIMITS          pmModelLimits_TRAIL
    5657# define PM_MODEL_RADIUS          pmModelRadius_TRAIL
     58# define PM_MODEL_SET_FWHM        pmModelSetFWHM_TRAIL
    5759# define PM_MODEL_FROM_PSF        pmModelFromPSF_TRAIL
    5860# define PM_MODEL_PARAMS_FROM_PSF pmModelParamsFromPSF_TRAIL
    … …  
    352354
    353355    psF32 *psfPAR  = source->modelPSF->params->data.F32;
    354     bool useReff = pmModelUseReff (source->modelPSF->type);
     356    bool useReff = source->modelPSF->class->useReff;
    355357
    356358    psEllipseAxes psfAxes;
    … …  
    413415    // PAR_LENGTH is the unconvolved length.  add a bit for safety
    414416    return (0.5*PAR[PM_PAR_LENGTH] + 2);
     417}
     418
     419psF64 PM_MODEL_SET_FWHM (const psVector *params, psF64 sigma) {
     420  return (NAN);
    415421}
    416422

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/models/pmModel_TRAIL.h

    r35560 r37403  
    88psF64 pmModelFlux_TRAIL(const psVector *params);
    99psF64 pmModelRadius_TRAIL(const psVector *params, psF64 flux);
     10psF64 pmModelSetFWHM_TRAIL(const psVector *params, psF64 flux);
    1011bool pmModelFromPSF_TRAIL(pmModel *modelPSF, pmModel *modelFLT, const pmPSF *psf);
    1112bool  pmModelParamsFromPSF_TRAIL(pmModel *model, const pmPSF *psf, float Xo, float Yo, float Io);

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmDetEff.c

    r36680 r37403  
    1717#include "pmMoments.h"
    1818#include "pmModelFuncs.h"
     19#include "pmModelClass.h"
    1920#include "pmModel.h"
    2021#include "pmModelUtils.h"
    21 #include "pmModelClass.h"
    2222#include "pmSourceMasks.h"
    2323#include "pmSourceExtendedPars.h"

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmGrowthCurve.c

    r36680 r37403  
    3030#include "pmMoments.h"
    3131#include "pmModelFuncs.h"
     32#include "pmModelClass.h"
    3233#include "pmModel.h"
    3334#include "pmModelUtils.h"
    34 #include "pmModelClass.h"
    3535#include "pmSourceMasks.h"
    3636#include "pmSourceExtendedPars.h"

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmGrowthCurveGenerate.c

    r36680 r37403  
    3737#include "pmMoments.h"
    3838#include "pmModelFuncs.h"
     39#include "pmModelClass.h"
    3940#include "pmModel.h"
    4041#include "pmModelUtils.h"
    41 #include "pmModelClass.h"
    4242#include "pmSourceMasks.h"
    4343#include "pmSourceExtendedPars.h"

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmModel.c

    r36680 r37403  
    3333#include "pmMoments.h"
    3434#include "pmModelFuncs.h"
     35#include "pmModelClass.h"
    3536#include "pmModel.h"
    36 #include "pmModelClass.h"
    3737
    3838static void modelFree(pmModel *tmp)
    3939{
    4040    psTrace("psModules.objects", 10, "---- %s() begin ----\n", __func__);
     41    if (!tmp) return;
     42
    4143    psFree(tmp->params);
    4244    psFree(tmp->dparams);
    … …  
    9092    }
    9193
    92     tmp->modelFunc          = class->modelFunc;
    93     tmp->modelFlux          = class->modelFlux;
    94     tmp->modelRadius        = class->modelRadius;
    95     tmp->modelLimits        = class->modelLimits;
    96     tmp->modelGuess         = class->modelGuess;
    97     tmp->modelFromPSF       = class->modelFromPSF;
    98     tmp->modelParamsFromPSF = class->modelParamsFromPSF;
    99     tmp->modelFitStatus     = class->modelFitStatus;
    100     tmp->modelSetLimits     = class->modelSetLimits;
     94    tmp->class = class;
     95
     96    // tmp->modelFunc          = class->modelFunc;
     97    // tmp->modelFlux          = class->modelFlux;
     98    // tmp->modelRadius        = class->modelRadius;
     99    // tmp->modelLimits        = class->modelLimits;
     100    // tmp->modelGuess         = class->modelGuess;
     101    // tmp->modelFromPSF       = class->modelFromPSF;
     102    // tmp->modelParamsFromPSF = class->modelParamsFromPSF;
     103    // tmp->modelFitStatus     = class->modelFitStatus;
     104    // tmp->modelSetLimits     = class->modelSetLimits;
    101105
    102106    psTrace("psModules.objects", 10, "---- %s() end ----\n", __func__);
    … …  
    156160    psF32 tmpF;
    157161
    158     tmpF = model->modelFunc (NULL, model->params, x);
     162    tmpF = model->class->modelFunc (NULL, model->params, x);
    159163    psFree(x);
    160164    psTrace("psModules.objects", 10, "---- %s() end ----\n", __func__);
    … …  
    176180    psF32 tmpF;
    177181
    178     tmpF = model->modelFunc (NULL, model->params, x);
     182    tmpF = model->class->modelFunc (NULL, model->params, x);
    179183    psFree(x);
    180184    psTrace("psModules.objects", 10, "---- %s() end ----\n", __func__);
    … …  
    283287            // add in the desired components for this coordinate
    284288            if (mode & PM_MODEL_OP_FUNC) {
    285                 pixelValue += model->modelFunc (NULL, params, x);
     289                pixelValue += model->class->modelFunc (NULL, params, x);
    286290            }
    287291

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmModel.h

    r31153 r37403  
    4747    bool isPCM;                         ///< is this model fitted with PSF-convolution?
    4848
     49    pmModelClass *class;
     50
    4951    // functions for this model which depend on the model class
    50     pmModelFunc          modelFunc;
    51     pmModelFlux          modelFlux;
    52     pmModelRadius        modelRadius;
    53     pmModelLimits        modelLimits;
    54     pmModelGuessFunc     modelGuess;
    55     pmModelFromPSFFunc   modelFromPSF;
    56     pmModelParamsFromPSF modelParamsFromPSF;
    57     pmModelFitStatusFunc modelFitStatus;
    58     pmModelSetLimitsFunc modelSetLimits;
     52   
     53    // pmModelFunc          modelFunc;
     54    // pmModelFlux          modelFlux;
     55    // pmModelRadius        modelRadius;
     56    // pmModelLimits        modelLimits;
     57    // pmModelGuessFunc     modelGuess;
     58    // pmModelFromPSFFunc   modelFromPSF;
     59    // pmModelParamsFromPSF modelParamsFromPSF;
     60    // pmModelFitStatusFunc modelFitStatus;
     61    // pmModelSetLimitsFunc modelSetLimits;
    5962};
    6063

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmModelClass.c

    r36680 r37403  
    3333#include "pmMoments.h"
    3434#include "pmModelFuncs.h"
     35#include "pmModelClass.h"
    3536#include "pmModel.h"
    3637#include "pmModelUtils.h"
    37 #include "pmModelClass.h"
    3838
    3939#include "pmErrorCodes.h"
    … …  
    5454
    5555static pmModelClass defaultModels[] = {
    56     {"PS_MODEL_GAUSS",        7, (pmModelFunc)pmModelFunc_GAUSS,   (pmModelFlux)pmModelFlux_GAUSS,   (pmModelRadius)pmModelRadius_GAUSS,   (pmModelLimits)pmModelLimits_GAUSS,   (pmModelGuessFunc)pmModelGuess_GAUSS,  (pmModelFromPSFFunc)pmModelFromPSF_GAUSS,  (pmModelParamsFromPSF)pmModelParamsFromPSF_GAUSS,  (pmModelFitStatusFunc)pmModelFitStatus_GAUSS,  (pmModelSetLimitsFunc)pmModelSetLimits_GAUSS  },
    57     {"PS_MODEL_PGAUSS",       7, (pmModelFunc)pmModelFunc_PGAUSS,  (pmModelFlux)pmModelFlux_PGAUSS,  (pmModelRadius)pmModelRadius_PGAUSS,  (pmModelLimits)pmModelLimits_PGAUSS,  (pmModelGuessFunc)pmModelGuess_PGAUSS, (pmModelFromPSFFunc)pmModelFromPSF_PGAUSS, (pmModelParamsFromPSF)pmModelParamsFromPSF_PGAUSS, (pmModelFitStatusFunc)pmModelFitStatus_PGAUSS, (pmModelSetLimitsFunc)pmModelSetLimits_PGAUSS },
    58     {"PS_MODEL_QGAUSS",       8, (pmModelFunc)pmModelFunc_QGAUSS,  (pmModelFlux)pmModelFlux_QGAUSS,  (pmModelRadius)pmModelRadius_QGAUSS,  (pmModelLimits)pmModelLimits_QGAUSS,  (pmModelGuessFunc)pmModelGuess_QGAUSS, (pmModelFromPSFFunc)pmModelFromPSF_QGAUSS, (pmModelParamsFromPSF)pmModelParamsFromPSF_QGAUSS, (pmModelFitStatusFunc)pmModelFitStatus_QGAUSS, (pmModelSetLimitsFunc)pmModelSetLimits_QGAUSS },
    59     {"PS_MODEL_PS1_V1",       8, (pmModelFunc)pmModelFunc_PS1_V1,  (pmModelFlux)pmModelFlux_PS1_V1,  (pmModelRadius)pmModelRadius_PS1_V1,  (pmModelLimits)pmModelLimits_PS1_V1,  (pmModelGuessFunc)pmModelGuess_PS1_V1, (pmModelFromPSFFunc)pmModelFromPSF_PS1_V1, (pmModelParamsFromPSF)pmModelParamsFromPSF_PS1_V1, (pmModelFitStatusFunc)pmModelFitStatus_PS1_V1, (pmModelSetLimitsFunc)pmModelSetLimits_PS1_V1 },
    60     {"PS_MODEL_RGAUSS",       8, (pmModelFunc)pmModelFunc_RGAUSS,  (pmModelFlux)pmModelFlux_RGAUSS,  (pmModelRadius)pmModelRadius_RGAUSS,  (pmModelLimits)pmModelLimits_RGAUSS,  (pmModelGuessFunc)pmModelGuess_RGAUSS, (pmModelFromPSFFunc)pmModelFromPSF_RGAUSS, (pmModelParamsFromPSF)pmModelParamsFromPSF_RGAUSS, (pmModelFitStatusFunc)pmModelFitStatus_RGAUSS, (pmModelSetLimitsFunc)pmModelSetLimits_RGAUSS },
    61     {"PS_MODEL_SERSIC",       8, (pmModelFunc)pmModelFunc_SERSIC,  (pmModelFlux)pmModelFlux_SERSIC,  (pmModelRadius)pmModelRadius_SERSIC,  (pmModelLimits)pmModelLimits_SERSIC,  (pmModelGuessFunc)pmModelGuess_SERSIC, (pmModelFromPSFFunc)pmModelFromPSF_SERSIC, (pmModelParamsFromPSF)pmModelParamsFromPSF_SERSIC, (pmModelFitStatusFunc)pmModelFitStatus_SERSIC, (pmModelSetLimitsFunc)pmModelSetLimits_SERSIC },
    62     {"PS_MODEL_EXP",          7, (pmModelFunc)pmModelFunc_EXP,     (pmModelFlux)pmModelFlux_EXP,     (pmModelRadius)pmModelRadius_EXP,     (pmModelLimits)pmModelLimits_EXP,     (pmModelGuessFunc)pmModelGuess_EXP,    (pmModelFromPSFFunc)pmModelFromPSF_EXP,    (pmModelParamsFromPSF)pmModelParamsFromPSF_EXP,    (pmModelFitStatusFunc)pmModelFitStatus_EXP,    (pmModelSetLimitsFunc)pmModelSetLimits_EXP    },
    63     {"PS_MODEL_DEV",          7, (pmModelFunc)pmModelFunc_DEV,     (pmModelFlux)pmModelFlux_DEV,     (pmModelRadius)pmModelRadius_DEV,     (pmModelLimits)pmModelLimits_DEV,     (pmModelGuessFunc)pmModelGuess_DEV,    (pmModelFromPSFFunc)pmModelFromPSF_DEV,    (pmModelParamsFromPSF)pmModelParamsFromPSF_DEV,    (pmModelFitStatusFunc)pmModelFitStatus_DEV,    (pmModelSetLimitsFunc)pmModelSetLimits_DEV    },
    64     {"PS_MODEL_TRAIL",        7, (pmModelFunc)pmModelFunc_TRAIL,   (pmModelFlux)pmModelFlux_TRAIL,   (pmModelRadius)pmModelRadius_TRAIL,   (pmModelLimits)pmModelLimits_TRAIL,   (pmModelGuessFunc)pmModelGuess_TRAIL,  (pmModelFromPSFFunc)pmModelFromPSF_TRAIL,  (pmModelParamsFromPSF)pmModelParamsFromPSF_TRAIL,  (pmModelFitStatusFunc)pmModelFitStatus_TRAIL,  (pmModelSetLimitsFunc)pmModelSetLimits_TRAIL  },
     56    {"PS_MODEL_GAUSS",        7, 0, (pmModelFunc)pmModelFunc_GAUSS,   (pmModelFlux)pmModelFlux_GAUSS,   (pmModelRadius)pmModelRadius_GAUSS,   (pmModelSetFWHM)pmModelSetFWHM_GAUSS,   (pmModelLimits)pmModelLimits_GAUSS,   (pmModelGuessFunc)pmModelGuess_GAUSS,  (pmModelFromPSFFunc)pmModelFromPSF_GAUSS,  (pmModelParamsFromPSF)pmModelParamsFromPSF_GAUSS,  (pmModelFitStatusFunc)pmModelFitStatus_GAUSS,  (pmModelSetLimitsFunc)pmModelSetLimits_GAUSS  },
     57    {"PS_MODEL_PGAUSS",       7, 0, (pmModelFunc)pmModelFunc_PGAUSS,  (pmModelFlux)pmModelFlux_PGAUSS,  (pmModelRadius)pmModelRadius_PGAUSS,  (pmModelSetFWHM)pmModelSetFWHM_PGAUSS,  (pmModelLimits)pmModelLimits_PGAUSS,  (pmModelGuessFunc)pmModelGuess_PGAUSS, (pmModelFromPSFFunc)pmModelFromPSF_PGAUSS, (pmModelParamsFromPSF)pmModelParamsFromPSF_PGAUSS, (pmModelFitStatusFunc)pmModelFitStatus_PGAUSS, (pmModelSetLimitsFunc)pmModelSetLimits_PGAUSS },
     58    {"PS_MODEL_QGAUSS",       8, 0, (pmModelFunc)pmModelFunc_QGAUSS,  (pmModelFlux)pmModelFlux_QGAUSS,  (pmModelRadius)pmModelRadius_QGAUSS,  (pmModelSetFWHM)pmModelSetFWHM_QGAUSS,  (pmModelLimits)pmModelLimits_QGAUSS,  (pmModelGuessFunc)pmModelGuess_QGAUSS, (pmModelFromPSFFunc)pmModelFromPSF_QGAUSS, (pmModelParamsFromPSF)pmModelParamsFromPSF_QGAUSS, (pmModelFitStatusFunc)pmModelFitStatus_QGAUSS, (pmModelSetLimitsFunc)pmModelSetLimits_QGAUSS },
     59    {"PS_MODEL_PS1_V1",       8, 0, (pmModelFunc)pmModelFunc_PS1_V1,  (pmModelFlux)pmModelFlux_PS1_V1,  (pmModelRadius)pmModelRadius_PS1_V1,  (pmModelSetFWHM)pmModelSetFWHM_PS1_V1,  (pmModelLimits)pmModelLimits_PS1_V1,  (pmModelGuessFunc)pmModelGuess_PS1_V1, (pmModelFromPSFFunc)pmModelFromPSF_PS1_V1, (pmModelParamsFromPSF)pmModelParamsFromPSF_PS1_V1, (pmModelFitStatusFunc)pmModelFitStatus_PS1_V1, (pmModelSetLimitsFunc)pmModelSetLimits_PS1_V1 },
     60    {"PS_MODEL_RGAUSS",       8, 0, (pmModelFunc)pmModelFunc_RGAUSS,  (pmModelFlux)pmModelFlux_RGAUSS,  (pmModelRadius)pmModelRadius_RGAUSS,  (pmModelSetFWHM)pmModelSetFWHM_RGAUSS,  (pmModelLimits)pmModelLimits_RGAUSS,  (pmModelGuessFunc)pmModelGuess_RGAUSS, (pmModelFromPSFFunc)pmModelFromPSF_RGAUSS, (pmModelParamsFromPSF)pmModelParamsFromPSF_RGAUSS, (pmModelFitStatusFunc)pmModelFitStatus_RGAUSS, (pmModelSetLimitsFunc)pmModelSetLimits_RGAUSS },
     61    {"PS_MODEL_SERSIC",       8, 1, (pmModelFunc)pmModelFunc_SERSIC,  (pmModelFlux)pmModelFlux_SERSIC,  (pmModelRadius)pmModelRadius_SERSIC,  (pmModelSetFWHM)pmModelSetFWHM_SERSIC,  (pmModelLimits)pmModelLimits_SERSIC,  (pmModelGuessFunc)pmModelGuess_SERSIC, (pmModelFromPSFFunc)pmModelFromPSF_SERSIC, (pmModelParamsFromPSF)pmModelParamsFromPSF_SERSIC, (pmModelFitStatusFunc)pmModelFitStatus_SERSIC, (pmModelSetLimitsFunc)pmModelSetLimits_SERSIC },
     62    {"PS_MODEL_EXP",          7, 1, (pmModelFunc)pmModelFunc_EXP,     (pmModelFlux)pmModelFlux_EXP,     (pmModelRadius)pmModelRadius_EXP,     (pmModelSetFWHM)pmModelSetFWHM_EXP,     (pmModelLimits)pmModelLimits_EXP,     (pmModelGuessFunc)pmModelGuess_EXP,    (pmModelFromPSFFunc)pmModelFromPSF_EXP,    (pmModelParamsFromPSF)pmModelParamsFromPSF_EXP,    (pmModelFitStatusFunc)pmModelFitStatus_EXP,    (pmModelSetLimitsFunc)pmModelSetLimits_EXP    },
     63    {"PS_MODEL_DEV",          7, 1, (pmModelFunc)pmModelFunc_DEV,     (pmModelFlux)pmModelFlux_DEV,     (pmModelRadius)pmModelRadius_DEV,     (pmModelSetFWHM)pmModelSetFWHM_DEV,     (pmModelLimits)pmModelLimits_DEV,     (pmModelGuessFunc)pmModelGuess_DEV,    (pmModelFromPSFFunc)pmModelFromPSF_DEV,    (pmModelParamsFromPSF)pmModelParamsFromPSF_DEV,    (pmModelFitStatusFunc)pmModelFitStatus_DEV,    (pmModelSetLimitsFunc)pmModelSetLimits_DEV    },
     64    {"PS_MODEL_TRAIL",        7, 0, (pmModelFunc)pmModelFunc_TRAIL,   (pmModelFlux)pmModelFlux_TRAIL,   (pmModelRadius)pmModelRadius_TRAIL,   (pmModelSetFWHM)pmModelSetFWHM_TRAIL,   (pmModelLimits)pmModelLimits_TRAIL,   (pmModelGuessFunc)pmModelGuess_TRAIL,  (pmModelFromPSFFunc)pmModelFromPSF_TRAIL,  (pmModelParamsFromPSF)pmModelParamsFromPSF_TRAIL,  (pmModelFitStatusFunc)pmModelFitStatus_TRAIL,  (pmModelSetLimitsFunc)pmModelSetLimits_TRAIL  },
    6565};
    6666

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmModelClass.h

    r36680 r37403  
    3535    char *name;
    3636    int nParams;
     37    bool useReff;
    3738    pmModelFunc          modelFunc;
    3839    pmModelFlux          modelFlux;
    3940    pmModelRadius        modelRadius;
     41    pmModelSetFWHM       modelSetFWHM;
    4042    pmModelLimits        modelLimits;
    4143    pmModelGuessFunc     modelGuess;

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmModelFuncs.h

    r36680 r37403  
    110110typedef psF64 (*pmModelRadius)(const psVector *params, double flux);
    111111
     112// This function returns the FWHM given the supplied sigma (major or minor)
     113typedef psF64 (*pmModelSetFWHM)(const psVector *params, double sigma);
     114
    112115//  This function provides the model guess parameters based on the details of
    113116//  the given source.

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmModelUtils.c

    r36680 r37403  
    3232#include "pmMoments.h"
    3333#include "pmModelFuncs.h"
     34#include "pmModelClass.h"
    3435#include "pmModel.h"
    3536#include "pmModelUtils.h"
    36 #include "pmModelClass.h"
    3737#include "pmSourceMasks.h"
    3838#include "pmSourceExtendedPars.h"
    … …  
    4646#include "pmErrorCodes.h"
    4747
    48 // XX static bool useModelVar = false;
    49 // XX
    50 // XX void pmModelSetModelVarOption (bool option) {
    51 // XX   useModelVar = option;
    52 // XX }
    53 // XX bool pmModelGetModelVarOption (void) {
    54 // XX   return useModelVar;
    55 // XX }
    56 
    5748/*****************************************************************************
    5849pmModelFromPSF (*modelEXT, *psf):  use the model position parameters to
    … …  
    6859
    6960    // set model parameters for this source based on PSF information
    70     if (!modelEXT->modelFromPSF (modelPSF, modelEXT, psf)) {
     61    if (!modelEXT->class->modelFromPSF (modelPSF, modelEXT, psf)) {
    7162        psTrace ("psModules.objects", 3, "Failed to set model params from PSF");
    7263        psFree(modelPSF);
    … …  
    8980
    9081    // set model parameters for this source based on PSF information
    91     if (!modelPSF->modelParamsFromPSF (modelPSF, psf, Xo, Yo, Io)) {
     82    if (!modelPSF->class->modelParamsFromPSF (modelPSF, psf, Xo, Yo, Io)) {
    9283        psFree(modelPSF);
    9384        return NULL;
    … …  
    109100
    110101    // determine the normalized flux
    111     float normFlux = model->modelFlux (model->params);
     102    float normFlux = model->class->modelFlux (model->params);
    112103    assert (isfinite(normFlux));
    113104    assert (normFlux > 0);
    … …  
    120111
    121112bool pmModelUseReff (pmModelType type) {
    122     bool useReff = false;
    123     useReff |= (type == pmModelClassGetType ("PS_MODEL_SERSIC"));
    124     useReff |= (type == pmModelClassGetType ("PS_MODEL_DEV"));
    125     useReff |= (type == pmModelClassGetType ("PS_MODEL_EXP"));
     113
     114    pmModelClass *class = pmModelClassSelect (type);
     115    psAssert (class, "undefined model class?");
     116    bool useReff = class->useReff;
    126117    return useReff;
    127118}

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmPCM_MinimizeChisq.c

    r36680 r37403  
    3131#include "pmMoments.h"
    3232#include "pmModelFuncs.h"
     33#include "pmModelClass.h"
    3334#include "pmModel.h"
    3435#include "pmModelUtils.h"
    35 #include "pmModelClass.h"
    3636#include "pmSourceMasks.h"
    3737#include "pmSourceExtendedPars.h"
    … …  
    455455            coord->data.F32[1] = (psF32) (i + 0.5 + source->pixels->row0);
    456456
    457             pcm->modelFlux->data.F32[i][j] = pcm->modelConv->modelFunc (deriv, params, coord);
     457            pcm->modelFlux->data.F32[i][j] = pcm->modelConv->class->modelFunc (deriv, params, coord);
    458458
    459459            for (int n = 0; n < params->n; n++) {

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmPCMdata.c

    r36680 r37403  
    3131#include "pmMoments.h"
    3232#include "pmModelFuncs.h"
     33#include "pmModelClass.h"
    3334#include "pmModel.h"
    3435#include "pmModelUtils.h"
    35 #include "pmModelClass.h"
    3636#include "pmSourceMasks.h"
    3737#include "pmSourceExtendedPars.h"
    … …  
    293293   
    294294    psEllipseAxes axes;
    295     bool useReff = pmModelUseReff (modelPSF->type);
     295    bool useReff = modelPSF->class->useReff;
    296296    psF32 *PAR = modelPSF->params->data.F32;
    297297    pmModelParamsToAxes (&axes, PAR[PM_PAR_SXX], PAR[PM_PAR_SXY], PAR[PM_PAR_SYY], useReff);
    … …  
    302302    // XXX need to do this more carefully
    303303    if (modelPSF->type == modelType_GAUSS) {
    304         float FWHM_MAJOR = 2*modelPSF->modelRadius (modelPSF->params, 0.5*PAR[PM_PAR_I0]);
     304        float FWHM_MAJOR = 2*modelPSF->class->modelRadius (modelPSF->params, 0.5*PAR[PM_PAR_I0]);
    305305        float FWHM_MINOR = FWHM_MAJOR * (axes.minor / axes.major);
    306306        *sigma = 0.50 * (FWHM_MAJOR + FWHM_MINOR) / 2.35;
    … …  
    330330   
    331331    psEllipseAxes axes;
    332     bool useReff = pmModelUseReff (modelPSF->type);
     332    bool useReff = modelPSF->class->useReff;
    333333    psF32 *PAR = modelPSF->params->data.F32;
    334334    pmModelParamsToAxes (&axes, PAR[PM_PAR_SXX], PAR[PM_PAR_SXY], PAR[PM_PAR_SYY], useReff);
    … …  
    339339    // XXX need to do this more carefully
    340340    if (modelPSF->type == modelType_GAUSS) {
    341         float FWHM_MAJOR = 2*modelPSF->modelRadius (modelPSF->params, 0.5*PAR[PM_PAR_I0]);
     341        float FWHM_MAJOR = 2*modelPSF->class->modelRadius (modelPSF->params, 0.5*PAR[PM_PAR_I0]);
    342342        float FWHM_MINOR = FWHM_MAJOR * (axes.minor / axes.major);
    343343        *sigma = 0.50 * (FWHM_MAJOR + FWHM_MINOR) / 2.35;
    … …  
    393393    psMinConstraint *constraint = psMinConstraintAlloc();
    394394    constraint->paramMask = psVectorAlloc (params->n, PS_TYPE_VECTOR_MASK);
    395     constraint->checkLimits = model->modelLimits;
     395    constraint->checkLimits = model->class->modelLimits;
    396396
    397397    int nParams = pmPCMsetParams (constraint, fitOptions->mode);

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmPSF.c

    r36680 r37403  
    3737#include "pmMoments.h"
    3838#include "pmModelFuncs.h"
     39#include "pmModelClass.h"
    3940#include "pmModel.h"
    4041#include "pmModelUtils.h"
    41 #include "pmModelClass.h"
    4242#include "pmSourceMasks.h"
    4343#include "pmSourceExtendedPars.h"
    … …  
    329329// convert the parameters used in the fitted source model to the psEllipseAxes representation
    330330// (major,minor,theta)
    331 psEllipseAxes pmPSF_ModelToAxes (psF32 *modelPar, pmModelType type)
     331psEllipseAxes pmPSF_ModelToAxes (psF32 *modelPar, bool useReff)
    332332{
    333333    psEllipseAxes axes;
    … …  
    338338    PS_ASSERT_PTR_NON_NULL(modelPar, axes);
    339339
    340     bool useReff = pmModelUseReff (type);
    341340    pmModelParamsToAxes (&axes, modelPar[PM_PAR_SXX], modelPar[PM_PAR_SXY], modelPar[PM_PAR_SYY], useReff);
    342341    return axes;
    … …  
    345344// convert the psEllipseAxes representation (major,minor,theta) to the parameters used in the
    346345// fitted source model
    347 bool pmPSF_AxesToModel (psF32 *modelPar, psEllipseAxes axes, pmModelType type)
     346bool pmPSF_AxesToModel (psF32 *modelPar, psEllipseAxes axes, bool useReff)
    348347{
    349348    PS_ASSERT_PTR_NON_NULL(modelPar, false);
    … …  
    357356    }
    358357   
    359     bool useReff = pmModelUseReff (type);
    360358    pmModelAxesToParams (&modelPar[PM_PAR_SXX], &modelPar[PM_PAR_SXY], &modelPar[PM_PAR_SYY], axes, useReff);
    361359    return true;
    … …  
    420418
    421419    // get the model full-width at half-max
    422     float fwhmMajor = 2*model->modelRadius (model->params, 0.5);
     420    float fwhmMajor = 2*model->class->modelRadius (model->params, 0.5);
    423421
    424422# if (0)
    425423    psF32 *params = model->params->data.F32; // Model parameters
    426     psEllipseAxes axes = pmPSF_ModelToAxes(params, MAX_AXIS_RATIO, model->type); // Ellipse axes
     424    psEllipseAxes axes = pmPSF_ModelToAxes(params, MAX_AXIS_RATIO, model->class->useReff); // Ellipse axes
    427425
    428426    // Curiously, the minor axis can be larger than the major axis, so need to check.

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmPSF.h

    r35768 r37403  
    106106pmPSF *pmPSFBuildSimple (char *typeName, float sxx, float syy, float sxy, ...);
    107107
    108 bool pmPSF_AxesToModel (psF32 *modelPar, psEllipseAxes axes, pmModelType type);
     108bool pmPSF_AxesToModel (psF32 *modelPar, psEllipseAxes axes, bool useReff);
    109109bool pmPSF_FitToModel (psF32 *fittedPar, float minMinorAxis, bool useReff);
    110110
    111111psEllipsePol pmPSF_ModelToFit (psF32 *modelPar, bool useReff);
    112 psEllipseAxes pmPSF_ModelToAxes (psF32 *modelPar, pmModelType type);
     112psEllipseAxes pmPSF_ModelToAxes (psF32 *modelPar, bool useReff);
    113113
    114114/// Calculate FWHM value from a PSF

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmPSF_IO.c

    r36680 r37403  
    4747#include "pmMoments.h"
    4848#include "pmModelFuncs.h"
     49#include "pmModelClass.h"
    4950#include "pmModel.h"
    5051#include "pmModelUtils.h"
    51 #include "pmModelClass.h"
    5252#include "pmSourceMasks.h"
    5353#include "pmSourceExtendedPars.h"
    … …  
    511511        psMetadataAddF32 (header, PS_LIST_TAIL, "SKY_BIAS", PS_DATA_F32, "sky bias level", psf->skyBias);
    512512
    513         float PSF_APERTURE =  psMetadataLookupF32(&status, roAnalysis, "PSF_APERTURE");
    514         if (status) {
     513        if (roAnalysis) {
     514          float PSF_APERTURE =  psMetadataLookupF32(&status, roAnalysis, "PSF_APERTURE");
     515          if (status) {
    515516            psMetadataAddF32 (header, PS_LIST_TAIL, "PSF_APERTURE", PS_DATA_F32, "aperture for psf objects", PSF_APERTURE);
    516         }
    517         float PSF_FIT_RADIUS =  psMetadataLookupF32(&status, roAnalysis, "PSF_FIT_RADIUS");
    518         if (status) {
     517          }
     518          float PSF_FIT_RADIUS =  psMetadataLookupF32(&status, roAnalysis, "PSF_FIT_RADIUS");
     519          if (status) {
    519520            psMetadataAddF32 (header, PS_LIST_TAIL, "PSF_FIT_RADIUS", PS_DATA_F32, "aperture for psf objects", PSF_FIT_RADIUS);
     521          }
    520522        }
    521523

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmPSFtry.c

    r36680 r37403  
    2929#include "pmMoments.h"
    3030#include "pmModelFuncs.h"
     31#include "pmModelClass.h"
    3132#include "pmModel.h"
    3233#include "pmModelUtils.h"
    33 #include "pmModelClass.h"
    3434#include "pmSourceMasks.h"
    3535#include "pmSourceExtendedPars.h"

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmPSFtryFitEXT.c

    r36680 r37403  
    2929#include "pmMoments.h"
    3030#include "pmModelFuncs.h"
     31#include "pmModelClass.h"
    3132#include "pmModel.h"
    3233#include "pmModelUtils.h"
    33 #include "pmModelClass.h"
    3434#include "pmSourceMasks.h"
    3535#include "pmSourceExtendedPars.h"

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmPSFtryFitPSF.c

    r36680 r37403  
    2727#include "pmMoments.h"
    2828#include "pmModelFuncs.h"
     29#include "pmModelClass.h"
    2930#include "pmModel.h"
    3031#include "pmModelUtils.h"
    31 #include "pmModelClass.h"
    3232#include "pmSourceMasks.h"
    3333#include "pmSourceExtendedPars.h"

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmPSFtryMakePSF.c

    r36680 r37403  
    2828#include "pmMoments.h"
    2929#include "pmModelFuncs.h"
     30#include "pmModelClass.h"
    3031#include "pmModel.h"
    3132#include "pmModelUtils.h"
    32 #include "pmModelClass.h"
    3333#include "pmSourceMasks.h"
    3434#include "pmSourceExtendedPars.h"
    … …  
    212212        assert (source->modelEXT); // all unmasked sources should have modelEXT
    213213
    214         bool useReff = pmModelUseReff (source->modelEXT->type);
     214        bool useReff = source->modelEXT->class->useReff;
    215215        psEllipsePol pol = pmPSF_ModelToFit (source->modelEXT->params->data.F32, useReff);
    216216
    … …  
    218218        e1->data.F32[i] = pol.e1;
    219219        e2->data.F32[i] = pol.e2;
     220    }
     221
     222    // weed out extreme e0 outliers here: find the median and exclude points not in the
     223    // range MEDIAN / 5 < e0 < 5 * MEDIAN
     224    {
     225      psStats *e0stats = psStatsAlloc (PS_STAT_SAMPLE_MEDIAN);
     226      if (psVectorStats (e0stats, e0, NULL, srcMask, 0xff)) {
     227        float e0med = e0stats->sampleMedian;
     228   
     229        for (int i = 0; i < sources->n; i++) {
     230          // skip any masked sources (failed to fit one of the model steps or get a magnitude)
     231          if (srcMask->data.PS_TYPE_VECTOR_MASK_DATA[i]) continue;
     232
     233          if (e0->data.F32[i] < 0.2*e0med) {
     234            srcMask->data.PS_TYPE_VECTOR_MASK_DATA[i] = PSFTRY_MASK_OUTLIER;
     235          }
     236          if (e0->data.F32[i] > 5.0*e0med) {
     237            srcMask->data.PS_TYPE_VECTOR_MASK_DATA[i] = PSFTRY_MASK_OUTLIER;
     238          }
     239        }
     240      }
     241      psFree (e0stats);
    220242    }
    221243

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmPSFtryMetric.c

    r36680 r37403  
    2828#include "pmMoments.h"
    2929#include "pmModelFuncs.h"
     30#include "pmModelClass.h"
    3031#include "pmModel.h"
    3132#include "pmModelUtils.h"
    32 #include "pmModelClass.h"
    3333#include "pmSourceMasks.h"
    3434#include "pmSourceExtendedPars.h"

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmPSFtryModel.c

    r36680 r37403  
    2929#include "pmMoments.h"
    3030#include "pmModelFuncs.h"
     31#include "pmModelClass.h"
    3132#include "pmModel.h"
    3233#include "pmModelUtils.h"
    33 #include "pmModelClass.h"
    3434#include "pmSourceMasks.h"
    3535#include "pmSourceExtendedPars.h"

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmPhotObj.c

    r36680 r37403  
    2929#include "pmMoments.h"
    3030#include "pmModelFuncs.h"
     31#include "pmModelClass.h"
    3132#include "pmModel.h"
    3233#include "pmModelUtils.h"
    33 #include "pmModelClass.h"
    3434#include "pmSourceMasks.h"
    3535#include "pmSourceExtendedPars.h"

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmSource.c

    r36680 r37403  
    3333#include "pmMoments.h"
    3434#include "pmModelFuncs.h"
     35#include "pmModelClass.h"
    3536#include "pmModel.h"
    3637#include "pmModelUtils.h"
    37 #include "pmModelClass.h"
    3838#include "pmSourceMasks.h"
    3939#include "pmSourceExtendedPars.h"
    … …  
    146146    source->apMagRaw         = NAN;
    147147    source->apRadius         = NAN;
     148    source->apNpixels        = 0;
    148149    source->apFlux           = NAN;
    149150    source->apFluxErr        = NAN;
    … …  
    162163    source->sky              = NAN;
    163164    source->skyErr           = NAN;   
     165    source->extSN            = NAN;   
    164166
    165167    source->region = psRegionSet(NAN, NAN, NAN, NAN);
    … …  
    174176    source->parent = NULL;
    175177    source->tmpPtr = NULL;
     178    source->chipNum = -1;
     179    source->chipX = -1000;
     180    source->chipY = -1000;
    176181    source->imageID = -1;
    177182    source->nFrames = 0;
    … …  
    236241    source->apMagRaw         = in->apMagRaw;
    237242    source->apRadius         = in->apRadius;
     243    source->apNpixels        = in->apNpixels;
    238244    source->apFlux           = in->apFlux;
    239245    source->apFluxErr        = in->apFluxErr;
    … …  
    986992    if (!isfinite(oldI0)) return false;
    987993
    988     bool useReff = pmModelUseReff (model->type);
     994    bool useReff = model->class->useReff;
    989995    pmModelParamsToAxes (&axes, PAR[PM_PAR_SXX], PAR[PM_PAR_SXY], PAR[PM_PAR_SYY], useReff);
    990996

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmSource.h

    r36680 r37403  
    9797    float apMagRaw;                     ///< raw mag in given aperture
    9898    float apRadius;                     ///< radius for aperture magnitude
     99    int   apNpixels;                    ///< number of unmasked pixels in aperture
    99100    float apFlux;                       ///< apFlux corresponding to psfMag or extMag (depending on type)
    100101    float apFluxErr;                    ///< apFluxErr corresponding to psfMag or extMag (depending on type)
    … …  
    113114    float sky;                          ///< The sky at the center of the object
    114115    float skyErr;                       ///< The sky error at the center of the object
     116    float extSN;                        ///< for externally supplied source the kron signal to noise (used by full force)
    115117
    116118    psRegion region;                    ///< area on image covered by selected pixels
    … …  
    119121    pmSourceExtendedPars *extpars;      ///< extended source parameters
    120122    pmSourceDiffStats *diffStats;       ///< extra parameters for difference detections
    121     pmSourceGalaxyFits *galaxyFits;     ///< fits to galaxy models (psphotFullForce only)
     123    psArray *galaxyFits;                ///< fits to galaxy models (psphotFullForce only)
    122124    pmSourceLensing *lensingOBJ;        ///< lensing moments parameters (per object)
    123125    pmSourceLensing *lensingPSF;        ///< lensing moments parameters (psf, interpolated)
    … …  
    125127    pmSource *parent;                   ///< reference to the master source from which this is derived
    126128    psPtr *tmpPtr;                      ///< pointer that may be used to store data in a particular module. e.g. psphotKronIterate.
     129    short chipNum;                      ///< camera dependent of chip suppling pixels for fullforce source
     130    short chipX;                        ///< chip space X coord of fullforce source
     131    short chipY;                        ///< chip space Y coord of fullforce source
    127132    int imageID;
    128133    psU16 nFrames;

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmSourceContour.c

    r36680 r37403  
    3333#include "pmMoments.h"
    3434#include "pmModelFuncs.h"
     35#include "pmModelClass.h"
    3536#include "pmModel.h"
    3637#include "pmModelUtils.h"
    37 #include "pmModelClass.h"
    3838#include "pmSourceMasks.h"
    3939#include "pmSourceExtendedPars.h"

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmSourceExtendedPars.h

    r36680 r37403  
    8383
    8484typedef struct {
     85  int       modelType;
    8586  psVector *Flux;
    8687  psVector *dFlux;
    8788  psVector *chisq;
    88   int nPix;
     89  int       nPix;
     90  bool      reducedTrials;
     91  float     fRmajorMin;
     92  float     fRmajorMax;
     93  float     fRmajorDel;
     94  float     fRminorMin;
     95  float     fRminorMax;
     96  float     fRminorDel;
    8997} pmSourceGalaxyFits;
    9098

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmSourceFitModel.c

    r36680 r37403  
    3333#include "pmMoments.h"
    3434#include "pmModelFuncs.h"
     35#include "pmModelClass.h"
    3536#include "pmModel.h"
    3637#include "pmModelUtils.h"
    37 #include "pmModelClass.h"
    3838#include "pmSourceMasks.h"
    3939#include "pmSourceExtendedPars.h"
    … …  
    170170    psMinConstraint *constraint = psMinConstraintAlloc();
    171171    constraint->paramMask = psVectorAlloc (params->n, PS_TYPE_VECTOR_MASK);
    172     constraint->checkLimits = model->modelLimits;
     172    constraint->checkLimits = model->class->modelLimits;
    173173
    174174    // set parameter mask based on fitting mode
    … …  
    233233    // force the floating parameters to fall within the contraint ranges
    234234    for (int i = 0; i < params->n; i++) {
    235         model->modelLimits (PS_MINIMIZE_PARAM_MIN, i, params->data.F32, NULL);
    236         model->modelLimits (PS_MINIMIZE_PARAM_MAX, i, params->data.F32, NULL);
     235        model->class->modelLimits (PS_MINIMIZE_PARAM_MIN, i, params->data.F32, NULL);
     236        model->class->modelLimits (PS_MINIMIZE_PARAM_MAX, i, params->data.F32, NULL);
    237237    }
    238238
    … …  
    254254    psImage *covar = psImageAlloc (params->n, params->n, PS_TYPE_F32);
    255255
    256     fitStatus = psMinimizeLMChi2(myMin, covar, params, constraint, x, y, yErr, model->modelFunc);
     256    fitStatus = psMinimizeLMChi2(myMin, covar, params, constraint, x, y, yErr, model->class->modelFunc);
    257257    for (int i = 0; i < dparams->n; i++) {
    258258        if ((constraint->paramMask != NULL) && constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[i])
    … …  
    306306            altmask->data.PS_TYPE_VECTOR_MASK_DATA[i] = (constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[i]) ? 0 : 1;
    307307        }
    308         psMinimizeGaussNewtonDelta(delta, params, altmask, x, y, yErr, model->modelFunc);
     308        psMinimizeGaussNewtonDelta(delta, params, altmask, x, y, yErr, model->class->modelFunc);
    309309
    310310        for (int i = 0; i < dparams->n; i++) {

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmSourceFitPCM.c

    r36680 r37403  
    3131#include "pmMoments.h"
    3232#include "pmModelFuncs.h"
     33#include "pmModelClass.h"
    3334#include "pmModel.h"
    3435#include "pmModelUtils.h"
    35 #include "pmModelClass.h"
    3636#include "pmSourceMasks.h"
    3737#include "pmSourceExtendedPars.h"
    … …  
    6363    // force the floating parameters to fall within the contraint ranges
    6464    for (int i = 0; i < params->n; i++) {
    65         pcm->modelConv->modelLimits (PS_MINIMIZE_PARAM_MIN, i, params->data.F32, NULL);
    66         pcm->modelConv->modelLimits (PS_MINIMIZE_PARAM_MAX, i, params->data.F32, NULL);
     65        pcm->modelConv->class->modelLimits (PS_MINIMIZE_PARAM_MIN, i, params->data.F32, NULL);
     66        pcm->modelConv->class->modelLimits (PS_MINIMIZE_PARAM_MAX, i, params->data.F32, NULL);
    6767    }
    6868
    … …  
    165165bool pmSourceModelGuessPCM (pmPCMdata *pcm, pmSource *source, psImageMaskType maskVal, psImageMaskType markVal) {
    166166
    167     if (!pcm->modelConv->modelGuess(pcm->modelConv, source, maskVal, markVal)) {
     167    if (!pcm->modelConv->class->modelGuess(pcm->modelConv, source, maskVal, markVal)) {
    168168        return false;
    169169    }

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmSourceFitSet.c

    r36680 r37403  
    3232#include "pmMoments.h"
    3333#include "pmModelFuncs.h"
     34#include "pmModelClass.h"
    3435#include "pmModel.h"
    3536#include "pmModelUtils.h"
    36 #include "pmModelClass.h"
    3737#include "pmSourceMasks.h"
    3838#include "pmSourceExtendedPars.h"
    … …  
    223223    float *paramOne = params + nParamBase;
    224224    float *betaOne = betas + nParamBase;
    225     bool status = model->modelLimits (mode, nParamOne, paramOne, betaOne);
     225    bool status = model->class->modelLimits (mode, nParamOne, paramOne, betaOne);
    226226    return status;
    227227}
    … …  
    388388        psVector *derivOne = thisSet->derivSet->data[i];
    389389
    390         chisqOne = model->modelFunc (derivOne, paramOne, x);
     390        chisqOne = model->class->modelFunc (derivOne, paramOne, x);
    391391        chisqSum += chisqOne;
    392392    }

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmSourceGroups.c

    r36680 r37403  
    1818#include "pmMoments.h"
    1919#include "pmModelFuncs.h"
     20#include "pmModelClass.h"
    2021#include "pmModel.h"
    2122#include "pmModelUtils.h"
    22 #include "pmModelClass.h"
    2323#include "pmSourceMasks.h"
    2424#include "pmSourceExtendedPars.h"

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmSourceIO.c

    r36680 r37403  
    4040#include "pmMoments.h"
    4141#include "pmModelFuncs.h"
     42#include "pmModelClass.h"
    4243#include "pmModel.h"
    4344#include "pmModelUtils.h"
    44 #include "pmModelClass.h"
    4545#include "pmSourceMasks.h"
    4646#include "pmSourceExtendedPars.h"
    … …  
    365365# define PM_SOURCES_WRITE(NAME,TYPE)                                    \
    366366    if (!strcmp (exttype, NAME)) {                                      \
    367         status &= pmSourcesWrite_##TYPE(file->fits, readout, sources, file->header, outhead, dataname, recipe); \
     367        status = pmSourcesWrite_##TYPE(file->fits, readout, sources, file->header, outhead, dataname, recipe); \
    368368        if (xsrcname) {                                                 \
    369369            status &= pmSourcesWrite_##TYPE##_XSRC(file->fits, readout, sources, file->header, xsrcname, recipe); \
    … …  
    589589
    590590            // these are case-sensitive since the EXTYPE is case-sensitive
    591             status = true;
     591            status = false;
    592592            PM_SOURCES_WRITE("SMPDATA",   SMPDATA);
    593593            PM_SOURCES_WRITE("PS1_DEV_0", PS1_DEV_0);
    … …  
    601601            PM_SOURCES_WRITE("PS1_SV1",   CMF_PS1_SV1);
    602602            PM_SOURCES_WRITE("PS1_SV2",   CMF_PS1_SV2);
     603            PM_SOURCES_WRITE("PS1_SV3",   CMF_PS1_SV3);
     604            PM_SOURCES_WRITE("PS1_SV4",   CMF_PS1_SV4);
    603605            PM_SOURCES_WRITE("PS1_DV1",   CMF_PS1_DV1);
    604606            PM_SOURCES_WRITE("PS1_DV2",   CMF_PS1_DV2);
    605607            PM_SOURCES_WRITE("PS1_DV3",   CMF_PS1_DV3);
     608            PM_SOURCES_WRITE("PS1_DV4",   CMF_PS1_DV4);
    606609
    607610            psFree (outhead);
    … …  
    11211124            PM_SOURCES_READ_PSF("PS1_SV1",   CMF_PS1_SV1);
    11221125            PM_SOURCES_READ_PSF("PS1_SV2",   CMF_PS1_SV2);
     1126            PM_SOURCES_READ_PSF("PS1_SV3",   CMF_PS1_SV3);
     1127            PM_SOURCES_READ_PSF("PS1_SV4",   CMF_PS1_SV4);
    11231128            PM_SOURCES_READ_PSF("PS1_DV1",   CMF_PS1_DV1);
    11241129            PM_SOURCES_READ_PSF("PS1_DV2",   CMF_PS1_DV2);
    11251130            PM_SOURCES_READ_PSF("PS1_DV3",   CMF_PS1_DV3);
     1131            PM_SOURCES_READ_PSF("PS1_DV4",   CMF_PS1_DV4);
     1132
     1133            if (!sources) {
     1134                psError(PS_ERR_IO, false, "reading CMF data from %s with format %s\n", file->filename, exttype);
     1135                return false;
     1136            }
    11261137
    11271138            long *sourceIndex = NULL;
    … …  
    12021213        break;
    12031214
    1204       case PM_FPA_FILE_CFF:
     1215      case PM_FPA_FILE_CFF: {
     1216        // determine the output table format
     1217        psMetadata *recipe = psMetadataLookupMetadata(&status, config->recipes, "PSPHOT");
     1218        if (!status) {
     1219            psError(PS_ERR_UNKNOWN, true, "missing recipe PSPHOT in config data");
     1220            return false;
     1221        }
    12051222        // read in header, if not yet loaded
    12061223        hdu = pmFPAviewThisHDU (view, file->fpa);
    … …  
    12441261        }
    12451262
    1246         sources = pmSourcesRead_CFF(file->fits, hdu->header);
     1263        sources = pmSourcesRead_CFF(file->fits, hdu->header, recipe);
    12471264
    12481265        psTrace("psModules.objects", 6, "read CMF table from %s : %s : %s", file->filename, headname, dataname);
    … …  
    12501267        psFree (dataname);
    12511268        psFree (tableHeader);
     1269        }
    12521270        break;
    12531271
    … …  
    13951413        PM_SOURCES_READ_XSRC("PS1_SV1",   CMF_PS1_SV1);
    13961414        PM_SOURCES_READ_XSRC("PS1_SV2",   CMF_PS1_SV2);
     1415        PM_SOURCES_READ_XSRC("PS1_SV3",   CMF_PS1_SV3);
     1416        PM_SOURCES_READ_XSRC("PS1_SV4",   CMF_PS1_SV4);
    13971417        PM_SOURCES_READ_XSRC("PS1_DV1",   CMF_PS1_DV1);
    13981418        PM_SOURCES_READ_XSRC("PS1_DV2",   CMF_PS1_DV2);
    13991419        PM_SOURCES_READ_XSRC("PS1_DV3",   CMF_PS1_DV3);
     1420        PM_SOURCES_READ_XSRC("PS1_DV4",   CMF_PS1_DV4);
    14001421    }
    14011422    psFree(tableHeader);
    … …  
    14351456        PM_SOURCES_READ_XFIT("PS1_SV1",   CMF_PS1_SV1);
    14361457        PM_SOURCES_READ_XFIT("PS1_SV2",   CMF_PS1_SV2);
     1458        PM_SOURCES_READ_XFIT("PS1_SV3",   CMF_PS1_SV3);
     1459        PM_SOURCES_READ_XFIT("PS1_SV4",   CMF_PS1_SV4);
    14371460        PM_SOURCES_READ_XFIT("PS1_DV1",   CMF_PS1_DV1);
    14381461        PM_SOURCES_READ_XFIT("PS1_DV2",   CMF_PS1_DV2);
    14391462        PM_SOURCES_READ_XFIT("PS1_DV3",   CMF_PS1_DV3);
     1463        PM_SOURCES_READ_XFIT("PS1_DV4",   CMF_PS1_DV4);
    14401464    }
    14411465    psFree(tableHeader);
    … …  
    14741498        PM_SOURCES_READ_XRAD("PS1_SV1",   CMF_PS1_SV1);
    14751499        PM_SOURCES_READ_XRAD("PS1_SV2",   CMF_PS1_SV2);
     1500        PM_SOURCES_READ_XRAD("PS1_SV3",   CMF_PS1_SV3);
     1501        PM_SOURCES_READ_XRAD("PS1_SV4",   CMF_PS1_SV4);
    14761502        PM_SOURCES_READ_XRAD("PS1_DV1",   CMF_PS1_DV1);
    14771503        PM_SOURCES_READ_XRAD("PS1_DV2",   CMF_PS1_DV2);
    14781504        PM_SOURCES_READ_XRAD("PS1_DV3",   CMF_PS1_DV3);
     1505        PM_SOURCES_READ_XRAD("PS1_DV4",   CMF_PS1_DV4);
    14791506    }
    14801507    psFree(tableHeader);
    … …  
    15131540        PM_SOURCES_READ_XGAL("PS1_SV1",   CMF_PS1_SV1);
    15141541        PM_SOURCES_READ_XGAL("PS1_SV2",   CMF_PS1_SV2);
     1542        PM_SOURCES_READ_XGAL("PS1_SV3",   CMF_PS1_SV3);
     1543        PM_SOURCES_READ_XGAL("PS1_SV4",   CMF_PS1_SV4);
    15151544        PM_SOURCES_READ_XGAL("PS1_DV1",   CMF_PS1_DV1);
    15161545        PM_SOURCES_READ_XGAL("PS1_DV2",   CMF_PS1_DV2);
    15171546        PM_SOURCES_READ_XGAL("PS1_DV3",   CMF_PS1_DV3);
     1547        PM_SOURCES_READ_XGAL("PS1_DV4",   CMF_PS1_DV4);
    15181548    }
    15191549    psFree(tableHeader);

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmSourceIO.h

    r36680 r37403  
    4040MK_PROTO(CMF_PS1_SV1);
    4141MK_PROTO(CMF_PS1_SV2);
     42MK_PROTO(CMF_PS1_SV3);
     43MK_PROTO(CMF_PS1_SV4);
    4244MK_PROTO(CMF_PS1_DV1);
    4345MK_PROTO(CMF_PS1_DV2);
    4446MK_PROTO(CMF_PS1_DV3);
     47MK_PROTO(CMF_PS1_DV4);
    4548
    4649int pmSourceGetDophotType (pmSource *source);
    … …  
    5558
    5659psArray *pmSourcesReadCMP (char *filename, psMetadata *header);
    57 psArray *pmSourcesRead_CFF (psFits *fits, psMetadata *header);
     60psArray *pmSourcesRead_CFF (psFits *fits, psMetadata *header, psMetadata *recipe);
    5861bool pmSourcesWrite_CFF (pmReadout *readout, psFits *fits, psArray *sources, psMetadata *header, psMetadata *recipe);
    5962

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmSourceIO_CFF.c

    r36680 r37403  
    3737#include "pmMoments.h"
    3838#include "pmModelFuncs.h"
     39#include "pmModelClass.h"
    3940#include "pmModel.h"
    4041#include "pmModelUtils.h"
    41 #include "pmModelClass.h"
    4242#include "pmSourceMasks.h"
    4343#include "pmSourceExtendedPars.h"
    … …  
    5353#include "pmSourceOutputs.h"
    5454
    55 // read in a readout from the fits file
    56 psArray *pmSourcesRead_CFF (psFits *fits, psMetadata *header)
     55// read in sources readout from a cff fits file
     56psArray *pmSourcesRead_CFF (psFits *fits, psMetadata *header, psMetadata *recipe)
    5757{
    5858    PS_ASSERT_PTR_NON_NULL(fits, false);
    … …  
    7575    PS_ASSERT_INT_NONNEGATIVE(modelType, NULL);
    7676
     77    pmModelType sersicModelType = pmModelClassGetType("PS_MODEL_SERSIC");
     78    pmModelType devModelType    = pmModelClassGetType("PS_MODEL_DEV");
     79
     80    psString modelForce = psMetadataLookupStr(&status, recipe, "EXT_MODEL_TYPE_FORCE");
     81    psF32 forceDevSersicMin = NAN;
     82    bool forceAll = false;
     83    int modelTypeForce = 0;
     84    if (!strcmp(modelForce, "ALL")) {
     85        forceAll = true;
     86    } else if (!strcmp(modelForce, "PS_MODEL_SERSIC")) {
     87        modelTypeForce = sersicModelType;
     88        forceDevSersicMin = psMetadataLookupF32(&status, recipe, "EXT_MODEL_FORCE_DEV_SERSIC_MIN");
     89    } else {
     90        modelTypeForce = pmModelClassGetType(modelForce);
     91        PS_ASSERT_INT_NONNEGATIVE(modelTypeForce, NULL);
     92    }
     93
     94    // skip extended model types for likely stars
     95    // max value of KronMag - psfMag to keep ...
     96    psF32 starCut = psMetadataLookupF32(&status, recipe, "EXT_MODEL_FORCE_MAGDIFF_MAX");
     97    if (!status) {
     98        starCut = 0;
     99    }
     100    // ... unless SN is less than this value
     101    psF32 SNMinForCut = psMetadataLookupF32(&status, recipe, "EXT_MODEL_FORCE_CUT_SN_MIN");
     102    if (!status) {
     103        SNMinForCut = 10;
     104    }
     105
    77106    // We get the size of the table, and allocate the array of sources first because the table
    78107    // is large and ephemeral --- when the table gets blown away, whatever is allocated after
    79108    // the table is read blocks the free.  In fact, it's better to read the table row by row.
    80     long numSources = psFitsTableSize(fits); // Number of sources in table
    81     psArray *sources = psArrayAlloc(numSources); // Array of sources, to return
    82 
    83     // convert the table to the pmSource entriesa
    84     for (int i = 0; i < numSources; i++) {
     109    long numRows = psFitsTableSize(fits); // Number of rows in table
     110    psArray *sources = psArrayAllocEmpty(numRows); // Array of sources, to return
     111
     112    // convert the table to the pmSource entries
     113    pmSource *source = NULL;
     114    for (int i = 0; i < numRows; i++) {
    85115        psMetadata *row = psFitsReadTableRow(fits, i); // Table row
    86116        if (!row) {
    … …  
    108138        float kronRadius = psMetadataLookupF32 (&status, row, "KRON_RADIUS");
    109139        float petRadius  = psMetadataLookupF32 (&status, row, "PETRO_RADIUS");
     140        float SN         = psMetadataLookupF32 (&status, row, "SN");
    110141        bool fitGalaxy   = psMetadataLookupU8 (&status, row, "FIT_GALAXY");
    111142        bool psfStar     = psMetadataLookupU8 (&status, row, "PSF_STAR");
    … …  
    114145        float Rminor     = psMetadataLookupF32 (&status, row, "R_MINOR");
    115146        float theta      = psMetadataLookupF32 (&status, row, "THETA");
     147        float chisq      = psMetadataLookupF32 (&status, row, "CHISQ");
     148        float nDOF       = psMetadataLookupF32 (&status, row, "NDOF");
     149        float magDiff    = psMetadataLookupF32 (&status, row, "MAG_DIFF");
     150        psS16 modelFlags = psMetadataLookupS32 (&status, row, "MODEL_FLAGS");
    116151
    117152        int   galaxyModelType = psMetadataLookupS32(&status, row, "MODEL_TYPE");
    118         if (status) {
     153        if (status && galaxyModelType >= 0) {
    119154            galaxyModelType = pmModelClassGetLocalType(galaxyModelType);
    120155        } else {
    … …  
    123158        float Sindex     = psMetadataLookupF32 (&status, row, "INDEX"); // Should this be PAR_07 not sersic index
    124159
    125         pmSource *source = pmSourceAlloc ();
    126         pmModel *model = pmModelAlloc (modelType);
    127         source->modelPSF  = model;
    128 //        RoughClass wants source type to be unknown
    129 //        source->type = PM_SOURCE_TYPE_STAR; // XXX this should be added to the flags
    130         source->type = PM_SOURCE_TYPE_UNKNOWN;
    131 
    132         // XXX we can set this in general, but for a specific image, we need to weed out SATSTARS and
    133         // stars that are masked
    134         if (psfStar) {
    135             source->tmpFlags |= PM_SOURCE_TMPF_CANDIDATE_PSFSTAR;
    136         }
    137 
    138         // NOTE: A SEGV here because "model" is NULL is probably caused by not initialising the models.
    139         psF32 *PAR = model->params->data.F32;
    140         psF32 *dPAR = model->dparams->data.F32;
    141 
    142         source->seq       = ID;
    143         PAR[PM_PAR_XPOS]  = X;
    144         PAR[PM_PAR_YPOS]  = Y;
    145 
    146         dPAR[PM_PAR_XPOS] = 0.0;
    147         dPAR[PM_PAR_YPOS] = 0.0;
    148 
    149         PAR[PM_PAR_SKY]   = 0.0;
    150         dPAR[PM_PAR_SKY]  = 0.0;
    151 
    152         PAR[PM_PAR_I0]    = 1.0;
    153         dPAR[PM_PAR_I0]   = 0.0;
    154 
    155         source->sky       = PAR[PM_PAR_SKY];
    156         source->skyErr    = dPAR[PM_PAR_SKY];
    157 
    158         source->psfMag    = 0.0;
    159         source->psfMagErr = 0.0;
    160         source->apMag     = 0.0;
    161         source->apRadius  = apRadius;
    162 
    163         // we generate a somewhat fake PSF model here --
    164         // in most (all?) contexts, we will replace this with a measured psf model
    165         // elsewhere
    166         axes.major        = 1.0;
    167         axes.minor        = 1.0;
    168         axes.theta        = 0.0;
    169         pmPSF_AxesToModel (PAR, axes, modelType);
    170 
    171         // peak->detValue, rawFlux, smoothFlux are all set to the flux argument which is counts per second
    172         source->peak      = pmPeakAlloc(X, Y, flux, PM_PEAK_LONE);
    173         source->peak->xf  = X; // pmPeakAlloc converts X,Y to int, so reset here
    174         source->peak->yf  = Y; // pmPeakAlloc converts X,Y to int, so reset here
    175         source->peak->dx  = 0.0;
    176         source->peak->dy  = 0.0;
    177 
    178         source->moments = pmMomentsAlloc ();
    179         source->moments->Mx = X;
    180         source->moments->My = Y;
    181         source->moments->Mrf = kronRadius * 0.4; // kronRadius is 2.5 * first radial moment
    182 
    183         // Don't mark the moments as measured because that causes many fields to be left blank.
    184         // The moments code knows not to change the position or the Mrf for external sources
    185         // source->tmpFlags |= PM_SOURCE_TMPF_MOMENTS_MEASURED;
    186 
    187         if (isfinite(petRadius)) {
    188             source->extpars = pmSourceExtendedParsAlloc ();
    189             source->extpars->petrosianRadius = petRadius;
    190         }
    191 
     160        if (!source || ID != source->seq) {
     161            if (source) {
     162                psArrayAdd (sources, 1, source);
     163                psFree(source);
     164            }
     165            source = pmSourceAlloc ();
     166            pmModel *model = pmModelAlloc (modelType);
     167            source->modelPSF  = model;
     168            //        RoughClass wants source type to be unknown
     169            //        source->type = PM_SOURCE_TYPE_STAR; // XXX this should be added to the flags
     170            source->type = PM_SOURCE_TYPE_UNKNOWN;
     171
     172            // XXX we can set this in general, but for a specific image, we need to weed out SATSTARS and
     173            // stars that are masked
     174            if (psfStar) {
     175                source->tmpFlags |= PM_SOURCE_TMPF_CANDIDATE_PSFSTAR;
     176            }
     177
     178            // NOTE: A SEGV here because "model" is NULL is probably caused by not initialising the models.
     179            psF32 *PAR = model->params->data.F32;
     180            psF32 *dPAR = model->dparams->data.F32;
     181
     182            source->seq       = ID;
     183
     184            PAR[PM_PAR_XPOS]  = X;
     185            PAR[PM_PAR_YPOS]  = Y;
     186
     187            dPAR[PM_PAR_XPOS] = 0.0;
     188            dPAR[PM_PAR_YPOS] = 0.0;
     189
     190            PAR[PM_PAR_SKY]   = 0.0;
     191            dPAR[PM_PAR_SKY]  = 0.0;
     192
     193            PAR[PM_PAR_I0]    = 1.0;
     194            dPAR[PM_PAR_I0]   = 0.0;
     195
     196            source->sky       = PAR[PM_PAR_SKY];
     197            source->skyErr    = dPAR[PM_PAR_SKY];
     198
     199            source->psfMag    = 0.0;
     200            source->psfMagErr = 0.0;
     201            source->apMag     = 0.0;
     202            source->apRadius  = apRadius;
     203
     204            // we generate a somewhat fake PSF model here --
     205            // in most (all?) contexts, we will replace this with a measured psf model
     206            // elsewhere
     207            axes.major        = 1.0;
     208            axes.minor        = 1.0;
     209            axes.theta        = 0.0;
     210            pmPSF_AxesToModel (PAR, axes, model->class->useReff);
     211
     212            // peak->detValue, rawFlux, smoothFlux are all set to the flux argument which is counts per second
     213            source->peak      = pmPeakAlloc(X, Y, flux, PM_PEAK_LONE);
     214            source->peak->xf  = X; // pmPeakAlloc converts X,Y to int, so reset here
     215            source->peak->yf  = Y; // pmPeakAlloc converts X,Y to int, so reset here
     216            source->peak->dx  = 0.0;
     217            source->peak->dy  = 0.0;
     218
     219            source->extSN     = SN;
     220
     221            source->moments = pmMomentsAlloc ();
     222            source->moments->Mx = X;
     223            source->moments->My = Y;
     224            source->moments->Mrf = kronRadius * 0.4; // kronRadius is 2.5 * first radial moment
     225
     226            // Don't mark the moments as measured because that causes many fields to be left blank.
     227            // The moments code knows not to change the position or the Mrf for external sources
     228            // source->tmpFlags |= PM_SOURCE_TMPF_MOMENTS_MEASURED;
     229
     230            if (isfinite(petRadius)) {
     231                source->extpars = pmSourceExtendedParsAlloc ();
     232                source->extpars->petrosianRadius = petRadius;
     233            }
     234
     235        }
     236        bool saveExtModelParams = false;
    192237        if (fitGalaxy && galaxyModelType >= 0) {
    193             source->modelFits = psArrayAllocEmpty (1);
    194             pmModel *model = pmModelAlloc(galaxyModelType);
    195             psF32 *xPAR = model->params->data.F32;
    196 
    197             xPAR[PM_PAR_SKY]  = 0.0;
    198             xPAR[PM_PAR_I0]   = 1.0;
    199             xPAR[PM_PAR_XPOS] = X;
     238            // skip likely stars
     239            if (magDiff < starCut || SN < SNMinForCut) {
     240                if (forceAll) {
     241                    saveExtModelParams = true;
     242                } else if (galaxyModelType == modelTypeForce) {
     243                    // This is the model type that we are looking for
     244                    // proceed
     245                    saveExtModelParams = true;
     246                } else if (modelTypeForce == sersicModelType && galaxyModelType == devModelType) {
     247                    // We're doing sersic models, if sersic index is greater than the recipe's minimum index
     248                    // do dev model as well
     249                    if (isfinite(forceDevSersicMin) || Sindex >= forceDevSersicMin) {
     250                        saveExtModelParams = true;
     251                    }
     252                } else {
     253                    // not interested in this model
     254                }
     255            }
     256        }
     257
     258        if (saveExtModelParams) {
     259            if (!source->modelFits) {
     260                source->modelFits = psArrayAllocEmpty (1);
     261            }
     262            pmModel *model = pmModelAlloc(galaxyModelType);
     263            psF32 *xPAR = model->params->data.F32;
     264
     265            xPAR[PM_PAR_SKY]  = 0.0;
     266            xPAR[PM_PAR_I0]   = 1.0;
     267            xPAR[PM_PAR_XPOS] = X;
    200268            xPAR[PM_PAR_YPOS] = Y;
    201269           
    … …  
    205273            galaxyAxes.theta = theta * PS_RAD_DEG;
    206274
    207             pmPSF_AxesToModel (xPAR, galaxyAxes, galaxyModelType);
     275            pmPSF_AxesToModel (xPAR, galaxyAxes, model->class->useReff);
    208276            if (model->params->n > 7) {
    209277                xPAR[PM_PAR_7] = 0.5 / Sindex;
    210278            }
    211279
     280            model->chisq = chisq;
     281            model->nDOF = nDOF;
     282            model->flags = modelFlags;
     283
    212284            psArrayAdd (source->modelFits, 1, model);
    213285
    214 #ifdef notyet
    215             // XXX: set source->modelEXT to this model and flag as extended so that we have a better
    216             // shot at subtracting extended sources?
    217 
    218             // This doesn't work right. Need to do some more work to flesh out the model before it can be
    219             // used in subtaction. Better idea might be to do 2 passes in psphotFullForceReadout to
    220             // First find the best extended models and then do everything else.
    221             source->modelEXT = psMemIncrRefCounter(model);
    222             // is this safe? (no see above)
    223             source->type = PM_SOURCE_TYPE_EXTENDED;
    224             source->mode |= PM_SOURCE_MODE_EXTMODEL;
    225 #endif
    226 
    227286            psFree (model);
    228287        }
    229288
    230         sources->data[i] = source;
    231289        psFree(row);
     290    }
     291    if (source) {
     292        // close out last source
     293        psArrayAdd (sources, 1, source);
     294        psFree(source);
    232295    }
    233296
    … …  
    250313
    251314    pmModelType sersicModelType = pmModelClassGetType("PS_MODEL_SERSIC");
     315    pmModelType devModelType    = pmModelClassGetType("PS_MODEL_DEV");
     316    pmModelType selectedModelType = -1;
     317    bool chooseBest = false;
     318    bool chooseAll = false;
    252319
    253320    psString modelToChoose = psMetadataLookupStr(&mdok, recipe, "EXT_MODEL_TYPE_FOR_CFF");
    254     pmModelType selectedModelType = -1;
     321
    255322    if (mdok && modelToChoose != NULL) {
    256         if (strcmp(modelToChoose, "BEST")) {
     323        if (!strcmp(modelToChoose, "BEST")) {
     324            chooseBest = true;
     325        } else if (!strcmp(modelToChoose, "ALL")) {
     326            chooseAll = true;
     327        } else if (strcmp(modelToChoose, "PS_MODEL_SERSIC")) {
     328            // We have selected a model type other than Sersic.
     329            // Save it's type for use below.  Sersic is handled specially
    257330            selectedModelType = pmModelClassGetType(modelToChoose);
    258331        }
    259332    }
     333
     334    // minimum sersic index to force devModel
     335    psF32 sersicMinDev = psMetadataLookupF32(&mdok, recipe, "EXT_MODEL_FORCE_DEV_SERSIC_MIN");
     336    if (!mdok) {
     337        sersicMinDev = NAN;
     338    }
     339
     340    sources = psArraySort (sources, pmSourceSortBySeq);
    260341
    261342    for (int i = 0; i < sources->n; i++) {
    … …  
    263344        pmSource *source = thisSource->parent ? thisSource->parent : thisSource;
    264345
    265         psF32 xPos, yPos, flux, rMajor, rMinor, theta;
    266         psS32 modelType = 0;
     346        #define MAX_ROWS_PER_SRC 10
     347        psF32 xPos[MAX_ROWS_PER_SRC], yPos[MAX_ROWS_PER_SRC], flux[MAX_ROWS_PER_SRC];
     348        psF32 rMajor[MAX_ROWS_PER_SRC], rMinor[MAX_ROWS_PER_SRC], theta[MAX_ROWS_PER_SRC];
     349        psF32 chisq[MAX_ROWS_PER_SRC], nDOF[MAX_ROWS_PER_SRC];
     350        psS32 modelFlags[MAX_ROWS_PER_SRC];
     351        psS32 modelType[MAX_ROWS_PER_SRC];
     352        psF32 sersicIndex = NAN;
    267353        bool fitGalaxy = false;
    268354        bool psfStar = (source->mode & PM_SOURCE_MODE_PSFSTAR) ? true : false;
    269         psF32 sersicIndex = 0;
    270         // For now only perform galaxy fits on extended objects
    271         if (source->modelEXT == NULL) {
    272             pmModel *model = source->modelPSF;
    273             if (model == NULL) continue;
    274             psF32 *PAR = model->params->data.F32;
    275             if (!isfinite(PAR[PM_PAR_SXX]) || !isfinite(PAR[PM_PAR_SYY])  || !isfinite(PAR[PM_PAR_SXY]) ||
    276                 !isfinite(source->psfFlux)) {
    277                 continue;
    278             }
    279 
    280             xPos = model->params->data.F32[PM_PAR_XPOS];
    281             yPos = model->params->data.F32[PM_PAR_YPOS];
    282             flux = source->psfFlux;
    283             rMajor = 0;
    284             rMinor = 0;
    285             theta = 0;
    286         } else {
    287             //   Find the model with the selected type. If selected type is -1 choose the one selected ad
    288             //   modelEXT which was the best
    289             int iModel = -1;
    290             if (source->modelEXT) {
    291                 pmModelType ext_model_type =  selectedModelType != -1  ? selectedModelType : source->modelEXT->type;
     355        int n_rows = 0;
     356
     357        psF32 kronFlux = source->moments->KronFlux;
     358        psF32 SN = NAN;
     359        psF32 magDiff = NAN;
     360        if (isfinite(kronFlux) && isfinite(source->moments->KronFluxErr) && isfinite(source->psfMag)) {
     361            SN = kronFlux/source->moments->KronFluxErr;
     362            // kronMag - psfMag for use as star/glaxy separator
     363            magDiff = -2.5 * log10(kronFlux) - source->psfMag ;
     364        }
     365
     366        // start with psf model
     367        pmModel *model = source->modelPSF;
     368        if (model == NULL) continue;
     369        psF32 *PAR = model->params->data.F32;
     370        if (!isfinite(PAR[PM_PAR_SXX]) || !isfinite(PAR[PM_PAR_SYY])  || !isfinite(PAR[PM_PAR_SXY]) ||
     371            !isfinite(source->psfFlux)) {
     372            continue;
     373        }
     374
     375        // save the PSF model parameters for each object as the first entry
     376        xPos[0] = model->params->data.F32[PM_PAR_XPOS];
     377        yPos[0] = model->params->data.F32[PM_PAR_YPOS];
     378        flux[0] = source->psfFlux;
     379        rMajor[0] = 0;
     380        rMinor[0] = 0;
     381        theta[0] = 0;
     382        modelType[0] = -1;
     383        sersicIndex = NAN;
     384        chisq[0] = NAN;
     385        nDOF[0] = NAN;
     386        modelFlags[0] = 0;
     387        n_rows ++;
     388
     389        if (source->modelFits != NULL) {
     390            // figure out which models to use based on recipe paramters
     391            if (chooseAll) {
     392                // Save parameters for all valid extended models
     393
     394                // but make sure we aren't going to overflow our arrays
     395                assert (source->modelFits->n < MAX_ROWS_PER_SRC);
     396
    292397                for (int j=0; j<source->modelFits->n; j++) {
    293                     pmModel *aModel = source->modelFits->data[j];
    294                     if (aModel->type == ext_model_type) {
    295                         iModel = j;
    296                         break;
     398                    pmModel *model = source->modelFits->data[j];
     399                    psF32 *PAR = model->params->data.F32;
     400
     401                    if (isfinite(PAR[PM_PAR_SXX]) && isfinite(PAR[PM_PAR_SYY])  && isfinite(PAR[PM_PAR_SXY]) &&
     402                        isfinite(model->mag)) {
     403
     404                        xPos[n_rows] = PAR[PM_PAR_XPOS];
     405                        yPos[n_rows] = PAR[PM_PAR_YPOS];
     406
     407                        psEllipseAxes axes = pmPSF_ModelToAxes (PAR, model->class->useReff);
     408                        rMajor[n_rows] = axes.major;
     409                        rMinor[n_rows] = axes.minor;
     410                        theta[n_rows]  = axes.theta*PS_DEG_RAD;
     411                        flux[n_rows] = pow(10.0, -0.4*model->mag);
     412                        modelType[n_rows] = model->type;
     413                        chisq[n_rows] = model->chisq;
     414                        nDOF[n_rows] = model->nDOF;
     415                        modelFlags[n_rows] = model->flags;
     416                        fitGalaxy = true;
     417                        if (model->params->n == 8) {
     418                            // this will save the sersic index in all models but that might
     419                            // be useful
     420                            sersicIndex = 0.5 / PAR[PM_PAR_7];
     421                        } else {
     422                            sersicIndex = NAN;
     423                        }
     424
     425                        n_rows++;
     426                    }
     427                }
     428            } else {
     429                int jModelSersic = -1;
     430                int jModelDev = -1;
     431                int jModelSelected = -1;
     432                psF32 minChisq = NAN;
     433                for (int j=0; j<source->modelFits->n; j++) {
     434                    pmModel *model = source->modelFits->data[j];
     435                    if (chooseBest) {
     436                        // choose the model with lowest chisq
     437                        if (isfinite(model->chisq) && (!isfinite(minChisq) || model->chisq < minChisq)) {
     438                            jModelSelected = j;
     439                            minChisq = model->chisq;
     440                        }
     441                    } else {
     442                        // find the index of models of interest
     443                        if (model->type == selectedModelType) {
     444                            jModelSelected = j;
     445                        } else if (model->type == sersicModelType) {
     446                            jModelSersic = j;
     447                        } else if (model->type == devModelType) {
     448                            jModelDev = j;
     449                        }
     450                    }
     451                }
     452                if (jModelSelected >= 0 || jModelSersic >= 0) {
     453                    // If a specific non-sersic model we take paramers from that one.
     454                    // Otherwise we do the sersic model.
     455                    pmModel *model = jModelSelected >= 0 ? source->modelFits->data[jModelSelected] :
     456                                                           source->modelFits->data[jModelSersic];
     457                    psF32 *PAR = model->params->data.F32;
     458
     459                    if (isfinite(PAR[PM_PAR_SXX]) && isfinite(PAR[PM_PAR_SYY])  && isfinite(PAR[PM_PAR_SXY]) &&
     460                        isfinite(model->mag)) {
     461
     462                        xPos[0] = PAR[PM_PAR_XPOS];
     463                        yPos[0] = PAR[PM_PAR_YPOS];
     464
     465                        psEllipseAxes axes = pmPSF_ModelToAxes (PAR, model->class->useReff);
     466                        rMajor[0] = axes.major;
     467                        rMinor[0] = axes.minor;
     468                        theta[0]  = axes.theta*PS_DEG_RAD;
     469                        flux[0] = pow(10.0, -0.4*model->mag);
     470                        modelType[0] = model->type;
     471                        chisq[0] = model->chisq;
     472                        nDOF[0] = model->nDOF;
     473                        modelFlags[0] = model->flags;
     474                        fitGalaxy = true;
     475                        if (model->type == sersicModelType) {
     476                            PS_ASSERT_FLOAT_LARGER_THAN(PAR[PM_PAR_7], 0.0, false);
     477                            sersicIndex = 0.5 / PAR[PM_PAR_7];
     478                        }
     479
     480                        n_rows = 1;
     481
     482                        // Unless a specific non-sersic model type was selected do dev model for sources with
     483                        // sersic index above the recipe limit.
     484                        if (jModelSelected == -1 && jModelDev >= 0 && isfinite(sersicMinDev) &&
     485                            sersicIndex > sersicMinDev) {
     486
     487                            model = source->modelFits->data[jModelDev];
     488                            if (isfinite(PAR[PM_PAR_SXX]) && isfinite(PAR[PM_PAR_SYY])  && isfinite(PAR[PM_PAR_SXY]) &&
     489                                isfinite(model->mag)) {
     490
     491                                xPos[1] = PAR[PM_PAR_XPOS];
     492                                yPos[1] = PAR[PM_PAR_YPOS];
     493
     494                                psEllipseAxes axes = pmPSF_ModelToAxes (PAR, model->class->useReff);
     495                                rMajor[1] = axes.major;
     496                                rMinor[1] = axes.minor;
     497                                theta[1]  = axes.theta*PS_DEG_RAD;
     498                                flux[1] = pow(10.0, -0.4*model->mag);
     499                                modelType[1] = model->type;
     500                                sersicIndex = NAN;
     501                                chisq[1] = model->chisq;
     502                                nDOF[1] = model->nDOF;
     503                                modelFlags[1] = model->flags;
     504                                n_rows = 2;
     505                            }
     506                        }
    297507                    }
    298508                }
    299509            }
    300             if (iModel == -1) {
    301                 // Can this happen? perhaps if model type is qgauss (extended but below s/n for model fits?
    302                 // XXX: Should this be an assert?
    303                 continue;
    304             }
    305             pmModel *model = source->modelFits->data[iModel];
    306             psF32 *PAR = model->params->data.F32;
    307             xPos = PAR[PM_PAR_XPOS];
    308             yPos = PAR[PM_PAR_YPOS];
    309             if (model->type == pmModelClassGetType("PS_MODEL_TRAIL")) {
    310                 // XXX: do we need to handle this type
    311                 continue;
    312             } else {
    313                 if (!isfinite(PAR[PM_PAR_SXX]) || !isfinite(PAR[PM_PAR_SYY])  || !isfinite(PAR[PM_PAR_SXY]) ||
    314                     !isfinite(model->mag)) {
    315                     // bad model
    316                     continue;
    317                 }
    318                 psEllipseAxes axes = pmPSF_ModelToAxes (PAR, model->type);
    319                 rMajor = axes.major;
    320                 rMinor = axes.minor;
    321                 theta  = axes.theta*PS_DEG_RAD;
    322                 flux = pow(10.0, -0.4*model->mag);
    323                 fitGalaxy = true;
    324             }
    325             modelType = model->type;
    326             if (modelType == sersicModelType) {
    327                 PS_ASSERT_FLOAT_LARGER_THAN(PAR[PM_PAR_7], 0.0, false);
    328                 sersicIndex = 0.5 / PAR[PM_PAR_7];
    329             }
    330         }
    331         psMetadata *row = psMetadataAlloc();
    332         psMetadataAddU32 (row, PS_LIST_TAIL, "ID",         0,   "IPP detection identifier",  source->seq);
    333         psMetadataAddF32 (row, PS_LIST_TAIL, "X",                0, "x coordinate",          xPos);
    334         psMetadataAddF32 (row, PS_LIST_TAIL, "Y",                0, "y coordinate",          yPos);
    335         psMetadataAddF32 (row, PS_LIST_TAIL, "FLUX",             0, "flux per second",       flux/exptime);
    336         psMetadataAddF32 (row, PS_LIST_TAIL, "AP_RADIUS",        0, "aperture radius",       source->apRadius);
    337         psMetadataAddF32 (row, PS_LIST_TAIL, "KRON_RADIUS",      0, "Kron radius",           source->moments->Mrf * 2.5);
    338         psMetadataAddF32 (row, PS_LIST_TAIL, "PETRO_RADIUS",     0, "Petrosian Radius",      source->extpars ? source->extpars->petrosianRadius : NAN);
    339         psMetadataAddBool (row, PS_LIST_TAIL, "FIT_GALAXY",      0, "source has xfit",       fitGalaxy);
    340         psMetadataAddBool (row, PS_LIST_TAIL, "PSF_STAR",        0, "source was psf star",   psfStar);
    341         psMetadataAddF32 (row, PS_LIST_TAIL, "R_MAJOR",          0, "radius of major axis",  rMajor);
    342         psMetadataAddF32 (row, PS_LIST_TAIL, "R_MINOR",          0, "radius of minor axis",  rMinor);
    343         psMetadataAddF32 (row, PS_LIST_TAIL, "THETA",            0, "theta",                 theta);
    344         psMetadataAddS32 (row, PS_LIST_TAIL, "MODEL_TYPE",       0, "model type",            modelType);
    345         psMetadataAddF32 (row, PS_LIST_TAIL, "INDEX",            0, "sersic index",          sersicIndex);
    346 
    347         psArrayAdd(table, 100, row);
    348         psFree(row);
     510        }
     511
     512        for (int j = 0; j < n_rows; j++) {
     513            psMetadata *row = psMetadataAlloc();
     514            psMetadataAddU32 (row, PS_LIST_TAIL, "ID",         0,   "IPP detection identifier",  source->seq);
     515            psMetadataAddF32 (row, PS_LIST_TAIL, "X",                0, "x coordinate",          xPos[j]);
     516            psMetadataAddF32 (row, PS_LIST_TAIL, "Y",                0, "y coordinate",          yPos[j]);
     517            psMetadataAddF32 (row, PS_LIST_TAIL, "FLUX",             0, "flux per second",       flux[j]/exptime);
     518            psMetadataAddF32 (row, PS_LIST_TAIL, "SN",               0, "kron flux signal to noise", SN);
     519            psMetadataAddF32 (row, PS_LIST_TAIL, "MAG_DIFF",         0, "psf mag - kron mag",    magDiff);
     520            psMetadataAddF32 (row, PS_LIST_TAIL, "AP_RADIUS",        0, "aperture radius",       source->apRadius);
     521            psMetadataAddF32 (row, PS_LIST_TAIL, "KRON_RADIUS",      0, "Kron radius",           source->moments->Mrf * 2.5);
     522            psMetadataAddF32 (row, PS_LIST_TAIL, "PETRO_RADIUS",     0, "Petrosian Radius",      source->extpars ? source->extpars->petrosianRadius : NAN);
     523            psMetadataAddBool (row, PS_LIST_TAIL, "FIT_GALAXY",      0, "source has xfit",       fitGalaxy);
     524            psMetadataAddBool (row, PS_LIST_TAIL, "PSF_STAR",        0, "source was psf star",   psfStar);
     525            psMetadataAddF32 (row, PS_LIST_TAIL, "R_MAJOR",          0, "radius of major axis",  rMajor[j]);
     526            psMetadataAddF32 (row, PS_LIST_TAIL, "R_MINOR",          0, "radius of minor axis",  rMinor[j]);
     527            psMetadataAddF32 (row, PS_LIST_TAIL, "THETA",            0, "theta",                 theta[j]);
     528            psMetadataAddS32 (row, PS_LIST_TAIL, "MODEL_TYPE",       0, "model type",            modelType[j]);
     529            psMetadataAddF32 (row, PS_LIST_TAIL, "INDEX",            0, "sersic index",          sersicIndex);
     530            psMetadataAddF32 (row, PS_LIST_TAIL, "CHISQ",            0, "chisq",                 chisq[j]);
     531            psMetadataAddF32 (row, PS_LIST_TAIL, "NDOF",             0, "n degrees of freedom",  nDOF[j]);
     532            psMetadataAddS32 (row, PS_LIST_TAIL, "MODEL_FLAGS",      0, "model flags",           modelFlags[j]);
     533
     534            psArrayAdd(table, 100, row);
     535            psFree(row);
     536        }
    349537    }
    350538

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmSourceIO_CMF.c.in

    r36680 r37403  
    3737#include "pmMoments.h"
    3838#include "pmModelFuncs.h"
     39#include "pmModelClass.h"
    3940#include "pmModel.h"
    4041#include "pmModelUtils.h"
    41 #include "pmModelClass.h"
    4242#include "pmSourceMasks.h"
    4343#include "pmSourceExtendedPars.h"
    … …  
    142142        @ALL@                       psMetadataAdd (row, PS_LIST_TAIL, "AP_MAG",           PS_DATA_F32, "magnitude in standard aperture",             source->apMag);
    143143        @>PS1_V2,PS1_SV?,>PS1_DV1@  psMetadataAdd (row, PS_LIST_TAIL, "AP_MAG_RAW",       PS_DATA_F32, "magnitude in reported aperture",             source->apMagRaw);
    144         @ALL@                       psMetadataAdd (row, PS_LIST_TAIL, "AP_MAG_RADIUS",    PS_DATA_F32, "radius used for aperture mags",              outputs.apRadius);
     144        @ALL@                       psMetadataAdd (row, PS_LIST_TAIL, "AP_MAG_RADIUS",    PS_DATA_F32, "radius used for aperture mags",              source->apRadius);
    145145        @>PS1_DV1,>PS1_V3,>PS1_SV1@ psMetadataAdd (row, PS_LIST_TAIL, "AP_FLUX",          PS_DATA_F32, "instrumental flux in standard aperture",     source->apFlux);
    146146        @>PS1_DV1,>PS1_V3,>PS1_SV1@ psMetadataAdd (row, PS_LIST_TAIL, "AP_FLUX_SIG",      PS_DATA_F32, "aperture flux error",                        source->apFluxErr);
     147        @>PS1_V4,>PS1_SV2,>PS1_DV3@ psMetadataAdd (row, PS_LIST_TAIL, "AP_NPIX",          PS_DATA_S32, "aperture unmasked pixels",                   source->apNpixels);
    147148
    148149        @<PS1_V3,PS1_SV1,PS1_DV?@ psMetadataAdd (row, PS_LIST_TAIL, "PEAK_FLUX_AS_MAG", PS_DATA_F32, "Peak flux expressed as magnitude",           outputs.peakMag);
    … …  
    163164        @ALL@                     psMetadataAdd (row, PS_LIST_TAIL, "EXT_NSIGMA",       PS_DATA_F32, "Nsigma deviations from PSF to EXT",          source->extNsigma);
    164165
     166        // PSF shape parameters:
    165167        @ALL@                     psMetadataAdd (row, PS_LIST_TAIL, "PSF_MAJOR",        PS_DATA_F32, "PSF width (major axis)",                     outputs.psfMajor);
    166168        @ALL@                     psMetadataAdd (row, PS_LIST_TAIL, "PSF_MINOR",        PS_DATA_F32, "PSF width (minor axis)",                     outputs.psfMinor);
    167169        @ALL@                     psMetadataAdd (row, PS_LIST_TAIL, "PSF_THETA",        PS_DATA_F32, "PSF orientation angle",                      outputs.psfTheta);
     170        @>PS1_V4,>PS1_SV2,>PS1_DV3@ psMetadataAdd (row, PS_LIST_TAIL, "PSF_CORE",         PS_DATA_F32, "k term if defined",                          outputs.psfCore);
     171
     172        // I use a look-up table and linear interpolation to map PSF_MAJOR,PSF_MINOR + PSF_CORE to FWHM values
     173        @>PS1_V4,>PS1_SV2,>PS1_DV3@ psMetadataAdd (row, PS_LIST_TAIL, "PSF_FWHM_MAJ",        PS_DATA_F32, "PSF FWHM (major axis)",                   outputs.psfMajorFWHM);
     174        @>PS1_V4,>PS1_SV2,>PS1_DV3@ psMetadataAdd (row, PS_LIST_TAIL, "PSF_FWHM_MIN",        PS_DATA_F32, "PSF FWHM (minor axis)",                   outputs.psfMinorFWHM);
     175
     176        // psf data quality
    168177        @ALL@                     psMetadataAdd (row, PS_LIST_TAIL, "PSF_QF",           PS_DATA_F32, "PSF coverage/quality factor (bad)",          source->pixWeightNotBad);
    169178        @>PS1_V2,PS1_SV?,>PS1_DV1@ psMetadataAdd (row, PS_LIST_TAIL, "PSF_QF_PERFECT",   PS_DATA_F32, "PSF coverage/quality factor (poor)",         source->pixWeightNotPoor);
    … …  
    197206        }
    198207
    199         if (source->lensingOBJ && source->lensingPSF->smear) {
     208        if (source->lensingPSF && source->lensingPSF->smear) {
    200209          @>PS1_V4@               psMetadataAdd (row, PS_LIST_TAIL, "LENS_X11_SM_PSF",  PS_DATA_F32, "smear polarizability element (objects)",     source->lensingPSF->smear->X11);
    201210          @>PS1_V4@               psMetadataAdd (row, PS_LIST_TAIL, "LENS_X12_SM_PSF",  PS_DATA_F32, "smear polarizability element (objects)",     source->lensingPSF->smear->X12);
    … …  
    205214        }
    206215
    207         if (source->lensingOBJ && source->lensingPSF->shear) {
     216        if (source->lensingPSF && source->lensingPSF->shear) {
    208217          @>PS1_V4@               psMetadataAdd (row, PS_LIST_TAIL, "LENS_X11_SH_PSF",  PS_DATA_F32, "shear polarizability element (objects)",     source->lensingPSF->shear->X11);
    209218          @>PS1_V4@               psMetadataAdd (row, PS_LIST_TAIL, "LENS_X12_SH_PSF",  PS_DATA_F32, "shear polarizability element (objects)",     source->lensingPSF->shear->X12);
    … …  
    212221          @>PS1_V4@               psMetadataAdd (row, PS_LIST_TAIL, "LENS_E2_SH_PSF",   PS_DATA_F32, "shear polarizability element (objects)",     source->lensingPSF->shear->e2);
    213222        }
     223
     224        // if lensing params exist also include the backmapped chipID and chip coordinates
     225        if (source->lensingPSF && source->lensingPSF->shear) {
     226            @>PS1_V4@               psMetadataAdd (row, PS_LIST_TAIL, "SRC_CHIP_NUM",   PS_DATA_S16, "id of warp input chip",     source->chipNum);
     227            @>PS1_V4@               psMetadataAdd (row, PS_LIST_TAIL, "SRC_CHIP_X",    PS_DATA_S16, "x coord in warp input chip",     source->chipX);
     228            @>PS1_V4@               psMetadataAdd (row, PS_LIST_TAIL, "SRC_CHIP_Y",    PS_DATA_S16, "y coord in warp input chip",     source->chipY);
     229            @>PS1_V4@               psMetadataAdd (row, PS_LIST_TAIL, "PADDING3",      PS_DATA_S16, "more padding", 0);
     230        }
    214231
    215232        @>PS1_V2,PS1_SV?,>PS1_DV1@ psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_R1",       PS_DATA_F32, "first radial moment",                        moments.Mrf);
    … …  
    302319
    303320    // define PSF model type
    304     // XXX need to carry the extra model parameters
    305321    int modelType = pmModelClassGetType ("PS_MODEL_GAUSS");
    306322
    307     char *PSF_NAME = psMetadataLookupStr (&status, header, "PSF_NAME");
     323    // if header does not define the model, default to a gaussian
     324    char *PSF_NAME = psMetadataLookupStr (&status, header, "PSFMODEL");
    308325    if (PSF_NAME != NULL) {
    309326        modelType = pmModelClassGetType (PSF_NAME);
    310327    }
    311328    assert (modelType > -1);
     329
     330    // do we expect to find lensing parameters?
     331    bool haveLensOBJ = psMetadataLookupBool (&status, header, "LENS_OBJ");
     332    bool haveLensPSF = psMetadataLookupBool (&status, header, "LENS_PSF");
    312333
    313334    // We get the size of the table, and allocate the array of sources first because the table
    … …  
    344365        @ALL@     axes.theta        = psMetadataLookupF32 (&status, row, "PSF_THETA");
    345366        @ALL@     axes.theta        = axes.theta * PS_RAD_DEG;
     367       
     368        @>PS1_V4,>PS1_SV2,>PS1_DV3@ if (model->params->n > PM_PAR_7) {
     369        @>PS1_V4,>PS1_SV2,>PS1_DV3@     PAR[PM_PAR_7] = psMetadataLookupF32 (&status, row, "PSF_CORE");
     370        @>PS1_V4,>PS1_SV2,>PS1_DV3@ }
    346371
    347372        @ALL@     PAR[PM_PAR_SKY]   = psMetadataLookupF32 (&status, row, "SKY");
    … …  
    355380        @ALL@     source->apMag     = psMetadataLookupF32 (&status, row, "AP_MAG");
    356381        @>PS1_V2,PS1_SV?,>PS1_DV1@ source->apMagRaw  = psMetadataLookupF32 (&status, row, "AP_MAG_RAW");
     382        @>PS1_DV1,>PS1_V3,>PS1_SV1@ source->apFlux = psMetadataLookupF32 (&status, row, "AP_FLUX");
     383        @>PS1_DV1,>PS1_V3,>PS1_SV1@ source->apFluxErr = psMetadataLookupF32 (&status, row, "AP_FLUX_SIG");
    357384
    358385        // XXX use these to determine PAR[PM_PAR_I0] if they exist?
    … …  
    365392        @ALL@     dPAR[PM_PAR_I0]   = (isfinite(source->psfMag)) ? PAR[PM_PAR_I0] * source->psfMagErr : NAN;
    366393
    367         pmPSF_AxesToModel (PAR, axes, modelType);
     394        pmPSF_AxesToModel (PAR, axes, model->class->useReff);
    368395
    369396        @ALL@     float peakMag     = psMetadataLookupF32 (&status, row, "PEAK_FLUX_AS_MAG");
    … …  
    383410        @ALL@     source->crNsigma  = psMetadataLookupF32 (&status, row, "CR_NSIGMA");
    384411        @ALL@     source->extNsigma = psMetadataLookupF32 (&status, row, "EXT_NSIGMA");
    385         @ALL@     source->apRadius  = psMetadataLookupS32 (&status, row, "AP_MAG_RADIUS");
     412        @ALL@     source->apRadius  = psMetadataLookupF32 (&status, row, "AP_MAG_RADIUS");
     413        @>PS1_V4,>PS1_SV2,>PS1_DV3@ source->apNpixels = psMetadataLookupS32 (&status, row, "AP_NPIX");
    386414
    387415        // note that some older versions used PSF_PROBABILITY: this was not well defined.
    … …  
    410438        @>PS1_V2,PS1_SV?@ source->moments->Mxyyy = -0.25 * psMetadataLookupF32 (&status, row, "MOMENTS_M4S");
    411439        @>PS1_V2,PS1_SV?@ source->moments->Myyyy = 0.0;
     440
     441        // Lensing parameters (on read if PS1_V5+)
     442        if (haveLensOBJ) {
     443          source->lensingOBJ = pmSourceLensingAlloc ();
     444          source->lensingOBJ->smear = pmLensingParsAlloc();
     445          source->lensingOBJ->shear = pmLensingParsAlloc();
     446
     447          @>PS1_V4@ source->lensingOBJ->smear->X11 = psMetadataLookupF32 (&status, row, "LENS_X11_SM_OBJ");
     448          @>PS1_V4@ source->lensingOBJ->smear->X12 = psMetadataLookupF32 (&status, row, "LENS_X12_SM_OBJ");
     449          @>PS1_V4@ source->lensingOBJ->smear->X22 = psMetadataLookupF32 (&status, row, "LENS_X22_SM_OBJ");
     450          @>PS1_V4@ source->lensingOBJ->smear->e1  = psMetadataLookupF32 (&status, row, "LENS_E1_SM_OBJ");
     451          @>PS1_V4@ source->lensingOBJ->smear->e2  = psMetadataLookupF32 (&status, row, "LENS_E2_SM_OBJ");
     452          @>PS1_V4@ source->lensingOBJ->shear->X11 = psMetadataLookupF32 (&status, row, "LENS_X11_SH_OBJ");
     453          @>PS1_V4@ source->lensingOBJ->shear->X12 = psMetadataLookupF32 (&status, row, "LENS_X12_SH_OBJ");
     454          @>PS1_V4@ source->lensingOBJ->shear->X22 = psMetadataLookupF32 (&status, row, "LENS_X22_SH_OBJ");
     455          @>PS1_V4@ source->lensingOBJ->shear->e1  = psMetadataLookupF32 (&status, row, "LENS_E1_SH_OBJ");
     456          @>PS1_V4@ source->lensingOBJ->shear->e2  = psMetadataLookupF32 (&status, row, "LENS_E2_SH_OBJ");
     457        }
     458
     459        if (haveLensPSF) {
     460          source->lensingPSF = pmSourceLensingAlloc ();
     461          source->lensingPSF->smear = pmLensingParsAlloc();
     462          source->lensingPSF->shear = pmLensingParsAlloc();
     463
     464          @>PS1_V4@ source->lensingPSF->smear->X11 = psMetadataLookupF32 (&status, row, "LENS_X11_SM_PSF");
     465          @>PS1_V4@ source->lensingPSF->smear->X12 = psMetadataLookupF32 (&status, row, "LENS_X12_SM_PSF");
     466          @>PS1_V4@ source->lensingPSF->smear->X22 = psMetadataLookupF32 (&status, row, "LENS_X22_SM_PSF");
     467          @>PS1_V4@ source->lensingPSF->smear->e1  = psMetadataLookupF32 (&status, row, "LENS_E1_SM_PSF");
     468          @>PS1_V4@ source->lensingPSF->smear->e2  = psMetadataLookupF32 (&status, row, "LENS_E2_SM_PSF");
     469          @>PS1_V4@ source->lensingPSF->shear->X11 = psMetadataLookupF32 (&status, row, "LENS_X11_SH_PSF");
     470          @>PS1_V4@ source->lensingPSF->shear->X12 = psMetadataLookupF32 (&status, row, "LENS_X12_SH_PSF");
     471          @>PS1_V4@ source->lensingPSF->shear->X22 = psMetadataLookupF32 (&status, row, "LENS_X22_SH_PSF");
     472          @>PS1_V4@ source->lensingPSF->shear->e1  = psMetadataLookupF32 (&status, row, "LENS_E1_SH_PSF");
     473          @>PS1_V4@ source->lensingPSF->shear->e2  = psMetadataLookupF32 (&status, row, "LENS_E2_SH_PSF");
     474        }
    412475
    413476        @>PS1_V2,PS1_SV?,>PS1_DV1@ source->moments->Mrf         = psMetadataLookupF32 (&status, row, "MOMENTS_R1");
    … …  
    482545    }
    483546
     547#ifdef SORT_EXTENSIONS_BY_FLUX
    484548    // let's write these out in S/N order
    485549    sources = psArraySort (sources, pmSourceSortByFlux);
     550#endif
    486551
    487552    table = psArrayAllocEmpty (sources->n);
    … …  
    563628                // XXX note that this mag is either calibrated or instrumental depending on existence of zero point
    564629                float mag = (extpars->petrosianFlux > 0.0) ? -2.5*log10(extpars->petrosianFlux) + magOffset : NAN; // XXX zero point
     630                // XXX NOTE EAM 20140806 : PETRO_MAG_ERR is inverted!! oops!!
    565631                float magErr = (extpars->petrosianFlux > 0.0) ? extpars->petrosianFlux / extpars->petrosianFluxErr : NAN; // XXX zero point
    566632                psMetadataAdd (row, PS_LIST_TAIL, "PETRO_MAG",        PS_DATA_F32, "Petrosian Magnitude", mag);
    … …  
    821887    psMetadataAddStr (outhead, PS_LIST_TAIL, "EXTNAME", PS_META_REPLACE, "xsrc table extension", extname);
    822888
     889#ifdef SORT_EXTENSIONS_BY_FLUX
    823890    // let's write these out in S/N order
    824891    sources = psArraySort (sources, pmSourceSortByFlux);
     892#endif
    825893
    826894    float magOffset;
    … …  
    847915    }
    848916
    849     @>PS1_DV2@ pmChip *chip = readout->parent->parent;
     917    @>PS1_DV2,>PS1_SV3@ pmChip *chip = readout->parent->parent;
    850918
    851919    pmModelStatus badModel = PM_MODEL_STATUS_NONE;
    … …  
    906974            }
    907975
    908             @>PS1_DV2@ psSphere ptSky = {0.0, 0.0, 0.0, 0.0};
    909             @>PS1_DV2@ float posAngle = 0.0;
    910             @>PS1_DV2@ float pltScale = 0.0;
    911             @>PS1_DV2@ pmSourceLocalAstrometry (&ptSky, &posAngle, &pltScale, chip, xPos, yPos);
    912             @>PS1_DV2@ double raPos = ptSky.r*PS_DEG_RAD;
    913             @>PS1_DV2@ double decPos = ptSky.d*PS_DEG_RAD;
    914             @>PS1_DV2@ posAngle *= PS_DEG_RAD;
    915             @>PS1_DV2@ pltScale *= PS_DEG_RAD*3600.0;
     976            @>PS1_DV2,>PS1_SV3@ psSphere ptSky = {0.0, 0.0, 0.0, 0.0};
     977            @>PS1_DV2,>PS1_SV3@ float posAngle = 0.0;
     978            @>PS1_DV2,>PS1_SV3@ float pltScale = 0.0;
     979            @>PS1_DV2,>PS1_SV3@ pmSourceLocalAstrometry (&ptSky, &posAngle, &pltScale, chip, xPos, yPos);
     980            @>PS1_DV2,>PS1_SV3@ double raPos = ptSky.r*PS_DEG_RAD;
     981            @>PS1_DV2,>PS1_SV3@ double decPos = ptSky.d*PS_DEG_RAD;
     982            @>PS1_DV2,>PS1_SV3@ posAngle *= PS_DEG_RAD;
     983            @>PS1_DV2,>PS1_SV3@ pltScale *= PS_DEG_RAD*3600.0;
    916984
    917985            float kronFlux = source->moments ? source->moments->KronFlux : NAN;
    … …  
    927995            psMetadataAddF32 (row, PS_LIST_TAIL, "X_EXT_SIG",        0, "Sigma in EXT x coordinate",                  xErr);
    928996            psMetadataAddF32 (row, PS_LIST_TAIL, "Y_EXT_SIG",        0, "Sigma in EXT y coordinate",                  yErr);
    929             @>PS1_DV2@ psMetadataAddF32 (row, PS_LIST_TAIL, "RA_EXT",           0, "EXT model ra coordinate",                    raPos);
    930             @>PS1_DV2@ psMetadataAddF32 (row, PS_LIST_TAIL, "DEC_EXT",          0, "EXT model dec coordinate",                   decPos);
     997            @>PS1_DV2,>PS1_SV3@ psMetadataAddF32 (row, PS_LIST_TAIL, "RA_EXT",           0, "EXT model ra coordinate",                    raPos);
     998            @>PS1_DV2,>PS1_SV3@ psMetadataAddF32 (row, PS_LIST_TAIL, "DEC_EXT",          0, "EXT model dec coordinate",                   decPos);
    931999            @>PS1_DV2@ float instFlux = isfinite(model->mag) ? pow(10.0, -0.4*model->mag) : NAN;
    9321000            @>PS1_DV2@ psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_INST_FLUX",    0, "EXT fit instrumental counts",                instFlux);
    … …  
    9421010
    9431011            // EAM : adding for PV2 outputs:
    944             @>PS1_SV1@ psMetadataAdd (row, PS_LIST_TAIL, "EXT_FLAGS", PS_DATA_S16, "model fit flags (pmModelStatus)", source->modelEXT ? source->modelEXT->flags : 0);
     1012            @>PS1_SV1@ psMetadataAdd (row, PS_LIST_TAIL, "EXT_FLAGS", PS_DATA_S16, "model fit flags (pmModelStatus)", model->flags);
    9451013
    9461014            @>PS1_DV2@ psMetadataAddF32 (row, PS_LIST_TAIL, "POSANGLE",   0, "position angle at source (degrees)",         posAngle);
    … …  
    9781046                    psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_THETA_ERR",     0, "EXT angle err (SXY, isnan)", dPAR[PM_PAR_SXY]);
    9791047                } else {
    980                     psEllipseAxes axes = pmPSF_ModelToAxes (PAR, model->type);
     1048                    psEllipseAxes axes = pmPSF_ModelToAxes (PAR, model->class->useReff);
    9811049                    psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_WIDTH_MAJ",    0, "EXT width (major axis), length for trail", axes.major);
    9821050                    psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_WIDTH_MIN",    0, "EXT width (minor axis), sigma for trail",  axes.minor);
    … …  
    11091177        model->chisq = psMetadataLookupF32(&status, row, "EXT_CHISQ");
    11101178        model->nDOF = psMetadataLookupF32(&status, row, "EXT_NDOF");
     1179        model->flags = psMetadataLookupS16(&status, row, "EXT_FLAGS");
    11111180
    11121181        // EXT_MODEL_TYPE gives the model chosen by psphot as the best.
    … …  
    11271196        axes.minor = psMetadataLookupF32(&status, row, "EXT_WIDTH_MIN");
    11281197        axes.theta = psMetadataLookupF32(&status, row, "EXT_THETA");
    1129         if (!pmPSF_AxesToModel(PAR, axes, modelType)) {
     1198        if (!pmPSF_AxesToModel(PAR, axes, model->class->useReff)) {
    11301199            // Do we need to fail here or can this happen?
    11311200            psError(PS_ERR_UNKNOWN, false, "Failed to convert psf axes to model");
    … …  
    12251294    psVector *fwhmValues = psMetadataLookupVector(&status, readout->analysis, "STACK.PSF.FWHM.VALUES");
    12261295
     1296#ifdef SORT_EXTENSIONS_BY_FLUX
    12271297    // let's write these out in S/N order
    12281298    sources = psArraySort (sources, pmSourceSortByFlux);
     1299#endif
    12291300
    12301301    table = psArrayAllocEmpty (sources->n);
    … …  
    14391510    psMetadataAddStr (outhead, PS_LIST_TAIL, "EXTNAME", PS_META_REPLACE, "galaxy table extension", extname);
    14401511
    1441     psMetadataAddStr (outhead, PS_LIST_TAIL, "HI", PS_META_REPLACE, "does this get through?", "THERE");
    1442 
    1443     // let's write these out in S/N order
    1444     sources = psArraySort (sources, pmSourceSortByFlux);
     1512    psF32 Q = psMetadataLookupF32(&status, recipe, "GALAXY_SHAPES_Q");
     1513    psMetadataAddF32 (outhead, PS_LIST_TAIL, "GALAXY_SHAPES_Q", PS_META_REPLACE, "", Q);
     1514
     1515    psF32 NSigma = psMetadataLookupF32(&status, recipe, "GALAXY_SHAPES_NSIGMA");
     1516    psMetadataAddF32 (outhead, PS_LIST_TAIL, "GALAXY_SHAPES_NSIGMA", PS_META_REPLACE, "", NSigma);
     1517
     1518    psF32 clampSN = psMetadataLookupF32(&status, recipe, "GALAXY_SHAPES_CLAMP_SN");
     1519    psMetadataAddF32 (outhead, PS_LIST_TAIL, "GALAXY_SHAPES_CLAMP_SN", PS_META_REPLACE, "", clampSN);
     1520
     1521    // They are probably already in this order but ...
     1522    sources = psArraySort (sources, pmSourceSortBySeq);
    14451523
    14461524    psArray *table = psArrayAllocEmpty (sources->n);
    … …  
    14591537        if (source->galaxyFits == NULL) continue;
    14601538
    1461         pmModel *model = source->modelFits->data[0];
    1462         if (!model) return false;
    1463 
    1464         // X,Y coordinates are stored with the model parameters
    1465         psF32 *PAR = model->params->data.F32;
    1466 
    1467         psMetadata *row = psMetadataAlloc ();
    1468 
    1469         // we write out the x,y positions so people can link to the psf either way (position or ID)
    1470         psMetadataAddU32 (row, PS_LIST_TAIL, "IPP_IDET",         0, "IPP detection identifier index", source->seq);
    1471         psMetadataAddF32 (row, PS_LIST_TAIL, "X_FIT",            0, "model x coordinate",             PAR[PM_PAR_XPOS]);
    1472         psMetadataAddF32 (row, PS_LIST_TAIL, "Y_FIT",            0, "model y coordinate",             PAR[PM_PAR_YPOS]);
    1473         psMetadataAddF32 (row, PS_LIST_TAIL, "NPIX",             0, "number of pixels for fits",      source->galaxyFits->nPix);
    1474 
    1475         psVector *Flux = source->galaxyFits->Flux;
    1476         psVector *dFlux = source->galaxyFits->dFlux;
    1477         psVector *chisq = source->galaxyFits->chisq;
    1478 
    1479         psMetadataAddVector (row, PS_LIST_TAIL, "GAL_FLUX",     PS_META_REPLACE, "normalization for galaxy flux", Flux);
    1480         psMetadataAddVector (row, PS_LIST_TAIL, "GAL_FLUX_ERR", PS_META_REPLACE, "error on normalization", dFlux);
    1481         psMetadataAddVector (row, PS_LIST_TAIL, "GAL_CHISQ",    PS_META_REPLACE, "galaxy fit chisq", chisq);
    1482 
    1483         psArrayAdd (table, 100, row);
    1484         psFree (row);
     1539        for (int iModel = 0; iModel < source->modelFits->n; iModel++) {
     1540            pmModel *model = source->modelFits->data[iModel];
     1541            if (!model) continue;
     1542
     1543            pmSourceGalaxyFits *galaxyFits = NULL;
     1544            for (int iFit = 0; iFit < source->galaxyFits->n; iFit++) {
     1545                galaxyFits = source->galaxyFits->data[iFit];
     1546                if (model->type == galaxyFits->modelType) break;
     1547                galaxyFits = NULL;
     1548            }
     1549
     1550            if (!galaxyFits) continue;
     1551
     1552            // X,Y coordinates are stored with the model parameters
     1553            psF32 *PAR = model->params->data.F32;
     1554
     1555            psMetadata *row = psMetadataAlloc ();
     1556
     1557            // we write out the x,y positions so people can link to the psf either way (position or ID)
     1558            psMetadataAddU32 (row, PS_LIST_TAIL, "IPP_IDET",         0, "IPP detection identifier index", source->seq);
     1559            psMetadataAddS32 (row, PS_LIST_TAIL, "MODEL_TYPE",       0, "model type",                     galaxyFits->modelType);
     1560            psMetadataAddF32 (row, PS_LIST_TAIL, "X_FIT",            0, "model x coordinate",             PAR[PM_PAR_XPOS]);
     1561            psMetadataAddF32 (row, PS_LIST_TAIL, "Y_FIT",            0, "model y coordinate",             PAR[PM_PAR_YPOS]);
     1562            psMetadataAddF32 (row, PS_LIST_TAIL, "NPIX",             0, "number of pixels for fits",      galaxyFits->nPix);
     1563            // psMetadataAddS32 (row, PS_LIST_TAIL, "REDUCED_TRIALS",   0, "source has reduced number of trials",      galaxyFits->reducedTrials);
     1564
     1565            psVector *Flux = galaxyFits->Flux;
     1566            psVector *dFlux = galaxyFits->dFlux;
     1567            psVector *chisq = galaxyFits->chisq;
     1568
     1569            psMetadataAddVector (row, PS_LIST_TAIL, "GAL_FLUX",     PS_META_REPLACE, "normalization for galaxy flux", Flux);
     1570            psMetadataAddVector (row, PS_LIST_TAIL, "GAL_FLUX_ERR", PS_META_REPLACE, "error on normalization", dFlux);
     1571            psMetadataAddVector (row, PS_LIST_TAIL, "GAL_CHISQ",    PS_META_REPLACE, "galaxy fit chisq", chisq);
     1572
     1573            psMetadataAddF32 (row, PS_LIST_TAIL, "FR_MAJOR_MIN",    0, "fractional major axis min",      galaxyFits->fRmajorMin);
     1574            psMetadataAddF32 (row, PS_LIST_TAIL, "FR_MAJOR_MAX",    0, "fractional major axis max",      galaxyFits->fRmajorMax);
     1575            psMetadataAddF32 (row, PS_LIST_TAIL, "FR_MAJOR_DEL",    0, "fractional major axis max",      galaxyFits->fRmajorDel);
     1576            psMetadataAddF32 (row, PS_LIST_TAIL, "FR_MINOR_MIN",    0, "fractional minor axis min",      galaxyFits->fRminorMin);
     1577            psMetadataAddF32 (row, PS_LIST_TAIL, "FR_MINOR_MAX",    0, "fractional minor axis max",      galaxyFits->fRminorMax);
     1578            psMetadataAddF32 (row, PS_LIST_TAIL, "FR_MINOR_DEL",    0, "fractional minor axis max",      galaxyFits->fRminorDel);
     1579
     1580            psArrayAdd (table, 100, row);
     1581            psFree (row);
     1582        }
    14851583    }
    14861584
    … …  
    15201618        return false;
    15211619    }
     1620    if (!readout->analysis) {
     1621        readout->analysis = psMetadataAlloc();
     1622    }
     1623    psF32 Q = psMetadataLookupF32(&status, tableHeader, "GALAXY_SHAPES_Q");
     1624    // XXX: turn this into an assert once we're done
     1625    if (status) {
     1626        psMetadataAddF32 (readout->analysis, PS_LIST_TAIL, "GALAXY_SHAPES_Q", PS_META_REPLACE, "", Q);
     1627
     1628        psF32 NSigma = psMetadataLookupF32(&status, tableHeader, "GALAXY_SHAPES_NSIGMA");
     1629        psAssert(status, "missing GALAXY_SHAPES_NSIGMA");
     1630        psMetadataAddF32 (readout->analysis, PS_LIST_TAIL, "GALAXY_SHAPES_NSIGMA", PS_META_REPLACE, "", NSigma);
     1631
     1632        psF32 clampSN = psMetadataLookupF32(&status, tableHeader, "GALAXY_SHAPES_CLAMP_SN");
     1633        psAssert(status, "missing GALAXY_SHAPES_CLAMP_SN");
     1634        psMetadataAddF32 (readout->analysis, PS_LIST_TAIL, "GALAXY_SHAPES_CLAMP_SN", PS_META_REPLACE, "", clampSN);
     1635    }
    15221636
    15231637    for (long i = 0; i < numSources; i++) {
    … …  
    15411655        }
    15421656
     1657        int modelType = psMetadataLookupS32 (&status,    row, "MODEL_TYPE");
    15431658        psVector *Flux  = psMetadataLookupVector(&status, row, "GAL_FLUX");
    15441659        psVector *dFlux = psMetadataLookupVector(&status, row, "GAL_FLUX_ERR");
    … …  
    15461661
    15471662        if (Flux && Flux->n > 0) {
    1548             psFree(source->galaxyFits);
    1549             source->galaxyFits = pmSourceGalaxyFitsAlloc();
    1550             source->galaxyFits->nPix = psMetadataLookupF32(&status, row, "NPIX");
    1551 
    1552             psFree(source->galaxyFits->Flux);
    1553             source->galaxyFits->Flux  = psMemIncrRefCounter(Flux);
    1554             psFree(source->galaxyFits->dFlux);
    1555             source->galaxyFits->dFlux = psMemIncrRefCounter(dFlux);
    1556             psFree(source->galaxyFits->chisq);
    1557             source->galaxyFits->chisq = psMemIncrRefCounter(chisq);
     1663            if (!source->galaxyFits) {
     1664                source->galaxyFits = psArrayAllocEmpty(1);
     1665            }
     1666
     1667            pmSourceGalaxyFits *galaxyFits = pmSourceGalaxyFitsAlloc();
     1668
     1669            psArrayAdd(source->galaxyFits, 1, galaxyFits);
     1670
     1671            psFree(galaxyFits);
     1672            galaxyFits->modelType = modelType;
     1673            galaxyFits->nPix = psMetadataLookupF32(&status, row, "NPIX");
     1674
     1675            galaxyFits->fRmajorMin = psMetadataLookupF32(&status, row, "FR_MAJOR_MIN");
     1676            galaxyFits->fRmajorMax = psMetadataLookupF32(&status, row, "FR_MAJOR_MAX");
     1677            galaxyFits->fRmajorDel = psMetadataLookupF32(&status, row, "FR_MAJOR_DEL");
     1678            galaxyFits->fRminorMin = psMetadataLookupF32(&status, row, "FR_MINOR_MIN");
     1679            galaxyFits->fRminorMax = psMetadataLookupF32(&status, row, "FR_MINOR_MAX");
     1680            galaxyFits->fRminorDel = psMetadataLookupF32(&status, row, "FR_MINOR_DEL");
     1681
     1682            psFree(galaxyFits->Flux);
     1683            galaxyFits->Flux  = psMemIncrRefCounter(Flux);
     1684            psFree(galaxyFits->dFlux);
     1685            galaxyFits->dFlux = psMemIncrRefCounter(dFlux);
     1686            psFree(galaxyFits->chisq);
     1687            galaxyFits->chisq = psMemIncrRefCounter(chisq);
    15581688        }
    15591689

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmSourceIO_CMP.c

    r36680 r37403  
    3737#include "pmMoments.h"
    3838#include "pmModelFuncs.h"
     39#include "pmModelClass.h"
    3940#include "pmModel.h"
    4041#include "pmModelUtils.h"
    41 #include "pmModelClass.h"
    4242#include "pmSourceMasks.h"
    4343#include "pmSourceExtendedPars.h"
    … …  
    136136        lsky = (source->sky < 1.0) ? 0.0 : log10(source->sky);
    137137
    138         axes = pmPSF_ModelToAxes (PAR, model->type);
     138        axes = pmPSF_ModelToAxes (PAR, model->class->useReff);
    139139
    140140        float psfMagErr = isfinite(source->psfMagErr) ? source->psfMagErr : 999;
    … …  
    293293                goto skip_source;
    294294
    295             pmPSF_AxesToModel (PAR, axes, modelType);
     295            pmPSF_AxesToModel (PAR, axes, source->modelPSF->class->useReff);
    296296
    297297            psArrayAdd (sources, 100, source);

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmSourceIO_MatchedRefs.c

    r36680 r37403  
    3737#include "pmMoments.h"
    3838#include "pmModelFuncs.h"
     39#include "pmModelClass.h"
    3940#include "pmModel.h"
    4041#include "pmModelUtils.h"
    41 #include "pmModelClass.h"
    4242#include "pmSourceMasks.h"
    4343#include "pmSourceExtendedPars.h"
    … …  
    9999
    100100                    // select the raw objects for this readout
    101                     psArray *rawstars = psMetadataLookupPtr (NULL, readout->analysis, "PSASTRO.RAWSTARS");
     101                    psArray *rawstars = psMetadataLookupPtr (NULL, readout->analysis, "PSASTRO.RAWSTARS.SUBSET");
    102102                    if (rawstars == NULL) continue;
    103103
    104104                    // select the raw objects for this readout
    105                     psArray *refstars = psMetadataLookupPtr (NULL, readout->analysis, "PSASTRO.REFSTARS");
     105                    psArray *refstars = psMetadataLookupPtr (NULL, readout->analysis, "PSASTRO.REFSTARS.SUBSET");
    106106                    if (refstars == NULL) continue;
    107107                    psTrace ("psastro", 4, "Trying %ld refstars\n", refstars->n);
    108 
    109 # if (0)
    110                     // XXX test
    111                     FILE *outfile = fopen ("refstars.dat", "w");
    112                     assert (outfile);
    113                     for (int nn = 0; nn < refstars->n; nn++) {
    114                         pmAstromObj *ref = refstars->data[nn];
    115                         fprintf (outfile, "%lf %lf\n", ref->sky->r*PS_DEG_RAD, ref->sky->d*PS_DEG_RAD);
    116                     }
    117                     fclose (outfile);
    118 # endif
    119108
    120109                    psArray *matches = psMetadataLookupPtr (NULL, readout->analysis, "PSASTRO.MATCH");
    … …  
    128117
    129118                        psMetadata *row = psMetadataAlloc ();
    130                         psMetadataAdd (row, PS_LIST_TAIL, "RA",       PS_DATA_F64, "right ascension (deg, J2000)", PM_DEG_RAD*ref->sky->r);
    131                         psMetadataAdd (row, PS_LIST_TAIL, "DEC",      PS_DATA_F64, "declination (deg, J2000)",     PM_DEG_RAD*ref->sky->d);
    132                         psMetadataAdd (row, PS_LIST_TAIL, "X_CHIP",   PS_DATA_F32, "x coord on chip",              raw->chip->x);
    133                         psMetadataAdd (row, PS_LIST_TAIL, "Y_CHIP",   PS_DATA_F32, "y coord on chip",              raw->chip->y);
    134                         psMetadataAdd (row, PS_LIST_TAIL, "X_CHIP_FIT",PS_DATA_F32, "x fitted coord on chip",      ref->chip->x);
    135                         psMetadataAdd (row, PS_LIST_TAIL, "Y_CHIP_FIT",PS_DATA_F32, "y fitted coord on chip",      ref->chip->y);
    136                         psMetadataAdd (row, PS_LIST_TAIL, "X_FPA",    PS_DATA_F32, "x coord on focal plane",       raw->FP->x);
    137                         psMetadataAdd (row, PS_LIST_TAIL, "Y_FPA",    PS_DATA_F32, "y coord on focal plane",       raw->FP->y);
    138                         psMetadataAdd (row, PS_LIST_TAIL, "MAG_INST", PS_DATA_F32, "instrumental magnitude",       raw->Mag);
    139                         psMetadataAdd (row, PS_LIST_TAIL, "MAG_REF",  PS_DATA_F32, "reference star magnitude",     ref->Mag);
    140                         psMetadataAdd (row, PS_LIST_TAIL, "COLOR_REF",PS_DATA_F32, "reference star color",         ref->Color);
    141                         psMetadataAdd (row, PS_LIST_TAIL, "CHIP_ID",  PS_DATA_STRING, "chip identifier",           chipName);
     119                        psMetadataAdd (row, PS_LIST_TAIL, "RA_REF",     PS_DATA_F64, "right ascension (deg, J2000)", PM_DEG_RAD*ref->sky->r);
     120                        psMetadataAdd (row, PS_LIST_TAIL, "DEC_REF",    PS_DATA_F64, "declination (deg, J2000)",     PM_DEG_RAD*ref->sky->d);
     121                        psMetadataAdd (row, PS_LIST_TAIL, "X_CHIP_REF", PS_DATA_F32, "x fitted coord on chip",       ref->chip->x);
     122                        psMetadataAdd (row, PS_LIST_TAIL, "Y_CHIP_REF", PS_DATA_F32, "y fitted coord on chip",       ref->chip->y);
     123                        psMetadataAdd (row, PS_LIST_TAIL, "X_CHIP_RAW", PS_DATA_F32, "x coord on chip",              raw->chip->x);
     124                        psMetadataAdd (row, PS_LIST_TAIL, "Y_CHIP_RAW", PS_DATA_F32, "y coord on chip",              raw->chip->y);
     125                        psMetadataAdd (row, PS_LIST_TAIL, "X_FPA_RAW",  PS_DATA_F32, "x coord on focal plane",       raw->FP->x);
     126                        psMetadataAdd (row, PS_LIST_TAIL, "Y_FPA_RAW",  PS_DATA_F32, "y coord on focal plane",       raw->FP->y);
     127                        psMetadataAdd (row, PS_LIST_TAIL, "X_TPA_RAW",  PS_DATA_F32, "x coord on focal plane",       raw->TP->x);
     128                        psMetadataAdd (row, PS_LIST_TAIL, "Y_TPA_RAW",  PS_DATA_F32, "y coord on focal plane",       raw->TP->y);
     129                        psMetadataAdd (row, PS_LIST_TAIL, "MAG_INST",   PS_DATA_F32, "instrumental magnitude",       raw->Mag);
     130                        psMetadataAdd (row, PS_LIST_TAIL, "MAG_REF",    PS_DATA_F32, "reference star magnitude",     ref->Mag);
     131                        psMetadataAdd (row, PS_LIST_TAIL, "COLOR_REF",  PS_DATA_F32, "reference star color",         ref->Color);
     132                        psMetadataAdd (row, PS_LIST_TAIL, "CHIP_ID",    PS_DATA_STRING, "chip identifier",           chipName);
    142133                        // XXX need to add the reference color, but this needs getstar / dvo.photcodes for the reference to be refined.
    143134

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmSourceIO_OBJ.c

    r36680 r37403  
    3737#include "pmMoments.h"
    3838#include "pmModelFuncs.h"
     39#include "pmModelClass.h"
    3940#include "pmModel.h"
    4041#include "pmModelUtils.h"
    41 #include "pmModelClass.h"
    4242#include "pmSourceMasks.h"
    4343#include "pmSourceExtendedPars.h"
    … …  
    9393        }
    9494
    95         axes = pmPSF_ModelToAxes (PAR, model->type);
     95        axes = pmPSF_ModelToAxes (PAR, model->class->useReff);
    9696
    9797        psLineInit (line);

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmSourceIO_PS1_CAL_0.c

    r36680 r37403  
    3737#include "pmMoments.h"
    3838#include "pmModelFuncs.h"
     39#include "pmModelClass.h"
    3940#include "pmModel.h"
    4041#include "pmModelUtils.h"
    41 #include "pmModelClass.h"
    4242#include "pmSourceMasks.h"
    4343#include "pmSourceExtendedPars.h"
    … …  
    115115            yErr = dPAR[PM_PAR_YPOS];
    116116            if (isfinite(PAR[PM_PAR_SXX]) && isfinite(PAR[PM_PAR_SXX]) && isfinite(PAR[PM_PAR_SXX])) {
    117                 axes = pmPSF_ModelToAxes (PAR, model->type);
     117                axes = pmPSF_ModelToAxes (PAR, model->class->useReff);
    118118            } else {
    119119                axes.major = NAN;
    … …  
    290290        dPAR[PM_PAR_I0]   = (isfinite(source->psfMag)) ? PAR[PM_PAR_I0] * source->psfMagErr : NAN;
    291291
    292         pmPSF_AxesToModel (PAR, axes, modelType);
     292        pmPSF_AxesToModel (PAR, axes, model->class->useReff);
    293293
    294294        float peakMag     = psMetadataLookupF32 (&status, row, "PEAK_FLUX_AS_MAG");
    … …  
    624624            yErr = dPAR[PM_PAR_YPOS];
    625625
    626             axes = pmPSF_ModelToAxes (PAR, model->type);
     626            axes = pmPSF_ModelToAxes (PAR, model->class->useReff);
    627627
    628628            // generate RA,DEC

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmSourceIO_PS1_DEV_0.c

    r36680 r37403  
    3737#include "pmMoments.h"
    3838#include "pmModelFuncs.h"
     39#include "pmModelClass.h"
    3940#include "pmModel.h"
    4041#include "pmModelUtils.h"
    41 #include "pmModelClass.h"
    4242#include "pmSourceMasks.h"
    4343#include "pmSourceExtendedPars.h"
    … …  
    9191            yErr = dPAR[PM_PAR_YPOS];
    9292
    93             axes = pmPSF_ModelToAxes (PAR, model->type);
     93            axes = pmPSF_ModelToAxes (PAR, model->class->useReff);
    9494        } else {
    9595            // XXX: This code seg faults if source->peak is NULL.
    … …  
    216216        source->psfMagErr    = psMetadataLookupF32 (&status, row, "PSF_INST_MAG_SIG");
    217217
    218         pmPSF_AxesToModel (PAR, axes, modelType);
     218        pmPSF_AxesToModel (PAR, axes, model->class->useReff);
    219219
    220220        float peakMag = psMetadataLookupF32 (&status, row, "PEAK_FLUX_AS_MAG");

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmSourceIO_PS1_DEV_1.c

    r36680 r37403  
    3737#include "pmMoments.h"
    3838#include "pmModelFuncs.h"
     39#include "pmModelClass.h"
    3940#include "pmModel.h"
    4041#include "pmModelUtils.h"
    41 #include "pmModelClass.h"
    4242#include "pmSourceMasks.h"
    4343#include "pmSourceExtendedPars.h"
    … …  
    9797            yErr = dPAR[PM_PAR_YPOS];
    9898            if (isfinite(PAR[PM_PAR_SXX]) && isfinite(PAR[PM_PAR_SXX]) && isfinite(PAR[PM_PAR_SXX])) {
    99                 axes = pmPSF_ModelToAxes (PAR, model->type);
     99                axes = pmPSF_ModelToAxes (PAR, model->class->useReff);
    100100            } else {
    101101                axes.major = NAN;
    … …  
    259259        dPAR[PM_PAR_I0]   = (isfinite(source->psfMag)) ? PAR[PM_PAR_I0] * source->psfMagErr : NAN;
    260260
    261         pmPSF_AxesToModel (PAR, axes, modelType);
     261        pmPSF_AxesToModel (PAR, axes, model->class->useReff);
    262262
    263263        float peakMag     = psMetadataLookupF32 (&status, row, "PEAK_FLUX_AS_MAG");
    … …  
    524524            yErr = dPAR[PM_PAR_YPOS];
    525525
    526             axes = pmPSF_ModelToAxes (PAR, model->type);
     526            axes = pmPSF_ModelToAxes (PAR, model->class->useReff);
    527527
    528528            row = psMetadataAlloc ();

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmSourceIO_RAW.c

    r36680 r37403  
    3737#include "pmMoments.h"
    3838#include "pmModelFuncs.h"
     39#include "pmModelClass.h"
    3940#include "pmModel.h"
    4041#include "pmModelUtils.h"
    41 #include "pmModelClass.h"
    4242#include "pmSourceMasks.h"
    4343#include "pmSourceExtendedPars.h"

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmSourceIO_SMPDATA.c

    r36680 r37403  
    3737#include "pmMoments.h"
    3838#include "pmModelFuncs.h"
     39#include "pmModelClass.h"
    3940#include "pmModel.h"
    4041#include "pmModelUtils.h"
    41 #include "pmModelClass.h"
    4242#include "pmSourceMasks.h"
    4343#include "pmSourceExtendedPars.h"
    … …  
    9393            lsky = (source->sky < 1.0) ? 0.0 : log10(source->sky);
    9494
    95             axes = pmPSF_ModelToAxes (PAR, model->type);
     95            axes = pmPSF_ModelToAxes (PAR, model->class->useReff);
    9696
    9797        } else {
    … …  
    190190        axes.theta       = psMetadataLookupF32 (&status, row, "THETA");
    191191
    192         pmPSF_AxesToModel (PAR, axes, modelType);
     192        pmPSF_AxesToModel (PAR, axes, model->class->useReff);
    193193
    194194        source->psfMag = psMetadataLookupF32 (&status, row, "MAG_RAW") - ZERO_POINT;

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmSourceIO_SX.c

    r36680 r37403  
    3737#include "pmMoments.h"
    3838#include "pmModelFuncs.h"
     39#include "pmModelClass.h"
    3940#include "pmModel.h"
    4041#include "pmModelUtils.h"
    41 #include "pmModelClass.h"
    4242#include "pmSourceMasks.h"
    4343#include "pmSourceExtendedPars.h"
    … …  
    8282        // pmSourceSextractType (source, &type, &flags);
    8383
    84         axes = pmPSF_ModelToAxes (PAR, model->type);
     84        axes = pmPSF_ModelToAxes (PAR, model->class->useReff);
    8585
    8686        psLineInit (line);

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmSourceMatch.c

    r36680 r37403  
    1818#include "pmMoments.h"
    1919#include "pmModelFuncs.h"
     20#include "pmModelClass.h"
    2021#include "pmModel.h"
    2122#include "pmModelUtils.h"
    22 #include "pmModelClass.h"
    2323#include "pmSourceMasks.h"
    2424#include "pmSourceExtendedPars.h"

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmSourceMoments.c

    r36680 r37403  
    3535#include "pmMoments.h"
    3636#include "pmModelFuncs.h"
     37#include "pmModelClass.h"
    3738#include "pmModel.h"
    3839#include "pmModelUtils.h"
    39 #include "pmModelClass.h"
    4040#include "pmSourceMasks.h"
    4141#include "pmSourceExtendedPars.h"

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmSourceOutputs.c

    r36680 r37403  
    2626#include "pmMoments.h"
    2727#include "pmModelFuncs.h"
     28#include "pmModelClass.h"
    2829#include "pmModel.h"
    2930#include "pmModelUtils.h"
    30 #include "pmModelClass.h"
    3131#include "pmSourceMasks.h"
    3232#include "pmSourceExtendedPars.h"
    … …  
    108108        }
    109109        if (isfinite(PAR[PM_PAR_SXX]) && isfinite(PAR[PM_PAR_SXY]) && isfinite(PAR[PM_PAR_SYY])) {
    110             axes = pmPSF_ModelToAxes (PAR, model->type);
     110            axes = pmPSF_ModelToAxes (PAR, model->class->useReff);
    111111            outputs->psfMajor = axes.major;
    112112            outputs->psfMinor = axes.minor;
    113113            outputs->psfTheta = axes.theta*PS_DEG_RAD;
     114
     115            // some models (PS1_V1, QGAUSS) have an extra 'core' parameter
     116            outputs->psfCore = NAN;
     117            if (model->type == pmModelClassGetType ("PS_MODEL_PS1_V1")) {
     118                outputs->psfCore = PAR[PM_PAR_7];
     119            }
     120            if (model->type == pmModelClassGetType ("PS_MODEL_QGAUSS")) {
     121                outputs->psfCore = PAR[PM_PAR_7];
     122            }
     123
     124            outputs->psfMajorFWHM = model->class->modelSetFWHM(model->params, axes.major);
     125            outputs->psfMinorFWHM = model->class->modelSetFWHM(model->params, axes.minor);
    114126        } else {
    115127            outputs->psfMajor = NAN;
    116128            outputs->psfMinor = NAN;
    117129            outputs->psfTheta = NAN;
     130            outputs->psfCore = NAN;
    118131        }
    119132        outputs->chisq = model->chisq;
    120133        outputs->nDOF = model->nDOF;
    121134        outputs->nPix = model->nPix;
    122         outputs->apRadius = source->apRadius;
    123135    } else {
    124136        bool useMoments = pmSourcePositionUseMoments(source);
    … …  
    138150        outputs->psfMinor = NAN;
    139151        outputs->psfTheta = NAN;
     152        outputs->psfCore = NAN;
    140153        outputs->chisq = NAN;
    141154        outputs->nDOF = 0;
    142155        outputs->nPix = 0;
    143         outputs->apRadius = NAN;
    144156    }
    145157

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmSourceOutputs.h

    r33690 r37403  
    2626    float psfMinor;
    2727    float psfTheta;
     28    float psfCore;
     29    float psfMajorFWHM;
     30    float psfMinorFWHM;
    2831    float chisq;
    29     float apRadius;
    3032    int nPix;
    3133    int nDOF;

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmSourcePhotometry.c

    r36680 r37403  
    3333#include "pmMoments.h"
    3434#include "pmModelFuncs.h"
     35#include "pmModelClass.h"
    3536#include "pmModel.h"
    3637#include "pmModelUtils.h"
    37 #include "pmModelClass.h"
    3838#include "pmSourceMasks.h"
    3939#include "pmSourceExtendedPars.h"
    … …  
    330330
    331331    // measure fitMag
    332     flux = model->modelFlux (model->params);
     332    flux = model->class->modelFlux (model->params);
    333333    if (flux > 0) {
    334334        mag = -2.5*log10(flux);
    … …  
    359359
    360360    bool status;
    361     int nPix = 0;
    362     status = pmSourcePhotometryAper(&nPix, &source->apMagRaw, &source->apFlux, &source->apFluxErr, model, image, variance, mask, maskVal);
     361    status = pmSourcePhotometryAper(&source->apNpixels, &source->apMagRaw, &source->apFlux, &source->apFluxErr, model, image, variance, mask, maskVal);
    363362    if (status) {
    364363        source->mode |= PM_SOURCE_MODE_AP_MAGS;
    … …  
    490489
    491490            // for the full model, add all points
    492             value = fabs(model->modelFunc (NULL, params, coord) - sky);
     491            value = fabs(model->class->modelFunc (NULL, params, coord) - sky);
    493492            modelSum += value;
    494493
    … …  
    893892
    894893            // for the full model, add all points
    895             float value = model->modelFunc (NULL, params, coord);
     894            float value = model->class->modelFunc (NULL, params, coord);
    896895
    897896            // fprintf (stderr, "%d, %d : %f, %f : %f - %f : %f\n",

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmSourcePlotApResid.c

    r36680 r37403  
    3535#include "pmMoments.h"
    3636#include "pmModelFuncs.h"
     37#include "pmModelClass.h"
    3738#include "pmModel.h"
    3839#include "pmModelUtils.h"
    39 #include "pmModelClass.h"
    4040#include "pmSourceMasks.h"
    4141#include "pmSourceExtendedPars.h"

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmSourcePlotMoments.c

    r36680 r37403  
    3838#include "pmMoments.h"
    3939#include "pmModelFuncs.h"
     40#include "pmModelClass.h"
    4041#include "pmModel.h"
    4142#include "pmModelUtils.h"
    42 #include "pmModelClass.h"
    4343#include "pmSourceMasks.h"
    4444#include "pmSourceExtendedPars.h"

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmSourcePlotPSFModel.c

    r36680 r37403  
    3939#include "pmMoments.h"
    4040#include "pmModelFuncs.h"
     41#include "pmModelClass.h"
    4142#include "pmModel.h"
    4243#include "pmModelUtils.h"
    43 #include "pmModelClass.h"
    4444#include "pmSourceMasks.h"
    4545#include "pmSourceExtendedPars.h"
    … …  
    147147        // force the axis ratio to be < 20.0
    148148        psEllipseAxes axes_mnt = psEllipseMomentsToAxes (moments, 20.0);
    149         psEllipseAxes axes_psf = pmPSF_ModelToAxes (PAR, model->type);
     149        psEllipseAxes axes_psf = pmPSF_ModelToAxes (PAR, model->class->useReff);
    150150
    151151        // moments major axis

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmSourceSky.c

    r36680 r37403  
    3434#include "pmMoments.h"
    3535#include "pmModelFuncs.h"
     36#include "pmModelClass.h"
    3637#include "pmModel.h"
    3738#include "pmModelUtils.h"
    38 #include "pmModelClass.h"
    3939#include "pmSourceMasks.h"
    4040#include "pmSourceExtendedPars.h"

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmSourceUtils.c

    r36680 r37403  
    3434#include "pmMoments.h"
    3535#include "pmModelFuncs.h"
     36#include "pmModelClass.h"
    3637#include "pmModel.h"
    3738#include "pmModelUtils.h"
    38 #include "pmModelClass.h"
    3939#include "pmSourceMasks.h"
    4040#include "pmSourceExtendedPars.h"
    … …  
    6565    pmModel *model = pmModelAlloc(modelType);
    6666
    67     if (!model->modelGuess(model, source, maskVal, markVal)) {
     67    if (!model->class->modelGuess(model, source, maskVal, markVal)) {
    6868        psFree (model);
    6969        return NULL;

  • branches/eam_branches/ps2-tc3-20130727/psModules/src/objects/pmSourceVisual.c

    r36680 r37403  
    1616#include "pmMoments.h"
    1717#include "pmModelFuncs.h"
     18#include "pmModelClass.h"
    1819#include "pmModel.h"
    1920#include "pmModelUtils.h"
    20 #include "pmModelClass.h"
    2121#include "pmSourceMasks.h"
    2222#include "pmSourceExtendedPars.h"
    … …  
    545545    psFree (model);
    546546
     547    bool dumpData = false;
     548
    547549    // pause and wait for user input:
    548550    // continue, save (provide name), ??
    549     pmVisualAskUser(&plotPSF);
     551retry:
     552    pmVisualAskUserOrDump(&plotPSF, &dumpData);
     553    if (dumpData) {
     554      char name[128];
     555      fprintf (stderr, "filename: ");
     556      int status = fscanf (stdin, "%127s", name);
     557      if (status != 1) {
     558        fprintf (stderr, "odd response\n");
     559        goto retry;
     560      }
     561
     562      FILE *f = fopen (name, "w");
     563      if (!f) {
     564        fprintf (stderr, "cannot open %s for output\n", name);
     565        goto retry;
     566      }
     567      for (int i = 0; i < x->n; i++) {
     568        float vModel = pmTrend2DEval (trend, x->data.F32[i], y->data.F32[i]);
     569        fprintf (f, "%f %f %f %f %d\n", x->data.F32[i], y->data.F32[i], param->data.F32[i], vModel, mask->data.PS_TYPE_VECTOR_MASK_DATA[i]);
     570      }
     571      fclose (f);
     572      goto retry;
     573    }
    550574
    551575    return true;
Note: See TracChangeset for help on using the changeset viewer.