PandAna.reco_validation.prod5_pid_validation Namespace Reference

Classes
class	caf_spectra

Functions
def	get_files (det, swap_str, horn_current)
def	ApplySlcCutsPngDF (png_df, slc_df)
def	kIsFarDet (tables)
	FD check. More...
def	kNueContain (tables)
	nue cuts ###################### More...
def	kNuePresel (tables)
def	kNumuContain (tables)
def	kNumuPresel (tables)
def	kNusContain (tables)
	nus cuts ###################### More...
def	kNusPresel (tables)
def	kProtonPIDProd5FHC (tables)
def	kProtonPIDProd5RHC (tables)
def	kPhotonPIDProd5FHC (tables)
def	kPhotonPIDProd5RHC (tables)
def	kPionPIDProd5FHC (tables)
def	kPionPIDProd5RHC (tables)
def	kElectronPIDProd5FHC (tables)
def	kElectronPIDProd5RHC (tables)
def	kMuonPIDProd5FHC (tables)
def	kMuonPIDProd5RHC (tables)
def	kEMPIDProd5FHC (tables)
def	kEMPIDProd5RHC (tables)
def	kProtonPID (tables)
def	kPhotonPID (tables)
def	kPionPID (tables)
def	kElectronPID (tables)
def	kMuonPID (tables)
def	kEMPID (tables)
def	main (wc, limit, stride, offset, spectra_file, make_plots, output, caf)
def	plot (spec, nbins, xlabel, ylabel, name)
def	event_count_report (label, specs, networks)
def	plot_ratio (specs, nbins, xlabel, ylabel, plot_name, logy=True, spec_styles=None, additional_handles=None)
def	ratio (spec1, spec2, nbins, pot, binrange=(0, 1))

Variables
	invalid
	divide
	KLP = KL+['rec.vtx.elastic.fuzzyk.png_idx']
	kNueContain = Cut(kNueContain)
	kNuePresel = Cut(kNuePresel)
	kNumuNoPIDNoCCEFD = kNumuBasicQuality&kNumuContainFD
	numu cuts ##################### kCCE isn't working yet More...
	kNumuNoPIDNoCCEND = kNumuBasicQuality&kNumuContainND
	kNumuContain = Cut(kNumuContain)
	kNumuPresel = Cut(kNumuPresel)
	kNusContain = Cut(kNusContain)
	kNusPresel = Cut(kNusPresel)
	kCosVeto = kVeto
	ORd cuts #####################. More...
	kOrContainment = kNumuContain|kNusContain|kNueContain
	kOrPreselection = kNumuPresel|kNusPresel|kNuePresel
	kHas2020Score = Cut(lambda tables: tables['rec.vtx.elastic.fuzzyk.png.cvnpart2020fhc']['muonid'] > 0)
	kHas2018Score = Cut(lambda tables: tables['rec.vtx.elastic.fuzzyk.png.cvnpart']['muonid'] > 0)
	kProngLength = Cut(lambda tables: tables['rec.vtx.elastic.fuzzyk.png']['len'] < 500)
	kProngCuts = kProngLength&kHas2020Score&kHas2018Score
	kIsChargedPion = Cut(lambda tables: abs(tables['rec.vtx.elastic.fuzzyk.png.truth']['pdg']) == 211)
	kIsPhoton = Cut(lambda tables: tables['rec.vtx.elastic.fuzzyk.png.truth']['pdg'] == 22)
	kIsNeutron = Cut(lambda tables: abs(tables['rec.vtx.elastic.fuzzyk.png.truth']['pdg']) == 2112)
	kIsProton = Cut(lambda tables: abs(tables['rec.vtx.elastic.fuzzyk.png.truth']['pdg']) == 2212)
	kIsElectron = Cut(lambda tables: abs(tables['rec.vtx.elastic.fuzzyk.png.truth']['pdg']) == 11)
	kIsMuon = Cut(lambda tables: abs(tables['rec.vtx.elastic.fuzzyk.png.truth']['pdg']) == 13)
	kPhotonPIDProd5FHC = Var(kPhotonPIDProd5FHC)
	kProtonPIDProd5FHC = Var(kProtonPIDProd5FHC)
	kPionPIDProd5FHC = Var(kPionPIDProd5FHC)
	kElectronPIDProd5FHC = Var(kElectronPIDProd5FHC)
	kMuonPIDProd5FHC = Var(kMuonPIDProd5FHC)
	kEMPIDProd5FHC = Var(kEMPIDProd5FHC)
	kPhotonPIDProd5RHC = Var(kPhotonPIDProd5RHC)
	kProtonPIDProd5RHC = Var(kProtonPIDProd5RHC)
	kPionPIDProd5RHC = Var(kPionPIDProd5RHC)
	kElectronPIDProd5RHC = Var(kElectronPIDProd5RHC)
	kMuonPIDProd5RHC = Var(kMuonPIDProd5RHC)
	kEMPIDProd5RHC = Var(kEMPIDProd5RHC)
	kPhotonPID = Var(kPhotonPID)
	kProtonPID = Var(kProtonPID)
	kPionPID = Var(kPionPID)
	kElectronPID = Var(kElectronPID)
	kMuonPID = Var(kMuonPID)
	kEMPID = Var(kEMPID)
dictionary	cut_levels
dictionary	datasets
list	pids = ['photonid', 'protonid', 'pionid', 'electronid', 'muonid', 'emid']
dictionary	pid_scores_fhc
dictionary	pid_scores_rhc
dictionary	pid_scores
dictionary	particle_cuts
dictionary	particle_colors
	parser = argparse.ArgumentParser('Plot prod5 and prod4 PID distributions')
	default
	None
	type
	help
	action
	args = parser.parse_args()

Function Documentation

def PandAna.reco_validation.prod5_pid_validation.ApplySlcCutsPngDF	(		png_df,
			slc_df
	)

Definition at line 33 of file prod5_pid_validation.py.

References g4zmq.apply().

Referenced by PandAna.reco_validation.prod5_pid_validation.main(), and PandAna.reco_validation.prod5_pid_validation_data_mc.prod5_pid_data_mc().

