Skip to content
Snippets Groups Projects
Commit b14c19b2 authored by Ryunosuke O'Neil's avatar Ryunosuke O'Neil :globe_with_meridians:
Browse files

Merge branch 'aburke-add-11774014' into 'master' 

run D02HH code on 11774014 MC (supersedes !275)

See merge request !303
parents cb5fbd61 6048acb1
No related branches found
No related tags found
1 merge request!303run D02HH code on 11774014 MC (supersedes !275)
Hide whitespace changes
Inline Side-by-side
D02HH/README.md 0 → 100644
+ 14
− 0
View file @ b14c19b2
# AnalysisProductions options for $` D^{0}\rightarrow h^+ h^- `$
The options contained in this directory generate the NTuples for the simulation
of prompt $` D^{\ast+} \rightarrow (D^{0}\rightarrow h^+ h^-) \pi^{+}_{tag} `$
decays (for both standard and LTUNB triggers),
with $` h^+ h^- = K^- \pi^+,\; K^+ K^-,\; \pi^+ \pi^-,\; K^+ \pi^- `$.
General features:
* `DecayTreeFitter` algorithm applied to the $` D^{\ast+} `$ decay chain
w/ the PV constraint, w/ and w/o the $` D^{0} `$ mass constraint;
* combination of the RS prompt sample with a `PersistReco` muon to be used
as proxy for secondary decays;
* momentum scaling of all particles, except the persisted muons of the prompt
sample.
D02HH/info.yaml 0 → 100644
+ 54
− 0
View file @ b14c19b2
checks:
RSdeltaM:
type: range
tree_pattern: RS_DT_Tuple/RS_DT
expression: B_DTF_Dst_M-B_DTF_D0_M
limits:
min: 139
max: 155
n_bins: 100
WSdeltaM:
type: range
tree_pattern: WS_DT_Tuple/WS_DT
expression: B_DTF_Dst_M-B_DTF_D0_M
limits:
min: 139
max: 155
n_bins: 100
defaults:
application: DaVinci/v46r3
automatically_configure: yes
turbo: yes
options:
- make_ntuples.py
output: CHARM_D02HH_DVNTUPLE.ROOT
wg: Charm
inform:
- aodhan.burke@cern.ch
{% for polarity in ["MagDown", "MagUp"] %}
D02HH_2016_{{polarity}}_11774014:
checks:
- RSdeltaM
- WSdeltaM
input:
bk_query: "/MC/2016/Beam6500GeV-2016-{{polarity}}-Nu1.6-25ns-Pythia8/Sim09l-ReDecay01/Trig0x6139160F/Reco16/Turbo03a/Stripping28r2NoPrescalingFlagged/Turbo03aFiltered/11774014/D02HH.HLTFILTER.MDST"
D02HH_2017_{{polarity}}_11774014:
checks:
- RSdeltaM
- WSdeltaM
input:
bk_query: "/MC/2017/Beam6500GeV-2017-{{polarity}}-Nu1.6-25ns-Pythia8/Sim09l-ReDecay01/Trig0x62661709/Reco17/Turbo04a-WithTurcal/Stripping29r2NoPrescalingFlagged/Turbo04aFiltered/11774014/D02HH.HLTFILTER.MDST"
D02HH_2018_{{polarity}}_11774014:
checks:
- RSdeltaM
- WSdeltaM
input:
bk_query: "/MC/2018/Beam6500GeV-2018-{{polarity}}-Nu1.6-25ns-Pythia8/Sim09l-ReDecay01/Trig0x617d18a4/Reco18/Turbo05-WithTurcal/Stripping34NoPrescalingFlagged/Turbo05Filtered/11774014/D02HH.HLTFILTER.MDST"
{% endfor %}
D02HH/make_ntuples.py 0 → 100644
+ 473
− 0
View file @ b14c19b2
from copy import copy
from Configurables import (
DaVinci,
GaudiSequencer,
ChargedProtoANNPIDConf,
LoKi__Hybrid__Dict2Tuple,
LoKi__Hybrid__DictOfFunctors)
from Configurables import LoKi__Hybrid__DTFDict as DTFDict
from Configurables import DecayTreeTuple
from DecayTreeTuple.Configuration import *
from PhysConf.Selections import (AutomaticData, MomentumScaling,
RebuildSelection, SelectionSequence,
CombineSelection)
from PhysConf.Filters import LoKi_Filters
from StandardParticles import StdAllLooseMuons
from TeslaTools import TeslaTruthUtils
DaVinci().Turbo = True
if DaVinci().Simulation or DaVinci().DataType == "2015" or DaVinci().DataType == "2016":
DaVinci().RootInTES = '/Event/Turbo'
else:
DaVinci().RootInTES = "/Event/Charmtwobody/Turbo"
# prompt
hh_keys = {
'KK': 'KmKp',
'PP': 'PimPip',
'RS': 'KmPip',
'WS': 'KpPim'
}
# semi-leptonic
hh_keys_SL = {
'KK_SL': 'KmKp',
'PP_SL': 'PimPip',
'KP_SL': 'KmPip'
}
# doubly-tagged
hh_keys_DT = {
'KK_DT' : 'KmKp',
'PP_DT' : 'PimPip',
'KP_DT' : 'KmPip'
}
hlt2_lines = {
'{k}{ltunb}'.format(k=k, ltunb=ltunb):
'Hlt2CharmHadDstp2D0Pip_D02{hh}{ltunb}Turbo'.format(hh=hh, ltunb=ltunb)
for k, hh in list(hh_keys.items())
for ltunb in ['', '_LTUNB']}
hlt2_lines.update({
'{k}'.format(k=k):
'Hlt2SLB_B2D0Mu_D02{hh}Turbo'.format(hh=hh)
for k, hh in list(hh_keys_SL.items())
})
hlt2_lines.update({
'{k}'.format(k=k):
'Hlt2SLB_B2DstMu_D02{hh}Turbo'.format(hh=hh)
for k, hh in list(hh_keys_DT.items())
})
# https://twiki.cern.ch/twiki/bin/view/LHCb/RefitTracksFromDST#Momentum_Scale_correction
particles = {k: AutomaticData('{hlt2_line}/Particles'.format(hlt2_line=hlt2_line))
for k, hlt2_line in list(hlt2_lines.items())}
if not DaVinci().Simulation:
for k in list(particles.keys()):
particles[k] = MomentumScaling(
particles[k], Turbo=True, Year=DaVinci().DataType)
# make (D*+ mu) combinations (proxy of secondary decays)
muons = RebuildSelection(StdAllLooseMuons)
dst_mu = CombineSelection(
'DstMu',
inputs=[RebuildSelection(StdAllLooseMuons), particles['RS']],
DecayDescriptors=['[B0 -> D*(2010)+ mu-]cc',
'[B0 -> D*(2010)+ mu+]cc'],
DaughtersCuts={
'D*(2010)+': 'ALL',
'D*(2010)-': 'ALL',
'mu-': '(PT > 800.0*MeV) & (P > 3.0*GeV) & (TRGHOSTPROB < 0.5) '
'& (TRCHI2DOF < 5.0) & (MIPCHI2DV(PRIMARY) > 4.0)',
'mu+': '(PT > 800.0*MeV) & (P > 3.0*GeV) & (TRGHOSTPROB < 0.5) '
'& (TRCHI2DOF < 5.0) & (MIPCHI2DV(PRIMARY) > 4.0)'},
CombinationCut='(AM > 2.0*GeV) & (AM < 10.0*GeV)',
MotherCut=('(VFASPF(VCHI2/VDOF) < 25) & (BPVDIRA> 0.999) &'
'(M > 3.0*GeV) & (M < 8.0*GeV)')
)
if DaVinci().DataType == '2015' or DaVinci().DataType == '2016':
dst_mu.InputPrimaryVertices = 'Primary'
if DaVinci().DataType == '2016' and not DaVinci().Simulation:
# https://twiki.cern.ch/twiki/bin/view/LHCb/MakeNTupleFromTurbo#Exact_clones_in_particle_combina
dst_mu.CheckOverlapTool = 'LoKi::CheckOverlap'
dst_mu_sequence = SelectionSequence('DstMuSequence', TopSelection=dst_mu)
particles['Mu'] = dst_mu_sequence
tuple_keys = {k:k for k in list(hlt2_lines.keys()) if 'KP' not in k}
tuple_keys.update({
'Mu': 'Mu',
'RS_SL': 'KP_SL',
'WS_SL': 'KP_SL',
'RS_DT': 'KP_DT',
'WS_DT': 'KP_DT'
})
inputs = { k : particles[tuple_keys[k]] for k in tuple_keys.keys() }
# https://twiki.cern.ch/twiki/bin/view/LHCb/EnsureProbNNsCalculated
probnn_sequence = {}
for k, v in list(hlt2_lines.items()):
probnn_sequence[k] = GaudiSequencer('{0}_ProbNNSeq'.format(k))
annpid = ChargedProtoANNPIDConf(
k + 'ProbNNalg',
RecoSequencer=probnn_sequence[k],
ProtoParticlesLocation='{0}/Protos'.format(v)
)
# K- pi+, K+ K-, pi+ pi- are reconstructed only as D0
# https://gitlab.cern.ch/lhcb/Hlt/blob/2018-patches/Hlt/Hlt2Lines/python/Hlt2Lines
# - CharmHad/D02HHLines.py
# - SLB/Lines.py
decay_descriptors = {
"KK_LTUNB": " ${Dst}[D*(2010)+ -> ${D0}([D0]cc -> ${P1}K+ ${P2}K- ) ${sPi}pi+]CC",
"PP_LTUNB": " ${Dst}[D*(2010)+ -> ${D0}([D0]cc -> ${P1}pi+ ${P2}pi-) ${sPi}pi+]CC",
"RS_LTUNB": " ${Dst}[D*(2010)+ -> ${D0}(D0 -> ${P1}K- ${P2}pi+) ${sPi}pi+]CC",
"WS_LTUNB": " ${Dst}[D*(2010)- -> ${D0}(D0 -> ${P1}K- ${P2}pi+) ${sPi}pi-]CC",
"KK": " ${Dst}[D*(2010)+ -> ${D0}([D0]cc -> ${P1}K+ ${P2}K- ) ${sPi}pi+]CC",
"PP": " ${Dst}[D*(2010)+ -> ${D0}([D0]cc -> ${P1}pi+ ${P2}pi-) ${sPi}pi+]CC",
"RS": " ${Dst}[D*(2010)+ -> ${D0}(D0 -> ${P1}K- ${P2}pi+) ${sPi}pi+]CC",
"WS": " ${Dst}[D*(2010)- -> ${D0}(D0 -> ${P1}K- ${P2}pi+) ${sPi}pi-]CC",
"Mu": " ${B}[Xb -> ${Dst}(D*(2010)+ -> ${D0}(D0 -> ${P1}K- ${P2}pi+) ${sPi}pi+) ${Mu}[mu-]cc]CC",
"KK_SL": "${B}[Xb -> ${D0}([D0]cc -> ${P1}K+ ${P2}K- ) ${Mu}mu- ]CC",
"PP_SL": "${B}[Xb -> ${D0}([D0]cc -> ${P1}pi+ ${P2}pi-) ${Mu}mu- ]CC",
"RS_SL": "${B}[Xb -> ${D0}(D0 -> ${P1}K- ${P2}pi+) ${Mu}mu- ]CC",
"WS_SL": "${B}[Xb -> ${D0}(D0 -> ${P1}K- ${P2}pi+) ${Mu}mu+ ]CC",
"KK_DT": "${B}[Xb -> ${Dst}(D*(2010)+ -> ${D0}([D0]cc -> ${P1}K+ ${P2}K- ) ${sPi}pi+) ${Mu}[mu-]cc]CC",
"PP_DT": "${B}[Xb -> ${Dst}(D*(2010)+ -> ${D0}([D0]cc -> ${P1}pi+ ${P2}pi-) ${sPi}pi+) ${Mu}[mu-]cc]CC",
"RS_DT": "${B}[Xb -> ${Dst}(D*(2010)+ -> ${D0}(D0 -> ${P1}K- ${P2}pi+) ${sPi}pi+) ${Mu}[mu-]cc]CC",
"WS_DT": "${B}[Xb -> ${Dst}(D*(2010)- -> ${D0}(D0 -> ${P1}K- ${P2}pi+) ${sPi}pi-) ${Mu}[mu+]cc]CC"
}
decay_descriptors_mc = {
"KK": " ${Dst}[D*(2010)+ => ${D0}([D0]cc => ${P1}K+ ${P2}K- ) ${sPi}pi+]CC",
"PP": " ${Dst}[D*(2010)+ => ${D0}([D0]cc => ${P1}pi+ ${P2}pi-) ${sPi}pi+]CC",
"RS": " ${Dst}[D*(2010)+ => ${D0}(D0 => ${P1}K- ${P2}pi+) ${sPi}pi+]CC",
"RS_Mu": " ${B}[Xb --> ${Dst}(D*(2010)+ => ${D0}(D0 => ${P1}K- ${P2}pi+) ${sPi}pi+) ${Mu}mu- ${Nu}nu_mu~]CC",
"B": "${B}[B0]cc" # to get the B0 decay time
}
def AddDTF(dtt, decay_type, constrain_pv=True, constrain_d0_m=False):
# DecayTreeFitter configuration
# https://twiki.cern.ch/twiki/bin/view/LHCb/DaVinciTutorial9b
name = 'DTF{0}{1}'.format('_PV' if constrain_pv else '',
'_D0M' if constrain_d0_m else '')
if decay_type == "P":
DictTuple = dtt.Dst.addTupleTool(LoKi__Hybrid__Dict2Tuple, '{}_DictTuple'.format(name))
else:
DictTuple = dtt.B.addTupleTool(LoKi__Hybrid__Dict2Tuple, '{}_DictTuple'.format(name))
DictTuple.addTool(DTFDict, name)
DictTuple.Source = 'LoKi::Hybrid::DTFDict/{}'.format(name)
DictTuple.NumVar = 61 # reserve enough for DT
dtf = getattr(DictTuple, name)
dtf.constrainToOriginVertex = constrain_pv
if constrain_d0_m:
dtf.daughtersToConstrain = ['D0', 'D~0']
dtf.addTool(LoKi__Hybrid__DictOfFunctors, 'dict')
dtf.Source = 'LoKi::Hybrid::DictOfFunctors/dict'
variables = {}
if decay_type == "P":
DTFvars = {
"Dst": "{0}",
"D0": "CHILD(1, {0})",
"P1": "CHILD(1, CHILD(1, {0}))",
"P2": "CHILD(1, CHILD(2, {0}))",
"sPi": "CHILD(2, {0})",
}
elif decay_type == "SL":
DTFvars = {
"B": "{0}",
"D0": " CHILD(1, {0})",
"P1": "CHILD(1, CHILD(1, {0}))",
"P2": "CHILD(1, CHILD(2, {0}))",
"Mu": "CHILD(2, {0})",
}
else:
DTFvars = {
"B": "{0}",
"Dst": "CHILD(1, {0})",
"D0": "CHILD(1, CHILD(1, {0}))",
"P1": "CHILD(1, CHILD(1, CHILD(1, {0})))",
"P2": "CHILD(1, CHILD(1, CHILD(2, {0})))",
"sPi": "CHILD(1, CHILD(2, {0}))",
"Mu": "CHILD(2, {0})",
}
for key, string in list(DTFvars.items()):
for var in ["M", "PT", "P", "ETA", "PHI"]:
variables["{0}_{1}".format(key,var)] = string.format(var)
dtf.dict.Variables = variables
# the DTF fit is run once for each of the following variable
if decay_type == "P":
Loki_DTF = dtt.Dst.addTupleTool('LoKi::Hybrid::TupleTool/LoKi_{0}'.format(name))
else:
Loki_DTF = dtt.B.addTupleTool('LoKi::Hybrid::TupleTool/LoKi_{0}'.format(name))
if decay_type != "DT":
Loki_DTF.Variables = {
"{0}_D0_CTAU".format(name): "DTF_CTAU(1, {0}{1})".format(
True if constrain_pv else False,
", strings(['D0', 'D~0'])" if constrain_d0_m else ""),
"{0}_D0_CTAUERR".format(name): "DTF_CTAUERR( 1, {0}{1})".format(
True if constrain_pv else False,
", strings(['D0', 'D~0'])" if constrain_d0_m else "")
}
else:
Loki_DTF.Variables = {
"{0}_D0_CTAU".format(name): "CHILD(1, DTF_CTAU(1, {0}{1}))".format(
True if constrain_pv else False,
", strings(['D0', 'D~0'])" if constrain_d0_m else ""),
"{0}_D0_CTAUERR".format(name): "CHILD(1, DTF_CTAUERR( 1, {0}{1}))".format(
True if constrain_pv else False,
", strings(['D0', 'D~0'])" if constrain_d0_m else "")
}
Loki_DTF.Variables.update({
"{0}_CHI2".format(name) : "DTF_CHI2({0}{1})".format(True if constrain_pv else False, ", strings(['D0', 'D~0'])" if constrain_d0_m else ""),
"{0}_NDOF".format(name) : "DTF_NDOF({0}{1})".format(True if constrain_pv else False, ", strings(['D0', 'D~0'])" if constrain_d0_m else ""),
"{0}_CHI2NDOF".format(name) : "DTF_CHI2NDOF({0}{1})".format(True if constrain_pv else False, ", strings(['D0', 'D~0'])" if constrain_d0_m else "")
})
return
def SetupMCTools(dtt, is_turbo):
dtt.ToolList += ['TupleToolMCTruth', 'TupleToolMCBackgroundInfo']
mc_tools = ['MCTupleToolPrompt', 'MCTupleToolKinematic', 'MCTupleToolHierarchy']
# https://twiki.cern.ch/twiki/bin/view/LHCb/MakeNTupleFromTurbo#Monte_Carlo_truth
relations = TeslaTruthUtils.getRelLocs() + [
TeslaTruthUtils.getRelLoc(''),
'Relations/Hlt2/Protos/Charged'] # Location of the truth tables for PersistReco objects
TeslaTruthUtils.makeTruth(dtt, relations, mc_tools)
return
# see https://gitlab.cern.ch/lhcb/Analysis/blob/master/Phys/*/src/*
tuple_tools = [
"TupleToolPropertime", # DecayTreeTuple
"TupleToolEventInfo", # DecayTreeTupleTrigger
"TupleToolBeamSpot", # DecayTreeTuple
"TupleToolPid", # DecayTreeTuple
"TupleToolRecoStats", # DecayTreeTupleReco
"TupleToolMuonPid"]
trigger_list = [
"L0B1gasDecision",
"L0B2gasDecision",
"L0DiEMDecision,lowMultDecision",
"L0DiHadron,lowMultDecision",
"L0DiMuonDecision",
"L0DiMuon,lowMultDecision",
"L0ElectronDecision",
"L0Electron,lowMultDecision",
"L0HadronDecision",
"L0JetElDecision",
"L0JetPhDecision",
"L0MuonDecision",
"L0Muon,lowMultDecision",
"L0MuonEWDecision",
"L0PhotonDecision",
"L0Photon,lowMultDecision",
"Hlt1TrackMVADecision",
"Hlt1TrackMVALooseDecision",
"Hlt1TrackMVATightDecision",
"Hlt1TwoTrackMVADecision",
"Hlt1TwoTrackMVALooseDecision",
"Hlt1TwoTrackMVATightDecision",
"Hlt1CalibTrackingKPiDecision",
"Hlt1CalibTrackingKKDecision",
"Hlt1CalibTrackingPiPiDecision"]
trigger_list_SL_DT = [
"Hlt1TrackMuonDecision",
"Hlt1TrackMuonMVADecision",
"Hlt1L0AnyDecision",
"Hlt1MBNoBiasDecision",
"Hlt2TopoMu2BodyDecision",
"Hlt2TopoMu3BodyDecision",
"Hlt2TopoMu4BodyDecision",
"Hlt2Topo2BodyDecision",
"Hlt2Topo3BodyDecision",
"Hlt2Topo4BodyDecision",
"Hlt2CharmHadInclDst2PiD02HHXBDTDecision",
"Hlt2SingleMuonDecision"]
loki_vars_dst = {
"DOCACHI2": "DOCACHI2(1,2)",
"DOCA": "DOCA(1,2)"}
loki_vars_d0 = {
"DOCACHI2": "DOCACHI2(1,2)",
"DOCA": "DOCA(1,2)",
"BPVLTIME": "BPVLTIME()"}
loki_var ={
"ETA": "ETA",
"PHI": "PHI"}
def MakeTuple(key):
""" Returns a DecayTreeTuple algorithm configured to be run on real data"""
dtt = DecayTreeTuple("{0}_Tuple".format(key))
dtt.TupleName = key
dtt.setDescriptorTemplate(decay_descriptors[key])
dtt.Inputs = [inputs[key].outputLocation()]
if DaVinci().DataType == '2015' or DaVinci().DataType == '2016':
dtt.InputPrimaryVertices = 'Primary'
dtt.ToolList = copy(tuple_tools)
# path of header files starts with https://gitlab.cern.ch/lhcb/Analysis/blob/master/Phys/*/src
dtt.addTupleTool("TupleToolTrackInfo").Verbose = True # DecayTreeTupleReco
dtt.addTupleTool("TupleToolGeometry").Verbose = True # DecayTreeTuple
dtt.addTupleTool("TupleToolKinematic").Verbose = True # DecayTreeTuple
dtt.addTupleTool("TupleToolANNPID").ANNPIDTunes = ["MC15TuneV1"] # DecayTreeTupleANNPID
primTool = dtt.addTupleTool("TupleToolPrimaries") # DecayTreeTuple
primTool.Verbose = True
if DaVinci().DataType == '2015' or DaVinci().DataType == '2016':
primTool.InputLocation = 'Primary'
# trigger global info for the event - DecayTreeTupleTrigger/src/TupleToolTrigger.h
global_trigger = dtt.addTupleTool("TupleToolTrigger")
global_trigger.VerboseL0 = True
global_trigger.VerboseHlt1 = True
global_trigger.VerboseHlt2 = True
global_trigger.TriggerList = copy(trigger_list)
# TISTOS - DecayTreeTupleTrigger/src/TupleToolTISTOS.h
tis_tos_tool = dtt.addTupleTool("TupleToolTISTOS")
tis_tos_tool.VerboseL0 = True
tis_tos_tool.VerboseHlt1 = True
tis_tos_tool.VerboseHlt2 = True
tis_tos_tool.FillHlt2 = True
tis_tos_tool.TriggerList = copy(trigger_list)
LoKi_D0 = dtt.D0.addTupleTool("LoKi::Hybrid::TupleTool/LoKi_D0")
LoKi_D0.Variables = loki_vars_d0
LoKi_All = dtt.addTupleTool("LoKi::Hybrid::TupleTool/LoKi_ETA_PHI")
LoKi_All.Variables = loki_var
if not ('SL' in key):
LoKi_DStar = dtt.Dst.addTupleTool("LoKi::Hybrid::TupleTool/LoKi_DStar")
LoKi_DStar.Variables = loki_vars_dst
# additional info for secondary samples only
if key == 'Mu' or ('SL' in key) or ('DT' in key):
dtt.B.addTupleTool("TupleToolCorrectedMass") # DecayTreeTuple/src/TupleToolCorrectedMass.h
loki_B = dtt.B.addTupleTool("LoKi::Hybrid::TupleTool/LoKi_B")
loki_B.Variables = {"BPVMCORR": "BPVCORRM",
"DOCACHI2": "DOCACHI2(1,2)",
"DOCA": "DOCA(1,2)"}
if ('SL' in key) or ('DT' in key):
global_trigger.TriggerList += trigger_list_SL_DT
tis_tos_tool.TriggerList += trigger_list_SL_DT
neutrinoTool = dtt.B.addTupleTool("TupleToolNeutrinoReco")
neutrinoTool.Verbose = True
neutrinoTool.MotherMass = 5279.63
else:
if ('TUNB' in key):
# add prompt Hlt2 line
global_trigger.TriggerList += [ hlt2_lines[key[:2]] + 'Decision' ]
tis_tos_tool.TriggerList += [ hlt2_lines[key[:2]] + 'Decision' ]
else:
# add LTUNB Hlt2 line
if key == 'Mu':
global_trigger.TriggerList += [hlt2_lines['RS_LTUNB'] + 'Decision' ]
tis_tos_tool.TriggerList += [hlt2_lines['RS_LTUNB'] + 'Decision' ]
else:
global_trigger.TriggerList += [hlt2_lines[key+'_LTUNB'] + 'Decision' ]
tis_tos_tool.TriggerList += [hlt2_lines[key+'_LTUNB'] + 'Decision' ]
type = "P" if 'B' not in list(dtt.Branches.keys()) else ("SL" if "Dst" not in list(dtt.Branches.keys()) else "DT")
AddDTF(dtt, type, constrain_pv=False, constrain_d0_m=False)
AddDTF(dtt, type, constrain_pv=False, constrain_d0_m=True)
AddDTF(dtt, type, constrain_pv=True, constrain_d0_m=False)
AddDTF(dtt, type, constrain_pv=True, constrain_d0_m=True)
if DaVinci().Simulation:
SetupMCTools(dtt, DaVinci().Turbo)
return dtt
def MakeTupleMC(key):
""" Returns a MCDecayTreeTuple algorithm configured to be run on simulated
data
"""
dtt = MCDecayTreeTuple('{0}_MCTuple'.format(key))
dtt.TupleName = key
dtt.setDescriptorTemplate(decay_descriptors_mc[key])
dtt.ToolList = [
"MCTupleToolKinematic",
"TupleToolEventInfo"]
return dtt
tuples = [MakeTuple(key) for key in list(tuple_keys.keys())]
if DaVinci().Simulation:
tuples += [MakeTupleMC(key) for key in decay_descriptors_mc.keys()]
def MomentumCorrection(is_mc=False):
"""
Returns the momentum scale correction algorithm for data tracks or the
momentum smearing algorithm for MC tracks
"""
if not is_mc:
from Configurables import TrackScaleState as SCALE
scaler = SCALE('StateScale')
return scaler
else:
from Configurables import TrackSmearState as SMEAR
smear = SMEAR('StateSmear')
return smear
return
trigger_filter = LoKi_Filters(
HLT1_Code=" HLT_PASS_RE('Hlt1.*TrackMVA.*Decision')"
"| HLT_PASS_RE('Hlt1TrackMuon.*Decision')"
"| HLT_PASS_RE('Hlt1CalibTracking.*Decision')",
HLT2_Code=" HLT_PASS_RE('"+hlt2_lines['KK']+"Decision') "
"| HLT_PASS_RE('"+hlt2_lines['PP']+"Decision') "
"| HLT_PASS_RE('"+hlt2_lines['RS']+"Decision') "
"| HLT_PASS_RE('"+hlt2_lines['WS']+"Decision') "
"| HLT_PASS_RE('"+hlt2_lines['KK_LTUNB']+"Decision') "
"| HLT_PASS_RE('"+hlt2_lines['PP_LTUNB']+"Decision') "
"| HLT_PASS_RE('"+hlt2_lines['RS_LTUNB']+"Decision') "
"| HLT_PASS_RE('"+hlt2_lines['WS_LTUNB']+"Decision') "
"| HLT_PASS_RE('"+hlt2_lines['KK_SL']+"Decision')"
"| HLT_PASS_RE('"+hlt2_lines['PP_SL']+"Decision')"
"| HLT_PASS_RE('"+hlt2_lines['KP_SL']+"Decision')"
"| HLT_PASS_RE('"+hlt2_lines['KK_DT']+"Decision')"
"| HLT_PASS_RE('"+hlt2_lines['PP_DT']+"Decision')"
"| HLT_PASS_RE('"+hlt2_lines['KP_DT']+"Decision')"
)
DaVinci().EventPreFilters = trigger_filter.filters('TriggerFilter')
DaVinci().UserAlgorithms += [v for v in probnn_sequence.values()]
DaVinci().UserAlgorithms += [MomentumCorrection(DaVinci().Simulation)]
DaVinci().UserAlgorithms += [p for p in particles.values()]
DaVinci().UserAlgorithms += [dst_mu_sequence.sequence()]
DaVinci().UserAlgorithms += tuples
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment