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.
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())
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()
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)
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",
"divide by zero"])
280 """Compute the weighted mean and mean error of the point source flux.
285 Summary object to store values in.
286 diaSources : `pandas.DataFrame`
287 DataFrame representing all diaSources associated with this
289 filterDiaSources : `pandas.DataFrame`
290 DataFrame representing diaSources associated with this
291 diaObject that are observed in the band pass ``filterName``.
293 Simple, string name of the filter for the flux being calculated.
295 Any additional keyword arguments that may be passed to the plugin.
297 meanName =
"{}PSFluxMean".
format(filterName)
298 errName =
"{}PSFluxMeanErr".
format(filterName)
299 nDataName =
"{}PSFluxNdata".
format(filterName)
300 if meanName
not in diaObjects.columns:
301 diaObjects[meanName] = np.nan
302 if errName
not in diaObjects.columns:
303 diaObjects[errName] = np.nan
304 if nDataName
not in diaObjects.columns:
305 diaObjects[nDataName] = 0
307 def _weightedMean(df):
308 tmpDf = df[~np.logical_or(np.isnan(df[
"psFlux"]),
309 np.isnan(df[
"psFluxErr"]))]
310 tot_weight = np.nansum(1 / tmpDf[
"psFluxErr"] ** 2)
311 fluxMean = np.nansum(tmpDf[
"psFlux"]
312 / tmpDf[
"psFluxErr"] ** 2)
313 fluxMean /= tot_weight
315 fluxMeanErr = np.sqrt(1 / tot_weight)
318 nFluxData = len(tmpDf)
320 return pd.Series({meanName: fluxMean,
321 errName: fluxMeanErr,
322 nDataName: nFluxData},
325 diaObjects.loc[:, [meanName, errName, nDataName]] = \
326 filterDiaSources.apply(_weightedMean)
330 percentiles = pexConfig.ListField(
332 default=[5, 25, 50, 75, 95],
333 doc=
"Percentiles to calculate to compute values for. Should be "
338 @register("ap_percentileFlux")
340 """Compute percentiles of diaSource fluxes.
343 ConfigClass = PercentileDiaPsFluxConfig
349 def __init__(self, config, name, metadata, **kwargs):
350 DiaObjectCalculationPlugin.__init__(self,
356 for percent
in self.
configconfig.percentiles]
362 @catchWarnings(warns=["All-NaN slice encountered"])
369 """Compute the percentile fluxes of the point source flux.
374 Summary object to store values in.
375 diaSources : `pandas.DataFrame`
376 DataFrame representing all diaSources associated with this
378 filterDiaSources : `pandas.DataFrame`
379 DataFrame representing diaSources associated with this
380 diaObject that are observed in the band pass ``filterName``.
382 Simple, string name of the filter for the flux being calculated.
384 Any additional keyword arguments that may be passed to the plugin.
387 for tilePercent
in self.
configconfig.percentiles:
388 pTileName =
"{}PSFluxPercentile{:02d}".
format(filterName,
390 pTileNames.append(pTileName)
391 if pTileName
not in diaObjects.columns:
392 diaObjects[pTileName] = np.nan
394 def _fluxPercentiles(df):
395 pTiles = np.nanpercentile(df[
"psFlux"], self.
configconfig.percentiles)
397 dict((tileName, pTile)
398 for tileName, pTile
in zip(pTileNames, pTiles)))
400 diaObjects.loc[:, pTileNames] = filterDiaSources.apply(_fluxPercentiles)
409 """Compute scatter of diaSource fluxes.
412 ConfigClass = SigmaDiaPsFluxConfig
414 outputCols = [
"PSFluxSigma"]
428 """Compute the sigma fluxes of the point source flux.
433 Summary object to store values in.
434 diaSources : `pandas.DataFrame`
435 DataFrame representing all diaSources associated with this
437 filterDiaSources : `pandas.DataFrame`
438 DataFrame representing diaSources associated with this
439 diaObject that are observed in the band pass ``filterName``.
441 Simple, string name of the filter for the flux being calculated.
443 Any additional keyword arguments that may be passed to the plugin.
447 diaObjects.loc[:,
"{}PSFluxSigma".
format(filterName)] = \
448 filterDiaSources.psFlux.std()
457 """Compute chi2 of diaSource fluxes.
460 ConfigClass = Chi2DiaPsFluxConfig
463 inputCols = [
"PSFluxMean"]
465 outputCols = [
"PSFluxChi2"]
473 @catchWarnings(warns=["All-NaN slice encountered"])
480 """Compute the chi2 of the point source fluxes.
485 Summary object to store values in.
486 diaSources : `pandas.DataFrame`
487 DataFrame representing all diaSources associated with this
489 filterDiaSources : `pandas.DataFrame`
490 DataFrame representing diaSources associated with this
491 diaObject that are observed in the band pass ``filterName``.
493 Simple, string name of the filter for the flux being calculated.
495 Any additional keyword arguments that may be passed to the plugin.
497 meanName =
"{}PSFluxMean".
format(filterName)
500 delta = (df[
"psFlux"]
501 - diaObjects.at[df.diaObjectId.iat[0], meanName])
502 return np.nansum((delta / df[
"psFluxErr"]) ** 2)
504 diaObjects.loc[:,
"{}PSFluxChi2".
format(filterName)] = \
505 filterDiaSources.apply(_chi2)
514 """Compute median absolute deviation of diaSource fluxes.
517 ConfigClass = MadDiaPsFluxConfig
521 outputCols = [
"PSFluxMAD"]
529 @catchWarnings(warns=["All-NaN slice encountered"])
536 """Compute the median absolute deviation of the point source fluxes.
541 Summary object to store values in.
542 diaSources : `pandas.DataFrame`
543 DataFrame representing all diaSources associated with this
545 filterDiaSources : `pandas.DataFrame`
546 DataFrame representing diaSources associated with this
547 diaObject that are observed in the band pass ``filterName``.
549 Simple, string name of the filter for the flux being calculated.
551 Any additional keyword arguments that may be passed to the plugin.
553 diaObjects.loc[:,
"{}PSFluxMAD".
format(filterName)] = \
554 filterDiaSources.psFlux.apply(median_absolute_deviation,
564 """Compute the skew of diaSource fluxes.
567 ConfigClass = SkewDiaPsFluxConfig
571 outputCols = [
"PSFluxSkew"]
585 """Compute the skew of the point source fluxes.
590 Summary object to store values in.
591 diaSources : `pandas.DataFrame`
592 DataFrame representing all diaSources associated with this
594 filterDiaSources : `pandas.DataFrame`
595 DataFrame representing diaSources associated with this
596 diaObject that are observed in the band pass ``filterName``.
598 Simple, string name of the filter for the flux being calculated.
600 Any additional keyword arguments that may be passed to the plugin.
602 diaObjects.loc[:,
"{}PSFluxSkew".
format(filterName)] = \
603 filterDiaSources.psFlux.skew()
612 """Compute min/max of diaSource fluxes.
615 ConfigClass = MinMaxDiaPsFluxConfig
619 outputCols = [
"PSFluxMin",
"PSFluxMax"]
633 """Compute min/max of the point source fluxes.
638 Summary object to store values in.
639 diaSources : `pandas.DataFrame`
640 DataFrame representing all diaSources associated with this
642 filterDiaSources : `pandas.DataFrame`
643 DataFrame representing diaSources associated with this
644 diaObject that are observed in the band pass ``filterName``.
646 Simple, string name of the filter for the flux being calculated.
648 Any additional keyword arguments that may be passed to the plugin.
650 minName =
"{}PSFluxMin".
format(filterName)
651 if minName
not in diaObjects.columns:
652 diaObjects[minName] = np.nan
653 maxName =
"{}PSFluxMax".
format(filterName)
654 if maxName
not in diaObjects.columns:
655 diaObjects[maxName] = np.nan
657 diaObjects.loc[:, minName] = filterDiaSources.psFlux.min()
658 diaObjects.loc[:, maxName] = filterDiaSources.psFlux.max()
667 """Compute the maximum ratio time ordered deltaFlux / deltaTime.
670 ConfigClass = MinMaxDiaPsFluxConfig
674 outputCols = [
"PSFluxMaxSlope"]
688 """Compute the maximum ratio time ordered deltaFlux / deltaTime.
693 Summary object to store values in.
694 diaSources : `pandas.DataFrame`
695 DataFrame representing all diaSources associated with this
697 filterDiaSources : `pandas.DataFrame`
698 DataFrame representing diaSources associated with this
699 diaObject that are observed in the band pass ``filterName``.
701 Simple, string name of the filter for the flux being calculated.
703 Any additional keyword arguments that may be passed to the plugin.
707 tmpDf = df[~np.logical_or(np.isnan(df[
"psFlux"]),
708 np.isnan(df[
"midPointTai"]))]
711 times = tmpDf[
"midPointTai"].to_numpy()
712 timeArgs = times.argsort()
713 times = times[timeArgs]
714 fluxes = tmpDf[
"psFlux"].to_numpy()[timeArgs]
715 return (np.diff(fluxes) / np.diff(times)).
max()
717 diaObjects.loc[:,
"{}PSFluxMaxSlope".
format(filterName)] = \
718 filterDiaSources.apply(_maxSlope)
727 """Compute the mean of the dia source errors.
730 ConfigClass = ErrMeanDiaPsFluxConfig
734 outputCols = [
"PSFluxErrMean"]
748 """Compute the mean of the dia source errors.
753 Summary object to store values in.
754 diaSources : `pandas.DataFrame`
755 DataFrame representing all diaSources associated with this
757 filterDiaSources : `pandas.DataFrame`
758 DataFrame representing diaSources associated with this
759 diaObject that are observed in the band pass ``filterName``.
761 Simple, string name of the filter for the flux being calculated.
763 Any additional keyword arguments that may be passed to the plugin.
765 diaObjects.loc[:,
"{}PSFluxErrMean".
format(filterName)] = \
766 filterDiaSources.psFluxErr.mean()
775 """Compute fit a linear model to flux vs time.
778 ConfigClass = LinearFitDiaPsFluxConfig
782 outputCols = [
"PSFluxLinearSlope",
"PSFluxLinearIntercept"]
796 """Compute fit a linear model to flux vs time.
801 Summary object to store values in.
802 diaSources : `pandas.DataFrame`
803 DataFrame representing all diaSources associated with this
805 filterDiaSources : `pandas.DataFrame`
806 DataFrame representing diaSources associated with this
807 diaObject that are observed in the band pass ``filterName``.
809 Simple, string name of the filter for the flux being calculated.
811 Any additional keyword arguments that may be passed to the plugin.
814 mName =
"{}PSFluxLinearSlope".
format(filterName)
815 if mName
not in diaObjects.columns:
816 diaObjects[mName] = np.nan
817 bName =
"{}PSFluxLinearIntercept".
format(filterName)
818 if bName
not in diaObjects.columns:
819 diaObjects[bName] = np.nan
822 tmpDf = df[~np.logical_or(
823 np.isnan(df[
"psFlux"]),
824 np.logical_or(np.isnan(df[
"psFluxErr"]),
825 np.isnan(df[
"midPointTai"])))]
827 return pd.Series({mName: np.nan, bName: np.nan})
828 fluxes = tmpDf[
"psFlux"].to_numpy()
829 errors = tmpDf[
"psFluxErr"].to_numpy()
830 times = tmpDf[
"midPointTai"].to_numpy()
831 A = np.array([times / errors, 1 / errors]).transpose()
832 m, b = lsq_linear(A, fluxes / errors).x
833 return pd.Series({mName: m, bName: b})
835 diaObjects.loc[:, [mName, bName]] = filterDiaSources.apply(_linearFit)
844 """Compute the StetsonJ statistic on the DIA point source fluxes.
847 ConfigClass = LinearFitDiaPsFluxConfig
850 inputCols = [
"PSFluxMean"]
852 outputCols = [
"PSFluxStetsonJ"]
866 """Compute the StetsonJ statistic on the DIA point source fluxes.
871 Summary object to store values in.
872 diaSources : `pandas.DataFrame`
873 DataFrame representing all diaSources associated with this
875 filterDiaSources : `pandas.DataFrame`
876 DataFrame representing diaSources associated with this
877 diaObject that are observed in the band pass ``filterName``.
879 Simple, string name of the filter for the flux being calculated.
881 Any additional keyword arguments that may be passed to the plugin.
883 meanName =
"{}PSFluxMean".
format(filterName)
886 tmpDf = df[~np.logical_or(np.isnan(df[
"psFlux"]),
887 np.isnan(df[
"psFluxErr"]))]
890 fluxes = tmpDf[
"psFlux"].to_numpy()
891 errors = tmpDf[
"psFluxErr"].to_numpy()
896 diaObjects.at[tmpDf.diaObjectId.iat[0], meanName])
898 diaObjects.loc[:,
"{}PSFluxStetsonJ".
format(filterName)] = \
899 filterDiaSources.apply(_stetsonJ)
901 def _stetson_J(self, fluxes, errors, mean=None):
902 """Compute the single band stetsonJ statistic.
906 fluxes : `numpy.ndarray` (N,)
907 Calibrated lightcurve flux values.
908 errors : `numpy.ndarray` (N,)
909 Errors on the calibrated lightcurve fluxes.
911 Starting mean from previous plugin.
916 stetsonJ statistic for the input fluxes and errors.
920 .. [1] Stetson, P. B., "On the Automatic Determination of Light-Curve
921 Parameters for Cepheid Variables", PASP, 108, 851S, 1996
923 n_points = len(fluxes)
924 flux_mean = self.
_stetson_mean_stetson_mean(fluxes, errors, mean)
926 np.sqrt(n_points / (n_points - 1)) * (fluxes - flux_mean) / errors)
927 p_k = delta_val ** 2 - 1
929 return np.mean(np.sign(p_k) * np.sqrt(np.fabs(p_k)))
931 def _stetson_mean(self,
939 """Compute the stetson mean of the fluxes which down-weights outliers.
941 Weighted biased on an error weighted difference scaled by a constant
942 (1/``a``) and raised to the power beta. Higher betas more harshly
943 penalize outliers and ``a`` sets the number of sigma where a weighted
944 difference of 1 occurs.
948 values : `numpy.dnarray`, (N,)
949 Input values to compute the mean of.
950 errors : `numpy.ndarray`, (N,)
951 Errors on the input values.
953 Starting mean value or None.
955 Scalar down-weighting of the fractional difference. lower->more
956 clipping. (Default value is 2.)
958 Power law slope of the used to down-weight outliers. higher->more
959 clipping. (Default value is 2.)
961 Number of iterations of clipping.
963 Fractional and absolute tolerance goal on the change in the mean
964 before exiting early. (Default value is 1e-6)
969 Weighted stetson mean result.
973 .. [1] Stetson, P. B., "On the Automatic Determination of Light-Curve
974 Parameters for Cepheid Variables", PASP, 108, 851S, 1996
976 n_points = len(values)
977 n_factor = np.sqrt(n_points / (n_points - 1))
978 inv_var = 1 / errors ** 2
981 mean = np.average(values, weights=inv_var)
982 for iter_idx
in range(n_iter):
983 chi = np.fabs(n_factor * (values - mean) / errors)
984 tmp_mean = np.average(
986 weights=inv_var / (1 + (chi / alpha) ** beta))
987 diff = np.fabs(tmp_mean - mean)
989 if diff / mean < tol
and diff < tol:
1000 """Compute the weighted mean and mean error on the point source fluxes
1001 forced photometered at the DiaSource location in the calibrated image.
1003 Additionally store number of usable data points.
1006 ConfigClass = WeightedMeanDiaPsFluxConfig
1007 outputCols = [
"TOTFluxMean",
"TOTFluxMeanErr"]
1015 @catchWarnings(warns=["invalid value encountered",
"divide by zero"])
1022 """Compute the weighted mean and mean error of the point source flux.
1027 Summary object to store values in.
1028 diaSources : `pandas.DataFrame`
1029 DataFrame representing all diaSources associated with this
1031 filterDiaSources : `pandas.DataFrame`
1032 DataFrame representing diaSources associated with this
1033 diaObject that are observed in the band pass ``filterName``.
1035 Simple, string name of the filter for the flux being calculated.
1037 Any additional keyword arguments that may be passed to the plugin.
1039 totMeanName =
"{}TOTFluxMean".
format(filterName)
1040 if totMeanName
not in diaObjects.columns:
1041 diaObjects[totMeanName] = np.nan
1042 totErrName =
"{}TOTFluxMeanErr".
format(filterName)
1043 if totErrName
not in diaObjects.columns:
1044 diaObjects[totErrName] = np.nan
1047 tmpDf = df[~np.logical_or(np.isnan(df[
"totFlux"]),
1048 np.isnan(df[
"totFluxErr"]))]
1049 tot_weight = np.nansum(1 / tmpDf[
"totFluxErr"] ** 2)
1050 fluxMean = np.nansum(tmpDf[
"totFlux"]
1051 / tmpDf[
"totFluxErr"] ** 2)
1052 fluxMean /= tot_weight
1053 fluxMeanErr = np.sqrt(1 / tot_weight)
1055 return pd.Series({totMeanName: fluxMean,
1056 totErrName: fluxMeanErr})
1058 diaObjects.loc[:, [totMeanName, totErrName]] = \
1059 filterDiaSources.apply(_meanFlux)
1068 """Compute scatter of diaSource fluxes.
1071 ConfigClass = SigmaDiaPsFluxConfig
1073 outputCols = [
"TOTFluxSigma"]
1087 """Compute the sigma fluxes of the point source flux measured on the
1093 Summary object to store values in.
1094 diaSources : `pandas.DataFrame`
1095 DataFrame representing all diaSources associated with this
1097 filterDiaSources : `pandas.DataFrame`
1098 DataFrame representing diaSources associated with this
1099 diaObject that are observed in the band pass ``filterName``.
1101 Simple, string name of the filter for the flux being calculated.
1103 Any additional keyword arguments that may be passed to the plugin.
1107 diaObjects.loc[:,
"{}TOTFluxSigma".
format(filterName)] = \
1108 filterDiaSources.totFlux.std()
1109
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)