def makeKst2Kpi(name, KaonPT, KaonIPCHI2, PionPT, PionIPCHI2, KstarPT,
KaonPIDK, KstarVCHI2, KstarMassWin, PionPIDK):
"""
Create and return a Kstar -> K+pi- Selection object.
Starts from DataOnDemand 'Phys/StdVeryLooseDetachedKst2Kpi'.
Arguments:
name : name of the Selection.
KaonPT : Minimum transverse momentum of K (MeV).
KaonIPCHI2 : Minimum impact parameter chi2 of K.
PionPT : Minimum transverse momentum of pi (MeV).
PionIPCHI2 : Minimum impact parameter chi2 of pi.
PionPIDK : Maximum PID_{K-pi} of pi.
KstarPT : Minimum transverse momentum of Kstar (MeV).
KaonPIDK : Minimum PID_{K-pi} of K.
KstarVCHI2 : Maximum Kstar vertex chi2 per degree of freedom.
KstarMassWin : Kstar invariant mass window around PDG mass value (MeV).
"""
KstarCuts = "(INTREE((ABSID=='K+') & (PT > %(KaonPT)s *MeV) & (MIPCHI2DV(PRIMARY)> %(KaonIPCHI2)s) & (PIDK > %(KaonPIDK)s) ))"\
"& (INTREE((ABSID=='pi-') & (PT > %(PionPT)s *MeV) & (MIPCHI2DV(PRIMARY)> %(PionIPCHI2)s) & (PIDK < %(PionPIDK)s ) ))"\
"& (ADMASS('K*(892)0') < %(KstarMassWin)s *MeV)"\
"& (VFASPF(VCHI2/VDOF)< %(KstarVCHI2)s) & (PT > %(KstarPT)s *MeV)"% locals()
_KstarFilter = FilterDesktop("_filterFor" + name)
_KstarFilter.Code = KstarCuts
_stdKst2Kpi = DataOnDemand(
Location="Phys/StdVeryLooseDetachedKst2Kpi/Particles")
return Selection(name,
Algorithm=_KstarFilter,
RequiredSelections=[_stdKst2Kpi])
def build_mc_unbiased_selection(decayDesc, arrow = '==>', refitpvs = True) :
'''Make a selection for the given decay descriptor that has no cuts besides
truth matching.'''
preamble = [ "from LoKiPhysMC.decorators import *" , "from LoKiPhysMC.functions import mcMatch" ]
decayDesc = decayDesc.copy()
decayDesc.clear_aliases()
decayDesc.set_carets(False)
decayDescCC = decayDesc.copy()
decayDescCC.cc = True
algname = decayDesc.get_full_alias() + '_MCSel'
algnameconj = decayDesc.conjugate().get_full_alias() + '_MCSel'
if algname in selections :
return selections[algname]
elif algnameconj in selections :
return selections[algnameconj]
if not decayDesc.daughters :
alg = FilterDesktop(algname + '_Filter')
basicname = decayDesc.particle.name
if not basicname in mcbasicinputs :
basicname = decayDesc.conjugate().particle.name
if basicname in mcbasicinputs :
inputsels = [RebuildSelection(getattr(StandardParticles, basicinput)) for basicinput in mcbasicinputs[basicname]]
else :
raise ValueError("Can't find MC basic input for particle " + repr(decayDesc.particle.name))
alg.Code = 'mcMatch({0!r})'.format(decayDescCC.to_string(arrow))
alg.Preambulo = preamble
sel = Selection(algname,
Algorithm = alg,
RequiredSelections = inputsels)
selections[algname] = sel
return sel
inputs = set()
daughtercuts = {}
for daughter in decayDescCC.daughters :
originaldaughtercc = daughter.cc
daughter.cc = True
sel = build_mc_unbiased_selection(daughter, arrow, refitpvs)
daughter.cc = originaldaughtercc
inputs.add(sel)
#daughter.caret = True
#daughtercuts[daughter.particle.name] = 'mcMatch({0!r})'.format(decayDescCC.to_string(arrow))
#daughter.caret = False
#comb = nCombiners[len(decayDesc.daughters)](algname + '_Comb')
comb = CombineParticles(algname + '_Comb')
# CombineParticles uses small cc, so set ishead = False
comb.DecayDescriptors = [decayDesc.to_string(depth = 1).replace('CC', 'cc')]
comb.MotherCut = 'mcMatch({0!r})'.format(decayDescCC.to_string(arrow))
comb.Preambulo = preamble
comb.DaughtersCuts = daughtercuts
comb.ReFitPVs = refitpvs
if refitpvs:
comb.MotherCut += ' & BPVVALID()'
sel = Selection(algname,
Algorithm = comb,
RequiredSelections = list(inputs))
selections[algname] = sel
return sel
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 inputSeq(self, outputLevel=INFO):
if not allConfigurables.get("AlignInputSeq"):
if outputLevel == VERBOSE:
print "VERBOSE: Filter Sequencer not defined! Defining!"
inputSequencer = GaudiSequencer("AlignInputSeq")
inputSequencer.MeasureTime = True
trackselections = self.getProp("TrackSelections")
if len(trackselections) > 0:
trackInputSeq = GaudiSequencer("AlignTrackSelSeq",
IgnoreFilterPassed=True)
inputSequencer.Members.append(trackInputSeq)
# add the algorithms for the track selections to the sequence.
# also merge the tracks lists into one list
from Configurables import TrackListMerger
trackmerger = TrackListMerger(
"AlignTracks", outputLocation="Rec/Track/AlignTracks")
self.setProp("TrackLocation", trackmerger.outputLocation)
for i in trackselections:
alg = i.algorithm()
if alg: trackInputSeq.Members.append(alg)
trackmerger.inputLocations.append(i.location())
trackInputSeq.Members.append(trackmerger)
# add all particle selections
if len(self.getProp("ParticleSelections")) > 0:
particleInputSeq = GaudiSequencer("AlignParticleSelSeq",
IgnoreFilterPassed=True)
inputSequencer.Members.append(particleInputSeq)
from Configurables import FilterDesktop
particlemerger = FilterDesktop("AlignParticles", Code="ALL")
particlemerger.Code = "ALL"
particlemerger.CloneFilteredParticles = False
for i in self.getProp("ParticleSelections"):
alg = i.algorithm()
if alg:
particleInputSeq.Members.append(alg)
print "adding particleinputsel to sequence: ", i.name(
), i.algorithm(), i.location()
particlemerger.Inputs.append(i.location())
particleInputSeq.Members.append(particlemerger)
self.setProp("ParticleLocation",
'/Event/Phys/AlignParticles/Particles')
# add the PV selection
if hasattr(self, "PVSelection"):
inputSequencer.Members.append(
self.getProp("PVSelection").algorithm())
self.setProp("VertexLocation",
self.getProp("PVSelection").location())
return inputSequencer
else:
if outputLevel == VERBOSE:
print "VERBOSE: AlignInputSeq already defined!"
return allConfigurables.get("AlignInputSeq")
def build_mc_unbiased_selection(decayDesc, arrow = '==>') :
preamble = [ "from LoKiPhysMC.decorators import *" , "from LoKiPhysMC.functions import mcMatch" ]
decayDesc.set_carets(False)
decayDescCC = decayDesc.copy()
decayDescCC.cc = True
algname = decayDesc.get_full_alias() + '_MCSel'
algnameconj = decayDesc.conjugate().get_full_alias() + '_MCSel'
if algname in selections :
return selections[algname]
elif algnameconj in selections :
return selections[algnameconj]
if not decayDesc.daughters :
alg = FilterDesktop(algname + '_Filter')
if decayDesc.particle.name in mcbasicinputs :
inputsel = mcbasicinputs[decayDesc.particle.name]
else :
conj = decayDesc.conjugate()
if conj.particle.name in mcbasicinputs :
inputsel = mcbasicinputs[conj.particle.name]
else :
raise ValueError("Can't find MC basic input for particle " + repr(decayDesc.particle.name))
alg.Code = 'mcMatch({0!r})'.format(decayDescCC.to_string(arrow))
alg.Preambulo = preamble
sel = Selection(algname,
Algorithm = alg,
RequiredSelections = [inputsel])
selections[algname] = sel
return sel
inputs = set()
daughtercuts = {}
for daughter in decayDescCC.daughters :
originaldaughtercc = daughter.cc
daughter.cc = True
sel = build_mc_unbiased_selection(daughter, arrow)
daughter.cc = originaldaughtercc
inputs.add(sel)
#daughter.caret = True
#daughtercuts[daughter.particle.name] = 'mcMatch({0!r})'.format(decayDescCC.to_string(arrow))
#daughter.caret = False
#comb = nCombiners[len(decayDesc.daughters)](algname + '_Comb')
comb = CombineParticles(algname + '_Comb')
# CombineParticles uses small cc, so set ishead = False
comb.DecayDescriptors = [decayDesc.to_string(depth = 1).replace('CC', 'cc')]
comb.MotherCut = 'mcMatch({0!r})'.format(decayDescCC.to_string(arrow))
comb.Preambulo = preamble
comb.DaughtersCuts = daughtercuts
sel = Selection(algname,
Algorithm = comb,
RequiredSelections = list(inputs))
selections[algname] = sel
return sel
def filterJpsi (localname,
_InputLocation=_my_immutable_config['JpsiForExclusiveLinesLocation'],
config=default_config):
_filterAlgorithm = FilterDesktop(localname+"JpsiMuonFilter");
_myCutOnMuons = ("(PIDmu > %(Muon4Jpsi_PIDmu)s) &"+
" (TRPCHI2 > %(Muon4Jpsi_TRPCHI2)s) &"+
" (PT > %(Muon4Jpsi_PT)s) ")%config
_filterAlgorithm.Code = ("(CHILDCUT(("+_myCutOnMuons+"),1) & CHILDCUT(("+_myCutOnMuons+"),2)) &"+
" (VFASPF(VCHI2/VDOF)<%(Jpsi_ENDVERTEXCHI2)s) &"+
" (ADMASS('J/psi(1S)') < %(Jpsi_MassWindowTight)s)") % config
return Selection (name = localname + 'JpsiMuonFilterSelection',
Algorithm = _filterAlgorithm,
RequiredSelections = [ AutomaticData(_InputLocation) ])
def build_mc_unbiased_selection(decayDesc, arrow = '==>') :
preamble = [ "from LoKiPhysMC.decorators import *" , "from LoKiPhysMC.functions import mcMatch" ]
decayDesc.set_carets(False)
decayDescCC = decayDesc.copy()
decayDescCC.cc = True
algname = decayDesc.get_full_alias() + '_MCSel'
if algname in selections :
return selections[algname]
if not decayDesc.daughters :
alg = FilterDesktop(algname + '_Filter')
if decayDesc.particle.name in mcbasicinputs :
inputsel = mcbasicinputs[decayDesc.particle.name]
else :
conj = decayDesc.conjugate()
if conj.particle.name in mcbasicinputs :
inputsel = mcbasicinputs[conj.particle.name]
else :
raise ValueError("Can't find MC basic input for particle " + repr(decayDesc.particle.name))
alg.Code = 'mcMatch({0!r})'.format(decayDescCC.to_string(arrow))
alg.Preambulo = preamble
sel = Selection(algname,
Algorithm = alg,
RequiredSelections = [inputsel])
selections[algname] = sel
return sel
inputs = []
daughtercuts = {}
for daughter in decayDescCC.daughters :
originaldaughtercc = daughter.cc
daughter.cc = True
sel = build_mc_unbiased_selection(daughter, arrow)
daughter.cc = originaldaughtercc
inputs.append(sel)
#daughter.caret = True
#daughtercuts[daughter.particle.name] = 'mcMatch({0!r})'.format(decayDescCC.to_string(arrow))
#daughter.caret = False
#comb = nCombiners[len(decayDesc.daughters)](algname + '_Comb')
comb = CombineParticles(algname + '_Comb')
# CombineParticles uses small cc, so set ishead = False
comb.DecayDescriptors = [decayDesc.to_string(depth = 1, ishead = False)]
comb.MotherCut = 'mcMatch({0!r})'.format(decayDescCC.to_string(arrow))
comb.Preambulo = preamble
comb.DaughtersCuts = daughtercuts
sel = Selection(algname,
Algorithm = comb,
RequiredSelections = inputs)
selections[algname] = sel
return sel
def __apply_configuration__(self):
from Configurables import (CombinedParticleMaker,
ProtoParticleMUONFilter,
ProtoParticleCALOFilter, FilterDesktop)
mName = "TaggingMuons"
eName = "TaggingElectrons"
pName = "TaggingPions"
tagName = 'TaggingParticles'
hat = 'Phys/'
leaf = '/Particles'
mLoc, eLoc, pLoc, tagLoc = [
hat + name + leaf for name in mName, eName, pName, tagName
]
taggerMuons = CombinedParticleMaker(mName)
taggerMuons.Particle = 'Muon'
taggerMuons.addTool(ProtoParticleMUONFilter, name="Muon")
taggerMuons.Muon.Selection = [
"RequiresDet='MUON' CombDLL(mu-pi)>'0.0'"
]
taggerElectrons = CombinedParticleMaker(eName)
taggerElectrons.Particle = 'Electron'
taggerElectrons.addTool(ProtoParticleCALOFilter, name="Electron")
taggerElectrons.Electron.Selection = [
"RequiresDet='CALO' CombDLL(e-pi)>'4.0'"
]
taggerPions = CombinedParticleMaker(pName)
taggerPions.Particle = 'Pion'
taggingParticles = FilterDesktop(tagName)
taggingParticles.Inputs = [eLoc, mLoc, pLoc]
taggingParticles.Code = "(P>2.0*GeV)"
dod = DataOnDemandSvc()
dod.AlgMap.update({mLoc: taggerMuons})
dod.AlgMap.update({eLoc: taggerElectrons})
dod.AlgMap.update({pLoc: taggerPions})
dod.AlgMap.update({tagLoc: taggingParticles})
# configure charm candidate lists
import FlavourTagging.CharmTaggerLists
def __init__(self, name='Tagging'):
mName = name + "Muons"
eName = name + "Electrons"
pName = name + "Pions"
tagName = name + 'Particles'
_taggerMuons = CombinedParticleMaker(mName)
_taggerMuons.Particle = 'Muon'
_taggerMuons.addTool(ProtoParticleMUONFilter, name="Muon")
_taggerMuons.Muon.Selection = [
"RequiresDet='MUON' CombDLL(mu-pi)>'0.0'"
]
_taggerElectrons = CombinedParticleMaker(eName)
_taggerElectrons.Particle = 'Electron'
_taggerElectrons.addTool(ProtoParticleCALOFilter, name="Electron")
_taggerElectrons.Electron.Selection = [
"RequiresDet='CALO' CombDLL(e-pi)>'4.0'"
]
_taggerPions = CombinedParticleMaker(pName)
_taggerPions.Particle = 'Pion'
_taggingParticles = FilterDesktop(tagName)
_taggingParticles.Code = "(P>2.0*GeV)"
taggerMuons = Selection(mName, Algorithm=_taggerMuons)
taggerElectrons = Selection(eName, Algorithm=_taggerElectrons)
taggerPions = Selection(pName, Algorithm=_taggerPions)
allTaggers = MergedSelection(
name + 'All',
RequiredSelections=[taggerPions, taggerMuons, taggerElectrons])
self.selection = Selection(tagName,
Algorithm=_taggingParticles,
RequiredSelections=[allTaggers])
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'
def patchBrunel():
"""
Instantiate the options to run Brunel with raw data
@author M.Frank
"""
import GaudiConf.DstConf
import Brunel.Configuration
import OnlineEnv
brunel = Brunel.Configuration.Brunel()
brunel.OnlineMode = True
try:
brunel.DDDBtag = OnlineEnv.DDDBTag
except:
print "DDDBTag not found, use default"
try:
brunel.CondDBtag = OnlineEnv.CondDBTag
except:
print "CondDBTag not found, use default"
##print '[ERROR]', OnlineEnv.DDDBTag, OnlineEnv.CondDBTag
conddb = CondDB()
conddb.IgnoreHeartBeat = True
#
# Adjust to pickup the proper online conditions
#
import ConditionsMap
conddb.setProp('RunChangeHandlerConditions',
ConditionsMap.RunChangeHandlerConditions)
conddb.setProp('EnableRunChangeHandler', True)
brunel.DataType = "2015"
brunel.UseDBSnapshot = True # Try it
brunel.WriteFSR = False # This crashes Jaap's stuff
conddb = CondDB()
conddb.Online = True
#
# Adjust to pickup the proper online conditions from ConditionsMap
#
conddb.RunChangeHandlerConditions = ConditionsMap.RunChangeHandlerConditions
conddb.setProp('EnableRunChangeHandler', True)
# Enabled data-on-demand
Gaudi.ApplicationMgr().ExtSvc += ["DataOnDemandSvc"]
################################################################################
# #
# Set up PID monitoring sequence #
# #
################################################################################
# The sequencer to run all the monitoring in
seq = GaudiSequencer("PIDMoniSeq")
pidSeq = GaudiSequencer("RichPIDSelections")
brunel.setOtherProps(RichPIDQCConf(), ['OutputLevel', 'Context'])
RichPIDQCConf().setProp("CalibSequencer", pidSeq)
seq.Members += [pidSeq]
################################################################################
# #
# Configure the muon efficiency monitor #
# #
################################################################################
muEffMoni = MuEffMonitor("MuEffMonitor")
muEffMoni.addTool(TrackMasterExtrapolator, name="MuEffExtrap")
muEffMoni.Extrapolator = muEffMoni.MuEffExtrap
muEffMoni.MuEffExtrap.ApplyMultScattCorr = True
muEffMoni.MuEffExtrap.ApplyEnergyLossCorr = True
muEffMoni.MuEffExtrap.MaterialLocator = "SimplifiedMaterialLocator"
muEffMoni.MuEffExtrap.OutputLevel = 6
muEffMoni.nSigma1X = [11., 8., 7., 7.]
muEffMoni.nSigma1Y = [6., 5., 5., 5.]
muEffMoni.nSigmaX = [5., 5., 5., 5.]
muEffMoni.nSigmaY = [5., 5., 5., 5.]
muEffMoni.RequiredStations = 4
muEffMoni.MomentumCut = 3000.0
muEffMoni.nSigmaFidVol = 3.0
muEffMoni.UseCalo = True
muEffMoni.EecalMax = 1500.0
muEffMoni.EhcalMax = 5000.0
muEffMoni.EhcalMin = 1000.0
muEffMoni.Chi2ProbTrMin = 0.01
muEffMoni.Chi2MuMin = 10.0
muEffMoni.nSigmaXother = 2.0
muEffMoni.nSigmaYother = 2.0
muEffMoni.HistoLevel = "OfflineFull"
seq.Members += [muEffMoni]
################################################################################
# #
# Configure the muon pid monitor #
# #
################################################################################
from Configurables import MuIDMonitor, CombineParticles
from Configurables import FilterDesktop
from StandardParticles import StdNoPIDsPions, StdNoPIDsProtons, StdNoPIDsMuons
from PhysSelPython.Wrappers import Selection, SelectionSequence, DataOnDemand
MuPidMoniSeq_Lambda = GaudiSequencer("MuPidMoniSeq_Lambda")
MuPidMoniSeq_Jpsi = GaudiSequencer("MuPidMoniSeq_Jpsi")
#
# Make pions and protons
#
PionsFilter = FilterDesktop("PionsFilter")
PionsFilter.Code = "(P>3000*MeV) & (PT>100*MeV) & (TRCHI2DOF<2) & (ISLONG) & (MIPCHI2DV(PRIMARY)>9)"
PionsFilterSel = Selection("PionsFilterSel",
Algorithm=PionsFilter,
RequiredSelections=[StdNoPIDsPions])
ProtonsFilter = FilterDesktop("ProtonsFilter")
ProtonsFilter.Code = "(P>3000*MeV) & (PT>100*MeV) & (TRCHI2DOF<2) & (ISLONG) & (MIPCHI2DV(PRIMARY)>9)"
ProtonsFilterSel = Selection("ProtonsFilterSel",
Algorithm=ProtonsFilter,
RequiredSelections=[StdNoPIDsProtons])
#
# Make Lambda_0
#
LambdaMonitor = CombineParticles("LambdaMonitor")
LambdaMonitor.DecayDescriptor = "[Lambda0 -> p+ pi-]cc"
LambdaMonitor.CombinationCut = "(ADAMASS('Lambda0')<10*MeV)"
LambdaMonitor.MotherCut = "(50<BPVVDZ) & (600>BPVVDZ) & (BPVDIRA>0.9999995) & (CHILDCUT((PT>0.2*GeV),1) | CHILDCUT((PT>0.2*GeV),2)) & (ADWM('KS0', WM('pi+', 'pi-')) > 20*MeV)"
LambdaMonitorSel = Selection(
"LambdaMonitorSel",
Algorithm=LambdaMonitor,
RequiredSelections=[PionsFilterSel, ProtonsFilterSel])
LambdaMonitorSeq = SelectionSequence("LambdaMonitorSeq",
TopSelection=LambdaMonitorSel)
MuPidMoniSeq_Lambda.Members += [LambdaMonitorSeq.sequence()]
#
# Make muons and J/psi
#
mucocut = '(0.5<PPINFO(LHCb.ProtoParticle.InAccMuon,-1)) & (P>3*GeV) & (PT>800*MeV) & (TRCHI2DOF<3) & (ISLONG)'
tag1cuts = " (CHILDCUT(ISMUON,1)) & (CHILDCUT((P>6*GeV),1)) & (CHILDCUT((PT>1.5*GeV),1)) "
tag2cuts = " (CHILDCUT(ISMUON,2)) & (CHILDCUT((P>6*GeV),2)) & (CHILDCUT((PT>1.5*GeV),2)) "
probe2cuts = " ( (CHILDCUT((PPINFO(LHCb.ProtoParticle.CaloEcalE,-10000)<1000*MeV),2)) & (CHILDCUT((PPINFO(LHCb.ProtoParticle.CaloHcalE,-10000)<4000*MeV),2)) & (CHILDCUT((PPINFO(LHCb.ProtoParticle.CaloEcalE,-10000)>-10*MeV),2)) & (CHILDCUT((PPINFO(LHCb.ProtoParticle.CaloHcalE,-10000)>1000*MeV),2)) ) "
probe1cuts = " ( (CHILDCUT((PPINFO(LHCb.ProtoParticle.CaloEcalE,-10000)<1000*MeV),1)) & (CHILDCUT((PPINFO(LHCb.ProtoParticle.CaloHcalE,-10000)<4000*MeV),1)) & (CHILDCUT((PPINFO(LHCb.ProtoParticle.CaloEcalE,-10000)>-10*MeV),1)) & (CHILDCUT((PPINFO(LHCb.ProtoParticle.CaloHcalE,-10000)>1000*MeV),1)) ) "
child1cuts = tag1cuts + " & " + probe2cuts
child2cuts = tag2cuts + " & " + probe1cuts
MuonsFilter = FilterDesktop("MuonsFilter")
MuonsFilter.Code = mucocut
MuonsFilterSel = Selection("MuonsFilterSel",
Algorithm=MuonsFilter,
RequiredSelections=[StdNoPIDsMuons])
JpsiMonitor = CombineParticles("JpsiMonitor")
JpsiMonitor.DecayDescriptor = "J/psi(1S) -> mu+ mu-"
JpsiMonitor.CombinationCut = "(ADAMASS('J/psi(1S)')<300*MeV)"
JpsiMonitor.MotherCut = "(VFASPF(VCHI2/VDOF)<20) & ( " + child1cuts + " | " + child2cuts + " ) "
JpsiMonitor.OutputLevel = 6
JpsiMonitorSel = Selection("JpsiMonitorSel",
Algorithm=JpsiMonitor,
RequiredSelections=[MuonsFilterSel])
JpsiMonitorSeq = SelectionSequence("JpsiMonitorSeq",
TopSelection=JpsiMonitorSel)
MuPidMoniSeq_Jpsi.Members += [JpsiMonitorSeq.sequence()]
#
# Monitoring muon mis-id with Lambda_0
#
MuIDLambdaPlot = MuIDMonitor("MuIDLambdaPlot")
MuIDLambdaPlot.Inputs = [LambdaMonitorSel.outputLocation()]
MuIDLambdaPlot.OutputLevel = 6
MuIDLambdaPlot.MassMean = 1115.68
MuIDLambdaPlot.MassWindow = 20.
MuIDLambdaPlot.EffMassWin = 2.
MuIDLambdaPlot.JpsiAnalysis = 0
MuIDLambdaPlot.LambdaAnalysis = 1
MuIDLambdaPlot.HitInFoi = 1
MuIDLambdaPlot.PreSelMomentum = 3000. # MuonID preselection momentum (MeV/c)
MuIDLambdaPlot.MomentumCuts = [6000., 10000.
] # MuonID momentum cut ranges (MeV/c)
# MuonID FOI parameters
MuIDLambdaPlot.FOIfactor = 1.
MuIDLambdaPlot.XFOIParameter1 = [
5.5, 4.0, 3.3, 2.8, 5.2, 3.6, 2.4, 2.4, 5.7, 4.4, 2.8, 2.3, 5.1, 3.1,
2.3, 2.1, 5.8, 3.4, 2.6, 2.8
]
MuIDLambdaPlot.XFOIParameter2 = [
11., 3., 1., 1., 31., 28., 21., 17., 30., 31., 27., 22., 28., 33., 35.,
47., 31., 39., 56., 151.
]
MuIDLambdaPlot.XFOIParameter3 = [
0.20, 0.08, 0.03, 0.1, 0.06, 0.08, 0.10, 0.15, 0.04, 0.06, 0.09, 0.12,
0.08, 0.15, 0.23, 0.36, 0.07, 0.14, 0.24, 0.49
]
MuIDLambdaPlot.YFOIParameter1 = [
2.8, 1.7, -153., 1.9, 3.3, 2.1, 1.7, 1.6, 3.6, 2.8, 1.9, 1.8, 4.4, 3.3,
2.2, 2.2, 4.8, 3.9, 2.6, 2.3
]
MuIDLambdaPlot.YFOIParameter2 = [
3., 2., 156., 0., 17., 15., 9., 5., 26., 25., 16., 15., 30., 49., 57.,
92., 32., 55., 96., 166.
]
MuIDLambdaPlot.YFOIParameter3 = [
0.03, 0.02, 0.00, 0.09, 0.13, 0.19, 0.19, 0.24, 0.11, 0.19, 0.21, 0.32,
0.10, 0.22, 0.30, 0.52, 0.08, 0.20, 0.34, 0.52
]
#
# Parameters of the Landau functions
#
MuIDLambdaPlot.distMuon = [
0.311, 1.349, 0.524, 0.0020, 17., 10.6, 0.04, 4.1, 1.64
]
MuIDLambdaPlot.distPion = [
11., -12., 0.2029, -0.026, 0.06, 0.59, 0.008, -29., 41.
]
MuPidMoniSeq_Lambda.Members += [MuIDLambdaPlot]
#
# Monitoring muon id with J/psi
#
MuIDJpsiPlot = MuIDMonitor("MuIDJpsiPlot")
MuIDJpsiPlot.Inputs = [JpsiMonitorSel.outputLocation()]
MuIDJpsiPlot.OutputLevel = 6
MuIDJpsiPlot.MassMean = 3096.91
MuIDJpsiPlot.MassWindow = 300.
MuIDJpsiPlot.EffMassWin = 20.
MuIDJpsiPlot.JpsiAnalysis = 1
MuIDJpsiPlot.LambdaAnalysis = 0
MuIDJpsiPlot.HitInFoi = 1
MuIDJpsiPlot.PreSelMomentum = MuIDLambdaPlot.PreSelMomentum
MuIDJpsiPlot.MomentumCuts = MuIDLambdaPlot.MomentumCuts
# MuonID FOI parameters
MuIDJpsiPlot.FOIfactor = MuIDLambdaPlot.FOIfactor
MuIDJpsiPlot.XFOIParameter1 = MuIDLambdaPlot.XFOIParameter1
MuIDJpsiPlot.XFOIParameter2 = MuIDLambdaPlot.XFOIParameter2
MuIDJpsiPlot.XFOIParameter3 = MuIDLambdaPlot.XFOIParameter3
MuIDJpsiPlot.YFOIParameter1 = MuIDLambdaPlot.YFOIParameter1
MuIDJpsiPlot.YFOIParameter2 = MuIDLambdaPlot.YFOIParameter2
MuIDJpsiPlot.YFOIParameter3 = MuIDLambdaPlot.YFOIParameter3
#
# Parameters of the Landau functions
#
MuIDJpsiPlot.distMuon = MuIDLambdaPlot.distMuon
MuIDJpsiPlot.distPion = MuIDLambdaPlot.distPion
MuPidMoniSeq_Jpsi.Members += [MuIDJpsiPlot]
MuPidMoniSeq_Jpsi.IgnoreFilterPassed = True
MuPidMoniSeq_Lambda.IgnoreFilterPassed = True
seq.Members += [MuPidMoniSeq_Lambda, MuPidMoniSeq_Jpsi]
# set the options
class __MonAdd:
def __init__(self, s):
self.seq = s
def addMonitors(self):
# Append to processing
GaudiSequencer("PhysicsSeq").Members += [self.seq]
mon = __MonAdd(seq)
Gaudi.appendPostConfigAction(mon.addMonitors)
EventLoopMgr().OutputLevel = MSG_DEBUG #ERROR
EventLoopMgr().Warnings = False
brunel.UseDBSnapshot = True # try it
Brunel.Configuration.Brunel.configureOutput = dummy
HistogramPersistencySvc().OutputFile = ""
HistogramPersistencySvc().OutputLevel = MSG_ERROR
print brunel
return brunel
with loose PID cuts.
'''
from Gaudi.Configuration import *
from StrippingConf.StrippingLine import StrippingLine, StrippingMember
from Configurables import FilterDesktop, CombineParticles, OfflineVertexFitter
import GaudiKernel.SystemOfUnits as Units
################
# KS long long #
################
KSLLForBd2Jpsi2MuMuKS = FilterDesktop("StripKSLLForBd2Jpsi2MuMuKS")
KSLLForBd2Jpsi2MuMuKS.InputLocations = ["StdLooseKsLL"]
KSLLForBd2Jpsi2MuMuKS.Code = " (MINTREE( ('pi+'==ABSID), P) >2.*GeV)"\
"& (MINTREE( ('pi+'==ABSID), MIPCHI2DV(PRIMARY)) >9.)"\
"& (MAXTREE( ('pi+'==ABSID), TRCHI2DOF) <10.)"\
"& (VFASPF(VCHI2/VDOF)<10.)"\
"& (ADMASS('KS0') < 80.0*MeV)"
############################
# KS downstream downstream #
############################
KSDDForBd2Jpsi2MuMuKS = FilterDesktop("StripKSDDForBd2Jpsi2MuMuKS")
KSDDForBd2Jpsi2MuMuKS.InputLocations = ["StdLooseKsDD"]
KSDDForBd2Jpsi2MuMuKS.Code = " (MINTREE( ('pi+'==ABSID), P) >2.*GeV)"\
"& (MINTREE( ('pi+'==ABSID), MIPCHI2DV(PRIMARY)) >4.)"\
"& (MAXTREE( ('pi+'==ABSID), TRCHI2DOF) <20.)"\
"& (VFASPF(VCHI2/VDOF)<20.)"\
"& (ADMASS('KS0') < 100.0*MeV)"
################
#
# @author Patrick Koppenburg
# @date 2009-02-03
#
##############################################################################
from Gaudi.Configuration import *
from Configurables import DaVinci, SelDSTWriter
##############################################################################
from Configurables import GaudiSequencer, FilterDesktop
MessageSvc().Format = "% F%60W%S%7W%R%T %0W%M"
#
# Get a J/psi
#
jpsi = FilterDesktop('MyJpsi')
jpsi.Code = "ALL"
from PhysSelPython.Wrappers import Selection, DataOnDemand, SelectionSequence
MyLooseJpsi = DataOnDemand(Location = 'Phys/StdLooseJpsi2MuMu')
SelJpsi = Selection('SelJpsi',
Algorithm = jpsi,
RequiredSelections = [MyLooseJpsi])
SeqJpsi = SelectionSequence('SeqJpsi', TopSelection = SelJpsi)
#from MicroDSTExample.Selections import SeqBs2Jpsi2MuMuPhi2KK
#SeqBs = SeqBs2Jpsi2MuMuPhi2KK.SeqBs2Jpsi2MuMuPhi2KK
#
@ Created by R. LAmbert
@ date 2009-11-20
Mu selection for tests
Long track muons with PT > 1 GeV
"""
__author__ = 'R. Lambert'
__date__ = 'November 2009'
__version__ = '$Revision: 1.3 $'
import GaudiKernel.SystemOfUnits as Units
from Gaudi.Configuration import *
from Configurables import FilterDesktop, DaVinci
from PhysSelPython.Wrappers import Selection, DataOnDemand, SelectionSequence
from StandardParticles import StdLooseMuons as MyStdMuons
MuForTests = FilterDesktop("_bachelorMu")
MuForTests.Code = "((ISLONG) & (PT > 250.*MeV))"
SelMuForTests = Selection("BachelorMuForTests",
Algorithm=MuForTests,
RequiredSelections=[MyStdMuons])
from Configurables import CheckPV
checkPV = CheckPV('TestCheckPV')
TestSequence = SelectionSequence("TestSeq",
TopSelection=SelMuForTests,
EventPreSelector=[checkPV])
dv = DaVinci()
DaVinci().UserAlgorithms = [TestSequence.sequence()]
def __apply_configuration__(self) :
from Configurables import ( GaudiSequencer,
CombineParticles, FilterDesktop )
from PhysSelPython.Wrappers import Selection, SelectionSequence, DataOnDemand
if not self.isPropertySet("Sequencer") :
raise RuntimeError("ERROR : Sequence not set")
seq = self.getProp("Sequencer")
if self.getProp("RunSelection") :
# STD particles
from StandardParticles import StdNoPIDsPions, StdNoPIDsProtons
# Filter Pi Tracks
pionfilterName = self.__sel_name__+"_PiFilter"
pionfilter = FilterDesktop(pionfilterName)
pionfilter.Code = "(ISLONG) & (TRCHI2DOF < 3) & (PT > 0.1*GeV) & (MIPCHI2DV(PRIMARY) > 9)"
self.setOptions(pionfilter)
pionfilterSel = Selection( pionfilterName+'Sel',
Algorithm = pionfilter,
RequiredSelections = [StdNoPIDsPions] )
# Filter Proton Tracks
protonfilterName = self.__sel_name__+"_PrFilter"
protonfilter = FilterDesktop(protonfilterName)
protonfilter.Code = "(ISLONG) & (TRCHI2DOF < 3) & (PT > 0.4*GeV) & (MIPCHI2DV(PRIMARY) > 9)"
self.setOptions(protonfilter)
protonfilterSel = Selection( protonfilterName+'Sel',
Algorithm = protonfilter,
RequiredSelections = [StdNoPIDsProtons] )
# Make the Lambda
lambda2ppi = CombineParticles(self.__sel_name__)
lambda2ppi.DecayDescriptor = "[ Lambda0 -> p+ pi- ]cc"
lambda2ppi.CombinationCut = "(ADAMASS('Lambda0') < 100*MeV) & (AMAXDOCA('') < 0.2*mm)"
lambda2ppi.MotherCut = "(ADMASS('Lambda0') < 50.0*MeV) & (PT > 0.5*GeV) & (VFASPF(VCHI2/VDOF) < 6.0) & (MIPDV(PRIMARY) < 0.5) & (BPVVDCHI2 > 750) & (MIPCHI2DV(PRIMARY) < 200) & ( ADWM( 'KS0' , WM( 'pi+' , 'pi-') ) > 15*MeV ) & (LV01 < 0.98) & (LV02 < 0.98) & (LV01 > -0.98) & (LV02 > -0.98)"
self.setOptions(lambda2ppi)
lambda2ppiSel = Selection( self.__sel_name__+'Sel',
Algorithm = lambda2ppi,
RequiredSelections = [pionfilterSel,protonfilterSel] )
# Selection Sequence
selSeq = SelectionSequence( self.__sel_name__+'Seq', TopSelection = lambda2ppiSel )
# Run the selection sequence.
seq.Members += [selSeq.sequence()]
# Particle Monitoring plots
if self.getProp("RunMonitors") :
from Configurables import ParticleMonitor
plotter = ParticleMonitor(self.__sel_name__+"Plots")
if self.getProp("RunSelection") :
plotter.Inputs = [ 'Phys/'+self.__sel_name__+'Sel' ]
else:
plotter.Inputs = self.getProp("Candidates")
plotter.PeakCut = "(ADMASS('Lambda0')<2*MeV)"
plotter.SideBandCut = "(ADMASS('Lambda0')>2*MeV)"
plotter.PlotTools = self.getProp("PlotTools")
self.setOptions(plotter)
seq.Members += [ plotter ]
# Make a DST ?
if self.getProp("MakeSelDST"):
# Prescale
from Configurables import DeterministicPrescaler
scaler = DeterministicPrescaler( self.__sel_name__+'PreScale',
AcceptFraction = self.getProp("DSTPreScaleFraction") )
seq.Members += [scaler]
# Write the DST
MyDSTWriter = SelDSTWriter( self.__sel_name__+"DST",
SelectionSequences = [ selSeq ],
OutputPrefix = self.__sel_name__ )
seq.Members += [MyDSTWriter.sequence()]
# MC Performance checking ?
if self.getProp("MCChecks") :
from Configurables import ParticleEffPurMoni
mcPerf = ParticleEffPurMoni(lambda2ppiName+"MCPerf")
mcPerf.Inputs = ["Phys/"+lambda2ppiName]
self.setOptions(mcPerf)
seq.Members += [mcPerf]
# Ntuple ?
if self.getProp("MakeNTuple") : pass
# MyStream.appendLines( [ line ] )
# sc = StrippingConf( HDRLocation = "MyStrip", Streams = [ MyStream ] )
# #------------------------------------------------------------------------
#----selection p+ and K- and Lambda0 -------------------------
# protons = DataOnDemand(Location = "Phys/StdNoPIDsProtons/Particles")
# protons = DataOnDemand(Location = "Phys/StdLooseProtons/Particles")
# pions = DataOnDemand(Location = "Phys/StdLoosePions/Particles")
Lambda0LL = DataOnDemand(Location = "Phys/StdLooseLambdaLL/Particles")
Lambda0DD = DataOnDemand(Location = "Phys/StdLooseLambdaDD/Particles")
AllLambda0 = MergedSelection( "AllLambda0", RequiredSelections = [Lambda0LL, Lambda0DD])
#----Selection /\->p+ pi-
_FilterL = FilterDesktop("_FilterL")
_FilterL.Code = "(ADMASS('Lambda0') < 30.*MeV)"\
"& (VFASPF(VCHI2/VDOF) < 12.0)"
FilterL = Selection( "FilterL",
Algorithm = _FilterL ,
RequiredSelections = [ AllLambda0 ] )
# _L2ppi = CombineParticles( "_L2ppi",
# DecayDescriptor = "[Lambda0 -> p+ pi-]cc",
# CombinationCut = "(ADMASS('Lambda0') < 30.*MeV) & (VFASPF(VCHI2/VDOF) < 12.0)",
# # CombinationCut = "AM < 2700. * MeV",
# MotherCut = "(VFASPF(VCHI2/VDOF)<2500) & (BPVDIRA > 0.9)",
# # MotherCut = "(VFASPF(VCHI2/VDOF)<25) & (BPVDIRA > 0.999) & (VFASPF(VCHI2PDOF) < 10)",# & (BPVVD > 1.5 *mm)",
# # MotherCut = "(ADMASS('Lambda0') < 30.*MeV)"\
# # "& (VFASPF(VCHI2/VDOF) < 12.0)",
# ReFitPVs = False )
# L2ppi = Selection( "L2ppi",
def __apply_configuration__(self):
from Configurables import (GaudiSequencer, CombineParticles,
FilterDesktop)
from PhysSelPython.Wrappers import Selection, SelectionSequence, DataOnDemand
if not self.isPropertySet("Sequencer"):
raise RuntimeError("ERROR : Sequence not set")
seq = self.getProp("Sequencer")
if self.getProp("RunSelection"):
# STD particles
from StandardParticles import StdNoPIDsPions
# Filter Pi Tracks
pionFilterName = self.__sel_name__ + "_PiFilter"
pionfilter = FilterDesktop(pionFilterName)
pionfilter.Code = "(ISLONG) & (TRCHI2DOF < 5) & (P > 2*GeV) & (MIPCHI2DV(PRIMARY) > 30)"
self.setOptions(pionfilter)
pionfilterSel = Selection(pionFilterName + 'Sel',
Algorithm=pionfilter,
RequiredSelections=[StdNoPIDsPions])
# Make the KS0
ks02pipi = CombineParticles(self.__sel_name__)
ks02pipi.DecayDescriptor = "KS0 -> pi+ pi-"
ks02pipi.CombinationCut = "(ADAMASS('KS0') < 200*MeV) & (AMAXDOCA('') < 0.6*mm)"
ks02pipi.MotherCut = "(ADMASS('KS0') < 100*MeV) & (VFASPF(VCHI2/VDOF) < 10) & (MIPDV(PRIMARY) < 0.75) & (BPVVDCHI2 > 150) & (MIPCHI2DV(PRIMARY) < 100) & ( ADWM( 'Lambda0' , WM( 'p+' , 'pi-') ) > 8*MeV ) & ( ADWM( 'Lambda0' , WM( 'pi+' , 'p~-') ) > 8*MeV )"
self.setOptions(ks02pipi)
ks02pipiSel = Selection(self.__sel_name__ + 'Sel',
Algorithm=ks02pipi,
RequiredSelections=[pionfilterSel])
# Selection Sequence
selSeq = SelectionSequence(self.__sel_name__ + 'Seq',
TopSelection=ks02pipiSel)
# Run the selection sequence.
seq.Members += [selSeq.sequence()]
# Particle Monitoring plots
if self.getProp("RunMonitors"):
from Configurables import ParticleMonitor
plotter = ParticleMonitor(self.__sel_name__ + "Plots")
if self.getProp("RunSelection"):
plotter.Inputs = ['Phys/' + self.__sel_name__ + 'Sel']
else:
plotter.Inputs = self.getProp("Candidates")
plotter.PeakCut = "(ADMASS('KS0')<7*MeV)"
plotter.SideBandCut = "(ADMASS('KS0')>7*MeV)"
plotter.PlotTools = self.getProp("PlotTools")
self.setOptions(plotter)
seq.Members += [plotter]
# Make a DST ?
if self.getProp("MakeSelDST"):
# Prescale
from Configurables import DeterministicPrescaler
scaler = DeterministicPrescaler(
self.__sel_name__ + 'PreScale',
AcceptFraction=self.getProp("DSTPreScaleFraction"))
seq.Members += [scaler]
# Write the DST
MyDSTWriter = SelDSTWriter(self.__sel_name__ + "DST",
SelectionSequences=[selSeq],
OutputPrefix=self.__sel_name__)
seq.Members += [MyDSTWriter.sequence()]
# MC Performance checking ?
if self.getProp("MCChecks"):
from Configurables import ParticleEffPurMoni
#mcPerfPi = ParticleEffPurMoni("StdNoPIDsPionsMCPerf")
#mcPerfPi.Inputs = ["Phys/StdNoPIDsPions"]
#mcPerfPi.OutputLevel = DEBUG
#seq.Members += [mcPerfPi]
#mcPerfPiFilt = ParticleEffPurMoni(pionFilterName+"MCPerf")
#mcPerfPiFilt.Inputs = ["Phys/"+pionFilterName]
#seq.Members += [mcPerfPiFilt]
mcPerfD = ParticleEffPurMoni(ks02pipiName + "MCPerf")
mcPerfD.Inputs = ["Phys/" + ks02pipiName]
self.setOptions(mcPerfD)
seq.Members += [mcPerfD]
# Ntuple ?
if self.getProp("MakeNTuple"): pass
Bu2LLK09_DiLepton.Inputs = ["Phys/StdLooseElectrons", "Phys/StdLooseMuons"]
Bu2LLK09_DiLepton.DecayDescriptors = [
"J/psi(1S) -> e+ e-", "J/psi(1S) -> mu+ mu-"
]
Bu2LLK09_DiLepton.DaughtersCuts = {"e+": leptoncut, "mu+": leptoncut}
Bu2LLK09_DiLepton.CombinationCut = "(AM<6*GeV)"
Bu2LLK09_DiLepton.MotherCut = "(VFASPF(VCHI2/VDOF)<25)"
###########################################################################
# Preselection
#
Presel09Bu2LLK = CombineParticles("Presel09Bu2LLK")
Sel09Bu2LLKFilterSequence.Members += [Presel09Bu2LLK]
Presel09Bu2LLK.Inputs = ["Phys/Bu2LLK09_DiLepton", "Phys/StdLooseKaons"]
Presel09Bu2LLK.DecayDescriptor = "[ B+ -> J/psi(1S) K+ ]cc"
Presel09Bu2LLK.DaughtersCuts = {"K+": kaoncut, "J/psi(1S)": llcut}
Presel09Bu2LLK.CombinationCut = combcut
Presel09Bu2LLK.MotherCut = bcut
##########################################################################
# Selection
#
from Configurables import FilterDesktop
Sel09Bu2LLK = FilterDesktop("Sel09Bu2LLK")
Sel09Bu2LLK.Inputs = ["Phys/Presel09Bu2LLK"]
Sel09Bu2LLK.Code = hardkaon + " & (" + hardelectron + " | " + hardmuon + " ) & " + harddilepton + " & " + hardB
Sel09Bu2LLKFilterSequence.Members += [Sel09Bu2LLK]
##########################################################################
#ApplicationMgr().TopAlg += [ Sel09Bu2LLKFilterSequence ]
from Configurables import TupleToolTISTOS, TriggerTisTos
EVTMAX = -1
MODE = 'data'
OUTPUTLEVEL = ERROR
#########################################################################################################
# Build the candidates, with selections following the WG productions
#########################################################################################################
############
InputJpsi = AutomaticData(
Location='/Event/Dimuon/Phys/FullDSTDiMuonJpsi2MuMuDetachedLine/Particles')
FilteredJpsi = FilterDesktop("FilteredJpsi")
FilteredJpsi.Code = "(INTREE((ABSID=='mu+')&(PT>550*MeV)&(TRCHI2DOF<4)&(PIDmu>0)))"
SelJpsi = Selection("Selpsi",
Algorithm=FilteredJpsi,
RequiredSelections=[InputJpsi])
############
SelPhotons = AutomaticData(Location='Phys/StdLooseAllPhotons/Particles')
MakeChic2JpsiGamma = CombineParticles("MakeChic2JpsiGamma")
MakeChic2JpsiGamma.DecayDescriptors = ['chi_c1(1P) -> J/psi(1S) gamma']
MakeChic2JpsiGamma.CombinationCut = "( AM - AM1 ) < 700 * MeV"
MakeChic2JpsiGamma.MotherCut = "MM<10000.*MeV"
MakeChic2JpsiGamma.DaughtersCuts = {
"J/psi(1S)": "M < ( 3.100 + 0.120 ) * GeV",
'gamma': "PT > 400 * MeV "
# MyLines = [ 'StrippingFullDSTDiMuonJpsi2MuMuDetachedLine' ]
# for stream in streams:
# for line in stream.lines:
# if line.name() in MyLines:
# MyStream.appendLines( [ line ] )
# sc = StrippingConf( HDRLocation = "MyStrip", Streams = [ MyStream ] )
# #------------------------------------------------------------------------
#----Jpsi->mumu---------------------------------
J2MuMu = AutomaticData(Location = "Phys/FullDSTDiMuonJpsi2MuMuDetachedLine/Particles")
_Jpsi2MuMu = FilterDesktop("_J2MuMu")
_Jpsi2MuMu.Code = "(ADMASS('J/psi(1S)')<50*MeV)"\
"& (MINTREE(ABSID=='mu+',PT)>500*MeV)"\
"& (MINTREE(ABSID=='mu+',TRCHI2DOF)<4)"
Jpsi2MuMu = Selection("FilterJ",
Algorithm = _Jpsi2MuMu ,
RequiredSelections = [ J2MuMu ] )
#----Selection K*->K+ pi-
Kstar2Kpi = DataOnDemand(Location = "Phys/StdLooseKstar2Kpi/Particles")
_Kst2Kpi = FilterDesktop("_Kst2Kpi")
_Kst2Kpi.Code = "(ADMASS('K*(892)0') < 100.*MeV)"\
# "& (VFASPF(VCHI2/VDOF) < 4)"\
# "& (MINTREE(ABSID=='K+',PT)>250*MeV)"\
# "& (MINTREE(ABSID=='pi-',PT)>250*MeV)"\
# "& ((MINTREE(ABSID=='K+',PT)+MINTREE(ABSID=='pi-',PT))>900*MeV)"\
def __apply_configuration__(self):
from Configurables import (GaudiSequencer, CombineParticles,
FilterDesktop)
from PhysSelPython.Wrappers import Selection, SelectionSequence, DataOnDemand
if not self.isPropertySet("Sequencer"):
raise RuntimeError("ERROR : Sequence not set")
seq = self.getProp("Sequencer")
if self.getProp("RunSelection"):
# STD particles
from StandardParticles import StdNoPIDsPions, StdNoPIDsKaons
# Filter Pi/K Tracks
trackfilterName = self.__sel_name__ + "_TrackFilter"
trackfilter = FilterDesktop(trackfilterName)
trackfilter.Code = "(PT > 0.4*GeV) & (P > 2.0*GeV) & (TRCHI2DOF < 10) & (MIPCHI2DV(PRIMARY) > 6)"
self.setOptions(trackfilter)
trackfilterSel = Selection(
trackfilterName + 'Sel',
Algorithm=trackfilter,
RequiredSelections=[StdNoPIDsPions, StdNoPIDsKaons])
# Filter Pi Tracks
pionfilterName = self.__sel_name__ + "_PiFilter"
pionfilter = FilterDesktop(pionfilterName)
pionfilter.Code = "(PT > 110*MeV) & (MIPCHI2DV(PRIMARY) > 2)"
self.setOptions(pionfilter)
pionfilterSel = Selection(pionfilterName + 'Sel',
Algorithm=pionfilter,
RequiredSelections=[StdNoPIDsPions])
# Make the D0
d02kpiName = self.__sel_name__ + "_D0ToKPiSel"
d02kpi = CombineParticles(d02kpiName)
d02kpi.DecayDescriptor = "[ D0 -> K- pi+ ]cc"
d02kpi.CombinationCut = "(ADAMASS('D0') < 100*MeV)"
d02kpi.MotherCut = "(ADMASS('D0') < 50.0*MeV)"\
"& (PT > 1.00*GeV)"\
"& (VFASPF(VCHI2/VDOF)< 10.0)"\
"& (BPVDIRA > 0.9999)"\
"& (BPVVDCHI2 > 12)"
self.setOptions(d02kpi)
d02kpiSel = Selection(d02kpiName + 'Sel',
Algorithm=d02kpi,
RequiredSelections=[trackfilterSel])
# Make the D*
dstar2d0piName = self.__sel_name__
dstar2d0pi = CombineParticles(dstar2d0piName)
dstar2d0pi.DecayDescriptor = "[ D*(2010)+ -> D0 pi+ ]cc"
dstar2d0pi.CombinationCut = "(ADAMASS('D*(2010)+') < 100*MeV)"
dstar2d0pi.MotherCut = "(ADMASS('D*(2010)+') < 50.0*MeV)"\
"& (PT > 2.2*GeV)"\
"& (VFASPF(VCHI2/VDOF)< 15.0)"\
"& (M-MAXTREE('D0'==ABSID,M)<155.5)"
self.setOptions(dstar2d0pi)
dstar2d0piSel = Selection(
dstar2d0piName + 'Sel',
Algorithm=dstar2d0pi,
RequiredSelections=[d02kpiSel, pionfilterSel])
# Selection Sequence
selSeq = SelectionSequence(self.__sel_name__ + 'Seq',
TopSelection=dstar2d0piSel)
# Run the selection sequence.
seq.Members += [selSeq.sequence()]
# Particle Monitoring plots
if self.getProp("RunMonitors"):
from Configurables import ParticleMonitor
plotter = ParticleMonitor(self.__sel_name__ + "Plots")
if self.getProp("RunSelection"):
plotter.Inputs = ['Phys/' + self.__sel_name__ + 'Sel']
else:
plotter.Inputs = self.getProp("Candidates")
plotter.PeakCut = "(M-MAXTREE('D0'==ABSID,M)<147.43) "\
"& (M-MAXTREE('D0'==ABSID,M)>143.43) "\
"& (INTREE((ABSID=='D0') & (ADMASS('D0') < 15*MeV) ))"
plotter.SideBandCut = "(M-MAXTREE('D0'==ABSID,M)>147.43) "\
"& (M-MAXTREE('D0'==ABSID,M)<143.43) "\
"& (INTREE((ABSID=='D0') & (ADMASS('D0') > 15*MeV) ))"
plotter.PlotTools = self.getProp("PlotTools")
self.setOptions(plotter)
seq.Members += [plotter]
# Make a DST ?
if self.getProp("MakeSelDST"):
# Prescale
from Configurables import DeterministicPrescaler
scaler = DeterministicPrescaler(
self.__sel_name__ + 'PreScale',
AcceptFraction=self.getProp("DSTPreScaleFraction"))
seq.Members += [scaler]
# Write the DST
MyDSTWriter = SelDSTWriter(self.__sel_name__ + "DST",
SelectionSequences=[selSeq],
OutputPrefix=self.__sel_name__)
seq.Members += [MyDSTWriter.sequence()]
# MC Performance checking ?
if self.getProp("MCChecks"):
from Configurables import ParticleEffPurMoni
mcPerf = ParticleEffPurMoni(dstar2d0piName + "MCPerf")
mcPerf.Inputs = ["Phys/" + dstar2d0piName]
self.setOptions(mcPerf)
seq.Members += [mcPerf]
# Ntuple ?
if self.getProp("MakeNTuple"): pass
from Configurables import CombineParticles, FilterDesktop
from Configurables import TupleToolMCBackgroundInfo, TupleToolMCTruth, BackgroundCategory
from StrippingConf.StrippingLine import StrippingLine
########################################################################
B2DhOfflineDplus2KPiPi = CombineParticles("B2DhOfflineDplus2KPiPi")
B2DhOfflineDplus2KPiPi.InputLocations = [ "StdTightPions", "StdTightKaons" ]
B2DhOfflineDplus2KPiPi.DecayDescriptor = "[D+ -> K- pi+ pi+]cc"
B2DhOfflineDplus2KPiPi.DaughtersCuts = {"pi+" : "((PT > 300*MeV) & (P > 2*GeV) & (MIPCHI2DV(PRIMARY) > 9))" , "K+" : "((PT> 300*MeV) & (P > 2*GeV) & (MIPCHI2DV(PRIMARY) > 9))"};
B2DhOfflineDplus2KPiPi.CombinationCut = "( (ADAMASS('D+') < 21*MeV) & (APT > 2.*GeV) )";
B2DhOfflineDplus2KPiPi.MotherCut = "((VFASPF(VCHI2/VDOF)<15) & (BPVVDCHI2>100.) & (MIPCHI2DV(PRIMARY)>9))";
########################################################################
B2DhOfflineBachelor = FilterDesktop("B2DhOfflineBachelor")
B2DhOfflineBachelor.InputLocations = [ "StdLoosePions" ]
B2DhOfflineBachelor.Code = "((PT > 500*MeV) & (P > 2*GeV) & (MIPCHI2DV(PRIMARY) > 9))"
########################################################################
B2DhOfflineSel = CombineParticles("B2DhOfflineSel")
B2DhOfflineSel.InputLocations = [ "B2DhOfflineDplus2KPiPi",
"B2DhOfflineBachelor"]
B2DhOfflineSel.DecayDescriptor = "[B0 -> D+ pi-]cc"
B2DhOfflineSel.DaughtersCuts = { "D+" : "ALL" }
B2DhOfflineSel.CombinationCut = "(ADAMASS('B0')<50*MeV)"
B2DhOfflineSel.MotherCut = "(VFASPF(VCHI2/VDOF)<10) & (BPVIPCHI2()<16.) & (BPVVDCHI2 > 6.25) & (BPVDIRA>0.9999)"
########################################################################
B2DhOfflineFilterSequence = GaudiSequencer("B2DhOfflineFilterSequence")
B2DhOfflineFilterSequence.Members += [ B2DhOfflineDplus2KPiPi ]
B2DhOfflineFilterSequence.Members += [ B2DhOfflineBachelor ]
B2DhOfflineFilterSequence.Members += [ B2DhOfflineSel ]
########################################################################
########################################################################
configurables. PV refitting is done. Based on roadmap selection
with loose PID cuts.
'''
from Gaudi.Configuration import *
from StrippingConf.StrippingLine import StrippingLine, StrippingMember
from Configurables import FilterDesktop, CombineParticles, OfflineVertexFitter
import GaudiKernel.SystemOfUnits as Units
#############################
# Standard Unbiased Phi->KK #
#############################
StdUnbiasedPhi2KK = FilterDesktop("StripStdUnbiasedPhi2KK")
StdUnbiasedPhi2KK.InputLocations = ["StdLooseUnbiasedPhi2KK"]
StdUnbiasedPhi2KK.Code = " (MINTREE('K+'==ABSID, PIDK) > -5.0)" \
"& (ADMASS('phi(1020)') < 15.*MeV)" \
"& (PT > 1000.*MeV)" \
"& (VFASPF(VCHI2/VDOF) < 20.0)"
######
# Bs #
######
Bs2JpsiPhi = CombineParticles("StripBs2JpsiPhi")
Bs2JpsiPhi.DecayDescriptor = "B_s0 -> J/psi(1S) phi(1020)"
Bs2JpsiPhi.InputLocations = [
"StdLTUnbiasedJpsi2MuMu", "StripStdUnbiasedPhi2KK"
]
# Set the OfflineVertexFitter to keep the 4 tracks and not the J/Psi Phi
Bs2JpsiPhi.addTool(OfflineVertexFitter())
Bs2JpsiPhi.VertexFitters.update({"": "OfflineVertexFitter"})
Bs2JpsiPhi.OfflineVertexFitter.useResonanceVertex = False
Bs2JpsiPhi.ReFitPVs = True
# =============================================================================
__author__ = " Albert Bursche "
__date__ = " 2011-07-22 "
__version__ = "0.1"
# =============================================================================
# =============================================================================
"""
Select MC particles having a chance to pass the offline criteria. Needs updating if these citeria change.
"""
from Configurables import FilterDesktop
MCPartFilter = FilterDesktop("FilteredStableParticles") #,OutputLevel = DEBUG)
MCPartFilter.InputLocations = ["Phys/StdHepMCParticles/Particles"]
MCPartFilter.Code = "(PT > 150*MeV) & (ETA >0)" # corresponds to an 200 MeV cut on reco tracks
# eta cut for speed optimisation
OutputTightKaonList = "Phys/Tag_CharmTightKaonList/Particles"
OutputKSList = "Phys/Tag_CharmKSList/Particles"
OutputProtonList = "Phys/Tag_CharmProtonList/Particles"
CharmPreambulo = [
"from LoKiPhysMC.decorators import *" ,
"from LoKiPhysMC.functions import mcMatch",
"from GaudiKernel.SystemOfUnits import *"
]
# =============================================================================
# PARTICLE LISTS #
Tag_CharmElecList = FilterDesktop("Tag_CharmElecList")
Tag_CharmElecList.Code = "(PT>100*MeV) & (P>1000*MeV) & (BPVIPCHI2() > 4.0) & (PROBNNe > 0.05) & (PROBNNmu < 0.35) & (PROBNNghost < 0.35)"
Tag_CharmElecList.Inputs = [InputElecList]
Tag_CharmElecList.Output = OutputElecList
locations = updateDoD(Tag_CharmElecList)
#Tag_CharmRecSeq.Members += [Tag_CharmElecList]
Tag_CharmMuonList = FilterDesktop("Tag_CharmMuonList")
Tag_CharmMuonList.Code = "(PT>100*MeV) & (P>1000*MeV) & (BPVIPCHI2() > 4.0) & (PROBNNmu > 0.05) & (PROBNNe < 0.35) & (PROBNNghost < 0.35)"
Tag_CharmMuonList.Inputs = [InputMuonList]
Tag_CharmMuonList.Output = OutputMuonList
locations.update(updateDoD(Tag_CharmMuonList))
#Tag_CharmRecSeq.Members += [Tag_CharmMuonList]
Tag_CharmPionList = FilterDesktop("Tag_CharmPionList")
Tag_CharmPionList.Code = "(PT>100*MeV) & (P>1000*MeV) & (BPVIPCHI2() > 4.0) & (PROBNNK < 0.35) & (PROBNNghost < 0.35)"
Tag_CharmPionList.Inputs = [InputPionList]
Jpsi2MuMu = AutomaticData(Location = location)
#----selection p+ and K- -------------------------
kaons = DataOnDemand(Location = "/Event/Phys/StdNoPIDsKaons/Particles")
protons = DataOnDemand(Location = "/Event/Phys/StdNoPIDsProtons/Particles")
Lambda0LL = DataOnDemand(Location = "/Event/Phys/StdLooseLambdaLL/Particles")
Lambda0DD = DataOnDemand(Location = "/Event/Phys/StdLooseLambdaDD/Particles")
#----Selection /\->p+ pi-
AllLambda0 = MergedSelection( "AllLambda0", RequiredSelections = [Lambda0LL, Lambda0DD])
_FilterL = FilterDesktop("_FilterL")
_FilterL.Code = "(ADMASS('Lambda0') < 30.*MeV)"\
"& (VFASPF(VCHI2/VDOF) < 12.0)"\
"& (ADWM( 'KS0' , WM( 'pi+' , 'pi-') ) > 20*MeV )"
FilterL = Selection( "FilterL",
Algorithm = _FilterL ,
RequiredSelections = [ AllLambda0 ] )
#----Selection /\b -> J/psi p+ K-------------------
_Lb2JpsipK = CombineParticles( "_Lb2JpsipK",
DecayDescriptor = "[Lambda_b0 -> J/psi(1S) Lambda0]cc",
CombinationCut = "AM < 6000. * MeV",
MotherCut = "(VFASPF(VCHI2/VDOF)<25) & (BPVDIRA > 0.999) & (VFASPF(VCHI2PDOF) < 10) & (BPVVD > 1.5 *mm)",
# DaughtersCuts = { 'K-': DaughtCutK },
ReFitPVs = True )
"""
__author__ = "Greig Cowan"
__version__ = "CVS tag $Name: not supported by cvs2svn $, version $Revision: 1.2 $"
# =============================================================================
__all__ = ('StdLTUnbiasedJpsi2MuMu', 'locations')
# =============================================================================
from Gaudi.Configuration import *
from Configurables import FilterDesktop
from CommonParticles.Utils import *
## ============================================================================
StdLTUnbiasedJpsi2MuMu = FilterDesktop("StdLTUnbiasedJpsi2MuMu")
StdLTUnbiasedJpsi2MuMu.Inputs = ["Phys/StdLooseJpsi2MuMu/Particles"]
StdLTUnbiasedJpsi2MuMu.Code = " (MINTREE('mu+'==ABSID, PT) > 500.*MeV)" \
"& (MINTREE('mu+'==ABSID, PIDmu) > -10.0)" \
"& (MAXTREE('mu+'==ABSID, PIDK) < 10.0)" \
"& (ADMASS('J/psi(1S)') < 50.*MeV)" \
"& (PT > 1000.*MeV)" \
"& (VFASPF(VCHI2) < 6.0)"
## configure Data-On-Demand service
locations = updateDoD(StdLTUnbiasedJpsi2MuMu)
## ============================================================================
if '__main__' == __name__:
print __doc__
print __author__
print __version__
print locationsDoD(locations)
"""
Configuration file for Standard Loose Kstar2Kpi
"""
__author__ = 'Diego Martinez Santos, P. Koppenburg'
__date__ = '29/06/2009'
from Gaudi.Configuration import *
from Configurables import FilterDesktop
from CommonParticles.Utils import *
import GaudiKernel.SystemOfUnits as Units
###########################
# StdLooseDetachetKst2Kpi #
###########################
StdLooseDetachedKst2Kpi = FilterDesktop("StdLooseDetachedKst2Kpi")
StdLooseDetachedKst2Kpi.Inputs = ["Phys/StdVeryLooseDetachedKst2Kpi/Particles"]
StdLooseDetachedKst2Kpi.Code = "(MIPCHI2DV(PRIMARY)> 2.25)"
locations = updateDoD(StdLooseDetachedKst2Kpi)
# =============================================================================
__author__ = "Albert Bursche"
__date__ = " 2011-07-22 "
__version__ = "0.1"
# =============================================================================
# =============================================================================
"""
Select a track sample for jet reconstruction.
"""
from Configurables import FilterDesktop
SelectedTracks = FilterDesktop("FilteredPions") #,OutputLevel = DEBUG)
SelectedTracks.InputLocations = [
"/Event/Phys/StdNoPIDsPions/Particles", "Phys/StdNoPIDsDownPions/Particles"
]
SelectedTracks.Code = "(PT > 200*MeV) & (PERR2/(P*P) < 0.04) "
#SelectedTracks.Preambulo = [ "from LoKiProtoParticles.decorators import *"]