def ApplySlcCutsPngDF(png_df, slc_df):
    png_name = png_df.name
    slc_name = slc_df.name

    # reset to slice level index
    df = png_df.reset_index().set_index(KL)
   
    val = df[png_name]  # get var column
    val = val.groupby(level=KL).agg(list)  # each row contains list of prong values

    # slc_df has indices that pass slice cuts. concat with prong column. join='inner' drops rows in prong column that don't pass slice cuts
    # drop slice var column
    val = pd.concat([val, slc_df], axis=1, join='inner').drop(slc_name, axis=1)
    
    # if no prongs pass prong and slice cuts, return an empty df
    if val.empty:
        val = pd.DataFrame([], columns=[png_name])

    else:
        # unlist each row
        val = val[png_name].apply(pd.Series).stack()
        val = val.reset_index()
        val.columns = KL + ['idx', png_name]
        # set new index 
        val = val.set_index(KL + ['idx'])

    # contains prong dataframe that has slice cuts applied
    return val[png_name]

# selection cuts

def PandAna.reco_validation.prod5_pid_validation.event_count_report	(		label,
			specs,
			networks
	)

Definition at line 483 of file prod5_pid_validation.py.

References novadaq::HexUtils.format(), febshutoff_auto.integral, PandAna.reco_validation.prod5_pid_validation.plot_ratio(), and print.

def event_count_report(label, specs, networks):
    integrals = [spec.integral() for spec in specs]
    nominal = specs[0].integral()
    print('{} | '.format(label), end='')
    for spec, label, integral in zip(specs, networks, integrals):
        perdiff = (nominal - integral) / nominal
        print('  {}: {} ({:.2f})  |'.format(label, integral, perdiff), end='')
    print('')

def PandAna.reco_validation.prod5_pid_validation.get_files	(		det,
			swap_str,
			horn_current
	)

Definition at line 24 of file prod5_pid_validation.py.

Referenced by PandAna.reco_validation.prod5_pid_validation.main().

def get_files(det, swap_str, horn_current):
    d = '/lfstev/nnet/R19-02-23-miniprod5/'
    if 'FD' in det:
        d = d + 'FD-' + swap_str + "-" + horn_current + '-Eval/'
    else:
        d = d + 'ND-Mont-' + horn_current + '/'
    return [os.path.join(d, f) for f in os.listdir(d) if 'h5caf.h5' in f]

# workaround for applying slice cuts such as preselections to prong level spectra

def PandAna.reco_validation.prod5_pid_validation.kElectronPID

(

tables

)

Definition at line 200 of file prod5_pid_validation.py.

References PandAna.reco_validation.prod5_pid_validation.kElectronPID.

def kElectronPID(tables):
    cvn_png_df = tables[('rec.vtx.elastic.fuzzyk.png.cvnpart')]
    return cvn_png_df['electronid']

def PandAna.reco_validation.prod5_pid_validation.kElectronPIDProd5FHC

(

tables

)

Definition at line 163 of file prod5_pid_validation.py.

References PandAna.reco_validation.prod5_pid_validation.kElectronPIDProd5FHC.

def kElectronPIDProd5FHC(tables):
    cvn_png_df = tables[('rec.vtx.elastic.fuzzyk.png.cvnpart2020fhc')]
    return cvn_png_df['electronid']

def PandAna.reco_validation.prod5_pid_validation.kElectronPIDProd5RHC

(

tables

)

Definition at line 166 of file prod5_pid_validation.py.

References PandAna.reco_validation.prod5_pid_validation.kElectronPIDProd5RHC.

def kElectronPIDProd5RHC(tables):
    cvn_png_df = tables[('rec.vtx.elastic.fuzzyk.png.cvnpart2020rhc')]
    return cvn_png_df['electronid']

def PandAna.reco_validation.prod5_pid_validation.kEMPID

(

tables

)

Definition at line 208 of file prod5_pid_validation.py.

References PandAna.reco_validation.prod5_pid_validation.kElectronPID, PandAna.reco_validation.prod5_pid_validation.kEMPID, and PandAna.reco_validation.prod5_pid_validation.kPhotonPID.

def kEMPID(tables):
    emid_df = kElectronPID(tables) + kPhotonPID(tables)
    emid_df.name = 'emid' # name the series, we'll need it later
    return emid_df

# fhc trained networks

def PandAna.reco_validation.prod5_pid_validation.kEMPIDProd5FHC

(

tables

)

Definition at line 177 of file prod5_pid_validation.py.

References PandAna.reco_validation.prod5_pid_validation.kElectronPIDProd5FHC, PandAna.reco_validation.prod5_pid_validation.kEMPIDProd5FHC, and PandAna.reco_validation.prod5_pid_validation.kPhotonPIDProd5FHC.

def kEMPIDProd5FHC(tables):
    emid_df = kElectronPIDProd5FHC(tables) + kPhotonPIDProd5FHC(tables)
    emid_df.name = 'emid' # name the series, we'll need it later
    return emid_df

def PandAna.reco_validation.prod5_pid_validation.kEMPIDProd5RHC

(

tables

)

Definition at line 181 of file prod5_pid_validation.py.

References PandAna.reco_validation.prod5_pid_validation.kElectronPIDProd5RHC, PandAna.reco_validation.prod5_pid_validation.kEMPIDProd5RHC, and PandAna.reco_validation.prod5_pid_validation.kPhotonPIDProd5RHC.

def kEMPIDProd5RHC(tables):
    emid_df = kElectronPIDProd5RHC(tables) + kPhotonPIDProd5RHC(tables)
    emid_df.name = 'emid' # name the series, we'll need it later
    return emid_df


# PID vars prod4

def PandAna.reco_validation.prod5_pid_validation.kIsFarDet

(

tables

)

FD check.

Definition at line 64 of file prod5_pid_validation.py.

References PandAna.reco_validation.prod5_pid_validation.type.

Referenced by PandAna.reco_validation.prod5_pid_validation.kNueContain(), PandAna.reco_validation.prod5_pid_validation.kNuePresel(), PandAna.reco_validation.prod5_pid_validation.kNumuContain(), PandAna.reco_validation.prod5_pid_validation.kNumuPresel(), PandAna.reco_validation.prod5_pid_validation.kNusContain(), and PandAna.reco_validation.prod5_pid_validation.kNusPresel().

def kIsFarDet(tables):
    query = tables._files.query
    if not type(query) is list: query = [query]
    return 'fardet' in query[0]

def PandAna.reco_validation.prod5_pid_validation.kMuonPID

(

tables

)

Definition at line 204 of file prod5_pid_validation.py.

References PandAna.reco_validation.prod5_pid_validation.kMuonPID.

