22 """Plugins for use in DiaSource summary statistics.
24 Output columns must be
25 as defined in the schema of the Apdb both in name and units.
31 from astropy.stats
import median_absolute_deviation
34 from scipy.optimize
import lsq_linear
40 from .diaCalculation
import (
41 DiaObjectCalculationPluginConfig,
42 DiaObjectCalculationPlugin)
43 from .pluginRegistry
import register
45 __all__ = (
"MeanDiaPositionConfig",
"MeanDiaPosition",
46 "HTMIndexDiaPosition",
"HTMIndexDiaPositionConfig",
47 "NumDiaSourcesDiaPlugin",
"NumDiaSourcesDiaPluginConfig",
48 "SimpleSourceFlagDiaPlugin",
"SimpleSourceFlagDiaPluginConfig",
49 "WeightedMeanDiaPsFluxConfig",
"WeightedMeanDiaPsFlux",
50 "PercentileDiaPsFlux",
"PercentileDiaPsFluxConfig",
51 "SigmaDiaPsFlux",
"SigmaDiaPsFluxConfig",
52 "Chi2DiaPsFlux",
"Chi2DiaPsFluxConfig",
53 "MadDiaPsFlux",
"MadDiaPsFluxConfig",
54 "SkewDiaPsFlux",
"SkewDiaPsFluxConfig",
55 "MinMaxDiaPsFlux",
"MinMaxDiaPsFluxConfig",
56 "MaxSlopeDiaPsFlux",
"MaxSlopeDiaPsFluxConfig",
57 "ErrMeanDiaPsFlux",
"ErrMeanDiaPsFluxConfig",
58 "LinearFitDiaPsFlux",
"LinearFitDiaPsFluxConfig",
59 "StetsonJDiaPsFlux",
"StetsonJDiaPsFluxConfig",
60 "WeightedMeanDiaTotFlux",
"WeightedMeanDiaTotFluxConfig",
61 "SigmaDiaTotFlux",
"SigmaDiaTotFluxConfig")
65 """Decorator for generically catching numpy warnings.
67 def decoratorCatchWarnings(func):
68 @functools.wraps(func)
69 def wrapperCatchWarnings(*args, **kwargs):
70 with warnings.catch_warnings():
72 warnings.filterwarnings(
"ignore", val)
73 return func(*args, **kwargs)
74 return wrapperCatchWarnings
77 return decoratorCatchWarnings
79 return decoratorCatchWarnings(_func)
88 """Compute the mean position of a DiaObject given a set of DiaSources.
91 ConfigClass = MeanDiaPositionConfig
95 outputCols = [
"ra",
"decl",
"radecTai"]
103 """Compute the mean ra/dec position of the diaObject given the
108 diaObjects : `pandas.DataFrame`
109 Summary objects to store values in.
110 diaSources : `pandas.DataFrame` or `pandas.DataFrameGroupBy`
111 Catalog of DiaSources summarized by this DiaObject.
113 Any additional keyword arguments that may be passed to the plugin.
116 if outCol
not in diaObjects.columns:
117 diaObjects[outCol] = np.nan
119 def _computeMeanPos(df):
122 for idx, src
in df.iterrows()))
123 ra = aveCoord.getRa().asDegrees()
124 decl = aveCoord.getDec().asDegrees()
125 if np.isnan(ra)
or np.isnan(decl):
128 radecTai = df[
"midPointTai"].
max()
130 return pd.Series({
"ra": aveCoord.getRa().asDegrees(),
131 "decl": aveCoord.getDec().asDegrees(),
132 "radecTai": radecTai})
134 ans = diaSources.apply(_computeMeanPos)
135 diaObjects.loc[:, [
"ra",
"decl",
"radecTai"]] = ans
140 htmLevel = pexConfig.Field(
142 doc=
"Level of the HTM pixelization.",
147 @register("ap_HTMIndex")
149 """Compute the mean position of a DiaObject given a set of DiaSources.
153 This plugin was implemented to satisfy requirements of old APDB interface
154 which required ``pixelId`` column in DiaObject with HTM20 index. APDB
155 interface had migrated to not need that information, but we keep this
156 plugin in case it may be useful for something else.
158 ConfigClass = HTMIndexDiaPositionConfig
162 inputCols = [
"ra",
"decl"]
163 outputCols = [
"pixelId"]
167 DiaObjectCalculationPlugin.__init__(self, config, name, metadata)
175 """Compute the mean position of a DiaObject given a set of DiaSources
179 diaObjects : `pandas.dataFrame`
180 Summary objects to store values in and read ra/decl from.
182 Id of the diaObject to update.
184 Any additional keyword arguments that may be passed to the plugin.
187 diaObjects.at[diaObjectId,
"ra"] * geom.degrees,
188 diaObjects.at[diaObjectId,
"decl"] * geom.degrees)
189 diaObjects.at[diaObjectId,
"pixelId"] = self.
pixelatorpixelator.index(
190 sphPoint.getVector())
199 """Compute the total number of DiaSources associated with this DiaObject.
202 ConfigClass = NumDiaSourcesDiaPluginConfig
203 outputCols = [
"nDiaSources"]
212 """Compute the total number of DiaSources associated with this DiaObject.
217 Summary object to store values in and read ra/decl from.
219 Any additional keyword arguments that may be passed to the plugin.
221 diaObjects.loc[:,
"nDiaSources"] = diaSources.diaObjectId.count()
230 """Find if any DiaSource is flagged.
232 Set the DiaObject flag if any DiaSource is flagged.
235 ConfigClass = NumDiaSourcesDiaPluginConfig
236 outputCols = [
"flags"]
245 """Find if any DiaSource is flagged.
247 Set the DiaObject flag if any DiaSource is flagged.
252 Summary object to store values in and read ra/decl from.
254 Any additional keyword arguments that may be passed to the plugin.
256 diaObjects.loc[:,
"flags"] = diaSources.flags.any().astype(np.uint64)
265 """Compute the weighted mean and mean error on the point source fluxes
266 of the DiaSource measured on the difference image.
268 Additionally store number of usable data points.
271 ConfigClass = WeightedMeanDiaPsFluxConfig
272 outputCols = [
"PSFluxMean",
"PSFluxMeanErr",
"PSFluxNdata"]
280 @catchWarnings(warns=["invalid value encountered",
"divide by zero"])
287 """Compute the weighted mean and mean error of the point source flux.
292 Summary object to store values in.
293 diaSources : `pandas.DataFrame`
294 DataFrame representing all diaSources associated with this
296 filterDiaSources : `pandas.DataFrame`
297 DataFrame representing diaSources associated with this
298 diaObject that are observed in the band pass ``filterName``.
300 Simple, string name of the filter for the flux being calculated.
302 Any additional keyword arguments that may be passed to the plugin.
304 meanName =
"{}PSFluxMean".
format(filterName)
305 errName =
"{}PSFluxMeanErr".
format(filterName)
306 nDataName =
"{}PSFluxNdata".
format(filterName)
307 if meanName
not in diaObjects.columns:
308 diaObjects[meanName] = np.nan
309 if errName
not in diaObjects.columns:
310 diaObjects[errName] = np.nan
311 if nDataName
not in diaObjects.columns:
312 diaObjects[nDataName] = 0
314 def _weightedMean(df):
315 tmpDf = df[~np.logical_or(np.isnan(df[
"psFlux"]),
316 np.isnan(df[
"psFluxErr"]))]
317 tot_weight = np.nansum(1 / tmpDf[
"psFluxErr"] ** 2)
318 fluxMean = np.nansum(tmpDf[
"psFlux"]
319 / tmpDf[
"psFluxErr"] ** 2)
320 fluxMean /= tot_weight
322 fluxMeanErr = np.sqrt(1 / tot_weight)
325 nFluxData = len(tmpDf)
327 return pd.Series({meanName: fluxMean,
328 errName: fluxMeanErr,
329 nDataName: nFluxData},
332 diaObjects.loc[:, [meanName, errName, nDataName]] = \
333 filterDiaSources.apply(_weightedMean)
337 percentiles = pexConfig.ListField(
339 default=[5, 25, 50, 75, 95],
340 doc=
"Percentiles to calculate to compute values for. Should be "
345 @register("ap_percentileFlux")
347 """Compute percentiles of diaSource fluxes.
350 ConfigClass = PercentileDiaPsFluxConfig
356 def __init__(self, config, name, metadata, **kwargs):
357 DiaObjectCalculationPlugin.__init__(self,
363 for percent
in self.
configconfig.percentiles]
369 @catchWarnings(warns=["All-NaN slice encountered"])
376 """Compute the percentile fluxes of the point source flux.
381 Summary object to store values in.
382 diaSources : `pandas.DataFrame`
383 DataFrame representing all diaSources associated with this
385 filterDiaSources : `pandas.DataFrame`
386 DataFrame representing diaSources associated with this
387 diaObject that are observed in the band pass ``filterName``.
389 Simple, string name of the filter for the flux being calculated.
391 Any additional keyword arguments that may be passed to the plugin.
394 for tilePercent
in self.
configconfig.percentiles:
395 pTileName =
"{}PSFluxPercentile{:02d}".
format(filterName,
397 pTileNames.append(pTileName)
398 if pTileName
not in diaObjects.columns:
399 diaObjects[pTileName] = np.nan
401 def _fluxPercentiles(df):
402 pTiles = np.nanpercentile(df[
"psFlux"], self.
configconfig.percentiles)
404 dict((tileName, pTile)
405 for tileName, pTile
in zip(pTileNames, pTiles)))
407 diaObjects.loc[:, pTileNames] = filterDiaSources.apply(_fluxPercentiles)
416 """Compute scatter of diaSource fluxes.
419 ConfigClass = SigmaDiaPsFluxConfig
421 outputCols = [
"PSFluxSigma"]
435 """Compute the sigma fluxes of the point source flux.
440 Summary object to store values in.
441 diaSources : `pandas.DataFrame`
442 DataFrame representing all diaSources associated with this
444 filterDiaSources : `pandas.DataFrame`
445 DataFrame representing diaSources associated with this
446 diaObject that are observed in the band pass ``filterName``.
448 Simple, string name of the filter for the flux being calculated.
450 Any additional keyword arguments that may be passed to the plugin.
454 diaObjects.loc[:,
"{}PSFluxSigma".
format(filterName)] = \
455 filterDiaSources.psFlux.std()
464 """Compute chi2 of diaSource fluxes.
467 ConfigClass = Chi2DiaPsFluxConfig
470 inputCols = [
"PSFluxMean"]
472 outputCols = [
"PSFluxChi2"]
480 @catchWarnings(warns=["All-NaN slice encountered"])
487 """Compute the chi2 of the point source fluxes.
492 Summary object to store values in.
493 diaSources : `pandas.DataFrame`
494 DataFrame representing all diaSources associated with this
496 filterDiaSources : `pandas.DataFrame`
497 DataFrame representing diaSources associated with this
498 diaObject that are observed in the band pass ``filterName``.
500 Simple, string name of the filter for the flux being calculated.
502 Any additional keyword arguments that may be passed to the plugin.
504 meanName =
"{}PSFluxMean".
format(filterName)
507 delta = (df[
"psFlux"]
508 - diaObjects.at[df.diaObjectId.iat[0], meanName])
509 return np.nansum((delta / df[
"psFluxErr"]) ** 2)
511 diaObjects.loc[:,
"{}PSFluxChi2".
format(filterName)] = \
512 filterDiaSources.apply(_chi2)
521 """Compute median absolute deviation of diaSource fluxes.
524 ConfigClass = MadDiaPsFluxConfig
528 outputCols = [
"PSFluxMAD"]
536 @catchWarnings(warns=["All-NaN slice encountered"])
543 """Compute the median absolute deviation of the point source fluxes.
548 Summary object to store values in.
549 diaSources : `pandas.DataFrame`
550 DataFrame representing all diaSources associated with this
552 filterDiaSources : `pandas.DataFrame`
553 DataFrame representing diaSources associated with this
554 diaObject that are observed in the band pass ``filterName``.
556 Simple, string name of the filter for the flux being calculated.
558 Any additional keyword arguments that may be passed to the plugin.
560 diaObjects.loc[:,
"{}PSFluxMAD".
format(filterName)] = \
561 filterDiaSources.psFlux.apply(median_absolute_deviation,
571 """Compute the skew of diaSource fluxes.
574 ConfigClass = SkewDiaPsFluxConfig
578 outputCols = [
"PSFluxSkew"]
592 """Compute the skew of the point source fluxes.
597 Summary object to store values in.
598 diaSources : `pandas.DataFrame`
599 DataFrame representing all diaSources associated with this
601 filterDiaSources : `pandas.DataFrame`
602 DataFrame representing diaSources associated with this
603 diaObject that are observed in the band pass ``filterName``.
605 Simple, string name of the filter for the flux being calculated.
607 Any additional keyword arguments that may be passed to the plugin.
609 diaObjects.loc[:,
"{}PSFluxSkew".
format(filterName)] = \
610 filterDiaSources.psFlux.skew()
619 """Compute min/max of diaSource fluxes.
622 ConfigClass = MinMaxDiaPsFluxConfig
626 outputCols = [
"PSFluxMin",
"PSFluxMax"]
640 """Compute min/max of the point source fluxes.
645 Summary object to store values in.
646 diaSources : `pandas.DataFrame`
647 DataFrame representing all diaSources associated with this
649 filterDiaSources : `pandas.DataFrame`
650 DataFrame representing diaSources associated with this
651 diaObject that are observed in the band pass ``filterName``.
653 Simple, string name of the filter for the flux being calculated.
655 Any additional keyword arguments that may be passed to the plugin.
657 minName =
"{}PSFluxMin".
format(filterName)
658 if minName
not in diaObjects.columns:
659 diaObjects[minName] = np.nan
660 maxName =
"{}PSFluxMax".
format(filterName)
661 if maxName
not in diaObjects.columns:
662 diaObjects[maxName] = np.nan
664 diaObjects.loc[:, minName] = filterDiaSources.psFlux.min()
665 diaObjects.loc[:, maxName] = filterDiaSources.psFlux.max()
674 """Compute the maximum ratio time ordered deltaFlux / deltaTime.
677 ConfigClass = MinMaxDiaPsFluxConfig
681 outputCols = [
"PSFluxMaxSlope"]
695 """Compute the maximum ratio time ordered deltaFlux / deltaTime.
700 Summary object to store values in.
701 diaSources : `pandas.DataFrame`
702 DataFrame representing all diaSources associated with this
704 filterDiaSources : `pandas.DataFrame`
705 DataFrame representing diaSources associated with this
706 diaObject that are observed in the band pass ``filterName``.
708 Simple, string name of the filter for the flux being calculated.
710 Any additional keyword arguments that may be passed to the plugin.
714 tmpDf = df[~np.logical_or(np.isnan(df[
"psFlux"]),
715 np.isnan(df[
"midPointTai"]))]
718 times = tmpDf[
"midPointTai"].to_numpy()
719 timeArgs = times.argsort()
720 times = times[timeArgs]
721 fluxes = tmpDf[
"psFlux"].to_numpy()[timeArgs]
722 return (np.diff(fluxes) / np.diff(times)).
max()
724 diaObjects.loc[:,
"{}PSFluxMaxSlope".
format(filterName)] = \
725 filterDiaSources.apply(_maxSlope)
734 """Compute the mean of the dia source errors.
737 ConfigClass = ErrMeanDiaPsFluxConfig
741 outputCols = [
"PSFluxErrMean"]
755 """Compute the mean of the dia source errors.
760 Summary object to store values in.
761 diaSources : `pandas.DataFrame`
762 DataFrame representing all diaSources associated with this
764 filterDiaSources : `pandas.DataFrame`
765 DataFrame representing diaSources associated with this
766 diaObject that are observed in the band pass ``filterName``.
768 Simple, string name of the filter for the flux being calculated.
770 Any additional keyword arguments that may be passed to the plugin.
772 diaObjects.loc[:,
"{}PSFluxErrMean".
format(filterName)] = \
773 filterDiaSources.psFluxErr.mean()
782 """Compute fit a linear model to flux vs time.
785 ConfigClass = LinearFitDiaPsFluxConfig
789 outputCols = [
"PSFluxLinearSlope",
"PSFluxLinearIntercept"]
803 """Compute fit a linear model to flux vs time.
808 Summary object to store values in.
809 diaSources : `pandas.DataFrame`
810 DataFrame representing all diaSources associated with this
812 filterDiaSources : `pandas.DataFrame`
813 DataFrame representing diaSources associated with this
814 diaObject that are observed in the band pass ``filterName``.
816 Simple, string name of the filter for the flux being calculated.
818 Any additional keyword arguments that may be passed to the plugin.
821 mName =
"{}PSFluxLinearSlope".
format(filterName)
822 if mName
not in diaObjects.columns:
823 diaObjects[mName] = np.nan
824 bName =
"{}PSFluxLinearIntercept".
format(filterName)
825 if bName
not in diaObjects.columns:
826 diaObjects[bName] = np.nan
829 tmpDf = df[~np.logical_or(
830 np.isnan(df[
"psFlux"]),
831 np.logical_or(np.isnan(df[
"psFluxErr"]),
832 np.isnan(df[
"midPointTai"])))]
834 return pd.Series({mName: np.nan, bName: np.nan})
835 fluxes = tmpDf[
"psFlux"].to_numpy()
836 errors = tmpDf[
"psFluxErr"].to_numpy()
837 times = tmpDf[
"midPointTai"].to_numpy()
838 A = np.array([times / errors, 1 / errors]).transpose()
839 m, b = lsq_linear(A, fluxes / errors).x
840 return pd.Series({mName: m, bName: b})
842 diaObjects.loc[:, [mName, bName]] = filterDiaSources.apply(_linearFit)
851 """Compute the StetsonJ statistic on the DIA point source fluxes.
854 ConfigClass = LinearFitDiaPsFluxConfig
857 inputCols = [
"PSFluxMean"]
859 outputCols = [
"PSFluxStetsonJ"]
873 """Compute the StetsonJ statistic on the DIA point source fluxes.
878 Summary object to store values in.
879 diaSources : `pandas.DataFrame`
880 DataFrame representing all diaSources associated with this
882 filterDiaSources : `pandas.DataFrame`
883 DataFrame representing diaSources associated with this
884 diaObject that are observed in the band pass ``filterName``.
886 Simple, string name of the filter for the flux being calculated.
888 Any additional keyword arguments that may be passed to the plugin.
890 meanName =
"{}PSFluxMean".
format(filterName)
893 tmpDf = df[~np.logical_or(np.isnan(df[
"psFlux"]),
894 np.isnan(df[
"psFluxErr"]))]
897 fluxes = tmpDf[
"psFlux"].to_numpy()
898 errors = tmpDf[
"psFluxErr"].to_numpy()
903 diaObjects.at[tmpDf.diaObjectId.iat[0], meanName])
905 diaObjects.loc[:,
"{}PSFluxStetsonJ".
format(filterName)] = \
906 filterDiaSources.apply(_stetsonJ)
908 def _stetson_J(self, fluxes, errors, mean=None):
909 """Compute the single band stetsonJ statistic.
913 fluxes : `numpy.ndarray` (N,)
914 Calibrated lightcurve flux values.
915 errors : `numpy.ndarray` (N,)
916 Errors on the calibrated lightcurve fluxes.
918 Starting mean from previous plugin.
923 stetsonJ statistic for the input fluxes and errors.
927 .. [1] Stetson, P. B., "On the Automatic Determination of Light-Curve
928 Parameters for Cepheid Variables", PASP, 108, 851S, 1996
930 n_points = len(fluxes)
931 flux_mean = self.
_stetson_mean_stetson_mean(fluxes, errors, mean)
933 np.sqrt(n_points / (n_points - 1)) * (fluxes - flux_mean) / errors)
934 p_k = delta_val ** 2 - 1
936 return np.mean(np.sign(p_k) * np.sqrt(np.fabs(p_k)))
938 def _stetson_mean(self,
946 """Compute the stetson mean of the fluxes which down-weights outliers.
948 Weighted biased on an error weighted difference scaled by a constant
949 (1/``a``) and raised to the power beta. Higher betas more harshly
950 penalize outliers and ``a`` sets the number of sigma where a weighted
951 difference of 1 occurs.
955 values : `numpy.dnarray`, (N,)
956 Input values to compute the mean of.
957 errors : `numpy.ndarray`, (N,)
958 Errors on the input values.
960 Starting mean value or None.
962 Scalar down-weighting of the fractional difference. lower->more
963 clipping. (Default value is 2.)
965 Power law slope of the used to down-weight outliers. higher->more
966 clipping. (Default value is 2.)
968 Number of iterations of clipping.
970 Fractional and absolute tolerance goal on the change in the mean
971 before exiting early. (Default value is 1e-6)
976 Weighted stetson mean result.
980 .. [1] Stetson, P. B., "On the Automatic Determination of Light-Curve
981 Parameters for Cepheid Variables", PASP, 108, 851S, 1996
983 n_points = len(values)
984 n_factor = np.sqrt(n_points / (n_points - 1))
985 inv_var = 1 / errors ** 2
988 mean = np.average(values, weights=inv_var)
989 for iter_idx
in range(n_iter):
990 chi = np.fabs(n_factor * (values - mean) / errors)
991 tmp_mean = np.average(
993 weights=inv_var / (1 + (chi / alpha) ** beta))
994 diff = np.fabs(tmp_mean - mean)
996 if diff / mean < tol
and diff < tol:
1007 """Compute the weighted mean and mean error on the point source fluxes
1008 forced photometered at the DiaSource location in the calibrated image.
1010 Additionally store number of usable data points.
1013 ConfigClass = WeightedMeanDiaPsFluxConfig
1014 outputCols = [
"TOTFluxMean",
"TOTFluxMeanErr"]
1022 @catchWarnings(warns=["invalid value encountered",
"divide by zero"])
1029 """Compute the weighted mean and mean error of the point source flux.
1034 Summary object to store values in.
1035 diaSources : `pandas.DataFrame`
1036 DataFrame representing all diaSources associated with this
1038 filterDiaSources : `pandas.DataFrame`
1039 DataFrame representing diaSources associated with this
1040 diaObject that are observed in the band pass ``filterName``.
1042 Simple, string name of the filter for the flux being calculated.
1044 Any additional keyword arguments that may be passed to the plugin.
1046 totMeanName =
"{}TOTFluxMean".
format(filterName)
1047 if totMeanName
not in diaObjects.columns:
1048 diaObjects[totMeanName] = np.nan
1049 totErrName =
"{}TOTFluxMeanErr".
format(filterName)
1050 if totErrName
not in diaObjects.columns:
1051 diaObjects[totErrName] = np.nan
1054 tmpDf = df[~np.logical_or(np.isnan(df[
"totFlux"]),
1055 np.isnan(df[
"totFluxErr"]))]
1056 tot_weight = np.nansum(1 / tmpDf[
"totFluxErr"] ** 2)
1057 fluxMean = np.nansum(tmpDf[
"totFlux"]
1058 / tmpDf[
"totFluxErr"] ** 2)
1059 fluxMean /= tot_weight
1060 fluxMeanErr = np.sqrt(1 / tot_weight)
1062 return pd.Series({totMeanName: fluxMean,
1063 totErrName: fluxMeanErr})
1065 diaObjects.loc[:, [totMeanName, totErrName]] = \
1066 filterDiaSources.apply(_meanFlux)
1075 """Compute scatter of diaSource fluxes.
1078 ConfigClass = SigmaDiaPsFluxConfig
1080 outputCols = [
"TOTFluxSigma"]
1094 """Compute the sigma fluxes of the point source flux measured on the
1100 Summary object to store values in.
1101 diaSources : `pandas.DataFrame`
1102 DataFrame representing all diaSources associated with this
1104 filterDiaSources : `pandas.DataFrame`
1105 DataFrame representing diaSources associated with this
1106 diaObject that are observed in the band pass ``filterName``.
1108 Simple, string name of the filter for the flux being calculated.
1110 Any additional keyword arguments that may be passed to the plugin.
1114 diaObjects.loc[:,
"{}TOTFluxSigma".
format(filterName)] = \
1115 filterDiaSources.totFlux.std()
1116
Point in an unspecified spherical coordinate system.
float FLUX_MOMENTS_CALCULATED
def getExecutionOrder(cls)
def calculate(self, diaObjects, diaSources, filterDiaSources, filterName, **kwargs)
def calculate(self, diaObjects, diaSources, filterDiaSources, filterName, **kwargs)
def getExecutionOrder(cls)
def calculate(self, diaObjects, diaObjectId, **kwargs)
def getExecutionOrder(cls)
def __init__(self, config, name, metadata)
def calculate(self, diaObjects, diaSources, filterDiaSources, filterName, **kwargs)
def getExecutionOrder(cls)
def getExecutionOrder(cls)
def calculate(self, diaObjects, diaSources, filterDiaSources, filterName, **kwargs)
def calculate(self, diaObjects, diaSources, filterDiaSources, filterName, **kwargs)
def getExecutionOrder(cls)
def getExecutionOrder(cls)
def calculate(self, diaObjects, diaSources, **kwargs)
def getExecutionOrder(cls)
def calculate(self, diaObjects, diaSources, filterDiaSources, filterName, **kwargs)
def calculate(self, diaObjects, diaSources, **kwargs)
def getExecutionOrder(cls)
def getExecutionOrder(cls)
def calculate(self, diaObjects, diaSources, filterDiaSources, filterName, **kwargs)
def __init__(self, config, name, metadata, **kwargs)
def calculate(self, diaObjects, diaSources, filterDiaSources, filterName, **kwargs)
def getExecutionOrder(cls)
def getExecutionOrder(cls)
def calculate(self, diaObjects, diaSources, filterDiaSources, filterName, **kwargs)
def getExecutionOrder(cls)
def calculate(self, diaObjects, diaSources, **kwargs)
def getExecutionOrder(cls)
def calculate(self, diaObjects, diaSources, filterDiaSources, filterName, **kwargs)
def _stetson_J(self, fluxes, errors, mean=None)
def _stetson_mean(self, values, errors, mean=None, alpha=2., beta=2., n_iter=20, tol=1e-6)
def getExecutionOrder(cls)
def calculate(self, diaObjects, diaSources, filterDiaSources, filterName, **kwargs)
def getExecutionOrder(cls)
def calculate(self, diaObjects, diaSources, filterDiaSources, filterName, **kwargs)
def getExecutionOrder(cls)
def calculate(self, diaObjects, diaSources, filterDiaSources, filterName, **kwargs)
float DEFAULT_CATALOGCALCULATION
HtmPixelization provides HTM indexing of points and regions.
daf::base::PropertyList * list
SpherePoint averageSpherePoint(std::vector< SpherePoint > const &coords)
Return the average of a list of coordinates.
def catchWarnings(_func=None, *warns=[])
def format(config, name=None, writeSourceLine=True, prefix="", verbose=False)