Index: /trunk/psModules/src/camera/pmFPAfileIO.c =================================================================== --- /trunk/psModules/src/camera/pmFPAfileIO.c (revision 29003) +++ /trunk/psModules/src/camera/pmFPAfileIO.c (revision 29004) @@ -24,17 +24,26 @@ #include "pmFPAfileFitsIO.h" #include "pmFPAfileFringeIO.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmResiduals.h" -#include "pmGrowthCurve.h" -#include "pmTrend2D.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" #include "pmPSF.h" -#include "pmModel.h" -#include "pmSource.h" +#include "pmPSFtry.h" + #include "pmSourceIO.h" -#include "pmResiduals.h" #include "pmPSF_IO.h" + #include "pmAstrometryModel.h" #include "pmAstrometryRefstars.h" Index: /trunk/psModules/src/camera/pmReadoutFake.c =================================================================== --- /trunk/psModules/src/camera/pmReadoutFake.c (revision 29003) +++ /trunk/psModules/src/camera/pmReadoutFake.c (revision 29004) @@ -10,19 +10,26 @@ #include "pmFPA.h" -#include "pmMoments.h" + +#include "pmTrend2D.h" #include "pmResiduals.h" #include "pmGrowthCurve.h" -#include "pmTrend2D.h" -#include "pmPSF.h" -#include "pmModel.h" -#include "pmModelClass.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" +#include "pmMoments.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" #include "pmSource.h" -#include "pmSourceUtils.h" -#include "pmModelUtils.h" +#include "pmSourceFitModel.h" +#include "pmPSF.h" +#include "pmPSFtry.h" + #include "pmSourceGroups.h" - #include "pmReadoutFake.h" Index: /trunk/psModules/src/camera/pmReadoutFake.h =================================================================== --- /trunk/psModules/src/camera/pmReadoutFake.h (revision 29003) +++ /trunk/psModules/src/camera/pmReadoutFake.h (revision 29004) @@ -2,14 +2,14 @@ #define PM_READOUT_FAKE_H -#include -#include -#include - -#include -#include -#include -#include -#include -#include +// #include +// #include +// #include +// +// #include +// #include +// #include +// #include +// #include +// #include /// Set threading Index: /trunk/psModules/src/config/pmConfig.c =================================================================== --- /trunk/psModules/src/config/pmConfig.c (revision 29003) +++ /trunk/psModules/src/config/pmConfig.c (revision 29004) @@ -32,4 +32,5 @@ #include "pmConfig.h" +#include "pmVisualUtils.h" #ifdef HAVE_NEBCLIENT @@ -638,4 +639,25 @@ psArgumentVerbosity(argc, argv); // XXX: substitute the string for the default log level for "2". + } + + // Set the visualization levels + // argument format is: -visual (facil) (level) + while ((argNum = psArgumentGet(*argc, argv, "-visual"))) { + if ( (*argc < argNum + 3) ) { + psError(PS_ERR_IO, true, "-visual switch specified without facility and level."); + return NULL; + } + psArgumentRemove(argNum, argc, argv); + pmVisualSetLevel(argv[argNum], atoi(argv[argNum+1])); + psArgumentRemove(argNum, argc, argv); + psArgumentRemove(argNum, argc, argv); + } + if ((argNum = psArgumentGet(*argc, argv, "-visual-all"))) { + pmVisualSetLevel(".", 10); + psArgumentRemove(argNum, argc, argv); + } + if ((argNum = psArgumentGet(*argc, argv, "-visual-levels"))) { + pmVisualPrintLevels(stdout); + psArgumentRemove(argNum, argc, argv); } Index: /trunk/psModules/src/detrend/pmMaskStats.c =================================================================== --- /trunk/psModules/src/detrend/pmMaskStats.c (revision 29003) +++ /trunk/psModules/src/detrend/pmMaskStats.c (revision 29004) @@ -7,5 +7,4 @@ #include -#include #include "pmHDU.h" @@ -16,4 +15,5 @@ #include "pmFPAAstrometry.h" +#include "pmMaskStats.h" #define ESCAPE { \ Index: /trunk/psModules/src/detrend/pmShutterCorrection.c =================================================================== --- /trunk/psModules/src/detrend/pmShutterCorrection.c (revision 29003) +++ /trunk/psModules/src/detrend/pmShutterCorrection.c (revision 29004) @@ -302,5 +302,5 @@ PS_ASSERT_PTR_NON_NULL(guess, NULL); - psMinimization *minInfo = psMinimizationAlloc(15, 0.1); // Minimization information + psMinimization *minInfo = psMinimizationAlloc(15, 0.1, 1.0); // Minimization information psVector *params = psVectorAlloc (3, PS_TYPE_F32); // Fitting parameters Index: /trunk/psModules/src/extras/Makefile.am =================================================================== --- /trunk/psModules/src/extras/Makefile.am (revision 29003) +++ /trunk/psModules/src/extras/Makefile.am (revision 29004) @@ -9,4 +9,5 @@ pmKapaPlots.c \ pmVisual.c \ + pmVisualUtils.c \ ippStages.c @@ -17,4 +18,5 @@ pmKapaPlots.h \ pmVisual.h \ + pmVisualUtils.h \ ippDiffMode.h \ ippStages.h Index: /trunk/psModules/src/extras/pmVisual.c =================================================================== --- /trunk/psModules/src/extras/pmVisual.c (revision 29003) +++ /trunk/psModules/src/extras/pmVisual.c (revision 29004) @@ -21,16 +21,24 @@ #include "pmAstrometryObjects.h" #include "pmSubtractionStamps.h" + #include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" +#include "pmSpan.h" +#include "pmFootprintSpans.h" +#include "pmFootprint.h" +#include "pmPeaks.h" +#include "pmMoments.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" #include "pmPSF.h" #include "pmPSFtry.h" -#include "pmSource.h" + #include "pmFPAExtent.h" - -# if (HAVE_KAPA) -# include -# include "pmVisual.h" -# include "pmKapaPlots.h" -# define KAPAX 700 -# define KAPAY 700 #include "pmAstrometryVisual.h" @@ -38,4 +46,12 @@ #include "pmStackVisual.h" #include "pmSourceVisual.h" + +# if (HAVE_KAPA) +# include +#include "pmVisual.h" +#include "pmKapaPlots.h" + +# define KAPAX 700 +# define KAPAY 700 //#define TESTING @@ -102,5 +118,5 @@ /* Wait up to 1.0 second for a response, then continue */ - timeout.tv_sec = 2; + timeout.tv_sec = 10; timeout.tv_usec = 0; Index: /trunk/psModules/src/extras/pmVisualUtils.c =================================================================== --- /trunk/psModules/src/extras/pmVisualUtils.c (revision 29004) +++ /trunk/psModules/src/extras/pmVisualUtils.c (revision 29004) @@ -0,0 +1,505 @@ +/** These utility functions manage the visual level information (equivalent to pmVisual levels) + * @author Eugene Magnier, IfA + * @date June 18, 2010 + */ + +/* Include Files */ +#ifdef HAVE_CONFIG_H +#include +#endif + +#include +#include +#include +#include +#include +#include + +#include + +#define PM_UNKNOWN_VISUAL_LEVEL -9999 // we don't know this name's level +#define PM_DEFAULT_VISUAL_LEVEL -1 +#define PM_THE_OTHER_DEFAULT_VISUAL_LEVEL 0 // ??? +#define MAX_COMPONENT_LENGTH 1024 + +/** Basic structure for the component tree. A component is a string of the + form aaa.bbb.ccc, and may itself contain further subcomponents. The + Component structure doesn't in fact contain it's full name, but only the + last part. */ + +static pmVisualComponent* cRoot = NULL; // The root of the visual component tree + +/** static function prototypes **/ +static void componentFree(pmVisualComponent* comp); +static pmVisualComponent* componentAlloc(const char *name, int level); +static int getLevel(const char *facil); +static void initVisualLevels(void); +static void componentFree(pmVisualComponent* comp); +static pmVisualComponent* componentAlloc(const char *name, int level); +static void doGetVisualLevels(psMetadata *out, const pmVisualComponent* comp, psString parent, int defLevel); +static void doPrintVisualLevels(const pmVisualComponent* comp, FILE *output, psS32 depth, psS32 defLevel); +static psS32 doGetVisualLevel(const char *aname); +static bool componentAdd(const char *addNodeName, psS32 level); + +/***************************************************************************** +Set all visual levels at or below the specified node to zero. + *****************************************************************************/ +void pmVisualReset(pmVisualComponent* currentNode) +{ + psAssert(currentNode, "impossible"); + + psS32 i = 0; + + if (NULL == currentNode) { + return; + } + + currentNode->level = 0; + for (i = 0; i < currentNode->n; i++) { + if (!currentNode->subcomp[i]) { + psLogMsg("pmVisualReset", PS_LOG_WARN, _("Sub-component %d of node %s in visual tree is NULL."), i, currentNode->name); + } else { + pmVisualReset(currentNode->subcomp[i]); + } + } + return; +} + +/***************************************************************************** +Free all visual levels + *****************************************************************************/ +void pmVisualCleanup() +{ + psFree(cRoot); + cRoot = NULL; +} + +// psSetVisualLevel(): add the component named "comp" to the component tree, +int pmVisualSetLevel(const char *comp, // component of interest + int level) // desired visual level +{ + PS_ASSERT_STRING_NON_EMPTY(comp, 0); + + char *compName = NULL; + int prevLevel = -1; + + // If the root component tree does not exist, then initialize it. + if (cRoot == NULL) { + initVisualLevels(); + } + + // If the component name has no leading dot, then supply it. + if (comp[0] != '.') { + compName = (char *) psAlloc(10 + strlen(comp)); + strcpy(compName, "."); + compName = strcat(compName, comp); + } else { + compName = (char *) comp; + } + prevLevel = getLevel(compName); + // Add the new component to the component tree. + if ( !componentAdd(compName, level) ) { + psError(PS_ERR_UNKNOWN, false, + _("Failed to set visual level (%d) to '%s'."), + level, + compName); + + if (comp[0] != '.') { + psFree(compName); + } + // return false; + return -1; + } + + if (comp[0] != '.') { + psFree(compName); + } + + // return true; + return prevLevel; +} + +// Append the function name to the facility +// NB: declares TARGET! +#define FACILITY(TARGET, FUNC, FACIL) \ + size_t _facilLength = strlen(FACIL); /* Length of facility name */ \ + size_t _funcLength = strlen(FUNC); /* Length of function name */ \ + char TARGET[_facilLength + _funcLength + 2]; /* facility + the function name */ \ + strcpy(&TARGET[0], FACIL); \ + TARGET[_facilLength] = '.'; \ + strcpy(&TARGET[_facilLength + 1], FUNC); + +int p_pmVisualGetLevel(const char *func, const char *name) +{ + PS_ASSERT_STRING_NON_EMPTY(name, 0); + PS_ASSERT_STRING_NON_EMPTY(func, 0); + + FACILITY(facility, func, name); + return getLevel(facility); +} + +/** the main tool in the pmVisual system : check that the specified level matches the desired level **/ +bool p_pmVisualTestLevel(const char *func, const char *name, int level) +{ + PS_ASSERT_STRING_NON_EMPTY(name, false); + PS_ASSERT_STRING_NON_EMPTY(func, false); + + // return true if level is set to be shown + FACILITY(facility, func, name); + bool valid = level <= getLevel(facility); + + if (valid) { + psLogMsg ("psModules.visual", PS_LOG_DETAIL, "visualization %s (%d)\n", facility, level); + } + + return (valid); +} + +// psPrintVisualLevels(): Simply print all the visual levels in the visual level +void pmVisualPrintLevels(FILE *output) +{ + if (cRoot == NULL) { + return; + } + + doPrintVisualLevels(cRoot, output, 0, PM_THE_OTHER_DEFAULT_VISUAL_LEVEL); +} + +// generate a metadata of the visual levels (is this really needed?) +psMetadata *pmVisualLevels(void) +{ + if (cRoot == NULL) { + return psMetadataAlloc(); + } + + psMetadata *out = psMetadataAlloc();// Output metadata with the levels + doGetVisualLevels(out, cRoot, NULL, PM_THE_OTHER_DEFAULT_VISUAL_LEVEL); + + return out; +} + +/****************************** static functions ******************************/ + +/***************************************************************************** +componentAdd(): Adds the component named "addNodeName" to the root tree. + *****************************************************************************/ +static bool componentAdd(const char *addNodeName, psS32 level) +{ + psAssert(addNodeName, "impossible"); + + psS32 i = 0; // Loop index variable. + char name[MAX_COMPONENT_LENGTH]; // buffer for writeable copy. + char *firstComponent = NULL; // first component of name + pmVisualComponent* currentNode = cRoot; + psS32 nodeExists = 0; + + // XXX: Verify that this is the correct behavior. + if (strcmp("", addNodeName) == 0) { + psError(PS_ERR_BAD_PARAMETER_NULL,true, + _("Failed to add null component to visual tree.")); + return false; + } + + // Is this the root node? If so, simply set level and return. + if (strcmp(".", addNodeName) == 0) { + cRoot->level = level; + return true; + } + + if (addNodeName[0] != '.') { + psError(PS_ERR_BAD_PARAMETER_VALUE,true, + _("Failed to add '%s' to the root component tree; component must start with '.'."), + addNodeName); + return false; + } + + strncpy(name, addNodeName, MAX_COMPONENT_LENGTH); + char *pname = name+1; // Take off the period + // Iterate through the components of addNodeName. Strip off the first + // component of the name, find that in the root tree, or add it if it + // does not exist, then move to the next component in the name. + + while (pname != NULL) { + firstComponent = pname; + pname = strchr(firstComponent, '.'); + if (pname != NULL) { + *pname = '\0'; + pname++; + } + nodeExists = 0; + for (i = 0; i < currentNode->n; i++) { + if (strcmp(currentNode->subcomp[i]->name, firstComponent) == 0) { + currentNode = currentNode->subcomp[i]; + nodeExists = 1; + if (pname == NULL) { + currentNode->level = level; + } + } + } + + if (nodeExists == 0) { + currentNode->subcomp = psRealloc(currentNode->subcomp, + (currentNode->n + 1) * sizeof(pmVisualComponent* )); + psMemSetPersistent(currentNode->subcomp,true); + + currentNode->n = (currentNode->n) + 1; + + if (pname == NULL) { + // This is the final component to add. + currentNode->subcomp[(currentNode->n) - 1] = + componentAlloc(firstComponent, level); + } else { + // We are adding an intermediate component. The visual level is not defined. + // An undefined visual level inherits the visual level of it's parent. However, + // we do not set that specifically here since that would result in a static, + // one-time, type of behavior. + + currentNode->subcomp[(currentNode->n) - 1] = + componentAlloc(firstComponent, PM_DEFAULT_VISUAL_LEVEL); + } + currentNode = currentNode->subcomp[(currentNode->n) - 1]; + } + } + + return true; +} + +/***************************************************************************** + doGetVisualLevel() + This function recursively searches the root component tree for the + component named "name", which is supplied by a parameter. If it + finds that component, it returns the level of that component. + Otherwise, it returns ???. + + NOTE: We modified this so that the user may omit the leading "," in a + component name. Since the code was already implemented assuming the "." + was required, rather than change all that code, in this function, I + simply add a leading "." to the component name if there is none. + + Inputs: + name: + Outputs: + none + Returns: + The visual level of the "name" component. + *****************************************************************************/ +static psS32 doGetVisualLevel(const char *aname) +{ + psAssert(aname, "impossible"); + char name[strlen(aname) + 1]; // need a writeable copy: for strsep() + char *pname = name; + char *firstComponent = NULL; // first component of name + pmVisualComponent* currentNode = cRoot; + psS32 i = 0; + psS32 defaultLevel = 0; + + if (NULL == currentNode) { + return (PM_UNKNOWN_VISUAL_LEVEL); + } + + if (strcmp(".", aname) == 0) { + return (cRoot->level); + } + + if (aname[0] != '.') { + return (PM_UNKNOWN_VISUAL_LEVEL); + } + + defaultLevel = cRoot->level; + strcpy(name, aname); + pname = name+1; + while (pname != NULL) { + firstComponent = pname; + pname = strchr(firstComponent, '.'); + if (pname != NULL) { + *pname = '\0'; + pname++; + } + for (i = 0; i < currentNode->n; i++) { + if (NULL == currentNode->subcomp[i]) { + psLogMsg("p_pmVisualReset", PS_LOG_WARN, + _("Sub-component %d of node %s in visual tree is NULL."), + i, currentNode->name); + } + + if (strcmp(currentNode->subcomp[i]->name, firstComponent) == 0) { + currentNode = currentNode->subcomp[i]; + // For level inheritance purpose, we save the level of this + // component if it is not DEFAULT. + if (currentNode->level != PM_DEFAULT_VISUAL_LEVEL) { + defaultLevel = currentNode->level; + } + // Determine if this is the last component: + if (pname == NULL) { + if (currentNode->level != PM_DEFAULT_VISUAL_LEVEL) { + return (currentNode->level); + } else { + return(defaultLevel); + } + } + } + } + } + return(defaultLevel); +} + +/***************************************************************************** + getLevel() + Return a visual level of "name" in the root component tree. If the + exact string of components in "name" does not exist in the root + tree, we return the deepest level of the match. + *****************************************************************************/ +static int getLevel(const char *name) +{ + if (cRoot == NULL) { + return (PM_UNKNOWN_VISUAL_LEVEL); + } + + psS32 visualLevel; + + // If the component name has no leading dot, then supply it. + if (name[0] != '.') { + char compName[strlen(name) + 2]; + compName[0] = '.'; + strcpy(&compName[1], name); + + visualLevel = doGetVisualLevel(compName); + } else { + // Search the component root tree, determine the visual level. + visualLevel = doGetVisualLevel(name); + } + + // XXX: The default visual level is currently set at -1, which is not a + // valid visual level. This is convenient in determining whether or not + // a component should inherit the visual level from parent nodes. However, + // it's not clear that -1 should ever be returned by this function. + // The SDR is unclear on this point and we should probably request IfA + // comment. + if (visualLevel == PM_DEFAULT_VISUAL_LEVEL) { + visualLevel = PM_THE_OTHER_DEFAULT_VISUAL_LEVEL; + } + + return(visualLevel); +} + +/***************************************************************************** + doPrintVisualLevels() + This function recursively searches the component tree supplied by the + parameter "comp" and prints the name and level of each component. + Inputs: + comp: a node in the component tree. + level: the level of that node + Outputs: + none + Returns: + null + *****************************************************************************/ +static void doPrintVisualLevels(const pmVisualComponent* comp, + FILE *output, + psS32 depth, + psS32 defLevel) +{ + psAssert(comp, "impossible"); + + char line[1024]; + psS32 i = 0; + + if (comp->name[0] == '\0') { + return; + } else { + if (comp->level == PM_DEFAULT_VISUAL_LEVEL) { + sprintf(line,"%*s%-*s %d\n", depth, "", 20 - depth, comp->name, defLevel); + fwrite (line, 1, strlen(line), output); + } else { + sprintf(line, "%*s%-*s %d\n", depth, "", 20 - depth, comp->name, comp->level); + fwrite (line, 1, strlen(line), output); + } + } + + for (i = 0; i < comp->n; i++) { + if (comp->level == PM_DEFAULT_VISUAL_LEVEL) { + doPrintVisualLevels(comp->subcomp[i], output, depth + 1, defLevel); + } else { + doPrintVisualLevels(comp->subcomp[i], output, depth + 1, comp->level); + } + } +} + +static void doGetVisualLevels(psMetadata *out, // Output metadata with the visual levels + const pmVisualComponent* comp, // Component to add + psString parent, // Name of parent level + int defLevel // Default level + ) +{ + if (comp->name[0] == '\0') { + return; + } + + psString name = psStringCopy(parent); // Name of this level + if (comp->name[0] == '.') { + psStringAppend(&name, "%s", comp->name + 1); + } else if (!parent) { + psStringAppend(&name, "%s", comp->name); + } else { + psStringAppend(&name, ".%s", comp->name); + } + + int level = (comp->level == PM_DEFAULT_VISUAL_LEVEL) ? defLevel : comp->level; // Level for component + if (name) { + psMetadataAddS32(out, PS_LIST_TAIL, name, 0, NULL, level); + } + for (int i = 0; i < comp->n; i++) { + doGetVisualLevels(out, comp->subcomp[i], name, level); + } + + psFree(name); + + return; +} + +/***************************************************************************** +componentAlloc(): allocate memory for a new node, and initialize members. + *****************************************************************************/ +static pmVisualComponent* componentAlloc(const char *name, int level) +{ + psAssert(name, "impossible"); + + pmVisualComponent* comp = psAlloc(sizeof(pmVisualComponent)); + psMemSetDeallocator(comp, (psFreeFunc) componentFree); + + comp->name = psStringCopy(name); + comp->level = level; + comp->n = 0; + comp->specified = false; + comp->subcomp = NULL; + return comp; +} + +/***************************************************************************** +componentFree(): free the current node in the root tree, and all children +nodes as well. + *****************************************************************************/ +static void componentFree(pmVisualComponent* comp) +{ + if (comp == NULL) { + return; + } + + if (comp->subcomp != NULL) { + for (psS32 i = 0; i < comp->n; i++) { + psFree(comp->subcomp[i]); + } + psFree(comp->subcomp); + } + psFree(comp->name); +} + +/***************************************************************************** +initVisualLevels(): simply initialize the component root tree. +*****************************************************************************/ +static void initVisualLevels(void) +{ + if (cRoot == NULL) { + cRoot = componentAlloc(".", PM_DEFAULT_VISUAL_LEVEL); + } +} Index: /trunk/psModules/src/extras/pmVisualUtils.h =================================================================== --- /trunk/psModules/src/extras/pmVisualUtils.h (revision 29004) +++ /trunk/psModules/src/extras/pmVisualUtils.h (revision 29004) @@ -0,0 +1,33 @@ +/* @file pmVisualUtils.h + * @brief functions to create visual diagnostics with the help of 'kapa' + * @author Chris Beaumont, IfA + * + * Copyright 2009 Institute for Astronomy, University of Hawaii + */ + +#ifndef PM_VISUAL_UTILS_H +#define PM_VISUAL_UTILS_H + +typedef struct pmVisualComponent +{ + const char *name; ///< last part of name of component + psS32 level; ///< visual level for this component + bool specified; ///< whether the component is specified + psS32 n; ///< number of subcomponents + struct pmVisualComponent* *subcomp; ///< next level of subcomponents +} +pmVisualComponent; + +psMetadata *pmVisualLevels(void); +void pmVisualPrintLevels(FILE *output); +int pmVisualSetLevel(const char *comp, int level); +void pmVisualCleanup(); +void pmVisualReset(pmVisualComponent* currentNode); + +int p_pmVisualGetLevel(const char *func, const char *name); +# define pmVisualGetLevel(facil) p_pmVisualGetLevel(__func__, facil) + +bool p_pmVisualTestLevel(const char *func, const char *name, int level); +# define pmVisualTestLevel(facil, level) p_pmVisualTestLevel(__func__, facil, level) + +#endif // PM_VISUAL_UTILS_H Index: /trunk/psModules/src/imcombine/pmPSFEnvelope.c =================================================================== --- /trunk/psModules/src/imcombine/pmPSFEnvelope.c (revision 29003) +++ /trunk/psModules/src/imcombine/pmPSFEnvelope.c (revision 29004) @@ -10,23 +10,26 @@ #include "pmHDU.h" #include "pmFPA.h" -#include "pmReadoutFake.h" - -#include "pmMoments.h" + +#include "pmTrend2D.h" #include "pmResiduals.h" #include "pmGrowthCurve.h" -#include "pmTrend2D.h" -#include "pmPSF.h" -#include "pmModel.h" -#include "pmModelClass.h" -#include "pmModelUtils.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" +#include "pmMoments.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" #include "pmSource.h" -#include "pmSourceUtils.h" #include "pmSourceFitModel.h" +#include "pmPSF.h" #include "pmPSFtry.h" - +#include "pmReadoutFake.h" #include "pmPSFEnvelope.h" #include "pmStackVisual.h" @@ -410,5 +413,13 @@ options->chiFluxTrend = false; // All sources have similar flux, so fitting a trend often fails - pmSourceFitModelInit(SOURCE_FIT_ITERATIONS, 0.01, VARIANCE_VAL, true); + // options which modify the behavior of the model fitting + options->fitOptions = pmSourceFitOptionsAlloc(); + options->fitOptions->nIter = SOURCE_FIT_ITERATIONS; + options->fitOptions->minTol = 0.01; + options->fitOptions->maxTol = 1.00; + options->fitOptions->poissonErrors = true; + options->fitOptions->weight = VARIANCE_VAL; + options->fitOptions->mode = PM_SOURCE_FIT_PSF; + pmModelClassSetLimits(PM_MODEL_LIMITS_STRICT); // Important for getting a good stack target PSF Index: /trunk/psModules/src/imcombine/pmSubtraction.c =================================================================== --- /trunk/psModules/src/imcombine/pmSubtraction.c (revision 29003) +++ /trunk/psModules/src/imcombine/pmSubtraction.c (revision 29004) @@ -33,4 +33,9 @@ #define USE_KERNEL_ERR // Use kernel error image? #define NUM_COVAR_POS 5 // Number of positions for covariance calculation + +// XXX we need to pass these fwhm values elsewhere. These should go on one of the structure, but +// things are too confusing to do that now. just save them here. +static float FWHM1 = NAN; +static float FWHM2 = NAN; ////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -752,5 +757,5 @@ -bool pmSubtractionConvolveStamp(pmSubtractionStamp *stamp, const pmSubtractionKernels *kernels, int footprint) +bool pmSubtractionConvolveStamp (pmSubtractionStamp *stamp, pmSubtractionKernels *kernels, int footprint) { PS_ASSERT_PTR_NON_NULL(stamp, false); @@ -774,4 +779,7 @@ stamp->convolutions1 = convolveStamp(stamp->convolutions1, stamp->image1, kernels, footprint); stamp->convolutions2 = convolveStamp(stamp->convolutions2, stamp->image2, kernels, footprint); + if (!pmSubtractionKernelPenaltiesStamp(stamp, kernels)) { + psAbort("failure in penalties"); + } break; default: @@ -1215,4 +1223,5 @@ bool threaded = pmSubtractionThreaded(); // Running threaded? + // XXX This is no longer used psImage *convMask = NULL; // Convolved mask image (common to inputs 1 and 2) if (subMask) { @@ -1413,2 +1422,16 @@ return true; } + +bool pmSubtractionGetFWHMs(float *fwhm1, float *fwhm2) { + + *fwhm1 = FWHM1; + *fwhm2 = FWHM2; + return true; +} + +bool pmSubtractionSetFWHMs(float fwhm1, float fwhm2) { + + FWHM1 = fwhm1; + FWHM2 = fwhm2; + return true; +} Index: /trunk/psModules/src/imcombine/pmSubtraction.h =================================================================== --- /trunk/psModules/src/imcombine/pmSubtraction.h (revision 29003) +++ /trunk/psModules/src/imcombine/pmSubtraction.h (revision 29004) @@ -59,5 +59,5 @@ /// Convolve the reference stamp with the kernel components bool pmSubtractionConvolveStamp(pmSubtractionStamp *stamp, ///< Stamp to convolve - const pmSubtractionKernels *kernels, ///< Kernel parameters + pmSubtractionKernels *kernels, ///< Kernel parameters int footprint ///< Half-size of region over which to calculate equation ); @@ -157,4 +157,7 @@ ); +bool pmSubtractionGetFWHMs(float *fwhm1, float *fwhm2); +bool pmSubtractionSetFWHMs(float fwhm1, float fwhm2); + /// @} #endif Index: /trunk/psModules/src/imcombine/pmSubtractionEquation.c =================================================================== --- /trunk/psModules/src/imcombine/pmSubtractionEquation.c (revision 29003) +++ /trunk/psModules/src/imcombine/pmSubtractionEquation.c (revision 29004) @@ -38,5 +38,6 @@ const psImage *polyValues, // Spatial polynomial values int footprint, // (Half-)Size of stamp - int normWindow, // Window (half-)size for normalisation measurement + int normWindow1, // Window (half-)size for normalisation measurement + int normWindow2, // Window (half-)size for normalisation measurement const pmSubtractionEquationCalculationMode mode ) @@ -184,6 +185,8 @@ double one = 1.0; - if (PS_SQR(x) + PS_SQR(y) <= PS_SQR(normWindow)) { + if (PS_SQR(x) + PS_SQR(y) <= PS_SQR(normWindow1)) { normI1 += ref; + } + if (PS_SQR(x) + PS_SQR(y) <= PS_SQR(normWindow2)) { normI2 += in; } @@ -214,4 +217,6 @@ *norm = normI2 / normI1; + + fprintf (stderr, "normValue: %f %f %f\n", normI1, normI2, *norm); if (mode & PM_SUBTRACTION_EQUATION_NORM) { @@ -262,5 +267,6 @@ const psImage *polyValues, // Spatial polynomial values int footprint, // (Half-)Size of stamp - int normWindow, // Window (half-)size for normalisation measurement + int normWindow1, // Window (half-)size for normalisation measurement + int normWindow2, // Window (half-)size for normalisation measurement const pmSubtractionEquationCalculationMode mode ) @@ -492,6 +498,8 @@ double i1i2 = i1 * i2; - if (PS_SQR(x) + PS_SQR(y) <= PS_SQR(normWindow)) { + if (PS_SQR(x) + PS_SQR(y) <= PS_SQR(normWindow1)) { normI1 += i1; + } + if (PS_SQR(x) + PS_SQR(y) <= PS_SQR(normWindow2)) { normI2 += i2; } @@ -522,4 +530,5 @@ *norm = normI2 / normI1; + fprintf (stderr, "normValue: %f %f %f\n", normI1, normI2, *norm); if (mode & PM_SUBTRACTION_EQUATION_NORM) { @@ -559,8 +568,8 @@ // Add in penalty term to least-squares vector bool calculatePenalty(psImage *matrix, // Matrix to which to add in penalty term - psVector *vector, // Vector to which to add in penalty term - const pmSubtractionKernels *kernels, // Kernel parameters - float norm // Normalisation - ) + psVector *vector, // Vector to which to add in penalty term + const pmSubtractionKernels *kernels, // Kernel parameters + float norm // Normalisation + ) { if (kernels->penalty == 0.0) { @@ -568,5 +577,7 @@ } - psVector *penalties = kernels->penalties; // Penalties for each kernel component + psVector *penalties1 = kernels->penalties1; // Penalties for each kernel component (input) + psVector *penalties2 = kernels->penalties2; // Penalties for each kernel component (ref) + int spatialOrder = kernels->spatialOrder; // Order of spatial variations int numKernels = kernels->num; // Number of kernel components @@ -588,8 +599,11 @@ for (int xOrder = 0; xOrder <= spatialOrder - yOrder; xOrder++, index += numKernels) { // Contribution to chi^2: a_i^2 P_i - psAssert(isfinite(penalties->data.F32[i]), "Invalid penalty"); - matrix->data.F64[index][index] += norm * penalties->data.F32[i]; + psAssert(isfinite(penalties1->data.F32[i]), "Invalid penalty"); + fprintf (stderr, "penalty: %f + %f (%f * %f)\n", matrix->data.F64[index][index], norm * penalties1->data.F32[i], norm, penalties1->data.F32[i]); + matrix->data.F64[index][index] += norm * penalties1->data.F32[i]; if (kernels->mode == PM_SUBTRACTION_MODE_DUAL) { - matrix->data.F64[index + numParams + 2][index + numParams + 2] += norm * penalties->data.F32[i]; + fprintf (stderr, "penalty: (x^%d y^%d fwhm %f) : %f + %f (%f * %f)\n", kernels->u->data.S32[index], kernels->v->data.S32[index], kernels->widths->data.F32[index], + matrix->data.F64[index + numParams + 2][index + numParams + 2], norm * penalties2->data.F32[i], norm, penalties2->data.F32[i]); + matrix->data.F64[index + numParams + 2][index + numParams + 2] += norm * penalties2->data.F32[i]; // matrix[i][i] is ~ (k_i * I_1)(k_i * I_1) // penalties scale with second moments @@ -682,5 +696,5 @@ pmSubtractionStampList *stamps = job->args->data[0]; // List of stamps - const pmSubtractionKernels *kernels = job->args->data[1]; // Kernels + pmSubtractionKernels *kernels = job->args->data[1]; // Kernels int index = PS_SCALAR_VALUE(job->args->data[2], S32); // Stamp index pmSubtractionEquationCalculationMode mode = PS_SCALAR_VALUE(job->args->data[3], S32); // calculation model @@ -689,5 +703,5 @@ } -bool pmSubtractionCalculateEquationStamp(pmSubtractionStampList *stamps, const pmSubtractionKernels *kernels, +bool pmSubtractionCalculateEquationStamp(pmSubtractionStampList *stamps, pmSubtractionKernels *kernels, int index, const pmSubtractionEquationCalculationMode mode) { @@ -778,10 +792,10 @@ status = calculateMatrixVector(stamp->matrix, stamp->vector, &stamp->norm, stamp->image2, stamp->image1, weight, window, stamp->convolutions1, kernels, - polyValues, footprint, stamps->normWindow, mode); + polyValues, footprint, stamps->normWindow1, stamps->normWindow2, mode); break; case PM_SUBTRACTION_MODE_2: status = calculateMatrixVector(stamp->matrix, stamp->vector, &stamp->norm, stamp->image1, stamp->image2, weight, window, stamp->convolutions2, kernels, - polyValues, footprint, stamps->normWindow, mode); + polyValues, footprint, stamps->normWindow2, stamps->normWindow1, mode); break; case PM_SUBTRACTION_MODE_DUAL: @@ -789,5 +803,5 @@ stamp->image1, stamp->image2, weight, window, stamp->convolutions1, stamp->convolutions2, - kernels, polyValues, footprint, stamps->normWindow, mode); + kernels, polyValues, footprint, stamps->normWindow1, stamps->normWindow2, mode); break; default: @@ -830,5 +844,5 @@ } -bool pmSubtractionCalculateEquation(pmSubtractionStampList *stamps, const pmSubtractionKernels *kernels, +bool pmSubtractionCalculateEquation(pmSubtractionStampList *stamps, pmSubtractionKernels *kernels, const pmSubtractionEquationCalculationMode mode) { @@ -996,4 +1010,5 @@ } + // double normValue = 1.0; double normValue = stats->robustMedian; // double bgValue = 0.0; @@ -1023,4 +1038,10 @@ } # endif + +#if (1) + for (int i = 0; i < solution->n; i++) { + fprintf(stderr, "Single solution %d: %lf\n", i, solution->data.F64[i]); + } +#endif if (!kernels->solution1) { @@ -1096,5 +1117,5 @@ int normIndex = PM_SUBTRACTION_INDEX_NORM(kernels); // Index for normalisation - calculatePenalty(sumMatrix, sumVector, kernels, sumMatrix->data.F64[normIndex][normIndex] / 1000.0); + calculatePenalty(sumMatrix, sumVector, kernels, sumMatrix->data.F64[normIndex][normIndex] / 100.0); #endif @@ -1177,5 +1198,5 @@ -#ifdef TESTING +#if (1) for (int i = 0; i < solution->n; i++) { fprintf(stderr, "Dual solution %d: %lf\n", i, solution->data.F64[i]); Index: /trunk/psModules/src/imcombine/pmSubtractionEquation.h =================================================================== --- /trunk/psModules/src/imcombine/pmSubtractionEquation.h (revision 29003) +++ /trunk/psModules/src/imcombine/pmSubtractionEquation.h (revision 29004) @@ -19,5 +19,5 @@ /// Calculate the least-squares equation to match the image quality for a single stamp bool pmSubtractionCalculateEquationStamp(pmSubtractionStampList *stamps, ///< Stamps - const pmSubtractionKernels *kernels, ///< Kernel parameters + pmSubtractionKernels *kernels, ///< Kernel parameters int index, ///< Index of stamp const pmSubtractionEquationCalculationMode mode @@ -26,5 +26,5 @@ /// Calculate the least-squares equation to match the image quality bool pmSubtractionCalculateEquation(pmSubtractionStampList *stamps, ///< Stamps - const pmSubtractionKernels *kernels, ///< Kernel parameters + pmSubtractionKernels *kernels, ///< Kernel parameters const pmSubtractionEquationCalculationMode mode ); Index: /trunk/psModules/src/imcombine/pmSubtractionKernels.c =================================================================== --- /trunk/psModules/src/imcombine/pmSubtractionKernels.c (revision 29003) +++ /trunk/psModules/src/imcombine/pmSubtractionKernels.c (revision 29004) @@ -26,5 +26,6 @@ psFree(kernels->vStop); psFree(kernels->preCalc); - psFree(kernels->penalties); + psFree(kernels->penalties1); + psFree(kernels->penalties2); psFree(kernels->solution1); psFree(kernels->solution2); @@ -140,5 +141,8 @@ kernels->v = psVectorRealloc(kernels->v, start + numNew); kernels->preCalc = psArrayRealloc(kernels->preCalc, start + numNew); - kernels->penalties = psVectorRealloc(kernels->penalties, start + numNew); + + kernels->penalties1 = psVectorRealloc(kernels->penalties1, start + numNew); + kernels->penalties2 = psVectorRealloc(kernels->penalties2, start + numNew); + kernels->inner = start; kernels->num += numNew; @@ -156,6 +160,12 @@ kernels->v->data.S32[index] = v; kernels->preCalc->data[index] = NULL; - kernels->penalties->data.F32[index] = kernels->penalty * PS_SQR(PS_SQR(u) + PS_SQR(v)); - psAssert (isfinite(kernels->penalties->data.F32[index]), "invalid penalty"); + + // XXX this needs to be changed to use the *convolved* second moment + kernels->penalties1->data.F32[index] = kernels->penalty * PS_SQR(PS_SQR(u) + PS_SQR(v)); + psAssert (isfinite(kernels->penalties1->data.F32[index]), "invalid penalty"); + + kernels->penalties2->data.F32[index] = kernels->penalty * PS_SQR(PS_SQR(u) + PS_SQR(v)); + psAssert (isfinite(kernels->penalties2->data.F32[index]), "invalid penalty"); + psTrace("psModules.imcombine", 7, "Kernel %d: %d %d\n", index, u, v); } @@ -166,12 +176,14 @@ kernels->v->n = start + numNew; kernels->preCalc->n = start + numNew; - kernels->penalties->n = start + numNew; + + kernels->penalties1->n = start + numNew; + kernels->penalties2->n = start + numNew; return true; } -bool pmSubtractionKernelPreCalcNormalize(pmSubtractionKernels *kernels, pmSubtractionKernelPreCalc *preCalc, - int index, int size, int uOrder, int vOrder, float fwhm, - bool AlardLuptonStyle, bool forceZeroNull) +static bool pmSubtractionKernelPreCalcNormalize(pmSubtractionKernels *kernels, pmSubtractionKernelPreCalc *preCalc, + int index, int uOrder, int vOrder, float fwhm, + bool AlardLuptonStyle, bool forceZeroNull) { // we have 4 cases here: @@ -182,14 +194,13 @@ // Calculate moments - double penalty = 0.0; // Moment, for penalty double sum = 0.0, sum2 = 0.0; // Sum of kernel component float min = INFINITY, max = -INFINITY; // Minimum and maximum kernel value - for (int v = -size; v <= size; v++) { - for (int u = -size; u <= size; u++) { + + for (int v = preCalc->kernel->yMin; v <= preCalc->kernel->yMax; v++) { + for (int u = preCalc->kernel->xMin; u <= preCalc->kernel->xMax; u++) { double value = preCalc->kernel->kernel[v][u]; double value2 = PS_SQR(value); sum += value; sum2 += value2; - penalty += value2 * PS_SQR((PS_SQR(u) + PS_SQR(v))); min = PS_MIN(value, min); max = PS_MAX(value, max); @@ -198,5 +209,5 @@ #if 0 - fprintf(stderr, "%d raw: %lf, null: %f, min: %lf, max: %lf, moment: %lf\n", index, sum, preCalc->kernel->kernel[0][0], min, max, penalty); + fprintf(stderr, "%d raw: %lf, null: %f, min: %lf, max: %lf\n", index, sum, preCalc->kernel->kernel[0][0], min, max); #endif @@ -207,5 +218,7 @@ if (uOrder % 2 == 0 && vOrder % 2 == 0) { // Even functions: normalise to unit sum and subtract null pixel so that sum is zero - scale2D = 1.0 / fabs(sum); + // Re-normalize + // scale2D = 1.0 / fabs(sum); + scale2D = 1.0 / sqrt(sum2); zeroNull = true; } else { @@ -239,22 +252,25 @@ psBinaryOp(preCalc->kernel->image, preCalc->kernel->image, "*", psScalarAlloc(scale2D, PS_TYPE_F32)); - penalty *= 1.0 / sum2; if (zeroNull) { - preCalc->kernel->kernel[0][0] -= 1.0; - } - -#if 0 + // preCalc->kernel->kernel[0][0] -= 1.0; + preCalc->kernel->kernel[0][0] -= sum / sqrt (sum2); + } + +#if 1 { - double sum = 0.0; // Sum of kernel component + double Sum = 0.0; // Sum of kernel component + double Sum2 = 0.0; // Sum of kernel component float min = INFINITY, max = -INFINITY; // Minimum and maximum kernel value - for (int v = -size; v <= size; v++) { - for (int u = -size; u <= size; u++) { - sum += preCalc->kernel->kernel[v][u]; + for (int v = preCalc->kernel->yMin; v <= preCalc->kernel->yMax; v++) { + for (int u = preCalc->kernel->xMin; u <= preCalc->kernel->xMax; u++) { + double value = preCalc->kernel->kernel[v][u]; + Sum += value; + Sum2 += PS_SQR(value); min = PS_MIN(preCalc->kernel->kernel[v][u], min); max = PS_MAX(preCalc->kernel->kernel[v][u], max); } } - fprintf(stderr, "%d mod: %lf, null: %f, min: %lf, max: %lf, scale: %f\n", index, sum, preCalc->kernel->kernel[0][0], min, max, scale2D); + fprintf(stderr, "%d sum: %lf, sum2: %lf, null: %f, min: %lf, max: %lf, scale: %f\n", index, Sum, Sum2, preCalc->kernel->kernel[0][0], min, max, scale2D); } #endif @@ -267,7 +283,5 @@ } kernels->preCalc->data[index] = preCalc; - kernels->penalties->data.F32[index] = kernels->penalty * penalty; - psAssert (isfinite(kernels->penalties->data.F32[index]), "invalid penalty"); - psTrace("psModules.imcombine", 7, "Kernel %d: %f %d %d %f\n", index, fwhm, uOrder, vOrder, penalty); + psTrace("psModules.imcombine", 7, "Kernel %d: %f %d %d\n", index, fwhm, uOrder, vOrder); return true; @@ -321,6 +335,6 @@ pmSubtractionKernelPreCalc *preCalc = pmSubtractionKernelPreCalcAlloc(PM_SUBTRACTION_KERNEL_ISIS, uOrder, vOrder, size, sigma); // structure to hold precalculated values - pmSubtractionKernelPreCalcNormalize (kernels, preCalc, index, size, uOrder, vOrder, fwhms->data.F32[i], true, false); - // pmSubtractionKernelPreCalcNormalize (kernels, preCalc, index, size, uOrder, vOrder, fwhms->data.F32[i], false, false); + pmSubtractionKernelPreCalcNormalize (kernels, preCalc, index, uOrder, vOrder, fwhms->data.F32[i], true, false); + // pmSubtractionKernelPreCalcNormalize (kernels, preCalc, index, uOrder, vOrder, fwhms->data.F32[i], false, false); } } @@ -379,5 +393,5 @@ for (int vOrder = 0; vOrder <= orders->data.S32[i] - uOrder; vOrder++, index++) { pmSubtractionKernelPreCalc *preCalc = pmSubtractionKernelPreCalcAlloc(PM_SUBTRACTION_KERNEL_ISIS, uOrder, vOrder, size, sigma); // structure to hold precalculated values - pmSubtractionKernelPreCalcNormalize (kernels, preCalc, index, size, uOrder, vOrder, fwhms->data.F32[i], true, false); + pmSubtractionKernelPreCalcNormalize (kernels, preCalc, index, uOrder, vOrder, fwhms->data.F32[i], true, false); } } @@ -385,5 +399,5 @@ // XXX modify size for hermitians to account for sqrt(2) in Hermitian definition (relative to ISIS Gaussian) pmSubtractionKernelPreCalc *preCalc = pmSubtractionKernelPreCalcAlloc(PM_SUBTRACTION_KERNEL_ISIS_RADIAL, order, order, size, sigma / sqrt(2.0)); // structure to hold precalculated values - pmSubtractionKernelPreCalcNormalize (kernels, preCalc, index, size, order, order, fwhms->data.F32[i], true, true); + pmSubtractionKernelPreCalcNormalize (kernels, preCalc, index, order, order, fwhms->data.F32[i], true, true); } } @@ -437,5 +451,5 @@ for (int vOrder = 0; vOrder <= orders->data.S32[i] - uOrder; vOrder++, index++) { pmSubtractionKernelPreCalc *preCalc = pmSubtractionKernelPreCalcAlloc(PM_SUBTRACTION_KERNEL_HERM, uOrder, vOrder, size, sigma); // structure to hold precalculated values - pmSubtractionKernelPreCalcNormalize (kernels, preCalc, index, size, uOrder, vOrder, fwhms->data.F32[i], true, false); + pmSubtractionKernelPreCalcNormalize (kernels, preCalc, index, uOrder, vOrder, fwhms->data.F32[i], true, false); } } @@ -506,5 +520,5 @@ // XXX do we use Alard-Lupton normalization (last param true) or not? - pmSubtractionKernelPreCalcNormalize (kernels, preCalc, index, size, uOrder, vOrder, fwhms->data.F32[i], true, false); + pmSubtractionKernelPreCalcNormalize (kernels, preCalc, index, uOrder, vOrder, fwhms->data.F32[i], true, false); // XXXX test demo that deconvolved kernel is valid @@ -572,5 +586,9 @@ kernels->preCalc = psArrayAlloc(numBasisFunctions); kernels->penalty = penalty; - kernels->penalties = psVectorAlloc(numBasisFunctions, PS_TYPE_F32); + kernels->penalties1 = psVectorAlloc(numBasisFunctions, PS_TYPE_F32); + psVectorInit(kernels->penalties1, NAN); + kernels->penalties2 = psVectorAlloc(numBasisFunctions, PS_TYPE_F32); + psVectorInit(kernels->penalties2, NAN); + kernels->havePenalties = false; kernels->size = size; kernels->inner = 0; @@ -771,5 +789,6 @@ psWarning("Kernel penalty for dual-convolution is not configured for SPAM kernels."); - psVectorInit(kernels->penalties, 0.0); + psVectorInit(kernels->penalties1, 0.0); + psVectorInit(kernels->penalties2, 0.0); return kernels; @@ -866,5 +885,6 @@ psWarning("Kernel penalty for dual-convolution is not configured for FRIES kernels."); - psVectorInit(kernels->penalties, 0.0); + psVectorInit(kernels->penalties1, 0.0); + psVectorInit(kernels->penalties2, 0.0); return kernels; @@ -1040,6 +1060,12 @@ kernels->u->data.S32[index] = uOrder; kernels->v->data.S32[index] = vOrder; - kernels->penalties->data.F32[index] = kernels->penalty * fabsf(moment); - if (!isfinite(kernels->penalties->data.F32[index])) { + + // XXX convert to use the convolved 2nd moment + kernels->penalties1->data.F32[index] = kernels->penalty * fabsf(moment); + if (!isfinite(kernels->penalties1->data.F32[index])) { + psAbort ("invalid penalty"); + } + kernels->penalties2->data.F32[index] = kernels->penalty * fabsf(moment); + if (!isfinite(kernels->penalties2->data.F32[index])) { psAbort ("invalid penalty"); } @@ -1247,5 +1273,6 @@ out->preCalc = psMemIncrRefCounter(in->preCalc); out->penalty = in->penalty; - out->penalties = psMemIncrRefCounter(in->penalties); + out->penalties1 = psMemIncrRefCounter(in->penalties1); + out->penalties2 = psMemIncrRefCounter(in->penalties2); out->uStop = psMemIncrRefCounter(in->uStop); out->vStop = psMemIncrRefCounter(in->vStop); Index: /trunk/psModules/src/imcombine/pmSubtractionKernels.h =================================================================== --- /trunk/psModules/src/imcombine/pmSubtractionKernels.h (revision 29003) +++ /trunk/psModules/src/imcombine/pmSubtractionKernels.h (revision 29004) @@ -39,5 +39,7 @@ psArray *preCalc; ///< Array of images containing pre-calculated kernel (for ISIS, HERM or DECONV_HERM) float penalty; ///< Penalty for wideness - psVector *penalties; ///< Penalty for each kernel component + psVector *penalties1; ///< Penalty for each kernel component + psVector *penalties2; ///< Penalty for each kernel component + bool havePenalties; ///< flag to test if we have already calculated the penalties or not. int size; ///< The half-size of the kernel int inner; ///< The size of an inner region @@ -308,4 +310,3 @@ ); - #endif Index: /trunk/psModules/src/imcombine/pmSubtractionMatch.c =================================================================== --- /trunk/psModules/src/imcombine/pmSubtractionMatch.c (revision 29003) +++ /trunk/psModules/src/imcombine/pmSubtractionMatch.c (revision 29004) @@ -1304,4 +1304,7 @@ float scale = PS_MAX(fwhm1, fwhm2) / scaleRef; // Scaling factor + // XXX save these values in a static for later use + pmSubtractionSetFWHMs(fwhm1, fwhm2); + if (isfinite(scaleMin) && scale < scaleMin) { scale = scaleMin; Index: /trunk/psModules/src/imcombine/pmSubtractionMatch.h =================================================================== --- /trunk/psModules/src/imcombine/pmSubtractionMatch.h (revision 29003) +++ /trunk/psModules/src/imcombine/pmSubtractionMatch.h (revision 29004) @@ -110,4 +110,3 @@ ); - #endif Index: /trunk/psModules/src/imcombine/pmSubtractionStamps.c =================================================================== --- /trunk/psModules/src/imcombine/pmSubtractionStamps.c (revision 29003) +++ /trunk/psModules/src/imcombine/pmSubtractionStamps.c (revision 29004) @@ -7,18 +7,23 @@ #include +#include "pmErrorCodes.h" +#include "pmHDU.h" +#include "pmFPA.h" + // All these includes required to get stamps out of an array of pmSources -#include "pmMoments.h" +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" -#include "pmResiduals.h" -#include "pmHDU.h" -#include "pmFPA.h" -#include "pmGrowthCurve.h" -#include "pmTrend2D.h" -#include "pmPSF.h" +#include "pmMoments.h" +#include "pmModelFuncs.h" #include "pmModel.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" #include "pmSource.h" -#include "pmErrorCodes.h" #include "pmSubtraction.h" @@ -46,5 +51,6 @@ psFree(list->y); psFree(list->flux); - psFree(list->window); + psFree(list->window1); + psFree(list->window2); } @@ -225,7 +231,9 @@ list->y = NULL; list->flux = NULL; - list->window = NULL; list->normFrac = normFrac; - list->normWindow = 0; + list->window1 = NULL; + list->window2 = NULL; + list->normWindow1 = 0; + list->normWindow2 = 0; list->footprint = footprint; list->sysErr = sysErr; @@ -248,7 +256,9 @@ out->y = NULL; out->flux = NULL; - out->window = psMemIncrRefCounter(in->window); + out->window1 = psMemIncrRefCounter(in->window1); + out->window2 = psMemIncrRefCounter(in->window2); out->footprint = in->footprint; - out->normWindow = in->normWindow; + out->normWindow1 = in->normWindow1; + out->normWindow2 = in->normWindow2; for (int i = 0; i < num; i++) { @@ -638,7 +648,11 @@ int size = stamps->footprint; // Size of postage stamps - psFree (stamps->window); - stamps->window = psKernelAlloc(-size, size, -size, size); - psImageInit(stamps->window->image, 0.0); + psFree (stamps->window1); + stamps->window1 = psKernelAlloc(-size, size, -size, size); + psImageInit(stamps->window1->image, 0.0); + + psFree (stamps->window2); + stamps->window2 = psKernelAlloc(-size, size, -size, size); + psImageInit(stamps->window2->image, 0.0); // generate normalizations for each stamp @@ -669,6 +683,8 @@ // generate the window pixels - double sum = 0.0; // Sum inside the window - float maxValue = 0.0; // Maximum value, for normalisation + double sum1 = 0.0; // Sum inside the window + double sum2 = 0.0; // Sum inside the window + float maxValue1 = 0.0; // Maximum value, for normalisation + float maxValue2 = 0.0; // Maximum value, for normalisation for (int y = -size; y <= size; y++) { for (int x = -size; x <= size; x++) { @@ -691,4 +707,5 @@ } float f1 = stats->robustMedian; + psStatsInit (stats); if (!psVectorStats (stats, flux2, NULL, NULL, 0)) { @@ -697,34 +714,104 @@ float f2 = stats->robustMedian; - stamps->window->kernel[y][x] = f1 + f2; + stamps->window1->kernel[y][x] = f1; if (PS_SQR(x) + PS_SQR(y) <= PS_SQR(size)) { - sum += stamps->window->kernel[y][x]; - } - maxValue = PS_MAX(maxValue, stamps->window->kernel[y][x]); - } - } - - psTrace("psModules.imcombine", 3, "Window total: %f, threshold: %f\n", - sum, (1.0 - stamps->normFrac) * sum); - bool done = false; - for (int radius = 1; radius <= size && !done; radius++) { - double within = 0.0; + sum1 += stamps->window1->kernel[y][x]; + } + maxValue1 = PS_MAX(maxValue1, stamps->window1->kernel[y][x]); + + stamps->window2->kernel[y][x] = f2; + if (PS_SQR(x) + PS_SQR(y) <= PS_SQR(size)) { + sum2 += stamps->window2->kernel[y][x]; + } + maxValue2 = PS_MAX(maxValue2, stamps->window2->kernel[y][x]); + } + } + + psTrace("psModules.imcombine", 3, "Window total (1): %f, threshold: %f\n", sum1, (1.0 - stamps->normFrac) * sum1); + psTrace("psModules.imcombine", 3, "Window total (2): %f, threshold: %f\n", sum2, (1.0 - stamps->normFrac) * sum2); + +# if (0) + // this block attempts to calculate the radius based on the first radial moment + bool done1 = false; + bool done2 = false; + double prior1 = 0.0; + double prior2 = 0.0; + for (int y = -size; y <= size; y++) { + for (int x = -size; x <= size; x++) { + float r = hypot(x, y); + Sr1 += r * stamps->window1->kernel[y][x]; + Sr2 += r * stamps->window2->kernel[y][x]; + Sf1 += stamps->window1->kernel[y][x]; + Sf2 += stamps->window2->kernel[y][x]; + } + } + + float R1 = Sr1 / Sf1; + float R2 = Sr2 / Sf2; + + stamps->normWindow1 = 2.5*R1; + stamps->normWindow1 = 2.5*R2; +# else + // XXX : this block attempts to calculate the radius by looking at the curve of growth (or something vaguely equivalent). + // It did not do very well (though a true curve-of-growth analysis might be better...) + bool done1 = false; + bool done2 = false; + double prior1 = 0.0; + double prior2 = 0.0; + double delta1o = 1.0; + double delta2o = 1.0; + for (int radius = 1; radius <= size && !(done1 && done2); radius++) { + double within1 = 0.0; + double within2 = 0.0; for (int y = -radius; y <= radius; y++) { for (int x = -radius; x <= radius; x++) { if (PS_SQR(x) + PS_SQR(y) <= PS_SQR(radius)) { - within += stamps->window->kernel[y][x]; + within1 += stamps->window1->kernel[y][x]; } - } - } - psTrace("psModules.imcombine", 5, "Radius %d: %f\n", radius, within); - if (within > (1.0 - stamps->normFrac) * sum) { - stamps->normWindow = radius; - done = true; - } - } - - psTrace("psModules.imcombine", 3, "Normalisation window radius set to %d\n", stamps->normWindow); - if (stamps->normWindow == 0 || stamps->normWindow >= size) { - psError(PM_ERR_STAMPS, true, "Unable to determine normalisation window size."); + if (PS_SQR(x) + PS_SQR(y) <= PS_SQR(radius)) { + within2 += stamps->window2->kernel[y][x]; + } + } + } + double delta1 = (within1 - prior1) / within1; + if (!done1 && (fabs(delta1) < stamps->normFrac)) { + // interpolate to the radius at which delta2 is normFrac: + stamps->normWindow1 = radius - (stamps->normFrac - delta1) / (delta1o - delta1); + fprintf (stderr, "choosing %f (%d) for 1 (%f : %f)\n", stamps->normWindow1, radius, within1, delta1); + done1 = true; + } + double delta2 = (within2 - prior2) / within2; + if (!done2 && (fabs(delta2) < stamps->normFrac)) { + // interpolate to the radius at which delta2 is normFrac: + stamps->normWindow2 = radius - (stamps->normFrac - delta2) / (delta2o - delta2); + fprintf (stderr, "choosing %f (%d) for 2 (%f : %f)\n", stamps->normWindow2, radius, within2, delta2); + done2 = true; + } + psTrace("psModules.imcombine", 5, "Radius %d: %f (%f) and %f (%f)\n", radius, within1, delta1, within2, delta2); + + prior1 = within1; + prior2 = within2; + delta1o = delta1; + delta2o = delta2; + + // if (!done1 && (within1 > (1.0 - stamps->normFrac) * sum1)) { + // stamps->normWindow1 = radius; + // done1 = true; + // } + // if (!done2 && (within2 > (1.0 - stamps->normFrac) * sum2)) { + // stamps->normWindow2 = radius; + // done2 = true; + // } + + } +# endif + + psTrace("psModules.imcombine", 3, "Normalisation window radii set to %f and %f\n", stamps->normWindow1, stamps->normWindow2); + if (stamps->normWindow1 == 0 || stamps->normWindow1 >= size) { + psError(PM_ERR_STAMPS, true, "Unable to determine normalisation window size (1)."); + return false; + } + if (stamps->normWindow2 == 0 || stamps->normWindow2 >= size) { + psError(PM_ERR_STAMPS, true, "Unable to determine normalisation window size (2)."); return false; } @@ -733,12 +820,22 @@ for (int y = -size; y <= size; y++) { for (int x = -size; x <= size; x++) { - stamps->window->kernel[y][x] /= maxValue; - } - } - -#if 0 + stamps->window1->kernel[y][x] /= maxValue1; + } + } + // re-normalize so chisquare values are sensible + for (int y = -size; y <= size; y++) { + for (int x = -size; x <= size; x++) { + stamps->window2->kernel[y][x] /= maxValue2; + } + } + +#if 1 { - psFits *fits = psFitsOpen ("window.fits", "w"); - psFitsWriteImage (fits, NULL, stamps->window->image, 0, NULL); + psFits *fits = NULL; + fits = psFitsOpen ("window1.fits", "w"); + psFitsWriteImage (fits, NULL, stamps->window1->image, 0, NULL); + psFitsClose (fits); + fits = psFitsOpen ("window2.fits", "w"); + psFitsWriteImage (fits, NULL, stamps->window2->image, 0, NULL); psFitsClose (fits); } @@ -747,8 +844,108 @@ psFree (stats); psFree (flux1); - psFree(flux2); + psFree (flux2); psFree (norm1); psFree (norm2); return true; +} + +static pthread_mutex_t getPenaltiesMutex = PTHREAD_MUTEX_INITIALIZER; + +// kernels->penalty is an overall scaling factor (user-supplied) +bool pmSubtractionKernelPenaltiesStamp(pmSubtractionStamp *stamp, pmSubtractionKernels *kernels) +{ + // we only need the penalties if we are doing dual convolution + if (kernels->mode != PM_SUBTRACTION_MODE_DUAL) return true; + + // we only calculate the penalties once. + if (kernels->havePenalties) return true; + + // in a threaded context, only one thread can calculate the penalties. attempt to grab a + // mutex before continuing + pthread_mutex_lock(&getPenaltiesMutex); + + // did someone else already get the mutex and do this? + if (kernels->havePenalties) { + pthread_mutex_unlock(&getPenaltiesMutex); + return true; + } + + for (int i = 0; i < kernels->num; i++) { + pmSubtractionKernelPenalties(stamp, kernels, i); + } + + kernels->havePenalties = true; + pthread_mutex_unlock(&getPenaltiesMutex); + return true; +} + +# define EMPIRICAL 0 + +// kernels->penalty is an overall scaling factor (user-supplied) +bool pmSubtractionKernelPenalties(pmSubtractionStamp *stamp, pmSubtractionKernels *kernels, int index) +{ + float penalty1, penalty2; + float fwhm1, fwhm2; + + // XXX this is annoyingly hack-ish + pmSubtractionGetFWHMs(&fwhm1, &fwhm2); + + bool zeroNull = false; + int uOrder = kernels->u->data.S32[index]; + int vOrder = kernels->v->data.S32[index]; + if (uOrder % 2 == 0 && vOrder % 2 == 0) zeroNull = true; + + if (EMPIRICAL) { + psKernel *convolution1 = stamp->convolutions1->data[index]; + penalty1 = pmSubtractionKernelPenaltySingle(convolution1, zeroNull); + + psKernel *convolution2 = stamp->convolutions2->data[index]; + penalty2 = pmSubtractionKernelPenaltySingle(convolution2, zeroNull); + } else { + pmSubtractionKernelPreCalc *kernel = kernels->preCalc->data[index]; + float M2 = pmSubtractionKernelPenaltySingle(kernel->kernel, zeroNull); + + penalty1 = M2 + PS_SQR(fwhm1 / 2.35); // rescale the unconvolved second-moment by the image second moment + penalty2 = M2 + PS_SQR(fwhm2 / 2.35); // rescale the unconvolved second-moment by the image second moment + } + kernels->penalties1->data.F32[index] = kernels->penalty * penalty1; + psAssert (isfinite(kernels->penalties1->data.F32[index]), "invalid penalty"); + + kernels->penalties2->data.F32[index] = kernels->penalty * penalty2; + psAssert (isfinite(kernels->penalties2->data.F32[index]), "invalid penalty"); + + fprintf(stderr, "penalty1: %f, penalty2: %f\n", penalty1, penalty2); + + return true; +} + +float pmSubtractionKernelPenaltySingle(psKernel *kernel, bool zeroNull) +{ + // Calculate moments + double penalty = 0.0; // Moment, for penalty + double sum = 0.0, sum2 = 0.0; // Sum of kernel component + float min = INFINITY, max = -INFINITY; // Minimum and maximum kernel value + for (int v = kernel->yMin; v <= kernel->yMax; v++) { + for (int u = kernel->xMin; u <= kernel->xMax; u++) { + double value = kernel->kernel[v][u]; + if (false && zeroNull && (u == 0) && (v == 0)) { + value += 1.0; + } + double value2 = PS_SQR(value); + sum += value; + sum2 += value2; + penalty += value2 * PS_SQR((PS_SQR(u) + PS_SQR(v))); + min = PS_MIN(value, min); + max = PS_MAX(value, max); + } + } + penalty *= 1.0 / sum2; + + if (1) { + fprintf(stderr, "min: %lf, max: %lf, moment: %lf, flux^2: %lf\n", min, max, penalty, sum2); + // psTrace("psModules.imcombine", 7, "Kernel %d: %f %d %d %f\n", index, fwhm, uOrder, vOrder, penalty); + } + + return penalty; } Index: /trunk/psModules/src/imcombine/pmSubtractionStamps.h =================================================================== --- /trunk/psModules/src/imcombine/pmSubtractionStamps.h (revision 29003) +++ /trunk/psModules/src/imcombine/pmSubtractionStamps.h (revision 29004) @@ -24,7 +24,9 @@ psArray *flux; ///< Fluxes for possible stamps (or NULL) int footprint; ///< Half-size of stamps - psKernel *window; ///< window function generated from ensemble of stamps float normFrac; ///< Fraction of flux in window for normalisation window - int normWindow; ///< Size of window for measuring normalisation + psKernel *window1; ///< window function generated from ensemble of stamps (input 1) + psKernel *window2; ///< window function generated from ensemble of stamps (input 2) + float normWindow1; ///< Size of window for measuring normalisation + float normWindow2; ///< Size of window for measuring normalisation float sysErr; ///< Systematic error float skyErr; ///< increase effective readnoise @@ -195,3 +197,8 @@ bool pmSubtractionStampsResetStatus (pmSubtractionStampList *stamps); + +bool pmSubtractionKernelPenaltiesStamp(pmSubtractionStamp *stamp, pmSubtractionKernels *kernels); +bool pmSubtractionKernelPenalties(pmSubtractionStamp *stamp, pmSubtractionKernels *kernels, int index); +float pmSubtractionKernelPenaltySingle(psKernel *kernel, bool zeroNull); + #endif Index: /trunk/psModules/src/imcombine/pmSubtractionVisual.c =================================================================== --- /trunk/psModules/src/imcombine/pmSubtractionVisual.c (revision 29003) +++ /trunk/psModules/src/imcombine/pmSubtractionVisual.c (revision 29004) @@ -21,4 +21,5 @@ #include "pmVisual.h" +#include "pmVisualUtils.h" #include "pmHDU.h" @@ -61,5 +62,9 @@ * @return true for success */ bool pmSubtractionVisualPlotConvKernels(psImage *convKernels) { - if (!pmVisualIsVisual() || !plotConvKernels) return true; + + if (!pmVisualTestLevel("ppsub.kernels", 1)) return true; + + if (!plotConvKernels) return true; + if (!pmVisualInitWindow(&kapa1, "ppSub:Images")) { return false; @@ -75,5 +80,9 @@ @return true for success */ bool pmSubtractionVisualPlotStamps(pmSubtractionStampList *stamps, pmReadout *ro) { - if (!pmVisualIsVisual() || !plotStamps) return true; + + if (!pmVisualTestLevel("ppsub.stamps", 1)) return true; + + if (!plotStamps) return true; + if (!pmVisualInitWindow (&kapa1, "ppSub:Images")) { return false; @@ -145,5 +154,8 @@ bool pmSubtractionVisualPlotLeastSquares (pmSubtractionStampList *stamps, bool dual) { - if (!pmVisualIsVisual() || !plotLeastSquares) return true; + if (!pmVisualTestLevel("ppsub.chisq", 1)) return true; + + if (!plotLeastSquares) return true; + if (!pmVisualInitWindow (&kapa1, "PPSub:Images")) { return false; @@ -204,5 +216,9 @@ bool pmSubtractionVisualShowSubtraction(psImage *image, psImage *ref, psImage *sub) { - if (!pmVisualIsVisual() || !plotImage) return true; + + if (!pmVisualTestLevel("ppsub.images.sub", 1)) return true; + + if (!plotImage) return true; + if (!pmVisualInitWindow (&kapa1, "PPSub:Images")) { return false; @@ -218,5 +234,6 @@ bool pmSubtractionVisualShowKernels(pmSubtractionKernels *kernels) { - if (!pmVisualIsVisual()) return true; + if (!pmVisualTestLevel("ppsub.kernels.final", 1)) return true; + if (!pmVisualInitWindow (&kapa1, "PPSub:Images")) { return false; @@ -264,5 +281,6 @@ bool pmSubtractionVisualShowBasis(pmSubtractionStampList *stamps) { - if (!pmVisualIsVisual()) return true; + if (!pmVisualTestLevel("ppsub.basis", 1)) return true; + if (!pmVisualInitWindow (&kapa2, "ppSub:StampMasterImage")) { return false; @@ -425,5 +443,5 @@ bool pmSubtractionVisualShowFitInit(pmSubtractionStampList *stamps) { - if (!pmVisualIsVisual()) return true; + if (!pmVisualTestLevel("ppsub.fit", 1)) return true; // generate 4 storage images large enough to hold the N stamps: @@ -462,5 +480,5 @@ bool pmSubtractionVisualShowFitAddStamp(psKernel *target, psKernel *source, psKernel *convolution, double background, double norm, int index) { - if (!pmVisualIsVisual()) return true; + if (!pmVisualTestLevel("ppsub.stamp", 1)) return true; double sum; @@ -543,5 +561,6 @@ } - if (!pmVisualIsVisual()) return true; + if (!pmVisualTestLevel("ppsub.fit", 1)) return true; + if (!pmVisualInitWindow(&kapa1, "ppSub:Images")) return false; if (!pmVisualInitWindow(&kapa2, "ppSub:Misc")) return false; @@ -605,5 +624,6 @@ Graphdata graphdata; - if (!pmVisualIsVisual()) return true; + if (!pmVisualTestLevel("ppsub.fit", 1)) return true; + if (!pmVisualInitWindow(&kapa3, "ppSub:plots")) return false; Index: /trunk/psModules/src/objects/Makefile.am =================================================================== --- /trunk/psModules/src/objects/Makefile.am (revision 29003) +++ /trunk/psModules/src/objects/Makefile.am (revision 29004) @@ -43,6 +43,8 @@ pmSourceIO_CMF_PS1_V1.c \ pmSourceIO_CMF_PS1_V2.c \ + pmSourceIO_CMF_PS1_V3.c \ pmSourceIO_CMF_PS1_SV1.c \ pmSourceIO_CMF_PS1_DV1.c \ + pmSourceIO_CMF_PS1_DV2.c \ pmSourceIO_MatchedRefs.c \ pmSourcePlots.c \ @@ -60,4 +62,7 @@ pmPSFtryFitPSF.c \ pmPSFtryMetric.c \ + pmPCMdata.c \ + pmPCM_MinimizeChisq.c \ + pmSourceFitPCM.c \ pmTrend2D.c \ pmGrowthCurveGenerate.c \ @@ -71,5 +76,7 @@ models/pmModel_QGAUSS.c \ models/pmModel_RGAUSS.c \ - models/pmModel_SERSIC.c + models/pmModel_SERSIC.c \ + models/pmModel_EXP.c \ + models/pmModel_DEV.c pkginclude_HEADERS = \ @@ -80,4 +87,5 @@ pmPeaks.h \ pmMoments.h \ + pmModelFuncs.h \ pmModel.h \ pmModelClass.h \ @@ -101,4 +109,5 @@ pmPSF_IO.h \ pmPSFtry.h \ + pmPCMdata.h \ pmTrend2D.h \ pmGrowthCurve.h \ @@ -111,5 +120,7 @@ models/pmModel_QGAUSS.h \ models/pmModel_RGAUSS.h \ - models/pmModel_SERSIC.h + models/pmModel_SERSIC.h \ + models/pmModel_EXP.h \ + models/pmModel_DEV.h CLEANFILES = *~ Index: /trunk/psModules/src/objects/models/pmModel_DEV.c =================================================================== --- /trunk/psModules/src/objects/models/pmModel_DEV.c (revision 29004) +++ /trunk/psModules/src/objects/models/pmModel_DEV.c (revision 29004) @@ -0,0 +1,472 @@ +/****************************************************************************** + * this file defines the DEV source shape model. Note that these model functions are loaded + * by pmModelClass.c using 'include', and thus need no 'include' statements of their own. The + * models use a psVector to represent the set of parameters, with the sequence used to specify + * the meaning of the parameter. The meaning of the parameters may thus vary depending on the + * specifics of the model. All models which are used as a PSF representations share a few + * parameters, for which # define names are listed in pmModel.h: + + f = exp(-z^n) + + * PM_PAR_SKY 0 - local sky : note that this is unused and may be dropped in the future + * PM_PAR_I0 1 - central intensity + * PM_PAR_XPOS 2 - X center of object + * PM_PAR_YPOS 3 - Y center of object + * PM_PAR_SXX 4 - X^2 term of elliptical contour (sqrt(2) / SigmaX) + * PM_PAR_SYY 5 - Y^2 term of elliptical contour (sqrt(2) / SigmaY) + * PM_PAR_SXY 6 - X*Y term of elliptical contour + * PM_PAR_7 7 - normalized dev parameter + + note that a standard dev model uses exp(-K*(z^(1/2n) - 1). the additional elements (K, + the -1 offset) are absorbed in this model by the normalization, the exponent, and the + radial scale. We fit the elements in this form, then re-normalize them on output. + *****************************************************************************/ + +#include +#include +#include "pmHDU.h" +#include "pmFPA.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" +#include "pmSpan.h" +#include "pmFootprintSpans.h" +#include "pmFootprint.h" +#include "pmPeaks.h" +#include "pmMoments.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" +#include "pmPSF.h" +#include "pmPSFtry.h" +#include "pmDetections.h" + +#include "pmModel_DEV.h" + +# define PM_MODEL_NPARAM 7 +# define PM_MODEL_FUNC pmModelFunc_DEV +# define PM_MODEL_FLUX pmModelFlux_DEV +# define PM_MODEL_GUESS pmModelGuess_DEV +# define PM_MODEL_LIMITS pmModelLimits_DEV +# define PM_MODEL_RADIUS pmModelRadius_DEV +# define PM_MODEL_FROM_PSF pmModelFromPSF_DEV +# define PM_MODEL_PARAMS_FROM_PSF pmModelParamsFromPSF_DEV +# define PM_MODEL_FIT_STATUS pmModelFitStatus_DEV +# define PM_MODEL_SET_LIMITS pmModelSetLimits_DEV + +// f = exp(-z^0.125) +# define ALPHA 0.125 +// # define ALPHA 0.25 + +// the model is a function of the pixel coordinate (pixcoord[0,1] = x,y) +// 0.5 PIX: the parameters are defined in terms of pixel coords, so the incoming pixcoords +// values need to be pixel coords + +// Lax parameter limits +static float paramsMinLax[] = { -1.0e3, 1.0e-2, -100, -100, 0.001, 0.001, -1.0 }; +static float paramsMaxLax[] = { 1.0e5, 1.0e8, 1.0e4, 1.0e4, 100, 100, 1.0 }; + +// Moderate parameter limits +static float *paramsMinModerate = paramsMinLax; +static float *paramsMaxModerate = paramsMaxLax; + +// Strict parameter limits +static float *paramsMinStrict = paramsMinLax; +static float *paramsMaxStrict = paramsMaxLax; + +// Parameter limits to use +static float *paramsMinUse = paramsMinLax; +static float *paramsMaxUse = paramsMaxLax; +static float betaUse[] = { 1000, 3e6, 5, 5, 1.0, 1.0, 0.5 }; + +static bool limitsApply = true; // Apply limits? + +psF32 PM_MODEL_FUNC (psVector *deriv, + const psVector *params, + const psVector *pixcoord) +{ + psF32 *PAR = params->data.F32; + + float index = 0.5 / ALPHA; + float bn = 1.9992*index - 0.3271; + float Io = exp(bn); + + psF32 X = pixcoord->data.F32[0] - PAR[PM_PAR_XPOS]; + psF32 Y = pixcoord->data.F32[1] - PAR[PM_PAR_YPOS]; + psF32 px = X / PAR[PM_PAR_SXX]; + psF32 py = Y / PAR[PM_PAR_SYY]; + psF32 z = (PS_SQR(px) + PS_SQR(py) + PAR[PM_PAR_SXY]*X*Y); + + assert (z >= 0); + + psF32 f2 = bn*pow(z,ALPHA); + psF32 f1 = Io*exp(-f2); + psF32 z0 = PAR[PM_PAR_I0]*f1; + psF32 f0 = PAR[PM_PAR_SKY] + z0; + + assert (isfinite(f2)); + assert (isfinite(f1)); + assert (isfinite(z0)); + assert (isfinite(f0)); + + if (deriv != NULL) { + psF32 *dPAR = deriv->data.F32; + + // gradient is infinite for z = 0; saturate at z = 0.01 + psF32 z1 = (z < 0.01) ? z0*bn*ALPHA*pow(0.01,ALPHA - 1.0) : z0*bn*ALPHA*pow(z,ALPHA - 1.0); + + dPAR[PM_PAR_SKY] = +1.0; + dPAR[PM_PAR_I0] = +2.0*f1; + + assert (isfinite(z1)); + + dPAR[PM_PAR_XPOS] = +1.0*z1*(2.0*px/PAR[PM_PAR_SXX] + Y*PAR[PM_PAR_SXY]); + dPAR[PM_PAR_YPOS] = +1.0*z1*(2.0*py/PAR[PM_PAR_SYY] + X*PAR[PM_PAR_SXY]); + dPAR[PM_PAR_SXX] = +2.0*z1*px*px/PAR[PM_PAR_SXX]; + dPAR[PM_PAR_SYY] = +2.0*z1*py*py/PAR[PM_PAR_SYY]; + dPAR[PM_PAR_SXY] = -1.0*z1*X*Y; + } + return (f0); +} + +// define the parameter limits +// AR_MAX is the maximum allowed axis ratio +// AR_RATIO is ((1-R)/(1+R))^2 where R = AR_MAX^(-2) +# define AR_MAX 20.0 +# define AR_RATIO 0.99 +bool PM_MODEL_LIMITS (psMinConstraintMode mode, int nParam, float *params, float *beta) +{ + if (!limitsApply) { + return true; + } + psAssert(nParam >= 0 && nParam < PM_MODEL_NPARAM, "Parameter index is out of bounds"); + + // we need to calculate the limits for SXY specially + float q2 = NAN; + if (nParam == PM_PAR_SXY) { + float f1 = 1.0 / PS_SQR(params[PM_PAR_SYY]) + 1.0 / PS_SQR(params[PM_PAR_SXX]); + float f2 = 1.0 / PS_SQR(params[PM_PAR_SYY]) - 1.0 / PS_SQR(params[PM_PAR_SXX]); + float q1 = PS_SQR(f1)*AR_RATIO - PS_SQR(f2); + q1 = (q1 < 0.0) ? 0.0 : q1; + // if q1 < 0.0, f2 ~ f1, we have a very large axis ratio near 45deg.. Saturate at that + // angle and let f2,f1 fight it out + q2 = 0.5*sqrtf(q1); + } + + switch (mode) { + case PS_MINIMIZE_BETA_LIMIT: { + psAssert(beta, "Require beta to limit beta"); + float limit = betaUse[nParam]; + if (nParam == PM_PAR_SXY) { + limit *= q2; + } + if (fabs(beta[nParam]) > fabs(limit)) { + beta[nParam] = (beta[nParam] > 0) ? fabs(limit) : -fabs(limit); + psTrace("psModules.objects", 5, "|beta[nParam==%d]| > |beta_lim|; %g v. %g", + nParam, beta[nParam], limit); + return false; + } + return true; + } + case PS_MINIMIZE_PARAM_MIN: { + psAssert(params, "Require parameters to limit parameters"); + psAssert(paramsMinUse, "Require parameter limits to limit parameters"); + float limit = paramsMinUse[nParam]; + if (nParam == PM_PAR_SXY) { + limit *= q2; + } + if (params[nParam] < limit) { + params[nParam] = limit; + psTrace("psModules.objects", 5, "params[nParam==%d] < params_min; %g v. %g", + nParam, params[nParam], limit); + return false; + } + return true; + } + case PS_MINIMIZE_PARAM_MAX: { + psAssert(params, "Require parameters to limit parameters"); + psAssert(paramsMaxUse, "Require parameter limits to limit parameters"); + float limit = paramsMaxUse[nParam]; + if (nParam == PM_PAR_SXY) { + limit *= q2; + } + if (params[nParam] > limit) { + params[nParam] = limit; + psTrace("psModules.objects", 5, "params[nParam==%d] > params_max; %g v. %g", + nParam, params[nParam], limit); + return false; + } + return true; + } + default: + psAbort("invalid choice for limits"); + } + psAbort("should not reach here"); + return false; +} + +// make an initial guess for parameters +// 0.5 PIX: moments and peaks are in pixel coords, thus so are model parameters +bool PM_MODEL_GUESS (pmModel *model, pmSource *source) +{ + pmMoments *moments = source->moments; + pmPeak *peak = source->peak; + psF32 *PAR = model->params->data.F32; + + psEllipseMoments emoments; + emoments.x2 = moments->Mxx; + emoments.xy = moments->Mxy; + emoments.y2 = moments->Myy; + + // force the axis ratio to be < 20.0 + psEllipseAxes axes = psEllipseMomentsToAxes (emoments, 20.0); + + if (!isfinite(axes.major)) return false; + if (!isfinite(axes.minor)) return false; + if (!isfinite(axes.theta)) return false; + + psEllipseShape shape = psEllipseAxesToShape (axes); + + if (!isfinite(shape.sx)) return false; + if (!isfinite(shape.sy)) return false; + if (!isfinite(shape.sxy)) return false; + + // the other parameters depend on the guess for PAR_7 + float index = 0.5 / ALPHA; + float bn = 1.9992*index - 0.3271; + // float fR = 1.0 / (sqrt(2.0) * pow (bn, index)); + float Io = exp(0.5*bn); + + float Sxx = PS_MAX(0.5, shape.sx); + float Syy = PS_MAX(0.5, shape.sy); + + PAR[PM_PAR_SKY] = 0.0; + PAR[PM_PAR_I0] = peak->flux / Io; + PAR[PM_PAR_XPOS] = peak->xf; + PAR[PM_PAR_YPOS] = peak->yf; + // PAR[PM_PAR_SXX] = Sxx * fR; + // PAR[PM_PAR_SYY] = Syy * fR; + PAR[PM_PAR_SXX] = Sxx; + PAR[PM_PAR_SYY] = Syy; + PAR[PM_PAR_SXY] = shape.sxy; + + return(true); +} + +psF64 PM_MODEL_FLUX (const psVector *params) +{ + float z, norm; + psEllipseShape shape; + + psF32 *PAR = params->data.F32; + + shape.sx = PAR[PM_PAR_SXX] / M_SQRT2; + shape.sy = PAR[PM_PAR_SYY] / M_SQRT2; + shape.sxy = PAR[PM_PAR_SXY]; + + // Area is equivalent to 2 pi sigma^2 + psEllipseAxes axes = psEllipseShapeToAxes (shape, 20.0); + psF64 Area = 2.0 * M_PI * axes.major * axes.minor; + + // the area needs to be multiplied by the integral of f(z) + norm = 0.0; + + # define DZ 0.25 + + float f0 = 1.0; + float f1, f2; + for (z = DZ; z < 50; z += DZ) { + f1 = exp(-pow(z,ALPHA)); + z += DZ; + f2 = exp(-pow(z,ALPHA)); + norm += f0 + 4*f1 + f2; + f0 = f2; + } + norm *= DZ / 3.0; + + psF64 Flux = PAR[PM_PAR_I0] * Area * norm; + + return(Flux); +} + +// define this function so it never returns Inf or NaN +// return the radius which yields the requested flux +psF64 PM_MODEL_RADIUS (const psVector *params, psF64 flux) +{ + psEllipseShape shape; + + psF32 *PAR = params->data.F32; + + if (flux <= 0) + return (1.0); + if (PAR[PM_PAR_I0] <= 0) + return (1.0); + if (flux >= PAR[PM_PAR_I0]) + return (1.0); + + shape.sx = PAR[PM_PAR_SXX] / M_SQRT2; + shape.sy = PAR[PM_PAR_SYY] / M_SQRT2; + shape.sxy = PAR[PM_PAR_SXY]; + + psEllipseAxes axes = psEllipseShapeToAxes (shape, 20.0); + + // f = Io exp(-z^n) -> z^n = ln(Io/f) + psF64 zn = log(PAR[PM_PAR_I0] / flux); + psF64 radius = axes.major * sqrt (2.0) * pow(zn, 0.5 / ALPHA); + + psAssert (isfinite(radius), "fix this code: z should not be nan"); + return (radius); +} + +bool PM_MODEL_FROM_PSF (pmModel *modelPSF, pmModel *modelFLT, const pmPSF *psf) +{ + + psF32 *out = modelPSF->params->data.F32; + psF32 *in = modelFLT->params->data.F32; + + // we require these two parameters to exist + assert (psf->params->n > PM_PAR_YPOS); + assert (psf->params->n > PM_PAR_XPOS); + + for (int i = 0; i < psf->params->n; i++) { + if (psf->params->data[i] == NULL) { + out[i] = in[i]; + } else { + pmTrend2D *trend = psf->params->data[i]; + out[i] = pmTrend2DEval(trend, in[PM_PAR_XPOS], in[PM_PAR_YPOS]); + } + } + + // the 2D PSF model fits polarization terms (E0,E1,E2) + // convert to shape terms (SXX,SYY,SXY) + if (!pmPSF_FitToModel (out, 0.1)) { + psTrace("psModules.objects", 5, "Failed to fit object at (r,c) = (%.1f,%.1f)", in[PM_PAR_YPOS], in[PM_PAR_XPOS]); + return false; + } + + // apply the model limits here: this truncates excessive extrapolation + // XXX do we need to do this still? should we put in asserts to test? + for (int i = 0; i < psf->params->n; i++) { + // apply the limits to all components or just the psf-model parameters? + if (psf->params->data[i] == NULL) + continue; + + bool status = true; + status &= PM_MODEL_LIMITS(PS_MINIMIZE_PARAM_MIN, i, out, NULL); + status &= PM_MODEL_LIMITS(PS_MINIMIZE_PARAM_MAX, i, out, NULL); + if (!status) { + psTrace ("psModules.objects", 5, "Hitting parameter limits at (r,c) = (%.1f, %.1f)", + in[PM_PAR_XPOS], in[PM_PAR_YPOS]); + modelPSF->flags |= PM_MODEL_STATUS_LIMITS; + } + } + + return true; +} + +// construct the PSF model from the FLT model and the psf +// XXX is this sufficiently general do be a global function, not a pmModelClass function? +bool PM_MODEL_PARAMS_FROM_PSF (pmModel *model, const pmPSF *psf, float Xo, float Yo, float Io) +{ + psF32 *PAR = model->params->data.F32; + + // we require these two parameters to exist + assert (psf->params->n > PM_PAR_YPOS); + assert (psf->params->n > PM_PAR_XPOS); + + PAR[PM_PAR_SKY] = 0.0; + PAR[PM_PAR_I0] = Io; + PAR[PM_PAR_XPOS] = Xo; + PAR[PM_PAR_YPOS] = Yo; + + // supply the model-fitted parameters, or copy from the input + for (int i = 0; i < psf->params->n; i++) { + if (i == PM_PAR_SKY) continue; + if (i == PM_PAR_I0) continue; + if (i == PM_PAR_XPOS) continue; + if (i == PM_PAR_YPOS) continue; + pmTrend2D *trend = psf->params->data[i]; + PAR[i] = pmTrend2DEval(trend, Xo, Yo); + } + + // the 2D PSF model fits polarization terms (E0,E1,E2) + // convert to shape terms (SXX,SYY,SXY) + // XXX user-defined value for limit? + if (!pmPSF_FitToModel (PAR, 0.1)) { + psTrace ("psModules.objects", 3, "Failed to fit object at (r,c) = (%.1f,%.1f)", Xo, Yo); + return false; + } + + // apply the model limits here: this truncates excessive extrapolation + // XXX do we need to do this still? should we put in asserts to test? + for (int i = 0; i < psf->params->n; i++) { + // apply the limits to all components or just the psf-model parameters? + if (psf->params->data[i] == NULL) + continue; + + bool status = true; + status &= PM_MODEL_LIMITS (PS_MINIMIZE_PARAM_MIN, i, PAR, NULL); + status &= PM_MODEL_LIMITS (PS_MINIMIZE_PARAM_MAX, i, PAR, NULL); + if (!status) { + psTrace ("psModules.objects", 5, "Hitting parameter limits at (r,c) = (%.1f, %.1f)", Xo, Yo); + model->flags |= PM_MODEL_STATUS_LIMITS; + } + } + return(true); +} + +bool PM_MODEL_FIT_STATUS (pmModel *model) +{ + bool status; + + psF32 *PAR = model->params->data.F32; + psF32 *dPAR = model->dparams->data.F32; + + status = true; + status &= (PAR[PM_PAR_I0] > 0); + status &= ((dPAR[PM_PAR_I0]/PAR[PM_PAR_I0]) < 0.5); + + return status; +} + + +void PM_MODEL_SET_LIMITS(pmModelLimitsType type) +{ + switch (type) { + case PM_MODEL_LIMITS_NONE: + paramsMinUse = NULL; + paramsMaxUse = NULL; + limitsApply = true; + break; + case PM_MODEL_LIMITS_IGNORE: + paramsMinUse = NULL; + paramsMaxUse = NULL; + limitsApply = false; + break; + case PM_MODEL_LIMITS_LAX: + paramsMinUse = paramsMinLax; + paramsMaxUse = paramsMaxLax; + limitsApply = true; + break; + case PM_MODEL_LIMITS_MODERATE: + paramsMinUse = paramsMinModerate; + paramsMaxUse = paramsMaxModerate; + limitsApply = true; + break; + case PM_MODEL_LIMITS_STRICT: + paramsMinUse = paramsMinStrict; + paramsMaxUse = paramsMaxStrict; + limitsApply = true; + break; + default: + psAbort("Unrecognised model limits type: %x", type); + } + return; +} Index: /trunk/psModules/src/objects/models/pmModel_DEV.h =================================================================== --- /trunk/psModules/src/objects/models/pmModel_DEV.h (revision 29004) +++ /trunk/psModules/src/objects/models/pmModel_DEV.h (revision 29004) @@ -0,0 +1,15 @@ +#ifndef PM_MODEL_DEV_H + +#include "pmModel.h" + +psF32 pmModelFunc_DEV(psVector *deriv, const psVector *params, const psVector *pixcoord); +bool pmModelLimits_DEV(psMinConstraintMode mode, int nParam, float *params, float *beta); +bool pmModelGuess_DEV(pmModel *model, pmSource *source); +psF64 pmModelFlux_DEV(const psVector *params); +psF64 pmModelRadius_DEV(const psVector *params, psF64 flux); +bool pmModelFromPSF_DEV(pmModel *modelPSF, pmModel *modelFLT, const pmPSF *psf); +bool pmModelParamsFromPSF_DEV(pmModel *model, const pmPSF *psf, float Xo, float Yo, float Io); +bool pmModelFitStatus_DEV(pmModel *model); +void pmModelSetLimits_DEV(pmModelLimitsType type); + +#endif Index: /trunk/psModules/src/objects/models/pmModel_EXP.c =================================================================== --- /trunk/psModules/src/objects/models/pmModel_EXP.c (revision 29004) +++ /trunk/psModules/src/objects/models/pmModel_EXP.c (revision 29004) @@ -0,0 +1,453 @@ +/****************************************************************************** + * this file defines the Exponential (EXP) source shape model. Note that these model functions + * are loaded by pmModelClass.c using 'include', and thus need no 'include' statements of their + * own. The models use a psVector to represent the set of parameters, with the sequence used + * to specify the meaning of the parameter. The meaning of the parameters may thus vary + * depending on the specifics of the model. All models which are used as a PSF representations + * share a few parameters, for which # define names are listed in pmModel.h: + + f = exp(-sqrt(z)) (since z is r^2) + + * PM_PAR_SKY 0 - local sky : note that this is unused and may be dropped in the future + * PM_PAR_I0 1 - central intensity + * PM_PAR_XPOS 2 - X center of object + * PM_PAR_YPOS 3 - Y center of object + * PM_PAR_SXX 4 - X^2 term of elliptical contour (sqrt(2) / SigmaX) + * PM_PAR_SYY 5 - Y^2 term of elliptical contour (sqrt(2) / SigmaY) + * PM_PAR_SXY 6 - X*Y term of elliptical contour + + *****************************************************************************/ + +#include +#include +#include "pmHDU.h" +#include "pmFPA.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" +#include "pmSpan.h" +#include "pmFootprintSpans.h" +#include "pmFootprint.h" +#include "pmPeaks.h" +#include "pmMoments.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" +#include "pmPSF.h" +#include "pmPSFtry.h" +#include "pmDetections.h" + +#include "pmModel_EXP.h" + +# define PM_MODEL_NPARAM 7 +# define PM_MODEL_FUNC pmModelFunc_EXP +# define PM_MODEL_FLUX pmModelFlux_EXP +# define PM_MODEL_GUESS pmModelGuess_EXP +# define PM_MODEL_LIMITS pmModelLimits_EXP +# define PM_MODEL_RADIUS pmModelRadius_EXP +# define PM_MODEL_FROM_PSF pmModelFromPSF_EXP +# define PM_MODEL_PARAMS_FROM_PSF pmModelParamsFromPSF_EXP +# define PM_MODEL_FIT_STATUS pmModelFitStatus_EXP +# define PM_MODEL_SET_LIMITS pmModelSetLimits_EXP + +// the model is a function of the pixel coordinate (pixcoord[0,1] = x,y) +// 0.5 PIX: the parameters are defined in terms of pixel coords, so the incoming pixcoords +// values need to be pixel coords + +// Lax parameter limits +static float paramsMinLax[] = { -1.0e3, 1.0e-2, -100, -100, 0.05, 0.05, -1.0 }; +static float paramsMaxLax[] = { 1.0e5, 1.0e8, 1.0e4, 1.0e4, 100, 100, 1.0 }; + +// Moderate parameter limits +static float *paramsMinModerate = paramsMinLax; +static float *paramsMaxModerate = paramsMaxLax; + +// Strict parameter limits +static float *paramsMinStrict = paramsMinLax; +static float *paramsMaxStrict = paramsMaxLax; + +// Parameter limits to use +static float *paramsMinUse = paramsMinLax; +static float *paramsMaxUse = paramsMaxLax; +static float betaUse[] = { 1000, 3e6, 5, 5, 1.0, 1.0, 0.5}; + +static bool limitsApply = true; // Apply limits? + +psF32 PM_MODEL_FUNC (psVector *deriv, + const psVector *params, + const psVector *pixcoord) +{ + psF32 *PAR = params->data.F32; + + psF32 X = pixcoord->data.F32[0] - PAR[PM_PAR_XPOS]; + psF32 Y = pixcoord->data.F32[1] - PAR[PM_PAR_YPOS]; + psF32 px = X / PAR[PM_PAR_SXX]; + psF32 py = Y / PAR[PM_PAR_SYY]; + psF32 z = PS_SQR(px) + PS_SQR(py) + PAR[PM_PAR_SXY]*X*Y; + + // XXX if the elliptical contour is defined in valid way, this step should not be required. + // other models (like PGAUSS) don't use fractional powers, and thus do not have NaN values + // for negative values of z + // XXX use an assert here to force the elliptical parameters to be correctly determined + // if (z < 0) z = 0; + assert (z >= 0); + + psF32 f2 = sqrt(z); + psF32 f1 = exp(-f2); + psF32 z0 = PAR[PM_PAR_I0]*f1; + psF32 f0 = PAR[PM_PAR_SKY] + z0; + + assert (isfinite(f2)); + assert (isfinite(f1)); + assert (isfinite(z0)); + assert (isfinite(f0)); + + if (deriv != NULL) { + psF32 *dPAR = deriv->data.F32; + + dPAR[PM_PAR_SKY] = +1.0; + dPAR[PM_PAR_I0] = +f1; + + // gradient is infinite for z = 0; saturate at z = 0.01 + // z1 is -df/dz (the negative sign is canceled by most of dz/dPAR[i] + psF32 z1 = (z < 0.01) ? 0.5*z0/sqrt(0.01) : 0.5*z0/sqrt(z); + + // XXX dampen SXX and SYY as in GAUSS? + dPAR[PM_PAR_XPOS] = +1.0*z1*(2.0*px/PAR[PM_PAR_SXX] + Y*PAR[PM_PAR_SXY]); + dPAR[PM_PAR_YPOS] = +1.0*z1*(2.0*py/PAR[PM_PAR_SYY] + X*PAR[PM_PAR_SXY]); + dPAR[PM_PAR_SXX] = +2.0*z1*px*px/PAR[PM_PAR_SXX]; + dPAR[PM_PAR_SYY] = +2.0*z1*py*py/PAR[PM_PAR_SYY]; + dPAR[PM_PAR_SXY] = -1.0*z1*X*Y; + } + return (f0); +} + +// define the parameter limits +// AR_MAX is the maximum allowed axis ratio +// AR_RATIO is ((1-R)/(1+R))^2 where R = AR_MAX^(-2) +# define AR_MAX 20.0 +# define AR_RATIO 0.99 +bool PM_MODEL_LIMITS (psMinConstraintMode mode, int nParam, float *params, float *beta) +{ + if (!limitsApply) { + return true; + } + psAssert(nParam >= 0 && nParam < PM_MODEL_NPARAM, "Parameter index is out of bounds"); + + // we need to calculate the limits for SXY specially + float q2 = NAN; + if (nParam == PM_PAR_SXY) { + float f1 = 1.0 / PS_SQR(params[PM_PAR_SYY]) + 1.0 / PS_SQR(params[PM_PAR_SXX]); + float f2 = 1.0 / PS_SQR(params[PM_PAR_SYY]) - 1.0 / PS_SQR(params[PM_PAR_SXX]); + float q1 = PS_SQR(f1)*AR_RATIO - PS_SQR(f2); + q1 = (q1 < 0.0) ? 0.0 : q1; + // if q1 < 0.0, f2 ~ f1, we have a very large axis ratio near 45deg.. Saturate at that + // angle and let f2,f1 fight it out + q2 = 0.5*sqrtf(q1); + } + + switch (mode) { + case PS_MINIMIZE_BETA_LIMIT: { + psAssert(beta, "Require beta to limit beta"); + float limit = betaUse[nParam]; + if (nParam == PM_PAR_SXY) { + limit *= q2; + } + if (fabs(beta[nParam]) > fabs(limit)) { + beta[nParam] = (beta[nParam] > 0) ? fabs(limit) : -fabs(limit); + psTrace("psModules.objects", 5, "|beta[nParam==%d]| > |beta_lim|; %g v. %g", + nParam, beta[nParam], limit); + return false; + } + return true; + } + case PS_MINIMIZE_PARAM_MIN: { + psAssert(params, "Require parameters to limit parameters"); + psAssert(paramsMinUse, "Require parameter limits to limit parameters"); + float limit = paramsMinUse[nParam]; + if (nParam == PM_PAR_SXY) { + limit *= q2; + } + if (params[nParam] < limit) { + params[nParam] = limit; + psTrace("psModules.objects", 5, "params[nParam==%d] < params_min; %g v. %g", + nParam, params[nParam], limit); + return false; + } + return true; + } + case PS_MINIMIZE_PARAM_MAX: { + psAssert(params, "Require parameters to limit parameters"); + psAssert(paramsMaxUse, "Require parameter limits to limit parameters"); + float limit = paramsMaxUse[nParam]; + if (nParam == PM_PAR_SXY) { + limit *= q2; + } + if (params[nParam] > limit) { + params[nParam] = limit; + psTrace("psModules.objects", 5, "params[nParam==%d] > params_max; %g v. %g", + nParam, params[nParam], limit); + return false; + } + return true; + } + default: + psAbort("invalid choice for limits"); + } + psAbort("should not reach here"); + return false; +} + +// make an initial guess for parameters +// 0.5 PIX: moments and peaks are in pixel coords, thus so are model parameters +bool PM_MODEL_GUESS (pmModel *model, pmSource *source) +{ + pmMoments *moments = source->moments; + pmPeak *peak = source->peak; + psF32 *PAR = model->params->data.F32; + + psEllipseMoments emoments; + emoments.x2 = moments->Mxx; + emoments.xy = moments->Mxy; + emoments.y2 = moments->Myy; + + // force the axis ratio to be < 20.0 + psEllipseAxes axes = psEllipseMomentsToAxes (emoments, 20.0); + + if (!isfinite(axes.major)) return false; + if (!isfinite(axes.minor)) return false; + if (!isfinite(axes.theta)) return false; + + psEllipseShape shape = psEllipseAxesToShape (axes); + + if (!isfinite(shape.sx)) return false; + if (!isfinite(shape.sy)) return false; + if (!isfinite(shape.sxy)) return false; + + PAR[PM_PAR_SKY] = 0.0; + PAR[PM_PAR_I0] = peak->flux; + PAR[PM_PAR_XPOS] = peak->xf; + PAR[PM_PAR_YPOS] = peak->yf; + PAR[PM_PAR_SXX] = PS_MAX(0.5, M_SQRT2*shape.sx); + PAR[PM_PAR_SYY] = PS_MAX(0.5, M_SQRT2*shape.sy); + PAR[PM_PAR_SXY] = shape.sxy; + return(true); +} + +psF64 PM_MODEL_FLUX (const psVector *params) +{ + float z, norm; + psEllipseShape shape; + + psF32 *PAR = params->data.F32; + + shape.sx = PAR[PM_PAR_SXX] / M_SQRT2; + shape.sy = PAR[PM_PAR_SYY] / M_SQRT2; + shape.sxy = PAR[PM_PAR_SXY]; + + // Area is equivalent to 2 pi sigma^2 + psEllipseAxes axes = psEllipseShapeToAxes (shape, 20.0); + psF64 Area = 2.0 * M_PI * axes.major * axes.minor; + + // the area needs to be multiplied by the integral of f(z) = exp(-sqrt(z)) [0 to infinity] + norm = 0.0; + + # define DZ 0.25 + + float f0 = 1.0; + float f1, f2; + for (z = DZ; z < 50; z += DZ) { + f1 = exp(-sqrt(z)); + z += DZ; + f2 = exp(-sqrt(z)); + norm += f0 + 4*f1 + f2; + f0 = f2; + } + norm *= DZ / 3.0; + + psF64 Flux = PAR[PM_PAR_I0] * Area * norm; + + return(Flux); +} + +// define this function so it never returns Inf or NaN +// return the radius which yields the requested flux +psF64 PM_MODEL_RADIUS (const psVector *params, psF64 flux) +{ + psEllipseShape shape; + + psF32 *PAR = params->data.F32; + + if (flux <= 0) + return (1.0); + if (PAR[PM_PAR_I0] <= 0) + return (1.0); + if (flux >= PAR[PM_PAR_I0]) + return (1.0); + + shape.sx = PAR[PM_PAR_SXX] / M_SQRT2; + shape.sy = PAR[PM_PAR_SYY] / M_SQRT2; + shape.sxy = PAR[PM_PAR_SXY]; + + psEllipseAxes axes = psEllipseShapeToAxes (shape, 20.0); + + // f = Io exp(-sqrt(z)) -> sqrt(z) = ln(Io/f) + psF64 zn = log(PAR[PM_PAR_I0] / flux); + psF64 radius = axes.major * sqrt (2.0) * zn; + + psAssert (isfinite(radius), "fix this code: z should not be nan for %f", PAR[PM_PAR_7]); + return (radius); +} + +bool PM_MODEL_FROM_PSF (pmModel *modelPSF, pmModel *modelFLT, const pmPSF *psf) +{ + + psF32 *out = modelPSF->params->data.F32; + psF32 *in = modelFLT->params->data.F32; + + // we require these two parameters to exist + assert (psf->params->n > PM_PAR_YPOS); + assert (psf->params->n > PM_PAR_XPOS); + + for (int i = 0; i < psf->params->n; i++) { + if (psf->params->data[i] == NULL) { + out[i] = in[i]; + } else { + pmTrend2D *trend = psf->params->data[i]; + out[i] = pmTrend2DEval(trend, in[PM_PAR_XPOS], in[PM_PAR_YPOS]); + } + } + + // the 2D PSF model fits polarization terms (E0,E1,E2) + // convert to shape terms (SXX,SYY,SXY) + if (!pmPSF_FitToModel (out, 0.1)) { + psTrace("psModules.objects", 5, "Failed to fit object at (r,c) = (%.1f,%.1f)", in[PM_PAR_YPOS], in[PM_PAR_XPOS]); + return false; + } + + // apply the model limits here: this truncates excessive extrapolation + // XXX do we need to do this still? should we put in asserts to test? + for (int i = 0; i < psf->params->n; i++) { + // apply the limits to all components or just the psf-model parameters? + if (psf->params->data[i] == NULL) + continue; + + bool status = true; + status &= PM_MODEL_LIMITS(PS_MINIMIZE_PARAM_MIN, i, out, NULL); + status &= PM_MODEL_LIMITS(PS_MINIMIZE_PARAM_MAX, i, out, NULL); + if (!status) { + psTrace ("psModules.objects", 5, "Hitting parameter limits at (r,c) = (%.1f, %.1f)", + in[PM_PAR_XPOS], in[PM_PAR_YPOS]); + modelPSF->flags |= PM_MODEL_STATUS_LIMITS; + } + } + + return true; +} + +// construct the PSF model from the FLT model and the psf +// XXX is this sufficiently general do be a global function, not a pmModelClass function? +bool PM_MODEL_PARAMS_FROM_PSF (pmModel *model, const pmPSF *psf, float Xo, float Yo, float Io) +{ + psF32 *PAR = model->params->data.F32; + + // we require these two parameters to exist + assert (psf->params->n > PM_PAR_YPOS); + assert (psf->params->n > PM_PAR_XPOS); + + PAR[PM_PAR_SKY] = 0.0; + PAR[PM_PAR_I0] = Io; + PAR[PM_PAR_XPOS] = Xo; + PAR[PM_PAR_YPOS] = Yo; + + // supply the model-fitted parameters, or copy from the input + for (int i = 0; i < psf->params->n; i++) { + if (i == PM_PAR_SKY) continue; + if (i == PM_PAR_I0) continue; + if (i == PM_PAR_XPOS) continue; + if (i == PM_PAR_YPOS) continue; + pmTrend2D *trend = psf->params->data[i]; + PAR[i] = pmTrend2DEval(trend, Xo, Yo); + } + + // the 2D PSF model fits polarization terms (E0,E1,E2) + // convert to shape terms (SXX,SYY,SXY) + // XXX user-defined value for limit? + if (!pmPSF_FitToModel (PAR, 0.1)) { + psTrace ("psModules.objects", 3, "Failed to fit object at (r,c) = (%.1f,%.1f)", Xo, Yo); + return false; + } + + // apply the model limits here: this truncates excessive extrapolation + // XXX do we need to do this still? should we put in asserts to test? + for (int i = 0; i < psf->params->n; i++) { + // apply the limits to all components or just the psf-model parameters? + if (psf->params->data[i] == NULL) + continue; + + bool status = true; + status &= PM_MODEL_LIMITS (PS_MINIMIZE_PARAM_MIN, i, PAR, NULL); + status &= PM_MODEL_LIMITS (PS_MINIMIZE_PARAM_MAX, i, PAR, NULL); + if (!status) { + psTrace ("psModules.objects", 5, "Hitting parameter limits at (r,c) = (%.1f, %.1f)", Xo, Yo); + model->flags |= PM_MODEL_STATUS_LIMITS; + } + } + return(true); +} + +bool PM_MODEL_FIT_STATUS (pmModel *model) +{ + bool status; + + psF32 *PAR = model->params->data.F32; + psF32 *dPAR = model->dparams->data.F32; + + status = true; + status &= (PAR[PM_PAR_I0] > 0); + status &= ((dPAR[PM_PAR_I0]/PAR[PM_PAR_I0]) < 0.5); + + return status; +} + + +void PM_MODEL_SET_LIMITS(pmModelLimitsType type) +{ + switch (type) { + case PM_MODEL_LIMITS_NONE: + paramsMinUse = NULL; + paramsMaxUse = NULL; + limitsApply = true; + break; + case PM_MODEL_LIMITS_IGNORE: + paramsMinUse = NULL; + paramsMaxUse = NULL; + limitsApply = false; + break; + case PM_MODEL_LIMITS_LAX: + paramsMinUse = paramsMinLax; + paramsMaxUse = paramsMaxLax; + limitsApply = true; + break; + case PM_MODEL_LIMITS_MODERATE: + paramsMinUse = paramsMinModerate; + paramsMaxUse = paramsMaxModerate; + limitsApply = true; + break; + case PM_MODEL_LIMITS_STRICT: + paramsMinUse = paramsMinStrict; + paramsMaxUse = paramsMaxStrict; + limitsApply = true; + break; + default: + psAbort("Unrecognised model limits type: %x", type); + } + return; +} Index: /trunk/psModules/src/objects/models/pmModel_EXP.h =================================================================== --- /trunk/psModules/src/objects/models/pmModel_EXP.h (revision 29004) +++ /trunk/psModules/src/objects/models/pmModel_EXP.h (revision 29004) @@ -0,0 +1,15 @@ +#ifndef PM_MODEL_EXP_H + +#include "pmModel.h" + +psF32 pmModelFunc_EXP(psVector *deriv, const psVector *params, const psVector *pixcoord); +bool pmModelLimits_EXP(psMinConstraintMode mode, int nParam, float *params, float *beta); +bool pmModelGuess_EXP(pmModel *model, pmSource *source); +psF64 pmModelFlux_EXP(const psVector *params); +psF64 pmModelRadius_EXP(const psVector *params, psF64 flux); +bool pmModelFromPSF_EXP(pmModel *modelPSF, pmModel *modelFLT, const pmPSF *psf); +bool pmModelParamsFromPSF_EXP(pmModel *model, const pmPSF *psf, float Xo, float Yo, float Io); +bool pmModelFitStatus_EXP(pmModel *model); +void pmModelSetLimits_EXP(pmModelLimitsType type); + +#endif Index: /trunk/psModules/src/objects/models/pmModel_GAUSS.c =================================================================== --- /trunk/psModules/src/objects/models/pmModel_GAUSS.c (revision 29003) +++ /trunk/psModules/src/objects/models/pmModel_GAUSS.c (revision 29004) @@ -21,11 +21,31 @@ #include #include - +#include "pmHDU.h" +#include "pmFPA.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" +#include "pmSpan.h" +#include "pmFootprintSpans.h" +#include "pmFootprint.h" +#include "pmPeaks.h" #include "pmMoments.h" -#include "pmPeaks.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" #include "pmSource.h" -#include "pmModel.h" +#include "pmSourceFitModel.h" +#include "pmPSF.h" +#include "pmPSFtry.h" +#include "pmDetections.h" + #include "pmModel_GAUSS.h" +# define PM_MODEL_NPARAM 7 # define PM_MODEL_FUNC pmModelFunc_GAUSS # define PM_MODEL_FLUX pmModelFlux_GAUSS @@ -83,4 +103,5 @@ dPAR[PM_PAR_XPOS] = q*(2*px/PAR[PM_PAR_SXX] + Y*PAR[PM_PAR_SXY]); dPAR[PM_PAR_YPOS] = q*(2*py/PAR[PM_PAR_SYY] + X*PAR[PM_PAR_SXY]); + // the extra factor of 2 below is needed to avoid excessive swings dPAR[PM_PAR_SXX] = +4.0*q*px*px/PAR[PM_PAR_SXX]; @@ -102,5 +123,5 @@ return true; } - psAssert(nParam >= 0 && nParam <= PM_PAR_7, "Parameter index is out of bounds"); + psAssert(nParam >= 0 && nParam < PM_MODEL_NPARAM, "Parameter index is out of bounds"); // we need to calculate the limits for SXY specially @@ -347,4 +368,5 @@ // this test is invalid if the parameters are derived // from the PSF model +// XXX how is this used? it prevents forced photometry from ever being 'successful' bool PM_MODEL_FIT_STATUS (pmModel *model) { @@ -394,12 +416,2 @@ return; } - -# undef PM_MODEL_FUNC -# undef PM_MODEL_FLUX -# undef PM_MODEL_GUESS -# undef PM_MODEL_LIMITS -# undef PM_MODEL_RADIUS -# undef PM_MODEL_FROM_PSF -# undef PM_MODEL_PARAMS_FROM_PSF -# undef PM_MODEL_FIT_STATUS -# undef PM_MODEL_SET_LIMITS Index: /trunk/psModules/src/objects/models/pmModel_PGAUSS.c =================================================================== --- /trunk/psModules/src/objects/models/pmModel_PGAUSS.c (revision 29003) +++ /trunk/psModules/src/objects/models/pmModel_PGAUSS.c (revision 29004) @@ -21,11 +21,31 @@ #include #include - +#include "pmHDU.h" +#include "pmFPA.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" +#include "pmSpan.h" +#include "pmFootprintSpans.h" +#include "pmFootprint.h" +#include "pmPeaks.h" #include "pmMoments.h" -#include "pmPeaks.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" #include "pmSource.h" -#include "pmModel.h" +#include "pmSourceFitModel.h" +#include "pmPSF.h" +#include "pmPSFtry.h" +#include "pmDetections.h" + #include "pmModel_PGAUSS.h" +# define PM_MODEL_NPARAM 7 # define PM_MODEL_FUNC pmModelFunc_PGAUSS # define PM_MODEL_FLUX pmModelFlux_PGAUSS @@ -103,5 +123,5 @@ return true; } - psAssert(nParam >= 0 && nParam <= PM_PAR_7, "Parameter index is out of bounds"); + psAssert(nParam >= 0 && nParam < PM_MODEL_NPARAM, "Parameter index is out of bounds"); // we need to calculate the limits for SXY specially @@ -448,12 +468,2 @@ return; } - -# undef PM_MODEL_FUNC -# undef PM_MODEL_FLUX -# undef PM_MODEL_GUESS -# undef PM_MODEL_LIMITS -# undef PM_MODEL_RADIUS -# undef PM_MODEL_FROM_PSF -# undef PM_MODEL_PARAMS_FROM_PSF -# undef PM_MODEL_FIT_STATUS -# undef PM_MODEL_SET_LIMITS Index: /trunk/psModules/src/objects/models/pmModel_PS1_V1.c =================================================================== --- /trunk/psModules/src/objects/models/pmModel_PS1_V1.c (revision 29003) +++ /trunk/psModules/src/objects/models/pmModel_PS1_V1.c (revision 29004) @@ -22,11 +22,31 @@ #include #include - +#include "pmHDU.h" +#include "pmFPA.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" +#include "pmSpan.h" +#include "pmFootprintSpans.h" +#include "pmFootprint.h" +#include "pmPeaks.h" #include "pmMoments.h" -#include "pmPeaks.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" #include "pmSource.h" -#include "pmModel.h" +#include "pmSourceFitModel.h" +#include "pmPSF.h" +#include "pmPSFtry.h" +#include "pmDetections.h" + #include "pmModel_PS1_V1.h" +# define PM_MODEL_NPARAM 8 # define PM_MODEL_FUNC pmModelFunc_PS1_V1 # define PM_MODEL_FLUX pmModelFlux_PS1_V1 @@ -122,5 +142,5 @@ return true; } - psAssert(nParam >= 0 && nParam <= PM_PAR_7, "Parameter index is out of bounds"); + psAssert(nParam >= 0 && nParam < PM_MODEL_NPARAM, "Parameter index is out of bounds"); // we need to calculate the limits for SXY specially @@ -222,5 +242,5 @@ PAR[PM_PAR_SYY] = PS_MAX(0.5, M_SQRT2*shape.sy); PAR[PM_PAR_SXY] = shape.sxy; - PAR[PM_PAR_7] = 1.0; + PAR[PM_PAR_7] = 0.5; return(true); @@ -468,14 +488,2 @@ return; } - -# undef PM_MODEL_FUNC -# undef PM_MODEL_FLUX -# undef PM_MODEL_GUESS -# undef PM_MODEL_LIMITS -# undef PM_MODEL_RADIUS -# undef PM_MODEL_FROM_PSF -# undef PM_MODEL_PARAMS_FROM_PSF -# undef PM_MODEL_FIT_STATUS -# undef PM_MODEL_SET_LIMITS -# undef ALPHA -# undef ALPHA_M Index: /trunk/psModules/src/objects/models/pmModel_QGAUSS.c =================================================================== --- /trunk/psModules/src/objects/models/pmModel_QGAUSS.c (revision 29003) +++ /trunk/psModules/src/objects/models/pmModel_QGAUSS.c (revision 29004) @@ -22,11 +22,31 @@ #include #include - +#include "pmHDU.h" +#include "pmFPA.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" +#include "pmSpan.h" +#include "pmFootprintSpans.h" +#include "pmFootprint.h" +#include "pmPeaks.h" #include "pmMoments.h" -#include "pmPeaks.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" #include "pmSource.h" -#include "pmModel.h" +#include "pmSourceFitModel.h" +#include "pmPSF.h" +#include "pmPSFtry.h" +#include "pmDetections.h" + #include "pmModel_QGAUSS.h" +# define PM_MODEL_NPARAM 8 # define PM_MODEL_FUNC pmModelFunc_QGAUSS # define PM_MODEL_FLUX pmModelFlux_QGAUSS @@ -123,5 +143,5 @@ return true; } - psAssert(nParam >= 0 && nParam <= PM_PAR_7, "Parameter index is out of bounds"); + psAssert(nParam >= 0 && nParam < PM_MODEL_NPARAM, "Parameter index is out of bounds"); // we need to calculate the limits for SXY specially @@ -469,14 +489,2 @@ return; } - -# undef PM_MODEL_FUNC -# undef PM_MODEL_FLUX -# undef PM_MODEL_GUESS -# undef PM_MODEL_LIMITS -# undef PM_MODEL_RADIUS -# undef PM_MODEL_FROM_PSF -# undef PM_MODEL_PARAMS_FROM_PSF -# undef PM_MODEL_FIT_STATUS -# undef PM_MODEL_SET_LIMITS -# undef ALPHA -# undef ALPHA_M Index: /trunk/psModules/src/objects/models/pmModel_RGAUSS.c =================================================================== --- /trunk/psModules/src/objects/models/pmModel_RGAUSS.c (revision 29003) +++ /trunk/psModules/src/objects/models/pmModel_RGAUSS.c (revision 29004) @@ -22,11 +22,31 @@ #include #include - +#include "pmHDU.h" +#include "pmFPA.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" +#include "pmSpan.h" +#include "pmFootprintSpans.h" +#include "pmFootprint.h" +#include "pmPeaks.h" #include "pmMoments.h" -#include "pmPeaks.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" #include "pmSource.h" -#include "pmModel.h" +#include "pmSourceFitModel.h" +#include "pmPSF.h" +#include "pmPSFtry.h" +#include "pmDetections.h" + #include "pmModel_RGAUSS.h" +# define PM_MODEL_NPARAM 8 # define PM_MODEL_FUNC pmModelFunc_RGAUSS # define PM_MODEL_FLUX pmModelFlux_RGAUSS @@ -112,5 +132,5 @@ return true; } - psAssert(nParam >= 0 && nParam <= PM_PAR_7, "Parameter index is out of bounds"); + psAssert(nParam >= 0 && nParam < PM_MODEL_NPARAM, "Parameter index is out of bounds"); // we need to calculate the limits for SXY specially @@ -209,8 +229,8 @@ PAR[PM_PAR_XPOS] = peak->xf; PAR[PM_PAR_YPOS] = peak->yf; - PAR[PM_PAR_SXX] = PS_MAX(0.5, M_SQRT2*shape.sx); - PAR[PM_PAR_SYY] = PS_MAX(0.5, M_SQRT2*shape.sy); + PAR[PM_PAR_SXX] = PS_MAX(0.5, shape.sx); + PAR[PM_PAR_SYY] = PS_MAX(0.5, shape.sy); PAR[PM_PAR_SXY] = shape.sxy; - PAR[PM_PAR_7] = 2.25; + PAR[PM_PAR_7] = 1.5; return(true); @@ -463,12 +483,2 @@ return; } - -# undef PM_MODEL_FUNC -# undef PM_MODEL_FLUX -# undef PM_MODEL_GUESS -# undef PM_MODEL_LIMITS -# undef PM_MODEL_RADIUS -# undef PM_MODEL_FROM_PSF -# undef PM_MODEL_PARAMS_FROM_PSF -# undef PM_MODEL_FIT_STATUS -# undef PM_MODEL_SET_LIMITS Index: /trunk/psModules/src/objects/models/pmModel_SERSIC.c =================================================================== --- /trunk/psModules/src/objects/models/pmModel_SERSIC.c (revision 29003) +++ /trunk/psModules/src/objects/models/pmModel_SERSIC.c (revision 29004) @@ -18,5 +18,5 @@ * PM_PAR_7 7 - normalized sersic parameter - note that a standard sersic model uses exp(-K*(z^(1/n) - 1). the additional elements (K, + note that a standard sersic model uses exp(-K*(z^(1/2n) - 1). the additional elements (K, the -1 offset) are absorbed in this model by the normalization, the exponent, and the radial scale. We fit the elements in this form, then re-normalize them on output. @@ -25,11 +25,31 @@ #include #include - +#include "pmHDU.h" +#include "pmFPA.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" +#include "pmSpan.h" +#include "pmFootprintSpans.h" +#include "pmFootprint.h" +#include "pmPeaks.h" #include "pmMoments.h" -#include "pmPeaks.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" #include "pmSource.h" -#include "pmModel.h" +#include "pmSourceFitModel.h" +#include "pmPSF.h" +#include "pmPSFtry.h" +#include "pmDetections.h" + #include "pmModel_SERSIC.h" +# define PM_MODEL_NPARAM 8 # define PM_MODEL_FUNC pmModelFunc_SERSIC # define PM_MODEL_FLUX pmModelFlux_SERSIC @@ -47,5 +67,5 @@ // Lax parameter limits -static float paramsMinLax[] = { -1.0e3, 1.0e-2, -100, -100, 0.05, 0.05, -1.0, 0.05 }; +static float paramsMinLax[] = { -1.0e3, 1.0e-2, -100, -100, 0.001, 0.001, -1.0, 0.05 }; static float paramsMaxLax[] = { 1.0e5, 1.0e8, 1.0e4, 1.0e4, 100, 100, 1.0, 4.0 }; @@ -84,6 +104,10 @@ assert (z >= 0); - psF32 f2 = pow(z,PAR[PM_PAR_7]); - psF32 f1 = exp(-f2); + float index = 0.5 / PAR[PM_PAR_7]; + float bn = 1.9992*index - 0.3271; + float Io = exp(bn); + + psF32 f2 = bn*pow(z,PAR[PM_PAR_7]); + psF32 f1 = Io*exp(-f2); psF32 z0 = PAR[PM_PAR_I0]*f1; psF32 f0 = PAR[PM_PAR_SKY] + z0; @@ -98,9 +122,10 @@ // gradient is infinite for z = 0; saturate at z = 0.01 - psF32 z1 = (z < 0.01) ? z0*PAR[PM_PAR_7]*pow(0.01,PAR[PM_PAR_7] - 1.0) : z0*PAR[PM_PAR_7]*pow(z,PAR[PM_PAR_7] - 1.0); + psF32 z1 = (z < 0.01) ? z0*bn*PAR[PM_PAR_7]*pow(0.01,PAR[PM_PAR_7] - 1.0) : z0*bn*PAR[PM_PAR_7]*pow(z,PAR[PM_PAR_7] - 1.0); dPAR[PM_PAR_SKY] = +1.0; dPAR[PM_PAR_I0] = +f1; - dPAR[PM_PAR_7] = (z == 0.0) ? 0.0 : -z0*f2*log(z); + dPAR[PM_PAR_7] = (z < 0.01) ? -z0*pow(0.01,PAR[PM_PAR_7])*log(0.01) : -z0*f2*log(z); + dPAR[PM_PAR_7] *= 3.0; assert (isfinite(z1)); @@ -109,7 +134,6 @@ dPAR[PM_PAR_XPOS] = +1.0*z1*(2.0*px/PAR[PM_PAR_SXX] + Y*PAR[PM_PAR_SXY]); dPAR[PM_PAR_YPOS] = +1.0*z1*(2.0*py/PAR[PM_PAR_SYY] + X*PAR[PM_PAR_SXY]); - dPAR[PM_PAR_SXX] = +2.0*z1*px*px/PAR[PM_PAR_SXX]; + dPAR[PM_PAR_SXX] = +2.0*z1*px*px/PAR[PM_PAR_SXX]; // XXX : increase drag? dPAR[PM_PAR_SYY] = +2.0*z1*py*py/PAR[PM_PAR_SYY]; - dPAR[PM_PAR_SXY] = -1.0*z1*X*Y; dPAR[PM_PAR_SXY] = -1.0*z1*X*Y; } @@ -127,5 +151,5 @@ return true; } - psAssert(nParam >= 0 && nParam <= PM_PAR_7, "Parameter index is out of bounds"); + psAssert(nParam >= 0 && nParam < PM_MODEL_NPARAM, "Parameter index is out of bounds"); // we need to calculate the limits for SXY specially @@ -201,4 +225,15 @@ psF32 *PAR = model->params->data.F32; + // the other parameters depend on the guess for PAR_7 + if (!isfinite(PAR[PM_PAR_7])) { + PAR[PM_PAR_7] = 0.25; + } + float index = 0.5 / PAR[PM_PAR_7]; + + // the scale-length is a function of the moments and the index: + // Rmajor_guess = Rmajor_moments * Scale * Zero + float Scale = 0.70 + 0.053 * PAR[PM_PAR_7]; + float Zero = 1.16 - 0.615 * PAR[PM_PAR_7]; + psEllipseMoments emoments; emoments.x2 = moments->Mxx; @@ -213,4 +248,12 @@ if (!isfinite(axes.theta)) return false; + // set a lower limit to avoid absurd solutions.. + float Rmajor = PS_MAX(1.0, Scale * axes.major + Zero); + float Rminor = Rmajor * (axes.minor / axes.major); + + fprintf (stderr, "guess index: %f : %f, %f -> %f, %f\n", index, axes.major, axes.minor, Rmajor, Rminor); + + axes.major = Rmajor; + axes.minor = Rminor; psEllipseShape shape = psEllipseAxesToShape (axes); @@ -219,12 +262,22 @@ if (!isfinite(shape.sxy)) return false; + float bn = 1.9992*index - 0.3271; + // float fR = 1.0 / (sqrt(2.0) * pow (bn, index)); + float Io = exp(0.5*bn); + + // XXX do we need this factor of sqrt(2)? + // float Sxx = PS_MAX(0.5, M_SQRT2*shape.sx); + // float Syy = PS_MAX(0.5, M_SQRT2*shape.sy); + + float Sxx = PS_MAX(0.5, shape.sx); + float Syy = PS_MAX(0.5, shape.sy); + PAR[PM_PAR_SKY] = 0.0; - PAR[PM_PAR_I0] = peak->flux; + PAR[PM_PAR_I0] = peak->flux / Io; PAR[PM_PAR_XPOS] = peak->xf; PAR[PM_PAR_YPOS] = peak->yf; - PAR[PM_PAR_SXX] = PS_MAX(0.5, M_SQRT2*shape.sx); - PAR[PM_PAR_SYY] = PS_MAX(0.5, M_SQRT2*shape.sy); + PAR[PM_PAR_SXX] = Sxx; + PAR[PM_PAR_SYY] = Syy; PAR[PM_PAR_SXY] = shape.sxy; - PAR[PM_PAR_7] = 0.5; return(true); @@ -254,7 +307,8 @@ float f1, f2; for (z = DZ; z < 50; z += DZ) { - f1 = 1.0 / (1 + PAR[PM_PAR_7]*z + pow(z, 2.25)); + // f1 = 1.0 / (1 + PAR[PM_PAR_7]*z + pow(z, 2.25)); + f1 = exp(-pow(z,PAR[PM_PAR_7])); z += DZ; - f2 = 1.0 / (1 + PAR[PM_PAR_7]*z + pow(z, 2.25)); + f2 = exp(-pow(z,PAR[PM_PAR_7])); norm += f0 + 4*f1 + f2; f0 = f2; @@ -287,17 +341,12 @@ psEllipseAxes axes = psEllipseShapeToAxes (shape, 20.0); - psF64 sigma = axes.major; - - psF64 limit = flux / PAR[PM_PAR_I0]; - - psF64 z = pow (-log(limit), (1.0 / PAR[PM_PAR_7])); - psAssert (isfinite(z), "fix this code: z should not be nan for %f", PAR[PM_PAR_7]); - - psF64 radius = sigma * sqrt (2.0 * z); - psAssert (isfinite(radius), "fix this code: radius should not be nan for %f, %f", PAR[PM_PAR_7], sigma); - - if (isnan(radius)) - psAbort("error in code: radius is NaN"); - + + // f = Io exp(-z^n) -> z^n = ln(Io/f) + psF64 zn = log(PAR[PM_PAR_I0] / flux); + psF64 radius = axes.major * sqrt (2.0) * pow(zn, 0.5 / PAR[PM_PAR_7]); + + fprintf (stderr, "sersic model %f %f, n %f, radius: %f, zn: %f, f/Io: %f, major: %f\n", PAR[PM_PAR_XPOS], PAR[PM_PAR_YPOS], PAR[PM_PAR_7], radius, zn, flux/PAR[PM_PAR_I0], axes.major); + + psAssert (isfinite(radius), "fix this code: z should not be nan for %f", PAR[PM_PAR_7]); return (radius); } @@ -448,12 +497,2 @@ return; } - -# undef PM_MODEL_FUNC -# undef PM_MODEL_FLUX -# undef PM_MODEL_GUESS -# undef PM_MODEL_LIMITS -# undef PM_MODEL_RADIUS -# undef PM_MODEL_FROM_PSF -# undef PM_MODEL_PARAMS_FROM_PSF -# undef PM_MODEL_FIT_STATUS -# undef PM_MODEL_SET_LIMITS Index: /trunk/psModules/src/objects/pmDetEff.c =================================================================== --- /trunk/psModules/src/objects/pmDetEff.c (revision 29003) +++ /trunk/psModules/src/objects/pmDetEff.c (revision 29004) @@ -3,8 +3,30 @@ #endif +#include #include +#include "pmHDU.h" +#include "pmFPA.h" +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" +#include "pmSpan.h" +#include "pmFootprintSpans.h" +#include "pmFootprint.h" +#include "pmPeaks.h" +#include "pmMoments.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" +#include "pmPSF.h" +#include "pmPSFtry.h" +#include "pmDetections.h" #include "pmDetEff.h" - static void detEffFree(pmDetEff *de) Index: /trunk/psModules/src/objects/pmDetEff.h =================================================================== --- /trunk/psModules/src/objects/pmDetEff.h (revision 29003) +++ /trunk/psModules/src/objects/pmDetEff.h (revision 29004) @@ -1,9 +1,4 @@ #ifndef PM_DET_EFF_H #define PM_DET_EFF_H - -#include -#include - -#include "pmFPA.h" #define PM_DETEFF_ANALYSIS "DETEFF" // Location of detection efficiency on pmReadout.analysis Index: /trunk/psModules/src/objects/pmFootprint.c =================================================================== --- /trunk/psModules/src/objects/pmFootprint.c (revision 29003) +++ /trunk/psModules/src/objects/pmFootprint.c (revision 29004) @@ -19,4 +19,5 @@ #include #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" Index: /trunk/psModules/src/objects/pmFootprint.h =================================================================== --- /trunk/psModules/src/objects/pmFootprint.h (revision 29003) +++ /trunk/psModules/src/objects/pmFootprint.h (revision 29004) @@ -10,8 +10,4 @@ #ifndef PM_FOOTPRINT_H #define PM_FOOTPRINT_H - -#include -#include "pmSpan.h" -#include "pmFootprintSpans.h" typedef struct { Index: /trunk/psModules/src/objects/pmFootprintArrayGrow.c =================================================================== --- /trunk/psModules/src/objects/pmFootprintArrayGrow.c (revision 29003) +++ /trunk/psModules/src/objects/pmFootprintArrayGrow.c (revision 29004) @@ -18,4 +18,5 @@ #include #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" Index: /trunk/psModules/src/objects/pmFootprintArraysMerge.c =================================================================== --- /trunk/psModules/src/objects/pmFootprintArraysMerge.c (revision 29003) +++ /trunk/psModules/src/objects/pmFootprintArraysMerge.c (revision 29004) @@ -18,4 +18,5 @@ #include #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" Index: /trunk/psModules/src/objects/pmFootprintAssignPeaks.c =================================================================== --- /trunk/psModules/src/objects/pmFootprintAssignPeaks.c (revision 29003) +++ /trunk/psModules/src/objects/pmFootprintAssignPeaks.c (revision 29004) @@ -18,4 +18,5 @@ #include #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" Index: /trunk/psModules/src/objects/pmFootprintCullPeaks.c =================================================================== --- /trunk/psModules/src/objects/pmFootprintCullPeaks.c (revision 29003) +++ /trunk/psModules/src/objects/pmFootprintCullPeaks.c (revision 29004) @@ -19,6 +19,6 @@ #include #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" -#include "pmFootprintSpans.h" #include "pmPeaks.h" Index: /trunk/psModules/src/objects/pmFootprintFind.c =================================================================== --- /trunk/psModules/src/objects/pmFootprintFind.c (revision 29003) +++ /trunk/psModules/src/objects/pmFootprintFind.c (revision 29004) @@ -19,4 +19,5 @@ #include #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" Index: /trunk/psModules/src/objects/pmFootprintFindAtPoint.c =================================================================== --- /trunk/psModules/src/objects/pmFootprintFindAtPoint.c (revision 29003) +++ /trunk/psModules/src/objects/pmFootprintFindAtPoint.c (revision 29004) @@ -19,7 +19,7 @@ #include #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" -#include "pmFootprintSpans.h" /************************************************************************************************************/ Index: /trunk/psModules/src/objects/pmFootprintIDs.c =================================================================== --- /trunk/psModules/src/objects/pmFootprintIDs.c (revision 29003) +++ /trunk/psModules/src/objects/pmFootprintIDs.c (revision 29004) @@ -19,4 +19,5 @@ #include #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" Index: /trunk/psModules/src/objects/pmFootprintSpans.c =================================================================== --- /trunk/psModules/src/objects/pmFootprintSpans.c (revision 29003) +++ /trunk/psModules/src/objects/pmFootprintSpans.c (revision 29004) @@ -19,7 +19,7 @@ #include #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" -#include "pmFootprintSpans.h" static void pmStartSpanFree(pmStartSpan *sspan) { Index: /trunk/psModules/src/objects/pmFootprintSpans.h =================================================================== --- /trunk/psModules/src/objects/pmFootprintSpans.h (revision 29003) +++ /trunk/psModules/src/objects/pmFootprintSpans.h (revision 29004) @@ -10,7 +10,4 @@ #ifndef PM_FOOTPRINT_SPANS_H #define PM_FOOTPRINT_SPANS_H - -#include -#include "pmSpan.h" /* We define two helper structures used in building the pmFootprints: Index: /trunk/psModules/src/objects/pmGrowthCurve.c =================================================================== --- /trunk/psModules/src/objects/pmGrowthCurve.c (revision 29003) +++ /trunk/psModules/src/objects/pmGrowthCurve.c (revision 29004) @@ -20,14 +20,26 @@ #include "pmHDU.h" #include "pmFPA.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmResiduals.h" -#include "pmGrowthCurve.h" -#include "pmTrend2D.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" #include "pmPSF.h" -#include "pmModel.h" -#include "pmSource.h" +#include "pmPSFtry.h" +#include "pmDetections.h" + #include "psVectorBracket.h" Index: /trunk/psModules/src/objects/pmGrowthCurveGenerate.c =================================================================== --- /trunk/psModules/src/objects/pmGrowthCurveGenerate.c (revision 29003) +++ /trunk/psModules/src/objects/pmGrowthCurveGenerate.c (revision 29004) @@ -24,20 +24,30 @@ #include "pmHDU.h" #include "pmFPA.h" +#include "pmFPAMaskWeight.h" +#include "psVectorBracket.h" +#include "pmErrorCodes.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmResiduals.h" -#include "pmGrowthCurve.h" -#include "pmTrend2D.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" #include "pmPSF.h" -#include "pmModel.h" -#include "pmSource.h" -#include "pmModelClass.h" -#include "pmModelUtils.h" +#include "pmPSFtry.h" +#include "pmDetections.h" + #include "pmSourcePhotometry.h" -#include "pmFPAMaskWeight.h" -#include "psVectorBracket.h" -#include "pmErrorCodes.h" pmGrowthCurve *pmGrowthCurveForPosition (psImage *image, pmPSF *psf, bool ignore, psImageMaskType maskVal, psImageMaskType markVal, float xc, float yc); Index: /trunk/psModules/src/objects/pmModel.c =================================================================== --- /trunk/psModules/src/objects/pmModel.c (revision 29003) +++ /trunk/psModules/src/objects/pmModel.c (revision 29004) @@ -23,8 +23,14 @@ #include "pmHDU.h" #include "pmFPA.h" + +#include "pmTrend2D.h" #include "pmResiduals.h" #include "pmGrowthCurve.h" -#include "pmTrend2D.h" -#include "pmPSF.h" +#include "pmSpan.h" +#include "pmFootprintSpans.h" +#include "pmFootprint.h" +#include "pmPeaks.h" +#include "pmMoments.h" +#include "pmModelFuncs.h" #include "pmModel.h" #include "pmModelClass.h" @@ -75,6 +81,6 @@ for (psS32 i = 0; i < tmp->params->n; i++) { - tmp->params->data.F32[i] = 0.0; - tmp->dparams->data.F32[i] = 0.0; + tmp->params->data.F32[i] = NAN; + tmp->dparams->data.F32[i] = NAN; } Index: /trunk/psModules/src/objects/pmModel.h =================================================================== --- /trunk/psModules/src/objects/pmModel.h (revision 29003) +++ /trunk/psModules/src/objects/pmModel.h (revision 29004) @@ -14,7 +14,4 @@ # define PM_MODEL_H -#include -#include "pmPSF.h" - /// @addtogroup Objects Object Detection / Analysis Functions /// @{ @@ -22,68 +19,4 @@ /* pointers for the functions types below are supplied to each pmModel, and can be used by the programmer without needing to know the model class */ - -typedef enum { - PM_MODEL_STATUS_NONE = 0x00, ///< model fit not yet attempted, no other info - PM_MODEL_STATUS_FITTED = 0x01, ///< model fit completed - PM_MODEL_STATUS_NONCONVERGE = 0x02, ///< model fit did not converge - PM_MODEL_STATUS_OFFIMAGE = 0x04, ///< model fit drove out of range - PM_MODEL_STATUS_BADARGS = 0x08, ///< model fit called with invalid args - PM_MODEL_STATUS_LIMITS = 0x10 ///< model parameters hit limits -} pmModelStatus; - -typedef enum { - PM_MODEL_OP_NONE = 0x00, - PM_MODEL_OP_FUNC = 0x01, - PM_MODEL_OP_RES0 = 0x02, - PM_MODEL_OP_RES1 = 0x04, - PM_MODEL_OP_FULL = 0x07, - PM_MODEL_OP_SKY = 0x08, - PM_MODEL_OP_CENTER = 0x10, - PM_MODEL_OP_NORM = 0x20, - PM_MODEL_OP_NOISE = 0x40, -} pmModelOpMode; - -/// Parameter limit types -typedef enum { - PM_MODEL_LIMITS_NONE, ///< Apply no limits: suitable for debugging - PM_MODEL_LIMITS_IGNORE, ///< Ignore all limits: fit can go to town - PM_MODEL_LIMITS_LAX, ///< Lax limits: attempting to reproduce even bad data - PM_MODEL_LIMITS_MODERATE, ///< Moderate limits: cope with mildly bad data - PM_MODEL_LIMITS_STRICT, ///< Strict limits: insist on good quality data -} pmModelLimitsType; - -typedef struct pmModel pmModel; -typedef struct pmSource pmSource; - -// This function is the model chi-square minimization function for this model. -typedef psMinimizeLMChi2Func pmModelFunc; - -// This function sets the parameter limits for this model. -typedef psMinimizeLMLimitFunc pmModelLimits; - -// This function returns the integrated flux for the given model parameters. -typedef psF64 (*pmModelFlux)(const psVector *params); - -// This function returns the radius at which the given model and parameters -// achieves the given flux. -typedef psF64 (*pmModelRadius)(const psVector *params, double flux); - -// This function provides the model guess parameters based on the details of -// the given source. -typedef bool (*pmModelGuessFunc)(pmModel *model, pmSource *source); - -// This function constructs the PSF model for the given source based on the -// supplied psf and the EXT model for the object. -typedef bool (*pmModelFromPSFFunc)(pmModel *modelPSF, pmModel *modelEXT, const pmPSF *psf); - -// This function sets the model parameters based on the PSF for a given coordinate and central -// intensity -typedef bool (*pmModelParamsFromPSF)(pmModel *model, const pmPSF *psf, float Xo, float Yo, float Io); - -// This function returns the success / failure status of the given model fit -typedef bool (*pmModelFitStatusFunc)(pmModel *model); - -// This function sets the parameter limits for the given model -typedef bool (*pmModelSetLimitsFunc)(pmModelLimitsType type); /** pmModel data structure @@ -122,18 +55,4 @@ pmModelSetLimitsFunc modelSetLimits; }; - -/** Symbolic names for the elements of [d]params - * Note: these are #defines not enums as a given element of [d]params - * may/will correspond to different parameters in different contexts - */ -#define PM_PAR_SKY 0 ///< Sky -#define PM_PAR_I0 1 ///< Central intensity -#define PM_PAR_XPOS 2 ///< X centre of object -#define PM_PAR_YPOS 3 ///< Y centre of object -#define PM_PAR_SXX 4 ///< shape X^2 moment -#define PM_PAR_SYY 5 ///< shape Y^2 moment -#define PM_PAR_SXY 6 ///< shape XY moment -#define PM_PAR_7 7 ///< ??? Unknown parameter -#define PM_PAR_8 8 ///< ??? Unknown parameter /** pmModelAlloc() Index: /trunk/psModules/src/objects/pmModelClass.c =================================================================== --- /trunk/psModules/src/objects/pmModelClass.c (revision 29003) +++ /trunk/psModules/src/objects/pmModelClass.c (revision 29004) @@ -23,15 +23,18 @@ #include "pmHDU.h" #include "pmFPA.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmResiduals.h" -#include "pmGrowthCurve.h" -#include "pmTrend2D.h" -#include "pmPSF.h" +#include "pmModelFuncs.h" #include "pmModel.h" -#include "pmSource.h" +#include "pmModelUtils.h" #include "pmModelClass.h" + #include "pmErrorCodes.h" @@ -46,4 +49,6 @@ # include "models/pmModel_RGAUSS.h" # include "models/pmModel_SERSIC.h" +# include "models/pmModel_EXP.h" +# include "models/pmModel_DEV.h" static pmModelClass defaultModels[] = { @@ -53,5 +58,7 @@ {"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 }, {"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 }, - {"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 } + {"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 }, + {"PS_MODEL_EXP", 7, (pmModelFunc)pmModelFunc_EXP, (pmModelFlux)pmModelFlux_EXP, (pmModelRadius)pmModelRadius_EXP, (pmModelLimits)pmModelLimits_EXP, (pmModelGuessFunc)pmModelGuess_EXP, (pmModelFromPSFFunc)pmModelFromPSF_EXP, (pmModelParamsFromPSF)pmModelParamsFromPSF_EXP, (pmModelFitStatusFunc)pmModelFitStatus_EXP, (pmModelSetLimitsFunc)pmModelSetLimits_EXP }, + {"PS_MODEL_DEV", 7, (pmModelFunc)pmModelFunc_DEV, (pmModelFlux)pmModelFlux_DEV, (pmModelRadius)pmModelRadius_DEV, (pmModelLimits)pmModelLimits_DEV, (pmModelGuessFunc)pmModelGuess_DEV, (pmModelFromPSFFunc)pmModelFromPSF_DEV, (pmModelParamsFromPSF)pmModelParamsFromPSF_DEV, (pmModelFitStatusFunc)pmModelFitStatus_DEV, (pmModelSetLimitsFunc)pmModelSetLimits_DEV }, }; Index: /trunk/psModules/src/objects/pmModelClass.h =================================================================== --- /trunk/psModules/src/objects/pmModelClass.h (revision 29003) +++ /trunk/psModules/src/objects/pmModelClass.h (revision 29004) @@ -28,6 +28,4 @@ # ifndef PM_MODEL_CLASS_H # define PM_MODEL_CLASS_H - -#include /// @addtogroup Objects Object Detection / Analysis Functions Index: /trunk/psModules/src/objects/pmModelFuncs.h =================================================================== --- /trunk/psModules/src/objects/pmModelFuncs.h (revision 29004) +++ /trunk/psModules/src/objects/pmModelFuncs.h (revision 29004) @@ -0,0 +1,120 @@ +/* @file pmModelClass.h + * + * The object model function types are desined to allow for the flexible addition of new + * object models. Every object model, with parameters represented by pmModel, has an + * associated set of functions which provide necessary support operations. A These + * functions allow the programmer to select the approriate function or property for a + * specific object model class. + * + * Every model instance belongs to a class of models, defined by the value of the + * pmModelType type entry. Various functions need access to information about each of the + * models. Some of this information varies from model to model, and may depend on the + * current parameter values or other data quantities. In order to keep the code from + * requiring the information about each model to be coded into the low-level fitting + * routines, we define a collection of functions which allow us to abstract this type of + * model-dependent information. These generic functions take the model type and return the + * corresponding function pointer for the specified model. Each model is defined by + * creating this collection of specific functions, and placing them in a single file for + * each model. We define the following structure to carry the collection of information + * about the models. + * + * @author EAM, IfA + * + * @version $Revision: 1.4 $ $Name: not supported by cvs2svn $ + * @date $Date: 2007-11-27 03:14:57 $ + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ + +# ifndef PM_MODEL_FUNCS_H +# define PM_MODEL_FUNCS_H + +/// @addtogroup Objects Object Detection / Analysis Functions +/// @{ + +// type of model carried by the pmModel structure +typedef int pmModelType; + +typedef enum { + PM_MODEL_STATUS_NONE = 0x00, ///< model fit not yet attempted, no other info + PM_MODEL_STATUS_FITTED = 0x01, ///< model fit completed + PM_MODEL_STATUS_NONCONVERGE = 0x02, ///< model fit did not converge + PM_MODEL_STATUS_OFFIMAGE = 0x04, ///< model fit drove out of range + PM_MODEL_STATUS_BADARGS = 0x08, ///< model fit called with invalid args + PM_MODEL_STATUS_LIMITS = 0x10, ///< model parameters hit limits + PM_MODEL_STATUS_WEAK_FIT = 0x20, ///< model fit met loose tolerance, but not tight tolerance +} pmModelStatus; + +typedef enum { + PM_MODEL_OP_NONE = 0x00, + PM_MODEL_OP_FUNC = 0x01, + PM_MODEL_OP_RES0 = 0x02, + PM_MODEL_OP_RES1 = 0x04, + PM_MODEL_OP_FULL = 0x07, + PM_MODEL_OP_SKY = 0x08, + PM_MODEL_OP_CENTER = 0x10, + PM_MODEL_OP_NORM = 0x20, + PM_MODEL_OP_NOISE = 0x40, +} pmModelOpMode; + +/// Parameter limit types +typedef enum { + PM_MODEL_LIMITS_NONE, ///< Apply no limits: suitable for debugging + PM_MODEL_LIMITS_IGNORE, ///< Ignore all limits: fit can go to town + PM_MODEL_LIMITS_LAX, ///< Lax limits: attempting to reproduce even bad data + PM_MODEL_LIMITS_MODERATE, ///< Moderate limits: cope with mildly bad data + PM_MODEL_LIMITS_STRICT, ///< Strict limits: insist on good quality data +} pmModelLimitsType; + +/** Symbolic names for the elements of [d]params + * Note: these are #defines not enums as a given element of [d]params + * may/will correspond to different parameters in different contexts + */ +#define PM_PAR_SKY 0 ///< Sky +#define PM_PAR_I0 1 ///< Central intensity +#define PM_PAR_XPOS 2 ///< X center of object +#define PM_PAR_YPOS 3 ///< Y center of object +#define PM_PAR_SXX 4 ///< shape X^2 moment +#define PM_PAR_SYY 5 ///< shape Y^2 moment +#define PM_PAR_SXY 6 ///< shape XY moment +#define PM_PAR_7 7 ///< Model-dependent parameter +#define PM_PAR_8 8 ///< Model-dependent parameter + +/*** these prototype classes are used to define elements of the pmModelClass structure below ***/ + +typedef struct pmModel pmModel; +typedef struct pmSource pmSource; +typedef struct pmPSF pmPSF; + +// This function is the model chi-square minimization function for this model. +typedef psMinimizeLMChi2Func pmModelFunc; + +// This function sets the parameter limits for this model. +typedef psMinimizeLMLimitFunc pmModelLimits; + +// This function returns the integrated flux for the given model parameters. +typedef psF64 (*pmModelFlux)(const psVector *params); + +// This function returns the radius at which the given model and parameters +// achieves the given flux. +typedef psF64 (*pmModelRadius)(const psVector *params, double flux); + +// This function provides the model guess parameters based on the details of +// the given source. +typedef bool (*pmModelGuessFunc)(pmModel *model, pmSource *source); + +// This function constructs the PSF model for the given source based on the +// supplied psf and the EXT model for the object. +typedef bool (*pmModelFromPSFFunc)(pmModel *modelPSF, pmModel *modelEXT, const pmPSF *psf); + +// This function sets the model parameters based on the PSF for a given coordinate and central +// intensity +typedef bool (*pmModelParamsFromPSF)(pmModel *model, const pmPSF *psf, float Xo, float Yo, float Io); + +// This function returns the success / failure status of the given model fit +typedef bool (*pmModelFitStatusFunc)(pmModel *model); + +// This function sets the parameter limits for the given model +typedef bool (*pmModelSetLimitsFunc)(pmModelLimitsType type); + +/// @} +# endif /* PM_MODEL_FUNCS_H */ Index: /trunk/psModules/src/objects/pmModelUtils.c =================================================================== --- /trunk/psModules/src/objects/pmModelUtils.c (revision 29003) +++ /trunk/psModules/src/objects/pmModelUtils.c (revision 29004) @@ -22,11 +22,25 @@ #include "pmHDU.h" #include "pmFPA.h" + +#include "pmTrend2D.h" #include "pmResiduals.h" #include "pmGrowthCurve.h" -#include "pmTrend2D.h" +#include "pmSpan.h" +#include "pmFootprintSpans.h" +#include "pmFootprint.h" +#include "pmPeaks.h" +#include "pmMoments.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" #include "pmPSF.h" -#include "pmModel.h" + #include "pmErrorCodes.h" -#include "pmModelUtils.h" /***************************************************************************** Index: /trunk/psModules/src/objects/pmMoments.c =================================================================== --- /trunk/psModules/src/objects/pmMoments.c (revision 29003) +++ /trunk/psModules/src/objects/pmMoments.c (revision 29004) @@ -29,4 +29,13 @@ psTrace("psModules.objects", 10, "---- %s() begin ----\n", __func__); pmMoments *tmp = (pmMoments *) psAlloc(sizeof(pmMoments)); + + tmp->Mrf = 0.0; + tmp->Mrh = 0.0; + tmp->KronFlux = 0.0; + tmp->KronFluxErr = 0.0; + + tmp->KronFinner = 0.0; + tmp->KronFouter = 0.0; + tmp->Mx = 0.0; tmp->My = 0.0; Index: /trunk/psModules/src/objects/pmMoments.h =================================================================== --- /trunk/psModules/src/objects/pmMoments.h (revision 29003) +++ /trunk/psModules/src/objects/pmMoments.h (revision 29004) @@ -24,4 +24,7 @@ typedef struct { + float Mrf; ///< radial first moment + float Mrh; ///< radial half moment + float Mx; ///< X-coord of centroid. float My; ///< Y-coord of centroid. @@ -47,4 +50,11 @@ float SN; ///< approx signal-to-noise int nPixels; ///< Number of pixels used. + + float KronFlux; ///< Kron flux (flux in 2.5*Mrf) + float KronFluxErr; ///< Kron flux error + + float KronFinner; ///< Kron flux (flux in 2.5*Mrf) + float KronFouter; ///< Kron flux (flux in 2.5*Mrf) + } pmMoments; Index: /trunk/psModules/src/objects/pmPCM_MinimizeChisq.c =================================================================== --- /trunk/psModules/src/objects/pmPCM_MinimizeChisq.c (revision 29004) +++ /trunk/psModules/src/objects/pmPCM_MinimizeChisq.c (revision 29004) @@ -0,0 +1,444 @@ +/* @file pmPCM_MinimizeChisq.c + * structures and functions to support PSF-convolved model fitting + * + * @author EAM, IfA + * + * @version $Revision: 1.29 $ + * @date $Date: 2009-02-16 22:30:50 $ + * Copyright 2010 Institute for Astronomy, University of Hawaii + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include +#include +#include +#include +#include +#include "pmHDU.h" +#include "pmFPA.h" +#include "pmFPAMaskWeight.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" +#include "pmSpan.h" +#include "pmFootprintSpans.h" +#include "pmFootprint.h" +#include "pmPeaks.h" +#include "pmMoments.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" +#include "pmPCMdata.h" + +# define FACILITY "psModules.objects" + +# define USE_FFT 1 +# define PRE_CONVOLVE 1 + +bool pmPCM_MinimizeChisq ( + psMinimization *min, + psImage *covar, + psVector *params, + pmSource *source, + pmPCMdata *pcm) +{ + psTrace(FACILITY, 3, "---- begin ----\n"); + PS_ASSERT_PTR_NON_NULL(min, false); + PS_ASSERT_VECTOR_NON_NULL(params, false); + PS_ASSERT_VECTOR_NON_EMPTY(params, false); + PS_ASSERT_VECTOR_TYPE(params, PS_TYPE_F32, false); + PS_ASSERT_PTR_NON_NULL(source, false); + PS_ASSERT_PTR_NON_NULL(pcm, false); + PS_ASSERT_VECTOR_TYPE(pcm->constraint->paramMask, PS_TYPE_VECTOR_MASK, false); + PS_ASSERT_VECTORS_SIZE_EQUAL(params, pcm->constraint->paramMask, false); + + psVector *paramMask = pcm->constraint->paramMask; + + psMinimizeLMLimitFunc checkLimits = pcm->constraint->checkLimits; + + // this function has test values and current values for several things + // the current value is in lower case + // the test value is in upper case + + // allocate internal arrays (current vs Guess) + psImage *Alpha = NULL; + psVector *Beta = NULL; + + // Alpha & Beta only contain elements to represent the unmasked parameters + if (!psMinLM_AllocAB (&Alpha, &Beta, params, paramMask)) { + psAbort ("programming error: no unmasked parameters to be fit\n"); + } + + // allocate internal arrays (current vs Guess) + psImage *alpha = psImageAlloc(Alpha->numCols, Alpha->numRows, PS_TYPE_F32); + psVector *beta = psVectorAlloc(Beta->n, PS_TYPE_F32); + psVector *Params = psVectorAlloc(params->n, PS_TYPE_F32); + + psF32 Chisq = 0.0; + psF32 lambda = 0.001; + psF32 dLinear = 0.0; + +# if (USE_FFT && PRE_CONVOLVE) + if (pcm->psfFFT) { + psFree (pcm->psfFFT); + } + pcm->psfFFT = psImageConvolveKernelInit(pcm->modelFlux, pcm->psf); +# endif + + // calculate initial alpha and beta, set chisq (min->value) + min->value = pmPCM_SetABX(alpha, beta, params, paramMask, pcm, source); + if (isnan(min->value)) { + min->iter = min->maxIter; + return(false); + } + // dump some useful info if trace is defined + if (psTraceGetLevel(FACILITY) >= 6) { + p_psImagePrint(psTraceGetDestination(), alpha, "alpha guess (0)"); + p_psVectorPrint(psTraceGetDestination(), beta, "beta guess (0)"); + } + if (psTraceGetLevel(FACILITY) >= 5) { + p_psVectorPrint(psTraceGetDestination(), params, "params guess (0)"); + } + + // iterate until the tolerance is reached, or give up + bool done = (min->iter >= min->maxIter); + while (!done) { + psTrace("psModules.objects", 5, "Iteration number %d. (max iterations is %d).\n", min->iter, min->maxIter); + psTrace("psModules.objects", 5, "Last delta is %f. stop if < %f, accept if < %f\n", min->lastDelta, min->minTol, min->maxTol); + + // set a new guess for Alpha, Beta, Params + if (!psMinLM_GuessABP(Alpha, Beta, Params, alpha, beta, params, paramMask, checkLimits, lambda, &dLinear)) { + min->iter ++; + if (min->iter >= min->maxIter) break; + lambda *= 10.0; + continue; + } + + // dump some useful info if trace is defined + if (psTraceGetLevel(FACILITY) >= 6) { + p_psImagePrint(psTraceGetDestination(), Alpha, "Alpha guess (1)"); + p_psVectorPrint(psTraceGetDestination(), Beta, "Beta guess (1)"); + p_psVectorPrint(psTraceGetDestination(), beta, "beta current (1)"); + } + if (psTraceGetLevel(FACILITY) >= 5) { + p_psVectorPrint(psTraceGetDestination(), Params, "params guess (1)"); + } + + // calculate Chisq for new guess, update Alpha & Beta + Chisq = pmPCM_SetABX(Alpha, Beta, Params, paramMask, pcm, source); + if (isnan(Chisq)) { + min->iter ++; + if (min->iter >= min->maxIter) break; + lambda *= 10.0; + continue; + } + + // convergence criterion: + // compare the delta (min->value - Chisq) with the + // expected delta from the linear model (dLinear) + // accept new guess if it is an improvement (rho > 0), or else increase lambda + psF32 rho = (min->value - Chisq) / dLinear; + + psTrace(FACILITY, 5, "last chisq: %f, new chisq %f, delta: %f, rho: %f\n", min->value, Chisq, min->lastDelta, rho); + + // dump some useful info if trace is defined + if (psTraceGetLevel(FACILITY) >= 6) { + p_psImagePrint(psTraceGetDestination(), Alpha, "alpha guess (2)"); + p_psVectorPrint(psTraceGetDestination(), Beta, "beta guess (2)"); + } + + /* if (Chisq < min->value) { */ + if (rho >= -1e-6) { + min->lastDelta = (min->value - Chisq) / (source->pixels->numCols*source->pixels->numRows - params->n); + min->value = Chisq; + alpha = psImageCopy(alpha, Alpha, PS_TYPE_F32); + beta = psVectorCopy(beta, Beta, PS_TYPE_F32); + params = psVectorCopy(params, Params, PS_TYPE_F32); + lambda *= 0.25; + + // save the new convolved model image + psFree (source->modelFlux); + source->modelFlux = pmPCMdataSaveImage(pcm); + } else { + lambda *= 10.0; + } + min->iter++; + + done = (min->iter >= min->maxIter); + + // check for convergence: + float chisqDOF = Chisq / pcm->nDOF; + if (!isfinite(min->maxChisqDOF) || ((chisqDOF < min->maxChisqDOF) && isfinite(min->lastDelta))) { + done |= (min->lastDelta < min->minTol); + } + } + psTrace(FACILITY, 5, "chisq: %f, last delta: %f, Niter: %d\n", min->value, min->lastDelta, min->iter); + + // construct & return the covariance matrix (if requested) + if (covar != NULL) { + if (!psMinLM_GuessABP(Alpha, Beta, Params, alpha, beta, params, paramMask, NULL, 0.0, NULL)) { + psTrace (FACILITY, 5, "failure to calculate covariance matrix\n"); + } + // set covar values which are not masked + psImageInit (covar, 0.0); + for (int j = 0, J = 0; j < params->n; j++) { + if (paramMask && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[j])) { + covar->data.F32[j][j] = 1.0; + continue; + } + for (int k = 0, K = 0; k < params->n; k++) { + if (paramMask && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[k])) continue; + covar->data.F32[j][k] = Alpha->data.F32[J][K]; + K++; + } + J++; + } + } + + // free the internal temporary data + psFree(alpha); + psFree(Alpha); + psFree(beta); + psFree(Beta); + psFree(Params); + + // if the last improvement was at least as good as maxTol, accept the fit: + if (min->lastDelta <= min->maxTol) { + psTrace(FACILITY, 6, "---- end (true) ----\n"); + return(true); + } + psTrace(FACILITY, 6, "---- end (false) ----\n"); + return(false); +} + +psF32 pmPCM_SetABX( + psImage *alpha, + psVector *beta, + const psVector *params, + const psVector *paramMask, + pmPCMdata *pcm, + const pmSource *source) +{ + // XXX: Check vector sizes. + PS_ASSERT_IMAGE_NON_NULL(alpha, NAN); + PS_ASSERT_VECTOR_NON_NULL(beta, NAN); + PS_ASSERT_VECTOR_NON_NULL(params, NAN); + + PS_ASSERT_PTR_NON_NULL(source, NAN); + PS_ASSERT_IMAGE_NON_NULL(source->pixels, NAN); + PS_ASSERT_IMAGE_NON_NULL(source->variance, NAN); + PS_ASSERT_IMAGE_NON_NULL(source->maskObj, NAN); + + PS_ASSERT_VECTOR_TYPE(params, PS_TYPE_F32, false); + if (paramMask) { + PS_ASSERT_VECTOR_TYPE(paramMask, PS_TYPE_VECTOR_MASK, false); + } + + // 1 *** generate the model and derivative images for this parameter set + + // storage for model derivatives + psVector *deriv = psVectorAlloc(params->n, PS_TYPE_F32); + + // working vector to store local coordinate + psVector *coord = psVectorAlloc(2, PS_TYPE_F32); + + psImageInit (pcm->modelFlux, 0.0); + for (int n = 0; n < params->n; n++) { + if (!pcm->dmodelsFlux->data[n]) continue; + psImageInit (pcm->dmodelsFlux->data[n], 0.0); + } + + // fill in the coordinate and value entries + for (psS32 i = 0; i < source->pixels->numRows; i++) { + for (psS32 j = 0; j < source->pixels->numCols; j++) { + + // XXX can we skip some of the data points where the model + // is not going to be fitted?? + + // skip masked points + // XXX probably should not skipped masked points: + // XXX skip if convolution of unmasked pixels will not see this pixel + // if (source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[i][j]) { + // continue; + // } + + // skip zero-variance points + // XXX why is this not masked? + // if (source->variance->data.F32[i][j] == 0) { + // continue; + // } + // skip nan value points + // XXX why is this not masked? + // if (!isfinite(source->pixels->data.F32[i][j])) { + // continue; + // } + + // Convert i/j to image space: + coord->data.F32[0] = (psF32) (j + source->pixels->col0); + coord->data.F32[1] = (psF32) (i + source->pixels->row0); + + pcm->modelFlux->data.F32[i][j] = pcm->modelConv->modelFunc (deriv, params, coord); + + for (int n = 0; n < params->n; n++) { + if ((paramMask != NULL) && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[n])) { continue; } + psImage *dmodel = pcm->dmodelsFlux->data[n]; + dmodel->data.F32[i][j] = deriv->data.F32[n]; + } + } + } + psFree(coord); + psFree(deriv); + + // convolve model and dmodel arrays with PSF + // XXX speed this up by saving the FFTed psf (for each source, obviously) + + // XXX save the FFT'ed psf + // XXX create an alternative function which takes a pre-FFTed kernel + +# if (USE_FFT) +# if (PRE_CONVOLVE) + // convolve model image and derivative images with pre-convolved kernel + psImageConvolveKernel (pcm->modelConvFlux, pcm->modelFlux, NULL, 0, pcm->psfFFT); + for (int n = 0; n < pcm->dmodelsFlux->n; n++) { + if (pcm->dmodelsFlux->data[n] == NULL) continue; + psImage *dmodel = pcm->dmodelsFlux->data[n]; + psImage *dmodelConv = pcm->dmodelsConvFlux->data[n]; + psImageConvolveKernel (dmodelConv, dmodel, NULL, 0, pcm->psfFFT); + } +# else + // convolve model image and derivative images with psf via FFT + psImageConvolveFFT (pcm->modelConvFlux, pcm->modelFlux, NULL, 0, pcm->psf); + for (int n = 0; n < pcm->dmodelsFlux->n; n++) { + if (pcm->dmodelsFlux->data[n] == NULL) continue; + psImage *dmodel = pcm->dmodelsFlux->data[n]; + psImage *dmodelConv = pcm->dmodelsConvFlux->data[n]; + psImageConvolveFFT (dmodelConv, dmodel, NULL, 0, pcm->psf); + } +# endif // PRE-CONVOLVE +# else + // convolve model image and derivative images with psf direct + psImageConvolveDirect (pcm->modelConvFlux, pcm->modelFlux, pcm->psf); + for (int n = 0; n < pcm->dmodelsFlux->n; n++) { + if (pcm->dmodelsFlux->data[n] == NULL) continue; + psImage *dmodel = pcm->dmodelsFlux->data[n]; + psImage *dmodelConv = pcm->dmodelsConvFlux->data[n]; + psImageConvolveDirect (dmodelConv, dmodel, pcm->psf); + } +# endif // USE_FFT + + // XXX TEST : SAVE IMAGES +# if (SAVE_IMAGES) + psphotSaveImage (NULL, pcm->psf->image, "psf.fits"); + psphotSaveImage (NULL, pcm->modelFlux, "model.fits"); + psphotSaveImage (NULL, pcm->modelConvFlux, "modelConv.fits"); + psphotSaveImage (NULL, source->pixels, "obj.fits"); + psphotSaveImage (NULL, source->maskObj, "mask.fits"); + psphotSaveImage (NULL, source->variance, "variance.fits"); +# endif + + // 2 *** accumulate alpha & beta + + // zero alpha and beta for summing below + psImageInit (alpha, 0.0); + psVectorInit (beta, 0.0); + float chisq = 0.0; + + for (psS32 i = 0; i < source->pixels->numRows; i++) { + for (psS32 j = 0; j < source->pixels->numCols; j++) { + // XXX are we doing the right thing with the mask? + // skip masked points + if (source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[i][j]) { + continue; + } + // skip zero-variance points + if (source->variance->data.F32[i][j] == 0) { + continue; + } + // skip nan value points + if (!isfinite(source->pixels->data.F32[i][j])) { + continue; + } + + float ymodel = pcm->modelConvFlux->data.F32[i][j]; + float yweight = 1.0 / source->variance->data.F32[i][j]; + float delta = ymodel - source->pixels->data.F32[i][j]; + + chisq += PS_SQR(delta) * yweight; + + if (isnan(delta)) psAbort("nan in delta"); + if (isnan(chisq)) psAbort("nan in chisq"); + + // alpha & beta only contain unmasked elements + for (int n1 = 0, N1 = 0; n1 < params->n; n1++) { + if ((paramMask != NULL) && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[n1])) continue; + psImage *dmodel = pcm->dmodelsConvFlux->data[n1]; + float weight = dmodel->data.F32[i][j] * yweight; + for (int n2 = 0, N2 = 0; n2 <= n1; n2++) { + if ((paramMask != NULL) && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[n2])) continue; + dmodel = pcm->dmodelsConvFlux->data[n2]; + alpha->data.F32[N1][N2] += weight * dmodel->data.F32[i][j]; + N2++; + } + beta->data.F32[N1] += weight * delta; + N1++; + } + } + } + + // calculate lower-left half of alpha + for (psS32 j = 1; j < alpha->numCols; j++) { + for (psS32 k = 0; k < j; k++) { + alpha->data.F32[k][j] = alpha->data.F32[j][k]; + } + } + + return(chisq); +} + + +/* + * + * we have a function func(param; value) + + * basic LMM: + + - fill in the data (x, y) + + chisq = SetABX (alpha, beta, params, paramMask, x, y, dy, func) + + while () { + GuessABP (Alpha, Beta, Params, alpha, beta, params, paramMask, checkLimits, lambda) + dLinear = dLinear(Beta, beta, lambda); + chisq = SetABX (alpha, beta, params, paramMask, x, y, dy, func) + convergence tests... + } + + + + ** GuessABP: + + f_c = sum_i (kern_i * func (x_i; p_o)) + + df_c/dp_o = d/dp_o [sum_i (kern_i * func (x_i; p_o))] + + df_c/dp_o = sum_i (d/dp_o [kern_i * func (x_i; p_o)]) + + df_c/dp_o = sum_i (kern_i * d/dp_o [func (x_i; p_o)]) + + - generate image arrays for func, dfunc/dp_j (not masked) + - convolve each with psf + - measure delta = f_conv - data + - etc +*/ + + Index: /trunk/psModules/src/objects/pmPCMdata.c =================================================================== --- /trunk/psModules/src/objects/pmPCMdata.c (revision 29004) +++ /trunk/psModules/src/objects/pmPCMdata.c (revision 29004) @@ -0,0 +1,364 @@ +/* @file pmPCMdata.c + * structures and functions to support PSF-convolved model fitting + * + * @author EAM, IfA + * + * @version $Revision: 1.29 $ + * @date $Date: 2009-02-16 22:30:50 $ + * Copyright 2010 Institute for Astronomy, University of Hawaii + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include +#include +#include +#include +#include +#include "pmHDU.h" +#include "pmFPA.h" +#include "pmFPAMaskWeight.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" +#include "pmSpan.h" +#include "pmFootprintSpans.h" +#include "pmFootprint.h" +#include "pmPeaks.h" +#include "pmMoments.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" +#include "pmPCMdata.h" + +static void pmPCMdataFree (pmPCMdata *pcm) { + + if (pcm == NULL) return; + + psFree (pcm->modelFlux); + psFree (pcm->modelConvFlux); + psFree (pcm->dmodelsFlux); + psFree (pcm->dmodelsConvFlux); + + psFree (pcm->modelConv); + psFree (pcm->psf); + psFree (pcm->psfFFT); + psFree (pcm->constraint); + return; +} + +pmPCMdata *pmPCMdataAlloc ( + const psVector *params, + const psVector *paramMask, + pmSource *source) { + + pmPCMdata *pcm = (pmPCMdata *) psAlloc(sizeof(pmPCMdata)); + psMemSetDeallocator(pcm, (psFreeFunc) pmPCMdataFree); + + // Allocate storage images for raw model and derivative images + pcm->modelFlux = psImageCopy (NULL, source->pixels, PS_TYPE_F32); + pcm->dmodelsFlux = psArrayAlloc (params->n); + for (psS32 n = 0; n < params->n; n++) { + pcm->dmodelsFlux->data[n] = NULL; + if ((paramMask != NULL) && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[n])) { continue; } + pcm->dmodelsFlux->data[n] = psImageCopy (NULL, source->pixels, PS_TYPE_F32); + } + + // Allocate storage images for convolved model and derivative images + pcm->modelConvFlux = psImageCopy (NULL, source->pixels, PS_TYPE_F32); + pcm->dmodelsConvFlux = psArrayAlloc (params->n); + for (psS32 n = 0; n < params->n; n++) { + pcm->dmodelsConvFlux->data[n] = NULL; + if ((paramMask != NULL) && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[n])) { continue; } + pcm->dmodelsConvFlux->data[n] = psImageCopy (NULL, source->pixels, PS_TYPE_F32); + } + + pcm->modelConv = NULL; + pcm->psf = NULL; + pcm->psfFFT = NULL; + pcm->constraint = NULL; + pcm->nDOF = 0; + + return pcm; +} + +psImage *pmPCMdataSaveImage (pmPCMdata *pcm) { + + psImage *model = psImageCopy (NULL, pcm->modelConvFlux, PS_TYPE_F32); + + return model; +} + +psKernel *pmPCMkernelFromPSF (pmSource *source, int nPix) { + + assert (source); + assert (source->psfImage); // XXX build if needed? + + int x0 = source->peak->xf - source->psfImage->col0; + int y0 = source->peak->yf - source->psfImage->row0; + + // need to decide on the size: dynamically? statically? + psKernel *psf = psKernelAlloc (-nPix, +nPix, -nPix, +nPix); + + // XXX we should just re-construct a PSF at this location + // psModelAdd (psf->image, NULL, source->modelPSF, PM_MODEL_OP_FULL | PM_MODEL_OP_NORM | PM_MODEL_OP_CENTER); + + // if the realized PSF for this object does not cover the full kernel, give up for now + if (x0 + psf->xMin < 0) goto escape; + if (x0 + psf->xMax >= source->psfImage->numCols) goto escape; + if (y0 + psf->yMin < 0) goto escape; + if (y0 + psf->yMax >= source->psfImage->numRows) goto escape; + + double sum = 0.0; + for (int j = psf->yMin; j <= psf->yMax; j++) { + for (int i = psf->xMin; i <= psf->xMax; i++) { + double value = source->psfImage->data.F32[y0 + j][x0 + i]; + psf->kernel[j][i] = value; + sum += value; + } + } + assert (sum > 0.0); + + // psf must be normalized (integral = 1.0) + for (int i = 0; i < psf->image->numRows; i++) { + for (int j = 0; j < psf->image->numCols; j++) { + psf->image->data.F32[i][j] /= sum; + } + } + + return psf; + +escape: + psFree (psf); + return NULL; +} + +pmPCMdata *pmPCMinit(pmSource *source, pmSourceFitOptions *fitOptions, pmModel *model, psImageMaskType maskVal, float psfSize) { + + // make sure we save a cached copy of the psf flux + pmSourceCachePSF (source, maskVal); + + // convert the cached cached psf model for this source to a psKernel + psKernel *psf = pmPCMkernelFromPSF (source, psfSize); + if (!psf) { + // NOTE: this only happens if the source is too close to an edge + model->flags |= PM_MODEL_STATUS_BADARGS; + return NULL; + } + +# if (USE_DELTA_PSF) + psImageInit (psf->image, 0.0); + psf->image->data.F32[(int)(0.5*psf->image->numRows)][(int)(0.5*psf->image->numCols)] = 1.0; +# endif + + // count the number of unmasked pixels: + int nPix = 0; + for (psS32 i = 0; i < source->pixels->numRows; i++) { + for (psS32 j = 0; j < source->pixels->numCols; j++) { + // XXX are we doing the right thing with the mask? + // skip masked points + if (source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[i][j]) { + continue; + } + // skip zero-variance points + if (source->variance->data.F32[i][j] == 0) { + continue; + } + // skip nan value points + if (!isfinite(source->pixels->data.F32[i][j])) { + continue; + } + nPix ++; + } + } + + psVector *params = model->params; + + // create the minimization constraints + psMinConstraint *constraint = psMinConstraintAlloc(); + constraint->paramMask = psVectorAlloc (params->n, PS_TYPE_VECTOR_MASK); + constraint->checkLimits = model->modelLimits; + + // set parameter mask based on fitting mode + int nParams = 0; + switch (fitOptions->mode) { + case PM_SOURCE_FIT_NORM: + // NORM-only model fits only source normalization (Io) + nParams = 1; + psVectorInit (constraint->paramMask, 1); + constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_I0] = 0; + break; + case PM_SOURCE_FIT_PSF: + // PSF model only fits x,y,Io + nParams = 3; + psVectorInit (constraint->paramMask, 1); + constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_I0] = 0; + constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_XPOS] = 0; + constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_YPOS] = 0; + break; + case PM_SOURCE_FIT_EXT: + // EXT model fits all params (except sky) + nParams = params->n - 1; + psVectorInit (constraint->paramMask, 0); + constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_SKY] = 1; + break; + case PM_SOURCE_FIT_INDEX: + // PSF model only fits Io, index (PAR7) -- only Io for models with < 8 params + psVectorInit (constraint->paramMask, 1); + constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_I0] = 0; + if (params->n == 7) { + nParams = 1; + } else { + nParams = 2; + constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_7] = 0; + } + break; + case PM_SOURCE_FIT_NO_INDEX: + // PSF model only fits Io, index (PAR7) -- only Io for models with < 8 params + psVectorInit (constraint->paramMask, 0); + constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_SKY] = 1; + if (params->n == 7) { + nParams = params->n - 1; + } else { + nParams = params->n - 2; + constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_7] = 1; + } + break; + default: + psAbort("invalid fitting mode"); + } + + if (nPix < nParams + 1) { + psTrace ("psModules.objects", 4, "insufficient valid pixels\n"); + psFree (psf); + psFree (constraint); + model->flags |= PM_MODEL_STATUS_BADARGS; + return NULL; + } + + // generate PCM data storage structure + pmPCMdata *pcm = pmPCMdataAlloc (params, constraint->paramMask, source); + + pcm->psf = psf; + pcm->modelConv = psMemIncrRefCounter(model); + pcm->constraint = constraint; + + pcm->nPix = nPix; + pcm->nDOF = nPix - nParams - 1; + + return pcm; +} + +// has the set of fitted terms changed? has the fitting radius changed? +bool pmPCMupdate(pmPCMdata *pcm, pmSource *source, pmSourceFitOptions *fitOptions, pmModel *model) { + + bool newWindow = (source->pixels->numRows != pcm->modelFlux->numRows) || (source->pixels->numCols != pcm->modelFlux->numCols); + + // re-count the number of unmasked pixels: + if (newWindow) { + for (psS32 i = 0; i < source->pixels->numRows; i++) { + for (psS32 j = 0; j < source->pixels->numCols; j++) { + // XXX are we doing the right thing with the mask? + // skip masked points + if (source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[i][j]) { + continue; + } + // skip zero-variance points + if (source->variance->data.F32[i][j] == 0) { + continue; + } + // skip nan value points + if (!isfinite(source->pixels->data.F32[i][j])) { + continue; + } + pcm->nPix ++; + } + } + } + + // if we changed the fit mode, we need to update nDOF + int nParams = 0; + // set parameter mask based on fitting mode + switch (fitOptions->mode) { + case PM_SOURCE_FIT_NORM: + // NORM-only model fits only source normalization (Io) + nParams = 1; + psVectorInit (pcm->constraint->paramMask, 1); + pcm->constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_I0] = 0; + break; + case PM_SOURCE_FIT_PSF: + // PSF model only fits x,y,Io + nParams = 3; + psVectorInit (pcm->constraint->paramMask, 1); + pcm->constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_I0] = 0; + pcm->constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_XPOS] = 0; + pcm->constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_YPOS] = 0; + break; + case PM_SOURCE_FIT_EXT: + // EXT model fits all params (except sky) + nParams = model->params->n - 1; + psVectorInit (pcm->constraint->paramMask, 0); + pcm->constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_SKY] = 1; + break; + case PM_SOURCE_FIT_INDEX: + // PSF model only fits Io, index (PAR7) -- only Io for models with < 8 params + psVectorInit (pcm->constraint->paramMask, 1); + pcm->constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_I0] = 0; + if (model->params->n == 7) { + nParams = 1; + } else { + nParams = 2; + pcm->constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_7] = 0; + } + break; + case PM_SOURCE_FIT_NO_INDEX: + // PSF model only fits Io, index (PAR7) -- only Io for models with < 8 params + psVectorInit (pcm->constraint->paramMask, 0); + pcm->constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_SKY] = 1; + if (model->params->n == 7) { + nParams = model->params->n - 1; + } else { + nParams = model->params->n - 2; + pcm->constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_7] = 1; + } + break; + default: + psAbort("invalid fitting mode"); + } + + if (pcm->nPix < nParams + 1) { + psTrace ("psModules.objects", 4, "insufficient valid pixels\n"); + model->flags |= PM_MODEL_STATUS_BADARGS; + return false; + } + pcm->nDOF = pcm->nPix - nParams - 1; + + // has the source pixel window changed? + if (newWindow) { + + // adjust all supporting images: + pcm->modelFlux = psImageCopy (pcm->modelFlux, source->pixels, PS_TYPE_F32); + for (psS32 n = 0; n < pcm->dmodelsFlux->n; n++) { + if ((pcm->constraint->paramMask != NULL) && (pcm->constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[n])) { continue; } + pcm->dmodelsFlux->data[n] = psImageCopy (pcm->dmodelsFlux->data[n], source->pixels, PS_TYPE_F32); + } + + // adjust images for convolved model and derivative images + pcm->modelConvFlux = psImageCopy (pcm->modelConvFlux, source->pixels, PS_TYPE_F32); + for (psS32 n = 0; n < pcm->dmodelsConvFlux->n; n++) { + if ((pcm->constraint->paramMask != NULL) && (pcm->constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[n])) { continue; } + pcm->dmodelsConvFlux->data[n] = psImageCopy (pcm->dmodelsConvFlux->data[n], source->pixels, PS_TYPE_F32); + } + } + + return true; +} Index: /trunk/psModules/src/objects/pmPCMdata.h =================================================================== --- /trunk/psModules/src/objects/pmPCMdata.h (revision 29004) +++ /trunk/psModules/src/objects/pmPCMdata.h (revision 29004) @@ -0,0 +1,91 @@ +/* @file pmPCMdata.h + * structures and functions to support PSF-convolved model fitting + * + * @author EAM, IfA + * + * @version $Revision: 1.29 $ + * @date $Date: 2009-02-16 22:30:50 $ + * Copyright 2010 Institute for Astronomy, University of Hawaii + */ + +# ifndef PM_PCM_DATA_H +# define PM_PCM_DATA_H + +/// @addtogroup Objects Object Detection / Analysis Functions +/// @{ + +/** pmPCMdata : PSF Convolved Model data storage structure + * + * Structure to carry the data needed to generate a PSF-convolve model fit + * + */ +// +typedef struct { + psImage *modelFlux; + psArray *dmodelsFlux; + psImage *modelConvFlux; + psArray *dmodelsConvFlux; + + pmModel *modelConv; + psKernel *psf; + psKernelFFT *psfFFT; + + psMinConstraint *constraint; + int nPix; + int nDOF; +} pmPCMdata; + +// structures & functions to support psf-convolved model fitting + +// psf-convolved model fitting +bool psphotModelWithPSF_LMM ( + psMinimization *min, + psImage *covar, + psVector *params, + psMinConstraint *constraint, + pmSource *source, + const psKernel *psf, + psMinimizeLMChi2Func func); + +psF32 psphotModelWithPSF_SetABX( + psImage *alpha, + psVector *beta, + const psVector *params, + const psVector *paramMask, + pmPCMdata *pcm, + const pmSource *source, + const psKernel *psf, + psMinimizeLMChi2Func func); + +pmPCMdata *pmPCMdataAlloc ( + const psVector *params, + const psVector *paramMask, + pmSource *source); + +pmPCMdata *pmPCMinit(pmSource *source, pmSourceFitOptions *fitOptions, pmModel *model, psImageMaskType maskVal, float psfSize); +bool pmPCMupdate(pmPCMdata *pcm, pmSource *source, pmSourceFitOptions *fitOptions, pmModel *model); + +psImage *pmPCMdataSaveImage (pmPCMdata *pcm); + +psF32 pmPCM_SetABX( + psImage *alpha, + psVector *beta, + const psVector *params, + const psVector *paramMask, + pmPCMdata *pcm, + const pmSource *source); + +bool pmPCM_MinimizeChisq ( + psMinimization *min, + psImage *covar, + psVector *params, + pmSource *source, + pmPCMdata *pcm); + +bool pmSourceModelGuessPCM (pmPCMdata *pcm, pmSource *source, psImageMaskType maskVal, psImageMaskType markVal); + +bool pmSourceFitPCM (pmPCMdata *pcm, pmSource *source, pmSourceFitOptions *fitOptions, psImageMaskType maskVal, psImageMaskType markVal, int psfSize); + + +/// @} +# endif /* PM_PCM_DATA_H */ Index: /trunk/psModules/src/objects/pmPSF.c =================================================================== --- /trunk/psModules/src/objects/pmPSF.c (revision 29003) +++ /trunk/psModules/src/objects/pmPSF.c (revision 29004) @@ -25,19 +25,28 @@ #include "pmHDU.h" #include "pmFPA.h" +#include "pmFPAMaskWeight.h" +#include "psVectorBracket.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmResiduals.h" -#include "pmGrowthCurve.h" -#include "pmTrend2D.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" #include "pmPSF.h" -#include "pmModel.h" -#include "pmSource.h" -#include "pmModelClass.h" -#include "pmModelUtils.h" -#include "pmSourcePhotometry.h" -#include "pmFPAMaskWeight.h" -#include "psVectorBracket.h" +#include "pmPSFtry.h" +#include "pmDetections.h" + #include "pmErrorCodes.h" @@ -54,4 +63,5 @@ psFree (options->stats); + psFree (options->fitOptions); return; } @@ -65,4 +75,5 @@ options->stats = NULL; + options->fitOptions = NULL; // XXX this has to be set before calling pmPSF fit functions options->psfTrendMode = PM_TREND_NONE; Index: /trunk/psModules/src/objects/pmPSF.h =================================================================== --- /trunk/psModules/src/objects/pmPSF.h (revision 29003) +++ /trunk/psModules/src/objects/pmPSF.h (revision 29004) @@ -14,15 +14,6 @@ # define PM_PSF_H -#include -#include "pmTrend2D.h" -#include "pmGrowthCurve.h" -#include "pmResiduals.h" -#include "pmFPA.h" - /// @addtogroup Objects Object Detection / Analysis Functions /// @{ - -// type of model carried by the pmModel structure -typedef int pmModelType; /** pmPSF data structure @@ -38,5 +29,5 @@ * */ -typedef struct { +struct pmPSF { pmModelType type; ///< PSF Model in use psArray *params; ///< Model parameters (psPolynomial2D) @@ -64,5 +55,5 @@ pmGrowthCurve *growth; ///< apMag vs Radius pmResiduals *residuals; ///< normalized residual image (no spatial variation) -} pmPSF; +}; typedef struct { @@ -82,4 +73,5 @@ float apRadius; bool chiFluxTrend; // Fit a trend in Chi2 as a function of flux? + pmSourceFitOptions *fitOptions; } pmPSFOptions; Index: /trunk/psModules/src/objects/pmPSF_IO.c =================================================================== --- /trunk/psModules/src/objects/pmPSF_IO.c (revision 29003) +++ /trunk/psModules/src/objects/pmPSF_IO.c (revision 29004) @@ -38,17 +38,26 @@ #include "pmFPAfileFitsIO.h" +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmGrowthCurve.h" -#include "pmResiduals.h" -#include "pmTrend2D.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" #include "pmPSF.h" -#include "pmModel.h" +#include "pmPSFtry.h" +#include "pmDetections.h" + #include "pmPSF_IO.h" -#include "pmSource.h" -#include "pmModelClass.h" -#include "pmModelUtils.h" #include "pmSourceIO.h" Index: /trunk/psModules/src/objects/pmPSFtry.c =================================================================== --- /trunk/psModules/src/objects/pmPSFtry.c (revision 29003) +++ /trunk/psModules/src/objects/pmPSFtry.c (revision 29004) @@ -19,19 +19,26 @@ #include "pmFPA.h" #include "pmFPAMaskWeight.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmResiduals.h" -#include "pmGrowthCurve.h" -#include "pmTrend2D.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" #include "pmPSF.h" -#include "pmModel.h" -#include "pmSource.h" -#include "pmSourceUtils.h" #include "pmPSFtry.h" -#include "pmModelClass.h" -#include "pmModelUtils.h" -#include "pmSourceFitModel.h" +#include "pmDetections.h" + #include "pmSourcePhotometry.h" #include "pmSourceVisual.h" Index: /trunk/psModules/src/objects/pmPSFtryFitEXT.c =================================================================== --- /trunk/psModules/src/objects/pmPSFtryFitEXT.c (revision 29003) +++ /trunk/psModules/src/objects/pmPSFtryFitEXT.c (revision 29004) @@ -19,19 +19,27 @@ #include "pmFPA.h" #include "pmFPAMaskWeight.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmResiduals.h" -#include "pmGrowthCurve.h" -#include "pmTrend2D.h" -#include "pmPSF.h" +#include "pmModelFuncs.h" #include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" #include "pmSource.h" #include "pmSourceUtils.h" +#include "pmSourceFitModel.h" +#include "pmPSF.h" #include "pmPSFtry.h" -#include "pmModelClass.h" -#include "pmModelUtils.h" -#include "pmSourceFitModel.h" +#include "pmDetections.h" + #include "pmSourcePhotometry.h" #include "pmSourceVisual.h" @@ -44,4 +52,7 @@ psTimerStart ("psf.fit"); + + // in this segment, we are fitting the full PSF model class (shape unconstrained) + options->fitOptions->mode = PM_SOURCE_FIT_EXT; // maskVal is used to test for rejected pixels, and must include markVal @@ -73,5 +84,5 @@ // fit model as EXT, not PSF - status = pmSourceFitModel (source, source->modelEXT, PM_SOURCE_FIT_EXT, maskVal); + status = pmSourceFitModel (source, source->modelEXT, options->fitOptions, maskVal); // clear object mask to define valid pixels Index: /trunk/psModules/src/objects/pmPSFtryFitPSF.c =================================================================== --- /trunk/psModules/src/objects/pmPSFtryFitPSF.c (revision 29003) +++ /trunk/psModules/src/objects/pmPSFtryFitPSF.c (revision 29004) @@ -17,19 +17,26 @@ #include "pmFPA.h" #include "pmFPAMaskWeight.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmResiduals.h" -#include "pmGrowthCurve.h" -#include "pmTrend2D.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" #include "pmPSF.h" -#include "pmModel.h" -#include "pmSource.h" -#include "pmSourceUtils.h" #include "pmPSFtry.h" -#include "pmModelClass.h" -#include "pmModelUtils.h" -#include "pmSourceFitModel.h" +#include "pmDetections.h" + #include "pmSourcePhotometry.h" #include "pmSourceVisual.h" @@ -42,4 +49,7 @@ psTimerStart ("psf.fit"); + + // in this segment, we are fitting the fitted PSF model class (shape constrained) + options->fitOptions->mode = PM_SOURCE_FIT_PSF; // maskVal is used to test for rejected pixels, and must include markVal @@ -81,5 +91,5 @@ // fit the PSF model to the source - status = pmSourceFitModel (source, source->modelPSF, PM_SOURCE_FIT_NORM, maskVal); + status = pmSourceFitModel (source, source->modelPSF, options->fitOptions, maskVal); // skip poor fits @@ -98,5 +108,5 @@ // This function calculates the psf and aperture magnitudes - status = pmSourceMagnitudes (source, psfTry->psf, PM_SOURCE_PHOT_INTERP, maskVal); // raw PSF mag, AP mag + status = pmSourceMagnitudes (source, psfTry->psf, PM_SOURCE_PHOT_INTERP, maskVal, markVal); // raw PSF mag, AP mag if (!status || isnan(source->apMag)) { psImageMaskPixels (source->maskObj, "AND", PS_NOT_IMAGE_MASK(markVal)); // clear the circular mask Index: /trunk/psModules/src/objects/pmPSFtryMakePSF.c =================================================================== --- /trunk/psModules/src/objects/pmPSFtryMakePSF.c (revision 29003) +++ /trunk/psModules/src/objects/pmPSFtryMakePSF.c (revision 29004) @@ -18,19 +18,26 @@ #include "pmFPA.h" #include "pmFPAMaskWeight.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmResiduals.h" -#include "pmGrowthCurve.h" -#include "pmTrend2D.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" #include "pmPSF.h" -#include "pmModel.h" -#include "pmSource.h" -#include "pmSourceUtils.h" #include "pmPSFtry.h" -#include "pmModelClass.h" -#include "pmModelUtils.h" -#include "pmSourceFitModel.h" +#include "pmDetections.h" + #include "pmSourcePhotometry.h" #include "pmSourceVisual.h" Index: /trunk/psModules/src/objects/pmPSFtryMetric.c =================================================================== --- /trunk/psModules/src/objects/pmPSFtryMetric.c (revision 29003) +++ /trunk/psModules/src/objects/pmPSFtryMetric.c (revision 29004) @@ -18,19 +18,26 @@ #include "pmFPA.h" #include "pmFPAMaskWeight.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmResiduals.h" -#include "pmGrowthCurve.h" -#include "pmTrend2D.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" #include "pmPSF.h" -#include "pmModel.h" -#include "pmSource.h" -#include "pmSourceUtils.h" #include "pmPSFtry.h" -#include "pmModelClass.h" -#include "pmModelUtils.h" -#include "pmSourceFitModel.h" +#include "pmDetections.h" + #include "pmSourcePhotometry.h" #include "pmSourceVisual.h" Index: /trunk/psModules/src/objects/pmPSFtryModel.c =================================================================== --- /trunk/psModules/src/objects/pmPSFtryModel.c (revision 29003) +++ /trunk/psModules/src/objects/pmPSFtryModel.c (revision 29004) @@ -19,20 +19,26 @@ #include "pmFPA.h" #include "pmFPAMaskWeight.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmResiduals.h" -#include "pmGrowthCurve.h" -#include "pmTrend2D.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" #include "pmPSF.h" -#include "pmModel.h" -#include "pmSource.h" -#include "pmSourceUtils.h" #include "pmPSFtry.h" -#include "pmModelClass.h" -#include "pmModelUtils.h" -#include "pmSourceFitModel.h" -#include "pmSourcePhotometry.h" +#include "pmDetections.h" + #include "pmSourceVisual.h" @@ -49,4 +55,6 @@ pmPSFtry *pmPSFtryModel (const psArray *sources, const char *modelName, pmPSFOptions *options, psImageMaskType maskVal, psImageMaskType markVal) { + assert (options->fitOptions); + // validate the requested model name options->type = pmModelClassGetType (modelName); Index: /trunk/psModules/src/objects/pmPeaks.c =================================================================== --- /trunk/psModules/src/objects/pmPeaks.c (revision 29003) +++ /trunk/psModules/src/objects/pmPeaks.c (revision 29004) @@ -22,4 +22,5 @@ #include #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" Index: /trunk/psModules/src/objects/pmPeaks.h =================================================================== --- /trunk/psModules/src/objects/pmPeaks.h (revision 29003) +++ /trunk/psModules/src/objects/pmPeaks.h (revision 29004) @@ -17,7 +17,4 @@ # ifndef PM_PEAKS_H # define PM_PEAKS_H - -#include -#include "pmFootprint.h" /// @addtogroup Objects Object Detection / Analysis Functions Index: /trunk/psModules/src/objects/pmPhotObj.c =================================================================== --- /trunk/psModules/src/objects/pmPhotObj.c (revision 29003) +++ /trunk/psModules/src/objects/pmPhotObj.c (revision 29004) @@ -16,6 +16,27 @@ #include #include + +#include "pmHDU.h" +#include "pmFPA.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" +#include "pmSpan.h" +#include "pmFootprintSpans.h" +#include "pmFootprint.h" +#include "pmPeaks.h" +#include "pmMoments.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" + #include "pmPhotObj.h" -#include "pmSource.h" + static void pmPhotObjFree (pmPhotObj *tmp) @@ -82,2 +103,17 @@ return (0); } + +// sort by X (ascending) +int pmPhotObjSortByX (const void **a, const void **b) +{ + pmPhotObj *objA = *(pmPhotObj **)a; + pmPhotObj *objB = *(pmPhotObj **)b; + + psF32 fA = objA->x; + psF32 fB = objB->x; + + psF32 diff = fA - fB; + if (diff > FLT_EPSILON) return (+1); + if (diff < FLT_EPSILON) return (-1); + return (0); +} Index: /trunk/psModules/src/objects/pmPhotObj.h =================================================================== --- /trunk/psModules/src/objects/pmPhotObj.h (revision 29003) +++ /trunk/psModules/src/objects/pmPhotObj.h (revision 29004) @@ -10,9 +10,4 @@ # ifndef PM_PHOT_OBJ_H # define PM_PHOT_OBJ_H - -#include -#include "pmPeaks.h" -#include "pmModel.h" -#include "pmMoments.h" /// @addtogroup Objects Object Detection / Analysis Functions @@ -47,4 +42,5 @@ int pmPhotObjSortBySN (const void **a, const void **b); +int pmPhotObjSortByX (const void **a, const void **b); /// @} Index: /trunk/psModules/src/objects/pmSource.c =================================================================== --- /trunk/psModules/src/objects/pmSource.c (revision 29003) +++ /trunk/psModules/src/objects/pmSource.c (revision 29004) @@ -23,13 +23,20 @@ #include "pmFPA.h" #include "pmFPAMaskWeight.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmResiduals.h" -#include "pmGrowthCurve.h" -#include "pmTrend2D.h" -#include "pmPSF.h" +#include "pmModelFuncs.h" #include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" #include "pmSource.h" @@ -98,5 +105,6 @@ static int id = 1; pmSource *source = (pmSource *) psAlloc(sizeof(pmSource)); - *(int *)&source->id = id++; + P_PM_SOURCE_SET_ID(source, id++); + source->seq = -1; source->peak = NULL; @@ -114,4 +122,5 @@ source->type = PM_SOURCE_TYPE_UNKNOWN; source->mode = PM_SOURCE_MODE_DEFAULT; + source->mode2 = PM_SOURCE_MODE_DEFAULT; source->tmpFlags = 0; source->extpars = NULL; @@ -131,5 +140,6 @@ source->sky = NAN; source->skyErr = NAN; - source->pixWeight = NAN; + source->pixWeightNotBad = NAN; + source->pixWeightNotPoor = NAN; source->psfChisq = NAN; @@ -142,8 +152,56 @@ /****************************************************************************** -pmSourceCopy(): copy the pmSource structure and contents -XXX : are we OK with incrementing the ID? +pmSourceCopy(): copy the pmSource, yielding a copy of the source that can be used without +affecting the original. This Copy can be used to allow multiple fit attempts on the same +object. The pixels, variance, and mask arrays all point to the same original subarrays. The +peak and moments point at the original values. *****************************************************************************/ pmSource *pmSourceCopy(pmSource *in) +{ + if (in == NULL) { + return(NULL); + } + pmSource *source = pmSourceAlloc (); + + // keep the original ID so we can find map back to the original + P_PM_SOURCE_SET_ID(source, in->id); + + // peak has the same values as the original + if (in->peak != NULL) { + source->peak = pmPeakAlloc (in->peak->x, in->peak->y, in->peak->value, in->peak->type); + source->peak->xf = in->peak->xf; + source->peak->yf = in->peak->yf; + source->peak->flux = in->peak->flux; + source->peak->SN = in->peak->SN; + } + + // copy the values in the moments structure + if (in->moments != NULL) { + source->moments = pmMomentsAlloc(); + *source->moments = *in->moments; + } + + // These images are all views to the parent. We want a new view, but pointing at the same + // pixels. Modifying these pixels (ie, subtracting the model) will affect the pixels seen + // by all copies. + source->pixels = psImageCopyView(NULL, in->pixels); + source->variance = psImageCopyView(NULL, in->variance); + source->maskView = in->maskView ? psImageCopyView(NULL, in->maskView) : NULL; + + // the maskObj is a unique mask array; create a new mask image + source->maskObj = in->maskObj ? psImageCopy (NULL, in->maskObj, PS_TYPE_IMAGE_MASK) : NULL; + + source->type = in->type; + source->mode = in->mode; + source->imageID = in->imageID; + + return(source); +} + +/****************************************************************************** +pmSourceCopyData(): this creates a new, duplicate source with the same parameters as the +original (but is actually a new source at the same location) +*****************************************************************************/ +pmSource *pmSourceCopyData(pmSource *in) { if (in == NULL) { @@ -482,5 +540,5 @@ } psfClump.X = stats->clippedMean; - psfClump.dX = stats->clippedStdev; + psfClump.dX = hypot(stats->clippedStdev, PSF_CLUMP_GRID_SCALE); if (!psVectorStats (stats, tmpSy, NULL, NULL, 0)) { @@ -489,5 +547,5 @@ } psfClump.Y = stats->clippedMean; - psfClump.dY = stats->clippedStdev; + psfClump.dY = hypot(stats->clippedStdev, PSF_CLUMP_GRID_SCALE); psTrace ("psModules.objects", 2, "clump X, Y: %f, %f\n", psfClump.X, psfClump.Y); @@ -910,5 +968,6 @@ bool addNoise = mode & PM_MODEL_OP_NOISE; - if (source->modelFlux) { + // require the use of pmModelAddWithOffset if we are adding noise (because the model size and norm are rescaled) + if (!addNoise && source->modelFlux) { // add in the pixels from the modelFlux image int dX = source->modelFlux->col0 - source->pixels->col0; @@ -931,8 +990,4 @@ psF32 **target = source->pixels->data.F32; - if (addNoise) { - // when adding noise, we assume the shape and Io have been modified - target = source->variance->data.F32; - } for (int iy = 0; iy < source->modelFlux->numRows; iy++) { @@ -949,10 +1004,8 @@ } } - if (!addNoise) { - if (add) { - source->tmpFlags &= ~PM_SOURCE_TMPF_SUBTRACTED; - } else { - source->tmpFlags |= PM_SOURCE_TMPF_SUBTRACTED; - } + if (add) { + source->tmpFlags &= ~PM_SOURCE_TMPF_SUBTRACTED; + } else { + source->tmpFlags |= PM_SOURCE_TMPF_SUBTRACTED; } return true; @@ -973,4 +1026,78 @@ } } + + return true; +} + +// should we call pmSourceCacheModel if it does not exist? +bool pmSourceNoiseOp (pmSource *source, pmModelOpMode mode, float FACTOR, float SIZE, bool add, psImageMaskType maskVal, int dx, int dy) +{ + assert (mode & PM_MODEL_OP_NOISE); + PS_ASSERT_PTR_NON_NULL(source, false); + PS_ASSERT_PTR_NON_NULL(source->peak, false); + + if (add) { + psTrace ("psphot", 3, "adding noise to object at %f,%f\n", source->peak->xf, source->peak->yf); + } else { + psTrace ("psphot", 3, "removing noise from object at %f,%f\n", source->peak->xf, source->peak->yf); + } + + pmSourceNoiseOpModel (source->modelPSF, source, mode, FACTOR, SIZE, add, maskVal, dx, dy); + + if (source->modelEXT) { + pmSourceNoiseOpModel (source->modelEXT, source, mode, FACTOR, SIZE, add, maskVal, dx, dy); + } + + return true; +} + +bool pmSourceNoiseOpModel (pmModel *model, pmSource *source, pmModelOpMode mode, float FACTOR, float SIZE, bool add, psImageMaskType maskVal, int dx, int dy) +{ + bool status; + psEllipseShape oldshape; + psEllipseShape newshape; + psEllipseAxes axes; + + if (add) { + psTrace ("psphot", 4, "adding noise for object at %f,%f\n", model->params->data.F32[PM_PAR_XPOS], model->params->data.F32[PM_PAR_YPOS]); + } else { + psTrace ("psphot", 4, "remove noise for object at %f,%f\n", model->params->data.F32[PM_PAR_XPOS], model->params->data.F32[PM_PAR_YPOS]); + } + + psF32 *PAR = model->params->data.F32; + + // save original values + float oldI0 = PAR[PM_PAR_I0]; + oldshape.sx = PAR[PM_PAR_SXX]; + oldshape.sy = PAR[PM_PAR_SYY]; + oldshape.sxy = PAR[PM_PAR_SXY]; + + // XXX can this be done more intelligently? + if (oldI0 == 0.0) return false; + if (!isfinite(oldI0)) return false; + + // increase size and height of source + axes = psEllipseShapeToAxes (oldshape, 20.0); + axes.major *= SIZE; + axes.minor *= SIZE; + newshape = psEllipseAxesToShape (axes); + PAR[PM_PAR_I0] = FACTOR*oldI0; + PAR[PM_PAR_SXX] = newshape.sx; + PAR[PM_PAR_SYY] = newshape.sy; + PAR[PM_PAR_SXY] = newshape.sxy; + + psImage *target = source->variance; + + if (add) { + status = pmModelAddWithOffset (target, source->maskObj, model, mode, maskVal, dx, dy); + } else { + status = pmModelSubWithOffset (target, source->maskObj, model, mode, maskVal, dx, dy); + } + + // restore original values + PAR[PM_PAR_I0] = oldI0; + PAR[PM_PAR_SXX] = oldshape.sx; + PAR[PM_PAR_SYY] = oldshape.sy; + PAR[PM_PAR_SXY] = oldshape.sxy; return true; Index: /trunk/psModules/src/objects/pmSource.h =================================================================== --- /trunk/psModules/src/objects/pmSource.h (revision 29003) +++ /trunk/psModules/src/objects/pmSource.h (revision 29004) @@ -11,15 +11,6 @@ # define PM_SOURCE_H -#include -#include "pmPeaks.h" -#include "pmModel.h" -#include "pmMoments.h" -#include "pmSourceExtendedPars.h" -#include "pmSourceDiffStats.h" - /// @addtogroup Objects Object Detection / Analysis Functions /// @{ - -#include /** pmSourceType enumeration @@ -74,4 +65,5 @@ pmSourceType type; ///< Best identification of object. pmSourceMode mode; ///< analysis flags set for object. + pmSourceMode2 mode2; ///< analysis flags set for object. pmSourceTmpF tmpFlags; ///< internal-only flags psArray *blends; ///< collection of sources thought to be confused with object @@ -82,10 +74,14 @@ float errMag; ///< error in psfMag OR extMag (depending on type) float apMag; ///< apMag corresponding to psfMag or extMag (depending on type) - float pixWeight; ///< model-weighted coverage of valid pixels + float apMagRaw; ///< raw mag in given aperture + float apRadius; ///< radius for aperture magnitude + + float pixWeightNotBad; ///< PSF-weighted coverage of unmasked (not BAD) pixels + float pixWeightNotPoor; ///< PSF-weighted coverage of unmasked (not POOR) pixels + float psfChisq; ///< probability of PSF float crNsigma; ///< Nsigma deviation from PSF to CR float extNsigma; ///< Nsigma deviation from PSF to EXT float sky, skyErr; ///< The sky and its error at the center of the object - float apRadius; psRegion region; ///< area on image covered by selected pixels pmSourceExtendedPars *extpars; ///< extended source parameters @@ -113,4 +109,6 @@ pmPSFClump; +// private macro to set the source ID (a const) +#define P_PM_SOURCE_SET_ID(S,V) { *(int *)&(S)->id = (V); } /** pmSourceAlloc() @@ -126,4 +124,5 @@ pmSource *pmSourceCopy(pmSource *source); +pmSource *pmSourceCopyData(pmSource *in); // free just the pixels for a source, keeping derived data @@ -242,4 +241,7 @@ bool pmSourceSubWithOffset (pmSource *source, pmModelOpMode mode, psImageMaskType maskVal, int dx, int dy); +bool pmSourceNoiseOpModel (pmModel *model, pmSource *source, pmModelOpMode mode, float FACTOR, float SIZE, bool add, psImageMaskType maskVal, int dx, int dy); +bool pmSourceNoiseOp (pmSource *source, pmModelOpMode mode, float FACTOR, float SIZE, bool add, psImageMaskType maskVal, int dx, int dy); + bool pmSourceOp (pmSource *source, pmModelOpMode mode, bool add, psImageMaskType maskVal, int dx, int dy); bool pmSourceCacheModel (pmSource *source, psImageMaskType maskVal); Index: /trunk/psModules/src/objects/pmSourceContour.c =================================================================== --- /trunk/psModules/src/objects/pmSourceContour.c (revision 29003) +++ /trunk/psModules/src/objects/pmSourceContour.c (revision 29004) @@ -23,14 +23,22 @@ #include "pmHDU.h" #include "pmFPA.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmResiduals.h" -#include "pmGrowthCurve.h" -#include "pmTrend2D.h" -#include "pmPSF.h" +#include "pmModelFuncs.h" #include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" #include "pmSource.h" + #include "pmSourceContour.h" Index: /trunk/psModules/src/objects/pmSourceDiffStats.c =================================================================== --- /trunk/psModules/src/objects/pmSourceDiffStats.c (revision 29003) +++ /trunk/psModules/src/objects/pmSourceDiffStats.c (revision 29004) @@ -29,4 +29,9 @@ diffStats->nRatioAll = NAN; diffStats->nGood = 0; + + diffStats->SNp = NAN; + diffStats->SNm = NAN; + diffStats->Rp = NAN; + diffStats->Rm = NAN; } Index: /trunk/psModules/src/objects/pmSourceDiffStats.h =================================================================== --- /trunk/psModules/src/objects/pmSourceDiffStats.h (revision 29003) +++ /trunk/psModules/src/objects/pmSourceDiffStats.h (revision 29004) @@ -29,4 +29,8 @@ float nRatioAll; // = nGood / (nGood + nMask + nBad) int nGood; // nGood as defined above + float SNp; // S/N of matched source in positive image + float SNm; // S/N of matched source in negative image + float Rp; // radius of matched source in positive image + float Rm; // radius of matched source in negative image } pmSourceDiffStats; Index: /trunk/psModules/src/objects/pmSourceFitModel.c =================================================================== --- /trunk/psModules/src/objects/pmSourceFitModel.c (revision 29003) +++ /trunk/psModules/src/objects/pmSourceFitModel.c (revision 29004) @@ -23,37 +23,47 @@ #include "pmHDU.h" #include "pmFPA.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmGrowthCurve.h" -#include "pmResiduals.h" -#include "pmTrend2D.h" -#include "pmPSF.h" +#include "pmModelFuncs.h" #include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" #include "pmSource.h" -#include "pmModelClass.h" #include "pmSourceFitModel.h" -// save as static values so they may be set externally -static psF32 PM_SOURCE_FIT_MODEL_NUM_ITERATIONS = 15; -static psF32 PM_SOURCE_FIT_MODEL_TOLERANCE = 0.1; -static psF32 PM_SOURCE_FIT_MODEL_WEIGHT = 1.0; -static bool PM_SOURCE_FIT_MODEL_PIX_WEIGHTS = true; - -bool pmSourceFitModelInit (float nIter, float tol, float weight, bool poissonErrors) +void pmSourceFitOptionsFree(pmSourceFitOptions *opt) { - - PM_SOURCE_FIT_MODEL_NUM_ITERATIONS = nIter; - PM_SOURCE_FIT_MODEL_TOLERANCE = tol; - PM_SOURCE_FIT_MODEL_WEIGHT = weight; - PM_SOURCE_FIT_MODEL_PIX_WEIGHTS = poissonErrors; - - return true; + return; +} + +pmSourceFitOptions *pmSourceFitOptionsAlloc(void) { + + pmSourceFitOptions *opt = (pmSourceFitOptions *) psAlloc(sizeof(pmSourceFitOptions)); + psMemSetDeallocator(opt, (psFreeFunc) pmSourceFitOptionsFree); + + opt->mode = PM_SOURCE_FIT_PSF; + opt->nIter = 15; + opt->minTol = 0.01; + opt->maxTol = 1.00; + opt->weight = 1.00; + opt->maxChisqDOF = NAN; + opt->poissonErrors = true; + + return opt; } bool pmSourceFitModel (pmSource *source, pmModel *model, - pmSourceFitMode mode, + pmSourceFitOptions *options, psImageMaskType maskVal) { @@ -76,4 +86,9 @@ psVector *yErr = psVectorAllocEmpty(nPix, PS_TYPE_F32); + // XXX for a test, skip the central pixel in the sersic fit + bool skipCenter = false && (model->type == pmModelClassGetType("PS_MODEL_SERSIC")); + float Xo = model->params->data.F32[PM_PAR_XPOS]; + float Yo = model->params->data.F32[PM_PAR_YPOS]; + // fill in the coordinate and value entries nPix = 0; @@ -95,14 +110,24 @@ // skip nan values in image if (!isfinite(source->variance->data.F32[i][j])) { - fprintf (stderr, "impossible! %x vs %x\n", source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[i][j], maskVal); - continue; - } - - psVector *coord = psVectorAlloc(2, PS_TYPE_F32); + fprintf (stderr, "impossible! %x vs %x\n", source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[i][j], maskVal); + continue; + } // Convert i/j to image space: // 0.5 PIX: the coordinate values must be in pixel coords, not index - coord->data.F32[0] = (psF32) (j + 0.5 + source->pixels->col0); - coord->data.F32[1] = (psF32) (i + 0.5 + source->pixels->row0); + float Xv = (psF32) (j + 0.5 + source->pixels->col0); + float Yv = (psF32) (i + 0.5 + source->pixels->row0); + + // XXX possible skip of center pixel: + if (skipCenter) { + float r = hypot(Xv - Xo, Yv - Yo); + if (r < 0.75) { + continue; + } + } + + psVector *coord = psVectorAlloc(2, PS_TYPE_F32); + coord->data.F32[0] = Xv; + coord->data.F32[1] = Yv; x->data[nPix] = (psPtr *) coord; y->data.F32[nPix] = source->pixels->data.F32[i][j]; @@ -111,8 +136,8 @@ // as variance to avoid the bias from systematic errors here we would just use the // source sky variance - if (PM_SOURCE_FIT_MODEL_PIX_WEIGHTS) { + if (options->poissonErrors) { yErr->data.F32[nPix] = 1.0 / source->variance->data.F32[i][j]; } else { - yErr->data.F32[nPix] = 1.0 / PM_SOURCE_FIT_MODEL_WEIGHT; + yErr->data.F32[nPix] = 1.0 / options->weight; } nPix++; @@ -133,6 +158,6 @@ // set parameter mask based on fitting mode int nParams = 0; - switch (mode) { - case PM_SOURCE_FIT_NORM: + switch (options->mode) { + case PM_SOURCE_FIT_NORM: // NORM-only model fits only source normalization (Io) nParams = 1; @@ -140,5 +165,5 @@ constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_I0] = 0; break; - case PM_SOURCE_FIT_PSF: + case PM_SOURCE_FIT_PSF: // PSF model only fits x,y,Io nParams = 3; @@ -148,5 +173,5 @@ constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_YPOS] = 0; break; - case PM_SOURCE_FIT_EXT: + case PM_SOURCE_FIT_EXT: // EXT model fits all params (except sky) nParams = params->n - 1; @@ -154,11 +179,33 @@ constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_SKY] = 1; break; - default: - psAbort("invalid fitting mode"); + case PM_SOURCE_FIT_INDEX: + // PSF model only fits Io, index (PAR7) -- only Io for models with < 8 params + psVectorInit (constraint->paramMask, 1); + constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_I0] = 0; + if (params->n == 7) { + nParams = 1; + } else { + nParams = 2; + constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_7] = 0; + } + break; + case PM_SOURCE_FIT_NO_INDEX: + // PSF model only fits Io, index (PAR7) -- only Io for models with < 8 params + psVectorInit (constraint->paramMask, 0); + constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_SKY] = 1; + if (params->n == 7) { + nParams = params->n - 1; + } else { + nParams = params->n - 2; + constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[PM_PAR_7] = 1; + } + break; + default: + psAbort("invalid fitting mode"); } // force the floating parameters to fall within the contraint ranges for (int i = 0; i < params->n; i++) { - model->modelLimits (PS_MINIMIZE_PARAM_MIN, i, params->data.F32, NULL); - model->modelLimits (PS_MINIMIZE_PARAM_MAX, i, params->data.F32, NULL); + model->modelLimits (PS_MINIMIZE_PARAM_MIN, i, params->data.F32, NULL); + model->modelLimits (PS_MINIMIZE_PARAM_MAX, i, params->data.F32, NULL); } @@ -173,5 +220,5 @@ } - psMinimization *myMin = psMinimizationAlloc (PM_SOURCE_FIT_MODEL_NUM_ITERATIONS, PM_SOURCE_FIT_MODEL_TOLERANCE); + psMinimization *myMin = psMinimizationAlloc (options->nIter, options->minTol, options->maxTol); psImage *covar = psImageAlloc (params->n, params->n, PS_TYPE_F32); @@ -194,4 +241,5 @@ model->flags |= PM_MODEL_STATUS_FITTED; if (!fitStatus) model->flags |= PM_MODEL_STATUS_NONCONVERGE; + if (myMin->lastDelta > myMin->minTol) model->flags |= PM_MODEL_STATUS_WEAK_FIT; // get the Gauss-Newton distance for fixed model parameters Index: /trunk/psModules/src/objects/pmSourceFitModel.h =================================================================== --- /trunk/psModules/src/objects/pmSourceFitModel.h (revision 29003) +++ /trunk/psModules/src/objects/pmSourceFitModel.h (revision 29004) @@ -19,13 +19,29 @@ PM_SOURCE_FIT_EXT, PM_SOURCE_FIT_PSF_AND_SKY, - PM_SOURCE_FIT_EXT_AND_SKY + PM_SOURCE_FIT_EXT_AND_SKY, + PM_SOURCE_FIT_INDEX, + PM_SOURCE_FIT_NO_INDEX, } pmSourceFitMode; -bool pmSourceFitModelInit( - float nIter, ///< max number of allowed iterations - float tol, ///< convergence criterion - float weight, ///< use this weight for constant-weight fits - bool poissonErrors // use poisson errors for fits? -); +typedef struct { + pmSourceFitMode mode; ///< optionally fit all or a subset of parameters + float nIter; ///< max number of allowed iterations + float minTol; ///< convergence criterion + float maxTol; ///< convergence criterion + float maxChisqDOF; ///< convergence criterion + float weight; ///< use this weight for constant-weight fits + bool poissonErrors; ///< use poisson errors for fits? +} pmSourceFitOptions; + +// the pmSourceFitOptions structure is used to control details of the fitting process +pmSourceFitOptions *pmSourceFitOptionsAlloc(void); + +// bool pmSourceFitModelInit( +// pmSourceFitMode mode, ///< what parameter set should be fitted? +// float nIter, ///< max number of allowed iterations +// float tol, ///< convergence criterion +// float weight, ///< use this weight for constant-weight fits +// bool poissonErrors ///< use poisson errors for fits? +// ); /** pmSourceFitModel() @@ -38,40 +54,39 @@ */ bool pmSourceFitModel( - pmSource *source, ///< The input pmSource - pmModel *model, ///< model to be fitted - pmSourceFitMode mode, ///< define parameters to be fitted + pmSource *source, ///< The input pmSource + pmModel *model, ///< model to be fitted + pmSourceFitOptions *options, ///< define parameters to be fitted psImageMaskType maskVal ///< Value to mask ); - -// initialize data for a group of object models -bool pmSourceFitSetInit (pmModelType type); - -// clear data for a group of object models -void pmSourceFitSetClear (void); - -// function used to set limits for a group of models -bool pmSourceFitSet_CheckLimits (psMinConstraintMode mode, int nParam, float *params, float *betas); - -// function used to fit a group of object models -psF32 pmSourceFitSet_Function(psVector *deriv, - const psVector *params, - const psVector *x); - -/** pmSourceFitSet() - * - * Fit the requested model to the specified source. The starting guess for the model is given - * by the input source.model parameter values. The pixels of interest are specified by the - * source.pixels and source.mask entries. This function calls psMinimizeLMChi2() on the image - * data. The function returns TRUE on success or FALSE on failure. - * - */ -bool pmSourceFitSet( - pmSource *source, ///< The input pmSource - psArray *modelSet, ///< model to be fitted - pmSourceFitMode mode, ///< define parameters to be fitted - psImageMaskType maskVal ///< Vale to mask - -); +// // initialize data for a group of object models +// bool pmSourceFitSetInit (pmModelType type); +// +// // clear data for a group of object models +// void pmSourceFitSetClear (void); +// +// // function used to set limits for a group of models +// bool pmSourceFitSet_CheckLimits (psMinConstraintMode mode, int nParam, float *params, float *betas); +// +// // function used to fit a group of object models +// psF32 pmSourceFitSet_Function(psVector *deriv, +// const psVector *params, +// const psVector *x); +// +// /** pmSourceFitSet() +// * +// * Fit the requested model to the specified source. The starting guess for the model is given +// * by the input source.model parameter values. The pixels of interest are specified by the +// * source.pixels and source.mask entries. This function calls psMinimizeLMChi2() on the image +// * data. The function returns TRUE on success or FALSE on failure. +// * +// */ +// bool pmSourceFitSet( +// pmSource *source, ///< The input pmSource +// psArray *modelSet, ///< model to be fitted +// pmSourceFitMode mode, ///< define parameters to be fitted +// psImageMaskType maskVal ///< Vale to mask +// +// ); /// @} Index: /trunk/psModules/src/objects/pmSourceFitPCM.c =================================================================== --- /trunk/psModules/src/objects/pmSourceFitPCM.c (revision 29004) +++ /trunk/psModules/src/objects/pmSourceFitPCM.c (revision 29004) @@ -0,0 +1,160 @@ +/* @file pmSourceFitPCM.c + * structures and functions to support PSF-convolved model fitting + * + * @author EAM, IfA + * + * @version $Revision: 1.29 $ + * @date $Date: 2009-02-16 22:30:50 $ + * Copyright 2010 Institute for Astronomy, University of Hawaii + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include +#include +#include +#include +#include +#include "pmHDU.h" +#include "pmFPA.h" +#include "pmFPAMaskWeight.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" +#include "pmSpan.h" +#include "pmFootprintSpans.h" +#include "pmFootprint.h" +#include "pmPeaks.h" +#include "pmMoments.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" +#include "pmPCMdata.h" + +# define FACILITY "psModules.objects" + +// input source has both modelPSF and modelEXT. on successful exit, we set the +// modelConv to contain the fitted parameters, and the modelFlux to contain the +// convolved model image. + +bool pmSourceFitPCM (pmPCMdata *pcm, pmSource *source, pmSourceFitOptions *fitOptions, psImageMaskType maskVal, psImageMaskType markVal, int psfSize) { + + psVector *params = pcm->modelConv->params; + psVector *dparams = pcm->modelConv->dparams; + + // force the floating parameters to fall within the contraint ranges + for (int i = 0; i < params->n; i++) { + pcm->modelConv->modelLimits (PS_MINIMIZE_PARAM_MIN, i, params->data.F32, NULL); + pcm->modelConv->modelLimits (PS_MINIMIZE_PARAM_MAX, i, params->data.F32, NULL); + } + + // set up the minimization process + psMinimization *myMin = psMinimizationAlloc (fitOptions->nIter, fitOptions->minTol, fitOptions->maxTol); + + psImage *covar = psImageAlloc (params->n, params->n, PS_TYPE_F32); + + bool fitStatus = pmPCM_MinimizeChisq (myMin, covar, params, source, pcm); + for (int i = 0; i < dparams->n; i++) { + if ((pcm->constraint->paramMask != NULL) && pcm->constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[i]) + continue; + dparams->data.F32[i] = sqrt(covar->data.F32[i][i]); + psTrace ("psModules.objects", 4, "%f +/- %f", params->data.F32[i], dparams->data.F32[i]); + } + psTrace ("psphot", 4, "niter: %d, chisq: %f", myMin->iter, myMin->value); + + // renormalize output model image (generated by fitting process) + float Io = params->data.F32[PM_PAR_I0]; + for (int iy = 0; iy < source->modelFlux->numRows; iy++) { + for (int ix = 0; ix < source->modelFlux->numCols; ix++) { + source->modelFlux->data.F32[iy][ix] /= Io; + } + } + + // save the resulting chisq, nDOF, nIter + pcm->modelConv->chisq = myMin->value; + pcm->modelConv->nIter = myMin->iter; + pcm->modelConv->nPix = pcm->nPix; + pcm->modelConv->nDOF = pcm->nDOF; + pcm->modelConv->chisqNorm = pcm->modelConv->chisq / pcm->modelConv->nDOF; + pcm->modelConv->flags |= PM_MODEL_STATUS_FITTED; + if (!fitStatus) pcm->modelConv->flags |= PM_MODEL_STATUS_NONCONVERGE; + + // models can go insane: reject these + bool onPic = true; + onPic &= (params->data.F32[PM_PAR_XPOS] >= source->pixels->col0); + onPic &= (params->data.F32[PM_PAR_XPOS] < source->pixels->col0 + source->pixels->numCols); + onPic &= (params->data.F32[PM_PAR_YPOS] >= source->pixels->row0); + onPic &= (params->data.F32[PM_PAR_YPOS] < source->pixels->row0 + source->pixels->numRows); + if (!onPic) pcm->modelConv->flags |= PM_MODEL_STATUS_OFFIMAGE; + + source->mode |= PM_SOURCE_MODE_FITTED; // XXX is this needed? + + psFree(myMin); + psFree(covar); + + return true; +} + +bool pmSourceModelGuessPCM (pmPCMdata *pcm, pmSource *source, psImageMaskType maskVal, psImageMaskType markVal) { + + if (!pcm->modelConv->modelGuess(pcm->modelConv, source)) { + return false; + } + return true; + + // generate copy of the model + // XXX we could modify the parameter values or even the model + // here based on the observed seeing (some lookup table...) + + // XXX test : modify the Io, SXX, SYY terms based on the psf SXX, SYY terms: + // SXX,SYY in model parameters are sqrt(2) * shape.Sxx,Syy + psEllipseShape psfShape; + psfShape.sx = source->modelPSF->params->data.F32[PM_PAR_SXX] / M_SQRT2; + psfShape.sxy = source->modelPSF->params->data.F32[PM_PAR_SXY]; + psfShape.sy = source->modelPSF->params->data.F32[PM_PAR_SYY] / M_SQRT2; + + psEllipseAxes psfAxes = psEllipseShapeToAxes (psfShape, 20.0); + if (!isfinite(psfAxes.major)) return false; + if (!isfinite(psfAxes.minor)) return false; + if (!isfinite(psfAxes.theta)) return false; + + // XXX test : modify the Io, SXX, SYY terms based on the psf SXX, SYY terms: + psEllipseShape extShape; + extShape.sx = pcm->modelConv->params->data.F32[PM_PAR_SXX] / M_SQRT2; + extShape.sxy = pcm->modelConv->params->data.F32[PM_PAR_SXY]; + extShape.sy = pcm->modelConv->params->data.F32[PM_PAR_SYY] / M_SQRT2; + + psEllipseAxes extAxes = psEllipseShapeToAxes (extShape, 20.0); + if (!isfinite(extAxes.major)) return false; + if (!isfinite(extAxes.minor)) return false; + if (!isfinite(extAxes.theta)) return false; + + // decrease the initial guess ellipse by psf_minor axis: + psEllipseAxes extAxesMod; + extAxesMod.major = sqrt (PS_MAX (0.25, PS_SQR(extAxes.major) - PS_SQR(psfAxes.minor))); + extAxesMod.minor = sqrt (PS_MAX (0.25, PS_SQR(extAxes.minor) - PS_SQR(psfAxes.minor))); + extAxesMod.theta = extAxes.theta; + + psEllipseShape extShapeMod = psEllipseAxesToShape (extAxesMod); + if (!isfinite(extShapeMod.sx)) return false; + if (!isfinite(extShapeMod.sy)) return false; + if (!isfinite(extShapeMod.sxy)) return false; + + pcm->modelConv->params->data.F32[PM_PAR_SXX] = extShapeMod.sx * M_SQRT2; + pcm->modelConv->params->data.F32[PM_PAR_SXY] = extShapeMod.sxy; + pcm->modelConv->params->data.F32[PM_PAR_SYY] = extShapeMod.sy * M_SQRT2; + + // increase the initial guess central intensity by 2pi r^2: + pcm->modelConv->params->data.F32[PM_PAR_I0] *= (1.0 + PS_SQR(psfAxes.minor) / PS_SQR(extAxesMod.minor)); + + return true; +} Index: /trunk/psModules/src/objects/pmSourceFitSet.c =================================================================== --- /trunk/psModules/src/objects/pmSourceFitSet.c (revision 29003) +++ /trunk/psModules/src/objects/pmSourceFitSet.c (revision 29004) @@ -22,23 +22,30 @@ #include "pmHDU.h" #include "pmFPA.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmGrowthCurve.h" -#include "pmResiduals.h" -#include "pmTrend2D.h" -#include "pmPSF.h" +#include "pmModelFuncs.h" #include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" #include "pmSource.h" -#include "pmModelClass.h" + #include "pmSourceFitModel.h" #include "pmSourceFitSet.h" // save as static values so they may be set externally -static psF32 PM_SOURCE_FIT_MODEL_NUM_ITERATIONS = 15; -static psF32 PM_SOURCE_FIT_MODEL_TOLERANCE = 0.1; -static psF32 PM_SOURCE_FIT_MODEL_WEIGHT = 1.0; -static bool PM_SOURCE_FIT_MODEL_PIX_WEIGHTS = true; +// static psF32 PM_SOURCE_FIT_MODEL_NUM_ITERATIONS = 15; +// static psF32 PM_SOURCE_FIT_MODEL_TOLERANCE = 0.1; +// static psF32 PM_SOURCE_FIT_MODEL_WEIGHT = 1.0; +// static bool PM_SOURCE_FIT_MODEL_PIX_WEIGHTS = true; /********************* Source Model Set Functions ***************************/ @@ -429,5 +436,5 @@ bool pmSourceFitSet (pmSource *source, psArray *modelSet, - pmSourceFitMode mode, + pmSourceFitOptions *options, psImageMaskType maskVal) { @@ -478,11 +485,11 @@ // as variance to avoid the bias from systematic errors here we would just use the // source sky variance - if (PM_SOURCE_FIT_MODEL_PIX_WEIGHTS) { - yErr->data.F32[nPix] = 1.0 / source->variance->data.F32[i][j]; - } else { - yErr->data.F32[nPix] = 1.0 / PM_SOURCE_FIT_MODEL_WEIGHT; - } - nPix++; - } + if (options->poissonErrors) { + yErr->data.F32[nPix] = 1.0 / source->variance->data.F32[i][j]; + } else { + yErr->data.F32[nPix] = 1.0 / options->weight; + } + nPix++; + } } x->n = nPix; @@ -490,49 +497,49 @@ yErr->n = nPix; - // create the FitSet for this thread and set the initial parameter guesses +// create the FitSet for this thread and set the initial parameter guesses pmSourceFitSetData *thisSet = pmSourceFitSetDataSet(modelSet); - // define param and deriv vectors for complete set of parameters +// define param and deriv vectors for complete set of parameters psVector *params = psVectorAlloc (thisSet->nParamSet, PS_TYPE_F32); - // set the param and deriv vectors based on the curent values +// set the param and deriv vectors based on the curent values pmSourceFitSetJoin (NULL, params, thisSet); - // create the minimization constraints +// create the minimization constraints psMinConstraint *constraint = psMinConstraintAlloc(); constraint->paramMask = psVectorAlloc (thisSet->nParamSet, PS_TYPE_VECTOR_MASK); constraint->checkLimits = pmSourceFitSetCheckLimits; - pmSourceFitSetMasks (constraint, thisSet, mode); - - // force the floating parameters to fall within the contraint ranges + pmSourceFitSetMasks (constraint, thisSet, options->mode); + +// force the floating parameters to fall within the contraint ranges for (int i = 0; i < params->n; i++) { - pmSourceFitSetCheckLimits (PS_MINIMIZE_PARAM_MIN, i, params->data.F32, NULL); - pmSourceFitSetCheckLimits (PS_MINIMIZE_PARAM_MAX, i, params->data.F32, NULL); + pmSourceFitSetCheckLimits (PS_MINIMIZE_PARAM_MIN, i, params->data.F32, NULL); + pmSourceFitSetCheckLimits (PS_MINIMIZE_PARAM_MAX, i, params->data.F32, NULL); } if (psTraceGetLevel("psModules.objects") >= 5) { - for (int i = 0; i < params->n; i++) { - fprintf (stderr, "%d %f %d\n", i, params->data.F32[i], constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[i]); - } + for (int i = 0; i < params->n; i++) { + fprintf (stderr, "%d %f %d\n", i, params->data.F32[i], constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[i]); + } } if (nPix < thisSet->nParamSet + 1) { - psTrace (__func__, 4, "insufficient valid pixels\n"); - psTrace("psModules.objects", 10, "---- %s() end : fail pixels ----\n", __func__); - for (int i = 0; i < modelSet->n; i++) { - pmModel *model = modelSet->data[i]; - model->flags |= PM_MODEL_STATUS_BADARGS; - } - psFree (x); - psFree (y); - psFree (yErr); - psFree (params); - psFree(constraint); - pmSourceFitSetDataClear(); // frees thisSet and removes if from the array of fitSets - return(false); - } - - psMinimization *myMin = psMinimizationAlloc (PM_SOURCE_FIT_MODEL_NUM_ITERATIONS, PM_SOURCE_FIT_MODEL_TOLERANCE); + psTrace (__func__, 4, "insufficient valid pixels\n"); + psTrace("psModules.objects", 10, "---- %s() end : fail pixels ----\n", __func__); + for (int i = 0; i < modelSet->n; i++) { + pmModel *model = modelSet->data[i]; + model->flags |= PM_MODEL_STATUS_BADARGS; + } + psFree (x); + psFree (y); + psFree (yErr); + psFree (params); + psFree(constraint); + pmSourceFitSetDataClear(); // frees thisSet and removes if from the array of fitSets + return(false); + } + + psMinimization *myMin = psMinimizationAlloc (options->nIter, options->minTol, options->maxTol); psImage *covar = psImageAlloc (params->n, params->n, PS_TYPE_F32); @@ -540,35 +547,35 @@ fitStatus = psMinimizeLMChi2(myMin, covar, params, constraint, x, y, yErr, pmSourceFitSetFunction); if (!fitStatus) { - psTrace("psModules.objects", 4, "Failed to fit model (%ld components)\n", modelSet->n); - } - - // parameter errors from the covariance matrix + psTrace("psModules.objects", 4, "Failed to fit model (%ld components)\n", modelSet->n); + } + +// parameter errors from the covariance matrix psVector *dparams = psVectorAlloc (thisSet->nParamSet, PS_TYPE_F32); for (int i = 0; i < dparams->n; i++) { - if ((constraint->paramMask != NULL) && constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[i]) - continue; - dparams->data.F32[i] = sqrt(covar->data.F32[i][i]); - } - - // get the Gauss-Newton distance for fixed model parameters + if ((constraint->paramMask != NULL) && constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[i]) + continue; + dparams->data.F32[i] = sqrt(covar->data.F32[i][i]); + } + +// get the Gauss-Newton distance for fixed model parameters if (constraint->paramMask != NULL) { - psVector *delta = psVectorAlloc (params->n, PS_TYPE_F32); - psVector *altmask = psVectorAlloc (params->n, PS_TYPE_VECTOR_MASK); - altmask->data.PS_TYPE_VECTOR_MASK_DATA[0] = 1; - for (int i = 1; i < dparams->n; i++) { - altmask->data.PS_TYPE_VECTOR_MASK_DATA[i] = (constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[i]) ? 0 : 1; - } - psMinimizeGaussNewtonDelta(delta, params, altmask, x, y, yErr, pmSourceFitSetFunction); - - for (int i = 0; i < dparams->n; i++) { - if (!constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[i]) - continue; - // note that delta is the value *subtracted* from the parameter - // to get the new guess. for dparams to represent the direction - // of motion, we need to take -delta - dparams->data.F32[i] = -delta->data.F32[i]; - } - psFree (delta); - psFree (altmask); + psVector *delta = psVectorAlloc (params->n, PS_TYPE_F32); + psVector *altmask = psVectorAlloc (params->n, PS_TYPE_VECTOR_MASK); + altmask->data.PS_TYPE_VECTOR_MASK_DATA[0] = 1; + for (int i = 1; i < dparams->n; i++) { + altmask->data.PS_TYPE_VECTOR_MASK_DATA[i] = (constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[i]) ? 0 : 1; + } + psMinimizeGaussNewtonDelta(delta, params, altmask, x, y, yErr, pmSourceFitSetFunction); + + for (int i = 0; i < dparams->n; i++) { + if (!constraint->paramMask->data.PS_TYPE_VECTOR_MASK_DATA[i]) + continue; + // note that delta is the value *subtracted* from the parameter + // to get the new guess. for dparams to represent the direction + // of motion, we need to take -delta + dparams->data.F32[i] = -delta->data.F32[i]; + } + psFree (delta); + psFree (altmask); } Index: /trunk/psModules/src/objects/pmSourceFitSet.h =================================================================== --- /trunk/psModules/src/objects/pmSourceFitSet.h (revision 29003) +++ /trunk/psModules/src/objects/pmSourceFitSet.h (revision 29004) @@ -56,5 +56,5 @@ pmSource *source, ///< The input pmSource psArray *modelSet, ///< model to be fitted - pmSourceFitMode mode, ///< define parameters to be fitted + pmSourceFitOptions *options, ///< define options for fitting process psImageMaskType maskVal ///< Vale to mask Index: unk/psModules/src/objects/pmSourceGroup.h =================================================================== --- /trunk/psModules/src/objects/pmSourceGroup.h (revision 29003) +++ (revision ) @@ -1,44 +1,0 @@ -/* @file pmSourceGroup.h - * - * @author EAM, IfA - * - * @version $Revision: $ - * @date $Date: 2009-02-16 22:30:50 $ - * Copyright 2009 Institute for Astronomy, University of Hawaii - */ - -# ifndef PM_SOURCE_GROUP_H -# define PM_SOURCE_GROUP_H - -#include -#include "pmPeaks.h" -#include "pmModel.h" -#include "pmMoments.h" -#include "pmSourceExtendedPars.h" - -/// @addtogroup Objects Object Detection / Analysis Functions -/// @{ - -#include - -/** pmSourceGroup data structure - * - * A source group is a connected set of source measurements with a - * common connection. Each source in the group represents the - * detection of some astronomical object on a single each. The group - * represents the related collection of measurements. The fits are - * coupled in some way. For example, they may all have the same - * position, but independent fluxes. Or, they may have a common set - * of positions and shape parameters. Or the position in each image - * may be related by a function. - * - * XXX is thre any info that is neaded for each source group beyond that carried by the sources (besides ID)? - */ -struct pmSource { - int seq; ///< ID for output (generated on write OR set on read) - psArray *sources; -} pmSourceGroup; - - -/// @} -# endif /* PM_SOURCE_GROUP_H */ Index: /trunk/psModules/src/objects/pmSourceGroups.c =================================================================== --- /trunk/psModules/src/objects/pmSourceGroups.c (revision 29003) +++ /trunk/psModules/src/objects/pmSourceGroups.c (revision 29004) @@ -6,6 +6,28 @@ #include +#include "pmHDU.h" #include "pmFPA.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" +#include "pmSpan.h" +#include "pmFootprintSpans.h" +#include "pmFootprint.h" +#include "pmPeaks.h" +#include "pmMoments.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" #include "pmSource.h" +#include "pmSourceFitModel.h" +#include "pmPSF.h" +#include "pmPSFtry.h" +#include "pmDetections.h" + #include "pmSourceGroups.h" Index: /trunk/psModules/src/objects/pmSourceGroups.h =================================================================== --- /trunk/psModules/src/objects/pmSourceGroups.h (revision 29003) +++ /trunk/psModules/src/objects/pmSourceGroups.h (revision 29004) @@ -1,8 +1,4 @@ #ifndef PM_SOURCE_GROUPS_H #define PM_SOURCE_GROUPS_H - -#include - -#include "pmFPA.h" /// Groups of sources Index: /trunk/psModules/src/objects/pmSourceIO.c =================================================================== --- /trunk/psModules/src/objects/pmSourceIO.c (revision 29003) +++ /trunk/psModules/src/objects/pmSourceIO.c (revision 29004) @@ -31,16 +31,25 @@ #include "pmConceptsRead.h" +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmGrowthCurve.h" -#include "pmResiduals.h" -#include "pmTrend2D.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" #include "pmPSF.h" -#include "pmModel.h" +#include "pmPSFtry.h" + #include "pmDetections.h" -#include "pmSource.h" -#include "pmModelClass.h" #include "pmDetEff.h" #include "pmSourceIO.h" @@ -326,4 +335,15 @@ } +# define PM_SOURCES_WRITE(NAME,TYPE) \ + if (!strcmp (exttype, NAME)) { \ + status &= pmSourcesWrite_##TYPE(file->fits, readout, sources, file->header, outhead, dataname, recipe); \ + if (xsrcname) { \ + status &= pmSourcesWrite_##TYPE##_XSRC(file->fits, readout, sources, file->header, xsrcname, recipe); \ + } \ + if (xfitname) { \ + status &= pmSourcesWrite_##TYPE##_XFIT (file->fits, readout, sources, file->header, xfitname); \ + } \ + } + // write out all readout-level Objects files for this cell bool pmReadoutWriteObjects (pmReadout *readout, const pmFPAview *view, pmFPAfile *file, const pmConfig *config) @@ -360,4 +380,5 @@ } + // the older types (RAW, OBJ, SX, CMP) are for backwards compatibility -- deprecate eventually? switch (file->type) { case PM_FPA_FILE_RAW: @@ -518,72 +539,19 @@ psMetadataAddStr (outhead, PS_LIST_TAIL, "XFITNAME", PS_META_REPLACE, "name of XFIT table extension", xfitname); } - - // XXX these are case-sensitive since the EXTYPE is case-sensitive + + + // these are case-sensitive since the EXTYPE is case-sensitive status = true; - if (!strcmp (exttype, "SMPDATA")) { - status &= pmSourcesWrite_SMPDATA (file->fits, sources, file->header, outhead, dataname); - } - if (!strcmp (exttype, "PS1_DEV_0")) { - status &= pmSourcesWrite_PS1_DEV_0 (file->fits, sources, file->header, outhead, dataname); - } - if (!strcmp (exttype, "PS1_DEV_1")) { - status &= pmSourcesWrite_PS1_DEV_1 (file->fits, sources, file->header, outhead, dataname); - } - if (!strcmp (exttype, "PS1_CAL_0")) { - status &= pmSourcesWrite_PS1_CAL_0 (file->fits, readout, sources, file->header, outhead, dataname); - } - if (!strcmp (exttype, "PS1_V1")) { - status &= pmSourcesWrite_CMF_PS1_V1 (file->fits, readout, sources, file->header, outhead, dataname); - } - if (!strcmp (exttype, "PS1_V2")) { - status &= pmSourcesWrite_CMF_PS1_V2 (file->fits, readout, sources, file->header, outhead, dataname); - } - if (!strcmp (exttype, "PS1_SV1")) { - status &= pmSourcesWrite_CMF_PS1_SV1 (file->fits, readout, sources, file->header, outhead, dataname, recipe); - } - if (!strcmp (exttype, "PS1_DV1")) { - status &= pmSourcesWrite_CMF_PS1_DV1 (file->fits, readout, sources, file->header, outhead, dataname); - } - - if (xsrcname) { - if (!strcmp (exttype, "PS1_DEV_1")) { - status &= pmSourcesWrite_PS1_DEV_1_XSRC (file->fits, sources, xsrcname, recipe); - } - if (!strcmp (exttype, "PS1_CAL_0")) { - status &= pmSourcesWrite_PS1_CAL_0_XSRC (file->fits, readout, sources, file->header, xsrcname, recipe); - } - if (!strcmp (exttype, "PS1_V1")) { - status &= pmSourcesWrite_CMF_PS1_V1_XSRC (file->fits, readout, sources, file->header, xsrcname, recipe); - } - if (!strcmp (exttype, "PS1_V2")) { - status &= pmSourcesWrite_CMF_PS1_V2_XSRC (file->fits, readout, sources, file->header, xsrcname, recipe); - } - if (!strcmp (exttype, "PS1_SV1")) { - status &= pmSourcesWrite_CMF_PS1_SV1_XSRC (file->fits, readout, sources, file->header, xsrcname, recipe); - } - if (!strcmp (exttype, "PS1_DV1")) { - status &= pmSourcesWrite_CMF_PS1_DV1_XSRC (file->fits, readout, sources, file->header, xsrcname, recipe); - } - } - if (xfitname) { - if (!strcmp (exttype, "PS1_DEV_1")) { - status &= pmSourcesWrite_PS1_DEV_1_XFIT (file->fits, sources, xfitname); - } - if (!strcmp (exttype, "PS1_CAL_0")) { - status &= pmSourcesWrite_PS1_CAL_0_XFIT (file->fits, readout, sources, file->header, xfitname); - } - if (!strcmp (exttype, "PS1_V1")) { - status &= pmSourcesWrite_CMF_PS1_V1_XFIT (file->fits, readout, sources, xfitname); - } - if (!strcmp (exttype, "PS1_V2")) { - status &= pmSourcesWrite_CMF_PS1_V2_XFIT (file->fits, readout, sources, xfitname); - } - if (!strcmp (exttype, "PS1_SV1")) { - status &= pmSourcesWrite_CMF_PS1_SV1_XFIT (file->fits, readout, sources, xfitname); - } - if (!strcmp (exttype, "PS1_DV1")) { - status &= pmSourcesWrite_CMF_PS1_DV1_XFIT (file->fits, readout, sources, xfitname); - } - } + PM_SOURCES_WRITE("SMPDATA", SMPDATA); + PM_SOURCES_WRITE("PS1_DEV_0", PS1_DEV_0); + PM_SOURCES_WRITE("PS1_DEV_1", PS1_DEV_1); + PM_SOURCES_WRITE("PS1_CAL_0", PS1_CAL_0); + PM_SOURCES_WRITE("PS1_V1", CMF_PS1_V1); + PM_SOURCES_WRITE("PS1_V2", CMF_PS1_V2); + PM_SOURCES_WRITE("PS1_V3", CMF_PS1_V3); + PM_SOURCES_WRITE("PS1_SV1", CMF_PS1_SV1); + PM_SOURCES_WRITE("PS1_DV1", CMF_PS1_DV1); + PM_SOURCES_WRITE("PS1_DV2", CMF_PS1_DV2); + psFree (outhead); psFree (exttype); @@ -1039,4 +1007,7 @@ sources = pmSourcesRead_CMF_PS1_DV1 (file->fits, hdu->header); } + if (!strcmp (exttype, "PS1_DV2")) { + sources = pmSourcesRead_CMF_PS1_DV2 (file->fits, hdu->header); + } if (!pmReadoutReadDetEff(file->fits, readout, deteffname)) { Index: /trunk/psModules/src/objects/pmSourceIO.h =================================================================== --- /trunk/psModules/src/objects/pmSourceIO.h (revision 29003) +++ /trunk/psModules/src/objects/pmSourceIO.h (revision 29004) @@ -24,32 +24,46 @@ bool pmSourcesWriteCMP (psArray *sources, char *filename, psMetadata *header); -bool pmSourcesWrite_SMPDATA (psFits *fits, psArray *sources, psMetadata *imageHeader, psMetadata *tableHeader, char *extname); -bool pmSourcesWrite_PS1_DEV_0 (psFits *fits, psArray *sources, psMetadata *imageHeader, psMetadata *tableHeader, char *extname); +bool pmSource_CMF_WritePHU (const pmFPAview *view, pmFPAfile *file, pmConfig *config); -bool pmSourcesWrite_PS1_DEV_1 (psFits *fits, psArray *sources, psMetadata *imageHeader, psMetadata *tableHeader, char *extname); -bool pmSourcesWrite_PS1_DEV_1_XSRC (psFits *fits, psArray *sources, char *extname, psMetadata *recipe); -bool pmSourcesWrite_PS1_DEV_1_XFIT (psFits *fits, psArray *sources, char *extname); +// All of these functions need to use the same API, even if not all elements are used in a specific case +bool pmSourcesWrite_SMPDATA(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, psMetadata *tableHeader, char *extname, psMetadata *recipe); +bool pmSourcesWrite_SMPDATA_XSRC(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname, psMetadata *recipe); +bool pmSourcesWrite_SMPDATA_XFIT(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname); -bool pmSourcesWrite_PS1_CAL_0 (psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, psMetadata *tableHeader, char *extname); -bool pmSourcesWrite_PS1_CAL_0_XSRC (psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname, psMetadata *recipe); -bool pmSourcesWrite_PS1_CAL_0_XFIT (psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname); +bool pmSourcesWrite_PS1_DEV_0(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, psMetadata *tableHeader, char *extname, psMetadata *recipe); +bool pmSourcesWrite_PS1_DEV_0_XSRC(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname, psMetadata *recipe); +bool pmSourcesWrite_PS1_DEV_0_XFIT(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname); -bool pmSourcesWrite_CMF_PS1_V1 (psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, psMetadata *tableHeader, char *extname); -bool pmSourcesWrite_CMF_PS1_V1_XSRC (psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname, psMetadata *recipe); -bool pmSourcesWrite_CMF_PS1_V1_XFIT (psFits *fits, pmReadout *readout, psArray *sources, char *extname); +bool pmSourcesWrite_PS1_DEV_1(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, psMetadata *tableHeader, char *extname, psMetadata *recipe); +bool pmSourcesWrite_PS1_DEV_1_XSRC(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname, psMetadata *recipe); +bool pmSourcesWrite_PS1_DEV_1_XFIT(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname); -bool pmSourcesWrite_CMF_PS1_V2 (psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, psMetadata *tableHeader, char *extname); -bool pmSourcesWrite_CMF_PS1_V2_XSRC (psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname, psMetadata *recipe); -bool pmSourcesWrite_CMF_PS1_V2_XFIT (psFits *fits, pmReadout *readout, psArray *sources, char *extname); +bool pmSourcesWrite_PS1_CAL_0(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, psMetadata *tableHeader, char *extname, psMetadata *recipe); +bool pmSourcesWrite_PS1_CAL_0_XSRC(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname, psMetadata *recipe); +bool pmSourcesWrite_PS1_CAL_0_XFIT(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname); -bool pmSourcesWrite_CMF_PS1_SV1 (psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, psMetadata *tableHeader, char *extname, psMetadata *recipe); -bool pmSourcesWrite_CMF_PS1_SV1_XSRC (psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname, psMetadata *recipe); -bool pmSourcesWrite_CMF_PS1_SV1_XFIT (psFits *fits, pmReadout *readout, psArray *sources, char *extname); +bool pmSourcesWrite_CMF_PS1_V1(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, psMetadata *tableHeader, char *extname, psMetadata *recipe); +bool pmSourcesWrite_CMF_PS1_V1_XSRC(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname, psMetadata *recipe); +bool pmSourcesWrite_CMF_PS1_V1_XFIT(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname); -bool pmSourcesWrite_CMF_PS1_DV1 (psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, psMetadata *tableHeader, char *extname); -bool pmSourcesWrite_CMF_PS1_DV1_XSRC (psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname, psMetadata *recipe); -bool pmSourcesWrite_CMF_PS1_DV1_XFIT (psFits *fits, pmReadout *readout, psArray *sources, char *extname); +bool pmSourcesWrite_CMF_PS1_V2(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, psMetadata *tableHeader, char *extname, psMetadata *recipe); +bool pmSourcesWrite_CMF_PS1_V2_XSRC(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname, psMetadata *recipe); +bool pmSourcesWrite_CMF_PS1_V2_XFIT(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname); -bool pmSource_CMF_WritePHU (const pmFPAview *view, pmFPAfile *file, pmConfig *config); +bool pmSourcesWrite_CMF_PS1_V3(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, psMetadata *tableHeader, char *extname, psMetadata *recipe); +bool pmSourcesWrite_CMF_PS1_V3_XSRC(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname, psMetadata *recipe); +bool pmSourcesWrite_CMF_PS1_V3_XFIT(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname); + +bool pmSourcesWrite_CMF_PS1_SV1(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, psMetadata *tableHeader, char *extname, psMetadata *recipe); +bool pmSourcesWrite_CMF_PS1_SV1_XSRC(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname, psMetadata *recipe); +bool pmSourcesWrite_CMF_PS1_SV1_XFIT(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname); + +bool pmSourcesWrite_CMF_PS1_DV1(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, psMetadata *tableHeader, char *extname, psMetadata *recipe); +bool pmSourcesWrite_CMF_PS1_DV1_XSRC(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname, psMetadata *recipe); +bool pmSourcesWrite_CMF_PS1_DV1_XFIT(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname); + +bool pmSourcesWrite_CMF_PS1_DV2(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, psMetadata *tableHeader, char *extname, psMetadata *recipe); +bool pmSourcesWrite_CMF_PS1_DV2_XSRC(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname, psMetadata *recipe); +bool pmSourcesWrite_CMF_PS1_DV2_XFIT(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname); psArray *pmSourcesReadCMP (char *filename, psMetadata *header); @@ -63,4 +77,5 @@ psArray *pmSourcesRead_CMF_PS1_SV1 (psFits *fits, psMetadata *header); psArray *pmSourcesRead_CMF_PS1_DV1 (psFits *fits, psMetadata *header); +psArray *pmSourcesRead_CMF_PS1_DV2 (psFits *fits, psMetadata *header); bool pmSourcesWritePSFs (psArray *sources, char *filename); Index: /trunk/psModules/src/objects/pmSourceIO_CMF_PS1_DV1.c =================================================================== --- /trunk/psModules/src/objects/pmSourceIO_CMF_PS1_DV1.c (revision 29003) +++ /trunk/psModules/src/objects/pmSourceIO_CMF_PS1_DV1.c (revision 29004) @@ -28,15 +28,24 @@ #include "pmFPAfile.h" +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmGrowthCurve.h" -#include "pmResiduals.h" -#include "pmTrend2D.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" #include "pmPSF.h" -#include "pmModel.h" -#include "pmSource.h" -#include "pmModelClass.h" +#include "pmPSFtry.h" + #include "pmSourceIO.h" @@ -47,6 +56,5 @@ // This version has elements intended for difference images & forced photometry: // diffStats entries (good for dipoles); flux + flux error (for insignificant detections) -bool pmSourcesWrite_CMF_PS1_DV1 (psFits *fits, pmReadout *readout, psArray *sources, - psMetadata *imageHeader, psMetadata *tableHeader, char *extname) +bool pmSourcesWrite_CMF_PS1_DV1 (psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, psMetadata *tableHeader, char *extname, psMetadata *recipe) { PS_ASSERT_PTR_NON_NULL(fits, false); @@ -194,5 +202,5 @@ psMetadataAdd (row, PS_LIST_TAIL, "PSF_MINOR", PS_DATA_F32, "PSF width (minor axis)", axes.minor); psMetadataAdd (row, PS_LIST_TAIL, "PSF_THETA", PS_DATA_F32, "PSF orientation angle", axes.theta); - psMetadataAdd (row, PS_LIST_TAIL, "PSF_QF", PS_DATA_F32, "PSF coverage/quality factor", source->pixWeight); + psMetadataAdd (row, PS_LIST_TAIL, "PSF_QF", PS_DATA_F32, "PSF coverage/quality factor", source->pixWeightNotBad); psMetadataAdd (row, PS_LIST_TAIL, "PSF_NDOF", PS_DATA_S32, "degrees of freedom", nDOF); psMetadataAdd (row, PS_LIST_TAIL, "PSF_NPIX", PS_DATA_S32, "number of pixels in fit", nPix); @@ -324,9 +332,15 @@ source->peak = pmPeakAlloc(PAR[PM_PAR_XPOS], PAR[PM_PAR_YPOS], peakFlux, PM_PEAK_LONE); source->peak->flux = peakFlux; + source->peak->xf = PAR[PM_PAR_XPOS]; // more accurate position + source->peak->yf = PAR[PM_PAR_YPOS]; // more accurate position source->peak->dx = dPAR[PM_PAR_XPOS]; source->peak->dy = dPAR[PM_PAR_YPOS]; - source->peak->SN = sqrt(source->peak->flux); // XXX a proxy: various functions sort by peak S/N - - source->pixWeight = psMetadataLookupF32 (&status, row, "PSF_QF"); + if (isfinite (source->errMag) && (source->errMag > 0.0)) { + source->peak->SN = 1.0 / source->errMag; + } else { + source->peak->SN = sqrt(source->peak->flux); // an alternate proxy: various functions sort by peak S/N + } + + source->pixWeightNotBad = psMetadataLookupF32 (&status, row, "PSF_QF"); source->crNsigma = psMetadataLookupF32 (&status, row, "CR_NSIGMA"); source->extNsigma = psMetadataLookupF32 (&status, row, "EXT_NSIGMA"); @@ -536,5 +550,5 @@ // XXX this layout is still the same as PS1_DEV_1 -bool pmSourcesWrite_CMF_PS1_DV1_XFIT (psFits *fits, pmReadout *readout, psArray *sources, char *extname) +bool pmSourcesWrite_CMF_PS1_DV1_XFIT(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname) { @@ -585,4 +599,7 @@ assert (model); + // skip models which were not actually fitted + if (model->flags & PM_MODEL_STATUS_BADARGS) continue; + PAR = model->params->data.F32; dPAR = model->dparams->data.F32; Index: /trunk/psModules/src/objects/pmSourceIO_CMF_PS1_DV2.c =================================================================== --- /trunk/psModules/src/objects/pmSourceIO_CMF_PS1_DV2.c (revision 29004) +++ /trunk/psModules/src/objects/pmSourceIO_CMF_PS1_DV2.c (revision 29004) @@ -0,0 +1,691 @@ +/** @file pmSourceIO.c + * + * @author EAM, IfA + * + * @version $Revision: 1.3 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-02-18 02:44:19 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + * + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include +#include +#include +#include + +#include "pmConfig.h" +#include "pmDetrendDB.h" + +#include "pmHDU.h" +#include "pmFPA.h" +#include "pmFPALevel.h" +#include "pmFPAview.h" +#include "pmFPAfile.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" +#include "pmSpan.h" +#include "pmFootprintSpans.h" +#include "pmFootprint.h" +#include "pmPeaks.h" +#include "pmMoments.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" +#include "pmPSF.h" +#include "pmPSFtry.h" + +#include "pmSourceIO.h" + +// panstarrs-style FITS table output (header + table in 1st extension) +// this format consists of a header derived from the image header +// followed by a zero-size matrix, followed by the table data + +// This version has elements intended for difference images & forced photometry: +// diffStats entries (good for dipoles); flux + flux error (for insignificant detections) +bool pmSourcesWrite_CMF_PS1_DV2 (psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, psMetadata *tableHeader, char *extname, psMetadata *recipe) +{ + PS_ASSERT_PTR_NON_NULL(fits, false); + PS_ASSERT_PTR_NON_NULL(sources, false); + PS_ASSERT_PTR_NON_NULL(extname, false); + + int i; + psArray *table; + psMetadata *row; + psF32 *PAR, *dPAR; + psEllipseAxes axes; + psF32 xPos, yPos; + psF32 xErr, yErr; + psF32 errMag, chisq, apRadius; + psS32 nPix, nDOF; + + pmChip *chip = readout->parent->parent; + pmFPA *fpa = chip->parent; + + bool status1 = false; + bool status2 = false; + float magOffset = NAN; + float exptime = psMetadataLookupF32 (&status1, fpa->concepts, "FPA.EXPOSURE"); + float zeropt = psMetadataLookupF32(&status2, fpa->concepts, "FPA.ZP"); + if (!isfinite(zeropt)) { + zeropt = psMetadataLookupF32 (&status2, imageHeader, "ZPT_OBS"); + } + if (status1 && status2 && (exptime > 0.0)) { + magOffset = zeropt + 2.5*log10(exptime); + } + float zeroptErr = psMetadataLookupF32 (&status2, imageHeader, "ZPT_ERR"); + + // if the sequence is defined, write these in seq order; otherwise + // write them in S/N order: + if (sources->n > 0) { + pmSource *source = (pmSource *) sources->data[0]; + if (source->seq == -1) { + // let's write these out in S/N order + sources = psArraySort (sources, pmSourceSortBySN); + } else { + sources = psArraySort (sources, pmSourceSortBySeq); + } + } + + table = psArrayAllocEmpty (sources->n); + + // we write out PSF-fits for all sources, regardless of quality. the source flags tell us the state + // by the time we call this function, all values should be assigned. let's use asserts to be sure in some cases. + for (i = 0; i < sources->n; i++) { + pmSource *source = (pmSource *) sources->data[i]; + + // If source->seq is -1, source was generated in this analysis. If source->seq is + // not -1, source was read from elsewhere: in the latter case, preserve the source + // ID. source.seq is used instead of source.id since the latter is a const + // generated on Alloc, and would thus be wrong for read in sources. + if (source->seq == -1) { + source->seq = i; + } + + // no difference between PSF and non-PSF model + pmModel *model = source->modelPSF; + + if (model != NULL) { + PAR = model->params->data.F32; + dPAR = model->dparams->data.F32; + xPos = PAR[PM_PAR_XPOS]; + yPos = PAR[PM_PAR_YPOS]; + if (source->mode & PM_SOURCE_MODE_NONLINEAR_FIT) { + xErr = dPAR[PM_PAR_XPOS]; + yErr = dPAR[PM_PAR_YPOS]; + } else { + // in linear-fit mode, there is no error on the centroid + xErr = source->peak->dx; + yErr = source->peak->dy; + } + if (isfinite(PAR[PM_PAR_SXX]) && isfinite(PAR[PM_PAR_SXX]) && isfinite(PAR[PM_PAR_SXX])) { + axes = pmPSF_ModelToAxes (PAR, 20.0); + } else { + axes.major = NAN; + axes.minor = NAN; + axes.theta = NAN; + } + chisq = model->chisq; + nDOF = model->nDOF; + nPix = model->nPix; + apRadius = source->apRadius; + errMag = model->dparams->data.F32[PM_PAR_I0] / model->params->data.F32[PM_PAR_I0]; + } else { + xPos = source->peak->xf; + yPos = source->peak->yf; + xErr = source->peak->dx; + yErr = source->peak->dy; + axes.major = NAN; + axes.minor = NAN; + axes.theta = NAN; + chisq = NAN; + nDOF = 0; + nPix = 0; + apRadius = NAN; + errMag = NAN; + } + + float calMag = isfinite(magOffset) ? source->psfMag + magOffset : NAN; + float peakMag = (source->peak->flux > 0) ? -2.5*log10(source->peak->flux) : NAN; + psS16 nImageOverlap = 1; + + psSphere ptSky = {0.0, 0.0, 0.0, 0.0}; + float posAngle = 0.0; + float pltScale = 0.0; + pmSourceLocalAstrometry (&ptSky, &posAngle, &pltScale, chip, xPos, yPos); + + pmSourceDiffStats diffStats; + pmSourceDiffStatsInit(&diffStats); + if (source->diffStats) { + diffStats = *source->diffStats; + } + + row = psMetadataAlloc (); + psMetadataAdd (row, PS_LIST_TAIL, "IPP_IDET", PS_DATA_U32, "IPP detection identifier index", source->seq); + psMetadataAdd (row, PS_LIST_TAIL, "X_PSF", PS_DATA_F32, "PSF x coordinate", xPos); + psMetadataAdd (row, PS_LIST_TAIL, "Y_PSF", PS_DATA_F32, "PSF y coordinate", yPos); + psMetadataAdd (row, PS_LIST_TAIL, "X_PSF_SIG", PS_DATA_F32, "Sigma in PSF x coordinate", xErr); // XXX this is only measured for non-linear fits + psMetadataAdd (row, PS_LIST_TAIL, "Y_PSF_SIG", PS_DATA_F32, "Sigma in PSF y coordinate", yErr); // XXX this is only measured for non-linear fits + psMetadataAdd (row, PS_LIST_TAIL, "POSANGLE", PS_DATA_F32, "position angle at source (degrees)", posAngle*PS_DEG_RAD); + psMetadataAdd (row, PS_LIST_TAIL, "PLTSCALE", PS_DATA_F32, "plate scale at source (arcsec/pixel)", pltScale*PS_DEG_RAD*3600.0); + psMetadataAdd (row, PS_LIST_TAIL, "PSF_INST_MAG", PS_DATA_F32, "PSF fit instrumental magnitude", source->psfMag); + psMetadataAdd (row, PS_LIST_TAIL, "PSF_INST_MAG_SIG", PS_DATA_F32, "Sigma of PSF instrumental magnitude", errMag); + psMetadataAdd (row, PS_LIST_TAIL, "PSF_INST_FLUX", PS_DATA_F32, "PSF fit instrumental magnitude", source->psfFlux); + psMetadataAdd (row, PS_LIST_TAIL, "PSF_INST_FLUX_SIG",PS_DATA_F32, "Sigma of PSF instrumental magnitude", source->psfFluxErr); + psMetadataAdd (row, PS_LIST_TAIL, "AP_MAG", PS_DATA_F32, "magnitude in standard aperture", source->apMag); + psMetadataAdd (row, PS_LIST_TAIL, "AP_MAG_RADIUS", PS_DATA_F32, "radius used for aperture mags", apRadius); + psMetadataAdd (row, PS_LIST_TAIL, "PEAK_FLUX_AS_MAG", PS_DATA_F32, "Peak flux expressed as magnitude", peakMag); + psMetadataAdd (row, PS_LIST_TAIL, "CAL_PSF_MAG", PS_DATA_F32, "PSF Magnitude using supplied calibration", calMag); + psMetadataAdd (row, PS_LIST_TAIL, "CAL_PSF_MAG_SIG", PS_DATA_F32, "measured scatter of zero point calibration", zeroptErr); + psMetadataAdd (row, PS_LIST_TAIL, "RA_PSF", PS_DATA_F64, "PSF RA coordinate (degrees)", ptSky.r*PS_DEG_RAD); + psMetadataAdd (row, PS_LIST_TAIL, "DEC_PSF", PS_DATA_F64, "PSF DEC coordinate (degrees)", ptSky.d*PS_DEG_RAD); + psMetadataAdd (row, PS_LIST_TAIL, "SKY", PS_DATA_F32, "Sky level", source->sky); + psMetadataAdd (row, PS_LIST_TAIL, "SKY_SIGMA", PS_DATA_F32, "Sigma of sky level", source->skyErr); + + psMetadataAdd (row, PS_LIST_TAIL, "PSF_CHISQ", PS_DATA_F32, "Chisq of PSF-fit", chisq); + psMetadataAdd (row, PS_LIST_TAIL, "CR_NSIGMA", PS_DATA_F32, "Nsigma deviations from PSF to CF", source->crNsigma); + psMetadataAdd (row, PS_LIST_TAIL, "EXT_NSIGMA", PS_DATA_F32, "Nsigma deviations from PSF to EXT", source->extNsigma); + + psMetadataAdd (row, PS_LIST_TAIL, "PSF_MAJOR", PS_DATA_F32, "PSF width (major axis)", axes.major); + psMetadataAdd (row, PS_LIST_TAIL, "PSF_MINOR", PS_DATA_F32, "PSF width (minor axis)", axes.minor); + psMetadataAdd (row, PS_LIST_TAIL, "PSF_THETA", PS_DATA_F32, "PSF orientation angle", axes.theta); + psMetadataAdd (row, PS_LIST_TAIL, "PSF_QF", PS_DATA_F32, "PSF coverage/quality factor (bad)", source->pixWeightNotBad); + psMetadataAdd (row, PS_LIST_TAIL, "PSF_QF_PERFECT", PS_DATA_F32, "PSF coverage/quality factor (poor)", source->pixWeightNotPoor); + psMetadataAdd (row, PS_LIST_TAIL, "PSF_NDOF", PS_DATA_S32, "degrees of freedom", nDOF); + psMetadataAdd (row, PS_LIST_TAIL, "PSF_NPIX", PS_DATA_S32, "number of pixels in fit", nPix); + + // distinguish moments measure from window vs S/N > XX ?? + float mxx = source->moments ? source->moments->Mxx : NAN; + float mxy = source->moments ? source->moments->Mxy : NAN; + float myy = source->moments ? source->moments->Myy : NAN; + psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_XX", PS_DATA_F32, "second moments (X^2)", mxx); + psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_XY", PS_DATA_F32, "second moments (X*Y)", mxy); + psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_YY", PS_DATA_F32, "second moments (Y*Y)", myy); + + psMetadataAdd (row, PS_LIST_TAIL, "DIFF_NPOS", PS_DATA_S32, "nPos (n pix > 3 sigma)", diffStats.nGood); + psMetadataAdd (row, PS_LIST_TAIL, "DIFF_FRATIO", PS_DATA_F32, "fPos / (fPos + fNeg)", diffStats.fRatio); + psMetadataAdd (row, PS_LIST_TAIL, "DIFF_NRATIO_BAD", PS_DATA_F32, "nPos / (nPos + nNeg)", diffStats.nRatioBad); + psMetadataAdd (row, PS_LIST_TAIL, "DIFF_NRATIO_MASK", PS_DATA_F32, "nPos / (nPos + nMask)", diffStats.nRatioMask); + psMetadataAdd (row, PS_LIST_TAIL, "DIFF_NRATIO_ALL", PS_DATA_F32, "nPos / (nGood + nMask + nBad)", diffStats.nRatioAll); + + psMetadataAdd (row, PS_LIST_TAIL, "DIFF_R_P", PS_DATA_F32, "distance to positive match source", diffStats.Rp); + psMetadataAdd (row, PS_LIST_TAIL, "DIFF_SN_P", PS_DATA_F32, "signal-to-noise of pos match src", diffStats.SNp); + psMetadataAdd (row, PS_LIST_TAIL, "DIFF_R_M", PS_DATA_F32, "distance to negative match source", diffStats.Rm); + psMetadataAdd (row, PS_LIST_TAIL, "DIFF_SN_M", PS_DATA_F32, "signal-to-noise of neg match src", diffStats.SNm); + + psMetadataAdd (row, PS_LIST_TAIL, "FLAGS", PS_DATA_U32, "psphot analysis flags", source->mode); + psMetadataAdd (row, PS_LIST_TAIL, "FLAGS2", PS_DATA_U32, "psphot analysis flags (group 2)", source->mode2); + + // XXX not sure how to get this : need to load Nimages with weight? + psMetadataAdd (row, PS_LIST_TAIL, "N_FRAMES", PS_DATA_U16, "Number of frames overlapping source center", nImageOverlap); + psMetadataAdd (row, PS_LIST_TAIL, "PADDING", PS_DATA_S16, "padding", 0); + + psArrayAdd (table, 100, row); + psFree (row); + + // EXT_NSIGMA will be NAN if: 1) contour ellipse is imaginary; 2) source is not + // subtracted + + // CR_NSIGMA will be NAN if: 1) source is not subtracted; 2) source is on the image + // edge; 3) any pixels in the 3x3 peak region are masked; + } + + psMetadata *header = psMetadataCopy(NULL, tableHeader); + pmSourceMasksHeader(header); + + if (table->n == 0) { + psFitsWriteBlank(fits, header, extname); + psFree(table); + psFree(header); + return true; + } + + psTrace ("pmFPAfile", 5, "writing ext data %s\n", extname); + if (!psFitsWriteTable(fits, header, table, extname)) { + psError(PS_ERR_IO, false, "writing ext data %s\n", extname); + psFree(table); + psFree(header); + return false; + } + psFree(table); + psFree(header); + + return true; +} + +// read in a readout from the fits file +psArray *pmSourcesRead_CMF_PS1_DV2 (psFits *fits, psMetadata *header) +{ + PS_ASSERT_PTR_NON_NULL(fits, false); + PS_ASSERT_PTR_NON_NULL(header, false); + + bool status; + psF32 *PAR, *dPAR; + psEllipseAxes axes; + + // define PSF model type + // XXX need to carry the extra model parameters + int modelType = pmModelClassGetType ("PS_MODEL_GAUSS"); + + char *PSF_NAME = psMetadataLookupStr (&status, header, "PSF_NAME"); + if (PSF_NAME != NULL) { + modelType = pmModelClassGetType (PSF_NAME); + } + assert (modelType > -1); + + // We get the size of the table, and allocate the array of sources first because the table + // is large and ephemeral --- when the table gets blown away, whatever is allocated after + // the table is read blocks the free. In fact, it's better to read the table row by row. + long numSources = psFitsTableSize(fits); // Number of sources in table + psArray *sources = psArrayAlloc(numSources); // Array of sources, to return + + // convert the table to the pmSource entriesa + for (int i = 0; i < numSources; i++) { + psMetadata *row = psFitsReadTableRow(fits, i); // Table row + + pmSource *source = pmSourceAlloc (); + pmModel *model = pmModelAlloc (modelType); + source->modelPSF = model; + source->type = PM_SOURCE_TYPE_STAR; // XXX this should be added to the flags + + // NOTE: A SEGV here because "model" is NULL is probably caused by not initialising the models. + PAR = model->params->data.F32; + dPAR = model->dparams->data.F32; + + source->seq = psMetadataLookupU32 (&status, row, "IPP_IDET"); + PAR[PM_PAR_XPOS] = psMetadataLookupF32 (&status, row, "X_PSF"); + PAR[PM_PAR_YPOS] = psMetadataLookupF32 (&status, row, "Y_PSF"); + dPAR[PM_PAR_XPOS] = psMetadataLookupF32 (&status, row, "X_PSF_SIG"); + dPAR[PM_PAR_YPOS] = psMetadataLookupF32 (&status, row, "Y_PSF_SIG"); + axes.major = psMetadataLookupF32 (&status, row, "PSF_MAJOR"); + axes.minor = psMetadataLookupF32 (&status, row, "PSF_MINOR"); + axes.theta = psMetadataLookupF32 (&status, row, "PSF_THETA"); + + PAR[PM_PAR_SKY] = psMetadataLookupF32 (&status, row, "SKY"); + dPAR[PM_PAR_SKY] = psMetadataLookupF32 (&status, row, "SKY_SIGMA"); + source->sky = PAR[PM_PAR_SKY]; + source->skyErr = dPAR[PM_PAR_SKY]; + + // XXX use these to determine PAR[PM_PAR_I0]? + source->psfFlux = psMetadataLookupF32 (&status, row, "PSF_INST_FLUX"); + source->psfFluxErr = psMetadataLookupF32 (&status, row, "PSF_INST_FLUX_SIG"); + + source->psfMag = psMetadataLookupF32 (&status, row, "PSF_INST_MAG"); + source->errMag = psMetadataLookupF32 (&status, row, "PSF_INST_MAG_SIG"); + source->apMag = psMetadataLookupF32 (&status, row, "AP_MAG"); + + // XXX this scaling is incorrect: does not include the 2 \pi AREA factor + PAR[PM_PAR_I0] = (isfinite(source->psfMag)) ? pow(10.0, -0.4*source->psfMag) : NAN; + dPAR[PM_PAR_I0] = (isfinite(source->psfMag)) ? PAR[PM_PAR_I0] * source->errMag : NAN; + + pmPSF_AxesToModel (PAR, axes); + + float peakMag = psMetadataLookupF32 (&status, row, "PEAK_FLUX_AS_MAG"); + float peakFlux = (isfinite(peakMag)) ? pow(10.0, -0.4*peakMag) : NAN; + + // recreate the peak to match (xPos, yPos) +/- (xErr, yErr) + source->peak = pmPeakAlloc(PAR[PM_PAR_XPOS], PAR[PM_PAR_YPOS], peakFlux, PM_PEAK_LONE); + source->peak->flux = peakFlux; + source->peak->xf = PAR[PM_PAR_XPOS]; // more accurate position + source->peak->yf = PAR[PM_PAR_YPOS]; // more accurate position + source->peak->dx = dPAR[PM_PAR_XPOS]; + source->peak->dy = dPAR[PM_PAR_YPOS]; + if (isfinite (source->errMag) && (source->errMag > 0.0)) { + source->peak->SN = 1.0 / source->errMag; + } else { + source->peak->SN = sqrt(source->peak->flux); // an alternate proxy: various functions sort by peak S/N + } + + source->pixWeightNotBad = psMetadataLookupF32 (&status, row, "PSF_QF"); + source->pixWeightNotPoor = psMetadataLookupF32 (&status, row, "PSF_QF_PERFECT"); + source->crNsigma = psMetadataLookupF32 (&status, row, "CR_NSIGMA"); + source->extNsigma = psMetadataLookupF32 (&status, row, "EXT_NSIGMA"); + source->apRadius = psMetadataLookupS32 (&status, row, "AP_MAG_RADIUS"); + + // note that some older versions used PSF_PROBABILITY: this was not well defined. + model->chisq = psMetadataLookupF32 (&status, row, "PSF_CHISQ"); + model->nDOF = psMetadataLookupS32 (&status, row, "PSF_NDOF"); + model->nPix = psMetadataLookupS32 (&status, row, "PSF_NPIX"); + + source->moments = pmMomentsAlloc (); + source->moments->Mxx = psMetadataLookupF32 (&status, row, "MOMENTS_XX"); + source->moments->Mxy = psMetadataLookupF32 (&status, row, "MOMENTS_XY"); + source->moments->Myy = psMetadataLookupF32 (&status, row, "MOMENTS_YY"); + + source->mode = psMetadataLookupU32 (&status, row, "FLAGS"); + source->mode2 = psMetadataLookupU32 (&status, row, "FLAGS2"); + assert (status); + + int nPos = psMetadataLookupS32 (&status, row, "DIFF_NPOS"); + if (nPos) { + source->diffStats = pmSourceDiffStatsAlloc(); + source->diffStats->nGood = nPos; + source->diffStats->fRatio = psMetadataLookupF32 (&status, row, "DIFF_FRATIO"); + source->diffStats->nRatioBad = psMetadataLookupF32 (&status, row, "DIFF_NRATIO_BAD"); + source->diffStats->nRatioMask = psMetadataLookupF32 (&status, row, "DIFF_NRATIO_MASK"); + source->diffStats->nRatioAll = psMetadataLookupF32 (&status, row, "DIFF_NRATIO_ALL"); + + source->diffStats->Rp = psMetadataLookupF32 (&status, row, "DIFF_R_P"); + source->diffStats->SNp = psMetadataLookupF32 (&status, row, "DIFF_SN_P"); + source->diffStats->Rm = psMetadataLookupF32 (&status, row, "DIFF_R_M"); + source->diffStats->SNm = psMetadataLookupF32 (&status, row, "DIFF_SN_M"); + } + + sources->data[i] = source; + psFree(row); + } + + return sources; +} + +// XXX this layout is still the same as PS1_DEV_1 +bool pmSourcesWrite_CMF_PS1_DV2_XSRC (psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname, psMetadata *recipe) +{ + + bool status; + psArray *table; + psMetadata *row; + psF32 *PAR, *dPAR; + psF32 xPos, yPos; + psF32 xErr, yErr; + + // create a header to hold the output data + psMetadata *outhead = psMetadataAlloc (); + + // write the links to the image header + psMetadataAddStr (outhead, PS_LIST_TAIL, "EXTNAME", PS_META_REPLACE, "xsrc table extension", extname); + + // let's write these out in S/N order + sources = psArraySort (sources, pmSourceSortBySN); + + table = psArrayAllocEmpty (sources->n); + + // which extended source analyses should we perform? + // bool doPetrosian = psMetadataLookupBool (&status, recipe, "EXTENDED_SOURCE_PETROSIAN"); + // bool doIsophotal = psMetadataLookupBool (&status, recipe, "EXTENDED_SOURCE_ISOPHOTAL"); + // bool doAnnuli = psMetadataLookupBool (&status, recipe, "EXTENDED_SOURCE_ANNULI"); + // bool doKron = psMetadataLookupBool (&status, recipe, "EXTENDED_SOURCE_KRON"); + + psVector *radialBinsLower = psMetadataLookupPtr (&status, recipe, "RADIAL.ANNULAR.BINS.LOWER"); + psVector *radialBinsUpper = psMetadataLookupPtr (&status, recipe, "RADIAL.ANNULAR.BINS.UPPER"); + assert (radialBinsLower->n == radialBinsUpper->n); + + // we write out all sources, regardless of quality. the source flags tell us the state + for (int i = 0; i < sources->n; i++) { + // skip source if it is not a ext sourc + // XXX we have two places that extended source parameters are measured: + // psphotExtendedSources, which measures the aperture-like parameters and (potentially) the psf-convolved extended source models, + // psphotFitEXT, which does the simple extended source model fit (not psf-convolved) + // should we require both? + + pmSource *source = sources->data[i]; + + // skip sources without measurements + if (source->extpars == NULL) continue; + + // we require a PSF model fit (ignore the real crud) + pmModel *model = source->modelPSF; + if (model == NULL) continue; + + // XXX I need to split the extended models from the extended aperture measurements + PAR = model->params->data.F32; + dPAR = model->dparams->data.F32; + xPos = PAR[PM_PAR_XPOS]; + yPos = PAR[PM_PAR_YPOS]; + xErr = dPAR[PM_PAR_XPOS]; + yErr = dPAR[PM_PAR_YPOS]; + + row = psMetadataAlloc (); + + // XXX we are not writing out the mode (flags) or the type (psf, ext, etc) + psMetadataAdd (row, PS_LIST_TAIL, "IPP_IDET", PS_DATA_U32, "IPP detection identifier index", source->seq); + psMetadataAdd (row, PS_LIST_TAIL, "X_EXT", PS_DATA_F32, "EXT model x coordinate", xPos); + psMetadataAdd (row, PS_LIST_TAIL, "Y_EXT", PS_DATA_F32, "EXT model y coordinate", yPos); + psMetadataAdd (row, PS_LIST_TAIL, "X_EXT_SIG", PS_DATA_F32, "Sigma in EXT x coordinate", xErr); + psMetadataAdd (row, PS_LIST_TAIL, "Y_EXT_SIG", PS_DATA_F32, "Sigma in EXT y coordinate", yErr); + +# if (0) + // Petrosian measurements + // XXX insert header data: petrosian ref radius, flux ratio + if (doPetrosian) { + pmSourcePetrosianValues *petrosian = source->extpars->petrosian; + if (petrosian) { + psMetadataAdd (row, PS_LIST_TAIL, "PETRO_MAG", PS_DATA_F32, "Petrosian Magnitude", petrosian->mag); + psMetadataAdd (row, PS_LIST_TAIL, "PETRO_MAG_ERR", PS_DATA_F32, "Petrosian Magnitude Error", petrosian->magErr); + psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS", PS_DATA_F32, "Petrosian Radius", petrosian->rad); + psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS_ERR", PS_DATA_F32, "Petrosian Radius Error", petrosian->radErr); + } else { + psMetadataAdd (row, PS_LIST_TAIL, "PETRO_MAG", PS_DATA_F32, "Petrosian Magnitude", NAN); + psMetadataAdd (row, PS_LIST_TAIL, "PETRO_MAG_ERR", PS_DATA_F32, "Petrosian Magnitude Error", NAN); + psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS", PS_DATA_F32, "Petrosian Radius", NAN); + psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS_ERR", PS_DATA_F32, "Petrosian Radius Error", NAN); + } + } + + // Kron measurements + if (doKron) { + pmSourceKronValues *kron = source->extpars->kron; + if (kron) { + psMetadataAdd (row, PS_LIST_TAIL, "KRON_MAG", PS_DATA_F32, "Kron Magnitude", kron->mag); + psMetadataAdd (row, PS_LIST_TAIL, "KRON_MAG_ERR", PS_DATA_F32, "Kron Magnitude Error", kron->magErr); + psMetadataAdd (row, PS_LIST_TAIL, "KRON_RADIUS", PS_DATA_F32, "Kron Radius", kron->rad); + psMetadataAdd (row, PS_LIST_TAIL, "KRON_RADIUS_ERR", PS_DATA_F32, "Kron Radius Error", kron->radErr); + } else { + psMetadataAdd (row, PS_LIST_TAIL, "KRON_MAG", PS_DATA_F32, "Kron Magnitude", NAN); + psMetadataAdd (row, PS_LIST_TAIL, "KRON_MAG_ERR", PS_DATA_F32, "Kron Magnitude Error", NAN); + psMetadataAdd (row, PS_LIST_TAIL, "KRON_RADIUS", PS_DATA_F32, "Kron Radius", NAN); + psMetadataAdd (row, PS_LIST_TAIL, "KRON_RADIUS_ERR", PS_DATA_F32, "Kron Radius Error", NAN); + } + } + + // Isophot measurements + // XXX insert header data: isophotal level + if (doIsophotal) { + pmSourceIsophotalValues *isophot = source->extpars->isophot; + if (isophot) { + psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_MAG", PS_DATA_F32, "Isophot Magnitude", isophot->mag); + psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_MAG_ERR", PS_DATA_F32, "Isophot Magnitude Error", isophot->magErr); + psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_RADIUS", PS_DATA_F32, "Isophot Radius", isophot->rad); + psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_RADIUS_ERR", PS_DATA_F32, "Isophot Radius Error", isophot->radErr); + } else { + psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_MAG", PS_DATA_F32, "Isophot Magnitude", NAN); + psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_MAG_ERR", PS_DATA_F32, "Isophot Magnitude Error", NAN); + psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_RADIUS", PS_DATA_F32, "Isophot Radius", NAN); + psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_RADIUS_ERR", PS_DATA_F32, "Isophot Radius Error", NAN); + } + } + + // Flux Annuli + if (doAnnuli) { + pmSourceAnnuli *annuli = source->extpars->annuli; + if (annuli) { + psVector *fluxVal = annuli->flux; + psVector *fluxErr = annuli->fluxErr; + psVector *fluxVar = annuli->fluxVar; + + for (int j = 0; j < fluxVal->n; j++) { + char name[32]; + sprintf (name, "FLUX_VAL_R_%02d", j); + psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux value in annulus", fluxVal->data.F32[j]); + sprintf (name, "FLUX_ERR_R_%02d", j); + psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux error in annulus", fluxErr->data.F32[j]); + sprintf (name, "FLUX_VAR_R_%02d", j); + psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux stdev in annulus", fluxVar->data.F32[j]); + } + } else { + for (int j = 0; j < radialBinsLower->n; j++) { + char name[32]; + sprintf (name, "FLUX_VAL_R_%02d", j); + psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux value in annulus", NAN); + sprintf (name, "FLUX_ERR_R_%02d", j); + psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux error in annulus", NAN); + sprintf (name, "FLUX_VAR_R_%02d", j); + psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "flux stdev in annulus", NAN); + } + } + } + +# endif + psArrayAdd (table, 100, row); + psFree (row); + } + + if (table->n == 0) { + psFitsWriteBlank (fits, outhead, extname); + psFree (outhead); + psFree (table); + return true; + } + + psTrace ("pmFPAfile", 5, "writing ext data %s\n", extname); + if (!psFitsWriteTable (fits, outhead, table, extname)) { + psError(PS_ERR_IO, false, "writing ext data %s\n", extname); + psFree (outhead); + psFree(table); + return false; + } + psFree (outhead); + psFree (table); + + return true; +} + +// XXX this layout is still the same as PS1_DEV_1 +bool pmSourcesWrite_CMF_PS1_DV2_XFIT(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname) +{ + + psArray *table; + psMetadata *row; + psF32 *PAR, *dPAR; + psEllipseAxes axes; + psF32 xPos, yPos; + psF32 xErr, yErr; + char name[64]; + + // create a header to hold the output data + psMetadata *outhead = psMetadataAlloc (); + + // write the links to the image header + psMetadataAddStr (outhead, PS_LIST_TAIL, "EXTNAME", PS_META_REPLACE, "xsrc table extension", extname); + + // let's write these out in S/N order + sources = psArraySort (sources, pmSourceSortBySN); + + // we are writing one row per model; we need to write out same number of columns for each row: find the max Nparams + int nParamMax = 0; + for (int i = 0; i < sources->n; i++) { + pmSource *source = sources->data[i]; + if (source->modelFits == NULL) continue; + for (int j = 0; j < source->modelFits->n; j++) { + pmModel *model = source->modelFits->data[j]; + assert (model); + nParamMax = PS_MAX (nParamMax, model->params->n); + } + } + + table = psArrayAllocEmpty (sources->n); + + // we write out all sources, regardless of quality. the source flags tell us the state + for (int i = 0; i < sources->n; i++) { + + pmSource *source = sources->data[i]; + + // XXX if no model fits are saved, write out modelEXT? + if (source->modelFits == NULL) continue; + + // We have multiple sources : need to flag the one used to subtract the light (the 'best' model) + for (int j = 0; j < source->modelFits->n; j++) { + + // choose the convolved EXT model, if available, otherwise the simple one + pmModel *model = source->modelFits->data[j]; + assert (model); + + // skip models which were not actually fitted + if (model->flags & PM_MODEL_STATUS_BADARGS) continue; + + PAR = model->params->data.F32; + dPAR = model->dparams->data.F32; + xPos = PAR[PM_PAR_XPOS]; + yPos = PAR[PM_PAR_YPOS]; + xErr = dPAR[PM_PAR_XPOS]; + yErr = dPAR[PM_PAR_YPOS]; + + axes = pmPSF_ModelToAxes (PAR, 20.0); + + row = psMetadataAlloc (); + + // XXX we are not writing out the mode (flags) or the type (psf, ext, etc) + psMetadataAddU32 (row, PS_LIST_TAIL, "IPP_IDET", 0, "IPP detection identifier index", source->seq); + psMetadataAddF32 (row, PS_LIST_TAIL, "X_EXT", 0, "EXT model x coordinate", xPos); + psMetadataAddF32 (row, PS_LIST_TAIL, "Y_EXT", 0, "EXT model y coordinate", yPos); + psMetadataAddF32 (row, PS_LIST_TAIL, "X_EXT_SIG", 0, "Sigma in EXT x coordinate", xErr); + psMetadataAddF32 (row, PS_LIST_TAIL, "Y_EXT_SIG", 0, "Sigma in EXT y coordinate", yErr); + psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_INST_MAG", 0, "EXT fit instrumental magnitude", model->mag); + psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_INST_MAG_SIG", 0, "Sigma of PSF instrumental magnitude", model->magErr); + + psMetadataAddF32 (row, PS_LIST_TAIL, "NPARAMS", 0, "number of model parameters", model->params->n); + psMetadataAddStr (row, PS_LIST_TAIL, "MODEL_TYPE", 0, "name of model", pmModelClassGetName (model->type)); + + // XXX these should be major and minor, not 'x' and 'y' + psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_WIDTH_MAJ", 0, "EXT width in x coordinate", axes.major); + psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_WIDTH_MIN", 0, "EXT width in y coordinate", axes.minor); + psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_THETA", 0, "EXT orientation angle", axes.theta); + + // write out the other generic parameters + for (int k = 0; k < nParamMax; k++) { + if (k == PM_PAR_I0) continue; + if (k == PM_PAR_SKY) continue; + if (k == PM_PAR_XPOS) continue; + if (k == PM_PAR_YPOS) continue; + if (k == PM_PAR_SXX) continue; + if (k == PM_PAR_SXY) continue; + if (k == PM_PAR_SYY) continue; + + snprintf (name, 64, "EXT_PAR_%02d", k); + + if (k < model->params->n) { + psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "", model->params->data.F32[k]); + } else { + psMetadataAddF32 (row, PS_LIST_TAIL, name, PS_DATA_F32, "", NAN); + } + } + + // XXX other parameters which may be set. + // XXX flag / value to define the model + // XXX write out the model type, fit status flags + + psArrayAdd (table, 100, row); + psFree (row); + } + } + + if (table->n == 0) { + psFitsWriteBlank (fits, outhead, extname); + psFree (outhead); + psFree (table); + return true; + } + + psTrace ("pmFPAfile", 5, "writing ext data %s\n", extname); + if (!psFitsWriteTable (fits, outhead, table, extname)) { + psError(PS_ERR_IO, false, "writing ext data %s\n", extname); + psFree (outhead); + psFree(table); + return false; + } + psFree (outhead); + psFree (table); + return true; +} Index: /trunk/psModules/src/objects/pmSourceIO_CMF_PS1_SV1.c =================================================================== --- /trunk/psModules/src/objects/pmSourceIO_CMF_PS1_SV1.c (revision 29003) +++ /trunk/psModules/src/objects/pmSourceIO_CMF_PS1_SV1.c (revision 29004) @@ -28,15 +28,24 @@ #include "pmFPAfile.h" +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmGrowthCurve.h" -#include "pmResiduals.h" -#include "pmTrend2D.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" #include "pmPSF.h" -#include "pmModel.h" -#include "pmSource.h" -#include "pmModelClass.h" +#include "pmPSFtry.h" + #include "pmSourceIO.h" @@ -46,5 +55,5 @@ // NOTE: this output function is intended for psphotStack analysis: it includes per-psf radial fluxes -// XXX currently in the 'read' function is NOT consistent with the 'write' function (does not read radial fluxes) +// XXX currently, the 'read' function is NOT consistent with the 'write' function (does not read radial fluxes) bool pmSourcesWrite_CMF_PS1_SV1 (psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, psMetadata *tableHeader, char *extname, psMetadata *recipe) @@ -62,4 +71,5 @@ psF32 errMag, chisq, apRadius; psS32 nPix, nDOF; + char keyword1[80], keyword2[80]; pmChip *chip = readout->parent->parent; @@ -95,7 +105,18 @@ // we use this just to define the output vectors (which must be present for all objects) bool status = false; + psVector *radMin = psMetadataLookupPtr (&status, recipe, "RADIAL.ANNULAR.BINS.LOWER"); psVector *radMax = psMetadataLookupPtr (&status, recipe, "RADIAL.ANNULAR.BINS.UPPER"); psAssert (radMax, "this must have been defined and tested earlier!"); psAssert (radMax->n, "this must have been defined and tested earlier!"); + psAssert (radMin->n == radMax->n, "inconsistent annular bins"); + + // write the radial profile apertures to header + for (int i = 0; i < radMax->n; i++) { + sprintf (keyword1, "RMIN_%02d", i); + sprintf (keyword2, "RMAX_%02d", i); + psMetadataAddF32 (imageHeader, PS_LIST_TAIL, keyword1, PS_META_REPLACE, "min radius for SB profile", radMin->data.F32[i]); + psMetadataAddF32 (imageHeader, PS_LIST_TAIL, keyword2, PS_META_REPLACE, "min radius for SB profile", radMax->data.F32[i]); + } + // we write out PSF-fits for all sources, regardless of quality. the source flags tell us the state @@ -193,17 +214,46 @@ psMetadataAdd (row, PS_LIST_TAIL, "PSF_MINOR", PS_DATA_F32, "PSF width (minor axis)", axes.minor); psMetadataAdd (row, PS_LIST_TAIL, "PSF_THETA", PS_DATA_F32, "PSF orientation angle", axes.theta); - psMetadataAdd (row, PS_LIST_TAIL, "PSF_QF", PS_DATA_F32, "PSF coverage/quality factor", source->pixWeight); + psMetadataAdd (row, PS_LIST_TAIL, "PSF_QF", PS_DATA_F32, "PSF coverage/quality factor (bad)", source->pixWeightNotBad); + psMetadataAdd (row, PS_LIST_TAIL, "PSF_QF_PERFECT", PS_DATA_F32, "PSF coverage/quality factor (poor)", source->pixWeightNotPoor); psMetadataAdd (row, PS_LIST_TAIL, "PSF_NDOF", PS_DATA_S32, "degrees of freedom", nDOF); psMetadataAdd (row, PS_LIST_TAIL, "PSF_NPIX", PS_DATA_S32, "number of pixels in fit", nPix); // distinguish moments measure from window vs S/N > XX ?? - float mxx = source->moments ? source->moments->Mxx : NAN; - float mxy = source->moments ? source->moments->Mxy : NAN; - float myy = source->moments ? source->moments->Myy : NAN; - psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_XX", PS_DATA_F32, "second moments (X^2)", mxx); - psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_XY", PS_DATA_F32, "second moments (X*Y)", mxy); - psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_YY", PS_DATA_F32, "second moments (Y*Y)", myy); - - psMetadataAdd (row, PS_LIST_TAIL, "FLAGS", PS_DATA_U32, "psphot analysis flags", source->mode); + float Mxx = source->moments ? source->moments->Mxx : NAN; + float Mxy = source->moments ? source->moments->Mxy : NAN; + float Myy = source->moments ? source->moments->Myy : NAN; + + float Mrf = source->moments ? source->moments->Mrf : NAN; + float Mrh = source->moments ? source->moments->Mrh : NAN; + float Krf = source->moments ? source->moments->KronFlux : NAN; + float dKrf = source->moments ? source->moments->KronFluxErr : NAN; + + float Kinner = source->moments ? source->moments->KronFinner : NAN; + float Kouter = source->moments ? source->moments->KronFouter : NAN; + + float M_c3 = source->moments ? 1.0*source->moments->Mxxx - 3.0*source->moments->Mxyy : NAN; + float M_s3 = source->moments ? 3.0*source->moments->Mxxy - 1.0*source->moments->Myyy : NAN; + float M_c4 = source->moments ? 1.0*source->moments->Mxxxx - 6.0*source->moments->Mxxyy + 1.0*source->moments->Myyyy : NAN; + float M_s4 = source->moments ? 4.0*source->moments->Mxxxy - 4.0*source->moments->Mxyyy : NAN; + + psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_XX", PS_DATA_F32, "second moments (X^2)", Mxx); + psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_XY", PS_DATA_F32, "second moments (X*Y)", Mxy); + psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_YY", PS_DATA_F32, "second moments (Y*Y)", Myy); + + psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_M3C", PS_DATA_F32, "third momemt cos theta", M_c3); + psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_M3S", PS_DATA_F32, "third momemt sin theta", M_s3); + psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_M4C", PS_DATA_F32, "fourth momemt cos theta", M_c4); + psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_M4S", PS_DATA_F32, "fourth momemt sin theta", M_s4); + + psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_R1", PS_DATA_F32, "first radial moment", Mrf); + psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_RH", PS_DATA_F32, "half radial moment", Mrh); + psMetadataAdd (row, PS_LIST_TAIL, "KRON_FLUX", PS_DATA_F32, "Kron Flux (in 2.5 R1)", Krf); + psMetadataAdd (row, PS_LIST_TAIL, "KRON_FLUX_ERR", PS_DATA_F32, "Kron Flux Error", dKrf); + + psMetadataAdd (row, PS_LIST_TAIL, "KRON_FLUX_INNER", PS_DATA_F32, "Kron Flux (in 2.5 R1)", Kinner); + psMetadataAdd (row, PS_LIST_TAIL, "KRON_FLUX_OUTER", PS_DATA_F32, "Kron Flux (in 2.5 R1)", Kouter); + + psMetadataAdd (row, PS_LIST_TAIL, "FLAGS", PS_DATA_U32, "psphot analysis flags", source->mode); + psMetadataAdd (row, PS_LIST_TAIL, "FLAGS2", PS_DATA_U32, "psphot analysis flags", source->mode2); psVector *radFlux = psVectorAlloc(radMax->n, PS_TYPE_F32); @@ -352,9 +402,16 @@ source->peak = pmPeakAlloc(PAR[PM_PAR_XPOS], PAR[PM_PAR_YPOS], peakFlux, PM_PEAK_LONE); source->peak->flux = peakFlux; + source->peak->xf = PAR[PM_PAR_XPOS]; // more accurate position + source->peak->yf = PAR[PM_PAR_YPOS]; // more accurate position source->peak->dx = dPAR[PM_PAR_XPOS]; source->peak->dy = dPAR[PM_PAR_YPOS]; - source->peak->SN = sqrt(source->peak->flux); // XXX a proxy: various functions sort by peak S/N - - source->pixWeight = psMetadataLookupF32 (&status, row, "PSF_QF"); + if (isfinite (source->errMag) && (source->errMag > 0.0)) { + source->peak->SN = 1.0 / source->errMag; + } else { + source->peak->SN = sqrt(source->peak->flux); // an alternate proxy: various functions sort by peak S/N + } + + source->pixWeightNotBad = psMetadataLookupF32 (&status, row, "PSF_QF"); + source->pixWeightNotPoor = psMetadataLookupF32 (&status, row, "PSF_QF_PERFECT"); source->crNsigma = psMetadataLookupF32 (&status, row, "CR_NSIGMA"); source->extNsigma = psMetadataLookupF32 (&status, row, "EXT_NSIGMA"); @@ -371,5 +428,27 @@ source->moments->Myy = psMetadataLookupF32 (&status, row, "MOMENTS_YY"); + source->moments->Mrf = psMetadataLookupF32 (&status, row, "MOMENTS_R1"); + source->moments->Mrh = psMetadataLookupF32 (&status, row, "MOMENTS_RH"); + source->moments->KronFlux = psMetadataLookupF32 (&status, row, "KRON_FLUX"); + source->moments->KronFluxErr = psMetadataLookupF32 (&status, row, "KRON_FLUX_ERR"); + + source->moments->KronFinner = psMetadataLookupF32 (&status, row, "KRON_FLUX_INNER"); + source->moments->KronFouter = psMetadataLookupF32 (&status, row, "KRON_FLUX_OUTER"); + + // XXX we do not save all of the 3rd and 4th moment parameters. when we load in data, + // we are storing enough information so the output will be consistent with the input + source->moments->Mxxx = +1.0 * psMetadataLookupF32 (&status, row, "MOMENTS_M3C"); + source->moments->Mxxy = 0.0; + source->moments->Mxyy = 0.0; + source->moments->Myyy = -1.0 * psMetadataLookupF32 (&status, row, "MOMENTS_M3S"); + + source->moments->Mxxxx = +1.00 * psMetadataLookupF32 (&status, row, "MOMENTS_M4C"); + source->moments->Mxxxy = 0.0; + source->moments->Mxxyy = 0.0; + source->moments->Mxyyy = -0.25 * psMetadataLookupF32 (&status, row, "MOMENTS_M4S"); + source->moments->Myyyy = 0.0; + source->mode = psMetadataLookupU32 (&status, row, "FLAGS"); + source->mode2 = psMetadataLookupU32 (&status, row, "FLAGS2"); assert (status); @@ -391,4 +470,5 @@ psF32 xErr, yErr; int nRow = -1; + char keyword1[80], keyword2[80]; // create a header to hold the output data @@ -422,6 +502,4 @@ bool doAnnuli = psMetadataLookupBool (&status, recipe, "EXTENDED_SOURCE_ANNULI"); bool doPetrosian = psMetadataLookupBool (&status, recipe, "EXTENDED_SOURCE_PETROSIAN"); - // bool doIsophotal = psMetadataLookupBool (&status, recipe, "EXTENDED_SOURCE_ISOPHOTAL"); - // bool doKron = psMetadataLookupBool (&status, recipe, "EXTENDED_SOURCE_KRON"); psVector *radMin = psMetadataLookupPtr (&status, recipe, "RADIAL.ANNULAR.BINS.LOWER"); @@ -429,24 +507,14 @@ psAssert (radMin->n == radMax->n, "inconsistent annular bins"); - // int nRadialBins = 0; - // if (doAnnuli) { - // // get the max count of radial bins - // for (int i = 0; i < sources->n; i++) { - // pmSource *source = sources->data[i]; - // if (!source->extpars) continue; - // if (!source->extpars->radProfile ) continue; - // if (!source->extpars->radProfile->binSB) continue; - // nRadialBins = PS_MAX(nRadialBins, source->extpars->radProfile->binSB->n); - // } - // } + // write the radial profile apertures to header + for (int i = 0; i < radMax->n; i++) { + sprintf (keyword1, "RMIN_%02d", i); + sprintf (keyword2, "RMAX_%02d", i); + psMetadataAddF32 (outhead, PS_LIST_TAIL, keyword1, PS_META_REPLACE, "min radius for SB profile", radMin->data.F32[i]); + psMetadataAddF32 (outhead, PS_LIST_TAIL, keyword2, PS_META_REPLACE, "min radius for SB profile", radMax->data.F32[i]); + } // we write out all sources, regardless of quality. the source flags tell us the state for (int i = 0; i < sources->n; i++) { - // skip source if it is not a ext sourc - // XXX we have two places that extended source parameters are measured: - // psphotExtendedSources, which measures the aperture-like parameters and (potentially) the psf-convolved extended source models, - // psphotFitEXT, which does the simple extended source model fit (not psf-convolved) - // should we require both? - pmSource *source = sources->data[i]; @@ -514,39 +582,4 @@ } -# if (0) - // Kron measurements - if (doKron) { - pmSourceKronValues *kron = source->extpars->kron; - if (kron) { - psMetadataAdd (row, PS_LIST_TAIL, "KRON_MAG", PS_DATA_F32, "Kron Magnitude", kron->mag); - psMetadataAdd (row, PS_LIST_TAIL, "KRON_MAG_ERR", PS_DATA_F32, "Kron Magnitude Error", kron->magErr); - psMetadataAdd (row, PS_LIST_TAIL, "KRON_RADIUS", PS_DATA_F32, "Kron Radius", kron->rad); - psMetadataAdd (row, PS_LIST_TAIL, "KRON_RADIUS_ERR", PS_DATA_F32, "Kron Radius Error", kron->radErr); - } else { - psMetadataAdd (row, PS_LIST_TAIL, "KRON_MAG", PS_DATA_F32, "Kron Magnitude", NAN); - psMetadataAdd (row, PS_LIST_TAIL, "KRON_MAG_ERR", PS_DATA_F32, "Kron Magnitude Error", NAN); - psMetadataAdd (row, PS_LIST_TAIL, "KRON_RADIUS", PS_DATA_F32, "Kron Radius", NAN); - psMetadataAdd (row, PS_LIST_TAIL, "KRON_RADIUS_ERR", PS_DATA_F32, "Kron Radius Error", NAN); - } - } - - // Isophot measurements - // XXX insert header data: isophotal level - if (doIsophotal) { - pmSourceIsophotalValues *isophot = source->extpars->isophot; - if (isophot) { - psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_MAG", PS_DATA_F32, "Isophot Magnitude", isophot->mag); - psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_MAG_ERR", PS_DATA_F32, "Isophot Magnitude Error", isophot->magErr); - psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_RADIUS", PS_DATA_F32, "Isophot Radius", isophot->rad); - psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_RADIUS_ERR", PS_DATA_F32, "Isophot Radius Error", isophot->radErr); - } else { - psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_MAG", PS_DATA_F32, "Isophot Magnitude", NAN); - psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_MAG_ERR", PS_DATA_F32, "Isophot Magnitude Error", NAN); - psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_RADIUS", PS_DATA_F32, "Isophot Radius", NAN); - psMetadataAdd (row, PS_LIST_TAIL, "ISOPHOT_RADIUS_ERR", PS_DATA_F32, "Isophot Radius Error", NAN); - } - } -# endif - // Flux Annuli (if we have extended source measurements, we have these. only optionally save them) if (doAnnuli) { @@ -616,5 +649,5 @@ // XXX this layout is still the same as PS1_DEV_1 -bool pmSourcesWrite_CMF_PS1_SV1_XFIT (psFits *fits, pmReadout *readout, psArray *sources, char *extname) +bool pmSourcesWrite_CMF_PS1_SV1_XFIT(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname) { @@ -665,4 +698,7 @@ assert (model); + // skip models which were not actually fitted + if (model->flags & PM_MODEL_STATUS_BADARGS) continue; + PAR = model->params->data.F32; dPAR = model->dparams->data.F32; Index: /trunk/psModules/src/objects/pmSourceIO_CMF_PS1_V1.c =================================================================== --- /trunk/psModules/src/objects/pmSourceIO_CMF_PS1_V1.c (revision 29003) +++ /trunk/psModules/src/objects/pmSourceIO_CMF_PS1_V1.c (revision 29004) @@ -28,15 +28,24 @@ #include "pmFPAfile.h" +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmGrowthCurve.h" -#include "pmResiduals.h" -#include "pmTrend2D.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" #include "pmPSF.h" -#include "pmModel.h" -#include "pmSource.h" -#include "pmModelClass.h" +#include "pmPSFtry.h" + #include "pmSourceIO.h" @@ -45,6 +54,5 @@ // followed by a zero-size matrix, followed by the table data -bool pmSourcesWrite_CMF_PS1_V1 (psFits *fits, pmReadout *readout, psArray *sources, - psMetadata *imageHeader, psMetadata *tableHeader, char *extname) +bool pmSourcesWrite_CMF_PS1_V1 (psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, psMetadata *tableHeader, char *extname, psMetadata *recipe) { PS_ASSERT_PTR_NON_NULL(fits, false); @@ -184,5 +192,5 @@ psMetadataAdd (row, PS_LIST_TAIL, "PSF_MINOR", PS_DATA_F32, "PSF width (minor axis)", axes.minor); psMetadataAdd (row, PS_LIST_TAIL, "PSF_THETA", PS_DATA_F32, "PSF orientation angle", axes.theta); - psMetadataAdd (row, PS_LIST_TAIL, "PSF_QF", PS_DATA_F32, "PSF coverage/quality factor", source->pixWeight); + psMetadataAdd (row, PS_LIST_TAIL, "PSF_QF", PS_DATA_F32, "PSF coverage/quality factor", source->pixWeightNotBad); psMetadataAdd (row, PS_LIST_TAIL, "PSF_NDOF", PS_DATA_S32, "degrees of freedom", nDOF); psMetadataAdd (row, PS_LIST_TAIL, "PSF_NPIX", PS_DATA_S32, "number of pixels in fit", nPix); @@ -310,8 +318,15 @@ source->peak = pmPeakAlloc(PAR[PM_PAR_XPOS], PAR[PM_PAR_YPOS], peakFlux, PM_PEAK_LONE); source->peak->flux = peakFlux; + source->peak->xf = PAR[PM_PAR_XPOS]; // more accurate position + source->peak->yf = PAR[PM_PAR_YPOS]; // more accurate position source->peak->dx = dPAR[PM_PAR_XPOS]; source->peak->dy = dPAR[PM_PAR_YPOS]; - - source->pixWeight = psMetadataLookupF32 (&status, row, "PSF_QF"); + if (isfinite (source->errMag) && (source->errMag > 0.0)) { + source->peak->SN = 1.0 / source->errMag; + } else { + source->peak->SN = sqrt(source->peak->flux); // an alternate proxy: various functions sort by peak S/N + } + + source->pixWeightNotBad = psMetadataLookupF32 (&status, row, "PSF_QF"); source->crNsigma = psMetadataLookupF32 (&status, row, "CR_NSIGMA"); source->extNsigma = psMetadataLookupF32 (&status, row, "EXT_NSIGMA"); @@ -516,5 +531,5 @@ // XXX this layout is still the same as PS1_DEV_1 -bool pmSourcesWrite_CMF_PS1_V1_XFIT (psFits *fits, pmReadout *readout, psArray *sources, char *extname) +bool pmSourcesWrite_CMF_PS1_V1_XFIT(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname) { @@ -565,4 +580,7 @@ assert (model); + // skip models which were not actually fitted + if (model->flags & PM_MODEL_STATUS_BADARGS) continue; + PAR = model->params->data.F32; dPAR = model->dparams->data.F32; Index: /trunk/psModules/src/objects/pmSourceIO_CMF_PS1_V2.c =================================================================== --- /trunk/psModules/src/objects/pmSourceIO_CMF_PS1_V2.c (revision 29003) +++ /trunk/psModules/src/objects/pmSourceIO_CMF_PS1_V2.c (revision 29004) @@ -28,15 +28,24 @@ #include "pmFPAfile.h" +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmGrowthCurve.h" -#include "pmResiduals.h" -#include "pmTrend2D.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" #include "pmPSF.h" -#include "pmModel.h" -#include "pmSource.h" -#include "pmModelClass.h" +#include "pmPSFtry.h" + #include "pmSourceIO.h" @@ -45,5 +54,5 @@ // followed by a zero-size matrix, followed by the table data -bool pmSourcesWrite_CMF_PS1_V2 (psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, psMetadata *tableHeader, char *extname) +bool pmSourcesWrite_CMF_PS1_V2 (psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, psMetadata *tableHeader, char *extname, psMetadata *recipe) { PS_ASSERT_PTR_NON_NULL(fits, false); @@ -182,5 +191,5 @@ psMetadataAdd (row, PS_LIST_TAIL, "PSF_MINOR", PS_DATA_F32, "PSF width (minor axis)", axes.minor); psMetadataAdd (row, PS_LIST_TAIL, "PSF_THETA", PS_DATA_F32, "PSF orientation angle", axes.theta); - psMetadataAdd (row, PS_LIST_TAIL, "PSF_QF", PS_DATA_F32, "PSF coverage/quality factor", source->pixWeight); + psMetadataAdd (row, PS_LIST_TAIL, "PSF_QF", PS_DATA_F32, "PSF coverage/quality factor", source->pixWeightNotBad); psMetadataAdd (row, PS_LIST_TAIL, "PSF_NDOF", PS_DATA_S32, "degrees of freedom", nDOF); psMetadataAdd (row, PS_LIST_TAIL, "PSF_NPIX", PS_DATA_S32, "number of pixels in fit", nPix); @@ -314,9 +323,15 @@ source->peak = pmPeakAlloc(PAR[PM_PAR_XPOS], PAR[PM_PAR_YPOS], peakFlux, PM_PEAK_LONE); source->peak->flux = peakFlux; + source->peak->xf = PAR[PM_PAR_XPOS]; // more accurate position + source->peak->yf = PAR[PM_PAR_YPOS]; // more accurate position source->peak->dx = dPAR[PM_PAR_XPOS]; source->peak->dy = dPAR[PM_PAR_YPOS]; - source->peak->SN = sqrt(source->peak->flux); // XXX a proxy: various functions sort by peak S/N - - source->pixWeight = psMetadataLookupF32 (&status, row, "PSF_QF"); + if (isfinite (source->errMag) && (source->errMag > 0.0)) { + source->peak->SN = 1.0 / source->errMag; + } else { + source->peak->SN = sqrt(source->peak->flux); // an alternate proxy: various functions sort by peak S/N + } + + source->pixWeightNotBad = psMetadataLookupF32 (&status, row, "PSF_QF"); source->crNsigma = psMetadataLookupF32 (&status, row, "CR_NSIGMA"); source->extNsigma = psMetadataLookupF32 (&status, row, "EXT_NSIGMA"); @@ -578,5 +593,5 @@ // XXX this layout is still the same as PS1_DEV_1 -bool pmSourcesWrite_CMF_PS1_V2_XFIT (psFits *fits, pmReadout *readout, psArray *sources, char *extname) +bool pmSourcesWrite_CMF_PS1_V2_XFIT(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname) { @@ -627,4 +642,7 @@ assert (model); + // skip models which were not actually fitted + if (model->flags & PM_MODEL_STATUS_BADARGS) continue; + PAR = model->params->data.F32; dPAR = model->dparams->data.F32; Index: /trunk/psModules/src/objects/pmSourceIO_CMF_PS1_V3.c =================================================================== --- /trunk/psModules/src/objects/pmSourceIO_CMF_PS1_V3.c (revision 29004) +++ /trunk/psModules/src/objects/pmSourceIO_CMF_PS1_V3.c (revision 29004) @@ -0,0 +1,732 @@ +/** @file pmSourceIO.c + * + * @author EAM, IfA + * + * @version $Revision: 1.3 $ $Name: not supported by cvs2svn $ + * @date $Date: 2009-02-18 02:44:19 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + * + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include +#include +#include +#include + +#include "pmConfig.h" +#include "pmDetrendDB.h" + +#include "pmHDU.h" +#include "pmFPA.h" +#include "pmFPALevel.h" +#include "pmFPAview.h" +#include "pmFPAfile.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" +#include "pmSpan.h" +#include "pmFootprintSpans.h" +#include "pmFootprint.h" +#include "pmPeaks.h" +#include "pmMoments.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" +#include "pmPSF.h" +#include "pmPSFtry.h" + +#include "pmSourceIO.h" + +// panstarrs-style FITS table output (header + table in 1st extension) +// this format consists of a header derived from the image header +// followed by a zero-size matrix, followed by the table data + +bool pmSourcesWrite_CMF_PS1_V3 (psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, psMetadata *tableHeader, char *extname, psMetadata *recipe) +{ + PS_ASSERT_PTR_NON_NULL(fits, false); + PS_ASSERT_PTR_NON_NULL(sources, false); + PS_ASSERT_PTR_NON_NULL(extname, false); + + psArray *table; + psMetadata *row; + psF32 *PAR, *dPAR; + psEllipseAxes axes; + psF32 xPos, yPos; + psF32 xErr, yErr; + psF32 errMag, chisq, apRadius; + psS32 nPix, nDOF; + + pmChip *chip = readout->parent->parent; + pmFPA *fpa = chip->parent; + + bool status1 = false; + bool status2 = false; + float magOffset = NAN; + float exptime = psMetadataLookupF32 (&status1, fpa->concepts, "FPA.EXPOSURE"); + float zeropt = psMetadataLookupF32(&status2, fpa->concepts, "FPA.ZP"); + if (!isfinite(zeropt)) { + zeropt = psMetadataLookupF32 (&status2, imageHeader, "ZPT_OBS"); + } + if (status1 && status2 && (exptime > 0.0)) { + magOffset = zeropt + 2.5*log10(exptime); + } + float zeroptErr = psMetadataLookupF32 (&status2, imageHeader, "ZPT_ERR"); + + // if the sequence is defined, write these in seq order; otherwise + // write them in S/N order: + if (sources->n > 0) { + pmSource *source = (pmSource *) sources->data[0]; + if (source->seq == -1) { + // let's write these out in S/N order + sources = psArraySort (sources, pmSourceSortBySN); + } else { + sources = psArraySort (sources, pmSourceSortBySeq); + } + } + + table = psArrayAllocEmpty (sources->n); + + // we write out PSF-fits for all sources, regardless of quality. the source flags tell us the state + // by the time we call this function, all values should be assigned. let's use asserts to be sure in some cases. + for (int i = 0; i < sources->n; i++) { + pmSource *source = (pmSource *) sources->data[i]; + + // If source->seq is -1, source was generated in this analysis. If source->seq is + // not -1, source was read from elsewhere: in the latter case, preserve the source + // ID. source.seq is used instead of source.id since the latter is a const + // generated on Alloc, and would thus be wrong for read in sources. + if (source->seq == -1) { + source->seq = i; + } + + // no difference between PSF and non-PSF model + pmModel *model = source->modelPSF; + + if (model != NULL) { + PAR = model->params->data.F32; + dPAR = model->dparams->data.F32; + xPos = PAR[PM_PAR_XPOS]; + yPos = PAR[PM_PAR_YPOS]; + if (source->mode & PM_SOURCE_MODE_NONLINEAR_FIT) { + xErr = dPAR[PM_PAR_XPOS]; + yErr = dPAR[PM_PAR_YPOS]; + } else { + // in linear-fit mode, there is no error on the centroid + xErr = source->peak->dx; + yErr = source->peak->dy; + } + if (isfinite(PAR[PM_PAR_SXX]) && isfinite(PAR[PM_PAR_SXX]) && isfinite(PAR[PM_PAR_SXX])) { + axes = pmPSF_ModelToAxes (PAR, 20.0); + } else { + axes.major = NAN; + axes.minor = NAN; + axes.theta = NAN; + } + chisq = model->chisq; + nDOF = model->nDOF; + nPix = model->nPix; + apRadius = source->apRadius; + errMag = model->dparams->data.F32[PM_PAR_I0] / model->params->data.F32[PM_PAR_I0]; + } else { + xPos = source->peak->xf; + yPos = source->peak->yf; + xErr = source->peak->dx; + yErr = source->peak->dy; + axes.major = NAN; + axes.minor = NAN; + axes.theta = NAN; + chisq = NAN; + nDOF = 0; + nPix = 0; + apRadius = NAN; + errMag = NAN; + } + + float calMag = isfinite(magOffset) ? source->psfMag + magOffset : NAN; + float peakMag = (source->peak->flux > 0) ? -2.5*log10(source->peak->flux) : NAN; + psS16 nImageOverlap = 1; + + psSphere ptSky = {0.0, 0.0, 0.0, 0.0}; + float posAngle = 0.0; + float pltScale = 0.0; + pmSourceLocalAstrometry (&ptSky, &posAngle, &pltScale, chip, xPos, yPos); + + row = psMetadataAlloc (); + psMetadataAdd (row, PS_LIST_TAIL, "IPP_IDET", PS_DATA_U32, "IPP detection identifier index", source->seq); + psMetadataAdd (row, PS_LIST_TAIL, "X_PSF", PS_DATA_F32, "PSF x coordinate", xPos); + psMetadataAdd (row, PS_LIST_TAIL, "Y_PSF", PS_DATA_F32, "PSF y coordinate", yPos); + psMetadataAdd (row, PS_LIST_TAIL, "X_PSF_SIG", PS_DATA_F32, "Sigma in PSF x coordinate", xErr); // XXX this is only measured for non-linear fits + psMetadataAdd (row, PS_LIST_TAIL, "Y_PSF_SIG", PS_DATA_F32, "Sigma in PSF y coordinate", yErr); // XXX this is only measured for non-linear fits + psMetadataAdd (row, PS_LIST_TAIL, "POSANGLE", PS_DATA_F32, "position angle at source (degrees)", posAngle*PS_DEG_RAD); + psMetadataAdd (row, PS_LIST_TAIL, "PLTSCALE", PS_DATA_F32, "plate scale at source (arcsec/pixel)", pltScale*PS_DEG_RAD*3600.0); + psMetadataAdd (row, PS_LIST_TAIL, "PSF_INST_MAG", PS_DATA_F32, "PSF fit instrumental magnitude", source->psfMag); + psMetadataAdd (row, PS_LIST_TAIL, "PSF_INST_MAG_SIG", PS_DATA_F32, "Sigma of PSF instrumental magnitude", errMag); + psMetadataAdd (row, PS_LIST_TAIL, "PSF_INST_FLUX", PS_DATA_F32, "PSF fit instrumental flux (counts)", source->psfFlux); + psMetadataAdd (row, PS_LIST_TAIL, "PSF_INST_FLUX_SIG",PS_DATA_F32, "Sigma of PSF instrumental flux", source->psfFluxErr); + psMetadataAdd (row, PS_LIST_TAIL, "AP_MAG", PS_DATA_F32, "magnitude in standard aperture", source->apMag); + psMetadataAdd (row, PS_LIST_TAIL, "AP_MAG_RADIUS", PS_DATA_F32, "radius used for aperture mags", apRadius); + psMetadataAdd (row, PS_LIST_TAIL, "PEAK_FLUX_AS_MAG", PS_DATA_F32, "Peak flux expressed as magnitude", peakMag); + psMetadataAdd (row, PS_LIST_TAIL, "CAL_PSF_MAG", PS_DATA_F32, "PSF Magnitude using supplied calibration", calMag); + psMetadataAdd (row, PS_LIST_TAIL, "CAL_PSF_MAG_SIG", PS_DATA_F32, "measured scatter of zero point calibration", zeroptErr); + psMetadataAdd (row, PS_LIST_TAIL, "RA_PSF", PS_DATA_F64, "PSF RA coordinate (degrees)", ptSky.r*PS_DEG_RAD); + psMetadataAdd (row, PS_LIST_TAIL, "DEC_PSF", PS_DATA_F64, "PSF DEC coordinate (degrees)", ptSky.d*PS_DEG_RAD); + psMetadataAdd (row, PS_LIST_TAIL, "SKY", PS_DATA_F32, "Sky level", source->sky); + psMetadataAdd (row, PS_LIST_TAIL, "SKY_SIGMA", PS_DATA_F32, "Sigma of sky level", source->skyErr); + + psMetadataAdd (row, PS_LIST_TAIL, "PSF_CHISQ", PS_DATA_F32, "Chisq of PSF-fit", chisq); + psMetadataAdd (row, PS_LIST_TAIL, "CR_NSIGMA", PS_DATA_F32, "Nsigma deviations from PSF to CF", source->crNsigma); + psMetadataAdd (row, PS_LIST_TAIL, "EXT_NSIGMA", PS_DATA_F32, "Nsigma deviations from PSF to EXT", source->extNsigma); + + psMetadataAdd (row, PS_LIST_TAIL, "PSF_MAJOR", PS_DATA_F32, "PSF width (major axis)", axes.major); + psMetadataAdd (row, PS_LIST_TAIL, "PSF_MINOR", PS_DATA_F32, "PSF width (minor axis)", axes.minor); + psMetadataAdd (row, PS_LIST_TAIL, "PSF_THETA", PS_DATA_F32, "PSF orientation angle", axes.theta); + psMetadataAdd (row, PS_LIST_TAIL, "PSF_QF", PS_DATA_F32, "PSF coverage/quality factor (bad)", source->pixWeightNotBad); + psMetadataAdd (row, PS_LIST_TAIL, "PSF_QF_PERFECT", PS_DATA_F32, "PSF coverage/quality factor (poor)", source->pixWeightNotPoor); + psMetadataAdd (row, PS_LIST_TAIL, "PSF_NDOF", PS_DATA_S32, "degrees of freedom", nDOF); + psMetadataAdd (row, PS_LIST_TAIL, "PSF_NPIX", PS_DATA_S32, "number of pixels in fit", nPix); + + // distinguish moments measure from window vs S/N > XX ?? + float Mxx = source->moments ? source->moments->Mxx : NAN; + float Mxy = source->moments ? source->moments->Mxy : NAN; + float Myy = source->moments ? source->moments->Myy : NAN; + + float Mrf = source->moments ? source->moments->Mrf : NAN; + float Mrh = source->moments ? source->moments->Mrh : NAN; + float Krf = source->moments ? source->moments->KronFlux : NAN; + float dKrf = source->moments ? source->moments->KronFluxErr : NAN; + + float Kinner = source->moments ? source->moments->KronFinner : NAN; + float Kouter = source->moments ? source->moments->KronFouter : NAN; + + float M_c3 = source->moments ? 1.0*source->moments->Mxxx - 3.0*source->moments->Mxyy : NAN; + float M_s3 = source->moments ? 3.0*source->moments->Mxxy - 1.0*source->moments->Myyy : NAN; + float M_c4 = source->moments ? 1.0*source->moments->Mxxxx - 6.0*source->moments->Mxxyy + 1.0*source->moments->Myyyy : NAN; + float M_s4 = source->moments ? 4.0*source->moments->Mxxxy - 4.0*source->moments->Mxyyy : NAN; + + psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_XX", PS_DATA_F32, "second moments (X^2)", Mxx); + psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_XY", PS_DATA_F32, "second moments (X*Y)", Mxy); + psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_YY", PS_DATA_F32, "second moments (Y*Y)", Myy); + + psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_M3C", PS_DATA_F32, "third momemt cos theta", M_c3); + psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_M3S", PS_DATA_F32, "third momemt sin theta", M_s3); + psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_M4C", PS_DATA_F32, "fourth momemt cos theta", M_c4); + psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_M4S", PS_DATA_F32, "fourth momemt sin theta", M_s4); + + psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_R1", PS_DATA_F32, "first radial moment", Mrf); + psMetadataAdd (row, PS_LIST_TAIL, "MOMENTS_RH", PS_DATA_F32, "half radial moment", Mrh); + psMetadataAdd (row, PS_LIST_TAIL, "KRON_FLUX", PS_DATA_F32, "Kron Flux (in 2.5 R1)", Krf); + psMetadataAdd (row, PS_LIST_TAIL, "KRON_FLUX_ERR", PS_DATA_F32, "Kron Flux Error", dKrf); + + psMetadataAdd (row, PS_LIST_TAIL, "KRON_FLUX_INNER", PS_DATA_F32, "Kron Flux (in 2.5 R1)", Kinner); + psMetadataAdd (row, PS_LIST_TAIL, "KRON_FLUX_OUTER", PS_DATA_F32, "Kron Flux (in 2.5 R1)", Kouter); + + psMetadataAdd (row, PS_LIST_TAIL, "FLAGS", PS_DATA_U32, "psphot analysis flags", source->mode); + psMetadataAdd (row, PS_LIST_TAIL, "FLAGS2", PS_DATA_U32, "psphot analysis flags", source->mode2); + + // XXX not sure how to get this : need to load Nimages with weight? + psMetadataAdd (row, PS_LIST_TAIL, "N_FRAMES", PS_DATA_U16, "Number of frames overlapping source center", nImageOverlap); + psMetadataAdd (row, PS_LIST_TAIL, "PADDING", PS_DATA_S16, "padding", 0); + + psArrayAdd (table, 100, row); + psFree (row); + + // EXT_NSIGMA will be NAN if: 1) contour ellipse is imaginary; 2) source is not + // subtracted + + // CR_NSIGMA will be NAN if: 1) source is not subtracted; 2) source is on the image + // edge; 3) any pixels in the 3x3 peak region are masked; + } + + // XXX why do we make a copy here to be supplemented with the masks? why not do this in the calling function? + psMetadata *header = psMetadataCopy(NULL, tableHeader); + pmSourceMasksHeader(header); + + if (table->n == 0) { + if (!psFitsWriteBlank(fits, header, extname)) { + psError(psErrorCodeLast(), false, "Unable to write blank sources file."); + psFree(table); + psFree(header); + return false; + } + psFree(table); + psFree(header); + return true; + } + + psTrace ("pmFPAfile", 5, "writing ext data %s\n", extname); + if (!psFitsWriteTable(fits, header, table, extname)) { + psError(psErrorCodeLast(), false, "writing ext data %s\n", extname); + psFree(table); + psFree(header); + return false; + } + psFree(table); + psFree(header); + + return true; +} + +// read in a readout from the fits file +psArray *pmSourcesRead_CMF_PS1_V3 (psFits *fits, psMetadata *header) +{ + PS_ASSERT_PTR_NON_NULL(fits, false); + PS_ASSERT_PTR_NON_NULL(header, false); + + bool status; + psF32 *PAR, *dPAR; + psEllipseAxes axes; + + // define PSF model type + // XXX need to carry the extra model parameters + int modelType = pmModelClassGetType ("PS_MODEL_GAUSS"); + + char *PSF_NAME = psMetadataLookupStr (&status, header, "PSF_NAME"); + if (PSF_NAME != NULL) { + modelType = pmModelClassGetType (PSF_NAME); + } + assert (modelType > -1); + + // We get the size of the table, and allocate the array of sources first because the table + // is large and ephemeral --- when the table gets blown away, whatever is allocated after + // the table is read blocks the free. In fact, it's better to read the table row by row. + long numSources = psFitsTableSize(fits); // Number of sources in table + psArray *sources = psArrayAlloc(numSources); // Array of sources, to return + + // convert the table to the pmSource entriesa + for (int i = 0; i < numSources; i++) { + psMetadata *row = psFitsReadTableRow(fits, i); // Table row + if (!row) { + psError(psErrorCodeLast(), false, "Unable to read row %d of sources", i); + psFree(sources); + return NULL; + } + + pmSource *source = pmSourceAlloc (); + pmModel *model = pmModelAlloc (modelType); + source->modelPSF = model; + source->type = PM_SOURCE_TYPE_STAR; // XXX this should be added to the flags + + // NOTE: A SEGV here because "model" is NULL is probably caused by not initialising the models. + PAR = model->params->data.F32; + dPAR = model->dparams->data.F32; + + source->seq = psMetadataLookupU32 (&status, row, "IPP_IDET"); + PAR[PM_PAR_XPOS] = psMetadataLookupF32 (&status, row, "X_PSF"); + PAR[PM_PAR_YPOS] = psMetadataLookupF32 (&status, row, "Y_PSF"); + dPAR[PM_PAR_XPOS] = psMetadataLookupF32 (&status, row, "X_PSF_SIG"); + dPAR[PM_PAR_YPOS] = psMetadataLookupF32 (&status, row, "Y_PSF_SIG"); + axes.major = psMetadataLookupF32 (&status, row, "PSF_MAJOR"); + axes.minor = psMetadataLookupF32 (&status, row, "PSF_MINOR"); + axes.theta = psMetadataLookupF32 (&status, row, "PSF_THETA"); + + PAR[PM_PAR_SKY] = psMetadataLookupF32 (&status, row, "SKY"); + dPAR[PM_PAR_SKY] = psMetadataLookupF32 (&status, row, "SKY_SIGMA"); + source->sky = PAR[PM_PAR_SKY]; + source->skyErr = dPAR[PM_PAR_SKY]; + + // XXX use these to determine PAR[PM_PAR_I0]? + source->psfMag = psMetadataLookupF32 (&status, row, "PSF_INST_MAG"); + source->errMag = psMetadataLookupF32 (&status, row, "PSF_INST_MAG_SIG"); + source->apMag = psMetadataLookupF32 (&status, row, "AP_MAG"); + + // XXX this scaling is incorrect: does not include the 2 \pi AREA factor + PAR[PM_PAR_I0] = (isfinite(source->psfMag)) ? pow(10.0, -0.4*source->psfMag) : NAN; + dPAR[PM_PAR_I0] = (isfinite(source->psfMag)) ? PAR[PM_PAR_I0] * source->errMag : NAN; + + pmPSF_AxesToModel (PAR, axes); + + float peakMag = psMetadataLookupF32 (&status, row, "PEAK_FLUX_AS_MAG"); + float peakFlux = (isfinite(peakMag)) ? pow(10.0, -0.4*peakMag) : NAN; + + // recreate the peak to match (xPos, yPos) +/- (xErr, yErr) + source->peak = pmPeakAlloc(PAR[PM_PAR_XPOS], PAR[PM_PAR_YPOS], peakFlux, PM_PEAK_LONE); + source->peak->flux = peakFlux; + source->peak->xf = PAR[PM_PAR_XPOS]; // more accurate position + source->peak->yf = PAR[PM_PAR_YPOS]; // more accurate position + source->peak->dx = dPAR[PM_PAR_XPOS]; + source->peak->dy = dPAR[PM_PAR_YPOS]; + if (isfinite (source->errMag) && (source->errMag > 0.0)) { + source->peak->SN = 1.0 / source->errMag; + } else { + source->peak->SN = sqrt(source->peak->flux); // an alternate proxy: various functions sort by peak S/N + } + + source->pixWeightNotBad = psMetadataLookupF32 (&status, row, "PSF_QF"); + source->pixWeightNotPoor = psMetadataLookupF32 (&status, row, "PSF_QF_PERFECT"); + source->crNsigma = psMetadataLookupF32 (&status, row, "CR_NSIGMA"); + source->extNsigma = psMetadataLookupF32 (&status, row, "EXT_NSIGMA"); + source->apRadius = psMetadataLookupS32 (&status, row, "AP_MAG_RADIUS"); + + // note that some older versions used PSF_PROBABILITY: this was not well defined. + model->chisq = psMetadataLookupF32 (&status, row, "PSF_CHISQ"); + model->nDOF = psMetadataLookupS32 (&status, row, "PSF_NDOF"); + model->nPix = psMetadataLookupS32 (&status, row, "PSF_NPIX"); + + source->moments = pmMomentsAlloc (); + source->moments->Mxx = psMetadataLookupF32 (&status, row, "MOMENTS_XX"); + source->moments->Mxy = psMetadataLookupF32 (&status, row, "MOMENTS_XY"); + source->moments->Myy = psMetadataLookupF32 (&status, row, "MOMENTS_YY"); + + source->moments->Mrf = psMetadataLookupF32 (&status, row, "MOMENTS_R1"); + source->moments->Mrh = psMetadataLookupF32 (&status, row, "MOMENTS_RH"); + source->moments->KronFlux = psMetadataLookupF32 (&status, row, "KRON_FLUX"); + source->moments->KronFluxErr = psMetadataLookupF32 (&status, row, "KRON_FLUX_ERR"); + + source->moments->KronFinner = psMetadataLookupF32 (&status, row, "KRON_FLUX_INNER"); + source->moments->KronFouter = psMetadataLookupF32 (&status, row, "KRON_FLUX_OUTER"); + + // XXX we do not save all of the 3rd and 4th moment parameters. when we load in data, + // we are storing enough information so the output will be consistent with the input + source->moments->Mxxx = +1.0 * psMetadataLookupF32 (&status, row, "MOMENTS_M3C"); + source->moments->Mxxy = 0.0; + source->moments->Mxyy = 0.0; + source->moments->Myyy = -1.0 * psMetadataLookupF32 (&status, row, "MOMENTS_M3S"); + + source->moments->Mxxxx = +1.00 * psMetadataLookupF32 (&status, row, "MOMENTS_M4C"); + source->moments->Mxxxy = 0.0; + source->moments->Mxxyy = 0.0; + source->moments->Mxyyy = -0.25 * psMetadataLookupF32 (&status, row, "MOMENTS_M4S"); + source->moments->Myyyy = 0.0; + + source->mode = psMetadataLookupU32 (&status, row, "FLAGS"); + source->mode2 = psMetadataLookupU32 (&status, row, "FLAGS2"); + assert (status); + + sources->data[i] = source; + psFree(row); + } + + return sources; +} + +bool pmSourcesWrite_CMF_PS1_V3_XSRC (psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname, psMetadata *recipe) +{ + bool status; + psArray *table; + psMetadata *row; + psF32 *PAR, *dPAR; + psF32 xPos, yPos; + psF32 xErr, yErr; + int nRow = -1; + char keyword1[80], keyword2[80]; + + // create a header to hold the output data + psMetadata *outhead = psMetadataAlloc (); + + // write the links to the image header + psMetadataAddStr (outhead, PS_LIST_TAIL, "EXTNAME", PS_META_REPLACE, "xsrc table extension", extname); + + pmChip *chip = readout->parent->parent; + pmFPA *fpa = chip->parent; + + // zero point corrections + bool status1 = false; + bool status2 = false; + float magOffset = 0.0; + float exptime = psMetadataLookupF32(&status1, fpa->concepts, "FPA.EXPOSURE"); + float zeropt = psMetadataLookupF32(&status2, fpa->concepts, "FPA.ZP"); + if (!isfinite(zeropt)) { + zeropt = psMetadataLookupF32 (&status2, imageHeader, "ZPT_OBS"); + } + if (status1 && status2 && (exptime > 0.0)) { + magOffset = zeropt + 2.5*log10(exptime); + } + + // let's write these out in S/N order + sources = psArraySort (sources, pmSourceSortBySN); + + table = psArrayAllocEmpty (sources->n); + + // which extended source analyses should we perform? + bool doAnnuli = psMetadataLookupBool (&status, recipe, "EXTENDED_SOURCE_ANNULI"); + bool doPetrosian = psMetadataLookupBool (&status, recipe, "EXTENDED_SOURCE_PETROSIAN"); + + psVector *radMin = psMetadataLookupPtr (&status, recipe, "RADIAL.ANNULAR.BINS.LOWER"); + psVector *radMax = psMetadataLookupPtr (&status, recipe, "RADIAL.ANNULAR.BINS.UPPER"); + psAssert (radMin->n == radMax->n, "inconsistent annular bins"); + + // write the radial profile apertures to header + for (int i = 0; i < radMax->n; i++) { + sprintf (keyword1, "RMIN_%02d", i); + sprintf (keyword2, "RMAX_%02d", i); + psMetadataAddF32 (outhead, PS_LIST_TAIL, keyword1, PS_META_REPLACE, "min radius for SB profile", radMin->data.F32[i]); + psMetadataAddF32 (outhead, PS_LIST_TAIL, keyword2, PS_META_REPLACE, "min radius for SB profile", radMax->data.F32[i]); + } + + // we write out all sources, regardless of quality. the source flags tell us the state + for (int i = 0; i < sources->n; i++) { + pmSource *source = sources->data[i]; + + // skip sources without measurements + if (source->extpars == NULL) continue; + + // we require a PSF model fit (ignore the real crud) + pmModel *model = source->modelPSF; + if (model == NULL) continue; + + // XXX I need to split the extended models from the extended aperture measurements + PAR = model->params->data.F32; + dPAR = model->dparams->data.F32; + xPos = PAR[PM_PAR_XPOS]; + yPos = PAR[PM_PAR_YPOS]; + xErr = dPAR[PM_PAR_XPOS]; + yErr = dPAR[PM_PAR_YPOS]; + + row = psMetadataAlloc (); + + // XXX we are not writing out the mode (flags) or the type (psf, ext, etc) + psMetadataAdd (row, PS_LIST_TAIL, "IPP_IDET", PS_DATA_U32, "IPP detection identifier index", source->seq); + psMetadataAdd (row, PS_LIST_TAIL, "X_EXT", PS_DATA_F32, "EXT model x coordinate", xPos); + psMetadataAdd (row, PS_LIST_TAIL, "Y_EXT", PS_DATA_F32, "EXT model y coordinate", yPos); + psMetadataAdd (row, PS_LIST_TAIL, "X_EXT_SIG", PS_DATA_F32, "Sigma in EXT x coordinate", xErr); + psMetadataAdd (row, PS_LIST_TAIL, "Y_EXT_SIG", PS_DATA_F32, "Sigma in EXT y coordinate", yErr); + + float AxialRatio = NAN; + float AxialTheta = NAN; + pmSourceExtendedPars *extpars = source->extpars; + if (extpars) { + AxialRatio = extpars->axes.minor / extpars->axes.major; + AxialTheta = extpars->axes.theta; + } + psMetadataAdd (row, PS_LIST_TAIL, "F25_ARATIO", PS_DATA_F32, "Axial Ratio of radial profile", AxialRatio); + psMetadataAdd (row, PS_LIST_TAIL, "F25_THETA", PS_DATA_F32, "Angle of radial profile ellipse", AxialTheta); + + // Petrosian measurements + // XXX insert header data: petrosian ref radius, flux ratio + // XXX check flags to see if Pet was measured + if (doPetrosian) { + pmSourceExtendedPars *extpars = source->extpars; + if (extpars) { + // XXX note that this mag is either calibrated or instrumental depending on existence of zero point + float mag = (extpars->petrosianFlux > 0.0) ? -2.5*log10(extpars->petrosianFlux) + magOffset : NAN; // XXX zero point + float magErr = (extpars->petrosianFlux > 0.0) ? extpars->petrosianFlux / extpars->petrosianFluxErr : NAN; // XXX zero point + psMetadataAdd (row, PS_LIST_TAIL, "PETRO_MAG", PS_DATA_F32, "Petrosian Magnitude", mag); + psMetadataAdd (row, PS_LIST_TAIL, "PETRO_MAG_ERR", PS_DATA_F32, "Petrosian Magnitude Error", magErr); + psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS", PS_DATA_F32, "Petrosian Radius (pix)", extpars->petrosianRadius); + psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS_ERR", PS_DATA_F32, "Petrosian Radius Error (pix)", extpars->petrosianRadiusErr); + psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS_50", PS_DATA_F32, "Petrosian R50 (pix)", extpars->petrosianR50); + psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS_50_ERR", PS_DATA_F32, "Petrosian R50 Error (pix)", extpars->petrosianR50Err); + psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS_90", PS_DATA_F32, "Petrosian R90 (pix)", extpars->petrosianR90); + psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS_90_ERR", PS_DATA_F32, "Petrosian R90 Error (pix)", extpars->petrosianR90Err); + } else { + psMetadataAdd (row, PS_LIST_TAIL, "PETRO_MAG", PS_DATA_F32, "Petrosian Magnitude", NAN); + psMetadataAdd (row, PS_LIST_TAIL, "PETRO_MAG_ERR", PS_DATA_F32, "Petrosian Magnitude Error", NAN); + psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS", PS_DATA_F32, "Petrosian Radius", NAN); + psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS_ERR", PS_DATA_F32, "Petrosian Radius Error", NAN); + psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS_50", PS_DATA_F32, "Petrosian R50 (pix)", NAN); + psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS_50_ERR", PS_DATA_F32, "Petrosian R50 Error (pix)",NAN); + psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS_90", PS_DATA_F32, "Petrosian R90 (pix)", NAN); + psMetadataAdd (row, PS_LIST_TAIL, "PETRO_RADIUS_90_ERR", PS_DATA_F32, "Petrosian R90 Error (pix)",NAN); + } + } + + // Flux Annuli (if we have extended source measurements, we have these. only optionally save them) + if (doAnnuli) { + psVector *radSB = psVectorAlloc(radMin->n, PS_TYPE_F32); + psVector *radFlux = psVectorAlloc(radMin->n, PS_TYPE_F32); + psVector *radFill = psVectorAlloc(radMin->n, PS_TYPE_F32); + psVectorInit (radSB, NAN); + psVectorInit (radFlux, NAN); + psVectorInit (radFill, NAN); + if (!source->extpars) goto empty_annuli; + if (!source->extpars->radProfile) goto empty_annuli; + if (!source->extpars->radProfile->binSB) goto empty_annuli; + psAssert (source->extpars->radProfile->binSum, "programming error"); + psAssert (source->extpars->radProfile->binFill, "programming error"); + psAssert (source->extpars->radProfile->binSB->n <= radFlux->n, "inconsistent vector lengths"); + psAssert (source->extpars->radProfile->binSum->n <= radFlux->n, "inconsistent vector lengths"); + psAssert (source->extpars->radProfile->binFill->n <= radFlux->n, "inconsistent vector lengths"); + + // copy the data from fluxVal (which is not guaranteed to be the full length) to radFlux + for (int j = 0; j < source->extpars->radProfile->binSB->n; j++) { + radSB->data.F32[j] = source->extpars->radProfile->binSB->data.F32[j]; + radFlux->data.F32[j] = source->extpars->radProfile->binSum->data.F32[j]; + radFill->data.F32[j] = source->extpars->radProfile->binFill->data.F32[j]; + } + + empty_annuli: + psMetadataAdd (row, PS_LIST_TAIL, "PROF_SB", PS_DATA_VECTOR, "mean surface brightness annuli", radSB); + psMetadataAdd (row, PS_LIST_TAIL, "PROF_FLUX", PS_DATA_VECTOR, "flux within annuli", radFlux); + psMetadataAdd (row, PS_LIST_TAIL, "PROF_FILL", PS_DATA_VECTOR, "fill factor of annuli", radFill); + psFree (radSB); + psFree (radFlux); + psFree (radFill); + } + if (nRow < 0) { + nRow = row->list->n; + } else { + psAssert (nRow == row->list->n, "inconsistent row lengths"); + } + psArrayAdd (table, 100, row); + psFree (row); + } + + if (table->n == 0) { + if (!psFitsWriteBlank (fits, outhead, extname)) { + psError(psErrorCodeLast(), false, "Unable to write empty sources file."); + psFree(outhead); + psFree(table); + return false; + } + psFree (outhead); + psFree (table); + return true; + } + + psTrace ("pmFPAfile", 5, "writing ext data %s\n", extname); + if (!psFitsWriteTable (fits, outhead, table, extname)) { + psError(psErrorCodeLast(), false, "writing ext data %s\n", extname); + psFree (outhead); + psFree(table); + return false; + } + psFree (outhead); + psFree (table); + + return true; +} + +// XXX this layout is still the same as PS1_DEV_1 +bool pmSourcesWrite_CMF_PS1_V3_XFIT (psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname) +{ + + psArray *table; + psMetadata *row; + psF32 *PAR, *dPAR; + psEllipseAxes axes; + psF32 xPos, yPos; + psF32 xErr, yErr; + char name[64]; + + // create a header to hold the output data + psMetadata *outhead = psMetadataAlloc (); + + // write the links to the image header + psMetadataAddStr (outhead, PS_LIST_TAIL, "EXTNAME", PS_META_REPLACE, "xsrc table extension", extname); + + // let's write these out in S/N order + sources = psArraySort (sources, pmSourceSortBySN); + + // we are writing one row per model; we need to write out same number of columns for each row: find the max Nparams + int nParamMax = 0; + for (int i = 0; i < sources->n; i++) { + pmSource *source = sources->data[i]; + if (source->modelFits == NULL) continue; + for (int j = 0; j < source->modelFits->n; j++) { + pmModel *model = source->modelFits->data[j]; + assert (model); + nParamMax = PS_MAX (nParamMax, model->params->n); + } + } + + table = psArrayAllocEmpty (sources->n); + + // we write out all sources, regardless of quality. the source flags tell us the state + for (int i = 0; i < sources->n; i++) { + + pmSource *source = sources->data[i]; + + // XXX if no model fits are saved, write out modelEXT? + if (source->modelFits == NULL) continue; + + // We have multiple sources : need to flag the one used to subtract the light (the 'best' model) + for (int j = 0; j < source->modelFits->n; j++) { + + // choose the convolved EXT model, if available, otherwise the simple one + pmModel *model = source->modelFits->data[j]; + assert (model); + + // skip models which were not actually fitted + if (model->flags & PM_MODEL_STATUS_BADARGS) continue; + + PAR = model->params->data.F32; + dPAR = model->dparams->data.F32; + xPos = PAR[PM_PAR_XPOS]; + yPos = PAR[PM_PAR_YPOS]; + xErr = dPAR[PM_PAR_XPOS]; + yErr = dPAR[PM_PAR_YPOS]; + + axes = pmPSF_ModelToAxes (PAR, 20.0); + + row = psMetadataAlloc (); + + // XXX we are not writing out the mode (flags) or the type (psf, ext, etc) + psMetadataAddU32 (row, PS_LIST_TAIL, "IPP_IDET", 0, "IPP detection identifier index", source->seq); + psMetadataAddF32 (row, PS_LIST_TAIL, "X_EXT", 0, "EXT model x coordinate", xPos); + psMetadataAddF32 (row, PS_LIST_TAIL, "Y_EXT", 0, "EXT model y coordinate", yPos); + psMetadataAddF32 (row, PS_LIST_TAIL, "X_EXT_SIG", 0, "Sigma in EXT x coordinate", xErr); + psMetadataAddF32 (row, PS_LIST_TAIL, "Y_EXT_SIG", 0, "Sigma in EXT y coordinate", yErr); + psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_INST_MAG", 0, "EXT fit instrumental magnitude", model->mag); + psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_INST_MAG_SIG", 0, "Sigma of PSF instrumental magnitude", model->magErr); + + psMetadataAddF32 (row, PS_LIST_TAIL, "NPARAMS", 0, "number of model parameters", model->params->n); + psMetadataAddStr (row, PS_LIST_TAIL, "MODEL_TYPE", 0, "name of model", pmModelClassGetName (model->type)); + + // XXX these should be major and minor, not 'x' and 'y' + psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_WIDTH_MAJ", 0, "EXT width in x coordinate", axes.major); + psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_WIDTH_MIN", 0, "EXT width in y coordinate", axes.minor); + psMetadataAddF32 (row, PS_LIST_TAIL, "EXT_THETA", 0, "EXT orientation angle", axes.theta); + + // write out the other generic parameters + for (int k = 0; k < nParamMax; k++) { + if (k == PM_PAR_I0) continue; + if (k == PM_PAR_SKY) continue; + if (k == PM_PAR_XPOS) continue; + if (k == PM_PAR_YPOS) continue; + if (k == PM_PAR_SXX) continue; + if (k == PM_PAR_SXY) continue; + if (k == PM_PAR_SYY) continue; + + snprintf (name, 64, "EXT_PAR_%02d", k); + + if (k < model->params->n) { + psMetadataAdd (row, PS_LIST_TAIL, name, PS_DATA_F32, "", model->params->data.F32[k]); + } else { + psMetadataAddF32 (row, PS_LIST_TAIL, name, PS_DATA_F32, "", NAN); + } + } + + // XXX other parameters which may be set. + // XXX flag / value to define the model + // XXX write out the model type, fit status flags + + psArrayAdd (table, 100, row); + psFree (row); + } + } + + if (table->n == 0) { + if (!psFitsWriteBlank (fits, outhead, extname)) { + psError(psErrorCodeLast(), false, "Unable to write empty sources file."); + psFree(outhead); + psFree(table); + return false; + } + psFree (outhead); + psFree (table); + return true; + } + + psTrace ("pmFPAfile", 5, "writing ext data %s\n", extname); + if (!psFitsWriteTable (fits, outhead, table, extname)) { + psError(psErrorCodeLast(), false, "writing ext data %s\n", extname); + psFree (outhead); + psFree(table); + return false; + } + psFree (outhead); + psFree (table); + return true; +} Index: /trunk/psModules/src/objects/pmSourceIO_CMP.c =================================================================== --- /trunk/psModules/src/objects/pmSourceIO_CMP.c (revision 29003) +++ /trunk/psModules/src/objects/pmSourceIO_CMP.c (revision 29004) @@ -28,15 +28,24 @@ #include "pmFPAfile.h" +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmGrowthCurve.h" -#include "pmResiduals.h" -#include "pmTrend2D.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" #include "pmPSF.h" -#include "pmModel.h" -#include "pmSource.h" -#include "pmModelClass.h" +#include "pmPSFtry.h" + #include "pmSourceIO.h" Index: /trunk/psModules/src/objects/pmSourceIO_MatchedRefs.c =================================================================== --- /trunk/psModules/src/objects/pmSourceIO_MatchedRefs.c (revision 29003) +++ /trunk/psModules/src/objects/pmSourceIO_MatchedRefs.c (revision 29004) @@ -28,16 +28,26 @@ #include "pmFPAfile.h" +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmGrowthCurve.h" -#include "pmResiduals.h" -#include "pmTrend2D.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" #include "pmPSF.h" -#include "pmModel.h" -#include "pmSource.h" -#include "pmModelClass.h" +#include "pmPSFtry.h" + #include "pmSourceIO.h" + #include "pmAstrometryObjects.h" #include "pmAstrometryWCS.h" Index: /trunk/psModules/src/objects/pmSourceIO_OBJ.c =================================================================== --- /trunk/psModules/src/objects/pmSourceIO_OBJ.c (revision 29003) +++ /trunk/psModules/src/objects/pmSourceIO_OBJ.c (revision 29004) @@ -28,15 +28,24 @@ #include "pmFPAfile.h" +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmGrowthCurve.h" -#include "pmResiduals.h" -#include "pmTrend2D.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" #include "pmPSF.h" -#include "pmModel.h" -#include "pmSource.h" -#include "pmModelClass.h" +#include "pmPSFtry.h" + #include "pmSourceIO.h" Index: /trunk/psModules/src/objects/pmSourceIO_PS1_CAL_0.c =================================================================== --- /trunk/psModules/src/objects/pmSourceIO_PS1_CAL_0.c (revision 29003) +++ /trunk/psModules/src/objects/pmSourceIO_PS1_CAL_0.c (revision 29004) @@ -28,15 +28,24 @@ #include "pmFPAfile.h" +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmGrowthCurve.h" -#include "pmResiduals.h" -#include "pmTrend2D.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" #include "pmPSF.h" -#include "pmModel.h" -#include "pmSource.h" -#include "pmModelClass.h" +#include "pmPSFtry.h" + #include "pmSourceIO.h" @@ -49,6 +58,5 @@ // XXX how do I generate the source tables which I need to send to PSPS? -bool pmSourcesWrite_PS1_CAL_0 (psFits *fits, pmReadout *readout, psArray *sources, - psMetadata *imageHeader, psMetadata *tableHeader, char *extname) +bool pmSourcesWrite_PS1_CAL_0 (psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, psMetadata *tableHeader, char *extname, psMetadata *recipe) { PS_ASSERT_PTR_NON_NULL(fits, false); @@ -180,5 +188,5 @@ psMetadataAdd (row, PS_LIST_TAIL, "PSF_WIDTH_Y", PS_DATA_F32, "PSF width in y coordinate", axes.minor); psMetadataAdd (row, PS_LIST_TAIL, "PSF_THETA", PS_DATA_F32, "PSF orientation angle", axes.theta); - psMetadataAdd (row, PS_LIST_TAIL, "PSF_QF", PS_DATA_F32, "PSF coverage/quality factor", source->pixWeight); + psMetadataAdd (row, PS_LIST_TAIL, "PSF_QF", PS_DATA_F32, "PSF coverage/quality factor", source->pixWeightNotBad); // XXX not sure how to get this : need to load Nimages with weight? @@ -289,6 +297,8 @@ source->peak->dx = dPAR[PM_PAR_XPOS]; source->peak->dy = dPAR[PM_PAR_YPOS]; - - source->pixWeight = psMetadataLookupF32 (&status, row, "PSF_QF"); + source->peak->xf = PAR[PM_PAR_XPOS]; // more accurate position + source->peak->yf = PAR[PM_PAR_YPOS]; // more accurate position + + source->pixWeightNotBad = psMetadataLookupF32 (&status, row, "PSF_QF"); // note that some older versions used PSF_PROBABILITY: this was not well defined. @@ -597,4 +607,7 @@ assert (model); + // skip models which were not actually fitted + if (model->flags & PM_MODEL_STATUS_BADARGS) continue; + PAR = model->params->data.F32; dPAR = model->dparams->data.F32; Index: /trunk/psModules/src/objects/pmSourceIO_PS1_DEV_0.c =================================================================== --- /trunk/psModules/src/objects/pmSourceIO_PS1_DEV_0.c (revision 29003) +++ /trunk/psModules/src/objects/pmSourceIO_PS1_DEV_0.c (revision 29004) @@ -28,15 +28,24 @@ #include "pmFPAfile.h" +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmGrowthCurve.h" -#include "pmResiduals.h" -#include "pmTrend2D.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" #include "pmPSF.h" -#include "pmModel.h" -#include "pmSource.h" -#include "pmModelClass.h" +#include "pmPSFtry.h" + #include "pmSourceIO.h" @@ -49,6 +58,5 @@ // XXX how do I generate the source tables which I need to send to PSPS? // XXX: input parameter imageHeader is never used. -bool pmSourcesWrite_PS1_DEV_0 (psFits *fits, psArray *sources, psMetadata *imageHeader, - psMetadata *tableHeader, char *extname) +bool pmSourcesWrite_PS1_DEV_0 (psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, psMetadata *tableHeader, char *extname, psMetadata *recipe) { PS_ASSERT_PTR_NON_NULL(fits, false); @@ -117,5 +125,5 @@ psMetadataAdd (row, PS_LIST_TAIL, "PSF_WIDTH_Y", PS_DATA_F32, "PSF width in y coordinate", axes.minor); psMetadataAdd (row, PS_LIST_TAIL, "PSF_THETA", PS_DATA_F32, "PSF orientation angle", axes.theta); - psMetadataAdd (row, PS_LIST_TAIL, "PSF_QF", PS_DATA_F32, "PSF coverage/quality factor", source->pixWeight); + psMetadataAdd (row, PS_LIST_TAIL, "PSF_QF", PS_DATA_F32, "PSF coverage/quality factor", source->pixWeightNotBad); // XXX not sure how to get this : need to load Nimages with weight psMetadataAdd (row, PS_LIST_TAIL, "N_FRAMES", PS_DATA_U16, "Number of frames overlapping source center", nImageOverlap); @@ -215,6 +223,8 @@ source->peak->dx = dPAR[PM_PAR_XPOS]; source->peak->dy = dPAR[PM_PAR_YPOS]; - - source->pixWeight = psMetadataLookupF32 (&status, row, "PSF_QF"); + source->peak->xf = PAR[PM_PAR_XPOS]; // more accurate position + source->peak->yf = PAR[PM_PAR_YPOS]; // more accurate position + + source->pixWeightNotBad = psMetadataLookupF32 (&status, row, "PSF_QF"); // XXX other values saved but not loaded? @@ -228,2 +238,12 @@ return (sources); } + +bool pmSourcesWrite_PS1_DEV_0_XSRC (psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname, psMetadata *recipe) +{ + return true; +} + +bool pmSourcesWrite_PS1_DEV_0_XFIT(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname) +{ + return true; +} Index: /trunk/psModules/src/objects/pmSourceIO_PS1_DEV_1.c =================================================================== --- /trunk/psModules/src/objects/pmSourceIO_PS1_DEV_1.c (revision 29003) +++ /trunk/psModules/src/objects/pmSourceIO_PS1_DEV_1.c (revision 29004) @@ -28,15 +28,24 @@ #include "pmFPAfile.h" +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmGrowthCurve.h" -#include "pmResiduals.h" -#include "pmTrend2D.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" #include "pmPSF.h" -#include "pmModel.h" -#include "pmSource.h" -#include "pmModelClass.h" +#include "pmPSFtry.h" + #include "pmSourceIO.h" @@ -47,8 +56,6 @@ // this output format is valid for psphot analysis of an image, and does not include calibrated // values derived in the DVO database. -// XXX how do I generate the source tables which I need to send to PSPS? - -bool pmSourcesWrite_PS1_DEV_1 (psFits *fits, psArray *sources, - psMetadata *imageHeader, psMetadata *tableHeader, char *extname) + +bool pmSourcesWrite_PS1_DEV_1(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, psMetadata *tableHeader, char *extname, psMetadata *recipe) { PS_ASSERT_PTR_NON_NULL(fits, false); @@ -142,5 +149,5 @@ psMetadataAdd (row, PS_LIST_TAIL, "PSF_WIDTH_Y", PS_DATA_F32, "PSF width in y coordinate", axes.minor); psMetadataAdd (row, PS_LIST_TAIL, "PSF_THETA", PS_DATA_F32, "PSF orientation angle", axes.theta); - psMetadataAdd (row, PS_LIST_TAIL, "PSF_QF", PS_DATA_F32, "PSF coverage/quality factor", source->pixWeight); + psMetadataAdd (row, PS_LIST_TAIL, "PSF_QF", PS_DATA_F32, "PSF coverage/quality factor", source->pixWeightNotBad); // XXX not sure how to get this : need to load Nimages with weight? @@ -259,6 +266,8 @@ source->peak->dx = dPAR[PM_PAR_XPOS]; source->peak->dy = dPAR[PM_PAR_YPOS]; - - source->pixWeight = psMetadataLookupF32 (&status, row, "PSF_QF"); + source->peak->xf = PAR[PM_PAR_XPOS]; // more accurate position + source->peak->yf = PAR[PM_PAR_YPOS]; // more accurate position + + source->pixWeightNotBad = psMetadataLookupF32 (&status, row, "PSF_QF"); // note that some older versions used PSF_PROBABILITY: this was not well defined. @@ -281,5 +290,5 @@ } -bool pmSourcesWrite_PS1_DEV_1_XSRC (psFits *fits, psArray *sources, char *extname, psMetadata *recipe) +bool pmSourcesWrite_PS1_DEV_1_XSRC (psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname, psMetadata *recipe) { @@ -453,5 +462,5 @@ } -bool pmSourcesWrite_PS1_DEV_1_XFIT (psFits *fits, psArray *sources, char *extname) +bool pmSourcesWrite_PS1_DEV_1_XFIT(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname) { @@ -502,4 +511,7 @@ assert (model); + // skip models which were not actually fitted + if (model->flags & PM_MODEL_STATUS_BADARGS) continue; + PAR = model->params->data.F32; dPAR = model->dparams->data.F32; Index: /trunk/psModules/src/objects/pmSourceIO_RAW.c =================================================================== --- /trunk/psModules/src/objects/pmSourceIO_RAW.c (revision 29003) +++ /trunk/psModules/src/objects/pmSourceIO_RAW.c (revision 29004) @@ -28,16 +28,24 @@ #include "pmFPAfile.h" +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmGrowthCurve.h" -#include "pmResiduals.h" -#include "pmTrend2D.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" #include "pmPSF.h" -#include "pmModel.h" -#include "pmSource.h" -#include "pmModelClass.h" -#include "pmSourcePhotometry.h" +#include "pmPSFtry.h" + #include "pmSourceIO.h" @@ -120,5 +128,5 @@ source[0].peak->SN, source[0].apRadius, - source[0].pixWeight, + source[0].pixWeightNotBad, model[0].nDOF, model[0].nIter); @@ -182,5 +190,5 @@ source[0].peak->SN, source[0].apRadius, - source[0].pixWeight, + source[0].pixWeightNotBad, model[0].nDOF, model[0].nIter); Index: /trunk/psModules/src/objects/pmSourceIO_SMPDATA.c =================================================================== --- /trunk/psModules/src/objects/pmSourceIO_SMPDATA.c (revision 29003) +++ /trunk/psModules/src/objects/pmSourceIO_SMPDATA.c (revision 29004) @@ -28,15 +28,24 @@ #include "pmFPAfile.h" +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmResiduals.h" -#include "pmGrowthCurve.h" -#include "pmTrend2D.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" #include "pmPSF.h" -#include "pmModel.h" -#include "pmSource.h" -#include "pmModelClass.h" +#include "pmPSFtry.h" + #include "pmSourceIO.h" @@ -45,6 +54,5 @@ // followed by a zero-size matrix, followed by the table data // XXX: input parameter imageHeader is never used -bool pmSourcesWrite_SMPDATA (psFits *fits, psArray *sources, psMetadata *imageHeader, - psMetadata *tableHeader, char *extname) +bool pmSourcesWrite_SMPDATA (psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, psMetadata *tableHeader, char *extname, psMetadata *recipe) { PS_ASSERT_PTR_NON_NULL(fits, false); @@ -106,5 +114,5 @@ psMetadataAdd (row, PS_LIST_TAIL, "THETA", PS_DATA_F32, "", axes.theta); psMetadataAdd (row, PS_LIST_TAIL, "DOPHOT", PS_DATA_U8, "", type); - psMetadataAdd (row, PS_LIST_TAIL, "WEIGHT", PS_DATA_U8, "", PS_MIN (255, PS_MAX(0, 255*source->pixWeight))); + psMetadataAdd (row, PS_LIST_TAIL, "WEIGHT", PS_DATA_U8, "", PS_MIN (255, PS_MAX(0, 255*source->pixWeightNotBad))); psMetadataAdd (row, PS_LIST_TAIL, "DUMMY", PS_DATA_U16, "", 0); @@ -189,5 +197,5 @@ source->apMag = psMetadataLookupF32 (&status, row, "MAG_AP") - ZERO_POINT; - source->pixWeight = psMetadataLookupU8 (&status, row, "WEIGHT")/255.0; + source->pixWeightNotBad = psMetadataLookupU8 (&status, row, "WEIGHT")/255.0; int dophot = psMetadataLookupU8 (&status, row, "DOPHOT"); pmSourceSetDophotType (source, dophot); @@ -204,2 +212,12 @@ return (sources); } + +bool pmSourcesWrite_SMPDATA_XSRC (psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname, psMetadata *recipe) +{ + return true; +} + +bool pmSourcesWrite_SMPDATA_XFIT(psFits *fits, pmReadout *readout, psArray *sources, psMetadata *imageHeader, char *extname) +{ + return true; +} Index: /trunk/psModules/src/objects/pmSourceIO_SX.c =================================================================== --- /trunk/psModules/src/objects/pmSourceIO_SX.c (revision 29003) +++ /trunk/psModules/src/objects/pmSourceIO_SX.c (revision 29004) @@ -28,15 +28,24 @@ #include "pmFPAfile.h" +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmGrowthCurve.h" -#include "pmResiduals.h" -#include "pmTrend2D.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" #include "pmPSF.h" -#include "pmModel.h" -#include "pmSource.h" -#include "pmModelClass.h" +#include "pmPSFtry.h" + #include "pmSourceIO.h" Index: /trunk/psModules/src/objects/pmSourceMasks.h =================================================================== --- /trunk/psModules/src/objects/pmSourceMasks.h (revision 29003) +++ /trunk/psModules/src/objects/pmSourceMasks.h (revision 29004) @@ -39,4 +39,11 @@ } pmSourceMode; +// Bit flags to distinguish analysis results +// When adding to or subtracting from this list, please also modify pmSourceMaskHeader +typedef enum { + PM_SOURCE_MODE2_DEFAULT = 0x00000000, ///< Initial value: resets all bits + PM_SOURCE_MODE2_DIFF_WITH_SINGLE = 0x00000001, ///< diff source matched to a single positive detection + PM_SOURCE_MODE2_DIFF_WITH_DOUBLE = 0x00000002, ///< diff source matched to positive detections in both images +} pmSourceMode2; /// Populate header with mask values Index: /trunk/psModules/src/objects/pmSourceMatch.c =================================================================== --- /trunk/psModules/src/objects/pmSourceMatch.c (revision 29003) +++ /trunk/psModules/src/objects/pmSourceMatch.c (revision 29004) @@ -6,6 +6,28 @@ #include #include - +#include "pmHDU.h" +#include "pmFPA.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" +#include "pmSpan.h" +#include "pmFootprintSpans.h" +#include "pmFootprint.h" +#include "pmPeaks.h" +#include "pmMoments.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" #include "pmSource.h" +#include "pmSourceFitModel.h" +#include "pmPSF.h" +#include "pmPSFtry.h" +#include "pmDetections.h" + #include "pmErrorCodes.h" Index: /trunk/psModules/src/objects/pmSourceMatch.h =================================================================== --- /trunk/psModules/src/objects/pmSourceMatch.h (revision 29003) +++ /trunk/psModules/src/objects/pmSourceMatch.h (revision 29004) @@ -1,6 +1,4 @@ #ifndef PM_SOURCE_MATCH_H #define PM_SOURCE_MATCH_H - -#include /// Mask values for matched sources Index: /trunk/psModules/src/objects/pmSourceMoments.c =================================================================== --- /trunk/psModules/src/objects/pmSourceMoments.c (revision 29003) +++ /trunk/psModules/src/objects/pmSourceMoments.c (revision 29004) @@ -22,16 +22,23 @@ #include #include + #include "pmHDU.h" #include "pmFPA.h" -#include "pmFPAMaskWeight.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmResiduals.h" -#include "pmGrowthCurve.h" -#include "pmTrend2D.h" -#include "pmPSF.h" +#include "pmModelFuncs.h" #include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" #include "pmSource.h" @@ -54,4 +61,7 @@ # define VALID_RADIUS(X,Y,RAD2) (((RAD2) >= (PS_SQR(X) + PS_SQR(Y))) ? 1 : 0) +static bool beVerbose = false; +void pmSourceMomentsSetVerbose(bool state){ beVerbose = state; } + bool pmSourceMoments(pmSource *source, psF32 radius, psF32 sigma, psF32 minSN, psImageMaskType maskVal) { @@ -61,11 +71,15 @@ PS_ASSERT_FLOAT_LARGER_THAN(radius, 0.0, false); - // use sky from moments if defined, 0.0 otherwise + // use sky from moments if defined, 0.0 otherwise + + // XXX this value comes from the sky model at the source center, and tends to over-estimate + // the sky in the vicinity of bright sources. we are better off assuming the model worked + // well: psF32 sky = 0.0; - if (source->moments == NULL) { - source->moments = pmMomentsAlloc(); - } else { - sky = source->moments->Sky; - } + // XXX if (source->moments == NULL) { + // XXX source->moments = pmMomentsAlloc(); + // XXX } else { + // XXX sky = source->moments->Sky; + // XXX } // First Pass: calculate the first moments (these are subtracted from the coordinates below) @@ -131,9 +145,11 @@ psF32 wDiff = *vWgt; - // skip pixels below specified significance level. this is allowed, but should be - // avoided -- the over-weights the wings of bright stars compared to those of faint - // stars. - if (PS_SQR(pDiff) < minSN2*wDiff) continue; - // if (pDiff < 0) continue; // XXX : MWV says I should include < 0.0 valued points... + // skip pixels below specified significance level. for a PSFs, this + // over-weights the wings of bright stars compared to those of faint stars. + // for the estimator used for extended source analysis (where the window + // function is allowed to be arbitrarily large), we need to clip to avoid + // negative second moments. + if (PS_SQR(pDiff) < minSN2*wDiff) continue; // + if ((minSN > 0.0) && (pDiff < 0)) continue; // // Apply a Gaussian window function. Be careful with the window function. S/N @@ -197,4 +213,7 @@ // Xn = SUM (x - xc)^n * (z - sky) + psF32 RF = 0.0; + psF32 RH = 0.0; + psF32 RS = 0.0; psF32 XX = 0.0; psF32 XY = 0.0; @@ -244,5 +263,6 @@ if (r > radius) continue; - psF32 pDiff = *vPix - sky; + psF32 fDiff = *vPix - sky; + psF32 pDiff = fDiff; psF32 wDiff = *vWgt; @@ -257,5 +277,7 @@ if (sigma > 0.0) { // XXX a lot of extra flops; can we do pre-calculate? - psF32 z = (PS_SQR(xDiff) + PS_SQR(yDiff))*rsigma2; + // XXX we were re-calculating r2 (maybe the compiler caught this?) + // psF32 z = (PS_SQR(xDiff) + PS_SQR(yDiff))*rsigma2; + psF32 z = r2 * rsigma2; assert (z >= 0.0); psF32 weight = exp(-z); @@ -266,4 +288,17 @@ Sum += pDiff; + +# if (1) +# if (0) + if (fDiff < 0) continue; +# endif + psF32 rf = r * fDiff; + psF32 rh = sqrt(r) * fDiff; + psF32 rs = fDiff; +# else + psF32 rf = r * pDiff; + psF32 rh = sqrt(r) * pDiff; + psF32 rs = pDiff; +# endif psF32 x = xDiff * pDiff; @@ -284,4 +319,8 @@ psF32 xyyy = xDiff * yyy / r2; psF32 yyyy = yDiff * yyy / r2; + + RF += rf; + RH += rh; + RS += rs; XX += xx; @@ -302,4 +341,7 @@ } + source->moments->Mrf = RF/RS; + source->moments->Mrh = RH/RS; + source->moments->Mxx = XX/Sum; source->moments->Mxy = XY/Sum; @@ -317,12 +359,71 @@ source->moments->Myyyy = YYYY/Sum; - // if (source->moments->Mxx < 0) { - // fprintf (stderr, "error: neg second moment??\n"); - // } - // if (source->moments->Myy < 0) { - // fprintf (stderr, "error: neg second moment??\n"); - // } - - psTrace ("psModules.objects", 4, "Mxx: %f Mxy: %f Myy: %f Mxxx: %f Mxxy: %f Mxyy: %f Myyy: %f Mxxxx: %f Mxxxy: %f Mxxyy: %f Mxyyy: %f Mxyyy: %f\n", + // Calculate the Kron magnitude (make this block optional?) + // float radKron = 2.5*source->moments->Mrf; + float radKinner = 1.0*source->moments->Mrf; + float radKron = 2.5*source->moments->Mrf; + float radKouter = 4.0*source->moments->Mrf; + + int nKronPix = 0; + Sum = Var = 0.0; + float SumInner = 0.0; + float SumOuter = 0.0; + + for (psS32 row = 0; row < source->pixels->numRows ; row++) { + + psF32 yDiff = row - yCM; + if (fabs(yDiff) > radKron) continue; + + psF32 *vPix = source->pixels->data.F32[row]; + psF32 *vWgt = source->variance->data.F32[row]; + psImageMaskType *vMsk = (source->maskObj == NULL) ? NULL : source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[row]; + + for (psS32 col = 0; col < source->pixels->numCols ; col++, vPix++, vWgt++) { + if (vMsk) { + if (*vMsk & maskVal) { + vMsk++; + continue; + } + vMsk++; + } + if (isnan(*vPix)) continue; + + psF32 xDiff = col - xCM; + if (fabs(xDiff) > radKron) continue; + + // radKron is just a function of (xDiff, yDiff) + psF32 r2 = PS_SQR(xDiff) + PS_SQR(yDiff); + psF32 r = sqrt(r2); + + psF32 pDiff = *vPix - sky; + psF32 wDiff = *vWgt; + + // skip pixels below specified significance level. this is allowed, but should be + // avoided -- the over-weights the wings of bright stars compared to those of faint + // stars. + if (PS_SQR(pDiff) < minSN2*wDiff) continue; + + if (r < radKron) { + Sum += pDiff; + Var += wDiff; + nKronPix ++; + // if (beVerbose) fprintf (stderr, "mome: %d %d %f %f %f\n", col, row, sky, *vPix, Sum); + } + + if ((r > radKinner) && (r < radKron)) { + SumInner += pDiff; + } + if ((r > radKron) && (r < radKouter)) { + SumOuter += pDiff; + } + } + } + source->moments->KronFlux = Sum; + source->moments->KronFinner = SumInner; + source->moments->KronFouter = SumOuter; + source->moments->KronFluxErr = sqrt(Var); + + psTrace ("psModules.objects", 4, "Mrf: %f KronFlux: %f Mxx: %f Mxy: %f Myy: %f Mxxx: %f Mxxy: %f Mxyy: %f Myyy: %f Mxxxx: %f Mxxxy: %f Mxxyy: %f Mxyyy: %f Mxyyy: %f\n", + source->moments->Mrf, source->moments->KronFlux, source->moments->Mxx, source->moments->Mxy, source->moments->Myy, source->moments->Mxxx, source->moments->Mxxy, source->moments->Mxyy, source->moments->Myyy, Index: /trunk/psModules/src/objects/pmSourcePhotometry.c =================================================================== --- /trunk/psModules/src/objects/pmSourcePhotometry.c (revision 29003) +++ /trunk/psModules/src/objects/pmSourcePhotometry.c (revision 29004) @@ -22,15 +22,25 @@ #include "pmFPA.h" #include "pmFPAMaskWeight.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmGrowthCurve.h" -#include "pmResiduals.h" -#include "pmTrend2D.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" #include "pmPSF.h" -#include "pmModel.h" -#include "pmSource.h" -#include "pmModelClass.h" +#include "pmPSFtry.h" + #include "pmSourcePhotometry.h" @@ -66,5 +76,5 @@ // XXX masked region should be (optionally) elliptical -bool pmSourceMagnitudes (pmSource *source, pmPSF *psf, pmSourcePhotometryMode mode, psImageMaskType maskVal) +bool pmSourceMagnitudes (pmSource *source, pmPSF *psf, pmSourcePhotometryMode mode, psImageMaskType maskVal, psImageMaskType markVal) { PS_ASSERT_PTR_NON_NULL(source, false); @@ -122,4 +132,5 @@ for (int i = 0; i < source->modelFits->n; i++) { pmModel *model = source->modelFits->data[i]; + if (model->flags & PM_MODEL_STATUS_BADARGS) continue; status = pmSourcePhotometryModel (&model->mag, NULL, model); if (model == source->modelEXT) foundEXT = true; @@ -145,10 +156,10 @@ // measure the contribution of included pixels if (mode & PM_SOURCE_PHOT_WEIGHT) { - pmSourcePixelWeight (&source->pixWeight, model, source->maskObj, maskVal); + pmSourcePixelWeight (&source->pixWeightNotBad, &source->pixWeightNotPoor, model, source->maskObj, maskVal, markVal); } // measure the contribution of included pixels if (mode & PM_SOURCE_PHOT_DIFFSTATS) { - pmSourceMeasureDiffStats (source, maskVal); + pmSourceMeasureDiffStats (source, maskVal, markVal); } @@ -191,5 +202,5 @@ // measure object aperture photometry - status = pmSourcePhotometryAper (&source->apMag, model, flux, mask, maskVal); + status = pmSourcePhotometryAper (&source->apMagRaw, model, flux, mask, maskVal); if (!status) { psTrace ("psModules.objects", 3, "fail mag : bad Ap Mag"); @@ -199,11 +210,15 @@ // if the aper mag is NAN, the flux < 0. this can happen for sources near the // detection limits (esp near bright neighbors) + source->apMag = source->apMagRaw; if (isfinite (source->apMag) && isPSF && psf) { if (psf->growth && (mode & PM_SOURCE_PHOT_GROWTH)) { - source->apMag += pmGrowthCurveCorrect (psf->growth, source->apRadius); + source->apMag = source->apMagRaw + pmGrowthCurveCorrect (psf->growth, source->apRadius); } if (mode & PM_SOURCE_PHOT_APCORR) { // XXX this should be removed -- we no longer fit for the 'sky bias' + // XXX is this happening??? rflux = pow (10.0, 0.4*source->psfMag); + psAssert (psf->skyBias == 0.0, "sky bias not 0"); + psAssert (psf->skySat == 0.0, "sky sat not 0"); source->apMag -= PS_SQR(source->apRadius)*rflux * psf->skyBias + psf->skySat / rflux; } @@ -257,5 +272,8 @@ PS_ASSERT_PTR_NON_NULL(image, false); PS_ASSERT_PTR_NON_NULL(mask, false); - PS_ASSERT_PTR_NON_NULL(model, false); + + if (DO_SKY) { + PS_ASSERT_PTR_NON_NULL(model, false); + } float apSum = 0; @@ -271,11 +289,14 @@ psF32 **imData = image->data.F32; psImageMaskType **mkData = mask->data.PS_TYPE_IMAGE_MASK_DATA; + int nAperPix = 0; // measure apMag - for (int ix = 0; ix < image->numCols; ix++) { - for (int iy = 0; iy < image->numRows; iy++) { + for (int iy = 0; iy < image->numRows; iy++) { + for (int ix = 0; ix < image->numCols; ix++) { if (mkData[iy][ix] & maskVal) continue; apSum += imData[iy][ix] - sky; + nAperPix ++; + // fprintf (stderr, "aper: %d %d %f %f %f\n", ix, iy, sky, imData[iy][ix], apSum); } } @@ -290,12 +311,14 @@ // return source aperture magnitude -bool pmSourcePixelWeight (float *pixWeight, pmModel *model, psImage *mask, psImageMaskType maskVal) -{ - PS_ASSERT_PTR_NON_NULL(pixWeight, false); +bool pmSourcePixelWeight (float *pixWeightNotBad, float *pixWeightNotPoor, pmModel *model, psImage *mask, psImageMaskType maskVal, psImageMaskType markVal) +{ + PS_ASSERT_PTR_NON_NULL(pixWeightNotBad, false); + PS_ASSERT_PTR_NON_NULL(pixWeightNotPoor, false); PS_ASSERT_PTR_NON_NULL(mask, false); PS_ASSERT_PTR_NON_NULL(model, false); float modelSum = 0; - float validSum = 0; + float notBadSum = 0; + float notPoorSum = 0; float sky = 0; float value; @@ -305,5 +328,6 @@ int dY, DY, NY; - *pixWeight = 0.0; + *pixWeightNotBad = 0.0; + *pixWeightNotPoor = 0.0; // we only care about the value of the object model, not the local sky @@ -345,28 +369,26 @@ // for the full model, add all points - value = model->modelFunc (NULL, params, coord) - sky; + value = fabs(model->modelFunc (NULL, params, coord) - sky); modelSum += value; // include count only the unmasked pixels within the image area - if (mx < 0) - continue; - if (my < 0) - continue; - if (mx >= NX) - continue; - if (my >= NY) - continue; - if (mask->data.PS_TYPE_IMAGE_MASK_DATA[my][mx] & maskVal) - continue; - - validSum += value; + if (mx < 0) continue; + if (my < 0) continue; + if (mx >= NX) continue; + if (my >= NY) continue; + + if (!(mask->data.PS_TYPE_IMAGE_MASK_DATA[my][mx] & maskVal)) { + notBadSum += value; + } + if (!(mask->data.PS_TYPE_IMAGE_MASK_DATA[my][mx] & ~markVal)) { + notPoorSum += value; + } } } psFree (coord); - if (validSum <= 0) - return false; - - *pixWeight = validSum / modelSum; + *pixWeightNotBad = notBadSum / modelSum; + *pixWeightNotPoor = notPoorSum / modelSum; + return (true); } @@ -374,6 +396,6 @@ # define FLUX_LIMIT 3.0 -// return source aperture magnitude -bool pmSourceMeasureDiffStats (pmSource *source, psImageMaskType maskVal) +// measure stats that may be using in difference images for distinguishing real sources from bad residuals +bool pmSourceMeasureDiffStats (pmSource *source, psImageMaskType maskVal, psImageMaskType markVal) { PS_ASSERT_PTR_NON_NULL(source, false); @@ -399,4 +421,8 @@ for (int iy = 0; iy < flux->numRows; iy++) { for (int ix = 0; ix < flux->numCols; ix++) { + // only count up the stats in the unmarked region (ie, the aperture) + if (mask->data.PS_TYPE_IMAGE_MASK_DATA[iy][ix] & markVal) { + continue; + } if (mask->data.PS_TYPE_IMAGE_MASK_DATA[iy][ix] & maskVal) { nMask ++; Index: /trunk/psModules/src/objects/pmSourcePhotometry.h =================================================================== --- /trunk/psModules/src/objects/pmSourcePhotometry.h (revision 29003) +++ /trunk/psModules/src/objects/pmSourcePhotometry.h (revision 29004) @@ -52,9 +52,11 @@ bool pmSourceMagnitudesInit (psMetadata *config); -bool pmSourceMagnitudes (pmSource *source, pmPSF *psf, pmSourcePhotometryMode mode, psImageMaskType maskVal); -bool pmSourcePixelWeight (float *pixWeight, pmModel *model, psImage *mask, psImageMaskType maskVal); +bool pmSourceMagnitudes (pmSource *source, pmPSF *psf, pmSourcePhotometryMode mode, psImageMaskType maskVal, psImageMaskType markVal); + +bool pmSourcePixelWeight (float *pixWeightNotBad, float *pixWeightNotPoor, pmModel *model, psImage *mask, psImageMaskType maskVal, psImageMaskType markVal); + bool pmSourceChisq (pmModel *model, psImage *image, psImage *mask, psImage *weight, psImageMaskType maskVal, const float covarFactor); -bool pmSourceMeasureDiffStats (pmSource *source, psImageMaskType maskVal); +bool pmSourceMeasureDiffStats (pmSource *source, psImageMaskType maskVal, psImageMaskType markVal); double pmSourceDataDotModel (const pmSource *Mi, const pmSource *Mj, const bool unweighted_sum, const float covarFactor, psImageMaskType maskVal); Index: /trunk/psModules/src/objects/pmSourcePlotApResid.c =================================================================== --- /trunk/psModules/src/objects/pmSourcePlotApResid.c (revision 29003) +++ /trunk/psModules/src/objects/pmSourcePlotApResid.c (revision 29004) @@ -25,15 +25,25 @@ #include "pmFPAview.h" #include "pmFPAfile.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmResiduals.h" -#include "pmGrowthCurve.h" -#include "pmTrend2D.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" #include "pmPSF.h" -#include "pmModel.h" #include "pmDetections.h" -#include "pmSource.h" + #include "pmSourcePlots.h" #include "pmKapaPlots.h" Index: /trunk/psModules/src/objects/pmSourcePlotMoments.c =================================================================== --- /trunk/psModules/src/objects/pmSourcePlotMoments.c (revision 29003) +++ /trunk/psModules/src/objects/pmSourcePlotMoments.c (revision 29004) @@ -28,15 +28,24 @@ #include "pmFPAview.h" #include "pmFPAfile.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmGrowthCurve.h" -#include "pmResiduals.h" -#include "pmTrend2D.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" #include "pmPSF.h" -#include "pmModel.h" #include "pmDetections.h" -#include "pmSource.h" #include "pmSourcePlots.h" #include "pmKapaPlots.h" Index: /trunk/psModules/src/objects/pmSourcePlotPSFModel.c =================================================================== --- /trunk/psModules/src/objects/pmSourcePlotPSFModel.c (revision 29003) +++ /trunk/psModules/src/objects/pmSourcePlotPSFModel.c (revision 29004) @@ -28,15 +28,25 @@ #include "pmFPAview.h" #include "pmFPAfile.h" + + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmGrowthCurve.h" -#include "pmResiduals.h" -#include "pmTrend2D.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" #include "pmPSF.h" -#include "pmModel.h" #include "pmDetections.h" -#include "pmSource.h" #include "pmSourcePlots.h" #include "pmKapaPlots.h" Index: /trunk/psModules/src/objects/pmSourceSky.c =================================================================== --- /trunk/psModules/src/objects/pmSourceSky.c (revision 29003) +++ /trunk/psModules/src/objects/pmSourceSky.c (revision 29004) @@ -21,17 +21,25 @@ #include #include + #include "pmHDU.h" #include "pmFPA.h" -#include "pmFPAMaskWeight.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmResiduals.h" -#include "pmGrowthCurve.h" -#include "pmTrend2D.h" -#include "pmPSF.h" +#include "pmModelFuncs.h" #include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" #include "pmSource.h" + #include "pmSourceSky.h" Index: /trunk/psModules/src/objects/pmSourceUtils.c =================================================================== --- /trunk/psModules/src/objects/pmSourceUtils.c (revision 29003) +++ /trunk/psModules/src/objects/pmSourceUtils.c (revision 29004) @@ -21,17 +21,25 @@ #include #include + #include "pmHDU.h" #include "pmFPA.h" -#include "pmFPAMaskWeight.h" + +#include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" #include "pmSpan.h" +#include "pmFootprintSpans.h" #include "pmFootprint.h" #include "pmPeaks.h" #include "pmMoments.h" -#include "pmResiduals.h" -#include "pmGrowthCurve.h" -#include "pmTrend2D.h" -#include "pmPSF.h" +#include "pmModelFuncs.h" #include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" #include "pmSource.h" + #include "pmSourceUtils.h" Index: /trunk/psModules/src/objects/pmSourceVisual.c =================================================================== --- /trunk/psModules/src/objects/pmSourceVisual.c (revision 29003) +++ /trunk/psModules/src/objects/pmSourceVisual.c (revision 29004) @@ -4,8 +4,28 @@ #include +#include "pmHDU.h" +#include "pmFPA.h" + #include "pmTrend2D.h" +#include "pmResiduals.h" +#include "pmGrowthCurve.h" +#include "pmSpan.h" +#include "pmFootprintSpans.h" +#include "pmFootprint.h" +#include "pmPeaks.h" +#include "pmMoments.h" +#include "pmModelFuncs.h" +#include "pmModel.h" +#include "pmModelUtils.h" +#include "pmModelClass.h" +#include "pmSourceMasks.h" +#include "pmSourceExtendedPars.h" +#include "pmSourceDiffStats.h" +#include "pmSource.h" +#include "pmSourceFitModel.h" #include "pmPSF.h" #include "pmPSFtry.h" -#include "pmSource.h" +#include "pmDetections.h" + #include "pmSourceVisual.h" @@ -13,4 +33,5 @@ #include #include "pmVisual.h" +#include "pmVisualUtils.h" // functions used to visualize the analysis as it goes @@ -34,5 +55,5 @@ Graphdata graphdata; - if (!pmVisualIsVisual()) return true; + if (!pmVisualTestLevel("psphot.psf.metric", 2)) return true; if (kapa1 == -1) { @@ -118,5 +139,5 @@ Graphdata graphdata; - if (!pmVisualIsVisual()) return true; + if (!pmVisualTestLevel("psphot.psf.subpix", 3)) return true; if (kapa1 == -1) { @@ -280,5 +301,5 @@ bool pmSourceVisualShowModelFits (pmPSF *psf, psArray *sources, psImageMaskType maskVal) { - if (!pmVisualIsVisual()) return true; + if (!pmVisualTestLevel("psphot.psf.fits", 2)) return true; if (kapa2 == -1) { @@ -360,5 +381,6 @@ bool pmSourceVisualShowModelFit (pmSource *source) { - if (!pmVisualIsVisual()) return true; + if (!pmVisualTestLevel("psphot.psf.fitresid", 2)) return true; + if (!source->pixels) return false; if (!source->modelFlux) return false; @@ -404,5 +426,6 @@ Graphdata graphdata; - if (!pmVisualIsVisual() || !plotPSF) return true; + if (!plotPSF) return true; + if (!pmVisualTestLevel("psphot.psf.resid", 2)) return true; if (kapa1 == -1) { Index: /trunk/psModules/src/objects/pmSpan.h =================================================================== --- /trunk/psModules/src/objects/pmSpan.h (revision 29003) +++ /trunk/psModules/src/objects/pmSpan.h (revision 29004) @@ -10,6 +10,4 @@ # ifndef PM_SPAN_H # define PM_SPAN_H - -#include /// @addtogroup Objects Object Detection / Analysis Functions Index: /trunk/psModules/src/objects/pmTrend2D.h =================================================================== --- /trunk/psModules/src/objects/pmTrend2D.h (revision 29003) +++ /trunk/psModules/src/objects/pmTrend2D.h (revision 29004) @@ -12,6 +12,4 @@ # ifndef PM_TREND_2D_H # define PM_TREND_2D_H - -#include /// @addtogroup Objects Object Detection / Analysis Functions Index: /trunk/psModules/src/psmodules.h =================================================================== --- /trunk/psModules/src/psmodules.h (revision 29003) +++ /trunk/psModules/src/psmodules.h (revision 29004) @@ -10,4 +10,5 @@ #include #include +#include #include #include @@ -113,4 +114,8 @@ // the following headers are from psModule:objects +#include +#include +#include + #include #include @@ -119,23 +124,23 @@ #include #include + +#include +#include + +#include #include #include -#include -#include -#include +#include +#include #include -#include -#include -#include +#include #include #include #include #include -#include #include #include #include #include -#include #include #include @@ -144,4 +149,5 @@ #include #include +#include // The following headers are from random locations, here because they cross bounds Index: /trunk/psphot/doc/notes.20100715.txt =================================================================== --- /trunk/psphot/doc/notes.20100715.txt (revision 29004) +++ /trunk/psphot/doc/notes.20100715.txt (revision 29004) @@ -0,0 +1,33 @@ + +2010.08.12 + + speeding up the PCM fitting. + + * first, I need to convert the convolutions to FFTs (double check that this will actually be faster!) + * second, I need to thread the PCM fitting process + + I have three options: + + 1) use the FFT threading in fftw -- each convolution would run threaded, but separate ones would be run in series + * con: the images are generally small, so the threading overhead may be large compared to the operation (test?) + 2) each pass of the minimization has 1 + N convolutions to perform: run these in separate threads + * can only use 1+N threads, where N is the number of free parameters (Io, Sxx, Syy, Sxy, but maybe also Xo, Yo) + 3) thread by source, using the system defined for the other fitting. + * since these source are large, this is a bit trickier to guarantee non-collision. + + infrastructure is easy -- copy psphotBlendFit. + +2010.07.15 + +various psphot issues that need to be addressed: + +* update extNsigma based on kron mags +* convert EXT sigmas to a probability (watch that extNsigma is correctly defined) +* psphot forced fails for negative flux + - do a run, plot a histogram of fluxes as various steps + FIXED: this was caused by minimum limit of 0.0 in linear fitting + +* capability to choose extended source fits based on |b| + +* update psf-convolved fitting to work with sersic (iteration) + DONE: but, needs to be sped up + Index: /trunk/psphot/doc/psf.load.txt =================================================================== --- /trunk/psphot/doc/psf.load.txt (revision 29004) +++ /trunk/psphot/doc/psf.load.txt (revision 29004) @@ -0,0 +1,75 @@ + +We need to have consistent behavior when we determine the PSF from the image or load it externally. + +Here is a list of the metadata info generated during the psphot analysis (these are mostly stored on the 'analysis' metadata, sometimes in chip and sometimes in readout). + + ANGLE : PSF Model position angle + APLOSS : flux lost out of reference aperture + APMIFIT : aperture magnitude - psf fit magnitude (aperture correction + DAPMIFIT : error on APMIFIT + *EFFECTIVE_AREA : effective area of the PSF model + FLIMIT : limiting flux (not currently set correctly) + FSATUR : saturation flux (not currently set correctly) + FWHM_MAJ : PSF Model FWHM (Major-Axis) + FWHM_MIN : PSF Model FWHM (Minor-Axis) + FW_MJ_LQ : PSF Model FWHM (Major-Axis lower quartile) + FW_MJ_SG : PSF Model FWHM (Major-Axis sigma) + FW_MJ_UQ : PSF Model FWHM (Major-Axis upper quartile) + FW_MN_LQ : PSF Model FWHM (Minor-Axis lower quartile) + FW_MN_SG : PSF Model FWHM (Minor-Axis sigma) + FW_MN_UQ : PSF Model FWHM (Minor-Axis upper quartile) + IQ_FW1 : Moments-based FWHM (Major-Axis) + IQ_FW1_E : Moments-based FWHM (Major-Axis Stdev) + IQ_FW2 : Moments-based FWHM (Minor-Axis) + IQ_FW2_E : Moments-based FWHM (Minor-Axis Stdev) + IQ_M2 : Moments-based shape parameter + IQ_M2C : Moments-based shape parameter + IQ_M2C_E : Moments-based shape parameter + IQ_M2C_L : Moments-based shape parameter + IQ_M2C_U : Moments-based shape parameter + IQ_M2S : Moments-based shape parameter + IQ_M2S_E : Moments-based shape parameter + IQ_M2S_L : Moments-based shape parameter + IQ_M2S_U : Moments-based shape parameter + IQ_M2_ER : Moments-based shape parameter + IQ_M2_LQ : Moments-based shape parameter + IQ_M2_UQ : Moments-based shape parameter + IQ_M3 : Moments-based shape parameter + IQ_M3_ER : Moments-based shape parameter + IQ_M3_LQ : Moments-based shape parameter + IQ_M3_UQ : Moments-based shape parameter + IQ_M4 : Moments-based shape parameter + IQ_M4_ER : Moments-based shape parameter + IQ_M4_LQ : Moments-based shape parameter + IQ_M4_UQ : Moments-based shape parameter + IQ_NSTAR : Number of sources used to measure moments-based parameters + MOMENTS_GAUSS_SIGMA : Sigma of Gaussian window used for moments analysis + MOMENTS_SX_MAX : max allowed Mxx (second moment in x) allowed for PSF clump + MOMENTS_SY_MAX : max allowed Myy (second moment in y) allowed for PSF clump + MSKY_MAX : Sky Model max value + MSKY_MIN : Sky Model min value + MSKY_MN : Sky Model mean value + MSKY_NX : Sky Model number of cells (x) + MSKY_NY : Sky Model number of cells (y) + MSKY_SIG : Sky Model sigma + NAPMIFIT : Number of stars used for APMIFIT analysis + NDET_CR : Number of sources classified as 'cosmic ray' + NDET_EXT : Number of sources classified as 'extended' + NPSFSTAR : Number of sources used for PSF model + NSTARS : Total number of sources + PEAK_THRESHOLD : threshold of peak detection analysis (saved but not re-used) + PSF.CLUMP.DX : size of clump in X + PSF.CLUMP.DY : size of clump in Y + PSF.CLUMP.NREGIONS : number of PSF clump regions measured for this image + PSF.CLUMP.X : center of clump in X + PSF.CLUMP.Y : center of clump in Y + PSFMODEL : do we have a valid PSF model? + PSF_APERTURE : aperture used to measure the aperture magnitude of PSF sources + PSF_CLUMP_GRID_SCALE: pixelization size used for PSF clump search + PSF_FIT_RADIUS : size of window used for PSF model fits + PSF_MAX_NSTARS : maximum number of sources used to find the PSF model + PSF_MOMENTS_RADIUS : size of window used for moments analysis (Gaussian window is applied within this radius) + SIGMA_SMOOTH : sigma of kernel used for smoothing to generate the significance + SIGNIFICANCE_SCALE_FACTOR : factor needed to adjust the level of the significance image + SKY_MEAN : mean of background + SKY_STDEV : stdev of full background image Index: /trunk/psphot/doc/visual.txt =================================================================== --- /trunk/psphot/doc/visual.txt (revision 29004) +++ /trunk/psphot/doc/visual.txt (revision 29004) @@ -0,0 +1,47 @@ + +Visualization Options + +image : display image +backgnd : display image +signif : display image + +show image : image 1 or object 1 +show background : image 2 or backgnd 1 +show significance : image 3 or signif 1 +show residual : image 2 or resid 1 + +XXX: these all need to have the image: +show peaks : object 1 or peaks 1 +show moments : object 2 or image.moments 1 +show footprints : object 3 or footprints 1 +show rough class : object 3 or class 3 +show flags : (disabled) +show size class : object 2 or class 2 +show petrosian : object 2 or petro 1 + +plot final moments (2D) : moments 1 +plot test moments (2D) : moments 2 +plot source sizes : class 1 +plot ap resid : apresid 1 +plot chisq : chisq 1 + +show PSF model : psf 1 +show PSF stars : psf 2 +show Sat stars : ? + +show radial profiles : profile + +petrosian visualization: + + psphotPetrosianVisualEllipticalContour + psphotPetrosianVisualStats + psphotPetrosianVisualProfileRadii + psphotPetrosianVisualProfileByAngle + +psphot visualization in psModules: + + pmSourceVisualPSFModelResid + pmSourceVisualShowModelFit + pmSourceVisualShowModelFits + pmSourceVisualPlotPSFMetricSubpix + pmSourceVisualPlotPSFMetric Index: /trunk/psphot/src/Makefile.am =================================================================== --- /trunk/psphot/src/Makefile.am (revision 29003) +++ /trunk/psphot/src/Makefile.am (revision 29004) @@ -163,10 +163,8 @@ psphotOutput.c \ psphotFakeSources.c \ - psphotModelWithPSF.c \ psphotExtendedSourceAnalysis.c \ psphotExtendedSourceAnalysisByObject.c \ psphotExtendedSourceFits.c \ psphotKernelFromPSF.c \ - psphotPSFConvModel.c \ psphotFitSet.c \ psphotSourceFreePixels.c \ Index: /trunk/psphot/src/psphot.h =================================================================== --- /trunk/psphot/src/psphot.h (revision 29003) +++ /trunk/psphot/src/psphot.h (revision 29004) @@ -12,12 +12,4 @@ #define PSPHOT_RECIPE_PSF_FAKE_ALLOW "PSF.FAKE.ALLOW" // Name for recipe component permitting fake PSFs - -// pmPCMData : PSF Convolved Model data storage structure -typedef struct { - psImage *model; - psArray *dmodels; - psImage *modelConv; - psArray *dmodelsConv; -} pmPCMData; // top-level psphot functions @@ -114,4 +106,5 @@ bool psphotExtendedSourceFits (pmConfig *config, const pmFPAview *view, const char *filerule); bool psphotExtendedSourceFitsReadout (pmConfig *config, const pmFPAview *view, const char *filerule, int index, psMetadata *recipe); +bool psphotExtendedSourceFits_Threaded (psThreadJob *job); bool psphotApResid (pmConfig *config, const pmFPAview *view, const char *filerule); @@ -188,11 +181,11 @@ // functions to set the correct source pixels -bool psphotInitRadiusPSF(const psMetadata *recipe, const psMetadata *analysis, const pmModelType type); +bool psphotInitRadiusPSF (psMetadata *recipe, pmReadout *readout); +bool psphotInitRadiusEXT (psMetadata *recipe, pmReadout *readout); bool psphotCheckRadiusPSF (pmReadout *readout, pmSource *source, pmModel *model, psImageMaskType markVal); bool psphotCheckRadiusPSFBlend (pmReadout *readout, pmSource *source, pmModel *model, psImageMaskType markVal, float dR); -bool psphotInitRadiusEXT (psMetadata *recipe, pmModelType type); -bool psphotCheckRadiusEXT (pmReadout *readout, pmSource *source, pmModel *model, psImageMaskType markVal); -float psphotSetRadiusEXT (pmReadout *readout, pmSource *source, psImageMaskType markVal); +bool psphotSetRadiusFootprint (float *radius, pmReadout *readout, pmSource *source, psImageMaskType markVal, float factor); +bool psphotSetRadiusModel (pmModel *model, pmReadout *readout, pmSource *source, psImageMaskType markVal, bool deep); bool psphotDumpMoments (psMetadata *recipe, psArray *sources); @@ -210,10 +203,10 @@ // functions to support the source fitting process bool psphotInitLimitsPSF (psMetadata *recipe, pmReadout *readout); -bool psphotInitLimitsEXT (psMetadata *recipe); -bool psphotFitBlend (pmReadout *readout, pmSource *source, pmPSF *psf, psImageMaskType maskVal, psImageMaskType markVal); -bool psphotFitBlob (pmReadout *readout, pmSource *source, psArray *sources, pmPSF *psf, psImageMaskType maskVal, psImageMaskType markVal); -bool psphotFitPSF (pmReadout *readout, pmSource *source, pmPSF *psf, psImageMaskType maskVal, psImageMaskType markVal); -pmModel *psphotFitEXT (pmReadout *readout, pmSource *source, pmModelType modelType, psImageMaskType maskVal, psImageMaskType markVal); -psArray *psphotFitDBL (pmReadout *readout, pmSource *source, psImageMaskType maskVal, psImageMaskType markVal); +bool psphotInitLimitsEXT (psMetadata *recipe, pmReadout *readout); +bool psphotFitBlend (pmReadout *readout, pmSource *source, pmPSF *psf, pmSourceFitOptions *fitOptions, psImageMaskType maskVal, psImageMaskType markVal); +bool psphotFitBlob (pmReadout *readout, pmSource *source, psArray *sources, pmPSF *psf, pmSourceFitOptions *fitOptions, psImageMaskType maskVal, psImageMaskType markVal); +bool psphotFitPSF (pmReadout *readout, pmSource *source, pmPSF *psf, pmSourceFitOptions *fitOptions, psImageMaskType maskVal, psImageMaskType markVal); +pmModel *psphotFitEXT (pmReadout *readout, pmSource *source, pmSourceFitOptions *fitOptions, pmModelType modelType, psImageMaskType maskVal, psImageMaskType markVal); +psArray *psphotFitDBL (pmReadout *readout, pmSource *source, pmSourceFitOptions *fitOptions, psImageMaskType maskVal, psImageMaskType markVal); // functions to support simultaneous multi-source fitting @@ -252,4 +245,5 @@ bool psphotVisualShowBackground (pmConfig *config, const pmFPAview *view, pmReadout *readout); bool psphotVisualShowSignificance (psImage *image, float min, float max); +bool psphotVisualShowLogSignificance (psImage *image, float min, float max); bool psphotVisualShowPeaks (pmDetections *detections); bool psphotVisualShowFootprints (pmDetections *detections); @@ -292,33 +286,4 @@ bool psphotRadialBins (psMetadata *recipe, pmSource *source, float radiusMax, float skynoise); -// structures & functions to support psf-convolved model fitting - -// psf-convolved model fitting -bool psphotModelWithPSF_LMM ( - psMinimization *min, - psImage *covar, - psVector *params, - psMinConstraint *constraint, - pmSource *source, - const psKernel *psf, - psMinimizeLMChi2Func func); - -psF32 psphotModelWithPSF_SetABX( - psImage *alpha, - psVector *beta, - const psVector *params, - const psVector *paramMask, - pmPCMData *pcm, - const pmSource *source, - const psKernel *psf, - psMinimizeLMChi2Func func); - -pmPCMData *pmPCMDataAlloc ( - const psVector *params, - const psVector *paramMask, - pmSource *source); - -psImage *pmPCMDataSaveImage (pmPCMData *pcm); - int psphotKapaOpen (void); bool psphotKapaClose (void); @@ -364,6 +329,4 @@ bool psphotFitSourcesLinearStack (pmConfig *config, psArray *objects, bool final); -int pmPhotObjSortBySN (const void **a, const void **b); -int pmPhotObjSortByX (const void **a, const void **b); typedef enum { @@ -462,3 +425,8 @@ bool psphotStackObjectsUnifyPosition (psArray *objects); +bool psphotFitSersicIndex (pmModel *model, pmReadout *readout, pmSource *source, pmSourceFitOptions *fitOptions, psImageMaskType maskVal, psImageMaskType markVal); + +bool psphotFitSersicIndexPCM (pmPCMdata *pcm, pmReadout *readout, pmSource *source, pmSourceFitOptions *fitOptions, psImageMaskType maskVal, psImageMaskType markVal, int psfSize); +pmModel *psphotFitPCM (pmReadout *readout, pmSource *source, pmSourceFitOptions *fitOptions, pmModelType modelType, psImageMaskType maskVal, psImageMaskType markVal, int psfSize); + #endif Index: /trunk/psphot/src/psphotAddNoise.c =================================================================== --- /trunk/psphot/src/psphotAddNoise.c (revision 29003) +++ /trunk/psphot/src/psphotAddNoise.c (revision 29004) @@ -34,7 +34,4 @@ bool status = false; - psEllipseShape oldshape; - psEllipseShape newshape; - psEllipseAxes axes; // find the currently selected readout @@ -86,44 +83,5 @@ if (!(source->tmpFlags & PM_SOURCE_TMPF_SUBTRACTED)) continue; - // select appropriate model - pmModel *model = pmSourceGetModel (NULL, source); - if (model == NULL) continue; // model must be defined - - if (add) { - psTrace ("psphot", 4, "adding noise for object at %f,%f\n", model->params->data.F32[PM_PAR_XPOS], model->params->data.F32[PM_PAR_YPOS]); - } else { - psTrace ("psphot", 4, "remove noise for object at %f,%f\n", model->params->data.F32[PM_PAR_XPOS], model->params->data.F32[PM_PAR_YPOS]); - } - - psF32 *PAR = model->params->data.F32; - - // save original values - float oldI0 = PAR[PM_PAR_I0]; - oldshape.sx = PAR[PM_PAR_SXX]; - oldshape.sy = PAR[PM_PAR_SYY]; - oldshape.sxy = PAR[PM_PAR_SXY]; - - // XXX can this be done more intelligently? - if (oldI0 == 0.0) continue; - if (!isfinite(oldI0)) continue; - - // increase size and height of source - axes = psEllipseShapeToAxes (oldshape, 20.0); - axes.major *= SIZE; - axes.minor *= SIZE; - newshape = psEllipseAxesToShape (axes); - PAR[PM_PAR_I0] = FACTOR*oldI0; - PAR[PM_PAR_SXX] = newshape.sx; - PAR[PM_PAR_SYY] = newshape.sy; - PAR[PM_PAR_SXY] = newshape.sxy; - - // XXX if we use pmSourceOp, the size (and possibly Io) will not be respected - pmSourceOp (source, PM_MODEL_OP_FULL | PM_MODEL_OP_NOISE, add, maskVal, 0, 0); - - // restore original values - PAR[PM_PAR_I0] = oldI0; - PAR[PM_PAR_SXX] = oldshape.sx; - PAR[PM_PAR_SYY] = oldshape.sy; - PAR[PM_PAR_SXY] = oldshape.sxy; + pmSourceNoiseOp (source, PM_MODEL_OP_FULL | PM_MODEL_OP_NOISE, FACTOR, SIZE, add, maskVal, 0, 0); } if (add) { @@ -132,4 +90,5 @@ psLogMsg ("psphot.noise", PS_LOG_INFO, "sub noise for %ld objects: %f sec\n", sources->n, psTimerMark ("psphot.noise")); } + return true; } Index: /trunk/psphot/src/psphotApResid.c =================================================================== --- /trunk/psphot/src/psphotApResid.c (revision 29003) +++ /trunk/psphot/src/psphotApResid.c (revision 29004) @@ -459,5 +459,5 @@ psImageKeepCircle (source->maskObj, source->peak->x, source->peak->y, source->apRadius, "OR", markVal); - bool status = pmSourceMagnitudes (source, psf, photMode, maskVal); + bool status = pmSourceMagnitudes (source, psf, photMode, maskVal, markVal); // clear the mask bit Index: /trunk/psphot/src/psphotArguments.c =================================================================== --- /trunk/psphot/src/psphotArguments.c (revision 29003) +++ /trunk/psphot/src/psphotArguments.c (revision 29004) @@ -176,10 +176,4 @@ } - // visual : interactive display mode - if ((N = psArgumentGet (argc, argv, "-visual"))) { - psArgumentRemove (N, &argc, argv); - pmVisualSetVisual(true); - } - // break : used from recipe throughout psphotReadout if ((N = psArgumentGet (argc, argv, "-break"))) { Index: /trunk/psphot/src/psphotBlendFit.c =================================================================== --- /trunk/psphot/src/psphotBlendFit.c (revision 29003) +++ /trunk/psphot/src/psphotBlendFit.c (revision 29004) @@ -65,19 +65,31 @@ assert (status && fitIter > 0); - float fitTol = psMetadataLookupF32 (&status, recipe, "EXT_FIT_TOL"); // Fit tolerance - assert (status && isfinite(fitTol) && fitTol > 0); + float fitMinTol = psMetadataLookupF32 (&status, recipe, "EXT_FIT_MIN_TOL"); // Fit tolerance + assert (status && isfinite(fitMinTol) && fitMinTol > 0); + + float fitMaxTol = psMetadataLookupF32 (&status, recipe, "EXT_FIT_MAX_TOL"); // Fit tolerance + assert (status && isfinite(fitMaxTol) && fitMaxTol > 0); bool poisson = psMetadataLookupBool(&status, recipe, "POISSON.ERRORS.PHOT.LMM"); // Poisson errors? assert (status); + float maxChisqDOF = psMetadataLookupF32 (&status, recipe, "EXT_FIT_MAX_CHISQ"); // Fit tolerance + float skySig = psMetadataLookupF32(&status, recipe, "SKY_SIG"); assert (status && isfinite(skySig) && skySig > 0); // Define source fitting parameters for extended source fits - pmSourceFitModelInit(fitIter, fitTol, PS_SQR(skySig), poisson); + pmSourceFitOptions *fitOptions = pmSourceFitOptionsAlloc(); + fitOptions->nIter = fitIter; + fitOptions->minTol = fitMinTol; + fitOptions->maxTol = fitMaxTol; + fitOptions->maxChisqDOF = maxChisqDOF; + fitOptions->poissonErrors = poisson; + fitOptions->weight = PS_SQR(skySig); + fitOptions->mode = PM_SOURCE_FIT_PSF; psphotInitLimitsPSF (recipe, readout); - psphotInitLimitsEXT (recipe); - psphotInitRadiusPSF (recipe, readout->analysis, psf->type); + psphotInitLimitsEXT (recipe, readout); + psphotInitRadiusPSF (recipe, readout); // starts the timer, sets up the array of fitSets @@ -88,4 +100,5 @@ if (!sources->n) { psLogMsg ("psphot", PS_LOG_INFO, "no sources, skipping blend"); + psFree (fitOptions); return true; } @@ -112,4 +125,5 @@ psArrayAdd(job->args, 1, psf); psArrayAdd(job->args, 1, newSources); // return for new sources + psArrayAdd(job->args, 1, fitOptions); // default fit options psFree (newSources); @@ -121,31 +135,7 @@ if (!psThreadJobAddPending(job)) { psError(PS_ERR_UNKNOWN, false, "Unable to guess model."); + psFree (fitOptions); return NULL; } - -# if (0) - { - int nfit = 0; - int npsf = 0; - int next = 0; - int nfail = 0; - psArray *newSources = psArrayAllocEmpty(16); - - if (!psphotBlendFit_Unthreaded (&nfit, &npsf, &next, &nfail, readout, recipe, cells->data[j], psf, newSources)) { - psError(PS_ERR_UNKNOWN, false, "Unable to guess model."); - return NULL; - } - Nfit += nfit; - Npsf += npsf; - Next += next; - Nfail += nfail; - - // add these back onto sources - for (int k = 0; k < newSources->n; k++) { - psArrayAdd (sources, 16, newSources->data[k]); - } - psFree (newSources); - } -# endif } @@ -153,4 +143,5 @@ if (!psThreadPoolWait (false)) { psError(PS_ERR_UNKNOWN, false, "Unable to guess model."); + psFree (fitOptions); return NULL; } @@ -163,11 +154,11 @@ } else { psScalar *scalar = NULL; - scalar = job->args->data[5]; + scalar = job->args->data[6]; Nfit += scalar->data.S32; - scalar = job->args->data[6]; + scalar = job->args->data[7]; Npsf += scalar->data.S32; - scalar = job->args->data[7]; + scalar = job->args->data[8]; Next += scalar->data.S32; - scalar = job->args->data[8]; + scalar = job->args->data[9]; Nfail += scalar->data.S32; @@ -186,4 +177,5 @@ psphotSaveImage (NULL, readout->image, "image.v2.fits"); } + psFree (fitOptions); psLogMsg ("psphot.psphotBlendFit", PS_LOG_INFO, "fit models: %f sec for %d objects (%d psf, %d ext, %d failed, %ld skipped)\n", psTimerMark ("psphot.fit.nonlinear"), Nfit, Npsf, Next, Nfail, sources->n - Nfit); @@ -204,9 +196,10 @@ psScalar *scalar = NULL; - pmReadout *readout = job->args->data[0]; - psMetadata *recipe = job->args->data[1]; - psArray *sources = job->args->data[2]; - pmPSF *psf = job->args->data[3]; - psArray *newSources = job->args->data[4]; + pmReadout *readout = job->args->data[0]; + psMetadata *recipe = job->args->data[1]; + psArray *sources = job->args->data[2]; + pmPSF *psf = job->args->data[3]; + psArray *newSources = job->args->data[4]; + pmSourceFitOptions *fitOptions = job->args->data[5]; // bit-masks to test for good/bad pixels @@ -269,8 +262,14 @@ Nfit ++; + if (0) { + psF32 Mxx = source->moments->Mxx; + psF32 Myy = source->moments->Myy; + fprintf (stderr, "1: Mxx: %f, Myy: %f\n", Mxx, Myy); + } + // try fitting PSFs or extended sources depending on source->mode // these functions subtract the resulting fitted source if (source->mode & PM_SOURCE_MODE_EXT_LIMIT) { - if (psphotFitBlob (readout, source, newSources, psf, maskVal, markVal)) { + if (psphotFitBlob (readout, source, newSources, psf, fitOptions, maskVal, markVal)) { source->type = PM_SOURCE_TYPE_EXTENDED; psTrace ("psphot", 5, "source at %7.1f, %7.1f is ext", source->peak->xf, source->peak->yf); @@ -280,5 +279,5 @@ } } else { - if (psphotFitBlend (readout, source, psf, maskVal, markVal)) { + if (psphotFitBlend (readout, source, psf, fitOptions, maskVal, markVal)) { source->type = PM_SOURCE_TYPE_STAR; psTrace ("psphot", 5, "source at %7.1f, %7.1f is psf", source->peak->xf, source->peak->yf); @@ -289,4 +288,10 @@ } + if (0) { + psF32 Mxx = source->moments->Mxx; + psF32 Myy = source->moments->Myy; + fprintf (stderr, "2: Mxx: %f, Myy: %f\n", Mxx, Myy); + } + psTrace ("psphot", 5, "source at %7.1f, %7.1f failed", source->peak->xf, source->peak->yf); Nfail ++; @@ -298,14 +303,14 @@ // change the value of a scalar on the array (wrap this and put it in psArray.h) - scalar = job->args->data[5]; + scalar = job->args->data[6]; scalar->data.S32 = Nfit; - scalar = job->args->data[6]; + scalar = job->args->data[7]; scalar->data.S32 = Npsf; - scalar = job->args->data[7]; + scalar = job->args->data[8]; scalar->data.S32 = Next; - scalar = job->args->data[8]; + scalar = job->args->data[9]; scalar->data.S32 = Nfail; Index: /trunk/psphot/src/psphotChoosePSF.c =================================================================== --- /trunk/psphot/src/psphotChoosePSF.c (revision 29003) +++ /trunk/psphot/src/psphotChoosePSF.c (revision 29004) @@ -74,5 +74,5 @@ // structure to store user options defining the psf - pmPSFOptions *options = pmPSFOptionsAlloc (); + pmPSFOptions *options = pmPSFOptionsAlloc(); // load user options from the recipe. no need to check existence -- they are @@ -138,11 +138,28 @@ return false; } - float fitTol = psMetadataLookupF32 (&status, recipe, "PSF_FIT_TOL"); // Fit tolerance - if (!status || !isfinite(fitTol) || fitTol <= 0) { - psError(PS_ERR_BAD_PARAMETER_VALUE, true, "PSF_FIT_TOL is not positive"); - return false; - } - pmSourceFitModelInit(fitIter, fitTol, PS_SQR(SKY_SIG), options->poissonErrorsPhotLMM); - + float fitMinTol = psMetadataLookupF32 (&status, recipe, "PSF_FIT_MIN_TOL"); // Fit tolerance + if (!status || !isfinite(fitMinTol) || fitMinTol <= 0) { + fitMinTol = psMetadataLookupF32 (&status, recipe, "PSF_FIT_TOL"); // Fit tolerance + if (!status || !isfinite(fitMinTol) || fitMinTol <= 0) { + psError(PS_ERR_BAD_PARAMETER_VALUE, true, "PSF_FIT_MIN_TOL (and PSF_FIT_TOL) not defined or positive"); + return false; + } + } + float fitMaxTol = psMetadataLookupF32 (&status, recipe, "PSF_FIT_MAX_TOL"); // Fit tolerance + if (!status || !isfinite(fitMaxTol) || fitMaxTol <= 0) { + fitMaxTol = 1.0; + } + float maxChisqDOF = psMetadataLookupF32 (&status, recipe, "PSF_FIT_MAX_CHISQ"); // Fit tolerance + + // options which modify the behavior of the model fitting + options->fitOptions = pmSourceFitOptionsAlloc(); + options->fitOptions->nIter = fitIter; + options->fitOptions->minTol = fitMinTol; + options->fitOptions->maxTol = fitMaxTol; + options->fitOptions->maxChisqDOF = maxChisqDOF; + options->fitOptions->poissonErrors = options->poissonErrorsPhotLMM; + options->fitOptions->weight = PS_SQR(SKY_SIG); + options->fitOptions->mode = PM_SOURCE_FIT_PSF; + psArray *stars = psArrayAllocEmpty (sources->n); @@ -227,4 +244,5 @@ // try each model option listed in config + // pmPSFtryModel makes a local copy of the sources -- those points are not the same as those for 'sources' for (int i = 0; i < modelNames->n; i++) { char *modelName = modelNames->data[i]; @@ -304,10 +322,42 @@ // unset the PSFSTAR flag for stars not used for PSF model + // XXX a more efficient way of achieving this would be to record a pair of arrays + // of the source index and the source id for the psf stars. but that would require we do + // not re-sort the source list in the meanwhile + int nDrop = 0; for (int i = 0; i < try->sources->n; i++) { pmSource *source = try->sources->data[i]; if (try->mask->data.PS_TYPE_VECTOR_MASK_DATA[i]) { - source->mode &= ~PM_SOURCE_MODE_PSFSTAR; - } - } + // need to find this source in the original list (these are copies, not pointers) + for (int j = 0; j < sources->n; j++) { + pmSource *realSource = sources->data[j]; + if (realSource->id != source->id) continue; + realSource->mode &= ~PM_SOURCE_MODE_PSFSTAR; + source->mode &= ~PM_SOURCE_MODE_PSFSTAR; + nDrop ++; + break; + } + } + } + // fprintf (stderr, "drop %d stars as PSF stars\n", nDrop); + + // XXX is this working? + // int N1 = 0; + // for (int i = 0; i < try->sources->n; i++) { + // pmSource *source = try->sources->data[i]; + // fprintf (stderr, "%llx : %d\n", (long long int) source, (source->mode & PM_SOURCE_MODE_PSFSTAR)); + // if (source->mode & PM_SOURCE_MODE_PSFSTAR) { + // N1 ++; + // } + // } + // int N2 = 0; + // for (int i = 0; i < sources->n; i++) { + // pmSource *source = sources->data[i]; + // fprintf (stderr, "%llx : %d\n", (long long int) source, (source->mode & PM_SOURCE_MODE_PSFSTAR)); + // if (source->mode & PM_SOURCE_MODE_PSFSTAR) { + // N2 ++; + // } + // } + // fprintf (stderr, "N1: %d, N2: %d\n", N1, N2); // build a PSF residual image Index: /trunk/psphot/src/psphotEllipticalContour.c =================================================================== --- /trunk/psphot/src/psphotEllipticalContour.c (revision 29003) +++ /trunk/psphot/src/psphotEllipticalContour.c (revision 29004) @@ -82,5 +82,5 @@ params->data.F32[PAR_RMIN] = Rmin; - psMinimization *myMin = psMinimizationAlloc (25, 0.001); + psMinimization *myMin = psMinimizationAlloc (25, 0.01, 1.00); psImage *covar = psImageAlloc (params->n, params->n, PS_TYPE_F32); Index: /trunk/psphot/src/psphotExtendedSourceAnalysis.c =================================================================== --- /trunk/psphot/src/psphotExtendedSourceAnalysis.c (revision 29003) +++ /trunk/psphot/src/psphotExtendedSourceAnalysis.c (revision 29004) @@ -157,27 +157,4 @@ } -# if (0) - // Isophotal Mags - if (doIsophotal) { - if (!psphotIsophotal (source, recipe, maskVal)) { - psTrace ("psphot", 5, "failed to measure isophotal mags for source at %7.1f, %7.1f", source->moments->Mx, source->moments->My); - } else { - psTrace ("psphot", 5, "measured isophotal mags for source at %7.1f, %7.1f", source->moments->Mx, source->moments->My); - Nisophot ++; - source->mode |= PM_SOURCE_MODE_EXTENDED_STATS; - } - } - // Kron Mags - if (doKron) { - if (!psphotKron (source, recipe, maskVal)) { - psTrace ("psphot", 5, "failed to measure kron mags for source at %7.1f, %7.1f", source->moments->Mx, source->moments->My); - } else { - psTrace ("psphot", 5, "measure kron mags for source at %7.1f, %7.1f", source->moments->Mx, source->moments->My); - Nkron ++; - source->mode |= PM_SOURCE_MODE_EXTENDED_STATS; - } - } -# endif - // re-subtract the object, leave local sky pmSourceSub (source, PM_MODEL_OP_FULL, maskVal); Index: /trunk/psphot/src/psphotExtendedSourceFits.c =================================================================== --- /trunk/psphot/src/psphotExtendedSourceFits.c (revision 29003) +++ /trunk/psphot/src/psphotExtendedSourceFits.c (revision 29004) @@ -31,4 +31,186 @@ // non-linear model fitting for extended sources bool psphotExtendedSourceFitsReadout (pmConfig *config, const pmFPAview *view, const char *filerule, int index, psMetadata *recipe) { + + bool status; + int Next = 0; + int Nconvolve = 0; + int NconvolvePass = 0; + int Nplain = 0; + int NplainPass = 0; + + psTimerStart ("psphot.extended"); + + // find the currently selected readout + pmFPAfile *file = pmFPAfileSelectSingle(config->files, filerule, index); // File of interest + psAssert (file, "missing file?"); + + pmReadout *readout = pmFPAviewThisReadout(view, file->fpa); + psAssert (readout, "missing readout?"); + + pmDetections *detections = psMetadataLookupPtr (&status, readout->analysis, "PSPHOT.DETECTIONS"); + psAssert (detections, "missing detections?"); + + psArray *sources = detections->allSources; + psAssert (sources, "missing sources?"); + + if (!sources->n) { + psLogMsg ("psphot", PS_LOG_INFO, "no sources, skipping source size"); + return true; + } + + // determine the number of allowed threads + int nThreads = psMetadataLookupS32(&status, config->arguments, "NTHREADS"); // Number of threads + if (!status) { + nThreads = 0; + } + + // user-defined masks to test for good/bad pixels (build from recipe list if not yet set) + psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels + assert (maskVal); + + psImageMaskType markVal = psMetadataLookupImageMask(&status, recipe, "MARK.PSPHOT"); // Mask value for bad pixels + assert (markVal); + + // maskVal is used to test for rejected pixels, and must include markVal + maskVal |= markVal; + + // select the collection of desired models + psMetadata *models = psMetadataLookupMetadata (&status, recipe, "EXTENDED_SOURCE_MODELS"); + if (!status) { + psWarning ("extended source model fits requested but model model is missing (EXTENDED_SOURCE_MODELS)\n"); + return true; + } + if (models->list->n == 0) { + psWarning ("extended source model fits requested but no models are specified\n"); + return true; + } + + // validate the model entries + psMetadataIterator *iter = psMetadataIteratorAlloc (models, PS_LIST_HEAD, NULL); + psMetadataItem *item = NULL; + while ((item = psMetadataGetAndIncrement (iter)) != NULL) { + + if (item->type != PS_DATA_METADATA) { + psAbort ("Invalid type for EXTENDED_SOURCE_MODEL entry %s, not a metadata folder", item->name); + // XXX we could cull the bad entries or build a validated model folder + } + + psMetadata *model = (psMetadata *) item->data.md; + + // check on the model type + char *modelName = psMetadataLookupStr (&status, model, "MODEL"); + int modelType = pmModelClassGetType (modelName); + if (modelType < 0) { + psAbort ("Unknown model class for EXTENDED_SOURCE_MODEL entry %s: %s", item->name, modelName); + } + psMetadataAddS32 (model, PS_LIST_TAIL, "MODEL_TYPE", PS_META_REPLACE, "", modelType); + + // check on the SNLIM, set a float value + char *SNword = psMetadataLookupStr (&status, model, "SNLIM"); + if (!status) { + psAbort("SNLIM not defined for extended source model %s\n", item->name); + } + float SNlim = atof (SNword); + psMetadataAddF32 (model, PS_LIST_TAIL, "SNLIM_VALUE", PS_META_REPLACE, "", SNlim); + + // check on the PSF-Convolution status + char *convolvedWord = psMetadataLookupStr (&status, model, "PSF_CONVOLVED"); + if (!status || (strcasecmp (convolvedWord, "true") && strcasecmp (convolvedWord, "false"))) { + psAbort ("PSF_CONVOLVED entry invalid or missing for EXTENDED_SOURCE_MODEL entry %s", item->name); + } + bool convolved = !strcasecmp (convolvedWord, "true"); + psMetadataAddBool (model, PS_LIST_TAIL, "PSF_CONVOLVED_VALUE", PS_META_REPLACE, "", convolved); + } + psFree (iter); + + // option to limit analysis to a specific region + char *region = psMetadataLookupStr (&status, recipe, "ANALYSIS_REGION"); + psRegion *AnalysisRegion = psRegionAlloc(0,0,0,0); + *AnalysisRegion = psRegionForImage(readout->image, psRegionFromString (region)); + if (psRegionIsNaN (*AnalysisRegion)) psAbort("analysis region mis-defined"); + + // what fraction of the PSF is used? (radius in pixels : 2 -> 5x5 box) + int psfSize = psMetadataLookupS32 (&status, recipe, "PCM_BOX_SIZE"); + assert (status); + + // source analysis is done in S/N order (brightest first) + sources = psArraySort (sources, pmSourceSortBySN); + + // choose Cx, Cy (see psphotThreadTools.c for overview of the concepts) + int Cx = 1, Cy = 1; + psphotChooseCellSizes (&Cx, &Cy, readout, nThreads); + + psArray *cellGroups = psphotAssignSources (Cx, Cy, sources); + + for (int i = 0; i < cellGroups->n; i++) { + + psArray *cells = cellGroups->data[i]; + + for (int j = 0; j < cells->n; j++) { + + // allocate a job -- if threads are not defined, this just runs the job + psThreadJob *job = psThreadJobAlloc ("PSPHOT_EXTENDED_FIT"); + + psArrayAdd(job->args, 1, readout); + psArrayAdd(job->args, 1, cells->data[j]); // sources + psArrayAdd(job->args, 1, models); + psArrayAdd(job->args, 1, AnalysisRegion); // XXX make a pointer + + PS_ARRAY_ADD_SCALAR(job->args, psfSize, PS_TYPE_S32); + PS_ARRAY_ADD_SCALAR(job->args, maskVal, PS_TYPE_IMAGE_MASK); + PS_ARRAY_ADD_SCALAR(job->args, markVal, PS_TYPE_IMAGE_MASK); + + PS_ARRAY_ADD_SCALAR(job->args, 0, PS_TYPE_S32); // this is used as a return value for Next + PS_ARRAY_ADD_SCALAR(job->args, 0, PS_TYPE_S32); // this is used as a return value for Nconvolve + PS_ARRAY_ADD_SCALAR(job->args, 0, PS_TYPE_S32); // this is used as a return value for NconvolvePass + PS_ARRAY_ADD_SCALAR(job->args, 0, PS_TYPE_S32); // this is used as a return value for Nplain + PS_ARRAY_ADD_SCALAR(job->args, 0, PS_TYPE_S32); // this is used as a return value for NplainPass + + if (!psThreadJobAddPending(job)) { + psError(PS_ERR_UNKNOWN, false, "Unable to guess model."); + psFree(AnalysisRegion); + return false; + } + } + + // wait for the threads to finish and manage results + if (!psThreadPoolWait (false)) { + psError(PS_ERR_UNKNOWN, false, "Unable to guess model."); + psFree(AnalysisRegion); + return false; + } + + // we have only supplied one type of job, so we can assume the types here + psThreadJob *job = NULL; + while ((job = psThreadJobGetDone()) != NULL) { + if (job->args->n < 1) { + fprintf (stderr, "error with job\n"); + } else { + psScalar *scalar = NULL; + scalar = job->args->data[7]; + Next += scalar->data.S32; + scalar = job->args->data[8]; + Nconvolve += scalar->data.S32; + scalar = job->args->data[9]; + NconvolvePass += scalar->data.S32; + scalar = job->args->data[10]; + Nplain += scalar->data.S32; + scalar = job->args->data[11]; + NplainPass += scalar->data.S32; + } + psFree(job); + } + } + psFree (cellGroups); + psFree(AnalysisRegion); + + psLogMsg ("psphot", PS_LOG_INFO, "extended source analysis: %f sec for %d objects\n", psTimerMark ("psphot.extended"), Next); + psLogMsg ("psphot", PS_LOG_INFO, " %d convolved models (%d passed)\n", Nconvolve, NconvolvePass); + psLogMsg ("psphot", PS_LOG_INFO, " %d plain models (%d passed)\n", Nplain, NplainPass); + return true; +} + +// non-linear model fitting for extended sources +bool psphotExtendedSourceFits_Threaded (psThreadJob *job) { bool status; @@ -39,93 +221,24 @@ int NplainPass = 0; bool savePics = false; - - // find the currently selected readout - pmFPAfile *file = pmFPAfileSelectSingle(config->files, filerule, index); // File of interest - psAssert (file, "missing file?"); - - pmReadout *readout = pmFPAviewThisReadout(view, file->fpa); - psAssert (readout, "missing readout?"); - - pmDetections *detections = psMetadataLookupPtr (&status, readout->analysis, "PSPHOT.DETECTIONS"); - psAssert (detections, "missing detections?"); - - psArray *sources = detections->allSources; - psAssert (sources, "missing sources?"); - - if (!sources->n) { - psLogMsg ("psphot", PS_LOG_INFO, "no sources, skipping source size"); - return true; - } - - // user-defined masks to test for good/bad pixels (build from recipe list if not yet set) - psImageMaskType maskVal = psMetadataLookupImageMask(&status, recipe, "MASK.PSPHOT"); // Mask value for bad pixels - assert (maskVal); - - psImageMaskType markVal = psMetadataLookupImageMask(&status, recipe, "MARK.PSPHOT"); // Mask value for bad pixels - assert (markVal); - - // maskVal is used to test for rejected pixels, and must include markVal - maskVal |= markVal; - - // select the collection of desired models - psMetadata *models = psMetadataLookupMetadata (&status, recipe, "EXTENDED_SOURCE_MODELS"); - if (!status) { - psWarning ("extended source model fits requested but model model is missing (EXTENDED_SOURCE_MODELS)\n"); - return true; - } - if (models->list->n == 0) { - psWarning ("extended source model fits requested but no models are specified\n"); - return true; - } - - // validate the model entries - psMetadataIterator *iter = psMetadataIteratorAlloc (models, PS_LIST_HEAD, NULL); - psMetadataItem *item = NULL; - while ((item = psMetadataGetAndIncrement (iter)) != NULL) { - - if (item->type != PS_DATA_METADATA) { - psAbort ("Invalid type for EXTENDED_SOURCE_MODEL entry %s, not a metadata folder", item->name); - // XXX we could cull the bad entries or build a validated model folder - } - - psMetadata *model = (psMetadata *) item->data.md; - - // check on the model type - char *modelName = psMetadataLookupStr (&status, model, "MODEL"); - int modelType = pmModelClassGetType (modelName); - if (modelType < 0) { - psAbort ("Unknown model class for EXTENDED_SOURCE_MODEL entry %s: %s", item->name, modelName); - } - psMetadataAddS32 (model, PS_LIST_TAIL, "MODEL_TYPE", PS_META_REPLACE, "", modelType); - - // check on the SNLIM, set a float value - char *SNword = psMetadataLookupStr (&status, model, "SNLIM"); - if (!status) { - psAbort("SNLIM not defined for extended source model %s\n", item->name); - } - float SNlim = atof (SNword); - psMetadataAddF32 (model, PS_LIST_TAIL, "SNLIM_VALUE", PS_META_REPLACE, "", SNlim); - - // check on the PSF-Convolution status - char *convolvedWord = psMetadataLookupStr (&status, model, "PSF_CONVOLVED"); - if (!status || (strcasecmp (convolvedWord, "true") && strcasecmp (convolvedWord, "false"))) { - psAbort ("PSF_CONVOLVED entry invalid or missing for EXTENDED_SOURCE_MODEL entry %s", item->name); - } - bool convolved = !strcasecmp (convolvedWord, "true"); - psMetadataAddBool (model, PS_LIST_TAIL, "PSF_CONVOLVED_VALUE", PS_META_REPLACE, "", convolved); - } - psFree (iter); - - // option to limit analysis to a specific region - char *region = psMetadataLookupStr (&status, recipe, "ANALYSIS_REGION"); - psRegion AnalysisRegion = psRegionForImage (readout->image, psRegionFromString (region)); - if (psRegionIsNaN (AnalysisRegion)) psAbort("analysis region mis-defined"); - - // what fraction of the PSF is used? (radius in pixels : 2 -> 5x5 box) - int psfSize = psMetadataLookupS32 (&status, recipe, "PCM_BOX_SIZE"); - assert (status); - - // source analysis is done in S/N order (brightest first) - sources = psArraySort (sources, pmSourceSortBySN); + float radius; + psScalar *scalar = NULL; + + // arguments: readout, sources, models, region, psfSize, maskVal, markVal + pmReadout *readout = job->args->data[0]; + psArray *sources = job->args->data[1]; + psMetadata *models = job->args->data[2]; + psRegion *region = job->args->data[3]; + int psfSize = PS_SCALAR_VALUE(job->args->data[4],PS_TYPE_IMAGE_MASK_DATA); + psImageMaskType maskVal = PS_SCALAR_VALUE(job->args->data[5],PS_TYPE_IMAGE_MASK_DATA); + psImageMaskType markVal = PS_SCALAR_VALUE(job->args->data[6],PS_TYPE_IMAGE_MASK_DATA); + + // Define source fitting parameters for extended source fits + pmSourceFitOptions *fitOptions = pmSourceFitOptionsAlloc(); + fitOptions->mode = PM_SOURCE_FIT_EXT; + // XXX for now, use the defaults for the rest: + // fitOptions->nIter = fitIter; + // fitOptions->tol = fitTol; + // fitOptions->poissonErrors = poisson; + // fitOptions->weight = PS_SQR(skySig); // choose the sources of interest @@ -140,8 +253,8 @@ // XXX this should use peak? - if (source->peak->x < AnalysisRegion.x0) continue; - if (source->peak->y < AnalysisRegion.y0) continue; - if (source->peak->x > AnalysisRegion.x1) continue; - if (source->peak->y > AnalysisRegion.y1) continue; + if (source->peak->x < region->x0) continue; + if (source->peak->y < region->y0) continue; + if (source->peak->x > region->x1) continue; + if (source->peak->y > region->y1) continue; // if model is NULL, we don't have a starting guess @@ -154,4 +267,22 @@ } Next ++; + + // set the radius based on the footprint (also sets the mask pixels) + if (!psphotSetRadiusFootprint(&radius, readout, source, markVal, 1.0)) { + psFree (fitOptions) + return false; + } + + // XXX note that this changes the source moments that are published... + // recalculate the source moments using the larger extended-source moments radius + // at this stage, skip Gaussian windowing, and do not clip pixels by S/N + // this uses the footprint to judge both radius and aperture? + // XXX save the psf-based moments for output + if (!pmSourceMoments (source, radius, 0.0, 0.0, maskVal)) { + // subtract the best fit from the object, leave local sky + pmSourceSub (source, PM_MODEL_OP_FULL, maskVal); + // XXX raise an error of some kind + continue; + } // save the modelFlux here in case we need to subtract it (for failure) @@ -201,5 +332,5 @@ pmModel *modelFit = NULL; if (convolved) { - modelFit = psphotPSFConvModel (readout, source, modelType, maskVal, markVal, psfSize); + modelFit = psphotFitPCM (readout, source, fitOptions, modelType, maskVal, markVal, psfSize); if (!modelFit) { psTrace ("psphot", 5, "failed to fit psf-conv model for object at %f, %f", source->moments->Mx, source->moments->My); @@ -215,5 +346,5 @@ psFree (source->modelFlux); source->modelFlux = NULL; - modelFit = psphotFitEXT (readout, source, modelType, maskVal, markVal); + modelFit = psphotFitEXT (readout, source, fitOptions, modelType, maskVal, markVal); if (!modelFit) { psTrace ("psphot", 5, "failed to fit plain model for object at %f, %f", source->moments->Mx, source->moments->My); @@ -233,4 +364,5 @@ // test for fit quality / result + modelFit->fitRadius = radius; psArrayAdd (source->modelFits, 4, modelFit); @@ -311,8 +443,22 @@ } } - - psLogMsg ("psphot", PS_LOG_INFO, "extended source analysis: %f sec for %d objects\n", psTimerMark ("psphot"), Next); - psLogMsg ("psphot", PS_LOG_INFO, " %d convolved models (%d passed)\n", Nconvolve, NconvolvePass); - psLogMsg ("psphot", PS_LOG_INFO, " %d plain models (%d passed)\n", Nplain, NplainPass); + psFree (fitOptions); + + // change the value of a scalar on the array (wrap this and put it in psArray.h) + scalar = job->args->data[7]; + scalar->data.S32 = Next; + + scalar = job->args->data[8]; + scalar->data.S32 = Nconvolve; + + scalar = job->args->data[9]; + scalar->data.S32 = NconvolvePass; + + scalar = job->args->data[10]; + scalar->data.S32 = Nplain; + + scalar = job->args->data[11]; + scalar->data.S32 = NplainPass; + return true; } Index: /trunk/psphot/src/psphotFindDetections.c =================================================================== --- /trunk/psphot/src/psphotFindDetections.c (revision 29003) +++ /trunk/psphot/src/psphotFindDetections.c (revision 29004) @@ -90,10 +90,6 @@ psphotVisualShowSignificance (significance, -1.0, PS_SQR(3.0*NSIGMA_PEAK)); - // XXX getting some strange results from significance image - if (0) { - psImage *lsig = (psImage *) psUnaryOp (NULL, significance, "log"); - psphotVisualShowSignificance (lsig, 0.0, 4.0); - psFree (lsig); - } + // display the log significance image + psphotVisualShowLogSignificance (significance, 0.0, 4.5); // detect the peaks in the significance image Index: /trunk/psphot/src/psphotFitSet.c =================================================================== --- /trunk/psphot/src/psphotFitSet.c (revision 29003) +++ /trunk/psphot/src/psphotFitSet.c (revision 29004) @@ -24,6 +24,15 @@ } + // Define source fitting parameters for extended source fits + pmSourceFitOptions *fitOptions = pmSourceFitOptionsAlloc(); + fitOptions->mode = PM_SOURCE_FIT_EXT; + // XXX for now, use the defaults for the rest: + // fitOptions->nIter = fitIter; + // fitOptions->tol = fitTol; + // fitOptions->poissonErrors = poisson; + // fitOptions->weight = PS_SQR(skySig); + // XXX pmSourceFitSet must cache the modelFlux? - pmSourceFitSet (source, modelSet, mode, maskVal); + pmSourceFitSet (source, modelSet, fitOptions, maskVal); // write out positive object Index: /trunk/psphot/src/psphotFitSourcesLinear.c =================================================================== --- /trunk/psphot/src/psphotFitSourcesLinear.c (revision 29003) +++ /trunk/psphot/src/psphotFitSourcesLinear.c (revision 29004) @@ -100,4 +100,13 @@ if (!status) { SKY_FIT_LINEAR = false; + } + + float MIN_VALID_FLUX = psMetadataLookupF32(&status, recipe, "PSF_FIT_MIN_VALID_FLUX"); + if (!status) { + MIN_VALID_FLUX = 1e-8; + } + float MAX_VALID_FLUX = psMetadataLookupF32(&status, recipe, "PSF_FIT_MAX_VALID_FLUX"); + if (!status) { + MAX_VALID_FLUX = 1e+8; } @@ -228,7 +237,7 @@ psSparseConstraint constraint; - constraint.paramMin = 0.0; - constraint.paramMax = 1e8; - constraint.paramDelta = 1e8; + constraint.paramMin = MIN_VALID_FLUX; + constraint.paramMax = MAX_VALID_FLUX; + constraint.paramDelta = 1e7; // solve for normalization terms (need include local sky?) Index: /trunk/psphot/src/psphotFitSourcesLinearStack.c =================================================================== --- /trunk/psphot/src/psphotFitSourcesLinearStack.c (revision 29003) +++ /trunk/psphot/src/psphotFitSourcesLinearStack.c (revision 29004) @@ -170,17 +170,2 @@ return true; } - -// sort by X (ascending) -int pmPhotObjSortByX (const void **a, const void **b) -{ - pmPhotObj *objA = *(pmPhotObj **)a; - pmPhotObj *objB = *(pmPhotObj **)b; - - psF32 fA = objA->x; - psF32 fB = objB->x; - - psF32 diff = fA - fB; - if (diff > FLT_EPSILON) return (+1); - if (diff < FLT_EPSILON) return (-1); - return (0); -} Index: /trunk/psphot/src/psphotGuessModels.c =================================================================== --- /trunk/psphot/src/psphotGuessModels.c (revision 29003) +++ /trunk/psphot/src/psphotGuessModels.c (revision 29004) @@ -80,5 +80,5 @@ // setup the PSF fit radius details - psphotInitRadiusPSF (recipe, readout->analysis, psf->type); + psphotInitRadiusPSF (recipe, readout); // choose Cx, Cy (see psphotThreadTools.c for overview of the concepts) Index: /trunk/psphot/src/psphotLoadSRCTEXT.c =================================================================== --- /trunk/psphot/src/psphotLoadSRCTEXT.c (revision 29003) +++ /trunk/psphot/src/psphotLoadSRCTEXT.c (revision 29004) @@ -84,5 +84,6 @@ source->peak->yf = PAR[PM_PAR_YPOS]; // but we know the pixel coordinate - source->pixWeight = 1.0; + source->pixWeightNotBad = 1.0; + source->pixWeightNotPoor = 1.0; source->crNsigma = 0.0; source->extNsigma = 0.0; Index: /trunk/psphot/src/psphotMagnitudes.c =================================================================== --- /trunk/psphot/src/psphotMagnitudes.c (revision 29003) +++ /trunk/psphot/src/psphotMagnitudes.c (revision 29004) @@ -124,13 +124,4 @@ return false; } - -# if (0) - int nap = 0; - if (!psphotMagnitudes_Unthreaded (&nap, cells->data[j], psf, binning, backModel, backStdev, photMode, maskVal)) { - psError(PS_ERR_UNKNOWN, false, "Unable to guess model."); - return false; - } - Nap += nap; -# endif } @@ -186,5 +177,5 @@ psImageKeepCircle (source->maskObj, source->peak->x, source->peak->y, source->apRadius, "OR", markVal); - status = pmSourceMagnitudes (source, psf, photMode, maskVal); // maskVal includes markVal + status = pmSourceMagnitudes (source, psf, photMode, maskVal, markVal); if (status && isfinite(source->apMag)) Nap ++; @@ -268,4 +259,5 @@ psArrayAdd(job->args, 1, cells->data[j]); // sources PS_ARRAY_ADD_SCALAR(job->args, maskVal, PS_TYPE_IMAGE_MASK); + PS_ARRAY_ADD_SCALAR(job->args, markVal, PS_TYPE_IMAGE_MASK); if (!psThreadJobAddPending(job)) { @@ -304,4 +296,5 @@ psArray *sources = job->args->data[0]; psImageMaskType maskVal = PS_SCALAR_VALUE(job->args->data[1],PS_TYPE_IMAGE_MASK_DATA); + psImageMaskType markVal = PS_SCALAR_VALUE(job->args->data[2],PS_TYPE_IMAGE_MASK_DATA); for (int i = 0; i < sources->n; i++) { @@ -312,12 +305,14 @@ if (model == NULL) { psTrace ("psphot", 3, "fail mag : no valid model"); - source->pixWeight = NAN; + source->pixWeightNotBad = NAN; + source->pixWeightNotPoor = NAN; continue; } - status = pmSourcePixelWeight (&source->pixWeight, model, source->maskObj, maskVal); + status = pmSourcePixelWeight (&source->pixWeightNotBad, &source->pixWeightNotPoor, model, source->maskObj, maskVal, markVal); if (!status) { psTrace ("psphot", 3, "fail to measure pixel weight"); - source->pixWeight = NAN; + source->pixWeightNotBad = NAN; + source->pixWeightNotPoor = NAN; continue; } Index: /trunk/psphot/src/psphotModelWithPSF.c =================================================================== --- /trunk/psphot/src/psphotModelWithPSF.c (revision 29003) +++ /trunk/psphot/src/psphotModelWithPSF.c (revision 29004) @@ -73,7 +73,7 @@ // iterate until the tolerance is reached, or give up - while ((min->iter < min->maxIter) && ((min->lastDelta > min->tol) || !isfinite(min->lastDelta))) { + while ((min->iter < min->maxIter) && ((min->lastDelta > min->minTol) || !isfinite(min->lastDelta))) { psTrace("psphot", 5, "Iteration number %d. (max iterations is %d).\n", min->iter, min->maxIter); - psTrace("psphot", 5, "Last delta is %f. Min->tol is %f.\n", min->lastDelta, min->tol); + psTrace("psphot", 5, "Last delta is %f. Min->minTol is %f.\n", min->lastDelta, min->minTol); @@ -166,11 +166,11 @@ psFree(pcm); - if (min->iter == min->maxIter) { - psTrace("psphot", 3, "---- end (false) ----\n"); - return(false); - } - - psTrace("psphot", 3, "---- end (true) ----\n"); - return(true); + // if the last improvement was at least as good as maxTol, accept the fit: + if (min->lastDelta <= min->maxTol) { + psTrace("psphot", 6, "---- end (true) ----\n"); + return(true); + } + psTrace("psphot", 6, "---- end (false) ----\n"); + return(false); } Index: /trunk/psphot/src/psphotPSFConvModel.c =================================================================== --- /trunk/psphot/src/psphotPSFConvModel.c (revision 29003) +++ /trunk/psphot/src/psphotPSFConvModel.c (revision 29004) @@ -4,10 +4,14 @@ // save as static values so they may be set externally static psF32 PM_SOURCE_FIT_MODEL_NUM_ITERATIONS = 15; -static psF32 PM_SOURCE_FIT_MODEL_TOLERANCE = 0.1; +static psF32 PM_SOURCE_FIT_MODEL_MIN_TOL = 0.1; +static psF32 PM_SOURCE_FIT_MODEL_MAX_TOL = 2.0; // input source has both modelPSF and modelEXT. on successful exit, we set the // modelConv to contain the fitted parameters, and the modelFlux to contain the // convolved model image. -pmModel *psphotPSFConvModel (pmReadout *readout, pmSource *source, pmModelType modelType, psImageMaskType maskVal, psImageMaskType markVal, int psfSize) { + +// XXX need to generalize this -- number of fitted parameters must be flexible based on the fitOptions + +pmModel *psphotPSFConvModel (pmReadout *readout, pmSource *source, pmSourceFitOptions *fitOptions, pmModelType modelType, psImageMaskType maskVal, psImageMaskType markVal, int psfSize) { // maskVal is used to test for rejected pixels, and must include markVal @@ -90,5 +94,5 @@ // set up the minimization process - psMinimization *myMin = psMinimizationAlloc (PM_SOURCE_FIT_MODEL_NUM_ITERATIONS, PM_SOURCE_FIT_MODEL_TOLERANCE); + psMinimization *myMin = psMinimizationAlloc (PM_SOURCE_FIT_MODEL_NUM_ITERATIONS, PM_SOURCE_FIT_MODEL_MIN_TOL, PM_SOURCE_FIT_MODEL_MAX_TOL); psImage *covar = psImageAlloc (params->n, params->n, PS_TYPE_F32); Index: /trunk/psphot/src/psphotPetrosianVisual.c =================================================================== --- /trunk/psphot/src/psphotPetrosianVisual.c (revision 29003) +++ /trunk/psphot/src/psphotPetrosianVisual.c (revision 29004) @@ -1,4 +1,3 @@ # include "psphotInternal.h" -# define FORCE_VISUAL 0 // this function displays representative images as the psphot analysis progresses: @@ -54,6 +53,5 @@ Graphdata graphdata; - // return true; - if (!FORCE_VISUAL && !pmVisualIsVisual()) return true; + if (!pmVisualTestLevel("psphot.petro.byangle", 2)) return true; if (kapa2 == -1) { @@ -101,6 +99,5 @@ Graphdata graphdata; - // return true; - if (!FORCE_VISUAL && !pmVisualIsVisual()) return true; + if (!pmVisualTestLevel("psphot.petro.radii", 2)) return true; if (kapa == -1) { @@ -173,5 +170,5 @@ KapaSection section; - if (!FORCE_VISUAL && !pmVisualIsVisual()) return true; + if (!pmVisualTestLevel("psphot.petro.stats", 2)) return true; if (kapa2 == -1) { @@ -311,5 +308,5 @@ Graphdata graphdata; - if (!FORCE_VISUAL && !pmVisualIsVisual()) return true; + if (!pmVisualTestLevel("psphot.petro.ellipse", 2)) return true; if (kapa == -1) { Index: /trunk/psphot/src/psphotRadiusChecks.c =================================================================== --- /trunk/psphot/src/psphotRadiusChecks.c (revision 29003) +++ /trunk/psphot/src/psphotRadiusChecks.c (revision 29004) @@ -8,5 +8,5 @@ // and a per-object radius is calculated) -bool psphotInitRadiusPSF(const psMetadata *recipe, const psMetadata *analysis, const pmModelType type) { +bool psphotInitRadiusPSF(psMetadata *recipe, pmReadout *readout) { bool status = true; @@ -15,10 +15,10 @@ PSF_FIT_PADDING = psMetadataLookupF32(&status, recipe, "PSF_FIT_PADDING"); - PSF_FIT_RADIUS = psMetadataLookupF32(&status, analysis, "PSF_FIT_RADIUS"); + PSF_FIT_RADIUS = psMetadataLookupF32(&status, readout->analysis, "PSF_FIT_RADIUS"); if (!status) { PSF_FIT_RADIUS = psMetadataLookupF32(&status, recipe, "PSF_FIT_RADIUS"); } - PSF_APERTURE = psMetadataLookupF32(&status, analysis, "PSF_APERTURE"); + PSF_APERTURE = psMetadataLookupF32(&status, readout->analysis, "PSF_APERTURE"); if (!status) { PSF_APERTURE = psMetadataLookupF32(&status, recipe, "PSF_APERTURE"); @@ -28,5 +28,5 @@ if (PSF_FIT_RADIUS == 0.0) { - float gaussSigma = psMetadataLookupF32(&status, analysis, "MOMENTS_GAUSS_SIGMA"); + float gaussSigma = psMetadataLookupF32(&status, readout->analysis, "MOMENTS_GAUSS_SIGMA"); if (!status) { gaussSigma = psMetadataLookupF32(&status, recipe, "MOMENTS_GAUSS_SIGMA"); @@ -37,5 +37,5 @@ if (PSF_APERTURE == 0.0) { - float gaussSigma = psMetadataLookupF32(&status, analysis, "MOMENTS_GAUSS_SIGMA"); + float gaussSigma = psMetadataLookupF32(&status, readout->analysis, "MOMENTS_GAUSS_SIGMA"); if (!status) { gaussSigma = psMetadataLookupF32(&status, recipe, "MOMENTS_GAUSS_SIGMA"); @@ -122,9 +122,10 @@ } +static float EXT_FIT_SKY_SIG; static float EXT_FIT_NSIGMA; static float EXT_FIT_PADDING; static float EXT_FIT_MAX_RADIUS; -bool psphotInitRadiusEXT (psMetadata *recipe, pmModelType type) { +bool psphotInitRadiusEXT (psMetadata *recipe, pmReadout *readout) { bool status; @@ -134,9 +135,16 @@ EXT_FIT_MAX_RADIUS = psMetadataLookupF32 (&status, recipe, "EXT_FIT_MAX_RADIUS"); + float skyMean = psMetadataLookupF32 (&status, readout->analysis, "SKY_MEAN"); + float skyStdev = psMetadataLookupF32 (&status, readout->analysis, "SKY_STDEV"); + + fprintf (stderr, "sky: %f +/- %f\n", skyMean, skyStdev); + + EXT_FIT_SKY_SIG = skyStdev; + return true; } // call this function whenever you (re)-define the EXT model -float psphotSetRadiusEXT (pmReadout *readout, pmSource *source, psImageMaskType markVal) { +bool psphotSetRadiusFootprint (float *radius, pmReadout *readout, pmSource *source, psImageMaskType markVal, float factor) { psAssert (source, "source not defined??"); @@ -146,11 +154,11 @@ // set the radius based on the footprint: - if (!peak->footprint) goto escape; + if (!peak->footprint) return false; pmFootprint *footprint = peak->footprint; - if (!footprint->spans) goto escape; - if (footprint->spans->n < 1) goto escape; + if (!footprint->spans) return false; + if (footprint->spans->n < 1) return false; // find the max radius - float radius = 0.0; + float rawRadius = 0.0; for (int j = 0; j < footprint->spans->n; j++) { pmSpan *span = footprint->spans->data[j]; @@ -160,30 +168,22 @@ float dX1 = span->x1 - peak->xf; - radius = PS_MAX (radius, hypot(dY, dX0)); - radius = PS_MAX (radius, hypot(dY, dX1)); - } - - radius += EXT_FIT_PADDING; - if (isnan(radius)) psAbort("error in radius"); - - radius = PS_MIN (radius, EXT_FIT_MAX_RADIUS); + rawRadius = PS_MAX (rawRadius, hypot(dY, dX0)); + rawRadius = PS_MAX (rawRadius, hypot(dY, dX1)); + } + if (isnan(rawRadius)) return false; + rawRadius = PS_MIN (factor*rawRadius + EXT_FIT_PADDING, EXT_FIT_MAX_RADIUS); // redefine the pixels if needed - pmSourceRedefinePixels (source, readout, peak->xf, peak->yf, radius); - - // set the mask to flag the excluded pixels - psImageKeepCircle (source->maskObj, peak->xf, peak->yf, radius, "OR", markVal); - return radius; - -escape: - return NAN; - // bool result = psphotCheckRadiusEXT (readout, source, model, markVal); - // return result; + pmSourceRedefinePixels (source, readout, peak->xf, peak->yf, rawRadius); + + // set the mask to flag the excluded pixels + psImageKeepCircle (source->maskObj, peak->xf, peak->yf, rawRadius, "OR", markVal); + + *radius = rawRadius; + return true; } // alternative EXT radius based on model guess (for use without footprints) -bool psphotCheckRadiusEXT (pmReadout *readout, pmSource *source, pmModel *model, psImageMaskType markVal) { - - psAbort ("do not use this function"); +bool psphotSetRadiusModel (pmModel *model, pmReadout *readout, pmSource *source, psImageMaskType markVal, bool deep) { psF32 *PAR = model->params->data.F32; @@ -193,14 +193,17 @@ // set the fit radius based on the object flux limit and the model - float rawRadius = model->modelRadius (model->params, EXT_FIT_NSIGMA*moments->dSky); - - model->fitRadius = rawRadius + EXT_FIT_PADDING; - if (isnan(model->fitRadius)) psAbort("error in radius"); + float flux = deep ? EXT_FIT_NSIGMA*EXT_FIT_SKY_SIG : 0.1 * model->params->data.F32[PM_PAR_I0]; + + float rawRadius = model->modelRadius (model->params, flux); + if (isnan(rawRadius)) return false; + + rawRadius = PS_MIN (rawRadius + EXT_FIT_PADDING, EXT_FIT_MAX_RADIUS); + model->fitRadius = rawRadius; // redefine the pixels if needed - bool status = pmSourceRedefinePixels (source, readout, PAR[PM_PAR_XPOS], PAR[PM_PAR_YPOS], model->fitRadius); + pmSourceRedefinePixels (source, readout, PAR[PM_PAR_XPOS], PAR[PM_PAR_YPOS], model->fitRadius); // set the mask to flag the excluded pixels psImageKeepCircle (source->maskObj, PAR[PM_PAR_XPOS], PAR[PM_PAR_YPOS], model->fitRadius, "OR", markVal); - return status; -} + return true; +} Index: /trunk/psphot/src/psphotReadout.c =================================================================== --- /trunk/psphot/src/psphotReadout.c (revision 29003) +++ /trunk/psphot/src/psphotReadout.c (revision 29004) @@ -53,6 +53,7 @@ } - // load the psf model, if suppled. FWHM_X,FWHM_Y,etc are determined and saved on - // readout->analysis XXX this function currently only works with a single PSPHOT.INPUT + // load the psf model, if suppled. FWHM_MAJ,FWHM_MIN,etc are determined and saved on + // readout->analysis. XXX Note: this function currently only works with a single + // PSPHOT.INPUT if (!psphotLoadPSF (config, view)) { // ??? need to supply 2 ? psError (PSPHOT_ERR_UNKNOWN, false, "error loading psf model"); Index: /trunk/psphot/src/psphotSetThreads.c =================================================================== --- /trunk/psphot/src/psphotSetThreads.c (revision 29003) +++ /trunk/psphot/src/psphotSetThreads.c (revision 29004) @@ -15,5 +15,5 @@ psFree(task); - task = psThreadTaskAlloc("PSPHOT_PSF_WEIGHTS", 2); + task = psThreadTaskAlloc("PSPHOT_PSF_WEIGHTS", 3); task->function = &psphotPSFWeights_Threaded; psThreadTaskAdd(task); @@ -30,6 +30,11 @@ psFree(task); - task = psThreadTaskAlloc("PSPHOT_BLEND_FIT", 9); + task = psThreadTaskAlloc("PSPHOT_BLEND_FIT", 10); task->function = &psphotBlendFit_Threaded; + psThreadTaskAdd(task); + psFree(task); + + task = psThreadTaskAlloc("PSPHOT_EXTENDED_FIT", 12); + task->function = &psphotExtendedSourceFits_Threaded; psThreadTaskAdd(task); psFree(task); Index: /trunk/psphot/src/psphotSignificanceImage.c =================================================================== --- /trunk/psphot/src/psphotSignificanceImage.c (revision 29003) +++ /trunk/psphot/src/psphotSignificanceImage.c (revision 29004) @@ -97,5 +97,6 @@ smooth_im->data.F32[j][i] = 0.0; } else { - smooth_im->data.F32[j][i] = factor * PS_SQR(value) / smooth_wt->data.F32[j][i]; + float v2 = value + PS_SQR(value/1000.0); + smooth_im->data.F32[j][i] = factor * PS_SQR(v2) / smooth_wt->data.F32[j][i]; } } Index: /trunk/psphot/src/psphotSourceFits.c =================================================================== --- /trunk/psphot/src/psphotSourceFits.c (revision 29003) +++ /trunk/psphot/src/psphotSourceFits.c (revision 29004) @@ -2,5 +2,4 @@ // given a source with an existing modelPSF, attempt a full PSF fit, subtract if successful -// XXX this function does not call pmSourceFitModelInit : fix this? static int NfitPSF = 0; @@ -8,4 +7,5 @@ static int NfitDBL = 0; static int NfitEXT = 0; +static int NfitPCM = 0; bool psphotFitInit (int nThreads) { @@ -18,11 +18,13 @@ psLogMsg ("psphot.pspsf", PS_LOG_INFO, "fitted %5d psf, %5d blend, %5d ext, %5d dbl : %6.2f sec\n", - NfitPSF, NfitBlend, NfitEXT, NfitDBL, psTimerMark ("psphot.fits")); - return true; -} - -bool psphotFitBlend (pmReadout *readout, pmSource *source, pmPSF *psf, psImageMaskType maskVal, psImageMaskType markVal) { + NfitPSF, NfitBlend, NfitEXT, NfitDBL, psTimerMark ("psphot.fits")); + return true; +} + +bool psphotFitBlend (pmReadout *readout, pmSource *source, pmPSF *psf, pmSourceFitOptions *fitOptions, psImageMaskType maskVal, psImageMaskType markVal) { float x, y, dR; + + pmSourceFitOptions options = *fitOptions; // maskVal is used to test for rejected pixels, and must include markVal @@ -31,5 +33,5 @@ // if this source is not a possible blend, just fit as PSF if ((source->blends == NULL) || (source->mode & PM_SOURCE_MODE_SATSTAR)) { - bool status = psphotFitPSF (readout, source, psf, maskVal, markVal); + bool status = psphotFitPSF (readout, source, psf, fitOptions, maskVal, markVal); return status; } @@ -91,5 +93,6 @@ // fit PSF model - pmSourceFitSet (source, modelSet, PM_SOURCE_FIT_PSF, maskVal); + options.mode = PM_SOURCE_FIT_PSF; + pmSourceFitSet (source, modelSet, &options, maskVal); // clear the circular mask @@ -154,7 +157,8 @@ } -bool psphotFitPSF (pmReadout *readout, pmSource *source, pmPSF *psf, psImageMaskType maskVal, psImageMaskType markVal) { +bool psphotFitPSF (pmReadout *readout, pmSource *source, pmPSF *psf, pmSourceFitOptions *fitOptions, psImageMaskType maskVal, psImageMaskType markVal) { double chiTrend; + pmSourceFitOptions options = *fitOptions; // maskVal is used to test for rejected pixels, and must include markVal @@ -171,5 +175,6 @@ // fit PSF model (set/unset the pixel mask) - pmSourceFitModel (source, PSF, PM_SOURCE_FIT_PSF, maskVal); + options.mode = PM_SOURCE_FIT_PSF; + pmSourceFitModel (source, PSF, &options, maskVal); if (!isfinite(PSF->params->data.F32[PM_PAR_I0])) psAbort("nan in fit"); @@ -199,7 +204,8 @@ } +// save a local, static copy of the EXT model type so we don't have to lookup for each object static pmModelType modelTypeEXT; -bool psphotInitLimitsEXT (psMetadata *recipe) { +bool psphotInitLimitsEXT (psMetadata *recipe, pmReadout *readout) { bool status; @@ -208,11 +214,13 @@ char *modelNameEXT = psMetadataLookupStr (&status, recipe, "EXT_MODEL"); modelTypeEXT = pmModelClassGetType (modelNameEXT); - psphotInitRadiusEXT (recipe, modelTypeEXT); - - return true; -} - -bool psphotFitBlob (pmReadout *readout, pmSource *source, psArray *newSources, pmPSF *psf, psImageMaskType maskVal, psImageMaskType markVal) { - + + psphotInitRadiusEXT (recipe, readout); + + return true; +} + +bool psphotFitBlob (pmReadout *readout, pmSource *source, psArray *newSources, pmPSF *psf, pmSourceFitOptions *fitOptions, psImageMaskType maskVal, psImageMaskType markVal) { + + float radius; bool okEXT, okDBL; float chiEXT, chiDBL; @@ -222,6 +230,8 @@ pmModel *EXT = NULL; psArray *DBL = NULL; + pmMoments psfMoments; // skip the source if we don't think it is extended + // XXX are these robust, or do we have better info from the source-size analysis?? if (source->type == PM_SOURCE_TYPE_UNKNOWN) return false; if (source->type == PM_SOURCE_TYPE_DEFECT) return false; @@ -229,11 +239,17 @@ // set the radius based on the footprint (also sets the mask pixels) - float radius = psphotSetRadiusEXT (readout, source, markVal); + if (!psphotSetRadiusFootprint(&radius, readout, source, markVal, 1.0)) return false; // XXX note that this changes the source moments that are published... + // XXX all published moments should use the same measurement // recalculate the source moments using the larger extended-source moments radius // at this stage, skip Gaussian windowing, and do not clip pixels by S/N // this uses the footprint to judge both radius and aperture? - if (!pmSourceMoments (source, radius, 0.0, 0.0, maskVal)) return false; + // XXX save the psf-based moments for output + psfMoments = *source->moments; + if (!pmSourceMoments (source, radius, 0.0, 0.5, maskVal)) { + *source->moments = psfMoments; + return false; + } psTrace ("psphot", 5, "trying blob...\n"); @@ -244,42 +260,47 @@ // this temporary source is used as a place-holder by the psphotEval functions below tmpSrc = pmSourceAlloc (); - - // XXX need to handle failures better here - EXT = psphotFitEXT (readout, source, modelTypeEXT, maskVal, markVal); - if (!EXT) goto escape; - if (!isfinite(EXT->params->data.F32[PM_PAR_I0])) goto escape; - - okEXT = psphotEvalEXT (tmpSrc, EXT); - chiEXT = EXT ? EXT->chisq / EXT->nDOF : NAN; - - // DBL will always be defined, but DBL->data[n] might not - DBL = psphotFitDBL (readout, source, maskVal, markVal); - if (!DBL) goto escape; - if (!DBL->n) goto escape; - - okDBL = psphotEvalDBL (tmpSrc, DBL->data[0]); - okDBL &= psphotEvalDBL (tmpSrc, DBL->data[1]); - // XXX should I keep / save the flags set in the eval functions? + { + // DBL will always be defined, but DBL->data[n] might not + DBL = psphotFitDBL (readout, source, fitOptions, maskVal, markVal); + if (!DBL) goto escape; + if (!DBL->n) goto escape; + + okDBL = psphotEvalDBL (tmpSrc, DBL->data[0]); + okDBL &= psphotEvalDBL (tmpSrc, DBL->data[1]); + // XXX should I keep / save the flags set in the eval functions? + + // correct first model chisqs for flux trend + chiDBL = NAN; + ONE = DBL->data[0]; + if (ONE) { + if (!isfinite(ONE->params->data.F32[PM_PAR_I0])) psAbort("nan in fit"); + chiTrend = psPolynomial1DEval (psf->ChiTrend, ONE->params->data.F32[1]); + ONE->chisqNorm = ONE->chisq / chiTrend; + chiDBL = ONE->chisq / ONE->nDOF; // save chisq for double-star/galaxy comparison + ONE->fitRadius = radius; + } + + // correct second model chisqs for flux trend + ONE = DBL->data[1]; + if (ONE) { + if (!isfinite(ONE->params->data.F32[PM_PAR_I0])) psAbort("nan in fit"); + chiTrend = psPolynomial1DEval (psf->ChiTrend, ONE->params->data.F32[1]); + ONE->chisqNorm = ONE->chisq / chiTrend; + ONE->fitRadius = radius; + } + } + + { + // XXX need to handle failures better here + EXT = psphotFitEXT (readout, source, fitOptions, modelTypeEXT, maskVal, markVal); + if (!EXT) goto escape; + if (!isfinite(EXT->params->data.F32[PM_PAR_I0])) goto escape; + + okEXT = psphotEvalEXT (tmpSrc, EXT); + chiEXT = EXT ? EXT->chisq / EXT->nDOF : NAN; + } // clear the circular mask psImageMaskPixels (source->maskObj, "AND", PS_NOT_IMAGE_MASK(markVal)); - - // correct first model chisqs for flux trend - chiDBL = NAN; - ONE = DBL->data[0]; - if (ONE) { - if (!isfinite(ONE->params->data.F32[PM_PAR_I0])) psAbort("nan in fit"); - chiTrend = psPolynomial1DEval (psf->ChiTrend, ONE->params->data.F32[1]); - ONE->chisqNorm = ONE->chisq / chiTrend; - chiDBL = ONE->chisq / ONE->nDOF; // save chisq for double-star/galaxy comparison - } - - // correct second model chisqs for flux trend - ONE = DBL->data[1]; - if (ONE) { - if (!isfinite(ONE->params->data.F32[PM_PAR_I0])) psAbort("nan in fit"); - chiTrend = psPolynomial1DEval (psf->ChiTrend, ONE->params->data.F32[1]); - ONE->chisqNorm = ONE->chisq / chiTrend; - } psFree (tmpSrc); @@ -298,5 +319,8 @@ // both models failed; reject them both - // XXX -- change type flags to psf in this case and keep original moments? + // XXX -- change type flags to psf in this case, and make sure we subtract it? + // reset the psf moments + *source->moments = psfMoments; + psFree (EXT); psFree (DBL); @@ -308,6 +332,6 @@ // save new model + // XXX save the correct radius... source->modelEXT = EXT; - source->modelEXT->fitRadius = radius; source->type = PM_SOURCE_TYPE_EXTENDED; source->mode |= PM_SOURCE_MODE_EXTMODEL; @@ -327,4 +351,6 @@ # endif + // reset the psf moments + *source->moments = psfMoments; return true; @@ -337,10 +363,8 @@ source->modelPSF = psMemIncrRefCounter (DBL->data[0]); source->mode |= PM_SOURCE_MODE_PAIR; - source->modelPSF->fitRadius = radius; // copy most data from the primary source (modelEXT, blends stay NULL) - pmSource *newSrc = pmSourceCopy (source); + pmSource *newSrc = pmSourceCopyData (source); newSrc->modelPSF = psMemIncrRefCounter (DBL->data[1]); - newSrc->modelPSF->fitRadius = radius; // build cached models and subtract @@ -365,4 +389,8 @@ # endif + // reset the (original) psf moments + *source->moments = psfMoments; + *newSrc->moments = psfMoments; + psArrayAdd (newSources, 100, newSrc); psFree (newSrc); @@ -371,4 +399,6 @@ escape: + // reset the psf moments + *source->moments = psfMoments; psImageMaskPixels (source->maskObj, "AND", PS_NOT_IMAGE_MASK(markVal)); psFree (tmpSrc); @@ -379,5 +409,5 @@ // fit a double PSF source to an extended blob -psArray *psphotFitDBL (pmReadout *readout, pmSource *source, psImageMaskType maskVal, psImageMaskType markVal) { +psArray *psphotFitDBL (pmReadout *readout, pmSource *source, pmSourceFitOptions *fitOptions, psImageMaskType maskVal, psImageMaskType markVal) { float dx, dy; @@ -387,4 +417,6 @@ psEllipseMoments moments; psArray *modelSet; + + pmSourceFitOptions options = *fitOptions; NfitDBL ++; @@ -403,4 +435,8 @@ axes = psEllipseMomentsToAxes (moments, 20.0); + if (isnan(axes.major)) return NULL; + if (isnan(axes.minor)) return NULL; + if (isnan(axes.theta)) return NULL; + // XXX this is really arbitrary: 4 pixel separation? dx = 2 * cos (axes.theta); @@ -426,9 +462,16 @@ // fit PSF model (set/unset the pixel mask) - pmSourceFitSet (source, modelSet, PM_SOURCE_FIT_PSF, maskVal); + options.mode = PM_SOURCE_FIT_PSF; + pmSourceFitSet (source, modelSet, &options, maskVal); return (modelSet); } -pmModel *psphotFitEXT (pmReadout *readout, pmSource *source, pmModelType modelType, psImageMaskType maskVal, psImageMaskType markVal) { +pmModel *psphotFitEXT (pmReadout *readout, pmSource *source, pmSourceFitOptions *fitOptions, pmModelType modelType, psImageMaskType maskVal, psImageMaskType markVal) { + + if ((source->moments->Mxx < 1e-3) || (source->moments->Myy < 1e-3)) { + psTrace ("psphot", 5, "problem source: moments: %f %f\n", source->moments->Mxx, source->moments->Myy); + } + + pmSourceFitOptions options = *fitOptions; NfitEXT ++; @@ -438,16 +481,222 @@ // use the source moments, etc to guess basic model parameters - pmModel *EXT = pmSourceModelGuess (source, modelType); - if (!EXT) { + pmModel *model = pmSourceModelGuess (source, modelType); + if (!model) { psTrace ("psphot", 5, "failed to generate a model for source: moments: %f %f\n", source->moments->Mxx, source->moments->Myy); return NULL; } + // for sersic models, use a grid search to choose an index, then float the params there + if (modelType == pmModelClassGetType("PS_MODEL_SERSIC")) { + // for the test fits, use a somewhat smaller radius + psphotSetRadiusFootprint(&model->fitRadius, readout, source, markVal, 0.5); + psphotFitSersicIndex (model, readout, source, fitOptions, maskVal, markVal); + } + + if (!psphotSetRadiusModel (model, readout, source, markVal, true)) { + psphotSetRadiusFootprint(&model->fitRadius, readout, source, markVal, 1.0); + } + + if (modelType == pmModelClassGetType("PS_MODEL_SERSIC")) { + options.mode = PM_SOURCE_FIT_NO_INDEX; + } else { + options.mode = PM_SOURCE_FIT_EXT; + } + + // psTraceSetLevel("psLib.math.psMinimizeLMChi2", 5); + pmSourceFitModel (source, model, &options, maskVal); + fprintf (stderr, "chisq: %f, nIter: %d, radius: %f, npix: %d\n\n", model->chisqNorm, model->nIter, model->fitRadius, model->nPix); + + // psTraceSetLevel("psLib.math.psMinimizeLMChi2", 0); + return (model); +} + +pmModel *psphotFitPCM (pmReadout *readout, pmSource *source, pmSourceFitOptions *fitOptions, pmModelType modelType, psImageMaskType maskVal, psImageMaskType markVal, int psfSize) { + if ((source->moments->Mxx < 1e-3) || (source->moments->Myy < 1e-3)) { psTrace ("psphot", 5, "problem source: moments: %f %f\n", source->moments->Mxx, source->moments->Myy); } + pmSourceFitOptions options = *fitOptions; + + NfitPCM ++; + + // maskVal is used to test for rejected pixels, and must include markVal + maskVal |= markVal; + + // allocate the model + pmModel *model = pmModelAlloc(modelType); + if (!model) { + return NULL; + } + + pmPCMdata *pcm = pmPCMinit (source, &options, model, maskVal, psfSize); + if (!pcm) { + psTrace ("psphot", 5, "failed to generate a model for source: moments: %f %f\n", source->moments->Mxx, source->moments->Myy); + model->flags |= PM_MODEL_STATUS_BADARGS; // XXX this is probably already set in pmPCMinit + return model; + } + + // use the source moments, etc to guess basic model parameters + if (!pmSourceModelGuessPCM (pcm, source, maskVal, markVal)) { + psFree (pcm); + model->flags |= PM_MODEL_STATUS_BADARGS; + return model; + } + + // for sersic models, use a grid search to choose an index, then float the params there + if (modelType == pmModelClassGetType("PS_MODEL_SERSIC")) { + // for the test fits, use a somewhat smaller radius + psphotSetRadiusFootprint(&model->fitRadius, readout, source, markVal, 0.5); + + if (!psphotFitSersicIndexPCM (pcm, readout, source, fitOptions, maskVal, markVal, psfSize)) { + model->flags |= PM_MODEL_STATUS_BADARGS; + return model; + } + } + + if (!psphotSetRadiusModel (model, readout, source, markVal, true)) { + psphotSetRadiusFootprint(&model->fitRadius, readout, source, markVal, 1.0); + } + + if (modelType == pmModelClassGetType("PS_MODEL_SERSIC")) { + options.mode = PM_SOURCE_FIT_NO_INDEX; + } else { + options.mode = PM_SOURCE_FIT_EXT; + } + // update the pcm elements if we have changed the circumstance (options.mode or source->pixels) + pmPCMupdate(pcm, source, &options, model); + + // psTraceSetLevel("psLib.math.psMinimizeLMChi2", 5); + pmSourceFitPCM (pcm, source, &options, maskVal, markVal, psfSize); + fprintf (stderr, "chisq: %f, nIter: %d, radius: %f, npix: %d\n\n", model->chisqNorm, model->nIter, model->fitRadius, model->nPix); + + // psTraceSetLevel("psLib.math.psMinimizeLMChi2", 0); + psFree (pcm); + + return model; +} + +// note that these should be 1/2n of the standard sersic index +float indexGuess[] = {0.5, 0.33, 0.25, 0.167, 0.125, 0.083}; +# define N_INDEX_GUESS 6 + +// A sersic model is very sensitive to the index. attempt to find the index first by grid search in just the index +// for a sersic model, attempt to fit just the index and normalization with a modest number of iterations +bool psphotFitSersicIndex (pmModel *model, pmReadout *readout, pmSource *source, pmSourceFitOptions *fitOptions, psImageMaskType maskVal, psImageMaskType markVal) { + + assert (model->type == pmModelClassGetType("PS_MODEL_SERSIC")); + + pmSourceFitOptions options = *fitOptions; + // fit EXT (not PSF) model (set/unset the pixel mask) - pmSourceFitModel (source, EXT, PM_SOURCE_FIT_EXT, maskVal); - return (EXT); -} + options.mode = PM_SOURCE_FIT_NO_INDEX; + options.nIter = 4; + + int iMin = -1; + float xMin = NAN; + float chiSquare[N_INDEX_GUESS]; + + for (int i = 0; i < N_INDEX_GUESS; i++) { + model->params->data.F32[PM_PAR_7] = indexGuess[i]; + + if (!model->modelGuess(model, source)) { + model->flags |= PM_MODEL_STATUS_BADARGS; + return false; + } + + // each time we change the model guess, we need to adjust the radius + // XXX this did not work : we do not need such a large radius -- just uses moments-based radius + if (false && !psphotSetRadiusModel (model, readout, source, markVal, false)) { + psphotSetRadiusFootprint(&model->fitRadius, readout, source, markVal, 0.5); + } + + pmSourceFitModel (source, model, &options, maskVal); + fprintf (stderr, "chisq: %f, nIter: %d, radius: %f, npix: %d\n", model->chisqNorm, model->nIter, model->fitRadius, model->nPix); + + chiSquare[i] = model->chisqNorm; + if (i == 0) { + xMin = chiSquare[i]; + iMin = i; + } else { + if (chiSquare[i] < xMin) { + xMin = chiSquare[i]; + iMin = i; + } + } + } + assert (iMin >= 0); + + model->flags = PM_MODEL_STATUS_NONE; // do not attempt to handle failures here, let the next iteration deal with it + model->params->data.F32[PM_PAR_7] = indexGuess[iMin]; + model->modelGuess(model, source); + + // each time we change the model guess, we need to adjust the radius + // if (!psphotSetRadiusModel (model, readout, source, markVal, true)) { + // psphotSetRadiusFootprint(&model->fitRadius, readout, source, markVal); + // } + + return true; +} + +// A sersic model is very sensitive to the index. attempt to find the index first by grid search in just the index +// for a sersic model, attempt to fit just the index and normalization with a modest number of iterations +bool psphotFitSersicIndexPCM (pmPCMdata *pcm, pmReadout *readout, pmSource *source, pmSourceFitOptions *fitOptions, psImageMaskType maskVal, psImageMaskType markVal, int psfSize) { + + pmModel *model = pcm->modelConv; + + assert (model->type == pmModelClassGetType("PS_MODEL_SERSIC")); + + pmSourceFitOptions options = *fitOptions; + + // fit EXT (not PSF) model (set/unset the pixel mask) + options.mode = PM_SOURCE_FIT_NO_INDEX; + options.nIter = 4; + + // update the pcm elements if we have changed the circumstance (here, options.mode) + pmPCMupdate(pcm, source, &options, model); + + int iMin = -1; + float xMin = NAN; + float chiSquare[N_INDEX_GUESS]; + + for (int i = 0; i < N_INDEX_GUESS; i++) { + model->params->data.F32[PM_PAR_7] = indexGuess[i]; + + if (!model->modelGuess(model, source)) { + model->flags |= PM_MODEL_STATUS_BADARGS; + return false; + } + + // each time we change the model guess, we need to adjust the radius + // XXX this did not work : we do not need such a large radius -- just uses moments-based radius + if (false && !psphotSetRadiusModel (model, readout, source, markVal, false)) { + psphotSetRadiusFootprint(&model->fitRadius, readout, source, markVal, 0.5); + } + + pmSourceFitModel (source, model, &options, maskVal); + fprintf (stderr, "chisq: %f, nIter: %d, radius: %f, npix: %d\n", model->chisqNorm, model->nIter, model->fitRadius, model->nPix); + + // pmSourceModelGuessPCM(pcm, source, maskVal, markVal); + // pmSourceFitPCM (pcm, source, &options, maskVal, markVal, psfSize); + + chiSquare[i] = model->chisq; + if (i == 0) { + xMin = chiSquare[i]; + iMin = i; + } else { + if (chiSquare[i] < xMin) { + xMin = chiSquare[i]; + iMin = i; + } + } + } + assert (iMin >= 0); + + model->flags = PM_MODEL_STATUS_NONE; // do not attempt to handle failures here, let the next iteration deal with it + model->params->data.F32[PM_PAR_7] = indexGuess[iMin]; + + pmSourceModelGuessPCM(pcm, source, maskVal, markVal); + + return true; +} Index: /trunk/psphot/src/psphotSourceSize.c =================================================================== --- /trunk/psphot/src/psphotSourceSize.c (revision 29003) +++ /trunk/psphot/src/psphotSourceSize.c (revision 29004) @@ -1,4 +1,6 @@ # include "psphotInternal.h" # include + +# define KRON 1 typedef struct { @@ -168,4 +170,5 @@ psVector *ApErr = psVectorAllocEmpty (100, PS_TYPE_F32); + psImageMaskType markVal = options->markVal; psImageMaskType maskVal = options->maskVal | options->markVal; @@ -189,5 +192,5 @@ // XXX can we test if psfMag is set and calculate only if needed? - pmSourceMagnitudes (source, psf, photMode, maskVal); // maskVal includes markVal + pmSourceMagnitudes (source, psf, photMode, maskVal, markVal); // clear the mask bit @@ -197,5 +200,10 @@ pmSourceSub (source, PM_MODEL_OP_FULL, options->maskVal); + // XXX test: switch to kron flux +# if (KRON) + float apMag = -2.5*log10(source->moments->KronFlux); +# else float apMag = -2.5*log10(source->moments->Sum); +# endif float dMag = source->psfMag - apMag; @@ -288,4 +296,5 @@ pmSourcePhotometryMode photMode = PM_SOURCE_PHOT_WEIGHT; + psImageMaskType markVal = options->markVal; psImageMaskType maskVal = options->maskVal | options->markVal; @@ -335,5 +344,5 @@ // XXX can we test if psfMag is set and calculate only if needed? - pmSourceMagnitudes (source, psf, photMode, maskVal); // maskVal includes markVal + pmSourceMagnitudes (source, psf, photMode, maskVal, markVal); // clear the mask bit @@ -343,16 +352,28 @@ pmSourceSub (source, PM_MODEL_OP_FULL, options->maskVal); +# if (KRON) + float apMag = -2.5*log10(source->moments->KronFlux); +# else float apMag = -2.5*log10(source->moments->Sum); +# endif float dMag = source->psfMag - apMag; // set nSigma to include both systematic and poisson error terms // XXX the 'poisson error' contribution for size is probably wrong... - float nSigmaMAG = (dMag - options->ApResid) / hypot(source->errMag, options->ApSysErr); + // XXX add in a hard floor on the Ap Sys Err (to be a bit generous) + float nSigmaMAG = (dMag - options->ApResid) / hypot(source->errMag, hypot(options->ApSysErr, 0.025)); float nSigmaMXX = (Mxx - psfClump->X) / hypot(psfClump->dX, psfClump->X*psfClump->X*source->errMag); float nSigmaMYY = (Myy - psfClump->Y) / hypot(psfClump->dY, psfClump->Y*psfClump->Y*source->errMag); - // partially-masked sources are more likely to be mis-measured PSFs + fprintf (stderr, "%f %f : Mxx: %f, Myy: %f, dx: %f, dy: %f, psfMag: %f, apMag: %f, dMag: %f, errMag: %f, nSigmaMag: %f, nSigmaMxx: %f, nSigmaMyy: %f\n", + source->peak->xf, source->peak->yf, Mxx, Myy, source->peak->xf - source->moments->Mx, source->peak->yf - source->moments->My, + source->psfMag, apMag, dMag, source->errMag, nSigmaMAG, nSigmaMXX, nSigmaMYY); + + // XXX double check on ths stuff!! partially-masked sources are more likely to be mis-measured PSFs float sizeBias = 1.0; - if (source->pixWeight < 0.9) { + if (source->pixWeightNotBad < 0.9) { + sizeBias = 3.0; + } + if (source->pixWeightNotPoor < 0.9) { sizeBias = 3.0; } @@ -389,5 +410,5 @@ if (isCR) { psTrace("psphotSourceClassRegion.CR",4,"CLASS: %g %g %f\t%g %g %g %g %g %g\t%g %g\t%g CR\t%g %g\n", - source->peak->xf,source->peak->yf,source->pixWeight,Mxx,Myy,psfClump->X,psfClump->Y,psfClump->dX,psfClump->dY,apMag,dMag,nSigmaMAG, + source->peak->xf,source->peak->yf,source->pixWeightNotBad,Mxx,Myy,psfClump->X,psfClump->Y,psfClump->dX,psfClump->dY,apMag,dMag,nSigmaMAG, options->nSigmaApResid,sizeBias*options->nSigmaMoments); source->mode |= PM_SOURCE_MODE_DEFECT; Index: /trunk/psphot/src/psphotSourceStats.c =================================================================== --- /trunk/psphot/src/psphotSourceStats.c (revision 29003) +++ /trunk/psphot/src/psphotSourceStats.c (revision 29004) @@ -1,3 +1,4 @@ # include "psphotInternal.h" +void pmSourceMomentsSetVerbose(bool state); // convert detections to sources and measure their basic properties (moments, local sky, sky @@ -369,4 +370,6 @@ maskVal |= markVal; + // XXX test : pmSourceMomentsSetVerbose(true); + // threaded measurement of the sources moments int Nfail = 0; @@ -408,4 +411,17 @@ // measure basic source moments (no S/N clipping on input pixels) status = pmSourceMoments (source, RADIUS, SIGMA, 0.0, maskVal); + // XXX moments / aperture test: + if (0) { + // clear the mask bit and set the circular mask pixels + psImageMaskPixels (source->maskObj, "AND", PS_NOT_IMAGE_MASK(markVal)); + psImageKeepCircle (source->maskObj, source->peak->x, source->peak->y, 4.0*source->moments->Mrf, "OR", markVal); + + float apMag = NAN; + pmSourcePhotometryAper (&apMag, NULL, source->pixels, source->maskObj, maskVal); + fprintf (stderr, "apMag: %f, kronMag: %f\n", apMag, -2.5*log10(source->moments->KronFlux)); + + // clear the mask bit + psImageMaskPixels (source->maskObj, "AND", PS_NOT_IMAGE_MASK(markVal)); + } if (status) { Nmoments ++; @@ -502,5 +518,7 @@ psMetadataAddF32 (regionMD, PS_LIST_TAIL, "PSF.CLUMP.DX", PS_META_REPLACE, "psf clump center", psfClump.dX); psMetadataAddF32 (regionMD, PS_LIST_TAIL, "PSF.CLUMP.DY", PS_META_REPLACE, "psf clump center", psfClump.dY); - psphotVisualPlotMoments (recipe, analysis, sources); + if (pmVisualTestLevel("psphot.moments.full", 2)) { + psphotVisualPlotMoments (recipe, analysis, sources); + } #endif Index: /trunk/psphot/src/psphotVisual.c =================================================================== --- /trunk/psphot/src/psphotVisual.c (revision 29003) +++ /trunk/psphot/src/psphotVisual.c (revision 29004) @@ -66,9 +66,9 @@ int myKapa = psphotKapaChannel (channel); if (!(strcasecmp (overlay, "all"))) { - KiiEraseOverlay (myKapa, "red"); - KiiEraseOverlay (myKapa, "green"); - KiiEraseOverlay (myKapa, "blue"); - KiiEraseOverlay (myKapa, "yellow"); - return true; + KiiEraseOverlay (myKapa, "red"); + KiiEraseOverlay (myKapa, "green"); + KiiEraseOverlay (myKapa, "blue"); + KiiEraseOverlay (myKapa, "yellow"); + return true; } KiiEraseOverlay (myKapa, overlay); @@ -182,5 +182,5 @@ bool psphotVisualShowImage (pmReadout *readout) { - if (!pmVisualIsVisual()) return true; + if (!pmVisualTestLevel("psphot.image", 1)) return true; int kapa = psphotKapaChannel (1); @@ -199,5 +199,5 @@ pmReadout *backgnd; - if (!DEBUG && !pmVisualIsVisual()) return true; + if (!pmVisualTestLevel("psphot.image.backgnd", 2)) return true; int kapa = psphotKapaChannel (1); @@ -208,7 +208,7 @@ if (file->mode == PM_FPA_MODE_INTERNAL) { - backgnd = file->readout; + backgnd = file->readout; } else { - backgnd = pmFPAviewThisReadout (view, file->fpa); + backgnd = pmFPAviewThisReadout (view, file->fpa); } @@ -222,5 +222,5 @@ bool psphotVisualShowSignificance (psImage *image, float min, float max) { - if (!DEBUG && !pmVisualIsVisual()) return true; + if (!pmVisualTestLevel("psphot.image.signif", 2)) return true; int kapa = psphotKapaChannel (1); @@ -233,4 +233,20 @@ } +bool psphotVisualShowLogSignificance (psImage *image, float min, float max) { + + if (!pmVisualTestLevel("psphot.image.logsignif", 3)) return true; + + int kapa = psphotKapaChannel (1); + if (kapa == -1) return false; + + psImage *lsig = (psImage *) psUnaryOp (NULL, image, "log"); + psphotVisualRangeImage (kapa, lsig, "log-signif", 2, min, max); + psFree (lsig); + + pmVisualAskUser(NULL); + return true; +} + +// XXX : requires psphotVisualShowImage bool psphotVisualShowPeaks (pmDetections *detections) { @@ -238,5 +254,5 @@ KiiOverlay *overlay; - if (!DEBUG && !pmVisualIsVisual()) return true; + if (!pmVisualTestLevel("psphot.objects.peaks", 1)) return true; int kapa = psphotKapaChannel (1); @@ -252,15 +268,15 @@ for (int i = 0; i < peaks->n; i++) { - pmPeak *peak = peaks->data[i]; - if (peak == NULL) continue; - - overlay[Noverlay].type = KII_OVERLAY_BOX; - overlay[Noverlay].x = peak->xf; - overlay[Noverlay].y = peak->yf; - overlay[Noverlay].dx = 2.0; - overlay[Noverlay].dy = 2.0; - overlay[Noverlay].angle = 0.0; - overlay[Noverlay].text = NULL; - Noverlay ++; + pmPeak *peak = peaks->data[i]; + if (peak == NULL) continue; + + overlay[Noverlay].type = KII_OVERLAY_BOX; + overlay[Noverlay].x = peak->xf; + overlay[Noverlay].y = peak->yf; + overlay[Noverlay].dx = 2.0; + overlay[Noverlay].dy = 2.0; + overlay[Noverlay].angle = 0.0; + overlay[Noverlay].text = NULL; + Noverlay ++; } @@ -272,4 +288,5 @@ } +// XXX : requires psphotVisualShowImage bool psphotVisualShowFootprints (pmDetections *detections) { @@ -277,5 +294,5 @@ KiiOverlay *overlay; - if (!DEBUG && !pmVisualIsVisual()) return true; + if (!pmVisualTestLevel("psphot.objects.footprints", 3)) return true; int kapa = psphotKapaChannel (1); @@ -292,82 +309,82 @@ for (int i = 0; i < footprints->n; i++) { - pmSpan *span = NULL; - - pmFootprint *footprint = footprints->data[i]; - if (footprint == NULL) continue; - if (footprint->spans == NULL) continue; - if (footprint->spans->n < 1) continue; - - // draw the top - // XXX need to allow top (and bottom) to have more than one span - span = footprint->spans->data[0]; - overlay[Noverlay].type = KII_OVERLAY_LINE; - overlay[Noverlay].x = span->x0; - overlay[Noverlay].y = span->y; - overlay[Noverlay].dx = span->x1 - span->x0; - overlay[Noverlay].dy = 0; - overlay[Noverlay].angle = 0.0; - overlay[Noverlay].text = NULL; - Noverlay ++; - CHECK_REALLOCATE (overlay, KiiOverlay, NOVERLAY, Noverlay, 100); - - int ys = span->y; - int x0s = span->x0; - int x1s = span->x1; - - // draw the outer span edges - for (int j = 1; j < footprint->spans->n; j++) { - pmSpan *span1 = footprint->spans->data[j]; - - int ye = span1->y; - int x0e = span1->x0; - int x1e = span1->x1; - - // we cannot have two discontinuous spans on the top or bottom, right? (no, probably not right) - // find all of the spans in this row and generate x0e, x01: - for (int k = j + 1; k < footprint->spans->n; k++) { - pmSpan *span2 = footprint->spans->data[k]; - if (span2->y > span1->y) break; - x0e = PS_MIN (x0e, span2->x0); - x1e = PS_MAX (x1e, span2->x1); - j++; - } - - overlay[Noverlay].type = KII_OVERLAY_LINE; - overlay[Noverlay].x = x0s; - overlay[Noverlay].y = ys; - overlay[Noverlay].dx = x0e - x0s; - overlay[Noverlay].dy = ye - ys; - overlay[Noverlay].angle = 0.0; - overlay[Noverlay].text = NULL; - Noverlay ++; - CHECK_REALLOCATE (overlay, KiiOverlay, NOVERLAY, Noverlay, 100); - - overlay[Noverlay].type = KII_OVERLAY_LINE; - overlay[Noverlay].x = x1s; - overlay[Noverlay].y = ys; - overlay[Noverlay].dx = x1e - x1s; - overlay[Noverlay].dy = ye - ys; - overlay[Noverlay].angle = 0.0; - overlay[Noverlay].text = NULL; - Noverlay ++; - CHECK_REALLOCATE (overlay, KiiOverlay, NOVERLAY, Noverlay, 100); - - ys = ye; - x0s = x0e; - x1s = x1e; - } - - // draw the bottom - span = footprint->spans->data[footprint->spans->n - 1]; - overlay[Noverlay].type = KII_OVERLAY_LINE; - overlay[Noverlay].x = span->x0; - overlay[Noverlay].y = span->y; - overlay[Noverlay].dx = span->x1 - span->x0; - overlay[Noverlay].dy = 0; - overlay[Noverlay].angle = 0.0; - overlay[Noverlay].text = NULL; - Noverlay ++; - CHECK_REALLOCATE (overlay, KiiOverlay, NOVERLAY, Noverlay, 100); + pmSpan *span = NULL; + + pmFootprint *footprint = footprints->data[i]; + if (footprint == NULL) continue; + if (footprint->spans == NULL) continue; + if (footprint->spans->n < 1) continue; + + // draw the top + // XXX need to allow top (and bottom) to have more than one span + span = footprint->spans->data[0]; + overlay[Noverlay].type = KII_OVERLAY_LINE; + overlay[Noverlay].x = span->x0; + overlay[Noverlay].y = span->y; + overlay[Noverlay].dx = span->x1 - span->x0; + overlay[Noverlay].dy = 0; + overlay[Noverlay].angle = 0.0; + overlay[Noverlay].text = NULL; + Noverlay ++; + CHECK_REALLOCATE (overlay, KiiOverlay, NOVERLAY, Noverlay, 100); + + int ys = span->y; + int x0s = span->x0; + int x1s = span->x1; + + // draw the outer span edges + for (int j = 1; j < footprint->spans->n; j++) { + pmSpan *span1 = footprint->spans->data[j]; + + int ye = span1->y; + int x0e = span1->x0; + int x1e = span1->x1; + + // we cannot have two discontinuous spans on the top or bottom, right? (no, probably not right) + // find all of the spans in this row and generate x0e, x01: + for (int k = j + 1; k < footprint->spans->n; k++) { + pmSpan *span2 = footprint->spans->data[k]; + if (span2->y > span1->y) break; + x0e = PS_MIN (x0e, span2->x0); + x1e = PS_MAX (x1e, span2->x1); + j++; + } + + overlay[Noverlay].type = KII_OVERLAY_LINE; + overlay[Noverlay].x = x0s; + overlay[Noverlay].y = ys; + overlay[Noverlay].dx = x0e - x0s; + overlay[Noverlay].dy = ye - ys; + overlay[Noverlay].angle = 0.0; + overlay[Noverlay].text = NULL; + Noverlay ++; + CHECK_REALLOCATE (overlay, KiiOverlay, NOVERLAY, Noverlay, 100); + + overlay[Noverlay].type = KII_OVERLAY_LINE; + overlay[Noverlay].x = x1s; + overlay[Noverlay].y = ys; + overlay[Noverlay].dx = x1e - x1s; + overlay[Noverlay].dy = ye - ys; + overlay[Noverlay].angle = 0.0; + overlay[Noverlay].text = NULL; + Noverlay ++; + CHECK_REALLOCATE (overlay, KiiOverlay, NOVERLAY, Noverlay, 100); + + ys = ye; + x0s = x0e; + x1s = x1e; + } + + // draw the bottom + span = footprint->spans->data[footprint->spans->n - 1]; + overlay[Noverlay].type = KII_OVERLAY_LINE; + overlay[Noverlay].x = span->x0; + overlay[Noverlay].y = span->y; + overlay[Noverlay].dx = span->x1 - span->x0; + overlay[Noverlay].dy = 0; + overlay[Noverlay].angle = 0.0; + overlay[Noverlay].text = NULL; + Noverlay ++; + CHECK_REALLOCATE (overlay, KiiOverlay, NOVERLAY, Noverlay, 100); } @@ -379,4 +396,5 @@ } +// XXX : requires psphotVisualShowImage bool psphotVisualShowMoments (psArray *sources) { @@ -387,5 +405,5 @@ psEllipseAxes axes; - if (!DEBUG && !pmVisualIsVisual()) return true; + if (!pmVisualTestLevel("psphot.objects.moments", 2)) return true; int kapa = psphotKapaChannel (1); @@ -401,27 +419,27 @@ for (int i = 0; i < sources->n; i++) { - pmSource *source = sources->data[i]; - if (source == NULL) continue; - - pmMoments *moments = source->moments; - if (moments == NULL) continue; - - overlay[Noverlay].type = KII_OVERLAY_CIRCLE; - overlay[Noverlay].x = moments->Mx; - overlay[Noverlay].y = moments->My; - - emoments.x2 = moments->Mxx; - emoments.xy = moments->Mxy; - emoments.y2 = moments->Myy; - - axes = psEllipseMomentsToAxes (emoments, 20.0); - - overlay[Noverlay].dx = 2.0*axes.major; - overlay[Noverlay].dy = 2.0*axes.minor; - - overlay[Noverlay].angle = axes.theta * PS_DEG_RAD; - - overlay[Noverlay].text = NULL; - Noverlay ++; + pmSource *source = sources->data[i]; + if (source == NULL) continue; + + pmMoments *moments = source->moments; + if (moments == NULL) continue; + + overlay[Noverlay].type = KII_OVERLAY_CIRCLE; + overlay[Noverlay].x = moments->Mx; + overlay[Noverlay].y = moments->My; + + emoments.x2 = moments->Mxx; + emoments.xy = moments->Mxy; + emoments.y2 = moments->Myy; + + axes = psEllipseMomentsToAxes (emoments, 20.0); + + overlay[Noverlay].dx = 2.0*axes.major; + overlay[Noverlay].dy = 2.0*axes.minor; + + overlay[Noverlay].angle = axes.theta * PS_DEG_RAD; + + overlay[Noverlay].text = NULL; + Noverlay ++; } @@ -439,5 +457,5 @@ KapaSection section; - if (!DEBUG && !pmVisualIsVisual()) return true; + if (!pmVisualTestLevel("psphot.moments", 1)) return true; int myKapa = psphotKapaChannel (2); @@ -456,26 +474,26 @@ float Ymin = 1000.0, Ymax = 0.0; { - int nRegions = psMetadataLookupS32 (&status, analysis, "PSF.CLUMP.NREGIONS"); - for (int n = 0; n < nRegions; n++) { - - char regionName[64]; - snprintf (regionName, 64, "PSF.CLUMP.REGION.%03d", n); - psMetadata *regionMD = psMetadataLookupPtr (&status, analysis, regionName); - - float psfX = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.X"); - float psfY = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.Y"); - float psfdX = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.DX"); - float psfdY = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.DY"); - - float X0 = psfX - 4.0*psfdX; - float X1 = psfX + 4.0*psfdX; - float Y0 = psfY - 4.0*psfdY; - float Y1 = psfY + 4.0*psfdY; - - if (isfinite(X0)) { Xmin = PS_MIN(Xmin, X0); } - if (isfinite(X1)) { Xmax = PS_MAX(Xmax, X1); } - if (isfinite(Y0)) { Ymin = PS_MIN(Ymin, Y0); } - if (isfinite(Y1)) { Ymax = PS_MAX(Ymax, Y1); } - } + int nRegions = psMetadataLookupS32 (&status, analysis, "PSF.CLUMP.NREGIONS"); + for (int n = 0; n < nRegions; n++) { + + char regionName[64]; + snprintf (regionName, 64, "PSF.CLUMP.REGION.%03d", n); + psMetadata *regionMD = psMetadataLookupPtr (&status, analysis, regionName); + + float psfX = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.X"); + float psfY = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.Y"); + float psfdX = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.DX"); + float psfdY = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.DY"); + + float X0 = psfX - 4.0*psfdX; + float X1 = psfX + 4.0*psfdX; + float Y0 = psfY - 4.0*psfdY; + float Y1 = psfY + 4.0*psfdY; + + if (isfinite(X0)) { Xmin = PS_MIN(Xmin, X0); } + if (isfinite(X1)) { Xmax = PS_MAX(Xmax, X1); } + if (isfinite(Y0)) { Ymin = PS_MIN(Ymin, Y0); } + if (isfinite(Y1)) { Ymax = PS_MAX(Ymax, Y1); } + } } Xmin = PS_MAX(Xmin, -0.1); @@ -498,21 +516,21 @@ int nF = 0; for (int i = 0; i < sources->n; i++) { - pmSource *source = sources->data[i]; - if (source->moments == NULL) - continue; - - xFaint->data.F32[nF] = source->moments->Mxx; - yFaint->data.F32[nF] = source->moments->Myy; - mFaint->data.F32[nF] = -2.5*log10(source->moments->Sum); - nF++; - - // XXX make this a user-defined cutoff - if (source->moments->SN < SN_LIM) - continue; - - xBright->data.F32[nB] = source->moments->Mxx; - yBright->data.F32[nB] = source->moments->Myy; - mBright->data.F32[nB] = -2.5*log10(source->moments->Sum); - nB++; + pmSource *source = sources->data[i]; + if (source->moments == NULL) + continue; + + xFaint->data.F32[nF] = source->moments->Mxx; + yFaint->data.F32[nF] = source->moments->Myy; + mFaint->data.F32[nF] = -2.5*log10(source->moments->Sum); + nF++; + + // XXX make this a user-defined cutoff + if (source->moments->SN < SN_LIM) + continue; + + xBright->data.F32[nB] = source->moments->Mxx; + yBright->data.F32[nB] = source->moments->Myy; + mBright->data.F32[nB] = -2.5*log10(source->moments->Sum); + nB++; } xFaint->n = nF; @@ -652,45 +670,45 @@ // draw N circles to outline the clumps { - KapaSelectSection (myKapa, "MxxMyy"); - - // draw a circle centered on psfX,Y with size of the psf limit - psVector *xLimit = psVectorAlloc (120, PS_TYPE_F32); - psVector *yLimit = psVectorAlloc (120, PS_TYPE_F32); - - int nRegions = psMetadataLookupS32 (&status, analysis, "PSF.CLUMP.NREGIONS"); - float PSF_CLUMP_NSIGMA = psMetadataLookupF32 (&status, recipe, "PSF_CLUMP_NSIGMA"); - - graphdata.color = KapaColorByName ("blue"); - graphdata.style = 0; - - graphdata.xmin = Xmin; - graphdata.ymin = Ymin; - graphdata.xmax = Xmax; - graphdata.ymax = Ymax; - KapaSetLimits (myKapa, &graphdata); - - for (int n = 0; n < nRegions; n++) { - - char regionName[64]; - snprintf (regionName, 64, "PSF.CLUMP.REGION.%03d", n); - psMetadata *regionMD = psMetadataLookupPtr (&status, analysis, regionName); - - float psfX = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.X"); - float psfY = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.Y"); - float psfdX = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.DX"); - float psfdY = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.DY"); - float Rx = psfdX * PSF_CLUMP_NSIGMA; - float Ry = psfdY * PSF_CLUMP_NSIGMA; - - for (int i = 0; i < xLimit->n; i++) { - xLimit->data.F32[i] = Rx*cos(i*2.0*M_PI/120.0) + psfX; - yLimit->data.F32[i] = Ry*sin(i*2.0*M_PI/120.0) + psfY; - } - KapaPrepPlot (myKapa, xLimit->n, &graphdata); - KapaPlotVector (myKapa, xLimit->n, xLimit->data.F32, "x"); - KapaPlotVector (myKapa, yLimit->n, yLimit->data.F32, "y"); - } - psFree (xLimit); - psFree (yLimit); + KapaSelectSection (myKapa, "MxxMyy"); + + // draw a circle centered on psfX,Y with size of the psf limit + psVector *xLimit = psVectorAlloc (120, PS_TYPE_F32); + psVector *yLimit = psVectorAlloc (120, PS_TYPE_F32); + + int nRegions = psMetadataLookupS32 (&status, analysis, "PSF.CLUMP.NREGIONS"); + float PSF_CLUMP_NSIGMA = psMetadataLookupF32 (&status, recipe, "PSF_CLUMP_NSIGMA"); + + graphdata.color = KapaColorByName ("blue"); + graphdata.style = 0; + + graphdata.xmin = Xmin; + graphdata.ymin = Ymin; + graphdata.xmax = Xmax; + graphdata.ymax = Ymax; + KapaSetLimits (myKapa, &graphdata); + + for (int n = 0; n < nRegions; n++) { + + char regionName[64]; + snprintf (regionName, 64, "PSF.CLUMP.REGION.%03d", n); + psMetadata *regionMD = psMetadataLookupPtr (&status, analysis, regionName); + + float psfX = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.X"); + float psfY = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.Y"); + float psfdX = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.DX"); + float psfdY = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.DY"); + float Rx = psfdX * PSF_CLUMP_NSIGMA; + float Ry = psfdY * PSF_CLUMP_NSIGMA; + + for (int i = 0; i < xLimit->n; i++) { + xLimit->data.F32[i] = Rx*cos(i*2.0*M_PI/120.0) + psfX; + yLimit->data.F32[i] = Ry*sin(i*2.0*M_PI/120.0) + psfY; + } + KapaPrepPlot (myKapa, xLimit->n, &graphdata); + KapaPlotVector (myKapa, xLimit->n, xLimit->data.F32, "x"); + KapaPlotVector (myKapa, yLimit->n, yLimit->data.F32, "y"); + } + psFree (xLimit); + psFree (yLimit); } @@ -721,28 +739,28 @@ for (int i = 0; i < sources->n; i++) { - pmSource *source = sources->data[i]; - if (source == NULL) continue; - - if (source->type != type) continue; - if (mode && !(source->mode & mode)) continue; - - pmMoments *moments = source->moments; - if (moments == NULL) continue; - - overlay[Noverlay].type = KII_OVERLAY_CIRCLE; - overlay[Noverlay].x = moments->Mx; - overlay[Noverlay].y = moments->My; - - emoments.x2 = moments->Mxx; - emoments.y2 = moments->Myy; - emoments.xy = moments->Mxy; - - axes = psEllipseMomentsToAxes (emoments, 20.0); - - overlay[Noverlay].dx = 2.0*axes.major; - overlay[Noverlay].dy = 2.0*axes.minor; - overlay[Noverlay].angle = axes.theta * PS_DEG_RAD; - overlay[Noverlay].text = NULL; - Noverlay ++; + pmSource *source = sources->data[i]; + if (source == NULL) continue; + + if (source->type != type) continue; + if (mode && !(source->mode & mode)) continue; + + pmMoments *moments = source->moments; + if (moments == NULL) continue; + + overlay[Noverlay].type = KII_OVERLAY_CIRCLE; + overlay[Noverlay].x = moments->Mx; + overlay[Noverlay].y = moments->My; + + emoments.x2 = moments->Mxx; + emoments.y2 = moments->Myy; + emoments.xy = moments->Mxy; + + axes = psEllipseMomentsToAxes (emoments, 20.0); + + overlay[Noverlay].dx = 2.0*axes.major; + overlay[Noverlay].dy = 2.0*axes.minor; + overlay[Noverlay].angle = axes.theta * PS_DEG_RAD; + overlay[Noverlay].text = NULL; + Noverlay ++; } @@ -753,7 +771,8 @@ } +// XXX : requires psphotVisualShowImage bool psphotVisualShowRoughClass (psArray *sources) { - if (!DEBUG && !pmVisualIsVisual()) return true; + if (!pmVisualTestLevel("psphot.objects.size", 3)) return true; int myKapa = psphotKapaChannel (1); @@ -776,5 +795,5 @@ bool psphotVisualShowPSFModel (pmReadout *readout, pmPSF *psf) { - if (!DEBUG && !pmVisualIsVisual()) return true; + if (!pmVisualTestLevel("psphot.psf.model", 1)) return true; int myKapa = psphotKapaChannel (3); @@ -797,28 +816,28 @@ // generate a fake model at each of the 3x3 image grid positions for (int x = -2; x <= +2; x ++) { - for (int y = -2; y <= +2; y ++) { - // use the center of the center pixel of the image - float xc = (int)((0.5 + 0.225*x)*readout->image->numCols) + readout->image->col0 + 0.5; - float yc = (int)((0.5 + 0.225*y)*readout->image->numRows) + readout->image->row0 + 0.5; - - // assign the x and y coords to the image center - // create an object with center intensity of 1000 - modelRef->params->data.F32[PM_PAR_SKY] = 0; - modelRef->params->data.F32[PM_PAR_I0] = 1000; - modelRef->params->data.F32[PM_PAR_XPOS] = xc; - modelRef->params->data.F32[PM_PAR_YPOS] = yc; - - // create modelPSF from this model - pmModel *model = pmModelFromPSF (modelRef, psf); - if (!model) continue; - - // place the reference object in the image center - // no need to mask the source here - // XXX should we measure this for the analytical model only or the full model? - pmModelAddWithOffset (psfMosaic, NULL, model, PM_MODEL_OP_FULL | PM_MODEL_OP_CENTER, 0, x*DX, y*DY); - pmModelAddWithOffset (funMosaic, NULL, model, PM_MODEL_OP_FUNC | PM_MODEL_OP_CENTER, 0, x*DX, y*DY); - pmModelAddWithOffset (resMosaic, NULL, model, PM_MODEL_OP_RES0 | PM_MODEL_OP_RES1 | PM_MODEL_OP_CENTER, 0, x*DX, y*DY); - psFree (model); - } + for (int y = -2; y <= +2; y ++) { + // use the center of the center pixel of the image + float xc = (int)((0.5 + 0.225*x)*readout->image->numCols) + readout->image->col0 + 0.5; + float yc = (int)((0.5 + 0.225*y)*readout->image->numRows) + readout->image->row0 + 0.5; + + // assign the x and y coords to the image center + // create an object with center intensity of 1000 + modelRef->params->data.F32[PM_PAR_SKY] = 0; + modelRef->params->data.F32[PM_PAR_I0] = 1000; + modelRef->params->data.F32[PM_PAR_XPOS] = xc; + modelRef->params->data.F32[PM_PAR_YPOS] = yc; + + // create modelPSF from this model + pmModel *model = pmModelFromPSF (modelRef, psf); + if (!model) continue; + + // place the reference object in the image center + // no need to mask the source here + // XXX should we measure this for the analytical model only or the full model? + pmModelAddWithOffset (psfMosaic, NULL, model, PM_MODEL_OP_FULL | PM_MODEL_OP_CENTER, 0, x*DX, y*DY); + pmModelAddWithOffset (funMosaic, NULL, model, PM_MODEL_OP_FUNC | PM_MODEL_OP_CENTER, 0, x*DX, y*DY); + pmModelAddWithOffset (resMosaic, NULL, model, PM_MODEL_OP_RES0 | PM_MODEL_OP_RES1 | PM_MODEL_OP_CENTER, 0, x*DX, y*DY); + psFree (model); + } } @@ -842,5 +861,5 @@ bool status; - if (!DEBUG && !pmVisualIsVisual()) return true; + if (!pmVisualTestLevel("psphot.psf.stars", 2)) return true; int myKapa = psphotKapaChannel (3); @@ -871,32 +890,32 @@ for (int i = 0; i < sources->n; i++) { - pmSource *source = sources->data[i]; - - bool keep = false; - keep |= (source->mode & PM_SOURCE_MODE_PSFSTAR); - if (!keep) continue; - - // how does this subimage get placed into the output image? - // DX = source->pixels->numCols - // DY = source->pixels->numRows - - if (dX + DX > NX) { - // too wide for the rest of this row - if (dX == 0) { - // alone on this row - NY += DY; - dX = 0; - dY = 0; - } else { - // start the next row - NY += dY; - dX = DX; - dY = DY; - } - } else { - // extend this row - dX += DX; - dY = PS_MAX (dY, DY); - } + pmSource *source = sources->data[i]; + + bool keep = false; + keep |= (source->mode & PM_SOURCE_MODE_PSFSTAR); + if (!keep) continue; + + // how does this subimage get placed into the output image? + // DX = source->pixels->numCols + // DY = source->pixels->numRows + + if (dX + DX > NX) { + // too wide for the rest of this row + if (dX == 0) { + // alone on this row + NY += DY; + dX = 0; + dY = 0; + } else { + // start the next row + NY += dY; + dX = DX; + dY = DY; + } + } else { + // extend this row + dX += DX; + dY = PS_MAX (dY, DY); + } } NY += DY; @@ -918,59 +937,59 @@ for (int i = 0; i < sources->n; i++) { - pmSource *source = sources->data[i]; - - bool keep = false; - if (source->mode & PM_SOURCE_MODE_PSFSTAR) { - nPSF ++; - keep = true; - } - if (!keep) continue; - - if (Xo + DX > NX) { - // too wide for the rest of this row - if (Xo == 0) { - // place source alone on this row - bool subtracted = (source->tmpFlags & PM_SOURCE_TMPF_SUBTRACTED); - if (subtracted) pmSourceAdd (source, PM_MODEL_OP_FULL, maskVal); - psphotMosaicSubimage (outpos, source, Xo, Yo, DX, DY, true); - - pmSourceSub (source, PM_MODEL_OP_FULL, maskVal); - psphotMosaicSubimage (outsub, source, Xo, Yo, DX, DY, true); - - if (!subtracted) pmSourceAdd (source, PM_MODEL_OP_FULL, maskVal); - - Yo += DY; - Xo = 0; - dY = 0; - } else { - // start the next row - Yo += dY; - Xo = 0; - - bool subtracted = (source->tmpFlags & PM_SOURCE_TMPF_SUBTRACTED); - if (subtracted) pmSourceAdd (source, PM_MODEL_OP_FULL, maskVal); - psphotMosaicSubimage (outpos, source, Xo, Yo, DX, DY, true); - - pmSourceSub (source, PM_MODEL_OP_FULL, maskVal); - psphotMosaicSubimage (outsub, source, Xo, Yo, DX, DY, true); - - if (!subtracted) pmSourceAdd (source, PM_MODEL_OP_FULL, maskVal); - - Xo = DX; - dY = DY; - } - } else { - // extend this row - bool subtracted = (source->tmpFlags & PM_SOURCE_TMPF_SUBTRACTED); - if (subtracted) pmSourceAdd (source, PM_MODEL_OP_FULL, maskVal); - psphotMosaicSubimage (outpos, source, Xo, Yo, DX, DY, true); - - pmSourceSub (source, PM_MODEL_OP_FULL, maskVal); - psphotMosaicSubimage (outsub, source, Xo, Yo, DX, DY, true); - if (!subtracted) pmSourceAdd (source, PM_MODEL_OP_FULL, maskVal); - - Xo += DX; - dY = PS_MAX (dY, DY); - } + pmSource *source = sources->data[i]; + + bool keep = false; + if (source->mode & PM_SOURCE_MODE_PSFSTAR) { + nPSF ++; + keep = true; + } + if (!keep) continue; + + if (Xo + DX > NX) { + // too wide for the rest of this row + if (Xo == 0) { + // place source alone on this row + bool subtracted = (source->tmpFlags & PM_SOURCE_TMPF_SUBTRACTED); + if (subtracted) pmSourceAdd (source, PM_MODEL_OP_FULL, maskVal); + psphotMosaicSubimage (outpos, source, Xo, Yo, DX, DY, true); + + pmSourceSub (source, PM_MODEL_OP_FULL, maskVal); + psphotMosaicSubimage (outsub, source, Xo, Yo, DX, DY, true); + + if (!subtracted) pmSourceAdd (source, PM_MODEL_OP_FULL, maskVal); + + Yo += DY; + Xo = 0; + dY = 0; + } else { + // start the next row + Yo += dY; + Xo = 0; + + bool subtracted = (source->tmpFlags & PM_SOURCE_TMPF_SUBTRACTED); + if (subtracted) pmSourceAdd (source, PM_MODEL_OP_FULL, maskVal); + psphotMosaicSubimage (outpos, source, Xo, Yo, DX, DY, true); + + pmSourceSub (source, PM_MODEL_OP_FULL, maskVal); + psphotMosaicSubimage (outsub, source, Xo, Yo, DX, DY, true); + + if (!subtracted) pmSourceAdd (source, PM_MODEL_OP_FULL, maskVal); + + Xo = DX; + dY = DY; + } + } else { + // extend this row + bool subtracted = (source->tmpFlags & PM_SOURCE_TMPF_SUBTRACTED); + if (subtracted) pmSourceAdd (source, PM_MODEL_OP_FULL, maskVal); + psphotMosaicSubimage (outpos, source, Xo, Yo, DX, DY, true); + + pmSourceSub (source, PM_MODEL_OP_FULL, maskVal); + psphotMosaicSubimage (outsub, source, Xo, Yo, DX, DY, true); + if (!subtracted) pmSourceAdd (source, PM_MODEL_OP_FULL, maskVal); + + Xo += DX; + dY = PS_MAX (dY, DY); + } } @@ -994,5 +1013,5 @@ bool status; - if (!DEBUG && !pmVisualIsVisual()) return true; + if (!pmVisualTestLevel("psphot.psf.sat", 3)) return true; int myKapa = psphotKapaChannel (3); @@ -1023,32 +1042,32 @@ for (int i = 0; i < sources->n; i++) { - pmSource *source = sources->data[i]; - - // only show "real" saturated stars (not defects) - if (!(source->mode & PM_SOURCE_MODE_SATSTAR)) continue;; - if (source->mode & PM_SOURCE_MODE_DEFECT) continue;; - - // how does this subimage get placed into the output image? - // DX = source->pixels->numCols - // DY = source->pixels->numRows - - if (dX + DX > NX) { - // too wide for the rest of this row - if (dX == 0) { - // alone on this row - NY += DY; - dX = 0; - dY = 0; - } else { - // start the next row - NY += dY; - dX = DX; - dY = DY; - } - } else { - // extend this row - dX += DX; - dY = PS_MAX (dY, DY); - } + pmSource *source = sources->data[i]; + + // only show "real" saturated stars (not defects) + if (!(source->mode & PM_SOURCE_MODE_SATSTAR)) continue;; + if (source->mode & PM_SOURCE_MODE_DEFECT) continue;; + + // how does this subimage get placed into the output image? + // DX = source->pixels->numCols + // DY = source->pixels->numRows + + if (dX + DX > NX) { + // too wide for the rest of this row + if (dX == 0) { + // alone on this row + NY += DY; + dX = 0; + dY = 0; + } else { + // start the next row + NY += dY; + dX = DX; + dY = DY; + } + } else { + // extend this row + dX += DX; + dY = PS_MAX (dY, DY); + } } NY += DY; @@ -1068,46 +1087,46 @@ for (int i = 0; i < sources->n; i++) { - pmSource *source = sources->data[i]; - - // only show "real" saturated stars (not defects) - if (!(source->mode & PM_SOURCE_MODE_SATSTAR)) continue;; - if (source->mode & PM_SOURCE_MODE_DEFECT) continue;; - nSAT ++; - - if (Xo + DX > NX) { - // too wide for the rest of this row - if (Xo == 0) { - // place source alone on this row - bool subtracted = (source->tmpFlags & PM_SOURCE_TMPF_SUBTRACTED); - if (subtracted) pmSourceAdd (source, PM_MODEL_OP_FULL, maskVal); - psphotMosaicSubimage (outsat, source, Xo, Yo, DX, DY, false); - if (subtracted) pmSourceSub (source, PM_MODEL_OP_FULL, maskVal); - - Yo += DY; - Xo = 0; - dY = 0; - } else { - // start the next row - Yo += dY; - Xo = 0; - - bool subtracted = (source->tmpFlags & PM_SOURCE_TMPF_SUBTRACTED); - if (subtracted) pmSourceAdd (source, PM_MODEL_OP_FULL, maskVal); - psphotMosaicSubimage (outsat, source, Xo, Yo, DX, DY, false); - if (subtracted) pmSourceSub (source, PM_MODEL_OP_FULL, maskVal); - - Xo = DX; - dY = DY; - } - } else { - // extend this row - bool subtracted = (source->tmpFlags & PM_SOURCE_TMPF_SUBTRACTED); - if (subtracted) pmSourceAdd (source, PM_MODEL_OP_FULL, maskVal); - psphotMosaicSubimage (outsat, source, Xo, Yo, DX, DY, false); - if (subtracted) pmSourceSub (source, PM_MODEL_OP_FULL, maskVal); - - Xo += DX; - dY = PS_MAX (dY, DY); - } + pmSource *source = sources->data[i]; + + // only show "real" saturated stars (not defects) + if (!(source->mode & PM_SOURCE_MODE_SATSTAR)) continue;; + if (source->mode & PM_SOURCE_MODE_DEFECT) continue;; + nSAT ++; + + if (Xo + DX > NX) { + // too wide for the rest of this row + if (Xo == 0) { + // place source alone on this row + bool subtracted = (source->tmpFlags & PM_SOURCE_TMPF_SUBTRACTED); + if (subtracted) pmSourceAdd (source, PM_MODEL_OP_FULL, maskVal); + psphotMosaicSubimage (outsat, source, Xo, Yo, DX, DY, false); + if (subtracted) pmSourceSub (source, PM_MODEL_OP_FULL, maskVal); + + Yo += DY; + Xo = 0; + dY = 0; + } else { + // start the next row + Yo += dY; + Xo = 0; + + bool subtracted = (source->tmpFlags & PM_SOURCE_TMPF_SUBTRACTED); + if (subtracted) pmSourceAdd (source, PM_MODEL_OP_FULL, maskVal); + psphotMosaicSubimage (outsat, source, Xo, Yo, DX, DY, false); + if (subtracted) pmSourceSub (source, PM_MODEL_OP_FULL, maskVal); + + Xo = DX; + dY = DY; + } + } else { + // extend this row + bool subtracted = (source->tmpFlags & PM_SOURCE_TMPF_SUBTRACTED); + if (subtracted) pmSourceAdd (source, PM_MODEL_OP_FULL, maskVal); + psphotMosaicSubimage (outsat, source, Xo, Yo, DX, DY, false); + if (subtracted) pmSourceSub (source, PM_MODEL_OP_FULL, maskVal); + + Xo += DX; + dY = PS_MAX (dY, DY); + } } @@ -1151,19 +1170,19 @@ float Yo = source->modelPSF->params->data.F32[PM_PAR_YPOS] - source->pixels->row0; for (int iy = 0; iy < source->pixels->numRows; iy++) { - for (int ix = 0; ix < source->pixels->numCols; ix++) { - if (source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[iy][ix]) { - rb->data.F32[nb] = hypot (ix + 0.5 - Xo, iy + 0.5 - Yo) ; - // rb->data.F32[nb] = hypot (ix - Xo, iy - Yo) ; - Rb->data.F32[nb] = log10(rb->data.F32[nb]); - fb->data.F32[nb] = log10(source->pixels->data.F32[iy][ix]); - nb++; - } else { - rg->data.F32[ng] = hypot (ix + 0.5 - Xo, iy + 0.5 - Yo) ; - // rg->data.F32[ng] = hypot (ix - Xo, iy - Yo) ; - Rg->data.F32[ng] = log10(rg->data.F32[ng]); - fg->data.F32[ng] = log10(source->pixels->data.F32[iy][ix]); - ng++; - } - } + for (int ix = 0; ix < source->pixels->numCols; ix++) { + if (source->maskObj->data.PS_TYPE_IMAGE_MASK_DATA[iy][ix]) { + rb->data.F32[nb] = hypot (ix + 0.5 - Xo, iy + 0.5 - Yo) ; + // rb->data.F32[nb] = hypot (ix - Xo, iy - Yo) ; + Rb->data.F32[nb] = log10(rb->data.F32[nb]); + fb->data.F32[nb] = log10(source->pixels->data.F32[iy][ix]); + nb++; + } else { + rg->data.F32[ng] = hypot (ix + 0.5 - Xo, iy + 0.5 - Yo) ; + // rg->data.F32[ng] = hypot (ix - Xo, iy - Yo) ; + Rg->data.F32[ng] = log10(rg->data.F32[ng]); + fg->data.F32[ng] = log10(source->pixels->data.F32[iy][ix]); + ng++; + } + } } @@ -1358,5 +1377,5 @@ KapaSection section; // put the positive profile in one and the residuals in another? - if (!DEBUG && !pmVisualIsVisual()) return true; + if (!pmVisualTestLevel("psphot.profiles", 3)) return true; int myKapa = psphotKapaChannel (2); @@ -1394,22 +1413,22 @@ for (int i = 0; i < sources->n; i++) { - pmSource *source = sources->data[i]; - if (!(source->mode & PM_SOURCE_MODE_PSFSTAR)) continue; - - psphotVisualPlotRadialProfile (myKapa, source, maskVal); - - // pause and wait for user input: - // continue, save (provide name), ?? - char key[10]; - fprintf (stdout, "[e]rase and continue? [o]verplot and continue? [s]kip rest of stars? : "); - if (!fgets(key, 8, stdin)) { - psWarning("Unable to read option"); - } - if (key[0] == 'e') { - KapaClearPlots (myKapa); - } - if (key[0] == 's') { - break; - } + pmSource *source = sources->data[i]; + if (!(source->mode & PM_SOURCE_MODE_PSFSTAR)) continue; + + psphotVisualPlotRadialProfile (myKapa, source, maskVal); + + // pause and wait for user input: + // continue, save (provide name), ?? + char key[10]; + fprintf (stdout, "[e]rase and continue? [o]verplot and continue? [s]kip rest of stars? : "); + if (!fgets(key, 8, stdin)) { + psWarning("Unable to read option"); + } + if (key[0] == 'e') { + KapaClearPlots (myKapa); + } + if (key[0] == 's') { + break; + } } @@ -1429,5 +1448,5 @@ return true; - if (!DEBUG && !pmVisualIsVisual()) return true; + if (!pmVisualTestLevel("psphot.objects.flags", 3)) return true; int myKapa = psphotKapaChannel (1); @@ -1445,62 +1464,62 @@ for (int i = 0; i < sources->n; i++) { - float Xo, Yo, Rmaj, Rmin, cs, sn; - - pmSource *source = sources->data[i]; - if (source == NULL) continue; - - pmMoments *moments = source->moments; - if (0) { - emoments.x2 = moments->Mxx; - emoments.y2 = moments->Myy; - emoments.xy = moments->Mxy; - Xo = moments->Mx; - Yo = moments->My; - - axes = psEllipseMomentsToAxes (emoments, 20.0); - Rmaj = 2.0*axes.major; - Rmin = 2.0*axes.minor; - cs = cos(axes.theta); - sn = sin(axes.theta); - } else { - Rmaj = Rmin = 5.0; - cs = 1.0; - sn = 0.0; - Xo = source->peak->xf; - Yo = source->peak->yf; - } - - unsigned short int flagMask = 0x01; - for (int j = 0; j < 8; j++) { - if (source->mode & flagMask) { - overlayE[NoverlayE].type = KII_OVERLAY_LINE; - overlayE[NoverlayE].x = Xo; - overlayE[NoverlayE].y = Yo; - - float phi = j*M_PI/4.0; - overlayE[NoverlayE].dx = +Rmaj*cos(phi)*cs - Rmin*sin(phi)*sn; - overlayE[NoverlayE].dy = +Rmaj*cos(phi)*sn + Rmin*sin(phi)*cs; - overlayE[NoverlayE].angle = 0; - overlayE[NoverlayE].text = NULL; - NoverlayE ++; - CHECK_REALLOCATE (overlayE, KiiOverlay, NOVERLAYE, NoverlayE, 100); - } - flagMask <<= 1; - - if (source->mode & flagMask) { - overlayO[NoverlayO].type = KII_OVERLAY_LINE; - overlayO[NoverlayO].x = Xo + 1; - overlayO[NoverlayO].y = Yo; - - float phi = j*M_PI/4.0; - overlayO[NoverlayO].dx = +Rmaj*cos(phi)*cs - Rmin*sin(phi)*sn; - overlayO[NoverlayO].dy = +Rmaj*cos(phi)*sn + Rmin*sin(phi)*cs; - overlayO[NoverlayO].angle = 0; - overlayO[NoverlayO].text = NULL; - NoverlayO ++; - CHECK_REALLOCATE (overlayO, KiiOverlay, NOVERLAYO, NoverlayO, 100); - } - flagMask <<= 1; - } + float Xo, Yo, Rmaj, Rmin, cs, sn; + + pmSource *source = sources->data[i]; + if (source == NULL) continue; + + pmMoments *moments = source->moments; + if (0) { + emoments.x2 = moments->Mxx; + emoments.y2 = moments->Myy; + emoments.xy = moments->Mxy; + Xo = moments->Mx; + Yo = moments->My; + + axes = psEllipseMomentsToAxes (emoments, 20.0); + Rmaj = 2.0*axes.major; + Rmin = 2.0*axes.minor; + cs = cos(axes.theta); + sn = sin(axes.theta); + } else { + Rmaj = Rmin = 5.0; + cs = 1.0; + sn = 0.0; + Xo = source->peak->xf; + Yo = source->peak->yf; + } + + unsigned short int flagMask = 0x01; + for (int j = 0; j < 8; j++) { + if (source->mode & flagMask) { + overlayE[NoverlayE].type = KII_OVERLAY_LINE; + overlayE[NoverlayE].x = Xo; + overlayE[NoverlayE].y = Yo; + + float phi = j*M_PI/4.0; + overlayE[NoverlayE].dx = +Rmaj*cos(phi)*cs - Rmin*sin(phi)*sn; + overlayE[NoverlayE].dy = +Rmaj*cos(phi)*sn + Rmin*sin(phi)*cs; + overlayE[NoverlayE].angle = 0; + overlayE[NoverlayE].text = NULL; + NoverlayE ++; + CHECK_REALLOCATE (overlayE, KiiOverlay, NOVERLAYE, NoverlayE, 100); + } + flagMask <<= 1; + + if (source->mode & flagMask) { + overlayO[NoverlayO].type = KII_OVERLAY_LINE; + overlayO[NoverlayO].x = Xo + 1; + overlayO[NoverlayO].y = Yo; + + float phi = j*M_PI/4.0; + overlayO[NoverlayO].dx = +Rmaj*cos(phi)*cs - Rmin*sin(phi)*sn; + overlayO[NoverlayO].dy = +Rmaj*cos(phi)*sn + Rmin*sin(phi)*cs; + overlayO[NoverlayO].angle = 0; + overlayO[NoverlayO].text = NULL; + NoverlayO ++; + CHECK_REALLOCATE (overlayO, KiiOverlay, NOVERLAYO, NoverlayO, 100); + } + flagMask <<= 1; + } } @@ -1531,33 +1550,33 @@ for (int i = 0; i < sources->n; i++) { - pmSource *source = sources->data[i]; - if (source == NULL) continue; - - if (mode) { - if (keep) { - if (!(source->mode & mode)) continue; - } else { - if (source->mode & mode) continue; - } - } - - pmMoments *moments = source->moments; - if (moments == NULL) continue; - - overlay[Noverlay].type = KII_OVERLAY_CIRCLE; - overlay[Noverlay].x = moments->Mx; - overlay[Noverlay].y = moments->My; - - emoments.x2 = moments->Mxx; - emoments.y2 = moments->Myy; - emoments.xy = moments->Mxy; - - axes = psEllipseMomentsToAxes (emoments, 20.0); - - overlay[Noverlay].dx = scale*2.0*axes.major; - overlay[Noverlay].dy = scale*2.0*axes.minor; - overlay[Noverlay].angle = axes.theta * PS_DEG_RAD; - overlay[Noverlay].text = NULL; - Noverlay ++; + pmSource *source = sources->data[i]; + if (source == NULL) continue; + + if (mode) { + if (keep) { + if (!(source->mode & mode)) continue; + } else { + if (source->mode & mode) continue; + } + } + + pmMoments *moments = source->moments; + if (moments == NULL) continue; + + overlay[Noverlay].type = KII_OVERLAY_CIRCLE; + overlay[Noverlay].x = moments->Mx; + overlay[Noverlay].y = moments->My; + + emoments.x2 = moments->Mxx; + emoments.y2 = moments->Myy; + emoments.xy = moments->Mxy; + + axes = psEllipseMomentsToAxes (emoments, 20.0); + + overlay[Noverlay].dx = scale*2.0*axes.major; + overlay[Noverlay].dy = scale*2.0*axes.minor; + overlay[Noverlay].angle = axes.theta * PS_DEG_RAD; + overlay[Noverlay].text = NULL; + Noverlay ++; } @@ -1570,5 +1589,5 @@ bool psphotVisualShowSourceSize (pmReadout *readout, psArray *sources) { - if (!DEBUG && !pmVisualIsVisual()) return true; + if (!pmVisualTestLevel("psphot.objects.size", 2)) return true; int myKapa = psphotKapaChannel (1); @@ -1597,5 +1616,5 @@ KapaSection section; - if (!DEBUG && !pmVisualIsVisual()) return true; + if (!pmVisualTestLevel("psphot.size", 2)) return true; int myKapa = psphotKapaChannel (2); @@ -1612,26 +1631,26 @@ float Ymin = 1000.0, Ymax = 0.0; { - int nRegions = psMetadataLookupS32 (&status, analysis, "PSF.CLUMP.NREGIONS"); - for (int n = 0; n < nRegions; n++) { - - char regionName[64]; - snprintf (regionName, 64, "PSF.CLUMP.REGION.%03d", n); - psMetadata *regionMD = psMetadataLookupPtr (&status, analysis, regionName); - - float psfX = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.X"); - float psfY = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.Y"); - float psfdX = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.DX"); - float psfdY = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.DY"); - - float X0 = psfX - 10.0*psfdX; - float X1 = psfX + 10.0*psfdX; - float Y0 = psfY - 10.0*psfdY; - float Y1 = psfY + 10.0*psfdY; - - if (isfinite(X0)) { Xmin = PS_MIN(Xmin, X0); } - if (isfinite(X1)) { Xmax = PS_MAX(Xmax, X1); } - if (isfinite(Y0)) { Ymin = PS_MIN(Ymin, Y0); } - if (isfinite(Y1)) { Ymax = PS_MAX(Ymax, Y1); } - } + int nRegions = psMetadataLookupS32 (&status, analysis, "PSF.CLUMP.NREGIONS"); + for (int n = 0; n < nRegions; n++) { + + char regionName[64]; + snprintf (regionName, 64, "PSF.CLUMP.REGION.%03d", n); + psMetadata *regionMD = psMetadataLookupPtr (&status, analysis, regionName); + + float psfX = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.X"); + float psfY = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.Y"); + float psfdX = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.DX"); + float psfdY = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.DY"); + + float X0 = psfX - 10.0*psfdX; + float X1 = psfX + 10.0*psfdX; + float Y0 = psfY - 10.0*psfdY; + float Y1 = psfY + 10.0*psfdY; + + if (isfinite(X0)) { Xmin = PS_MIN(Xmin, X0); } + if (isfinite(X1)) { Xmax = PS_MAX(Xmax, X1); } + if (isfinite(Y0)) { Ymin = PS_MIN(Ymin, Y0); } + if (isfinite(Y1)) { Ymax = PS_MAX(Ymax, Y1); } + } } Xmin = PS_MAX(Xmin, -0.1); @@ -1677,53 +1696,53 @@ int nCR = 0; for (int i = 0; i < sources->n; i++) { - pmSource *source = sources->data[i]; - if (source->moments == NULL) continue; + pmSource *source = sources->data[i]; + if (source->moments == NULL) continue; // only plot the measured sources... - if (!(source->tmpFlags & PM_SOURCE_TMPF_SIZE_MEASURED)) continue; - - if (source->mode & PM_SOURCE_MODE_CR_LIMIT) { - xCR->data.F32[nCR] = source->moments->Mxx; - yCR->data.F32[nCR] = source->moments->Myy; - mCR->data.F32[nCR] = -2.5*log10(source->moments->Sum); - sCR->data.F32[nCR] = source->extNsigma; - nCR++; - } - if (source->mode & PM_SOURCE_MODE_SATSTAR) { - xSAT->data.F32[nSAT] = source->moments->Mxx; - ySAT->data.F32[nSAT] = source->moments->Myy; - mSAT->data.F32[nSAT] = -2.5*log10(source->moments->Sum); - sSAT->data.F32[nSAT] = source->extNsigma; - nSAT++; - } - if (source->mode & PM_SOURCE_MODE_EXT_LIMIT) { - xEXT->data.F32[nEXT] = source->moments->Mxx; - yEXT->data.F32[nEXT] = source->moments->Myy; - mEXT->data.F32[nEXT] = -2.5*log10(source->moments->Sum); - sEXT->data.F32[nEXT] = source->extNsigma; - nEXT++; - continue; - } - if (source->mode & PM_SOURCE_MODE_DEFECT) { - xDEF->data.F32[nDEF] = source->moments->Mxx; - yDEF->data.F32[nDEF] = source->moments->Myy; - mDEF->data.F32[nDEF] = -2.5*log10(source->moments->Sum); - sDEF->data.F32[nDEF] = source->extNsigma; - nDEF++; - continue; - } - if (source->errMag > 0.1) { - xLOW->data.F32[nLOW] = source->moments->Mxx; - yLOW->data.F32[nLOW] = source->moments->Myy; - mLOW->data.F32[nLOW] = -2.5*log10(source->moments->Sum); - sLOW->data.F32[nLOW] = source->extNsigma; - nLOW++; - continue; - } - xPSF->data.F32[nPSF] = source->moments->Mxx; - yPSF->data.F32[nPSF] = source->moments->Myy; - mPSF->data.F32[nPSF] = -2.5*log10(source->moments->Sum); - sPSF->data.F32[nPSF] = source->extNsigma; - nPSF++; + if (!(source->tmpFlags & PM_SOURCE_TMPF_SIZE_MEASURED)) continue; + + if (source->mode & PM_SOURCE_MODE_CR_LIMIT) { + xCR->data.F32[nCR] = source->moments->Mxx; + yCR->data.F32[nCR] = source->moments->Myy; + mCR->data.F32[nCR] = -2.5*log10(source->moments->Sum); + sCR->data.F32[nCR] = source->extNsigma; + nCR++; + } + if (source->mode & PM_SOURCE_MODE_SATSTAR) { + xSAT->data.F32[nSAT] = source->moments->Mxx; + ySAT->data.F32[nSAT] = source->moments->Myy; + mSAT->data.F32[nSAT] = -2.5*log10(source->moments->Sum); + sSAT->data.F32[nSAT] = source->extNsigma; + nSAT++; + } + if (source->mode & PM_SOURCE_MODE_EXT_LIMIT) { + xEXT->data.F32[nEXT] = source->moments->Mxx; + yEXT->data.F32[nEXT] = source->moments->Myy; + mEXT->data.F32[nEXT] = -2.5*log10(source->moments->Sum); + sEXT->data.F32[nEXT] = source->extNsigma; + nEXT++; + continue; + } + if (source->mode & PM_SOURCE_MODE_DEFECT) { + xDEF->data.F32[nDEF] = source->moments->Mxx; + yDEF->data.F32[nDEF] = source->moments->Myy; + mDEF->data.F32[nDEF] = -2.5*log10(source->moments->Sum); + sDEF->data.F32[nDEF] = source->extNsigma; + nDEF++; + continue; + } + if (source->errMag > 0.1) { + xLOW->data.F32[nLOW] = source->moments->Mxx; + yLOW->data.F32[nLOW] = source->moments->Myy; + mLOW->data.F32[nLOW] = -2.5*log10(source->moments->Sum); + sLOW->data.F32[nLOW] = source->extNsigma; + nLOW++; + continue; + } + xPSF->data.F32[nPSF] = source->moments->Mxx; + yPSF->data.F32[nPSF] = source->moments->Myy; + mPSF->data.F32[nPSF] = -2.5*log10(source->moments->Sum); + sPSF->data.F32[nPSF] = source->extNsigma; + nPSF++; } @@ -2029,45 +2048,45 @@ // draw N circles to outline the clumps { - KapaSelectSection (myKapa, "MxxMyy"); - - // draw a circle centered on psfX,Y with size of the psf limit - psVector *xLimit = psVectorAlloc (120, PS_TYPE_F32); - psVector *yLimit = psVectorAlloc (120, PS_TYPE_F32); - - int nRegions = psMetadataLookupS32 (&status, analysis, "PSF.CLUMP.NREGIONS"); - float PSF_CLUMP_NSIGMA = psMetadataLookupF32 (&status, recipe, "PSF_CLUMP_NSIGMA"); - - graphdata.color = KapaColorByName ("blue"); - graphdata.style = 0; - - graphdata.xmin = Xmin; - graphdata.ymin = Ymin; - graphdata.xmax = Xmax; - graphdata.ymax = Ymax; - KapaSetLimits (myKapa, &graphdata); - - for (int n = 0; n < nRegions; n++) { - - char regionName[64]; - snprintf (regionName, 64, "PSF.CLUMP.REGION.%03d", n); - psMetadata *regionMD = psMetadataLookupPtr (&status, analysis, regionName); - - float psfX = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.X"); - float psfY = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.Y"); - float psfdX = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.DX"); - float psfdY = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.DY"); - float Rx = psfdX * PSF_CLUMP_NSIGMA; - float Ry = psfdY * PSF_CLUMP_NSIGMA; - - for (int i = 0; i < xLimit->n; i++) { - xLimit->data.F32[i] = Rx*cos(i*2.0*M_PI/120.0) + psfX; - yLimit->data.F32[i] = Ry*sin(i*2.0*M_PI/120.0) + psfY; - } - KapaPrepPlot (myKapa, xLimit->n, &graphdata); - KapaPlotVector (myKapa, xLimit->n, xLimit->data.F32, "x"); - KapaPlotVector (myKapa, yLimit->n, yLimit->data.F32, "y"); - } - psFree (xLimit); - psFree (yLimit); + KapaSelectSection (myKapa, "MxxMyy"); + + // draw a circle centered on psfX,Y with size of the psf limit + psVector *xLimit = psVectorAlloc (120, PS_TYPE_F32); + psVector *yLimit = psVectorAlloc (120, PS_TYPE_F32); + + int nRegions = psMetadataLookupS32 (&status, analysis, "PSF.CLUMP.NREGIONS"); + float PSF_CLUMP_NSIGMA = psMetadataLookupF32 (&status, recipe, "PSF_CLUMP_NSIGMA"); + + graphdata.color = KapaColorByName ("blue"); + graphdata.style = 0; + + graphdata.xmin = Xmin; + graphdata.ymin = Ymin; + graphdata.xmax = Xmax; + graphdata.ymax = Ymax; + KapaSetLimits (myKapa, &graphdata); + + for (int n = 0; n < nRegions; n++) { + + char regionName[64]; + snprintf (regionName, 64, "PSF.CLUMP.REGION.%03d", n); + psMetadata *regionMD = psMetadataLookupPtr (&status, analysis, regionName); + + float psfX = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.X"); + float psfY = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.Y"); + float psfdX = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.DX"); + float psfdY = psMetadataLookupF32 (&status, regionMD, "PSF.CLUMP.DY"); + float Rx = psfdX * PSF_CLUMP_NSIGMA; + float Ry = psfdY * PSF_CLUMP_NSIGMA; + + for (int i = 0; i < xLimit->n; i++) { + xLimit->data.F32[i] = Rx*cos(i*2.0*M_PI/120.0) + psfX; + yLimit->data.F32[i] = Ry*sin(i*2.0*M_PI/120.0) + psfY; + } + KapaPrepPlot (myKapa, xLimit->n, &graphdata); + KapaPlotVector (myKapa, xLimit->n, xLimit->data.F32, "x"); + KapaPlotVector (myKapa, yLimit->n, yLimit->data.F32, "y"); + } + psFree (xLimit); + psFree (yLimit); } @@ -2108,5 +2127,5 @@ bool psphotVisualShowResidualImage (pmReadout *readout) { - if (!DEBUG && !pmVisualIsVisual()) return true; + if (!pmVisualTestLevel("psphot.image.resid", 2)) return true; int myKapa = psphotKapaChannel (1); @@ -2124,5 +2143,5 @@ float lineX[2], lineY[2]; - if (!DEBUG && !pmVisualIsVisual()) return true; + if (!pmVisualTestLevel("psphot.apresid", 1)) return true; int myKapa = psphotKapaChannel (2); @@ -2144,19 +2163,19 @@ int n = 0; for (int i = 0; i < sources->n; i++) { - pmSource *source = sources->data[i]; - if (!source) continue; - if (source->type != PM_SOURCE_TYPE_STAR) continue; - if (!isfinite (source->apMag)) continue; - if (!isfinite (source->psfMag)) continue; - - x->data.F32[n] = source->psfMag; - y->data.F32[n] = source->apMag - source->psfMag; - dy->data.F32[n] = source->errMag; - graphdata.xmin = PS_MIN(graphdata.xmin, x->data.F32[n]); - graphdata.xmax = PS_MAX(graphdata.xmax, x->data.F32[n]); - graphdata.ymin = PS_MIN(graphdata.ymin, y->data.F32[n]); - graphdata.ymax = PS_MAX(graphdata.ymax, y->data.F32[n]); - - n++; + pmSource *source = sources->data[i]; + if (!source) continue; + if (source->type != PM_SOURCE_TYPE_STAR) continue; + if (!isfinite (source->apMag)) continue; + if (!isfinite (source->psfMag)) continue; + + x->data.F32[n] = source->psfMag; + y->data.F32[n] = source->apMag - source->psfMag; + dy->data.F32[n] = source->errMag; + graphdata.xmin = PS_MIN(graphdata.xmin, x->data.F32[n]); + graphdata.xmax = PS_MAX(graphdata.xmax, x->data.F32[n]); + graphdata.ymin = PS_MIN(graphdata.ymin, y->data.F32[n]); + graphdata.ymax = PS_MAX(graphdata.ymax, y->data.F32[n]); + + n++; } x->n = y->n = dy->n = n; @@ -2242,5 +2261,5 @@ Graphdata graphdata; - if (!DEBUG && !pmVisualIsVisual()) return true; + if (!pmVisualTestLevel("psphot.chisq", 1)) return true; int myKapa = psphotKapaChannel (2); @@ -2263,22 +2282,22 @@ int n = 0; for (int i = 0; i < sources->n; i++) { - pmSource *source = sources->data[i]; - if (!source) continue; - if (source->type != PM_SOURCE_TYPE_STAR) continue; - if (!source->moments) continue; - if (!isfinite(source->moments->Sum)) continue; - if (!source->modelPSF) continue; - if (!isfinite(source->modelPSF->chisq)) continue; - - x->data.F32[n] = -2.5*log10(source->moments->Sum); - y->data.F32[n] = source->modelPSF->chisq / source->modelPSF->nDOF; - graphdata.xmin = PS_MIN(graphdata.xmin, x->data.F32[n]); - graphdata.xmax = PS_MAX(graphdata.xmax, x->data.F32[n]); - graphdata.ymin = PS_MIN(graphdata.ymin, y->data.F32[n]); - graphdata.ymax = PS_MAX(graphdata.ymax, y->data.F32[n]); - - fprintf (f, "%d %d %f %f\n", i, n, x->data.F32[n], y->data.F32[n]); - - n++; + pmSource *source = sources->data[i]; + if (!source) continue; + if (source->type != PM_SOURCE_TYPE_STAR) continue; + if (!source->moments) continue; + if (!isfinite(source->moments->Sum)) continue; + if (!source->modelPSF) continue; + if (!isfinite(source->modelPSF->chisq)) continue; + + x->data.F32[n] = -2.5*log10(source->moments->Sum); + y->data.F32[n] = source->modelPSF->chisq / source->modelPSF->nDOF; + graphdata.xmin = PS_MIN(graphdata.xmin, x->data.F32[n]); + graphdata.xmax = PS_MAX(graphdata.xmax, x->data.F32[n]); + graphdata.ymin = PS_MIN(graphdata.ymin, y->data.F32[n]); + graphdata.ymax = PS_MAX(graphdata.ymax, y->data.F32[n]); + + fprintf (f, "%d %d %f %f\n", i, n, x->data.F32[n], y->data.F32[n]); + + n++; } x->n = y->n = n; @@ -2326,5 +2345,5 @@ KiiOverlay *overlay; - if (!DEBUG && !pmVisualIsVisual()) return true; + if (!pmVisualTestLevel("psphot.objects.petro", 2)) return true; int kapa = psphotKapaChannel (1); @@ -2336,32 +2355,32 @@ for (int i = 0; i < sources->n; i++) { - pmSource *source = sources->data[i]; - - if (!source) continue; - if (!source->extpars) continue; - if (!source->extpars->petProfile) continue; - - float petrosianRadius = source->extpars->petrosianRadius; + pmSource *source = sources->data[i]; + + if (!source) continue; + if (!source->extpars) continue; + if (!source->extpars->petProfile) continue; + + float petrosianRadius = source->extpars->petrosianRadius; psEllipseAxes *axes = &source->extpars->axes; - overlay[Noverlay].type = KII_OVERLAY_CIRCLE; - overlay[Noverlay].x = source->peak->xf; - overlay[Noverlay].y = source->peak->yf; - overlay[Noverlay].dx = 1.0*petrosianRadius; - overlay[Noverlay].dy = 1.0*petrosianRadius*axes->minor/axes->major; - overlay[Noverlay].angle = axes->theta * PS_DEG_RAD; - overlay[Noverlay].text = NULL; - Noverlay ++; - CHECK_REALLOCATE (overlay, KiiOverlay, NOVERLAY, Noverlay, 100); - - // overlay[Noverlay].type = KII_OVERLAY_CIRCLE; - // overlay[Noverlay].x = source->peak->xf; - // overlay[Noverlay].y = source->peak->yf; - // overlay[Noverlay].dx = 2.0*petrosianRadius; - // overlay[Noverlay].dy = 2.0*petrosianRadius*axes->minor/axes->major; - // overlay[Noverlay].angle = axes->theta * PS_DEG_RAD; - // overlay[Noverlay].text = NULL; - // Noverlay ++; - // CHECK_REALLOCATE (overlay, KiiOverlay, NOVERLAY, Noverlay, 100); + overlay[Noverlay].type = KII_OVERLAY_CIRCLE; + overlay[Noverlay].x = source->peak->xf; + overlay[Noverlay].y = source->peak->yf; + overlay[Noverlay].dx = 1.0*petrosianRadius; + overlay[Noverlay].dy = 1.0*petrosianRadius*axes->minor/axes->major; + overlay[Noverlay].angle = axes->theta * PS_DEG_RAD; + overlay[Noverlay].text = NULL; + Noverlay ++; + CHECK_REALLOCATE (overlay, KiiOverlay, NOVERLAY, Noverlay, 100); + + // overlay[Noverlay].type = KII_OVERLAY_CIRCLE; + // overlay[Noverlay].x = source->peak->xf; + // overlay[Noverlay].y = source->peak->yf; + // overlay[Noverlay].dx = 2.0*petrosianRadius; + // overlay[Noverlay].dy = 2.0*petrosianRadius*axes->minor/axes->major; + // overlay[Noverlay].angle = axes->theta * PS_DEG_RAD; + // overlay[Noverlay].text = NULL; + // Noverlay ++; + // CHECK_REALLOCATE (overlay, KiiOverlay, NOVERLAY, Noverlay, 100); }