def kMuonPID(tables):
    cvn_png_df = tables[('rec.vtx.elastic.fuzzyk.png.cvnpart')]
    return cvn_png_df['muonid']

def PandAna.reco_validation.prod5_pid_validation.kMuonPIDProd5FHC

(

tables

)

Definition at line 170 of file prod5_pid_validation.py.

References PandAna.reco_validation.prod5_pid_validation.kMuonPIDProd5FHC.

def kMuonPIDProd5FHC(tables):
    cvn_png_df = tables[('rec.vtx.elastic.fuzzyk.png.cvnpart2020fhc')]
    return cvn_png_df['muonid']

def PandAna.reco_validation.prod5_pid_validation.kMuonPIDProd5RHC

(

tables

)

Definition at line 173 of file prod5_pid_validation.py.

References PandAna.reco_validation.prod5_pid_validation.kMuonPIDProd5RHC.

def kMuonPIDProd5RHC(tables):
    cvn_png_df = tables[('rec.vtx.elastic.fuzzyk.png.cvnpart2020rhc')]
    return cvn_png_df['muonid']

def PandAna.reco_validation.prod5_pid_validation.kNueContain

(

tables

)

nue cuts ######################

Definition at line 70 of file prod5_pid_validation.py.

References PandAna.reco_validation.prod5_pid_validation.kIsFarDet(), kNueBasicPart, PandAna.reco_validation.prod5_pid_validation.kNueContain, PandAna.cut.analysis_cuts.kNueNDContain, and PandAna.cut.analysis_cuts.kNueProngContainment.

def kNueContain(tables):
    if kIsFarDet(tables):
        return kNueProngContainment(tables) & kNueBasicPart(tables)
    else:
        return kNueNDContain(tables)

def PandAna.reco_validation.prod5_pid_validation.kNuePresel

(

tables

)

Definition at line 78 of file prod5_pid_validation.py.

References PandAna.reco_validation.prod5_pid_validation.kIsFarDet(), PandAna.cut.analysis_cuts.kNueCorePresel, PandAna.cut.analysis_cuts.kNueNDPresel, and PandAna.reco_validation.prod5_pid_validation.kNuePresel.

def kNuePresel(tables):
    if kIsFarDet(tables):
        return kNueCorePresel(tables)
    else:
        return kNueNDPresel(tables)

def PandAna.reco_validation.prod5_pid_validation.kNumuContain

(

tables

)

Definition at line 90 of file prod5_pid_validation.py.

References PandAna.reco_validation.prod5_pid_validation.kIsFarDet(), PandAna.reco_validation.prod5_pid_validation.kNumuContain, ana.kNumuContainFD, and ana.kNumuContainND.

def kNumuContain(tables):
    if kIsFarDet(tables):
        return kNumuContainFD(tables)
    else:
        return kNumuContainND(tables)
        

def PandAna.reco_validation.prod5_pid_validation.kNumuPresel

(

tables

)

Definition at line 98 of file prod5_pid_validation.py.

References PandAna.reco_validation.prod5_pid_validation.kIsFarDet(), PandAna.reco_validation.prod5_pid_validation.kNumuNoPIDNoCCEFD, PandAna.reco_validation.prod5_pid_validation.kNumuNoPIDNoCCEND, and PandAna.reco_validation.prod5_pid_validation.kNumuPresel.

def kNumuPresel(tables):
    if kIsFarDet(tables):
        return kNumuNoPIDNoCCEFD(tables)
    else:
        return kNumuNoPIDNoCCEND(tables)

def PandAna.reco_validation.prod5_pid_validation.kNusContain

(

tables

)

nus cuts ######################

Definition at line 107 of file prod5_pid_validation.py.

References PandAna.reco_validation.prod5_pid_validation.kIsFarDet(), PandAna.reco_validation.prod5_pid_validation.kNusContain, ana.kNusFDContain, and ana.kNusNDContain.

def kNusContain(tables):
    if kIsFarDet(tables):
        return kNusFDContain(tables)
    else:
        return kNusNDContain(tables)

def PandAna.reco_validation.prod5_pid_validation.kNusPresel

(

tables

)

Definition at line 114 of file prod5_pid_validation.py.

References PandAna.reco_validation.prod5_pid_validation.kIsFarDet(), ana.kNusFDPresel, ana.kNusNDPresel, and PandAna.reco_validation.prod5_pid_validation.kNusPresel.

def kNusPresel(tables):
    if kIsFarDet(tables):
        return kNusFDPresel(tables)
    else:
        return kNusNDPresel(tables)

def PandAna.reco_validation.prod5_pid_validation.kPhotonPID

(

tables

)

Definition at line 192 of file prod5_pid_validation.py.

References PandAna.reco_validation.prod5_pid_validation.kPhotonPID.

def kPhotonPID(tables):
    cvn_png_df = tables[('rec.vtx.elastic.fuzzyk.png.cvnpart')]
    return cvn_png_df['photonid']

def PandAna.reco_validation.prod5_pid_validation.kPhotonPIDProd5FHC

(

tables

)

Definition at line 149 of file prod5_pid_validation.py.

References PandAna.reco_validation.prod5_pid_validation.kPhotonPIDProd5FHC.

def kPhotonPIDProd5FHC(tables):
    cvn_png_df = tables[('rec.vtx.elastic.fuzzyk.png.cvnpart2020fhc')]
    return cvn_png_df['photonid']

def PandAna.reco_validation.prod5_pid_validation.kPhotonPIDProd5RHC

(

tables

)

Definition at line 152 of file prod5_pid_validation.py.

References PandAna.reco_validation.prod5_pid_validation.kPhotonPIDProd5RHC.

def kPhotonPIDProd5RHC(tables):
    cvn_png_df = tables[('rec.vtx.elastic.fuzzyk.png.cvnpart2020rhc')]
    return cvn_png_df['photonid']

def PandAna.reco_validation.prod5_pid_validation.kPionPID

(

tables

)

Definition at line 196 of file prod5_pid_validation.py.

References PandAna.reco_validation.prod5_pid_validation.kPionPID.

def kPionPID(tables):
    cvn_png_df = tables[('rec.vtx.elastic.fuzzyk.png.cvnpart')]
    return cvn_png_df['pionid']

def PandAna.reco_validation.prod5_pid_validation.kPionPIDProd5FHC

(

tables

)

Definition at line 156 of file prod5_pid_validation.py.

References PandAna.reco_validation.prod5_pid_validation.kPionPIDProd5FHC.

