from heppy.analyzers.JetTreeProducer import JetTreeProducer
jet_tree = cfg.Analyzer(JetTreeProducer,
tree_name='events',
tree_title='jets',
jets='jets',
taggers=['b', 'b_ip', 'bmatch', 'bfrac'],
njets=2,
store_match=False)
# definition of a sequence of analyzers,
# the analyzers will process each event in this order
sequence = cfg.Sequence(
source,
# gen_particles_stable,
papas_sequence,
jets,
btag_parametrized,
btag_ip_smearing,
jet_tree,
display)
# Specifics to read FCC events
from ROOT import gSystem
gSystem.Load("libdatamodelDict")
from EventStore import EventStore as Events
config = cfg.Config(components=selectedComponents,
sequence=sequence,
services=[],
events_class=Events)
from heppy_fcc.analyzers.JetTreeProducer import JetTreeProducer
papas_jet_tree = cfg.Analyzer(JetTreeProducer,
instance_label='papas',
tree_name='events',
tree_title='jets',
jets='papas_jets')
# definition of a sequence of analyzers,
# the analyzers will process each event in this order
sequence = cfg.Sequence([
source,
gen_jets,
papas,
papas_muons,
papas_muons_tree,
papas_jets,
papas_jet_match,
papas_jet_tree,
])
config = cfg.Config(components=selectedComponents,
sequence=sequence,
services=[],
events_class=Events)
if __name__ == '__main__':
import sys
from heppy.framework.looper import Looper
import random
electrons = 'electrons_150',
muons = 'muons_150',
)
# definition of a sequence of analyzers,
# the analyzers will process each event in this order
sequence = cfg.Sequence( [
source,
jets_pf02_1500,
jets_pf04_1000,
jets_pf04_1500,
jets_pf08_1500,
jets_trk02_1000,
jets_trk04_1000,
jets_trk08_1000,
electrons_150,
muons_150,
tree,
] )
config = cfg.Config(
components = selectedComponents,
sequence = sequence,
services = [],
events_class = Events
)
# store interesting quantities into flat ROOT tree
from heppy.FCChhAnalyses.hza.TreeProducer import TreeProducer
reco_tree = cfg.Analyzer(
TreeProducer,
zeds='zeds',
photons='selected_photons',
)
# definition of a sequence of analyzers,
# the analyzers will process each event in this order
sequence = cfg.Sequence([
source,
selected_muons,
selected_electrons,
selected_leptons,
selected_photons,
zeds,
reco_tree,
])
config = cfg.Config(components=selectedComponents,
sequence=sequence,
services=[],
events_class=Events)
if __name__ == '__main__':
import sys
from heppy.framework.looper import Looper
def next():
# sv_z_resolution = 0.0015,
smear_tv=True,
# IDL-like res
tv_x_resolution=0.005,
tv_y_resolution=0.005,
tv_z_resolution=0.005,
# progressive res
# tv_x_resolution = 0.002,
# tv_y_resolution = 0.002,
# tv_z_resolution = 0.002,
# outstanding res
# tv_x_resolution = 0.001,
# tv_y_resolution = 0.001,
# tv_z_resolution = 0.001,
stylepath=os.environ.get('FCC') + 'lhcbstyle.C',
tree_name='Events',
tree_title='Events',
mc_truth_tree_name='MCTruth',
mc_truth_tree_title='MC Truth',
verbose=False)
# definition of a sequence of analyzers, the analyzers will process each event in this order
sequence = cfg.Sequence([bgana])
# finalization of the configuration object.
gSystem.Load('libdatamodel')
config = cfg.Config(components=selected_components,
sequence=sequence,
services=[],
events_class=Events)
nbins=1000,
input_objects='gen_objects',
value_func=pt,
log_y=True)
# definition of a sequence of analyzers,
# the analyzers will process each event in this order
sequence = cfg.Sequence([
source,
goodGenObjectFilter,
qualityFilter,
genPtDistribution,
objectPtDistributionBinnedInMatchedObject,
objectMatchedObjectPtRatioDistributionBinnedInMatchedObject,
objectEtaDistributionBinnedInMatchedObject,
matchedObjectEtaDistributionBinnedInMatchedObject,
deltaRDistributionBinnedInMatchedObject,
deltaPtDistributionBinnedInMatchedObject,
objectPtDistribution,
objectQualityDistribution,
matchedObjectPtDistribution,
matchedObjectPtDistributionBinnedInMatchedObject,
objectPtCumulativeDistributionBinnedInMatchedObject,
#genJetL1TObjectTree
])
config = cfg.Config(components=selectedComponents,
sequence=sequence,
services=[tfile_service_1],
events_class=Events)
if __name__ == '__main__':
# store interesting quantities into flat ROOT tree
from FCChhAnalyses.FCChh.haa.TreeProducer import TreeProducer
reco_tree = cfg.Analyzer(
TreeProducer,
higgses = 'higgses',
)
# definition of a sequence of analyzers,
# the analyzers will process each event in this order
sequence = cfg.Sequence( [
source,
selected_photons,
jets,
match_photon_jets,
jets_nophoton,
selected_lights,
selected_bs,
higgses,
selection,
reco_tree,
] )
config = cfg.Config(
components = selectedComponents,
sequence = sequence,
services = [],
events_class = Events
)
if __name__ == '__main__':
import sys
# definition of the sequence of analyzers,
# the analyzers will process each event in this order
sequence = cfg.Sequence(
source,
papas_sequence,
# leptons,
# iso_leptons,
# sel_iso_leptons,
# lepton_veto,
# jets,
# compute_jet_energy,
photons,
# iso_photons,
muons,
iso_muons,
# sel_iso_photons,
# bquarks,
# genjets,
# genjet_to_b_match,
# jet_to_genjet_match,
# btag,
# missing_energy,
selection1,
jets,
selection2,
# zhreco,
tree,
display)
# Specifics to read FCC events
from ROOT import gSystem
sequence = cfg.Sequence([
source,
#etaGenParticleSelector,
#etaGenJetSelector,
#electronSelector,
#muonSelector,
#tauSelector,
#photonSelector,
#electronRecoPtDistribution,
#electronLeadingRecoPtDistribution,
#electronLeadingRecoEtaDistribution,
#electronSubLeadingRecoPtDistribution,
#electronSubLeadingRecoEtaDistribution,
#electronRecoEtaDistribution,
#electronGenPtDistribution,
#muonRecoPtDistribution,
#muonLeadingRecoPtDistribution,
#muonLeadingRecoEtaDistribution,
#muonRecoEtaDistribution,
#muonGenPtDistribution,
#tauGenPtDistribution,
#photonRecoPtDistribution,
#photonLeadingRecoPtDistribution,
#photonSubLeadingRecoPtDistribution,
#photonLeadingRecoEtaDistribution,
#photonSubLeadingRecoEtaDistribution,
#photonRecoEtaDistribution,
#photonGenPtDistribution,
jetRecoPtDistribution,
jetLeadingRecoPtDistribution,
#jetSubLeadingRecoPtDistribution,
#jetLeadingRecoEtaDistribution,
#jetSubLeadingRecoEtaDistribution,
#jetRecoEtaDistribution,
jetGenPtDistribution,
jetLeadingGenPtDistribution,
#jetRecoPtEtaDistribution
])
output_particles_dict='particles_dict',
output_particles_list='particles_list')
#compare orignal and new reconstructions
from heppy.analyzers.PapasParticlesComparer import PapasParticlesComparer
particlescomparer = cfg.Analyzer(
PapasParticlesComparer,
particlesA='papas_PFreconstruction_particles_list',
particlesB='papas_sim_rec_particles')
# and then particle reconstruction from blocks
# definition of a sequence of analyzers,
# the analyzers will process each event in this order
sequence = cfg.Sequence([
source, gen_particles_stable, papas, pfblocks, pfreconstruct,
particlescomparer
])
config = cfg.Config(components=selectedComponents,
sequence=sequence,
services=[],
events_class=Events)
if __name__ == '__main__':
import sys
from heppy.framework.looper import Looper
import heppy.statistics.rrandom as random
random.seed(0xdeadbeef)
def process(iev=None):
from papas_analysis_gael.analyzers.SimTrackTreeProducer import SimTrackTreeProducer
tree = cfg.Analyzer(SimTrackTreeProducer,
tree_name='simtracks',
tree_title='simtracks',
simtracks='simtracks')
from PhysicsTools.HeppyCore.framework.eventsfwlite import Events
if debug:
comp = selectedComponents[0]
comp.splitFactor = 1
selectedComponents = [comp]
# definition of a sequence of analyzers,
# the analyzers will process each event in this order
sequence = cfg.Sequence(
[source_ptc, gen_filter, gen_counter, simtrack_reader, tree])
config = cfg.Config(components=selectedComponents,
sequence=sequence,
services=[],
events_class=Events)
if __name__ == '__main__':
import sys
from heppy.framework.looper import Looper
import random
random.seed(0xdeadbeef)
def process(iev=None):
if iev is None:
debug_filename=os.getcwd() +
'/python_physics_debug.log' #optional argument
)
# definition of a sequence of analyzers,
# the analyzers will process each event in this order
sequence = cfg.Sequence(
source,
#pdebug,
gen_leptons,
gen_counter,
papas_sequence,
leptons_true,
iso_leptons,
sel_iso_leptons,
zeds,
zed_counter,
recoil,
missing_energy,
particles_not_zed,
jets,
btag_parametrized,
higgses,
selection,
tree,
display)
# Specifics to read FCC events
from ROOT import gSystem
gSystem.Load("libdatamodelDict")
from EventStore import EventStore as Events
papas = cfg.Analyzer(
PFSim,
instance_label = 'papas',
detector = CMS(),
gen_particles = 'gen_particles_stable',
sim_particles = 'sim_particles',
rec_particles = 'rec_particles',
display = False,
verbose = True
)
# definition of a sequence of analyzers,
# the analyzers will process each event in this order
sequence = cfg.Sequence( [
source,
papas
] )
config = cfg.Config(
components = selectedComponents,
sequence = sequence,
services = [],
events_class = Events
)
if __name__ == '__main__':
import sys
from heppy.framework.looper import Looper
import random
random.seed(0xdeadbeef)
tree = cfg.Analyzer(ZHTreeProducer,
zeds='zeds',
jets='jets',
higgses='higgses',
recoil='recoil',
misenergy='missing_energy')
from heppy.analyzers.PDebugger import PDebugger
pdebug = cfg.Analyzer(
PDebugger,
output_to_stdout=False, #optional
debug_filename=None #No physics debug output unless this is subsequently set
)
# definition of a sequence of analyzers,
# the analyzers will process each event in this order
sequence = cfg.Sequence(source, pdebug, papas_sequence, leptons_true,
iso_leptons, sel_iso_leptons, zeds, recoil,
missing_energy, particles_not_zed, jets, higgses,
selection, tree, display)
# Specifics to read FCC events
from ROOT import gSystem
gSystem.Load("libdatamodelDict")
from EventStore import EventStore as Events
config = cfg.Config(components=selectedComponents,
sequence=sequence,
services=[],
events_class=Events)
pfbTags02='pfbTags02',
pfjetsOneSubJettiness02='pfjetsOneSubJettiness02',
pfjetsTwoSubJettiness02='pfjetsTwoSubJettiness02',
pfjetsThreeSubJettiness02='pfjetsThreeSubJettiness02',
pfsubjetsSoftDropTagged02='pfsubjetsSoftDropTagged02',
pfsubjetsSoftDrop02='pfsubjetsSoftDrop02',
pfjets04='pfjets04',
pfbTags04='pfbTags04',
pfjetsFlavor04='pfjetsFlavor04',
pfjets08='pfjets08',
pfbTags08='pfbTags08',
trkjets04='trkjets04',
trkjets08='trkjets08',
photons='photons',
pfphotons='pfphotons',
pfcharged='pfcharged',
pfneutrals='pfneutrals')
sequence = cfg.Sequence([
source,
pfjets04_pdg,
# selected_electrons,
tree
])
# finalization of the configuration object.
config = cfg.Config(components=selectedComponents,
sequence=sequence,
services=[],
events_class=Events)
# electrons = 'electrons_100',
# muons = 'muons_100',
#
#)
# definition of a sequence of analyzers,
# the analyzers will process each event in this order
sequence = cfg.Sequence([
source,
pfjets04_fix,
lepton_jets,
jets_pf02_1500,
jets_pf04_1000,
jets_pf04_1000_pdg,
#all_particles,
jets_pf04_1500,
jets_pf08_1500,
jets_trk02_1000,
jets_trk04_1000,
jets_trk08_1000,
electrons_100,
muons_100,
tree,
# tree2,
])
config = cfg.Config(components=selectedComponents,
sequence=sequence,
services=[],
events_class=Events)
if __name__ == '__main__':
instance_label = 'gen',
tree_name = 'events',
tree_title = 'leptons',
leptons = 'gen_muons'
)
from heppy_fcc.analyzers.IsoParticleTreeProducer import IsoParticleTreeProducer
gen_muons_tree = cfg.Analyzer(
IsoParticleTreeProducer,
instance_label = 'gen',
tree_name = 'ptcs',
tree_title = 'isolation particles',
leptons = 'gen_muons'
)
# definition of a sequence of analyzers,
# the analyzers will process each event in this order
sequence = cfg.Sequence( [
source,
gen_muons,
gen_muons_tree,
] )
config = cfg.Config(
components = selectedComponents,
sequence = sequence,
services = [],
events_class = Events
)
import os
import heppy.framework.config as cfg
import logging
logging.basicConfig(level=logging.WARNING)
# input component
# several input components can be declared and added to the list of selected components
input_component = cfg.Component('Z2uu', files = ['/afs/cern.ch/work/a/ansemkiv/private/FCC/analysis/Z2uubar_100.root'])
selected_components = [input_component]
# analyzers
# analyzer for signal events
from heppy_fcc.analyzers.Z2UUAnalyzer import Z2UUAnalyzer
ana = cfg.Analyzer(Z2UUAnalyzer)
# definition of a sequence of analyzers, the analyzers will process each event in this order
sequence = cfg.Sequence([ana])
# finalization of the configuration object.
from ROOT import gSystem
gSystem.Load('libdatamodel')
from EventStore import EventStore as Events
config = cfg.Config(components = selected_components, sequence = sequence, services = [], events_class = Events)
reco_tree = cfg.Analyzer(
TreeProducer,
zeds="zeds",
)
# definition of a sequence of analyzers,
# the analyzers will process each event in this order
sequence = cfg.Sequence( [
source,
selected_muons,
selected_electrons,
selected_leptons,
jets_30,
match_lepton_jets,
jets_nolepton,
selected_lights,
selected_bs,
selection,
zeds,
reco_tree,
] )
config = cfg.Config(
components = selectedComponents,
sequence = sequence,
services = [],
events_class = Events
)
x_label= "pt [GeV]",
y_label = "# events",
histo_name = 'genJetPtDistribution',
histo_title = 'Gen jet transverse momentum distribution',
min = 0,
max = 400,
nbins = 400,
input_objects = 'gen_objects',
value_func = pt,
log_y = True
)
# definition of a sequence of analyzers,
# the analyzers will process each event in this order
sequence = cfg.Sequence( [
source,
genJetPtDistribution
] )
config = cfg.Config(
components = selectedComponents,
sequence = sequence,
services = [tfile_service_1],
events_class = Events
)
if __name__ == '__main__':
def next():
loop.process(loop.iEvent+1)
loop = Looper( 'looper', config,
# produce flat root tree containing jet substructure information
from heppy.FCChhAnalyses.Dijet_reso.TreeProducer import TreeProducer
tree = cfg.Analyzer(
TreeProducer,
jets_pf04_2000 = 'jets_pf04_2000',
jets_calo04_2000 = 'jets_calo04_2000',
)
# definition of a sequence of analyzers,
# the analyzers will process each event in this order
sequence = cfg.Sequence( [
source,
jets_pf04_2000,
jets_calo04_2000,
tree,
] )
config = cfg.Config(
components = selectedComponents,
sequence = sequence,
services = [],
events_class = Events
)
if __name__ == '__main__':
import sys
from heppy.framework.looper import Looper
def next():
tree_name='bottomJetTree',
tree_title='Tree containing info about matched jet and bottoms',
particle_collection='matched_b_quarks',
particle_name="b_quark",
matched_particle_name="jet")
# definition of a sequence of analyzers,
# the analyzers will process each event in this order
sequence = cfg.Sequence([
source, etaGenParticleSelector, genJetSelector, bQuarkSelector,
tightRestrictionJetBottomMatcher, tightRestrictionJetBottomFinder,
matchedTightRestrictionBottomSelector, matchedTightRestrictionJetSelector,
jetPtDistributionBinnedInMatchedJet,
bottomPtDistributionBinnedInMatchedJet,
bottomJetPtRatioDistributionBinnedInMatchedJet,
bottomEtaDistributionBinnedInMatchedJet,
deltaRDistributionBinnedInMatchedJet,
totalBottomJetPtRatioDistributionBinnedInMatchedJet,
numberOfBottomQuarksDistributionBinnedInMatchedJet,
bottomJetPtRatioDistributionBinnedInNumberOfFoundBQuarks,
totalPtFractionCarriedByBottomQuarksDistribution,
numberOfMatchedBottomQuarksDistribution, bottomJetTree
])
config = cfg.Config(components=selectedComponents,
sequence=sequence,
services=[tfile_service_1],
events_class=Events)
if __name__ == '__main__':
# store interesting quantities into flat ROOT tree
from heppy.analyzers.examples.hzz4l.HTo4lTreeProducer import HTo4lTreeProducer
reco_tree = cfg.Analyzer(
HTo4lTreeProducer,
zeds='zeds',
higgses='higgses',
)
# definition of a sequence of analyzers,
# the analyzers will process each event in this order
sequence = cfg.Sequence([
source,
gen_leptons,
gen_tree,
selected_muons,
selected_electrons,
selected_leptons,
zeds,
selection,
higgses,
reco_tree,
])
config = cfg.Config(components=selectedComponents,
sequence=sequence,
services=[],
events_class=Events)
if __name__ == '__main__':
import sys
from heppy.framework.looper import Looper
# sv_y_resolution = 0.003,
# sv_z_resolution = 0.003,
smear_tv = True,
# IDL-like res
tv_x_resolution = 0.005,
tv_y_resolution = 0.005,
tv_z_resolution = 0.005,
# progressive res
# tv_x_resolution = 0.002,
# tv_y_resolution = 0.002,
# tv_z_resolution = 0.002,
smear_momentum = True,
momentum_x_resolution = 0.01,
momentum_y_resolution = 0.01,
momentum_z_resolution = 0.01,
stylepath = os.environ.get('FCC') + 'lhcbstyle.C',
tree_name = 'Events',
tree_title = 'Events',
mc_truth_tree_name = 'MCTruth',
mc_truth_tree_title = 'MC Truth',
verbose = False)
# definition of a sequence of analyzers, the analyzers will process each event in this order
sequence = cfg.Sequence([sigana])
# finalization of the configuration object.
from ROOT import gSystem
gSystem.Load('libdatamodel')
from EventStore import EventStore as Events
config = cfg.Config(components = selected_components, sequence = sequence, services = [], events_class = Events)
from heppy.FCChhAnalyses.FCChh.Zprime_tautau.TreeProducer import TreeProducer
reco_tree = cfg.Analyzer(
TreeProducer,
jets_pf04_trf='jets_pf04_trf',
leptons='selected_leptons',
met='met',
)
# definition of a sequence of analyzers,
# the analyzers will process each event in this order
sequence = cfg.Sequence([
source,
selected_muons,
selected_electrons,
selected_leptons,
jets_pf04,
match_lepton_jets,
jets_nolepton,
jets_pf04_trf,
#jets_pf04_rew,
reco_tree,
])
config = cfg.Config(components=selectedComponents,
sequence=sequence,
services=[],
events_class=Events)
if __name__ == '__main__':
import sys
from heppy.framework.looper import Looper
filter_func=lambda ptc: abs(ptc.m() - 91) < 5.)
# match all resonances to the resonant ones.
from heppy.analyzers.ResonanceMatcher import ResonanceMatcher
match = cfg.Analyzer(ResonanceMatcher,
resonances='zeds',
match_resonances='sel_zeds',
nmatch=2)
# select unmatched resonances
unmatched_resonances = cfg.Analyzer(
Selector,
output='unmatched',
input_objects='zeds',
filter_func=lambda ptc: len(ptc.matches) == 0)
# definition of a sequence of analyzers,
# the analyzers will process each event in this order
sequence = cfg.Sequence(source, leptons_true, zeds, select_zeds, match,
unmatched_resonances)
# Specifics to read FCC events
from ROOT import gSystem
gSystem.Load("libdatamodelDict")
from EventStore import EventStore as Events
config = cfg.Config(components=selectedComponents,
sequence=sequence,
services=[],
events_class=Events)
from heppy.test.papas_cfg import papasdisplaycompare as display
from heppy.analyzers.SingleJetBuilder import SingleJetBuilder
sum_particles = cfg.Analyzer(SingleJetBuilder,
output='sum_all_ptcs',
particles='rec_particles')
sum_gen = cfg.Analyzer(SingleJetBuilder,
output='sum_all_gen',
particles='gen_particles_stable')
from heppy.analyzers.GlobalEventTreeProducer import GlobalEventTreeProducer
tree = cfg.Analyzer(GlobalEventTreeProducer,
sum_all='sum_all_ptcs',
sum_all_gen='sum_all_gen')
# definition of a sequence of analyzers,
# the analyzers will process each event in this order
sequence = cfg.Sequence(source, papas_sequence, sum_particles, sum_gen, tree,
display)
# Specifics to read FCC events
from ROOT import gSystem
gSystem.Load("libdatamodelDict")
from EventStore import EventStore as Events
config = cfg.Config(components=selectedComponents,
sequence=sequence,
services=[],
events_class=Events)
jets='rescaled_jets',
higgs='higgs',
zed='zed',
leptons='sel_iso_leptons')
# definition of the sequence of analyzers,
# the analyzers will process each event in this order
sequence = cfg.Sequence(
source,
papas_sequence,
leptons,
iso_leptons,
sel_iso_leptons,
# lepton_veto,
jets,
compute_jet_energy,
bquarks,
genjets,
genjet_to_b_match,
jet_to_genjet_match,
btag,
missing_energy,
selection,
zhreco,
tree)
# Specifics to read FCC events
from ROOT import gSystem
gSystem.Load("libdatamodelDict")
from EventStore import EventStore as Events
config = cfg.Config(components=selectedComponents,
photons='selected_photons',
bs='selected_bs',
)
# definition of a sequence of analyzers,
# the analyzers will process each event in this order
sequence = cfg.Sequence([
source,
selected_muons,
selected_electrons,
selected_leptons,
selected_photons,
jets_20,
match_jet_electrons,
jets_noelectron,
match_muon_jets,
jets_nomuon,
match_photon_jets,
jets_nophoton,
selected_bs,
selected_lights,
#photon_higgses,
#b_higgses,
tree
])
config = cfg.Config(components=selectedComponents,
sequence=sequence,
services=[],
events_class=Events)
normalise=False)
# definition of a sequence of analyzers,
# the analyzers will process each event in this order
if useOnlyLeadingGenJet:
sequence = cfg.Sequence([
source,
goodJetSelector,
leadingPtGenJetFinder,
shiftJetMomentum,
smearJetToTriggerObject,
smearedSelector,
leadingPtSimL1TObjectFinder,
barrelSelector,
endcapSelector,
forwardSelector,
simL1TObjectLeadingPtDistribution,
genJetSimL1TObjectTree,
simL1TObjectRate,
genJetRate,
barrelSimL1TObjectRate,
endcapSimL1TObjectRate,
forwardSimL1TObjectRate,
])
else:
sequence = cfg.Sequence([
source,
goodJetSelector,
shiftJetMomentum,
smearJetToTriggerObject,
