Coverage for python/lsst/sims/maf/batches/movingObjectsBatch.py : 4%

from __future__ import print_function, division 

from copy import deepcopy 

import os 

import numpy as np 

import numpy.ma as ma 

import matplotlib.pyplot as plt 

import lsst.sims.maf.metrics as metrics 

import lsst.sims.maf.slicers as slicers 

import lsst.sims.maf.stackers as stackers 

import lsst.sims.maf.plots as plots 

import lsst.sims.maf.metricBundles as mb 

from .colMapDict import ColMapDict 

from .common import summaryCompletenessAtTime, summaryCompletenessOverH, fractionPopulationAtThreshold 

__all__ = ['defaultHrange', 'defaultCharacterization','setupMoSlicer', 

'quickDiscoveryBatch', 'discoveryBatch', 

'runCompletenessSummary', 'plotCompleteness', 

'characterizationInnerBatch', 'characterizationOuterBatch', 

'runFractionSummary', 'plotFractions', 

'plotSingle', 'plotActivity', 

'readAndCombine', 'combineSubsets'] 

def defaultHrange(metadata): 

"Provide useful default ranges for H, based on metadata of population type." 

defaultRanges = {'PHA': [16, 28, 0.2], 

'NEO': [16, 28, 0.2], 

'MBA': [16, 26, 0.2], 

'Trojan': [14, 22, 0.2], 

'TNO': [4, 12, 0.2], 

'SDO': [4, 12, 0.2]} 

defaultHmark = {'PHA': 22, 'NEO': 22, 'MBA': 20, 

'Trojan': 18, 'TNO': 8, 'SDO': 8} 

if metadata in defaultRanges: 

Hrange = defaultRanges[metadata] 

Hmark = defaultHmark[metadata] 

elif metadata.upper().startswith('GRANVIK'): 

Hrange = defaultRanges['NEO'] 

Hmark = defaultHmark['NEO'] 

elif metadata.upper().startswith('L7'): 

Hrange = defaultRanges('TNO') 

Hmark = defaultHmark['TNO'] 

else: 

print(f'## Could not find {metadata} in default keys ({defaultRanges.keys()}). \n' 

f'## Using expanded default range instead.') 

Hrange = [4, 28, 0.5] 

Hmark = 10 

return Hrange, Hmark 

def defaultCharacterization(metadata): 

"Provide useful characterization bundle type, based on metadata of population type." 

defaultChar = {'PHA': 'inner', 'NEO': 'inner', 

'MBA': 'inner', 'Trojan': 'inner', 

'TNO': 'outer', 'SDO': 'outer'} 

if metadata in defaultChar: 

char = defaultChar[metadata] 

elif metadata.upper().startswith('GRANVIK'): 

char = 'inner' 

elif metadata.upper().startswith('L7'): 

char = 'outer' 

else: 

print(f'## Could not find {metadata} in default keys ({defaultChar.keys()}). \n' 

f'## Using Inner (Asteroid) characterization by default.') 

char = 'inner' 

return char 

def setupMoSlicer(orbitFile, Hrange, obsFile=None): 

""" 

Set up the slicer and read orbitFile and obsFile from disk. 

Parameters 

---------- 

orbitFile : str 

The file containing the orbit information. 

Hrange : numpy.ndarray or None 

The Hrange parameter to pass to slicer.readOrbits 

obsFile : str, optional 

The file containing the observations of each object, optional. 

If not provided (default, None), then the slicer will not be able to 'slice', but can still plot. 

Returns 

------- 

~lsst.sims.maf.slicer.MoObjSlicer 

""" 

# Read the orbit file and set the H values for the slicer. 

slicer = slicers.MoObjSlicer(Hrange=Hrange) 

slicer.setupSlicer(orbitFile=orbitFile, obsFile=obsFile) 

return slicer 

def quickDiscoveryBatch(slicer, colmap=None, runName='opsim', detectionLosses='detection', metadata='', 

albedo=None, Hmark=None, npReduce=np.mean, constraint=None): 

if colmap is None: 

colmap = ColMapDict('opsimV4') 