def kPionPIDProd5FHC(tables):
    cvn_png_df = tables[('rec.vtx.elastic.fuzzyk.png.cvnpart2020fhc')]
    return cvn_png_df['pionid']

def PandAna.reco_validation.prod5_pid_validation.kPionPIDProd5RHC

(

tables

)

Definition at line 159 of file prod5_pid_validation.py.

References PandAna.reco_validation.prod5_pid_validation.kPionPIDProd5RHC.

def kPionPIDProd5RHC(tables):
    cvn_png_df = tables[('rec.vtx.elastic.fuzzyk.png.cvnpart2020rhc')]
    return cvn_png_df['pionid']

def PandAna.reco_validation.prod5_pid_validation.kProtonPID

(

tables

)

Definition at line 188 of file prod5_pid_validation.py.

References PandAna.reco_validation.prod5_pid_validation.kProtonPID.

def kProtonPID(tables):
    cvn_png_df = tables[('rec.vtx.elastic.fuzzyk.png.cvnpart')]
    return cvn_png_df['protonid']

def PandAna.reco_validation.prod5_pid_validation.kProtonPIDProd5FHC

(

tables

)

Definition at line 142 of file prod5_pid_validation.py.

References PandAna.reco_validation.prod5_pid_validation.kProtonPIDProd5FHC.

def kProtonPIDProd5FHC(tables):
    cvn_png_df = tables[('rec.vtx.elastic.fuzzyk.png.cvnpart2020fhc')]
    return cvn_png_df['protonid']

def PandAna.reco_validation.prod5_pid_validation.kProtonPIDProd5RHC

(

tables

)

Definition at line 145 of file prod5_pid_validation.py.

References PandAna.reco_validation.prod5_pid_validation.kProtonPIDProd5RHC.

def kProtonPIDProd5RHC(tables):
    cvn_png_df = tables[('rec.vtx.elastic.fuzzyk.png.cvnpart2020rhc')]
    return cvn_png_df['protonid']

def PandAna.reco_validation.prod5_pid_validation.main	(		wc,
			limit,
			stride,
			offset,
			spectra_file,
			make_plots,
			output,
			caf
	)

Definition at line 294 of file prod5_pid_validation.py.

References PandAna.reco_validation.prod5_pid_validation.ApplySlcCutsPngDF(), allInOneTrainingPlots.df, novadaq::HexUtils.format(), PandAna.reco_validation.prod5_pid_validation.get_files(), parse_dependency_file_t.list, PandAna.core.core.load_spectra(), PandAna.reco_validation.prod5_pid_validation.plot_ratio(), print, and PandAna.core.core.save_spectra().

def main(wc, limit, stride, offset, spectra_file, make_plots, output, caf):        

    if spectra_file is None:
        loaders = {}
        slc_tables = {}  # loader for slice level cuts only
        prong_tables = {} # loader for prong level cuts only 
        for dataset_name, data in datasets.items():
            if wc:
                det, swap, horn = dataset_name.split('_')
                slc_tables[dataset_name] = loader(get_files(det, swap, horn), 
                                                  stride=stride,
                                                  limit=limit,
                                                  offset=offset)
                prong_tables[dataset_name] = loader(get_files(det, swap, horn), 
                                                    stride=stride,
                                                    limit=limit,
                                                    offset=offset, index=KLP)
                loaders[dataset_name] = associate([slc_tables[dataset_name], 
                                                   prong_tables[dataset_name]]) # read same data only once for both loaders
            else:                
                query = 'defname: {}'.format(data)
                if limit is not None or stride is not None:
                    query += ' with'
                if limit is not None:
                    query += ' limit {}'.format(limit)
                if stride is not None:
                    query += ' stride {}'.format(stride)
                if offset is not None:
                    query += ' offset {}'.format(offset)
                print(query)
                slc_tables[dataset_name] = loader(query)
                prong_tables[dataset_name] = loader(query, index=KLP)
                loaders[dataset_name] = associate([slc_tables[dataset_name], prong_tables[dataset_name]])

    
        specs = {}
        slc_specs = {}
        save_specs = []
        save_labels = []
        for cut_name, cut in cut_levels.items():
            slc_specs[cut_name] = {}
            specs[cut_name] = {}
            for dataset_name, data in datasets.items():
                slc_specs[cut_name][dataset_name] \
                    = spectrum(slc_tables[dataset_name], cut, kCaloE)  # use dummy var for slice spectra with slice cuts
                specs[cut_name][dataset_name] = {}
                for particle_name, particle_cut in particle_cuts.items():
                    specs[cut_name][dataset_name][particle_name] = {}
                    for var_name, var in pid_scores.items():
                        specs[cut_name][dataset_name][particle_name][var_name] \
                                = spectrum(prong_tables[dataset_name], kProngCuts & particle_cut, var) # apply only particle truth cuts to prong level var

        for loader_name, load in loaders.items(): 
            load.Go() # go, go, go 

        filename = output + '/prod5_pid_validation_spectra'
        if stride:
            filename += '_s{}'.format(stride)
        if limit:
            filename += '_l{}'.format(limit)
        if offset:
            filename += '_o{}'.format(offset)
        filename += '.hdf5'
        for cut_name, cut in cut_levels.items():
            for dataset_name, data in datasets.items():
                for particle_name, particle_cut in particle_cuts.items():
                    for var_name in pid_scores:
                        # get prong dataframe
                        df_prong = specs[cut_name][dataset_name][particle_name][var_name].df()
                        df_weight = specs[cut_name][dataset_name][particle_name][var_name]._weight
                        # apply slice cuts to prong dataframe
                        df_prong = ApplySlcCutsPngDF(df_prong, slc_specs[cut_name][dataset_name].df())
                        df_weight = ApplySlcCutsPngDF(df_weight, slc_specs[cut_name][dataset_name].df())
                        # reset prong spectrum with new dataframe
                        specs[cut_name][dataset_name][particle_name][var_name]._df = df_prong
                        specs[cut_name][dataset_name][particle_name][var_name]._weight = df_weight
                        # save
                        save_specs.append(specs[cut_name][dataset_name][particle_name][var_name])
                        save_labels.append('{}_{}_{}_{}'.format(cut_name, particle_name, var_name, dataset_name))


        save_spectra(filename,
                     save_specs,
                     save_labels)

    else:
        print('Loading spectra from {}'.format(spectra_file))
        if caf:
            print('Loading caf results from {}'.format(caf))
            caf_file = h5py.File(caf, 'r')

        specs = {}
        pid_score_names = list(pid_scores.keys())
        for cut_name, cut in cut_levels.items():
            specs[cut_name] = {}
            for particle_name, particle_cut in particle_cuts.items():
                specs[cut_name][particle_name] = {}
                for dataset_name, data in datasets.items():
                    specs[cut_name][particle_name][dataset_name] = {}
                    for var_name in pid_scores:
                        if caf and 'prod4' in var_name:
                            specs[cut_name][particle_name][dataset_name][var_name+'caf'] = {}
                        spec_name = '{}_{}_{}_{}'.format(cut_name, particle_name, var_name, dataset_name)
                        specs[cut_name][particle_name][dataset_name][var_name] = load_spectra(spectra_file, 
                                                                                              spec_name)
                        if caf and 'prod4' in var_name:
                            specs[cut_name][particle_name][dataset_name][var_name + 'caf'] \
                                = caf_spectra(caf_file,
                                              '{}_{}_{}_{}'.format(cut_name,
                                                                   dataset_name,
                                                                   var_name.split('_')[0],
                                                                   particle_name))
        if caf: caf_file.close()
                                
                            
    if make_plots or spectra_file:
        particle_id = ['photonid',
                       'pionid',
                       'protonid',  
                       'electronid',
                       'muonid',
                       'emid']

        network_linestyles = {'prod4': '-',
                              'prod5fhc': '--',
                              'prod5rhc': '-.',
                              'prod4caf': '-'}
    
        for cut_name, cut in cut_levels.items():
            for dataset_name, data in datasets.items():
                for pid in particle_id:
                    prod4pid = pid + '_prod4'
                    prod5pidfhc = pid + '_prod5fhc'
                    prod5pidrhc = pid + '_prod5rhc'
                    prod4pid_caf = pid + '_prod4caf'
                    networks = [prod4pid, prod5pidfhc, prod5pidrhc]
                    if caf:
                        networks = networks + [prod4pid_caf]
                    for particle_name, particle_cut in particle_cuts.items():
                        plot_spectra = []
                        plot_spectra_styles = []
                        for network in networks:
                            plot_spectra_styles.append({})
                            if 'caf' in network: plot_spectra.append(specs[cut_name][particle_name][dataset_name][network])
                            else: plot_spectra.append(copy_spectrum(specs[cut_name][particle_name][dataset_name][network]))
                            
                            plot_spectra_styles[-1]['color'] = particle_colors[particle_name]
                            plot_spectra_styles[-1]['label'] = network.split('_')[-1]
                            plot_spectra_styles[-1]['linestyle'] = network_linestyles[network.split('_')[-1]]
                            if 'caf' in network:
                                plot_spectra_styles[-1]['color'] = 'springgreen'
                                plot_spectra_styles[-1]['yerr'] = True
                            else:
                                # only plot error bars for the caf hist
                                # try overriding with None
                                plot_spectra_styles[-1]['yerr'] = False
                                
                        plot_ratio(plot_spectra,
                                   30,
                                   pid,
                                   'Prongs',
                                   'pid_plots_technote/{}_{}_{}_{}'.format(cut_name, dataset_name, pid, particle_name),
                                   logy=True,
                                   spec_styles=plot_spectra_styles)

