def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
self.__confdict__ = config
self.GECs = {
"Code":
"( recSummaryTrack(LHCb.RecSummary.nLongTracks, TrLONG) < %(GEC_nLongTrk)s )"
% config,
"Preambulo": ["from LoKiTracks.decorators import *"]
}
#== selection of standard particles
self.Kaon1Cuts = "(TRCHI2DOF < 3) & (TRGHOSTPROB < 0.5) & (PT > %(K1PT)s *MeV) &"\
"(MIPCHI2DV(PRIMARY) < %(K1MinIPChi2)s) & "\
"(PIDK-PIDpi > %(K1PIDK)s) & (PIDK-PIDp > 0) & (PIDK-PIDmu > 0)" %config
self.Kaon1CutsLoose = "(TRCHI2DOF < 3) & (TRGHOSTPROB < 0.5) & (PT > %(K1PTLoose)s *MeV) &"\
"(MIPCHI2DV(PRIMARY) < %(K1MinIPChi2)s) & "\
"(PIDK-PIDpi > %(K1PIDK)s) & (PIDK-PIDp > 0) & (PIDK-PIDmu > 0)" %config
self.Kaon2Cuts = "(TRCHI2DOF < 3) & (TRGHOSTPROB < 0.5) & "\
"(P > %(K2P)s *MeV) & (PT > %(K2PT)s *MeV) & "\
"(MIPCHI2DV(PRIMARY) > %(K2MinIPChi2)s) & "\
"(PIDK-PIDpi > %(K2PIDK)s) & (PIDK-PIDp > 0) & (PIDK-PIDmu > 0)" %config
self.MuonCuts = "(TRCHI2DOF < 3) & (TRGHOSTPROB < 0.5) & "\
"(P > %(MuP)s *MeV) & (PT > %(MuPT)s *MeV) & "\
"(MIPCHI2DV(PRIMARY) > %(MuMinIPChi2)s) & "\
"(PIDmu-PIDK > 0) & (PIDmu-PIDp > 0) & (PIDmu-PIDpi > %(MuPIDmu)s)" %config
self.JpsiCuts = "(PFUNA(ADAMASS('J/psi(1S)')) < %(JpsiMassWindow)s * MeV)" % config
self.SelKaon1 = Selection("K1_for" + name,
Algorithm=FilterDesktop(Code=self.Kaon1Cuts),
RequiredSelections=[StdAllLooseKaons])
self.SelKaon1Loose = Selection(
"K1Loose_for" + name,
Algorithm=FilterDesktop(Code=self.Kaon1CutsLoose),
RequiredSelections=[StdAllLooseKaons])
self.SelKaon2 = Selection("K2_for" + name,
Algorithm=FilterDesktop(Code=self.Kaon2Cuts),
RequiredSelections=[StdLooseKaons])
self.SelMuon = Selection("Mu_for" + name,
Algorithm=FilterDesktop(Code=self.MuonCuts),
RequiredSelections=[StdLooseMuons])
self.SelJpsi = Selection(
"Jpsi_for" + name,
Algorithm=FilterDesktop(Code=self.JpsiCuts),
RequiredSelections=[StdMassConstrainedJpsi2MuMu])
# B -> K Mu X, both opposite & same signed K mu can be signals
self.Bu2KMu = CombineParticles(
DecayDescriptors=["[B+ -> K+ mu-]cc", "[B+ -> K+ mu+]cc"])
self.Bu2KMu.CombinationCut = "(AM > %(KMuMassMin)s*MeV) & (AM < %(KMuMassMax)s*MeV)" % config
self.Bu2KMu.MotherCut = "(VFASPF(VCHI2/VDOF) < %(KMuVChi2Dof)s) & (BPVDIRA > 0.99) & "\
"(BPVVDCHI2 > %(KMuFdChi2)s)" % config
self.Bu2KMu.ReFitPVs = True
self.SelBu2KMu = Selection(
"Bu2KMu_for" + name,
Algorithm=self.Bu2KMu,
RequiredSelections=[self.SelKaon2, self.SelMuon])
# B -> K J/psi
self.Bu2KJpsi = CombineParticles(
DecayDescriptors=["[B+ -> J/psi(1S) K+]cc"])
self.Bu2KJpsi.CombinationCut = "(AM > %(KJpsiMassMin)s*MeV) & (AM < %(KJpsiMassMax)s*MeV)" % config
self.Bu2KJpsi.MotherCut = "(VFASPF(VCHI2/VDOF) < %(KJpsiVChi2Dof)s) & (BPVDIRA > 0.99) & "\
"(BPVVDCHI2 > %(KJpsiFdChi2)s)" % config
self.Bu2KJpsi.ReFitPVs = True
self.SelBu2KJpsi = Selection(
"Bu2KJpsi_for" + name,
Algorithm=self.Bu2KJpsi,
RequiredSelections=[self.SelKaon2, self.SelJpsi])
# B_s2*0 -> (B -> K Mu X) K, signal KK have opposite signed charge.
self.Bs2KKMu = CombineParticles(DecayDescriptor="[B*_s20 -> B+ K-]cc")
self.Bs2KKMu.CombinationCut = "(AM-AM1 < %(DMKKMu)s*MeV) & "\
"(abs(ACHILD(BPV(VZ),1)-ACHILD(BPV(VZ),2))<%(DZBPV)s*mm)" % config
self.Bs2KKMu.MotherCut = "(PT > %(Bs2PT)s*MeV)" % config
self.Bs2KKMu.ReFitPVs = False
self.SelBs2KKMu = Selection(
"Bs2KKMu_for" + name,
Algorithm=self.Bs2KKMu,
RequiredSelections=[self.SelBu2KMu, self.SelKaon1])
# B_s2*0 -> (B -> K Mu X) K, same signed KK for back ground
self.Bs2KKMuWS = CombineParticles(
DecayDescriptor="[B*_s20 -> B+ K+]cc")
self.Bs2KKMuWS.CombinationCut = self.Bs2KKMu.CombinationCut
self.Bs2KKMuWS.MotherCut = self.Bs2KKMu.MotherCut
self.Bs2KKMuWS.ReFitPVs = self.Bs2KKMu.ReFitPVs
self.SelBs2KKMuWS = Selection(
"Bs2KKMuWS_for" + name,
Algorithm=self.Bs2KKMuWS,
RequiredSelections=[self.SelBu2KMu, self.SelKaon1])
# B_s2*0 -> (B -> K Jpsi) K, signal KK have opposite signed charge.
self.Bs2KKJpsi = CombineParticles(
DecayDescriptor="[B*_s20 -> B+ K-]cc")
self.Bs2KKJpsi.CombinationCut = "(AM-AM1 < %(DMKKJpsi)s*MeV) & "\
"(abs(ACHILD(BPV(VZ),1)-ACHILD(BPV(VZ),2))<%(DZBPV)s*mm)" % config
self.Bs2KKJpsi.MotherCut = "(PT > %(Bs2PT)s*MeV)" % config
self.Bs2KKJpsi.ReFitPVs = False
self.SelBs2KKJpsi = Selection(
"Bs2KKJpsi_for" + name,
Algorithm=self.Bs2KKJpsi,
RequiredSelections=[self.SelBu2KJpsi, self.SelKaon1Loose])
# B_s2*0 -> (B -> K Jpsi) K, same signed KK for back ground
self.Bs2KKJpsiWS = CombineParticles(
DecayDescriptor="[B*_s20 -> B+ K+]cc")
self.Bs2KKJpsiWS.CombinationCut = self.Bs2KKJpsi.CombinationCut
self.Bs2KKJpsiWS.MotherCut = self.Bs2KKJpsi.MotherCut
self.Bs2KKJpsiWS.ReFitPVs = self.Bs2KKJpsi.ReFitPVs
self.SelBs2KKJpsiWS = Selection(
"Bs2KKJpsiWS_for" + name,
Algorithm=self.Bs2KKJpsiWS,
RequiredSelections=[self.SelBu2KJpsi, self.SelKaon1Loose])
# register stripping lines
self.Bs2st2KKMuLine = StrippingLine(
"Bs2st2KKMuLine",
prescale=config['Bs2st2KKMuPrescale'],
FILTER=self.GECs,
RelatedInfoTools=config['RelatedInfoTools'],
selection=self.SelBs2KKMu
#, MDSTFlag = True
)
self.Bs2st2KKMuWSLine = StrippingLine(
"Bs2st2KKMuWSLine",
prescale=config['Bs2st2KKMuWSPrescale'],
FILTER=self.GECs,
RelatedInfoTools=self.Bs2st2KKMuLine.RelatedInfoTools,
selection=self.SelBs2KKMuWS
#, MDSTFlag = True
)
self.Bs2st2KKJpsiLine = StrippingLine(
"Bs2st2KKJpsiLine",
prescale=config['Bs2st2KKMuPrescale'],
FILTER=self.GECs,
selection=self.SelBs2KKJpsi
#, MDSTFlag = True
)
self.Bs2st2KKJpsiWSLine = StrippingLine(
"Bs2st2KKJpsiWSLine",
prescale=config['Bs2st2KKJpsiWSPrescale'],
FILTER=self.GECs,
selection=self.SelBs2KKJpsiWS
#, MDSTFlag = True
)
# register stripping lines
self.registerLine(self.Bs2st2KKMuLine)
self.registerLine(self.Bs2st2KKMuWSLine)
self.registerLine(self.Bs2st2KKJpsiLine)
self.registerLine(self.Bs2st2KKJpsiWSLine)
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
# if name not set outside, set it to empty
#if name == None:
# name = ""
# Selection of Bc daughters: photon, D0, Ds1
self.selPhoton = makePhoton('GammaFor%s' % name, config['photonPT'])
self.selD0 = makeD0('D0For%s' % name, config['KaonProbNN'],
config['pionProbNN'], config['TrGhostProb'])
self.selDs1 = makeDs1(
'Ds1For%s' % name,
self.selD0,
'[D_s1(2536)+ -> D0 K+]cc', #DecayDescriptor
config['KaonProbNN'],
config['TrGhostProb'],
config['Ds1DeltaMassWin'],
config['MaxDs1VertChi2DOF'])
self.selDs1WS = makeDs1(
'Ds1WSFor%s' % name,
self.selD0,
'[D_s1(2536)+ -> D~0 K+]cc', #DecayDescriptor
config['KaonProbNN'],
config['TrGhostProb'],
config['Ds1DeltaMassWin'],
config['MaxDs1VertChi2DOF'])
# Bc->Ds1 Gamma selections
self.selBc2Ds1Gamma = makeBc2Ds1Gamma(
'Bc2Ds1GammaFor%s' % name,
self.selDs1,
self.selPhoton,
config['BcPVIPchi2'],
# config['BcMassWin'],
config['MinBcMass'],
config['MaxBcMass'],
config['Bc_PT'],
config['CTAU_Bc'])
self.selBc2Ds1GammaWS = makeBc2Ds1Gamma(
'Bc2Ds1GammaWSFor%s' % name,
self.selDs1WS,
self.selPhoton,
config['BcPVIPchi2'],
# config['BcMassWin'],
config['MinBcMass'],
config['MaxBcMass'],
config['Bc_PT'],
config['CTAU_Bc'])
# Create and register stripping lines
self.Bc2Ds1GammaLine = StrippingLine(
"%s_Line" % name,
prescale=config['Bc2Ds1GammaPreScale'],
postscale=config['Bc2Ds1GammaPostScale'],
selection=self.selBc2Ds1Gamma)
self.registerLine(self.Bc2Ds1GammaLine)
self.Bc2Ds1GammaLineWS = StrippingLine(
"%sWS_Line" % name,
prescale=config['Bc2Ds1GammaPreScale'],
postscale=config['Bc2Ds1GammaPostScale'],
selection=self.selBc2Ds1GammaWS)
self.registerLine(self.Bc2Ds1GammaLineWS)
def _KSS_line(self):
from StrippingConf.StrippingLine import StrippingLine
return StrippingLine(self._name + 'Bs2KSSLine',
prescale=0.5,
FILTER=self.GECs,
algos=[self._Bs2KMuNuSS()])
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
self.selStdAllNoPIDMuons = StdAllNoPIDsMuons
self.selStdNoPIDMuons = StdNoPIDsMuons
#self.selStdNoPIDMuons_L0 = makeTISTOS( name + "muons_L0" , self.selStdNoPIDMuons , "L0.*Physics.*Decision%TIS" )
#self.selStdNoPIDMuons_Hlt1 = makeTISTOS( name + "muons_Hlt1", self.selStdNoPIDMuons_L0, "Hlt1.*Physics.*Decision%TIS" )
#self.selStdNoPIDMuons_Hlt2 = makeTISTOS( name + "muons_Hlt2", self.selStdNoPIDMuons_Hlt1, "Hlt2.*Physics.*Decision%TIS" )
self.selStdNoPIDKaons = StdNoPIDsKaons
self.selStdNoPIDPions = StdNoPIDsPions
self.selStdNoPIDProtons = StdNoPIDsProtons
#Prompt line
self.sel_Prompt = makePromptSelection(name + "_Combine",
self.selStdAllNoPIDMuons)
self.line_Prompt = StrippingLine(name + '_JpsiNoPID',
prescale=config['PromptPrescale'],
selection=self.sel_Prompt)
#Detached
self.sel_Detached = makeDetachedSelection(name + "_FromBCombine",
self.selStdNoPIDMuons)
self.line_Detached = StrippingLine(name + '_JpsiFromBNoPID',
prescale=config['DetachedPrescale'],
selection=self.sel_Detached)
self.sel_DetachedNoMIP = makeDetachedNoMIPSelection(
name + "_FromBNoMipCombine", self.selStdNoPIDMuons)
self.line_DetachedNoMIP = StrippingLine(
name + '_JpsiFromBNoPIDNoMip',
prescale=config['DetachedNoMIPPrescale'],
selection=self.sel_DetachedNoMIP)
self.sel_DetachedNoMIPHiP = makeDetachedNoMIPHiPSelection(
name + "_FromBNoMipHiPCombine", self.selStdNoPIDMuons)
self.line_DetachedNoMIPHiP = StrippingLine(
name + '_JpsiFromBNoPIDNoMipHiP',
prescale=config['DetachedNoMIPHiPPrescale'],
selection=self.sel_DetachedNoMIPHiP)
self.sel_DetachedNoMIPNoPCut = makeDetachedNoMIPNoPCutSelection(
name + "_FromBNoMipCombineNoPCut", self.selStdNoPIDMuons)
self.sel_DetachedNoMIPK = makeDetachedNoMIPKSelection(
name + "_FromBNoMipWithKCombine", self.sel_DetachedNoMIPNoPCut,
self.selStdNoPIDKaons)
self.line_DetachedNoMIPK = StrippingLine(
name + '_JpsiKFromBNoPIDNoMip',
prescale=config['DetachedNoMIPKPrescale'],
selection=self.sel_DetachedNoMIPK)
#lambda_c
self.sel_Lambdac = makeLambdacSelection(name + '_FromLambdac', "",
self.selStdNoPIDPions,
self.selStdNoPIDKaons,
self.selStdNoPIDProtons)
self.line_Lambdac = StrippingLine(
name + '_FromLambdacDecay',
prescale=config['FromLambdacPrescale'],
selection=self.sel_Lambdac)
self.sel_PiLambdac = makeLambdacSelection(name + '_PiFromLambdac',
"pion",
self.selStdNoPIDPions,
self.selStdNoPIDKaons,
self.selStdNoPIDProtons)
self.line_PiLambdac = StrippingLine(
name + '_PiFromLambdacDecay',
prescale=config['PiFromLambdacPrescale'],
selection=self.sel_PiLambdac)
self.sel_KLambdac = makeLambdacSelection(name + '_KFromLambdac',
"kaon", self.selStdNoPIDPions,
self.selStdNoPIDKaons,
self.selStdNoPIDProtons)
self.line_KLambdac = StrippingLine(
name + '_KFromLambdacDecay',
prescale=config['KFromLambdacPrescale'],
selection=self.sel_KLambdac)
self.sel_PLambdac = makeLambdacSelection(name + '_PFromLambdac',
"proton",
self.selStdNoPIDPions,
self.selStdNoPIDKaons,
self.selStdNoPIDProtons)
self.line_PLambdac = StrippingLine(
name + '_PFromLambdacDecay',
prescale=config['PFromLambdacPrescale'],
selection=self.sel_PLambdac)
self.sel_PiISMUONLambdac = makeLambdacSelection(
name + '_PiISMUONFromLambdac', "pionISMUON", self.selStdNoPIDPions,
self.selStdNoPIDKaons, self.selStdNoPIDProtons)
self.line_PiISMUONLambdac = StrippingLine(
name + '_PiISMUONFromLambdacDecay',
prescale=config['PiISMUONFromLambdacPrescale'],
selection=self.sel_PiISMUONLambdac)
self.sel_KISMUONLambdac = makeLambdacSelection(
name + '_KISMUONFromLambdac', "kaonISMUON", self.selStdNoPIDPions,
self.selStdNoPIDKaons, self.selStdNoPIDProtons)
self.line_KISMUONLambdac = StrippingLine(
name + '_KISMUONFromLambdacDecay',
prescale=config['KISMUONFromLambdacPrescale'],
selection=self.sel_KISMUONLambdac)
self.sel_PISMUONLambdac = makeLambdacSelection(
name + '_PISMUONFromLambdac', "protonISMUON",
self.selStdNoPIDPions, self.selStdNoPIDKaons,
self.selStdNoPIDProtons)
self.line_PISMUONLambdac = StrippingLine(
name + '_PISMUONFromLambdacDecay',
prescale=config['PISMUONFromLambdacPrescale'],
selection=self.sel_PISMUONLambdac)
self.registerLine(self.line_Prompt)
self.registerLine(self.line_Detached)
self.registerLine(self.line_DetachedNoMIP)
self.registerLine(self.line_DetachedNoMIPHiP)
self.registerLine(self.line_DetachedNoMIPK)
self.registerLine(self.line_Lambdac)
self.registerLine(self.line_PiLambdac)
self.registerLine(self.line_KLambdac)
self.registerLine(self.line_PLambdac)
self.registerLine(self.line_PiISMUONLambdac)
self.registerLine(self.line_KISMUONLambdac)
self.registerLine(self.line_PISMUONLambdac)
def __init__(self, moduleName, config):
LineBuilder.__init__(self, moduleName, config)
# pre-filter inputs
uppions = filterInputs('PiUP', [StdNoPIDsUpPions], config['UPSTREAM'])
pions = filterInputs('Pi', [StdAllNoPIDsPions], config['ALL'])
kaons = filterInputs('K', [StdAllNoPIDsKaons], config['ALL'])
protons = filterInputs('P', [StdAllNoPIDsProtons], config['ALL'])
ks_dd = filterInputs('KS0_DD', [dataOnDemand("StdLooseKsDD")],
config['KS0'])
ks_ll = filterInputs('KS0_LL', [dataOnDemand("StdLooseKsLL")],
config['KS0'])
ks = {"DD": [ks_dd], "LL": [ks_ll]}
pi0_merged = filterPi0s('Merged', [StdLooseMergedPi0], config['Pi0'])
pi0_resolved = filterPi0s('Resolved', [StdLooseResolvedPi0],
config['Pi0'])
pi0 = {"Merged": [pi0_merged], "Resolved": [pi0_resolved]}
pcut = 'P > %s' % config['Pi0']['FROM_B_P_MIN']
pi0_fromB_merged = filterSelection('Pi0FromBMerged', pcut,
[pi0_merged])
pi0_fromB_resolved = filterSelection('Pi0FromBResolved', pcut,
[pi0_resolved])
pi0_fromB = {
'Merged': [pi0_fromB_merged],
'Resolved': [pi0_fromB_resolved]
}
muons = filterInputs('MU', [StdLooseMuons],
config['ALL']) # make muons (for D -> phi mu nu)
# pre-filter hard inputs (these could have been used in HLT2)
topoPions = topoInputs('Pi', [pions])
topoKaons = topoInputs('K', [kaons])
topoProtons = topoInputs('P', [protons])
# make D->X, etc. inputs
d = DBuilder(pions, kaons, ks, pi0, uppions, muons, config['D2X'],
config['PID'])
dst = DstarBuilder(d, pions, pi0, config['Dstar'], config['PID'])
# X -> hh
hh = HHBuilder(pions, kaons, protons, ks, pi0_fromB, config['HH'],
config['PID'])
# X -> hhh
hhh = HHHBuilder(pions, kaons, protons, config['HHH'])
# Lc -> X
lc = LcBuilder(pions, kaons, protons, config['D2X'], config['PID'])
# make B->DX
b2dx = B2DXBuilder(d, dst, topoPions, topoKaons, ks, pi0_fromB, hh,
hhh, config['B2X'])
self._makeLines(b2dx.lines, config)
# Lb -> X
lb2x = Lb2XBuilder(lc, d, hh, topoPions, topoKaons, topoProtons, hhh,
dst, config['B2X'])
self._makeLines(lb2x.lines, config)
# Unbiased lines
ltub = LTUnbiasedBuilder(d, config['B2X'])
self._makeLines(ltub.lines, config)
# UP D* lines
for line in b2dx.lines:
for sel in line.selections:
if sel.name().find('WS') > 0: continue
dstar_sel = makeB2DstarX(sel, uppions, config['B2X'])
self._makeLine(ProtoLine([dstar_sel], line.pre), config)
# Double Topo line
from Configurables import DoubleTopoTool as DT
code = "ACCEPT('DoubleTopoTool/DoubleTopoLine_DT')"
alg = LoKi__VoidFilter('DoubleTopoLineFilter', Code=code)
sel = EventSelection('DoubleTopoEventSel', Algorithm=alg)
dt = DT('DoubleTopoLine_DT')
dt.minAngle = 2 / 57.
dt.minMass = 19000
hlt = "HLT_PASS_RE('Hlt2Topo.*Decision')"
sline = StrippingLine('DoubleTopoLine', 1.0, selection=sel, HLT=hlt)
self.registerLine(sline)
def __init__(self, name, config) :
LineBuilder.__init__(self, name, config)
# Set up global event cuts.
# Conceptually these come first, although the place where they're
# inserted into the line is at the bottom of the code.
_globalEventCuts = { "Code":"( recSummaryTrack(LHCb.RecSummary.nLongTracks, TrLONG) < %(LongTrackGEC)s )" % config,
"Preambulo": ["from LoKiTracks.decorators import *"]}
# Select all kaons and pions.
self.selDauKaon = filterDaughters('KFor'+name, 'Phys/StdAllLooseKaons/Particles',
config['TrkChi2_MAX_Child_MAX'],
config['Trk_PT_MIN'],
config['Trk_P_MIN'],
config['IPCHI2_MAX_Child_MIN'])
self.selDauPion = filterDaughters('PiFor'+name, 'Phys/StdAllLoosePions/Particles',
config['TrkChi2_MAX_Child_MAX'],
config['Trk_PT_MIN'],
config['Trk_P_MIN'],
config['IPCHI2_MAX_Child_MIN'])
self.selDauPP = [self.selDauPion]
self.selDauKK = [self.selDauKaon]
self.selDauKP = [self.selDauKaon, self.selDauPion]
# Now make the various decays of the K*(892)0
strDecaysPiPi = ["K*(892)0 -> pi+ pi-"]
strDecaysKK = ["K*(892)0 -> K+ K-"]
strDecaysKPlusPiMinus = ["K*(892)0 -> K+ pi-"]
strDecaysKMinusPiPlus = ["K*(892)0 -> K- pi+"]
self.selKstarPiPi = makeKstar('Kstar2PiPi' + name, strDecaysPiPi, self.selDauPP, config['Pair_SumAPT_MIN'], config['Pair_AMINDOCA_MAX'], config['Pair_BPVVD_MIN'], config['Pair_BPVCORRM_MAX'], config['FDCHI2_D0_MIN'], config['DIRA_D0_MIN'], config['M_MAX'], config['VCHI2_D0_MAX'])
self.selKstarKK = makeKstar('Kstar2KK' + name, strDecaysKK , self.selDauKK, config['Pair_SumAPT_MIN'], config['Pair_AMINDOCA_MAX'], config['Pair_BPVVD_MIN'], config['Pair_BPVCORRM_MAX'], config['FDCHI2_D0_MIN'], config['DIRA_D0_MIN'], config['M_MAX'], config['VCHI2_D0_MAX'])
self.selKstarKPlusPiMinus = makeKstar('Kstar2KPlusPiMinus'+ name, strDecaysKPlusPiMinus, self.selDauKP, config['Pair_SumAPT_MIN'], config['Pair_AMINDOCA_MAX'], config['Pair_BPVVD_MIN'], config['Pair_BPVCORRM_MAX'], config['FDCHI2_D0_MIN'], config['DIRA_D0_MIN'], config['M_MAX'], config['VCHI2_D0_MAX'])
self.selKstarKMinusPiPlus = makeKstar('Kstar2KMinusPiPlus'+ name, strDecaysKMinusPiPlus, self.selDauKP, config['Pair_SumAPT_MIN'], config['Pair_AMINDOCA_MAX'], config['Pair_BPVVD_MIN'], config['Pair_BPVCORRM_MAX'], config['FDCHI2_D0_MIN'], config['DIRA_D0_MIN'], config['M_MAX'], config['VCHI2_D0_MAX'])
# Now make the D* -> K*(892)0 pi
self.selDstarPiPi = makeDstar('Dstar_PiPi' + name, [self.selKstarPiPi], config['IPCHI2_PiSlow_MAX'], config['PairMaxDoca_Dstar'], config['PT_Dstar_MIN'], config['DeltaM_MIN'], config['DeltaM_MAX'])
self.selDstarKK = makeDstar('Dstar_KK' + name, [self.selKstarKK], config['IPCHI2_PiSlow_MAX'], config['PairMaxDoca_Dstar'], config['PT_Dstar_MIN'], config['DeltaM_MIN'], config['DeltaM_MAX'])
self.selDstarKPlusPiMinus = makeDstar('Dstar_KPlusPiMinus' + name, [self.selKstarKPlusPiMinus], config['IPCHI2_PiSlow_MAX'], config['PairMaxDoca_Dstar'], config['PT_Dstar_MIN'], config['DeltaM_MIN'], config['DeltaM_MAX'])
self.selDstarKMinusPiPlus = makeDstar('Dstar_KMinusPiPlus' + name, [self.selKstarKMinusPiPlus], config['IPCHI2_PiSlow_MAX'], config['PairMaxDoca_Dstar'], config['PT_Dstar_MIN'], config['DeltaM_MIN'], config['DeltaM_MAX'])
# Make the stripping lines
self.linePiPi = StrippingLine(name+'PiPiLine',
FILTER = _globalEventCuts,
prescale = config['prescale'],
postscale = config['postscale'],
selection = self.selDstarPiPi)
self.lineKK = StrippingLine(name + 'KKLine',
FILTER = _globalEventCuts,
prescale = config['prescale'],
postscale = config['postscale'],
selection = self.selDstarKK)
self.lineKPlusPiMinus = StrippingLine(name + 'KPlusPiMinusLine',
FILTER = _globalEventCuts,
prescale = config['prescale'],
postscale = config['postscale'],
selection = self.selDstarKPlusPiMinus)
self.lineKMinusPiPlus = StrippingLine(name + 'KMinusPiPlusLine',
FILTER = _globalEventCuts,
prescale = config['prescale'],
postscale = config['postscale'],
selection = self.selDstarKMinusPiPlus)
self.registerLine(self.linePiPi)
self.registerLine(self.lineKK)
self.registerLine(self.lineKPlusPiMinus)
self.registerLine(self.lineKMinusPiPlus)
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
self.selPions = self._makePions(name="PionsFor" + name, config=config)
self.selPions_high = self._makePions_high(name="PionsHighFor" + name,
config=config)
self.rawPions = DataOnDemand("Phys/StdLoosePions/Particles")
#
self.incTauVertices = self._makeTauVertices(name=name +
"_IncTopoVtxFor",
pionInput=self.selPions,
config=config)
self.incTauVertices_high = self._makeTauVertices(
name=name + "_IncTopoVtxHighFor",
pionInput=self.selPions_high,
config=config)
#
self.selTau = self._filterTau(name=name + "_TauFilter",
tauInput=self.incTauVertices,
config=config)
#
self.selHigh = self._filterHigh(name=name + "_HighFilter",
tauInput=self.incTauVertices_high,
config=config)
#
self.selB2TauTau, self.selB2TauTauSS = self._makeB2TauTau(
name=name, tauSel=self.selTau, config=config)
#
self.TauTau_Line = StrippingLine(
name + "_TauTau_Line",
# self.TauTau_Line = StrippingLine(name+"_TauTau_Line",
prescale=config['B2TauTau_LinePrescale'],
postscale=config['B2TauTau_LinePostscale'],
# selection = self._makeTOS(name+"_TOSForTauTau",selB2TauTau)
MDSTFlag=False,
RelatedInfoTools=[{
"Type": "RelInfoBstautauTauIsolationBDT",
"Location": "TauIsolationBDT"
}, {
"Type": "RelInfoBstautauTauIsolation",
"Location": "TauIsolation"
}, {
"Type": "RelInfoBstautauTrackIsolationBDT",
"Location": "TrackIsolationBDT"
}, {
"Type": "RelInfoBstautauTrackIsolation",
"Location": "TrackIsolation"
}, {
"Type": "RelInfoBstautauCDFIso",
"Location": "CDFIso"
}, {
"Type": "RelInfoBstautauZVisoBDT",
"Location": "ZVisoBDT"
}, {
"Type": "RelInfoVertexIsolation",
"Location": "BVars_VertexIsoInfo",
"DaughterLocations": {
"[B0 -> ^tau+ tau-]CC": "TauVars_VertexIsoInfo_0",
"[B0 -> tau+ ^tau-]CC": "TauVars_VertexIsoInfo_1"
}
}],
selection=self.selB2TauTau)
self.TauTauSS_Line = StrippingLine(
name + "_TauTauSS_Line",
# self.TauTau_Line = StrippingLine(name+"_TauTau_Line",
prescale=config['B2TauTauSS_LinePrescale'],
postscale=config['B2TauTauSS_LinePostscale'],
# selection = self._makeTOS(name+"_TOSForTauTau",selB2TauTau)
MDSTFlag=False,
RelatedInfoTools=[{
"Type": "RelInfoBstautauTauIsolationBDT",
"Location": "TauIsolationBDT"
}, {
"Type": "RelInfoBstautauTauIsolation",
"Location": "TauIsolation"
}, {
"Type": "RelInfoBstautauTrackIsolationBDT",
"Location": "TrackIsolationBDT"
}, {
"Type": "RelInfoBstautauTrackIsolation",
"Location": "TrackIsolation"
}, {
"Type": "RelInfoBstautauCDFIso",
"Location": "CDFIso"
}, {
"Type": "RelInfoBstautauZVisoBDT",
"Location": "ZVisoBDT"
}, {
"Type": "RelInfoVertexIsolation",
"Location": "BVars_VertexIsoInfo",
"DaughterLocations": {
"[B0 -> ^tau+ tau+]CC": "TauVars_VertexIsoInfo_0",
"[B0 -> tau+ ^tau+]CC": "TauVars_VertexIsoInfo_1"
}
}],
selection=self.selB2TauTauSS)
self.High_Line = StrippingLine(
name + "_High_Line",
prescale=config['High_LinePrescale'],
postscale=config['High_LinePostscale'],
# selection = self._makeTOS(name+"_TOSForTauTau",selB2TauTau)
MDSTFlag=False,
RelatedInfoTools=[{
"Type": "RelInfoBstautauTauIsolationBDT",
"Location": "TauIsolationBDT"
}, {
"Type": "RelInfoBstautauTauIsolation",
"Location": "TauIsolation"
}, {
"Type": "RelInfoBstautauTrackIsolationBDT",
"Location": "TrackIsolationBDT"
}, {
"Type": "RelInfoBstautauTrackIsolation",
"Location": "TrackIsolation"
}, {
"Type": "RelInfoBstautauCDFIso",
"Location": "CDFIso"
}, {
"Type": "RelInfoBstautauZVisoBDT",
"Location": "ZVisoBDT"
}, {
"Type": "RelInfoVertexIsolation",
"Location": "Vars_VertexIsoInfo"
}],
selection=self.selHigh)
#
self.registerLine(self.TauTau_Line)
self.registerLine(self.TauTauSS_Line)
self.registerLine(self.High_Line)
def _makeInclbJetLine(self, name):
return StrippingLine(name,
HLT2=self.__confdict__['HLT2'],
prescale=self.__confdict__['scale'],
RequiredRawEvents=["Calo"],
selection=self._makeInclbJetSel(name))
def __init__(self, name, config):
'''The constructor of the configuration class.
Requires a configuration dictionary, config, which must provide all the settings for cuts which are not hard coded'''
LineBuilder.__init__(self, name, config)
# _globalEventCuts = (
# "(recSummary (LHCb.RecSummary.nLongTracks, 'Rec/Track/Long') < 800 )"
# ) % config
self.name = name
self.BuToK1MuMuLineName = self.name + "_BuToK1MuMu"
# Define cut strings
self.BuCombCut = "(AM > %(B_Comb_MassLow)s * MeV) & (AM < %(B_Comb_MassHigh)s * MeV)" % config
self.BuCut = "(M > %(B_MassLow)s * MeV) & " \
"(M < %(B_MassHigh)s * MeV) & " \
"(VFASPF(VCHI2/VDOF) < %(B_VertexCHI2)s) & " \
"(BPVIPCHI2() < %(B_IPCHI2)s) & " \
"(BPVDIRA> %(B_DIRA)s) & " \
"(BPVVDCHI2 > %(B_FlightCHI2)s) & " \
"(MAXTREE(ISBASIC,MIPCHI2DV(PRIMARY))> %(B_Dau_MaxIPCHI2)s )" %config
DaughterCuts = "(VFASPF(VCHI2/VDOF) < %(Dau_VertexCHI2)s) & " \
"(BPVDIRA> %(Dau_DIRA)s)" %config
self.K1CombCut = "(AM > %(K1_Comb_MassLow)s * MeV) & " \
"(AM < %(K1_Comb_MassHigh)s * MeV) & " \
"(ADOCACHI2CUT(20.,''))" %config
self.K1Cut = DaughterCuts + " & (M > %(K1_MassLow)s * MeV) & " \
"(M < %(K1_MassHigh)s * MeV) & " \
"(BPVVDCHI2 > %(K1_FlightChi2)s) & " \
"(MIPCHI2DV(PRIMARY) > %(K1_MinIPCHI2)s) &" \
"(MAXTREE(ISBASIC,MIPCHI2DV(PRIMARY))> %(K1_Dau_MaxIPCHI2)s )" %config
self.DiMuonCut = DaughterCuts + " & (BPVVDCHI2 > %(Dimu_FlightChi2)s) & " \
"(MAXTREE(ISBASIC,MIPCHI2DV(PRIMARY))> %(Dimu_Dau_MaxIPCHI2)s )" %config
TrackCuts = "(TRCHI2DOF < %(Track_CHI2nDOF)s) " % config
HadronCuts = "(MIPCHI2DV(PRIMARY) > %(Hadron_MinIPCHI2)s)&"\
"(PT > %(Hadron_PT)s * MeV)" %config
self.KaonCut = TrackCuts + " & " + HadronCuts #+ "& (PIDK > %(K_PIDK_min)s)" %config
self.PionCut = TrackCuts + " & " + HadronCuts #+ "& (PIDK < %(pi_PIDK_max)s)" %config
self.MuonCut = TrackCuts + " & (MIPCHI2DV(PRIMARY) > %(Muon_MinIPCHI2)s)" % config
#if(config["Muon_IsMuon"]):
# self.MuonCut += " & (ISMUON)"
self.K1FilterCut = self.K1Cut + " & (INTREE(ABSID=='K+') & " + self.KaonCut + ") & (INTREE(ABSID=='pi+') & " + self.PionCut + ")"
#self.DiMuonFilterCut = self.DiMuonCut + " & (2 == NINTREE((ABSID=='mu-') & " + self.MuonCut + "))"
#########################
## Make the selections ##
#########################
Sel_Kaon = self.__Selection_FilterKaon__(self.name, self.KaonCut,
config['UseNoPIDsHadrons'])
Sel_K1 = self.__Selection_CreateK1__(self.name, self.K1CombCut,
self.K1Cut, self.KaonCut,
self.PionCut,
config['UseNoPIDsHadrons'])
Sel_DiMuon = self.__Selection_CreateDiMuon__(self.name, self.DiMuonCut,
self.MuonCut,
config['Muon_IsMuon'])
Sel_DiMuonSS = self.__Selection_CreateDiMuonSS__(
self.name, self.DiMuonCut, self.MuonCut, config['Muon_IsMuon'])
Sel_BuToK1MuMu = self.__Selection_CreateBuToK1MuMu__(
self.name, [Sel_DiMuon, Sel_K1], self.BuCombCut, self.BuCut)
Sel_BuToK1MuMuSS = self.__Selection_CreateBuToK1MuMu__(
self.name + "SS", [Sel_DiMuonSS, Sel_K1], self.BuCombCut,
self.BuCut)
###################################
## Construct the stripping lines ##
###################################
from StrippingConf.StrippingLine import StrippingLine
## --- Bu -> K1 mu mu (default) line ---
Line_BuToK1MuMu_Name = self.BuToK1MuMuLineName + "Line"
Line_BuToK1MuMu = StrippingLine(
Line_BuToK1MuMu_Name,
prescale=config['Prescale_BuToK1MuMu'],
postscale=config['Postscale_BuToK1MuMu'],
selection=Sel_BuToK1MuMu)
self.registerLine(Line_BuToK1MuMu)
## --- Bu -> K1 mu mu same sign line ---
Line_BuToK1MuMuSS_Name = self.BuToK1MuMuLineName + "SSLine"
Line_BuToK1MuMuSS = StrippingLine(
Line_BuToK1MuMuSS_Name,
prescale=config['Prescale_BuToK1MuMuSS'],
postscale=config['Postscale_BuToK1MuMuSS'],
selection=Sel_BuToK1MuMuSS)
self.registerLine(Line_BuToK1MuMuSS)
def __init__(self, name, config) :
# Initialize the stripping.
LineBuilder.__init__(self, name, config)
self._config = config
self._name = name
# Preselection strings for HLT and FILTER.
hlt = "HLT_PASS_RE('" + self._config["HLT"]["LINETOPO"] + ".*Decision')"
hltMB = "HLT_PASS('"+self._config["HLT"]["LINEMB"]+"')"
fltDIFF = {"Code" : "(recSummary(LHCb.RecSummary.nPVs, 'Rec/Vertex/Primary')<2)"
"& (recSummaryTrack(LHCb.RecSummary.nBackTracks, TrBACKWARD) < 1)",
'Preambulo' : ['from LoKiTracks.decorators import *',
'from LoKiCore.functions import *']}
# Select the particles.
trks = self._create_trks([StdAllNoPIDsPions])
svrs = self._create_svrs([trks])
mptJets = self._filter_hPTJets([StdJets],str(self._config["JET"]["MIN_PT"]) )
hptJets = self._filter_hPTJets([StdJets],str(self._config["JET"]["VERYLOW_PT"]) )
bJets = self._create_bJets(mptJets,svrs)
#one jet has 60% of a TOPO object LHCbID, with PT > 15, 50, 90
fbJets0 = self._filter_bJets(bJets,0,str(self._config["JET"]["VERYLOW_PT"]))
fbJets1 = self._filter_bJets(bJets,0,str(self._config["JET"]["MEDIUM_PT"]))
fbJets2 = self._filter_bJets(bJets,0,str(self._config["JET"]["HIGH_PT"]))
dijets_T6_A = self._create_dijets([hptJets, bJets], cut2=0, PT = str(self._config["JET"]["LOW_PT"]))
#one jet has 60% of a TOPO object LHCbID, the other has both trk of one 2-trk SV
dijets_T6_PS = self._create_dijets([bJets], cut1=0, cut3=15, PT = str(self._config["JET"]["LOW_PT"]))
#
#cut1 and cut2 act on the TopoObject tagging for jet1 and jet2:
# cut1 apply to jet1 and cut2 apply to jet2, or cut2 apply to jet1 and cut1
# apply to jet2
#cut3 and cut4 act on the created SV tagging for jet1 and jet2
#
# cutX == 0 no tagging
# cutX == 1 at least 60% of the LHCbID to the "tagging" object are
# continas in the jet
# cutX == 11 TOS (or all tracks in the jet)
#
#The three following lines are designed for the 4b analyses (Contact: Stephane Tourneur):
_3jets_Pt7_3sv = self._create_3jets([mptJets, bJets], minPT = str(self._config["JET"]["EXTLOW_PT"]), Nsvtag="2.5")
_4jets_Pt5_3sv = self._create_4jets([mptJets, bJets], minPT = str(self._config["JET"]["MIN_PT"]), Nsvtag="2.5")
_4jets_Pt5_0sv = self._create_4jets([mptJets, bJets], minPT = str(self._config["JET"]["MIN_PT"]), Nsvtag="-0.5")
line_jetDIFF = StrippingLine(
name + "Diffractive",
prescale = self._config["PRESCALE"]["DIFF"],
HLT = hlt,
FILTER = fltDIFF,
selection = hptJets,
RequiredRawEvents = ["Calo"]
)
line_jetMB = StrippingLine(
name + "MB",
prescale = self._config["PRESCALE"]["MB"],
HLT = hltMB,
selection = hptJets,
RequiredRawEvents = ["Calo"]
)
line_jetPT0 = StrippingLine(
name + "bJetPT15",
prescale = self._config["PRESCALE"]["bJetPT15"],
HLT = hlt,
selection = fbJets0,
RequiredRawEvents = ["Calo"]
)
line_jetPT1 = StrippingLine(
name + "bJetPT50",
prescale = self._config["PRESCALE"]["bJetPT50"],
HLT = hlt,
selection = fbJets1,
RequiredRawEvents = ["Calo"]
)
line_jetPT2 = StrippingLine(
name + "bJetPT90",
prescale = self._config["PRESCALE"]["bJetPT90"],
HLT = hlt,
selection = fbJets2,
RequiredRawEvents = ["Calo"]
)
line_Dijets_T6A = StrippingLine(
name + "DiJet20_T6A",
prescale = self._config["PRESCALE"]["dibJetT6A"],
HLT = hlt,
selection = dijets_T6_A,
RequiredRawEvents = ["Calo"]
)
line_Dijets_T6PS = StrippingLine(
name + "DiJet20_T6PS",
prescale = self._config["PRESCALE"]["dibJetT6PS"],
HLT = hlt,
selection = dijets_T6_PS,
RequiredRawEvents = ["Calo"]
)
line__3jets_Pt7_3sv = StrippingLine(
name + "_3jets_Pt7_3sv",
prescale = self._config["PRESCALE"]["_3jets_Pt7_3sv"],
HLT = hlt,
selection = _3jets_Pt7_3sv,
RequiredRawEvents = ["Calo"]
)
line__4jets_Pt5_3sv = StrippingLine(
name + "_4jets_Pt5_3sv",
prescale = self._config["PRESCALE"]["_4jets_Pt5_3sv"],
HLT = hlt,
selection = _4jets_Pt5_3sv,
RequiredRawEvents = ["Calo"]
)
line__4jets_Pt5_0sv_Prescaled = StrippingLine(
name + "_4jets_Pt5_0sv_Prescaled",
prescale = self._config["PRESCALE"]["_4jets_Pt5_0sv_Prescaled"],
HLT = hlt,
selection = _4jets_Pt5_0sv,
RequiredRawEvents = ["Calo"]
)
self.registerLine(line_jetMB)
self.registerLine(line_jetDIFF)
self.registerLine(line_jetPT0)
self.registerLine(line_jetPT1)
self.registerLine(line_jetPT2)
self.registerLine(line_Dijets_T6A)
self.registerLine(line_Dijets_T6PS)
self.registerLine(line__3jets_Pt7_3sv)
self.registerLine(line__4jets_Pt5_3sv)
self.registerLine(line__4jets_Pt5_0sv_Prescaled)
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
B2etap_LL_name = name + 'B2etapKSLL'
B2etap_DD_name = name + 'B2etapKSDD'
B2eta_LL_name = name + 'B2etaKSLL'
B2eta_DD_name = name + 'B2etaKSDD'
Lb2etap_LL_name = name + 'Lb2etapLLL'
Lb2etap_DD_name = name + 'Lb2etapLDD'
Lb2eta_LL_name = name + 'Lb2etaLLL'
Lb2eta_DD_name = name + 'Lb2etaLDD'
GECCode = {
'Code':
"(recSummaryTrack(LHCb.RecSummary.nLongTracks, TrLONG) < %s)" %
config['GEC_MaxTracks'],
'Preambulo': ["from LoKiTracks.decorators import *"]
}
self.pions = Pions
self.photons = Photons
self.eta = Eta
self.daughters = MergedSelection(
"DaughtersFor" + name,
RequiredSelections=[self.pions, self.photons, self.eta])
self.makeKS2LL('KSfor' + B2etap_LL_name, config)
self.makeKS2DD('KSfor' + B2etap_DD_name, config)
self.makeL2LL('Lambdafor' + Lb2etap_LL_name, config)
self.makeL2DD('Lambdafor' + Lb2etap_DD_name, config)
self.makeEta('Etafor' + name, config)
self.makeEtap('Etapfor' + name, config)
self.makeB2KSLLetap(B2etap_LL_name, config)
self.makeB2KSDDetap(B2etap_DD_name, config)
self.makeB2KSLLeta(B2eta_LL_name, config)
self.makeB2KSDDeta(B2eta_DD_name, config)
self.makeLb2LLLetap(Lb2etap_LL_name, config)
self.makeLb2LDDetap(Lb2etap_DD_name, config)
self.makeLb2LLLeta(Lb2eta_LL_name, config)
self.makeLb2LDDeta(Lb2eta_DD_name, config)
self.B2etap_LL_line = StrippingLine(B2etap_LL_name + 'Line',
prescale=config['Prescale'],
postscale=config['Postscale'],
selection=self.selB2KSLLetap,
FILTER=GECCode)
self.B2etap_DD_line = StrippingLine(B2etap_DD_name + 'Line',
prescale=config['Prescale'],
postscale=config['Postscale'],
selection=self.selB2KSDDetap,
FILTER=GECCode)
self.B2eta_LL_line = StrippingLine(B2eta_LL_name + 'Line',
prescale=config['Prescale'],
postscale=config['Postscale'],
selection=self.selB2KSLLeta,
FILTER=GECCode)
self.B2eta_DD_line = StrippingLine(B2eta_DD_name + 'Line',
prescale=config['Prescale'],
postscale=config['Postscale'],
selection=self.selB2KSDDeta,
FILTER=GECCode)
self.Lb2etap_LL_line = StrippingLine(Lb2etap_LL_name + 'Line',
prescale=config['Prescale'],
postscale=config['Postscale'],
selection=self.selLb2LLLetap,
FILTER=GECCode)
self.Lb2etap_DD_line = StrippingLine(Lb2etap_DD_name + 'Line',
prescale=config['Prescale'],
postscale=config['Postscale'],
selection=self.selLb2LDDetap,
FILTER=GECCode)
self.Lb2eta_LL_line = StrippingLine(Lb2eta_LL_name + 'Line',
prescale=config['Prescale'],
postscale=config['Postscale'],
selection=self.selLb2LLLeta,
FILTER=GECCode)
self.Lb2eta_DD_line = StrippingLine(Lb2eta_DD_name + 'Line',
prescale=config['Prescale'],
postscale=config['Postscale'],
selection=self.selLb2LDDeta,
FILTER=GECCode)
self.registerLine(self.B2etap_LL_line)
self.registerLine(self.B2etap_DD_line)
self.registerLine(self.B2eta_LL_line)
self.registerLine(self.B2eta_DD_line)
self.registerLine(self.Lb2etap_LL_line)
self.registerLine(self.Lb2etap_DD_line)
self.registerLine(self.Lb2eta_LL_line)
self.registerLine(self.Lb2eta_DD_line)
def __init__(self, name="B24p", config=default_config):
LineBuilder.__init__(self, name, config)
B24p_name = name + "B24p"
B2JpsiKpi_name = name + "B2JpsiKpi"
B2PhiKh_name = name + "B2PhiKh"
#############################################################################
self.TrackCuts = """
( MIPCHI2DV(PRIMARY) > %(MinTrIPChi2)s )
& ( TRCHI2DOF < %(MaxTrChi2Dof)s )
& ( TRGHP < %(MaxTrGhp)s )
""" % config
self.CommonCombi12Cuts = "(ADOCA(1,2) < %(MaxDoca)s*mm)" % config
self.CommonCombi123Cuts = """
(ADOCA(1,3) < %(MaxDoca)s*mm)
& (ADOCA(2,3) < %(MaxDoca)s*mm)
""" % config
self.CommonCombiCuts = """
(ADAMASS(5323*MeV) < %(mDiffb)s*MeV)
& (ADOCA(1,4) < %(MaxDoca)s*mm)
& (ADOCA(2,4) < %(MaxDoca)s*mm)
& (ADOCA(3,4) < %(MaxDoca)s*mm)
""" % config
self.MotherCuts = """
(BPVIPCHI2() < %(MaxIPChi2)s )
& (BPVVDCHI2 > %(MinVDChi2)s )
& (VFASPF(VCHI2/VDOF) < %(MaxVtxChi2Dof)s )
& (BPVDIRA > %(MinDira)s )
& (BPVLTIME() > %(MinTau)s*ps )
""" % config
self.B2JpsiKpiCombi12Cut = "(ADOCA(1,2) < %(MaxDoca)s*mm) & ( in_range(2990*MeV,AM12,3200*MeV) )"
#############################################################################
self.selB24p = self.makeB24p(B24p_name)
self.selB2JpsiKpi = self.makeB2JpsiKpi(B2JpsiKpi_name, config)
self.selB2PhiKh = self.makeB2PhiKh(B2PhiKh_name, config)
#############################################################################
self.B24p_Line = StrippingLine(
B24p_name + "Line",
prescale=config["B24pPrescale"],
postscale=config["Postscale"],
MDSTFlag=True,
selection=self.selB24p,
RelatedInfoTools=[
{
"Type": "RelInfoConeVariables",
"ConeAngle": 0.5,
"Variables": [],
"RecursionLevel": 1,
"Locations": {
self.selB24p:
"ConeIso05B0",
"Phys/StdAllLooseProtons": [
"ConeIso05p1", "ConeIso05p2", "ConeIso05p3",
"ConeIso05p4"
],
},
},
{
"Type": "RelInfoConeVariables",
"ConeAngle": 1.0,
"Variables": [],
"RecursionLevel": 1,
"Locations": {
self.selB24p:
"ConeIso10B0",
"Phys/StdAllLooseProtons": [
"ConeIso10p1", "ConeIso10p2", "ConeIso10p3",
"ConeIso10p4"
],
},
},
{
"Type": "RelInfoConeVariables",
"ConeAngle": 1.5,
"Variables": [],
"RecursionLevel": 1,
"Locations": {
self.selB24p:
"ConeIso15B0",
"Phys/StdAllLooseProtons": [
"ConeIso15p1", "ConeIso15p2", "ConeIso15p3",
"ConeIso15p4"
],
},
},
{
"Type": "RelInfoTrackIsolationBDT",
"RecursionLevel": 1,
"Variables": 0,
"Locations": {
"Phys/StdAllLooseProtons": [
"TrackIsoBDTp1", "TrackIsoBDTp2", "TrackIsoBDTp3",
"TrackIsoBDTp4"
],
},
},
{
"Type": "RelInfoBs2MuMuTrackIsolations",
"RecursionLevel": 1,
"Variables": [],
"IsoTwoBody": True,
"Locations": {
"Phys/StdAllLooseProtons": [
"BsMuMuTrackIsop1", "BsMuMuTrackIsop2",
"BsMuMuTrackIsop3", "BsMuMuTrackIsop4"
],
},
},
] + config["CommonRelInfoTools"] # end of RelatedInfoTools
) # closes Strippingline
self.B2JpsiKpi_Line = StrippingLine(
B2JpsiKpi_name + "Line",
prescale=config["B2JpsiKpiPrescale"],
postscale=config["Postscale"],
MDSTFlag=True,
selection=self.selB2JpsiKpi,
RelatedInfoTools=[
{
"Type": "RelInfoConeVariables",
"ConeAngle": 0.5,
"Variables": [],
"RecursionLevel": 1,
"Locations": {
self.selB2JpsiKpi: "ConeIso05B0",
"Phys/StdAllLooseProtons":
["ConeIso05p1", "ConeIso05p2"],
"Phys/StdAllLooseKaons": "ConeIso05K",
"Phys/StdAllNoPIDsPions": "ConeIso05pi",
},
},
{
"Type": "RelInfoConeVariables",
"ConeAngle": 1.0,
"Variables": [],
"RecursionLevel": 1,
"Locations": {
self.selB2JpsiKpi: "ConeIso10B0",
"Phys/StdAllLooseProtons":
["ConeIso10p1", "ConeIso10p2"],
"Phys/StdAllLooseKaons": "ConeIso10K",
"Phys/StdAllNoPIDsPions": "ConeIso10pi",
},
},
{
"Type": "RelInfoConeVariables",
"ConeAngle": 1.5,
"Variables": [],
"RecursionLevel": 1,
"Locations": {
self.selB2JpsiKpi: "ConeIso15B0",
"Phys/StdAllLooseProtons":
["ConeIso15p1", "ConeIso15p2"],
"Phys/StdAllLooseKaons": ["ConeIso15K"],
"Phys/StdAllNoPIDsPions": ["ConeIso15pi"],
},
},
{
"Type": "RelInfoTrackIsolationBDT",
"RecursionLevel": 1,
"Variables": 0,
"Locations": {
"Phys/StdAllLooseProtons":
["TrackIsoBDTp1", "TrackIsoBDTp2"],
"Phys/StdAllLooseKaons":
"TrackIsoBDTK",
"Phys/StdAllNoPIDsPions":
"TrackIsoBDTpi",
},
},
{
"Type": "RelInfoBs2MuMuTrackIsolations",
"RecursionLevel": 1,
"Variables": [],
"IsoTwoBody": True,
"Locations": {
"Phys/StdAllLooseKaons":
"BsMuMuTrackIsoK",
"Phys/StdAllNoPIDsPions":
"BsMuMuTrackIsopi",
"Phys/StdAllLooseProtons":
["BsMuMuTrackIsop1", "BsMuMuTrackIsop2"],
},
},
] + config["CommonRelInfoTools"] # end of RelatedInfoTools
) # closes Strippingline
self.B2PhiKh_Line = StrippingLine(
B2PhiKh_name + "Line",
prescale=config["B2PhiKhPrescale"],
postscale=config["Postscale"],
MDSTFlag=True,
selection=self.selB2PhiKh,
RelatedInfoTools=[
{
"Type": "RelInfoConeVariables",
"ConeAngle": 0.5,
"Variables": [],
"RecursionLevel": 1,
"Locations": {
self.selB2PhiKh:
"ConeIso05B0",
"Phys/StdAllNoPIDsPions":
"ConeIso05pi",
"Phys/StdAllLooseKaons":
["ConeIso05K1", "ConeIso05K2", "ConeIso05K3"],
},
},
{
"Type": "RelInfoConeVariables",
"ConeAngle": 1.0,
"Variables": [],
"RecursionLevel": 1,
"Locations": {
self.selB2PhiKh:
"ConeIso10B0",
"Phys/StdAllNoPIDsPions":
"ConeIso10pi",
"Phys/StdAllLooseKaons":
["ConeIso10K1", "ConeIso10K2", "ConeIso10K3"],
},
},
{
"Type": "RelInfoConeVariables",
"ConeAngle": 1.5,
"Variables": [],
"RecursionLevel": 1,
"Locations": {
self.selB2PhiKh:
"ConeIso15B0",
"Phys/StdAllNoPIDsPions": ["ConeIso15pi"],
"Phys/StdAllLooseKaons":
["ConeIso15K1", "ConeIso15K2", "ConeIso15K3"],
},
},
{
"Type": "RelInfoTrackIsolationBDT",
"RecursionLevel": 1,
"Variables": 0,
"Locations": {
"Phys/StdAllNoPIDsPions":
"TrackIsoBDTpi",
"Phys/StdAllLooseKaons":
["TrackIsoBDTK1", "TrackIsoBDTK2", "TrackIsoBDTK3"],
},
},
{
"Type": "RelInfoBs2MuMuTrackIsolations",
"RecursionLevel": 1,
"Variables": [],
"IsoTwoBody": True,
"Locations": {
"Phys/StdAllNoPIDsPions":
"BsMuMuTrackIsopi",
"Phys/StdAllLooseKaons": [
"BsMuMuTrackIsoK1", "BsMuMuTrackIsoK2",
"BsMuMuTrackIsoK3"
],
},
},
] + config["CommonRelInfoTools"] # end of RelatedInfoTools
) # closes Strippingline
#############################################################################
self.registerLine(self.B24p_Line)
self.registerLine(self.B2JpsiKpi_Line)
self.registerLine(self.B2PhiKh_Line)
def __init__(self, name, config):
self.name = name
LineBuilder.__init__(self, name, config)
#################################################################################
# Configure trigger
#################################################################################
l0 = None
if config['L0']:
l0 = "L0_CHANNEL_RE('%s')" % ('|'.join(config['L0']))
l0_conv = None
if config['L0_Conv']:
l0_conv = "L0_CHANNEL_RE('%s')" % ('|'.join(config['L0_Conv']))
hlt1 = None
if config['HLT1']:
hlt1 = "HLT_PASS_RE('%s')" % ('|'.join(config['HLT1']))
hlt2 = None
if config['HLT2']:
hlt2 = "HLT_PASS_RE('%s')" % ('|'.join(config['HLT2']))
#################################################################################
# Build Lambda_0
#################################################################################
tracks_code = """(MAXTREE(TRCHI2DOF, HASTRACK) < %(Track_Chi2ndf_Max)s) &
(MINTREE(TRCHI2DOF, HASTRACK) < %(Track_MinChi2ndf_Max)s) &
(MAXTREE(TRGHOSTPROB, HASTRACK) < %(Track_GhostProb_Max)s) &
(INTREE(('p+'==ABSID) & (PT > %(Proton_Pt_Min)s))) &
(INTREE(('pi+'==ABSID) & (PT > %(Pion_Pt_Min)s))) &
(INTREE(('p+'==ABSID) & (P > %(Proton_P_Min)s))) &
(INTREE(('pi+'==ABSID) & (P > %(Pion_P_Min)s)))"""
lambda0_ll_dod = DataOnDemand(
Location='Phys/StdLooseLambdaLL/Particles')
lambda0_ll_code = """(PT>%(Lambda0_Pt_Min)s*MeV) &
(VFASPF(VCHI2/VDOF)<%(Lambda0_VtxChi2_Max)s) &
(MINTREE(MIPCHI2DV(PRIMARY), ISLONG) > %(TrackLL_IPChi2_Min)s) &
(MIPDV(PRIMARY) > %(Lambda0LL_IP_Min)s*mm) &
(ADMASS('Lambda0') < %(Lambda0LL_MassWindow)s*MeV)"""
lambda0_ll_code = (lambda0_ll_code + " & " + tracks_code) % config
lambda0_ll_filter = FilterDesktop(Code=lambda0_ll_code)
lambda0_ll = Selection("LooseLambda0LL",
Algorithm=lambda0_ll_filter,
RequiredSelections=[lambda0_ll_dod])
lambda0_dd_dod = DataOnDemand(
Location='Phys/StdLooseLambdaDD/Particles')
lambda0_dd_code = """(PT>%(Lambda0_Pt_Min)s*MeV) &
(VFASPF(VCHI2/VDOF)<%(Lambda0_VtxChi2_Max)s) &
(ADMASS('Lambda0') < %(Lambda0DD_MassWindow)s*MeV)"""
lambda0_dd_code = (lambda0_dd_code + " & " + tracks_code) % config
lambda0_dd_filter = FilterDesktop(Code=lambda0_dd_code)
lambda0_dd = Selection("LooseLambda0DD",
Algorithm=lambda0_dd_filter,
RequiredSelections=[lambda0_dd_dod])
lambda0 = MergedSelection("LooseLambda0",
RequiredSelections=[lambda0_ll, lambda0_dd])
#################################################################################
# Filter photons
#################################################################################
photons_noncnv_filter = FilterDesktop(
Code="(PT > %(Photon_PT_Min)s*MeV) & (CL > %(Photon_CL_Min)s)" %
config)
photons_noncnv = Selection("Photons_NonCnv",
Algorithm=photons_noncnv_filter,
RequiredSelections=[StdLooseAllPhotons])
photons_cnv_merged = MergedSelection(
"Photons_Cnv_Merge",
RequiredSelections=[StdAllLooseGammaDD, StdAllLooseGammaLL])
photons_cnv_code = """(HASVERTEX) &
(MM < %(PhotonCnv_MM_Max)s*MeV) &
(PT > %(PhotonCnv_PT_Min)s*MeV) &
(VFASPF(VCHI2/VDOF)<%(PhotonCnv_VtxChi2_Max)s)""" % config
photons_cnv_filter = FilterDesktop(Code=photons_cnv_code % config)
photons_cnv = Selection("Photons_Cnv",
Algorithm=photons_cnv_filter,
RequiredSelections=[photons_cnv_merged])
#################################################################################
# Build Lambda_b
#################################################################################
# With non-converted photons
lambda_b_combine = CombineParticles("Lambdab_NonConv_Combine")
lambda_b_combine.DecayDescriptor = "[Lambda_b0 -> Lambda0 gamma]cc"
lambda_b_combine.DaughtersCuts = {'Lambda0': 'ALL', 'gamma': 'ALL'}
lambda_b_combine.ParticleCombiners = {'': 'MomentumCombiner:PUBLIC'}
lambda_b_combine.CombinationCut = """(ADAMASS('Lambda_b0') < %(Lambdab_MassWindow)s*MeV) &
(ASUM(PT) > %(Lambdab_SumPt_Min)s )""" % config
lambda_b_combine.MotherCut = """(PT > %(Lambdab_Pt_Min)s*MeV) &
(MTDOCACHI2(1) < %(Lambdab_MTDOCAChi2_Max)s)""" % config
lambda_b = Selection("Lambdab_NonConv_Sel",
Algorithm=lambda_b_combine,
RequiredSelections=[photons_noncnv, lambda0])
# With converted photons
lambda_b_cnv_combine = CombineParticles("Lambdab_Conv_Combine")
lambda_b_cnv_combine.DecayDescriptor = "[Lambda_b0 -> Lambda0 gamma]cc"
lambda_b_cnv_combine.DaughtersCuts = {'Lambda0': 'ALL', 'gamma': 'ALL'}
lambda_b_cnv_combine.ParticleCombiners = {
"": "OfflineVertexFitter:PUBLIC"
}
lambda_b_cnv_combine.CombinationCut = "(ADAMASS('Lambda_b0') < 1.5*%(Lambdab_MassWindow)s*MeV)" % config
lambda_b_cnv_combine.MotherCut = """(HASVERTEX) & (VFASPF(VCHI2/VDOF)<%(Lambdab_VtxChi2_Max)s) &
(PT > %(Lambdab_Pt_Min)s*MeV) &
(BPVIPCHI2() < %(Lambdab_IPChi2_Max)s) &
(ADMASS('Lambda_b0') < %(Lambdab_MassWindow)s*MeV)""" % config
#(MTDOCACHI2(1) < %(Lambdab_MTDOCAChi2_Max)s) &
lambda_b_cnv = Selection("Lambdab_Conv_Sel",
Algorithm=lambda_b_cnv_combine,
RequiredSelections=[photons_cnv, lambda0])
#################################################################################
# Build lines
#################################################################################
children = {'L0': '[Lambda_b0 -> ^Lambda0 gamma]CC'}
self.line = StrippingLine("Lb2L0Gamma",
prescale=config["Lb2L0GammaPrescale"],
L0DU=l0,
HLT1=hlt1,
HLT2=hlt2,
checkPV=True,
RelatedInfoTools=[
self.get_cone_relinfo(1.7,
children=children),
self.get_cone_relinfo(1.35,
children=children),
self.get_cone_relinfo(1.0,
children=children),
],
RequiredRawEvents=['Calo'],
MDSTFlag=True,
selection=lambda_b)
self.registerLine(self.line)
self.line_cnv = StrippingLine(
"Lb2L0GammaConverted",
prescale=config["Lb2L0GammaPrescale"],
L0DU=l0_conv,
HLT1=hlt1,
HLT2=hlt2,
checkPV=True,
RelatedInfoTools=[
self.get_cone_relinfo(1.7, lambda_b_cnv, children),
self.get_cone_relinfo(1.35, lambda_b_cnv, children),
self.get_cone_relinfo(1.0, lambda_b_cnv, children),
self.get_vtxisol_relinfo(lambda_b_cnv),
],
RequiredRawEvents=['Calo'],
MDSTFlag=True,
selection=lambda_b_cnv)
self.registerLine(self.line_cnv)
def __init__( self, name, config ) :
LineBuilder.__init__( self, name, config )
self.selStdAllNoPIDMuons = StdAllNoPIDsMuons
self.selStdNoPIDMuons = StdNoPIDsMuons
#self.selStdNoPIDMuons_L0 = makeTISTOS( name + "muons_L0" , self.selStdNoPIDMuons , "L0.*Physics.*Decision%TIS" )
#self.selStdNoPIDMuons_Hlt1 = makeTISTOS( name + "muons_Hlt1", self.selStdNoPIDMuons_L0, "Hlt1.*Physics.*Decision%TIS" )
#self.selStdNoPIDMuons_Hlt2 = makeTISTOS( name + "muons_Hlt2", self.selStdNoPIDMuons_Hlt1, "Hlt2.*Physics.*Decision%TIS" )
self.selStdNoPIDKaons = StdNoPIDsKaons
self.selStdNoPIDPions = StdNoPIDsPions
self.selStdNoPIDProtons = StdNoPIDsProtons
#Prompt line
self.sel_Prompt = makePromptSelection( name + "_Combine", self.selStdAllNoPIDMuons )
self.line_Prompt = StrippingLine( name + '_JpsiNoPID',
prescale = config[ 'PromptPrescale' ],
selection = self.sel_Prompt,
RequiredRawEvents = ["Muon"],
RelatedInfoTools = [addRelInfoMuonIsolation(self.sel_Prompt.algorithm().DecayDescriptor) ]
)
#Detached
self.sel_Detached = makeDetachedSelection( name + "_FromBCombine", self.selStdNoPIDMuons)
self.line_Detached = StrippingLine( name + '_JpsiFromBNoPID',
prescale = config[ 'DetachedPrescale' ],
selection = self.sel_Detached,
RequiredRawEvents = ["Muon"],
RelatedInfoTools = [addRelInfoMuonIsolation(self.sel_Detached.algorithm().DecayDescriptor) ]
)
self.sel_DetachedNoMIP = makeDetachedNoMIPSelection( name + "_FromBNoMipCombine", self.selStdNoPIDMuons )
self.line_DetachedNoMIP = StrippingLine( name + '_JpsiFromBNoPIDNoMip',
prescale = config[ 'DetachedNoMIPPrescale' ],
selection = self.sel_DetachedNoMIP,
RequiredRawEvents = ["Muon"],
RelatedInfoTools = [addRelInfoMuonIsolation(self.sel_DetachedNoMIP.algorithm().DecayDescriptor) ]
)
self.sel_DetachedNoMIPHiP = makeDetachedNoMIPHiPSelection( name + "_FromBNoMipHiPCombine", self.selStdNoPIDMuons )
self.line_DetachedNoMIPHiP = StrippingLine( name + '_JpsiFromBNoPIDNoMipHiP',
prescale = config[ 'DetachedNoMIPHiPPrescale' ],
selection = self.sel_DetachedNoMIPHiP,
RequiredRawEvents = ["Muon"],
RelatedInfoTools = [addRelInfoMuonIsolation(self.sel_DetachedNoMIPHiP.algorithm().DecayDescriptor) ]
)
self.sel_DetachedNoMIPNoPCut = makeDetachedNoMIPNoPCutSelection( name + "_FromBNoMipCombineNoPCut", self.selStdNoPIDMuons )
self.sel_DetachedNoMIPK = makeDetachedNoMIPKSelection( name + "_FromBNoMipWithKCombine", self.sel_DetachedNoMIPNoPCut, self.selStdNoPIDKaons )
self.line_DetachedNoMIPK = StrippingLine( name + '_JpsiKFromBNoPIDNoMip',
prescale = config[ 'DetachedNoMIPKPrescale' ],
selection = self.sel_DetachedNoMIPK,
MDSTFlag = True,
RequiredRawEvents = ["Muon"],
RelatedInfoTools = [ addRelInfoMuonIsolation('[B+ -> ( J/psi(1S) -> mu+ mu-) K+ ]CC') ]
)
#lambda_c
self.sel_Lambdac = makeLambdacSelection( name + '_FromLambdac', "", self.selStdNoPIDPions, self.selStdNoPIDKaons, self.selStdNoPIDProtons)
self.line_Lambdac = StrippingLine( name + '_FromLambdacDecay',
prescale = config[ 'FromLambdacPrescale' ],
selection = self.sel_Lambdac,
MDSTFlag = True,
RequiredRawEvents = ["Muon"],
RelatedInfoTools = [addRelInfoMuonIsolation(self.sel_Lambdac.algorithm().DecayDescriptor) ]
)
self.sel_PiLambdac = makeLambdacSelection( name + '_PiFromLambdac', "pion", self.selStdNoPIDPions, self.selStdNoPIDKaons, self.selStdNoPIDProtons)
self.line_PiLambdac = StrippingLine( name + '_PiFromLambdacDecay',
prescale = config[ 'PiFromLambdacPrescale' ],
selection = self.sel_PiLambdac,
RequiredRawEvents = ["Muon"],
RelatedInfoTools = [addRelInfoMuonIsolation(self.sel_PiLambdac.algorithm().DecayDescriptor) ]
)
self.sel_KLambdac = makeLambdacSelection( name + '_KFromLambdac', "kaon", self.selStdNoPIDPions, self.selStdNoPIDKaons, self.selStdNoPIDProtons)
self.line_KLambdac = StrippingLine( name + '_KFromLambdacDecay',
prescale = config[ 'KFromLambdacPrescale' ],
selection = self.sel_KLambdac,
RequiredRawEvents = ["Muon"],
RelatedInfoTools = [addRelInfoMuonIsolation(self.sel_KLambdac.algorithm().DecayDescriptor) ]
)
self.sel_PLambdac = makeLambdacSelection( name + '_PFromLambdac', "proton", self.selStdNoPIDPions, self.selStdNoPIDKaons, self.selStdNoPIDProtons)
self.line_PLambdac = StrippingLine( name + '_PFromLambdacDecay',
prescale = config[ 'PFromLambdacPrescale' ],
selection = self.sel_PLambdac,
RequiredRawEvents = ["Muon"],
RelatedInfoTools = [addRelInfoMuonIsolation(self.sel_PLambdac.algorithm().DecayDescriptor) ]
)
self.sel_PiISMUONLambdac = makeLambdacSelection( name + '_PiISMUONFromLambdac', "pionISMUON",
self.selStdNoPIDPions, self.selStdNoPIDKaons, self.selStdNoPIDProtons)
self.line_PiISMUONLambdac = StrippingLine( name + '_PiISMUONFromLambdacDecay',
prescale = config[ 'PiISMUONFromLambdacPrescale' ],
selection = self.sel_PiISMUONLambdac,
RequiredRawEvents = ["Muon"],
RelatedInfoTools = [addRelInfoMuonIsolation(self.sel_PiISMUONLambdac.algorithm().DecayDescriptor) ]
)
self.sel_KISMUONLambdac = makeLambdacSelection( name + '_KISMUONFromLambdac', "kaonISMUON",
self.selStdNoPIDPions, self.selStdNoPIDKaons, self.selStdNoPIDProtons)
self.line_KISMUONLambdac = StrippingLine( name + '_KISMUONFromLambdacDecay',
prescale = config[ 'KISMUONFromLambdacPrescale' ],
selection = self.sel_KISMUONLambdac,
RequiredRawEvents = ["Muon"],
RelatedInfoTools = [addRelInfoMuonIsolation(self.sel_KISMUONLambdac.algorithm().DecayDescriptor) ]
)
self.sel_PISMUONLambdac = makeLambdacSelection( name + '_PISMUONFromLambdac', "protonISMUON"
, self.selStdNoPIDPions, self.selStdNoPIDKaons, self.selStdNoPIDProtons)
self.line_PISMUONLambdac = StrippingLine( name + '_PISMUONFromLambdacDecay',
prescale = config[ 'PISMUONFromLambdacPrescale' ],
selection = self.sel_PISMUONLambdac,
RequiredRawEvents = ["Muon"],
RelatedInfoTools = [addRelInfoMuonIsolation(self.sel_PISMUONLambdac.algorithm().DecayDescriptor) ]
)
#self.registerLine( self.line_Prompt )
#self.registerLine( self.line_Detached )
self.registerLine( self.line_DetachedNoMIP )
#self.registerLine( self.line_DetachedNoMIPHiP )
self.registerLine( self.line_DetachedNoMIPK )
self.registerLine( self.line_Lambdac )
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
# Set up global event cuts.
# Conceptually these come first, although the place where they're
# inserted into the line is at the bottom of the code.
_globalEventCuts = {
"Code":
"( recSummaryTrack(LHCb.RecSummary.nLongTracks, TrLONG) < %(LongTrackGEC)s )"
% config,
"Preambulo": ["from LoKiTracks.decorators import *"]
}
# Select all charged kaons, protons and pions.
self.selKaon = filterKaons('KFor' + name,
'Phys/StdTightKaons/Particles',
config['isLong'], config['Trk_P_MIN'],
config['KAON_PIDK_MIN'],
config['KAON_PIDKp_MIN'],
config['KAON_ipChi2_MAX'])
self.selPion = filterPions('PiFor' + name,
'Phys/StdAllNoPIDsPions/Particles',
config['isLong'], config['PION_ipChi2_MIN'],
config['PION_P_MIN'])
#using the same function/method to select Protons as Pions
self.selProton = filterPions('ProtonFor' + name,
'Phys/StdAllNoPIDsProtons/Particles',
config['isLong'],
config['PROTON_ipChi2_MIN'],
config['PROTON_P_MIN'])
self.selPPi = [self.selPion, self.selProton]
self.selKK = [self.selKaon]
# Now make the various decays e.g. Lambda/Lambda-bar decays which are real
# and the dummy decays "f_2(2300) -> Lambda0 Lambda~0", - not real decay but dummy
# "phi(1020) -> K+ K-" - not real but dummy
# "Lambda_c+ -> Lambda0 K+" - not real but dummy
# "Lambda_c- -> Lambda~0 K-" - not real but dummy
#
# real decays
strDecaysLambda = ["Lambda0 -> p+ pi-"]
strDecaysLambdabar = ["Lambda~0 -> p~- pi+"]
# dummy decays
strDecaysF2 = ["f_2(2300) -> Lambda0 Lambda~0"]
strDecaysPhi = ["phi(1020) -> K+ K-"]
strDecaysLambdaCplus = ["Lambda_c+ -> Lambda0 K+"]
strDecaysLambdaCminus = ["Lambda_c~- -> Lambda~0 K-"]
# make real decays
self.selLambda = makeLambda('Lambda' + name, strDecaysLambda,
self.selPPi, config['Fisher'],
config['Lambda_V_Chi2_Max'],
config['Lambda_Adamass'],
config['Lambda_ipChi2_MAX'])
self.selLambdabar = makeLambda('Lambdabar' + name, strDecaysLambdabar,
self.selPPi, config['Fisher'],
config['Lambda_V_Chi2_Max'],
config['Lambda_Adamass'],
config['Lambda_ipChi2_MAX'])
# print self.selKK
# make a dummy Phi
self.selPhi = makePhi('Phi' + name, strDecaysPhi, self.selKK)
# Now make the dummy decays with at least a Lambda
# print [self.selLambda] + [self.selLambdabar]
# print [self.selLambda] + self.selKK
# print [self.selLambdabar] + self.selKK
# print 'input'
# print strDecaysLambda
# print strDecaysLambdabar
# print strDecaysPhi
# print strDecaysF2
# print strDecaysLambdaCplus
# print strDecaysLambdaCminus
self.selF2 = makePhi('F2LambdaLambdabar' + name, strDecaysF2,
[self.selLambda] + [self.selLambdabar])
self.selLambdaCplus = makePhi('LambdaCplus' + name,
strDecaysLambdaCplus,
[self.selLambda] + self.selKK)
self.selLambdaCminus = makePhi('LambdaCminus' + name,
strDecaysLambdaCminus,
[self.selLambdabar] + self.selKK)
# Make the stripping lines
self.linePhi = StrippingLine(name + 'PhiLine',
FILTER=_globalEventCuts,
prescale=config['Phiprescale'],
postscale=config['postscale'],
HLT=config['HLT'],
selection=self.selPhi)
self.lineF2 = StrippingLine(name + 'F2Line',
FILTER=_globalEventCuts,
prescale=config['F2prescale'],
postscale=config['postscale'],
HLT=config['HLT'],
selection=self.selF2)
self.lineLambdaCplus = StrippingLine(
name + 'LambdaCplusLine',
FILTER=_globalEventCuts,
prescale=config['LambdaCprescale'],
postscale=config['postscale'],
HLT=config['HLT'],
selection=self.selLambdaCplus)
self.lineLambdaCminus = StrippingLine(
name + 'LambdaCminusLine',
FILTER=_globalEventCuts,
prescale=config['LambdaCprescale'],
postscale=config['postscale'],
HLT=config['HLT'],
selection=self.selLambdaCminus)
self.registerLine(self.linePhi)
self.registerLine(self.lineF2)
self.registerLine(self.lineLambdaCplus)
self.registerLine(self.lineLambdaCminus)
def __init__(self, name, config):
'''The constructor of the configuration class.
Requires a configuration dictionary, config, which must provide all the settings for cuts which are not hard coded
'''
LineBuilder.__init__(self, name, config)
self.name = name
self.BuToKX3872LineName = self.name + "_BuToKX3872"
self.BuToKPsi2SLineName = self.name + "_BuToKPsi2S"
self.BuToKX3872LooseLineName = self.name + "_BuToKX3872Loose"
self.BuToKPsi2SLooseLineName = self.name + "_BuToKPsi2SLoose"
#self.__PVOutputLocation__ = "Rec/Vertex/"+name+"_ModPrimary"
##self.__PVOutputLocation__ = "Rec/Vertex/Primary"
############################
## Define the cut strings ##
############################
###############
# Bu cuts ##
###############
self.BuCombCut = "(ADAMASS('B+') < %(Bu_Comb_MassWindow)s * MeV)" % config
self.BuCombLooseCut = "(ADAMASS('B+') < %(Bu_Comb_MassWindowLoose)s * MeV)" % config
self.BuCut = "(ADMASS('B+') < %(Bu_MassWindow)s * MeV) & (VFASPF(VCHI2/VDOF) < %(Bu_VertexCHI2)s) & (BPVIPCHI2() < %(Bu_IPCHI2)s) & (BPVDIRA> %(Bu_DIRA)s) & (BPVVDCHI2 > %(Bu_FlightCHI2)s)" % config
self.BuLooseCut = "(ADMASS('B+') < %(Bu_MassWindowLoose)s * MeV) & (VFASPF(VCHI2/VDOF) < %(Bu_VertexCHI2Loose)s) & (BPVIPCHI2() < %(Bu_IPCHI2Loose)s) & (BPVDIRA> %(Bu_DIRALoose)s) & (BPVVDCHI2 > %(Bu_FlightCHI2Loose)s)" % config
##############################
## X3872 and Psi(2S) cuts ##
##############################
self.X3872CombCut = "(ADAMASS('X_1(3872)') < %(X3872_Comb_MassWindow)s * MeV)" % config
self.X3872CombLooseCut = "(ADAMASS('X_1(3872)') < %(X3872_Comb_MassWindowLoose)s * MeV)" % config
self.Psi2SCombCut = "(ADAMASS('psi(2S)') < %(X3872_Comb_MassWindow)s * MeV)" % config
self.Psi2SCombLooseCut = "(ADAMASS('psi(2S)') < %(X3872_Comb_MassWindowLoose)s * MeV)" % config
ResonanceVertexCut = "(VFASPF(VCHI2/VDOF) < %(X3872_VertexCHI2)s)" % config
ResonanceVertexLooseCut = "(VFASPF(VCHI2/VDOF) < %(X3872_VertexCHI2Loose)s)" % config
self.X3872Cut = "(ADMASS('X_1(3872)') < %(X3872_MassWindow)s * MeV) & " % config + ResonanceVertexCut
self.X3872LooseCut = "(ADMASS('X_1(3872)') < %(X3872_MassWindowLoose)s * MeV) & " % config + ResonanceVertexLooseCut
self.Psi2SCut = "(ADMASS('psi(2S)') < %(X3872_MassWindow)s * MeV) & " % config + ResonanceVertexCut
self.Psi2SLooseCut = "(ADMASS('psi(2S)') < %(X3872_MassWindowLoose)s * MeV) & " % config + ResonanceVertexLooseCut
######################
## Track cuts ##
######################
TrackCut = "(TRCHI2DOF < %(Track_CHI2nDOF)s)" % config
self.KaonCut = TrackCut + " & (PT > %(Kaon_PT)s * MeV) & (MIPCHI2DV(PRIMARY) > %(Kaon_MinIPCHI2)s)" % config
self.KaonLooseCut = TrackCut + " & (PT > %(Kaon_PTLoose)s * MeV) & (MIPCHI2DV(PRIMARY) > %(Kaon_MinIPCHI2Loose)s)" % config
self.PionCut = TrackCut + " & (MIPCHI2DV(PRIMARY) > %(Pion_MinIPCHI2)s)" % config
self.PionLooseCut = TrackCut + " & (MIPCHI2DV(PRIMARY) > %(Pion_MinIPCHI2Loose)s)" % config
MuonCut = TrackCut + " & (MIPCHI2DV(PRIMARY) > %(Muon_MinIPCHI2)s) & (PT > %(Muon_PT)s * MeV)" % config
if (config["Muon_IsMuon"]):
MuonCut += " & (ISMUON)"
MuonLooseCut = TrackCut + " & (MIPCHI2DV(PRIMARY) > %(Muon_MinIPCHI2Loose)s) & (PT > %(Muon_PT)s * MeV)" % config
if (config["Muon_IsMuon"]):
MuonLooseCut += " & (ISMUON)"
MuonPVCut = TrackCut + " & (PT > %(Muon_PT)s * MeV)" % config
if (config["Muon_IsMuon"]):
MuonPVCut += " & (ISMUON)"
##################
## Rho cuts ##
##################
self.RhoCuts = "(2 == NINTREE((ABSID=='pi+') & " + self.PionCut + "))"
######################
## J/psi cuts ##
######################
JPsiCut = "(ADMASS('J/psi(1S)') < %(JPsi_MassWindow)s * MeV) & (VFASPF(VCHI2/VDOF) < %(JPsi_VertexCHI2)s)" % config
JPsiLooseCut = "(ADMASS('J/psi(1S)') < %(JPsi_MassWindowLoose)s * MeV) & (VFASPF(VCHI2/VDOF) < %(JPsi_VertexCHI2Loose)s)" % config
self.JPsiCuts = JPsiCut + " & (2 == NINTREE((ABSID=='mu-') & " + MuonCut + "))"
self.JPsiLooseCuts = JPsiLooseCut + " & (2 == NINTREE((ABSID=='mu-') & " + MuonLooseCut + "))"
#########################
## Make the selections ##
#########################
## loose selections
Sel_JPsiLoose = self.__FilterSelectionJPsi__(self.name + "Loose",
self.JPsiLooseCuts)
Sel_RhoLoose = self.__CreateSelectionRho__(self.name + "Loose", "",
"ALL", self.PionCut)
Sel_X3872Loose = self.__CreateSelectionX3872__(
self.BuToKX3872LooseLineName, self.X3872CombLooseCut,
self.X3872LooseCut, [Sel_JPsiLoose, Sel_RhoLoose])
Sel_Psi2SLoose = self.__CreateSelectionX3872__(
self.BuToKPsi2SLooseLineName, self.Psi2SCombLooseCut,
self.Psi2SLooseCut, [Sel_JPsiLoose, Sel_RhoLoose])
Sel_KaonLoose = self.__FilterKaon__(self.name + "Loose",
self.KaonLooseCut)
Sel_BuX3872KLoose = self.__CreateSelectionBu__(
self.BuToKX3872LooseLineName, self.BuCombLooseCut, self.BuLooseCut,
[Sel_X3872Loose, Sel_KaonLoose])
Sel_BuPsi2SKLoose = self.__CreateSelectionBu__(
self.BuToKPsi2SLooseLineName, self.BuCombLooseCut, self.BuLooseCut,
[Sel_Psi2SLoose, Sel_KaonLoose])
## tight selections
Sel_JPsi = self.__FilterSelectionJPsi__(self.name, self.JPsiCuts)
Sel_Rho = self.__FilterSelectionRho__(self.name, self.RhoCuts,
[Sel_RhoLoose])
Sel_X3872 = self.__CreateSelectionX3872__(self.BuToKX3872LineName,
self.X3872CombCut,
self.X3872Cut,
[Sel_JPsi, Sel_Rho])
Sel_Psi2S = self.__CreateSelectionX3872__(self.BuToKPsi2SLineName,
self.Psi2SCombCut,
self.Psi2SCut,
[Sel_JPsi, Sel_Rho])
Sel_Kaon = self.__FilterKaon__(self.name, self.KaonCut)
Sel_BuX3872K = self.__CreateSelectionBu__(self.BuToKX3872LineName,
self.BuCombCut, self.BuCut,
[Sel_X3872, Sel_Kaon])
Sel_BuPsi2SK = self.__CreateSelectionBu__(self.BuToKPsi2SLineName,
self.BuCombCut, self.BuCut,
[Sel_Psi2S, Sel_Kaon])
###################################
## Construct the stripping lines ##
###################################
from StrippingConf.StrippingLine import StrippingLine
## Define PV filter
#MyFilterPVs = {'Code' : "VSOURCE('Rec/Vertex/Primary') >> (NTRACKS > 6) >> RV_SINKTES('"+self.__PVOutputLocation__+"') >> ~VEMPTY", 'Preambulo' : ["from LoKiPhys.decorators import *"]}
## --- B+ -> X3872 K+ loose line ---
Line_BuToX3872Loose_Name = self.BuToKX3872LooseLineName + "Line"
Line_BuToX3872Loose = StrippingLine(
Line_BuToX3872Loose_Name,
prescale=config['Prescale_BuToKX3872Loose'],
postscale=config['Postscale_BuToKX3872Loose'],
#FILTER = MyFilterPVs,
selection=Sel_BuX3872KLoose)
self.registerLine(Line_BuToX3872Loose)
## --- B+ -> Psi2S K+ loose line ---
Line_BuToPsi2SLoose_Name = self.BuToKPsi2SLooseLineName + "Line"
Line_BuToPsi2SLoose = StrippingLine(
Line_BuToPsi2SLoose_Name,
prescale=config['Prescale_BuToKPsi2SLoose'],
postscale=config['Postscale_BuToKPsi2SLoose'],
selection=Sel_BuPsi2SKLoose)
self.registerLine(Line_BuToPsi2SLoose)
## --- B+ -> X3872 K+ line ---
Line_BuToX3872_Name = self.BuToKX3872LineName + "Line"
Line_BuToX3872 = StrippingLine(
Line_BuToX3872_Name,
prescale=config['Prescale_BuToKX3872'],
postscale=config['Postscale_BuToKX3872'],
selection=Sel_BuX3872K)
self.registerLine(Line_BuToX3872)
## --- B+ -> Psi2S K+ line ---
Line_BuToPsi2S_Name = self.BuToKPsi2SLineName + "Line"
Line_BuToPsi2S = StrippingLine(
Line_BuToPsi2S_Name,
prescale=config['Prescale_BuToKPsi2S'],
postscale=config['Postscale_BuToKPsi2S'],
selection=Sel_BuPsi2SK)
self.registerLine(Line_BuToPsi2S)
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
KstKst_name = name + "Nominal"
KstKstSameCharge_name = name + 'SameCharge'
BdJpsiKst_name = "Bd2JPsiKstFor" + name
self.selJPsi2mumu = makeJPsi2mumu('Jpsi2MuMuFor' + name,
MuonPT=config['KaonPT'],
MuonIPCHI2=config['KaonIPCHI2'],
JPsiPT=config["KstarPT"],
JPsiVCHI2=config['KstarVCHI2'])
self.selKst2Kpi = makeKst2Kpi('Kst2KpiFor' + name,
KaonPT=config['KaonPT'],
KaonIPCHI2=config['KaonIPCHI2'],
PionPT=config['PionPT'],
PionIPCHI2=config['PionIPCHI2'],
KstarPT=config["KstarPT"],
KaonPIDK=config['KaonPIDK'],
KstarVCHI2=config['KstarVCHI2'],
KstarMassWin=config['KstarMassWin'],
PionPIDK=config['PionPIDK'])
self.selBs2KstKst = makeBs2KstKst(KstKst_name,
Kstsel=self.selKst2Kpi,
BMassWin=config['BMassWin'],
BVCHI2=config['BVCHI2'],
BDOCA=config['BDOCA'],
BIPCHI2=config['BIPCHI2'])
self.selBs2KstKstSameCharge = makeBs2KstKstSameCharge(
KstKstSameCharge_name,
Kstsel=self.selKst2Kpi,
BMassWin=config['BMassWin'],
BVCHI2=config['BVCHI2'],
BDOCA=config['BDOCA'],
BIPCHI2=config['BIPCHI2'])
self.selBd2JPsiKst = makeBd2JPsiKst(BdJpsiKst_name,
JPsisel=self.selJPsi2mumu,
Kstsel=self.selKst2Kpi,
BMassWin=config['BMassWin'],
BVCHI2=config['BVCHI2'],
BDOCA=config['BDOCA'],
BIPCHI2=config['BIPCHI2'])
self.Bs2KstKst_line = StrippingLine(KstKst_name + "Line",
prescale=1,
postscale=1,
algos=[self.selBs2KstKst])
self.Bs2KstKstSameCharge_line = StrippingLine(
KstKstSameCharge_name + "Line",
prescale=1,
postscale=1,
algos=[self.selBs2KstKstSameCharge])
self.Bd2JPsiKstar_line = StrippingLine(BdJpsiKst_name + "Line",
prescale=1,
postscale=1,
algos=[self.selBd2JPsiKst])
self.registerLine(self.Bs2KstKst_line)
self.registerLine(self.Bs2KstKstSameCharge_line)
self.registerLine(self.Bd2JPsiKstar_line)
def __init__(self, moduleName, config):
LineBuilder.__init__(self, moduleName, config)
selD02hhhh = makeD02hhhh(
moduleName = moduleName
,combMassWin = config['CombD0MassWin']
,massWin = config['D0MassWin']
,maxDOCA = config['D0MaxDOCA']
,pt = config['D0Pt']
,dauPt = config['D0DauPt']
,dauMom = config['D0DauP']
,vtxChi2DOF = config['D0VtxChi2DOF']
,FDChi2 = config['D0FDChi2']
,IPChi2 = config['D0IPChi2']
,dauMaxIPChi2 = config['D0DauMaxIPChi2']
,dauIPChi2 = config['D0DauIPChi2']
,DIRA = config['D0DIRA']
,trackChi2DOF = config['TrackChi2DOF']
,applyKaonPIDK = config['ApplyKaonPIDK']
,kaonPIDK = config['KaonPIDK']
,applyPionPIDK = config['ApplyPionPIDK']
,pionPIDK = config['PionPIDK']
,applyGhostProbCut = config['ApplyGhostProbCut']
,ghostProbCut = config['GhostProbCut']
)
selPromptDstar = makePromptDstar(
moduleName = moduleName
,selection = selD02hhhh
,combDelmLower = config['CombDelmLower']
,combDelmUpper = config['CombDelmUpper']
,delmLower = config['DelmLower']
,delmUpper = config['DelmUpper']
,DOCA = config['DstarDOCA']
,vertexChi2DOF = config['DstarVtxChi2DOF']
,pt = config['DstarPt']
,slowPionPt = config['SlowPionPt']
,trackChi2DOF = config['TrackChi2DOF']
)
_GECfilter = None
if config['ApplyGECs']:
_filter = ""
nLong = config["MaxLongTracks"]
if nLong is not None:
if _filter != "":
_filter+=" & "
_filter += "( recSummaryTrack(LHCb.RecSummary.nLongTracks,TrLONG) < %s )" %nLong
nDigits = config["MaxSpdDigits"]
if nDigits is not None:
if _filter != "":
_filter+=" & "
_filter += "( recSummary(LHCb.RecSummary.nSpdhits,'Raw/Spd/Digits') < %s )" %nDigits
nClusters = config["MaxITClusters"]
if nClusters is not None:
if _filter != "":
_filter+=" & "
_filter += " ( recSummary(LHCb.RecSummary.nITClusters,'Raw/IT/Clusters') < %s )" %nClusters
nVELO = config["MaxVeloTracks"]
if nVELO is not None:
if _filter != "":
_filter+=" & "
_filter += "( recSummaryTrack(LHCb.RecSummary.nVeloTracks,TrVELO) < %s )" %nVELO
if _filter != "":
_GECfilter = {'Code' : _filter,
'Preambulo' : ["from LoKiTracks.decorators import *",
'from LoKiNumbers.decorators import *',
'from LoKiCore.functions import *']
}
self.line_tagged_d02hhhh = StrippingLine(
moduleName+"Line"
,prescale=config['Prescale']
,postscale=config['Postscale']
,selection=selPromptDstar
,checkPV=config['CheckPV']
,FILTER=_GECfilter)
self.registerLine(self.line_tagged_d02hhhh)
def __init__(self, moduleName, config):
LineBuilder.__init__(self, moduleName, config)
selD02hhhh = makeD02hhhh(moduleName=moduleName,
combMassWin=config['CombD0MassWin'],
massWin=config['D0MassWin'],
maxDOCA=config['D0MaxDOCA'],
pt=config['D0Pt'],
dauPt=config['D0DauPt'],
dauMom=config['D0DauP'],
vtxChi2DOF=config['D0VtxChi2DOF'],
FDChi2=config['D0FDChi2'],
IPChi2=config['D0IPChi2'],
dauMaxIPChi2=config['D0DauMaxIPChi2'],
dauIPChi2=config['D0DauIPChi2'],
DIRA=config['D0DIRA'],
trackChi2DOF=config['TrackChi2DOF'],
applyKaonPIDK=config['ApplyKaonPIDK'],
kaonPIDK=config['KaonPIDK'],
applyPionPIDK=config['ApplyPionPIDK'],
pionPIDK=config['PionPIDK'])
selPromptDstar = makePromptDstar(
moduleName=moduleName,
selection=selD02hhhh,
combDelmLower=config['CombDelmLower'],
combDelmUpper=config['CombDelmUpper'],
delmLower=config['DelmLower'],
delmUpper=config['DelmUpper'],
DOCA=config['DstarDOCA'],
vertexChi2DOF=config['DstarVtxChi2DOF'],
pt=config['DstarPt'],
slowPionPt=config['SlowPionPt'],
trackChi2DOF=config['TrackChi2DOF'])
_filter = None
if config['ApplyGECs']:
_filter = ""
nLong = config["MaxLongTracks"]
if nLong is not None:
if _filter != "":
_filter += " & "
_filter += "(TrSOURCE('Rec/Track/Best') >> TrLONG >> (TrSIZE < %s))" % nLong
nDigits = config["MaxSpdDigits"]
if nDigits is not None:
if _filter != "":
_filter += " & "
_filter += "(CONTAINS('Raw/Spd/Digits') < %s)" % nDigits
nClusters = config["MaxITClusters"]
if nClusters is not None:
if _filter != "":
_filter += " & "
_filter += "(CONTAINS('Raw/IT/Clusters') < %s)" % nClusters
nVELO = config["MaxVeloTracks"]
if nVELO is not None:
if _filter != "":
_filter += " & "
_filter += "(TrSOURCE('Rec/Track/Best') >> TrVELO >> (TrSIZE < %s))" % nVELO
if _filter == "": _filter = None # no filters
self.line_tagged_d02hhhh = StrippingLine(moduleName + "Line",
prescale=config['Prescale'],
postscale=config['Postscale'],
selection=selPromptDstar,
checkPV=config['CheckPV'],
FILTER=_filter)
self.registerLine(self.line_tagged_d02hhhh)
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
_pipipi_exclName = name + '_pipipi_excl'
_Kpipi_exclName = name + '_Kpipi_excl'
_KKpi_exclName = name + '_KKpi_excl'
_KKK_exclName = name + '_KKK_excl'
_pppi_exclName = name + '_pppi_excl'
_ppK_exclName = name + '_ppK_excl'
self.selpipipi = makepipipi_excl(
'pipipiexclFor' + _pipipi_exclName + 'Sel',
_h_PT=config['_h_PT'],
_h_P=config['_h_P'],
_h_IPCHI2=config['_h_IPCHI2'],
_h_TRCHI2DOF=config['_h_TRCHI2DOF'],
_h_TRGHP=config['_h_TRGHP'],
_3h_DOCA=config['_3h_DOCA'],
_3h_PTmax=config['_3h_PTmax'],
_3h_DIRA=config['_3h_DIRA'],
_3h_FDCHI2=config['_3h_FDCHI2'],
_3h_SVPV=config['_3h_SVPV'],
_3h_CHI2=config['_3h_CHI2'],
_3h_IPCHI2=config['_3h_IPCHI2'],
_3h_PT=config['_3h_PT'],
_3h_PTsum=config['_3h_PTsum'],
_3h_Psum=config['_3h_Psum'],
_3h_PVIPCHI2sum=config['_3h_PVIPCHI2sum'],
_3h_TRKCHIDOFmin=config['_3h_TRKCHIDOFmin'],
_3h_Mmin=config['_3h_Mmin'],
_3h_Mmax=config['_3h_Mmax'],
_bu3h_Mmin=config['_bu3h_Mmin'],
_bu3h_Mmax=config['_bu3h_Mmax'])
self.selKpipi = makeKpipi_excl(
'KpipiexclFor' + _Kpipi_exclName + 'Sel',
_h_PT=config['_h_PT'],
_h_P=config['_h_P'],
_h_IPCHI2=config['_h_IPCHI2'],
_h_TRCHI2DOF=config['_h_TRCHI2DOF'],
_h_TRGHP=config['_h_TRGHP'],
_3h_DOCA=config['_3h_DOCA'],
_3h_PTmax=config['_3h_PTmax'],
_3h_DIRA=config['_3h_DIRA'],
_3h_FDCHI2=config['_3h_FDCHI2'],
_3h_SVPV=config['_3h_SVPV'],
_3h_CHI2=config['_3h_CHI2'],
_3h_IPCHI2=config['_3h_IPCHI2'],
_3h_PT=config['_3h_PT'],
_3h_PTsum=config['_3h_PTsum'],
_3h_Psum=config['_3h_Psum'],
_3h_PVIPCHI2sum=config['_3h_PVIPCHI2sum'],
_3h_TRKCHIDOFmin=config['_3h_TRKCHIDOFmin'],
_3h_Mmin=config['_3h_Mmin'],
_3h_Mmax=config['_3h_Mmax'],
_bu3h_Mmin=config['_bu3h_Mmin'],
_bu3h_Mmax=config['_bu3h_Mmax'],
_probnnk=config['_probnnk'])
self.selKKpi = makeKKpi_excl(
'KKpiexclFor' + _KKpi_exclName + 'Sel',
_h_PT=config['_h_PT'],
_h_P=config['_h_P'],
_h_IPCHI2=config['_h_IPCHI2'],
_h_TRCHI2DOF=config['_h_TRCHI2DOF'],
_h_TRGHP=config['_h_TRGHP'],
_3h_DOCA=config['_3h_DOCA'],
_3h_PTmax=config['_3h_PTmax'],
_3h_DIRA=config['_3h_DIRA'],
_3h_FDCHI2=config['_3h_FDCHI2'],
_3h_SVPV=config['_3h_SVPV'],
_3h_CHI2=config['_3h_CHI2'],
_3h_IPCHI2=config['_3h_IPCHI2'],
_3h_PT=config['_3h_PT'],
_3h_PTsum=config['_3h_PTsum'],
_3h_Psum=config['_3h_Psum'],
_3h_PVIPCHI2sum=config['_3h_PVIPCHI2sum'],
_3h_TRKCHIDOFmin=config['_3h_TRKCHIDOFmin'],
_3h_Mmin=config['_3h_Mmin'],
_3h_Mmax=config['_3h_Mmax'],
_bu3h_Mmin=config['_bu3h_Mmin'],
_bu3h_Mmax=config['_bu3h_Mmax'],
_probnnpi=config['_probnnpi'],
_probnnk=config['_probnnk'])
self.selKKK = makeKKK_excl('KKKexclFor' + _KKK_exclName + 'Sel',
_h_PT=config['_h_PT'],
_h_P=config['_h_P'],
_h_IPCHI2=config['_h_IPCHI2'],
_h_TRCHI2DOF=config['_h_TRCHI2DOF'],
_h_TRGHP=config['_h_TRGHP'],
_3h_DOCA=config['_3h_DOCA'],
_3h_PTmax=config['_3h_PTmax'],
_3h_DIRA=config['_3h_DIRA'],
_3h_FDCHI2=config['_3h_FDCHI2'],
_3h_SVPV=config['_3h_SVPV'],
_3h_CHI2=config['_3h_CHI2'],
_3h_IPCHI2=config['_3h_IPCHI2'],
_3h_PT=config['_3h_PT'],
_3h_PTsum=config['_3h_PTsum'],
_3h_Psum=config['_3h_Psum'],
_3h_PVIPCHI2sum=config['_3h_PVIPCHI2sum'],
_3h_TRKCHIDOFmin=config['_3h_TRKCHIDOFmin'],
_3h_Mmin=config['_3h_Mmin'],
_3h_Mmax=config['_3h_Mmax'],
_bu3h_Mmin=config['_bu3h_Mmin'],
_bu3h_Mmax=config['_bu3h_Mmax'],
_probnnk=config['_probnnk'])
self.selpppi = makepppi_excl(
'pppiexclFor' + _pppi_exclName + 'Sel',
_h_PT=config['_h_PT'],
_h_P=config['_h_P'],
_h_IPCHI2=config['_h_IPCHI2'],
_h_TRCHI2DOF=config['_h_TRCHI2DOF'],
_h_TRGHP=config['_h_TRGHP'],
_3h_DOCA=config['_3h_DOCA'],
_3h_PTmax=config['_3h_PTmax'],
_3h_DIRA=config['_3h_DIRA'],
_3h_FDCHI2=config['_3h_FDCHI2'],
_3h_SVPV=config['_3h_SVPV'],
_3h_CHI2=config['_3h_CHI2'],
_3h_IPCHI2=config['_3h_IPCHI2'],
_3h_PT=config['_3h_PT'],
_3h_PTsum=config['_3h_PTsum'],
_3h_Psum=config['_3h_Psum'],
_3h_PVIPCHI2sum=config['_3h_PVIPCHI2sum'],
_3h_TRKCHIDOFmin=config['_3h_TRKCHIDOFmin'],
_3h_Mmin=config['_3h_Mmin'],
_3h_Mmax=config['_3h_Mmax'],
_bu3h_Mmin=config['_bu3h_Mmin'],
_bu3h_Mmax=config['_bu3h_Mmax'],
_probnnpi=config['_probnnpi'],
_probnnp=config['_probnnp'])
self.selppK = makeppK_excl('ppKexclFor' + _ppK_exclName + 'Sel',
_h_PT=config['_h_PT'],
_h_P=config['_h_P'],
_h_IPCHI2=config['_h_IPCHI2'],
_h_TRCHI2DOF=config['_h_TRCHI2DOF'],
_h_TRGHP=config['_h_TRGHP'],
_3h_DOCA=config['_3h_DOCA'],
_3h_PTmax=config['_3h_PTmax'],
_3h_DIRA=config['_3h_DIRA'],
_3h_FDCHI2=config['_3h_FDCHI2'],
_3h_SVPV=config['_3h_SVPV'],
_3h_CHI2=config['_3h_CHI2'],
_3h_IPCHI2=config['_3h_IPCHI2'],
_3h_PT=config['_3h_PT'],
_3h_PTsum=config['_3h_PTsum'],
_3h_Psum=config['_3h_Psum'],
_3h_PVIPCHI2sum=config['_3h_PVIPCHI2sum'],
_3h_TRKCHIDOFmin=config['_3h_TRKCHIDOFmin'],
_3h_Mmin=config['_3h_Mmin'],
_3h_Mmax=config['_3h_Mmax'],
_bu3h_Mmin=config['_bu3h_Mmin'],
_bu3h_Mmax=config['_bu3h_Mmax'],
_probnnk=config['_probnnk'],
_probnnp=config['_probnnp'])
self.gECFilter = globalEventCutFilter(name + 'GlobalEventCutFilter',
MaxTrSIZE=config['MaxTrSIZE'])
self.algospipipi = []
if self.gECFilter != None: self.algospipipi.append(self.gECFilter)
self.algospipipi.append(self.selpipipi)
self.algosKpipi = []
if self.gECFilter != None: self.algosKpipi.append(self.gECFilter)
self.algosKpipi.append(self.selKpipi)
self.algosKKpi = []
if self.gECFilter != None: self.algosKKpi.append(self.gECFilter)
self.algosKKpi.append(self.selKKpi)
self.algosKKK = []
if self.gECFilter != None: self.algosKKK.append(self.gECFilter)
self.algosKKK.append(self.selKKK)
self.algospppi = []
if self.gECFilter != None: self.algospppi.append(self.gECFilter)
self.algospppi.append(self.selpppi)
self.algosppK = []
if self.gECFilter != None: self.algosppK.append(self.gECFilter)
self.algosppK.append(self.selppK)
self.linepipipi_excl = StrippingLine(
_pipipi_exclName + 'Line',
prescale=config['pipipi_exclLinePrescale'],
postscale=config['pipipi_exclLinePostscale'],
algos=self.algospipipi,
MDSTFlag=True,
EnableFlavourTagging=True)
self.lineKpipi_excl = StrippingLine(
_Kpipi_exclName + 'Line',
prescale=config['Kpipi_exclLinePrescale'],
postscale=config['Kpipi_exclLinePostscale'],
algos=self.algosKpipi,
MDSTFlag=True,
EnableFlavourTagging=True)
self.lineKKpi_excl = StrippingLine(
_KKpi_exclName + 'Line',
prescale=config['KKpi_exclLinePrescale'],
postscale=config['KKpi_exclLinePostscale'],
algos=self.algosKKpi,
MDSTFlag=True,
EnableFlavourTagging=True)
self.lineKKK_excl = StrippingLine(
_KKK_exclName + 'Line',
prescale=config['KKK_exclLinePrescale'],
postscale=config['KKK_exclLinePostscale'],
algos=self.algosKKK,
MDSTFlag=True,
EnableFlavourTagging=True)
self.linepppi_excl = StrippingLine(
_pppi_exclName + 'Line',
prescale=config['pppi_exclLinePrescale'],
postscale=config['pppi_exclLinePostscale'],
algos=self.algospppi,
MDSTFlag=True,
EnableFlavourTagging=True)
self.lineppK_excl = StrippingLine(
_ppK_exclName + 'Line',
prescale=config['ppK_exclLinePrescale'],
postscale=config['ppK_exclLinePostscale'],
algos=self.algosppK,
MDSTFlag=True,
EnableFlavourTagging=True)
self.registerLine(self.linepipipi_excl)
self.registerLine(self.lineKpipi_excl)
self.registerLine(self.lineKKpi_excl)
self.registerLine(self.lineKKK_excl)
self.registerLine(self.linepppi_excl)
self.registerLine(self.lineppK_excl)
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
_KKK_inclName = name + '_KKK_incl'
_KpKpKp_inclName = name + '_KKK_samesign'
_pph_inclName = name + '_pph_incl'
self.selKKK = makeKKK_incl('KKKinclFor' + _KKK_inclName + 'Sel',
_h_PT=config['_h_PT'],
_h_P=config['_h_P'],
_h_IPCHI2=config['_h_IPCHI2'],
_h_TRCHI2DOF=config['_h_TRCHI2DOF'],
_h_TRGHP=config['_h_TRGHP'],
_3h_DOCA=config['_3h_DOCA'],
_3h_PTmax=config['_3h_PTmax'],
_3h_DIRA=config['_3h_DIRA'],
_3h_FDCHI2=config['_3h_FDCHI2'],
_3h_PVDOCAmin=config['_3h_PVDOCAmin'],
_3h_CHI2=config['_3h_CHI2'],
_3h_IPCHI2=config['_3h_IPCHI2'],
_3h_PT=config['_3h_PT'],
_3h_PTsum=config['_3h_PTsum'],
_3h_Psum=config['_3h_Psum'],
_3h_PVIPCHI2sum=config['_3h_PVIPCHI2sum'],
_3h_TRKCHIDOFmin=config['_3h_TRKCHIDOFmin'],
_3h_CORRMmax=config['_3h_CORRMmax'],
_3h_CORRMmin=config['_3h_CORRMmin'],
_3hKKK_Mmin=config['_3hKKK_Mmin'],
_3hKKK_Mmax=config['_3hKKK_Mmax'])
self.selKpKpKp = makeKpKpKp_incl(
'KpKpKpinclFor' + _KpKpKp_inclName + 'Sel',
_h_PT=config['_h_PT'],
_h_P=config['_h_P'],
_h_IPCHI2=config['_h_IPCHI2'],
_h_TRCHI2DOF=config['_h_TRCHI2DOF'],
_h_TRGHP=config['_h_TRGHP'],
_3h_DOCA=config['_3h_DOCA'],
_3h_PTmax=config['_3h_PTmax'],
_3h_DIRA=config['_3h_DIRA'],
_3h_FDCHI2=config['_3h_FDCHI2'],
_3h_PVDOCAmin=config['_3h_PVDOCAmin'],
_3h_CHI2=config['_3h_CHI2'],
_3h_IPCHI2=config['_3h_IPCHI2'],
_3h_PT=config['_3h_PT'],
_3h_PTsum=config['_3h_PTsum'],
_3h_Psum=config['_3h_Psum'],
_3h_PVIPCHI2sum=config['_3h_PVIPCHI2sum'],
_3h_TRKCHIDOFmin=config['_3h_TRKCHIDOFmin'],
_3h_CORRMmax=config['_3h_CORRMmax'],
_3h_CORRMmin=config['_3h_CORRMmin'],
_3hKKK_Mmin=config['_3hKKK_Mmin'],
_3hKKK_Mmax=config['_3hKKK_Mmax'])
self.selpph = makepph_incl('pphinclFor' + _pph_inclName + 'Sel',
_h_PT=config['_h_PT'],
_h_P=config['_h_P'],
_h_IPCHI2=config['_h_IPCHI2'],
_h_TRCHI2DOF=config['_h_TRCHI2DOF'],
_h_TRGHP=config['_h_TRGHP'],
_3h_DOCA=config['_3h_DOCA'],
_3h_PTmax=config['_3h_PTmax'],
_3h_DIRA=config['_3h_DIRA'],
_3h_FDCHI2=config['_3h_FDCHI2'],
_3h_PVDOCAmin=config['_3h_PVDOCAmin'],
_3h_CHI2=config['_3h_CHI2'],
_3h_IPCHI2=config['_3h_IPCHI2'],
_3h_PT=config['_3h_PT'],
_3h_PTsum=config['_3h_PTsum'],
_3h_Psum=config['_3h_Psum'],
_3h_PVIPCHI2sum=config['_3h_PVIPCHI2sum'],
_3h_TRKCHIDOFmin=config['_3h_TRKCHIDOFmin'],
_3h_CORRMmax=config['_3h_CORRMmax'],
_3h_CORRMmin=config['_3h_CORRMmin'],
_3hpph_deltaMmax=config['_3hpph_deltaMmax'],
_3hpph_deltaMmin=config['_3hpph_deltaMmin'])
self.algosKKK = []
self.algosKKK.append(self.selKKK)
self.algosKpKpKp = []
self.algosKpKpKp.append(self.selKpKpKp)
self.algospph = []
self.algospph.append(self.selpph)
self.lineKKK_incl = StrippingLine(
_KKK_inclName + 'Line',
prescale=config['KKK_inclLinePrescale'],
postscale=config['KKK_inclLinePostscale'],
algos=self.algosKKK,
FILTER=filter,
RelatedInfoTools=[{
'Type':
'RelInfoConeVariables',
'ConeAngle':
0.5,
'Variables':
['CONEANGLE', 'CONEMULT', 'CONEPASYM', 'CONEPTASYM'],
'Location':
'ConeIso05B',
"DaughterLocations": {
"[B+ -> ^K+ K+ K-]CC": "ConeIso05h1",
"[B+ -> K+ ^K+ K-]CC": "ConeIso05h2",
"[B+ -> K+ K+ ^K-]CC": "ConeIso05h3",
}
}, {
'Type':
'RelInfoConeVariables',
'ConeAngle':
1.0,
'Variables':
['CONEANGLE', 'CONEMULT', 'CONEPASYM', 'CONEPTASYM'],
'Location':
'ConeIso10B',
"DaughterLocations": {
"[B+ -> ^K+ K+ K-]CC": "ConeIso10h1",
"[B+ -> K+ ^K+ K-]CC": "ConeIso10h2",
"[B+ -> K+ K+ ^K-]CC": "ConeIso10h3",
}
}, {
'Type':
'RelInfoConeVariables',
'ConeAngle':
1.5,
'Variables':
['CONEANGLE', 'CONEMULT', 'CONEPASYM', 'CONEPTASYM'],
'Location':
'ConeIso15B',
"DaughterLocations": {
"[B+ -> ^K+ K+ K-]CC": "ConeIso15h1",
"[B+ -> K+ ^K+ K-]CC": "ConeIso15h2",
"[B+ -> K+ K+ ^K-]CC": "ConeIso15h3",
}
}, {
'Type':
'RelInfoConeVariables',
'ConeAngle':
2.0,
'Variables':
['CONEANGLE', 'CONEMULT', 'CONEPASYM', 'CONEPTASYM'],
'Location':
'ConeIso20B',
"DaughterLocations": {
"[B+ -> ^K+ K+ K-]CC": "ConeIso20h1",
"[B+ -> K+ ^K+ K-]CC": "ConeIso20h2",
"[B+ -> K+ K+ ^K-]CC": "ConeIso20h3",
}
}, {
'Type':
'RelInfoConeVariablesForEW',
'ConeAngle':
0.5,
'Variables': [
'EWCONEANGLE', 'EWCONENPX', 'EWCONENPY', 'EWCONENPZ',
'EWCONENMULT', 'EWCONENVPT', 'EWCONENSPT', 'EWCONENVP',
'EWCONENSP'
],
'Location':
'NConeIso05B',
"DaughterLocations": {
"[B+ -> ^K+ K+ K-]CC": "NConeIso05h1",
"[B+ -> K+ ^K+ K-]CC": "NConeIso05h2",
"[B+ -> K+ K+ ^K-]CC": "NConeIso05h3",
}
}, {
'Type':
'RelInfoConeVariablesForEW',
'ConeAngle':
1.0,
'Variables': [
'EWCONEANGLE', 'EWCONENPX', 'EWCONENPY', 'EWCONENPZ',
'EWCONENMULT', 'EWCONENVPT', 'EWCONENSPT', 'EWCONENVP',
'EWCONENSP'
],
'Location':
'NConeIso10B',
"DaughterLocations": {
"[B+ -> ^K+ K+ K-]CC": "NConeIso10h1",
"[B+ -> K+ ^K+ K-]CC": "NConeIso10h2",
"[B+ -> K+ K+ ^K-]CC": "NConeIso10h3",
}
}, {
'Type':
'RelInfoConeVariablesForEW',
'ConeAngle':
1.5,
'Variables': [
'EWCONEANGLE', 'EWCONENPX', 'EWCONENPY', 'EWCONENPZ',
'EWCONENMULT', 'EWCONENVPT', 'EWCONENSPT', 'EWCONENVP',
'EWCONENSP'
],
'Location':
'NConeIso15B',
"DaughterLocations": {
"[B+ -> ^K+ K+ K-]CC": "NConeIso15h1",
"[B+ -> K+ ^K+ K-]CC": "NConeIso15h2",
"[B+ -> K+ K+ ^K-]CC": "NConeIso15h3",
}
}, {
'Type':
'RelInfoConeVariablesForEW',
'ConeAngle':
2.0,
'Variables': [
'EWCONEANGLE', 'EWCONENPX', 'EWCONENPY', 'EWCONENPZ',
'EWCONENMULT', 'EWCONENVPT', 'EWCONENSPT', 'EWCONENVP',
'EWCONENSP'
],
'Location':
'NConeIso20B',
"DaughterLocations": {
"[B+ -> ^K+ K+ K-]CC": "NConeIso20h1",
"[B+ -> K+ ^K+ K-]CC": "NConeIso20h2",
"[B+ -> K+ K+ ^K-]CC": "NConeIso20h3",
}
}])
self.lineKpKpKp_incl = StrippingLine(
_KpKpKp_inclName + 'Line',
prescale=config['KpKpKp_inclLinePrescale'],
postscale=config['KpKpKp_inclLinePostscale'],
algos=self.algosKpKpKp,
FILTER=filter,
RelatedInfoTools=[{
'Type':
'RelInfoConeVariables',
'ConeAngle':
0.5,
'Variables':
['CONEANGLE', 'CONEMULT', 'CONEPASYM', 'CONEPTASYM'],
'Location':
'ConeIso05B',
"DaughterLocations": {
"[B+ -> ^K+ K+ K+]CC": "ConeIso05h1",
"[B+ -> K+ ^K+ K+]CC": "ConeIso05h2",
"[B+ -> K+ K+ ^K+]CC": "ConeIso05h3",
}
}, {
'Type':
'RelInfoConeVariables',
'ConeAngle':
1.0,
'Variables':
['CONEANGLE', 'CONEMULT', 'CONEPASYM', 'CONEPTASYM'],
'Location':
'ConeIso10B',
"DaughterLocations": {
"[B+ -> ^K+ K+ K+]CC": "ConeIso10h1",
"[B+ -> K+ ^K+ K+]CC": "ConeIso10h2",
"[B+ -> K+ K+ ^K+]CC": "ConeIso10h3",
}
}, {
'Type':
'RelInfoConeVariables',
'ConeAngle':
1.5,
'Variables':
['CONEANGLE', 'CONEMULT', 'CONEPASYM', 'CONEPTASYM'],
'Location':
'ConeIso15B',
"DaughterLocations": {
"[B+ -> ^K+ K+ K+]CC": "ConeIso15h1",
"[B+ -> K+ ^K+ K+]CC": "ConeIso15h2",
"[B+ -> K+ K+ ^K+]CC": "ConeIso15h3",
}
}, {
'Type':
'RelInfoConeVariables',
'ConeAngle':
2.0,
'Variables':
['CONEANGLE', 'CONEMULT', 'CONEPASYM', 'CONEPTASYM'],
'Location':
'ConeIso20B',
"DaughterLocations": {
"[B+ -> ^K+ K+ K+]CC": "ConeIso20h1",
"[B+ -> K+ ^K+ K+]CC": "ConeIso20h2",
"[B+ -> K+ K+ ^K+]CC": "ConeIso20h3",
}
}, {
'Type':
'RelInfoConeVariablesForEW',
'ConeAngle':
0.5,
'Variables': [
'EWCONEANGLE', 'EWCONENPX', 'EWCONENPY', 'EWCONENPZ',
'EWCONENMULT', 'EWCONENVPT', 'EWCONENSPT', 'EWCONENVP',
'EWCONENSP'
],
'Location':
'NConeIso05B',
"DaughterLocations": {
"[B+ -> ^K+ K+ K+]CC": "NConeIso05h1",
"[B+ -> K+ ^K+ K+]CC": "NConeIso05h2",
"[B+ -> K+ K+ ^K+]CC": "NConeIso05h3",
}
}, {
'Type':
'RelInfoConeVariablesForEW',
'ConeAngle':
1.0,
'Variables': [
'EWCONEANGLE', 'EWCONENPX', 'EWCONENPY', 'EWCONENPZ',
'EWCONENMULT', 'EWCONENVPT', 'EWCONENSPT', 'EWCONENVP',
'EWCONENSP'
],
'Location':
'NConeIso10B',
"DaughterLocations": {
"[B+ -> ^K+ K+ K+]CC": "NConeIso10h1",
"[B+ -> K+ ^K+ K+]CC": "NConeIso10h2",
"[B+ -> K+ K+ ^K+]CC": "NConeIso10h3",
}
}, {
'Type':
'RelInfoConeVariablesForEW',
'ConeAngle':
1.5,
'Variables': [
'EWCONEANGLE', 'EWCONENPX', 'EWCONENPY', 'EWCONENPZ',
'EWCONENMULT', 'EWCONENVPT', 'EWCONENSPT', 'EWCONENVP',
'EWCONENSP'
],
'Location':
'NConeIso15B',
"DaughterLocations": {
"[B+ -> ^K+ K+ K+]CC": "NConeIso15h1",
"[B+ -> K+ ^K+ K+]CC": "NConeIso15h2",
"[B+ -> K+ K+ ^K+]CC": "NConeIso15h3",
}
}, {
'Type':
'RelInfoConeVariablesForEW',
'ConeAngle':
2.0,
'Variables': [
'EWCONEANGLE', 'EWCONENPX', 'EWCONENPY', 'EWCONENPZ',
'EWCONENMULT', 'EWCONENVPT', 'EWCONENSPT', 'EWCONENVP',
'EWCONENSP'
],
'Location':
'NConeIso20B',
"DaughterLocations": {
"[B+ -> ^K+ K+ K+]CC": "NConeIso20h1",
"[B+ -> K+ ^K+ K+]CC": "NConeIso20h2",
"[B+ -> K+ K+ ^K+]CC": "NConeIso20h3",
}
}])
self.linepph_incl = StrippingLine(
_pph_inclName + 'Line',
prescale=config['pph_inclLinePrescale'],
postscale=config['pph_inclLinePostscale'],
algos=self.algospph,
FILTER=filter,
RelatedInfoTools=[{
'Type':
'RelInfoConeVariables',
'ConeAngle':
0.5,
'Variables':
['CONEANGLE', 'CONEMULT', 'CONEPASYM', 'CONEPTASYM'],
'Location':
'ConeIso05B',
"DaughterLocations": {
"[B+ -> ^p+ p~- K+]CC": "ConeIso05p1",
"[B+ -> p+ ^p~- K+]CC": "ConeIso05p2",
"[B+ -> p+ p~- ^K+]CC": "ConeIso05h",
}
}, {
'Type':
'RelInfoConeVariables',
'ConeAngle':
1.0,
'Variables':
['CONEANGLE', 'CONEMULT', 'CONEPASYM', 'CONEPTASYM'],
'Location':
'ConeIso10B',
"DaughterLocations": {
"[B+ -> ^p+ p~- K+]CC": "ConeIso10p1",
"[B+ -> p+ ^p~- K+]CC": "ConeIso10p2",
"[B+ -> p+ p~- ^K+]CC": "ConeIso10h",
}
}, {
'Type':
'RelInfoConeVariables',
'ConeAngle':
1.5,
'Variables':
['CONEANGLE', 'CONEMULT', 'CONEPASYM', 'CONEPTASYM'],
'Location':
'ConeIso15B',
"DaughterLocations": {
"[B+ -> ^p+ p~- K+]CC": "ConeIso15p1",
"[B+ -> p+ ^p~- K+]CC": "ConeIso15p2",
"[B+ -> p+ p~- ^K+]CC": "ConeIso15h",
}
}, {
'Type':
'RelInfoConeVariables',
'ConeAngle':
2.0,
'Variables':
['CONEANGLE', 'CONEMULT', 'CONEPASYM', 'CONEPTASYM'],
'Location':
'ConeIso20B',
"DaughterLocations": {
"[B+ -> ^p+ p~- K+]CC": "ConeIso20p1",
"[B+ -> p+ ^p~- K+]CC": "ConeIso20p2",
"[B+ -> p+ p~- ^K+]CC": "ConeIso20h",
}
}, {
'Type':
'RelInfoConeVariablesForEW',
'ConeAngle':
0.5,
'Variables': [
'EWCONEANGLE', 'EWCONENPX', 'EWCONENPY', 'EWCONENPZ',
'EWCONENMULT', 'EWCONENVPT', 'EWCONENSPT', 'EWCONENVP',
'EWCONENSP'
],
'Location':
'NConeIso05B',
"DaughterLocations": {
"[B+ -> ^p+ p~- K+]CC": "NConeIso05p1",
"[B+ -> p+ ^p~- K+]CC": "NConeIso05p2",
"[B+ -> p+ p~- ^K+]CC": "NConeIso05h",
}
}, {
'Type':
'RelInfoConeVariablesForEW',
'ConeAngle':
1.0,
'Variables': [
'EWCONEANGLE', 'EWCONENPX', 'EWCONENPY', 'EWCONENPZ',
'EWCONENMULT', 'EWCONENVPT', 'EWCONENSPT', 'EWCONENVP',
'EWCONENSP'
],
'Location':
'NConeIso10B',
"DaughterLocations": {
"[B+ -> ^p+ p~- K+]CC": "NConeIso10p1",
"[B+ -> p+ ^p~- K+]CC": "NConeIso10p2",
"[B+ -> p+ p~- ^K+]CC": "NConeIso10h",
}
}, {
'Type':
'RelInfoConeVariablesForEW',
'ConeAngle':
1.5,
'Variables': [
'EWCONEANGLE', 'EWCONENPX', 'EWCONENPY', 'EWCONENPZ',
'EWCONENMULT', 'EWCONENVPT', 'EWCONENSPT', 'EWCONENVP',
'EWCONENSP'
],
'Location':
'NConeIso15B',
"DaughterLocations": {
"[B+ -> ^p+ p~- K+]CC": "NConeIso15p1",
"[B+ -> p+ ^p~- K+]CC": "NConeIso15p2",
"[B+ -> p+ p~- ^K+]CC": "NConeIso15h",
}
}, {
'Type':
'RelInfoConeVariablesForEW',
'ConeAngle':
2.0,
'Variables': [
'EWCONEANGLE', 'EWCONENPX', 'EWCONENPY', 'EWCONENPZ',
'EWCONENMULT', 'EWCONENVPT', 'EWCONENSPT', 'EWCONENVP',
'EWCONENSP'
],
'Location':
'NConeIso20B',
"DaughterLocations": {
"[B+ -> ^p+ p~- K+]CC": "NConeIso20p1",
"[B+ -> p+ ^p~- K+]CC": "NConeIso20p2",
"[B+ -> p+ p~- ^K+]CC": "NConeIso20h",
}
}])
self.registerLine(self.lineKKK_incl)
self.registerLine(self.lineKpKpKp_incl)
self.registerLine(self.linepph_incl)
def BtoDlnuLine(module_name,
name,
BDecays,
DDecays,
CONFIG,
CHARM_DAUGHTERS,
MUON,
FAKE_MUON=None):
DEFAULT_GECs = {
"Code":
"( recSummaryTrack(LHCb.RecSummary.nLongTracks, TrLONG) < %(GEC_nLongTrk)s )"
% CONFIG,
"Preambulo": ["from LoKiTracks.decorators import *"]
}
CHARM_DaugCuts = {}
CHARM_ComboCuts = CONFIG["CharmComboCuts"]
CHARM_MotherCuts = CONFIG["CharmMotherCuts"]
CHARM_ComboCuts += " & (ADOCACHI2CUT( %(D_DocaChi2Max)s, ''))" % CONFIG
CHARM_MotherCuts += "& (VFASPF(VCHI2/VDOF) < %(D_VCHI2DOF)s) " \
"& (BPVVDCHI2 > %(D_FDCHI2)s) & (BPVDIRA> %(D_BPVDIRA)s)" % CONFIG
if "CharmDaugCuts" in CONFIG.keys():
CHARM_DaugCuts = CONFIG["CharmDaugCuts"]
if "CharmExtraComboCuts" in CONFIG.keys():
CHARM_ComboCuts += CONFIG["CharmExtraComboCuts"]
if "CharmExtraMotherCuts" in CONFIG.keys():
CHARM_MotherCuts += CONFIG["CharmExtraMotherCuts"]
CHARM = Selection("CharmSelFor" + name + module_name,
Algorithm=CombineParticles(
DecayDescriptors=DDecays,
DaughtersCuts=CHARM_DaugCuts,
CombinationCut=CHARM_ComboCuts,
MotherCut=CHARM_MotherCuts),
RequiredSelections=CHARM_DAUGHTERS)
USED_CHARM = CHARM
if "D*" in BDecays:
DST = makeDstar("CharmSelDstFor" + name + module_name, CHARM, CONFIG)
USED_CHARM = DST
B_combinationCut = "(AM > %(B_MassMin)s) & (AM < %(B_MassMax)s) & (ADOCACHI2CUT( %(B_DocaChi2Max)s, ''))" % CONFIG
B_motherCut = " (MM>%(B_MassMin)s) & (MM<%(B_MassMax)s)"\
"&(VFASPF(VCHI2/VDOF)< %(B_VCHI2DOF)s) & (BPVDIRA> %(B_DIRA)s)"\
"&(MINTREE(((ABSID=='D+')|(ABSID=='D0')|(ABSID=='Lambda_c+')|(ABSID=='Omega_c0')|(ABSID=='Xi_c+')|(ABSID=='Xi_c0'))"\
", VFASPF(VZ))-VFASPF(VZ) > %(B_D_DZ)s ) " %CONFIG
if "ExtraComboCuts" in CONFIG.keys():
B_combinationCut += CONFIG["ExtraComboCuts"]
if "ExtraMotherCuts" in CONFIG.keys():
B_motherCut += CONFIG["ExtraMotherCuts"]
B_DaugCuts = {}
if "ExtraMuonCuts" in CONFIG.keys():
B_DaugCuts = {"mu+": CONFIG["ExtraMuonCuts"]}
if "ExtraElectronCuts" in CONFIG.keys():
B_DaugCuts = {"e+": CONFIG["ExtraElectronCuts"]}
_B = CombineParticles(DecayDescriptors=BDecays,
DaughtersCuts=B_DaugCuts,
CombinationCut=B_combinationCut,
MotherCut=B_motherCut)
if CONFIG["Monitor"] == True:
_B.Preambulo = [
"hdm1 = Gaudi.Histo1DDef ( 'D_M' , 1700 , 2800 , 200 )"
]
_B.Monitor = True
_B.MotherMonitor = "process ( monitor ( CHILD(M,1) , hdm1 , 'D_M' ) ) >> ~EMPTY " ""
BSel = Selection("BSelFor" + name + module_name,
Algorithm=_B,
RequiredSelections=[MUON, USED_CHARM])
BSelTOS = TOSFilter("BSelFor" + name + module_name + "TOS", BSel,
CONFIG["TTSpecs"])
LINE_NAME = module_name + "_" + name
_prescale = 1.0
if LINE_NAME in CONFIG["prescales"].keys():
_prescale = CONFIG["prescales"][LINE_NAME]
main_line = StrippingLine(LINE_NAME,
selection=BSelTOS,
HLT1=CONFIG["HLT1"],
HLT2=CONFIG["HLT2"],
FILTER=DEFAULT_GECs,
prescale=_prescale)
if FAKE_MUON == None:
return main_line
else:
BSelFake = Selection("BSelFakeFor" + name + module_name,
Algorithm=_B,
RequiredSelections=[FAKE_MUON, USED_CHARM])
BSelFakeTOS = TOSFilter("BSelFakeFor" + name + module_name + "TOS",
BSelFake, CONFIG["TTSpecs"])
return {
"RealMuon":
main_line,
"FakeMuon":
StrippingLine(LINE_NAME + '_FakeMuon',
selection=BSelFakeTOS,
HLT1=CONFIG["HLT1"],
HLT2=CONFIG["HLT2"],
FILTER=DEFAULT_GECs,
prescale=CONFIG["prescaleFakes"])
}
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
PiOSLine_name = name + "_PiOS"
PiSSLine_name = name + "_PiSS"
KOSLine_name = name + "_KOS"
KSSLine_name = name + "_KSS"
# 1 : Make kaons
selKaons = makeKaons(name="KaonsFor" + name,
KaonP=config['KaonP'],
KaonPT=config['KaonPT'],
KaonMINIPCHI2=config['KaonMINIPCHI2'])
# 2 : Make pions
selPions = makePions(name="PionsFor" + name,
PionP=config['PionP'],
PionPT=config['PionPT'],
PionMINIPCHI2=config['PionMINIPCHI2'])
# 3 : Make muons
selMuons = makeMuons(name="MuonsFor" + name,
MuonP=config['MuonP'],
MuonPT=config['MuonPT'],
MuonMINIPCHI2=config['MuonMINIPCHI2'])
# 4 : Combine
selB2PiMuMuOS = self._makeB2PiMuMuOS(name=PiOSLine_name,
pionSel=selPions,
muonSel=selMuons,
config=config)
selB2PiMuMuSS = self._makeB2PiMuMuSS(name=PiSSLine_name,
pionSel=selPions,
muonSel=selMuons,
config=config)
selB2KMuMuOS = self._makeB2KMuMuOS(name=KOSLine_name,
kaonSel=selKaons,
muonSel=selMuons,
config=config)
selB2KMuMuSS = self._makeB2KMuMuSS(name=KSSLine_name,
kaonSel=selKaons,
muonSel=selMuons,
config=config)
# 5 : Declare Lines
self.PiOSLine = StrippingLine(
PiOSLine_name + "Line",
prescale=config['B2PiMuMuOSLinePrescale'],
postscale=config['B2PiMuMuOSLinePostscale'],
selection=selB2PiMuMuOS)
self.PiSSLine = StrippingLine(
PiSSLine_name + "Line",
prescale=config['B2PiMuMuSSLinePrescale'],
postscale=config['B2PiMuMuSSLinePostscale'],
selection=selB2PiMuMuSS)
self.KOSLine = StrippingLine(
KOSLine_name + "Line",
prescale=config['B2KMuMuOSLinePrescale'],
postscale=config['B2KMuMuOSLinePostscale'],
selection=selB2KMuMuOS)
self.KSSLine = StrippingLine(
KSSLine_name + "Line",
prescale=config['B2KMuMuSSLinePrescale'],
postscale=config['B2KMuMuSSLinePostscale'],
selection=selB2KMuMuSS)
# 6 : register Line
self.registerLine(self.PiOSLine)
self.registerLine(self.PiSSLine)
self.registerLine(self.KOSLine)
self.registerLine(self.KSSLine)
print "Created lines"
def _lines_inner(self):
if hasattr(self, '_Lines'): return self._Lines
self._Lines = [
##
StrippingLine(
"K0SLLLine" + self._name,
prescale=self._KS0LLPrescale,
checkPV=True, ## attention! PV is required!
postscale=1,
#HLT = self._hlt ,
algos=[self.K0S_LL_Bin1()]),
##
StrippingLine(
"K0SDDLine" + self._name,
prescale=self._KS0DDPrescale,
checkPV=True, ## attention! PV is required!
postscale=1,
#HLT = self._hlt ,
algos=[self.K0S_DD_Bin1()]),
##
StrippingLine(
"Lam0LLLine1" + self._name,
prescale=self._LamLLPrescale_LoP,
checkPV=True, ## attention! PV is required!
postscale=1,
#HLT = self._hlt ,
algos=[self.Lam0_LL_Bin1()]),
##
StrippingLine(
"Lam0LLLine2" + self._name,
prescale=self._LamLLPrescale_HiP,
checkPV=True, ## attention! PV is required!
postscale=1,
#HLT = self._hlt ,
algos=[self.Lam0_LL_Bin2()]),
##
StrippingLine(
"Lam0DDLine" + self._name,
prescale=self._LamDDPrescale,
checkPV=True, ## attention! PV is required!
postscale=1,
#HLT = self._hlt ,
algos=[self.Lam0_DD_Bin1()]),
##
StrippingLine(
"Lam0LLIsMUONLine1" + self._name,
prescale=self._LamLLIsMUONPrescale_LoP,
checkPV=True, ## attention! PV is required!
postscale=1,
#HLT = self._hlt ,
algos=[self.Lam0_LL_Bin1_IsMUON()]),
##
StrippingLine(
"Lam0LLIsMUONLine2" + self._name,
prescale=self._LamLLIsMUONPrescale_HiP,
checkPV=True, ## attention! PV is required!
postscale=1,
#HLT = self._hlt ,
algos=[self.Lam0_LL_Bin2_IsMUON()]),
##
StrippingLine(
"Lam0DDIsMUONLine" + self._name,
prescale=self._LamDDIsMUONPrescale,
checkPV=True, ## attention! PV is required!
postscale=1,
#HLT = self._hlt ,
algos=[self.Lam0_DD_Bin1_IsMUON()])
]
return self._Lines
def __init__(self, name, config):
'''The constructor of the configuration class.
Requires a name which is added to the end of each algorithm name,
and a configuration dictionary, config, which must provide all the settings
which differ between the lines'''
LineBuilder.__init__(self, name, config)
### first we define the cuts from the configuration ###
### NB: Common particles are defined with some cuts ###
### Check in CommonParticles the definition ###
# Cuts for Mu
self.MuCut = " (PT > %(MuPT)s *MeV) & (P > 2.0*GeV) & (ISMUON) & (HASMUON) & "\
" (TRGHOSTPROB < %(TrGHOSTPROBCut)s) & "\
" (PIDmu > %(MuTrPID)s) " % config
# Cuts to refine D0 selection
self.KCut = "& CHILDCUT(CHILDCUT( (PT > %(KPT)s*MeV) & (P > 2.0*GeV) & "\
" (MIPDV(PRIMARY) > 0.04*mm) & "\
" (TRGHOSTPROB < %(TrGHOSTPROBCut)s) & "\
" (PIDK > %(KTrPID)s ),1),2) " % config
self.PiCut = "& CHILDCUT(CHILDCUT( (PT> %(PiPT)s*MeV) & (P > 2.0*GeV) & "\
" (TRGHOSTPROB < %(TrGHOSTPROBCut)s) & "\
" (MIPDV(PRIMARY) > 0.04*mm) ,2),2) " % config
self.D0Cut = "& CHILDCUT( (PT>1600*MeV) & (ADMASS('D0') < %(D0MassW)s *MeV ) & " \
" (BPVVDCHI2 > %(D0_BPVVDCHI2)s) & (VFASPF(VCHI2/VDOF)<10),2) "% config
# Cuts to refine D* selection
self.slowPiCut= "& CHILDCUT( (PT>110*MeV) & "\
" (MIPDV(PRIMARY) > 0.04*mm),1) " % config
self.DstarCut = " (VFASPF(VCHI2/VDOF) < %(Dstar_VCHI2)s ) & " \
" (PT>%(Dstar_PT)s *MeV) & (ADMASS('D*(2010)+')< %(DstarMassW)s*MeV)" % config
#& (M-MAXTREE('D0'==ABSID,M)<165 * MeV) &"\
# Cuts for B0
self.BCombCut="((AM > 3000.*MeV) )"
self.BCut = " (BPVDIRA> 0.999 ) & "\
" in_range(3000.*MeV,M,5280.*MeV) & "\
" (MINTREE(ABSID=='D0', VFASPF(VZ))-VFASPF(VZ) > %(B0dD0_DeltaZVtx)s*mm) & (BPVVDZ > %(B0dPV_DeltaZVtx)s*mm) & "\
" (VFASPF(VCHI2/VDOF)< %(B0d_VCHI2)s ) " % config
self.totalDstarCut = self.DstarCut + self.KCut + self.PiCut + self.D0Cut + self.slowPiCut
### Now make all the selections ###
self.__MakeMuSel__()
self.__MakeDstar__()
self.__MakeB0d__()
from StrippingConf.StrippingLine import StrippingLine
### Now make a stripping line ###
B0dLine=StrippingLine(self._name,
prescale = config['Prescale'],
postscale = config['Postscale'],
algos = [ self.B0Sel ],
EnableFlavourTagging = True
)
self.registerLine(B0dLine)
### Collect them all together in a nice way ###
self.Line=B0dLine
#self.TopSelectionSeq=SeqBd2DstarMuNu
self.Selections=[self.MuSel, self.D0Sel, self.DstarSel, self.B0Sel]
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
mmKLine_name = name + "_mm"
eeKLine_name = name + "_ee"
meKLine_name = name + "_me"
# 1 : Make high IP, Pt kaons
Kaons = StdLooseKaons
selKaons = makeKaons(name="KaonsFor" + name,
KaonIPCHI2=config['KaonIPCHI2'],
KaonPT=config['KaonPT'])
selKstars = makeKstars(name="KstarsFor" + name,
KaonIPCHI2=config['KaonIPCHI2'],
KaonPT=config['KaonPT'])
# 2 : Dileptons
Electrons = DataOnDemand(Location="Phys/StdLooseDiElectron/Particles")
Electrons2 = DataOnDemand(
Location="Phys/StdDiElectronFromTracks/Particles") # TEST
Muons = DataOnDemand(Location="Phys/StdLooseDiMuon/Particles")
MuE = makeMuE()
selDiElectron = self._makeDiLepton(name='Dilepton_For' + eeKLine_name,
leptonSel=Electrons,
config=config)
selDiElectron2 = self._makeDiLepton(
name='Dilepton2_For' + eeKLine_name, # TEST
leptonSel=Electrons2,
config=config)
selDiMuon = self._makeDiLepton(name='Dilepton_For' + mmKLine_name,
leptonSel=Muons,
config=config)
selMuE = self._makeDiLepton(name='Dilepton_For' + meKLine_name,
leptonSel=MuE,
config=config)
# 3 : Combine
selB2LLK_ee = self._makeB2LLK(name=eeKLine_name,
dileptonSel=selDiElectron,
kaonSel=selKaons,
kstarSel=selKstars,
config=config,
massCut="1000*MeV")
selB2LLK_ee2 = self._makeB2LLK(name=eeKLine_name + "2",
dileptonSel=selDiElectron2,
kaonSel=selKaons,
kstarSel=selKstars,
config=config,
massCut="1000*MeV")
selB2LLK_mm = self._makeB2LLK(name=mmKLine_name,
dileptonSel=selDiMuon,
kaonSel=selKaons,
kstarSel=selKstars,
config=config,
massCut="600*MeV")
selB2LLK_me = self._makeB2LLK(name=meKLine_name,
dileptonSel=selMuE,
kaonSel=selKaons,
kstarSel=selKstars,
config=config,
massCut="600*MeV")
# 4 : Declare Lines
self.eeKLine = StrippingLine(eeKLine_name + "Line",
prescale=config['Bu2eeKLinePrescale'],
postscale=1,
selection=selB2LLK_ee,
ExtraInfoTools=config['ExtraInfoTools'])
self.eeKLine2 = StrippingLine(eeKLine_name + "Line2",
prescale=config['Bu2eeKLinePrescale'],
postscale=1,
selection=selB2LLK_ee2,
ExtraInfoTools=config['ExtraInfoTools'])
self.mmKLine = StrippingLine(mmKLine_name + "Line",
prescale=config['Bu2mmKLinePrescale'],
postscale=1,
selection=selB2LLK_mm,
ExtraInfoTools=config['ExtraInfoTools'])
self.meKLine = StrippingLine(meKLine_name + "Line",
prescale=config['Bu2meKLinePrescale'],
postscale=1,
selection=selB2LLK_me,
ExtraInfoTools=config['ExtraInfoTools'])
# 5 : register Line
self.registerLine(self.eeKLine)
self.registerLine(self.eeKLine2)
self.registerLine(self.mmKLine)
self.registerLine(self.meKLine)
def _K_line(self):
from StrippingConf.StrippingLine import StrippingLine
return StrippingLine(self._name + 'Bs2KLine',
prescale=1.0,
FILTER=self.GECs,
algos=[self._Bs2KMuNu()])
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
# Set up global event cuts.
# Conceptually these come first, although the place where they're
# inserted into the line is at the bottom of the code.
_globalEventCuts = {
'Code':
("(recSummary (LHCb.RecSummary.nLongTracks, 'Rec/Track/Long') < %(LongTrackGEC)s )"
) % config,
'Preambulo': ["from LoKiTracks.decorators import *"]
}
####################################### Common Jpsi #########################################
self._muon4Jpsi = AutomaticData(
_my_immutable_config['MuonsForJpsiLocation'])
self._Jpsi = filterJpsi(name, config=config)
######################################## Xibc+ Exclusive Line ##################################
self._pions4Lambdac = AutomaticData(
_my_immutable_config['PionsForLambdacLocation'])
self._protons4Lambdac = AutomaticData(
_my_immutable_config['ProtonsForLambdacLocation'])
self._kaons4Lambdac = AutomaticData(
_my_immutable_config['KaonsForLambdacLocation'])
self._Lambdac = makeLambdac(
name,
[self._protons4Lambdac, self._kaons4Lambdac, self._pions4Lambdac],
config)
self._Xibc = makeXibc(name, [self._Jpsi, self._Lambdac], config)
#declare the line:
self.lineXibc2LcJpsi = StrippingLine(
name + 'Xibc2LcJpsi',
prescale=config['Xibc2LcJpsiPrescale'],
postscale=1.0,
FILTER=_globalEventCuts,
selection=self._Xibc)
self.registerLine(self.lineXibc2LcJpsi)
##################################### Xibc0 ###################################################
self._Lambda0 = makeLambda0(name, [], config)
#Note: the Jpsi requirement is added to quickly skip events without a Jpsi saving CPU time
self._XiminusL = makeXi(name + "LongPi", [
self._Lambda0,
AutomaticData(_my_immutable_config['LongPionsForXi']), self._Jpsi
], config)
self._XiminusD = makeXi(name + "DownPi", [
self._Lambda0,
AutomaticData(_my_immutable_config['DownPionsForXi']), self._Jpsi
], config)
self._Ximinus = MergedSelection(
name + "MergedXiminus",
RequiredSelections=[self._XiminusL, self._XiminusD])
self._Xic0 = makeXic(name, [
self._Ximinus,
AutomaticData(_my_immutable_config['PionsForXic'])
], config)
self._Xibc0 = makeXibc0(name, [self._Jpsi, self._Xic0], config)
#declare the line:
self.lineXibc2XicJpsi = StrippingLine(name + 'Xibc2XicJpsi',
prescale=1,
postscale=1.0,
FILTER=_globalEventCuts,
selection=self._Xibc0)
self.registerLine(self.lineXibc2XicJpsi)
########################################## Xibc -> J/psi K p Line #######################
self._Xibc2JpsiKpi = makeXibc2JpsiKp(name, [
self._Jpsi,
AutomaticData(_my_immutable_config['Protons4JpsiKp']),
AutomaticData(_my_immutable_config['Kaons4JpsiKp'])
], config)
self.lineXibc2JpsiKp = StrippingLine((name + 'Xibc2JpsiKp'),
prescale=1.0,
postscale=1.0,
FILTER=_globalEventCuts,
selection=self._Xibc2JpsiKpi)
self.registerLine(self.lineXibc2JpsiKp)
########################################## Xibc -> J/psi K p Control Line #######################
self._Xibc2JpsiKpiCtrl = makeXibc2JpsiKp(name + "Lb", [
self._Jpsi,
AutomaticData(_my_immutable_config['Protons4JpsiKp']),
AutomaticData(_my_immutable_config['Kaons4JpsiKp'])
],
config,
controlLine=True)
self.lineXibc2JpsiKp = StrippingLine(
(name + 'Lb2JpsiKp'),
prescale=config['JpsiKp_CtrlLine_Prescale'],
postscale=1.0,
FILTER=_globalEventCuts,
selection=self._Xibc2JpsiKpiCtrl)
self.registerLine(self.lineXibc2JpsiKp)
########################################## Inclusive X -> p J/psi Line #####################
self._X = makeX(
name,
[ #self._Jpsi,
AutomaticData(_my_immutable_config['Jpsi4HighMassBaryon']),
AutomaticData(_my_immutable_config['Protons4HighMassBaryon'])
],
config)
self.lineX2JpsiProton = StrippingLine(name + 'X2JpsiProton',
prescale=1.0,
postscale=1.0,
FILTER=_globalEventCuts,
selection=self._X)
self.registerLine(self.lineX2JpsiProton)
def _RhoSB_line(self):
from StrippingConf.StrippingLine import StrippingLine
return StrippingLine(self._name + 'Bu2RhoSBLine',
prescale=1.0,
FILTER=self.GECs,
algos=[self._Bu2RhoMuNuSB()])
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
'''
Here we construct the selections
'''
name_DpKs_line = name + '_DpKs'
name_DstarpKs_line = name + '_DstarpKs'
name_DstarD02K3PiKs_line = name + '_DstarD02K3PiKs'
name_D0K_line = name + '_D0K'
name_DpPim_line = name + '_DpPim'
name_D0Pip_line = name + '_D0Pip'
name_DstarpPim_line = name + '_DstarpPim'
name_DzP_line = name + '_DzP'
name_DpP_line = name + '_DpP'
name_DsKs_line = name + '_DsKs'
name_DsKm_line = name + '_DsKm'
'''
make particles
'''
self.sel_Dp2KmPipPip = makeDp2KmPipPip(name + "Dplus")
self.sel_KS02LL = makeKS02LL(name + "KSLongLong")
self.sel_KS02DD = makeKS02DD(name + "KSDownDown")
self.sel_KS0 = MergedSelection(
name + "KS0",
RequiredSelections=[self.sel_KS02LL, self.sel_KS02DD])
self.sel_Dstarp = makeDstar2D0pi(name + "Dstar")
self.sel_Ds = makeDs2KKPi(name + "Ds")
self.sel_D0 = makePromptD02KPi(name + "D0")
self.sel_K = makePromptTracks(name + "K",
"Phys/StdTightKaons/Particles")
self.sel_Pi = makePromptTracks(name + "Pi",
"Phys/StdTightPions/Particles")
self.sel_P = makePromptTracks(name + "P",
"Phys/StdTightProtons/Particles")
self.sel_LoosePi = makeNoPromptTracks(
name + "LoosePi", "Phys/StdAllLoosePions/Particles")
self.sel_LooseK = makeNoPromptTracks(
name + "LooseK", "Phys/StdAllLooseKaons/Particles")
self.sel_LoosePromptPi = makePromptSoftTracks(
name + "LoosePromptPi", "Phys/StdAllLoosePions/Particles")
self.sel_D02K3Pi = makeD02K3Pi(name + "D02K3Pi", self.sel_LoosePi,
self.sel_LooseK)
self.sel_DstarD02K3Pi = makeDstarD02K3Pi(name + "DstarD02K3Pi",
self.sel_D02K3Pi,
self.sel_LoosePromptPi)
'''
combine particles
'''
self.DpKs = CombineDandTrack(name + "Ds2DpKs", "[D*_s2+ -> D+ KS0]cc",
self.sel_Dp2KmPipPip, self.sel_KS0)
self.DstarpKs = CombineDandTrack(name + "Ds2DstarpKs",
"[D_s1(2536)+ -> D*(2010)+ KS0]cc",
self.sel_Dstarp, self.sel_KS0)
self.DstarD02K3PiKs = CombineDandTrack(
name + "Ds2DstarD02K3PiKs", "[D_s1(2536)+ -> D*(2010)+ KS0]cc",
self.sel_DstarD02K3Pi, self.sel_KS0)
self.D0K = CombineDandTrack(name + "Ds2D0K",
"[D_s1(2536)+ -> D0 K+]cc", self.sel_D0,
self.sel_K)
self.DpPim = CombineDandTrack(name + "Dj2DpPim",
"[D*_2(2460)0 -> D+ pi-]cc",
self.sel_Dp2KmPipPip, self.sel_Pi)
self.D0Pip = CombineDandTrack(name + "Dj2D0Pip",
"[D*_2(2460)+ -> D0 pi+]cc", self.sel_D0,
self.sel_Pi)
self.DstarpPim = CombineDandTrack(name + "Dj2DstarpPim",
"[D*_2(2460)0 -> D*(2010)+ pi-]cc",
self.sel_Dstarp, self.sel_Pi)
self.DzP = CombineDandTrack(name + "Lam2DzP",
"[Lambda_c(2625)+ -> D0 p+]cc",
self.sel_D0, self.sel_P)
self.DpP = CombineDandTrack(name + "Lam2DpP",
"[Lambda_c(2625)+ -> D+ p~-]cc",
self.sel_Dp2KmPipPip, self.sel_P)
self.DsKs = CombineDandTrack(name + "D2DsKs",
"[D*_2(2460)+ -> D_s+ KS0]cc",
self.sel_Ds, self.sel_KS0)
self.DsKm = CombineDandTrack(name + "D2DsKm",
"[D*_2(2460)0 -> D_s+ K-]cc", self.sel_Ds,
self.sel_K)
'''
Here we construct the stripping lines
'''
self.DpKs_line = StrippingLine(name_DpKs_line,
prescale=config['DpKs_prescale'],
selection=self.DpKs)
self.DstarpKs_line = StrippingLine(
name_DstarpKs_line,
prescale=config['DstarpKs_prescale'],
selection=self.DstarpKs)
self.D0K_line = StrippingLine(name_D0K_line,
prescale=config['D0K_prescale'],
selection=self.D0K)
self.DpPim_line = StrippingLine(name_DpPim_line,
prescale=config['DpPim_prescale'],
selection=self.DpPim)
self.D0Pip_line = StrippingLine(name_D0Pip_line,
prescale=config['D0Pip_prescale'],
selection=self.D0Pip)
self.DstarpPim_line = StrippingLine(
name_DstarpPim_line,
prescale=config['DstarpPim_prescale'],
selection=self.DstarpPim)
self.DzP_line = StrippingLine(name_DzP_line,
prescale=config['DzP_prescale'],
selection=self.DzP)
self.DpP_line = StrippingLine(name_DpP_line,
prescale=config['DpP_prescale'],
selection=self.DpP)
self.DsKs_line = StrippingLine(name_DsKs_line,
prescale=config['DsKs_prescale'],
selection=self.DsKs)
self.DsKm_line = StrippingLine(name_DsKm_line,
prescale=config['DsKm_prescale'],
selection=self.DsKm)
self.DstarD02K3PiKs_line = StrippingLine(
name_DstarD02K3PiKs_line,
prescale=config['DstarD02K3PiKs_prescale'],
selection=self.DstarD02K3PiKs)
'''
register stripping lines
'''
self.registerLine(self.DpKs_line)
self.registerLine(self.DstarpKs_line)
self.registerLine(self.D0K_line)
self.registerLine(self.DpPim_line)
self.registerLine(self.D0Pip_line)
self.registerLine(self.DstarpPim_line)
self.registerLine(self.DzP_line)
self.registerLine(self.DpP_line)
self.registerLine(self.DsKs_line)
self.registerLine(self.DsKm_line)
self.registerLine(self.DstarD02K3PiKs_line)