bundleList = [] 

plotBundles = [] 

basicPlotDict = {'albedo': albedo, 'Hmark': Hmark, 'npReduce': npReduce, 

'nxbins': 200, 'nybins': 200} 

plotFuncs = [plots.MetricVsH()] 

displayDict ={'group': 'Discovery'} 

if detectionLosses not in ('detection', 'trailing'): 

raise ValueError('Please choose detection or trailing as options for detectionLosses.') 

if detectionLosses == 'trailing': 

magStacker = stackers.MoMagStacker(lossCol='dmagTrail') 

detectionLosses = ' trailing loss' 

else: 

magStacker = stackers.MoMagStacker(lossCol='dmagDetect') 

detectionLosses = ' detection loss' 

# Set up a dictionary to pass to each metric for the column names. 

colkwargs = {'mjdCol': colmap['mjd'], 'seeingCol': colmap['seeingGeom'], 

'expTimeCol': colmap['exptime'], 'm5Col': colmap['fiveSigmaDepth'], 

'nightCol': colmap['night'], 'filterCol': colmap['filter']} 

def _setup_child_metrics(parentMetric): 

childMetrics = {} 

childMetrics['Time'] = metrics.Discovery_TimeMetric(parentMetric, **colkwargs) 

childMetrics['N_Chances'] = metrics.Discovery_N_ChancesMetric(parentMetric, **colkwargs) 

# Could expand to add N_chances per year, but not really necessary. 

return childMetrics 

def _configure_child_bundles(parentBundle): 

dispDict = {'group': 'Discovery', 'subgroup': 'Time', 

'caption': 'Time of discovery of objects', 'order': 0} 

parentBundle.childBundles['Time'].setDisplayDict(dispDict) 

dispDict = {'group': 'Discovery', 'subgroup': 'NChances', 

'caption': 'Number of chances for discovery of objects', 'order': 0} 

parentBundle.childBundles['N_Chances'].setDisplayDict(dispDict) 

return 

# 3 pairs in 15 

md = metadata + ' 3 pairs in 15 nights' + detectionLosses 

# Set up plot dict. 

plotDict = {'title': '%s: %s' % (runName, md)} 

plotDict.update(basicPlotDict) 

metric = metrics.DiscoveryMetric(nObsPerNight=2, tMin=0, tMax=90./60./24., 

nNightsPerWindow=3, tWindow=15, **colkwargs) 

childMetrics = _setup_child_metrics(metric) 

bundle = mb.MoMetricBundle(metric, slicer, constraint, 

stackerList=[magStacker], 

runName=runName, metadata=md, 

childMetrics=childMetrics, 

plotDict=plotDict, plotFuncs=plotFuncs, 

displayDict=displayDict) 

_configure_child_bundles(bundle) 

bundleList.append(bundle) 

# 3 pairs in 30 

md = metadata + ' 3 pairs in 30 nights' + detectionLosses 

plotDict = {'title': '%s: %s' % (runName, md)} 

plotDict.update(basicPlotDict) 

metric = metrics.DiscoveryMetric(nObsPerNight=2, tMin=0, tMax=90. / 60. / 24., 

nNightsPerWindow=3, tWindow=30, **colkwargs) 

childMetrics = _setup_child_metrics(metric) 

bundle = mb.MoMetricBundle(metric, slicer, constraint, 

stackerList=[magStacker], 

runName=runName, metadata=md, 

childMetrics=childMetrics, 

plotDict=plotDict, plotFuncs=plotFuncs, 

displayDict=displayDict) 

_configure_child_bundles(bundle) 

bundleList.append(bundle) 

# Set the runName for all bundles and return the bundleDict. 

for b in bundleList: 

b.setRunName(runName) 

return mb.makeBundlesDictFromList(bundleList), plotBundles 

def discoveryBatch(slicer, colmap=None, runName='opsim', detectionLosses='detection', metadata='', 

albedo=None, Hmark=None, npReduce=np.mean, constraint=None): 

if colmap is None: 

colmap = ColMapDict('opsimV4') 

bundleList = [] 