def PandAna.reco_validation.prod5_pid_validation.plot	(		spec,
			nbins,
			xlabel,
			ylabel,
			name
	)

Definition at line 473 of file prod5_pid_validation.py.

Referenced by PandAna.reco_validation.prod5_pid_validation.plot_ratio().

def plot(spec, nbins, xlabel, ylabel, name):
    fig, ax = plt.subplots()
    n, bins = spec.histogram(bins=nbins, range=(0, 1))
    ax.hist(bins[:-1], bins, weights=n, histtype='step')
    ax.set_xlabel(xlabel)
    ax.set_ylabel(ylabel)
    plt.legend(loc='upper right')
    fig.savefig(name + '.png')
    plt.close()

def PandAna.reco_validation.prod5_pid_validation.plot_ratio	(		specs,
			nbins,
			xlabel,
			ylabel,
			plot_name,
			logy = True,
			spec_styles = None,
			additional_handles = None
	)

Definition at line 493 of file prod5_pid_validation.py.

References novadaq::HexUtils.format(), analysePickle.hist, RunSnowGlobes.histogram, make_mec_shifts_plots.legend, PandAna.reco_validation.prod5_pid_validation.plot(), POT, print, PandAna.Demos.demo1.range, PandAna.reco_validation.prod5_pid_validation.ratio(), and PandAna.reco_validation.prod5_pid_validation.type.

Referenced by PandAna.reco_validation.prod5_pid_validation.event_count_report(), and PandAna.reco_validation.prod5_pid_validation.main().

               logy = True, spec_styles = None, additional_handles=None):
    # assume the first entry is the one to take ratios wrt to
    if not type(specs) is list: specs = [specs]
    if spec_styles is not None:
        if not type(spec_styles) is list: spec_styles = [spec_styles]
    else:
        spec_styles = [{} for _ in range(len(specs))]
    assert len(specs) == len(spec_styles), 'Each spectrum must have a style if any are provided'
    
    pot = specs[0].POT()
    fig, ax = plt.subplots(2, sharex=True, gridspec_kw = {'hspace': 0, 'height_ratios': [3, 1]})

    one_x = np.linspace(0, 1)
    one_y = [1 for _ in range(len(one_x))]
    ax[1].plot(one_x, one_y, color='k', linestyle='dashed')
    for spec, spec_style in zip(specs, spec_styles):
        plot_ratio_err = spec_style['yerr']
        spec_style.pop('yerr')
        n, bins = spec.histogram(bins=nbins, range=(0, 1), POT=pot)
        nratio, binsratio = ratio(spec, specs[0], nbins, pot)        
            
        try:
            # matplotlib doesn't like plotting histograms with all weights = 0
            ax[0].hist(bins[:-1], bins, weights=n, histtype='step',
                       **spec_style)
            ax[1].hist(binsratio[:-1], binsratio, weights=nratio, histtype='step',
                       **spec_style)
        except:
            print('{} is empty. skipping...'.format(plot_name))

        if plot_ratio_err:
            bin_centers = (bins[:-1] + bins[1:])/2
            nominal, nominal_bins = specs[0].histogram(bins=nbins, range=(0, 1))
            err = np.sqrt(1/n + 1/nominal) * nominal / n
            ax[1].errorbar(bin_centers, nratio, yerr=err, ecolor='k', fmt='k.')



    ax[1].set_xlabel(xlabel)
    ax[1].set_ylabel('Ratio to prod4')
    ax[1].set_xlim([0, 1])
    ax[0].set_xlim([0, 1])
    ax[0].set_ylabel(ylabel)
    ax[0].set_yscale('log')

    # configure the legend on the main figure
    handles, labels = ax[0].get_legend_handles_labels()
    line_handles = [Line2D([], [], c=h.get_edgecolor(), ls=h.get_linestyle()) for h in handles]
    if additional_handles is not None:
        line_handles = line_handles + additional_handles['handles']
        labels = labels + additional_handles['labels']
    ax[0].legend(handles=line_handles, labels=labels, loc='upper center')

    plt.tight_layout()
    plt.subplots_adjust(top=0.93)
    fig.suptitle(plot_name.split('/')[-1].replace('_', ' '))
    fig.savefig(plot_name + '.png')
    print('Created {}.png'.format(plot_name))
    plt.close()
    

