IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 36857


Ignore:
Timestamp:
Jun 13, 2014, 6:25:48 AM (12 years ago)
Author:
eugene
Message:

I added a new model function class, pmModelSetFHWM; also added a boolean useReff to the model class for use instead of pmModelUseReff everywhere

Location:
trunk/psModules/src/objects/models
Files:
1 added
18 edited

Legend:

Unmodified
Added
Removed

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

    r36623 r36857  
    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
    … …  
    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);

  • trunk/psModules/src/objects/models/pmModel_DEV.h

    r35560 r36857  
    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);

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

    r36623 r36857  
    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);

  • trunk/psModules/src/objects/models/pmModel_EXP.h

    r35560 r36857  
    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);

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

    r36623 r36857  
    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);

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

    r35560 r36857  
    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);

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

    r36623 r36857  
    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);

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

    r35560 r36857  
    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);

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

    r36623 r36857  
    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);

  • trunk/psModules/src/objects/models/pmModel_PS1_V1.h

    r35560 r36857  
    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);

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

    r36623 r36857  
    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);

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

    r35560 r36857  
    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);

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

    r36623 r36857  
    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);

  • trunk/psModules/src/objects/models/pmModel_RGAUSS.h

    r35560 r36857  
    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);

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

    r36762 r36857  
    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
    … …  
    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);

  • trunk/psModules/src/objects/models/pmModel_SERSIC.h

    r35560 r36857  
    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);

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

    r36623 r36857  
    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

  • trunk/psModules/src/objects/models/pmModel_TRAIL.h

    r35560 r36857  
    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);
Note: See TracChangeset for help on using the changeset viewer.