plotBundles = [] 

basicPlotDict = {'albedo': albedo, 'Hmark': Hmark, 'npReduce': npReduce, 

'nxbins': 200, 'nybins': 200} 

plotFuncs = [plots.MetricVsH()] 

displayDict ={'group': 'Discovery'} 

if detectionLosses not in ('detection', 'trailing'): 

raise ValueError('Please choose detection or trailing as options for detectionLosses.') 

if detectionLosses == 'trailing': 

# These are the SNR-losses only. 

magStacker = stackers.MoMagStacker(lossCol='dmagTrail') 

detectionLosses = ' trailing loss' 

else: 

# This is SNR losses, plus additional loss due to detecting with stellar PSF. 

magStacker = stackers.MoMagStacker(lossCol='dmagDetect') 

detectionLosses = ' detection loss' 

# Set up a dictionary to pass to each metric for the column names. 

colkwargs = {'mjdCol': colmap['mjd'], 'seeingCol': colmap['seeingGeom'], 

'expTimeCol': colmap['exptime'], 'm5Col': colmap['fiveSigmaDepth'], 

'nightCol': colmap['night'], 'filterCol': colmap['filter']} 

def _setup_child_metrics(parentMetric): 

childMetrics = {} 

childMetrics['Time'] = metrics.Discovery_TimeMetric(parentMetric, **colkwargs) 

childMetrics['N_Chances'] = metrics.Discovery_N_ChancesMetric(parentMetric, **colkwargs) 

# Could expand to add N_chances per year, but not really necessary. 

return childMetrics 

def _configure_child_bundles(parentBundle): 

dispDict = {'group': 'Discovery', 'subgroup': 'Time', 

'caption': 'Time of discovery of objects', 'order': 0} 

parentBundle.childBundles['Time'].setDisplayDict(dispDict) 

dispDict = {'group': 'Discovery', 'subgroup': 'NChances', 

'caption': 'Number of chances for discovery of objects', 'order': 0} 

parentBundle.childBundles['N_Chances'].setDisplayDict(dispDict) 

return 

# 3 pairs in 15 and 3 pairs in 30 done in 'quickDiscoveryBatch' (with vis). 

# 3 pairs in 12 

md = metadata + ' 3 pairs in 12 nights' + detectionLosses 

plotDict = {'title': '%s: %s' % (runName, md)} 

plotDict.update(basicPlotDict) 

metric = metrics.DiscoveryMetric(nObsPerNight=2, tMin=0, tMax=90. / 60. / 24., 

nNightsPerWindow=3, tWindow=12, **colkwargs) 

childMetrics = _setup_child_metrics(metric) 

bundle = mb.MoMetricBundle(metric, slicer, constraint, 

stackerList=[magStacker], 

runName=runName, metadata=md, 

childMetrics=childMetrics, 

plotDict=plotDict, plotFuncs=plotFuncs, 

displayDict=displayDict) 

_configure_child_bundles(bundle) 

bundleList.append(bundle) 

# 3 pairs in 20 

md = metadata + ' 3 pairs in 20 nights' + detectionLosses 

plotDict = {'title': '%s: %s' % (runName, md)} 

plotDict.update(basicPlotDict) 

metric = metrics.DiscoveryMetric(nObsPerNight=2, tMin=0, tMax=90. / 60. / 24., 

nNightsPerWindow=3, tWindow=20, **colkwargs) 

childMetrics = _setup_child_metrics(metric) 

bundle = mb.MoMetricBundle(metric, slicer, constraint, 

stackerList=[magStacker], 

runName=runName, metadata=md, 

childMetrics=childMetrics, 

plotDict=plotDict, plotFuncs=plotFuncs, 

displayDict=displayDict) 

_configure_child_bundles(bundle) 

bundleList.append(bundle) 

# 3 pairs in 25 

md = metadata + ' 3 pairs in 25 nights' + detectionLosses 

plotDict = {'title': '%s: %s' % (runName, md)} 

plotDict.update(basicPlotDict) 

