Cut-flow table with python

[ZhenxuanZhang-Jensen]

Hi experts,
Recently I am trying to produce the cut-flow table for my analysis. And it was very easy if I did this in C++ "for loop". I just need to for over all the events and do all the cuts step by step in the events and count the events numbers after each cut like this:

for events:
   pt>20
   pt_counts += 1
   eta<2.4
   pt_eta_counts += 1
eff_pt = pt_count / n_events
eff_pt_eta = pt_eta_count / n_events

And for now, if we use python with uproot and do all the parallel operation, I only can use mask method to cut each array elements, but I'm not sure how to do this step by step and have the cut-flow results.
Any ideas are highly appreciated! Thanks in advanced!
Best regards,
Zhenxuan

[agoose77]

Hi @ZhenxuanZhang-Jensen, I'm not familiar with what "cut-flow" means (though I'm sure it's probably standard HEP language), but I think I can understand what you're trying do.

To compute the number o

is_large_pt = events.pt > 20
is_small_eta = events.eta < 2.4

eff_pt = ak.count_nonzero(is_large_pt) / len(events)

is_large_pt_and_small_eta = np.logical_and(
    is_large_pt, is_small_eta
)
eff_pt_eta = ak.count_nonzero(is_large_pt_and_small_eta) / len(events)

This corresponds to :

n_large_pt = 0
n_large_pt_small_eta = 0

for event in events:
    if event.pt > 20:
        n_large_pt += 1
        if event.eta < 2.4:
            n_large_pt_small_eta += 1

eff_pt = n_large_pt / len(events)
eff_pt_eta = n_large_pt_small_eta / len(events)

[ZhenxuanZhang-Jensen]

yes, thanks a lot, this looks feasible for me. thank you very much for the quick reply. Then I guess I need to find a way to implement the code in my framework, which uses uproot to open a root file. Anyway, this seems like a great solution for me, let me check. thanks

[MoAly98]

Hi,
if you want something quick and dirty you can do possibly:

counts = {}
with uproot.open("myfile.root") as f:
    events = f["tree"]
    counts['all'] = ak.num(events.pt, axis = 0)
    events = events[events.pt>20]
    counts["pt>20"] = ak.num(events.pt, axis = 0) 
    events = events[events.eta< 2.4] 
    counts["eta<2.4"] = ak.num(events.pt, axis = 0) 

but then the way you open the file can be optimized based on the size of your input, and the way you store the counts can also be done a bit more neatly.

[ZhenxuanZhang-Jensen]

yes, I think to do this too. I mean if I can't find a way to add a function to my framework to cut safely, then I probably will use your suggestion code to simply open a root file and do the cut-flow check. Thanks.