IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 25521


Ignore:
Timestamp:
Sep 23, 2009, 5:12:22 PM (17 years ago)
Author:
Paul Price
Message:

Added multiple sets of limits for models. Involved reorganisation of how the models are sucked into the pmModelClasses: now using header files instead of including the source for each model. This allows static variables to be properly respected.

Location:
branches/pap/psModules/src/objects
Files:
6 added
11 edited

Legend:

Unmodified
Added
Removed

  • branches/pap/psModules/src/objects/Makefile.am

    r25383 r25521  
    5454        pmGrowthCurve.c \
    5555        pmSourceMatch.c \
    56         pmDetEff.c
    57 
    58 EXTRA_DIST = \
     56        pmDetEff.c \
    5957        models/pmModel_GAUSS.c \
    6058        models/pmModel_PGAUSS.c \
     59        models/pmModel_PS1_V1.c \
    6160        models/pmModel_QGAUSS.c \
    62         models/pmModel_SGAUSS.c \
    6361        models/pmModel_RGAUSS.c \
    6462        models/pmModel_SERSIC.c
    … …  
    9290        pmGrowthCurve.h \
    9391        pmSourceMatch.h \
    94         pmDetEff.h
     92        pmDetEff.h \
     93        models/pmModel_GAUSS.h \
     94        models/pmModel_PGAUSS.h \
     95        models/pmModel_PS1_V1.h \
     96        models/pmModel_QGAUSS.h \
     97        models/pmModel_RGAUSS.h \
     98        models/pmModel_SERSIC.h
    9599
    96100CLEANFILES = *~

  • branches/pap/psModules/src/objects/models/pmModel_GAUSS.c

    r20001 r25521  
    1919 *****************************************************************************/
    2020
     21#include <stdio.h>
     22#include <pslib.h>
     23
     24#include "pmMoments.h"
     25#include "pmPeaks.h"
     26#include "pmSource.h"
     27#include "pmModel.h"
     28#include "pmModel_GAUSS.h"
     29
    2130# define PM_MODEL_FUNC            pmModelFunc_GAUSS
    2231# define PM_MODEL_FLUX            pmModelFlux_GAUSS
    … …  
    2736# define PM_MODEL_PARAMS_FROM_PSF pmModelParamsFromPSF_GAUSS
    2837# define PM_MODEL_FIT_STATUS      pmModelFitStatus_GAUSS
     38# define PM_MODEL_SET_LIMITS      pmModelSetLimits_GAUSS
     39
     40// Lax parameter limits
     41static float paramsMinLax[] = { -1.0e3, 1.0e-2, -100, -100, 0.5, 0.5, -1.0 };
     42static float paramsMaxLax[] = { 1.0e5, 1.0e8, 1.0e4, 1.0e4, 100, 100, 1.0 };
     43
     44// Strict parameter limits
     45static float *paramsMinStrict = paramsMinLax;
     46static float *paramsMaxStrict = paramsMaxLax;
     47
     48// Parameter limits to use
     49static float *paramsMinUse = NULL;
     50static float *paramsMaxUse = NULL;
     51static float betaUse[] = { 1000, 3e6, 5, 5, 2.0, 2.0, 0.5 };
    2952
    3053// the model is a function of the pixel coordinate (pixcoord[0,1] = x,y)
    … …  
    6891bool PM_MODEL_LIMITS (psMinConstraintMode mode, int nParam, float *params, float *beta)
    6992{
    70     float beta_lim = 0, params_min = 0, params_max = 0;
    71     float f1 = 0, f2 = 0, q1 = 0, q2 = 0;
     93    psAssert(nParam >= 0 && nParam <= PM_PAR_7, "Parameter index is out of bounds");
    7294
    7395    // we need to calculate the limits for SXY specially
     96    float q2 = NAN;
    7497    if (nParam == PM_PAR_SXY) {
    75         f1 = 1.0 / PS_SQR(params[PM_PAR_SYY]) + 1.0 / PS_SQR(params[PM_PAR_SXX]);
    76         f2 = 1.0 / PS_SQR(params[PM_PAR_SYY]) - 1.0 / PS_SQR(params[PM_PAR_SXX]);
    77         q1 = PS_SQR(f1)*AR_RATIO - PS_SQR(f2);
    78         q1 = PS_MAX (0.0, q1);
     98        float f1 = 1.0 / PS_SQR(params[PM_PAR_SYY]) + 1.0 / PS_SQR(params[PM_PAR_SXX]);
     99        float f2 = 1.0 / PS_SQR(params[PM_PAR_SYY]) - 1.0 / PS_SQR(params[PM_PAR_SXX]);
     100        float q1 = PS_SQR(f1)*AR_RATIO - PS_SQR(f2);
     101        q1 = (q1 < 0.0) ? 0.0 : q1;
    79102        // if q1 < 0.0, f2 ~ f1, we have a very large axis ratio near 45deg..  Saturate at that
    80103        // angle and let f2,f1 fight it out
    81         q2  = 0.5*sqrt (q1);
     104        q2 = 0.5*sqrtf(q1);
    82105    }
    83106
    84107    switch (mode) {
    85     case PS_MINIMIZE_BETA_LIMIT:
    86         switch (nParam) {
    87         case PM_PAR_SKY:
    88             beta_lim = 1000;
    89             break;
    90         case PM_PAR_I0:
    91             beta_lim = 3e6;
    92             break;
    93         case PM_PAR_XPOS:
    94             beta_lim = 5;
    95             break;
    96         case PM_PAR_YPOS:
    97             beta_lim = 5;
    98             break;
    99         case PM_PAR_SXX:
    100             beta_lim = 2.0;
    101             break;
    102         case PM_PAR_SYY:
    103             beta_lim = 2.0;
    104             break;
    105         case PM_PAR_SXY:
    106             beta_lim =  0.5*q2;
    107             break;
    108         default:
    109             psAbort("invalid parameter %d for beta test", nParam);
    110         }
    111         if (fabs(beta[nParam]) > fabs(beta_lim)) {
    112             beta[nParam] = (beta[nParam] > 0) ? fabs(beta_lim) : -fabs(beta_lim);
    113             psTrace ("psModules.objects", 5, "|beta[nParam==%d]| > |beta_lim|; %g v. %g",
    114                      nParam, beta[nParam], beta_lim);
    115             return false;
    116         }
    117         return true;
    118     case PS_MINIMIZE_PARAM_MIN:
    119         switch (nParam) {
    120         case PM_PAR_SKY:
    121             params_min = -1000;
    122             break;
    123         case PM_PAR_I0:
    124             params_min =   0.01;
    125             break;
    126         case PM_PAR_XPOS:
    127             params_min =  -100;
    128             break;
    129         case PM_PAR_YPOS:
    130             params_min =  -100;
    131             break;
    132         case PM_PAR_SXX:
    133             params_min =   0.5;
    134             break;
    135         case PM_PAR_SYY:
    136             params_min =   0.5;
    137             break;
    138         case PM_PAR_SXY:
    139             params_min =   -q2;
    140             break;
    141         default:
    142             psAbort("invalid parameter %d for param min test", nParam);
    143         }
    144         if (params[nParam] < params_min) {
    145             params[nParam] = params_min;
    146             psTrace ("psModules.objects", 5, "params[nParam==%d] < params_min; %g v. %g",
    147                      nParam, params[nParam], params_min);
    148             return false;
    149         }
    150         return true;
    151     case PS_MINIMIZE_PARAM_MAX:
    152         switch (nParam) {
    153         case PM_PAR_SKY:
    154             params_max =   1e5;
    155             break;
    156         case PM_PAR_I0:
    157             params_max =   1e8;
    158             break;
    159         case PM_PAR_XPOS:
    160             params_max =   1e4;
    161             break;
    162         case PM_PAR_YPOS:
    163             params_max =   1e4;
    164             break;
    165         case PM_PAR_SXX:
    166             params_max =   100;
    167             break;
    168         case PM_PAR_SYY:
    169             params_max =   100;
    170             break;
    171         case PM_PAR_SXY:
    172             params_max =   +q2;
    173             break;
    174         default:
    175             psAbort("invalid parameter %d for param max test", nParam);
    176         }
    177         if (params[nParam] > params_max) {
    178             params[nParam] = params_max;
    179             psTrace ("psModules.objects", 5, "params[nParam==%d] > params_max; %g v. %g",
    180                      nParam, params[nParam], params_max);
    181             return false;
    182         }
    183         return true;
     108      case PS_MINIMIZE_BETA_LIMIT: {
     109          psAssert(beta, "Require beta to limit beta");
     110          float limit = betaUse[nParam];
     111          if (nParam == PM_PAR_SXY) {
     112              limit *= q2;
     113          }
     114          if (fabs(beta[nParam]) > fabs(limit)) {
     115              beta[nParam] = (beta[nParam] > 0) ? fabs(limit) : -fabs(limit);
     116              psTrace("psModules.objects", 5, "|beta[nParam==%d]| > |beta_lim|; %g v. %g",
     117                      nParam, beta[nParam], limit);
     118              return false;
     119          }
     120          return true;
     121      }
     122      case PS_MINIMIZE_PARAM_MIN: {
     123          psAssert(params, "Require parameters to limit parameters");
     124          psAssert(paramsMinUse, "Require parameter limits to limit parameters");
     125          float limit = paramsMinUse[nParam];
     126          if (nParam == PM_PAR_SXY) {
     127              limit *= q2;
     128          }
     129          if (params[nParam] < limit) {
     130              params[nParam] = limit;
     131              psTrace("psModules.objects", 5, "params[nParam==%d] < params_min; %g v. %g",
     132                      nParam, params[nParam], limit);
     133              return false;
     134          }
     135          return true;
     136      }
     137      case PS_MINIMIZE_PARAM_MAX: {
     138          psAssert(params, "Require parameters to limit parameters");
     139          psAssert(paramsMaxUse, "Require parameter limits to limit parameters");
     140          float limit = paramsMaxUse[nParam];
     141          if (nParam == PM_PAR_SXY) {
     142              limit *= q2;
     143          }
     144          if (params[nParam] > limit) {
     145              params[nParam] = limit;
     146              psTrace("psModules.objects", 5, "params[nParam==%d] > params_max; %g v. %g",
     147                      nParam, params[nParam], limit);
     148              return false;
     149          }
     150          return true;
     151      }
    184152    default:
    185153        psAbort("invalid choice for limits");
    … …  
    388356}
    389357
     358void PM_MODEL_SET_LIMITS(pmModelLimitsType type)
     359{
     360    switch (type) {
     361      case PM_MODEL_LIMITS_NONE:
     362        paramsMinUse = NULL;
     363        paramsMaxUse = NULL;
     364      case PM_MODEL_LIMITS_LAX:
     365        paramsMinUse = paramsMinLax;
     366        paramsMaxUse = paramsMaxLax;
     367        break;
     368      case PM_MODEL_LIMITS_STRICT:
     369        paramsMinUse = paramsMinStrict;
     370        paramsMaxUse = paramsMaxStrict;
     371        break;
     372      default:
     373        psAbort("Unrecognised model limits type: %x", type);
     374    }
     375    return;
     376}
     377
    390378# undef PM_MODEL_FUNC
    391379# undef PM_MODEL_FLUX
    … …  
    396384# undef PM_MODEL_PARAMS_FROM_PSF
    397385# undef PM_MODEL_FIT_STATUS
     386# undef PM_MODEL_SET_LIMITS

  • branches/pap/psModules/src/objects/models/pmModel_PGAUSS.c

    r20001 r25521  
    1919 *****************************************************************************/
    2020
     21#include <stdio.h>
     22#include <pslib.h>
     23
     24#include "pmMoments.h"
     25#include "pmPeaks.h"
     26#include "pmSource.h"
     27#include "pmModel.h"
     28#include "pmModel_PGAUSS.h"
     29
    2130# define PM_MODEL_FUNC            pmModelFunc_PGAUSS
    2231# define PM_MODEL_FLUX            pmModelFlux_PGAUSS
    … …  
    2736# define PM_MODEL_PARAMS_FROM_PSF pmModelParamsFromPSF_PGAUSS
    2837# define PM_MODEL_FIT_STATUS      pmModelFitStatus_PGAUSS
     38# define PM_MODEL_SET_LIMITS      pmModelSetLimits_PGAUSS
     39
     40// Lax parameter limits
     41static float paramsMinLax[] = { -1.0e3, 1.0e-2, -100, -100, 0.5, 0.5, -1.0 };
     42static float paramsMaxLax[] = { 1.0e5, 1.0e8, 1.0e4, 1.0e4, 100, 100, 1.0 };
     43
     44// Strict parameter limits
     45static float *paramsMinStrict = paramsMinLax;
     46static float *paramsMaxStrict = paramsMaxLax;
     47
     48// Parameter limits to use
     49static float *paramsMinUse = NULL;
     50static float *paramsMaxUse = NULL;
     51static float betaUse[] = { 1000, 3e6, 5, 5, 2.0, 2.0, 0.5 };
    2952
    3053// the model is a function of the pixel coordinate (pixcoord[0,1] = x,y)
    … …  
    6992bool PM_MODEL_LIMITS (psMinConstraintMode mode, int nParam, float *params, float *beta)
    7093{
    71     float beta_lim = 0, params_min = 0, params_max = 0;
    72     float f1 = 0, f2 = 0, q1 = 0, q2 = 0;
     94    psAssert(nParam >= 0 && nParam <= PM_PAR_7, "Parameter index is out of bounds");
    7395
    7496    // we need to calculate the limits for SXY specially
     97    float q2 = NAN;
    7598    if (nParam == PM_PAR_SXY) {
    76         f1 = 1.0 / PS_SQR(params[PM_PAR_SYY]) + 1.0 / PS_SQR(params[PM_PAR_SXX]);
    77         f2 = 1.0 / PS_SQR(params[PM_PAR_SYY]) - 1.0 / PS_SQR(params[PM_PAR_SXX]);
    78         q1 = PS_SQR(f1)*AR_RATIO - PS_SQR(f2);
    79         q1 = PS_MAX (0.0, q1);
     99        float f1 = 1.0 / PS_SQR(params[PM_PAR_SYY]) + 1.0 / PS_SQR(params[PM_PAR_SXX]);
     100        float f2 = 1.0 / PS_SQR(params[PM_PAR_SYY]) - 1.0 / PS_SQR(params[PM_PAR_SXX]);
     101        float q1 = PS_SQR(f1)*AR_RATIO - PS_SQR(f2);
     102        q1 = (q1 < 0.0) ? 0.0 : q1;
    80103        // if q1 < 0.0, f2 ~ f1, we have a very large axis ratio near 45deg..  Saturate at that
    81104        // angle and let f2,f1 fight it out
    82         q2  = 0.5*sqrt (q1);
     105        q2 = 0.5*sqrtf(q1);
    83106    }
    84107
    85108    switch (mode) {
    86     case PS_MINIMIZE_BETA_LIMIT:
    87         switch (nParam) {
    88         case PM_PAR_SKY:
    89             beta_lim = 1000;
    90             break;
    91         case PM_PAR_I0:
    92             beta_lim = 3e6;
    93             break;
    94         case PM_PAR_XPOS:
    95             beta_lim = 5;
    96             break;
    97         case PM_PAR_YPOS:
    98             beta_lim = 5;
    99             break;
    100         case PM_PAR_SXX:
    101             beta_lim = 2.0;
    102             break;
    103         case PM_PAR_SYY:
    104             beta_lim = 2.0;
    105             break;
    106         case PM_PAR_SXY:
    107             beta_lim =  0.5*q2;
    108             break;
    109         default:
    110             psAbort("invalid parameter %d for beta test", nParam);
    111         }
    112         if (fabs(beta[nParam]) > fabs(beta_lim)) {
    113             beta[nParam] = (beta[nParam] > 0) ? fabs(beta_lim) : -fabs(beta_lim);
    114             psTrace ("psModules.objects", 5, "|beta[nParam==%d]| > |beta_lim|; %g v. %g",
    115                      nParam, beta[nParam], beta_lim);
    116             return false;
    117         }
    118         return true;
    119     case PS_MINIMIZE_PARAM_MIN:
    120         switch (nParam) {
    121         case PM_PAR_SKY:
    122             params_min = -1000;
    123             break;
    124         case PM_PAR_I0:
    125             params_min =  0.01;
    126             break;
    127         case PM_PAR_XPOS:
    128             params_min =  -100;
    129             break;
    130         case PM_PAR_YPOS:
    131             params_min =  -100;
    132             break;
    133         case PM_PAR_SXX:
    134             params_min =   0.5;
    135             break;
    136         case PM_PAR_SYY:
    137             params_min =   0.5;
    138             break;
    139         case PM_PAR_SXY:
    140             params_min =   -q2;
    141             break;
    142         default:
    143             psAbort("invalid parameter %d for param min test", nParam);
    144         }
    145         if (params[nParam] < params_min) {
    146             params[nParam] = params_min;
    147             psTrace ("psModules.objects", 5, "params[nParam==%d] < params_min; %g v. %g",
    148                      nParam, params[nParam], params_min);
    149             return false;
    150         }
    151         return true;
    152     case PS_MINIMIZE_PARAM_MAX:
    153         switch (nParam) {
    154         case PM_PAR_SKY:
    155             params_max =   1e5;
    156             break;
    157         case PM_PAR_I0:
    158             params_max =   1e8;
    159             break;
    160         case PM_PAR_XPOS:
    161             params_max =   1e4;
    162             break;
    163         case PM_PAR_YPOS:
    164             params_max =   1e4;
    165             break;
    166         case PM_PAR_SXX:
    167             params_max =   100;
    168             break;
    169         case PM_PAR_SYY:
    170             params_max =   100;
    171             break;
    172         case PM_PAR_SXY:
    173             params_max =   +q2;
    174             break;
    175         default:
    176             psAbort("invalid parameter %d for param max test", nParam);
    177         }
    178         if (params[nParam] > params_max) {
    179             params[nParam] = params_max;
    180             psTrace ("psModules.objects", 5, "params[nParam==%d] > params_max; %g v. %g",
    181                      nParam, params[nParam], params_max);
    182             return false;
    183         }
    184         return true;
    185     default:
     109      case PS_MINIMIZE_BETA_LIMIT: {
     110          psAssert(beta, "Require beta to limit beta");
     111          float limit = betaUse[nParam];
     112          if (nParam == PM_PAR_SXY) {
     113              limit *= q2;
     114          }
     115          if (fabs(beta[nParam]) > fabs(limit)) {
     116              beta[nParam] = (beta[nParam] > 0) ? fabs(limit) : -fabs(limit);
     117              psTrace("psModules.objects", 5, "|beta[nParam==%d]| > |beta_lim|; %g v. %g",
     118                      nParam, beta[nParam], limit);
     119              return false;
     120          }
     121          return true;
     122      }
     123      case PS_MINIMIZE_PARAM_MIN: {
     124          psAssert(params, "Require parameters to limit parameters");
     125          psAssert(paramsMinUse, "Require parameter limits to limit parameters");
     126          float limit = paramsMinUse[nParam];
     127          if (nParam == PM_PAR_SXY) {
     128              limit *= q2;
     129          }
     130          if (params[nParam] < limit) {
     131              params[nParam] = limit;
     132              psTrace("psModules.objects", 5, "params[nParam==%d] < params_min; %g v. %g",
     133                      nParam, params[nParam], limit);
     134              return false;
     135          }
     136          return true;
     137      }
     138      case PS_MINIMIZE_PARAM_MAX: {
     139          psAssert(params, "Require parameters to limit parameters");
     140          psAssert(paramsMaxUse, "Require parameter limits to limit parameters");
     141          float limit = paramsMaxUse[nParam];
     142          if (nParam == PM_PAR_SXY) {
     143              limit *= q2;
     144          }
     145          if (params[nParam] > limit) {
     146              params[nParam] = limit;
     147              psTrace("psModules.objects", 5, "params[nParam==%d] > params_max; %g v. %g",
     148                      nParam, params[nParam], limit);
     149              return false;
     150          }
     151          return true;
     152      }
     153      default:
    186154        psAbort("invalid choice for limits");
    187155    }
    … …  
    189157    return false;
    190158}
     159
    191160
    192161// make an initial guess for parameters
    … …  
    434403}
    435404
     405void PM_MODEL_SET_LIMITS(pmModelLimitsType type)
     406{
     407    switch (type) {
     408      case PM_MODEL_LIMITS_NONE:
     409        paramsMinUse = NULL;
     410        paramsMaxUse = NULL;
     411      case PM_MODEL_LIMITS_LAX:
     412        paramsMinUse = paramsMinLax;
     413        paramsMaxUse = paramsMaxLax;
     414        break;
     415      case PM_MODEL_LIMITS_STRICT:
     416        paramsMinUse = paramsMinStrict;
     417        paramsMaxUse = paramsMaxStrict;
     418        break;
     419      default:
     420        psAbort("Unrecognised model limits type: %x", type);
     421    }
     422    return;
     423}
     424
    436425# undef PM_MODEL_FUNC
    437426# undef PM_MODEL_FLUX
    … …  
    442431# undef PM_MODEL_PARAMS_FROM_PSF
    443432# undef PM_MODEL_FIT_STATUS
     433# undef PM_MODEL_SET_LIMITS

  • branches/pap/psModules/src/objects/models/pmModel_PS1_V1.c

    r23962 r25521  
    2020   *****************************************************************************/
    2121
     22#include <stdio.h>
     23#include <pslib.h>
     24
     25#include "pmMoments.h"
     26#include "pmPeaks.h"
     27#include "pmSource.h"
     28#include "pmModel.h"
     29#include "pmModel_PS1_V1.h"
     30
    2231# define PM_MODEL_FUNC            pmModelFunc_PS1_V1
    2332# define PM_MODEL_FLUX            pmModelFlux_PS1_V1
    … …  
    2837# define PM_MODEL_PARAMS_FROM_PSF pmModelParamsFromPSF_PS1_V1
    2938# define PM_MODEL_FIT_STATUS      pmModelFitStatus_PS1_V1
     39# define PM_MODEL_SET_LIMITS      pmModelSetLimits_PS1_V1
    3040
    3141# define ALPHA   1.666
    3242# define ALPHA_M 0.666
     43
     44// Lax parameter limits
     45static float paramsMinLax[] = { -1.0e3, 1.0e-2, -100, -100, 0.5, 0.5, -1.0, -1.0 };
     46static float paramsMaxLax[] = { 1.0e5, 1.0e8, 1.0e4, 1.0e4, 100, 100, 1.0, 20.0 };
     47
     48// Strict parameter limits
     49// k = PAR_7 < 0 is very undesirable (big divot in the middle)
     50static float paramsMinStrict[] = { -1.0e3, 1.0e-2, -100, -100, 0.5, 0.5, -1.0, 0.0 };
     51static float paramsMaxStrict[] = { 1.0e5, 1.0e8, 1.0e4, 1.0e4, 100, 100, 1.0, 20.0 };
     52
     53// Parameter limits to use
     54static float *paramsMinUse = NULL;
     55static float *paramsMaxUse = NULL;
     56static float betaUse[] = { 1000, 3e6, 5, 5, 1.0, 1.0, 0.5, 2.0 };
     57
    3358
    3459psF32 PM_MODEL_FUNC (psVector *deriv,
    … …  
    84109bool PM_MODEL_LIMITS (psMinConstraintMode mode, int nParam, float *params, float *beta)
    85110{
    86     float beta_lim = 0, params_min = 0, params_max = 0;
    87     float f1 = 0, f2 = 0, q1 = 0, q2 = 0;
     111    psAssert(nParam >= 0 && nParam <= PM_PAR_7, "Parameter index is out of bounds");
    88112
    89113    // we need to calculate the limits for SXY specially
     114    float q2 = NAN;
    90115    if (nParam == PM_PAR_SXY) {
    91         f1 = 1.0 / PS_SQR(params[PM_PAR_SYY]) + 1.0 / PS_SQR(params[PM_PAR_SXX]);
    92         f2 = 1.0 / PS_SQR(params[PM_PAR_SYY]) - 1.0 / PS_SQR(params[PM_PAR_SXX]);
    93         q1 = PS_SQR(f1)*AR_RATIO - PS_SQR(f2);
     116        float f1 = 1.0 / PS_SQR(params[PM_PAR_SYY]) + 1.0 / PS_SQR(params[PM_PAR_SXX]);
     117        float f2 = 1.0 / PS_SQR(params[PM_PAR_SYY]) - 1.0 / PS_SQR(params[PM_PAR_SXX]);
     118        float q1 = PS_SQR(f1)*AR_RATIO - PS_SQR(f2);
    94119        q1 = (q1 < 0.0) ? 0.0 : q1;
    95120        // if q1 < 0.0, f2 ~ f1, we have a very large axis ratio near 45deg..  Saturate at that
    96121        // angle and let f2,f1 fight it out
    97         q2  = 0.5*sqrt (q1);
     122        q2 = 0.5*sqrtf(q1);
    98123    }
    99124
    100125    switch (mode) {
    101     case PS_MINIMIZE_BETA_LIMIT:
    102         switch (nParam) {
    103         case PM_PAR_SKY:
    104             beta_lim = 1000;
    105             break;
    106         case PM_PAR_I0:
    107             beta_lim = 3e6;
    108             break;
    109         case PM_PAR_XPOS:
    110             beta_lim = 5;
    111             break;
    112         case PM_PAR_YPOS:
    113             beta_lim = 5;
    114             break;
    115         case PM_PAR_SXX:
    116             beta_lim = 1.0;
    117             break;
    118         case PM_PAR_SYY:
    119             beta_lim = 1.0;
    120             break;
    121         case PM_PAR_SXY:
    122             beta_lim =  0.5*q2;
    123             break;
    124         case PM_PAR_7:
    125             beta_lim = 2.0;
    126             break;
    127         default:
    128             psAbort("invalid parameter %d for beta test", nParam);
    129         }
    130         if (fabs(beta[nParam]) > fabs(beta_lim)) {
    131             beta[nParam] = (beta[nParam] > 0) ? fabs(beta_lim) : -fabs(beta_lim);
    132             psTrace ("psModules.objects", 5, "|beta[nParam==%d]| > |beta_lim|; %g v. %g",
    133                      nParam, beta[nParam], beta_lim);
    134             return false;
    135         }
    136         return true;
    137     case PS_MINIMIZE_PARAM_MIN:
    138         switch (nParam) {
    139         case PM_PAR_SKY:
    140             params_min = -1000;
    141             break;
    142         case PM_PAR_I0:
    143             params_min =   0.01;
    144             break;
    145         case PM_PAR_XPOS:
    146             params_min =  -100;
    147             break;
    148         case PM_PAR_YPOS:
    149             params_min =  -100;
    150             break;
    151         case PM_PAR_SXX:
    152             params_min =   0.5;
    153             break;
    154         case PM_PAR_SYY:
    155             params_min =   0.5;
    156             break;
    157         case PM_PAR_SXY:
    158             params_min =  -q2;
    159             break;
    160         case PM_PAR_7:
    161             params_min =  -1.0;
    162             break;
    163         default:
    164             psAbort("invalid parameter %d for param min test", nParam);
    165         }
    166         if (params[nParam] < params_min) {
    167             params[nParam] = params_min;
    168             psTrace ("psModules.objects", 5, "params[nParam==%d] < params_min; %g v. %g",
    169                      nParam, params[nParam], params_min);
    170             return false;
    171         }
    172         return true;
    173     case PS_MINIMIZE_PARAM_MAX:
    174         switch (nParam) {
    175         case PM_PAR_SKY:
    176             params_max =   1e5;
    177             break;
    178         case PM_PAR_I0:
    179             params_max =   1e8;
    180             break;
    181         case PM_PAR_XPOS:
    182             params_max =   1e4;
    183             break;
    184         case PM_PAR_YPOS:
    185             params_max =   1e4;
    186             break;
    187         case PM_PAR_SXX:
    188             params_max =   100;
    189             break;
    190         case PM_PAR_SYY:
    191             params_max =   100;
    192             break;
    193         case PM_PAR_SXY:
    194             params_max =  +q2;
    195             break;
    196         case PM_PAR_7:
    197             params_max =  20.0;
    198             break;
    199         default:
    200             psAbort("invalid parameter %d for param max test", nParam);
    201         }
    202         if (params[nParam] > params_max) {
    203             params[nParam] = params_max;
    204             psTrace ("psModules.objects", 5, "params[nParam==%d] > params_max; %g v. %g",
    205                      nParam, params[nParam], params_max);
    206             return false;
    207         }
    208         return true;
    209     default:
     126      case PS_MINIMIZE_BETA_LIMIT: {
     127          psAssert(beta, "Require beta to limit beta");
     128          float limit = betaUse[nParam];
     129          if (nParam == PM_PAR_SXY) {
     130              limit *= q2;
     131          }
     132          if (fabs(beta[nParam]) > fabs(limit)) {
     133              beta[nParam] = (beta[nParam] > 0) ? fabs(limit) : -fabs(limit);
     134              psTrace("psModules.objects", 5, "|beta[nParam==%d]| > |beta_lim|; %g v. %g",
     135                      nParam, beta[nParam], limit);
     136              return false;
     137          }
     138          return true;
     139      }
     140      case PS_MINIMIZE_PARAM_MIN: {
     141          psAssert(params, "Require parameters to limit parameters");
     142          psAssert(paramsMinUse, "Require parameter limits to limit parameters");
     143          float limit = paramsMinUse[nParam];
     144          if (nParam == PM_PAR_SXY) {
     145              limit *= q2;
     146          }
     147          if (params[nParam] < limit) {
     148              params[nParam] = limit;
     149              psTrace("psModules.objects", 5, "params[nParam==%d] < params_min; %g v. %g",
     150                      nParam, params[nParam], limit);
     151              return false;
     152          }
     153          return true;
     154      }
     155      case PS_MINIMIZE_PARAM_MAX: {
     156          psAssert(params, "Require parameters to limit parameters");
     157          psAssert(paramsMaxUse, "Require parameter limits to limit parameters");
     158          float limit = paramsMaxUse[nParam];
     159          if (nParam == PM_PAR_SXY) {
     160              limit *= q2;
     161          }
     162          if (params[nParam] > limit) {
     163              params[nParam] = limit;
     164              psTrace("psModules.objects", 5, "params[nParam==%d] > params_max; %g v. %g",
     165                      nParam, params[nParam], limit);
     166              return false;
     167          }
     168          return true;
     169      }
     170      default:
    210171        psAbort("invalid choice for limits");
    211172    }
    … …  
    468429}
    469430
     431
     432void PM_MODEL_SET_LIMITS(pmModelLimitsType type)
     433{
     434    switch (type) {
     435      case PM_MODEL_LIMITS_NONE:
     436        paramsMinUse = NULL;
     437        paramsMaxUse = NULL;
     438      case PM_MODEL_LIMITS_LAX:
     439        paramsMinUse = paramsMinLax;
     440        paramsMaxUse = paramsMaxLax;
     441        break;
     442      case PM_MODEL_LIMITS_STRICT:
     443        paramsMinUse = paramsMinStrict;
     444        paramsMaxUse = paramsMaxStrict;
     445        break;
     446      default:
     447        psAbort("Unrecognised model limits type: %x", type);
     448    }
     449    return;
     450}
     451
     452
    470453# undef PM_MODEL_FUNC
    471454# undef PM_MODEL_FLUX
    … …  
    476459# undef PM_MODEL_PARAMS_FROM_PSF
    477460# undef PM_MODEL_FIT_STATUS
     461# undef PM_MODEL_SET_LIMITS
    478462# undef ALPHA
    479463# undef ALPHA_M

  • branches/pap/psModules/src/objects/models/pmModel_QGAUSS.c

    r20001 r25521  
    2020   *****************************************************************************/
    2121
     22#include <stdio.h>
     23#include <pslib.h>
     24
     25#include "pmMoments.h"
     26#include "pmPeaks.h"
     27#include "pmSource.h"
     28#include "pmModel.h"
     29#include "pmModel_QGAUSS.h"
     30
    2231# define PM_MODEL_FUNC            pmModelFunc_QGAUSS
    2332# define PM_MODEL_FLUX            pmModelFlux_QGAUSS
    … …  
    2837# define PM_MODEL_PARAMS_FROM_PSF pmModelParamsFromPSF_QGAUSS
    2938# define PM_MODEL_FIT_STATUS      pmModelFitStatus_QGAUSS
     39# define PM_MODEL_SET_LIMITS      pmModelSetLimits_QGAUSS
     40
     41// Lax parameter limits
     42static float paramsMinLax[] = { -1.0e3, 1.0e-2, -100, -100, 0.5, 0.5, -1.0, 0.1 };
     43static float paramsMaxLax[] = { 1.0e5, 1.0e8, 1.0e4, 1.0e4, 100, 100, 1.0, 20.0 };
     44
     45// Strict parameter limits
     46static float *paramsMinStrict = paramsMinLax;
     47static float *paramsMaxStrict = paramsMaxLax;
     48
     49// Parameter limits to use
     50static float *paramsMinUse = NULL;
     51static float *paramsMaxUse = NULL;
     52static float betaUse[] = { 1000, 3e6, 5, 5, 1.0, 1.0, 0.5 };
    3053
    3154psF32 PM_MODEL_FUNC (psVector *deriv,
    … …  
    79102# define AR_MAX 20.0
    80103# define AR_RATIO 0.99
     104
    81105bool PM_MODEL_LIMITS (psMinConstraintMode mode, int nParam, float *params, float *beta)
    82106{
    83     float beta_lim = 0, params_min = 0, params_max = 0;
    84     float f1 = 0, f2 = 0, q1 = 0, q2 = 0;
     107    psAssert(nParam >= 0 && nParam <= PM_PAR_7, "Parameter index is out of bounds");
    85108
    86109    // we need to calculate the limits for SXY specially
     110    float q2 = NAN;
    87111    if (nParam == PM_PAR_SXY) {
    88         f1 = 1.0 / PS_SQR(params[PM_PAR_SYY]) + 1.0 / PS_SQR(params[PM_PAR_SXX]);
    89         f2 = 1.0 / PS_SQR(params[PM_PAR_SYY]) - 1.0 / PS_SQR(params[PM_PAR_SXX]);
    90         q1 = PS_SQR(f1)*AR_RATIO - PS_SQR(f2);
     112        float f1 = 1.0 / PS_SQR(params[PM_PAR_SYY]) + 1.0 / PS_SQR(params[PM_PAR_SXX]);
     113        float f2 = 1.0 / PS_SQR(params[PM_PAR_SYY]) - 1.0 / PS_SQR(params[PM_PAR_SXX]);
     114        float q1 = PS_SQR(f1)*AR_RATIO - PS_SQR(f2);
    91115        q1 = (q1 < 0.0) ? 0.0 : q1;
    92116        // if q1 < 0.0, f2 ~ f1, we have a very large axis ratio near 45deg..  Saturate at that
    93117        // angle and let f2,f1 fight it out
    94         q2  = 0.5*sqrt (q1);
     118        q2 = 0.5*sqrtf(q1);
    95119    }
    96120
    97121    switch (mode) {
    98     case PS_MINIMIZE_BETA_LIMIT:
    99         switch (nParam) {
    100         case PM_PAR_SKY:
    101             beta_lim = 1000;
    102             break;
    103         case PM_PAR_I0:
    104             beta_lim = 3e6;
    105             break;
    106         case PM_PAR_XPOS:
    107             beta_lim = 5;
    108             break;
    109         case PM_PAR_YPOS:
    110             beta_lim = 5;
    111             break;
    112         case PM_PAR_SXX:
    113             beta_lim = 1.0;
    114             break;
    115         case PM_PAR_SYY:
    116             beta_lim = 1.0;
    117             break;
    118         case PM_PAR_SXY:
    119             beta_lim =  0.5*q2;
    120             break;
    121         case PM_PAR_7:
    122             beta_lim = 2.0;
    123             break;
    124         default:
    125             psAbort("invalid parameter %d for beta test", nParam);
    126         }
    127         if (fabs(beta[nParam]) > fabs(beta_lim)) {
    128             beta[nParam] = (beta[nParam] > 0) ? fabs(beta_lim) : -fabs(beta_lim);
    129             psTrace ("psModules.objects", 5, "|beta[nParam==%d]| > |beta_lim|; %g v. %g",
    130                      nParam, beta[nParam], beta_lim);
    131             return false;
    132         }
    133         return true;
    134     case PS_MINIMIZE_PARAM_MIN:
    135         switch (nParam) {
    136         case PM_PAR_SKY:
    137             params_min = -1000;
    138             break;
    139         case PM_PAR_I0:
    140             params_min =   0.01;
    141             break;
    142         case PM_PAR_XPOS:
    143             params_min =  -100;
    144             break;
    145         case PM_PAR_YPOS:
    146             params_min =  -100;
    147             break;
    148         case PM_PAR_SXX:
    149             params_min =   0.5;
    150             break;
    151         case PM_PAR_SYY:
    152             params_min =   0.5;
    153             break;
    154         case PM_PAR_SXY:
    155             params_min =  -q2;
    156             break;
    157         case PM_PAR_7:
    158             params_min =   0.1;
    159             break;
    160         default:
    161             psAbort("invalid parameter %d for param min test", nParam);
    162         }
    163         if (params[nParam] < params_min) {
    164             params[nParam] = params_min;
    165             psTrace ("psModules.objects", 5, "params[nParam==%d] < params_min; %g v. %g",
    166                      nParam, params[nParam], params_min);
    167             return false;
    168         }
    169         return true;
    170     case PS_MINIMIZE_PARAM_MAX:
    171         switch (nParam) {
    172         case PM_PAR_SKY:
    173             params_max =   1e5;
    174             break;
    175         case PM_PAR_I0:
    176             params_max =   1e8;
    177             break;
    178         case PM_PAR_XPOS:
    179             params_max =   1e4;
    180             break;
    181         case PM_PAR_YPOS:
    182             params_max =   1e4;
    183             break;
    184         case PM_PAR_SXX:
    185             params_max =   100;
    186             break;
    187         case PM_PAR_SYY:
    188             params_max =   100;
    189             break;
    190         case PM_PAR_SXY:
    191             params_max =  +q2;
    192             break;
    193         case PM_PAR_7:
    194             params_max =  20.0;
    195             break;
    196         default:
    197             psAbort("invalid parameter %d for param max test", nParam);
    198         }
    199         if (params[nParam] > params_max) {
    200             params[nParam] = params_max;
    201             psTrace ("psModules.objects", 5, "params[nParam==%d] > params_max; %g v. %g",
    202                      nParam, params[nParam], params_max);
    203             return false;
    204         }
    205         return true;
     122      case PS_MINIMIZE_BETA_LIMIT: {
     123          psAssert(beta, "Require beta to limit beta");
     124          float limit = betaUse[nParam];
     125          if (nParam == PM_PAR_SXY) {
     126              limit *= q2;
     127          }
     128          if (fabs(beta[nParam]) > fabs(limit)) {
     129              beta[nParam] = (beta[nParam] > 0) ? fabs(limit) : -fabs(limit);
     130              psTrace("psModules.objects", 5, "|beta[nParam==%d]| > |beta_lim|; %g v. %g",
     131                      nParam, beta[nParam], limit);
     132              return false;
     133          }
     134          return true;
     135      }
     136      case PS_MINIMIZE_PARAM_MIN: {
     137          psAssert(params, "Require parameters to limit parameters");
     138          psAssert(paramsMinUse, "Require parameter limits to limit parameters");
     139          float limit = paramsMinUse[nParam];
     140          if (nParam == PM_PAR_SXY) {
     141              limit *= q2;
     142          }
     143          if (params[nParam] < limit) {
     144              params[nParam] = limit;
     145              psTrace("psModules.objects", 5, "params[nParam==%d] < params_min; %g v. %g",
     146                      nParam, params[nParam], limit);
     147              return false;
     148          }
     149          return true;
     150      }
     151      case PS_MINIMIZE_PARAM_MAX: {
     152          psAssert(params, "Require parameters to limit parameters");
     153          psAssert(paramsMaxUse, "Require parameter limits to limit parameters");
     154          float limit = paramsMaxUse[nParam];
     155          if (nParam == PM_PAR_SXY) {
     156              limit *= q2;
     157          }
     158          if (params[nParam] > limit) {
     159              params[nParam] = limit;
     160              psTrace("psModules.objects", 5, "params[nParam==%d] > params_max; %g v. %g",
     161                      nParam, params[nParam], limit);
     162              return false;
     163          }
     164          return true;
     165      }
    206166    default:
    207167        psAbort("invalid choice for limits");
    … …  
    464424}
    465425
     426void PM_MODEL_SET_LIMITS(pmModelLimitsType type)
     427{
     428    switch (type) {
     429      case PM_MODEL_LIMITS_NONE:
     430        paramsMinUse = NULL;
     431        paramsMaxUse = NULL;
     432      case PM_MODEL_LIMITS_LAX:
     433        paramsMinUse = paramsMinLax;
     434        paramsMaxUse = paramsMaxLax;
     435        break;
     436      case PM_MODEL_LIMITS_STRICT:
     437        paramsMinUse = paramsMinStrict;
     438        paramsMaxUse = paramsMaxStrict;
     439        break;
     440      default:
     441        psAbort("Unrecognised model limits type: %x", type);
     442    }
     443    return;
     444}
     445
    466446# undef PM_MODEL_FUNC
    467447# undef PM_MODEL_FLUX
    … …  
    472452# undef PM_MODEL_PARAMS_FROM_PSF
    473453# undef PM_MODEL_FIT_STATUS
     454# undef PM_MODEL_SET_LIMITS

  • branches/pap/psModules/src/objects/models/pmModel_RGAUSS.c

    r20001 r25521  
    2020 *****************************************************************************/
    2121
     22#include <stdio.h>
     23#include <pslib.h>
     24
     25#include "pmMoments.h"
     26#include "pmPeaks.h"
     27#include "pmSource.h"
     28#include "pmModel.h"
     29#include "pmModel_RGAUSS.h"
     30
    2231# define PM_MODEL_FUNC            pmModelFunc_RGAUSS
    2332# define PM_MODEL_FLUX            pmModelFlux_RGAUSS
    … …  
    2837# define PM_MODEL_PARAMS_FROM_PSF pmModelParamsFromPSF_RGAUSS
    2938# define PM_MODEL_FIT_STATUS      pmModelFitStatus_RGAUSS
     39# define PM_MODEL_SET_LIMITS      pmModelSetLimits_RGAUSS
     40
     41// Lax parameter limits
     42static float paramsMinLax[] = { -1.0e3, 1.0e-2, -100, -100, 0.5, 0.5, -1.0, 1.25 };
     43static float paramsMaxLax[] = { 1.0e5, 1.0e8, 1.0e4, 1.0e4, 100, 100, 1.0, 4.0 };
     44
     45// Strict parameter limits
     46static float *paramsMinStrict = paramsMinLax;
     47static float *paramsMaxStrict = paramsMaxLax;
     48
     49// Parameter limits to use
     50static float *paramsMinUse = NULL;
     51static float *paramsMaxUse = NULL;
     52static float betaUse[] = { 1000, 3e6, 5, 5, 0.5, 0.5, 0.5, 0.5 };
    3053
    3154psF32 PM_MODEL_FUNC (psVector *deriv,
    … …  
    7396# define AR_MAX 20.0
    7497# define AR_RATIO 0.99
     98
    7599bool PM_MODEL_LIMITS (psMinConstraintMode mode, int nParam, float *params, float *beta)
    76100{
    77     float beta_lim = 0, params_min = 0, params_max = 0;
    78     float f1 = 0, f2 = 0, q1 = 0, q2 = 0;
     101    psAssert(nParam >= 0 && nParam <= PM_PAR_7, "Parameter index is out of bounds");
    79102
    80103    // we need to calculate the limits for SXY specially
     104    float q2 = NAN;
    81105    if (nParam == PM_PAR_SXY) {
    82         f1 = 1.0 / PS_SQR(params[PM_PAR_SYY]) + 1.0 / PS_SQR(params[PM_PAR_SXX]);
    83         f2 = 1.0 / PS_SQR(params[PM_PAR_SYY]) - 1.0 / PS_SQR(params[PM_PAR_SXX]);
    84         q1 = PS_SQR(f1)*AR_RATIO - PS_SQR(f2);
     106        float f1 = 1.0 / PS_SQR(params[PM_PAR_SYY]) + 1.0 / PS_SQR(params[PM_PAR_SXX]);
     107        float f2 = 1.0 / PS_SQR(params[PM_PAR_SYY]) - 1.0 / PS_SQR(params[PM_PAR_SXX]);
     108        float q1 = PS_SQR(f1)*AR_RATIO - PS_SQR(f2);
    85109        q1 = (q1 < 0.0) ? 0.0 : q1;
    86110        // if q1 < 0.0, f2 ~ f1, we have a very large axis ratio near 45deg..  Saturate at that
    87111        // angle and let f2,f1 fight it out
    88         q2  = 0.5*sqrt (q1);
     112        q2 = 0.5*sqrtf(q1);
    89113    }
    90114
    91115    switch (mode) {
    92     case PS_MINIMIZE_BETA_LIMIT:
    93         switch (nParam) {
    94         case PM_PAR_SKY:
    95             beta_lim = 1000;
    96             break;
    97         case PM_PAR_I0:
    98             beta_lim = 3e6;
    99             break;
    100         case PM_PAR_XPOS:
    101             beta_lim = 5;
    102             break;
    103         case PM_PAR_YPOS:
    104             beta_lim = 5;
    105             break;
    106         case PM_PAR_SXX:
    107             beta_lim = 0.5;
    108             break;
    109         case PM_PAR_SYY:
    110             beta_lim = 0.5;
    111             break;
    112         case PM_PAR_SXY:
    113             beta_lim =  0.5*q2;
    114             break;
    115         case PM_PAR_7:
    116             beta_lim = 0.5;
    117             break;
    118         default:
    119             psAbort("invalid parameter %d for beta test", nParam);
    120         }
    121         if (fabs(beta[nParam]) > fabs(beta_lim)) {
    122             beta[nParam] = (beta[nParam] > 0) ? fabs(beta_lim) : -fabs(beta_lim);
    123             psTrace ("psModules.objects", 5, "|beta[nParam==%d]| > |beta_lim|; %g v. %g",
    124                      nParam, beta[nParam], beta_lim);
    125             return false;
    126         }
    127         return true;
    128     case PS_MINIMIZE_PARAM_MIN:
    129         switch (nParam) {
    130         case PM_PAR_SKY:
    131             params_min = -1000;
    132             break;
    133         case PM_PAR_I0:
    134             params_min =   0.01;
    135             break;
    136         case PM_PAR_XPOS:
    137             params_min =  -100;
    138             break;
    139         case PM_PAR_YPOS:
    140             params_min =  -100;
    141             break;
    142         case PM_PAR_SXX:
    143             params_min =   0.5;
    144             break;
    145         case PM_PAR_SYY:
    146             params_min =   0.5;
    147             break;
    148         case PM_PAR_SXY:
    149             params_min =  -q2;
    150             break;
    151         case PM_PAR_7:
    152             params_min =   1.25;
    153             break;
    154         default:
    155             psAbort("invalid parameter %d for param min test", nParam);
    156         }
    157         if (params[nParam] < params_min) {
    158             params[nParam] = params_min;
    159             psTrace ("psModules.objects", 5, "params[nParam==%d] < params_min; %g v. %g",
    160                      nParam, params[nParam], params_min);
    161             return false;
    162         }
    163         return true;
    164     case PS_MINIMIZE_PARAM_MAX:
    165         switch (nParam) {
    166         case PM_PAR_SKY:
    167             params_max =   1e5;
    168             break;
    169         case PM_PAR_I0:
    170             params_max =   1e8;
    171             break;
    172         case PM_PAR_XPOS:
    173             params_max =   1e4;
    174             break;
    175         case PM_PAR_YPOS:
    176             params_max =   1e4;
    177             break;
    178         case PM_PAR_SXX:
    179             params_max =   100;
    180             break;
    181         case PM_PAR_SYY:
    182             params_max =   100;
    183             break;
    184         case PM_PAR_SXY:
    185             params_max =  +q2;
    186             break;
    187         case PM_PAR_7:
    188             params_max =  4.0;
    189             break;
    190         default:
    191             psAbort("invalid parameter %d for param max test", nParam);
    192         }
    193         if (params[nParam] > params_max) {
    194             params[nParam] = params_max;
    195             psTrace ("psModules.objects", 5, "params[nParam==%d] > params_max; %g v. %g",
    196                      nParam, params[nParam], params_max);
    197             return false;
    198         }
    199         return true;
    200     default:
     116      case PS_MINIMIZE_BETA_LIMIT: {
     117          psAssert(beta, "Require beta to limit beta");
     118          float limit = betaUse[nParam];
     119          if (nParam == PM_PAR_SXY) {
     120              limit *= q2;
     121          }
     122          if (fabs(beta[nParam]) > fabs(limit)) {
     123              beta[nParam] = (beta[nParam] > 0) ? fabs(limit) : -fabs(limit);
     124              psTrace("psModules.objects", 5, "|beta[nParam==%d]| > |beta_lim|; %g v. %g",
     125                      nParam, beta[nParam], limit);
     126              return false;
     127          }
     128          return true;
     129      }
     130      case PS_MINIMIZE_PARAM_MIN: {
     131          psAssert(params, "Require parameters to limit parameters");
     132          psAssert(paramsMinUse, "Require parameter limits to limit parameters");
     133          float limit = paramsMinUse[nParam];
     134          if (nParam == PM_PAR_SXY) {
     135              limit *= q2;
     136          }
     137          if (params[nParam] < limit) {
     138              params[nParam] = limit;
     139              psTrace("psModules.objects", 5, "params[nParam==%d] < params_min; %g v. %g",
     140                      nParam, params[nParam], limit);
     141              return false;
     142          }
     143          return true;
     144      }
     145      case PS_MINIMIZE_PARAM_MAX: {
     146          psAssert(params, "Require parameters to limit parameters");
     147          psAssert(paramsMaxUse, "Require parameter limits to limit parameters");
     148          float limit = paramsMaxUse[nParam];
     149          if (nParam == PM_PAR_SXY) {
     150              limit *= q2;
     151          }
     152          if (params[nParam] > limit) {
     153              params[nParam] = limit;
     154              psTrace("psModules.objects", 5, "params[nParam==%d] > params_max; %g v. %g",
     155                      nParam, params[nParam], limit);
     156              return false;
     157          }
     158          return true;
     159      }
     160      default:
    201161        psAbort("invalid choice for limits");
    202162    }
    … …  
    204164    return false;
    205165}
     166
    206167
    207168// make an initial guess for parameters
    … …  
    456417}
    457418
     419void PM_MODEL_SET_LIMITS(pmModelLimitsType type)
     420{
     421    switch (type) {
     422      case PM_MODEL_LIMITS_NONE:
     423        paramsMinUse = NULL;
     424        paramsMaxUse = NULL;
     425      case PM_MODEL_LIMITS_LAX:
     426        paramsMinUse = paramsMinLax;
     427        paramsMaxUse = paramsMaxLax;
     428        break;
     429      case PM_MODEL_LIMITS_STRICT:
     430        paramsMinUse = paramsMinStrict;
     431        paramsMaxUse = paramsMaxStrict;
     432        break;
     433      default:
     434        psAbort("Unrecognised model limits type: %x", type);
     435    }
     436    return;
     437}
     438
    458439# undef PM_MODEL_FUNC
    459440# undef PM_MODEL_FLUX
    … …  
    464445# undef PM_MODEL_PARAMS_FROM_PSF
    465446# undef PM_MODEL_FIT_STATUS
     447# undef PM_MODEL_SET_LIMITS

  • branches/pap/psModules/src/objects/models/pmModel_SERSIC.c

    r20001 r25521  
    2323   *****************************************************************************/
    2424
     25#include <stdio.h>
     26#include <pslib.h>
     27
     28#include "pmMoments.h"
     29#include "pmPeaks.h"
     30#include "pmSource.h"
     31#include "pmModel.h"
     32#include "pmModel_SERSIC.h"
     33
    2534# define PM_MODEL_FUNC            pmModelFunc_SERSIC
    2635# define PM_MODEL_FLUX            pmModelFlux_SERSIC
    … …  
    3140# define PM_MODEL_PARAMS_FROM_PSF pmModelParamsFromPSF_SERSIC
    3241# define PM_MODEL_FIT_STATUS      pmModelFitStatus_SERSIC
     42# define PM_MODEL_SET_LIMITS      pmModelSetLimits_SERSIC
     43
     44// Lax parameter limits
     45static float paramsMinLax[] = { -1.0e3, 1.0e-2, -100, -100, 0.05, 0.05, -1.0, 0.05 };
     46static float paramsMaxLax[] = { 1.0e5, 1.0e8, 1.0e4, 1.0e4, 100, 100, 1.0, 4.0 };
     47
     48// Strict parameter limits
     49static float *paramsMinStrict = paramsMinLax;
     50static float *paramsMaxStrict = paramsMaxLax;
     51
     52// Parameter limits to use
     53static float *paramsMinUse = NULL;
     54static float *paramsMaxUse = NULL;
     55static float betaUse[] = { 1000, 3e6, 5, 5, 1.0, 1.0, 0.5, 2.0 };
    3356
    3457psF32 PM_MODEL_FUNC (psVector *deriv,
    … …  
    91114bool PM_MODEL_LIMITS (psMinConstraintMode mode, int nParam, float *params, float *beta)
    92115{
    93     float beta_lim = 0, params_min = 0, params_max = 0;
    94     float f1 = 0, f2 = 0, q1 = 0, q2 = 0;
     116    psAssert(nParam >= 0 && nParam <= PM_PAR_7, "Parameter index is out of bounds");
    95117
    96118    // we need to calculate the limits for SXY specially
     119    float q2 = NAN;
    97120    if (nParam == PM_PAR_SXY) {
    98         f1 = 1.0 / PS_SQR(params[PM_PAR_SYY]) + 1.0 / PS_SQR(params[PM_PAR_SXX]);
    99         f2 = 1.0 / PS_SQR(params[PM_PAR_SYY]) - 1.0 / PS_SQR(params[PM_PAR_SXX]);
    100         q1 = PS_SQR(f1)*AR_RATIO - PS_SQR(f2);
     121        float f1 = 1.0 / PS_SQR(params[PM_PAR_SYY]) + 1.0 / PS_SQR(params[PM_PAR_SXX]);
     122        float f2 = 1.0 / PS_SQR(params[PM_PAR_SYY]) - 1.0 / PS_SQR(params[PM_PAR_SXX]);
     123        float q1 = PS_SQR(f1)*AR_RATIO - PS_SQR(f2);
    101124        q1 = (q1 < 0.0) ? 0.0 : q1;
    102125        // if q1 < 0.0, f2 ~ f1, we have a very large axis ratio near 45deg..  Saturate at that
    103126        // angle and let f2,f1 fight it out
    104         q2  = 0.5*sqrt (q1);
     127        q2 = 0.5*sqrtf(q1);
    105128    }
    106129
    107130    switch (mode) {
    108     case PS_MINIMIZE_BETA_LIMIT:
    109         switch (nParam) {
    110         case PM_PAR_SKY:
    111             beta_lim = 1000;
    112             break;
    113         case PM_PAR_I0:
    114             beta_lim = 3e6;
    115             break;
    116         case PM_PAR_XPOS:
    117             beta_lim = 5;
    118             break;
    119         case PM_PAR_YPOS:
    120             beta_lim = 5;
    121             break;
    122         case PM_PAR_SXX:
    123             beta_lim = 1.0;
    124             break;
    125         case PM_PAR_SYY:
    126             beta_lim = 1.0;
    127             break;
    128         case PM_PAR_SXY:
    129             beta_lim =  0.5*q2;
    130             break;
    131         case PM_PAR_7:
    132             beta_lim = 2.0;
    133             break;
    134         default:
    135             psAbort("invalid parameter %d for beta test", nParam);
    136         }
    137         if (fabs(beta[nParam]) > fabs(beta_lim)) {
    138             beta[nParam] = (beta[nParam] > 0) ? fabs(beta_lim) : -fabs(beta_lim);
    139             psTrace ("psModules.objects", 5, "|beta[nParam==%d]| > |beta_lim|; %g v. %g",
    140                      nParam, beta[nParam], beta_lim);
    141             return false;
    142         }
    143         return true;
    144     case PS_MINIMIZE_PARAM_MIN:
    145         switch (nParam) {
    146         case PM_PAR_SKY:
    147             params_min = -1000;
    148             break;
    149         case PM_PAR_I0:
    150             params_min =     0.01;
    151             break;
    152         case PM_PAR_XPOS:
    153             params_min =  -100;
    154             break;
    155         case PM_PAR_YPOS:
    156             params_min =  -100;
    157             break;
    158         case PM_PAR_SXX:
    159             params_min =   0.05;
    160             break;
    161         case PM_PAR_SYY:
    162             params_min =   0.05;
    163             break;
    164         case PM_PAR_SXY:
    165             params_min =  -q2;
    166             break;
    167         case PM_PAR_7:
    168             params_min =   0.05;
    169             break;
    170         default:
    171             psAbort("invalid parameter %d for param min test", nParam);
    172         }
    173         if (params[nParam] < params_min) {
    174             params[nParam] = params_min;
    175             psTrace ("psModules.objects", 5, "params[nParam==%d] < params_min; %g v. %g",
    176                      nParam, params[nParam], params_min);
    177             return false;
    178         }
    179         return true;
    180     case PS_MINIMIZE_PARAM_MAX:
    181         switch (nParam) {
    182         case PM_PAR_SKY:
    183             params_max =   1e5;
    184             break;
    185         case PM_PAR_I0:
    186             params_max =   1e8;
    187             break;
    188         case PM_PAR_XPOS:
    189             params_max =   1e4;
    190             break;
    191         case PM_PAR_YPOS:
    192             params_max =   1e4;
    193             break;
    194         case PM_PAR_SXX:
    195             params_max =   100;
    196             break;
    197         case PM_PAR_SYY:
    198             params_max =   100;
    199             break;
    200         case PM_PAR_SXY:
    201             params_max =  +q2;
    202             break;
    203         case PM_PAR_7:
    204             params_max =   4.0;
    205             break;
    206         default:
    207             psAbort("invalid parameter %d for param max test", nParam);
    208         }
    209         if (params[nParam] > params_max) {
    210             params[nParam] = params_max;
    211             psTrace ("psModules.objects", 5, "params[nParam==%d] > params_max; %g v. %g",
    212                      nParam, params[nParam], params_max);
    213             return false;
    214         }
    215         return true;
    216     default:
     131      case PS_MINIMIZE_BETA_LIMIT: {
     132          psAssert(beta, "Require beta to limit beta");
     133          float limit = betaUse[nParam];
     134          if (nParam == PM_PAR_SXY) {
     135              limit *= q2;
     136          }
     137          if (fabs(beta[nParam]) > fabs(limit)) {
     138              beta[nParam] = (beta[nParam] > 0) ? fabs(limit) : -fabs(limit);
     139              psTrace("psModules.objects", 5, "|beta[nParam==%d]| > |beta_lim|; %g v. %g",
     140                      nParam, beta[nParam], limit);
     141              return false;
     142          }
     143          return true;
     144      }
     145      case PS_MINIMIZE_PARAM_MIN: {
     146          psAssert(params, "Require parameters to limit parameters");
     147          psAssert(paramsMinUse, "Require parameter limits to limit parameters");
     148          float limit = paramsMinUse[nParam];
     149          if (nParam == PM_PAR_SXY) {
     150              limit *= q2;
     151          }
     152          if (params[nParam] < limit) {
     153              params[nParam] = limit;
     154              psTrace("psModules.objects", 5, "params[nParam==%d] < params_min; %g v. %g",
     155                      nParam, params[nParam], limit);
     156              return false;
     157          }
     158          return true;
     159      }
     160      case PS_MINIMIZE_PARAM_MAX: {
     161          psAssert(params, "Require parameters to limit parameters");
     162          psAssert(paramsMaxUse, "Require parameter limits to limit parameters");
     163          float limit = paramsMaxUse[nParam];
     164          if (nParam == PM_PAR_SXY) {
     165              limit *= q2;
     166          }
     167          if (params[nParam] > limit) {
     168              params[nParam] = limit;
     169              psTrace("psModules.objects", 5, "params[nParam==%d] > params_max; %g v. %g",
     170                      nParam, params[nParam], limit);
     171              return false;
     172          }
     173          return true;
     174      }
     175      default:
    217176        psAbort("invalid choice for limits");
    218177    }
    … …  
    220179    return false;
    221180}
    222 
    223181
    224182// make an initial guess for parameters
    … …  
    447405
    448406    fprintf (stderr, "SERSIC status pars: dP: %f, I0: %f, S/N: %f\n",
    449              dP, PAR[PM_PAR_I0], (dPAR[PM_PAR_I0]/PAR[PM_PAR_I0]));
     407             dP, PAR[PM_PAR_I0], (dPAR[PM_PAR_I0]/PAR[PM_PAR_I0]));
    450408
    451409    return status;
     410}
     411
     412void PM_MODEL_SET_LIMITS(pmModelLimitsType type)
     413{
     414    switch (type) {
     415      case PM_MODEL_LIMITS_NONE:
     416        paramsMinUse = NULL;
     417        paramsMaxUse = NULL;
     418      case PM_MODEL_LIMITS_LAX:
     419        paramsMinUse = paramsMinLax;
     420        paramsMaxUse = paramsMaxLax;
     421        break;
     422      case PM_MODEL_LIMITS_STRICT:
     423        paramsMinUse = paramsMinStrict;
     424        paramsMaxUse = paramsMaxStrict;
     425        break;
     426      default:
     427        psAbort("Unrecognised model limits type: %x", type);
     428    }
     429    return;
    452430}
    453431
    … …  
    460438# undef PM_MODEL_PARAMS_FROM_PSF
    461439# undef PM_MODEL_FIT_STATUS
     440# undef PM_MODEL_SET_LIMITS

  • branches/pap/psModules/src/objects/pmModel.c

    r23187 r25521  
    8686    tmp->modelParamsFromPSF = class->modelParamsFromPSF;
    8787    tmp->modelFitStatus     = class->modelFitStatus;
     88    tmp->modelSetLimits     = class->modelSetLimits;
    8889
    8990    psTrace("psModules.objects", 10, "---- %s() end ----\n", __func__);
    … …  
    235236
    236237    if (model->residuals) {
    237         DX = xBin*(image->col0 - xCenter - dx) + model->residuals->xCenter + 0.5;
    238         DY = yBin*(image->row0 - yCenter - dy) + model->residuals->yCenter + 0.5;
    239         Ro = (model->residuals->Ro)   ? model->residuals->Ro->data.F32 : NULL;
    240         Rx = (model->residuals->Rx)   ? model->residuals->Rx->data.F32 : NULL;
    241         Ry = (model->residuals->Ry)   ? model->residuals->Ry->data.F32 : NULL;
    242         Rm = (model->residuals->mask) ? model->residuals->mask->data.PS_TYPE_IMAGE_MASK_DATA : NULL;
    243         if (Ro) {
    244             NX = model->residuals->Ro->numCols;
    245             NY = model->residuals->Ro->numRows;
    246         }           
     238        DX = xBin*(image->col0 - xCenter - dx) + model->residuals->xCenter + 0.5;
     239        DY = yBin*(image->row0 - yCenter - dy) + model->residuals->yCenter + 0.5;
     240        Ro = (model->residuals->Ro)   ? model->residuals->Ro->data.F32 : NULL;
     241        Rx = (model->residuals->Rx)   ? model->residuals->Rx->data.F32 : NULL;
     242        Ry = (model->residuals->Ry)   ? model->residuals->Ry->data.F32 : NULL;
     243        Rm = (model->residuals->mask) ? model->residuals->mask->data.PS_TYPE_IMAGE_MASK_DATA : NULL;
     244        if (Ro) {
     245            NX = model->residuals->Ro->numCols;
     246            NY = model->residuals->Ro->numRows;
     247        }
    247248    }
    248249
    … …  
    256257
    257258            // XXX should we use using 0.5 pixel offset?
    258             // Convert to coordinate in parent image, with offset (dx,dy)
     259            // Convert to coordinate in parent image, with offset (dx,dy)
    259260            imageCol = ix + image->col0 - dx;
    260261            imageRow = iy + image->row0 - dy;
    … …  
    276277                float rx = xBin*ix + DX;
    277278
    278                 int rx0 = rx - 0.5;
    279                 int rx1 = rx + 0.5;
    280                 int ry0 = ry - 0.5;
    281                 int ry1 = ry + 0.5;
    282 
    283                 if (rx0 < 0) goto skip;
    284                 if (ry0 < 0) goto skip;
    285                 if (rx1 >= NX) goto skip;
    286                 if (ry1 >= NY) goto skip;
    287 
    288                 // these go from 0.0 to 1.0 between the centers of the pixels
    289                 float fx = rx - 0.5 - rx0;
    290                 float Fx = 1.0 - fx;
    291                 float fy = ry - 0.5 - ry0;
    292                 float Fy = 1.0 - fy;
    293 
    294                 // check the residual image mask (if set). give up if any of the 4 pixels are masked.
    295                 if (Rm) {
    296                     if (Rm[ry0][rx0]) goto skip;
    297                     if (Rm[ry0][rx1]) goto skip;
    298                     if (Rm[ry1][rx0]) goto skip;
    299                     if (Rm[ry1][rx1]) goto skip;
    300                 }
    301 
    302                 // a possible further optimization if we re-use these values
    303                 // XXX allow for masked pixels, and add pixel weights
    304                 float V0 = (Ro[ry0][rx0]*Fx + Ro[ry0][rx1]*fx);
    305                 float V1 = (Ro[ry1][rx0]*Fx + Ro[ry1][rx1]*fx);
    306                 float Vo = V0*Fy + V1*fy;
    307                 if (!isfinite(Vo)) goto skip;
    308 
    309                 float Vx = 0.0;
    310                 float Vy = 0.0;
    311 
    312                 // skip Rx,Ry if Ro is masked
    313                 if (Rx && Ry && (mode & PM_MODEL_OP_RES1)) {
    314                     V0 = (Rx[ry0][rx0]*Fx + Rx[ry0][rx1]*fx);
    315                     V1 = (Rx[ry1][rx0]*Fx + Rx[ry1][rx1]*fx);
    316                     Vx = V0*Fy + V1*fy;
    317 
    318                     V0 = (Ry[ry0][rx0]*Fx + Ry[ry0][rx1]*fx);
    319                     V1 = (Ry[ry1][rx0]*Fx + Ry[ry1][rx1]*fx);
    320                     Vy = V0*Fy + V1*fy;
    321                 }
    322                 if (!isfinite(Vx)) goto skip;
    323                 if (!isfinite(Vy)) goto skip;
    324 
    325                 // 2D residual variations are set for the true source position
    326                 pixelValue += Io*(Vo + XoSave*Vx + XoSave*Vy);
     279                int rx0 = rx - 0.5;
     280                int rx1 = rx + 0.5;
     281                int ry0 = ry - 0.5;
     282                int ry1 = ry + 0.5;
     283
     284                if (rx0 < 0) goto skip;
     285                if (ry0 < 0) goto skip;
     286                if (rx1 >= NX) goto skip;
     287                if (ry1 >= NY) goto skip;
     288
     289                // these go from 0.0 to 1.0 between the centers of the pixels
     290                float fx = rx - 0.5 - rx0;
     291                float Fx = 1.0 - fx;
     292                float fy = ry - 0.5 - ry0;
     293                float Fy = 1.0 - fy;
     294
     295                // check the residual image mask (if set). give up if any of the 4 pixels are masked.
     296                if (Rm) {
     297                    if (Rm[ry0][rx0]) goto skip;
     298                    if (Rm[ry0][rx1]) goto skip;
     299                    if (Rm[ry1][rx0]) goto skip;
     300                    if (Rm[ry1][rx1]) goto skip;
     301                }
     302
     303                // a possible further optimization if we re-use these values
     304                // XXX allow for masked pixels, and add pixel weights
     305                float V0 = (Ro[ry0][rx0]*Fx + Ro[ry0][rx1]*fx);
     306                float V1 = (Ro[ry1][rx0]*Fx + Ro[ry1][rx1]*fx);
     307                float Vo = V0*Fy + V1*fy;
     308                if (!isfinite(Vo)) goto skip;
     309
     310                float Vx = 0.0;
     311                float Vy = 0.0;
     312
     313                // skip Rx,Ry if Ro is masked
     314                if (Rx && Ry && (mode & PM_MODEL_OP_RES1)) {
     315                    V0 = (Rx[ry0][rx0]*Fx + Rx[ry0][rx1]*fx);
     316                    V1 = (Rx[ry1][rx0]*Fx + Rx[ry1][rx1]*fx);
     317                    Vx = V0*Fy + V1*fy;
     318
     319                    V0 = (Ry[ry0][rx0]*Fx + Ry[ry0][rx1]*fx);
     320                    V1 = (Ry[ry1][rx0]*Fx + Ry[ry1][rx1]*fx);
     321                    Vy = V0*Fy + V1*fy;
     322                }
     323                if (!isfinite(Vx)) goto skip;
     324                if (!isfinite(Vy)) goto skip;
     325
     326                // 2D residual variations are set for the true source position
     327                pixelValue += Io*(Vo + XoSave*Vx + XoSave*Vy);
    327328            }
    328329
    329         skip:
     330        skip:
    330331            // add or subtract the value
    331332            if (add) {

  • branches/pap/psModules/src/objects/pmModel.h

    r21516 r25521  
    4444} pmModelOpMode;
    4545
     46/// Parameter limit types
     47typedef enum {
     48    PM_MODEL_LIMITS_NONE,               ///< No limits: fit can go to town
     49    PM_MODEL_LIMITS_LAX,                ///< Lax limits: attempting to reproduce mildly bad data
     50    PM_MODEL_LIMITS_STRICT,             ///< Strict limits: good quality data
     51} pmModelLimitsType;
     52
    4653typedef struct pmModel pmModel;
    4754typedef struct pmSource pmSource;
    … …  
    7481//  This function returns the success / failure status of the given model fit
    7582typedef bool (*pmModelFitStatusFunc)(pmModel *model);
     83
     84//  This function sets the parameter limits for the given model
     85typedef bool (*pmModelSetLimitsFunc)(pmModelLimits type);
    7686
    7787/** pmModel data structure
    … …  
    108118    pmModelParamsFromPSF modelParamsFromPSF;
    109119    pmModelFitStatusFunc modelFitStatus;
     120    pmModelSetLimitsFunc modelSetLimits;
    110121};
    111122
    … …  
    151162    pmModel *model,                     ///< The input pmModel
    152163    pmModelOpMode mode,                 ///< mode to control how the model is added into the image
    153     psImageMaskType maskVal             ///< Value to mask
     164    psImageMaskType maskVal             ///< Value to mask
    154165);
    155166
    … …  
    169180    pmModel *model,                     ///< The input pmModel
    170181    pmModelOpMode mode,                 ///< mode to control how the model is added into the image
    171     psImageMaskType maskVal             ///< Value to mask
     182    psImageMaskType maskVal             ///< Value to mask
    172183);
    173184
    … …  
    202213);
    203214
     215
     216/// Set the model parameter limits for the given model
     217///
     218/// Wraps the model-specific pmModelSetLimitsFunc function.
     219bool pmModelSetLimits(
     220    const pmModel *model,               ///< Model of interest
     221    pmModelLimits type                  ///< Type of limits
     222    );
     223
     224
    204225/// @}
    205226# endif /* PM_MODEL_H */

  • branches/pap/psModules/src/objects/pmModelClass.c

    r20937 r25521  
    4040double sqrt (double x);
    4141
    42 # include "models/pmModel_GAUSS.c"
    43 # include "models/pmModel_PGAUSS.c"
    44 # include "models/pmModel_QGAUSS.c"
    45 # include "models/pmModel_PS1_V1.c"
    46 # include "models/pmModel_RGAUSS.c"
    47 # include "models/pmModel_SERSIC.c"
     42# include "models/pmModel_GAUSS.h"
     43# include "models/pmModel_PGAUSS.h"
     44# include "models/pmModel_QGAUSS.h"
     45# include "models/pmModel_PS1_V1.h"
     46# include "models/pmModel_RGAUSS.h"
     47# include "models/pmModel_SERSIC.h"
    4848
    4949static pmModelClass defaultModels[] = {
    50     {"PS_MODEL_GAUSS",        7, pmModelFunc_GAUSS,   pmModelFlux_GAUSS,   pmModelRadius_GAUSS,   pmModelLimits_GAUSS,   pmModelGuess_GAUSS,  pmModelFromPSF_GAUSS,  pmModelParamsFromPSF_GAUSS,  pmModelFitStatus_GAUSS},
    51     {"PS_MODEL_PGAUSS",       7, pmModelFunc_PGAUSS,  pmModelFlux_PGAUSS,  pmModelRadius_PGAUSS,  pmModelLimits_PGAUSS,  pmModelGuess_PGAUSS, pmModelFromPSF_PGAUSS, pmModelParamsFromPSF_PGAUSS, pmModelFitStatus_PGAUSS},
    52     {"PS_MODEL_QGAUSS",       8, pmModelFunc_QGAUSS,  pmModelFlux_QGAUSS,  pmModelRadius_QGAUSS,  pmModelLimits_QGAUSS,  pmModelGuess_QGAUSS, pmModelFromPSF_QGAUSS, pmModelParamsFromPSF_QGAUSS, pmModelFitStatus_QGAUSS},
    53     {"PS_MODEL_PS1_V1",       8, pmModelFunc_PS1_V1,  pmModelFlux_PS1_V1,  pmModelRadius_PS1_V1,  pmModelLimits_PS1_V1,  pmModelGuess_PS1_V1, pmModelFromPSF_PS1_V1, pmModelParamsFromPSF_PS1_V1, pmModelFitStatus_PS1_V1},
    54     {"PS_MODEL_RGAUSS",       8, pmModelFunc_RGAUSS,  pmModelFlux_RGAUSS,  pmModelRadius_RGAUSS,  pmModelLimits_RGAUSS,  pmModelGuess_RGAUSS, pmModelFromPSF_RGAUSS, pmModelParamsFromPSF_RGAUSS, pmModelFitStatus_RGAUSS},
    55     {"PS_MODEL_SERSIC",       8, pmModelFunc_SERSIC,  pmModelFlux_SERSIC,  pmModelRadius_SERSIC,  pmModelLimits_SERSIC,  pmModelGuess_SERSIC, pmModelFromPSF_SERSIC, pmModelParamsFromPSF_SERSIC, pmModelFitStatus_SERSIC}
     50    {"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  },
     51    {"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 },
     52    {"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 },
     53    {"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 },
     54    {"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 },
     55    {"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 }
    5656};
    5757

  • branches/pap/psModules/src/objects/pmModelClass.h

    r15697 r25521  
    3232/// @{
    3333
    34 typedef struct
    35 {
     34typedef struct {
    3635    char *name;
    3736    int nParams;
    … …  
    4443    pmModelParamsFromPSF modelParamsFromPSF;
    4544    pmModelFitStatusFunc modelFitStatus;
     45    pmModelSetLimitsFunc modelSetLimits;
    4646} pmModelClass;
    4747
Note: See TracChangeset for help on using the changeset viewer.