metric = metrics.DiscoveryMetric(nObsPerNight=2, tMin=0, tMax=90. / 60. / 24., 

nNightsPerWindow=3, tWindow=25, **colkwargs) 

childMetrics = _setup_child_metrics(metric) 

bundle = mb.MoMetricBundle(metric, slicer, constraint, 

stackerList=[magStacker], 

runName=runName, metadata=md, 

childMetrics=childMetrics, 

plotDict=plotDict, plotFuncs=plotFuncs, 

displayDict=displayDict) 

_configure_child_bundles(bundle) 

bundleList.append(bundle) 

# 4 pairs in 20 

md = metadata + ' 4 pairs in 20 nights' + detectionLosses 

plotDict = {'title': '%s: %s' % (runName, md)} 

plotDict.update(basicPlotDict) 

metric = metrics.DiscoveryMetric(nObsPerNight=2, tMin=0, tMax=90. / 60. / 24., 

nNightsPerWindow=4, tWindow=20, **colkwargs) 

childMetrics = _setup_child_metrics(metric) 

bundle = mb.MoMetricBundle(metric, slicer, constraint, 

stackerList=[magStacker], 

runName=runName, metadata=md, 

childMetrics=childMetrics, 

plotDict=plotDict, plotFuncs=plotFuncs, 

displayDict=displayDict) 

_configure_child_bundles(bundle) 

bundleList.append(bundle) 

# 3 triplets in 30 

md = metadata + ' 3 triplets in 30 nights' + detectionLosses 

plotDict = {'title': '%s: %s' % (runName, md)} 

plotDict.update(basicPlotDict) 

metric = metrics.DiscoveryMetric(nObsPerNight=3, tMin=0, tMax=120. / 60. / 24., 

nNightsPerWindow=3, tWindow=30, **colkwargs) 

childMetrics = _setup_child_metrics(metric) 

bundle = mb.MoMetricBundle(metric, slicer, constraint, 

stackerList=[magStacker], 

runName=runName, metadata=md, 

childMetrics=childMetrics, 

plotDict=plotDict, plotFuncs=plotFuncs, 

displayDict=displayDict) 

_configure_child_bundles(bundle) 

bundleList.append(bundle) 

# 3 quads in 30 

md = metadata + ' 3 quads in 30 nights' + detectionLosses 

plotDict = {'title': '%s: %s' % (runName, md)} 

plotDict.update(basicPlotDict) 

metric = metrics.DiscoveryMetric(nObsPerNight=4, tMin=0, tMax=150. / 60. / 24., 

nNightsPerWindow=3, tWindow=30, **colkwargs) 

childMetrics = _setup_child_metrics(metric) 

bundle = mb.MoMetricBundle(metric, slicer, constraint, 

stackerList=[magStacker], 

runName=runName, metadata=md, 

childMetrics=childMetrics, 

plotDict=plotDict, plotFuncs=plotFuncs, 

displayDict=displayDict) 

_configure_child_bundles(bundle) 

bundleList.append(bundle) 

# Play with SNR. 

# First standard SNR / probabilistic visibility (SNR~5) 

# 3 pairs in 15 

md = metadata + ' 3 pairs in 15 nights SNR=5' + detectionLosses 

# Set up plot dict. 

plotDict = {'title': '%s: %s' % (runName, md)} 

plotDict.update(basicPlotDict) 

metric = metrics.DiscoveryMetric(nObsPerNight=2, tMin=0, tMax=90./60./24., 

nNightsPerWindow=3, tWindow=15, snrLimit=5, **colkwargs) 

childMetrics = _setup_child_metrics(metric) 

bundle = mb.MoMetricBundle(metric, slicer, constraint, 

stackerList=[magStacker], 

runName=runName, metadata=md, 

childMetrics=childMetrics, 

plotDict=plotDict, plotFuncs=plotFuncs, 

displayDict=displayDict) 

_configure_child_bundles(bundle) 

bundleList.append(bundle) 

# 3 pairs in 15, SNR=4. 

md = metadata + ' 3 pairs in 15 nights SNR=4' + detectionLosses 

plotDict = {'title': '%s: %s' % (runName, md)} 

