def _strippingLine ( self,
name , # the base name for the Line
prescale = 1.0 , # prescale factor
ODIN = None , # ODIN predicate
L0DU = None , # L0DU predicate
HLT = None , # HltDecReports predicate
FILTER = None , # 'VOID'-predicate, e.g. Global Event Cut
checkPV = True , # Check PV before running algos
algos = None , # the list of stripping members
selection = None ,
postscale = 1.0 , # postscale factor
MaxCandidates = "Override", # Maxumum number
MaxCombinations = "Override", # Maxumum number
HDRLocation = None ) : # other configuration parameters
# {
if (prescale > 0) and (postscale > 0) : # {
line = StrippingLine( name,
prescale = prescale,
ODIN = ODIN,
L0DU = L0DU,
HLT = HLT,
FILTER = FILTER,
checkPV = checkPV,
algos = algos,
selection = selection,
postscale = postscale,
MaxCandidates = MaxCandidates,
MaxCombinations = MaxCombinations,
HDRLocation = HDRLocation )
self.registerLine(line)
return line
# }
else :
return False
def make_line(self, name, selection, prescale, postscale, **kwargs):
"""Create the stripping line defined by the selection.
Keyword arguments:
name -- Base name for the Line
selection -- Selection instance
prescale -- Fraction of candidates to randomly drop before stripping
postscale -- Fraction of candidates to randomly drop after stripping
**kwargs -- Keyword arguments passed to StrippingLine constructor
"""
# Only create the line with positive pre- and postscales
# You can disable each line by setting either to a negative value
if prescale > 0 and postscale > 0:
line = StrippingLine(
name,
selection=selection,
prescale=prescale,
postscale=postscale,
**kwargs
)
self.registerLine(line)
return line
else:
return False
def __init__(self, name, config):
self.name = name
LineBuilder.__init__(self, name, config)
_trkFilter = FilterDesktop(
Code="(TRCHI2DOF < 4) & (MIPCHI2DV(PRIMARY) > 16) & (PT > 250*MeV)"
)
self.TrackList = Selection('TrackList' + self.name,
Algorithm=_trkFilter,
RequiredSelections=[StdNoPIDsPions])
self.DiTrackList = mkDiTrackList(
name="DiTracksForCharmlessB" + self.name,
trkList=self.TrackList,
MinPTCut=config['Q2BResMinPT'],
MinPCut=config['Q2BResMinP'],
MaxMassCut=config['Q2BResMaxMass'],
VtxChi2DOFCut=config['Q2BResVtxChiDOF'])
Bs2Q2BName = self.name
self.B2CharmlessQ2B4pi = mkBs2Q2B4pi(
Bs2Q2BName,
diTrkList=self.DiTrackList,
MinMassCut=config['Q2BBMinM'],
MaxMassCut=config['Q2BBMaxM'],
MinCorrMCut=config['Q2BBMinCorrM'],
MaxCorrMCut=config['Q2BBMaxCorrM'],
VtxChi2DOFCut=config['Q2BBVtxChi2DOF'],
MinTrkPTCut=config['Q2BBMinTrkPT'],
BIPchi2Cut=config['Q2BIPCHI2'])
self.Q2B4piLine = StrippingLine(Bs2Q2BName + "Line",
prescale=config['Q2BPrescale'],
selection=self.B2CharmlessQ2B4pi)
self.registerLine(self.Q2B4piLine)
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
self.__confdict__ = config
############### MUON SELECTIONS ###################
self.selmuon = Selection("Mufor" + name,
Algorithm=self._muonFilter(),
RequiredSelections=[StdAllLooseMuons])
self.selFakemuon = Selection("FakeMufor" + name,
Algorithm=self._FakemuonFilter(),
RequiredSelections=[StdAllNoPIDsMuons])
############### KAON AND PION SELECTIONS ################
self.selKaon = Selection("Kfor" + name,
Algorithm=self._kaonFilter(),
RequiredSelections=[StdLooseKaons])
self.selPion = Selection("Pifor" + name,
Algorithm=self._pionFilter(),
RequiredSelections=[StdLoosePions])
################ D0 -> HH SELECTION ##########################
self.seld02kpi = Selection(
"D02KPifor" + name,
Algorithm=self._D02KPiFilter(),
RequiredSelections=[self.selKaon, self.selPion])
self.selb2D0MuX = makeb2DMuX(
'b2D0MuX' + name,
DecayDescriptors=['[B- -> D0 mu-]cc', '[B+ -> D0 mu+]cc'],
MuSel=self.selmuon,
DSel=self.seld02kpi,
BVCHI2DOF=config['BVCHI2DOF'],
BDIRA=config['BDIRA'])
self.selFakeb2D0MuX = makeFakeb2DMuX(
'b2D0MuXFake' + name,
DecayDescriptors=['[B- -> D0 mu-]cc', '[B+ -> D0 mu+]cc'],
FakeMuSel=self.selFakemuon,
DSel=self.seld02kpi,
BVCHI2DOF=config['BVCHI2DOF'],
BDIRA=config['BDIRA'])
################# DECLARE THE STRIPPING LINES #################################
GECs = {
"Code":
" ( recSummary(LHCb.RecSummary.nSPDhits,'Raw/Spd/Digits') < %(SPDmax)s )"
% config,
"Preambulo": ["from LoKiTracks.decorators import *"]
}
########## D0 -> HH ###########
self.B2DMuForTauMu = StrippingLine('b2D0MuX' + name + 'Line',
prescale=1,
selection=self.selb2D0MuX,
FILTER=GECs)
self.registerLine(self.B2DMuForTauMu)
self.FakeB2DMuForTauMu = StrippingLine('b2D0MuXFake' + name + 'Line',
prescale=0.08,
selection=self.selFakeb2D0MuX,
FILTER=GECs)
self.registerLine(self.FakeB2DMuForTauMu)
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
dd_name = name + 'DD'
ll_name = name + 'LL'
GECCode = {
'Code':
"(recSummaryTrack(LHCb.RecSummary.nLongTracks, TrLONG) < %s)" %
config['GEC_MaxTracks'],
'Preambulo': ["from LoKiTracks.decorators import *"]
}
Hlt1Filter = {
'Code': "HLT_PASS_RE('%s')" % config['HLT1Dec'],
'Preambulo': ["from LoKiCore.functions import *"]
}
Hlt2Filter = {
'Code': "HLT_PASS_RE('%s')" % config['HLT2Dec'],
'Preambulo': ["from LoKiCore.functions import *"]
}
relInfo = [{
"Type": "RelInfoConeVariables",
"ConeAngle": config['ConeAngle10'],
"Variables": ['CONEANGLE', 'CONEMULT', 'CONEPTASYM'],
'Location': 'P2ConeVar10_B',
"DaughterLocations": {
"[B+ -> ^pi+ pi- (K*(892)+ -> KS0 pi+)]CC": 'P2ConeVar10_1',
"[B+ -> pi+ ^pi- (K*(892)+ -> KS0 pi+)]CC": 'P2ConeVar10_2',
"[B+ -> pi+ pi- (K*(892)+ -> ^KS0 pi+)]CC": 'P2ConeVar10_3',
"[B+ -> pi+ pi- (K*(892)+ -> KS0 ^pi+)]CC": 'P2ConeVar10_4'
}
}, {
"Type": "RelInfoConeVariables",
"ConeAngle": config['ConeAngle15'],
"Variables": ['CONEANGLE', 'CONEMULT', 'CONEPTASYM'],
'Location': 'P2ConeVar15_B',
"DaughterLocations": {
"[B+ -> ^pi+ pi- (K*(892)+ -> KS0 pi+)]CC": 'P2ConeVar15_1',
"[B+ -> pi+ ^pi- (K*(892)+ -> KS0 pi+)]CC": 'P2ConeVar15_2',
"[B+ -> pi+ pi- (K*(892)+ -> ^KS0 pi+)]CC": 'P2ConeVar15_3',
"[B+ -> pi+ pi- (K*(892)+ -> KS0 ^pi+)]CC": 'P2ConeVar15_4'
}
}, {
"Type": "RelInfoConeVariables",
"ConeAngle": config['ConeAngle17'],
"Variables": ['CONEANGLE', 'CONEMULT', 'CONEPTASYM'],
'Location': 'P2ConeVar17_B',
"DaughterLocations": {
"[B+ -> ^pi+ pi- (K*(892)+ -> KS0 pi+)]CC": 'P2ConeVar17_1',
"[B+ -> pi+ ^pi- (K*(892)+ -> KS0 pi+)]CC": 'P2ConeVar17_2',
"[B+ -> pi+ pi- (K*(892)+ -> ^KS0 pi+)]CC": 'P2ConeVar17_3',
"[B+ -> pi+ pi- (K*(892)+ -> KS0 ^pi+)]CC": 'P2ConeVar17_4'
}
}, {
"Type": "RelInfoVertexIsolation",
"Location": 'VtxIsolationVar'
}]
self.pions = Pions
self.makeKS2DD('KSfor' + dd_name, config)
self.makeKS2LL('KSfor' + ll_name, config)
self.makeKst2KSDDpi('Kstfor' + dd_name, config)
self.makeKst2KSLLpi('Kstfor' + ll_name, config)
self.makeBu2KstDDhh(dd_name, config)
self.makeBu2KstLLhh(ll_name, config)
self.dd_line = StrippingLine(dd_name + "Line",
prescale=config['Prescale'],
postscale=config['Postscale'],
selection=self.selBu2KstDDhh,
HLT1=Hlt1Filter,
HLT2=Hlt2Filter,
FILTER=GECCode,
RelatedInfoTools=relInfo,
EnableFlavourTagging=True,
MDSTFlag=True)
self.ll_line = StrippingLine(ll_name + "Line",
prescale=config['Prescale'],
postscale=config['Postscale'],
selection=self.selBu2KstLLhh,
HLT1=Hlt1Filter,
HLT2=Hlt2Filter,
FILTER=GECCode,
RelatedInfoTools=relInfo,
EnableFlavourTagging=True,
MDSTFlag=True)
self.registerLine(self.dd_line)
self.registerLine(self.ll_line)
def _Lb2PhipK_X_Line(self, name, config):
# Cuts on the phi and KK pair
Phi2KK_DC = "(TRGHOSTPROB < 0.5) & (PT>%(KaonPT)s*MeV)&(MIPCHI2DV(PRIMARY)>%(KaonIPCHI2)s)" % config
Phi2KK_CC = "(AM<(%(PhiMassMax)s+30)*MeV)&(ADOCACHI2CUT(40, ''))" % config
Phi2KK_MassCut = "&(ADMASS('phi(1020)')<%(PhiMassWindow)s*MeV)" % config
Phi2KK_MC = "(VFASPF(VCHI2/VDOF)<%(PhiVertexCHI2pDOF)s)" % config + Phi2KK_MassCut
# Same cuts are applied to both the proton and kaon in the pK pair
pK_DC = "(TRGHOSTPROB < 0.5) & (PT>%(KaonPT)s*MeV)&(MIPCHI2DV(PRIMARY)>%(KaonIPCHI2)s)" % config
pK_CC = "(AM<(4600)*MeV)&(ADOCACHI2CUT(40, ''))" % config
pK_MC = "(VFASPF(VCHI2/VDOF)<%(PhiVertexCHI2pDOF)s)" % config
# Cuts on the Lambda_b
Lb2PhipK_DC = "(PT>%(PhiPT)s*MeV)" % config
Lb2PhipK_CC = "(ADAMASS('Lambda_b0')<((%(BsMassWindow)s+30)*MeV))&(ACHILD(PT,1)*ACHILD(PT,2)>%(PhiPTsq)s*GeV*GeV)" % config
Lb2PhipK_MC = "(BPVDIRA > 0.999) & (VFASPF(VCHI2/VDOF)<%(BsVertexCHI2pDOF)s)&(ADMASS('Lambda_b0')<%(BsMassWindow)s*MeV)" % config
ps = 1.0
_Lb2PhipKLooseDetachedPhi2KK = CombineParticles(
DecayDescriptor="phi(1020) -> K+ K-",
DaughtersCuts={"K+": Phi2KK_DC},
CombinationCut=Phi2KK_CC,
MotherCut=Phi2KK_MC)
# Lambda(1520)0 used as nominal intermediary particle for the pK pair
_Lb2PhipKLooseDetachedpK = CombineParticles(
DecayDescriptor="Lambda(1520)0 -> p+ K-",
DaughtersCuts={
"K-": pK_DC,
"p+": pK_DC
},
CombinationCut=pK_CC,
MotherCut=pK_MC)
_Lb2PhipK = CombineParticles(
DecayDescriptor="Lambda_b0 -> Lambda(1520)0 phi(1020)",
DaughtersCuts={
"phi(1020)": Lb2PhipK_DC,
"Lambda(1520)0": Lb2PhipK_DC
},
CombinationCut=Lb2PhipK_CC,
MotherCut=Lb2PhipK_MC)
Lb2PhipKLooseDetachedPhi2KK = Selection(
name + "_LoosePhi2KK",
Algorithm=_Lb2PhipKLooseDetachedPhi2KK,
RequiredSelections=[MyLooseKaons])
Lb2PhipKLooseDetachedpK = Selection(
name + "_LoosepK",
Algorithm=_Lb2PhipKLooseDetachedpK,
RequiredSelections=[MyLooseKaons, MyLooseProtons])
Lb2PhipK = Selection(name,
Algorithm=_Lb2PhipK,
RequiredSelections=[
Lb2PhipKLooseDetachedPhi2KK,
Lb2PhipKLooseDetachedpK
])
return StrippingLine(name + "Line",
prescale=ps,
postscale=1,
selection=Lb2PhipK,
EnableFlavourTagging=False)
def _lines_psiX(self):
"""
Get all psiX lines
"""
sel = self._selection('PsiX_Lines')
if sel: return sel
#
sel = [
# =================================================================
#
## 1h
#
StrippingLine("B2PsiPiFor" + self.name(),
prescale=self['B2PsiPiPrescale'],
checkPV=self['CheckPV'],
FILTER=self['FILTER'],
ODIN=self['ODIN'],
L0DU=self['L0DU'],
HLT=self['L0DU'],
algos=[self.psi_pi()]),
##
StrippingLine("B2PsiKFor" + self.name(),
prescale=self['B2PsiKPrescale'],
checkPV=self['CheckPV'],
FILTER=self['FILTER'],
ODIN=self['ODIN'],
L0DU=self['L0DU'],
HLT=self['L0DU'],
algos=[self.psi_K()]),
#
## 2h
#
StrippingLine("B2Psi2PiFor" + self.name(),
prescale=self['B2Psi2PiPrescale'],
checkPV=self['CheckPV'],
FILTER=self['FILTER'],
ODIN=self['ODIN'],
L0DU=self['L0DU'],
HLT=self['L0DU'],
algos=[self.psi_2pi()]),
##
StrippingLine("B2PsiKPiFor" + self.name(),
prescale=self['B2PsiKPiPrescale'],
checkPV=self['CheckPV'],
FILTER=self['FILTER'],
ODIN=self['ODIN'],
L0DU=self['L0DU'],
HLT=self['L0DU'],
algos=[self.psi_Kpi()]),
#
StrippingLine("B2Psi2KFor" + self.name(),
prescale=self['B2Psi2KPrescale'],
checkPV=self['CheckPV'],
FILTER=self['FILTER'],
ODIN=self['ODIN'],
L0DU=self['L0DU'],
HLT=self['L0DU'],
algos=[self.psi_2K()]),
#
## 3h
#
StrippingLine("B2Psi3KFor" + self.name(),
prescale=self['B2Psi3KPrescale'],
checkPV=self['CheckPV'],
FILTER=self['FILTER'],
ODIN=self['ODIN'],
L0DU=self['L0DU'],
HLT=self['L0DU'],
algos=[self.psi_3K()]),
##
StrippingLine("B2Psi3PiFor" + self.name(),
prescale=self['B2Psi3PiPrescale'],
checkPV=self['CheckPV'],
FILTER=self['FILTER'],
ODIN=self['ODIN'],
L0DU=self['L0DU'],
HLT=self['L0DU'],
algos=[self.psi_3pi()]),
##
StrippingLine("B2Psi3KPiFor" + self.name(),
prescale=self['B2Psi3KPiPrescale'],
checkPV=self['CheckPV'],
FILTER=self['FILTER'],
ODIN=self['ODIN'],
L0DU=self['L0DU'],
HLT=self['L0DU'],
algos=[self.psi_3Kpi()]),
#
## 4h
#
StrippingLine("B2Psi4PiFor" + self.name(),
prescale=self['B2Psi4PiPrescale'],
checkPV=self['CheckPV'],
FILTER=self['FILTER'],
ODIN=self['ODIN'],
L0DU=self['L0DU'],
HLT=self['L0DU'],
algos=[self.psi_4pi()]),
##
StrippingLine("B2Psi4KPiFor" + self.name(),
prescale=self['B2Psi4KPiPrescale'],
checkPV=self['CheckPV'],
FILTER=self['FILTER'],
ODIN=self['ODIN'],
L0DU=self['L0DU'],
HLT=self['L0DU'],
algos=[self.psi_4Kpi()]),
##
StrippingLine("B2Psi4KFor" + self.name(),
prescale=self['B2Psi4KPrescale'],
checkPV=self['CheckPV'],
FILTER=self['FILTER'],
ODIN=self['ODIN'],
L0DU=self['L0DU'],
HLT=self['L0DU'],
algos=[self.psi_4K()]),
#
## 5h
#
StrippingLine("B2Psi5PiFor" + self.name(),
prescale=self['B2Psi5PiPrescale'],
checkPV=self['CheckPV'],
FILTER=self['FILTER'],
ODIN=self['ODIN'],
L0DU=self['L0DU'],
HLT=self['L0DU'],
algos=[self.psi_5pi()]),
##
StrippingLine("B2Psi5KPiFor" + self.name(),
prescale=self['B2Psi5KPiPrescale'],
checkPV=self['CheckPV'],
FILTER=self['FILTER'],
ODIN=self['ODIN'],
L0DU=self['L0DU'],
HLT=self['L0DU'],
algos=[self.psi_5Kpi()]),
#
## 6h
#
StrippingLine("B2Psi6PiFor" + self.name(),
prescale=self['B2Psi6PiPrescale'],
checkPV=self['CheckPV'],
FILTER=self['FILTER'],
ODIN=self['ODIN'],
L0DU=self['L0DU'],
HLT=self['L0DU'],
algos=[self.psi_5pi()]),
##
StrippingLine("B2Psi6KPiFor" + self.name(),
prescale=self['B2Psi6KPiPrescale'],
checkPV=self['CheckPV'],
FILTER=self['FILTER'],
ODIN=self['ODIN'],
L0DU=self['L0DU'],
HLT=self['L0DU'],
algos=[self.psi_5Kpi()]),
##
# =================================================================
# Helper line to study gamma/pi0 reconstruction efficiency
# =================================================================
StrippingLine("B2PsiKstFor" + self.name(),
prescale=self['B2PsiKstPrescale'],
checkPV=self['CheckPV'],
FILTER=self['FILTER'],
ODIN=self['ODIN'],
L0DU=self['L0DU'],
HLT=self['L0DU'],
algos=[self.psi_Kst()]),
##
# =================================================================
]
##
return self._add_selection('PsiX_Lines', sel)
def __init__(self, NAME, CONFIG):
## Required the explicit name/dconfig, no default allow
LineBuilder.__init__(self, NAME, CONFIG)
## Prepare raw particle for identification
preambulo = CONFIG['preambulo']
ditau_pcomb = CONFIG['ditau_pcomb']
input_e = [AutomaticData(Location=CONFIG['TES_e'])]
input_mu = [AutomaticData(Location=CONFIG['TES_mu'])]
input_pi = [AutomaticData(Location=CONFIG['TES_pi'])]
## Make pre-selection tau candidates, no isolation here.
## Merge these together (parallel, not sequential selection)
tau_noiso = MergedSelection('TauNoiso', [
selection_filt(CONFIG['tau_e'], preambulo, input_e,
'SelTauNoiso_e'),
selection_filt(CONFIG['tau_mu'], preambulo, input_mu,
'SelTauNoiso_mu'),
selection_filt(CONFIG['tau_h1'], preambulo, input_pi,
'SelTauNoiso_h1'),
selection_tau_h3(CONFIG, preambulo, input_pi),
])
# ## Cut on isolation: RelInfoConeVariables + AddRelatedInfo + FilterDesktop
tau_iso = selection_tauiso(tau_noiso, CONFIG['tau_isolation'])
## Prepare selection of ditau
# Selections, indexed by dcname (for emu sharing). Think of it as caching.
sels_ditau = {}
## Loop over all lines, make groupping
for linename, condict in CONFIG['CONSTRUCTORS'].iteritems():
## Make the fullname: e.g., 'Ditau' + 'EXss' + 'Line'
fullname = NAME + linename + 'Line'
## Get list of decay, indexed by Line's name
dcdict = lines_decays[linename]
## Make list of selections to be put in single line
sels = []
for dcname, decay in dcdict.iteritems():
## Make selection if it hasn't been done.
if dcname not in sels_ditau:
dtype = dcname.split('_')[0] # eh1_ss --> eh1
config = CONFIG['DITAU'][
dtype] # Same ditau-level config for OS/SS
inputs = [tau_noiso if 'noiso' in linename else tau_iso]
# inputs = [ tau_noiso ]
sel = selection_ditau(config, preambulo, ditau_pcomb,
dcname, decay, inputs)
sels_ditau[dcname] = sel
sels.append(sels_ditau[dcname])
## Finally, merged it
selection = MergedSelection('Sel' + linename, sels)
# ## Adding isolation cut on the ditau level.
# filt = None
# if 'noiso' not in linename:
# filt = rif_isolation( fullname, CONFIG['tau_isolation'] )
## Finally, compose a stripping line, register
self.registerLine(
StrippingLine(
fullname,
selection=selection,
# RelatedInfoFilter = filt,
**CONFIG['CONSTRUCTORS'][linename]))
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
self.__confdict__ = config
self.selmuon = Selection("Mufor" + name,
Algorithm=self._muonFilter(),
RequiredSelections=[StdLooseMuons])
self.selmuonhighPT = Selection(
"MuhighPTfor" + name,
Algorithm=FilterDesktop(Code="(PT>1.2*GeV)"),
RequiredSelections=[self.selmuon])
self.selmuontight = Selection(
"Mutightfor" + name,
Algorithm=FilterDesktop(Code="(MIPCHI2DV(PRIMARY)> 100)"),
RequiredSelections=[self.selmuonhighPT])
self.selmuonTOS = TOSFilter("MuTOS" + name, self.selmuontight,
"Hlt2SingleMuonDecision")
self.selKaon = Selection("Kfor" + name,
Algorithm=self._kaonFilter(),
RequiredSelections=[StdLooseKaons])
self.selPion = Selection("Pifor" + name,
Algorithm=self._pionFilter(),
RequiredSelections=[StdLoosePions])
self.seld02kpi = Selection(
"D02KPifor" + name,
Algorithm=self._D02KPiFilter(),
RequiredSelections=[self.selKaon, self.selPion])
self.seld02k3pi = Selection(
"D02K3Pifor" + name,
Algorithm=self._D02K3PiFilter(),
RequiredSelections=[self.selKaon, StdLoosePions])
self.seldp2kpipi = Selection(
"Dp2KPiPifor" + name,
Algorithm=self._Dp2KPiPiFilter(),
RequiredSelections=[self.selKaon, self.selPion])
self.selds2kkpi = Selection(
"Ds2KKPifor" + name,
Algorithm=self._Ds2KKPiFilter(),
RequiredSelections=[self.selKaon, self.selPion])
self.sellambdac = Selection(
"Lc2PKPifor" + name,
Algorithm=self._Lc2PKPiFilter(),
RequiredSelections=[self.selKaon, self.selPion, StdLooseProtons])
self.selb2D0MuX = makeb2DMuX(
'b2D0MuX' + name,
DecayDescriptors=['[B- -> D0 mu-]cc', '[B+ -> D0 mu+]cc'],
MuSel=self.selmuonhighPT,
DSel=self.seld02kpi,
BVCHI2DOF=config['BVCHI2DOF'],
BDIRA=config['BDIRA'],
DZ=config['DZ'])
self.selb2D0MuXK3Pi = makeb2DMuX(
'b2D0MuXK3Pi' + name,
DecayDescriptors=['[B- -> D0 mu-]cc', '[B+ -> D0 mu+]cc'],
MuSel=self.selmuonTOS,
DSel=self.seld02k3pi,
BVCHI2DOF=config['BVCHI2DOF'],
BDIRA=config['BDIRA'],
DZ=config['DZ'])
self.selb2DpMuX = makeb2DMuX(
'b2DpMuX' + name,
DecayDescriptors=['[B0 -> D- mu+]cc', '[B0 -> D- mu-]cc'],
MuSel=self.selmuon,
DSel=self.seldp2kpipi,
BVCHI2DOF=config['BVCHI2DOF'],
BDIRA=config['BDIRA'],
DZ=config['DZ'])
self.selb2DsMuX = makeb2DMuX(
'b2DsMuX' + name,
DecayDescriptors=['[B0 -> D- mu+]cc', '[B0 -> D- mu-]cc'],
MuSel=self.selmuon,
DSel=self.selds2kkpi,
BVCHI2DOF=config['BVCHI2DOF'],
BDIRA=config['BDIRA'],
DZ=config['DZ'])
self.selb2LcMuX = makeb2DMuX('b2LcMuX' + name,
DecayDescriptors=[
'[Lambda_b0 -> Lambda_c+ mu-]cc',
'[Lambda_b0 -> Lambda_c+ mu+]cc'
],
MuSel=self.selmuon,
DSel=self.sellambdac,
BVCHI2DOF=config['BVCHI2DOF'],
BDIRA=config['BDIRA'],
DZ=config['DZ'])
self.b2D0MuXLine = StrippingLine(
'b2D0MuX' + name + 'Line'
#, HLT = " HLT_PASS_RE('Hlt.*(Muon|MuTrack).*Decision') "
,
prescale=1,
selection=self.selb2D0MuX)
self.b2D0MuXK3PiLine = StrippingLine(
'b2D0MuXK3Pi' + name + 'Line'
# , HLT = " HLT_PASS_RE('Hlt.*(Muon|MuTrack).*Decision') "
,
prescale=1,
selection=self.selb2D0MuXK3Pi)
self.b2DpMuXLine = StrippingLine('b2DpMuX' + name + 'Line',
prescale=1,
selection=self.selb2DpMuX)
self.b2DsMuXLine = StrippingLine('b2DsMuX' + name + 'Line',
prescale=1,
selection=self.selb2DsMuX)
self.b2LcMuXLine = StrippingLine('b2LcMuX' + name + 'Line',
prescale=1,
selection=self.selb2LcMuX)
self.registerLine(self.b2D0MuXLine)
self.registerLine(self.b2DpMuXLine)
self.registerLine(self.b2DsMuXLine)
self.registerLine(self.b2LcMuXLine)
self.registerLine(self.b2D0MuXK3PiLine)
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']
,runK3pi = config['RunK3pi']
,run4pi = config['Run4pi']
,run2K2pi = config['Run2K2pi']
,run3Kpi = config['Run3Kpi']
)
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']
,RelatedInfoTools = [
{
'Type' : 'RelInfoConeVariables', 'ConeAngle' : 1.5, 'Variables' : ['CONEANGLE', 'CONEMULT', 'CONEPTASYM'],
'RecursionLevel' : 1,
'Locations' : {
selPromptDstar : 'P2CVDstar1',
selD02hhhh : 'P2CVD1',
}
},
]
,FILTER=_GECfilter)
self.registerLine(self.line_tagged_d02hhhh)
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
#######################################################################
### ###
### VELO BASED VERTEXING SEQUENCE ###
### ###
#######################################################################
bestTracks = AutomaticData("Rec/Track/Best")
withVeloTracksForVertexing = bestTracks
if self.configurationParameter("FilterVelo")["Apply"]:
from GaudiConfUtils.ConfigurableGenerators import SelectVeloTracksNotFromPV
veloWithIP = SelectVeloTracksNotFromPV()
self.validatedSetProps("FilterVelo",
DisplVerticesLinesConf.veloWithIPCuts,
veloWithIP)
withVeloTracksForVertexing = Selection(
"%sVeloFilteredTracks" % self.name(),
RequiredSelections=[bestTracks],
Algorithm=veloWithIP)
# Displaced Vertex reconstruction with best tracks (dominated by those with a Velo segment)
from Configurables import PatPV3D, PVOfflineTool, PVSeed3DTool, LSAdaptPV3DFitter, LSAdaptPVFitter
withVeloVertexFinder = PVOfflineTool("%sWithVeloVertexFinder" %
self.name(),
PVsChi2Separation=0,
PVsChi2SeparationLowMult=0,
PVSeedingName="PVSeed3DTool",
PVFitterName="LSAdaptPV3DFitter")
withVeloVertexFinder.addTool(PVSeed3DTool)
withVeloVertexFinder.PVSeed3DTool.MinCloseTracks = 3
withVeloVertexFinder.addTool(LSAdaptPV3DFitter)
withVeloVertexFinder.LSAdaptPV3DFitter.maxIP2PV = 2.0 * units.mm
withVeloVertexFinder.LSAdaptPV3DFitter.MinTracks = 4
withVeloVertexAlg = PatPV3D("%sWithVeloVertexAlg")
withVeloVertexAlg.addTool(withVeloVertexFinder, name="PVOfflineTool")
withVeloVertexing = SelectionPatPV3DWrapper(
"%sWithVeloVertexing" % self.name(),
withVeloVertexAlg,
RequiredSelections=[withVeloTracksForVertexing])
# Make Particles out of the RecVertices
from GaudiConfUtils.ConfigurableGenerators import LLParticlesFromRecVertices
rv2pWithVelo = LLParticlesFromRecVertices(VerticesFromVeloOnly=False,
WriteP2PVRelations=False,
ForceP2PVBuild=False)
self.validatedSetProps(
"RV2PWithVelo", DisplVerticesLinesConf.recoCuts +
DisplVerticesLinesConf.singleCuts, rv2pWithVelo)
withVeloCandidates = Selection("%sWithVeloCandidates" % self.name(),
RequiredSelections=[withVeloVertexing],
Algorithm=rv2pWithVelo,
InputDataSetter="RecVertexLocations")
#######################################################################
### ###
### DOWNSTREAM VERTEXING SEQUENCE ###
### ###
#######################################################################
from GaudiConfUtils.ConfigurableGenerators import CopyDownstreamTracks
downTracks = Selection("%sDownstreamTracks" % self.name(),
RequiredSelections=[bestTracks],
Algorithm=CopyDownstreamTracks())
# Displaced Vertex reconstruction from downstream tracks
downVertexFinder = PVOfflineTool("%sDownVertexFinder" % self.name(),
RequireVelo=False,
PVsChi2Separation=0,
PVsChi2SeparationLowMult=0,
PVSeedingName="PVSeed3DTool",
PVFitterName="LSAdaptPVFitter")
downVertexFinder.addTool(PVSeed3DTool)
downVertexFinder.PVSeed3DTool.TrackPairMaxDistance = 2.0 * units.mm
downVertexFinder.PVSeed3DTool.zMaxSpread = 20.0 * units.mm
downVertexFinder.PVSeed3DTool.MinCloseTracks = 4
downVertexFinder.addTool(LSAdaptPVFitter)
downVertexFinder.LSAdaptPVFitter.MinTracks = 4
downVertexFinder.LSAdaptPVFitter.maxChi2 = 400.0
downVertexFinder.LSAdaptPVFitter.maxDeltaZ = 0.0005 * units.mm
downVertexFinder.LSAdaptPVFitter.maxDeltaChi2NDoF = 0.002
downVertexFinder.LSAdaptPVFitter.acceptTrack = 0.000000001
downVertexFinder.LSAdaptPVFitter.trackMaxChi2 = 9
downVertexFinder.LSAdaptPVFitter.trackMaxChi2Remove = 64
downVertexAlg = PatPV3D("%sDownVertexAlg" % self.name())
downVertexAlg.addTool(downVertexFinder, name="PVOfflineTool")
downVertexing = SelectionPatPV3DWrapper(
"%sDownVertexing" % self.name(),
downVertexAlg,
RequiredSelections=[downTracks])
# Make Particles out of the RecVertices
rv2pDown = LLParticlesFromRecVertices(VerticesFromVeloOnly=False,
WriteP2PVRelations=False,
ForceP2PVBuild=False
#, OutputLevel = VERBOSE
)
self.validatedSetProps(
"RV2PDown", DisplVerticesLinesConf.recoCuts +
DisplVerticesLinesConf.singleCuts, rv2pDown)
downCandidates = Selection("%sDownCandidates" % self.name(),
RequiredSelections=[downVertexing],
Algorithm=rv2pDown,
InputDataSetter="RecVertexLocations")
#######################################################################
### ###
### LINE DEFINITIONS ###
### ###
#######################################################################
##============================== Single ===================================##
singleLineNames = [
p.split("Single")[1].split("Selection")[0]
for p in self.configKeys()
if p.startswith("Single") and p.endswith("Selection")
]
for lAcroName in singleLineNames:
lShortName = "Single%s" % lAcroName # SingleMedium
lSelName = "%sSelection" % lShortName # SingleMediumSelection
lLineName = "%s%s" % (self.name(), lShortName
) # DisplVerticesSingleMedium
# Choose between Velo-based and downstream vertexing input
candidates = withVeloCandidates
code = None
if "Down" in lAcroName:
candidates = downCandidates
code = self.getLLPSelection(
self.validatedGetProps(
lSelName, DisplVerticesLinesConf.singleCuts +
DisplVerticesLinesConf.downCuts))
else:
code = self.getLLPSelection(
self.validatedGetProps(lSelName,
DisplVerticesLinesConf.singleCuts))
lineFilter = FilterDesktop(
DecayDescriptor=LLPLHCbName,
Preambulo=DisplVerticesLinesConf.llpSelectionPreambulo,
Code=code,
WriteP2PVRelations=False,
ForceP2PVBuild=False
#, OutputLevel = VERBOSE
)
lineSel = Selection("".join((self.name(), lSelName)),
RequiredSelections=[candidates],
Algorithm=lineFilter)
line = StrippingLine(
lLineName,
prescale=self.validatedGetProps(lSelName,
["PreScale"])["PreScale"],
selection=lineSel
## , FILTER = { "Preambulo" : [ "nVeloTracks = RECSUMMARY(13, 0)"
## , "nVeloClusters = RECSUMMARY(30, -1)"
## , "from LoKiCore.functions import *" ]
## , "Code" : "monitor( 1.*nVeloTracks/nVeloClusters , Gaudi.Histo1DDef('Number of Velo Tracks / Clusters', 0., 1., 100) , 'NumVeloTracksPerCluster' ) < 0.2" }
)
if lShortName in self.configurationParameter("HLT"):
line.HLT = self.configurationParameter("HLT")[lShortName]
self.registerLine(line)
##============================== Double ===================================##
doubleLineNames = [
p.split("Double")[1].split("Selection")[0]
for p in self.configKeys()
if p.startswith("Double") and p.endswith("Selection")
]
for lAcroName in doubleLineNames:
lShortName = "Double%s" % lAcroName
lSelName = "%sSelection" % lShortName
lLineName = "%s%s" % (self.name(), lShortName)
combinationCut, motherCut = self.getResonanceSelection(
self.validatedGetProps(
lSelName, DisplVerticesLinesConf.doubleResonanceCuts))
lineFilter = CombineParticles(
DecayDescriptor="H_10 -> %s %s" % (LLPLHCbName, LLPLHCbName),
Preambulo=DisplVerticesLinesConf.llpSelectionPreambulo,
DaughtersCuts={
LLPLHCbName:
self.getLLPSelection(
self.validatedGetProps(
lSelName, DisplVerticesLinesConf.singleCuts))
},
CombinationCut=combinationCut,
MotherCut=motherCut,
WriteP2PVRelations=False,
ForceP2PVBuild=False
#, OutputLevel = VERBOSE
)
lineSel = Selection("".join((self.name(), lSelName)),
RequiredSelections=[withVeloCandidates],
Algorithm=lineFilter)
line = StrippingLine(lLineName,
prescale=self.validatedGetProps(
lSelName, ["PreScale"])["PreScale"],
selection=lineSel)
if lShortName in self.configurationParameter("HLT"):
line.HLT = self.configurationParameter("HLT")[lShortName]
self.registerLine(line)
##============================== HLT PS ===================================##
hltPSLineNames = [
p.split("HLTPS")[0] for p in self.configKeys()
if p.endswith("HLTPS")
]
for lAcroName in hltPSLineNames:
lShortName = "%sHLTPS" % lAcroName
lLineName = "%s%s" % (self.name(), lShortName
) # DisplVerticesSingleMedium
line = StrippingLine(
lLineName,
prescale=self.validatedGetProps(lShortName,
["PreScale"])["PreScale"]
# these lines MUST have an HLT filter
,
HLT=self.validatedGetProps("HLT", [lShortName])[lShortName],
selection=withVeloCandidates)
self.registerLine(line)
##============================== OTHER ===================================##
hltEffLineNames = [
p.split("HltEff")[1].split("Selection")[0]
for p in self.configKeys()
if p.startswith("HltEff") and p.endswith("Selection")
]
for lShortName in hltEffLineNames:
lSelName = "HltEff%sSelection" % lShortName
lLineName = "%s%s" % (self.name(), lShortName)
# HltEff lines are single, Velo-vertexing based lines
lineFilter = FilterDesktop(
DecayDescriptor=LLPLHCbName,
Preambulo=DisplVerticesLinesConf.llpSelectionPreambulo,
Code=self.getLLPSelection(
self.validatedGetProps(lSelName,
DisplVerticesLinesConf.singleCuts)),
WriteP2PVRelations=False,
ForceP2PVBuild=False
#, OutputLevel = VERBOSE
)
lineSel = Selection("".join((self.name(), lSelName)),
RequiredSelections=[withVeloCandidates],
Algorithm=lineFilter)
line = StrippingLine(
lLineName,
prescale=self.validatedGetProps(lSelName,
["PreScale"])["PreScale"]
# these lines MUST have an HLT filter
,
HLT=self.configurationParameter("HLT")[lShortName],
selection=lineSel)
self.registerLine(line)
def __init__(self, name='Tau23Mu', config=None):
LineBuilder.__init__(self, name, config)
#checkConfig(Bs2MuMuLinesConf.__configuration_keys__,config)
tau_name = name + 'Tau23Mu'
ds23PiTIS_name = name + 'Ds23PiTIS'
ds23Pi_name = name + 'Ds23Pi'
ds2PhiPi_name = name + 'Ds2PhiPi'
tau25_name = name + 'Tau25Mu'
tau2pmm_name = name + 'Tau2PMuMu'
self.selTau23Mu = makeTau23Mu(tau_name, config)
#self.selDs23PiTIS = makeDs23PiTIS(self,ds23PiTIS_name)
self.selDs23Pi = makeDs23Pi(ds23Pi_name, config)
self.selDs2PhiPi = makeDs2PhiPi(ds2PhiPi_name, config)
self.selTau25Mu = makeTau25Mu(tau25_name, config)
self.selTau2PMuMu = makeTau2pmm(tau2pmm_name, config)
self.tau23MuLine = StrippingLine(
tau_name + "Line",
prescale=config['TauPrescale'],
postscale=config['TauPostscale'],
MDSTFlag=True,
RequiredRawEvents=["Calo"],
algos=[self.selTau23Mu],
RelatedInfoTools=[{
'Type':
'RelInfoConeVariables',
'ConeAngle':
1.,
'Variables': ['CONEANGLE', 'CONEMULT', 'CONEPT', 'CONEPTASYM'],
'Location':
'ConeIsoInfo',
'DaughterLocations': {
'[tau+ -> ^mu+ mu+ mu-]CC': 'MuonConeVarInfo1',
'[tau+ -> mu+ ^mu+ mu-]CC': 'MuonConeVarInfo2',
'[tau+ -> mu+ mu+ ^mu-]CC': 'MuonConeVarInfo3'
}
}, {
'Type': 'RelInfoVertexIsolation',
'Location': 'VtxIsoInfo'
}, {
'Type': 'RelInfoTrackIsolationBDT',
'Variables': 0,
'Location': 'TrackIsoInfo',
'DaughterLocations': {
'[tau+ -> ^mu+ mu+ mu-]CC': 'MuonTrackIsoBDTInfo1',
'[tau+ -> mu+ ^mu+ mu-]CC': 'MuonTrackIsoBDTInfo2',
'[tau+ -> mu+ mu+ ^mu-]CC': 'MuonTrackIsoBDTInfo3'
}
}])
#self.ds23PiTISLine = StrippingLine(ds23PiTIS_name+"Line",
# prescale = config['Ds23PiTISPrescale'],
# postscale = config['TauPostscale'],
# algos = [ self.selDs23PiTIS ]
# )
self.ds23PiLine = StrippingLine(ds23Pi_name + "Line",
prescale=config['Ds23PiPrescale'],
postscale=config['TauPostscale'],
MDSTFlag=True,
RequiredRawEvents=[],
algos=[self.selDs23Pi])
self.ds2PhiPiLine = StrippingLine(
ds2PhiPi_name + "Line",
prescale=config['Ds2PhiPiPrescale'],
postscale=config['TauPostscale'],
MDSTFlag=True,
RequiredRawEvents=["Calo"],
algos=[self.selDs2PhiPi],
RelatedInfoTools=[{
'Type':
'RelInfoConeVariables',
'ConeAngle':
1.,
'Variables': ['CONEANGLE', 'CONEMULT', 'CONEPT', 'CONEPTASYM'],
'Location':
'ConeIsoInfo',
'DaughterLocations': {
'[D_s+ -> ^pi+ mu+ mu-]CC': 'PionConeVarInfo',
'[D_s+ -> pi+ ^mu+ mu-]CC': 'MuonConeVarInfo1',
'[D_s+ -> pi+ mu+ ^mu-]CC': 'MuonConeVarInfo2'
}
}, {
'Type': 'RelInfoVertexIsolation',
'Location': 'VtxIsoInfo'
}, {
'Type': 'RelInfoTrackIsolationBDT',
'Variables': 0,
'Location': 'TrackIsoInfo',
'DaughterLocations': {
'[D_s+ -> ^pi+ mu+ mu-]CC': 'PionTrackIsoBDTInfo',
'[D_s+ -> pi+ ^mu+ mu-]CC': 'MuonTrackIsoBDTInfo1',
'[D_s+ -> pi+ mu+ ^mu-]CC': 'MuonTrackIsoBDT_mu_2'
}
}])
self.tau25MuLine = StrippingLine(tau25_name + "Line",
prescale=config['Tau25Prescale'],
postscale=config['TauPostscale'],
MDSTFlag=True,
RequiredRawEvents=[],
algos=[self.selTau25Mu])
self.tau2PMuMuLine = StrippingLine(
tau2pmm_name + "Line",
prescale=config['Tau2PMuMuPrescale'],
postscale=config['TauPostscale'],
MDSTFlag=True,
RequiredRawEvents=["Calo"],
algos=[self.selTau2PMuMu],
RelatedInfoTools=[{
'Type':
'RelInfoConeVariables',
'ConeAngle':
1.,
'Variables': ['CONEANGLE', 'CONEMULT', 'CONEPT', 'CONEPTASYM'],
'Location':
'ConeIsoInfo',
'DaughterLocations': {
"[[ tau+ -> ^p+ mu+ mu- ]CC, [ tau+ -> ^p~- mu+ mu+ ]CC, [ Lambda_c+ -> ^p+ mu+ mu- ]CC, [ Lambda_c+ -> ^p~- mu+ mu+ ]CC]":
'ProtonConeVarInfo',
"[[ tau+ -> p+ ^mu+ mu- ]CC, [ tau+ -> p~- ^mu+ mu+ ]CC, [ Lambda_c+ -> p+ ^mu+ mu- ]CC, [ Lambda_c+ -> p~- ^mu+ mu+ ]CC]":
'MuonConeVarInfo1',
"[[ tau+ -> p+ mu+ ^mu- ]CC, [ tau+ -> p~- mu+ ^mu+ ]CC, [ Lambda_c+ -> p+ mu+ ^mu- ]CC, [ Lambda_c+ -> p~- mu+ ^mu+ ]CC]":
'MuonConeVarInfo2'
}
}, {
'Type': 'RelInfoVertexIsolation',
'Location': 'VtxIsoInfo'
}, {
'Type': 'RelInfoTrackIsolationBDT',
'Variables': 0,
'Location': 'TrackIsoInfo',
'DaughterLocations': {
"[[ tau+ -> ^p+ mu+ mu- ]CC, [ tau+ -> ^p~- mu+ mu+ ]CC, [ Lambda_c+ -> ^p+ mu+ mu- ]CC, [ Lambda_c+ -> ^p~- mu+ mu+ ]CC]":
'ProtonTrackIsoBDTInfo',
"[[ tau+ -> p+ ^mu+ mu- ]CC, [ tau+ -> p~- ^mu+ mu+ ]CC, [ Lambda_c+ -> p+ ^mu+ mu- ]CC, [ Lambda_c+ -> p~- ^mu+ mu+ ]CC]":
'MuonTrackIsoBDTInfo1',
"[[ tau+ -> p+ mu+ ^mu- ]CC, [ tau+ -> p~- mu+ ^mu+ ]CC, [ Lambda_c+ -> p+ mu+ ^mu- ]CC, [ Lambda_c+ -> p~- mu+ ^mu+ ]CC]":
'MuonTrackIsoBDTInfo2'
}
}])
self.registerLine(self.tau23MuLine)
#self.registerLine(self.ds23PiTISLine)
self.registerLine(self.ds23PiLine)
self.registerLine(self.ds2PhiPiLine)
self.registerLine(self.tau25MuLine)
self.registerLine(self.tau2PMuMuLine)
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
prescaled_name = name + 'Prescaled'
self.selMuons = makeMuons('MuonsFor' + prescaled_name,
TRACK_Chi2=config['TRACK_Chi2'],
MUON_MinPT=config['MUON_MinPT'],
MUON_PIDmu=config['MUON_PIDmu'])
self.selKaons = makeKaons('KaonsFor' + prescaled_name,
TRACK_Chi2=config['TRACK_Chi2'],
KAON_PIDK=config['KAON_PIDK'],
KAON_MinPT=config['KAON_MinPT'])
self.selPions = makePions('PionsFor' + prescaled_name,
TRACK_Chi2=config['TRACK_Chi2'],
PION_PIDmu=config['PION_PIDmu'],
PION_PIDK=config['PION_PIDK'],
PION_MinPT=config['PION_MinPT'])
self.selSlowPions = makeSlowPions('SlowPionsFor' + prescaled_name,
TRACK_Chi2=config['TRACK_Chi2'],
PION_PIDmu=config['PION_PIDmu'])
self.selKstar = makeKstar('KstarFor' + prescaled_name,
pionSel=self.selPions,
kaonSel=self.selKaons,
Kstar_MinPT=config['Kstar_MinPT'],
Kstar_MassMax=config['Kstar_MassMax'],
Kstar_MassMin=config['Kstar_MassMin'])
self.selRho = makeRho('RhoFor' + prescaled_name,
pionSel=self.selPions,
Rho_MinPT=config['Rho_MinPT'],
Rho_MassMax=config['Rho_MassMax'],
Rho_MassMin=config['Rho_MassMin'])
self.selDplus2KstarMuNu = makeDplus2KstarMuNu(
'Dplus2RhoMuNuFor' + prescaled_name,
muonSel=self.selMuons,
KstarSel=self.selKstar,
PAIR_SumPTMin=config['PAIR_SumPTMin'],
D_MassMax=config['D_MassMax'],
D_DIRA=config['D_DIRA'],
D_DOCA=config['D_DOCA'],
D_MinP=config['D_MinP'],
Dplus_FD=config['Dplus_FD'],
D_MCORR_MIN=config['D_MCORR_MIN'],
D_MCORR_MAX=config['D_MCORR_MAX'],
D_BPVVDZ=config['D_BPVVDZ'],
D_VtxChi2=config['D_VtxChi2'])
self.selDplus2RhoMuNu = makeDplus2RhoMuNu(
'Dplus2KstarMuNuFor' + prescaled_name,
muonSel=self.selMuons,
RhoSel=self.selRho,
PAIR_SumPTMin=config['PAIR_SumPTMin'],
D_MassMax=config['D_MassMax'],
D_DIRA=config['D_DIRA'],
D_DOCA=config['D_DOCA'],
D_MinP=config['D_MinP'],
Dplus_FD=config['Dplus_FD'],
D_MCORR_MIN=config['D_MCORR_MIN'],
D_MCORR_MAX=config['D_MCORR_MAX'],
D_BPVVDZ=config['D_BPVVDZ'],
D_VtxChi2=config['D_VtxChi2'])
self.selD02PiMuNu = makeD02PiMuNu(
'D0PiMuNuFor' + prescaled_name,
muonSel=self.selMuons,
pionSel=self.selPions,
PAIR_SumPTMin=config['PAIR_SumPTMin'],
D_MassMax=config['D_MassMax'],
D_DIRA=config['D_DIRA'],
D_DOCA=config['D_DOCA'],
D_MinP=config['D_MinP'],
D0_FD=config['D0_FD'],
D_MCORR_MIN=config['D_MCORR_MIN'],
D_MCORR_MAX=config['D_MCORR_MAX'],
D_BPVVDZ=config['D_BPVVDZ'],
D_VtxChi2=config['D_VtxChi2'])
self.selDstarD02PiMuNu = makeDstarD02PiMuNu(
'DstarD0PiMuNuFor' + prescaled_name,
D02PiMuNuSel=self.selD02PiMuNu,
slowPionSel=self.selSlowPions,
Dstar_MassMin=config['Dstar_MassMin'],
Dstar_DOCA=config['Dstar_DOCA'],
Dstar_VtxChi2=config['Dstar_VtxChi2'],
Dstar_DeltaMass=config['Dstar_DeltaMass'])
self.prescaled_lineKstarMuNu = StrippingLine(
prescaled_name + "KstarMuNuLine",
prescale=config['PrescaledKstarLinePrescale'],
postscale=config['PrescaledLinePostscale'],
selection=self.selDplus2KstarMuNu)
self.prescaled_lineRhoMuNu = StrippingLine(
prescaled_name + "RhoMuNuLine",
prescale=config['PrescaledRhoLinePrescale'],
postscale=config['PrescaledLinePostscale'],
selection=self.selDplus2RhoMuNu)
self.prescaled_linePiMuNu = StrippingLine(
prescaled_name + "PiMuNuLine",
prescale=config['PrescaledPiLinePrescale'],
postscale=config['PrescaledLinePostscale'],
selection=self.selDstarD02PiMuNu)
self.registerLine(self.prescaled_lineKstarMuNu)
self.registerLine(self.prescaled_lineRhoMuNu)
self.registerLine(self.prescaled_linePiMuNu)
def __init__(self, name, config) :
LineBuilder.__init__(self, name, config)
prescaled_name = name + 'Nominal'
self.selKaons = makeKaons (
'KaonFor'+prescaled_name,
K_PT = config['K_PT'],
K_TRCHI2 = config['K_TRCHI2'],
K_IPCHI2 = config['K_IPCHI2']
)
self.selPions = makePions (
'PionFor'+prescaled_name,
pi_PT = config['pi_PT'],
pi_TRCHI2 = config['pi_TRCHI2'],
pi_IPCHI2 = config['pi_IPCHI2']
)
self.selPhi2KK = makePhi2KK (
'PhiFor'+prescaled_name,
kaons = self.selKaons,
phi_VDZ = config['phi_VDZ'],
phi_PT = config['phi_PT'],
phi_IPCHI2 = config['phi_IPCHI2'],
phi_VCHI2_VDOF = config['phi_VCHI2_VDOF']
)
self.selPhi2KKForEtac = makePhi2KKForEtac (
'PhiForEtacFor'+prescaled_name,
kaons = self.selKaons,
phi_etac_VDZ = config['phi_etac_VDZ'],
phi_etac_VCHI2_VDOF = config['phi_etac_VCHI2_VDOF']
)
self.selRho2PiPiForEtac = makeRho2PiPiForEtac (
'RhoForEtacFor'+prescaled_name,
pions = self.selPions,
rho_etac_VDZ = config['rho_etac_VDZ'],
rho_etac_VCHI2_VDOF = config['rho_etac_VCHI2_VDOF']
)
self.selEtac2RhoPhi = makeEtac2RhoPhi (
'EtacFor'+prescaled_name,
phiForEtacSel = self.selPhi2KKForEtac,
rhoForEtacSel = self.selRho2PiPiForEtac,
etac_VDZ = config['etac_VDZ'],
etac_PT = config['etac_PT'],
etac_IPCHI2 = config['etac_IPCHI2'],
etac_VCHI2_VDOF = config['etac_VCHI2_VDOF']
)
self.selBs2EtacPhi = makeBs2EtacPhi (
prescaled_name,
etacSel = self.selEtac2RhoPhi,
phiSel = self.selPhi2KK,
Bs_VDZ = config['Bs_VDZ'],
Bs_DIRA = config['Bs_DIRA'],
Bs_IPCHI2 = config['Bs_IPCHI2'],
Bs_VCHI2_VDOF = config['Bs_VCHI2_VDOF']
)
self.prescaled_line = StrippingLine (
prescaled_name+"Line",
prescale = config['Prescale'],
postscale = config['Postscale'],
algos = [ self.selBs2EtacPhi ]
)
self.registerLine(self.prescaled_line)
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
self.name = name
self.config = config
self.SelKaons = self.createSubSel(
OutputList=self.name + "SelKaons",
InputList=DataOnDemand(Location='Phys/StdLooseKaons/Particles'),
Cuts=config['KaonCuts'])
self.SelPions = self.createSubSel(
OutputList=self.name + "SelPions",
InputList=DataOnDemand(Location='Phys/StdLoosePions/Particles'),
Cuts=config['PionCuts'])
"""
Etac-> K K Pi Pi
"""
self.SelEtac2KKPiPi = self.createN4BodySel(
OutputList=self.name + "SelEtac2KKPiPi",
DaughterLists=[self.SelKaons, self.SelPions],
DecayDescriptor="eta_c(1S) -> K+ K- pi+ pi-",
ComAMCuts=config['EtacComAMCuts'],
PreVertexCuts=config['EtacComN4Cuts'],
PostVertexCuts=config['EtacMomN4Cuts'])
"""
Etac-> K K K K
"""
self.SelEtac2KKKK = self.createN4BodySel(
OutputList=self.name + "SelEtac2KKKK",
DaughterLists=[self.SelKaons],
DecayDescriptor="eta_c(1S) -> K+ K- K+ K-",
ComAMCuts=config['EtacComAMCuts'],
PreVertexCuts=config['EtacComN4Cuts'],
PostVertexCuts=config['EtacMomN4Cuts'])
"""
Etac-> Pi Pi Pi Pi
"""
self.SelEtac2PiPiPiPi = self.createN4BodySel(
OutputList=self.name + "SelEtac2PiPiPiPi",
DaughterLists=[self.SelPions],
DecayDescriptor="eta_c(1S) -> pi+ pi- pi+ pi-",
ComAMCuts=config['EtacComAMCuts'],
PreVertexCuts=config['EtacComN4Cuts'],
PostVertexCuts=config['EtacMomN4Cuts'])
"""
Eta_c
"""
from PhysSelPython.Wrappers import MergedSelection
self.SelEtac = MergedSelection(self.name + "SelEtac",
RequiredSelections=[
self.SelEtac2KKPiPi,
self.SelEtac2KKKK,
self.SelEtac2PiPiPiPi
])
"""
Phi
"""
self.SelPhi = self.createSubSel(
OutputList=self.name + "SelPhi",
InputList=DataOnDemand(Location='Phys/StdTightPhi2KK/Particles'),
Cuts=config['PhiCuts'])
"""
Kshort
"""
# Both LL and DD
self.InputKs = MergedSelection(
self.name + "InputKs",
RequiredSelections=[
DataOnDemand(Location="Phys/StdLooseKsDD/Particles"),
DataOnDemand(Location="Phys/StdLooseKsLL/Particles")
])
self.SelKs = self.createSubSel(OutputList=self.name + "SelKs",
InputList=self.InputKs,
Cuts=config['KsCuts'])
# Eta_c -> KS0 K Pi
self.SelEtac2KsKPi = self.createCombinationSel(
OutputList=self.name + "SelEtac2KsKPi",
DecayDescriptor="[eta_c(1S) -> KS0 K+ pi-]cc",
DaughterLists=[self.SelKs, self.SelKaons, self.SelPions],
PreVertexCuts=config['EtacComCuts'],
PostVertexCuts=config['EtacMomN4Cuts'])
"""
Bs->Eta_c(KsKPi) Phi
"""
self.SelBs2EtacPhi_KsKPi = self.createCombinationSel(
OutputList=self.name + "SelBs2EtacPhi_KsKPi",
DecayDescriptor="B_s0 -> eta_c(1S) phi(1020)",
DaughterLists=[self.SelPhi, self.SelEtac2KsKPi],
PreVertexCuts=config['BsComCuts'],
PostVertexCuts=config['BsMomCuts'])
self.Bs2EtacPhi_KsKPiLine = StrippingLine(
self.name + '_KsKPiLine',
prescale=config['Prescale'],
HLT2=config['HLTCuts'],
algos=[self.SelBs2EtacPhi_KsKPi],
EnableFlavourTagging=True) #, MDSTFlag = True )
self.registerLine(self.Bs2EtacPhi_KsKPiLine)
"""
Bs->Eta_c Phi
"""
self.SelBs2EtacPhi = self.createCombinationSel(
OutputList=self.name + "SelBs2EtacPhi",
DecayDescriptor="B_s0 -> eta_c(1S) phi(1020)",
DaughterLists=[self.SelPhi, self.SelEtac],
PreVertexCuts=config['BsComCuts'],
PostVertexCuts=config['BsMomCuts'])
"""
Apply MVA
"""
self.Bs2EtacPhiVars = {
'sqrt(Kp_Etac_IPCHI2_OWNPV)': "sqrt( CHILD(MIPCHI2DV(), 1, 1) )",
'sqrt(Km_Etac_IPCHI2_OWNPV)': "sqrt( CHILD(MIPCHI2DV(), 1, 2) )",
'sqrt(Pip_Etac_IPCHI2_OWNPV)': "sqrt( CHILD(MIPCHI2DV(), 1, 3) )",
'sqrt(Pim_Etac_IPCHI2_OWNPV)': "sqrt( CHILD(MIPCHI2DV(), 1, 4) )",
'sqrt(Kp_Phi_IPCHI2_OWNPV)': "sqrt( CHILD(MIPCHI2DV(), 2, 1) )",
'sqrt(Km_Phi_IPCHI2_OWNPV)': "sqrt( CHILD(MIPCHI2DV(), 2, 2) )",
'EtacSumIPCHI2':
"sqrt( CHILD(MIPCHI2DV(), 1, 1)+CHILD(MIPCHI2DV(), 1, 2)+CHILD(MIPCHI2DV(), 1, 3)+CHILD(MIPCHI2DV(), 1, 4))",
'sqrt(Etac_IPCHI2_OWNPV)': "sqrt( CHILD(MIPCHI2DV(), 1 ) )",
'sqrt(Phi_IPCHI2_OWNPV)': "sqrt( CHILD(MIPCHI2DV(), 2 ) )",
'log(Kp_Etac_PT)': "log( CHILD(PT, 1, 1) )",
'log(Km_Etac_PT)': "log( CHILD(PT, 1, 2) )",
'log(Pip_Etac_PT)': "log( CHILD(PT, 1, 3) )",
'log(Pim_Etac_PT)': "log( CHILD(PT, 1, 4) )",
'log(Kp_Phi_PT)': "log( CHILD(PT, 2, 1) )",
'log(Km_Phi_PT)': "log( CHILD(PT, 2, 2) )",
'log(Etac_PT)': "log( CHILD(PT, 1 ) )",
'log(Phi_PT)': "log( CHILD(PT, 2 ) )",
'Etac_ENDVERTEX_CHI2': "CHILD(VFASPF(VCHI2/VDOF), 1)",
'Phi_ENDVERTEX_CHI2': "CHILD(VFASPF(VCHI2/VDOF), 2)",
'sqrt(B_IPCHI2_OWNPV)': "sqrt( BPVIPCHI2() )",
'B_DIRA_OWNPV': "BPVDIRA",
'B_LOKI_FDS': "BPVDLS",
'B_PVFit_chi2[0]': "DTF_CHI2 ( True )"
}
self.MvaBs2EtacPhi = self.applyMVA(
self.name + "MvaBs2EtacPhi",
SelB=self.SelBs2EtacPhi,
MVAVars=self.Bs2EtacPhiVars,
MVACutValue=config['Bs2EtacPhiMVACut'],
MVAxmlFile=config['Bs2EtacPhiXmlFile'])
self.Bs2EtacPhiBDTLine = StrippingLine(
self.name + 'Line',
prescale=config['Prescale'],
HLT2=config['HLTCuts'],
algos=[self.MvaBs2EtacPhi],
EnableFlavourTagging=True) #, MDSTFlag = True )
self.registerLine(self.Bs2EtacPhiBDTLine)
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
myKaons = StdTightKaons
myPions = StdTightPions
allPions = StdAllNoPIDsPions
d2kpi_name = name + 'PromptD2KPiPi0'
d0RS_name = name + 'PromptD0RSPi0'
d0WS_name = name + 'PromptD0WSPi0'
d2KK_name = name + 'PromptD2KKPi0'
d2pipi_name = name + 'PromptD2PiPiPi0'
dst2Dpipi_name = name + 'PromptDst2D2PiPiPi0'
dst2DKK_name = name + 'PromptDst2D2KKPi0'
dst2DRS_name = name + 'PromptDst2D2RSPi0'
dst2DWS_name = name + 'PromptDst2D2WSPi0'
# D0 -> hh' selections
self.selD2WSR = makeD2hhAsymm(
d0WS_name + 'R',
config,
KPIDK_string=' & (PIDK > %(HighPIDK)s)',
PiPIDK_string=' & (PIDK < %(LowPIDK)s)',
Mass_low_string=
'& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KPiMassWindowWidthLow)s* MeV)',
Mass_high_string=
'& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KPiMassWindowWidthHigh)s* MeV)',
Kst_Mass_high_string=
'& (DAMASS(%(KstMassWindowCentre)s* MeV) < %(KstKPiMassWindowWidthHigh)s* MeV)',
CombPIDK_string='',
DecayDescriptor='K+ pi-',
inputSel=[myPions, myKaons],
useResolved=True,
TOSFilter='TOS')
self.selD2WSM = makeD2hhAsymm(
d0WS_name + 'M',
config,
KPIDK_string=' & (PIDK > %(HighPIDK)s)',
PiPIDK_string=' & (PIDK < %(LowPIDK)s)',
Mass_low_string=
'& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KPiMassWindowWidthLow)s* MeV)',
Mass_high_string=
'& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KPiMassWindowWidthHigh)s* MeV)',
Kst_Mass_high_string=
'& (DAMASS(%(KstMassWindowCentre)s* MeV) < %(KstKPiMassWindowWidthHigh)s* MeV)',
CombPIDK_string='',
DecayDescriptor='K+ pi-',
inputSel=[myPions, myKaons],
useResolved=False,
TOSFilter='TOS')
self.selD2KpiR = makeD2hhAsymm(
d2kpi_name + 'R',
config,
KPIDK_string=' & (PIDK > %(HighPIDK)s)',
PiPIDK_string=' & (PIDK < %(LowPIDK)s)',
Mass_low_string=
'& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KPiMassWindowWidthLow)s* MeV)',
Mass_high_string=
'& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KPiMassWindowWidthHigh)s* MeV)',
Kst_Mass_high_string=
'& (DAMASS(%(KstMassWindowCentre)s* MeV) < %(KstKPiMassWindowWidthHigh)s* MeV)',
CombPIDK_string='',
DecayDescriptor='K- pi+',
inputSel=[myPions, myKaons],
useResolved=True,
TOSFilter='TOS')
self.selD2KpiM = makeD2hhAsymm(
d2kpi_name + 'M',
config,
KPIDK_string=' & (PIDK > %(HighPIDK)s)',
PiPIDK_string=' & (PIDK < %(LowPIDK)s)',
Mass_low_string=
'& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KPiMassWindowWidthLow)s* MeV)',
Mass_high_string=
'& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KPiMassWindowWidthHigh)s* MeV)',
Kst_Mass_high_string=
'& (DAMASS(%(KstMassWindowCentre)s* MeV) < %(KstKPiMassWindowWidthHigh)s* MeV)',
CombPIDK_string='',
DecayDescriptor='K- pi+',
inputSel=[myPions, myKaons],
useResolved=False,
TOSFilter='TOS')
self.selD2KpiRSS = makeD2hhAsymm(
d2kpi_name + 'RSS',
config,
KPIDK_string=' & (PIDK > %(HighPIDK)s)',
PiPIDK_string=' & (PIDK < %(LowPIDK)s)',
Mass_low_string=
'& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KPiMassWindowWidthLow)s* MeV)',
Mass_high_string=
'& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KPiMassWindowWidthHigh)s* MeV)',
Kst_Mass_high_string=
'& (DAMASS(%(KstMassWindowCentre)s* MeV) < %(KstKPiMassWindowWidthHigh)s* MeV)',
CombPIDK_string='',
DecayDescriptor='K- pi-',
inputSel=[myPions, myKaons],
useResolved=True,
TOSFilter='NONE')
self.selD2KpiMSS = makeD2hhAsymm(
d2kpi_name + 'MSS',
config,
KPIDK_string=' & (PIDK > %(HighPIDK)s)',
PiPIDK_string=' & (PIDK < %(LowPIDK)s)',
Mass_low_string=
'& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KPiMassWindowWidthLow)s* MeV)',
Mass_high_string=
'& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KPiMassWindowWidthHigh)s* MeV)',
Kst_Mass_high_string=
'& (DAMASS(%(KstMassWindowCentre)s* MeV) < %(KstKPiMassWindowWidthHigh)s* MeV)',
CombPIDK_string='',
DecayDescriptor='K- pi-',
inputSel=[myPions, myKaons],
useResolved=False,
TOSFilter='NONE')
self.selD2KKR = makeD2hhAsymm(
d2KK_name + 'R',
config,
KPIDK_string=' & (PIDK > %(HighPIDK)s)',
PiPIDK_string=' & (PIDK < %(LowPIDK)s)',
Mass_low_string=
'& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KPiMassWindowWidthLow)s* MeV)',
Mass_high_string=
'& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KPiMassWindowWidthHigh)s* MeV)',
Kst_Mass_high_string=
'& (DAMASS(%(KstMassWindowCentre)s* MeV) < %(KstKPiMassWindowWidthHigh)s* MeV)',
CombPIDK_string='',
DecayDescriptor='K- K+',
inputSel=[myKaons],
useResolved=True,
TOSFilter='TOS')
self.selD2KKM = makeD2hhAsymm(
d2KK_name + 'M',
config,
KPIDK_string=' & (PIDK > %(HighPIDK)s)',
PiPIDK_string=' & (PIDK < %(LowPIDK)s)',
Mass_low_string=
'& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KPiMassWindowWidthLow)s* MeV)',
Mass_high_string=
'& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KPiMassWindowWidthHigh)s* MeV)',
Kst_Mass_high_string=
'& (DAMASS(%(KstMassWindowCentre)s* MeV) < %(KstKPiMassWindowWidthHigh)s* MeV)',
CombPIDK_string='',
DecayDescriptor='K- K+',
inputSel=[myKaons],
useResolved=False,
TOSFilter='TOS')
self.selD2KKRSS = makeD2hhAsymm(
d2KK_name + 'RSS',
config,
KPIDK_string=' & (PIDK > %(HighPIDK)s)',
PiPIDK_string=' & (PIDK < %(LowPIDK)s)',
Mass_low_string=
'& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KPiMassWindowWidthLow)s* MeV)',
Mass_high_string=
'& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KPiMassWindowWidthHigh)s* MeV)',
Kst_Mass_high_string=
'& (DAMASS(%(KstMassWindowCentre)s* MeV) < %(KstKPiMassWindowWidthHigh)s* MeV)',
CombPIDK_string='',
DecayDescriptor='K- K-',
inputSel=[myKaons],
useResolved=True,
TOSFilter='NONE')
self.selD2KKMSS = makeD2hhAsymm(
d2KK_name + 'MSS',
config,
KPIDK_string=' & (PIDK > %(HighPIDK)s)',
PiPIDK_string=' & (PIDK < %(LowPIDK)s)',
Mass_low_string=
'& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KPiMassWindowWidthLow)s* MeV)',
Mass_high_string=
'& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KPiMassWindowWidthHigh)s* MeV)',
Kst_Mass_high_string=
'& (DAMASS(%(KstMassWindowCentre)s* MeV) < %(KstKPiMassWindowWidthHigh)s* MeV)',
CombPIDK_string='',
DecayDescriptor='K- K-',
inputSel=[myKaons],
useResolved=False,
TOSFilter='NONE')
self.selD2pipiR = makeD2hhAsymm(
d2pipi_name + 'R',
config,
KPIDK_string=' & (PIDK > %(HighPIDK)s)',
PiPIDK_string=' & (PIDK < %(LowPIDK)s)',
Mass_low_string=
'& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KPiMassWindowWidthLow)s* MeV)',
Mass_high_string=
'& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KPiMassWindowWidthHigh)s* MeV)',
Kst_Mass_high_string=
'& (DAMASS(%(KstMassWindowCentre)s* MeV) < %(KstKPiMassWindowWidthHigh)s* MeV)',
CombPIDK_string='',
DecayDescriptor='pi- pi+',
inputSel=[myPions],
useResolved=True,
TOSFilter='TOS')
self.selD2pipiM = makeD2hhAsymm(
d2pipi_name + 'M',
config,
KPIDK_string=' & (PIDK > %(HighPIDK)s)',
PiPIDK_string=' & (PIDK < %(LowPIDK)s)',
Mass_low_string=
'& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KPiMassWindowWidthLow)s* MeV)',
Mass_high_string=
'& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KPiMassWindowWidthHigh)s* MeV)',
Kst_Mass_high_string=
'& (DAMASS(%(KstMassWindowCentre)s* MeV) < %(KstKPiMassWindowWidthHigh)s* MeV)',
CombPIDK_string='',
DecayDescriptor='pi- pi+',
inputSel=[myPions],
useResolved=False,
TOSFilter='TOS')
self.selD2pipiRSS = makeD2hhAsymm(
d2pipi_name + 'RSS',
config,
KPIDK_string=' & (PIDK > %(HighPIDK)s)',
PiPIDK_string=' & (PIDK < %(LowPIDK)s)',
Mass_low_string=
'& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KPiMassWindowWidthLow)s* MeV)',
Mass_high_string=
'& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KPiMassWindowWidthHigh)s* MeV)',
Kst_Mass_high_string=
'& (DAMASS(%(KstMassWindowCentre)s* MeV) < %(KstKPiMassWindowWidthHigh)s* MeV)',
CombPIDK_string='',
DecayDescriptor='pi- pi-',
inputSel=[myPions],
useResolved=True,
TOSFilter='NONE')
self.selD2pipiMSS = makeD2hhAsymm(
d2pipi_name + 'MSS',
config,
KPIDK_string=' & (PIDK > %(HighPIDK)s)',
PiPIDK_string=' & (PIDK < %(LowPIDK)s)',
Mass_low_string=
'& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KPiMassWindowWidthLow)s* MeV)',
Mass_high_string=
'& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KPiMassWindowWidthHigh)s* MeV)',
Kst_Mass_high_string=
'& (DAMASS(%(KstMassWindowCentre)s* MeV) < %(KstKPiMassWindowWidthHigh)s* MeV)',
CombPIDK_string='',
DecayDescriptor='pi- pi-',
inputSel=[myPions],
useResolved=False,
TOSFilter='NONE')
# Dstar -> D0 pi selections
self.selDstRSR = makeDstar2D0Pi(dst2DRS_name + 'R',
config,
'[D*(2010)+ -> D0 pi+]cc',
inputSel=[self.selD2KpiR, allPions])
self.selDstRSM = makeDstar2D0Pi(dst2DRS_name + 'M',
config,
'[D*(2010)+ -> D0 pi+]cc',
inputSel=[self.selD2KpiM, allPions])
self.selDstWSR = makeDstar2D0Pi(dst2DWS_name + 'R',
config,
'[D*(2010)+ -> D0 pi+]cc',
inputSel=[self.selD2WSR, allPions])
self.selDstWSM = makeDstar2D0Pi(dst2DWS_name + 'M',
config,
'[D*(2010)+ -> D0 pi+]cc',
inputSel=[self.selD2WSM, allPions])
self.selDstRSRSS = makeDstar2D0Pi(
dst2DRS_name + 'RSS',
config,
'[D*(2010)+ -> D0 pi+]cc',
inputSel=[self.selD2KpiRSS, allPions])
self.selDstRSMSS = makeDstar2D0Pi(
dst2DRS_name + 'MSS',
config,
'[D*(2010)+ -> D0 pi+]cc',
inputSel=[self.selD2KpiMSS, allPions])
self.selDstKKR = makeDstar2D0Pi(dst2DKK_name + 'R',
config,
'[D*(2010)+ -> D0 pi+]cc',
inputSel=[self.selD2KKR, allPions])
self.selDstKKM = makeDstar2D0Pi(dst2DKK_name + 'M',
config,
'[D*(2010)+ -> D0 pi+]cc',
inputSel=[self.selD2KKM, allPions])
self.selDstKKRSS = makeDstar2D0Pi(dst2DKK_name + 'RSS',
config,
'[D*(2010)+ -> D0 pi+]cc',
inputSel=[self.selD2KKRSS, allPions])
self.selDstKKMSS = makeDstar2D0Pi(dst2DKK_name + 'MSS',
config,
'[D*(2010)+ -> D0 pi+]cc',
inputSel=[self.selD2KKMSS, allPions])
self.selDstpipiR = makeDstar2D0Pi(dst2Dpipi_name + 'R',
config,
'[D*(2010)+ -> D0 pi+]cc',
inputSel=[self.selD2pipiR, allPions])
self.selDstpipiM = makeDstar2D0Pi(dst2Dpipi_name + 'M',
config,
'[D*(2010)+ -> D0 pi+]cc',
inputSel=[self.selD2pipiM, allPions])
self.selDstpipiRSS = makeDstar2D0Pi(
dst2Dpipi_name + 'RSS',
config,
'[D*(2010)+ -> D0 pi+]cc',
inputSel=[self.selD2pipiRSS, allPions])
self.selDstpipiMSS = makeDstar2D0Pi(
dst2Dpipi_name + 'MSS',
config,
'[D*(2010)+ -> D0 pi+]cc',
inputSel=[self.selD2pipiMSS, allPions])
# Tagged lines
self.dstRSR_line = StrippingLine(
dst2DRS_name + "RLine",
prescale=config['TaggedRSLinePrescale'],
postscale=config['TaggedRSLinePostscale'],
selection=self.selDstRSR)
self.dstRSM_line = StrippingLine(
dst2DRS_name + "MLine",
prescale=config['TaggedRSLinePrescale'],
postscale=config['TaggedRSLinePostscale'],
selection=self.selDstRSM)
self.dstWSR_line = StrippingLine(
dst2DWS_name + "RLine",
prescale=config['TaggedWSLinePrescale'],
postscale=config['TaggedWSLinePostscale'],
selection=self.selDstWSR)
self.dstWSM_line = StrippingLine(
dst2DWS_name + "MLine",
prescale=config['TaggedWSLinePrescale'],
postscale=config['TaggedWSLinePostscale'],
selection=self.selDstWSM)
self.dstRSRSS_line = StrippingLine(
dst2DRS_name + "RSSLine",
prescale=config['TaggedRSLinePrescale'],
postscale=config['TaggedRSLinePostscale'],
selection=self.selDstRSRSS)
self.dstRSMSS_line = StrippingLine(
dst2DRS_name + "MSSLine",
prescale=config['TaggedRSLinePrescale'],
postscale=config['TaggedRSLinePostscale'],
selection=self.selDstRSMSS)
self.dstKKR_line = StrippingLine(
dst2DKK_name + "RLine",
prescale=config['TaggedSCSLinePrescale'],
postscale=config['TaggedSCSLinePostscale'],
selection=self.selDstKKR)
self.dstKKM_line = StrippingLine(
dst2DKK_name + "MLine",
prescale=config['TaggedSCSLinePrescale'],
postscale=config['TaggedSCSLinePostscale'],
selection=self.selDstKKM)
self.dstKKRSS_line = StrippingLine(
dst2DKK_name + "RSSLine",
prescale=config['TaggedSCSLinePrescale'],
postscale=config['TaggedSCSLinePostscale'],
selection=self.selDstKKRSS)
self.dstKKMSS_line = StrippingLine(
dst2DKK_name + "MSSLine",
prescale=config['TaggedSCSLinePrescale'],
postscale=config['TaggedSCSLinePostscale'],
selection=self.selDstKKMSS)
self.dstpipiR_line = StrippingLine(
dst2Dpipi_name + "RLine",
prescale=config['TaggedSCSLinePrescale'],
postscale=config['TaggedSCSLinePostscale'],
selection=self.selDstpipiR)
self.dstpipiM_line = StrippingLine(
dst2Dpipi_name + "MLine",
prescale=config['TaggedSCSLinePrescale'],
postscale=config['TaggedSCSLinePostscale'],
selection=self.selDstpipiM)
self.dstpipiRSS_line = StrippingLine(
dst2Dpipi_name + "RSSLine",
prescale=config['TaggedSCSLinePrescale'],
postscale=config['TaggedSCSLinePostscale'],
selection=self.selDstpipiRSS)
self.dstpipiMSS_line = StrippingLine(
dst2Dpipi_name + "MSSLine",
prescale=config['TaggedSCSLinePrescale'],
postscale=config['TaggedSCSLinePostscale'],
selection=self.selDstpipiMSS)
# register lines
if config['RunSameSign']:
self.registerLine(self.dstRSRSS_line)
self.registerLine(self.dstRSMSS_line)
self.registerLine(self.dstKKRSS_line)
self.registerLine(self.dstKKMSS_line)
self.registerLine(self.dstpipiRSS_line)
self.registerLine(self.dstpipiMSS_line)
if config['RunDefault']:
self.registerLine(self.dstRSR_line)
self.registerLine(self.dstRSM_line)
self.registerLine(self.dstWSR_line)
self.registerLine(self.dstWSM_line)
self.registerLine(self.dstKKR_line)
self.registerLine(self.dstKKM_line)
self.registerLine(self.dstpipiR_line)
self.registerLine(self.dstpipiM_line)
def __init__(self, name, config) :
LineBuilder.__init__(self, name, config)
self.name = name
# Bd2KstartMuMu cuts definitions
self.BdCombCut = "(AM > %(B_Comb_MassLow)s * MeV) & (AM < %(B_Comb_MassHigh)s * MeV)" %config
self.BdCut = "(abs(SUMQ) < 3) & " \
"(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.KstarCombCut = "(AM > %(Kstar_Comb_MassLow)s * MeV) & " \
"(AM < %(Kstar_Comb_MassHigh)s * MeV) & " \
"(ADOCACHI2CUT(20.,''))" %config
self.KstarCut = DaughterCuts + " & (M > %(Kstar_MassLow)s * MeV) & " \
"(M < %(Kstar_MassHigh)s * MeV) & " \
"(BPVVDCHI2 > %(Kstar_FlightChi2)s) & " \
"(MIPCHI2DV(PRIMARY) > %(Kstar_MinIPCHI2)s) & " \
"(MAXTREE(ISBASIC,MIPCHI2DV(PRIMARY))> %(Kstar_Dau_MaxIPCHI2)s )" %config
self.DiMuonCombCut = "(AM < %(DimuonUPPERMASS)s *MeV)" %config
self.DiMuonCut = DaughterCuts + " & (BPVVDCHI2 > %(Dimu_FlightChi2)s) & " \
"(MAXTREE(ISBASIC,MIPCHI2DV(PRIMARY))> %(Dimu_Dau_MaxIPCHI2)s )" %config
self.TrackCuts = "(TRCHI2DOF < %(Track_CHI2nDOF)s) & (TRGHP < %(Track_GhostProb)s)" %config
#self.TrackCuts = "(TRCHI2DOF < %(Track_CHI2nDOF)s)" %config
self.HadronCuts = "(MIPCHI2DV(PRIMARY) > %(Hadron_MinIPCHI2)s) & (HASRICH)" %config
self.KaonCut = self.TrackCuts + " & " + self.HadronCuts
self.PionCut = self.TrackCuts + " & " + self.HadronCuts
self.MuonCut = self.TrackCuts + " & (MIPCHI2DV(PRIMARY) > %(Muon_MinIPCHI2)s) & (PIDmu> %(MuonPID)s)" %config
#self.KstarFilterCut = self.KstarCut + " & (INTREE(ABSID=='K+') & " + self.KaonCut + ") & (INTREE(ABSID=='pi+') & " + self.PionCut + ")"
self.Dimuon = self.__Dimuon__(config)
self.Protons = self.__Protons__(config)
self.Kaons = self.__Kaons__(config)
self.Pions = self.__Pions__(config)
self.Kshort = self.__Kshort__(config)
self.Dplus = self.__Dplus__(config)
self.Dzero = self.__Dzero__(config)
self.Lambda = self.__Lambda__(config)
self.Pi0 = self.__Pi0__(config)
self.Rho = self.__Rho__(self.Pions, config)
self.F2 = self.__F2__(self.Rho, config)
self.Phi = self.__Phi__(self.Rho, config)
self.Kstar = self.__Kstar__(self.Rho, config)
self.Lambdastar = self.__Lambdastar__(self.Rho, config)
self.Kstar2KsPi = self.__Kstar2KsPi__(self.Kshort, self.Pions, config)
self.Kstar2KPi0 = self.__Kstar2KPi0__(self.Kaons, self.Pi0, config)
self.Dstar = self.__Dstar__(config)
self.A1 = self.__A1__(self.Pions, config)
self.K1 = self.__K1__(self.A1, config)
self.K2 = self.__K2__(self.A1, config)
self.AvailableDaughters = {
'K*(892)0' : [ self.Kstar ] ,
'rho(770)0' : [ self.Rho ] ,
'f_2(1950)' : [ self.F2 ] ,
'KS0' : [ self.Kshort] ,
'D~0' : [ self.Dzero ] ,
'K+' : [ self.Kaons ] ,
'pi+' : [ self.Pions ] ,
'K*(892)+' : [ self.Kstar2KsPi, self.Kstar2KPi0 ],
'D+' : [ self.Dplus ] ,
'D*(2010)+' : [ self.Dstar ] ,
'Lambda0' : [ self.Lambda ] ,
'Lambda(1520)0' : [ self.Lambdastar ] ,
'pi0' : [ self.Pi0 ] ,
'a_1(1260)' : [ self.A1 ],
'K_1(1270)' : [ self.K1 ],
'K_2(1770)' : [ self.K2 ]
}
self.DeclaredDaughters = []
for d in config['DECAYS']:
for k in self.AvailableDaughters.keys():
if k in d: self.DeclaredDaughters += self.AvailableDaughters.pop(k)
self.Bs = self.__Bs__( self.Dimuon,
daughters = self.DeclaredDaughters,
conf = config)
self.line = StrippingLine(
self.name+"_Line",
prescale = 1,
FILTER = {
'Code' : " ( recSummary(LHCb.RecSummary.nSPDhits,'Raw/Spd/Digits') < %(SpdMult)s )" %config ,
'Preambulo' : [
"from LoKiNumbers.decorators import *", "from LoKiCore.basic import LHCb"
]
},
algos=[self.Bs]
)
self.registerLine(self.line)
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
self._myname = name
#Define the cuts
_mucut1 = '(PT>%(mupt1)s*MeV)&(TRPCHI2>%(mutrkpchi2)s)&(MIPDV(PRIMARY)/MIPCHI2DV(PRIMARY)<%(muipdvchi2ratio)s)&((PIDmu-PIDpi)>%(mupidreq)s)' % config
_mucut2 = '(PT>%(mupt2)s*GeV)&(TRPCHI2>%(mutrkpchi2)s)&(MIPDV(PRIMARY)/MIPCHI2DV(PRIMARY)<%(muipdvchi2ratio)s)' % config
_DY1MassCut = '((MM>%(DY1MinMass)s*GeV)&(MM<%(DY1jpsiexclow)s*GeV))|((MM>%(DY1jpsiexchigh)s*GeV)&(MM<%(DY1MaxMass)s*GeV))' % config
_DY1MassCutHlt = '((MM>%(DY1MinMass)s*GeV)&(MM<%(DY1jpsiexclow)s*GeV))|((MM>%(DY1jpsiexchigh)s*GeV))' % config
_DY2MassCut = '(MM>%(DY2MinMass)s*GeV)&(MM<%(DY2MaxMass)s*GeV)' % config
_DY2MassCutHlt = '(MM>%(DY2MinMass)s*GeV)' % config
_DY3MassCut = '(MM>%(DY3MinMass)s*GeV)&(MM<%(DY3MaxMass)s*GeV)' % config
_DY4MassCut = '(MM>%(DY4MinMass)s*GeV)&(MM<%(DY4MaxMass)s*GeV)' % config
self.selDY2MuMu1 = makeDY2MuMu1(self._myname + 'DYDecay1_ps',
_DY1MassCut, _mucut1)
self.selDY2MuMu1_Hlt = makeDY2MuMu1(self._myname + 'DYDecay1_Hlt',
_DY1MassCutHlt, _mucut1)
self.DY2MuMu_line1_ps = StrippingLine(
self._myname + "Line1_ps",
prescale=config['DY2MuMu1Line_psPrescale'],
postscale=config['DY2MuMu1LinePostscale'],
selection=self.selDY2MuMu1)
self.DY2MuMu_line1_Hlt = StrippingLine(
self._myname + "Line1_Hlt",
prescale=config['DY2MuMu1Line_HltPrescale'],
postscale=config['DY2MuMu1LinePostscale'],
HLT="HLT_PASS_RE('Hlt2DiMuonDY.*Decision')",
selection=self.selDY2MuMu1_Hlt)
self.DY2MuMu_line1_Hlta = StrippingLine(
self._myname + "Line1_Hlta",
prescale=config['DY2MuMu1Line_HltaPrescale'],
postscale=config['DY2MuMu1LinePostscale'],
HLT="HLT_PASS_RE('Hlt2(MuonFromHLT1|PassThrough).*Decision')",
selection=self.selDY2MuMu1_Hlt)
self.registerLine(self.DY2MuMu_line1_ps)
self.registerLine(self.DY2MuMu_line1_Hlt)
self.registerLine(self.DY2MuMu_line1_Hlta)
self.selDY2MuMu2 = makeDY2MuMu2(self._myname + 'DYDecay2', _DY2MassCut,
_mucut2)
self.selDY2MuMu2_Hlt = makeDY2MuMu2(self._myname + 'DYDecay2_Hlt',
_DY2MassCutHlt, _mucut1)
self.DY2MuMu_line2 = StrippingLine(
self._myname + "Line2",
prescale=config['DY2MuMu2LinePrescale'],
postscale=config['DY2MuMu2LinePostscale'],
selection=self.selDY2MuMu2)
self.DY2MuMu_line2_Hlt = StrippingLine(
self._myname + "Line2_Hlt",
prescale=config['DY2MuMu2Line_HltPrescale'],
postscale=config['DY2MuMu2LinePostscale'],
HLT="HLT_PASS_RE('Hlt2DiMuonDY.*Decision')",
selection=self.selDY2MuMu2_Hlt)
self.DY2MuMu_line2_Hlta = StrippingLine(
self._myname + "Line2_Hlta",
prescale=config['DY2MuMu2Line_HltaPrescale'],
postscale=config['DY2MuMu2LinePostscale'],
HLT="HLT_PASS_RE('Hlt2(MuonFromHLT1|PassThrough).*Decision')",
selection=self.selDY2MuMu2_Hlt)
self.registerLine(self.DY2MuMu_line2)
self.registerLine(self.DY2MuMu_line2_Hlt)
self.registerLine(self.DY2MuMu_line2_Hlta)
self.selDY2MuMu3 = makeDY2MuMu3(self._myname + 'DY2MuMuDecay3',
_DY3MassCut, _mucut2)
self.DY2MuMu_line3 = StrippingLine(
self._myname + "Line3",
prescale=config['DY2MuMu3LinePrescale'],
postscale=config['DY2MuMu3LinePostscale'],
selection=self.selDY2MuMu3)
self.registerLine(self.DY2MuMu_line3)
self.selDY2MuMu4 = makeDY2MuMu4(self._myname + 'DY2MuMuDecay4',
_DY4MassCut, _mucut2)
self.DY2MuMu_line4 = StrippingLine(
self._myname + "Line4",
prescale=config['DY2MuMu4LinePrescale'],
postscale=config['DY2MuMu4LinePostscale'],
selection=self.selDY2MuMu4)
self.registerLine(self.DY2MuMu_line4)
def _Bs2PhiPhi_X_Line( self, name, config, wide ) :
Phi2KK_DC = "(PT>%(KaonPT)s*MeV)&(MIPCHI2DV(PRIMARY)>%(KaonIPCHI2)s)" % config
Phi2KK_CC = "(AM<(%(PhiMassMax)s+30)*MeV)&(ADOCACHI2CUT(40, ''))" % config
Phi2KK_MassCut = ""
if wide == False :
Phi2KK_MassCut = "&(ADMASS('phi(1020)')<%(PhiMassWindow)s*MeV)" % config
else :
Phi2KK_MassCut = "&(MM<%(PhiMassMax)s*MeV)" % config
Phi2KK_MC = "(VFASPF(VCHI2/VDOF)<%(PhiVertexCHI2pDOF)s)" % config + Phi2KK_MassCut
Bs2PhiPhi_DC = "(PT>%(PhiPT)s*MeV)" % config
Bs2PhiPhi_CC = "(ADAMASS('B_s0')<((%(BsMassWindow)s+30)*MeV))&(ACHILD(PT,1)*ACHILD(PT,2)>%(PhiPTsq)s*GeV*GeV)" % config
Bs2PhiPhi_MC = "(VFASPF(VCHI2/VDOF)<%(BsVertexCHI2pDOF)s)&(ADMASS('B_s0')<%(BsMassWindow)s*MeV)" % config
ps = 1.0
if wide == True :
ps = config['WidePrescale']
#print "Cuts for "+name+"Line"
#print Phi2KK_DC
#print Phi2KK_CC
#print Phi2KK_MC
#print Bs2PhiPhi_DC
#print Bs2PhiPhi_CC
#print Bs2PhiPhi_MC
#print "Prescale: ", ps
#_stdLooseKaons = DataOnDemand(Location = "Phys/StdLooseKaons/Particles")
_Bs2PhiPhiLooseDetachedPhi2KK = CombineParticles(
DecayDescriptor = "phi(1020) -> K+ K-"
, DaughtersCuts = {"K+": Phi2KK_DC}
, CombinationCut = Phi2KK_CC
, MotherCut = Phi2KK_MC
)
_Bs2PhiPhi = CombineParticles(
DecayDescriptor = "B_s0 -> phi(1020) phi(1020)"
, DaughtersCuts = {"phi(1020)" : Bs2PhiPhi_DC}
, CombinationCut = Bs2PhiPhi_CC
, MotherCut = Bs2PhiPhi_MC
)
Bs2PhiPhiLooseDetachedPhi2KK = Selection(
name+ "_LoosePhi2KK",
Algorithm = _Bs2PhiPhiLooseDetachedPhi2KK,
RequiredSelections = [MyLooseKaons])
Bs2PhiPhi = Selection(
name,
Algorithm = _Bs2PhiPhi,
RequiredSelections = [Bs2PhiPhiLooseDetachedPhi2KK])
return StrippingLine(name+"Line"
, prescale = ps
, postscale = 1
, selection = Bs2PhiPhi
)
def __init__(self, name, config): # {
LineBuilder.__init__(self, name, config)
from Configurables import LoKi__VoidFilter as VoidFilter
from Configurables import LoKi__Hybrid__CoreFactory as CoreFactory
modules = CoreFactory('CoreFactory').Modules
for i in ['LoKiTracks.decorators']:
if i not in modules: modules.append(i)
d02KKmumu_name = 'D0For' + name
dstar_name = name
self.inPions = DataOnDemand(Location="Phys/StdLoosePions/Particles")
self.inMuons = DataOnDemand(Location="Phys/StdLooseMuons/Particles")
self.inKaons = DataOnDemand(Location="Phys/StdLooseKaons/Particles")
self.selD02KKmumu = makeD02KKmumu(
d02KKmumu_name,
inputSel=[self.inMuons, self.inKaons],
TrackChi2max=config['TrackChi2max'],
DDauKPTmin=config['DDauKPTmin'],
DDauKPmin=config['DDauKPmin'],
DDauMuPTmin=config['DDauMuPTmin'],
DDauMuPmin=config['DDauMuPmin'],
DDauKDelPIDmin=config['DDauKDelPIDmin'],
DDauMuDelPIDmin=config['DDauMuDelPIDmin'],
DCombMassWind=config['DCombMassWind'],
DCombAMAXDOCAmax=config['DCombAMAXDOCAmax'],
DMothPTmin=config['DMothPTmin'],
DMothBPVDIRAmin=config['DMothBPVDIRAmin'],
DMothMIPDVmax=config['DMothMIPDVmax'],
DMothMIPCHI2DVmax=config['DMothMIPCHI2DVmax'],
DMothBPVVDmin=config['DMothBPVVDmin'],
DMothBPVDCHI2min=config['DMothBPVDCHI2min'],
DMothBPVVDZmin=config['DMothBPVVDZmin'],
DMothVFASPFmax=config['DMothVFASPFmax'])
self.selDstar2D0Pi_D02KKmumu = makeDstar2D0Pi(
dstar_name,
inputSel=[self.inPions, self.selD02KKmumu],
DstarCombMassWind=config['DstarCombMassWind'],
DstarCombAMAXDOCAmax=config['DstarCombAMAXDOCAmax'],
DstarMothVFASPFmax=config['DstarMothVFASPFmax'],
DstarMothPTmin=config['DstarMothPTmin'],
DstarMothDMmin=config['DstarMothDMmin'],
DstarMothDMmax=config['DstarMothDMmax'],
DstarMothSlpiMIPDVmax=config['DstarMothSlpiMIPDVmax'],
DstarMothSlpiMIPCHI2DVmax=config['DstarMothSlpiMIPCHI2DVmax'],
DstarMothSlpiPTmin=config['DstarMothSlpiPTmin'])
self.line_Dstar2D0Pi_D02KKmumu = StrippingLine(
dstar_name + "Line",
prescale=config['LinePrescale'],
postscale=config['LinePostscale'],
FILTER={
"Code":
"(recSummaryTrack(LHCb.RecSummary.nLongTracks, TrLONG) < %s )"
% config['NTracksLim'],
"Preambulo": ["from LoKiTracks.decorators import *"]
},
algos=[self.selDstar2D0Pi_D02KKmumu])
self.registerLine(self.line_Dstar2D0Pi_D02KKmumu)
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
# Select photons
self.selPhotons = {
'':
self.makePhoton('GammaFor' + name, config['photonPT']),
'_CNVLL':
self.makePhotonConv('CNVGammaLLFor' + name,
config['MaxMass_CNV_LL'],
config['MaxVCHI2_CNV_LL'],
config['MinPT_CNV_LL'], [StdAllLooseGammaLL]),
'_CNVDD':
self.makePhotonConv('CNVGammaDDFor' + name,
config['MaxMass_CNV_DD'],
config['MaxVCHI2_CNV_DD'],
config['MinPT_CNV_DD'], [StdAllLooseGammaDD])
}
self.HHForD2XGamma, self.D2XGamma, self.Dst2D0pi, self.lineDstarD2XGamma = {}, {}, {}, {}
decays = {
'PiPiGamma': {
'HHdesc': ['rho(770)0 -> pi+ pi-'],
'D0desc': ['D0 -> rho(770)0 gamma']
},
'KPiGamma': {
'HHdesc': ['K*(892)0 -> K- pi+', 'K*(892)0 -> K+ pi-'],
'D0desc': ['D0 -> K*(892)0 gamma']
},
'KKGamma': {
'HHdesc': ['phi(1020) -> K+ K-'],
'D0desc': ['D0 -> phi(1020) gamma']
},
}
for decay, decayDescriptors in decays.iteritems():
# make the various stripping selections
DstarD2XGammaName = name + "DstarD2" + decay
D2XGammaName = name + "D2" + decay
HHCombName = name + "HHForD2" + decay
inputs = [StdNoPIDsPions] if decays == 'PiPiGamma' else [
StdNoPIDsPions, StdNoPIDsKaons
]
# Create the 2-body candidate
self.HHForD2XGamma[decay] = self.makeHH(
HHCombName,
decayDescriptors['HHdesc'],
config['TrChi2'],
config['TrGhostProb'],
config['MinTrkPT'],
config['MinTrkIPChi2'],
config['HighPIDK'],
config['LowPIDK'],
config['CombMassLow_HH'], # FIXME!!!!
config['CombMassHigh_HH'],
config['MinCombPT'],
config['MaxADOCACHI2'],
config['MinVDCHI2_HHComb'],
config['MassLow_HH'],
config['MassHigh_HH'],
config['MaxVCHI2NDOF_HH'],
config['MinVDCHI2_HH'],
inputs)
for phName, photons in self.selPhotons.iteritems():
# Create the D0 candidate
self.D2XGamma[decay + phName] = self.makeD2XGamma(
D2XGammaName + phName,
decayDescriptors['D0desc'],
config['CombMassLow'],
config['CombMassHigh'],
config['MassLow'],
config['MassHigh'],
config['MinPT'],
config['MaxVCHI2NDOF'],
config['MinBPVDIRA'],
config['MinBPVTAU'],
inputSel=[self.HHForD2XGamma[decay], photons])
# Create the D* candidate
self.Dst2D0pi[decay + phName] = self.makeDstar2D0Pi(
DstarD2XGammaName + phName,
config, ['D*(2010)+ -> D0 pi+', 'D*(2010)- -> D0 pi-'],
inputSel=[self.D2XGamma[decay + phName], StdNoPIDsPions])
# Create the stripping line
self.lineDstarD2XGamma[decay + phName] = StrippingLine(
DstarD2XGammaName + phName + "Line",
prescale=config['PrescaleDstarD2' + decay + phName],
selection=self.Dst2D0pi[decay + phName],
HLT1=config['Hlt1Filter'],
HLT2=config['Hlt2Filter'])
# Register the line
self.registerLine(self.lineDstarD2XGamma[decay + phName])
def __init__(self, name, config) :
LineBuilder.__init__(self, name, config)
stdNoPIDsKaons = StdAllNoPIDsKaons
stdNoPIDsPions = StdAllNoPIDsPions
d2kpi_name = name+'PromptD2KPi'
d0RS_name = name+'PromptD0RS'
d0WS_name = name+'PromptD0WS'
d2kk_name = name+'PromptD2KK'
d2pipi_name = name+'PromptD2PiPi'
dst2DPiPi_name = name+'PromptDst2D2PiPi'
dst2DKK_name = name+'PromptDst2D2KK'
dst2DRS_name = name+'PromptDst2D2RS'
dst2DWS_name = name+'PromptDst2D2WS'
dPartial_name = name+'PromptDPartial'
dstarPartial_name = name+'PromptDstarPartial'
pseudoPsi_name = name+'PromptD0D0FromDstarPartial'
# D0 -> hh' selections
self.selD2Kpi = makeD2hhAsymm(d2kpi_name,
config,
KPIDK_string = ' & (PIDK > %(HighPIDK)s)',
PiPIDK_string = ' & (PIDK < %(LowPIDK)s)',
Mass_low_string = '& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KPiMassWindowWidthLow)s* MeV)',
Mass_high_string = '& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KPiMassWindowWidthHigh)s* MeV)',
CombPIDK_string = '',
DecayDescriptor = '[D0 -> K- pi+]cc',
inputSel = [stdNoPIDsPions, stdNoPIDsKaons],
useTOS = config['UseTOSFilter'],
Hlt1TOS = config['Hlt1TOS'],
Hlt2TOS = config['Hlt2TOSKPi']
)
self.selD0KK = makeD2hhAsymm(d2kk_name,
config,
KPIDK_string = ' & (PIDK > %(LowPIDK)s)',
PiPIDK_string = '',
Mass_low_string = '& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KKMassWindowWidthLow)s* MeV)',
Mass_high_string = '& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KKMassWindowWidthHigh)s* MeV)',
CombPIDK_string = ' & (AHASCHILD( PIDK > %(HighPIDK)s ) )',
DecayDescriptor = 'D0 -> K+ K-',
inputSel = [stdNoPIDsKaons],
useTOS = config['UseTOSFilter'],
Hlt1TOS = config['Hlt1TOS'],
Hlt2TOS = config['Hlt2TOSKK']
)
self.selD0PiPi = makeD2hhAsymm(d2pipi_name,
config,
KPIDK_string = '',
PiPIDK_string = ' & (PIDK < %(LowPIDK)s)',
Mass_low_string = '& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0PiPiMassWindowWidthLow)s* MeV)',
Mass_high_string = '& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0PiPiMassWindowWidthHigh)s* MeV)',
CombPIDK_string = '',
DecayDescriptor = 'D0 -> pi+ pi-',
inputSel = [stdNoPIDsPions],
useTOS = config['UseTOSFilter'],
Hlt1TOS = config['Hlt1TOS'],
Hlt2TOS = config['Hlt2TOSPiPi']
)
self.selD2KpiSS = makeD2hhAsymm(d2kpi_name+'SS',
config,
KPIDK_string = ' & (PIDK > %(HighPIDK)s)',
PiPIDK_string = ' & (PIDK < %(LowPIDK)s)',
Mass_low_string = '& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KPiMassWindowWidthLow)s* MeV)',
Mass_high_string = '& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KPiMassWindowWidthHigh)s* MeV)',
CombPIDK_string = '',
DecayDescriptor = '[D0 -> K- pi-]cc',
inputSel = [stdNoPIDsPions, stdNoPIDsKaons],
useTOS = False,
Hlt1TOS = config['Hlt1TOS'],
Hlt2TOS = config['Hlt2TOSKPi']
)
self.selD0KKSS = makeD2hhAsymm(d2kk_name+'SS',
config,
KPIDK_string = ' & (PIDK > %(LowPIDK)s)',
PiPIDK_string = '',
Mass_low_string = '& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KKMassWindowWidthLow)s* MeV)',
Mass_high_string = '& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KKMassWindowWidthHigh)s* MeV)',
CombPIDK_string = ' & (AHASCHILD( PIDK > %(HighPIDK)s ) )',
DecayDescriptor = 'D0 -> K- K-',
inputSel = [stdNoPIDsKaons],
useTOS = False,
Hlt1TOS = config['Hlt1TOS'],
Hlt2TOS = config['Hlt2TOSKK']
)
self.selD0PiPiSS = makeD2hhAsymm(d2pipi_name+'SS',
config,
KPIDK_string = '',
PiPIDK_string = ' & (PIDK < %(LowPIDK)s)',
Mass_low_string = '& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0PiPiMassWindowWidthLow)s* MeV)',
Mass_high_string = '& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0PiPiMassWindowWidthHigh)s* MeV)',
CombPIDK_string = '',
DecayDescriptor = 'D0 -> pi- pi-',
inputSel = [stdNoPIDsPions],
useTOS = False,
Hlt1TOS = config['Hlt1TOS'],
Hlt2TOS = config['Hlt2TOSPiPi']
)
self.selD2KpiTIS = makeD2hhAsymm(d2kpi_name+'TIS',
config,
KPIDK_string = ' & (PIDK > %(HighPIDK)s)',
PiPIDK_string = ' & (PIDK < %(LowPIDK)s)',
Mass_low_string = '& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KPiMassWindowWidthLow)s* MeV)',
Mass_high_string = '& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KPiMassWindowWidthHigh)s* MeV)',
CombPIDK_string = '',
DecayDescriptor = '[D0 -> K- pi+]cc',
inputSel = [stdNoPIDsPions, stdNoPIDsKaons],
useTOS = True,
Hlt1TOS = { 'Hlt1Global%TIS' : 0 },
Hlt2TOS = { 'Hlt2Global%TIS' : 0 }
)
self.selD0KKTIS = makeD2hhAsymm(d2kk_name+'TIS',
config,
KPIDK_string = ' & (PIDK > %(LowPIDK)s)',
PiPIDK_string = '',
Mass_low_string = '& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KKMassWindowWidthLow)s* MeV)',
Mass_high_string = '& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KKMassWindowWidthHigh)s* MeV)',
CombPIDK_string = ' & (AHASCHILD( PIDK > %(HighPIDK)s ) )',
DecayDescriptor = 'D0 -> K+ K-',
inputSel = [stdNoPIDsKaons],
useTOS = True,
Hlt1TOS = { 'Hlt1Global%TIS' : 0 },
Hlt2TOS = { 'Hlt2Global%TIS' : 0 }
)
self.selD0PiPiTIS = makeD2hhAsymm(d2pipi_name+'TIS',
config,
KPIDK_string = '',
PiPIDK_string = ' & (PIDK < %(LowPIDK)s)',
Mass_low_string = '& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0PiPiMassWindowWidthLow)s* MeV)',
Mass_high_string = '& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0PiPiMassWindowWidthHigh)s* MeV)',
CombPIDK_string = '',
DecayDescriptor = 'D0 -> pi+ pi-',
inputSel = [stdNoPIDsPions],
useTOS = True,
Hlt1TOS = { 'Hlt1Global%TIS' : 0 },
Hlt2TOS = { 'Hlt2Global%TIS' : 0 }
)
from Configurables import ConjugateNeutralPID
from PhysSelPython.Wrappers import Selection
_localConj_KPi = ConjugateNeutralPID('Conjugate'+d0WS_name)
_localConj_KK = ConjugateNeutralPID('Conjugate'+d2kk_name)
_localConj_PiPi = ConjugateNeutralPID('Conjugate'+d2pipi_name)
self.selD0WS = Selection(d0WS_name, Algorithm=_localConj_KPi, RequiredSelections=[self.selD2Kpi])
self.selD0ConjKK = Selection('SelConjugate'+d2kk_name, Algorithm = _localConj_KK, RequiredSelections = [self.selD0KK])
self.selD0ConjPiPi = Selection('SelConjugate'+d2pipi_name, Algorithm = _localConj_PiPi, RequiredSelections = [self.selD0PiPi])
_localConj_KKSS = ConjugateNeutralPID('Conjugate'+d2kk_name+'SS')
_localConj_PiPiSS = ConjugateNeutralPID('Conjugate'+d2pipi_name+'SS')
self.selD0ConjKKSS = Selection('SelConjugate'+d2kk_name+'SS', Algorithm = _localConj_KKSS, RequiredSelections = [self.selD0KKSS])
self.selD0ConjPiPiSS = Selection('SelConjugate'+d2pipi_name+'SS', Algorithm = _localConj_PiPiSS, RequiredSelections = [self.selD0PiPiSS])
# Dstar -> D0 pi selections
self.selDstRS = makeDstar2D0Pi( dst2DRS_name
, config
, '[D*(2010)+ -> D0 pi+]cc'
, inputSel = [self.selD2Kpi, stdNoPIDsPions]
)
self.selDstWS = makeDstar2D0Pi( dst2DWS_name
, config
, '[D*(2010)+ -> D0 pi+]cc'
, inputSel = [self.selD0WS, stdNoPIDsPions]
)
self.selDstKK = makeDstar2D0Pi( dst2DKK_name
, config
, '[D*(2010)+ -> D0 pi+]cc'
, inputSel = [self.selD0KK, self.selD0ConjKK, stdNoPIDsPions]
)
self.selDstPiPi = makeDstar2D0Pi( dst2DPiPi_name
, config
, '[D*(2010)+ -> D0 pi+]cc'
, inputSel = [self.selD0PiPi, self.selD0ConjPiPi, stdNoPIDsPions]
)
self.selDstRSSS = makeDstar2D0Pi( dst2DRS_name+'SS'
, config
, '[D*(2010)+ -> D0 pi+]cc'
, inputSel = [self.selD2KpiSS, stdNoPIDsPions]
)
self.selDstKKSS = makeDstar2D0Pi( dst2DKK_name+'SS'
, config
, '[D*(2010)+ -> D0 pi+]cc'
, inputSel = [self.selD0KKSS, self.selD0ConjKKSS, stdNoPIDsPions]
)
self.selDstPiPiSS = makeDstar2D0Pi( dst2DPiPi_name+'SS'
, config
, '[D*(2010)+ -> D0 pi+]cc'
, inputSel = [self.selD0PiPiSS, self.selD0ConjPiPiSS, stdNoPIDsPions]
)
self.selDPartial = makeDPartial( dPartial_name
, config
, '[D- -> K- pi- pi+]cc'
, inputSel = [stdNoPIDsPions, stdNoPIDsKaons]
)
self.selDstarPartial = makeDstarPartial( dstarPartial_name
, config
, '[D*(2010)+ -> D- pi+]cc'
, inputSel = [self.selDPartial, stdNoPIDsPions]
)
self.selPseudoPsi = makePseudoPsi( pseudoPsi_name
, config
, '[psi(3770) -> D0 D*(2010)+]cc'
, inputSel = [self.selD2Kpi, self.selDstarPartial]
#, inputSel = [self.selD0PiPi, self.selD0ConjPiPi, self.selD0KK, self.selD0ConjKK, self.selD2Kpi, self.selD0WS, self.selDstarPartial]
)
# Untagged lines
self.d2kpi_line = StrippingLine(d2kpi_name+"Line",
prescale = config['UntaggedCFLinePrescale'],
postscale = config['UntaggedCFLinePostscale'],
selection = self.selD2Kpi
)
self.d2kk_line = StrippingLine(d2kk_name+"Line",
prescale = config['UntaggedSCSLinePrescale'],
postscale = config['UntaggedSCSLinePostscale'],
selection = self.selD0KK
)
self.d2pipi_line = StrippingLine(d2pipi_name+"Line",
prescale = config['UntaggedSCSLinePrescale'],
postscale = config['UntaggedSCSLinePostscale'],
selection = self.selD0PiPi
)
# Untagged TIS lines
self.d2kpiTIS_line = StrippingLine(d2kpi_name+"TISLine",
prescale = config['UntaggedTISLinePrescale'],
postscale = config['UntaggedTISLinePostscale'],
selection = self.selD2KpiTIS
)
self.d2kkTIS_line = StrippingLine(d2kk_name+"TISLine",
prescale = config['UntaggedTISLinePrescale'],
postscale = config['UntaggedTISLinePostscale'],
selection = self.selD0KKTIS
)
self.d2pipiTIS_line = StrippingLine(d2pipi_name+"TISLine",
prescale = config['UntaggedTISLinePrescale'],
postscale = config['UntaggedTISLinePostscale'],
selection = self.selD0PiPiTIS
)
# Tagged lines
self.dstRS_line = StrippingLine(dst2DRS_name+"Line",
prescale = config['TaggedRSLinePrescale'],
postscale = config['TaggedRSLinePostscale'],
selection = self.selDstRS
)
self.dstWS_line = StrippingLine(dst2DWS_name+"Line",
prescale = config['TaggedWSLinePrescale'],
postscale = config['TaggedWSLinePostscale'],
selection = self.selDstWS
)
self.dstKK_line = StrippingLine(dst2DKK_name+"Line",
prescale = config['TaggedSCSLinePrescale'],
postscale = config['TaggedSCSLinePostscale'],
selection = self.selDstKK
)
self.dstPiPi_line = StrippingLine(dst2DPiPi_name+"Line",
prescale = config['TaggedSCSLinePrescale'],
postscale = config['TaggedSCSLinePostscale'],
selection = self.selDstPiPi
)
# Tagged same sign lines
self.dstRSSS_line = StrippingLine(dst2DRS_name+"SSLine",
prescale = config['TaggedRSLinePrescale'],
postscale = config['TaggedRSLinePostscale'],
selection = self.selDstRSSS
)
self.dstKKSS_line = StrippingLine(dst2DKK_name+"SSLine",
prescale = config['TaggedSCSLinePrescale'],
postscale = config['TaggedSCSLinePostscale'],
selection = self.selDstKKSS
)
self.dstPiPiSS_line = StrippingLine(dst2DPiPi_name+"SSLine",
prescale = config['TaggedSCSLinePrescale'],
postscale = config['TaggedSCSLinePostscale'],
selection = self.selDstPiPiSS
)
# Pseudo Psi line
self.pseudoPsi_line = StrippingLine(pseudoPsi_name+"Line",
prescale = 1.,
postscale = 1.,
selection = self.selPseudoPsi
)
# register lines
if config['RunSameSign']:
self.registerLine(self.dstRSSS_line)
self.registerLine(self.dstKKSS_line)
self.registerLine(self.dstPiPiSS_line)
if config['RunTISLines']:
self.registerLine(self.d2kpiTIS_line)
self.registerLine(self.d2kkTIS_line)
self.registerLine(self.d2pipiTIS_line)
if config['RunDefault']:
self.registerLine(self.d2kpi_line)
if not config['UntaggedKpiOnly']:
self.registerLine(self.d2kk_line)
self.registerLine(self.d2pipi_line)
self.registerLine(self.dstRS_line)
self.registerLine(self.dstWS_line)
self.registerLine(self.dstKK_line)
self.registerLine(self.dstPiPi_line)
if config['AddPartialD']:
self.registerLine(self.pseudoPsi_line)
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
#
selPions = self._makePions(name="PionsFor" + name, config=config)
selKaons = self._makeKaons(name="KaonsFor" + name, config=config)
selMuons = self._makeMuons(name="MuonsFor" + name, config=config)
#
selTau = self._makeTau(name="TauFor" + name,
pionSel=selPions,
config=config)
selD = self._makeD(name="DFor" + name,
pionSel=selPions,
kaonSel=selKaons,
config=config)
#
selB2TauTau, selB2DD = self._makeB2XX(name=name,
tauSel=selTau,
DSel=selD,
config=config)
selB2TauMu, selB2DMu = self._makeB2XMu(name=name,
tauSel=selTau,
DSel=selD,
muonSel=selMuons,
config=config)
#
self.TauTau_TOSLine = StrippingLine(
name + "_TauTau_TOSLine",
#HLT = " HLT_PASS_RE('"+HLT_DECISIONS+"') ",
prescale=config['B2TauTau_TOSLinePrescale'],
postscale=config['B2TauTau_TOSLinePostscale'],
selection=self._makeTOS(name + "_TOSForTauTau", selB2TauTau))
self.DD_TOSLine = StrippingLine(
name + "_DD_TOSLine",
#HLT = " HLT_PASS_RE('"+HLT_DECISIONS+"') ",
prescale=config['B2DD_TOSLinePrescale'],
postscale=config['B2DD_TOSLinePostscale'],
selection=self._makeTOS(name + "_TOSForDD", selB2DD))
self.TauMu_TOSLine = StrippingLine(
name + "_TauMu_TOSLine",
#HLT = " HLT_PASS_RE('"+HLT_DECISIONS+"') ",
prescale=config['B2TauMu_TOSLinePrescale'],
postscale=config['B2TauMu_TOSLinePostscale'],
selection=self._makeTOS(name + "_TOSForTauMu", selB2TauMu))
self.DMu_TOSLine = StrippingLine(
name + "_DMu_TOSLine",
#HLT = " HLT_PASS_RE('"+HLT_DECISIONS+"') ",
prescale=config['B2DMu_TOSLinePrescale'],
postscale=config['B2DMu_TOSLinePostscale'],
selection=self._makeTOS(name + "_TOSForDMu", selB2DMu))
#
self.TauTau_TISLine = StrippingLine(
name + "_TauTau_TISLine",
#HLT = " HLT_PASS_RE('"+HLT_DECISIONS+"') ",
prescale=config['B2TauTau_TISLinePrescale'],
postscale=config['B2TauTau_TISLinePostscale'],
selection=self._makeTIS(name + "_TISForTauTau", selB2TauTau))
self.DD_TISLine = StrippingLine(
name + "_DD_TISLine",
#HLT = " HLT_PASS_RE('"+HLT_DECISIONS+"') ",
prescale=config['B2DD_TISLinePrescale'],
postscale=config['B2DD_TISLinePostscale'],
selection=self._makeTIS(name + "_TISForDD", selB2DD))
self.TauMu_TISLine = StrippingLine(
name + "_TauMu_TISLine",
#HLT = " HLT_PASS_RE('"+HLT_DECISIONS+"') ",
prescale=config['B2TauMu_TISLinePrescale'],
postscale=config['B2TauMu_TISLinePostscale'],
selection=self._makeTIS(name + "_TISForTauMu", selB2TauMu))
self.DMu_TISLine = StrippingLine(
name + "_DMu_TISLine",
#HLT = " HLT_PASS_RE('"+HLT_DECISIONS+"') ",
prescale=config['B2DMu_TISLinePrescale'],
postscale=config['B2DMu_TISLinePostscale'],
selection=self._makeTIS(name + "_TISForDMu", selB2DMu))
#
self.registerLine(self.TauTau_TOSLine)
self.registerLine(self.DD_TOSLine)
self.registerLine(self.TauMu_TOSLine)
self.registerLine(self.DMu_TOSLine)
self.registerLine(self.TauTau_TISLine)
self.registerLine(self.DD_TISLine)
self.registerLine(self.TauMu_TISLine)
self.registerLine(self.DMu_TISLine)
print "Created lines"
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
self._myname = name
# Define the cuts
_pT = '(PT>%(pT)s*GeV)' % config
#_pT = "(PT>%(pT)s*GeV) & (HASTRACK & TRCUT(0<TrIDC('isTT')))"%config
_pTlow = '(PT>%(pTlow)s*GeV)' % config
_pTvlow = '(PT>%(pTvlow)s*GeV)' % config
_pTSingMuon10 = '(PT>%(SingMuon10_pT)s*GeV)' % config
_pTSingMuon48 = '(PT>%(SingMuon48_pT)s*GeV)' % config
#Single Muon Control Lines
self.sel_Mu10 = makeFilter(self._myname + 'Mu10', StdAllLooseMuons,
"from LoKiTracks.decorators import *",
_pTSingMuon10)
self.line_Mu10 = StrippingLine(
self._myname + 'Control10Line',
prescale=config['SingMuon10_Prescale'],
postscale=config['WMu_Postscale'],
checkPV=False,
HLT="HLT_PASS('Hlt2SingleMuonHighPTDecision')",
selection=self.sel_Mu10)
self.registerLine(self.line_Mu10)
self.sel_Mu48 = makeFilter(self._myname + 'Mu48', StdAllLooseMuons,
"from LoKiTracks.decorators import *",
_pTSingMuon48)
self.line_Mu48 = StrippingLine(
self._myname + 'Control4800Line',
prescale=config['SingMuon48_Prescale'],
postscale=config['WMu_Postscale'],
checkPV=False,
HLT="HLT_PASS('Hlt2SingleMuonLowPTDecision')",
selection=self.sel_Mu48)
self.registerLine(self.line_Mu48)
# WMu signal
self.sel_WMu = makeFilter(self._myname + 'WMu', StdAllLooseMuons,
"from LoKiTracks.decorators import *", _pT)
self.line_WMu = StrippingLine(self._myname + 'Line',
prescale=config['WMu_Prescale'],
postscale=config['WMu_Postscale'],
checkPV=False,
selection=self.sel_WMu)
self.registerLine(self.line_WMu)
# WMu control
self.sel_WMuLow = makeFilter(self._myname + 'WMuLow', StdAllLooseMuons,
"from LoKiTracks.decorators import *",
_pTlow)
self.line_WMuLow = StrippingLine(self._myname + 'LowLine',
prescale=config['WMuLow_Prescale'],
postscale=config['WMu_Postscale'],
checkPV=False,
selection=self.sel_WMuLow)
self.registerLine(self.line_WMuLow)
# WMu background
self.sel_SingleTrackNoBias = makeFilter(
self._myname + 'SingleTrackNoBias', StdAllNoPIDsMuons,
"from LoKiTracks.decorators import *", _pTvlow)
self.line_SingleTrackNoBias = StrippingLine(
self._myname + 'SingleTrackNoBiasLine',
prescale=config['STNB_Prescale'],
postscale=config['WMu_Postscale'],
checkPV=False,
HLT="HLT_PASS( 'Hlt1MBNoBiasDecision' )",
selection=self.sel_SingleTrackNoBias)
self.registerLine(self.line_SingleTrackNoBias)
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._myname = name
#define cuts
#LL selection cuts
self.LLPi_FilterCut_WS = "(P > 2.*GeV) & (P < 100.*GeV) & (TRCHI2DOF<5.) & (BPVIPCHI2() > %(KSdaughterPiIPCHI2_LL)s)" % config
self.KSLL_CombCut_WS = "(ADAMASS('KS0') < 25.*MeV) & (AMINDOCA('LoKi::TrgDistanceCalculator')<1.5)"
self.KSLL_MotherCut_WS = "(ADMASS('KS0') < 20.*MeV) & (VFASPF(VCHI2/VDOF) < %(KSVertexCHI2_LL)s) & (BPVVDCHI2 > %(KSFlightCHI2_LL)s)" % config
self.D_LL_DaughterCut_WS = "(P > 2.*GeV) & (P < 100.*GeV) & (TRCHI2DOF<5.) & (BPVIPCHI2() > %(DdaughterIPCHI2_LL)s) " % config
self.D_LL_CombCut_WS = "(ADAMASS('D0') < 38.*MeV) & (ADOCACUT(1.8, 'LoKi::TrgDistanceCalculator'))"
self.D_LL_MotherCut_WS = "(ADMASS('D0') < 33.*MeV) & (VFASPF(VCHI2/VDOF) < %(DVertexCHI2_LL)s)" % config
self.B_LL_BachCut_WS = "(PT > %(BachPt_LL)s *GeV ) & (P > 2.*GeV) & (P < 100.*GeV) & (TRCHI2DOF<5.) & (BPVIPCHI2() > %(BachIPCHI2_LL)s )" % config
self.B_LL_CombCut_WS = "(ADAMASS('B+') < 505.*MeV) & (AMINDOCA('LoKi::TrgDistanceCalculator')<0.5)"
self.B_LL_MotherCut_WS = "(ADMASS('B+') < 500.*MeV) & (VFASPF(VCHI2/VDOF)<%(BVertexCHI2_LL)s) & (BPVIPCHI2() < %(BIPCHI2_LL)s) & (BPVVDCHI2 > %(BFlightCHI2_LL)s) & (BPVDIRA > %(BDIRA_LL)s)" % config
#DD selection cuts
self.DDPi_FilterCut_WS = "(ISDOWN) & (P > 2.*GeV) & (P < 100.*GeV) & (TRCHI2DOF<10.) & (BPVIPCHI2() > %(KSdaughterPiIPCHI2_DD)s) & ((-PIDK) > 0.)" % config
self.KSDD_CombCut_WS = "(ADAMASS('KS0') < 40.*MeV) & (AMINDOCA('LoKi::TrgDistanceCalculator')<22.)"
self.KSDD_MotherCut_WS = "(ADMASS('KS0') < 28.*MeV) & (VFASPF(VCHI2/VDOF) < %(KSVertexCHI2_DD)s) & (BPVVDCHI2 > %(KSFlightCHI2_DD)s)" % config
self.D_DD_DaughterCut_WS = " (P > 2.*GeV) & (P < 100.*GeV) & (TRCHI2DOF<5.) & (BPVIPCHI2() > %(DdaughterIPCHI2_DD)s)" % config
self.D_DD_CombCut_WS = "(ADAMASS('D0') < 45.*MeV) & (ADOCACUT(9.2, 'LoKi::TrgDistanceCalculator'))"
self.D_DD_MotherCut_WS = "(ADMASS('D0') < 40.*MeV) & (VFASPF(VCHI2/VDOF) < %(DVertexCHI2_DD)s)" % config
self.B_DD_BachCut_WS = "(PT > %(BachPt_DD)s *GeV) & (P > 2.*GeV) & (P < 100.*GeV) & (TRCHI2DOF<5.) & (BPVIPCHI2() > %(BachIPCHI2_DD)s)" % config
self.B_DD_CombCut_WS = "(ADAMASS('B+') < 505.*MeV) & (AMINDOCA('LoKi::TrgDistanceCalculator')<0.5)"
self.B_DD_MotherCut_WS = "(ADMASS('B+') < 500.*MeV) & (VFASPF(VCHI2/VDOF) < %(BVertexCHI2_DD)s) & (BPVIPCHI2() < %(BIPCHI2_DD)s) & (BPVVDCHI2 > %(BFlightCHI2_DD)s)& (BPVDIRA > %(BDIRA_DD)s)" % config
#Make the selections
self.LLPionFilterForBu2D0h_D02KShhAlg_WS()
self.KSLLForBu2D0h_D02KShhAlg_WS()
self.DForBu2D0h_D02KShh_KSLLAlg_WS()
self.Bu2D0h_KShh_KSLLAlg_WS()
self.DDPionFilterForBu2D0h_D02KShhAlg_WS()
self.KSDDForBu2D0h_D02KShhAlg_WS()
self.DForBu2D0h_D02KShh_KSDDAlg_WS()
self.Bu2D0h_KShh_KSDDAlg_WS()
## '''
## Define the GEC on number of long tracks, needed in order to control
## the time for the combinatorics (D in particular)
## '''
B2Dh_D2KShh_StrippingNumTracksGECLL_WS = {
'Code':
"(recSummaryTrack(LHCb.RecSummary.nLongTracks, TrLONG) < 250)",
'Preambulo': ["from LoKiTracks.decorators import *"]
}
B2Dh_D2KShh_StrippingNumTracksGECDD_WS = {
'Code':
"(recSummaryTrack(LHCb.RecSummary.nLongTracks, TrLONG) < 250)",
'Preambulo': ["from LoKiTracks.decorators import *"]
}
## B2Dh_D2KShh_StrippingNumTracksGECLL_WS = {'Code' : "RECSUMMARY ( LHCb.RecSummary.nLongTracks , -1 ) < 250"}
## B2Dh_D2KShh_StrippingNumTracksGECDD_WS = {'Code' : "RECSUMMARY ( LHCb.RecSummary.nLongTracks , -1 ) < 250"}
#Stripping lines
self.Line_LL_Bu2D0h_D02KShh_WS = StrippingLine(
self._myname + 'Bu2D0h_D02KShh_KSLL_WS',
prescale=config['PrescaleLL'],
postscale=config['PostscaleLL'],
FILTER=B2Dh_D2KShh_StrippingNumTracksGECLL_WS,
selection=self.Bu2D0h_LLSel_noPID_WS)
self.Line_DD_Bu2D0h_D02KShh_WS = StrippingLine(
self._myname + 'Bu2D0h_D02KShh_KSDD_WS',
prescale=config['PrescaleDD'],
postscale=config['PostscaleDD'],
FILTER=B2Dh_D2KShh_StrippingNumTracksGECDD_WS,
selection=self.Bu2D0h_DDSel_noPID_WS)
self.registerLine(self.Line_LL_Bu2D0h_D02KShh_WS)
self.registerLine(self.Line_DD_Bu2D0h_D02KShh_WS)
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 __init__(self, name, config):
LineBuilder.__init__(self, name, config)
_2hName = name + '2h'
_3hName = name + '3h'
self.sel2hLoose = make2hLoose('2hLooseFor' + _2hName + 'Sel',
_h_PT=config['_h_PT'],
_h_P=config['_h_P'],
_h_IPCHI2=config['_h_IPCHI2'],
_h_TRCHI2DOF=config['_h_TRCHI2DOF'],
_2hLoose_DOCA=config['_2hLoose_DOCA'])
self.sel2h = make2h('2hFor' + _2hName + 'Sel',
Sel2hLoose=self.sel2hLoose,
_2h_PTmax=config['_2h_PTmax'],
_2h_PTsum=config['_2h_PTsum'],
_2h_PVIPCHI2sum=config['_2h_PVIPCHI2sum'],
_2h_FDCHI2=config['_2h_FDCHI2'],
_2h_DIRA=config['_2h_DIRA'],
_2h_CORRMmax=config['_2h_CORRMmax'],
_2h_CORRMmin=config['_2h_CORRMmin'],
_2h_CharmVetoIPCHI2=config['_2h_CharmVetoIPCHI2'],
_2h_CharmVetoM=config['_2h_CharmVetoM'],
_2h_TRKCHIDOFmin=config['_2h_TRKCHIDOFmin'],
_2h_Mmin=config['_2h_Mmin'],
_2h_PVDOCAmin=config['_2h_PVDOCAmin'],
_2h_CHI2=config['_2h_CHI2'],
_2h_PTRANS=config['_2h_PTRANS'])
self.sel3h = make3h('3hFor' + _3hName + 'Sel',
Sel2hLoose=self.sel2hLoose,
_h_PT=config['_h_PT'],
_h_P=config['_h_P'],
_h_IPCHI2=config['_h_IPCHI2'],
_h_TRCHI2DOF=config['_h_TRCHI2DOF'],
_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_IP=config['_3h_IP'],
_3h_PT=config['_3h_PT'],
_3h_PTsum=config['_3h_PTsum'],
_3h_PVIPCHI2sum=config['_3h_PVIPCHI2sum'],
_3h_Charge=config['_3h_Charge'],
_3h_CORRMmax=config['_3h_CORRMmax'],
_3h_CORRMmin=config['_3h_CORRMmin'],
_3h_Mmin=config['_3h_Mmin'],
_3h_Mmax=config['_3h_Mmax'])
self.gECFilter = globalEventCutFilter(name + 'GlobalEventCutFilter',
MaxTrSIZE=config['MaxTrSIZE'])
self.algos2h = []
if self.gECFilter != None: self.algos2h.append(self.gECFilter)
self.algos2h.append(self.sel2h)
self.algos3h = []
if self.gECFilter != None: self.algos3h.append(self.gECFilter)
self.algos3h.append(self.sel3h)
self.line2h = StrippingLine(_2hName + 'Line',
prescale=config['2hLinePrescale'],
postscale=config['2hLinePostscale'],
algos=self.algos2h)
self.line3h = StrippingLine(_3hName + 'Line',
prescale=config['3hLinePrescale'],
postscale=config['3hLinePostscale'],
algos=self.algos3h)
self.registerLine(self.line2h)
self.registerLine(self.line3h)
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
prescaled_name = name + 'Prescaled'
self.selMuons = makeMuons('MuonsFor' + prescaled_name,
MUON_MinPT=config['MUON_MinPT'],
MUON_PIDmu=config['MUON_PIDmu'])
self.selMuonsFromB = makeMuonsFromB(
'MuonsFromBFor' + prescaled_name,
muonSel=self.selMuons,
TRACK_MINIPCHI2=config['TRACK_MINIPCHI2'])
self.selKaons = makeKaons('KaonsFor' + prescaled_name,
KAON_PIDK=config['KAON_PIDK'],
KAON_MinPT=config['KAON_MinPT'])
self.selKaonsFromB = makeKaonsFromB(
'KaonsFromBFor' + prescaled_name,
kaonSel=self.selKaons,
TRACK_MINIPCHI2=config['TRACK_MINIPCHI2'])
self.selPions = makePions('PionsFor' + prescaled_name,
PION_PIDmu=config['PION_PIDmu'],
PION_PIDK=config['PION_PIDK'],
PION_MinPT=config['PION_MinPT'])
self.selPionsFromB = makePionsFromB(
'PionsFromBFor' + prescaled_name,
pionSel=self.selPions,
TRACK_MINIPCHI2=config['TRACK_MINIPCHI2'])
self.selSlowPions = makeSlowPions('SlowPionsFor' + prescaled_name,
PION_PIDmu=config['PION_PIDmu'])
self.selRho = makeRho('RhoFor' + prescaled_name,
pionFromBSel=self.selPionsFromB,
Rho_MinPT=config['Rho_MinPT'],
Rho_MassMax=config['Rho_MassMax'],
Rho_MassMin=config['Rho_MassMin'])
self.selKstar = makeKstar('KstarFor' + prescaled_name,
pionFromBSel=self.selPionsFromB,
kaonFromBSel=self.selKaonsFromB,
Kstar_MinPT=config['Kstar_MinPT'],
Kstar_MassMax=config['Kstar_MassMax'],
Kstar_MassMin=config['Kstar_MassMin'])
self.selDplus2VMuNu = makeDplus2VMuNu(
'Dplus2VMuNuFor' + prescaled_name,
muonFromBSel=self.selMuonsFromB,
RhoSel=self.selRho,
KstarSel=self.selKstar,
PAIR_SumPTMin=config['PAIR_SumPTMin'],
D_MassMax=config['D_MassMax'],
D_DOCA=config['D_DOCA'],
D_MinP=config['D_MinP'],
Dplus_FD=config['Dplus_FD'],
D_MCORR_MIN=config['D_MCORR_MIN'],
D_MCORR_MAX=config['D_MCORR_MAX'],
D_BPVVDZ=config['D_BPVVDZ'],
D_VtxChi2=config['D_VtxChi2'])
self.selBtoDplusVMuNu = makeBtoDplusVMuNu(
'BtoDplusVMuNu' + prescaled_name,
Dplus2VMuNuSel=self.selDplus2VMuNu,
PionsFromBSel=self.selPionsFromB,
BtoD_DeltaMass_MIN=config['BtoD_DeltaMass_MIN'],
BtoD_DeltaMass_MAX=config['BtoD_DeltaMass_MAX'],
B_DIRA=config['B_DIRA'],
B_FDCHI2=config['B_FDCHI2'])
self.selD02HMuNu = makeD02HMuNu('D0HMuNuFor' + prescaled_name,
muonSel=self.selMuons,
pionSel=self.selPions,
kaonSel=self.selKaons,
PAIR_SumPTMin=config['PAIR_SumPTMin'],
D_MassMax=config['D_MassMax'],
D_DOCA=config['D_DOCA'],
D_MinP=config['D_MinP'],
D0_FD=config['D0_FD'],
D_MCORR_MIN=config['D_MCORR_MIN'],
D_MCORR_MAX=config['D_MCORR_MAX'],
D_BPVVDZ=config['D_BPVVDZ'],
D_VtxChi2=config['D_VtxChi2'])
self.selDstarD02HMuNu = makeDstarD02HMuNu(
'DstarD0HMuNuFor' + prescaled_name,
D02HMuNuSel=self.selD02HMuNu,
slowPionSel=self.selSlowPions,
Dstar_MassMin=config['Dstar_MassMin'],
Dstar_DOCA=config['Dstar_DOCA'],
Dstar_VtxChi2=config['Dstar_VtxChi2'],
Dstar_DeltaMass=config['Dstar_DeltaMass'])
self.prescaled_lineVMuNu = StrippingLine(
prescaled_name + "VMuNuLine",
prescale=config['PrescaledVLinePrescale'],
HLT=config['HLT_FILTER_VMuNu'],
selection=self.selBtoDplusVMuNu)
self.prescaled_lineHMuNu = StrippingLine(
prescaled_name + "HMuNuLine",
prescale=config['PrescaledHLinePrescale'],
HLT=config['HLT_FILTER_HMuNu'],
selection=self.selDstarD02HMuNu)
self.registerLine(self.prescaled_lineVMuNu)
self.registerLine(self.prescaled_lineHMuNu)
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
#####################################################################################################################
self.lineL0DiHadron = StrippingLine(
"L0DiHadron" + "Line",
prescale=config['PrescaleL0DiHadron'],
checkPV=False,
EnableFlavourTagging=False,
L0DU=config['DecisionL0DiHadron'],
RequiredRawEvents=config["LowMultRequiredRawEvents"])
self.registerLine(self.lineL0DiHadron)
self.lineL0DiEM = StrippingLine(
"L0DiEM" + "Line",
prescale=config['PrescaleL0DiEM'],
checkPV=False,
EnableFlavourTagging=False,
L0DU=config['DecisionL0DiEM'],
RequiredRawEvents=config["LowMultRequiredRawEvents"])
self.registerLine(self.lineL0DiEM)
self.lineL0Photon = StrippingLine(
"L0Photon" + "Line",
prescale=config['PrescaleL0Photon'],
checkPV=False,
EnableFlavourTagging=False,
L0DU=config['DecisionL0Photon'],
RequiredRawEvents=config["LowMultRequiredRawEvents"])
self.registerLine(self.lineL0Photon)
self.lineL0DiMuon = StrippingLine(
"L0DiMuon" + "Line",
prescale=config['PrescaleL0DiMuon'],
checkPV=False,
EnableFlavourTagging=False,
L0DU=config['DecisionL0DiMuon'],
RequiredRawEvents=config["LowMultRequiredRawEvents"])
self.registerLine(self.lineL0DiMuon)
self.lineL0Muon = StrippingLine(
"L0Muon" + "Line",
prescale=config['PrescaleL0Muon'],
checkPV=False,
EnableFlavourTagging=False,
L0DU=config['DecisionL0Muon'],
RequiredRawEvents=config["LowMultRequiredRawEvents"])
self.registerLine(self.lineL0Muon)
self.lineL0Electron = StrippingLine(
"L0Electron" + "Line",
prescale=config['PrescaleL0Electron'],
checkPV=False,
EnableFlavourTagging=False,
L0DU=config['DecisionL0Electron'],
RequiredRawEvents=config["LowMultRequiredRawEvents"])
self.registerLine(self.lineL0Electron)
#################################################
self.lineLowMultL2pPi = StrippingLine(
"LowMultL2pPi" + "Line",
prescale=config['PrescaleLowMultL2pPi'],
checkPV=False,
EnableFlavourTagging=False,
L0DU=None,
HLT2=config['DecisionLowMultL2pPi'],
RequiredRawEvents=config["LowMultRequiredRawEvents"])
self.registerLine(self.lineLowMultL2pPi)
self.lineLowMultD2KPi = StrippingLine(
"LowMultD2KPi" + "Line",
prescale=config['PrescaleLowMultD2KPi'],
checkPV=False,
EnableFlavourTagging=False,
L0DU=None,
HLT2=config['DecisionLowMultD2KPi'],
RequiredRawEvents=config["LowMultRequiredRawEvents"])
self.registerLine(self.lineLowMultD2KPi)
self.lineLowMultD2KPiPi = StrippingLine(
"LowMultD2KPiPi" + "Line",
prescale=config['PrescaleLowMultD2KPiPi'],
checkPV=False,
EnableFlavourTagging=False,
L0DU=None,
HLT2=config['DecisionLowMultD2KPiPi'],
RequiredRawEvents=config["LowMultRequiredRawEvents"])
self.registerLine(self.lineLowMultD2KPiPi)
self.lineLowMultD2KKPi = StrippingLine(
"LowMultD2KKPi" + "Line",
prescale=config['PrescaleLowMultD2KKPi'],
checkPV=False,
EnableFlavourTagging=False,
L0DU=None,
HLT2=config['DecisionLowMultD2KKPi'],
RequiredRawEvents=config["LowMultRequiredRawEvents"])
self.registerLine(self.lineLowMultD2KKPi)
self.lineLowMultD2K3Pi = StrippingLine(
"LowMultD2K3Pi" + "Line",
prescale=config['PrescaleLowMultD2K3Pi'],
checkPV=False,
EnableFlavourTagging=False,
L0DU=None,
HLT2=config['DecisionLowMultD2K3Pi'],
RequiredRawEvents=config["LowMultRequiredRawEvents"])
self.registerLine(self.lineLowMultD2K3Pi)
self.lineLowMultChiC2HH = StrippingLine(
"LowMultChiC2HH" + "Line",
prescale=config['PrescaleLowMultChiC2HH'],
checkPV=False,
EnableFlavourTagging=False,
L0DU=None,
HLT2=config['DecisionLowMultChiC2HH'],
RequiredRawEvents=config["LowMultRequiredRawEvents"])
self.registerLine(self.lineLowMultChiC2HH)
self.lineLowMultChiC2HHHH = StrippingLine(
"LowMultChiC2HHHH" + "Line",
prescale=config['PrescaleLowMultChiC2HHHH'],
checkPV=False,
EnableFlavourTagging=False,
L0DU=None,
HLT2=config['DecisionLowMultChiC2HHHH'],
RequiredRawEvents=config["LowMultRequiredRawEvents"])
self.registerLine(self.lineLowMultChiC2HHHH)
self.lineLowMultChiC2PP = StrippingLine(
"LowMultChiC2PP" + "Line",
prescale=config['PrescaleLowMultChiC2PP'],
checkPV=False,
EnableFlavourTagging=False,
L0DU=None,
HLT2=config['DecisionLowMultChiC2PP'],
RequiredRawEvents=config["LowMultRequiredRawEvents"])
self.registerLine(self.lineLowMultChiC2PP)
#################################################
self.lineLowMultLMR2HH = StrippingLine(
"LowMultLMR2HH" + "Line",
prescale=config['PrescaleLowMultLMR2HH'],
checkPV=False,
EnableFlavourTagging=False,
L0DU=None,
HLT2=config['DecisionLowMultLMR2HH'],
RequiredRawEvents=config["LowMultRequiredRawEvents"])
self.registerLine(self.lineLowMultLMR2HH)
self.lineLowMultLMR2HHHH = StrippingLine(
"LowMultLMR2HHHH" + "Line",
prescale=config['PrescaleLowMultLMR2HHHH'],
checkPV=False,
EnableFlavourTagging=False,
L0DU=None,
HLT2=config['DecisionLowMultLMR2HHHH'],
RequiredRawEvents=config["LowMultRequiredRawEvents"])
self.registerLine(self.lineLowMultLMR2HHHH)
#
self.lineLowMultLMR2HH_mediumPS = StrippingLine(
"LowMultLMR2HH_mediumPS" + "Line",
prescale=config['PrescaleLowMultLMR2HH_mediumPS'],
checkPV=False,
EnableFlavourTagging=False,
L0DU=None,
HLT2=config['DecisionLowMultLMR2HH_mediumPS'],
RequiredRawEvents=config["LowMultRequiredRawEvents"])
self.registerLine(self.lineLowMultLMR2HH_mediumPS)
self.lineLowMultLMR2HH_mediumPSHH = StrippingLine(
"LowMultLMR2HHHH_mediumPS" + "Line",
prescale=config['PrescaleLowMultLMR2HHHH_mediumPS'],
checkPV=False,
EnableFlavourTagging=False,
L0DU=None,
HLT2=config['DecisionLowMultLMR2HHHH_mediumPS'],
RequiredRawEvents=config["LowMultRequiredRawEvents"])
self.registerLine(self.lineLowMultLMR2HH_mediumPSHH)
#
self.lineLowMultLMR2HH_heavyPS = StrippingLine(
"LowMultLMR2HH_heavyPS" + "Line",
prescale=config['PrescaleLowMultLMR2HH_heavyPS'],
checkPV=False,
EnableFlavourTagging=False,
L0DU=None,
HLT2=config['DecisionLowMultLMR2HH_heavyPS'],
RequiredRawEvents=config["LowMultRequiredRawEvents"])
self.registerLine(self.lineLowMultLMR2HH_heavyPS)
self.lineLowMultLMR2HH_heavyPSHH = StrippingLine(
"LowMultLMR2HHHH_heavyPS" + "Line",
prescale=config['PrescaleLowMultLMR2HHHH_heavyPS'],
checkPV=False,
EnableFlavourTagging=False,
L0DU=None,
HLT2=config['DecisionLowMultLMR2HHHH_heavyPS'],
RequiredRawEvents=config["LowMultRequiredRawEvents"])
self.registerLine(self.lineLowMultLMR2HH_heavyPSHH)
#################################################
self.lineLowMultHadron_noTrFilt = StrippingLine(
"LowMultHadron_noTrFilt" + "Line",
prescale=config['PrescaleLowMultHadron_noTrFilt'],
checkPV=False,
EnableFlavourTagging=False,
L0DU=None,
HLT2=config['DecisionLowMultHadron_noTrFilt'],
RequiredRawEvents=config["LowMultRequiredRawEvents"])
self.registerLine(self.lineLowMultHadron_noTrFilt)
#################################################
self.lineLowMultDiMuon = StrippingLine(
"LowMultDiMuon" + "Line",
prescale=config['PrescaleLowMultDiMuon'],
checkPV=False,
EnableFlavourTagging=False,
L0DU=None,
HLT2=config['DecisionLowMultDiMuon'],
RequiredRawEvents=config["LowMultRequiredRawEvents"])
self.registerLine(self.lineLowMultDiMuon)
self.lineLowMultDiMuon_PS = StrippingLine(
"LowMultDiMuon_PS" + "Line",
prescale=config['PrescaleLowMultDiMuon_PS'],
checkPV=False,
EnableFlavourTagging=False,
L0DU=None,
HLT2=config['DecisionLowMultDiMuon_PS'],
RequiredRawEvents=config["LowMultRequiredRawEvents"])
self.registerLine(self.lineLowMultDiMuon_PS)
self.lineLowMultMuon = StrippingLine(
"LowMultMuon" + "Line",
prescale=config['PrescaleLowMultMuon'],
checkPV=False,
EnableFlavourTagging=False,
L0DU=None,
HLT2=config['DecisionLowMultMuon'],
RequiredRawEvents=config["LowMultRequiredRawEvents"])
self.registerLine(self.lineLowMultMuon)
#################################################
self.lineLowMultDiElectron = StrippingLine(
"LowMultDiElectron" + "Line",
prescale=config['PrescaleLowMultDiElectron'],
checkPV=False,
EnableFlavourTagging=False,
L0DU=None,
HLT2=config['DecisionLowMultDiElectron'],
RequiredRawEvents=config["LowMultRequiredRawEvents"])
self.registerLine(self.lineLowMultDiElectron)
self.lineLowMultDiElectron_noTrFilt = StrippingLine(
"LowMultDiElectron_noTrFilt" + "Line",
prescale=config['PrescaleLowMultDiElectron_noTrFilt'],
checkPV=False,
EnableFlavourTagging=False,
L0DU=None,
HLT2=config['DecisionLowMultDiElectron_noTrFilt'],
RequiredRawEvents=config["LowMultRequiredRawEvents"])
self.registerLine(self.lineLowMultDiElectron_noTrFilt)
#################################################
self.lineLowMultDiPhoton = StrippingLine(
"LowMultDiPhoton" + "Line",
prescale=config['PrescaleLowMultDiPhoton'],
checkPV=False,
EnableFlavourTagging=False,
L0DU=None,
HLT2=config['DecisionLowMultDiPhoton'],
RequiredRawEvents=config["LowMultRequiredRawEvents"])
self.registerLine(self.lineLowMultDiPhoton)
self.lineLowMultDiPhoton_HighMass = StrippingLine(
"LowMultDiPhoton_HighMass" + "Line",
prescale=config['PrescaleLowMultDiPhoton_HighMass'],
checkPV=False,
EnableFlavourTagging=False,
L0DU=None,
HLT2=config['DecisionLowMultDiPhoton_HighMass'],
RequiredRawEvents=config["LowMultRequiredRawEvents"])
self.registerLine(self.lineLowMultDiPhoton_HighMass)
self.lineLowMultPi0 = StrippingLine(
"LowMultPi0" + "Line",
prescale=config['PrescaleLowMultPi0'],
checkPV=False,
EnableFlavourTagging=False,
L0DU=None,
HLT2=config['DecisionLowMultPi0'],
RequiredRawEvents=config["LowMultRequiredRawEvents"])
self.registerLine(self.lineLowMultPi0)
#####
#####
self.lineLowMultNonBeamBeamNoBias = StrippingLine(
"LowMultNonBeamBeamNoBias" + "Line",
prescale=config['PrescaleLowMultNonBeamBeamNoBias'],
checkPV=False,
EnableFlavourTagging=False,
L0DU=None,
HLT2=config['DecisionLowMultNonBeamBeamNoBias'],
RequiredRawEvents=config["LowMultRequiredRawEvents"])
self.registerLine(self.lineLowMultNonBeamBeamNoBias)
self.lineLowMultTechnical = StrippingLine(
"LowMultTechnical" + "Line",
prescale=config['PrescaleLowMultTechnical'],
checkPV=False,
EnableFlavourTagging=False,
L0DU=None,
HLT2=config['DecisionLowMultTechnical'],
RequiredRawEvents=config["LowMultRequiredRawEvents"])
self.registerLine(self.lineLowMultTechnical)
#####
self.lineHlt1NoBiasNonBeamBeam = StrippingLine(
"Hlt1NoBiasNonBeamBeam" + "Line",
prescale=config['PrescaleHlt1NoBiasNonBeamBeam'],
checkPV=False,
EnableFlavourTagging=False,
L0DU=None,
HLT1=config['DecisionHlt1NoBiasNonBeamBeam'],
RequiredRawEvents=config["LowMultRequiredRawEvents"])
self.registerLine(self.lineHlt1NoBiasNonBeamBeam)
self.lineHlt2PassThrough = StrippingLine(
"Hlt2PassThrough" + "Line",
prescale=config['PrescaleHlt2PassThrough'],
checkPV=False,
EnableFlavourTagging=False,
L0DU=None,
HLT2=config['DecisionHlt2PassThrough'],
RequiredRawEvents=config["LowMultRequiredRawEvents"])
self.registerLine(self.lineHlt2PassThrough)
#####
self.lineLowMultTMP1 = StrippingLine(
"LowMultTMP1" + "Line",
prescale=config['PrescaleLowMultTMP1'],
checkPV=False,
EnableFlavourTagging=False,
L0DU=None,
HLT2=config['DecisionLowMultTMP1'],
RequiredRawEvents=config["LowMultRequiredRawEvents"])
self.registerLine(self.lineLowMultTMP1)
self.lineLowMultTMP2 = StrippingLine(
"LowMultTMP2" + "Line",
prescale=config['PrescaleLowMultTMP2'],
checkPV=False,
EnableFlavourTagging=False,
L0DU=None,
HLT2=config['DecisionLowMultTMP2'],
RequiredRawEvents=config["LowMultRequiredRawEvents"])
self.registerLine(self.lineLowMultTMP2)
####################################################################################################
self.lineLowMultBXTYPE = StrippingLine(
"LowMultBXTYPE" + "Line",
prescale=config['PrescaleLowMultBXTYPE'],
checkPV=False,
EnableFlavourTagging=False,
ODIN="( ODIN_BXTYP == LHCb.ODIN.NoBeam)",
L0DU=None,
HLT2=None,
RequiredRawEvents=config["LowMultRequiredRawEvents"])
self.registerLine(self.lineLowMultBXTYPE)
def __init__(self, name, config ):
LineBuilder.__init__(self, name, config)
self.name = name
self.config = config
"""
Di letpons
"""
from StandardParticles import StdDiElectronFromTracks, StdLooseDiMuon
self.SelDiElectron = self.createSubSel( OutputList = self.name + "SelDiElectron",
InputList = StdDiElectronFromTracks ,
Cuts = config['DiElectronCuts']
)
self.SelDiMuon = self.createSubSel( OutputList = self.name + "SelDiMuon",
InputList = StdLooseDiMuon ,
Cuts = config['DiMuonCuts']
)
"""
Basic particles, long tracks
"""
from StandardParticles import StdLooseANNPions, StdLooseANNKaons, StdLooseANNProtons
self.SelPions = self.createSubSel( OutputList = self.name + "SelPions",
InputList = StdLooseANNPions ,
Cuts = config['PionCuts']
)
self.SelKaons = self.createSubSel( OutputList = self.name + "SelKaons",
InputList = StdLooseANNKaons,
Cuts = config['KaonCuts']
)
self.SelProtons = self.createSubSel( OutputList = self.name + "SelProtons",
InputList = StdLooseANNProtons,
Cuts = config['ProtonCuts']
)
from StandardParticles import StdAllLooseANNPions
self.SelPions4LP = self.createSubSel( OutputList = self.name + "SelPions4LP",
InputList = StdAllLooseANNPions ,
Cuts = config['Pion4LPCuts']
)
"""
Kstar
"""
from StandardParticles import StdVeryLooseDetachedKst2Kpi
self.SelKstar = self.createSubSel( OutputList = self.name + "SelKstar",
InputList = StdVeryLooseDetachedKst2Kpi,
Cuts = config['KstarCuts']
)
"""
Kshort, both LL and DD
"""
from StandardParticles import StdLooseKsDD, StdLooseKsLL
self.SelKsDD = self.createSubSel( OutputList = self.name + "SelKsDD",
InputList = StdLooseKsDD,
Cuts = config['KsDDCuts'] )
"""
self.SelKsLL = self.createSubSel( OutputList = self.name + "SelKsLL",
InputList = StdLooseKsLL,
Cuts = config['KsLLCuts'] )
"""
self.SelKsLL = self.createCombinationSel( OutputList = self.name + "SelKsLL",
DecayDescriptor = "KS0 -> pi+ pi-",
DaughterLists = [ self.SelPions4LP ],
PreVertexCuts = config['KsLLComCuts'],
PostVertexCuts = config['KsLLCuts'] )
self.SelKs = MergedSelection( self.name + "SelKs",
RequiredSelections = [ self.SelKsDD,
self.SelKsLL ] )
"""
Phi
"""
from StandardParticles import StdLoosePhi2KK
self.SelPhi = self.createSubSel( OutputList = self.name + "SelPhi",
InputList = StdLoosePhi2KK,
Cuts = config['PhiCuts']
)
"""
Lambda, both LL and DD
"""
from StandardParticles import StdLooseLambdaDD, StdLooseLambdaLL
self.SelLambdaDD = self.createSubSel( OutputList = self.name + "SelLambdaDD",
InputList = StdLooseLambdaDD,
Cuts = config['LambdaDDCuts'] )
self.SelLambdaLL = self.createCombinationSel( OutputList = self.name + "SelLambdaLL",
DecayDescriptor = "[Lambda0 -> p+ pi-]cc",
DaughterLists = [ self.SelProtons, self.SelPions4LP ],
PreVertexCuts = config['LambdaLLComCuts'],
PostVertexCuts = config['LambdaLLCuts'] )
self.SelLambda = MergedSelection( self.name + "SelLambda",
RequiredSelections = [ self.SelLambdaDD,
self.SelLambdaLL ] )
"""
Lambda* -> p K
"""
self.SelLambdastar = self.createCombinationSel( OutputList = self.name + "SelLambdastar",
DecayDescriptor = "[Lambda(1520)0 -> p+ K-]cc",
DaughterLists = [ self.SelProtons, self.SelKaons ],
PreVertexCuts = config['LambdastarComCuts'],
PostVertexCuts = config['LambdastarCuts'] )
#
# Stripping lines here
#
self.B2LLHVars = {
"sqrt(L1_IPCHI2_OWNPV)" : "sqrt(CHILD(MIPCHI2DV(), 1, 1))",
"sqrt(L2_IPCHI2_OWNPV)" : "sqrt(CHILD(MIPCHI2DV(), 1, 2))",
"sqrt(Jpsi_IPCHI2_OWNPV}" : "sqrt(CHILD(MIPCHI2DV(), 1 ))",
"sqrt(H_IPCHI2_OWNPV}" : "sqrt(CHILD(MIPCHI2DV(), 2 ))",
"sqrt(B_IPCHI2_OWNPV)" : "sqrt(BPVIPCHI2())" ,
"log(L1_PT)" : "log(CHILD(PT, 1, 1))",
"log(L2_PT)" : "log(CHILD(PT, 1, 2))",
"log(Jpsi_PT)" : "log(CHILD(PT, 1))",
"log(H_PT)" : "log(CHILD(PT, 2))",
"log(B_PT)" : "log(PT)",
"sqrt(Jpsi_FDCHI2_OWNPV)" : "sqrt(CHILD(BPVVDCHI2,1))",
"sqrt(B_FDCHI2_OWNPV)" : "sqrt(BPVVDCHI2)" ,
"B_DIRA_OWNPV" : "BPVDIRA"
}
"""
Bu2eeK
"""
self.SelBu2eeK = self.createCombinationSel( OutputList = self.name + "SelBu2eeK",
DecayDescriptor = "[B+ -> J/psi(1S) K+]cc",
DaughterLists = [ self.SelDiElectron, self.SelKaons ],
PreVertexCuts = config['BComCuts'],
PostVertexCuts = config['BMomCuts'] )
self.MvaBu2eeK = self.applyMVA( self.name + "MvaBu2eeK",
SelB = self.SelBu2eeK,
MVAVars = self.B2LLHVars,
MVACutValue = config['Bu2eeKMVACut'],
MVAxmlFile = config['Bu2LLKXmlFile']
)
self.Bu2eeKLine = StrippingLine( self.name + '_Bu2eeKLine',
RelatedInfoTools = config['RelatedInfoTools'],
algos = [ self.MvaBu2eeK ],
MDSTFlag = True
)
self.registerLine( self.Bu2eeKLine )
"""
Bu2mumuK
"""
self.SelBu2mumuK = self.createCombinationSel( OutputList = self.name + "SelBu2mumuK",
DecayDescriptor = "[B+ -> J/psi(1S) K+]cc",
DaughterLists = [ self.SelDiMuon, self.SelKaons ],
PreVertexCuts = config['BComCuts'],
PostVertexCuts = config['BMomCuts'] )
self.MvaBu2mumuK = self.applyMVA( self.name + "MvaBu2mumuK",
SelB = self.SelBu2mumuK,
MVAVars = self.B2LLHVars,
MVACutValue = config['Bu2mumuKMVACut'],
MVAxmlFile = config['Bu2LLKXmlFile']
)
self.Bu2mumuKLine = StrippingLine( self.name + '_Bu2mumuKLine',
RelatedInfoTools = config['RelatedInfoTools'],
algos = [ self.MvaBu2mumuK ],
MDSTFlag = True
)
self.registerLine( self.Bu2mumuKLine )
#
# Bd2LLKstar
#
"""
B2LLXVars
"""
self.B2LLXVars = {
"sqrt(L1_IPCHI2_OWNPV)" : "sqrt(CHILD(MIPCHI2DV(), 1, 1))",
"sqrt(L2_IPCHI2_OWNPV)" : "sqrt(CHILD(MIPCHI2DV(), 1, 2))",
"sqrt(Jpsi_IPCHI2_OWNPV}" : "sqrt(CHILD(MIPCHI2DV(), 1 ))",
"sqrt(H1_IPCHI2_OWNPV)" : "sqrt(CHILD(MIPCHI2DV(), 2, 1))",
"sqrt(H2_IPCHI2_OWNPV)" : "sqrt(CHILD(MIPCHI2DV(), 2, 2))",
"sqrt(X_IPCHI2_OWNPV}" : "sqrt(CHILD(MIPCHI2DV(), 2 ))",
"sqrt(B_IPCHI2_OWNPV)" : "sqrt(BPVIPCHI2())" ,
"log(L1_PT)" : "log(CHILD(PT, 1, 1))",
"log(L2_PT)" : "log(CHILD(PT, 1, 2))",
"log(Jpsi_PT)" : "log(CHILD(PT, 1))",
"log(H1_PT)" : "log(CHILD(PT, 2, 1))",
"log(H2_PT)" : "log(CHILD(PT, 2, 2))",
"log(X_PT)" : "log(CHILD(PT, 2))",
"log(B_PT)" : "log(PT)",
"sqrt(Jpsi_FDCHI2_OWNPV)" : "sqrt(CHILD(BPVVDCHI2,1))",
"sqrt(X_FDCHI2_OWNPV)" : "sqrt(CHILD(BPVVDCHI2,2))",
"sqrt(B_FDCHI2_OWNPV)" : "sqrt(BPVVDCHI2)" ,
"B_DIRA_OWNPV" : "BPVDIRA"
}
"""
Bd2eeKstar
"""
self.SelBd2eeKstar = self.createCombinationSel( OutputList = self.name + "SelBd2eeKstar",
DecayDescriptor = "[B0 -> J/psi(1S) K*(892)0]cc",
DaughterLists = [ self.SelDiElectron, self.SelKstar ],
PreVertexCuts = config['BComCuts'],
PostVertexCuts = config['BMomCuts'] )
self.MvaBd2eeKstar = self.applyMVA( self.name + "MvaBd2eeKstar",
SelB = self.SelBd2eeKstar,
MVAVars = self.B2LLXVars,
MVACutValue = config['Bd2eeKstarMVACut'],
MVAxmlFile = config['Bd2LLKstarXmlFile']
)
self.Bd2eeKstarLine = StrippingLine( self.name + '_Bd2eeKstarLine',
RelatedInfoTools = config['RelatedInfoTools'],
algos = [ self.MvaBd2eeKstar ],
MDSTFlag = True
)
self.registerLine( self.Bd2eeKstarLine )
"""
Bd2mumuKstar
"""
self.SelBd2mumuKstar = self.createCombinationSel( OutputList = self.name + "SelBd2mumuKstar",
DecayDescriptor = "[B0 -> J/psi(1S) K*(892)0]cc",
DaughterLists = [ self.SelDiMuon, self.SelKstar ],
PreVertexCuts = config['BComCuts'],
PostVertexCuts = config['BMomCuts'] )
self.MvaBd2mumuKstar = self.applyMVA( self.name + "MvaBd2mumuKstar",
SelB = self.SelBd2mumuKstar,
MVAVars = self.B2LLXVars,
MVACutValue = config['Bd2mumuKstarMVACut'],
MVAxmlFile = config['Bd2LLKstarXmlFile']
)
self.Bd2mumuKstarLine = StrippingLine( self.name + '_Bd2mumuKstarLine',
RelatedInfoTools = config['RelatedInfoTools'],
algos = [ self.MvaBd2mumuKstar ],
MDSTFlag = True
)
self.registerLine( self.Bd2mumuKstarLine )
"""
Bd2eeKs
"""
self.SelBd2eeKs = self.createCombinationSel( OutputList = self.name + "SelBd2eeKs",
DecayDescriptor = "B0 -> J/psi(1S) KS0",
DaughterLists = [ self.SelDiElectron, self.SelKs ],
PreVertexCuts = config['BComCuts'],
PostVertexCuts = config['BMomCuts'] )
self.MvaBd2eeKs = self.applyMVA( self.name + "MvaBd2eeKs",
SelB = self.SelBd2eeKs,
MVAVars = self.B2LLXVars,
MVACutValue = config['Bd2eeKsMVACut'],
MVAxmlFile = config['Bd2LLKsXmlFile']
)
self.Bd2eeKsLine = StrippingLine( self.name + '_Bd2eeKsLine',
RelatedInfoTools = config['RelatedInfoTools'],
algos = [ self.MvaBd2eeKs ],
MDSTFlag = True
)
self.registerLine( self.Bd2eeKsLine )
"""
Bd2mumuKs
"""
self.SelBd2mumuKs = self.createCombinationSel( OutputList = self.name + "SelBd2mumuKs",
DecayDescriptor = "B0 -> J/psi(1S) KS0",
DaughterLists = [ self.SelDiMuon, self.SelKs ],
PreVertexCuts = config['BComCuts'],
PostVertexCuts = config['BMomCuts'] )
self.MvaBd2mumuKs = self.applyMVA( self.name + "MvaBd2mumuKs",
SelB = self.SelBd2mumuKs,
MVAVars = self.B2LLXVars,
MVACutValue = config['Bd2mumuKsMVACut'],
MVAxmlFile = config['Bd2LLKsXmlFile']
)
self.Bd2mumuKsLine = StrippingLine( self.name + '_Bd2mumuKsLine',
RelatedInfoTools = config['RelatedInfoTools'],
algos = [ self.MvaBd2mumuKs ],
MDSTFlag = True
)
self.registerLine( self.Bd2mumuKsLine )
"""
Bs2eePhi
"""
self.SelBs2eePhi = self.createCombinationSel( OutputList = self.name + "SelBs2eePhi",
DecayDescriptor = "B_s0 -> J/psi(1S) phi(1020)",
DaughterLists = [ self.SelDiElectron, self.SelPhi ],
PreVertexCuts = config['BComCuts'],
PostVertexCuts = config['BMomCuts'] )
self.MvaBs2eePhi = self.applyMVA( self.name + "MvaBs2eePhi",
SelB = self.SelBs2eePhi,
MVAVars = self.B2LLXVars,
MVACutValue = config['Bs2eePhiMVACut'],
MVAxmlFile = config['Bs2LLPhiXmlFile']
)
self.Bs2eePhiLine = StrippingLine( self.name + '_Bs2eePhiLine',
RelatedInfoTools = config['RelatedInfoTools'],
algos = [ self.MvaBs2eePhi ],
MDSTFlag = True
)
self.registerLine( self.Bs2eePhiLine )
"""
Bs2mumuPhi
"""
self.SelBs2mumuPhi = self.createCombinationSel( OutputList = self.name + "SelBs2mumuPhi",
DecayDescriptor = "B_s0 -> J/psi(1S) phi(1020)",
DaughterLists = [ self.SelDiMuon, self.SelPhi ],
PreVertexCuts = config['BComCuts'],
PostVertexCuts = config['BMomCuts'] )
self.MvaBs2mumuPhi = self.applyMVA( self.name + "MvaBs2mumuPhi",
SelB = self.SelBs2mumuPhi,
MVAVars = self.B2LLXVars,
MVACutValue = config['Bs2mumuPhiMVACut'],
MVAxmlFile = config['Bs2LLPhiXmlFile']
)
self.Bs2mumuPhiLine = StrippingLine( self.name + '_Bs2mumuPhiLine',
RelatedInfoTools = config['RelatedInfoTools'],
algos = [ self.MvaBs2mumuPhi ],
MDSTFlag = True
)
self.registerLine( self.Bs2mumuPhiLine )
"""
Lb2eeLambda
"""
self.SelLb2eeLambda = self.createCombinationSel( OutputList = self.name + "SelLb2eeLambda",
DecayDescriptor = "[Lambda_b0 -> J/psi(1S) Lambda0]cc",
DaughterLists = [ self.SelDiElectron, self.SelLambda ],
PreVertexCuts = config['LbComCuts'],
PostVertexCuts = config['LbMomCuts'] )
self.MvaLb2eeLambda = self.applyMVA( self.name + "MvaLb2eeLambda",
SelB = self.SelLb2eeLambda,
MVAVars = self.B2LLXVars,
MVACutValue = config['Lb2eeLambdaMVACut'],
MVAxmlFile = config['Lb2LLLambdaXmlFile']
)
self.Lb2eeLambdaLine = StrippingLine( self.name + '_Lb2eeLambdaLine',
RelatedInfoTools = config['RelatedInfoTools'],
algos = [ self.MvaLb2eeLambda ],
MDSTFlag = True
)
self.registerLine( self.Lb2eeLambdaLine )
"""
Lb2mumuLambda
"""
self.SelLb2mumuLambda = self.createCombinationSel( OutputList = self.name + "SelLb2mumuLambda",
DecayDescriptor = "[Lambda_b0 -> J/psi(1S) Lambda0]cc",
DaughterLists = [ self.SelDiMuon, self.SelLambda ],
PreVertexCuts = config['LbComCuts'],
PostVertexCuts = config['LbMomCuts'] )
self.MvaLb2mumuLambda = self.applyMVA( self.name + "MvaLb2mumuLambda",
SelB = self.SelLb2mumuLambda,
MVAVars = self.B2LLXVars,
MVACutValue = config['Lb2mumuLambdaMVACut'],
MVAxmlFile = config['Lb2LLLambdaXmlFile']
)
self.Lb2mumuLambdaLine = StrippingLine( self.name + '_Lb2mumuLambdaLine',
RelatedInfoTools = config['RelatedInfoTools'],
algos = [ self.MvaLb2mumuLambda ],
MDSTFlag = True
)
self.registerLine( self.Lb2mumuLambdaLine )
#
# Lb-> LL Kstar
#
"""
Lb2eePK
"""
self.SelLb2eePK = self.createCombinationSel( OutputList = self.name + "SelLb2eePK",
DecayDescriptor = "[Lambda_b0 -> J/psi(1S) Lambda(1520)0]cc",
DaughterLists = [ self.SelDiElectron, self.SelLambdastar ],
PreVertexCuts = config['LbComCuts'],
PostVertexCuts = config['LbMomCuts'] )
self.MvaLb2eePK = self.applyMVA( self.name + "MvaLb2eePK",
SelB = self.SelLb2eePK,
MVAVars = self.B2LLXVars,
MVACutValue = config['Lb2eePKMVACut'],
MVAxmlFile = config['Lb2LLPKXmlFile']
)
self.Lb2eePKLine = StrippingLine( self.name + '_Lb2eePKLine',
RelatedInfoTools = config['RelatedInfoTools'],
algos = [ self.MvaLb2eePK ],
MDSTFlag = True
)
self.registerLine( self.Lb2eePKLine )
"""
Lb2mumuPK
"""
self.SelLb2mumuPK = self.createCombinationSel( OutputList = self.name + "SelLb2mumuPK",
DecayDescriptor = "[Lambda_b0 -> J/psi(1S) Lambda(1520)0]cc",
DaughterLists = [ self.SelDiMuon, self.SelLambdastar ],
PreVertexCuts = config['LbComCuts'],
PostVertexCuts = config['LbMomCuts'] )
self.MvaLb2mumuPK = self.applyMVA( self.name + "MvaLb2mumuPK",
SelB = self.SelLb2mumuPK,
MVAVars = self.B2LLXVars,
MVACutValue = config['Lb2mumuPKMVACut'],
MVAxmlFile = config['Lb2LLPKXmlFile']
)
self.Lb2mumuPKLine = StrippingLine( self.name + '_Lb2mumuPKLine',
RelatedInfoTools = config['RelatedInfoTools'],
algos = [ self.MvaLb2mumuPK ],
MDSTFlag = True
)
self.registerLine( self.Lb2mumuPKLine )
