IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Jun 20, 2012, 12:22:52 PM (14 years ago)
Author:
eugene
Message:

merge changes from trunk

Location:
branches/eam_branches/ipp-20120601
Files:
21 edited

Legend:

Unmodified
Added
Removed

  • branches/eam_branches/ipp-20120601

  • branches/eam_branches/ipp-20120601/Ohana/src/opihi/cmd.astro

    • Property svn:mergeinfo changed (with no actual effect on merging)

  • branches/eam_branches/ipp-20120601/ippTasks/addstar.pro

    r33706 r34049  
    321321    end
    322322    if ("$STAGE" == "staticsky")
    323       $run = $run --multi_num $STAGE_EXTRA1
     323      $run = $run --stage_extra1 $STAGE_EXTRA1  --stage_id $STAGE_ID
    324324    end
    325325    if ("$STAGE" == "cam")

  • branches/eam_branches/ipp-20120601/ppImage/src

    • Property svn:mergeinfo changed (with no actual effect on merging)

  • branches/eam_branches/ipp-20120601/psModules

  • branches/eam_branches/ipp-20120601/psModules/src/objects/pmModelFuncs.h

    r33963 r34049  
    2929# define PM_MODEL_FUNCS_H
    3030
     31# define HAVE_MODEL_VAR 1
     32
    3133/// @addtogroup Objects Object Detection / Analysis Functions
    3234/// @{
    … …  
    5557    PM_MODEL_OP_NORM     = 0x20,
    5658    PM_MODEL_OP_NOISE    = 0x40,
     59# if (HAVE_MODEL_VAR)
    5760    PM_MODEL_OP_MODELVAR = 0x80,
     61# endif
    5862} pmModelOpMode;
    5963

  • branches/eam_branches/ipp-20120601/psModules/src/objects/pmSource.c

    r34044 r34049  
    5151    psFree(tmp->pixels);
    5252    psFree(tmp->variance);
     53# if (HAVE_MODEL_VAR)
    5354    psFree(tmp->modelVar);
     55# endif
    5456    psFree(tmp->maskObj);
    5557    psFree(tmp->maskView);
    … …  
    7880    psFree (source->pixels);
    7981    psFree (source->variance);
     82# if (HAVE_MODEL_VAR)
    8083    psFree (source->modelVar);
     84# endif
    8185    psFree (source->maskObj);
    8286    psFree (source->maskView);
    … …  
    8690    source->pixels = NULL;
    8791    source->variance = NULL;
     92# if (HAVE_MODEL_VAR)
    8893    source->modelVar = NULL;
     94# endif
    8995    source->maskObj = NULL;
    9096    source->maskView = NULL;
    … …  
    116122    source->pixels = NULL;
    117123    source->variance = NULL;
     124# if (HAVE_MODEL_VAR)
    118125    source->modelVar = NULL;
     126# endif
    119127    source->maskObj = NULL;
    120128    source->maskView = NULL;
    … …  
    204212    source->pixels   = in->pixels   ? psImageCopyView(NULL, in->pixels)   : NULL;
    205213    source->variance = in->variance ? psImageCopyView(NULL, in->variance) : NULL;
     214# if (HAVE_MODEL_VAR)
    206215    source->modelVar = NULL;
     216# endif
    207217    source->maskView = in->maskView ? psImageCopyView(NULL, in->maskView) : NULL;
    208218
    … …  
    10331043
    10341044    bool addNoise = mode & PM_MODEL_OP_NOISE;
     1045
     1046# if (HAVE_MODEL_VAR)
    10351047    bool addModelVar = mode & PM_MODEL_OP_MODELVAR;
    1036 
    10371048    if (addModelVar) psAssert (source->modelVar, "programming error");
     1049# endif
    10381050
    10391051    // require the use of pmModelAddWithOffset if we are adding noise (because the model size and norm are rescaled)
    … …  
    10581070        }
    10591071
     1072# if (HAVE_MODEL_VAR)
    10601073        psF32 **target = addModelVar ? source->modelVar->data.F32 : source->pixels->data.F32;
     1074# else
     1075        psF32 **target = source->pixels->data.F32;
     1076# endif
    10611077
    10621078        for (int iy = 0; iy < source->modelFlux->numRows; iy++) {
    … …  
    10731089            }
    10741090        }
     1091# if (HAVE_MODEL_VAR)
    10751092        if (!addModelVar) {
    10761093            if (add) {
    … …  
    10801097            }
    10811098        }
     1099# else
     1100        if (add) {
     1101            source->tmpFlags &= ~PM_SOURCE_TMPF_SUBTRACTED;
     1102        } else {
     1103            source->tmpFlags |= PM_SOURCE_TMPF_SUBTRACTED;
     1104        }
     1105# endif
    10821106        return true;
    10831107    }
    … …  
    10871111        target = source->variance;
    10881112    }
     1113# if (HAVE_MODEL_VAR)
    10891114    if (addModelVar) {
    10901115        target = source->modelVar;
    10911116    }
     1117# endif
    10921118
    10931119    if (add) {
    10941120        status = pmModelAddWithOffset (target, source->maskObj, model, PM_MODEL_OP_FULL, maskVal, dx, dy);
     1121# if (HAVE_MODEL_VAR)
    10951122        if (!addNoise && !addModelVar) source->tmpFlags &= ~PM_SOURCE_TMPF_SUBTRACTED;
     1123# else
     1124        source->tmpFlags &= ~PM_SOURCE_TMPF_SUBTRACTED;
     1125# endif
    10961126    } else {
    10971127        status = pmModelSubWithOffset (target, source->maskObj, model, PM_MODEL_OP_FULL, maskVal, dx, dy);
     1128# if (HAVE_MODEL_VAR)
    10981129        if (!addNoise && !addModelVar) source->tmpFlags |= PM_SOURCE_TMPF_SUBTRACTED;
     1130# else
     1131        source->tmpFlags |= PM_SOURCE_TMPF_SUBTRACTED;
     1132# endif
    10991133    }
    11001134    if (!status) {

  • branches/eam_branches/ipp-20120601/psModules/src/objects/pmSource.h

    r33963 r34049  
    7272    psImage *pixels;                    ///< Rectangular region including object pixels.
    7373    psImage *variance;                  ///< Image variance.
     74# if (HAVE_MODEL_VAR)
    7475    psImage *modelVar;                  ///< variance based on current models
     76# endif
    7577    psImage *maskObj;                   ///< unique mask for this object which marks included pixels associated with objects.
    7678    psImage *maskView;                  ///< view into global image mask for this object region

  • branches/eam_branches/ipp-20120601/psModules/src/objects/pmSourcePhotometry.c

    r33963 r34049  
    899899}
    900900
     901# if (HAVE_MODEL_VAR)
    901902double pmSourceModelWeight(const pmSource *Mi, int term, const pmSourceFitVarMode fitVarMode, const float covarFactor, psImageMaskType maskVal)
     903# else
     904double pmSourceModelWeight(const pmSource *Mi, int term, const bool unweighted_sum, const float covarFactor, psImageMaskType maskVal)
     905# endif
    902906{
    903907    PS_ASSERT_PTR_NON_NULL(Mi, NAN);
     908# if (HAVE_MODEL_VAR)
    904909    double flux = 0, wt = 1.0, factor = 0;
     910# else
     911    double flux = 0, wt = 0, factor = 0;
     912# endif
    905913
    906914    const psImage *Pi = Mi->modelFlux;
    907915    assert (Pi != NULL);
    908916
     917# if (HAVE_MODEL_VAR)
    909918    const psImage *Wi = NULL;
    910919    switch (fitVarMode) {
    … …  
    922931        psAbort("programming error");
    923932    }   
    924 
     933# else
     934    const psImage *Wi = Mi->variance;
     935    if (!unweighted_sum) {
     936        assert (Wi != NULL);
     937    }
     938# endif
    925939    const psImage *Ti = Mi->maskObj;
    926940    assert (Ti != NULL);
    … …  
    928942    for (int yi = 0; yi < Pi->numRows; yi++) {
    929943        for (int xi = 0; xi < Pi->numCols; xi++) {
    930             if (Ti->data.PS_TYPE_IMAGE_MASK_DATA[yi][xi] & maskVal) continue;
     944            if (Ti->data.PS_TYPE_IMAGE_MASK_DATA[yi][xi] & maskVal)
     945                continue;
     946# if (HAVE_MODEL_VAR)
    931947            if (fitVarMode != PM_SOURCE_PHOTFIT_CONST) {
    932948                wt = covarFactor * Wi->data.F32[yi][xi];
    933949                if (wt == 0) continue;
    934950            }
     951# else
     952            if (!unweighted_sum) {
     953                wt = covarFactor * Wi->data.F32[yi][xi];
     954                if (wt == 0)
     955                    continue;
     956            }
     957# endif
    935958
    936959            switch (term) {
    … …  
    948971            }
    949972
     973# if (HAVE_MODEL_VAR)
    950974            // wt is 1.0 for CONST
    951975            flux += (factor * Pi->data.F32[yi][xi]) / wt;
     976# else
     977            if (unweighted_sum) {
     978                flux += (factor * Pi->data.F32[yi][xi]);
     979            } else {
     980                flux += (factor * Pi->data.F32[yi][xi]) / wt;
     981            }
     982# endif
    952983        }
    953984    }
    … …  
    955986}
    956987
     988# if (HAVE_MODEL_VAR)
    957989double pmSourceModelDotModel (const pmSource *Mi, const pmSource *Mj, const pmSourceFitVarMode fitVarMode, const float covarFactor, psImageMaskType maskVal)
     990# else
     991double pmSourceModelDotModel (const pmSource *Mi, const pmSource *Mj, const bool unweighted_sum, const float covarFactor, psImageMaskType maskVal)
     992# endif
    958993{
    959994    PS_ASSERT_PTR_NON_NULL(Mi, NAN);
    … …  
    963998    int xIs, xJs, yIs, yJs;
    964999    int xIe, yIe;
     1000# if (HAVE_MODEL_VAR)
    9651001    double flux;
    9661002    double wt = 1.0;
     1003# else
     1004    double flux, wt;
     1005# endif
    9671006
    9681007    const psImage *Pi = Mi->modelFlux;
    … …  
    9711010    assert (Pj != NULL);
    9721011
     1012# if (HAVE_MODEL_VAR)
    9731013    const psImage *Wi = NULL;
    9741014    switch (fitVarMode) {
    … …  
    9861026        psAbort("programming error");
    9871027    }   
     1028# else
     1029    const psImage *Wi = Mi->variance;
     1030    if (!unweighted_sum) {
     1031        assert (Wi != NULL);
     1032    }
     1033# endif
    9881034
    9891035    const psImage *Ti = Mi->maskObj;
    … …  
    10151061                continue;
    10161062
     1063# if (HAVE_MODEL_VAR)
    10171064            float value = (Pi->data.F32[yi][xi] * Pj->data.F32[yj][xj]);
    10181065            switch (fitVarMode) {
    … …  
    10311078
    10321079            flux += value / wt;
     1080# else
     1081            // XXX skip the nonsense weight pixels?
     1082            if (unweighted_sum) {
     1083                flux += (Pi->data.F32[yi][xi] * Pj->data.F32[yj][xj]);
     1084            } else {
     1085                wt = covarFactor * Wi->data.F32[yi][xi];
     1086                if (wt > 0) {
     1087                    flux += (Pi->data.F32[yi][xi] * Pj->data.F32[yj][xj]) / wt;
     1088                }
     1089            }
     1090# endif
    10331091        }
    10341092    }
    … …  
    10361094}
    10371095
     1096# if (HAVE_MODEL_VAR)
    10381097double pmSourceDataDotModel (const pmSource *Mi, const pmSource *Mj, const pmSourceFitVarMode fitVarMode, const float covarFactor, psImageMaskType maskVal)
     1098# else
     1099double pmSourceDataDotModel (const pmSource *Mi, const pmSource *Mj, const bool unweighted_sum, const float covarFactor, psImageMaskType maskVal)
     1100# endif
    10391101{
    10401102    PS_ASSERT_PTR_NON_NULL(Mi, NAN);
    … …  
    10441106    int xIs, xJs, yIs, yJs;
    10451107    int xIe, yIe;
     1108# if (HAVE_MODEL_VAR)
    10461109    double flux;
    10471110    double wt = 1.0;
     1111# else
     1112    double flux, wt;
     1113# endif
    10481114
    10491115    const psImage *Pi = Mi->pixels;
    … …  
    10521118    assert (Pj != NULL);
    10531119
     1120# if (HAVE_MODEL_VAR)
    10541121    const psImage *Wi = NULL;
    10551122    switch (fitVarMode) {
    … …  
    10671134        psAbort("programming error");
    10681135    }   
     1136# else
     1137    const psImage *Wi = Mi->variance;
     1138    if (!unweighted_sum) {
     1139        assert (Wi != NULL);
     1140    }
     1141# endif
    10691142
    10701143    const psImage *Ti = Mi->maskObj;
    … …  
    10961169                continue;
    10971170
     1171# if (HAVE_MODEL_VAR)
    10981172            float value = (Pi->data.F32[yi][xi] * Pj->data.F32[yj][xj]);
    10991173            switch (fitVarMode) {
    … …  
    11131187            flux += value / wt;
    11141188
     1189# else
     1190            // XXX skip the nonsense weight pixels?
     1191            if (unweighted_sum) {
     1192                flux += (Pi->data.F32[yi][xi] * Pj->data.F32[yj][xj]);
     1193            } else {
     1194                wt = covarFactor * Wi->data.F32[yi][xi];
     1195                if (wt > 0) {
     1196                    flux += (Pi->data.F32[yi][xi] * Pj->data.F32[yj][xj]) / wt;
     1197                }
     1198            }
     1199# endif
    11151200        }
    11161201    }

  • branches/eam_branches/ipp-20120601/psModules/src/objects/pmSourcePhotometry.h

    r33963 r34049  
    3838} pmSourcePhotometryMode;
    3939
     40# if (HAVE_MODEL_VAR)
    4041typedef enum {
    4142    PM_SOURCE_PHOTFIT_NONE       = 0,
    … …  
    4445    PM_SOURCE_PHOTFIT_MODEL_VAR  = 3,
    4546} pmSourceFitVarMode;
     47# endif
    4648
    4749bool pmSourcePhotometryModel(
    … …  
    8284bool pmSourceMeasureDiffStats (pmSource *source, psImageMaskType maskVal, psImageMaskType markVal);
    8385
     86# if (HAVE_MODEL_VAR)
    8487double pmSourceDataDotModel (const pmSource *Mi, const pmSource *Mj, const pmSourceFitVarMode fitVarMode, const float covarFactor, psImageMaskType maskVal);
    8588double pmSourceModelDotModel (const pmSource *Mi, const pmSource *Mj, const pmSourceFitVarMode fitVarMode, const float covarFactor, psImageMaskType maskVal);
    8689double pmSourceModelWeight(const pmSource *Mi, int term, const pmSourceFitVarMode fitVarMode, const float covarFactor, psImageMaskType maskVal);
     90# else
     91double pmSourceDataDotModel (const pmSource *Mi, const pmSource *Mj, const bool unweighted_sum, const float covarFactor, psImageMaskType maskVal);
     92double pmSourceModelDotModel (const pmSource *Mi, const pmSource *Mj, const bool unweighted_sum, const float covarFactor, psImageMaskType maskVal);
     93double pmSourceModelWeight(const pmSource *Mi, int term, const bool unweighted_sum, const float covarFactor, psImageMaskType maskVal);
     94# endif
    8795
    8896bool pmSourceNeighborFlags (pmSource *source);

  • branches/eam_branches/ipp-20120601/psphot

  • branches/eam_branches/ipp-20120601/psphot/src

  • branches/eam_branches/ipp-20120601/psphot/src/psphot.h

    r33963 r34049  
    9999
    100100bool            psphotFitSourcesLinear (pmConfig *config, const pmFPAview *view, const char *filerule, bool final);
     101
     102# if (HAVE_MODEL_VAR)
    101103bool            psphotFitSourcesLinearReadout (psMetadata *recipe, pmReadout *readout, psArray *sources, pmPSF *psf, bool final, pmSourceFitVarMode fitVarMode);
     104# else
     105bool            psphotFitSourcesLinearReadout (psMetadata *recipe, pmReadout *readout, psArray *sources, pmPSF *psf, bool final);
     106# endif
    102107
    103108bool            psphotSourceSize (pmConfig *config, const pmFPAview *view, const char *filerule, bool getPSFsize);

  • branches/eam_branches/ipp-20120601/psphot/src/psphotAddNoise.c

    r32348 r34049  
    4747
    4848    psArray *sources = detections->allSources;
    49     psAssert (sources, "missing sources?");
     49    //psAssert (sources, "missing sources?");
     50    // if no work, should just return true
     51    if (!sources) return true;
    5052
    5153    psTimerStart ("psphot.noise");

  • branches/eam_branches/ipp-20120601/psphot/src/psphotEfficiency.c

    r33963 r34049  
    420420
    421421    // psphotFitSourcesLinearReadout subtracts the model fits
     422# if (HAVE_MODEL_VAR)
    422423    if (!psphotFitSourcesLinearReadout(recipe, readout, fakeSourcesAll, psf, true, PM_SOURCE_PHOTFIT_CONST)) {
     424# else
     425    if (!psphotFitSourcesLinearReadout(recipe, readout, fakeSourcesAll, psf, true)) {
     426# endif
    423427        psError(PS_ERR_UNKNOWN, false, "Unable to perform linear fit on fake sources.");
    424428        psFree(fakeSources);

  • branches/eam_branches/ipp-20120601/psphot/src/psphotFitSourcesLinear.c

    r33963 r34049  
    1212static bool SetBorderMatrixElements (psSparseBorder *border, pmReadout *readout, psArray *sources, bool constant_weights, int SKY_FIT_ORDER, psImageMaskType markVal);
    1313
     14# if (HAVE_MODEL_VAR)
    1415bool psphotGenerateModelVariance (pmConfig *config, const pmFPAview *view, pmFPAfile *file, int index, psMetadata *recipe, pmReadout *readout, psArray *sources);
    1516pmSourceFitVarMode psphotGetFitVarMode (psMetadata *recipe);
    1617bool psphotFreeModelVariance (pmReadout *readout, psArray *sources);
     18# endif
    1719
    1820// for now, let's store the detections on the readout->analysis for each readout
    … …  
    2830    assert (recipe);
    2931
     32# if (HAVE_MODEL_VAR)
    3033    pmSourceFitVarMode fitVarMode = psphotGetFitVarMode (recipe);
    3134    if (!fitVarMode) {
    … …  
    3740    // do a single pass.
    3841    pmSourceFitVarMode fitVarModePass1 = (fitVarMode == PM_SOURCE_PHOTFIT_MODEL_VAR) ? PM_SOURCE_PHOTFIT_CONST : fitVarMode;
     42# endif
    3943
    4044    int num = psphotFileruleCount(config, filerule);
    … …  
    6468        psAssert (psf, "missing psf?");
    6569
    66         if (!psphotFitSourcesLinearReadout (recipe, readout, sources, psf, final, fitVarModePass1)) {
     70# if (HAVE_MODEL_VAR)
     71        if (!psphotFitSourcesLinearReadout (recipe, readout, sources, psf, final, fitVarModePass1))
     72# else
     73        if (!psphotFitSourcesLinearReadout (recipe, readout, sources, psf, final))
     74# endif
     75        {
    6776            psError (PSPHOT_ERR_CONFIG, false, "failed to fit sources (linear) for %s entry %d", filerule, i);
    6877            return false;
    6978        }
    7079
     80# if (HAVE_MODEL_VAR)
    7181        // the MODEL_VAR weighting scheme requires knowledge of the model fluxes to generate the variance
    7282        // after we have determined the initial set of fits, then we can generate the variance image and
    … …  
    94104            }
    95105        }
     106# endif
    96107
    97108        psphotVisualShowResidualImage (readout, (num > 0));
    … …  
    102113}
    103114
     115# if (HAVE_MODEL_VAR)
    104116// look up the fit variance mode from the recipe; older recipes do not have the value
    105117// 'LINEAR_FIT_VARIANCE_MODE'; in those cases, look for 'CONSTANT_PHOTOMETRIC_WEIGHTS' as a boolean and
    … …  
    130142    return PM_SOURCE_PHOTFIT_NONE;
    131143}
    132 
    133 bool psphotFitSourcesLinearReadout (psMetadata *recipe, pmReadout *readout, psArray *sources, pmPSF *psf, bool final, pmSourceFitVarMode fitVarMode) {
    134 
     144# endif
     145
     146# if (HAVE_MODEL_VAR)
     147bool psphotFitSourcesLinearReadout (psMetadata *recipe, pmReadout *readout, psArray *sources, pmPSF *psf, bool final, pmSourceFitVarMode fitVarMode)
     148# else
     149bool psphotFitSourcesLinearReadout (psMetadata *recipe, pmReadout *readout, psArray *sources, pmPSF *psf, bool final)
     150# endif
     151{
    135152    bool status;
    136153    float x;
    … …  
    168185    if (psRegionIsNaN (AnalysisRegion)) psAbort("analysis region mis-defined");
    169186
     187# if (!HAVE_MODEL_VAR)
     188    bool CONSTANT_PHOTOMETRIC_WEIGHTS =
     189        psMetadataLookupBool(&status, recipe, "CONSTANT_PHOTOMETRIC_WEIGHTS");
     190    if (!status) {
     191        psAbort("You must provide a value for the BOOL recipe CONSTANT_PHOTOMETRIC_WEIGHTS");
     192    }
     193# endif
    170194    int SKY_FIT_ORDER = psMetadataLookupS32(&status, recipe, "SKY_FIT_ORDER");
    171195    if (!status) {
    … …  
    295319    psSparseBorder *border = psSparseBorderAlloc (sparse, nBorder);
    296320
     321# if (HAVE_MODEL_VAR)
    297322    // if fitVarMode is MODEL_VAR, then we need to generate the model image variance
    298323    // XXX we have two possibilities here:
    … …  
    302327
    303328    // 2) do a single pass, and use the model guess to define the model variance (but do I trust the Model Guess?)
     329# endif
    304330
    305331    // fill out the sparse matrix elements and border elements (B)
    … …  
    310336
    311337        // diagonal elements of the sparse matrix (auto-cross-product)
     338# if (HAVE_MODEL_VAR)
    312339        f = pmSourceModelDotModel (SRCi, SRCi, fitVarMode, covarFactor, maskVal);
     340# else
     341        f = pmSourceModelDotModel (SRCi, SRCi, CONSTANT_PHOTOMETRIC_WEIGHTS, covarFactor, maskVal);
     342# endif
    313343        psSparseMatrixElement (sparse, i, i, f);
    314344
     345# if (HAVE_MODEL_VAR)
    315346        // if we have used CONSTANT errors, then we need to calculate the value of the parameter error
    316347        if (fitVarMode != PM_SOURCE_PHOTFIT_IMAGE_VAR) {
    … …  
    320351            errors->data.F32[i] = 1.0 / sqrt(f);
    321352        }
    322 
     353# else
     354        // the formal error depends on the weighting scheme
     355        if (CONSTANT_PHOTOMETRIC_WEIGHTS) {
     356            float var = pmSourceModelDotModel (SRCi, SRCi, false, covarFactor, maskVal);
     357            errors->data.F32[i] = 1.0 / sqrt(var);
     358        } else {
     359            errors->data.F32[i] = 1.0 / sqrt(f);
     360        }
     361# endif
    323362
    324363        // find the image x model value
     364# if (HAVE_MODEL_VAR)
    325365        f = pmSourceDataDotModel (SRCi, SRCi, fitVarMode, covarFactor, maskVal);
     366# else
     367        f = pmSourceDataDotModel (SRCi, SRCi, CONSTANT_PHOTOMETRIC_WEIGHTS, covarFactor, maskVal);
     368# endif
    326369        psSparseVectorElement (sparse, i, f);
    327370
    … …  
    329372        switch (SKY_FIT_ORDER) {
    330373          case 1:
     374# if (HAVE_MODEL_VAR)
    331375            f = pmSourceModelWeight (SRCi, 1, fitVarMode, covarFactor, maskVal);
    332376            psSparseBorderElementB (border, i, 1, f);
    333377            f = pmSourceModelWeight (SRCi, 2, fitVarMode, covarFactor, maskVal);
    334378            psSparseBorderElementB (border, i, 2, f);
     379# else
     380            f = pmSourceModelWeight (SRCi, 1, CONSTANT_PHOTOMETRIC_WEIGHTS, covarFactor, maskVal);
     381            psSparseBorderElementB (border, i, 1, f);
     382            f = pmSourceModelWeight (SRCi, 2, CONSTANT_PHOTOMETRIC_WEIGHTS, covarFactor, maskVal);
     383            psSparseBorderElementB (border, i, 2, f);
     384# endif
    335385
    336386          case 0:
     387# if (HAVE_MODEL_VAR)
    337388            f = pmSourceModelWeight (SRCi, 0, fitVarMode, covarFactor, maskVal);
     389# else
     390            f = pmSourceModelWeight (SRCi, 0, CONSTANT_PHOTOMETRIC_WEIGHTS, covarFactor, maskVal);
     391# endif
    338392            psSparseBorderElementB (border, i, 0, f);
    339393            break;
    … …  
    355409
    356410            // got an overlap; calculate cross-product and add to output array
     411# if (HAVE_MODEL_VAR)
    357412            f = pmSourceModelDotModel (SRCi, SRCj, fitVarMode, covarFactor, maskVal);
     413# else
     414            f = pmSourceModelDotModel (SRCi, SRCj, CONSTANT_PHOTOMETRIC_WEIGHTS, covarFactor, maskVal);
     415# endif
    358416            psSparseMatrixElement (sparse, j, i, f);
    359417        }
    … …  
    393451
    394452    // set the sky, sky_x, sky_y components of border matrix
     453# if (HAVE_MODEL_VAR)
    395454    SetBorderMatrixElements (border, readout, fitSources, (fitVarMode == PM_SOURCE_PHOTFIT_CONST), SKY_FIT_ORDER, markVal);
     455# else
     456    SetBorderMatrixElements (border, readout, fitSources, CONSTANT_PHOTOMETRIC_WEIGHTS, SKY_FIT_ORDER, markVal);
     457# endif
    396458
    397459    psSparseConstraint constraint;
    … …  
    552614}
    553615
     616# if (HAVE_MODEL_VAR)
    554617bool psphotModelBackgroundReadout(psImage *model,  // Model image
    555618                                  psImage *modelStdev, // Model stdev image
    … …  
    661724    return true;
    662725}
     726# endif

  • branches/eam_branches/ipp-20120601/psphot/src/psphotReplaceUnfit.c

    r32721 r34049  
    6060
    6161    psArray *sources = detections->allSources;
    62     psAssert (sources, "missing sources?");
     62    //psAssert (sources, "missing sources?");
     63    if (!sources) return true;
    6364
    6465    // user-defined masks to test for good/bad pixels (build from recipe list if not yet set)
    … …  
    139140
    140141    psArray *sources = detections->allSources;
    141     psAssert (sources, "missing sources?");
    142 
     142    //psAssert (sources, "missing sources?");
     143    if (!sources) return true;
     144   
    143145    // user-defined masks to test for good/bad pixels (build from recipe list if not yet set)
    144146    psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels

  • branches/eam_branches/ipp-20120601/psphot/src/psphotStackImageLoop.c

    • Property svn:mergeinfo changed (with no actual effect on merging)

  • branches/eam_branches/ipp-20120601/pstamp/scripts

    • Property svn:mergeinfo changed (with no actual effect on merging)

  • branches/eam_branches/ipp-20120601/psvideophot

    • Property svn:mergeinfo changed (with no actual effect on merging)

  • branches/eam_branches/ipp-20120601/tools/regpeek.pl

    r32419 r34049  
    33use DBI;
    44use Getopt::Long qw( GetOptions :config auto_help auto_version gnu_getopt );
     5use PS::IPP::Config 1.0.1 qw( :standard );
     6
     7my $ipprc =  PS::IPP::Config->new(); # IPP Configuration
     8my $siteConfig = $ipprc->{_siteConfig};
    59
    610my $dbname = 'gpc1';
    … …  
    6569
    6670sub init_gpc_db {
     71    ## change to use the siteConfig setting, while readonly probably do not want to use a readonly replicated DB incase it gets behind
    6772    use constant DB_SOCKET => '/var/run/mysqld/mysqld.sock';
    68     my $dbserver = 'ippdb01';
    69     my $dbuser = 'ippuser';
    70     my $dbpass = 'ippuser';
     73    #my $dbserver = 'ippdb01';
     74    #my $dbuser = 'ippuser';
     75    #my $dbpass = 'ippuser';
     76    my $dbserver = metadataLookupStr($siteConfig, 'DBSERVER');
     77    my $dbuser = metadataLookupStr($ipprc->{_siteConfig}, "RO_DBUSER");
     78    my $dbpass = metadataLookupStr($ipprc->{_siteConfig}, "RO_DBPASSWORD");
     79    die "database configuration not set up" unless defined($dbserver);
     80    die "database configuration not set up" unless defined($dbuser);
     81    die "database configuration not set up" unless defined($dbpass);
    7182    $db = DBI->connect("DBI:mysql:database=${dbname};host=${dbserver};" .
    7283                       "mysql_socket=" . DB_SOCKET(),
    7384                       ${dbuser},${dbpass},
    74 { RaiseError => 1, AutoCommit => 1}
     85                       { RaiseError => 1, AutoCommit => 1}
    7586        ) or die "Unable to connect to database $DBI::errstr\n";
    7687return($db);
Note: See TracChangeset for help on using the changeset viewer.