plotDict.update(basicPlotDict) 

metric = metrics.DiscoveryMetric(nObsPerNight=2, tMin=0, tMax=90. / 60. / 24., 

nNightsPerWindow=3, tWindow=15, snrLimit=4, **colkwargs) 

childMetrics = _setup_child_metrics(metric) 

bundle = mb.MoMetricBundle(metric, slicer, constraint, 

stackerList=[magStacker], 

runName=runName, metadata=md, 

childMetrics=childMetrics, 

plotDict=plotDict, plotFuncs=plotFuncs, 

displayDict=displayDict) 

_configure_child_bundles(bundle) 

bundleList.append(bundle) 

# 3 pairs in 30, SNR=5 

md = metadata + ' 3 pairs in 30 nights SNR=5' + detectionLosses 

plotDict = {'title': '%s: %s' % (runName, md)} 

plotDict.update(basicPlotDict) 

metric = metrics.DiscoveryMetric(nObsPerNight=2, tMin=0, tMax=90. / 60. / 24., 

nNightsPerWindow=3, tWindow=30, snrLimit=5, **colkwargs) 

childMetrics = _setup_child_metrics(metric) 

bundle = mb.MoMetricBundle(metric, slicer, constraint, 

stackerList=[magStacker], 

runName=runName, metadata=md, 

childMetrics=childMetrics, 

plotDict=plotDict, plotFuncs=plotFuncs, 

displayDict=displayDict) 

_configure_child_bundles(bundle) 

bundleList.append(bundle) 

# 3 pairs in 30, SNR=4 

md = metadata + ' 3 pairs in 30 nights SNR=4' + detectionLosses 

plotDict = {'title': '%s: %s' % (runName, md)} 

plotDict.update(basicPlotDict) 

metric = metrics.DiscoveryMetric(nObsPerNight=2, tMin=0, tMax=90. / 60. / 24., 

nNightsPerWindow=3, tWindow=30, snrLimit=4, **colkwargs) 

childMetrics = _setup_child_metrics(metric) 

bundle = mb.MoMetricBundle(metric, slicer, constraint, 

stackerList=[magStacker], 

runName=runName, metadata=md, 

childMetrics=childMetrics, 

plotDict=plotDict, plotFuncs=plotFuncs, 

displayDict=displayDict) 

_configure_child_bundles(bundle) 

bundleList.append(bundle) 

# Play with SNR. SNR=3 

# 3 pairs in 15, SNR=3 

md = metadata + ' 3 pairs in 15 nights SNR=3' + detectionLosses 

plotDict = {'title': '%s: %s' % (runName, md)} 

plotDict.update(basicPlotDict) 

metric = metrics.DiscoveryMetric(nObsPerNight=2, tMin=0, tMax=90. / 60. / 24., 

nNightsPerWindow=3, tWindow=15, snrLimit=3, **colkwargs) 

childMetrics = _setup_child_metrics(metric) 

bundle = mb.MoMetricBundle(metric, slicer, constraint, 

stackerList=[magStacker], 

runName=runName, metadata=md, 

childMetrics=childMetrics, 

plotDict=plotDict, plotFuncs=plotFuncs, 

displayDict=displayDict) 

_configure_child_bundles(bundle) 

bundleList.append(bundle) 

# SNR = 0 

# 3 pairs in 15, SNR=0 

md = metadata + ' 3 pairs in 15 nights SNR=0' + detectionLosses 

plotDict = {'title': '%s: %s' % (runName, md)} 

plotDict.update(basicPlotDict) 

metric = metrics.DiscoveryMetric(nObsPerNight=2, tMin=0, tMax=90. / 60. / 24., 

nNightsPerWindow=3, tWindow=15, snrLimit=0, **colkwargs) 

childMetrics = _setup_child_metrics(metric) 

bundle = mb.MoMetricBundle(metric, slicer, constraint, 

stackerList=[magStacker], 

runName=runName, metadata=md, 

childMetrics=childMetrics, 

plotDict=plotDict, plotFuncs=plotFuncs, 

displayDict=displayDict) 

