22"""Plugins for use in DiaSource summary statistics.
25as defined in the schema of the Apdb both in name and units.
31from astropy.stats
import median_absolute_deviation
34from scipy.optimize
import lsq_linear
40from .diaCalculation
import (
41 DiaObjectCalculationPluginConfig,
42 DiaObjectCalculationPlugin)
43from .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)
86@register(
"ap_meanPosition")
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):
120 aveCoord = geom.averageSpherePoint(
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.
151 ConfigClass = HTMIndexDiaPositionConfig
155 inputCols = [
"ra",
"decl"]
156 outputCols = [
"pixelId"]
160 DiaObjectCalculationPlugin.__init__(self, config, name, metadata)
168 """Compute the mean position of a DiaObject given a set of DiaSources
172 diaObjects : `pandas.dataFrame`
173 Summary objects to store values in and read ra/decl
from.
175 Id of the diaObject to update.
177 Any additional keyword arguments that may be passed to the plugin.
180 diaObjects.at[diaObjectId, "ra"] * geom.degrees,
181 diaObjects.at[diaObjectId,
"decl"] * geom.degrees)
182 diaObjects.at[diaObjectId,
"pixelId"] = self.
pixelatorpixelator.index(
183 sphPoint.getVector())
190@register(
"ap_nDiaSources")
192 """Compute the total number of DiaSources associated with this DiaObject.
195 ConfigClass = NumDiaSourcesDiaPluginConfig
196 outputCols = ["nDiaSources"]
205 """Compute the total number of DiaSources associated with this DiaObject.
210 Summary object to store values in and read ra/decl
from.
212 Any additional keyword arguments that may be passed to the plugin.
214 diaObjects.loc[:, "nDiaSources"] = diaSources.diaObjectId.count()
221@register(
"ap_diaObjectFlag")
223 """Find if any DiaSource is flagged.
225 Set the DiaObject flag if any DiaSource
is flagged.
228 ConfigClass = NumDiaSourcesDiaPluginConfig
229 outputCols = ["flags"]
238 """Find if any DiaSource is flagged.
240 Set the DiaObject flag if any DiaSource
is flagged.
245 Summary object to store values
in and read ra/decl
from.
247 Any additional keyword arguments that may be passed to the plugin.
249 diaObjects.loc[:, "flags"] = diaSources.flags.any().astype(np.uint64)
256@register(
"ap_meanFlux")
258 """Compute the weighted mean and mean error on the point source fluxes
259 of the DiaSource measured on the difference image.
261 Additionally store number of usable data points.
264 ConfigClass = WeightedMeanDiaPsFluxConfig
265 outputCols = ["PSFluxMean",
"PSFluxMeanErr",
"PSFluxNdata"]
273 @catchWarnings(warns=[
"invalid value encountered",
281 """Compute the weighted mean and mean error of the point source flux.
286 Summary object to store values in.
287 diaSources : `pandas.DataFrame`
288 DataFrame representing all diaSources associated
with this
290 filterDiaSources : `pandas.DataFrame`
291 DataFrame representing diaSources associated
with this
292 diaObject that are observed
in the band
pass ``filterName``.
294 Simple, string name of the filter
for the flux being calculated.
296 Any additional keyword arguments that may be passed to the plugin.
298 meanName = "{}PSFluxMean".format(filterName)
299 errName =
"{}PSFluxMeanErr".format(filterName)
300 nDataName =
"{}PSFluxNdata".format(filterName)
301 if meanName
not in diaObjects.columns:
302 diaObjects[meanName] = np.nan
303 if errName
not in diaObjects.columns:
304 diaObjects[errName] = np.nan
305 if nDataName
not in diaObjects.columns:
306 diaObjects[nDataName] = 0
308 def _weightedMean(df):
309 tmpDf = df[~np.logical_or(np.isnan(df[
"psFlux"]),
310 np.isnan(df[
"psFluxErr"]))]
311 tot_weight = np.nansum(1 / tmpDf[
"psFluxErr"] ** 2)
312 fluxMean = np.nansum(tmpDf[
"psFlux"]
313 / tmpDf[
"psFluxErr"] ** 2)
314 fluxMean /= tot_weight
316 fluxMeanErr = np.sqrt(1 / tot_weight)
319 nFluxData = len(tmpDf)
321 return pd.Series({meanName: fluxMean,
322 errName: fluxMeanErr,
323 nDataName: nFluxData},
326 diaObjects.loc[:, [meanName, errName, nDataName]] = \
327 filterDiaSources.apply(_weightedMean)
331 percentiles = pexConfig.ListField(
333 default=[5, 25, 50, 75, 95],
334 doc=
"Percentiles to calculate to compute values for. Should be "
339@register("ap_percentileFlux")
341 """Compute percentiles of diaSource fluxes.
344 ConfigClass = PercentileDiaPsFluxConfig
350 def __init__(self, config, name, metadata, **kwargs):
351 DiaObjectCalculationPlugin.__init__(self,
357 for percent
in self.
configconfig.percentiles]
363 @catchWarnings(warns=["All-NaN slice encountered"])
370 """Compute the percentile fluxes of the point source flux.
375 Summary object to store values in.
376 diaSources : `pandas.DataFrame`
377 DataFrame representing all diaSources associated
with this
379 filterDiaSources : `pandas.DataFrame`
380 DataFrame representing diaSources associated
with this
381 diaObject that are observed
in the band
pass ``filterName``.
383 Simple, string name of the filter
for the flux being calculated.
385 Any additional keyword arguments that may be passed to the plugin.
388 for tilePercent
in self.
configconfig.percentiles:
389 pTileName =
"{}PSFluxPercentile{:02d}".format(filterName,
391 pTileNames.append(pTileName)
392 if pTileName
not in diaObjects.columns:
393 diaObjects[pTileName] = np.nan
395 def _fluxPercentiles(df):
396 pTiles = np.nanpercentile(df[
"psFlux"], self.
configconfig.percentiles)
398 dict((tileName, pTile)
399 for tileName, pTile
in zip(pTileNames, pTiles)))
401 diaObjects.loc[:, pTileNames] = filterDiaSources.apply(_fluxPercentiles)
408@register(
"ap_sigmaFlux")
410 """Compute scatter of diaSource fluxes.
413 ConfigClass = SigmaDiaPsFluxConfig
415 outputCols = [
"PSFluxSigma"]
429 """Compute the sigma fluxes of the point source flux.
434 Summary object to store values in.
435 diaSources : `pandas.DataFrame`
436 DataFrame representing all diaSources associated
with this
438 filterDiaSources : `pandas.DataFrame`
439 DataFrame representing diaSources associated
with this
440 diaObject that are observed
in the band
pass ``filterName``.
442 Simple, string name of the filter
for the flux being calculated.
444 Any additional keyword arguments that may be passed to the plugin.
448 diaObjects.loc[:,
"{}PSFluxSigma".format(filterName)] = \
449 filterDiaSources.psFlux.std()
456@register(
"ap_chi2Flux")
458 """Compute chi2 of diaSource fluxes.
461 ConfigClass = Chi2DiaPsFluxConfig
464 inputCols = [
"PSFluxMean"]
466 outputCols = [
"PSFluxChi2"]
474 @catchWarnings(warns=["All-NaN slice encountered"])
481 """Compute the chi2 of the point source fluxes.
486 Summary object to store values in.
487 diaSources : `pandas.DataFrame`
488 DataFrame representing all diaSources associated
with this
490 filterDiaSources : `pandas.DataFrame`
491 DataFrame representing diaSources associated
with this
492 diaObject that are observed
in the band
pass ``filterName``.
494 Simple, string name of the filter
for the flux being calculated.
496 Any additional keyword arguments that may be passed to the plugin.
498 meanName = "{}PSFluxMean".format(filterName)
501 delta = (df[
"psFlux"]
502 - diaObjects.at[df.diaObjectId.iat[0], meanName])
503 return np.nansum((delta / df[
"psFluxErr"]) ** 2)
505 diaObjects.loc[:,
"{}PSFluxChi2".format(filterName)] = \
506 filterDiaSources.apply(_chi2)
513@register(
"ap_madFlux")
515 """Compute median absolute deviation of diaSource fluxes.
518 ConfigClass = MadDiaPsFluxConfig
522 outputCols = [
"PSFluxMAD"]
530 @catchWarnings(warns=["All-NaN slice encountered"])
537 """Compute the median absolute deviation of the point source fluxes.
542 Summary object to store values in.
543 diaSources : `pandas.DataFrame`
544 DataFrame representing all diaSources associated
with this
546 filterDiaSources : `pandas.DataFrame`
547 DataFrame representing diaSources associated
with this
548 diaObject that are observed
in the band
pass ``filterName``.
550 Simple, string name of the filter
for the flux being calculated.
552 Any additional keyword arguments that may be passed to the plugin.
554 diaObjects.loc[:, "{}PSFluxMAD".format(filterName)] = \
555 filterDiaSources.psFlux.apply(median_absolute_deviation,
563@register(
"ap_skewFlux")
565 """Compute the skew of diaSource fluxes.
568 ConfigClass = SkewDiaPsFluxConfig
572 outputCols = [
"PSFluxSkew"]
586 """Compute the skew of the point source fluxes.
591 Summary object to store values in.
592 diaSources : `pandas.DataFrame`
593 DataFrame representing all diaSources associated
with this
595 filterDiaSources : `pandas.DataFrame`
596 DataFrame representing diaSources associated
with this
597 diaObject that are observed
in the band
pass ``filterName``.
599 Simple, string name of the filter
for the flux being calculated.
601 Any additional keyword arguments that may be passed to the plugin.
603 diaObjects.loc[:, "{}PSFluxSkew".format(filterName)] = \
604 filterDiaSources.psFlux.skew()
611@register(
"ap_minMaxFlux")
613 """Compute min/max of diaSource fluxes.
616 ConfigClass = MinMaxDiaPsFluxConfig
620 outputCols = [
"PSFluxMin",
"PSFluxMax"]
634 """Compute min/max of the point source fluxes.
639 Summary object to store values in.
640 diaSources : `pandas.DataFrame`
641 DataFrame representing all diaSources associated
with this
643 filterDiaSources : `pandas.DataFrame`
644 DataFrame representing diaSources associated
with this
645 diaObject that are observed
in the band
pass ``filterName``.
647 Simple, string name of the filter
for the flux being calculated.
649 Any additional keyword arguments that may be passed to the plugin.
651 minName = "{}PSFluxMin".format(filterName)
652 if minName
not in diaObjects.columns:
653 diaObjects[minName] = np.nan
654 maxName =
"{}PSFluxMax".format(filterName)
655 if maxName
not in diaObjects.columns:
656 diaObjects[maxName] = np.nan
658 diaObjects.loc[:, minName] = filterDiaSources.psFlux.min()
659 diaObjects.loc[:, maxName] = filterDiaSources.psFlux.max()
666@register(
"ap_maxSlopeFlux")
668 """Compute the maximum ratio time ordered deltaFlux / deltaTime.
671 ConfigClass = MinMaxDiaPsFluxConfig
675 outputCols = [
"PSFluxMaxSlope"]
689 """Compute the maximum ratio time ordered deltaFlux / deltaTime.
694 Summary object to store values in.
695 diaSources : `pandas.DataFrame`
696 DataFrame representing all diaSources associated
with this
698 filterDiaSources : `pandas.DataFrame`
699 DataFrame representing diaSources associated
with this
700 diaObject that are observed
in the band
pass ``filterName``.
702 Simple, string name of the filter
for the flux being calculated.
704 Any additional keyword arguments that may be passed to the plugin.
708 tmpDf = df[~np.logical_or(np.isnan(df[
"psFlux"]),
709 np.isnan(df[
"midPointTai"]))]
712 times = tmpDf[
"midPointTai"].to_numpy()
713 timeArgs = times.argsort()
714 times = times[timeArgs]
715 fluxes = tmpDf[
"psFlux"].to_numpy()[timeArgs]
716 return (np.diff(fluxes) / np.diff(times)).max()
718 diaObjects.loc[:,
"{}PSFluxMaxSlope".format(filterName)] = \
719 filterDiaSources.apply(_maxSlope)
726@register(
"ap_meanErrFlux")
728 """Compute the mean of the dia source errors.
731 ConfigClass = ErrMeanDiaPsFluxConfig
735 outputCols = [
"PSFluxErrMean"]
749 """Compute the mean of the dia source errors.
754 Summary object to store values in.
755 diaSources : `pandas.DataFrame`
756 DataFrame representing all diaSources associated
with this
758 filterDiaSources : `pandas.DataFrame`
759 DataFrame representing diaSources associated
with this
760 diaObject that are observed
in the band
pass ``filterName``.
762 Simple, string name of the filter
for the flux being calculated.
764 Any additional keyword arguments that may be passed to the plugin.
766 diaObjects.loc[:, "{}PSFluxErrMean".format(filterName)] = \
767 filterDiaSources.psFluxErr.mean()
774@register(
"ap_linearFit")
776 """Compute fit a linear model to flux vs time.
779 ConfigClass = LinearFitDiaPsFluxConfig
783 outputCols = [
"PSFluxLinearSlope",
"PSFluxLinearIntercept"]
797 """Compute fit a linear model to flux vs time.
802 Summary object to store values in.
803 diaSources : `pandas.DataFrame`
804 DataFrame representing all diaSources associated
with this
806 filterDiaSources : `pandas.DataFrame`
807 DataFrame representing diaSources associated
with this
808 diaObject that are observed
in the band
pass ``filterName``.
810 Simple, string name of the filter
for the flux being calculated.
812 Any additional keyword arguments that may be passed to the plugin.
815 mName = "{}PSFluxLinearSlope".format(filterName)
816 if mName
not in diaObjects.columns:
817 diaObjects[mName] = np.nan
818 bName =
"{}PSFluxLinearIntercept".format(filterName)
819 if bName
not in diaObjects.columns:
820 diaObjects[bName] = np.nan
823 tmpDf = df[~np.logical_or(
824 np.isnan(df[
"psFlux"]),
825 np.logical_or(np.isnan(df[
"psFluxErr"]),
826 np.isnan(df[
"midPointTai"])))]
828 return pd.Series({mName: np.nan, bName: np.nan})
829 fluxes = tmpDf[
"psFlux"].to_numpy()
830 errors = tmpDf[
"psFluxErr"].to_numpy()
831 times = tmpDf[
"midPointTai"].to_numpy()
832 A = np.array([times / errors, 1 / errors]).transpose()
833 m, b = lsq_linear(A, fluxes / errors).x
834 return pd.Series({mName: m, bName: b})
836 diaObjects.loc[:, [mName, bName]] = filterDiaSources.apply(_linearFit)
843@register(
"ap_stetsonJ")
845 """Compute the StetsonJ statistic on the DIA point source fluxes.
848 ConfigClass = LinearFitDiaPsFluxConfig
851 inputCols = [
"PSFluxMean"]
853 outputCols = [
"PSFluxStetsonJ"]
867 """Compute the StetsonJ statistic on the DIA point source fluxes.
872 Summary object to store values in.
873 diaSources : `pandas.DataFrame`
874 DataFrame representing all diaSources associated
with this
876 filterDiaSources : `pandas.DataFrame`
877 DataFrame representing diaSources associated
with this
878 diaObject that are observed
in the band
pass ``filterName``.
880 Simple, string name of the filter
for the flux being calculated.
882 Any additional keyword arguments that may be passed to the plugin.
884 meanName = "{}PSFluxMean".format(filterName)
887 tmpDf = df[~np.logical_or(np.isnan(df[
"psFlux"]),
888 np.isnan(df[
"psFluxErr"]))]
891 fluxes = tmpDf[
"psFlux"].to_numpy()
892 errors = tmpDf[
"psFluxErr"].to_numpy()
897 diaObjects.at[tmpDf.diaObjectId.iat[0], meanName])
899 diaObjects.loc[:,
"{}PSFluxStetsonJ".format(filterName)] = \
900 filterDiaSources.apply(_stetsonJ)
902 def _stetson_J(self, fluxes, errors, mean=None):
903 """Compute the single band stetsonJ statistic.
907 fluxes : `numpy.ndarray` (N,)
908 Calibrated lightcurve flux values.
909 errors : `numpy.ndarray` (N,)
910 Errors on the calibrated lightcurve fluxes.
912 Starting mean from previous plugin.
917 stetsonJ statistic
for the input fluxes
and errors.
921 .. [1] Stetson, P. B.,
"On the Automatic Determination of Light-Curve
922 Parameters for Cepheid Variables
", PASP, 108, 851S, 1996
924 n_points = len(fluxes)
925 flux_mean = self._stetson_mean_stetson_mean(fluxes, errors, mean)
927 np.sqrt(n_points / (n_points - 1)) * (fluxes - flux_mean) / errors)
928 p_k = delta_val ** 2 - 1
930 return np.mean(np.sign(p_k) * np.sqrt(np.fabs(p_k)))
932 def _stetson_mean(self,
940 """Compute the stetson mean of the fluxes which down-weights outliers.
942 Weighted biased on an error weighted difference scaled by a constant
943 (1/``a``) and raised to the power beta. Higher betas more harshly
944 penalize outliers
and ``a`` sets the number of sigma where a weighted
945 difference of 1 occurs.
949 values : `numpy.dnarray`, (N,)
950 Input values to compute the mean of.
951 errors : `numpy.ndarray`, (N,)
952 Errors on the input values.
954 Starting mean value
or None.
956 Scalar down-weighting of the fractional difference. lower->more
957 clipping. (Default value
is 2.)
959 Power law slope of the used to down-weight outliers. higher->more
960 clipping. (Default value
is 2.)
962 Number of iterations of clipping.
964 Fractional
and absolute tolerance goal on the change
in the mean
965 before exiting early. (Default value
is 1e-6)
970 Weighted stetson mean result.
974 .. [1] Stetson, P. B.,
"On the Automatic Determination of Light-Curve
975 Parameters for Cepheid Variables
", PASP, 108, 851S, 1996
977 n_points = len(values)
978 n_factor = np.sqrt(n_points / (n_points - 1))
979 inv_var = 1 / errors ** 2
982 mean = np.average(values, weights=inv_var)
983 for iter_idx
in range(n_iter):
984 chi = np.fabs(n_factor * (values - mean) / errors)
985 tmp_mean = np.average(
987 weights=inv_var / (1 + (chi / alpha) ** beta))
988 diff = np.fabs(tmp_mean - mean)
990 if diff / mean < tol
and diff < tol:
999@register(
"ap_meanTotFlux")
1001 """Compute the weighted mean and mean error on the point source fluxes
1002 forced photometered at the DiaSource location in the calibrated image.
1004 Additionally store number of usable data points.
1007 ConfigClass = WeightedMeanDiaPsFluxConfig
1008 outputCols = ["TOTFluxMean",
"TOTFluxMeanErr"]
1016 @catchWarnings(warns=[
"invalid value encountered",
1024 """Compute the weighted mean and mean error of the point source flux.
1029 Summary object to store values in.
1030 diaSources : `pandas.DataFrame`
1031 DataFrame representing all diaSources associated
with this
1033 filterDiaSources : `pandas.DataFrame`
1034 DataFrame representing diaSources associated
with this
1035 diaObject that are observed
in the band
pass ``filterName``.
1037 Simple, string name of the filter
for the flux being calculated.
1039 Any additional keyword arguments that may be passed to the plugin.
1041 totMeanName = "{}TOTFluxMean".format(filterName)
1042 if totMeanName
not in diaObjects.columns:
1043 diaObjects[totMeanName] = np.nan
1044 totErrName =
"{}TOTFluxMeanErr".format(filterName)
1045 if totErrName
not in diaObjects.columns:
1046 diaObjects[totErrName] = np.nan
1049 tmpDf = df[~np.logical_or(np.isnan(df[
"totFlux"]),
1050 np.isnan(df[
"totFluxErr"]))]
1051 tot_weight = np.nansum(1 / tmpDf[
"totFluxErr"] ** 2)
1052 fluxMean = np.nansum(tmpDf[
"totFlux"]
1053 / tmpDf[
"totFluxErr"] ** 2)
1054 fluxMean /= tot_weight
1055 fluxMeanErr = np.sqrt(1 / tot_weight)
1057 return pd.Series({totMeanName: fluxMean,
1058 totErrName: fluxMeanErr})
1060 diaObjects.loc[:, [totMeanName, totErrName]] = \
1061 filterDiaSources.apply(_meanFlux)
1068@register(
"ap_sigmaTotFlux")
1070 """Compute scatter of diaSource fluxes.
1073 ConfigClass = SigmaDiaPsFluxConfig
1075 outputCols = [
"TOTFluxSigma"]
1089 """Compute the sigma fluxes of the point source flux measured on the
1095 Summary object to store values in.
1096 diaSources : `pandas.DataFrame`
1097 DataFrame representing all diaSources associated
with this
1099 filterDiaSources : `pandas.DataFrame`
1100 DataFrame representing diaSources associated
with this
1101 diaObject that are observed
in the band
pass ``filterName``.
1103 Simple, string name of the filter
for the flux being calculated.
1105 Any additional keyword arguments that may be passed to the plugin.
1109 diaObjects.loc[:,
"{}TOTFluxSigma".format(filterName)] = \
1110 filterDiaSources.totFlux.std()
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
def catchWarnings(_func=None, *warns=[])