def PandAna.reco_validation.prod5_pid_validation.ratio	(		spec1,
			spec2,
			nbins,
			pot,
			binrange = (0, 1)
	)

Definition at line 554 of file prod5_pid_validation.py.

Referenced by PandAna.reco_validation.prod5_pid_validation.plot_ratio().

def ratio(spec1, spec2, nbins, pot, binrange=(0, 1)):
    h1, bins1 = spec1.histogram(bins=nbins, range=binrange, POT=pot)
    h2, bins2 = spec2.histogram(bins=nbins, range=binrange, POT=pot)
    ratio = np.nan_to_num(h1) / np.nan_to_num(h2)
    return np.nan_to_num(ratio), bins1

Variable Documentation

PandAna.reco_validation.prod5_pid_validation.action

Definition at line 572 of file prod5_pid_validation.py.

PandAna.reco_validation.prod5_pid_validation.args = parser.parse_args()

Definition at line 580 of file prod5_pid_validation.py.

dictionary PandAna.reco_validation.prod5_pid_validation.cut_levels

Initial value:

= {'Veto'         : kCosVeto,
              'Containment'  : kCosVeto & kOrContainment,
              'Preselection' : kCosVeto & kOrContainment & kOrPreselection}

Definition at line 237 of file prod5_pid_validation.py.

dictionary PandAna.reco_validation.prod5_pid_validation.datasets

Initial value:

= {'FD_Nonswap_FHC'  : 'prod_h5_R19-02-23-miniprod5.n_fd_genie_default_nonswap_fhc_nova_v08_full_v1_eval',
              'FD_Fluxswap_FHC' : 'prod_h5_R19-02-23-miniprod5.n_fd_genie_default_fluxswap_fhc_nova_v08_full_v1_eval',
              'ND_Nonswap_FHC'  : 'junk',
              'ND_Nonswap_RHC'  : 'junk'}

Definition at line 241 of file prod5_pid_validation.py.

PandAna.reco_validation.prod5_pid_validation.default

Definition at line 564 of file prod5_pid_validation.py.

PandAna.reco_validation.prod5_pid_validation.divide

Definition at line 8 of file prod5_pid_validation.py.

PandAna.reco_validation.prod5_pid_validation.help

Definition at line 565 of file prod5_pid_validation.py.

PandAna.reco_validation.prod5_pid_validation.invalid

Definition at line 8 of file prod5_pid_validation.py.

Referenced by art::Consumer.consumes(), art::Consumer.consumesView(), art::EventID.invalidEvent(), art.is_valid(), art::IDNumber< Level::Event >.max_valid(), art::IDNumber< Level::SubRun >.max_valid(), art::IDNumber< Level::Run >.max_valid(), art::Consumer.mayConsume(), and art::Consumer.mayConsumeView().

PandAna.reco_validation.prod5_pid_validation.kCosVeto = kVeto

ORd cuts #####################.

Definition at line 122 of file prod5_pid_validation.py.

PandAna.reco_validation.prod5_pid_validation.kElectronPID = Var(kElectronPID)

Definition at line 232 of file prod5_pid_validation.py.

Referenced by PandAna.reco_validation.prod5_pid_validation.kElectronPID(), and PandAna.reco_validation.prod5_pid_validation.kEMPID().

PandAna.reco_validation.prod5_pid_validation.kElectronPIDProd5FHC = Var(kElectronPIDProd5FHC)

Definition at line 217 of file prod5_pid_validation.py.

Referenced by PandAna.reco_validation.prod5_pid_validation.kElectronPIDProd5FHC(), and PandAna.reco_validation.prod5_pid_validation.kEMPIDProd5FHC().

PandAna.reco_validation.prod5_pid_validation.kElectronPIDProd5RHC = Var(kElectronPIDProd5RHC)

Definition at line 224 of file prod5_pid_validation.py.

Referenced by PandAna.reco_validation.prod5_pid_validation.kElectronPIDProd5RHC(), and PandAna.reco_validation.prod5_pid_validation.kEMPIDProd5RHC().

PandAna.reco_validation.prod5_pid_validation.kEMPID = Var(kEMPID)

Definition at line 234 of file prod5_pid_validation.py.

Referenced by PandAna.reco_validation.prod5_pid_validation.kEMPID().

PandAna.reco_validation.prod5_pid_validation.kEMPIDProd5FHC = Var(kEMPIDProd5FHC)

Definition at line 219 of file prod5_pid_validation.py.

Referenced by PandAna.reco_validation.prod5_pid_validation.kEMPIDProd5FHC().

PandAna.reco_validation.prod5_pid_validation.kEMPIDProd5RHC = Var(kEMPIDProd5RHC)

Definition at line 226 of file prod5_pid_validation.py.

Referenced by PandAna.reco_validation.prod5_pid_validation.kEMPIDProd5RHC().

PandAna.reco_validation.prod5_pid_validation.kHas2018Score = Cut(lambda tables: tables['rec.vtx.elastic.fuzzyk.png.cvnpart']['muonid'] > 0)

Definition at line 128 of file prod5_pid_validation.py.

PandAna.reco_validation.prod5_pid_validation.kHas2020Score = Cut(lambda tables: tables['rec.vtx.elastic.fuzzyk.png.cvnpart2020fhc']['muonid'] > 0)