_configure_child_bundles(bundle) 

bundleList.append(bundle) 

# Play with weird strategies. 

# Single detection. 

md = metadata + ' Single detection' + detectionLosses 

plotDict = {'title': '%s: %s' % (runName, md)} 

plotDict.update(basicPlotDict) 

metric = metrics.DiscoveryMetric(nObsPerNight=1, tMin=0, tMax=90. / 60. / 24., 

nNightsPerWindow=1, tWindow=5, **colkwargs) 

childMetrics = _setup_child_metrics(metric) 

bundle = mb.MoMetricBundle(metric, slicer, constraint, 

stackerList=[magStacker], 

runName=runName, metadata=md, 

childMetrics=childMetrics, 

plotDict=plotDict, plotFuncs=plotFuncs, 

displayDict=displayDict) 

_configure_child_bundles(bundle) 

bundleList.append(bundle) 

# Single pair of detections. 

md = metadata + ' Single pair' + detectionLosses 

plotDict = {'title': '%s: %s' % (runName, md)} 

plotDict.update(basicPlotDict) 

metric = metrics.DiscoveryMetric(nObsPerNight=2, tMin=0, tMax=90. / 60. / 24., 

nNightsPerWindow=1, tWindow=5, **colkwargs) 

childMetrics = _setup_child_metrics(metric) 

bundle = mb.MoMetricBundle(metric, slicer, constraint, 

stackerList=[magStacker], 

runName=runName, metadata=md, 

childMetrics=childMetrics, 

plotDict=plotDict, plotFuncs=plotFuncs, 

displayDict=displayDict) 

_configure_child_bundles(bundle) 

bundleList.append(bundle) 

# High velocity discovery. 

displayDict['subgroup'] = 'High Velocity' 

# High velocity. 

md = metadata + ' High velocity pair' + detectionLosses 

plotDict = {'title': '%s: %s' % (runName, md)} 

plotDict.update(basicPlotDict) 

metric = metrics.HighVelocityNightsMetric(psfFactor=2., nObsPerNight=2, **colkwargs) 

bundle = mb.MoMetricBundle(metric, slicer, constraint, 

stackerList=[magStacker], 

runName=runName, metadata=md, 

plotDict=plotDict, plotFuncs=plotFuncs, 

displayDict=displayDict) 

bundleList.append(bundle) 

# "magic" detection - 6 in 60 days. 

md = metadata + ' 6 detections in 60 nights' + detectionLosses 

plotDict = {'title': '%s: %s' % (runName, md)} 

plotDict.update(basicPlotDict) 

metric = metrics.MagicDiscoveryMetric(nObs=6, tWindow=60, **colkwargs) 

bundle = mb.MoMetricBundle(metric, slicer, constraint, 

stackerList=[magStacker], 

runName=runName, metadata=md, 

plotDict=plotDict, plotFuncs=plotFuncs, 

displayDict=displayDict) 

bundleList.append(bundle) 

# Set the runName for all bundles and return the bundleDict. 

for b in bundleList: 

b.setRunName(runName) 

return mb.makeBundlesDictFromList(bundleList), plotBundles 

def runCompletenessSummary(bdict, Hmark, times, outDir, resultsDb): 

""" 

Calculate completeness and create completeness bundles from all N_Chances and Time (child) metrics 

of the (discovery) bundles in bdict, and write completeness at Hmark to resultsDb, save bundle to disk. 

This should be done after combining any sub-sets of the metric results. 

Parameters 

---------- 

bdict : dict of metricBundles 

Dict containing ~lsst.sims.maf.MoMetricBundles, 

including bundles we're expecting to contain completeness. 

Hmark : float 

Hmark value to add to completeness plotting dict. 

If not defined (None), then the Hmark from the plotdict from the metric will be used if available. 

If None and Hmark not in plotDict, then median of Hrange value will be used. 

times : np.ndarray 

The times at which to calculate completeness (over time). 

outDir : str 

Output directory to save completeness bundles to disk. 

resultsDb : ~lsst.sims.maf.db.ResultsDb 

Results database to save information about completeness bundle. 

Returns 

------- 

dict of metricBundles 

A dictionary of the new completeness bundles. Keys match original keys, 

with additions of "[Differential,Cumulative]Completeness@Time" 

and "[Differential,Cumulative]Completeness" to distinguish new entries. 

""" 

