def add_mc_unbiased_sequence(self, decayDesc, arrow = '==>',
toolList = ["TupleToolPropertime",
"TupleToolKinematic",
"TupleToolGeometry",
"TupleToolEventInfo",
"TupleToolPrimaries",
"TupleToolPid",
"TupleToolANNPID",
"TupleToolTrackInfo",
"TupleToolRecoStats",],
mcToolList = ['TupleToolMCTruth',
'TupleToolMCBackgroundInfo',
'MCTupleToolPrompt'],
L0List = [],
HLT1List = [],
HLT2List = [],
strippingList = []) :
decayDescCC = decayDesc.copy()
decayDescCC.cc = True
sel = build_mc_unbiased_selection(decayDesc, arrow)
selseq = SelectionSequence(decayDesc.get_full_alias() + '_MCSeq',
TopSelection = sel)
seq = selseq.sequence()
seq.Members.insert(0, CheckPV())
dtt = DecayTreeTuple(decayDesc.get_full_alias() + '_MCTuple',
Decay = decayDesc.to_string(carets = True),
Inputs = [sel.outputLocation()],
ToolList = [])
dtt.addBranches(decayDesc.branches())
headBranch = getattr(dtt, decayDesc.get_alias())
dtt.configure_tools(toolList = toolList,
mcToolList = mcToolList,
L0List = L0List,
HLT1List = HLT1List,
HLT2List = HLT2List,
strippingList = strippingList,
headBranch = headBranch)
lokituple = headBranch.addTupleTool('LoKi::Hybrid::TupleTool')
lokituple.Preambulo = ['from LoKiPhysMC.decorators import *',
'from LoKiPhysMC.functions import mcMatch']
mcmatch = 'switch(mcMatch({0!r}), 1, 0)'.format(decayDescCC.to_string(carets = False,
arrow = '==>'))
lokituple.Variables = {'mcMatch' : mcmatch}
seq.Members.append(dtt)
self.UserAlgorithms.append(seq)
mcdtt = MCDecayTreeTuple(decayDesc.get_full_alias() + '_MCDecayTreeTuple')
mcdtt.addBranches(decayDesc.branches())
mcdtt.Decay = decayDescCC.to_string(arrow = arrow, carets = True)
mcdtt.ToolList += filter(lambda t : t.startswith('MC'), mcToolList)
self.UserAlgorithms.append(mcdtt)
return seq
def test_instantiate_multi_sequencer():
sel00 = AutomaticData(Location='Phys/Sel00')
sel01 = AutomaticData(Location='Phys/Sel01')
alg00 = MockConfGenerator()
alg01 = MockConfGenerator()
sel00 = Selection('100011', Algorithm=alg00, RequiredSelections=[sel00])
sel01 = Selection('100012', Algorithm=alg01, RequiredSelections=[sel01])
seq00 = SelectionSequence('Seq000', TopSelection=sel00)
seq01 = SelectionSequence('Seq001', TopSelection=sel01)
seq = MultiSelectionSequence('MultiSeq00z', Sequences=[seq00, seq01])
def make_mc_unbiased_seq(desc, arrow = '==>', refitpvs = True) :
'''Make a selection sequence for the given decay descriptor that has no cuts besides
truth matching.'''
desc = desc.copy()
desc.clear_aliases()
sel = build_mc_unbiased_selection(desc, arrow, refitpvs)
selseq = SelectionSequence(desc.get_full_alias() + '_MCUnbiasedSeq',
TopSelection = sel)
seq = selseq.sequence()
seq.Members.insert(0, CheckPV())
return seq, selseq
def test_call_important_methods():
sel00 = AutomaticData(Location='Phys/Sel00/Particles')
sel01 = AutomaticData(Location='Phys/Sel01/Particles')
seq00 = SelectionSequence('Seq00y', TopSelection=sel00)
seq01 = SelectionSequence('Seq01y', TopSelection=sel01)
seq = MultiSelectionSequence('MultiSeq00y', Sequences=[seq00, seq01])
assert seq.outputLocations() == [
'Phys/Sel00/Particles', 'Phys/Sel01/Particles'
]
algs = seq.algorithms()
seq = seq.sequence()
def add_mc_unbiased_sequence(self, decayDesc, arrow = '==>',
toolList = ["TupleToolPropertime",
"TupleToolKinematic",
"TupleToolGeometry",
"TupleToolEventInfo",
"TupleToolPrimaries",
"TupleToolPid",
"TupleToolANNPID",
"TupleToolTrackInfo",
"TupleToolRecoStats",],
mcToolList = ['TupleToolMCTruth',
'TupleToolMCBackgroundInfo',
'MCTupleToolPrompt'],
L0List = [],
HLT1List = [],
HLT2List = [],
strippingList = []) :
sel = build_mc_unbiased_selection(decayDesc, arrow)
selseq = SelectionSequence(decayDesc.get_full_alias() + '_MCSeq',
TopSelection = sel)
seq = selseq.sequence()
seq.Members.insert(0, CheckPV())
dtt = DecayTreeTuple(decayDesc.get_full_alias() + '_MCTuple',
Decay = decayDesc.to_string(carets = True),
Inputs = [sel.outputLocation()],
ToolList = [])
dtt.addBranches(decayDesc.branches())
headBranch = getattr(dtt, decayDesc.get_alias())
dtt.configure_tools(toolList = toolList,
mcToolList = mcToolList,
L0List = L0List,
HLT1List = HLT1List,
HLT2List = HLT2List,
strippingList = strippingList,
headBranch = headBranch)
lokituple = headBranch.addTupleTool('LoKi::Hybrid::TupleTool')
lokituple.Preambulo = ['from LoKiPhysMC.decorators import *',
'from LoKiPhysMC.functions import mcMatch']
mcmatch = 'switch(mcMatch({0!r}), 1, 0)'.format(decayDesc.to_string(carets = False,
arrow = '==>'))
lokituple.Variables = {'mcMatch' : mcmatch}
seq.Members.append(dtt)
self.UserAlgorithms.append(seq)
mcdtt = MCDecayTreeTuple(decayDesc.get_full_alias() + '_MCDecayTreeTuple')
mcdtt.Decay = decayDesc.to_string(arrow = arrow, carets = True)
self.UserAlgorithms.append(mcdtt)
return seq
def test_multiselectionsequence_with_existing_configurable_name_raises():
fd = FilterDesktop('MultiSeq00')
sel00 = AutomaticData(Location='Phys/Sel00')
sel01 = AutomaticData(Location='Phys/Sel01')
seq00 = SelectionSequence('SelSeq00x', TopSelection=sel00)
seq01 = SelectionSequence('SelSeq01x', TopSelection=sel01)
raises(NameError,
MultiSelectionSequence,
'MultiSeq00',
Sequences=[seq00, seq01])
def test_sequencer_sequence():
_sel00 = AutomaticData(Location='Phys/Sel00')
_sel01 = AutomaticData(Location='Phys/Sel01')
_sel02 = AutomaticData(Location='Phys/Sel02')
_sel03 = AutomaticData(Location='Phys/Sel03')
sel01 = Selection('000110',
Algorithm=MockConfGenerator(),
RequiredSelections=[_sel00, _sel01])
sel02 = Selection('000111',
Algorithm=MockConfGenerator(),
RequiredSelections=[_sel02, _sel03])
sel03 = Selection('000112',
Algorithm=MockConfGenerator(),
RequiredSelections=[sel01, sel02])
presel0 = MockConfGenerator()
presel1 = MockConfGenerator()
postsel0 = MockConfGenerator()
postsel1 = MockConfGenerator()
presels = [presel0, presel1]
postsels = [postsel0, postsel1]
seq = SelectionSequence('Seq0002',
TopSelection=sel03,
EventPreSelector=presels,
PostSelectionAlgs=postsels,
sequencerType=DummySequencer)
seqAlgos = seq.sequence().Members
ref_algos = [
presel0, presel1,
_sel00.algorithm(),
_sel01.algorithm(),
_sel02.algorithm(),
_sel03.algorithm(),
sel02.algorithm(),
sel01.algorithm(),
sel03.algorithm(), postsel0, postsel1
]
assert len(seqAlgos) == 11
assert presels == ref_algos[:len(presels)]
assert postsels == ref_algos[len(ref_algos) - len(postsels):]
for sel in [sel01, sel02, sel03]:
assert sel.algorithm() in ref_algos[len(presels):len(ref_algos) -
len(postsels)]
def __init__(self, _name, _config={}):
self.name = _name
self.config = {
"ALL":
{ # Cuts made on all charged input particles in all lines (excpt. upstream)
'TRCHI2DOF_MAX': 5,
'PT_MIN': '100*MeV',
'P_MIN': '1000*MeV',
'MIPCHI2DV_MIN': 4,
'TRGHP_MAX': 0.4
},
"V0s": {
'PT_MIN': '500*MeV',
'P_MIN': '1000*MeV',
'MIPCHI2DV_MIN': 4
},
"Photons": {
'PT_MIN': '2500*MeV',
'P_MIN': '4000*MeV'
},
'BB': {
'ADDSUMPT': 0,
'COSANGLE_MAX': 0.99,
'COSDPHI_MAX': 0,
'M_MIN': 0,
'MAXPT_MIN': 4000
},
'PIDE_MIN': -2.0
}
self.config.update(_config)
self.algorithms = []
self.kaons = self.filterInputs('mK', [StdAllNoPIDsKaons],
self.config['ALL'])
self.V0s = self.filterInputs('mV0s', [
self.dataOnDemand('StdLooseKsLL'),
self.dataOnDemand('StdLooseKsDD'),
self.dataOnDemand('StdLooseLambdaLL'),
self.dataOnDemand('StdLooseLambdaDD')
], self.config['V0s'])
self.Photons = self.filterInputs(
'mG', [self.dataOnDemand('StdLooseAllPhotons')],
self.config['Photons'])
self.topoKaons = self.topoInputs('mK', [self.kaons])
self.topos = self.makeTopoCands(
MergedSelection('allInput', [self.topoKaons, self.V0s]),
self.config['BB']['ADDSUMPT'])
self.seq = SelectionSequence('seq', TopSelection=self.topos)
self.algorithms = [self.seq.sequence()]
class SelectionTree(object):
sel000 = Selection('0.00000',
Algorithm=MockConfGenerator(),
RequiredSelections=[])
sel001 = Selection('0.00001',
Algorithm=MockConfGenerator(),
RequiredSelections=[])
sel002 = Selection('0.00002',
Algorithm=MockConfGenerator(),
RequiredSelections=[])
sel003 = Selection('0.00003',
Algorithm=MockConfGenerator(),
RequiredSelections=[])
sel100 = Selection('1.00000',
Algorithm=MockConfGenerator(),
RequiredSelections=[sel000, sel001])
sel101 = Selection('1.00001',
Algorithm=MockConfGenerator(),
RequiredSelections=[sel002, sel003])
sel200 = Selection('2.00000',
Algorithm=MockConfGenerator(),
RequiredSelections=[sel100, sel101])
selSeq = SelectionSequence('Seq06', TopSelection=sel200)
algs = selSeq.algorithms()
alg_names = [a.name() for a in algs]
def get_selection_sequence(name):
"""Get the selection from stripping stream"""
# Relative lesLoc for uDST, no preceeding '/'
tesLoc = 'Phys/B2DPiPiD2HHHCFPIDBeauty2CharmLine/Particles'
alg = FilterDesktop('SelFilterFor{}B2D'.format(name))
alg.Code = 'ALL'
reqSels = [DataOnDemand(Location=tesLoc)]
sel = Selection('Sel' + name, Algorithm=alg, RequiredSelections=reqSels)
return SelectionSequence('SelSeq' + name, TopSelection=sel)
def add_tuples():
'''Make ntuples for the D0->hhpi0 stripping lines. Assumes the data settings have already
been configured in DaVinci.'''
# Normal data
stream = 'Charm.mdst'
simulation = DaVinci().getProp('Simulation')
# For restripping
if DaVinci().getProp('ProductionType') == 'Stripping':
stream = 'CharmCompleteEvent.dst'
# For MC.
elif simulation:
stream = 'AllStreams.dst'
fulldst = stream.endswith('.dst')
streamname = '.'.join(stream.split('.')[:-1])
tuples = []
seqs = []
for line in get_line_docs():
stripdata = StrippingData(line.name,
stream=(streamname if fulldst else None))
if not simulation:
stripdata = MomentumScaling(stripdata)
lineconfig = line.tuple_config()
del lineconfig['Inputs']
dttsel = TupleSelection(line.name + 'Tuple', [stripdata], **lineconfig)
dtt = dttsel.algorithm()
dtt.addBranches(line.branches)
tuples.append(dtt)
add_tools(dtt)
seq = SelectionSequence(line.name + 'Seq', TopSelection=dttsel)
DaVinci().UserAlgorithms += [seq.sequence()]
#DaVinci(**line.davinci_config(stream))
DaVinci().StrippingStream = streamname
DaVinci().TupleFile = 'DaVinciTuples.root'
if DaVinci().getProp('Simulation'):
for dtt in tuples:
add_mc_tools(dtt)
else:
DaVinci().Lumi = True
return tuples
def test_remove_duplicates():
sel000 = SelectionTree.sel000
sel001 = SelectionTree.sel001
sel002 = SelectionTree.sel002
sel003 = SelectionTree.sel003
sel100 = Selection('1.10000',
Algorithm=MockConfGenerator(),
RequiredSelections=[sel000, sel001, sel002])
sel101 = Selection('1.10001',
Algorithm=MockConfGenerator(),
RequiredSelections=[sel001, sel002, sel003])
sel200 = Selection('2.10000',
Algorithm=MockConfGenerator(),
RequiredSelections=[sel100, sel101])
selSeq = SelectionSequence('Seq07', TopSelection=sel200)
algs = selSeq.algorithms()
alg_names = [a.name() for a in algs]
assert len(algs) == 7
assert alg_names.count('0.00000') == 1
assert alg_names.count('0.00001') == 1
assert alg_names.count('0.00002') == 1
assert alg_names.count('0.00003') == 1
assert alg_names.count('1.10000') == 1
assert alg_names.count('1.10001') == 1
assert alg_names.count('2.10000') == 1
assert alg_names.index('0.00000') < alg_names.index('1.10000')
assert alg_names.index('0.00001') < alg_names.index('1.10000')
assert alg_names.index('0.00002') < alg_names.index('1.10000')
assert alg_names.index('0.00001') < alg_names.index('1.10001')
assert alg_names.index('0.00002') < alg_names.index('1.10001')
assert alg_names.index('0.00003') < alg_names.index('1.10001')
assert alg_names.index('1.10000') < alg_names.index('2.10000')
assert alg_names.index('1.10001') < alg_names.index('2.10000')
def test_order_line():
sel000 = Selection('0.0000',
Algorithm=MockConfGenerator(),
RequiredSelections=[])
sel001 = Selection('0.0001',
Algorithm=MockConfGenerator(),
RequiredSelections=[sel000])
sel101 = Selection('1.0000',
Algorithm=MockConfGenerator(),
RequiredSelections=[sel001])
sel102 = Selection('1.0001',
Algorithm=MockConfGenerator(),
RequiredSelections=[sel101])
sel203 = Selection('2.0000',
Algorithm=MockConfGenerator(),
RequiredSelections=[sel102])
selSeq = SelectionSequence('Seq04', TopSelection=sel203)
algs = selSeq.algorithms()
assert [a.name() for a in algs
] == ['0.0000', '0.0001', '1.0000', '1.0001', '2.0000']
def test_sequencer_algos():
_sel00 = AutomaticData(Location='Phys/Sel00')
_sel01 = AutomaticData(Location='Phys/Sel01')
_sel02 = AutomaticData(Location='Phys/Sel02')
_sel03 = AutomaticData(Location='Phys/Sel03')
sel01 = Selection('00100',
Algorithm=MockConfGenerator(),
RequiredSelections=[_sel00, _sel01])
sel02 = Selection('00101',
Algorithm=MockConfGenerator(),
RequiredSelections=[_sel02, _sel03])
sel03 = Selection('00102',
Algorithm=MockConfGenerator(),
RequiredSelections=[sel01, sel02])
seq = SelectionSequence('Seq01', TopSelection=sel03)
seqAlgos = seq.algorithms()
assert len(seqAlgos) == 7
for sel in [sel01, sel02, sel03]:
assert sel.algorithm() in seqAlgos
def oneTosMonitor(name="None", input=None, calo=False):
from PhysSelPython.Wrappers import Selection, SelectionSequence
from Configurables import TisTosParticleTagger, ParticleMonitor, PrintDecayTree
Tosser = TisTosParticleTagger(name + "Tosser")
Tosser.TisTosSpecs = {name + "Decision%TOS": 0}
Tosser.ProjectTracksToCalo = calo
Tosser.CaloClustForCharged = calo
s1 = Selection("TOSPresel" + name,
Algorithm=Tosser,
RequiredSelections=[input])
tools = ["MomentumPlotTool"]
if ('Muon' in name): tools += ["MuonPlotTool"]
plotter = ParticleMonitor(name + "TosMoni", PlotTools=tools)
# Make things a bit faster
if ('L0Hadron' in name): plotter.MotherCut = "PT>1*GeV"
else: plotter.MotherCut = "PT>0.5*GeV"
s2 = Selection("TOSSel" + name, Algorithm=plotter, RequiredSelections=[s1])
ss = SelectionSequence("TOSSeq" + name, TopSelection=s2)
return ss.sequence()
def select(self):
"""
Get data and selection
"""
from PhysSelPython.Wrappers import Selection, SelectionSequence, DataOnDemand, AutomaticData
# from StandardParticles import StdLooseMuons, StdLooseKaons
from Configurables import FilterDesktop, CombineParticles, OfflineVertexFitter, LoKi__HDRFilter
from GaudiKernel.PhysicalConstants import c_light
evtPreselectors = []
if dataSample.isPrescaled != False:
if dataSample.isPrescaled == True:
dataSample.isPrescaled = 0.1
prescaler = DeterministicPrescaler("Prescaler", AcceptFraction=dataSample.isPrescaled)
evtPreselectors.append(prescaler)
# # Stripping filter
strippingFilter = LoKi__HDRFilter(
"StripPassFilter",
Code="HLT_PASS('Stripping" + self.lineName + "Decision')",
Location="/Event/Strip/Phys/DecReports",
)
evtPreselectors.append(strippingFilter)
stripped_data = AutomaticData(Location=self.lineLocation)
# Trigger selection
# from Configurables import TisTosParticleTagger
# _tisTosFilter = TisTosParticleTagger( self.name + "Triggered" )
# _tisTosFilter.TisTosSpecs = { 'L0Global%TUS' : 0,
# 'L0Global%TIS' : 0,
# }
# for trigger in trigger_list:
# for tistos in ['TIS', 'TUS']:
# _tisTosFilter.TisTosSpecs['{0}%{1}'.format(trigger, tistos)] = 0
# triggered_data = Selection( self.name+'TriggerSelection',
# Algorithm = _tisTosFilter,
# RequiredSelections = [ stripped_data ],
# )
Candidate_selection = stripped_data # triggered_data
self.sequence = SelectionSequence(
"Seq" + self.name, TopSelection=Candidate_selection, EventPreSelector=evtPreselectors
)
def makeSelectionSequenceSS(line, stream):
location = "/Event/" + stream + "/Phys/" + line + "/Particles"
strippingfilter = LoKi__HDRFilter('StripPassFilter',
Code="HLT_PASS('Stripping" + line +
"Decision')",
Location="/Event/Strip/Phys/DecReports")
BuSel = AutomaticData(Location=location)
selBss2bukSS = Selection("selBss2bukSS" + line,
Algorithm=bss2bukSS,
RequiredSelections=[BuSel, selK])
return SelectionSequence('seqBss2bukSS' + line, TopSelection=selBss2bukSS)
"LoKi_nOThits": "CONTAINS('Raw/OT/Times')",
"LoKi_nNeutrals": "CONTAINS('Rec/ProtoP/Neutrals')",
"LoKi_nCharged": "CONTAINS('Rec/ProtoP/Charged')"
}
#HRC tool
tool = tupalg.addTupleTool("TupleToolHerschel")
## for debugging:
from SelPy.graph import graph
for tup in tuples:
graph(tup, format='png')
from PhysSelPython.Wrappers import SelectionSequence
#seq = SelectionSequence ( 'LbKSSEQ' , tupLbKS )
#dv.UserAlgorithms += [ seq.sequence() ]
#seq = SelectionSequence ( 'LbKstSEQ' , tupLbKst )
#dv.UserAlgorithms += [ seq.sequence() ]
#seq = SelectionSequence ( 'LbKSJpsipKSEQ' , tupLbKS_jpsipk )
#dv.UserAlgorithms += [ seq.sequence() ]
#seq = SelectionSequence ( 'LbKstJpsipKSEQ' , tupLbKst_jpsipk )
#dv.UserAlgorithms += [ seq.sequence() ]
from Configurables import HCRawBankDecoder
decoder = HCRawBankDecoder()
DaVinci().UserAlgorithms += [decoder]
for tup in tuples:
seq = SelectionSequence(tup.name() + '_SEQ', tup)
dv.UserAlgorithms += [seq.sequence()]
def parseConfiguration(
tupleConfig, # TupleConfig object describing sample
tesFormat, # Input TES with "<line>" placeholder
mdstOutputFile, # MicroDST output extension
mdstOutputPrefix, # MicroDST prefix for production
varsByType, # requested variables by type
varsByName, # requested variables by name
eventVariables, # event variables
writeNullWeightCandidates=True,
writeMuonPIDPlus=True,
mdstInput=False,
tupleOutput=True):
cfg = tupleConfig
reviveSequences = [] # mark sequences to unpack std particles
swSequences = [] # mark sequences to apply sWeights
filterSequences = [] # mark sequences to be written in tuples
matchSequences = [] # mark sequences to be written in tuples
tupleSequences = [] # mark tuple sequences
dstSequences = [] # sequences writing (Micro)DST files
triggerList = [
"L0MuonDecision",
"L0HadronDecision",
"L0ElectronDecision",
"Hlt1TrackMVADecision",
"Hlt1TrackMuonDecision",
]
for basicPart in ["Muons", "Pions", "Kaons", "Protons", "Electrons"]:
location = "Phys/StdAllNoPIDs{s}/Particles".format(s=basicPart)
reviveSequences += [
SelectionSequence("fs_std" + basicPart,
TopSelection=DataOnDemand(location))
]
for basicPart in [
"DownPions", "DownKaons", "DownProtons", "DownElectrons"
]:
location = "Phys/StdNoPIDs{s}/Particles".format(s=basicPart)
reviveSequences += [
SelectionSequence("fs_std" + basicPart,
TopSelection=DataOnDemand(location))
]
location = "Phys/StdLooseDownMuons/Particles"
reviveSequences += [
SelectionSequence("fs_std" + "DownMuons",
TopSelection=DataOnDemand(location))
]
for sample in cfg:
################################################################################
## Configure sWeighting ##
################################################################################
for line in cfg[sample].InputLines:
location = tesFormat.replace('<line>', line)
protoLocation = location.replace('/Particles', '/Protos')
# swSequences+=[ProbNNcalib ("TurboProbNN" + line, protoLocation).sequence()]
if cfg[sample].Calibration:
swSequences += [
ApplySWeights(
"ApplySW" + sample,
InputTes=location,
sTableDir=cfg[sample].Calibration,
sTableName="sTableSignal",
)
]
################################################################################
## Creates filter sequences to fill nTuples ##
################################################################################
selectionName = sample
_cut = "DECTREE ('{}')".format(cfg[sample].Decay.replace("^", ""))
if writeNullWeightCandidates == False:
_cut += " & ( WEIGHT != 0 ) "
if cfg[sample].Filter:
_cut += " & ({}) ".format(cfg[sample].Filter.cut)
inputSelection = MergedSelection(
"input" + selectionName,
RequiredSelections=[
DataOnDemand(tesFormat.replace('<line>', line))
for line in cfg[sample].InputLines
],
)
selection = Selection(
selectionName,
RequiredSelections=[inputSelection],
Algorithm=FilterDesktop("alg_" + selectionName, Code=_cut),
)
filterSequence = SelectionSequence("Seq" + selectionName,
TopSelection=selection)
filterSequences += [filterSequence]
################################################################################
## Creates matching selections (used to create the proper locations in mdst) ##
################################################################################
matchingSel = Selection("Match" + selectionName,
Algorithm=CopyAndMatchCombination(
"MatchAlg" + selectionName,
Downstream=cfg[sample].Downstream,
),
RequiredSelections=[selection])
matchingSeq = SelectionSequence("SeqMatch" + selectionName,
TopSelection=matchingSel)
matchSequences += [matchingSeq]
partsInBranches = []
for branchName in cfg[sample].Branches:
partName = branchName
if len(cfg[sample].Branches[branchName].isAlso) > 0:
partName = cfg[sample].Branches[branchName].isAlso[0]
partsInBranches += [partName]
#print("partsInBranches = ", partsInBranches)
################################################################################
## Parses the configuration dictionaries and configure the tuples ##
################################################################################
tuple = DecayTreeTuple(sample + "Tuple")
tuple.Inputs = [filterSequence.outputLocation()]
tuple.Decay = cfg[sample].Decay
tuple.ToolList = ["TupleToolANNPID"]
if mdstInput:
tuple.RootInTES = "/Event/Turbo"
if "e" in partsInBranches:
ttBrem = tuple.addTupleTool("TupleToolBremInfo")
ttBrem.Particle = ["pi+", "p", "K+", "mu+", "e+"]
ttBrem.Verbose = True
ttBrem.RootInTES = "" #### !!!!
ttPPD = tuple.addTupleTool("TupleToolProtoPData")
ttPPD.DataList = [
"VeloCharge", "CaloEoverP", "CaloEcalChi2", "CaloPrsE",
"CaloHcalE", "EcalPIDe", "PrsPIDe", "HcalPIDe", "CaloEcalE"
]
if writeMuonPIDPlus and ("mu" in partsInBranches):
muidPlus = tuple.addTupleTool("TupleToolMuonPidPlus")
muidPlus.MuonIDPlusToolName = "MuonIDPlusTool"
muidPlus.OutputLevel = 5
muidPlus.RootInTES = "" #### !!!!!
muidPlus.addTool(MuonIDPlusTool)
muidPlus.MuonIDPlusTool.OutputLevel = 5
muidPlus.MuonIDPlusTool.RootInTES = "" #### !!!!!
muidPlus.MuonIDPlusTool.ReleaseObjectOwnership = False
muidPlus.MuonIDPlusTool.MatchToolName = "MuonChi2MatchTool"
muidPlus.Verbose = True
eventTool = tuple.addTupleTool("LoKi::Hybrid::EvtTupleTool/LoKiEvent")
if 'VOID' in eventVariables.keys():
eventTool.VOID_Variables = eventVariables['VOID']
if not mdstInput:
if 'ODIN' in eventVariables.keys():
eventTool.ODIN_Variables = eventVariables['ODIN']
if 'HLT' in eventVariables.keys():
eventTool.HLT_Variables = eventVariables['HLT']
if 'L0DU' in eventVariables.keys():
eventTool.L0DU_Variables = eventVariables['L0DU']
eventTool.Preambulo = [
"from LoKiTracks.decorators import *",
"from LoKiCore.functions import *"
]
tuple.addTool(eventTool)
if mdstInput:
matchingLocation = {
"mu+": "/Event/PIDCALIB/Phys/Match" + sample + "/Particles",
"pi+": "/Event/PIDCALIB/Phys/Match" + sample + "/Particles",
"K+": "/Event/PIDCALIB/Phys/Match" + sample + "/Particles",
"p+": "/Event/PIDCALIB/Phys/Match" + sample + "/Particles",
"e+": "/Event/PIDCALIB/Phys/Match" + sample + "/Particles",
}
else:
if cfg[sample].Downstream:
matchingLocation = {
"mu+": "Phys/StdLooseDownMuons/Particles",
"pi+": "Phys/StdNoPIDsDownPions/Particles",
"K+": "Phys/StdNoPIDsDownKaons/Particles",
"p+": "Phys/StdNoPIDsDownProtons/Particles",
"e+": "Phys/StdNoPIDsDownElectrons/Particles",
}
else:
matchingLocation = {
"mu+": "Phys/StdAllNoPIDsMuons/Particles",
"pi+": "Phys/StdAllNoPIDsPions/Particles",
"K+": "Phys/StdAllNoPIDsKaons/Particles",
"p+": "Phys/StdAllNoPIDsProtons/Particles",
"e+": "Phys/StdAllNoPIDsElectrons/Particles",
}
tupleSequences += [tuple]
for branchName in cfg[sample].Branches:
partName = branchName
if len(cfg[sample].Branches[branchName].isAlso) > 0:
partName = cfg[sample].Branches[branchName].isAlso[0]
#print ("PartName = ", partName)
b = tuple.addBranches(
{branchName: cfg[sample].Branches[branchName].Particle})
b = b[branchName]
matcher = b.addTupleTool("TupleToolTwoParticleMatching/Matcher_" +
branchName)
matcher.ToolList = []
matcher.Prefix = ""
matcher.Suffix = "_Brunel"
matcher.MatchLocations = matchingLocation
lokitool = b.addTupleTool("LoKi::Hybrid::TupleTool/LoKi_" +
branchName)
vardict = copy(varsByType[cfg[sample].Branches[branchName].Type])
pidcalibtool = b.addTupleTool("TupleToolPIDCalib/PIDCalibTool_" +
branchName)
pidcalibtool_matched = TTpid("PIDCalibTool_match_" + branchName)
for partName in [branchName
] + cfg[sample].Branches[branchName].isAlso:
if partName in varsByName:
vardict.update(varsByName[partName])
# if partName == 'e':
# pidcalibtool.FillBremInfo = True
# pidcalibtool_matched.FillBremInfo = True
lokimatchedtool = LokiTool("LoKi_match_" + branchName)
matcher.addTool(pidcalibtool_matched)
matcher.ToolList += [
"LoKi::Hybrid::TupleTool/LoKi_match_" + branchName,
"TupleToolPIDCalib/PIDCalibTool_match_" + branchName
]
from Configurables import TupleToolTISTOS
tistostool = TupleToolTISTOS("TISTOSForTheOffline" + branchName)
tistostool.FillL0 = True
tistostool.FillHlt1 = True
tistostool.FillHlt2 = False
tistostool.Verbose = True # 16/01/2020 for L0Calo
tistostool.VerboseL0 = True
tistostool.VerboseHlt1 = True
tistostool.VerboseHlt2 = False
tistostool.TriggerList = triggerList
matcher.addTool(tistostool)
matcher.ToolList += [
"TupleToolTISTOS/TISTOSForTheOffline" + branchName
]
# 16/01/2020 for L0Calo variables
from Configurables import TupleToolL0Calo
l0calotool = TupleToolL0Calo("L0CaloForTheOffline" + branchName)
l0calotool.WhichCalo = "HCAL"
l0calotool.TriggerClusterLocation = "Trig/L0/FullCalo" # Added 29/01/2020 for "trigger" variables
matcher.addTool(l0calotool)
matcher.ToolList += [
"TupleToolL0Calo/L0CaloForTheOffline" + branchName
]
from Configurables import TupleToolBremInfo, TupleToolProtoPData, TupleToolANNPID, TupleToolMuonPidPlus
if partName == "e":
ttbi = TupleToolBremInfo("BremInfoForTheOffline" + branchName)
ttbi.Particle = ["pi+", "p", "K+", "mu+", "e+"]
ttbi.RootInTES = ""
matcher.addTool(ttbi)
matcher.ToolList += [
"TupleToolBremInfo/BremInfoForTheOffline" + branchName
]
ttppd = TupleToolProtoPData("ProtoPDataForTheOffline" + branchName)
ttppd.DataList = [
"VeloCharge", "CaloEoverP", "CaloEcalChi2", "CaloPrsE",
"CaloHcalE", "EcalPIDe", "PrsPIDe", "HcalPIDe", "CaloEcalE"
]
matcher.addTool(ttppd)
matcher.ToolList += [
"TupleToolProtoPData/ProtoPDataForTheOffline" + branchName
]
ttann = TupleToolANNPID("ANNPIDForTheOffline" + branchName)
ttann.PIDTypes = [
"Electron", "Muon", "Pion", "Kaon", "Proton", "Ghost",
"Deuteron"
]
# ttann.PIDTypes = [ "Electron","Muon","Pion","Kaon","Proton","Ghost" ]
ttann.ANNPIDTunes = [
"MC12TuneV2", "MC12TuneV3", "MC12TuneV4", "MC15TuneV1",
"MC15TuneDNNV1", "MC15TuneCatBoostV1", "MC15TuneFLAT4dV1"
]
matcher.addTool(ttann)
matcher.ToolList += [
"TupleToolANNPID/ANNPIDForTheOffline" + branchName
]
if writeMuonPIDPlus and partName == "mu":
ttmuidPlus = TupleToolMuonPidPlus(
"TupleToolMuonPidPlusForTheOffline" + branchName)
ttmuidPlus.MuonIDPlusToolName = "MuonIDPlusTool"
ttmuidPlus.OutputLevel = 5
ttmuidPlus.RootInTES = "" #### !!!!!
ttmuidPlus.addTool(MuonIDPlusTool)
ttmuidPlus.MuonIDPlusTool.OutputLevel = 5
ttmuidPlus.MuonIDPlusTool.RootInTES = "" #### !!!!!
ttmuidPlus.MuonIDPlusTool.ReleaseObjectOwnership = False
ttmuidPlus.MuonIDPlusTool.MatchToolName = "MuonChi2MatchTool"
ttmuidPlus.Verbose = True
matcher.addTool(ttmuidPlus)
matcher.ToolList += [
"TupleToolMuonPidPlus/TupleToolMuonPidPlusForTheOffline" +
branchName
]
vardict.update(cfg[sample].Branches[branchName].LokiVariables)
lokimatchedtool.Variables = vardict
lokitool.Variables = vardict
matcher.addTool(lokimatchedtool)
# Additional variables for Greg/Phoebe's uBDT
from Configurables import TupleToolANNPIDTrainingLight
if hasattr(tuple, 'probe'):
tuple.probe.addTool(TupleToolANNPIDTrainingLight,
name='TupleToolANNPIDTrainingLight')
tuple.probe.ToolList += [
'TupleToolANNPIDTrainingLight/TupleToolANNPIDTrainingLight'
]
print "Input TES: "
print "\n".join([f.outputLocation() for f in filterSequences])
if mdstOutputFile:
dstSequences += configureMicroDSTwriter(
mdstOutputFile, mdstOutputPrefix, filterSequences + matchSequences)
if mdstInput:
return (reviveSequences + swSequences + filterSequences +
matchSequences + tupleSequences)
else:
if tupleOutput:
return (reviveSequences + swSequences + filterSequences +
matchSequences + dstSequences + tupleSequences)
else:
return (reviveSequences + filterSequences + matchSequences +
dstSequences)
}
d0_comb = "(AMAXDOCA('') < 0.2*mm) & (ADAMASS('D0') < 100*MeV)"
# We can split long selections across multiple lines
d0_mother = ('(VFASPF(VCHI2/VDOF)< 9)'
'& (BPVDIRA > 0.9997)'
"& (ADMASS('D0') < 70*MeV)")
d0 = CombineParticles('Combine_D0',
DecayDescriptor='([D0 -> pi- K+]CC)',
DaughtersCuts=d0_daughters,
CombinationCut=d0_comb,
MotherCut=d0_mother)
d0_sel = Selection('Sel_D0', Algorithm=d0, RequiredSelections=[Pions, Kaons])
dstar_daughters = {'pi+': '(TRCHI2DOF < 3) & (PT > 100*MeV)'}
dstar_comb = "(ADAMASS('D*(2010)+') < 400*MeV)"
dstar_mother = ("(abs(M-MAXTREE('D0'==ABSID,M)-145.42) < 10*MeV)"
'& (VFASPF(VCHI2/VDOF)< 9)')
dstar_sel = SimpleSelection('Sel_Dstar',
ConfigurableGenerators.CombineParticles,
[d0_sel, Pions],
DecayDescriptor='[D*(2010)+ -> D0 pi+]cc',
DaughtersCuts=dstar_daughters,
CombinationCut=dstar_comb,
MotherCut=dstar_mother)
dstar_seq = SelectionSequence('Dstar_Seq', TopSelection=dstar_sel)
DaVinci().UserAlgorithms += [dstar_seq.sequence()]
DstConf().Turbo = True
TurboConf().PersistReco = True
pions = DataOnDemand('Phys/StdAllNoPIDsPions/Particles')
ks0 = CombineParticles('Ks0Topipi',
DecayDescriptors=['[KS0 -> pi+ pi+]cc'],
CombinationCut=("AM < 320*MeV"), #parent
MotherCut="ALL")
ks0_sel = Selection(
'Sel_Ks0Topipi',
Algorithm=ks0,
RequiredSelections=[pions]
)
ks0_selseq = SelectionSequence(
'SelSeq_Ks0Topipi',
TopSelection=ks0_sel
)
dtt_ks0 = DecayTreeTuple('TupleKs0Topipi')
dtt_ks0.Inputs = ks0_selseq.outputLocations()
dtt_ks0.Decay = '[KS0 -> ^pi+ ^pi+]CC'
dtt_ks0.addBranches({
'Ks0': '[KS0 -> pi+ pi+]CC',
'pi1': '[KS0 -> ^pi+ pi+]CC',
'pi2': '[KS0 -> pi+ ^pi+]CC'
})
DaVinci().UserAlgorithms = [ks0_selseq.sequence(), dtt_ks0]
DaVinci().DataType = '2016'
DaVinci().EvtMax = 1000
DaVinci().TupleFile = 'PersistRecoTuple_ks0_pipi.root'
def ConfigureDaVinci():
config = Swimming()
from Configurables import DaVinci
from StrippingConf.Configuration import StrippingConf
from Configurables import ProcStatusCheck
from Configurables import EventNodeKiller, GaudiSequencer
from PhysSelPython.Wrappers import (AutomaticData, SelectionSequence,
MultiSelectionSequence)
# Get the stripping line
from StrippingSettings.Utils import lineBuilderConfiguration
strippingFile = None
if config.getProp('StrippingFile') != 'none':
strippingFile = config.getProp('StrippingFile')
else:
strippingFile = config.getProp('StrippingLineGroup')
myconfig = lineBuilderConfiguration(config.getProp('StrippingVersion'),
config.getProp('StrippingLineGroup'))
import StrippingArchive
mylineconf = getattr(
__import__(
'StrippingArchive.' +
config.getProp('StrippingVersion') + '.Stripping' + strippingFile,
globals(), locals(), [myconfig["BUILDERTYPE"]], -1),
myconfig["BUILDERTYPE"])
mylinedict = myconfig["CONFIG"]
substitutions = config.getProp('StrippingConfigSubstitutions')
print "mylinedict before substitutions:", mylinedict
print "stripping config substitutions:", substitutions
mylinedict.update(substitutions)
print "mylineconf:", mylineconf
print "mylinedict after substitutions:", mylinedict
from StrippingConf.StrippingStream import StrippingStream
stream = StrippingStream(config.getProp('StrippingStream') + "Swimming")
allLines = mylineconf(config.getProp('StrippingLineGroup'),
mylinedict).lines()
lines = []
#lineNames = [l.split('/')[-1] for l in config.getProp('StripCands').keys()]
lineNames = config.getProp('StrippingLines')
print "lineNames:", lineNames
for l in allLines:
for lineName in lineNames:
if l.outputLocation().find(lineName) != -1:
lines.append(l)
print l.outputLocation()
stream.appendLines(lines)
# Define the stream
filterBadEvents = ProcStatusCheck()
sc = StrippingConf(Streams=[stream],
MaxCandidates=2000,
AcceptBadEvents=False,
BadEventSelection=filterBadEvents)
# Define the node killer, and make sure to kill everything corresponding to
# the stream which we want to swim
outputs = []
from Configurables import Swimming__PVReFitter as ReFitter
for l in lines:
for f in l.filterMembers():
if hasattr(f, 'ReFitPVs') and f.ReFitPVs:
if not config.getProp('RefitPVs'):
log.warning('RefitPVs is not set, but stripping line applies refitting. Refitted ' + \
'PVs will be used for turning-point lifetime calculations.')
config.setProp('RefitPVs', True)
t = f.PVReFitters['']
f.PVReFitters = {'': 'Swimming::PVReFitter/PVReFitter'}
f.addTool(ReFitter, 'PVReFitter')
f.PVReFitter.PVReFitter = t
elif not hasattr(f, 'Output'):
continue
# Remove the last item so we get everything (Particle, relations,
# decayVertices, etc...
o = '/'.join(f.Output.split('/')[:-1])
outputs.append(o)
print "Outputs are", outputs
mykiller = EventNodeKiller("killStripping")
# Some default nodes which we will want to kill in all cases
nodestokill = outputs + ['Strip', '/Event/Rec/Vertex/Primary']
mykiller.Nodes = nodestokill
deathstar = GaudiSequencer("killStrippingSeq")
deathstar.Members = [mykiller]
# Configure DaVinci
DaVinci().InputType = config.getProp('InputType')
DaVinci().DataType = config.getProp('DataType')
DaVinci().Simulation = config.getProp('Simulation')
DaVinci().DDDBtag = config.getProp('DDDBtag')
DaVinci().CondDBtag = config.getProp('CondDBtag')
try:
DaVinci().Persistency = config.getProp('Persistency')
except AttributeError:
print "DaVinci doesn't have a Persistency attribute to set"
# The sequence for the swimming has to be configured
# by hand inserting the node killer before it
DaVinci().appendToMainSequence([deathstar])
DaVinci().appendToMainSequence([sc.sequence()])
# Since the name of the output file is configured in two places in DaVinci,
# do some splitting.
splitName = config.getProp('OutputFile').split(os.path.extsep)
seqName = ''
prefix = ''
if len(splitName) <= 2:
seqName = splitName[0]
print "Warning, an output filename in three parts was specified. This does not work well, " + \
" so 'Swimming.' will be prefixed."
prefix = 'Swimming'
else:
prefix = splitName[0]
seqName = os.path.extsep.join(splitName[1:-1])
dstWriter = None
print config.getProp('OutputType')
# Offline candidate selection sequences
sequences = []
offCands = config.getProp('OffCands').keys()
for i, cands in enumerate(offCands):
data = AutomaticData(Location=cands + "/Particles")
offSeq = SelectionSequence("OfflineCandidates_%d" % i,
TopSelection=data)
sequences.append(offSeq)
# selection sequence for offline candidates
muCands = config.getProp('MuDSTCands')
for i, cands in enumerate(muCands):
# Add extra selections for additional MuDSTCands
data = AutomaticData(Location=cands + "/Particles")
seq = SelectionSequence("MuDSTCands_%d" % i, TopSelection=data)
sequences.append(seq)
selectionSeq = MultiSelectionSequence(seqName, Sequences=sequences)
if config.getProp('OutputType') == 'MDST':
pack = False
isMC = config.getProp("Simulation")
SwimmingConf = config.getProp('MicroDSTStreamConf')
SwimmingElements = config.getProp('MicroDSTElements')
if SwimmingConf == False:
from DSTWriters.Configuration import stripMicroDSTStreamConf
SwimmingConf = stripMicroDSTStreamConf(pack=pack, isMC=isMC)
if len(SwimmingElements) == 0:
from DSTWriters.Configuration import stripMicroDSTElements
from DSTWriters.microdstelements import CloneSwimmingReports, CloneParticleTrees, CloneTPRelations
mdstElements = stripMicroDSTElements(pack=pack, isMC=isMC)
SwimmingElements = [CloneSwimmingReports()]
for element in mdstElements:
SwimmingElements += [element]
if type(element) == CloneParticleTrees:
SwimmingElements += [CloneTPRelations("P2TPRelations")]
streamConf = {'default': SwimmingConf}
elementsConf = {'default': SwimmingElements}
try:
from DSTWriters.__dev__.Configuration import MicroDSTWriter
except:
from DSTWriters.Configuration import MicroDSTWriter
dstWriter = MicroDSTWriter('MicroDST',
StreamConf=streamConf,
MicroDSTElements=elementsConf,
WriteFSR=config.getProp('WriteFSR'),
OutputFileSuffix=prefix,
SelectionSequences=[selectionSeq])
elif config.getProp('OutputType') == 'DST':
try:
from DSTWriters.__dev__.streamconf import OutputStreamConf
from DSTWriters.__dev__.Configuration import SelDSTWriter
except ImportError:
from DSTWriters.streamconf import OutputStreamConf
from DSTWriters.Configuration import SelDSTWriter
streamConf = OutputStreamConf(streamType = InputCopyStream,
fileExtension = '.dst',
extraItems = [config.getProp('SwimmingPrefix') + '/Reports#1'] +\
list(set([l + '/P2TPRelations#1' for l in config.getProp('OffCands').values()])))
SelDSTWriterElements = {'default': []}
SelDSTWriterConf = {'default': streamConf}
dstWriter = SelDSTWriter('FullDST',
StreamConf=SelDSTWriterConf,
MicroDSTElements=SelDSTWriterElements,
WriteFSR=config.getProp('WriteFSR'),
OutputFileSuffix=prefix,
SelectionSequences=[selectionSeq])
DaVinci().appendToMainSequence([dstWriter.sequence()])
#Truth matching
matchpion = "(mcMatch('[^pi-]CC'))"
#matchpion = "ALL"
#######################################
# pions
_pions = DataOnDemand(Location='Phys/StdLoosePions')
_filter = FilterDesktop("filterPions", Code = matchpion)
_filter.Preambulo = [
"from LoKiPhysMC.decorators import *" ,
"from PartProp.Nodes import CC"
]
_selPions = Selection("SelFilterPions",
Algorithm = _filter,
RequiredSelections = [_pions])
_seqPions = SelectionSequence("SeqFilterPions", TopSelection = _selPions)
#######################################
# pions
_pions2 = DataOnDemand(Location='Phys/SmrdLoosePions')
_filter2 = FilterDesktop("filterPions", Code = matchpion)
_filter2.Preambulo = [
"from LoKiPhysMC.decorators import *" ,
"from PartProp.Nodes import CC"
]
_selPions2 = Selection("SelFilterPions2",
Algorithm = _filter2,
RequiredSelections = [_pions2])
_seqPions2 = SelectionSequence("SeqFilterPions2", TopSelection = _selPions2)
# Finish the selection
Phi2KK = Selection("SelPhi2KK",
Algorithm=_phi2kk,
RequiredSelections=[StdLooseKaons])
_bs2JpsiPhi = CombineParticles(
"Bs2JpsiPhi",
DecayDescriptor="B_s0 -> phi(1020) J/psi(1S)",
CombinationCut="ADAMASS('B_s0')<2*GeV",
MotherCut="(VFASPF(VCHI2/VDOF)<10) & (BPVIPCHI2()<100)")
Bs2JpsiPhi = Selection("SelBs2JpsiPhi",
Algorithm=_bs2JpsiPhi,
RequiredSelections=[Phi2KK, Jpsi2MuMu])
from PhysSelPython.Wrappers import SelectionSequence
SeqBs2JpsiPhi = SelectionSequence("SeqBs2JpsiPhi", TopSelection=Bs2JpsiPhi)
simulation = False
from DecayTreeTuple.Configuration import *
tuple = DecayTreeTuple()
tuple.Inputs = ["Phys/SelBs2JpsiPhi/Particles"]
tuple.Decay = "[B_s0 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^(phi(1020) -> ^K+ ^K-)]CC"
tuple.ToolList = []
tuple.UseLabXSyntax = True
tuple.RevertToPositiveID = False
LoKi_All = tuple.addTupleTool("LoKi::Hybrid::TupleTool/LoKi_All")
LoKi_All.Variables = {
"lokiP": "P",
"lokiPT": "PT",
tau_selection = Selection('SelTau2PhiMu', Algorithm = recoTau, RequiredSelections = [ looseMuons, phi_selection ])
# Select D
recoD = CombineParticles("D2PhiPi")
recoD.DecayDescriptor = '[D- -> phi(1020) pi-]cc'
recoD.DaughtersCuts = { "pi-" : " ( PT > 300 * MeV ) & ( BPVIPCHI2 () > 9 ) & ( TRCHI2DOF < 3 )& (TRGHOSTPROB<0.3)" }
recoD.CombinationCut = "(ADAMASS('tau-')<150*MeV)"
recoD.MotherCut = "( VFASPF(VCHI2) < 10 ) & ( (BPVLTIME () * c_light) > 200 * micrometer ) & ( BPVIPCHI2() < 100 ) "
D_selection = Selection('SelD2PhiPi', Algorithm = recoD, RequiredSelections = [ loosePions, phi_selection ])
tau_sequence = SelectionSequence('SeqTau2PhiMu',
TopSelection = tau_selection,
EventPreSelector = evtPreselectors)
D_sequence = SelectionSequence('SeqD2PhiPi',
TopSelection = D_selection,
EventPreSelector = evtPreselectors)
# ## Per i dati forse funziona:
# tau_stripped = AutomaticData(Location = location)
## #prescaler = DeterministicPrescaler("Prescaler", AcceptFraction = 1.0)
# tau_filter = FilterDesktop('tauFilter', Code = 'ALL')
# tau_selection = Selection('SelTau2PhiMu', Algorithm = tau_filter, RequiredSelections = [ tau_stripped ])
# tau_sequence = SelectionSequence('SeqTau2PhiMu',
# TopSelection = tau_selection)
from PhysSelPython.Wrappers import SelectionSequence
from PhysSelPython.Wrappers import DataOnDemand
# Stream and stripping line we want to use
tesLoc = '/Event/{0}/Phys/{1}/Particles'.format(stream, line)
# get the selection(s) created by the stripping
strippingSels = [DataOnDemand(Location=tesLoc)]
# create a selection using the substitution algorithm
selSub = Selection(
'KpforPip_sel',
Algorithm=subs,
RequiredSelections=strippingSels
)
selSeq = SelectionSequence('selSeq', TopSelection=selSub)
from Configurables import DecayTreeTuple
from DecayTreeTuple.Configuration import *
tuple=DecayTreeTuple("KpforPipTuple")
tuple.Decay="[B0 -> ^(K*(892)0 -> ^pi+ ^pi-) ^(eta_prime -> ^pi- ^pi+ ^gamma)]CC"
tuple.Branches={"B0":"[B0 -> (K*(892)0 -> pi+ pi-) (eta_prime -> pi- pi+ gamma)]CC"}
tuple.Inputs=[selSeq.outputLocation()]
tuple.ToolList += [
"TupleToolGeometry"
, "TupleToolDira"
, "TupleToolAngles"
, "TupleToolPid"
, "TupleToolKinematic"
def configure(datafiles, catalogs=[], params={}, castor=False):
"""
Configure the job
"""
from Configurables import DaVinci ## needed for job configuration
from Configurables import EventSelector ## needed for job configuration
from Configurables import MessageSvc
msg = MessageSvc()
msg.setError += [ 'HcalDet.Quality' ,
'EcalDet.Quality' ,
'MagneticFieldSvc' ,
'PropertyConfigSvc' ]
from PhysSelPython.Wrappers import AutomaticData
jpsi_location = 'FullDSTDiMuonJpsi2MuMuDetachedLine'
jpsi = AutomaticData(
Location='/Event/AllStreams/Phys/%s/Particles' % jpsi_location)
# =============================================================================
from StrippingSelections.StrippingPsiXForBandQ import PsiX_BQ_Conf as PsiX
## 1) redefine stripping configurations
def _psi_(self):
"""
psi(') -> mu+ mu-
"""
return jpsi
PsiX.psi = _psi_
logger.warning("Redefine PsiX .psi")
## 2) unify the pion& kaon selections
# =============================================================================
_PionCut_ = """
( CLONEDIST > 5000 ) &
( TRCHI2DOF < 4 ) &
( TRGHOSTPROB < 0.4 ) &
( PT > 200 * MeV ) &
in_range ( 2 , ETA , 4.9 ) &
in_range ( 3.2 * GeV , P , 150 * GeV ) &
HASRICH &
( PROBNNpi > 0.15 ) &
( MIPCHI2DV() > 9. )
"""
_KaonCut_ = """
( CLONEDIST > 5000 ) &
( TRCHI2DOF < 4 ) &
( TRGHOSTPROB < 0.4 ) &
( PT > 200 * MeV ) &
in_range ( 2 , ETA , 4.9 ) &
in_range ( 3.2 * GeV , P , 150 * GeV ) &
HASRICH &
( PROBNNk > 0.15 ) &
( MIPCHI2DV() > 9. )
"""
from GaudiConfUtils.ConfigurableGenerators import FilterDesktop
_alg_pi = FilterDesktop(
##
Code=_PionCut_,
##
)
from PhysSelPython.Wrappers import Selection
from StandardParticles import StdAllNoPIDsPions as input_pions
pions = Selection(
"SelPiForBQ",
Algorithm=_alg_pi,
RequiredSelections=[input_pions]
)
from GaudiConfUtils.ConfigurableGenerators import FilterDesktop
_alg_k = FilterDesktop(
##
Code=_KaonCut_,
##
)
from PhysSelPython.Wrappers import Selection
from StandardParticles import StdAllNoPIDsKaons as input_kaons
kaons = Selection(
"SelKForBQ",
Algorithm=_alg_k,
RequiredSelections=[input_kaons]
)
def _kaons_(self):
return kaons
def _pions_(self):
return pions
#
## get the selections
#
for s in [PsiX]:
s.pions = _pions_
s.kaons = _kaons_
logger.warning("Redefine PsiX.kaons ")
logger.warning("Redefine PsiX.kaons ")
psix = PsiX('PsiX', {})
for s in [psix.psi_3Kpi()]:
a = s.algorithm()
a.ParticleCombiners = {'': 'LoKi::VertexFitter:PUBLIC'}
from PhysSelPython.Wrappers import SelectionSequence
sel_seq = SelectionSequence('B2Psi3Kpi', psix . psi_3Kpi())
davinci = DaVinci(
InputType = 'DST' ,
Simulation = True ,
PrintFreq = 1000 ,
EvtMax = -1 ,
Lumi = True ,
DataType = params['Year'],
DDDBtag = params['DDDB'],
CondDBtag = params['SIMCOND'],
# HistogramFile = 'DVHistos.root' ,
TupleFile = 'DVNtuples.root' ,
)
my_name = "Bplus"
from Configurables import GaudiSequencer
davinci.UserAlgorithms = [ sel_seq.sequence() , my_name ]
setData ( datafiles , catalogs , castor )
gaudi = appMgr()
print 'seq.outputLocation()= ', sel_seq.outputLocation() # Phys/SelPsi3KPiForPsiX/Particles
# create local algorithm:
alg = MCAnalysisAlgorithm(
my_name,
Inputs = [
sel_seq.outputLocation()
] ,
PP2MCs = [ 'Relations/Rec/ProtoP/Charged' ]
)
return SUCCESS
]
makeBu= CombineParticles("makeBu",
Preambulo=preambulo,
DecayDescriptors = ['[B+ -> eta_prime pi+]cc'],
CombinationCut="(AM>3000.0) & (AM<10000.0) & (ACUTDOCA(0.04*mm,''))",
MotherCut ="(VFASPF(VCHI2/VDOF)<20.0)"
)
Bu_sel = Selection("Bu_sel",
Algorithm= makeBu,
RequiredSelections=[etap_selection,pion_Sel]
)
Bu_selSeq = SelectionSequence("Bu_selSeq",TopSelection=Bu_sel)
from Configurables import PrintDecayTree
pt= PrintDecayTree(Inputs=[Bu_selSeq.outputLocation()])
from Configurables import SubstitutePID
SubKToPi = SubstitutePID (name = "SubKToPi",
Code = "DECTREE('[(B+ -> eta_prime pi+),(B- -> eta_prime pi-)]')",
Substitutions = {
'B+ -> eta_prime ^pi+' : 'K+',
'B- -> eta_prime ^pi-' : 'K-',
}
)
BuK_Sel=Selection("BuK_Sel",Algorithm=SubKToPi,RequiredSelections=[Bu_sel])
def configure(datafiles,
catalogs=[],
castor=False,
params={}):
"""
Job configuration
"""
## needed for job configuration
from Configurables import DaVinci
the_year = "2011"
from BenderTools.Parser import hasInFile
if params:
the_year = params['Year']
logger.info('Year is set from params to be %s ' % the_year)
else:
if hasInFile(datafiles, 'Collision11'):
the_year = '2011'
elif hasInFile(datafiles, 'Collision12'):
the_year = '2012'
elif hasInFile(datafiles, 'Stripping17'):
the_year = '2011'
elif hasInFile(datafiles, 'Stripping13'):
the_year = '2011'
elif hasInFile(datafiles, 'Stripping15'):
the_year = '2011'
elif hasInFile(datafiles, 'Stripping19'):
the_year = '2012'
elif hasInFile(datafiles, 'Stripping20'):
the_year = '2012'
logger.info('Year is set from files to be %s ' % the_year)
#
# check
#
if '2011' == the_year and hasInFile(datafiles, 'Collision12'):
raise AttributeError, 'Invalid Year %s ' % the_year
if '2012' == the_year and hasInFile(datafiles, 'Collision11'):
raise AttributeError, 'Invalid Year %s ' % the_year
logger.info('Use the Year = %s ' % the_year)
#
Jpsi_location = '/Event/Dimuon/Phys/FullDSTDiMuonJpsi2MuMuDetachedLine/Particles'
#
# Read only fired events to speed up
from PhysConf.Filters import LoKi_Filters
fltrs = LoKi_Filters(
STRIP_Code="HLT_PASS_RE('Stripping.*DiMuonJpsi2MuMuDeta.*')",
VOID_Code="""
0.5 < CONTAINS('%s')
""" % Jpsi_location
)
#
# protection agains ``corrupted'' Stripping 17b DIMUON.DST
fltrs_0 = LoKi_Filters(
VOID_Code="""
( EXISTS ( '/Event/DAQ/RawEvent') | EXISTS('/Event/Trigger/RawEvent' ) )
& EXISTS ( '/Event/Strip/Phys/DecReports')
"""
)
davinci = DaVinci(
EventPreFilters=fltrs_0.filters(
'Filters0') + fltrs.filters('Filters'),
DataType=the_year,
InputType='DST',
Simulation=False,
PrintFreq=1000,
EvtMax=-1,
#
HistogramFile='Bcc1_Histos.root',
TupleFile='Bcc1.root',
#
Lumi=True,
#
)
from Configurables import CondDB
CondDB(LatestGlobalTagByDataType=the_year)
# ------- decoding set-up start ----------
## from BenderTools.MicroDST import uDstConf
## uDstConf ( rootInTES )
# ------- decoding set-up end -----------
#
# dimuon locations in DIMUON.DST
#
from PhysSelPython.Wrappers import AutomaticData
jpsi = AutomaticData(Location=Jpsi_location)
#
# get the prompt charm
#
from StrippingSelections.StrippingPromptCharm import StrippingPromptCharmConf as PC
#
# ======================================
pc = PC('PromptCharm', {
'TrackCuts' : """
( TRCHI2DOF < 4 ) &
( TRGHOSTPROB < 0.5 ) &
( PT > 250 * MeV ) &
in_range ( 2 , ETA , 5 )
""" ,
'KaonCuts': ' & in_range ( 3.2 * GeV , P , 100 * GeV ) & ( 2 < PIDK - PIDpi ) ',
'PionCuts': ' & in_range ( 3.2 * GeV , P , 100 * GeV ) & ( 0 < PIDpi - PIDK ) ',
}
)
pions = pc.pions()
kaons = pc.kaons()
Preambulo = [
# shortcut for chi2 of vertex fit
'chi2vx = VFASPF(VCHI2) ',
# shortcut for the c*tau
"from GaudiKernel.PhysicalConstants import c_light",
# use the embedded cut for chi2(LifetimeFit)<9 !!!
"ctau = BPVLTIME ( 9 ) * c_light " # ATTENTION, 9 is here!
]
from GaudiConfUtils.ConfigurableGenerators import CombineParticles
# ========================================================================
# B -> J/psi + K pi pi
# ========================================================================
from GaudiConfUtils.ConfigurableGenerators import CombineParticles
bc_Kpp = CombineParticles(
DecayDescriptor='[B+ -> J/psi(1S) K+ pi+ pi-]cc',
#
Preambulo=Preambulo,
DaughtersCuts={
"J/psi(1S)": " in_range( 3.096 * GeV - 45 * MeV , M , 3.096 * GeV + 45 * MeV ) "
},
#
CombinationCut="""
in_range ( 5.0 * GeV , AM , 5.6 * GeV )
""" ,
#
MotherCut="""
in_range ( 5.1 * GeV , M , 5.5 * GeV ) &
( PT > 1 * GeV ) &
( chi2vx < 49 ) &
in_range ( 150 * micrometer , ctau , 1000 * micrometer )
""" ,
#
ParticleCombiners={'': 'LoKi::VertexFitter'},
ReFitPVs=True
)
#
from PhysSelPython.Wrappers import Selection
Bc_Kpp = Selection(
'PsiKpp',
Algorithm=bc_Kpp,
RequiredSelections=[jpsi, pions, kaons]
)
# ========================================================================
# B -> J/psi + K
# ========================================================================
from GaudiConfUtils.ConfigurableGenerators import CombineParticles
bc_K = CombineParticles(
DecayDescriptor='[ B+ -> J/psi(1S) K+ ]cc',
#
Preambulo=Preambulo,
DaughtersCuts={
"J/psi(1S)": " in_range( 3.096 * GeV - 45 * MeV , M , 3.096 * GeV + 45 * MeV ) "
},
#
CombinationCut="""
in_range ( 5.0 * GeV , AM , 5.6 * GeV )
""" ,
#
MotherCut="""
in_range ( 5.1 * GeV , M , 5.5 * GeV ) &
( PT > 1 * GeV ) &
( chi2vx < 16 ) &
in_range ( 150 * micrometer , ctau , 1000 * micrometer )
""" ,
ParticleCombiners={'': 'LoKi::VertexFitter'},
ReFitPVs=True
)
#
Bc_K = Selection(
'PsiK',
Algorithm=bc_K,
RequiredSelections=[jpsi, kaons]
)
from PhysSelPython.Wrappers import SelectionSequence
Seq_Kpp = SelectionSequence("PSIKPP", TopSelection=Bc_Kpp)
Seq_K = SelectionSequence("PSIK", TopSelection=Bc_K)
from Configurables import GaudiSequencer
davinci.UserAlgorithms = [
GaudiSequencer(
'K', Members=[Seq_K .sequence(), 'B2PsiK']),
GaudiSequencer('KPP', Members=[Seq_Kpp.sequence(), 'B2PsiKpp'])
]
#
# come back to Bender
#
setData(datafiles, catalogs, castor)
#
# start Gaudi
#
gaudi = appMgr()
#
algKpp = B2Kpp(
'B2PsiKpp', # Algorithm name ,
Inputs=[Seq_Kpp.outputLocation()]
)
algK = B2K(
'B2PsiK', # Algorithm name ,
Inputs=[Seq_K .outputLocation()]
)
return SUCCESS
def execute(simulation=True,
turbo=True,
decay_descriptor="J/psi(1S) -> mu- mu+"):
# Configure all the unpacking, algorithms, tags and input files
appConf = ApplicationMgr()
appConf.ExtSvc+= ['ToolSvc', 'DataOnDemandSvc', LoKiSvc()]
ConfigTarFileAccessSvc().File = 'config.tar'
dv = DaVinci()
dv.DataType = "2012"
lhcbApp = LHCbApp()
lhcbApp.Simulation = simulation
CondDB().Upgrade = False
dtt = DecayTreeTuple("Early2015")
if turbo:
tesla_prefix = "Hlt2DiMuonJPsi"
dtt.Inputs = ["/Event/"+tesla_prefix+"/Particles"]
dtt.InputPrimaryVertices = "/Event/"+tesla_prefix+"/Primary"
dtt.WriteP2PVRelations = False
else:
LHCbApp().DDDBtag = "dddb-20140729"
polarity = "u"
LHCbApp().CondDBtag = "sim-20140730-vc-m%s100"%polarity
muons = AutomaticData(Location="Phys/StdAllLooseMuons/Particles")
jpsi = CombineParticles('MyJPsi')
jpsi.DecayDescriptors = [decay_descriptor]
jpsi.CombinationCut = "(AM < 7100.0 *GeV)"
jpsi.DaughtersCuts = {"": "ALL", "mu+": "ALL", "mu-": "ALL"}
jpsi.MotherCut = "(VFASPF(VCHI2/VDOF) < 999999.0)"
code = """
('J/psi(1S)' == ID) &
in_range(2.990*GeV, M, 3.210*GeV) &
DECTREE('%s') &
CHILDCUT(1, HASMUON & ISMUON) &
CHILDCUT(2, HASMUON & ISMUON) &
(MINTREE('mu+' == ABSID, PT) > 700*MeV) &
(MAXTREE(ISBASIC & HASTRACK, TRCHI2DOF) < 5) &
(MINTREE(ISBASIC & HASTRACK, CLONEDIST) > 5000) &
(VFASPF(VPCHI2) > 0.5/100) &
(abs(BPV(VZ)) < 0.5*meter) &
(BPV(vrho2) < (10*mm)**2)
"""%(decay_descriptor)
# similar to the HLT2 line
code = """
(ADMASS('J/psi(1S)')< 120*MeV) &
DECTREE('%s') &
(PT>0*MeV) &
(MAXTREE('mu-'==ABSID,TRCHI2DOF) < 4) &
(MINTREE('mu-'==ABSID,PT)> 0*MeV) &
(VFASPF(VCHI2PDOF)< 25)
"""%(decay_descriptor)
filter_jpsi = FilterDesktop("MyFilterJPsi",
Code=code,
Preambulo=["vrho2 = VX**2 + VY**2"],
ReFitPVs=True,
#IgnoreP2PVFromInputLocations=True,
#WriteP2PVRelations=True
)
jpsi_sel = Selection("SelMyJPsi", Algorithm=jpsi, RequiredSelections=[muons])
filter_jpsi_sel = Selection("SelFilterMyJPsi",
Algorithm=filter_jpsi,
RequiredSelections=[jpsi_sel])
jpsi_seq = SelectionSequence("SeqMyJPsi", TopSelection=filter_jpsi_sel)
dtt.Inputs = [jpsi_seq.outputLocation()]
# Overwriting default list of TupleTools
dtt.ToolList = ["TupleToolKinematic",
"TupleToolPid",
"TupleToolEventInfo",
"TupleToolMCBackgroundInfo",
"TupleToolMCTruth",
#"MCTupleToolHierarchy",
#"MCTupleToolPID",
"TupleToolGeometry",
"TupleToolTISTOS",
# with turbo this crashes
#"TupleToolTrackInfo",
"TupleToolTrigger",
]
tlist = ["L0HadronDecision", "L0MuonDecision",
"L0DiMuonDecision", "L0ElectronDecision",
"L0PhotonDecision",
"Hlt1DiMuonHighMassDecision", "Hlt1DiMuonLowMassDecision",
"Hlt1TrackMuonDecision", "Hlt1TrackAllL0Decision",
"Hlt2DiMuonJPsiDecision", "Hlt2SingleMuonDecision",
]
dtt.addTool(TupleToolTrigger, name="TupleToolTrigger")
dtt.addTool(TupleToolTISTOS, name="TupleToolTISTOS")
# Get trigger info
dtt.TupleToolTrigger.Verbose = True
dtt.TupleToolTrigger.TriggerList = tlist
dtt.TupleToolTISTOS.Verbose = True
dtt.TupleToolTISTOS.TriggerList = tlist
from Configurables import TupleToolMCTruth, MCTupleToolHierarchy
dtt.addTool(TupleToolMCBackgroundInfo,
name="TupleToolMCBackgroundInfo")
dtt.TupleToolMCBackgroundInfo.Verbose = True
dtt.addTool(MCTupleToolHierarchy,
name="MCTupleToolHierarchy")
dtt.MCTupleToolHierarchy.Verbose = True
dtt.addTool(TupleToolMCTruth,
name="TupleToolMCTruth")
dtt.TupleToolMCTruth.Verbose = True
if turbo:
assoc_seq = TeslaTruthUtils.associateSequence(tesla_prefix, False)
ChargedPP2MC(tesla_prefix+"ProtoAssocPP").OutputLevel = 1
assoc_seq.Members.insert(0, PatLHCbID2MCParticle())
from Configurables import MuonCoord2MCParticleLink
muon_coords = MuonCoord2MCParticleLink("TeslaMuonCoordLinker")
assoc_seq.Members.insert(1, muon_coords)
TrackAssociator("TeslaAssocTr").DecideUsingMuons = True
relations = TeslaTruthUtils.getRelLoc(tesla_prefix)
else:
relations = "Relations/Rec/ProtoP/Charged"
TeslaTruthUtils.makeTruth(dtt,
relations,
["MCTupleToolKinematic",
"MCTupleToolHierarchy",
"MCTupleToolPID",
]
)
dtt.Decay = mark(2, mark(3, decay_descriptor)) #"J/psi(1S) -> ^mu- ^mu+"
dtt.addBranches({"X": "^(%s)"%(decay_descriptor),
"muplus": mark(3, decay_descriptor),#"J/psi(1S) -> mu- ^mu+",
"muminus": mark(2, decay_descriptor),#"J/psi(1S) -> ^mu- mu+",
})
x_preamble = ["DZ = VFASPF(VZ) - BPV(VZ)",
]
x_vars = {"ETA": "ETA",
"Y": "Y",
"PHI": "PHI",
"VPCHI2": "VFASPF(VPCHI2)",
"DELTAZ": "DZ",
# DZ * M / PZ / c with c in units of mm/s
# XXX should this be the PDG mass or measured mass?
#"TZ": "DZ*M / PZ / 299792458000.0", #seconds
"TZ": "DZ*3096.916 / PZ/299792458000.0*(10**12)", #ps
"minpt": "MINTREE('mu+' == ABSID, PT)",
"minclonedist": "MINTREE(ISBASIC & HASTRACK, CLONEDIST)",
"maxtrchi2dof": "MAXTREE(ISBASIC & HASTRACK, TRCHI2DOF)",
}
muon_vars = {"ETA": "ETA",
"Y": "Y",
"PHI": "PHI",
"CHARGE": "Q",
"CLONEDIST": "CLONEDIST",
"TRCHI2DOF": "TRCHI2DOF",
}
loki_X = dtt.X.addTupleTool("LoKi::Hybrid::TupleTool/LoKi_X")
loki_X.Variables = x_vars
loki_X.Preambulo = x_preamble
loki_mup = dtt.muplus.addTupleTool("LoKi::Hybrid::TupleTool/LoKi_MuPlus")
loki_mup.Variables = muon_vars
#dtt.muplus.addTupleTool("TupleToolGeometry")
loki_mum = dtt.muminus.addTupleTool("LoKi::Hybrid::TupleTool/LoKi_MuMinus")
loki_mum.Variables = muon_vars
#dtt.muminus.addTupleTool("TupleToolGeometry")
dv.TupleFile = "DVNtuples.root"
if turbo:
dv.UserAlgorithms = [assoc_seq, dtt]
else:
assocpp = ChargedPP2MC("TimsChargedPP2MC")
assocpp.OutputLevel = 1
dv.UserAlgorithms = [jpsi_seq.sequence(), assocpp, dtt]
def configure(datafiles,
catalogs=[],
castor=False,
params={}):
"""
Job configuration
"""
## needed for job configuration
from Configurables import DaVinci
the_year = "2011"
from BenderTools.Parser import hasInFile
if params:
the_year = params['Year']
logger.info('Year is set from params to be %s ' % the_year)
else:
if hasInFile(datafiles, 'Collision11'):
the_year = '2011'
elif hasInFile(datafiles, 'Collision12'):
the_year = '2012'
elif hasInFile(datafiles, 'Collision13'):
the_year = '2013'
elif hasInFile(datafiles, 'Stripping17'):
the_year = '2011'
elif hasInFile(datafiles, 'Stripping13'):
the_year = '2011'
elif hasInFile(datafiles, 'Stripping15'):
the_year = '2011'
elif hasInFile(datafiles, 'Stripping19'):
the_year = '2012'
elif hasInFile(datafiles, 'Stripping20r1'):
the_year = '2011'
elif hasInFile(datafiles, 'Stripping20r1p1'):
the_year = '2011'
elif hasInFile(datafiles, 'Stripping20r0p1'):
the_year = '2012'
elif hasInFile(datafiles, 'MC11'):
the_year = '2011'
logger.info('Year is set from files to be %s ' % the_year)
#
# check
#
if '2011' == the_year and hasInFile(datafiles, 'Collision12'):
raise AttributeError, 'Invalid Year %s ' % the_year
if '2012' == the_year and hasInFile(datafiles, 'Collision11'):
raise AttributeError, 'Invalid Year %s ' % the_year
logger.info('Use the Year = %s ' % the_year)
W_Location = '/Event/AllStreams/Phys/WMuLine/Particles'
from PhysSelPython.Wrappers import AutomaticData
W_Strip = AutomaticData(Location=W_Location)
EW_preambulo = [
"pion_cuts = in_range ( 300 * MeV , PT , 10 * GeV ) & ( CLONEDIST > 5000 ) & ( TRCHI2DOF < 5 ) & ( TRGHOSTPROB < 0.5 ) & ( PERR2/P2 < 0.05**2 ) ",
"ptCone_ = SUMCONE ( 0.25 , PT , '/Event/Phys/StdAllLoosePions/Particles' )",
"ptCone_2 = SUMCONE ( 0.25 , PT , '/Event/Phys/StdAllLoosePions/Particles' , pion_cuts )",
"etCone_ = SUMCONE ( 0.25 , PT , '/Event/Phys/StdLooseAllPhotons/Particles' )",
"ptCone = SINFO ( 55001 , ptCone_ , True ) ",
"ptCone2 = SINFO ( 55003 , ptCone_2 , True ) ",
"etCone = SINFO ( 55002 , etCone_ , True ) ",
]
# ========================================================================
# good W
# ========================================================================
from GaudiConfUtils.ConfigurableGenerators import FilterDesktop
gW = FilterDesktop(
Preambulo=EW_preambulo,
Code="""
in_range ( 15 * GeV , PT , 100 * GeV ) &
( -1e+10 * GeV < ptCone ) &
( -1e+10 * GeV < ptCone2 ) &
( -1e+10 * GeV < etCone )
"""
)
from PhysSelPython.Wrappers import Selection
W_Data = Selection(
'W',
Algorithm=gW,
RequiredSelections=[W_Strip]
)
from PhysSelPython.Wrappers import SelectionSequence
seq = SelectionSequence("Wseq", TopSelection=W_Data)
# counters
from Configurables import LoKi__CounterAlg as CounterAlg
cnt = CounterAlg(
'CharmEWCounters',
Location="Counters/CharmEW",
Preambulo=[
"from LoKiPhys.decorators import *",
"from LoKiCore.functions import *",
"pion_cuts = in_range ( 300 * MeV , PT , 120 * GeV ) & ( CLONEDIST > 5000 ) & ( TRCHI2DOF < 5 ) ",
"gamma_cuts = in_range ( 300 * MeV , PT , 10 * GeV ) ",
"pions = SOURCE ( '/Event/Phys/StdAllNoPIDsPions/Particles' , pion_cuts ) ",
"gammas = SOURCE ( '/Event/Phys/StdLooseAllPhotons/Particles' , gamma_cuts ) ",
],
Variables={
"px_c": " pions >> sum ( PX ) ",
"py_c": " pions >> sum ( PY ) ",
"px_g": " gammas >> sum ( PX ) ",
"py_g": " gammas >> sum ( PY ) ",
"n_c": " pions >> SIZE ",
"g_c": " gammas >> SIZE ",
}
)
from Configurables import DataOnDemandSvc
dod = DataOnDemandSvc()
dod.AlgMap['/Event/Counters/CharmEW'] = cnt
# ========================================================================
# prefilters for drastical speedup in the reading of input data
# ========================================================================
from PhysConf.Filters import LoKi_Filters
fltrs = LoKi_Filters(
STRIP_Code=" HLT_PASS_RE ( 'Stripping.*WMuLine.*Decision' ) "
)
davinci = DaVinci(
EventPreFilters=fltrs.filters('Filters'), # PREFILTERS
DataType=the_year,
InputType='DST',
Simulation=True,
PrintFreq=10000,
EvtMax=-1,
#
HistogramFile='MCW_Histos.root',
TupleFile='MCW.root',
#
)
# connect to DaVinci
from Configurables import GaudiSequencer
davinci.UserAlgorithms = [
GaudiSequencer('MySeq', Members=[seq.sequence(), 'MCW'])
]
#
# take care abotu DB-tags:
#
# try to get the tags from Rec/Header
from BenderTools.GetDBtags import getDBTags
tags = getDBTags(
datafiles[0],
castor
)
logger.info('Extract tags from DATA : %s' % tags)
if tags.has_key('DDDB') and tags['DDDB']:
davinci.DDDBtag = tags['DDDB']
logger.info('Set DDDB %s ' % davinci.DDDBtag)
if tags.has_key('CONDDB') and tags['CONDDB']:
davinci.CondDBtag = tags['CONDDB']
logger.info('Set CONDDB %s ' % davinci.CondDBtag)
if tags.has_key('SIMCOND') and tags['SIMCOND']:
davinci.CondDBtag = tags['SIMCOND']
logger.info('Set SIMCOND %s ' % davinci.CondDBtag)
#
# remove excessive printout
#
from Configurables import MessageSvc
msg = MessageSvc()
msg.setError += ['HcalDet.Quality',
'EcalDet.Quality',
'MagneticFieldSvc',
'PropertyConfigSvc',
'ToolSvc.L0DUConfig',
'ToolSvc.L0CondDBProvider',
'L0MuonFromRaw',
'IntegrateBeamCrossing']
#
# come back to Bender
#
setData(datafiles, catalogs, castor)
#
# start Gaudi
#
gaudi = appMgr()
#
# more silence
#
_a = gaudi.tool('ToolSvc.L0DUConfig')
_a.OutputLevel = 4
alg = MCW(
'MCW',
Inputs=[seq.outputLocation()],
PP2MCs=['Relations/Rec/ProtoP/Charged']
)
return SUCCESS
dz=DataOnDemand(turbo_loc.format(dz_line))
pions = DataOnDemand('Phys/StdAllNoPIDsPions/Particles')
dst = CombineParticles('DstToD0pi',
DecayDescriptors=['[D*(2010)+ -> D0 pi+]cc'],
CombinationCut=("AM - ACHILD(M,1) < 800*MeV"),
MotherCut="(VFASPF(VCHI2/VDOF) < 6)")
dst_sel = Selection(
'Sel_DstToD0pi',
Algorithm=dst,
RequiredSelections=[dz, pions]
)
dst_selseq = SelectionSequence(
'SelSeq_DstToD0pi',
TopSelection=dst_sel
)
dtt_dst = DecayTreeTuple('TupleDstToD0pi_D0ToKpi_PersistReco')
dtt_dst.addTupleTool('TupleToolTrackInfo')
dtt_dst.Inputs = dst_selseq.outputLocations()
dtt_dst.Decay = '[D*(2010)+ -> ^(D0 -> ^K- ^pi+) ^pi+]CC'
dtt_dst.addBranches({
'Dst': '[D*(2010)+ -> (D0 -> K- pi+) pi+]CC',
'Dst_pi': '[D*(2010)+ -> (D0 -> K- pi+) ^pi+]CC',
'D0': '[D*(2010)+ -> ^(D0 -> K- pi+) pi+]CC',
'D0_K': '[D*(2010)+ -> (D0 -> ^K- pi+) pi+]CC',
'D0_pi': '[D*(2010)+ -> (D0 -> K- ^pi+) pi+]CC',
})
dstar_hybrid = dtt_dst.Dst.addTupleTool('LoKi::Hybrid::TupleTool/LoKi_Dstar')
_selDimuons= Selection( "_selDimuons", Algorithm = _filterDimuons, RequiredSelections = [bothstripping] )
from Configurables import SubstitutePID
subalg = SubstitutePID("_B2Jpsi_SubPID", Code="(DECTREE('B0 -> mu+ mu-'))",
Substitutions={'B0 -> mu+ mu-' : 'J/psi(1S)'}, MaxChi2PerDoF=-666)
subsel = Selection("subsel",Algorithm = subalg, RequiredSelections = [_selDimuons])
# Try and make B->J/psi K
_B = CombineParticles()
_B.DaughtersCuts = { "K+" : "(PT>500*MeV)&(MIPCHI2DV(PRIMARY) > 9)" }
_B.MotherCut = "(DMASS('B+')<5000*MeV) & (VFASPF(VCHI2)/VFASPF(VDOF)<5.0) & (BPVDIRA > 0.999)" #need to check these cuts
_B.DecayDescriptors = [ "[B+ -> J/psi(1S) K+]cc" ]
_BdecaySelection = Selection( "TurboB", Algorithm = _B, RequiredSelections = [subsel,kaons] )
SeqB = SelectionSequence('SeqB', TopSelection = _BdecaySelection)
# Here we just put the output candidates in an Tuple
tupleB = DecayTreeTuple("bae-muon-data")
tupleB.Inputs = [SeqB.outputLocation()]
tupleB.Decay = "[B+ -> ^K+ ^(J/psi(1S) -> ^mu+ ^mu-)]CC"
tupleB.ToolList = [
"TupleToolKinematic"
, "TupleToolEventInfo"
, "TupleToolRecoStats"
, "TupleToolTrigger",
"TupleToolPid",
"TupleToolPrimaries",
#
from PhysSelPython.Wrappers import Selection, DataOnDemand
from PhysSelPython.Wrappers import MergedSelection
from PhysSelPython.Wrappers import SelectionSequence
muons = DataOnDemand('Phys/StdLooseMuons')
jPsiSel = Selection("jPsiSel", Algorithm=JPsi, RequiredSelections=[muons])
mumuSel = Selection("mumuSel", Algorithm=MuMu, RequiredSelections=[muons])
jPsiNBSel = Selection("jPsiNBSel",
Algorithm=jPsiNB,
RequiredSelections=[jPsiSel])
mumuNBSel = Selection("mumuNBSel",
Algorithm=mumuNB,
RequiredSelections=[mumuSel])
SelSeqJPsi = SelectionSequence("SeqJPsi", TopSelection=jPsiNBSel)
SelSeqMuMu = SelectionSequence("SeqMuMu", TopSelection=mumuNBSel)
SelSeqMuMuAll = SelectionSequence("SeqMuMuAll", TopSelection=mumuSel)
SeqJPsi = SelSeqJPsi.sequence()
SeqMuMu = SelSeqMuMu.sequence()
SeqMuMuAll = SelSeqMuMuAll.sequence()
########################################################################
#
# NTupling
#
from Configurables import DecayTreeTuple
tupleMuMu = DecayTreeTuple("tupleMuMu")
tupleMuMu.InputLocations = [SelSeqMuMu.outputLocation()]
d0 = CombineParticles('Combine_D0',
DecayDescriptor='[D0 -> pi- K+]cc',
DaughtersCuts=d0_daughters,
CombinationCut=d0_comb,
MotherCut=d0_mother)
d0_sel = Selection('Sel_D0',
Algorithm=d0,
RequiredSelections=[Pions, Kaons])
dstar_daughters = {'pi+': '(TRCHI2DOF < 3) & (PT > 100*MeV)'}
dstar_comb = "(ADAMASS('D*(2010)+') < 400*MeV)"
dstar_mother = (
"(abs(M-MAXTREE('D0'==ABSID,M)-145.42) < 10*MeV)"
'& (VFASPF(VCHI2/VDOF)< 9)'
)
dstar_sel = SimpleSelection(
'Sel_Dstar',
ConfigurableGenerators.CombineParticles,
[d0_sel, Pions],
DecayDescriptor='[D*(2010)+ -> D0 pi+]cc',
DaughtersCuts=dstar_daughters,
CombinationCut=dstar_comb,
MotherCut=dstar_mother
)
dstar_seq = SelectionSequence('Dstar_Seq', TopSelection=dstar_sel)
DaVinci().UserAlgorithms += [dstar_seq.sequence()]
ReFitPVs = True )
#---- Refit vertices with Jpsi mass constraint----------------
#_Lb2JpsipK.addTool( OfflineVertexFitter() )
#_Lb2JpsipK.VertexFitters.update( { "" : "OfflineVertexFitter"} )
#_Lb2JpsipK.OfflineVertexFitter.applyDauMassConstraint = True
Lb2JpsiS = Selection( "Lb2JpsiS",
Algorithm = _Lb2JpsiS ,
RequiredSelections = [ Jpsi2MuMu, S2L0g, FilterL ] )
### Gaudi sequence
SeqLb2JpsiS = SelectionSequence("SeqLb2JpsiS", TopSelection = Lb2JpsiS)
seq = SeqLb2JpsiS.sequence()
#--------------------------------------------------------------------------
# Configure DaVinci
#-------------------------------------------------------------------------
from Configurables import DaVinci
from Configurables import OfflineVertexFitter
from Configurables import DecayTreeTuple, MCDecayTreeTuple
importOptions("Xb2JpsiXTree.py")
tuple = DecayTreeTuple( "Lb2JpsiSTree" )
tuple.Inputs = [ SeqLb2JpsiS.outputLocation() ]
KsPiPi= CombineParticles("KsPiPi")
KsPiPi.DecayDescriptor = "KS0 -> pi+ pi-"
KsPiPi.CombinationCut = "ADAMASS('KS0')<100*MeV"
KsPiPi.MotherCut = "(VFASPF(VCHI2/VDOF)<10)"
KsPiPi.DaughtersCuts = { "pi+" : "ALL",
"pi-" : "ALL" }
KsPiPi.MotherCut = "(M > 400) & (M < 600) & (BPVVDCHI2 > 100.) & (VFASPF(VCHI2/VDOF) < 10)"
from PhysSelPython.Wrappers import Selection
from StandardParticles import StdNoPIDsDownPions, StdLoosePions
LooseKsPiPi = Selection("SelLooseKsPiPi",
Algorithm = KsPiPi,
RequiredSelections = [StdNoPIDsDownPions ])
#RequiredSelections = [StdLoosePions])
from PhysSelPython.Wrappers import SelectionSequence
SeqKsPiPi = SelectionSequence('SeqKsPiPi', TopSelection = LooseKsPiPi)
KsPiPiTuple = DecayTreeTuple("KsPiPiTuple")
# input locations
KsPiPiTuple.Inputs = [ LooseKsPiPi.outputLocation() ]
# decay descriptors
KsPiPiTuple.Decay = "KS0 -> ^pi+ ^pi-"
# define the tools and configure them
KsPiPiTuple.ToolList = [
"TupleToolKinematic"
,"TupleToolGeometry"
,"TupleToolPid"
,"TupleToolANNPID"
#,"TupleToolTrackInfo"
,"TupleToolRecoStats"
from Configurables import DaVinci, FilterDesktop, DecayTreeTuple
from PhysSelPython.Wrappers import Selection, SelectionSequence, TupleSelection
import StandardParticles
alg = FilterDesktop('pions')
alg.Code = 'ALL'
sel = Selection('pions_sel',
Algorithm=alg,
RequiredSelections=[StandardParticles.StdAllNoPIDsPions])
tuplesel = TupleSelection('pions_tuple_sel',
Decay='[pi+]cc',
RequiredSelection=sel)
selseq = SelectionSequence('pions_seq', TopSelection=tuplesel)
DaVinci().UserAlgorithms.append(selseq.sequence())
DaVinci().TupleFile = 'DVTuples.root'
recPF.EcalBest = True
recPF.SprRecover = False
recPF.TrkLnErrMax = 10
recPF.TrkUpErrMax = 10
recPF.TrkDnErrMax = 10
recJB = HltJetBuilder('recJB')
recJB.JetEcPath = ''
recJB.Inputs = [recPF.Output]
recJB.Output = 'Phys/JB/Particles'
recJB.JetPtMin = JetPtMin
from commonSelections import *
from PhysSelPython.Wrappers import SelectionSequence
recSVs_seq = SelectionSequence('recSVs_Seq', TopSelection=recSVs)
recMus_seq = SelectionSequence('recMus_Seq', TopSelection=recMus)
Jpsi_seq = SelectionSequence('Jpsi_Seq', TopSelection=recJpsi)
D0_seq = SelectionSequence('D0_Seq', TopSelection=recD0)
Dp_seq = SelectionSequence('Dp_Seq', TopSelection=recDp)
Ds_seq = SelectionSequence('Ds_Seq', TopSelection=recDs)
Lc_seq = SelectionSequence('Lc_Seq', TopSelection=recLc)
D02K3pi_seq = SelectionSequence('D2K3pi0_Seq', TopSelection=recD02K3pi)
##########################
# Turbo/DaVinci configuration.
from Configurables import DstConf, TurboConf, DaVinci
DaVinci().Simulation = False
def configure ( inputdata , ## the list of input files
catalogs = [] , ## xml-catalogs (filled by GRID)
castor = False , ## use the direct access to castor/EOS ?
params = {} ) :
## configure Track <--> MC relation table
import LoKiPhysMC.Track2MC_Configuration
import LoKiMC.MC
## import DaVinci
from Configurables import DaVinci, GaudiSequencer
## delegate the actual configurtaion to DaVinci
dv = DaVinci ( DataType = '2011' ,
InputType = 'MDST',
Lumi = True,
Simulation = True,
DDDBtag="MC11-20111102",
CondDBtag="sim-20111111-vc-md100",
HistogramFile = "mcd02kpi_tracks7_histo.root",
TupleFile = "mcd02kpi_tracks7_ntuple.root",
PrintFreq = 1000)
from Configurables import DecayTreeTuple, FilterDesktop, TupleToolGeometry, CombineParticles
from Configurables import MCDecayTreeTuple, TupleToolMCTruth, MCTupleToolHierarchy
from PhysSelPython.Wrappers import AutomaticData, Selection, SelectionSequence, DataOnDemand
from Configurables import CheckPV
# First using CombineParticle to create the D0
################################################################################
#from StandardParticles import StdAllNoPIDsPions, StdAllNoPIDsKaons
_pions = DataOnDemand(Location='Phys/StdAllNoPIDsPions/Particles')
_kaons = DataOnDemand(Location='Phys/StdAllNoPIDsKaons/Particles')
_d2kpi = CombineParticles("d2kpi")
_d2kpi.DecayDescriptor = "[D0 -> K- pi+]cc"
_d2kpi.DaughtersCuts = { "K-" : "(PT > 500.0) & (0.0 < PIDK)",
"pi+" : "(PT > 500.0) & (5.0 > PIDK)",
"K+" : "(PT > 500.0) & (0.0 < PIDK)",
"pi-" : "(PT > 500.0) & (5.0 > PIDK) " }
_d2kpi.MotherCut = "(VFASPF(VCHI2/VDOF)<10)"
_d2kpi.CombinationCut = "(ADAMASS('D0') < 50.0)"
_d2kpi.Preambulo = [
"from LoKiPhysMC.decorators import *" ,
"from PartProp.Nodes import CC" ]
#_d2kpi.ReFitPVs = True
SelD2KPi = Selection( "SelD2KPi",
Algorithm= _d2kpi,
RequiredSelections=[_pions,_kaons] )
SeqD2KPi = SelectionSequence('SeqD2KPi',TopSelection = SelD2KPi)
# Now the CheckPV method to filter algorithms
c = CheckPV("OnePV")
c.MinPVs = 1
# And a sequencer to put them together
gseq = GaudiSequencer()
gseq.Members = [ c, SeqD2KPi.sequence() ]
## define the input data
setData ( inputdata , catalogs , castor )
## get/create application manager
gaudi = appMgr()
#
## modify/update the configuration:
#
## (1) create the algorithm
alg = TrackFilter( 'TrackFilter' )
#seq = createSequencer()
## (2) replace the list of top level algorithm by
# new list, which contains only *THIS* algorithm
gaudi.setAlgorithms( [ gseq, alg ] )
return SUCCESS
# #----Selection /\b -> J/psi /\-------------------
# _Lb2JpsiL = CombineParticles( "_Lb2JpsiL",
# DecayDescriptor = "[Lambda_b0 -> J/psi(1S) Lambda0]cc",
# CombinationCut = "AM < 6000. * MeV",
#
# ReFitPVs = True )
# Lb2JpsiL = Selection( "Lb2JpsiL",
# Algorithm = _Lb2JpsiL ,
# RequiredSelections = [ Jpsi2MuMu, FilterL ] )
### Gaudi sequence
# SeqL2ppi = SelectionSequence("SeqL2ppi", TopSelection = L2ppi)
# seq = SeqL2ppi.sequence()
SeqFilterL = SelectionSequence("SeqFilterL", TopSelection = FilterL)
seq = SeqFilterL.sequence()
#--------------------------------------------------------------------------
# Configure DaVinci
#-------------------------------------------------------------------------
from Configurables import DaVinci
# DaVinci().appendToMainSequence( [sc.sequence() ] ) # Append the stripping selection sequence to DaVinci
from Configurables import OfflineVertexFitter
from Configurables import DecayTreeTuple, MCDecayTreeTuple
importOptions("Xb2JpsiXTreeMC.py")
from StandardParticles import StdLoosePions, StdLooseKsLL, StdLooseKsDD
from Configurables import FilterDesktop, CombineParticles
from DecayTreeTuple.Configuration import *
from GaudiKernel.SystemOfUnits import MeV, GeV, mrad, picosecond
location = "/Event/Charm/Phys/PhiToKSKS_JPsiToKsKsLine/Particles"
JPsiSel = DataOnDemand(Location=location)
jpsiFilter = FilterDesktop("jpsiFilter", Code="PT > 400")
JPsiFilterSel = Selection(name="jpsiFilterSel", Algorithm=jpsiFilter, RequiredSelections=[JPsiSel])
seq = SelectionSequence("Seq", TopSelection=JPsiFilterSel)
# This filter is used just to speed up the process, nothing happens if there
# # is no stripped candidates at that location.
# from PhysConf.Filters import LoKi_Filters
# fltrs = LoKi_Filters(
# STRIP_Code = "HLT_PASS('StrippingPhiToKSKS_PhiToKsKsLineDecision')")
from Configurables import (
FitDecayTrees,
DecayTreeTuple,
TupleToolDecayTreeFitter,
TupleToolDecay,
TupleToolTrigger,
def configure(datafiles, catalogs=[], params={}, castor=False):
"""
Configure the job
"""
from Configurables import DaVinci ## needed for job configuration
## get the builder
from StrippingSelections.StrippingPsiXForBandQ import PsiX_BQ_Conf as PSIX
## for MC it is better to exclude PID/DLL/PROBNN cuts
builder_configuration = {
# 'PionCut' : """
# ( PT > 200 * MeV ) &
'PionCut' : """
( CLONEDIST > 5000 ) &
"""
# ( TRGHOSTPROB < 0.5 ) &
# ( TRCHI2DOF < 4 ) &
# in_range ( 2 , ETA , 5 ) &
# in_range ( 3.2 * GeV , P , 150 * GeV ) &
# HASRICH &
# ( PROBNNpi > 0.1 )
#( MIPCHI2DV() > 4 )
,
# ( PT > 200 * MeV ) &
'KaonCut' : """
( CLONEDIST > 5000 ) &
( TRGHOSTPROB < 0.5 ) &
( TRCHI2DOF < 4 ) &
in_range ( 2 , ETA , 5 ) &
in_range ( 3.2 * GeV , P , 150 * GeV ) &
HASRICH &
( PROBNNk > 0.1 )
"""
# ( MIPCHI2DV() > 4 )
}
def _kaons_ ( self ) :
"""
Kaons for B -> psi X lines
"""
from GaudiConfUtils.ConfigurableGenerators import FilterDesktop
## from StandardParticles import StdAllLooseKaons as inpts
from StandardParticles import StdNoPIDsKaons as inpts
##
return self.make_selection (
'Kaon' ,
FilterDesktop ,
[ inpts ] ,
Code = self['KaonCut'] ,
)
def _pions_ ( self ) :
"""
Pions for B -> psi X lines
"""
from GaudiConfUtils.ConfigurableGenerators import FilterDesktop
## from StandardParticles import StdAllLoosePions as inpts
from StandardParticles import StdNoPIDsPions as inpts
##
return self.make_selection (
'Pion' ,
FilterDesktop ,
[ inpts ] ,
Code = self['PionCut'] ,
)
jpsi_name = 'FullDSTDiMuonJpsi2MuMuDetachedLine'
psi2_name = 'FullDSTDiMuonPsi2MuMuDetachedLine'
from PhysSelPython.Wrappers import AutomaticData
jpsi = AutomaticData ( '/Event/AllStreams/Phys/%s/Particles' % jpsi_name )
psi2s = AutomaticData ( '/Event/AllStreams/Phys/%s/Particles' % psi2_name )
#
## merged selectoon for J/psi & psi'
#
from PhysSelPython.Wrappers import MergedSelection
psis = MergedSelection (
'SelDetachedPsisForBandQ' ,
RequiredSelections = [ jpsi ]
)
def _psi_ ( self ) :
"""
psi(') -> mu+ mu-
"""
return psis
PSIX.pions = _pions_
PSIX.kaons = _kaons_
PSIX.psi = _psi_
## use builder
builder = PSIX ( 'PsiX' , builder_configuration )
from PhysSelPython.Wrappers import SelectionSequence
psi3k = SelectionSequence ( 'Psi3K' , builder.psi_3K () )
psi3kpi = SelectionSequence ( 'Psi3Kpi' , builder.psi_3Kpi () )
from PhysConf.Filters import LoKi_Filters
fltrs = LoKi_Filters (
STRIP_Code = """
HLT_PASS_RE('Stripping.*FullDSTDiMuonJpsi2MuMuDetachedLine.*')
"""
)
davinci = DaVinci(
EventPreFilters = fltrs.filters('WG'),
InputType = 'DST' ,
Simulation = True ,
PrintFreq = 1000 ,
EvtMax = -1 ,
Lumi = True ,
DataType = params['Year'],
DDDBtag = params['DDDB'],
CondDBtag = params['SIMCOND'],
# HistogramFile = 'DVHistos.root' ,
TupleFile = 'output_kpipi.root' ,
)
from Configurables import GaudiSequencer
# seq = GaudiSequencer('SEQ1', Members=[psi3k.sequence()])
seq = GaudiSequencer('SEQ2', Members=[psi3kpi.sequence()])
my_name = "Bplus"
davinci.UserAlgorithms = [ my_name ]
setData ( datafiles , catalogs , castor )
gaudi = appMgr()
from StandardParticles import StdAllNoPIDsPions, StdAllNoPIDsKaons
# create local algorithm:
alg = MCAnalysisAlgorithm(
my_name,
Inputs = [
StdAllNoPIDsPions.outputLocation(),
StdAllNoPIDsKaons.outputLocation(),
'/Event/AllStreams/Phys/%s/Particles' % jpsi_name
] ,
PP2MCs = [ 'Relations/Rec/ProtoP/Charged' ],
ReFitPVs = True
)
return SUCCESS
Substitutions={
'Charm -> (D0 -> ^K- pi+) Meson': 'pi-',
'Charm -> (D~0 -> ^K+ pi-) Meson': 'pi+',
'Charm -> (D0 -> K- ^K+) Meson': 'pi+',
'Charm -> (D~0 -> K+ ^K-) Meson': 'pi-'
}
)
# create a selection using the substitution algorithm
selSub = Selection(
'Dst2D0pi_D02pipi_Sel',
Algorithm=subs,
RequiredSelections=strippingSels
)
# in order to add the selection into the program make a sequence
selSeq = SelectionSequence('SelSeq', TopSelection=selSub)
# Create an ntuple to capture D*+ decays from the new selection
dtt = DecayTreeTuple('TupleDstToD0pi_D0Topipi')
dtt.Inputs = [selSeq.outputLocation()]
dtt.Decay = '[D*(2010)+ -> ^(D0 -> ^pi- ^pi+) ^pi+]CC'
# Configure DaVinci
# add our new selection and the tuple into the sequencer
seq = GaudiSequencer('MyTupleSeq')
seq.Members += [selSeq.sequence()]
seq.Members += [dtt]
DaVinci().appendToMainSequence([seq])
from GaudiKernel import SystemOfUnits as Units
##Type = 'MC'
JetPtMin = 10 * Units.GeV
from StandardParticles import StdAllNoPIDsMuons as loosemuons
from PhysSelPython.Wrappers import SimpleSelection, MergedSelection, DataOnDemand, Selection
from GaudiConfUtils.ConfigurableGenerators import FilterDesktop, CombineParticles
from commonSelections import *
from PhysSelPython.Wrappers import SelectionSequence
Z_seq = SelectionSequence('Z_Seq', TopSelection=Zs)
# Create the generated jets.
from Configurables import McParticleFlow, McJetBuilder
genPF = McParticleFlow('genPF')
genPF.Inputs = [
['PID', 'ban', '12,-12,14,-14,16,-16'],
['PID', 'particle', '321,211,130,3222,310,3122,3112,3312,3322,'
'-321,-211,-130,-3222,-310,-3122,-3112,-3312,-3322'],
['MCParticle', 'daughters', 'MC/Particles']
]
genPF.Output = 'Phys/PF/MCParticles'
genJB = McJetBuilder('genJB')
genJB.JetPtMin = JetPtMin
genJB.JetR = 0.5
genJB.ChrVrt = True
Code = " DECTREE('[(B+ -> eta_prime pi+),(B- -> eta_prime pi-) ]') " ,
Substitutions = {
'B+ -> eta_prime ^pi+' : 'K+',
'B- -> eta_prime ^pi-' : 'K-',
}
)
B2EtapKSel = Selection("B2EtapKSel", Algorithm = SubKToPi, RequiredSelections = [B2etap_piSub])
#B2EtapKSeq = SelectionSequence("B2EtapKSeq", TopSelection = B2EtapKSel)
#Code="(M>4800 *MeV) & (M<5700 *MeV) & (VFASPF(VCHI2/VDOF)<9.) & (PT> 1500.*MeV)"
B2EtapKFil= FilterDesktop("B2EtapKFil", Code="(M>4800 *MeV) & (M<5700 *MeV) & (VFASPF(VCHI2/VDOF)<9.)")# & (PT> 1500.*MeV)")
B2EtapKFil_Sel= Selection('B2EtapKFil_Sel', Algorithm=B2EtapKFil, RequiredSelections=[B2EtapKSel])
B2EtapKFil_Seq = SelectionSequence("B2etap_pi_FilSeq", TopSelection =B2EtapKFil_Sel)
# Fill Tuple
from Configurables import DecayTreeTuple
tuple = DecayTreeTuple("B2_ETAPK")
tuple.ToolList += [
"TupleToolGeometry",
"TupleToolPhotonInfo",
"TupleToolPid",
"TupleToolMCTruth",
tup.B0.addTool( LoKi_B0 )
tup.B0.ToolList += ["LoKi::Hybrid::TupleTool/LoKi_B0"]
tup.Jpsi.addTool( LoKi_Jpsi )
tup.Jpsi.ToolList += ["LoKi::Hybrid::TupleTool/LoKi_Jpsi"]
tup.muplus.addTool( LoKi_Mu )
tup.muplus.ToolList += ["LoKi::Hybrid::TupleTool/LoKi_Mu"]
tup.muminus.addTool( LoKi_Mu )
tup.muminus.ToolList += ["LoKi::Hybrid::TupleTool/LoKi_Mu"]
for particle in [ tup.B0 ]:
particle.addTool(TISTOSTool, name = "TISTOSTool")
particle.ToolList += [ "TupleToolTISTOS/TISTOSTool" ]
from PhysSelPython.Wrappers import SelectionSequence
rd_SEQ = SelectionSequence ( 'DATA' , rd_selection )
###################### DAVINCI SETTINGS ############################################
lum = True
sim = False
if MODE == 'MC':
lum = False
sim = True
daVinci = DaVinci (
EvtMax = EVTMAX
, RootInTES = rootInTES
, InputType = "MDST"
CondDB().LatestGlobalTagByDataType = DataYear
#CondDB(UseOracle = True, IgnoreHeartBeat = True)
############################################
#from Configurables import *
from Configurables import LHCbApp
LHCbApp().XMLSummary='summary.xml'
from Configurables import DataOnDemandSvc
from Configurables import L0SelReportsMaker, L0DecReportsMaker
DataOnDemandSvc().AlgMap["HltLikeL0/DecReports"] = L0DecReportsMaker( OutputLevel = 4 )
DataOnDemandSvc().AlgMap["HltLikeL0/SelReports"] = L0SelReportsMaker( OutputLevel = 4 )
if myDecayType and IsMC:
BsPhiRho_Sequence = GaudiSequencer("BsPhiRho_Sequence")
SeqBsPhiRho = SelectionSequence("SeqBsPhiRho", TopSelection = selSeq)
BsPhiRho_Sequence.Members += [SeqBsPhiRho.sequence()]
BsPhiRho_Sequence.Members += [smear]
BsPhiRho_Sequence.Members += [tuple]
userAlgos.append(BsPhiRho_Sequence)
elif not myDecayType and IsMC:
userAlgos.append( smear )
userAlgos.append( tuple )
elif not IsMC:
MySequencer.Members += [scaler]
MySequencer.Members += [tuple]
userAlgos.append(MySequencer)
from Configurables import EventTuple
etuple = EventTuple()
userAlgos.append( HltSelReportsDecoder() )
def configure ( datafiles , catalogs = [] , castor = False ) :
"""
Job configuration
"""
from Configurables import DaVinci ## needed for job configuration
from Configurables import EventSelector ## needed for job configuration
from Configurables import MessageSvc
msg = MessageSvc()
msg.setError += [ 'HcalDet.Quality' ,
'EcalDet.Quality' ,
'MagneticFieldSvc' ,
'PropertyConfigSvc' ]
## # =========================================================================
## ## 0) Rerun stripping if MC is nt MC/2011 or MC/2012
## # =========================================================================
## if '2012' == the_year :
## import StrippingArchive.Stripping20.StrippingDiMuonNew as DiMuon
## import StrippingSettings.Stripping20.LineConfigDictionaries_BandQ as LineSettings
## elif '2011' == the_year :
## import StrippingArchive.Stripping20r1.StrippingDiMuonNew as DiMuon
## import StrippingSettings.Stripping20r1.LineConfigDictionaries_BandQ as LineSettings
## config = LineSettings.FullDSTDiMuon['CONFIG']
## name = 'FullDST'
## builder = DiMuon.DiMuonConf ( name , config )
## ## selection
## jpsi = builder.SelJpsi2MuMuDetached
# =========================================================================
## 0) Otherwise use existing stripping ilne
# =========================================================================
from PhysSelPython.Wrappers import AutomaticData
jpsi_location = 'FullDSTDiMuonJpsi2MuMuDetachedLine'
jpsi = AutomaticData ( Location = '/Event/AllStreams/Phys/%s/Particles' % jpsi_location )
# =============================================================================
from StrippingSelections.StrippingPsiXForBandQ import PsiX_BQ_Conf as PsiX
# =============================================================================
## 1) redefine stripping configurations
# =============================================================================
#
## redefine psi(') -> mu+ mu-
#
def _psi_ ( self ) :
"""
psi(') -> mu+ mu-
"""
return jpsi
PsiX . psi = _psi_
logger.warning ( "Redefine PsiX .psi" )
# =============================================================================
## 2) unify the pion& kaon selections
# =============================================================================
_PionCut_ = """
( CLONEDIST > 5000 ) &
( TRCHI2DOF < 4 ) &
( TRGHOSTPROB < 0.4 ) &
( PT > 200 * MeV ) &
in_range ( 2 , ETA , 4.9 ) &
in_range ( 3.2 * GeV , P , 150 * GeV ) &
HASRICH &
( PROBNNpi > 0.15 ) &
( MIPCHI2DV() > 9. )
"""
_KaonCut_ = """
( CLONEDIST > 5000 ) &
( TRCHI2DOF < 4 ) &
( TRGHOSTPROB < 0.4 ) &
( PT > 200 * MeV ) &
in_range ( 2 , ETA , 4.9 ) &
in_range ( 3.2 * GeV , P , 150 * GeV ) &
HASRICH &
( PROBNNk > 0.15 ) &
( MIPCHI2DV() > 9. )
"""
from GaudiConfUtils.ConfigurableGenerators import FilterDesktop
_alg_pi = FilterDesktop (
##
Code = _PionCut_ ,
##
)
from PhysSelPython.Wrappers import Selection
from StandardParticles import StdAllNoPIDsPions as input_pions
pions = Selection (
"SelPiForBQ" ,
Algorithm = _alg_pi ,
RequiredSelections = [ input_pions ]
)
from GaudiConfUtils.ConfigurableGenerators import FilterDesktop
_alg_k = FilterDesktop (
##
Code = _KaonCut_ ,
##
)
from PhysSelPython.Wrappers import Selection
from StandardParticles import StdAllNoPIDsKaons as input_kaons
kaons = Selection (
"SelKForBQ" ,
Algorithm = _alg_k ,
RequiredSelections = [ input_kaons ]
)
def _kaons_ ( self ) : return kaons
def _pions_ ( self ) : return pions
#
## get the selections
#
for s in [ PsiX ] :
s.pions = _pions_
s.kaons = _kaons_
logger.warning ( "Redefine PsiX.kaons " )
logger.warning ( "Redefine PsiX.kaons " )
psix = PsiX ( 'PsiX' , {} )
for s in [ psix.psi_pi() ] :
a = s.algorithm ()
a.ParticleCombiners = { '' : 'LoKi::VertexFitter:PUBLIC' }
from PhysSelPython.Wrappers import SelectionSequence
sel_seq = SelectionSequence ( 'B2PsiPi' , psix . psi_pi () )
the_year = '2012'
davinci = DaVinci (
DataType = the_year ,
InputType = 'DST' ,
Simulation = True ,
PrintFreq = 1000 ,
EvtMax = -1 ,
HistogramFile = 'DVHistos.root' ,
TupleFile = 'DVNtuples.root' ,
Lumi = True ,
##
# MC :
## SIMCOND : 'Sim08-20130503-1', 'Sim08-20130503-1-vc-md100'
#
DDDBtag = "Sim08-20130503-1" ,
CondDBtag = "Sim08-20130503-1-vc-md100"
)
my_name = "Bplus"
from Configurables import GaudiSequencer
davinci.UserAlgorithms = [ sel_seq.sequence() , my_name ]
setData ( datafiles , catalogs , castor )
gaudi = appMgr()
print 'seq.outputLocation()= ', sel_seq.outputLocation() # Phys/SelPsi3KPiForPsiX/Particles
alg = Jpsi_mu(
my_name , ## Algorithm name
Inputs = [
sel_seq.outputLocation()
] ,
PP2MCs = [ 'Relations/Rec/ProtoP/Charged' ]
)
return SUCCESS
def configure(
inputdata, ## the list of input files
catalogs=[], ## xml-catalogs (filled by GRID)
castor=False, ## use the direct access to castor/EOS ?
params={}):
## import DaVinci
from Configurables import DaVinci
decay = '[(D0 => K- mu+ nu_mu) && ~(D0 --> K- (pi0|eta) mu+ nu_mu ... )]CC'
decay_K = '[(D0 => ^K- mu+ nu_mu) && ~(D0 --> K- (pi0|eta) mu+ nu_mu ... )]CC'
decay_mu = '[(D0 => K- ^mu+ nu_mu) && ~(D0 --> K- (pi0|eta) mu+ nu_mu ... )]CC'
from PhysConf.Filters import LoKi_Filters
fltrs = LoKi_Filters(MC_Code="has ( MCDECTREE('%s') )" % decay,
MC_Preambulo=["from LoKiCore.functions import has"])
## delegate the actual configuration to DaVinci
dv = DaVinci(DataType='2012',
EventPreFilters=fltrs.filters('MC-filter'),
InputType='DST',
Simulation=True,
TupleFile='Xuhao.root',
DDDBtag='Sim08-20130503-1',
CondDBtag='Sim08-20130503-1-vc-md100')
##
## reconstruct D0 -> K mu candidates
##
from StandardParticles import StdAllLooseKaons as kaons
from StandardParticles import StdAllLooseMuons as muons
from PhysSelPython.Wrappers import SimpleSelection
from GaudiConfUtils.ConfigurableGenerators import FilterDesktop
#
true_kaons = SimpleSelection(
'MCTrueKaon', ## selection name
FilterDesktop, ## algorithm type
[kaons], ## input/required selection
## algorithm propperties
Preambulo=["from LoKiPhysMC.decorators import *"],
Code="mcMatch ('%s', 2 )" % decay_K)
#
true_muons = SimpleSelection(
'MCTrueMuon', ## selection name
FilterDesktop, ## algorithm type
[muons], ## input/required selection
## algorithm propperties
Preambulo=["from LoKiPhysMC.decorators import *"],
Code="mcMatch ('%s', 2 )" % decay_mu)
from GaudiConfUtils.ConfigurableGenerators import CombineParticles
sel_D0 = SimpleSelection(
'SelD0', ## name
CombineParticles, ## algorithm type
[true_muons, true_kaons], ## input/required selections
## the decays to be reconstructed
DecayDescriptor='[D0 -> K- mu+]cc',
## combination cut : mass window
CombinationCut="""
in_range ( 1 * GeV , AM , 2 * GeV )
""",
## mother cut : require good vertex & some separation
MotherCut="""
( VFASPF( VCHI2 ) < 10 ) &
( BPVVDCHI2 > 9 )
""",
)
from PhysSelPython.Wrappers import SelectionSequence
SEQ_D0 = SelectionSequence('TRUED0', sel_D0)
alg1_name = 'Lines'
## add the name of Bender algorithm into User sequence sequence
from Configurables import GaudiSequencer
seq_lines = GaudiSequencer('SEQ_lines',
Members=[SEQ_D0.sequence(), alg1_name])
alg2_name = 'TisTosAlg'
## add the name of Bender algorithm into User sequence sequence
from Configurables import GaudiSequencer
seq_tistos = GaudiSequencer('SEQ_tistos',
Members=[SEQ_D0.sequence(), alg2_name])
dv.UserAlgorithms = [seq_lines, seq_tistos]
## define the input data
setData(inputdata, catalogs, castor)
from BenderTools.Utils import silence, totalSilence
silence()
totalSilence()
## get/create application manager
gaudi = appMgr()
alg1 = Lines(alg1_name, Inputs=[SEQ_D0.outputLocation()])
alg2 = Tistos(alg2_name, Inputs=[SEQ_D0.outputLocation()])
return SUCCESS
class strippingLine:
"""
Class to store information about stripping line that I will need to make nTuple
"""
def __init__(self,name, lineName, dec, branches):
self.name = name
self.lineName = lineName
self.dec = dec
self.branches = branches
self.lineLocation = "Phys/"+lineName+"/Particles"
def select(self):
"""
Get data and selection
"""
from PhysSelPython.Wrappers import Selection, SelectionSequence, DataOnDemand, AutomaticData
# from StandardParticles import StdLooseMuons, StdLooseKaons
from Configurables import FilterDesktop, CombineParticles, OfflineVertexFitter, LoKi__HDRFilter
from GaudiKernel.PhysicalConstants import c_light
evtPreselectors = []
if dataSample.isPrescaled != False:
if dataSample.isPrescaled == True:
dataSample.isPrescaled = 0.1
prescaler = DeterministicPrescaler("Prescaler", AcceptFraction = dataSample.isPrescaled)
evtPreselectors.append(prescaler)
# # Stripping filter
strippingFilter = LoKi__HDRFilter( 'StripPassFilter', Code="HLT_PASS('Stripping"+self.lineName+"Decision')", Location="/Event/Strip/Phys/DecReports" )
evtPreselectors.append(strippingFilter)
stripped_data = AutomaticData(Location = self.lineLocation)
# Trigger selection
from Configurables import TisTosParticleTagger
_tisTosFilter = TisTosParticleTagger( self.name + "Triggered" )
_tisTosFilter.TisTosSpecs = { 'L0Global%TUS' : 0,
'L0Global%TIS' : 0,
}
for trigger in trigger_list:
for tistos in ['TIS', 'TUS']:
_tisTosFilter.TisTosSpecs['{0}%{1}'.format(trigger, tistos)] = 0
triggered_data = Selection( self.name+'TriggerSelection',
Algorithm = _tisTosFilter,
RequiredSelections = [ stripped_data ],
)
Candidate_selection = stripped_data #triggered_data
self.sequence = SelectionSequence('Seq'+self.name,
TopSelection = Candidate_selection,
EventPreSelector = evtPreselectors)
def makeTuple(self):
"""
Make tuple
"""
from Configurables import FitDecayTrees, DecayTreeTuple, TupleToolDecayTreeFitter, TupleToolDecay, TupleToolTrigger, TupleToolTISTOS, TupleToolPropertime, PropertimeFitter, TupleToolKinematic, TupleToolGeometry, TupleToolEventInfo, TupleToolPrimaries, TupleToolPid, TupleToolTrackInfo, TupleToolRecoStats, TupleToolMCTruth, LoKi__Hybrid__TupleTool, LoKi__Hybrid__EvtTupleTool
tuple = DecayTreeTuple('Tuple'+self.name) # I can put as an argument a name if I use more than a DecayTreeTuple
tuple.Inputs = [ self.sequence.outputLocation() ]
tuple.Decay = self.dec
tuple.ToolList = ['TupleToolKinematic',
'TupleToolEventInfo',
'TupleToolTrackInfo',
'TupleToolPid',
'TupleToolGeometry',
'TupleToolAngles', # Helicity angle
# 'TupleToolPropertime', #proper time TAU of reco particles
]
tuple.InputPrimaryVertices = '/Event/Charm/Rec/Vertex/Primary'
# Other event infos
tuple.addTupleTool('LoKi::Hybrid::EvtTupleTool/LoKi_Evt')
tuple.LoKi_Evt.VOID_Variables = {
#"nSPDHits" : " CONTAINS('Raw/Spd/Digits') " ,
'nTracks' : " CONTAINS ('Charm/Rec/Track/Best') " ,
}
# # Other variables
# tuple.addTupleTool('LoKi::Hybrid::TupleTool/LoKi_All')
# tuple.LoKi_All.Variables = {
# 'BPVIPCHI2' : 'BPVIPCHI2()',
# 'BPVDIRA' : 'BPVDIRA',
# 'BPVLTFITCHI2' : 'BPVLTFITCHI2()',
# }
tuple.addBranches(self.branches)
tuple.phi.addTupleTool("LoKi::Hybrid::TupleTool/LoKi_phi")
tuple.phi.LoKi_phi.Variables = {
'DOCAMAX' : 'DOCAMAX',
"MassDiff_Phi" : "DMASS('phi(1020)')",
"BPVDIRA" : "BPVDIRA",
"IPS_Phi" : "MIPCHI2DV(PRIMARY)",
"VFASPF_CHI2DOF" : "VFASPF(VCHI2/VDOF)",
"VFASPF_CHI2" : "VFASPF(VCHI2)",
"BPVIPCHI2" : "BPVIPCHI2()",
"ADOCA" : "DOCA(1,2)",
"ADOCACHI2" : "DOCACHI2(1,2)",
"DTF_CHI2_PV" : "DTF_CHI2( True, 'phi(1020)' )",
"DTF_NDOF_PV" : "DTF_NDOF( True, 'phi(1020)' )",
"DTF_M_PV" : "DTF_FUN ( M, True, 'phi(1020)' )",
"DTF_M_Ks1_PV" : "DTF_FUN ( CHILD(M,1), True, 'phi(1020)' )",
"DTF_M_Ks2_PV" : "DTF_FUN ( CHILD(M,2), True, 'phi(1020)' )",
# "DTF_CTAU_Ks1" : "DTF_CTAU(1, False, 'phi(1020)' )",
# "DTF_CTAU_Ks2" : "DTF_CTAU(2, False, 'phi(1020)' )",
}
def mySharedConf_Ks(branch):
atool=branch.addTupleTool('LoKi::Hybrid::TupleTool/LoKi_Ks')
atool.Variables = {
"BPVDIRA" : "BPVDIRA",
"VFASPF_CHI2DOF" : "VFASPF(VCHI2/VDOF)",
"VFASPF_CHI2" : "VFASPF(VCHI2)",
"BPVIPCHI2" : "BPVIPCHI2()",
"BPVVD" : "BPVVD",
"BPVVDCHI2" : "BPVVDCHI2",
"ADOCA" : "DOCA(1,2)",
"ADOCACHI2" : "DOCACHI2(1,2)",
'BPVLTIME' : 'BPVLTIME()',
}
PropertimeTool = branch.addTupleTool("TupleToolPropertime/Propertime_Ks")
mySharedConf_Ks(tuple.Ks1)
mySharedConf_Ks(tuple.Ks2)
def mySharedConf_pi(branch):
atool=branch.addTupleTool('LoKi::Hybrid::TupleTool/LoKi_pi')
atool.Variables = {
'TRCHI2DOF' : 'TRCHI2DOF',
'TRGHOSTPROB' : 'TRGHOSTPROB',
}
mySharedConf_pi(tuple.pi1)
mySharedConf_pi(tuple.pi2)
mySharedConf_pi(tuple.pi3)
mySharedConf_pi(tuple.pi4)
# Triggers:
tuple.phi.addTupleTool('TupleToolTISTOS/TISTOS')
tuple.phi.TISTOS.TriggerList = trigger_list
tuple.phi.TISTOS.VerboseL0 = True
tuple.phi.TISTOS.VerboseHlt1 = True
tuple.phi.TISTOS.VerboseHlt2 = True
if dataSample.isMC:
from Configurables import MCDecayTreeTuple, MCTupleToolKinematic, TupleToolMCTruth, MCTupleToolHierarchy, MCTupleToolReconstructed, MCTupleToolAngles, TupleToolMCBackgroundInfo
tuple.addTupleTool('TupleToolMCTruth/MCTruth')
tuple.MCTruth.ToolList = ['MCTupleToolKinematic',
'MCTupleToolHierarchy',
'MCTupleToolReconstructed',
'MCTupleToolAngles',
]
tuple.phi.addTupleTool( "TupleToolMCBackgroundInfo")
self.sequence.sequence().Members += [tuple]
# Stream and stripping line we want to use
stream = 'AllStreams'
line = 'D2hhCompleteEventPromptDst2D2RSLine'
tesLoc = '/Event/{0}/Phys/{1}/Particles'.format(stream, line)
# get the selection(s) created by the stripping
strippingSels = [DataOnDemand(Location=tesLoc)]
# create a selection using the substitution algorithm
selSub = Selection(
'Dst2D0pi_D02pipi_Sel',
Algorithm=subs,
RequiredSelections=strippingSels
)
selSeq = SelectionSequence('SelSeq', TopSelection=selSub)
# Create an ntuple to capture D*+ decays from the new selection
from Configurables import DecayTreeTuple
dtt = DecayTreeTuple('TupleDstToD0pi_D0Topipi')
dtt.Inputs = [selSeq.outputLocation()]
# note the redefined decay of the D0
dtt.Decay = '[D*(2010)+ -> ^(D0 -> ^pi- ^pi+) ^pi+]CC'
# add our new selection and the tuple into the sequencer
from Configurables import GaudiSequencer, DaVinci
seq = GaudiSequencer('MyTupleSeq')
seq.Members += [selSeq.sequence()]
seq.Members += [dtt]
DaVinci().appendToMainSequence([seq])
Ds = CombineParticles("Ds2PhiPi")
Ds.DecayDescriptor = '[D_s+ -> phi(1020) pi+]cc'
Ds.DaughtersCuts = { '' : 'ALL' , 'phi(1020)' : '(ALL)' , 'pi+' : '(PT >150 *MeV) & (BPVIPCHI2() > 1.0) & ( TRCHI2DOF < 5 )& (TRGHOSTPROB<0.3)'}
Ds.CombinationCut = "(ADAMASS('D_s+')<180*MeV)"
Ds.MotherCut = "(VFASPF(VCHI2/VDOF) < 25.0)& (((BPVVDCHI2 > 16.0)|(BPVLTIME() > 0.150 * picosecond)))"#& (BPVDIRA > 35.0*mrad)"
Ds.MotherCut += "&(ADMASS('D_s+')<150*MeV)" %config
Ds_Sel = Selection(name = "Sel_Ds2PhiPi",
Algorithm = Ds,
RequiredSelections = [Phi_Sel, Pions])
Ds_sequence = SelectionSequence('SeqDs2PhiPi',
TopSelection = Ds_Sel
)
#This filter is used just to speed up the process, nothing happens if there
# # is no stripped candidates at that location.
# from PhysConf.Filters import LoKi_Filters
# fltrs = LoKi_Filters(
# STRIP_Code = "HLT_PASS('StrippingPhiToKSKS_PhiToKsKsLineDecision')")
from Configurables import FitDecayTrees, DecayTreeTuple, TupleToolDecayTreeFitter, TupleToolDecay, TupleToolTrigger, TupleToolTISTOS, TupleToolPropertime, PropertimeFitter, TupleToolKinematic, TupleToolGeometry, TupleToolEventInfo, TupleToolPrimaries, TupleToolPid, TupleToolTrackInfo, TupleToolRecoStats, TupleToolMCTruth, LoKi__Hybrid__TupleTool, LoKi__Hybrid__EvtTupleTool
from Configurables import LoKi__LifetimeFitter
tuple = DecayTreeTuple("TuplePhi2KsKs")
def configure(datafiles, catalogs=[], castor=True, params=None):
"""
Configure the job
"""
from Configurables import DaVinci # needed for job configuration
# from Configurables import EventSelector # needed for job configuration
# from Configurables import NTupleSvc
from PhysConf.Filters import LoKi_Filters
fltrs = LoKi_Filters(
STRIP_Code="""
HLT_PASS_RE ( 'Stripping.*DiMuonHighMass.*Decision' )
""",
VOID_Code="""
0 < CONTAINS (
'/Event/AllStreams/Phys/FullDSTDiMuonDiMuonHighMassLine/Particles')
"""
)
filters = fltrs.filters('Filters')
filters.reverse()
from PhysSelPython.Wrappers import AutomaticData, Selection, SelectionSequence
#
# defimuon in stripping DST
#
# DiMuLocation =
# '/Event/Dimuon/Phys/FullDSTDiMuonDiMuonHighMassLine/Particles'
DiMuLocation = '/Event/AllStreams/Phys/FullDSTDiMuonDiMuonHighMassLine/Particles'
from PhysSelPython.Wrappers import AutomaticData
DiMuData = AutomaticData(Location=DiMuLocation)
# =========================================================================
# Upsilon -> mumu, cuts by Giulia Manca
# ========================================================================
from GaudiConfUtils.ConfigurableGenerators import FilterDesktop
UpsAlg = FilterDesktop(
Code="""
( M > 7 * GeV ) &
DECTREE ('Meson -> mu+ mu-' ) &
CHILDCUT( 1 , HASMUON & ISMUON ) &
CHILDCUT( 2 , HASMUON & ISMUON ) &
( MINTREE ( 'mu+' == ABSID , PT ) > 1 * GeV ) &
( MAXTREE ( ISBASIC & HASTRACK , TRCHI2DOF ) < 4 ) &
( MINTREE ( ISBASIC & HASTRACK , CLONEDIST ) > 5000 ) &
( VFASPF ( VPCHI2 ) > 0.5/100 )
& ( abs ( BPV ( VZ ) ) < 0.5 * meter )
& ( BPV ( vrho2 ) < ( 10 * mm ) ** 2 )
""",
Preambulo=[
"vrho2 = VX**2 + VY**2"
],
ReFitPVs=True
)
UpsSel = Selection(
'UpsSel',
Algorithm=UpsAlg,
RequiredSelections=[DiMuData]
)
# =========================================================================
# chi_b -> Upsilon gamma
# ========================================================================
from GaudiConfUtils.ConfigurableGenerators import CombineParticles
ChibCombine = CombineParticles(
DecayDescriptor="chi_b1(1P) -> J/psi(1S) gamma",
DaughtersCuts={
"gamma": " ( 350 * MeV < PT ) & ( CL > 0.01 ) "
},
CombinationCut="""
( AM - AM1 ) < 3 * GeV
""",
MotherCut=" PALL",
#
# we are dealing with photons!
#
ParticleCombiners={
'': 'LoKi::VertexFitter'
}
)
from StandardParticles import StdLooseAllPhotons # needed for chi_b
ChibSel1 = Selection(
'PreSelChib',
Algorithm=ChibCombine,
RequiredSelections=[UpsSel, StdLooseAllPhotons]
)
from GaudiConfUtils.ConfigurableGenerators import Pi0Veto__Tagger
TagAlg = Pi0Veto__Tagger(
ExtraInfoIndex=25001, # should be unique!
MassWindow=20 * MeV, # cut on delta-mass
MassChi2=-1, # no cut for chi2(mass)
)
ChibSel2 = Selection(
'Chi_b',
Algorithm=TagAlg,
RequiredSelections=[ChibSel1]
)
Chib = SelectionSequence("ChiB", TopSelection=ChibSel2)
# print 'OUTPUT!!!' , output_loc
# =========================================================================
# Upsilons
# ========================================================================
Ups = SelectionSequence("UpsSelSeq", TopSelection=UpsSel)
# ========================================================================
from Configurables import GaudiSequencer
myChibSeq = GaudiSequencer('MyChibSeq')
myChibSeq.Members = [Chib.sequence()] + ["ChibAlg"]
myUpsSeq = GaudiSequencer('MyUpsSeq')
myUpsSeq.Members = [Ups.sequence()] + ["UpsilonAlg"]
davinci = DaVinci(
EventPreFilters=filters,
DataType='2011',
Simulation=True,
InputType='DST',
HistogramFile="chib_histos.root",
TupleFile="chib_tuples.root",
PrintFreq=1000,
Lumi=True,
EvtMax=-1
)
davinci.UserAlgorithms = [myChibSeq, myUpsSeq]
# =========================================================================
from Configurables import Gaudi__IODataManager as IODataManager
IODataManager().AgeLimit = 2
# =========================================================================
# come back to Bender
setData(datafiles, catalogs, castor)
gaudi = appMgr()
alg_chib = ChibMC(
'ChibAlg', # Algorithm name ,
# input particles
Inputs=[
Chib.outputLocation()
],
# take care about the proper particle combiner
ParticleCombiners={'': 'LoKi::VertexFitter'}
)
alg_ups = UpsilonMC(
'UpsilonAlg', # Algorithm name ,
# input particles
Inputs=[
Ups.outputLocation()
],
# take care about the proper particle combiner
ParticleCombiners={'': 'LoKi::VertexFitter'}
)
alg_chib.nb = alg_ups.nb = params['nb']
alg_chib.np = alg_ups.np = params['np']
# =========================================================================
return SUCCESS
sc = StrippingConf( Streams = [ AllStreams ],
MaxCandidates = 2000
)
stripsel = AutomaticData(Location = "Phys/B2XMuMuIncl_InclDiMuLowQ2Line/Particles")
stripfilter = FilterDesktop("stripfilter",
Preambulo = ["from LoKiPhysMC.decorators import *",
"from LoKiPhysMC.functions import mcMatch"],
Code = "ALL")
inclmumu = Selection ("Sel"+name,
Algorithm = stripfilter,
RequiredSelections = [stripsel])
seq = SelectionSequence("seq",
TopSelection = inclmumu)
tuple = DecayTreeTuple("Incl_Tuple")
tuple.Inputs = [stripsel.outputLocation()]
tuple.ToolList = [
"TupleToolKinematic"
, "TupleToolEventInfo"
, "TupleToolRecoStats"
, "TupleToolMCBackgroundInfo"
, "TupleToolGeometry"
, "TupleToolPid"
, "TupleToolPropertime"
, "TupleToolPrimaries"
, "TupleToolTrackInfo"
combineAB = CombineParticles('CombineAB')
combineAB.DecayDescriptor = "B_s0 -> D_s- D_s+"
combineAB.MotherCut = "ALL"
combineAB.Preambulo = [
"from LoKiPhysMC.decorators import *",
"from PartProp.Nodes import CC" ]
selectionA = Selection("FakeDsPlusSel",
Algorithm = combineA,
RequiredSelections=[_kaons, _pions])
selectionB = Selection("FakeDsMinusSel",
Algorithm = combineB,
RequiredSelections=[_kaons, _pions])
selASelectionSequence = SelectionSequence('FakeDsPlus', TopSelection = selectionA)
selBSelectionSequence = SelectionSequence('FakeDsMinus', TopSelection = selectionB)
selectionAB = Selection("FakeBsSel",
Algorithm = combineAB,
RequiredSelections=[DataOnDemand(Location=selASelectionSequence.outputLocation()),
DataOnDemand(Location=selBSelectionSequence.outputLocation())])
selABSelectionSequence = SelectionSequence('FakeBs', TopSelection = selectionAB)
from Configurables import FitDecayTrees
fitD2KKP = FitDecayTrees (
"fitD2KKP" ,
Code = "DECTREE('B_s0 -> (D_s+ -> K+ K- pi+) (D_s- -> K- K+ pi-)')",
MassConstraints = [ 'D_s+', 'D_s-' ],
Algorithm = makeeta_prime,
RequiredSelections= [rhoselection, photonselection])
stdKaons = DataOnDemand("Phys/StdLooseKaons/Particles")
makeBu= CombineParticles('makeBu',
DecayDescriptor="[B+ -> eta_prime K+]cc",
CombinationCut ="(AM > 4500) & (AM < 6500)",
MotherCut = "(VFASPF(VCHI2/VDOF)<9.0)",
)
BuSel = Selection('BuSel',
Algorithm=makeBu,
RequiredSelections = [eta_primesel,stdKaons])
Buseq = SelectionSequence('Buseq',
TopSelection= BuSel)
# Build an Eta_prime
#eta_prime_daughters = {
# 'pi+' : '(PT > 200*MeV)',
# 'pi-' : '(PT> 200*MeV)',
# 'gamma' : '(PT>400*MeV)'
# }
#CombEta_prime = CombineParticles('CombEta_prime',
# Inputs= ['Phys/StdAllLoosePions/Particles','Phys/StdLooseAllPhotons/Particles',StrippingSels.outputLocation()],
# DecayDescriptor = 'eta_prime -> rho(770)0 gamma',
# DaughtersCuts=eta_prime_daughters,
# CombinationCut='(APT>1200*MeV)',
):
a = s.algorithm()
a.ParticleCombiners = {'': 'LoKi::VertexFitter:PUBLIC'}
#
a.MaxCandidates = 2000
a.StopAtMaxCandidates = True
a.StopIncidentType = 'ExceedsCombinatoricsLimit'
#
from PhysSelPython.Wrappers import MultiSelectionSequence
from PhysSelPython.Wrappers import SelectionSequence
psi_x = MultiSelectionSequence(
"PSIX",
Sequences=[
## channels with chic
#
SelectionSequence('B2CHICK', psix0.b2chicK()),
SelectionSequence('B2CHICKK', psix0.b2chicKK()),
SelectionSequence('B2CHICKPi', psix0.b2chicKpi()),
SelectionSequence('B2CHICKPiPi', psix0.b2chicKpipi()),
SelectionSequence('B2CHICPiPi', psix0.b2chicpipi()),
#
SelectionSequence('BC2CHICPi', psix0.bc2chicpi()),
SelectionSequence('Lb2CHICPi', psix0.lb2chicpK()),
])
###################### DAVINCI SETTINGS ############################################
DaVinci().SkipEvents = 0 #1945
DaVinci().PrintFreq = 10000
DaVinci().EvtMax = EVTMAX
DaVinci().TupleFile = "DVTuples1.root"
DaVinci().HistogramFile = 'DVHistos.root'
# Change mass hypothesis
newDecay = "DECTREE('B_s0 -> (phi(1020) -> K+ K-) (f_0(980) -> K+ K-)')"
_SubstituteB0 = SubstitutePID( name = "_SubstituteB0"
, Code = " DECTREE('B0 -> (phi(1020) -> K+ K-) (rho(770)0 -> pi+ pi-)') "
, Substitutions = { 'Beauty -> (phi(1020) -> K+ K-) ^(rho(770)0 -> X+ X-)' : 'f_0(980)'
, 'Beauty -> (phi(1020) -> K+ K-) (X0 -> ^pi+ X-)' : 'K+'
, 'Beauty -> (phi(1020) -> K+ K-) (X0 -> X+ ^pi-)' : 'K-'
, 'Beauty -> (phi(1020) -> K+ K-) (X0 -> X+ X-)' : 'B_s0'
}
)
_ddChangeSel = Selection( "_ddChangeSel"
, Algorithm = _SubstituteB0
, RequiredSelections = [_strippingOutput]
)
selSeq = SelectionSequence("selseqname", TopSelection = _ddChangeSel)
# Create Decay Tree Tuple #####################################################
from Configurables import DecayTreeTuple
from DecayTreeTuple.Configuration import *
tuple = DecayTreeTuple()
tuple.Inputs = [ selSeq.outputLocation() ]
#tuple.Inputs = [ strippingline ]
from Configurables import BackgroundCategory
from Configurables import TupleToolTrigger, TupleToolRecoStats, TupleToolTrackIsolation, TupleToolTagging, TupleToolTISTOS
# Universal tools
tuple.ToolList += [ "TupleToolGeometry"
, "TupleToolKinematic"
, "TupleToolPropertime"
# , "TupleToolPrimaries"