Definition at line 127 of file prod5_pid_validation.py.

PandAna.reco_validation.prod5_pid_validation.kIsChargedPion = Cut(lambda tables: abs(tables['rec.vtx.elastic.fuzzyk.png.truth']['pdg']) == 211)

Definition at line 134 of file prod5_pid_validation.py.

PandAna.reco_validation.prod5_pid_validation.kIsElectron = Cut(lambda tables: abs(tables['rec.vtx.elastic.fuzzyk.png.truth']['pdg']) == 11)

Definition at line 138 of file prod5_pid_validation.py.

PandAna.reco_validation.prod5_pid_validation.kIsMuon = Cut(lambda tables: abs(tables['rec.vtx.elastic.fuzzyk.png.truth']['pdg']) == 13)

Definition at line 139 of file prod5_pid_validation.py.

PandAna.reco_validation.prod5_pid_validation.kIsNeutron = Cut(lambda tables: abs(tables['rec.vtx.elastic.fuzzyk.png.truth']['pdg']) == 2112)

Definition at line 136 of file prod5_pid_validation.py.

PandAna.reco_validation.prod5_pid_validation.kIsPhoton = Cut(lambda tables: tables['rec.vtx.elastic.fuzzyk.png.truth']['pdg'] == 22)

Definition at line 135 of file prod5_pid_validation.py.

PandAna.reco_validation.prod5_pid_validation.kIsProton = Cut(lambda tables: abs(tables['rec.vtx.elastic.fuzzyk.png.truth']['pdg']) == 2212)

Definition at line 137 of file prod5_pid_validation.py.

PandAna.reco_validation.prod5_pid_validation.KLP = KL+['rec.vtx.elastic.fuzzyk.png_idx']

Definition at line 22 of file prod5_pid_validation.py.

PandAna.reco_validation.prod5_pid_validation.kMuonPID = Var(kMuonPID)

Definition at line 233 of file prod5_pid_validation.py.

Referenced by PandAna.reco_validation.prod5_pid_validation.kMuonPID().

PandAna.reco_validation.prod5_pid_validation.kMuonPIDProd5FHC = Var(kMuonPIDProd5FHC)

Definition at line 218 of file prod5_pid_validation.py.

Referenced by PandAna.reco_validation.prod5_pid_validation.kMuonPIDProd5FHC().

PandAna.reco_validation.prod5_pid_validation.kMuonPIDProd5RHC = Var(kMuonPIDProd5RHC)

Definition at line 225 of file prod5_pid_validation.py.

Referenced by PandAna.reco_validation.prod5_pid_validation.kMuonPIDProd5RHC().

PandAna.reco_validation.prod5_pid_validation.kNueContain = Cut(kNueContain)

Definition at line 76 of file prod5_pid_validation.py.

Referenced by PandAna.reco_validation.prod5_pid_validation.kNueContain().

PandAna.reco_validation.prod5_pid_validation.kNuePresel = Cut(kNuePresel)

Definition at line 84 of file prod5_pid_validation.py.

Referenced by PandAna.reco_validation.prod5_pid_validation.kNuePresel().

PandAna.reco_validation.prod5_pid_validation.kNumuContain = Cut(kNumuContain)

Definition at line 96 of file prod5_pid_validation.py.

Referenced by PandAna.reco_validation.prod5_pid_validation.kNumuContain().

PandAna.reco_validation.prod5_pid_validation.kNumuNoPIDNoCCEFD = kNumuBasicQuality&kNumuContainFD

numu cuts ##################### kCCE isn't working yet

Definition at line 88 of file prod5_pid_validation.py.

Referenced by PandAna.reco_validation.prod5_pid_validation.kNumuPresel().

PandAna.reco_validation.prod5_pid_validation.kNumuNoPIDNoCCEND = kNumuBasicQuality&kNumuContainND

Definition at line 89 of file prod5_pid_validation.py.

Referenced by PandAna.reco_validation.prod5_pid_validation.kNumuPresel().

PandAna.reco_validation.prod5_pid_validation.kNumuPresel = Cut(kNumuPresel)

Definition at line 104 of file prod5_pid_validation.py.

Referenced by PandAna.reco_validation.prod5_pid_validation.kNumuPresel().

PandAna.reco_validation.prod5_pid_validation.kNusContain = Cut(kNusContain)

Definition at line 112 of file prod5_pid_validation.py.

Referenced by PandAna.reco_validation.prod5_pid_validation.kNusContain().

PandAna.reco_validation.prod5_pid_validation.kNusPresel = Cut(kNusPresel)

Definition at line 119 of file prod5_pid_validation.py.

Referenced by PandAna.reco_validation.prod5_pid_validation.kNusPresel().

PandAna.reco_validation.prod5_pid_validation.kOrContainment = kNumuContain|kNusContain|kNueContain

Definition at line 123 of file prod5_pid_validation.py.

PandAna.reco_validation.prod5_pid_validation.kOrPreselection = kNumuPresel|kNusPresel|kNuePresel

Definition at line 124 of file prod5_pid_validation.py.

PandAna.reco_validation.prod5_pid_validation.kPhotonPID = Var(kPhotonPID)

Definition at line 229 of file prod5_pid_validation.py.

Referenced by PandAna.reco_validation.prod5_pid_validation.kEMPID(), and PandAna.reco_validation.prod5_pid_validation.kPhotonPID().

PandAna.reco_validation.prod5_pid_validation.kPhotonPIDProd5FHC = Var(kPhotonPIDProd5FHC)

Definition at line 214 of file prod5_pid_validation.py.

Referenced by PandAna.reco_validation.prod5_pid_validation.kEMPIDProd5FHC(), and PandAna.reco_validation.prod5_pid_validation.kPhotonPIDProd5FHC().

PandAna.reco_validation.prod5_pid_validation.kPhotonPIDProd5RHC = Var(kPhotonPIDProd5RHC)

Definition at line 221 of file prod5_pid_validation.py.

Referenced by PandAna.reco_validation.prod5_pid_validation.kEMPIDProd5RHC(), and PandAna.reco_validation.prod5_pid_validation.kPhotonPIDProd5RHC().

PandAna.reco_validation.prod5_pid_validation.kPionPID = Var(kPionPID)

Definition at line 231 of file prod5_pid_validation.py.

Referenced by PandAna.reco_validation.prod5_pid_validation.kPionPID().