# Add completeness bundles and write completeness at Hmark to resultsDb. 

completeness = {} 

group = 'Discovery' 

subgroup = 'Completeness' 

def _compbundles(b, bundle, Hmark, resultsDb): 

# Find Hmark if not set (this may be different for different bundles). 

if Hmark is None and 'Hmark' in bundle.plotDict: 

Hmark = bundle.plotDict['Hmark'] 

if Hmark is None: 

Hmark = np.median(bundle.slicer.slicePoints['H']) 

# Set up the summary metrics. 

summaryTimeMetrics = summaryCompletenessAtTime(times, Hval=Hmark, Hindex=0.33) 

summaryTimeMetrics2 = summaryCompletenessAtTime(times, Hval=Hmark - 2, Hindex=0.33) 

summaryHMetrics = summaryCompletenessOverH(requiredChances=1, Hindex=0.33) 

comp = {} 

# Bundle = single metric bundle. Add differential and cumulative completeness. 

if 'Time' in bundle.metric.name: 

for metric in summaryTimeMetrics: 

newkey = b + ' ' + metric.name 

comp[newkey] = mb.makeCompletenessBundle(bundle, metric, 

Hmark=None, resultsDb=resultsDb) 

comp[newkey].plotDict['times'] = times 

comp[newkey].plotDict['Hval'] = metric.Hval 

for metric in summaryTimeMetrics2: 

newkey = b + ' ' + metric.name 

comp[newkey] = mb.makeCompletenessBundle(bundle, metric, 

Hmark=None, resultsDb=resultsDb) 

comp[newkey].plotDict['times'] = times 

comp[newkey].plotDict['Hval'] = metric.Hval 

elif 'N_Chances' in bundle.metric.name: 

for metric in summaryHMetrics: 

newkey = b + ' ' + metric.name 

comp[newkey] = mb.makeCompletenessBundle(bundle, metric, 

Hmark=Hmark, resultsDb=resultsDb) 

return comp 

# Generate the completeness bundles for the various discovery metrics. 

for b, bundle in bdict.items(): 

if 'Discovery' in bundle.metric.name: 

completeness.update(_compbundles(b, bundle, Hmark, resultsDb)) 

if isinstance(bundle.metric, metrics.HighVelocityNightsMetric): 

completeness.update(_compbundles(b, bundle, Hmark, resultsDb)) 

if isinstance(bundle.metric, metrics.MagicDiscoveryMetric): 

completeness.update(_compbundles(b, bundle, Hmark, resultsDb)) 

# Write the completeness bundles to disk, so we can re-read them later. 

# (also set the display dict properties, for the resultsDb output). 

for b, bundle in completeness.items(): 

bundle.setDisplayDict({'group': group, 'subgroup': subgroup}) 

bundle.write(outDir=outDir, resultsDb=resultsDb) 

return completeness 

def plotCompleteness(bdictCompleteness, figroot=None, resultsDb=None, 

outDir='.', figformat='pdf'): 

"""Plot a minor subset of the completeness results. 

""" 

# Separate some subsets to plot together. 

keys = ['3_pairs_in_30_nights_detection_loss', 

'3_pairs_in_15_nights_detection_loss'] 

plotTimes = {} 

plotComp = {} 

plotDiff = {} 

for k in bdictCompleteness: 

for key in keys: 

if key in k: 

if 'Discovery_Time' in k: 

if 'Cumulative' in k: 

plotTimes[k] = bdictCompleteness[k] 

elif 'Discovery_N_Chances' in k: 

if 'Differential' in k: 

plotDiff[k] = bdictCompleteness[k] 

elif 'Cumulative' in k: 

plotComp[k] = bdictCompleteness[k] 

# Add plot dictionaries to code 30 nights red, 15 nights blue, differentials dotted. 

