IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 8882


Ignore:
Timestamp:
Sep 22, 2006, 2:29:31 AM (20 years ago)
Author:
rhl
Message:

[Start to] provide symbolic names for parameters

Location:
trunk
Files:
14 edited

Legend:

Unmodified
Added
Removed

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

    r6872 r8882  
    66 *  @author EAM, IfA
    77 *
    8  *  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2006-04-17 18:01:05 $
     8 *  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2006-09-22 12:24:38 $
    1010 *
    1111 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    4949}
    5050pmModel;
     51
     52/** Symbolic names for the elements of [d]params
     53 * Note: these are #defines not enums as a given element of [d]params
     54 * may/will correspond to different parameters in different contexts
     55 */
     56#define PM_PAR_SKY 0   // Sky
     57#define PM_PAR_FLUX 1   // Flux
     58#define PM_PAR_XPOS 2   // X centre of object
     59#define PM_PAR_YPOS 3   // Y centre of object
     60#define PM_PAR_SXX 4   // shape X^2 moment
     61#define PM_PAR_SYY 5   // shape Y^2 moment
     62#define PM_PAR_SXY 6   // shape XY moment
     63#define PM_PAR_7 7   // ??? Unknown parameter
     64#define PM_PAR_8 8   // ??? Unknown parameter
    5165
    5266/** pmModelAlloc()

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

    r8815 r8882  
    55 *  @author EAM, IfA
    66 *
    7  *  @version $Revision: 1.15 $ $Name: not supported by cvs2svn $
    8  *  @date $Date: 2006-09-15 09:49:01 $
     7 *  @version $Revision: 1.16 $ $Name: not supported by cvs2svn $
     8 *  @date $Date: 2006-09-22 12:24:38 $
    99 *
    1010 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    191191    psTrace ("psphot.psftry", 3, "keeping %d of %ld PSF candidates (PSF)\n", Npsf, sources->n);
    192192
    193     // measure the chi-square trend as a function of flux (PAR[1])
     193    // measure the chi-square trend as a function of flux (PAR[PM_PAR_FLUX])
    194194    // this should be linear for Poisson errors and quadratic for constant sky errors
    195195    psVector *flux  = psVectorAlloc (psfTry->sources->n, PS_TYPE_F64);
    … …  
    206206            mask->data.U8[i] = 1;
    207207        } else {
    208             flux->data.F64[i] = model->params->data.F32[1];
     208            flux->data.F64[i] = model->params->data.F32[PM_PAR_FLUX];
    209209            chisq->data.F64[i] = model[0].chisq/model[0].nDOF;
    210210            mask->data.U8[i] = 0;

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

    r8815 r8882  
    33 *  @author EAM, IfA
    44 *
    5  *  @version $Revision: 1.13 $ $Name: not supported by cvs2svn $
    6  *  @date $Date: 2006-09-15 09:49:01 $
     5 *  @version $Revision: 1.14 $ $Name: not supported by cvs2svn $
     6 *  @date $Date: 2006-09-22 12:24:38 $
    77 *
    88 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    116116
    117117        type = pmSourceDophotType (source);
    118         lsky = (PAR[0] < 1.0) ? 0.0 : log10(PAR[0]);
    119 
    120         shape.sx  = PAR[4];
    121         shape.sy  = PAR[5];
    122         shape.sxy = PAR[6];
     118        lsky = (PAR[PM_PAR_SKY] < 1.0) ? 0.0 : log10(PAR[PM_PAR_SKY]);
     119
     120        shape.sx  = PAR[PM_PAR_SXX];
     121        shape.sy  = PAR[PM_PAR_SYY];
     122        shape.sxy = PAR[PM_PAR_SXY];
    123123        axes = psEllipseShapeToAxes (shape);
    124124
    125125        psLineInit (line);
    126         psLineAdd (line, "%6.1f ",  PAR[2]);
    127         psLineAdd (line, "%6.1f ",  PAR[3]);
     126        psLineAdd (line, "%6.1f ",  PAR[PM_PAR_XPOS]);
     127        psLineAdd (line, "%6.1f ",  PAR[PM_PAR_YPOS]);
    128128        psLineAdd (line, "%6.3f ",  PS_MIN (99.0, source->psfMag + ZERO_POINT));
    129129        psLineAdd (line, "%03d ",   PS_MIN (999, (int)(1000*source->errMag)));
    … …  
    253253            dPAR = model->dparams->data.F32;
    254254
    255             PAR[0]        = pow (atof (array->data[5]), 10.0);
    256             PAR[2]        = atof (array->data[0]);
    257             PAR[3]        = atof (array->data[1]);
     255            PAR[PM_PAR_SKY] = pow (atof (array->data[5]), 10.0);
     256            PAR[PM_PAR_XPOS] = atof (array->data[0]);
     257            PAR[PM_PAR_YPOS] = atof (array->data[1]);
    258258            source->psfMag = atof (array->data[2]);
    259259            source->extMag = atof (array->data[6]);

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

    r8815 r8882  
    33 *  @author EAM, IfA
    44 *
    5  *  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
    6  *  @date $Date: 2006-09-15 09:49:01 $
     5 *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
     6 *  @date $Date: 2006-09-22 12:24:38 $
    77 *
    88 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    6262        dPAR = model->dparams->data.F32;
    6363
    64         dmag = dPAR[1] / PAR[1];
     64        dmag = dPAR[PM_PAR_FLUX] / PAR[PM_PAR_FLUX];
    6565        type = pmSourceDophotType (source);
    6666        if ((source->apMag < 99.0) && (source->psfMag < 99.0)) {
    … …  
    7070        }
    7171
    72         shape.sx  = PAR[4];
    73         shape.sy  = PAR[5];
    74         shape.sxy = PAR[6];
     72        shape.sx  = PAR[PM_PAR_SXX];
     73        shape.sy  = PAR[PM_PAR_SYY];
     74        shape.sxy = PAR[PM_PAR_SXY];
    7575        axes = psEllipseShapeToAxes (shape);
    7676
    7777        psLineInit (line);
    7878        psLineAdd (line, "%3d",   type);
    79         psLineAdd (line, "%8.2f", PAR[2]);
    80         psLineAdd (line, "%8.2f", PAR[3]);
     79        psLineAdd (line, "%8.2f", PAR[PM_PAR_XPOS]);
     80        psLineAdd (line, "%8.2f", PAR[PM_PAR_YPOS]);
    8181        psLineAdd (line, "%8.3f", source->psfMag);
    8282        psLineAdd (line, "%6.3f", dmag);
    83         psLineAdd (line, "%9.2f", PAR[0]);
     83        psLineAdd (line, "%9.2f", PAR[PM_PAR_SKY]);
    8484        psLineAdd (line, "%9.3f", axes.major);
    8585        psLineAdd (line, "%9.3f", axes.minor);

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

    r8815 r8882  
    33 *  @author EAM, IfA
    44 *
    5  *  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
    6  *  @date $Date: 2006-09-15 09:49:01 $
     5 *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
     6 *  @date $Date: 2006-09-22 12:24:38 $
    77 *
    88 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    8484
    8585        // dPos is positional error, dMag is mag error
    86         dPos = hypot (dPAR[2], dPAR[3]);
     86        dPos = hypot (dPAR[PM_PAR_XPOS], dPAR[PM_PAR_YPOS]);
    8787
    8888        fprintf (f, "%7.1f %7.1f  %7.1f %8.4f  %7.4f %7.4f  ",
    89                  PAR[2], PAR[3], PAR[0], source->psfMag, source->errMag, dPos);
     89                 PAR[PM_PAR_XPOS], PAR[PM_PAR_YPOS], PAR[PM_PAR_SKY],
     90                 source->psfMag, source->errMag, dPos);
    9091
    9192        for (j = 4; j < model->params->n; j++) {
    … …  
    142143        // dPos is shape error
    143144        // XXX these are hardwired for SGAUSS
    144         dPos = hypot ((dPAR[4] / PAR[4]), (dPAR[5] / PAR[5]));
     145        dPos = hypot ((dPAR[PM_PAR_SXX] / PAR[PM_PAR_SXX]), (dPAR[PM_PAR_SYY] / PAR[PM_PAR_SYY]));
    145146
    146147        fprintf (f, "%7.1f %7.1f  %7.1f %8.4f  %7.4f %7.4f  ",
    147                  PAR[2], PAR[3], PAR[0], source->extMag, source->errMag, dPos);
     148                 PAR[PM_PAR_XPOS], PAR[PM_PAR_YPOS], PAR[PM_PAR_SKY],
     149                 source->extMag, source->errMag, dPos);
    148150
    149151        for (j = 4; j < model->params->n; j++) {

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

    r8815 r8882  
    33 *  @author EAM, IfA
    44 *
    5  *  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
    6  *  @date $Date: 2006-09-15 09:49:01 $
     5 *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
     6 *  @date $Date: 2006-09-22 12:24:38 $
    77 *
    88 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    6060        // pmSourceSextractType (source, &type, &flags);
    6161
    62         shape.sx  = PAR[4];
    63         shape.sy  = PAR[5];
    64         shape.sxy = PAR[6];
     62        shape.sx  = PAR[PM_PAR_SXX];
     63        shape.sy  = PAR[PM_PAR_SYY];
     64        shape.sxy = PAR[PM_PAR_SXY];
    6565        axes = psEllipseShapeToAxes (shape);
    6666
    6767        psLineInit (line);
    6868        psLineAdd (line, "%5.2f",  0.0); // should be type
    69         psLineAdd (line, "%11.3f", PAR[2]);
    70         psLineAdd (line, "%11.3f", PAR[3]);
     69        psLineAdd (line, "%11.3f", PAR[PM_PAR_XPOS]);
     70        psLineAdd (line, "%11.3f", PAR[PM_PAR_YPOS]);
    7171        psLineAdd (line, "%9.4f",  source->psfMag);
    7272        psLineAdd (line, "%9.4f",  source->errMag);
    73         psLineAdd (line, "%13.4f", PAR[0]);
     73        psLineAdd (line, "%13.4f", PAR[PM_PAR_SKY]);
    7474        psLineAdd (line, "%9.2f",  axes.major);
    7575        psLineAdd (line, "%9.2f",  axes.minor);

  • trunk/psphot/src/models/pmModel_GAUSS.c

    r5593 r8882  
    139139
    140140    dP = 0;
    141     dP += PS_SQR(dPAR[4] / PAR[4]);
    142     dP += PS_SQR(dPAR[5] / PAR[5]);
     141    dP += PS_SQR(dPAR[PM_PAR_SXX] / PAR[PM_PAR_SXX]);
     142    dP += PS_SQR(dPAR[PM_PAR_SYY] / PAR[PM_PAR_SYY]);
    143143    dP = sqrt (dP);
    144144
    145145    status = true;
    146146    status &= (dP < 0.5);
    147     status &= (PAR[1] > 0);
    148     status &= ((dPAR[1]/PAR[1]) < 0.5);
     147    status &= (PAR[PM_PAR_FLUX] > 0);
     148    status &= ((dPAR[PM_PAR_FLUX]/PAR[PM_PAR_FLUX]) < 0.5);
    149149
    150150    if (status) return true;

  • trunk/psphot/src/models/pmModel_PGAUSS.c

    r5593 r8882  
    1616    psF32 *PAR = params->data.F32;
    1717
    18     psF32 X  = x->data.F32[0] - PAR[2];
    19     psF32 Y  = x->data.F32[1] - PAR[3];
    20     psF32 px = PAR[4]*X;
    21     psF32 py = PAR[5]*Y;
    22     psF32 z  = 0.5*PS_SQR(px) + 0.5*PS_SQR(py) + PAR[6]*X*Y;
     18    psF32 X  = x->data.F32[0] - PAR[PM_PAR_XPOS];
     19    psF32 Y  = x->data.F32[1] - PAR[PM_PAR_YPOS];
     20    psF32 px = PAR[PM_PAR_SXX]*X;
     21    psF32 py = PAR[PM_PAR_SYY]*Y;
     22    psF32 z  = 0.5*PS_SQR(px) + 0.5*PS_SQR(py) + PAR[PM_PAR_SXY]*X*Y;
    2323    psF32 t  = 1 + z + z*z/2.0;
    2424    psF32 r  = 1.0 / (t + z*z*z/6.0); /* exp (-Z) */
    25     psF32 f  = PAR[1]*r + PAR[0];
     25    psF32 f  = PAR[PM_PAR_FLUX]*r + PAR[PM_PAR_SKY];
    2626
    2727    if (deriv != NULL) {
    28         // note difference from a pure gaussian: q = PAR[1]*r
    29         psF32 q = PAR[1]*r*r*t;
     28        // note difference from a pure gaussian: q = PAR[PM_PAR_FLUX]*r
     29        psF32 q = PAR[PM_PAR_FLUX]*r*r*t;
    3030        deriv->data.F32[0] = +1.0;
    3131        deriv->data.F32[1] = +r;
    32         deriv->data.F32[2] = q*(2.0*px*PAR[4] + PAR[6]*Y);
    33         deriv->data.F32[3] = q*(2.0*py*PAR[5] + PAR[6]*X);
     32        deriv->data.F32[2] = q*(2.0*px*PAR[PM_PAR_SXX] + PAR[PM_PAR_SXY]*Y);
     33        deriv->data.F32[3] = q*(2.0*py*PAR[PM_PAR_SYY] + PAR[PM_PAR_SXY]*X);
    3434        deriv->data.F32[4] = -2.0*q*px*X;
    3535        deriv->data.F32[5] = -2.0*q*py*Y;
    … …  
    7878    psF32 *PAR = params->data.F32;
    7979
    80     psF64 A1   = PS_SQR(PAR[4]);
    81     psF64 A2   = PS_SQR(PAR[5]);
    82     psF64 A3   = PS_SQR(PAR[6]);
     80    psF64 A1   = PS_SQR(PAR[PM_PAR_SXX]);
     81    psF64 A2   = PS_SQR(PAR[PM_PAR_SYY]);
     82    psF64 A3   = PS_SQR(PAR[PM_PAR_SXY]);
    8383    psF64 Area = 2.0 * M_PI / sqrt(A1*A2 - A3);
    8484    // Area is equivalent to 2 pi sigma^2
    … …  
    9292    norm *= 0.01;
    9393   
    94     psF64 Flux = params->data.F32[1] * Area * norm;
     94    psF64 Flux = params->data.F32[PM_PAR_FLUX] * Area * norm;
    9595
    9696    return(Flux);
    … …  
    154154
    155155    dP = 0;
    156     dP += PS_SQR(dPAR[4] / PAR[4]);
    157     dP += PS_SQR(dPAR[5] / PAR[5]);
     156    dP += PS_SQR(dPAR[PM_PAR_SXX] / PAR[PM_PAR_SXX]);
     157    dP += PS_SQR(dPAR[PM_PAR_SYY] / PAR[PM_PAR_SYY]);
    158158    dP = sqrt (dP);
    159159
    160160    status = true;
    161161    status &= (dP < 0.5);
    162     status &= (PAR[1] > 0);
    163     status &= ((dPAR[1]/PAR[1]) < 0.5);
     162    status &= (PAR[PM_PAR_FLUX] > 0);
     163    status &= ((dPAR[PM_PAR_FLUX]/PAR[PM_PAR_FLUX]) < 0.5);
    164164
    165165    if (status) return true;

  • trunk/psphot/src/models/pmModel_QGAUSS.c

    r5593 r8882  
    2626    psF32 *PAR = params->data.F32;
    2727
    28     psF32 X  = x->data.F32[0] - PAR[2];
    29     psF32 Y  = x->data.F32[1] - PAR[3];
    30     psF32 px = PAR[4]*X;
    31     psF32 py = PAR[5]*Y;
    32     psF32 z  = 0.5*PS_SQR(px) + 0.5*PS_SQR(py) + PAR[6]*X*Y;
     28    psF32 X  = x->data.F32[0] - PAR[PM_PAR_XPOS];
     29    psF32 Y  = x->data.F32[1] - PAR[PM_PAR_YPOS];
     30    psF32 px = PAR[PM_PAR_SXX]*X;
     31    psF32 py = PAR[PM_PAR_SYY]*Y;
     32    psF32 z  = 0.5*PS_SQR(px) + 0.5*PS_SQR(py) + PAR[PM_PAR_SXY]*X*Y;
    3333
    34     psF32 r  = 1.0 / (1 + PAR[7]*z + pow(z, QG_S1));
    35     psF32 f  = PAR[1]*r + PAR[0];
     34    psF32 r  = 1.0 / (1 + PAR[PM_PAR_7]*z + pow(z, QG_S1));
     35    psF32 f  = PAR[PM_PAR_FLUX]*r + PAR[PM_PAR_SKY];
    3636
    3737    if (deriv != NULL) {
    3838        // note difference from a pure gaussian: q = params->data.F32[1]*r
    39         psF32 t = PAR[1]*r*r;
    40         psF32 q = t*(PAR[7] + QG_S1*pow(z, dQG_S1));
     39        psF32 t = PAR[PM_PAR_FLUX]*r*r;
     40        psF32 q = t*(PAR[PM_PAR_7] + QG_S1*pow(z, dQG_S1));
    4141
    4242        deriv->data.F32[0] = +1.0;
    4343        deriv->data.F32[1] = +r;
    44         deriv->data.F32[2] = q*(2.0*px*PAR[4] + PAR[6]*Y);
    45         deriv->data.F32[3] = q*(2.0*py*PAR[5] + PAR[6]*X);
     44        deriv->data.F32[2] = q*(2.0*px*PAR[PM_PAR_SXX] + PAR[PM_PAR_SXY]*Y);
     45        deriv->data.F32[3] = q*(2.0*py*PAR[PM_PAR_SYY] + PAR[PM_PAR_SXY]*X);
    4646        deriv->data.F32[4] = -2.0*q*px*X;
    4747        deriv->data.F32[5] = -2.0*q*py*Y;
    … …  
    111111    psF32 *PAR = params->data.F32;
    112112
    113     psF64 A1   = PS_SQR(PAR[4]);
    114     psF64 A2   = PS_SQR(PAR[5]);
    115     psF64 A3   = PS_SQR(PAR[6]);
     113    psF64 A1   = PS_SQR(PAR[PM_PAR_SXX]);
     114    psF64 A2   = PS_SQR(PAR[PM_PAR_SYY]);
     115    psF64 A3   = PS_SQR(PAR[PM_PAR_SXY]);
    116116    psF64 Area = 2.0 * M_PI / sqrt(A1*A2 - A3);
    117117    // Area is equivalent to 2 pi sigma^2
    … …  
    120120    norm = 0.0;
    121121    for (z = 0.005; z < 50; z += 0.01) {
    122         f = 1.0 / (1 + PAR[7]*z + pow(z, QG_S1));
     122        f = 1.0 / (1 + PAR[PM_PAR_7]*z + pow(z, QG_S1));
    123123        norm += f;
    124124    }
    125125    norm *= 0.01;
    126126   
    127     psF64 Flux = PAR[1] * Area * norm;
     127    psF64 Flux = PAR[PM_PAR_FLUX] * Area * norm;
    128128
    129129    return(Flux);
    … …  
    138138
    139139    if (flux <= 0) return (1.0);
    140     if (PAR[1] <= 0) return (1.0);
    141     if (flux >= PAR[1]) return (1.0);
     140    if (PAR[PM_PAR_FLUX] <= 0) return (1.0);
     141    if (flux >= PAR[PM_PAR_FLUX]) return (1.0);
    142142
    143143    // if Sx == Sy, sigma = Sx == Sy
    144     psF64 sigma = hypot (1.0 / PAR[4], 1.0 / PAR[5]) / sqrt(2.0);
     144    psF64 sigma = hypot (1.0 / PAR[PM_PAR_SXX], 1.0 / PAR[PM_PAR_SYY]) / sqrt(2.0);
    145145    psF64 dz = 1.0 / (2.0 * sigma*sigma);
    146     psF64 limit = flux / PAR[1];
     146    psF64 limit = flux / PAR[PM_PAR_FLUX];
    147147
    148148    // we can do this much better with intelligent choices here
    149149    for (z = 0.0; z < 20.0; z += dz) {
    150         f = 1.0 / (1 + PAR[7]*z + pow(z, QG_S1));
     150        f = 1.0 / (1 + PAR[PM_PAR_7]*z + pow(z, QG_S1));
    151151        if (f < limit) break;
    152152    }
    … …  
    184184
    185185    dP = 0;
    186     dP += PS_SQR(dPAR[4] / PAR[4]);
    187     dP += PS_SQR(dPAR[5] / PAR[5]);
     186    dP += PS_SQR(dPAR[PM_PAR_SXX] / PAR[PM_PAR_SXX]);
     187    dP += PS_SQR(dPAR[PM_PAR_SYY] / PAR[PM_PAR_SYY]);
    188188    dP = sqrt (dP);
    189189
    190190    status = true;
    191191    status &= (dP < 0.5);
    192     status &= (PAR[1] > 0);
    193     status &= ((dPAR[1]/PAR[1]) < 0.5);
     192    status &= (PAR[PM_PAR_FLUX] > 0);
     193    status &= ((dPAR[PM_PAR_FLUX]/PAR[PM_PAR_FLUX]) < 0.5);
    194194
    195195    if (status) return true;

  • trunk/psphot/src/models/pmModel_RGAUSS.c

    r4954 r8882  
    2020    psF32 *PAR = params->data.F32;
    2121
    22     psF32 X  = x->data.F32[0] - PAR[2];
    23     psF32 Y  = x->data.F32[1] - PAR[3];
    24     psF32 px = PAR[4]*X;
    25     psF32 py = PAR[5]*Y;
    26     psF32 z  = 0.5*PS_SQR(px) + 0.5*PS_SQR(py) + PAR[6]*X*Y;
     22    psF32 X  = x->data.F32[0] - PAR[PM_PAR_XPOS];
     23    psF32 Y  = x->data.F32[1] - PAR[PM_PAR_YPOS];
     24    psF32 px = PAR[PM_PAR_SXX]*X;
     25    psF32 py = PAR[PM_PAR_SYY]*Y;
     26    psF32 z  = 0.5*PS_SQR(px) + 0.5*PS_SQR(py) + PAR[PM_PAR_SXY]*X*Y;
    2727
    2828    // psF32 FACT = 1 + 5*exp(-5*PAR[7]);
    2929   
    30     psF32 p  = pow(z, PAR[7] - 1.0);
     30    psF32 p  = pow(z, PAR[PM_PAR_7] - 1.0);
    3131    psF32 r  = 1.0 / (1 + z + z*p);
    32     psF32 f  = PAR[1]*r + PAR[0];
     32    psF32 f  = PAR[PM_PAR_FLUX]*r + PAR[PM_PAR_SKY];
    3333
    3434    if (deriv != NULL) {
    3535        // note difference from a pure gaussian: q = params->data.F32[1]*r
    36         psF32 t = PAR[1]*r*r;
    37         psF32 q = t*(1 + PAR[7]*p);
     36        psF32 t = PAR[PM_PAR_FLUX]*r*r;
     37        psF32 q = t*(1 + PAR[PM_PAR_7]*p);
    3838
    3939        deriv->data.F32[0] = +1.0;
    4040        deriv->data.F32[1] = +r;
    41         deriv->data.F32[2] = q*(2.0*px*PAR[4] + PAR[6]*Y);
    42         deriv->data.F32[3] = q*(2.0*py*PAR[5] + PAR[6]*X);
     41        deriv->data.F32[2] = q*(2.0*px*PAR[PM_PAR_SXX] + PAR[PM_PAR_SXY]*Y);
     42        deriv->data.F32[3] = q*(2.0*py*PAR[PM_PAR_SYY] + PAR[PM_PAR_SXY]*X);
    4343        deriv->data.F32[4] = -q*px*X*2;
    4444        deriv->data.F32[5] = -q*py*Y*2;
    … …  
    6060    psF32 *PAR = params->data.F32;
    6161
    62     psF64 A1   = PS_SQR(PAR[4]);
    63     psF64 A2   = PS_SQR(PAR[5]);
    64     psF64 A3   = PS_SQR(PAR[6]);
     62    psF64 A1   = PS_SQR(PAR[PM_PAR_SXX]);
     63    psF64 A2   = PS_SQR(PAR[PM_PAR_SYY]);
     64    psF64 A3   = PS_SQR(PAR[PM_PAR_SXY]);
    6565    psF64 Area = 2.0 * M_PI / sqrt(A1*A2 - A3);
    6666    // Area is equivalent to 2 pi sigma^2
    … …  
    6969    norm = 0.0;
    7070    for (z = 0.005; z < 50; z += 0.01) {
    71         f = 1.0 / (1 + z + pow(z, PAR[7]));
     71        f = 1.0 / (1 + z + pow(z, PAR[PM_PAR_7]));
    7272        norm += f;
    7373    }
    … …  
    8787
    8888    if (flux <= 0) return (1.0);
    89     if (PAR[1] <= 0) return (1.0);
    90     if (flux >= PAR[1]) return (1.0);
     89    if (PAR[PM_PAR_FLUX] <= 0) return (1.0);
     90    if (flux >= PAR[PM_PAR_FLUX]) return (1.0);
    9191
    9292    // if Sx == Sy, sigma = Sx == Sy
    93     psF64 sigma = hypot (1.0 / PAR[4], 1.0 / PAR[5]) / sqrt(2.0);
     93    psF64 sigma = hypot (1.0 / PAR[PM_PAR_SXX], 1.0 / PAR[PM_PAR_SYY]) / sqrt(2.0);
    9494    psF64 dz = 1.0 / (2.0 * sigma*sigma);
    95     psF64 limit = flux / PAR[1];
     95    psF64 limit = flux / PAR[PM_PAR_FLUX];
    9696
    9797    // we can do this much better with intelligent choices here
    9898    for (z = 0.0; z < 20.0; z += dz) {
    99         p = pow(z, PAR[7]);
     99        p = pow(z, PAR[PM_PAR_7]);
    100100        f = 1.0 / (1 + z + p);
    101101        if (f < limit) break;

  • trunk/psphot/src/models/pmModel_SGAUSS.c

    r5772 r8882  
    2525    psF32 *PAR = params->data.F32;
    2626
    27     psF32 X  = x->data.F32[0] - PAR[2];
    28     psF32 Y  = x->data.F32[1] - PAR[3];
    29     psF32 px = PAR[4]*X;
    30     psF32 py = PAR[5]*Y;
    31     psF32 z  = PS_MAX((0.5*PS_SQR(px) + 0.5*PS_SQR(py) + PAR[6]*X*Y), 1e-8);
    32     // note that if z -> 0, dPAR[7] -> -inf
    33     // also z^(PAR[7]-1) -> Inf
    34 
    35     psF32 pr = z*PAR[8];
     27    psF32 X  = x->data.F32[0] - PAR[PM_PAR_XPOS];
     28    psF32 Y  = x->data.F32[1] - PAR[PM_PAR_YPOS];
     29    psF32 px = PAR[PM_PAR_SXX]*X;
     30    psF32 py = PAR[PM_PAR_SYY]*Y;
     31    psF32 z  = PS_MAX((0.5*PS_SQR(px) + 0.5*PS_SQR(py) + PAR[PM_PAR_SXY]*X*Y), 1e-8);
     32    // note that if z -> 0, dPAR[PM_PAR_7] -> -inf
     33    // also z^(PAR[PM_PAR_7]-1) -> Inf
     34
     35    psF32 pr = z*PAR[PM_PAR_8];
    3636    psF32 pr3 = pr*pr*pr;
    37     psF32 p  = pow(z, PAR[7] - 1.0);
     37    psF32 p  = pow(z, PAR[PM_PAR_7] - 1.0);
    3838    psF32 r  = 1.0 / (1 + z*p + pr*pr3);
    39     psF32 f  = PAR[1]*r + PAR[0];
     39    psF32 f  = PAR[PM_PAR_FLUX]*r + PAR[PM_PAR_SKY];
    4040
    4141    if (deriv != NULL) {
    4242        // note difference from a pure gaussian: q = params->data.F32[1]*r
    43         psF32 t = PAR[1]*r*r;
    44         psF32 q = t*(PAR[7]*p + 4*PAR[8]*pr3);
     43        psF32 t = PAR[PM_PAR_FLUX]*r*r;
     44        psF32 q = t*(PAR[PM_PAR_7]*p + 4*PAR[PM_PAR_8]*pr3);
    4545
    4646        deriv->data.F32[0] = +1.0;
    4747        deriv->data.F32[1] = +r;
    48         deriv->data.F32[2] = q*(2.0*px*PAR[4] + PAR[6]*Y);
    49         deriv->data.F32[3] = q*(2.0*py*PAR[5] + PAR[6]*X);
     48        deriv->data.F32[2] = q*(2.0*px*PAR[PM_PAR_SXX] + PAR[PM_PAR_SXY]*Y);
     49        deriv->data.F32[3] = q*(2.0*py*PAR[PM_PAR_SYY] + PAR[PM_PAR_SXY]*X);
    5050        deriv->data.F32[4] = -2.0*q*px*X;
    5151        deriv->data.F32[5] = -2.0*q*py*Y;
    … …  
    230230    psF32 *PAR = params->data.F32;
    231231
    232     psF64 A1   = PS_SQR(PAR[4]);
    233     psF64 A2   = PS_SQR(PAR[5]);
    234     psF64 A3   = PS_SQR(PAR[6]);
     232    psF64 A1   = PS_SQR(PAR[PM_PAR_SXX]);
     233    psF64 A2   = PS_SQR(PAR[PM_PAR_SYY]);
     234    psF64 A3   = PS_SQR(PAR[PM_PAR_SXY]);
    235235    psF64 Area = 2.0 * M_PI / sqrt(A1*A2 - A3);
    236236    // Area is equivalent to 2 pi sigma^2
    … …  
    239239    norm = 0.0;
    240240    for (z = 0.005; z < 50; z += 0.01) {
    241       psF32 pr = PAR[8]*z;
    242         f = 1.0 / (1 + pow(z, PAR[7]) + SQ(SQ(pr)));
     241      psF32 pr = PAR[PM_PAR_8]*z;
     242        f = 1.0 / (1 + pow(z, PAR[PM_PAR_7]) + SQ(SQ(pr)));
    243243        norm += f;
    244244    }
    245245    norm *= 0.01;
    246246   
    247     psF64 Flux = PAR[1] * Area * norm;
     247    psF64 Flux = PAR[PM_PAR_FLUX] * Area * norm;
    248248
    249249    return(Flux);
    … …  
    262262
    263263    if (flux <= 0) return (1.0);
    264     if (PAR[1] <= 0) return (1.0);
    265     if (flux >= PAR[1]) return (1.0);
     264    if (PAR[PM_PAR_FLUX] <= 0) return (1.0);
     265    if (flux >= PAR[PM_PAR_FLUX]) return (1.0);
    266266
    267267    // convert Sx,Sy,Sxy to major/minor axes
    268     shape.sx = 1.0 / PAR[4];
    269     shape.sy = 1.0 / PAR[5];
    270     shape.sxy = PAR[6];
     268    shape.sx = 1.0 / PAR[PM_PAR_SXX];
     269    shape.sy = 1.0 / PAR[PM_PAR_SYY];
     270    shape.sxy = PAR[PM_PAR_SXY];
    271271
    272272    axes = EllipseShapeToAxes (shape);
    273273    psF64 dr = 1.0 / axes.major;
    274     psF64 limit = flux / PAR[1];
     274    psF64 limit = flux / PAR[PM_PAR_FLUX];
    275275
    276276    // XXX : we can do this faster with an intelligent starting choice
    277277    for (r = 0.0; r < 20.0; r += dr) {
    278278        z = SQ(r);
    279         pr = PAR[8]*z;
    280         f = 1.0 / (1 + pow(z, PAR[7]) + SQ(SQ(pr)));
     279        pr = PAR[PM_PAR_8]*z;
     280        f = 1.0 / (1 + pow(z, PAR[PM_PAR_7]) + SQ(SQ(pr)));
    281281        if (f < limit) break;
    282282    }
    … …  
    315315    psF32 *dPAR = model->dparams->data.F32;
    316316
    317     shape.sx = 1.0 / PAR[4];
    318     shape.sy = 1.0 / PAR[5];
    319     shape.sxy = PAR[6];
     317    shape.sx = 1.0 / PAR[PM_PAR_SXX];
     318    shape.sy = 1.0 / PAR[PM_PAR_SYY];
     319    shape.sxy = PAR[PM_PAR_SXY];
    320320
    321321    axes = EllipseShapeToAxes (shape);
    322322
    323323    dP = 0;
    324     dP += PS_SQR(dPAR[4] / PAR[4]);
    325     dP += PS_SQR(dPAR[5] / PAR[5]);
    326     dP += PS_SQR(dPAR[7] / PAR[7]);
     324    dP += PS_SQR(dPAR[PM_PAR_SXX] / PAR[PM_PAR_SXX]);
     325    dP += PS_SQR(dPAR[PM_PAR_SYY] / PAR[PM_PAR_SYY]);
     326    dP += PS_SQR(dPAR[PM_PAR_7] / PAR[PM_PAR_7]);
    327327    dP = sqrt (dP);
    328328
    329329    status = true;
    330330    status &= (dP < 0.5);
    331     status &= (PAR[1] > 0);
    332     status &= ((dPAR[1]/PAR[1]) < 0.5);
    333     status &= (fabs(PAR[8]) < 0.5);
    334     status &= (dPAR[8] < 0.1);
     331    status &= (PAR[PM_PAR_FLUX] > 0);
     332    status &= ((dPAR[PM_PAR_FLUX]/PAR[PM_PAR_FLUX]) < 0.5);
     333    status &= (fabs(PAR[PM_PAR_8]) < 0.5);
     334    status &= (dPAR[PM_PAR_8] < 0.1);
    335335    status &= (axes.major > 1.41);
    336336    status &= (axes.minor > 1.41);
    337337    status &= ((axes.major / axes.minor) < 5.0);
    338     status &= (PAR[7] > 0.5);
     338    status &= (PAR[PM_PAR_7] > 0.5);
    339339
    340340    if (status) return true;

  • trunk/psphot/src/models/pmModel_TAUSS.c

    r5718 r8882  
    1 
    21/******************************************************************************
    32    params->data.F32[0] = So;
    … …  
    150149
    151150    dP = 0;
    152     dP += PS_SQR(dPAR[4] / PAR[4]);
    153     dP += PS_SQR(dPAR[5] / PAR[5]);
     151    dP += PS_SQR(dPAR[PM_PAR_SXX] / PAR[PM_PAR_SXX]);
     152    dP += PS_SQR(dPAR[PM_PAR_SYY] / PAR[PM_PAR_SYY]);
    154153    dP = sqrt (dP);
    155154
    156155    status = true;
    157156    status &= (dP < 0.5);
    158     status &= (PAR[1] > 0);
    159     status &= ((dPAR[1]/PAR[1]) < 0.5);
     157    status &= (PAR[PM_PAR_FLUX] > 0);
     158    status &= ((dPAR[PM_PAR_FLUX]/PAR[PM_PAR_FLUX]) < 0.5);
    160159
    161160    if (status)

  • trunk/psphot/src/models/pmModel_TGAUSS.c

    r5593 r8882  
    2727    psF32 *PAR = params->data.F32;
    2828
    29     psF32 X  = x->data.F32[0] - PAR[2];
    30     psF32 Y  = x->data.F32[1] - PAR[3];
    31     psF32 px = PAR[4]*X;
    32     psF32 py = PAR[5]*Y;
    33     psF32 z  = 0.5*PS_SQR(px) + 0.5*PS_SQR(py) + PAR[6]*X*Y;
     29    psF32 X  = x->data.F32[0] - PAR[PM_PAR_XPOS];
     30    psF32 Y  = x->data.F32[1] - PAR[PM_PAR_YPOS];
     31    psF32 px = PAR[PM_PAR_SXX]*X;
     32    psF32 py = PAR[PM_PAR_SYY]*Y;
     33    psF32 z  = 0.5*PS_SQR(px) + 0.5*PS_SQR(py) + PAR[PM_PAR_SXY]*X*Y;
    3434    psF32 er = exp(TRF*z);
    3535
    36     psF32 r  = 1.0 / (er + PAR[7]*z + pow(z, TG_S));    // (1/R)
    37     psF32 f  = PAR[1]*r + PAR[0];
     36    psF32 r  = 1.0 / (er + PAR[PM_PAR_7]*z + pow(z, TG_S));    // (1/R)
     37    psF32 f  = PAR[PM_PAR_FLUX]*r + PAR[PM_PAR_SKY];
    3838
    3939    if (deriv != NULL) {
    40         psF32 t = PAR[1]*r*r;                            // df/dR
    41         psF32 q = t*(TRF*er + PAR[7] + TG_S*pow(z, dTG_S));  // (df/dR)(dR/dz)
     40        psF32 t = PAR[PM_PAR_FLUX]*r*r; // df/dR
     41        psF32 q = t*(TRF*er + PAR[PM_PAR_7] + TG_S*pow(z, dTG_S));  // (df/dR)(dR/dz)
    4242
    4343        deriv->data.F32[0] = +1.0;
    4444        deriv->data.F32[1] = +r;
    45         deriv->data.F32[2] = q*(2.0*px*PAR[4] + PAR[6]*Y);
    46         deriv->data.F32[3] = q*(2.0*py*PAR[5] + PAR[6]*X);
     45        deriv->data.F32[2] = q*(2.0*px*PAR[PM_PAR_SXX] + PAR[PM_PAR_SXY]*Y);
     46        deriv->data.F32[3] = q*(2.0*py*PAR[PM_PAR_SYY] + PAR[PM_PAR_SXY]*X);
    4747        deriv->data.F32[4] = -2.0*q*px*X;
    4848        deriv->data.F32[5] = -2.0*q*py*Y;
    … …  
    112112    psF32 *PAR = params->data.F32;
    113113
    114     psF64 A1   = PS_SQR(PAR[4]);
    115     psF64 A2   = PS_SQR(PAR[5]);
    116     psF64 A3   = PS_SQR(PAR[6]);
     114    psF64 A1   = PS_SQR(PAR[PM_PAR_SXX]);
     115    psF64 A2   = PS_SQR(PAR[PM_PAR_SYY]);
     116    psF64 A3   = PS_SQR(PAR[PM_PAR_SXY]);
    117117    psF64 Area = 2.0 * M_PI / sqrt(A1*A2 - A3);
    118118    // Area is equivalent to 2 pi sigma^2
    … …  
    122122    for (z = 0.005; z < 50; z += 0.01) {
    123123        psF32 er = exp(TRF*z);
    124         f = 1.0 / (er + PAR[7]*z + pow(z, TG_S));
     124        f = 1.0 / (er + PAR[PM_PAR_7]*z + pow(z, TG_S));
    125125        norm += f;
    126126    }
    127127    norm *= 0.01;
    128128   
    129     psF64 Flux = PAR[1] * Area * norm;
     129    psF64 Flux = PAR[PM_PAR_FLUX] * Area * norm;
    130130
    131131    return(Flux);
    … …  
    140140
    141141    if (flux <= 0) return (1.0);
    142     if (PAR[1] <= 0) return (1.0);
    143     if (flux >= PAR[1]) return (1.0);
     142    if (PAR[PM_PAR_FLUX] <= 0) return (1.0);
     143    if (flux >= PAR[PM_PAR_FLUX]) return (1.0);
    144144
    145145    // if Sx == Sy, sigma = Sx == Sy
    146     psF64 sigma = hypot (1.0 / PAR[4], 1.0 / PAR[5]) / sqrt(2.0);
     146    psF64 sigma = hypot (1.0 / PAR[PM_PAR_SXX], 1.0 / PAR[PM_PAR_SYY]) / sqrt(2.0);
    147147    psF64 dz = 1.0 / (2.0 * sigma*sigma);
    148     psF64 limit = flux / PAR[1];
     148    psF64 limit = flux / PAR[PM_PAR_FLUX];
    149149
    150150    // we can do this much better with intelligent choices here
    151151    for (z = 0.0; z < 20.0; z += dz) {
    152152        psF32 er = exp(TRF*z);
    153         f = 1.0 / (er + PAR[7]*z + pow(z, TG_S));
     153        f = 1.0 / (er + PAR[PM_PAR_7]*z + pow(z, TG_S));
    154154        if (f < limit) break;
    155155    }
    … …  
    187187
    188188    dP = 0;
    189     dP += PS_SQR(dPAR[4] / PAR[4]);
    190     dP += PS_SQR(dPAR[5] / PAR[5]);
     189    dP += PS_SQR(dPAR[PM_PAR_SXX] / PAR[PM_PAR_SXX]);
     190    dP += PS_SQR(dPAR[PM_PAR_SYY] / PAR[PM_PAR_SYY]);
    191191    dP = sqrt (dP);
    192192
    193193    status = true;
    194194    status &= (dP < 0.5);
    195     status &= (PAR[1] > 0);
    196     status &= ((dPAR[1]/PAR[1]) < 0.5);
     195    status &= (PAR[PM_PAR_FLUX] > 0);
     196    status &= ((dPAR[PM_PAR_FLUX]/PAR[PM_PAR_FLUX]) < 0.5);
    197197
    198198    if (status) return true;

  • trunk/psphot/src/models/pmModel_ZGAUSS.c

    r4954 r8882  
    2323    psF32 *PAR = params->data.F32;
    2424
    25     psF32 X  = x->data.F32[0] - PAR[2];
    26     psF32 Y  = x->data.F32[1] - PAR[3];
    27     psF32 px = PAR[4]*X;
    28     psF32 py = PAR[5]*Y;
    29     psF32 z  = 0.5*PS_SQR(px) + 0.5*PS_SQR(py) + PAR[6]*X*Y;
     25    psF32 X  = x->data.F32[0] - PAR[PM_PAR_XPOS];
     26    psF32 Y  = x->data.F32[1] - PAR[PM_PAR_YPOS];
     27    psF32 px = PAR[PM_PAR_SXX]*X;
     28    psF32 py = PAR[PM_PAR_SYY]*Y;
     29    psF32 z  = 0.5*PS_SQR(px) + 0.5*PS_SQR(py) + PAR[PM_PAR_SXY]*X*Y;
    3030
    3131    psF32 pr = PAR8*z;
    32     psF32 p  = pow(z, PAR[7] - 1.0);
     32    psF32 p  = pow(z, PAR[PM_PAR_7] - 1.0);
    3333    psF32 r  = 1.0 / (1 + z*p + SQ(SQ(pr)));
    34     psF32 f  = PAR[1]*r + PAR[0];
     34    psF32 f  = PAR[PM_PAR_FLUX]*r + PAR[PM_PAR_SKY];
    3535
    3636    if (deriv != NULL) {
    3737        // note difference from a pure gaussian: q = params->data.F32[1]*r
    38         psF32 t = PAR[1]*r*r;
    39         psF32 q = t*(PAR[7]*p + 4*PAR8*pr*pr*pr);
     38        psF32 t = PAR[PM_PAR_FLUX]*r*r;
     39        psF32 q = t*(PAR[PM_PAR_7]*p + 4*PAR8*pr*pr*pr);
    4040
    4141        deriv->data.F32[0] = +1.0;
    4242        deriv->data.F32[1] = +r;
    43         deriv->data.F32[2] = q*(2.0*px*PAR[4] + PAR[6]*Y);
    44         deriv->data.F32[3] = q*(2.0*py*PAR[5] + PAR[6]*X);
     43        deriv->data.F32[2] = q*(2.0*px*PAR[PM_PAR_SXX] + PAR[PM_PAR_SXY]*Y);
     44        deriv->data.F32[3] = q*(2.0*py*PAR[PM_PAR_SYY] + PAR[PM_PAR_SXY]*X);
    4545        deriv->data.F32[4] = -q*px*X;
    4646        deriv->data.F32[5] = -q*py*Y;
    … …  
    5757    psF32 *PAR = params->data.F32;
    5858
    59     psF64 A1   = PS_SQR(PAR[4]);
    60     psF64 A2   = PS_SQR(PAR[5]);
    61     psF64 A3   = PS_SQR(PAR[6]);
     59    psF64 A1   = PS_SQR(PAR[PM_PAR_SXX]);
     60    psF64 A2   = PS_SQR(PAR[PM_PAR_SYY]);
     61    psF64 A3   = PS_SQR(PAR[PM_PAR_SXY]);
    6262    psF64 Area = 2.0 * M_PI / sqrt(A1*A2 - A3);
    6363    // Area is equivalent to 2 pi sigma^2
    … …  
    6767    psF32 pr = PAR8*z;
    6868    for (z = 0.005; z < 50; z += 0.01) {
    69         f = 1.0 / (1 + pow(z, PAR[7]) + SQ(SQ(pr)));
     69        f = 1.0 / (1 + pow(z, PAR[PM_PAR_7]) + SQ(SQ(pr)));
    7070        norm += f;
    7171    }
    7272    norm *= 0.01;
    7373   
    74     psF64 Flux = PAR[1] * Area * norm;
     74    psF64 Flux = PAR[PM_PAR_FLUX] * Area * norm;
    7575
    7676    return(Flux);
    … …  
    8989
    9090    if (flux <= 0) return (1.0);
    91     if (PAR[1] <= 0) return (1.0);
    92     if (flux >= PAR[1]) return (1.0);
     91    if (PAR[PM_PAR_FLUX] <= 0) return (1.0);
     92    if (flux >= PAR[PM_PAR_FLUX]) return (1.0);
    9393
    9494    // convert Sx,Sy,Sxy to major/minor axes
    95     shape.sx = 1.0 / PAR[4];
    96     shape.sy = 1.0 / PAR[5];
    97     shape.sxy = PAR[6];
     95    shape.sx = 1.0 / PAR[PM_PAR_SXX];
     96    shape.sy = 1.0 / PAR[PM_PAR_SYY];
     97    shape.sxy = PAR[PM_PAR_SXY];
    9898
    9999    axes = EllipseShapeToAxes (shape);
    100100    psF64 dr = 1.0 / axes.major;
    101     psF64 limit = flux / PAR[1];
     101    psF64 limit = flux / PAR[PM_PAR_FLUX];
    102102
    103103    // XXX : we can do this faster with an intelligent starting choice
    … …  
    105105        z = SQ(r);
    106106        pr = PAR8*z;
    107         f = 1.0 / (1 + pow(z, PAR[7]) + SQ(SQ(pr)));
     107        f = 1.0 / (1 + pow(z, PAR[PM_PAR_7]) + SQ(SQ(pr)));
    108108        if (f < limit) break;
    109109    }
Note: See TracChangeset for help on using the changeset viewer.