PandAna.reco_validation.prod5_pid_validation.kPionPIDProd5FHC = Var(kPionPIDProd5FHC)

Definition at line 216 of file prod5_pid_validation.py.

Referenced by PandAna.reco_validation.prod5_pid_validation.kPionPIDProd5FHC().

PandAna.reco_validation.prod5_pid_validation.kPionPIDProd5RHC = Var(kPionPIDProd5RHC)

Definition at line 223 of file prod5_pid_validation.py.

Referenced by PandAna.reco_validation.prod5_pid_validation.kPionPIDProd5RHC().

PandAna.reco_validation.prod5_pid_validation.kProngCuts = kProngLength&kHas2020Score&kHas2018Score

Definition at line 131 of file prod5_pid_validation.py.

PandAna.reco_validation.prod5_pid_validation.kProngLength = Cut(lambda tables: tables['rec.vtx.elastic.fuzzyk.png']['len'] < 500)

Definition at line 129 of file prod5_pid_validation.py.

PandAna.reco_validation.prod5_pid_validation.kProtonPID = Var(kProtonPID)

Definition at line 230 of file prod5_pid_validation.py.

Referenced by PandAna.reco_validation.prod5_pid_validation.kProtonPID().

PandAna.reco_validation.prod5_pid_validation.kProtonPIDProd5FHC = Var(kProtonPIDProd5FHC)

Definition at line 215 of file prod5_pid_validation.py.

Referenced by PandAna.reco_validation.prod5_pid_validation.kProtonPIDProd5FHC().

PandAna.reco_validation.prod5_pid_validation.kProtonPIDProd5RHC = Var(kProtonPIDProd5RHC)

Definition at line 222 of file prod5_pid_validation.py.

Referenced by PandAna.reco_validation.prod5_pid_validation.kProtonPIDProd5RHC().

PandAna.reco_validation.prod5_pid_validation.None

Definition at line 564 of file prod5_pid_validation.py.

PandAna.reco_validation.prod5_pid_validation.parser = argparse.ArgumentParser('Plot prod5 and prod4 PID distributions')

Definition at line 563 of file prod5_pid_validation.py.

dictionary PandAna.reco_validation.prod5_pid_validation.particle_colors

Initial value:

= {'true_pion'      : 'darkgreen',
                   'true_pizero'    : 'chartreuse',
                   'true_photon'    : 'crimson',
                   'true_neutron'   : 'indigo',
                   'true_proton'    : 'orangered',
                   'true_electron'  : 'blueviolet',
                   'true_muon'      : 'cyan',
                   'true_em'        : 'green'}

Definition at line 285 of file prod5_pid_validation.py.

dictionary PandAna.reco_validation.prod5_pid_validation.particle_cuts

Initial value:

= {'true_pion'      : kIsChargedPion,
                 'true_photon'    : kIsPhoton,
                 'true_proton'    : kIsProton,
                 'true_electron'  : kIsElectron,
                 'true_muon'      : kIsMuon}

Definition at line 279 of file prod5_pid_validation.py.

dictionary PandAna.reco_validation.prod5_pid_validation.pid_scores

Initial value:

= {'photonid_prod4'     : kPhotonPID,
              'protonid_prod4'     : kProtonPID,
              'pionid_prod4'       : kPionPID,
              'electronid_prod4'   : kElectronPID,
              'muonid_prod4'       : kMuonPID,
              'emid_prod4'         : kEMPID,
              'photonid_prod5fhc'     : kPhotonPIDProd5FHC,
              'protonid_prod5fhc'     : kProtonPIDProd5FHC,
              'pionid_prod5fhc'       : kPionPIDProd5FHC,
              'electronid_prod5fhc'   : kElectronPIDProd5FHC,
              'muonid_prod5fhc'       : kMuonPIDProd5FHC,
              'emid_prod5fhc'         : kEMPIDProd5FHC,
              'photonid_prod5rhc'     : kPhotonPIDProd5RHC,
              'protonid_prod5rhc'     : kProtonPIDProd5RHC,
              'pionid_prod5rhc'       : kPionPIDProd5RHC,
              'electronid_prod5rhc'   : kElectronPIDProd5RHC,
              'muonid_prod5rhc'       : kMuonPIDProd5RHC,
              'emid_prod5rhc'         : kEMPIDProd5RHC}

Definition at line 260 of file prod5_pid_validation.py.

dictionary PandAna.reco_validation.prod5_pid_validation.pid_scores_fhc

Initial value:

= {'photonid_prod5fhc'     : kPhotonPIDProd5FHC,
                  'protonid_prod5fhc'     : kProtonPIDProd5FHC,
                  'pionid_prod5fhc'       : kPionPIDProd5FHC,
                  'electronid_prod5fhc'   : kElectronPIDProd5FHC,
                  'muonid_prod5fhc'       : kMuonPIDProd5FHC}

Definition at line 249 of file prod5_pid_validation.py.

dictionary PandAna.reco_validation.prod5_pid_validation.pid_scores_rhc

Initial value:

= {'photonid_prod5rhc'     : kPhotonPIDProd5RHC,
                  'protonid_prod5rhc'     : kProtonPIDProd5RHC,
                  'pionid_prod5rhc'       : kPionPIDProd5RHC,
                  'electronid_prod5rhc'   : kElectronPIDProd5RHC,
                  'muonid_prod5rhc'       : kMuonPIDProd5RHC}

Definition at line 254 of file prod5_pid_validation.py.

list PandAna.reco_validation.prod5_pid_validation.pids = ['photonid', 'protonid', 'pionid', 'electronid', 'muonid', 'emid']

Definition at line 246 of file prod5_pid_validation.py.

Referenced by SliceLID::ProngCVNVars.getCVNVars(), LSTME::ProngCVNVars.getCVNVars(), SliceLID::ProngCVNVars.getFallbackCVNVars(), LSTME::ProngCVNVars.getFallbackCVNVars(), nerd::NERDProng.MakeCluster(), lem::LEMMixer.MixPIDDetails(), lem::LEMMixer.nSecondaries(), lem::LEMAssociator.produce(), and nerd::NERDProng.produce().

PandAna.reco_validation.prod5_pid_validation.type

Definition at line 564 of file prod5_pid_validation.py.

Referenced by PandAna.reco_validation.prod5_pid_validation.kIsFarDet(), and PandAna.reco_validation.prod5_pid_validation.plot_ratio().