def _codePlot(key): 

plotDict = {} 

if 'Differential' in k: 

plotDict['linestyle'] = ':' 

else: 

plotDict['linestyle'] = '-' 

if '30_nights' in k: 

plotDict['color'] = 'r' 

if '15_nights' in k: 

plotDict['color'] = 'b' 

return plotDict 

# Apply color-coding. 

for k, b in plotTimes.items(): 

b.setPlotDict(_codePlot(k)) 

for k, b in plotDiff.items(): 

b.setPlotDict(_codePlot(k)) 

for k, b in plotComp.items(): 

b.setPlotDict(_codePlot(k)) 

first = bdictCompleteness[list(bdictCompleteness.keys())[0]] 

if figroot is None: 

figroot = first.runName 

# Plot completeness as a function of time. 

fig = plt.figure(figsize=(8, 6)) 

for k in plotTimes: 

plt.plot(plotTimes[k].plotDict['times'], plotTimes[k].metricValues[0, :], 

label=plotTimes[k].plotDict['label'] + ' @H=%.2f' % plotTimes[k].plotDict['Hval']) 

plt.legend() 

plt.xlabel('Time (MJD)') 

plt.ylabel('Completeness') 

plt.grid(True, alpha=0.3) 

# Make a PlotHandler to deal with savings/resultsDb, etc. 

ph = plots.PlotHandler(figformat=figformat, resultsDb=resultsDb, outDir=outDir) 

displayDict = {'group': 'Completeness', 'subgroup': 'Over Time', 

'caption': 'Completeness over time, for H values indicated in legend.'} 

ph.saveFig(fig.number, f'{figroot}_CompletenessOverTime', 'Combo', 'CompletenessOverTime', 'MoObjSlicer', 

figroot, None, None, displayDict=displayDict) 

plt.savefig(os.path.join(outDir, f'{figroot}_CompletenessOverTime.{figformat}'), format=figformat) 

# Plot cumulative completeness. 

ph = plots.PlotHandler(figformat=figformat, resultsDb=resultsDb, outDir=outDir) 

ph.setMetricBundles(plotComp) 

plotDict = {'ylabel': "Completeness", 'figsize': (8, 6), 'albedo': 0.14} 

ph.plot(plotFunc=plots.MetricVsH(), plotDicts=plotDict, 

outfileRoot=figroot + '_CumulativeCompleteness') 

# Plot differential completeness. 

ph = plots.PlotHandler(figformat=figformat, resultsDb=resultsDb, outDir=outDir) 

ph.setMetricBundles(plotDiff) 

plotDict = {'ylabel': "Completeness", 'figsize': (8, 6)} 

ph.plot(plotFunc=plots.MetricVsH(), plotDicts=plotDict, 

outfileRoot=figroot + '_DifferentialCompleteness') 

def characterizationInnerBatch(slicer, colmap=None, runName='opsim', metadata='', 

albedo=None, Hmark=None, constraint=None, npReduce=np.mean, 

windows=None, bins=None): 

"""Characterization metrics for inner solar system objects. 

""" 

if colmap is None: 

colmap = ColMapDict('opsimV4') 

bundleList = [] 

plotBundles = [] 

# Set up a dictionary to pass to each metric for the column names. 

colkwargs = {'mjdCol': colmap['mjd'], 'seeingCol': colmap['seeingGeom'], 

'expTimeCol': colmap['exptime'], 'm5Col': colmap['fiveSigmaDepth'], 

'nightCol': colmap['night'], 'filterCol': colmap['filter']} 

basicPlotDict = {'albedo': albedo, 'Hmark': Hmark, 'npReduce': npReduce, 

'nxbins': 200, 'nybins': 200} 

plotFuncs = [plots.MetricVsH()] 

displayDict ={'group': 'Characterization'} 

# Stackers 

magStacker = stackers.MoMagStacker(lossCol='dmagDetect') 

eclStacker = stackers.EclStacker() 

stackerList = [magStacker, eclStacker] 

# Windows are the different 'length of activity' 

if windows is None: 

windows = np.arange(10, 200, 30.)