IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 9529


Ignore:
Timestamp:
Oct 12, 2006, 4:36:54 PM (20 years ago)
Author:
rhl
Message:

Renamed PM_PAR_FLUX to PM_PAR_I0

Location:
trunk/psphot/src
Files:
11 edited

Legend:

Unmodified
Added
Removed

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

    r8882 r9529  
    145145    status = true;
    146146    status &= (dP < 0.5);
    147     status &= (PAR[PM_PAR_FLUX] > 0);
    148     status &= ((dPAR[PM_PAR_FLUX]/PAR[PM_PAR_FLUX]) < 0.5);
     147    status &= (PAR[PM_PAR_I0] > 0);
     148    status &= ((dPAR[PM_PAR_I0]/PAR[PM_PAR_I0]) < 0.5);
    149149
    150150    if (status) return true;

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

    r8882 r9529  
    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[PM_PAR_FLUX]*r + PAR[PM_PAR_SKY];
     25    psF32 f  = PAR[PM_PAR_I0]*r + PAR[PM_PAR_SKY];
    2626
    2727    if (deriv != NULL) {
    28         // note difference from a pure gaussian: q = PAR[PM_PAR_FLUX]*r
    29         psF32 q = PAR[PM_PAR_FLUX]*r*r*t;
     28        // note difference from a pure gaussian: q = PAR[PM_PAR_I0]*r
     29        psF32 q = PAR[PM_PAR_I0]*r*r*t;
    3030        deriv->data.F32[0] = +1.0;
    3131        deriv->data.F32[1] = +r;
    … …  
    9292    norm *= 0.01;
    9393   
    94     psF64 Flux = params->data.F32[PM_PAR_FLUX] * Area * norm;
     94    psF64 Flux = params->data.F32[PM_PAR_I0] * Area * norm;
    9595
    9696    return(Flux);
    … …  
    160160    status = true;
    161161    status &= (dP < 0.5);
    162     status &= (PAR[PM_PAR_FLUX] > 0);
    163     status &= ((dPAR[PM_PAR_FLUX]/PAR[PM_PAR_FLUX]) < 0.5);
     162    status &= (PAR[PM_PAR_I0] > 0);
     163    status &= ((dPAR[PM_PAR_I0]/PAR[PM_PAR_I0]) < 0.5);
    164164
    165165    if (status) return true;

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

    r8882 r9529  
    3333
    3434    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];
     35    psF32 f  = PAR[PM_PAR_I0]*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[PM_PAR_FLUX]*r*r;
     39        psF32 t = PAR[PM_PAR_I0]*r*r;
    4040        psF32 q = t*(PAR[PM_PAR_7] + QG_S1*pow(z, dQG_S1));
    4141
    … …  
    125125    norm *= 0.01;
    126126   
    127     psF64 Flux = PAR[PM_PAR_FLUX] * Area * norm;
     127    psF64 Flux = PAR[PM_PAR_I0] * Area * norm;
    128128
    129129    return(Flux);
    … …  
    138138
    139139    if (flux <= 0) return (1.0);
    140     if (PAR[PM_PAR_FLUX] <= 0) return (1.0);
    141     if (flux >= PAR[PM_PAR_FLUX]) return (1.0);
     140    if (PAR[PM_PAR_I0] <= 0) return (1.0);
     141    if (flux >= PAR[PM_PAR_I0]) return (1.0);
    142142
    143143    // if Sx == Sy, sigma = Sx == Sy
    144144    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[PM_PAR_FLUX];
     146    psF64 limit = flux / PAR[PM_PAR_I0];
    147147
    148148    // we can do this much better with intelligent choices here
    … …  
    190190    status = true;
    191191    status &= (dP < 0.5);
    192     status &= (PAR[PM_PAR_FLUX] > 0);
    193     status &= ((dPAR[PM_PAR_FLUX]/PAR[PM_PAR_FLUX]) < 0.5);
     192    status &= (PAR[PM_PAR_I0] > 0);
     193    status &= ((dPAR[PM_PAR_I0]/PAR[PM_PAR_I0]) < 0.5);
    194194
    195195    if (status) return true;

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

    r8882 r9529  
    3030    psF32 p  = pow(z, PAR[PM_PAR_7] - 1.0);
    3131    psF32 r  = 1.0 / (1 + z + z*p);
    32     psF32 f  = PAR[PM_PAR_FLUX]*r + PAR[PM_PAR_SKY];
     32    psF32 f  = PAR[PM_PAR_I0]*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[PM_PAR_FLUX]*r*r;
     36        psF32 t = PAR[PM_PAR_I0]*r*r;
    3737        psF32 q = t*(1 + PAR[PM_PAR_7]*p);
    3838
    … …  
    8787
    8888    if (flux <= 0) return (1.0);
    89     if (PAR[PM_PAR_FLUX] <= 0) return (1.0);
    90     if (flux >= PAR[PM_PAR_FLUX]) return (1.0);
     89    if (PAR[PM_PAR_I0] <= 0) return (1.0);
     90    if (flux >= PAR[PM_PAR_I0]) return (1.0);
    9191
    9292    // if Sx == Sy, sigma = Sx == Sy
    9393    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[PM_PAR_FLUX];
     95    psF64 limit = flux / PAR[PM_PAR_I0];
    9696
    9797    // we can do this much better with intelligent choices here

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

    r8882 r9529  
    3737    psF32 p  = pow(z, PAR[PM_PAR_7] - 1.0);
    3838    psF32 r  = 1.0 / (1 + z*p + pr*pr3);
    39     psF32 f  = PAR[PM_PAR_FLUX]*r + PAR[PM_PAR_SKY];
     39    psF32 f  = PAR[PM_PAR_I0]*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[PM_PAR_FLUX]*r*r;
     43        psF32 t = PAR[PM_PAR_I0]*r*r;
    4444        psF32 q = t*(PAR[PM_PAR_7]*p + 4*PAR[PM_PAR_8]*pr3);
    4545
    … …  
    245245    norm *= 0.01;
    246246   
    247     psF64 Flux = PAR[PM_PAR_FLUX] * Area * norm;
     247    psF64 Flux = PAR[PM_PAR_I0] * Area * norm;
    248248
    249249    return(Flux);
    … …  
    262262
    263263    if (flux <= 0) return (1.0);
    264     if (PAR[PM_PAR_FLUX] <= 0) return (1.0);
    265     if (flux >= PAR[PM_PAR_FLUX]) return (1.0);
     264    if (PAR[PM_PAR_I0] <= 0) return (1.0);
     265    if (flux >= PAR[PM_PAR_I0]) return (1.0);
    266266
    267267    // convert Sx,Sy,Sxy to major/minor axes
    … …  
    272272    axes = EllipseShapeToAxes (shape);
    273273    psF64 dr = 1.0 / axes.major;
    274     psF64 limit = flux / PAR[PM_PAR_FLUX];
     274    psF64 limit = flux / PAR[PM_PAR_I0];
    275275
    276276    // XXX : we can do this faster with an intelligent starting choice
    … …  
    329329    status = true;
    330330    status &= (dP < 0.5);
    331     status &= (PAR[PM_PAR_FLUX] > 0);
    332     status &= ((dPAR[PM_PAR_FLUX]/PAR[PM_PAR_FLUX]) < 0.5);
     331    status &= (PAR[PM_PAR_I0] > 0);
     332    status &= ((dPAR[PM_PAR_I0]/PAR[PM_PAR_I0]) < 0.5);
    333333    status &= (fabs(PAR[PM_PAR_8]) < 0.5);
    334334    status &= (dPAR[PM_PAR_8] < 0.1);

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

    r8882 r9529  
    155155    status = true;
    156156    status &= (dP < 0.5);
    157     status &= (PAR[PM_PAR_FLUX] > 0);
    158     status &= ((dPAR[PM_PAR_FLUX]/PAR[PM_PAR_FLUX]) < 0.5);
     157    status &= (PAR[PM_PAR_I0] > 0);
     158    status &= ((dPAR[PM_PAR_I0]/PAR[PM_PAR_I0]) < 0.5);
    159159
    160160    if (status)

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

    r8882 r9529  
    3535
    3636    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];
     37    psF32 f  = PAR[PM_PAR_I0]*r + PAR[PM_PAR_SKY];
    3838
    3939    if (deriv != NULL) {
    40         psF32 t = PAR[PM_PAR_FLUX]*r*r; // df/dR
     40        psF32 t = PAR[PM_PAR_I0]*r*r;   // df/dR
    4141        psF32 q = t*(TRF*er + PAR[PM_PAR_7] + TG_S*pow(z, dTG_S));  // (df/dR)(dR/dz)
    4242
    … …  
    127127    norm *= 0.01;
    128128   
    129     psF64 Flux = PAR[PM_PAR_FLUX] * Area * norm;
     129    psF64 Flux = PAR[PM_PAR_I0] * Area * norm;
    130130
    131131    return(Flux);
    … …  
    140140
    141141    if (flux <= 0) return (1.0);
    142     if (PAR[PM_PAR_FLUX] <= 0) return (1.0);
    143     if (flux >= PAR[PM_PAR_FLUX]) return (1.0);
     142    if (PAR[PM_PAR_I0] <= 0) return (1.0);
     143    if (flux >= PAR[PM_PAR_I0]) return (1.0);
    144144
    145145    // if Sx == Sy, sigma = Sx == Sy
    146146    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[PM_PAR_FLUX];
     148    psF64 limit = flux / PAR[PM_PAR_I0];
    149149
    150150    // we can do this much better with intelligent choices here
    … …  
    193193    status = true;
    194194    status &= (dP < 0.5);
    195     status &= (PAR[PM_PAR_FLUX] > 0);
    196     status &= ((dPAR[PM_PAR_FLUX]/PAR[PM_PAR_FLUX]) < 0.5);
     195    status &= (PAR[PM_PAR_I0] > 0);
     196    status &= ((dPAR[PM_PAR_I0]/PAR[PM_PAR_I0]) < 0.5);
    197197
    198198    if (status) return true;

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

    r8882 r9529  
    3232    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[PM_PAR_FLUX]*r + PAR[PM_PAR_SKY];
     34    psF32 f  = PAR[PM_PAR_I0]*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[PM_PAR_FLUX]*r*r;
     38        psF32 t = PAR[PM_PAR_I0]*r*r;
    3939        psF32 q = t*(PAR[PM_PAR_7]*p + 4*PAR8*pr*pr*pr);
    4040
    … …  
    7272    norm *= 0.01;
    7373   
    74     psF64 Flux = PAR[PM_PAR_FLUX] * Area * norm;
     74    psF64 Flux = PAR[PM_PAR_I0] * Area * norm;
    7575
    7676    return(Flux);
    … …  
    8989
    9090    if (flux <= 0) return (1.0);
    91     if (PAR[PM_PAR_FLUX] <= 0) return (1.0);
    92     if (flux >= PAR[PM_PAR_FLUX]) return (1.0);
     91    if (PAR[PM_PAR_I0] <= 0) return (1.0);
     92    if (flux >= PAR[PM_PAR_I0]) return (1.0);
    9393
    9494    // convert Sx,Sy,Sxy to major/minor axes
    … …  
    9999    axes = EllipseShapeToAxes (shape);
    100100    psF64 dr = 1.0 / axes.major;
    101     psF64 limit = flux / PAR[PM_PAR_FLUX];
     101    psF64 limit = flux / PAR[PM_PAR_I0];
    102102
    103103    // XXX : we can do this faster with an intelligent starting choice

  • trunk/psphot/src/psphotApResid.c

    r9526 r9529  
    7373        }
    7474
    75         dMag->data.F64[Npsf] = model->dparams->data.F32[PM_PAR_FLUX] / model->params->data.F32[PM_PAR_FLUX];
     75        dMag->data.F64[Npsf] = model->dparams->data.F32[PM_PAR_I0] / model->params->data.F32[PM_PAR_I0];
    7676
    7777        psVectorExtend (mask,    100, 1);

  • trunk/psphot/src/psphotEnsemblePSF.c

    r9527 r9529  
    119119        // set model to unit peak, zero sky (we assume sky is subtracted)
    120120        model->params->data.F32[PM_PAR_SKY] = 0.0;
    121         model->params->data.F32[PM_PAR_FLUX] = 1.0;
     121        model->params->data.F32[PM_PAR_I0] = 1.0;
    122122
    123123        // fill in the model pixel values
    … …  
    200200            psAbort ("psphot", "ensemble source is nan");
    201201        }
    202         Fi->modelPSF->params->data.F32[PM_PAR_FLUX] = norm->data.F32[i];
    203         Fi->modelPSF->dparams->data.F32[PM_PAR_FLUX] = sqrt(sqrt(2) * norm->data.F32[i] / (sparse->Bfj->data.F32[i] * weight->data.F32[i]));
     202        Fi->modelPSF->params->data.F32[PM_PAR_I0] = norm->data.F32[i];
     203        Fi->modelPSF->dparams->data.F32[PM_PAR_I0] = sqrt(sqrt(2) * norm->data.F32[i] / (sparse->Bfj->data.F32[i] * weight->data.F32[i]));
    204204        // XXX EAM : this factor of sqrt(2) makes the errors consistent, but I don't understand it
    205205

  • trunk/psphot/src/psphotGrowthCurve.c

    r9526 r9529  
    2424    // create an object with center intensity of 1000
    2525    modelRef->params->data.F32[PM_PAR_SKY] = 0;
    26     modelRef->params->data.F32[PM_PAR_FLUX] = 1000;
     26    modelRef->params->data.F32[PM_PAR_I0] = 1000;
    2727    modelRef->params->data.F32[PM_PAR_XPOS] = xc;
    2828    modelRef->params->data.F32[PM_PAR_YPOS] = yc;
Note: See TracChangeset for help on using the changeset viewer.