def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
self.__confdict__ = config
self.GECs = {
"Code":
"( recSummaryTrack(LHCb.RecSummary.nLongTracks, TrLONG) < %(GEC_nLongTrk)s )"
% config,
"Preambulo": ["from LoKiTracks.decorators import *"]
}
#== selection of standard particles
self.Kaon1Cuts = "(TRCHI2DOF < 3) & (TRGHOSTPROB < 0.5) & (PT > %(K1PT)s *MeV) &"\
"(MIPCHI2DV(PRIMARY) < %(K1MinIPChi2)s) & "\
"(PIDK-PIDpi > %(K1PIDK)s) & (PIDK-PIDp > 0) & (PIDK-PIDmu > 0)" %config
self.Kaon1CutsLoose = "(TRCHI2DOF < 3) & (TRGHOSTPROB < 0.5) & (PT > %(K1PTLoose)s *MeV) &"\
"(MIPCHI2DV(PRIMARY) < %(K1MinIPChi2)s) & "\
"(PIDK-PIDpi > %(K1PIDK)s) & (PIDK-PIDp > 0) & (PIDK-PIDmu > 0)" %config
self.Kaon2Cuts = "(TRCHI2DOF < 3) & (TRGHOSTPROB < 0.5) & "\
"(P > %(K2P)s *MeV) & (PT > %(K2PT)s *MeV) & "\
"(MIPCHI2DV(PRIMARY) > %(K2MinIPChi2)s) & "\
"(PIDK-PIDpi > %(K2PIDK)s) & (PIDK-PIDp > 0) & (PIDK-PIDmu > 0)" %config
self.MuonCuts = "(TRCHI2DOF < 3) & (TRGHOSTPROB < 0.5) & "\
"(P > %(MuP)s *MeV) & (PT > %(MuPT)s *MeV) & "\
"(MIPCHI2DV(PRIMARY) > %(MuMinIPChi2)s) & "\
"(PIDmu-PIDK > 0) & (PIDmu-PIDp > 0) & (PIDmu-PIDpi > %(MuPIDmu)s)" %config
self.JpsiCuts = "(PFUNA(ADAMASS('J/psi(1S)')) < %(JpsiMassWindow)s * MeV)" % config
self.SelKaon1 = Selection("K1_for" + name,
Algorithm=FilterDesktop(Code=self.Kaon1Cuts),
RequiredSelections=[StdAllLooseKaons])
self.SelKaon1Loose = Selection(
"K1Loose_for" + name,
Algorithm=FilterDesktop(Code=self.Kaon1CutsLoose),
RequiredSelections=[StdAllLooseKaons])
self.SelKaon2 = Selection("K2_for" + name,
Algorithm=FilterDesktop(Code=self.Kaon2Cuts),
RequiredSelections=[StdLooseKaons])
self.SelMuon = Selection("Mu_for" + name,
Algorithm=FilterDesktop(Code=self.MuonCuts),
RequiredSelections=[StdLooseMuons])
self.SelJpsi = Selection(
"Jpsi_for" + name,
Algorithm=FilterDesktop(Code=self.JpsiCuts),
RequiredSelections=[StdMassConstrainedJpsi2MuMu])
# B -> K Mu X, both opposite & same signed K mu can be signals
self.Bu2KMu = CombineParticles(
DecayDescriptors=["[B+ -> K+ mu-]cc", "[B+ -> K+ mu+]cc"])
self.Bu2KMu.CombinationCut = "(AM > %(KMuMassMin)s*MeV) & (AM < %(KMuMassMax)s*MeV)" % config
self.Bu2KMu.MotherCut = "(VFASPF(VCHI2/VDOF) < %(KMuVChi2Dof)s) & (BPVDIRA > 0.99) & "\
"(BPVVDCHI2 > %(KMuFdChi2)s)" % config
self.Bu2KMu.ReFitPVs = True
self.SelBu2KMu = Selection(
"Bu2KMu_for" + name,
Algorithm=self.Bu2KMu,
RequiredSelections=[self.SelKaon2, self.SelMuon])
# B -> K J/psi
self.Bu2KJpsi = CombineParticles(
DecayDescriptors=["[B+ -> J/psi(1S) K+]cc"])
self.Bu2KJpsi.CombinationCut = "(AM > %(KJpsiMassMin)s*MeV) & (AM < %(KJpsiMassMax)s*MeV)" % config
self.Bu2KJpsi.MotherCut = "(VFASPF(VCHI2/VDOF) < %(KJpsiVChi2Dof)s) & (BPVDIRA > 0.99) & "\
"(BPVVDCHI2 > %(KJpsiFdChi2)s)" % config
self.Bu2KJpsi.ReFitPVs = True
self.SelBu2KJpsi = Selection(
"Bu2KJpsi_for" + name,
Algorithm=self.Bu2KJpsi,
RequiredSelections=[self.SelKaon2, self.SelJpsi])
# B_s2*0 -> (B -> K Mu X) K, signal KK have opposite signed charge.
self.Bs2KKMu = CombineParticles(DecayDescriptor="[B*_s20 -> B+ K-]cc")
self.Bs2KKMu.CombinationCut = "(AM-AM1 < %(DMKKMu)s*MeV) & "\
"(abs(ACHILD(BPV(VZ),1)-ACHILD(BPV(VZ),2))<%(DZBPV)s*mm)" % config
self.Bs2KKMu.MotherCut = "(PT > %(Bs2PT)s*MeV)" % config
self.Bs2KKMu.ReFitPVs = False
self.SelBs2KKMu = Selection(
"Bs2KKMu_for" + name,
Algorithm=self.Bs2KKMu,
RequiredSelections=[self.SelBu2KMu, self.SelKaon1])
# B_s2*0 -> (B -> K Mu X) K, same signed KK for back ground
self.Bs2KKMuWS = CombineParticles(
DecayDescriptor="[B*_s20 -> B+ K+]cc")
self.Bs2KKMuWS.CombinationCut = self.Bs2KKMu.CombinationCut
self.Bs2KKMuWS.MotherCut = self.Bs2KKMu.MotherCut
self.Bs2KKMuWS.ReFitPVs = self.Bs2KKMu.ReFitPVs
self.SelBs2KKMuWS = Selection(
"Bs2KKMuWS_for" + name,
Algorithm=self.Bs2KKMuWS,
RequiredSelections=[self.SelBu2KMu, self.SelKaon1])
# B_s2*0 -> (B -> K Jpsi) K, signal KK have opposite signed charge.
self.Bs2KKJpsi = CombineParticles(
DecayDescriptor="[B*_s20 -> B+ K-]cc")
self.Bs2KKJpsi.CombinationCut = "(AM-AM1 < %(DMKKJpsi)s*MeV) & "\
"(abs(ACHILD(BPV(VZ),1)-ACHILD(BPV(VZ),2))<%(DZBPV)s*mm)" % config
self.Bs2KKJpsi.MotherCut = "(PT > %(Bs2PT)s*MeV)" % config
self.Bs2KKJpsi.ReFitPVs = False
self.SelBs2KKJpsi = Selection(
"Bs2KKJpsi_for" + name,
Algorithm=self.Bs2KKJpsi,
RequiredSelections=[self.SelBu2KJpsi, self.SelKaon1Loose])
# B_s2*0 -> (B -> K Jpsi) K, same signed KK for back ground
self.Bs2KKJpsiWS = CombineParticles(
DecayDescriptor="[B*_s20 -> B+ K+]cc")
self.Bs2KKJpsiWS.CombinationCut = self.Bs2KKJpsi.CombinationCut
self.Bs2KKJpsiWS.MotherCut = self.Bs2KKJpsi.MotherCut
self.Bs2KKJpsiWS.ReFitPVs = self.Bs2KKJpsi.ReFitPVs
self.SelBs2KKJpsiWS = Selection(
"Bs2KKJpsiWS_for" + name,
Algorithm=self.Bs2KKJpsiWS,
RequiredSelections=[self.SelBu2KJpsi, self.SelKaon1Loose])
# register stripping lines
self.Bs2st2KKMuLine = StrippingLine(
"Bs2st2KKMuLine",
prescale=config['Bs2st2KKMuPrescale'],
FILTER=self.GECs,
RelatedInfoTools=config['RelatedInfoTools'],
selection=self.SelBs2KKMu
#, MDSTFlag = True
)
self.Bs2st2KKMuWSLine = StrippingLine(
"Bs2st2KKMuWSLine",
prescale=config['Bs2st2KKMuWSPrescale'],
FILTER=self.GECs,
RelatedInfoTools=self.Bs2st2KKMuLine.RelatedInfoTools,
selection=self.SelBs2KKMuWS
#, MDSTFlag = True
)
self.Bs2st2KKJpsiLine = StrippingLine(
"Bs2st2KKJpsiLine",
prescale=config['Bs2st2KKMuPrescale'],
FILTER=self.GECs,
selection=self.SelBs2KKJpsi
#, MDSTFlag = True
)
self.Bs2st2KKJpsiWSLine = StrippingLine(
"Bs2st2KKJpsiWSLine",
prescale=config['Bs2st2KKJpsiWSPrescale'],
FILTER=self.GECs,
selection=self.SelBs2KKJpsiWS
#, MDSTFlag = True
)
# register stripping lines
self.registerLine(self.Bs2st2KKMuLine)
self.registerLine(self.Bs2st2KKMuWSLine)
self.registerLine(self.Bs2st2KKJpsiLine)
self.registerLine(self.Bs2st2KKJpsiWSLine)
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
self.SelMuMu = self.MuMu(name + "MuMu",
massMin=config['MuMuMassMin'],
massMax=config['MuMuMassMax'],
trackChi2=config['trackChi2'],
vertexChi2=config['vertexChi2'])
self.SelMuMuHigh = self.MuMu(name + "MuMuHigh",
massMin=config['MuMuMassHighMin'],
massMax=config['MuMuMassHighMax'],
trackChi2=config['trackChi2'],
vertexChi2=config['vertexChi2'])
self.SelJPsi = self.MuMu(name + "JPsi",
massMin=config['JPsiMassMin'],
massMax=config['JPsiMassMax'],
trackChi2=config['trackChi2'],
vertexChi2=config['vertexChi2'])
self.SelMuMuNB = self.MuMuNB(name + "MuMuNB",
self.SelMuMu,
Expertise=config['ExpertiseMuMu'],
NBVersion=config['NBVersionMuMu'],
NBCut=config['NBCutMuMu'],
massMin=config['MuMuMassMin'],
massMax=config['MuMuMassMax'],
nBins=120,
doPlot=False)
self.SelMuMuHighNB = self.MuMuNB(name + "MuMuHighNB",
self.SelMuMuHigh,
Expertise=config['ExpertiseMuMuHigh'],
NBVersion=config['NBVersionMuMuHigh'],
NBCut=config['NBCutMuMuHigh'],
massMin=config['MuMuMassHighMin'],
massMax=config['MuMuMassHighMax'],
nBins=120,
doPlot=False)
self.SelJPsiNB = self.MuMuNB(name + "JPsiNB",
self.SelJPsi,
Expertise=config['ExpertiseJPsi'],
NBVersion=config['NBVersionJPsi'],
NBCut=config['NBCutJPsi'],
massMin=config['JPsiMassMin'],
massMax=config['JPsiMassMax'],
nBins=120,
doPlot=False)
self.mumuLine = StrippingLine(name + "MuMuNBLine",
prescale=config['PrescaleMuMu'],
postscale=config['PostscaleMuMu'],
selection=self.SelMuMuNB)
self.mumuHighLine = StrippingLine(
name + "MuMuHighNBLine",
prescale=config['PrescaleMuMuHigh'],
postscale=config['PostscaleMuMuHigh'],
selection=self.SelMuMuHighNB)
self.jPsiLine = StrippingLine(name + "JPsiNBLine",
prescale=config['PrescaleJPsi'],
postscale=config['PostscaleJPsi'],
selection=self.SelJPsiNB)
self.registerLine(self.mumuLine)
self.registerLine(self.mumuHighLine)
self.registerLine(self.jPsiLine)
def __init__(self, name, config) :
LineBuilder.__init__(self, name, config)
self.selPi = makePi( 'PiFor'+name,
MinPiPt =config['MinPiPt'],
MinPiIPChi2DV=config['MinPiIPChi2DV'],
MaxPiChi2 =config['MaxPiChi2'],
MinPiPIDK =config['MinPiPIDK'],
MinPiPIDp =config['MinPiPIDp'],
MaxPiGHP =config['MaxPiGHP'])
self.selK = makeK( 'KFor'+name,
MinKPt =config['MinKPt'],
MinKIPChi2DV=config['MinKIPChi2DV'],
MaxKChi2 =config['MaxKChi2'],
MinKPIDPi =config['MinKPIDPi'],
MinKPIDp =config['MinKPIDp'],
MaxKGHP =config['MaxKGHP'])
self.selp = makep( 'pFor'+name,
MinpPt =config['MinpPt'],
MinpIPChi2DV=config['MinpIPChi2DV'],
MaxpChi2 =config['MaxpChi2'],
MinpPIDPi =config['MinpPIDPi'],
MinpPIDK =config['MinpPIDK'],
MaxpGHP =config['MaxpGHP'])
self.selKs = makeKs('KsFor'+name,
MaxKsDeltaM =config['MaxKsDeltaM'],
MinKsPt =config['MinKsPt'],
MaxKsVertChi2DOF=config['MaxKsVertChi2DOF'],
MinKsPVVDChi2 =config['MinKsPVVDChi2'],
MinKsIPChi2 =config['MinKsIPChi2'],
MinKsDauPt =config['MinKsDauPt'],
MinKsDauIPChi2 =config['MinKsDauIPChi2'],
MaxKsDauTrkChi2 =config['MaxKsDauTrkChi2'])
self.selLm = makeLm('LmFor'+name,
MaxLmDeltaM =config['MaxLmDeltaM'],
MinLmPt =config['MinLmPt'],
MaxLmVertChi2DOF=config['MaxLmVertChi2DOF'],
MinLmPVVDChi2 =config['MinLmPVVDChi2'],
MinLmIPChi2 =config['MinLmIPChi2'],
MinLmPrtPt =config['MinLmPrtPt'],
MinLmPiPt =config['MinLmPiPt'],
MinLmPrtIPChi2 =config['MinLmPrtIPChi2'],
MinLmPiIPChi2 =config['MinLmPiIPChi2'],
MaxLmPrtTrkChi2 =config['MaxLmPrtTrkChi2'],
MaxLmPiTrkChi2 =config['MaxLmPiTrkChi2'])
self.selDz = makeDz('DzFor'+name,
MaxDzDeltaM =config['MaxDzDeltaM'],
MinDzPt =config['MinDzPt'],
MaxDzVertChi2DOF=config['MaxDzVertChi2DOF'],
MinDzPVVDChi2 =config['MinDzPVVDChi2'],
MinDzIPChi2 =config['MinDzIPChi2'],
MinDzDauPt =config['MinDzDauPt'],
MinDzDauIPChi2 =config['MinDzDauIPChi2'],
MaxDzDauTrkChi2 =config['MaxDzDauTrkChi2'],
MinDzKPIDPi =config['MinDzKPIDPi'],
MinDzPiPIDK =config['MinDzPiPIDK'])
self.selDp = makeDp('DpFor'+name,
MaxDpDeltaM =config['MaxDpDeltaM'],
MinDpPt =config['MinDpPt'],
MaxDpVertChi2DOF=config['MaxDpVertChi2DOF'],
MinDpPVVDChi2 =config['MinDpPVVDChi2'],
MinDpIPChi2 =config['MinDpIPChi2'],
MinDpDauPt =config['MinDpDauPt'],
MinDpDauIPChi2 =config['MinDpDauIPChi2'],
MaxDpDauTrkChi2 =config['MaxDpDauTrkChi2'],
MinDpKPIDPi =config['MinDpKPIDPi'],
MinDpPiPIDK =config['MinDpPiPIDK'])
self.selDs = makeDs('DsFor'+name,
MaxDsDeltaM =config['MaxDsDeltaM'],
MinDsPt =config['MinDsPt'],
MaxDsVertChi2DOF=config['MaxDsVertChi2DOF'],
MinDsPVVDChi2 =config['MinDsPVVDChi2'],
MinDsIPChi2 =config['MinDsIPChi2'],
MinDsDauPt =config['MinDsDauPt'],
MinDsDauIPChi2 =config['MinDsDauIPChi2'],
MaxDsDauTrkChi2 =config['MaxDsDauTrkChi2'],
MinDsKmPIDPi =config['MinDsKmPIDPi'],
MinDsKpPIDPi =config['MinDsKpPIDPi'],
MinDsPiPIDK =config['MinDsPiPIDK'])
self.selLc = makeLc('LcFor'+name,
MaxLcDeltaM =config['MaxLcDeltaM'],
MinLcPt =config['MinLcPt'],
MaxLcVertChi2DOF=config['MaxLcVertChi2DOF'],
MinLcPVVDChi2 =config['MinLcPVVDChi2'],
MinLcIPChi2 =config['MinLcIPChi2'],
MinLcDauPt =config['MinLcDauPt'],
MinLcDauIPChi2 =config['MinLcDauIPChi2'],
MaxLcDauTrkChi2 =config['MaxLcDauTrkChi2'],
MinLcKPIDPi =config['MinLcKPIDPi'],
MinLcpPIDPi =config['MinLcpPIDPi'],
MinLcpPIDK =config['MinLcpPIDK'],
MinLcPiPIDK =config['MinLcPiPIDK'])
self.selPh = makePh('PhFor'+name,
MaxPhDeltaM =config['MaxPhDeltaM'],
MinPhPt =config['MinPhPt'],
MaxPhVertChi2DOF=config['MaxPhVertChi2DOF'],
MinPhPVVDChi2 =config['MinPhPVVDChi2'],
MinPhIPChi2 =config['MinPhIPChi2'],
MinPhDauPt =config['MinPhDauPt'],
MinPhDauIPChi2 =config['MinPhDauIPChi2'],
MaxPhDauTrkChi2 =config['MaxPhDauTrkChi2'])
self.selKS = makeKS('KSFor'+name,
MaxKSDeltaM =config['MaxKSDeltaM'],
MinKSPt =config['MinKSPt'],
MaxKSVertChi2DOF=config['MaxKSVertChi2DOF'],
MinKSPVVDChi2 =config['MinKSPVVDChi2'],
MinKSIPChi2 =config['MinKSIPChi2'],
MinKSDauPt =config['MinKSDauPt'],
MinKSDauIPChi2 =config['MinKSDauIPChi2'],
MaxKSDauTrkChi2 =config['MaxKSDauTrkChi2'],
MinKSKPIDPi =config['MinKSKPIDPi'],
MinKSPiPIDK =config['MinKSPiPIDK'])
self.selJp = makeJp('JpFor'+name,
MaxJpDeltaM =config['MaxJpDeltaM'],
MinJpPt =config['MinJpPt'],
MaxJpVertChi2DOF=config['MaxJpVertChi2DOF'],
MinJpPVVDChi2 =config['MinJpPVVDChi2'],
MinJpIPChi2 =config['MinJpIPChi2'],
MinJpDauPt =config['MinJpDauPt'],
MinJpDauIPChi2 =config['MinJpDauIPChi2'],
MaxJpDauTrkChi2 =config['MaxJpDauTrkChi2'])
self.selDS = makeDS('DSFor'+name,
MaxDSDeltaM =config['MaxDSDeltaM'],
MinDSPt =config['MinDSPt'],
MaxDSVertChi2DOF =config['MaxDSVertChi2DOF'],
MinDSPVVDChi2 =config['MinDSPVVDChi2'],
MinDSIPChi2 =config['MinDSIPChi2'],
MinDSPiPt =config['MinDSPiPt'],
MinDSPiIPChi2 =config['MinDSPiIPChi2'],
MaxDSPiTrkChi2 =config['MaxDSPiTrkChi2'],
MaxDSD0DeltaM =config['MaxDSD0DeltaM'],
MinDSD0Pt =config['MinDSD0Pt'],
MaxDSD0VertChi2DOF=config['MaxDSD0VertChi2DOF'],
MinDSD0PVVDChi2 =config['MinDSD0PVVDChi2'],
MinDSD0IPChi2 =config['MinDSD0IPChi2'],
MinDSD0DauPt =config['MinDSD0DauPt'],
MinDSD0DauIPChi2 =config['MinDSD0DauIPChi2'],
MaxDSD0DauTrkChi2 =config['MaxDSD0DauTrkChi2'])
self.selB2nbody = makeB2nbody(name,
PiSel=self.selPi,
KSel =self.selK,
pSel =self.selp,
KsSel=self.selKs,
LmSel=self.selLm,
DzSel=self.selDz,
DpSel=self.selDp,
DsSel=self.selDs,
LcSel=self.selLc,
PhSel=self.selPh,
KSSel=self.selKS,
JpSel=self.selJp,
DSSel=self.selDS,
nbody =config['nbody'],
MinBMass =config['MinBMass'],
MaxBMass =config['MaxBMass'],
MinBPt =config['MinBPt'],
MaxBVertChi2DOF=config['MaxBVertChi2DOF'],
MinBPVVDChi2 =config['MinBPVVDChi2'],
MaxBPVIPChi2 =config['MaxBPVIPChi2'],
MinBPVDIRA =config['MinBPVDIRA'],
MaxMass =config['MaxMass'],
MaxNtrk =config['MaxNtrk'],
MinNvc =config['MinNvc'],
doPi =config['doPi'],
doK =config['doK'],
dop =config['dop'],
doKs =config['doKs'],
doLm =config['doLm'],
doDz =config['doDz'],
doDp =config['doDp'],
doDs =config['doDs'],
doLc =config['doLc'],
doPh =config['doPh'],
doKS =config['doKS'],
doJp =config['doJp'],
doDS =config['doDS'])
TrLongFilter={'Code' : "(recSummaryTrack(LHCb.RecSummary.nLongTracks, TrLONG) < %s )"% config['MaxTrLong'],
'Preambulo' : [ "from LoKiTracks.decorators import *",'from LoKiCore.functions import *' ]}
self.line = StrippingLine(name+"Line",
selection = self.selB2nbody,
prescale = config['prescale'],
FILTER = TrLongFilter )
self.registerLine(self.line)
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)
self.name = name
self.config = config
#### LLL case ####
PionsForLambdaLList = createSubSel( OutputList = "PionsForLambda" + self.name,
InputList = DataOnDemand("Phys/StdAllLoosePions/Particles"),
Cuts = "(ISLONG) & (TRCHI2DOF < %(TRCHI2DOF)s ) & "\
"(BPVIPCHI2() > %(minCHI2IPPV_pPi_LL)s)" % self.config )
ProtonsForLambdaLList = createSubSel( OutputList = "ProtonsForLambdaLoose" + self.name,
InputList = DataOnDemand("Phys/StdAllLooseProtons/Particles"),
Cuts = "(ISLONG) & (TRCHI2DOF < %(TRCHI2DOF)s ) & "\
"(BPVIPCHI2() > %(minCHI2IPPV_L_LL)s)" % self.config )
PionsForXiLList = createSubSel( OutputList = "PionsForXi" + self.name,
InputList = DataOnDemand("Phys/StdAllLoosePions/Particles"),
Cuts = "(ISLONG) & (TRCHI2DOF < %(TRCHI2DOF)s ) & "\
"(BPVIPCHI2() > %(minCHI2IPPV_Pi_Bachelor_LLL)s)" % self.config )
KaonsForOmegaLList = createSubSel( OutputList = "KaonsForOmega" + self.name,
InputList = DataOnDemand("Phys/StdAllLooseKaons/Particles"),
Cuts = "(ISLONG) & (TRCHI2DOF < %(TRCHI2DOF)s ) & "\
"(BPVIPCHI2() > %(minCHI2IPPV_K_Bachelor_L)s)" % self.config )
#### DDL ####
PionsForLambdaDList = createSubSel( OutputList = "PionsForLambdaD" + self.name,
InputList = DataOnDemand("Phys/StdNoPIDsDownPions/Particles"),
Cuts = "(TRCHI2DOF < %(TRCHI2DOF)s ) & "\
"(BPVIPCHI2() > %(minCHI2IPPV_pPi)s)" % self.config )
ProtonsForLambdaDList = createSubSel( OutputList = "ProtonsForLambdaD" + self.name,
InputList = DataOnDemand("Phys/StdNoPIDsDownProtons/Particles"),
Cuts = "HASRICH & ((PIDp-PIDpi) > %(ProtonPIDppi)s) & "\
"(TRCHI2DOF < %(TRCHI2DOF)s ) "\
"& (BPVIPCHI2() > %(minCHI2IPPV_pPi)s)" % self.config )
PionsForXiDLList = createSubSel( OutputList = "PionsForXiDL" + self.name,
InputList = DataOnDemand("Phys/StdAllLoosePions/Particles"),
Cuts = "(ISLONG) & (TRCHI2DOF < %(TRCHI2DOF)s ) & "\
"(BPVIPCHI2() > %(minCHI2IPPV_Bachelor)s)" % self.config )
#### DDD ####de adaugat conditiile pentru protoni
PionsForXiDDList = createSubSel( OutputList = "PionsForXiDD" + self.name,
InputList = DataOnDemand("Phys/StdNoPIDsDownPions/Particles"),
Cuts = "(TRCHI2DOF < %(TRCHI2DOF)s ) & "\
"(BPVIPCHI2() > %(minCHI2IPPV_Pi_Bachelor_DDD)s)" % self.config )
KaonsForOmegaDList = createSubSel( OutputList = "KaonsForOmegaD" + self.name,
InputList = DataOnDemand("Phys/StdLooseDownKaons/Particles"),
Cuts = "(TRCHI2DOF < %(TRCHI2DOF)s ) & "\
"(BPVIPCHI2() > %(minCHI2IPPV_K_Bachelor_D)s)" % self.config )
#Create Lambdas
Lambda2pPiL = createCombinationSel(OutputList = "Lambda2pPiL"+ self.name,
DecayDescriptor = "[Lambda0 -> p+ pi-]cc",
DaughterLists = [PionsForLambdaLList, ProtonsForLambdaLList],
DaughterCuts = {},
PreVertexCuts = "(ADAMASS('Lambda0') < %(Lambda0MassWindow)s*MeV)"% self.config,
PostVertexCuts = "(BPVIPCHI2() > %(minCHI2IPPV_L_LL)s) & (VFASPF(VCHI2) < %(CHI2VTX_L)s) &"\
"(BPVVDCHI2 > %(L_FDCHI2_OWNPV_LL)s)" %self.config
#PostVertexCuts = "(BPVIPCHI2() > %(minCHI2IPPV_L_Loose)s) & (VFASPF(VCHI2) < %(CHI2VTX_L)s)" %self.config
)
Lambda2pPiLOmega = createCombinationSel(OutputList = "Lambda2pPiLOmega"+ self.name,
DecayDescriptor = "[Lambda0 -> p+ pi-]cc",
DaughterLists = [PionsForLambdaLList, ProtonsForLambdaLList],
DaughterCuts = {},
PreVertexCuts = "(ADAMASS('Lambda0') < %(Lambda0MassWindow)s*MeV)"% self.config,
PostVertexCuts = "(BPVIPCHI2() > %(minCHI2IPPV_L_LL)s) & (VFASPF(VCHI2) < %(CHI2VTX_L)s) &"\
"(BPVVDCHI2 > %(L_FDCHI2_OWNPV_LL_Omega)s)" %self.config
#PostVertexCuts = "(BPVIPCHI2() > %(minCHI2IPPV_L_Loose)s) & (VFASPF(VCHI2) < %(CHI2VTX_L)s)" %self.config
)
Lambda2pPiD = createCombinationSel(OutputList = "Lambda2pPiD"+ self.name,
DecayDescriptor = "[Lambda0 -> p+ pi-]cc",
DaughterLists = [PionsForLambdaDList, ProtonsForLambdaDList],
DaughterCuts = {},
PreVertexCuts = "(ADAMASS('Lambda0') < %(Lambda0MassWindow)s*MeV)"% self.config,
PostVertexCuts = "(BPVIPCHI2() > %(minCHI2IPPV_L)s) & (VFASPF(VCHI2) < %(CHI2VTX_L)s) &"\
"(BPVVDCHI2 > %(L_FDCHI2_OWNPV)s)" %self.config
#PostVertexCuts = "(BPVIPCHI2() > %(minCHI2IPPV_L)s) & (VFASPF(VCHI2) < %(CHI2VTX_L)s)" %self.config
)
Lambda2pPiDOmega = createCombinationSel(OutputList = "Lambda2pPiDOmega"+ self.name,
DecayDescriptor = "[Lambda0 -> p+ pi-]cc",
DaughterLists = [PionsForLambdaDList, ProtonsForLambdaDList],
DaughterCuts = {},
PreVertexCuts = "(ADAMASS('Lambda0') < %(Lambda0MassWindow)s*MeV)"% self.config,
PostVertexCuts = "(BPVIPCHI2() > %(minCHI2IPPV_L)s) & (VFASPF(VCHI2) < %(CHI2VTX_L)s) &"\
"(BPVVDCHI2 > %(L_FDCHI2_OWNPV_Omega)s)" %self.config
#PostVertexCuts = "(BPVIPCHI2() > %(minCHI2IPPV_L)s) & (VFASPF(VCHI2) < %(CHI2VTX_L)s)" %self.config
)
self.makeXiminus("XiminusLLL", [Lambda2pPiL, PionsForXiLList], 'Xi_FDCHI2_OWNPV_LLL')
# self.makeXiminus("XiminusDDL", [Lambda2pPiD, PionsForXiDLList], 'Xi_FDCHI2_OWNPV_DDL')
self.makeXiminus("XiminusDDD", [Lambda2pPiD, PionsForXiDDList], 'Xi_FDCHI2_OWNPV')
self.makeXiminus("XiminusDDL", [Lambda2pPiD, PionsForXiDLList], 'Xi_FDCHI2_OWNPV_DDL')
self.makeOmegaminus("OmegaminusLLL", [Lambda2pPiLOmega, KaonsForOmegaLList], 'Omega_FDCHI2_OWNPV')
# self.makeOmegaminus("OmegaminusDDL", [Lambda2pPiD, KaonsForOmegaLList], 'Omega_FDCHI2_OWNPV')
self.makeOmegaminus("OmegaminusDDD", [Lambda2pPiDOmega, KaonsForOmegaDList], 'Omega_FDCHI2_OWNPV')
self.makeOmegaminus("OmegaminusDDL", [Lambda2pPiDOmega, KaonsForOmegaLList], 'Omega_FDCHI2_OWNPV')
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
self.name = name
PVRange = True
#self.__PVOutputLocation__ = "Rec/Vertex/Primary"
### DEFINE HADRONS
selHad = {
name: self._createHadProng(name="Hadron_" + self.name,
config=config)
}
### DEFINE TAUS
selTau = {
name:
self._createTauProng(name="Tau_" + self.name,
hadSel=selHad[self.name],
config=config),
name + "_SameSignTau":
self._createTauProng_SameSign(name="Tau_" + self.name +
"_SameSignTau",
hadSel=selHad[self.name],
config=config),
}
##### DEFINE LINES
self.Z2TauTauLine = StrippingLine(
name + "_Line",
prescale=config['Z2TauTau_Prong_LinePrescale'],
postscale=config['Z2TauTau_Prong_LinePostscale'],
checkPV=PVRange,
selection=self._createZ(name=name,
tauSel=selTau[name],
config=config))
self.Z2TauTauSameSignLine = StrippingLine(
name + "_SameSign_Line",
prescale=config['Z2TauTau_Prong_LinePrescale'],
postscale=config['Z2TauTau_Prong_LinePostscale'],
checkPV=PVRange,
selection=self._createZ_SameSign(name=name + "_SameSign",
tauSel=selTau[name],
config=config))
self.Z2TauTauSameSignTauLine = StrippingLine(
name + "_SameSignTau_Line",
prescale=config['Z2TauTau_Prong_LinePrescale'],
postscale=config['Z2TauTau_Prong_LinePostscale'],
checkPV=PVRange,
selection=self._createZ(name=name + "_SameSignTau",
tauSel=selTau[name + "_SameSignTau"],
config=config))
self.Z2TauTauSameSignAllLine = StrippingLine(
name + "_SameSignAll_Line",
prescale=config['Z2TauTau_Prong_LinePrescale'],
postscale=config['Z2TauTau_Prong_LinePostscale'],
checkPV=PVRange,
selection=self._createZ_SameSign(name=name + "_SameSignAll",
tauSel=selTau[name +
"_SameSignTau"],
config=config))
self.registerLine(self.Z2TauTauLine)
self.registerLine(self.Z2TauTauSameSignLine)
self.registerLine(self.Z2TauTauSameSignTauLine)
self.registerLine(self.Z2TauTauSameSignAllLine)
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=
"(TRCHI2DOF < %(TRCHI2)s) & (PT>1.2*GeV) & (MIPCHI2DV(PRIMARY)> 9.0)"
% self.__confdict__),
RequiredSelections=[self.selmuon])
self.selmuontight = Selection(
"Mutightfor" + name,
Algorithm=FilterDesktop(Code="(MIPCHI2DV(PRIMARY)> 100)"),
RequiredSelections=[self.selmuonhighPT])
self.selmuonnew = Selection(
"Munewfor" + name,
Algorithm=FilterDesktop(
Code="(MIPCHI2DV(PRIMARY)> 9.0) & (TRCHI2DOF < %(TRCHI2)s)" %
self.__confdict__),
RequiredSelections=[self.selmuon])
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.selPionloose = Selection("Piloosefor" + name,
Algorithm=self._pionlooseFilter(),
RequiredSelections=[StdNoPIDsPions])
self.selKaonloose = Selection("Kloosefor" + name,
Algorithm=self._kaonlooseFilter(),
RequiredSelections=[StdLooseKaons])
self.selphi2kk = Selection("Phi2KKfor" + name,
Algorithm=self._Phi2KKFilter(),
RequiredSelections=[self.selKaonloose])
self.seld02kpi = Selection(
"D02KPifor" + name,
Algorithm=self._D02KPiFilter(),
RequiredSelections=[self.selKaon, self.selPion])
self.seld02kk = Selection("D02KKfor" + name,
Algorithm=self._D02KKFilter(),
RequiredSelections=[self.selKaon])
self.seld02pipi = Selection("D02PiPifor" + name,
Algorithm=self._D02PiPiFilter(),
RequiredSelections=[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.selds2phipi = Selection(
"Ds2PhiPifor" + name,
Algorithm=self._Ds2PhiPiFilter(),
RequiredSelections=[self.selphi2kk, self.selPionloose])
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.selb2D0MuXKK = makeb2DMuX(
'b2D0MuXKK' + name,
DecayDescriptors=['[B- -> D0 mu-]cc', '[B+ -> D0 mu+]cc'],
MuSel=self.selmuon,
DSel=self.seld02kk,
BVCHI2DOF=config['BVCHI2DOF'],
BDIRA=config['BDIRA'],
DZ=config['DZ'])
self.selb2D0MuXpipi = makeb2DMuX(
'b2D0MuXpipi' + name,
DecayDescriptors=['[B- -> D0 mu-]cc', '[B+ -> D0 mu+]cc'],
MuSel=self.selmuon,
DSel=self.seld02pipi,
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.selmuonnew,
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.selmuonnew,
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.selmuonnew,
DSel=self.sellambdac,
BVCHI2DOF=config['BVCHI2DOF'],
BDIRA=config['BDIRA'],
DZ=config['DZ'])
self.selb2DsMuXPhiPi = makeb2DMuX(
'b2DsMuXPhiPi' + name,
DecayDescriptors=['[B0 -> D- mu+]cc', '[B0 -> D- mu-]cc'],
MuSel=self.selmuon,
DSel=self.selds2phipi,
BVCHI2DOF=config['BVCHI2DOF'],
BDIRA=config['BDIRA'],
DZ=config['DZ'])
self.b2D0MuXLine = StrippingLine(
'b2D0MuX' + name + 'Line'
#, HLT = " HLT_PASS_RE('Hlt.*(Muon|MuTrack).*Decision') "
,
prescale=config['PrescalD0Mu'],
selection=self.selb2D0MuX)
self.b2D0MuXKKLine = StrippingLine('b2D0MuXKK' + name + 'Line',
prescale=1,
selection=self.selb2D0MuXKK)
self.b2D0MuXpipiLine = StrippingLine('b2D0MuXpipi' + name + 'Line',
prescale=1,
selection=self.selb2D0MuXpipi)
self.b2D0MuXK3PiLine = StrippingLine('b2D0MuXK3Pi' + name + 'Line',
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.b2DsMuXPhiPiLine = StrippingLine('b2DsMuXPhiPi' + name + 'Line',
prescale=1,
selection=self.selb2DsMuXPhiPi)
self.registerLine(self.b2D0MuXLine)
self.registerLine(self.b2DpMuXLine)
self.registerLine(self.b2DsMuXLine)
self.registerLine(self.b2LcMuXLine)
self.registerLine(self.b2D0MuXK3PiLine)
self.registerLine(self.b2D0MuXKKLine)
self.registerLine(self.b2D0MuXpipiLine)
self.registerLine(self.b2DsMuXPhiPiLine)
def __init__(self, _name, config):
LineBuilder.__init__(self, _name, config)
self.__confdict__ = config
#### define the cuts for the Lambda_b0 daughter tracks
self.MuonCuts = "(TRGHOSTPROB < %(MAXGHOSTPROB)s) & (PIDmu > 0) & (PT > %(Mu_PT)s *MeV)" % self.__confdict__
self.PionCuts = "(TRGHOSTPROB < %(MAXGHOSTPROB)s) & (PIDK < %(Pi_PIDKMax)s) & (PT > %(H_PT)s *MeV)" % self.__confdict__
self.KaonCuts = "(TRGHOSTPROB < %(MAXGHOSTPROB)s) & (PIDK > %(K_PIDKMin)s) & (PT > %(H_PT)s *MeV)" % self.__confdict__
self.ProtonCuts = "(TRGHOSTPROB < %(MAXGHOSTPROB)s) & (PT > %(H_PT)s *MeV)" % self.__confdict__
#### Define the combination cuts
self.LambdaC_CombinationCut = "(ADAMASS('Lambda_c+') < %(LambdaC_MASSWIN)s *MeV)"\
"& (ACHILD(PT,1)+ACHILD(PT,2)+ACHILD(PT,3) > %(LambdaC_PTSUM)s *MeV)"\
"& (ADOCACHI2CUT(%(LambdaC_DOCACHI2_MAX)s, ''))" % self.__confdict__
self.LambdaC_MotherCut = "(ADMASS('Lambda_c+') < %(LambdaC_MASSWIN)s *MeV)"\
"& (VFASPF(VCHI2/VDOF) < %(LambdaC_VCHI2NDF)s) " \
"& (BPVVDCHI2 > %(LambdaC_FDCHI2)s)"\
"& (BPVDIRA> %(LambdaC_DIRA)s)" % self.__confdict__
self.LambdaB_CombinationCut = "(AM > %(LambdaB_MASS_MIN)s *MeV)"\
"& (AM < %(LambdaB_MASS_MAX)s *MeV)"\
"& (ADOCACHI2CUT(%(LambdaB_DOCACHI2_MAX)s, ''))" % self.__confdict__
self.LambdaB_MotherCut = "( MINTREE((ABSID=='Lambda_c+'),VFASPF(VZ)) - VFASPF(VZ) > %(LambdaC_DZ)s *mm )"\
"& (BPVDIRA> %(LambdaB_DIRA)s)"\
"& (VFASPF(VCHI2/VDOF) < %(LambdaB_VCHI2NDF)s)" % self.__confdict__
#### make the Lambda_c -> p K pi
self.comb_Lc2PKPi = CombineParticles(
DecayDescriptors=['[Lambda_c+ -> p+ K- pi+]cc'],
DaughtersCuts={
"pi+": self.PionCuts,
"K-": self.KaonCuts,
"p+": self.ProtonCuts
},
CombinationCut=self.LambdaC_CombinationCut,
MotherCut=self.LambdaC_MotherCut)
self.sel_Lc2PKPi = Selection(name="SelLc2PKPiFor" + _name,
Algorithm=self.comb_Lc2PKPi,
RequiredSelections=[
StdLoosePions, StdLooseKaons,
StdNoPIDsProtons
])
#### combine the Lambda_c -> p K pi with a muon
self.comb_Lb2LcMuNu = CombineParticles(
DecayDescriptor='[Lambda_b0 -> Lambda_c+ mu-]cc',
DaughtersCuts={"mu-": self.MuonCuts},
CombinationCut=self.LambdaB_CombinationCut,
MotherCut=self.LambdaB_MotherCut)
self.sel_Lb2LcMuNu = Selection(
name="sel_Lb2LcMuNu" + _name,
Algorithm=self.comb_Lb2LcMuNu,
RequiredSelections=[self.sel_Lc2PKPi, StdLooseMuons])
#### define the GECs
GECs = {
"Code":
"( recSummaryTrack(LHCb.RecSummary.nLongTracks, TrLONG) < %(GEC_nLongTrk)s)"
% self.__confdict__,
"Preambulo": ["from LoKiTracks.decorators import *"]
}
#### make the line
self.StrippingLine = StrippingLine(_name + '_LbToLcMuNuLcToPKPi',
prescale=config['prescale'],
FILTER=GECs,
selection=self.sel_Lb2LcMuNu)
self.registerLine(self.StrippingLine)
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)
d02KKpipi_name = 'D0For'+name
dstar_name = name
self.inPions = DataOnDemand(Location = "Phys/StdLoosePions/Particles")
self.inKaons = DataOnDemand(Location = "Phys/StdLooseKaons/Particles")
self.selD02KKpipi = makeD02KKpipi( d02KKpipi_name,
inputSel = [ self.inPions, self.inKaons ],
TrackChi2max = config['TrackChi2max'],
DDauKPTmin = config['DDauKPTmin'],
DDauKPmin = config['DDauKPmin'],
DDauPiPTmin = config['DDauPiPTmin'],
DDauPiPmin = config['DDauPiPmin'],
DDauKDelPIDmin = config['DDauKDelPIDmin'],
DDauPiDelPIDmin = config['DDauPiDelPIDmin'],
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_D02KKpipi = makeDstar2D0Pi( dstar_name,
inputSel = [ self.inPions, self.selD02KKpipi ],
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_D02KKpipi = 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_D02KKpipi ]
)
self.registerLine(self.line_Dstar2D0Pi_D02KKpipi)
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
LongLine_name = name + "_Long"
DownstreamLine_name = name + "_Down"
# 5 : Make Muons for Kshort2PiPiMuMu
selLongMuonsForPiPiMuMu = makeLongMuonsForPiPiMuMu(
name="LongMuonsFor" + name,
MuonP=config['MuonP'],
MuonPT=config['PT_hhmumu'],
MuonMINIPCHI2=config['MINIPCHI2_hhmumu'],
MuonTRCHI2=config['MuonTRCHI2'],
MuonPIDmu_CS_hhmumu=config['MuonPIDmu_hhmumu'])
selDownstreamMuonsForPiPiMuMu = makeDownstreamMuonsForPiPiMuMu(
name="DownMuonsFor" + name,
MuonP=config['MuonP'],
MuonPT=config['PT_hhmumu'],
MuonMINIPCHI2=config['MINIPCHI2_hhmumu'],
MuonTRCHI2=config['MuonTRCHI2'],
MuonPIDmu_CS_hhmumu=config['MuonPIDmu_hhmumu'])
# 7 : Make Pions for Kshort2PiPiMuMu
selLongPionsForPiPiMuMu = makeLongPionsForPiPiMuMu(
name="LongPionsFor" + name,
PionP=config['PionP'],
PionPT=config['PT_hhmumu'],
PionMINIPCHI2=config['MINIPCHI2_hhmumu'],
PionTRCHI2=config['PionTRCHI2'])
selDownstreamPionsForPiPiMuMu = makeDownstreamPionsForPiPiMuMu(
name="DownPionsFor" + name,
PionP=config['PionP'],
PionPT=config['PT_hhmumu'],
PionMINIPCHI2=config['MINIPCHI2_hhmumu'],
PionTRCHI2=config['PionTRCHI2'])
# 7 : Combine
selLongKshort2PiPiMuMu = self._makeKshort2PiPiMuMu(
name=LongLine_name,
pionSel=selLongPionsForPiPiMuMu,
muonSel=selLongMuonsForPiPiMuMu,
config=config)
selDownstreamKshort2PiPiMuMu = self._makeKshort2PiPiMuMu(
name=DownstreamLine_name,
pionSel=selDownstreamPionsForPiPiMuMu,
muonSel=selDownstreamMuonsForPiPiMuMu,
config=config)
# 8 : Declare Lines
self.LongLine = StrippingLine(
LongLine_name + "Line",
prescale=config['Kshort2PiPiMuMuLinePrescale'],
postscale=config['Kshort2PiPiMuMuLinePostscale'],
selection=selLongKshort2PiPiMuMu)
self.DownstreamLine = StrippingLine(
DownstreamLine_name + "Line",
prescale=config['Kshort2PiPiMuMuLinePrescale'],
postscale=config['Kshort2PiPiMuMuLinePostscale'],
selection=selDownstreamKshort2PiPiMuMu)
# 9 : register Line
self.registerLine(self.LongLine)
self.registerLine(self.DownstreamLine)
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
self._myname = name
#MUON
ExclusiveMuonGEC = {
'Code':
"(recSummaryTrack(LHCb.RecSummary.nLongTracks, TrLONG) > 0) & (recSummaryTrack( LHCb.RecSummary.nBackTracks, TrBACKWARD)<1) & (recSummary(LHCb.RecSummary.nTracks , 'Rec/Track/Best') < 6)",
'Preambulo': ["from LoKiTracks.decorators import *"]
}
self.LowMultMuon_line = StrippingLine(
self._myname + "MuonLine",
prescale=config['LowMultPrescale'],
postscale=config['LowMultPostscale'],
checkPV=False,
FILTER=ExclusiveMuonGEC,
HLT="HLT_PASS('Hlt2LowMultMuonDecision')")
self.registerLine(self.LowMultMuon_line)
self.LowMultMuon_lineps = StrippingLine(
self._myname + "MuonLinePS",
prescale=config['LowMultPrescale_ps'],
postscale=config['LowMultPostscale'],
checkPV=False,
HLT="HLT_PASS('Hlt2LowMultMuonDecision')")
self.registerLine(self.LowMultMuon_lineps)
ExclusiveDiMuonGEC = {
'Code':
"(recSummaryTrack(LHCb.RecSummary.nLongTracks, TrLONG) > 0) & (recSummaryTrack( LHCb.RecSummary.nBackTracks, TrBACKWARD)<1)",
'Preambulo': ["from LoKiTracks.decorators import *"]
}
self.LowMultPP2PPMuMu_line = StrippingLine(
self._myname + "PP2PPMuMuLine",
prescale=config['LowMultPrescale'],
postscale=config['LowMultPostscale'],
checkPV=False,
FILTER=ExclusiveDiMuonGEC,
HLT="HLT_PASS('Hlt2diPhotonDiMuonDecision')")
self.registerLine(self.LowMultPP2PPMuMu_line)
self.LowMultPP2PPMuMu_lineps = StrippingLine(
self._myname + "PP2PPMuMuLinePS",
prescale=config['LowMultPrescale_ps'],
postscale=config['LowMultPostscale'],
checkPV=False,
HLT="HLT_PASS('Hlt2diPhotonDiMuonDecision')")
self.registerLine(self.LowMultPP2PPMuMu_lineps)
#ELECTRON
ExclusiveElectronGEC = {
'Code':
"(recSummaryTrack( LHCb.RecSummary.nBackTracks, TrBACKWARD)<1) & ( recSummary(LHCb.RecSummary.nTracks , 'Rec/Track/Best' ) < 6 ) ",
'Preambulo': ["from LoKiTracks.decorators import *"]
}
self.LowMultElectron_line = StrippingLine(
self._myname + "ElectronLine",
prescale=config['LowMultPrescale'],
postscale=config['LowMultPostscale'],
checkPV=False,
FILTER=ExclusiveElectronGEC,
HLT="HLT_PASS('Hlt2LowMultElectronDecision')")
self.registerLine(self.LowMultElectron_line)
self.LowMultElectron_lineps = StrippingLine(
self._myname + "ElectronLinePS",
prescale=config['LowMultPrescale_ps'],
postscale=config['LowMultPostscale'],
checkPV=False,
HLT="HLT_PASS('Hlt2LowMultElectronDecision')")
self.registerLine(self.LowMultElectron_lineps)
self.LowMultElectron_nofilter_line = StrippingLine(
self._myname + "ElectronLineNoFilter",
prescale=config['LowMultNoFilterPrescale'],
postscale=config['LowMultPostscale'],
checkPV=False,
HLT="HLT_PASS('Hlt2LowMultElectron_nofilterDecision')")
self.registerLine(self.LowMultElectron_nofilter_line)
#HADRON
ExclusiveHadronGEC = {
'Code':
"(recSummaryTrack(LHCb.RecSummary.nLongTracks, TrLONG) > 1) & (recSummaryTrack( LHCb.RecSummary.nBackTracks, TrBACKWARD)<1) & ( CONTAINS ( 'Rec/Track/Best' ) < 6 ) ",
'Preambulo': ["from LoKiTracks.decorators import *"]
}
self.LowMultHadron_line = StrippingLine(
self._myname + "HadronLine",
prescale=config['LowMultPrescale'],
postscale=config['LowMultPostscale'],
checkPV=False,
FILTER=ExclusiveHadronGEC,
HLT="HLT_PASS('Hlt2LowMultHadronDecision')")
self.registerLine(self.LowMultHadron_line)
self.LowMultHadron_lineps = StrippingLine(
self._myname + "HadronLinePS",
prescale=config['LowMultPrescale_ps'],
postscale=config['LowMultPostscale'],
checkPV=False,
HLT="HLT_PASS('Hlt2LowMultHadronDecision')")
self.registerLine(self.LowMultHadron_lineps)
self.LowMultHadron_nofilter_line = StrippingLine(
self._myname + "HadronLineNoFilter",
prescale=config['LowMultNoFilterPrescale'],
postscale=config['LowMultPostscale'],
checkPV=False,
HLT="HLT_PASS('Hlt2LowMultHadron_nofilterDecision')")
self.registerLine(self.LowMultHadron_nofilter_line)
#PHOTON
self.LowMultPhoton_line = StrippingLine(
self._myname + "PhotonLine",
prescale=config['LowMultPrescale'],
postscale=config['LowMultPostscale'],
checkPV=False,
HLT="HLT_PASS('Hlt2LowMultPhotonDecision')")
self.registerLine(self.LowMultPhoton_line)
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
self.selPi = makePi('PiFor' + name,
MinPiPt=config['MinPiPt'],
MinPiIPChi2DV=config['MinPiIPChi2DV'],
MaxPiChi2=config['MaxPiChi2'])
self.selK = makeK('KFor' + name,
MinKPt=config['MinKPt'],
MinKIPChi2DV=config['MinKIPChi2DV'],
MaxKChi2=config['MaxKChi2'])
self.selp = makep('pFor' + name,
MinpPt=config['MinpPt'],
MinpIPChi2DV=config['MinpIPChi2DV'],
MaxpChi2=config['MaxpChi2'])
self.selKs = makeKs('KsFor' + name,
MaxKsDeltaM=config['MaxKsDeltaM'],
MinKsPt=config['MinKsPt'],
MaxKsVertChi2DOF=config['MaxKsVertChi2DOF'],
MinKsPVVDChi2=config['MinKsPVVDChi2'],
MinKsIPChi2=config['MinKsIPChi2'],
MinKsDauPt=config['MinKsDauPt'],
MinKsDauIPChi2=config['MinKsDauIPChi2'],
MaxKsDauTrkChi2=config['MaxKsDauTrkChi2'])
self.selLm = makeLm('LmFor' + name,
MaxLmDeltaM=config['MaxLmDeltaM'],
MinLmPt=config['MinLmPt'],
MaxLmVertChi2DOF=config['MaxLmVertChi2DOF'],
MinLmPVVDChi2=config['MinLmPVVDChi2'],
MinLmIPChi2=config['MinLmIPChi2'],
MinLmPrtPt=config['MinLmPrtPt'],
MinLmPiPt=config['MinLmPiPt'],
MinLmPrtIPChi2=config['MinLmPrtIPChi2'],
MinLmPiIPChi2=config['MinLmPiIPChi2'],
MaxLmPrtTrkChi2=config['MaxLmPrtTrkChi2'],
MaxLmPiTrkChi2=config['MaxLmPiTrkChi2'])
self.selDz = makeDz('DzFor' + name,
MaxDzDeltaM=config['MaxDzDeltaM'],
MinDzPt=config['MinDzPt'],
MaxDzVertChi2DOF=config['MaxDzVertChi2DOF'],
MinDzPVVDChi2=config['MinDzPVVDChi2'],
MinDzIPChi2=config['MinDzIPChi2'],
MinDzDauPt=config['MinDzDauPt'],
MinDzDauIPChi2=config['MinDzDauIPChi2'],
MaxDzDauTrkChi2=config['MaxDzDauTrkChi2'],
MinDzPIDK=config['MinDzPIDK'])
self.selDp = makeDp('DpFor' + name,
MaxDpDeltaM=config['MaxDpDeltaM'],
MinDpPt=config['MinDpPt'],
MaxDpVertChi2DOF=config['MaxDpVertChi2DOF'],
MinDpPVVDChi2=config['MinDpPVVDChi2'],
MinDpIPChi2=config['MinDpIPChi2'],
MinDpDauPt=config['MinDpDauPt'],
MinDpDauIPChi2=config['MinDpDauIPChi2'],
MaxDpDauTrkChi2=config['MaxDpDauTrkChi2'],
MinDpPIDK=config['MinDpPIDK'])
self.selDs = makeDs('DsFor' + name,
MaxDsDeltaM=config['MaxDsDeltaM'],
MinDsPt=config['MinDsPt'],
MaxDsVertChi2DOF=config['MaxDsVertChi2DOF'],
MinDsPVVDChi2=config['MinDsPVVDChi2'],
MinDsIPChi2=config['MinDsIPChi2'],
MinDsDauPt=config['MinDsDauPt'],
MinDsDauIPChi2=config['MinDsDauIPChi2'],
MaxDsDauTrkChi2=config['MaxDsDauTrkChi2'],
MinDsPIDK=config['MinDsPIDK'])
self.selLc = makeLc('LcFor' + name,
MaxLcDeltaM=config['MaxLcDeltaM'],
MinLcPt=config['MinLcPt'],
MaxLcVertChi2DOF=config['MaxLcVertChi2DOF'],
MinLcPVVDChi2=config['MinLcPVVDChi2'],
MinLcIPChi2=config['MinLcIPChi2'],
MinLcDauPt=config['MinLcDauPt'],
MinLcDauIPChi2=config['MinLcDauIPChi2'],
MaxLcDauTrkChi2=config['MaxLcDauTrkChi2'],
MinLcPIDK=config['MinLcPIDK'],
MinLcPIDp=config['MinLcPIDp'])
self.selPh = makePh('PhFor' + name,
MaxPhDeltaM=config['MaxPhDeltaM'],
MinPhPt=config['MinPhPt'],
MaxPhVertChi2DOF=config['MaxPhVertChi2DOF'],
MinPhPVVDChi2=config['MinPhPVVDChi2'],
MinPhIPChi2=config['MinPhIPChi2'],
MinPhDauPt=config['MinPhDauPt'],
MinPhDauIPChi2=config['MinPhDauIPChi2'],
MaxPhDauTrkChi2=config['MaxPhDauTrkChi2'])
self.selKS = makeKS('KSFor' + name,
MaxKSDeltaM=config['MaxKSDeltaM'],
MinKSPt=config['MinKSPt'],
MaxKSVertChi2DOF=config['MaxKSVertChi2DOF'],
MinKSPVVDChi2=config['MinKSPVVDChi2'],
MinKSIPChi2=config['MinKSIPChi2'],
MinKSDauPt=config['MinKSDauPt'],
MinKSDauIPChi2=config['MinKSDauIPChi2'],
MaxKSDauTrkChi2=config['MaxKSDauTrkChi2'])
self.selJp = makeJp('JpFor' + name,
MaxJpDeltaM=config['MaxJpDeltaM'],
MinJpPt=config['MinJpPt'],
MaxJpVertChi2DOF=config['MaxJpVertChi2DOF'],
MinJpPVVDChi2=config['MinJpPVVDChi2'],
MinJpIPChi2=config['MinJpIPChi2'],
MinJpDauPt=config['MinJpDauPt'],
MinJpDauIPChi2=config['MinJpDauIPChi2'],
MaxJpDauTrkChi2=config['MaxJpDauTrkChi2'])
self.selDS = makeDS('DSFor' + name,
MaxDSDeltaM=config['MaxDSDeltaM'],
MinDSPt=config['MinDSPt'],
MaxDSVertChi2DOF=config['MaxDSVertChi2DOF'],
MinDSPVVDChi2=config['MinDSPVVDChi2'],
MinDSIPChi2=config['MinDSIPChi2'],
MinDSPiPt=config['MinDSPiPt'],
MinDSPiIPChi2=config['MinDSPiIPChi2'],
MaxDSPiTrkChi2=config['MaxDSPiTrkChi2'],
MaxDSD0DeltaM=config['MaxDSD0DeltaM'],
MinDSD0Pt=config['MinDSD0Pt'],
MaxDSD0VertChi2DOF=config['MaxDSD0VertChi2DOF'],
MinDSD0PVVDChi2=config['MinDSD0PVVDChi2'],
MinDSD0IPChi2=config['MinDSD0IPChi2'],
MinDSD0DauPt=config['MinDSD0DauPt'],
MinDSD0DauIPChi2=config['MinDSD0DauIPChi2'],
MaxDSD0DauTrkChi2=config['MaxDSD0DauTrkChi2'])
self.selB2nbody = makeB2nbody(
name,
PiSel=self.selPi,
KSel=self.selK,
pSel=self.selp,
KsSel=self.selKs,
LmSel=self.selLm,
DzSel=self.selDz,
DpSel=self.selDp,
DsSel=self.selDs,
LcSel=self.selLc,
PhSel=self.selPh,
KSSel=self.selKS,
JpSel=self.selJp,
DSSel=self.selDS,
nbody=config['nbody'],
MinBMass=config['MinBMass'],
MaxBMass=config['MaxBMass'],
MinBPt=config['MinBPt'],
MaxBVertChi2DOF=config['MaxBVertChi2DOF'],
MinBPVVDChi2=config['MinBPVVDChi2'],
MaxBPVIPChi2=config['MaxBPVIPChi2'],
MinBPVDIRA=config['MinBPVDIRA'],
MinNvc=config['MinNvc'],
doPi=config['doPi'],
doK=config['doK'],
dop=config['dop'],
doKs=config['doKs'],
doLm=config['doLm'],
doDz=config['doDz'],
doDp=config['doDp'],
doDs=config['doDs'],
doLc=config['doLc'],
doPh=config['doPh'],
doKS=config['doKS'],
doJp=config['doJp'],
doDS=config['doDS'])
self.line = StrippingLine(name + "Line", selection=self.selB2nbody)
self.registerLine(self.line)
def __init__(self, name, config) :
# Initialize the stripping.
LineBuilder.__init__(self, name, config)
self._config = config
self._name = name
# Preselection strings for HLT and FILTER.
hlt = "HLT_PASS_RE('" + self._config["HLT"]["LINETOPO"] + ".*Decision')"
hltMB = "HLT_PASS('"+self._config["HLT"]["LINEMB"]+"')"
fltDIFF = {"Code" : "(recSummary(LHCb.RecSummary.nPVs, 'Rec/Vertex/Primary')<2)"
"& (recSummaryTrack(LHCb.RecSummary.nBackTracks, TrBACKWARD) < 1)",
'Preambulo' : ['from LoKiTracks.decorators import *',
'from LoKiCore.functions import *']}
# Select the particles.
trks = self._create_trks([StdAllNoPIDsPions])
svrs = self._create_svrs([trks])
mptJets = self._filter_hPTJets([StdJets],str(self._config["JET"]["MIN_PT"]) )
hptJets = self._filter_hPTJets([StdJets],str(self._config["JET"]["VERYLOW_PT"]) )
bJets = self._create_bJets(mptJets,svrs)
#one jet has 60% of a TOPO object LHCbID, with PT > 15, 50, 90
fbJets0 = self._filter_bJets(bJets,0,str(self._config["JET"]["VERYLOW_PT"]))
fbJets1 = self._filter_bJets(bJets,0,str(self._config["JET"]["MEDIUM_PT"]))
fbJets2 = self._filter_bJets(bJets,0,str(self._config["JET"]["HIGH_PT"]))
dijets_T6_A = self._create_dijets([hptJets, bJets], cut2=0, PT = str(self._config["JET"]["LOW_PT"]))
#one jet has 60% of a TOPO object LHCbID, the other has both trk of one 2-trk SV
dijets_T6_PS = self._create_dijets([bJets], cut1=0, cut3=15, PT = str(self._config["JET"]["LOW_PT"]))
#
#cut1 and cut2 act on the TopoObject tagging for jet1 and jet2:
# cut1 apply to jet1 and cut2 apply to jet2, or cut2 apply to jet1 and cut1
# apply to jet2
#cut3 and cut4 act on the created SV tagging for jet1 and jet2
#
# cutX == 0 no tagging
# cutX == 1 at least 60% of the LHCbID to the "tagging" object are
# continas in the jet
# cutX == 11 TOS (or all tracks in the jet)
#
#The three following lines are designed for the 4b analyses (Contact: Stephane Tourneur):
_3jets_Pt7_3sv = self._create_3jets([mptJets, bJets], minPT = str(self._config["JET"]["EXTLOW_PT"]), Nsvtag="2.5")
_4jets_Pt5_3sv = self._create_4jets([mptJets, bJets], minPT = str(self._config["JET"]["MIN_PT"]), Nsvtag="2.5")
_4jets_Pt5_0sv = self._create_4jets([mptJets, bJets], minPT = str(self._config["JET"]["MIN_PT"]), Nsvtag="-0.5")
line_jetDIFF = StrippingLine(
name + "Diffractive",
prescale = self._config["PRESCALE"]["DIFF"],
HLT2 = hlt,
FILTER = fltDIFF,
selection = hptJets,
RequiredRawEvents = ["Calo"]
)
line_jetMB = StrippingLine(
name + "MB",
prescale = self._config["PRESCALE"]["MB"],
HLT1 = hltMB,
selection = hptJets,
RequiredRawEvents = ["Calo"]
)
line_jetPT0 = StrippingLine(
name + "bJetPT15",
prescale = self._config["PRESCALE"]["bJetPT15"],
HLT2 = hlt,
selection = fbJets0,
RequiredRawEvents = ["Calo"]
)
line_jetPT1 = StrippingLine(
name + "bJetPT50",
prescale = self._config["PRESCALE"]["bJetPT50"],
HLT2 = hlt,
selection = fbJets1,
RequiredRawEvents = ["Calo"]
)
line_jetPT2 = StrippingLine(
name + "bJetPT90",
prescale = self._config["PRESCALE"]["bJetPT90"],
HLT2 = hlt,
selection = fbJets2,
RequiredRawEvents = ["Calo"]
)
line_Dijets_T6A = StrippingLine(
name + "DiJet20_T6A",
prescale = self._config["PRESCALE"]["dibJetT6A"],
HLT2 = hlt,
selection = dijets_T6_A,
RequiredRawEvents = ["Calo"]
)
line_Dijets_T6PS = StrippingLine(
name + "DiJet20_T6PS",
prescale = self._config["PRESCALE"]["dibJetT6PS"],
HLT2 = hlt,
selection = dijets_T6_PS,
RequiredRawEvents = ["Calo"]
)
line__3jets_Pt7_3sv = StrippingLine(
name + "_3jets_Pt7_3sv",
prescale = self._config["PRESCALE"]["_3jets_Pt7_3sv"],
HLT2 = hlt,
selection = _3jets_Pt7_3sv,
RequiredRawEvents = ["Calo"]
)
line__4jets_Pt5_3sv = StrippingLine(
name + "_4jets_Pt5_3sv",
prescale = self._config["PRESCALE"]["_4jets_Pt5_3sv"],
HLT2 = hlt,
selection = _4jets_Pt5_3sv,
RequiredRawEvents = ["Calo"]
)
line__4jets_Pt5_0sv_Prescaled = StrippingLine(
name + "_4jets_Pt5_0sv_Prescaled",
prescale = self._config["PRESCALE"]["_4jets_Pt5_0sv_Prescaled"],
HLT2 = hlt,
selection = _4jets_Pt5_0sv,
RequiredRawEvents = ["Calo"]
)
self.registerLine(line_jetMB)
self.registerLine(line_jetDIFF)
self.registerLine(line_jetPT0)
self.registerLine(line_jetPT1)
self.registerLine(line_jetPT2)
self.registerLine(line_Dijets_T6A)
self.registerLine(line_Dijets_T6PS)
self.registerLine(line__3jets_Pt7_3sv)
self.registerLine(line__4jets_Pt5_3sv)
self.registerLine(line__4jets_Pt5_0sv_Prescaled)
def __init__(self, name, config):
'''The constructor of the configuration class.
Requires a configuration dictionary, config, which must provide all the settings for cuts which are not hard coded'''
LineBuilder.__init__(self, name, config)
self.name = name
self.BdToKstarMuMuLineName = self.name + "_BdToKstarMuMu"
self.BuToKMuMuLineName = self.name + "_BuToKMuMu"
# Define cut strings
self.BdCombCut = "(AM > %(B_Comb_MassLow)s * MeV) & (AM < %(B_Comb_MassHigh)s * MeV)" % config
self.BdCut = "(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.DiMuonCut = DaughterCuts + " & (BPVVDCHI2 > %(Dimu_FlightChi2)s) & " \
"(MAXTREE(ISBASIC,MIPCHI2DV(PRIMARY))> %(Dimu_Dau_MaxIPCHI2)s )" %config
TrackCuts = "(TRCHI2DOF < %(Track_CHI2nDOF)s)" % config
HadronCuts = "(MIPCHI2DV(PRIMARY) > %(Hadron_MinIPCHI2)s)" % config
self.KaonCut = TrackCuts + " & " + HadronCuts
self.PionCut = TrackCuts + " & " + HadronCuts
self.MuonCut = TrackCuts + " & (MIPCHI2DV(PRIMARY) > %(Muon_MinIPCHI2)s)" % config
#if(config["Muon_IsMuon"]):
# self.MuonCut += " & (ISMUON)"
self.KstarFilterCut = self.KstarCut + " & (INTREE(ABSID=='K+') & " + self.KaonCut + ") & (INTREE(ABSID=='pi+') & " + self.PionCut + ")"
#self.DiMuonFilterCut = self.DiMuonCut + " & (2 == NINTREE((ABSID=='mu-') & " + self.MuonCut + "))"
#########################
## Make the selections ##
#########################
Sel_Kaon = self.__Selection_FilterKaon__(self.name, self.KaonCut,
config['UseNoPIDsHadrons'])
Sel_Kstar = self.__Selection_CreateKstar__(self.name,
self.KstarCombCut,
self.KstarCut, self.KaonCut,
self.PionCut,
config['UseNoPIDsHadrons'])
#if(config['UseNoPIDsHadrons']):
# must build the K* ourselves from the NoPIDs particles
# Sel_Kstar = self.__Selection_CreateKstar__(self.name, self.KstarCombCut, self.KstarCut, self.KaonCut, self.PionCut)
#else:
# can just filter the StdVeryLooseDetachedKst2Kpi built using StdLooseKaons and StdLoosePions
# Sel_Kstar = self.__Selection_FilterKstar__(self.name, self.KstarFilterCut)
Sel_DiMuon = self.__Selection_CreateDiMuon__(self.name, self.DiMuonCut,
self.MuonCut,
config['Muon_IsMuon'])
Sel_DiMuonSS = self.__Selection_CreateDiMuonSS__(
self.name, self.DiMuonCut, self.MuonCut, config['Muon_IsMuon'])
Sel_BdToKstarMuMu = self.__Selection_CreateBdToKstarMuMu__(
self.name, [Sel_DiMuon, Sel_Kstar], self.BdCombCut, self.BdCut)
Sel_BdToKstarMuMuSS = self.__Selection_CreateBdToKstarMuMu__(
self.name + "SS", [Sel_DiMuonSS, Sel_Kstar], self.BdCombCut,
self.BdCut)
Sel_BuToKMuMu = self.__Selection_CreateBuToKMuMu__(
self.name, [Sel_DiMuon, Sel_Kaon], self.BdCombCut, self.BdCut)
Sel_BuToKMuMuSS = self.__Selection_CreateBuToKMuMu__(
self.name + "SS", [Sel_DiMuonSS, Sel_Kaon], self.BdCombCut,
self.BdCut)
###################################
## Construct the stripping lines ##
###################################
from StrippingConf.StrippingLine import StrippingLine
## --- Bd -> K* mu mu (default) line ---
Line_BdToKstarMuMu_Name = self.BdToKstarMuMuLineName + "Line"
Line_BdToKstarMuMu = StrippingLine(
Line_BdToKstarMuMu_Name,
prescale=config['Prescale_BdToKstarMuMu'],
postscale=config['Postscale_BdToKstarMuMu'],
selection=Sel_BdToKstarMuMu)
self.registerLine(Line_BdToKstarMuMu)
## --- Bd -> K* mu mu same sign line ---
Line_BdToKstarMuMuSS_Name = self.BdToKstarMuMuLineName + "SSLine"
Line_BdToKstarMuMuSS = StrippingLine(
Line_BdToKstarMuMuSS_Name,
prescale=config['Prescale_BdToKstarMuMuSS'],
postscale=config['Postscale_BdToKstarMuMuSS'],
selection=Sel_BdToKstarMuMuSS)
self.registerLine(Line_BdToKstarMuMuSS)
## --- Bu -> K mu mu (default) line ---
Line_BuToKMuMu_Name = self.BuToKMuMuLineName + "Line"
Line_BuToKMuMu = StrippingLine(Line_BuToKMuMu_Name,
prescale=config['Prescale_BuToKMuMu'],
postscale=config['Postscale_BuToKMuMu'],
selection=Sel_BuToKMuMu)
self.registerLine(Line_BuToKMuMu)
## --- Bu -> K mu mu same sign line ---
Line_BuToKMuMuSS_Name = self.BuToKMuMuLineName + "SSLine"
Line_BuToKMuMuSS = StrippingLine(
Line_BuToKMuMuSS_Name,
prescale=config['Prescale_BuToKMuMuSS'],
postscale=config['Postscale_BuToKMuMuSS'],
selection=Sel_BuToKMuMuSS)
self.registerLine(Line_BuToKMuMuSS)
self.printCuts()
def __init__(self, name, config): # {
## Base class constructor
LineBuilder.__init__(self, name, config)
## Line names
d2KPP_name = name + 'D2KPP'
d2KKP_name = name + 'D2KKP'
d2KKK_name = name + 'D2KKK'
d2PPP_name = name + 'D2PPP'
d2PPK_name = name + 'D2KPPDCS'
self.inNoPIDsPions = StdAllNoPIDsPions
self.inNoPIDsKaons = StdAllNoPIDsKaons
## The (K- pi+ pi+) final state
## No PID lines. It looks like the Loose PID lines have the
self.selD2KPP = makeD2HHH(
name=d2KPP_name,
inputSel=[self.inNoPIDsPions, self.inNoPIDsKaons],
Daug_All_PT_MIN=config['Daug_All_PT_MIN'],
Daug_2of3_PT_MIN=config['Daug_2of3_PT_MIN'],
Daug_1of3_PT_MIN=config['Daug_1of3_PT_MIN'],
Daug_All_BPVIPCHI2_MIN=config['Daug_All_BPVIPCHI2_MIN'],
Daug_2of3_BPVIPCHI2_MIN=config['Daug_2of3_BPVIPCHI2_MIN'],
Daug_1of3_BPVIPCHI2_MIN=config['Daug_1of3_BPVIPCHI2_MIN'],
K_PIDK_MIN=config['K_PIDK_MIN'],
Pi_PIDK_MAX=config['Pi_PIDK_MAX'],
Comb_AM_MIN=config['Comb_AM_MIN'],
Comb_AM_MAX=config['Comb_AM_MAX'],
Comb_ADOCAMAX_MAX=config['Comb_ADOCAMAX_MAX'],
D_VCHI2VDOF_MAX=config['D_VCHI2VDOF_MAX'],
D_acosBPVDIRA_MAX=config['D_acosBPVDIRA_MAX'],
D_PVDispCut=config['D_PVDispCut'],
decDescriptors=['[D+ -> K- pi+ pi+]cc'])
self.line_D2KPP = self._strippingLine(
name=d2KPP_name + 'Line',
HLT=config['HltFilter'],
prescale=config['PrescaleD2KPP'],
postscale=config['PostscaleD2KPP'],
selection=self.selD2KPP)
## The (K- K+ pi+) final state
## No PID lines.
self.selD2KKP = makeD2HHH(
name=d2KKP_name,
inputSel=[self.inNoPIDsPions, self.inNoPIDsKaons],
Daug_All_PT_MIN=config['Daug_All_PT_MIN'],
Daug_2of3_PT_MIN=config['Daug_2of3_PT_MIN'],
Daug_1of3_PT_MIN=config['Daug_1of3_PT_MIN'],
Daug_All_BPVIPCHI2_MIN=config['Daug_All_BPVIPCHI2_MIN'],
Daug_2of3_BPVIPCHI2_MIN=config['Daug_2of3_BPVIPCHI2_MIN'],
Daug_1of3_BPVIPCHI2_MIN=config['Daug_1of3_BPVIPCHI2_MIN'],
K_PIDK_MIN=config['K_PIDK_MIN'],
Pi_PIDK_MAX=config['Pi_PIDK_MAX'],
Comb_AM_MIN=config['Comb_AM_MIN'],
Comb_AM_MAX=config['Comb_AM_MAX'],
Comb_ADOCAMAX_MAX=config['Comb_ADOCAMAX_MAX'],
D_VCHI2VDOF_MAX=config['D_VCHI2VDOF_MAX'],
D_acosBPVDIRA_MAX=config['D_acosBPVDIRA_MAX'],
D_PVDispCut=config['D_PVDispCut'],
decDescriptors=['[D+ -> K- K+ pi+]cc'])
self.line_D2KKP = self._strippingLine(
name=d2KKP_name + 'Line',
HLT=config['HltFilter'],
prescale=config['PrescaleD2KKP'],
postscale=config['PostscaleD2KKP'],
selection=self.selD2KKP)
## The (K- K+ K+) final state
self.selD2KKK = makeD2HHH(
name=d2KKK_name,
inputSel=[self.inNoPIDsKaons],
Daug_All_PT_MIN=config['Daug_All_PT_MIN'],
Daug_2of3_PT_MIN=config['Daug_2of3_PT_MIN'],
Daug_1of3_PT_MIN=config['Daug_1of3_PT_MIN'],
Daug_All_BPVIPCHI2_MIN=config['Daug_All_BPVIPCHI2_MIN'],
Daug_2of3_BPVIPCHI2_MIN=config['Daug_2of3_BPVIPCHI2_MIN'],
Daug_1of3_BPVIPCHI2_MIN=config['Daug_1of3_BPVIPCHI2_MIN'],
K_PIDK_MIN=config['K_PIDK_MIN'],
Pi_PIDK_MAX=config['Pi_PIDK_MAX'],
Comb_AM_MIN=config['Comb_AM_MIN'],
Comb_AM_MAX=config['Comb_AM_MAX'],
Comb_ADOCAMAX_MAX=config['Comb_ADOCAMAX_MAX'],
D_VCHI2VDOF_MAX=config['D_VCHI2VDOF_MAX'],
D_acosBPVDIRA_MAX=config['D_acosBPVDIRA_MAX'],
D_PVDispCut=config['D_PVDispCut'],
decDescriptors=['[D+ -> K- K+ K+]cc'])
self.line_D2KKK = self._strippingLine(
name=d2KKK_name + 'Line',
HLT=config['HltFilter'],
prescale=config['PrescaleD2KKK'],
postscale=config['PostscaleD2KKK'],
selection=self.selD2KKK)
## The (pi- pi+ pi+) final state
## No PID lines.
self.selD2PPP = makeD2HHH(
name=d2PPP_name,
inputSel=[self.inNoPIDsPions, self.inNoPIDsKaons],
Daug_All_PT_MIN=config['Daug_All_PT_MIN'],
Daug_2of3_PT_MIN=config['Daug_2of3_PT_MIN'],
Daug_1of3_PT_MIN=config['Daug_1of3_PT_MIN'],
Daug_All_BPVIPCHI2_MIN=config['Daug_All_BPVIPCHI2_MIN'],
Daug_2of3_BPVIPCHI2_MIN=config['Daug_2of3_BPVIPCHI2_MIN'],
Daug_1of3_BPVIPCHI2_MIN=config['Daug_1of3_BPVIPCHI2_MIN'],
K_PIDK_MIN=config['K_PIDK_MIN'],
Pi_PIDK_MAX=config['Pi_PIDK_MAX'],
Comb_AM_MIN=config['Comb_AM_MIN'],
Comb_AM_MAX=config['Comb_AM_MAX'],
Comb_ADOCAMAX_MAX=config['Comb_ADOCAMAX_MAX'],
D_VCHI2VDOF_MAX=config['D_VCHI2VDOF_MAX'],
D_acosBPVDIRA_MAX=config['D_acosBPVDIRA_MAX'],
D_PVDispCut=config['D_PVDispCut'],
decDescriptors=['[D+ -> pi- pi+ pi+]cc'])
self.line_D2PPP = self._strippingLine(
name=d2PPP_name + 'Line',
HLT=config['HltFilter'],
prescale=config['PrescaleD2PPP'],
postscale=config['PostscaleD2PPP'],
selection=self.selD2PPP)
## The (K+ pi- pi+) final state
## No PID lines. It looks like the Loose PID lines have the
self.selD2PPK = makeD2HHH(
name=d2PPK_name,
inputSel=[self.inNoPIDsPions, self.inNoPIDsKaons],
Daug_All_PT_MIN=config['Daug_All_PT_MIN'],
Daug_2of3_PT_MIN=config['Daug_2of3_PT_MIN'],
Daug_1of3_PT_MIN=config['Daug_1of3_PT_MIN'],
Daug_All_BPVIPCHI2_MIN=config['Daug_All_BPVIPCHI2_MIN'],
Daug_2of3_BPVIPCHI2_MIN=config['Daug_2of3_BPVIPCHI2_MIN'],
Daug_1of3_BPVIPCHI2_MIN=config['Daug_1of3_BPVIPCHI2_MIN'],
K_PIDK_MIN=config['K_PIDK_MIN'],
Pi_PIDK_MAX=config['Pi_PIDK_MAX'],
Comb_AM_MIN=config['Comb_AM_MIN'],
Comb_AM_MAX=config['Comb_AM_MAX'],
Comb_ADOCAMAX_MAX=config['Comb_ADOCAMAX_MAX'],
D_VCHI2VDOF_MAX=config['D_VCHI2VDOF_MAX'],
D_acosBPVDIRA_MAX=config['D_acosBPVDIRA_MAX'],
D_PVDispCut=config['D_PVDispCut'],
decDescriptors=['[D+ -> K+ pi- pi+]cc'])
self.line_D2PPK = self._strippingLine(
name=d2PPK_name + 'Line',
HLT=config['HltFilter'],
prescale=config['PrescaleD2KPPDCS'],
postscale=config['PostscaleD2KPPDCS'],
selection=self.selD2PPK)
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
self.__confdict__ = config
self.name = name
self.inclbJetLine = self._makeInclbJetLine(name)
self.registerLine(self.inclbJetLine)
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.selD0WS = makeD2hhAsymm(
d0WS_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.selD0KKsgl = makeD2hhAsymm(
d2kk_name + '_single',
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.selD0PiPisgl = makeD2hhAsymm(
d2pipi_name + '_single',
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.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-]cc',
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-]cc',
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-]cc',
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-]cc',
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})
# 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, stdNoPIDsPions])
self.selDstPiPi = makeDstar2D0Pi(
dst2DPiPi_name,
config,
'[D*(2010)+ -> D0 pi+]cc',
inputSel=[self.selD0PiPi, 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, stdNoPIDsPions])
self.selDstPiPiSS = makeDstar2D0Pi(
dst2DPiPi_name + 'SS',
config,
'[D*(2010)+ -> D0 pi+]cc',
inputSel=[self.selD0PiPiSS, 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])
# Untagged lines
self.d2kpi_line = StrippingLine(
d2kpi_name + "Line",
prescale=config['UntaggedCFLinePrescale'],
postscale=config['UntaggedCFLinePostscale'],
selection=self.selD2Kpi,
RequiredRawEvents=config['RequiredRawEvents'])
self.d2kk_line = StrippingLine(
d2kk_name + "Line",
prescale=config['UntaggedSCSLinePrescale'],
postscale=config['UntaggedSCSLinePostscale'],
selection=self.selD0KKsgl,
RequiredRawEvents=config['RequiredRawEvents'])
self.d2pipi_line = StrippingLine(
d2pipi_name + "Line",
prescale=config['UntaggedSCSLinePrescale'],
postscale=config['UntaggedSCSLinePostscale'],
selection=self.selD0PiPisgl,
RequiredRawEvents=config['RequiredRawEvents'])
# Untagged TIS lines
self.d2kpiTIS_line = StrippingLine(
d2kpi_name + "TISLine",
prescale=config['UntaggedTISLinePrescale'],
postscale=config['UntaggedTISLinePostscale'],
selection=self.selD2KpiTIS,
RequiredRawEvents=config['RequiredRawEvents'])
self.d2kkTIS_line = StrippingLine(
d2kk_name + "TISLine",
prescale=config['UntaggedTISLinePrescale'],
postscale=config['UntaggedTISLinePostscale'],
selection=self.selD0KKTIS,
RequiredRawEvents=config['RequiredRawEvents'])
self.d2pipiTIS_line = StrippingLine(
d2pipi_name + "TISLine",
prescale=config['UntaggedTISLinePrescale'],
postscale=config['UntaggedTISLinePostscale'],
selection=self.selD0PiPiTIS,
RequiredRawEvents=config['RequiredRawEvents'])
# Tagged lines
self.dstRS_line = StrippingLine(
dst2DRS_name + "Line",
prescale=config['TaggedRSLinePrescale'],
postscale=config['TaggedRSLinePostscale'],
selection=self.selDstRS,
RequiredRawEvents=config['RequiredRawEvents'])
self.dstWS_line = StrippingLine(
dst2DWS_name + "Line",
prescale=config['TaggedWSLinePrescale'],
postscale=config['TaggedWSLinePostscale'],
selection=self.selDstWS,
RequiredRawEvents=config['RequiredRawEvents'])
self.dstKK_line = StrippingLine(
dst2DKK_name + "Line",
prescale=config['TaggedSCSLinePrescale'],
postscale=config['TaggedSCSLinePostscale'],
selection=self.selDstKK,
RequiredRawEvents=config['RequiredRawEvents'])
self.dstPiPi_line = StrippingLine(
dst2DPiPi_name + "Line",
prescale=config['TaggedSCSLinePrescale'],
postscale=config['TaggedSCSLinePostscale'],
selection=self.selDstPiPi,
RequiredRawEvents=config['RequiredRawEvents'])
# Tagged same sign lines
self.dstRSSS_line = StrippingLine(
dst2DRS_name + "SSLine",
prescale=config['TaggedRSLinePrescale'],
postscale=config['TaggedRSLinePostscale'],
selection=self.selDstRSSS,
RequiredRawEvents=config['RequiredRawEvents'])
self.dstKKSS_line = StrippingLine(
dst2DKK_name + "SSLine",
prescale=config['TaggedSCSLinePrescale'],
postscale=config['TaggedSCSLinePostscale'],
selection=self.selDstKKSS,
RequiredRawEvents=config['RequiredRawEvents'])
self.dstPiPiSS_line = StrippingLine(
dst2DPiPi_name + "SSLine",
prescale=config['TaggedSCSLinePrescale'],
postscale=config['TaggedSCSLinePostscale'],
selection=self.selDstPiPiSS,
RequiredRawEvents=config['RequiredRawEvents'])
# Pseudo Psi line
self.pseudoPsi_line = StrippingLine(
pseudoPsi_name + "Line",
prescale=1.,
postscale=1.,
selection=self.selPseudoPsi,
RequiredRawEvents=config['RequiredRawEvents'])
# 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):
self.name = name
LineBuilder.__init__(self, name, config)
incl = self.name + '_InclPsi2SToJpsiPiPi'
incl_detatched_name = incl + 'Detatched'
sig = self.name + '_Bs2Psi2SPhiJpsiPiPi'
K = self.name + '_Bu2Psi2SKJpsiPiPi'
Kstar = self.name + '_Bd2Psi2SKstarJpsiPiPi'
Ks = self.name + '_Bd2Psi2SKsJpsiPiPi'
self.selPions = makePions(self.name + '_PionsForPsi2SJpsiPiPi',
PionsTRCHI2DOF=config['PionsTRCHI2DOF'])
self.selJpsi = makeJpsi(self.name + '_JpsiForPsi2SJpsiPiPi')
self.selPsi2S2JpsiPiPi = makePsi2S(
self.name + '_Psi2SJpsiPiPi',
Pions=self.selPions,
Jpsi=self.selJpsi,
# Psi2SJpsiMIPCHI2DV = config['Psi2SJpsiMIPCHI2DV'],
Psi2SPiMIPCHI2DV=config['Psi2SPiMIPCHI2DV'],
Psi2SAM23down=config['Psi2SAM23down'],
Psi2SAM23up=config['Psi2SAM23up'],
Psi2SAPT=config['Psi2SAPT'],
Psi2SADAMASS=config['Psi2SADAMASS'],
Psi2SVFASPF=config['Psi2SVFASPF'],
PIDpi=config['PIDpi'])
self.selChargedK = makeChK(self.name + '_ChKForPsi2SJpsiPiPi',
ChKTRCHI2DOF=config['ChKTRCHI2DOF'],
ChKPID=config['ChKPID'])
self.selPhi2KK = makePhi2KK(self.name + '_PhiForPsi2SJpsiPiPi',
PhiWin=config['PhiWin'],
PhiPT=config['PhiPT'],
PhiVFASPF=config['PhiVFASPF'],
PhiMAXTRCHI2DOF=config['PhiMAXTRCHI2DOF'],
PhiMINTRCHI2DOF=config['PhiMINTRCHI2DOF'])
self.selKstar = makeKstar(self.name + '_KstarForPsi2SJpsiPiPi',
KstMassDown=config['KstMassDown'],
KstMassUp=config['KstMassUp'],
KstAPT=config['KstAPT'],
KstVFASPF=config['KstVFASPF'],
KstTRCHI2DOF=config['KstTRCHI2DOF'],
KstPIDK=config['KstPIDK'],
KstPIDpi=config['KstPIDpi'])
self.selKsLoose = makeKsLoose(self.name + '_KsLooseForPsi2SJpsiPiPi')
self.selKs = makeKs(self.name + '_KsForPsi2SJpsiPiPi',
KsLooseSel=self.selKsLoose,
KsVFASPF=config['KsVFASPF'],
KsBPVDLS=config['KsBPVDLS'])
####################
### Inlusive psi(2S). We keep it for as long as we can.
####################
self.InclPsi2SToJpsiPiPi = makeInclPsi2SToJpsiPiPi(
incl, Psi2SSel=self.selPsi2S2JpsiPiPi)
self.InclPsi2SToJpsiPiPi_line = StrippingLine(
incl + "Line",
prescale=config['incl_LinePrescale'],
postscale=config['incl_LinePostscale'],
selection=self.InclPsi2SToJpsiPiPi)
#####################
### Bs->Psi(2S)Phi ##
#####################
self.selBs2Psi2SPhiJpsiPiPi = makeBs2Psi2SPhiJpsiPiPi(
sig,
Psi2SSel=self.selPsi2S2JpsiPiPi,
PhiSel=self.selPhi2KK,
BsMassCutDownPre=config['BsMassCutDownPre'],
BsMassCutUpPre=config['BsMassCutUpPre'],
BsMassCutDownPost=config['BsMassCutDownPost'],
BsMassCutUpPost=config['BsMassCutUpPost'],
BsVCHI2PDOF=config['BsVCHI2PDOF'],
BPVLTIME=config['BPVLTIME_detatched'])
self.Bs2Psi2SPhiJpsiPiPi_line = StrippingLine(
sig + "Line",
prescale=config['sig_LinePrescale'],
postscale=config['sig_LinePostscale'],
selection=self.selBs2Psi2SPhiJpsiPiPi)
#####################
### Bu->Psi(2S)K+ ###
#####################
self.selBu2Psi2SKJpsiPiPi = makeBu2Psi2SKJpsiPiPi(
K,
Psi2SSel=self.selPsi2S2JpsiPiPi,
ChKSel=self.selChargedK,
ChKPT=config['ChKPT'],
BsMassCutDownPre=config['BsMassCutDownPre'],
BsMassCutUpPre=config['BsMassCutUpPre'],
BsMassCutDownPost=config['BsMassCutDownPost'],
BsMassCutUpPost=config['BsMassCutUpPost'],
BsVCHI2PDOF=config['BsVCHI2PDOF'],
BPVLTIME=config['BPVLTIME_detatched'])
self.Bu2Psi2SKJpsiPiPi_line = StrippingLine(
K + "Line",
prescale=config['K_LinePrescale'],
postscale=config['K_LinePostscale'],
selection=self.selBu2Psi2SKJpsiPiPi)
#####################
### B0->Psi(2S)K* ##
#####################
self.selBd2Psi2SKstarJpsiPiPi = makeBd2Psi2SKstarJpsiPiPi(
Kstar,
Psi2SSel=self.selPsi2S2JpsiPiPi,
KstarSel=self.selKstar,
BsMassCutDownPre=config['BsMassCutDownPre'],
BsMassCutUpPre=config['BsMassCutUpPre'],
BsMassCutDownPost=config['BsMassCutDownPost'],
BsMassCutUpPost=config['BsMassCutUpPost'],
BsVCHI2PDOF=config['BsVCHI2PDOF'],
MINTREEPT2=config['MINTREEPT2'],
BPVLTIME=config['BPVLTIME_detatched'])
self.Bd2Psi2SKstarJpsiPiPi_line = StrippingLine(
Kstar + "Line",
prescale=config['Kstar_LinePrescale'],
postscale=config['Kstar_LinePostscale'],
selection=self.selBd2Psi2SKstarJpsiPiPi)
#####################
### Bd->Psi(2S)KS ###
#####################
self.selBd2Psi2SKsJpsiPiPi = makeBd2Psi2SKsJpsiPiPi(
Ks,
Psi2SSel=self.selPsi2S2JpsiPiPi,
KsSel=self.selKs,
BsMassCutDownPre=config['BsMassCutDownPre'],
BsMassCutUpPre=config['BsMassCutUpPre'],
BsMassCutDownPost=config['BsMassCutDownPost'],
BsMassCutUpPost=config['BsMassCutUpPost'],
BKsVCHI2PDOF=config['BKsVCHI2PDOF'])
self.Bd2Psi2SKsJpsiPiPi_line = StrippingLine(
Ks + "Line",
prescale=config['Ks_LinePrescale'],
postscale=config['Ks_LinePostscale'],
selection=self.selBd2Psi2SKsJpsiPiPi)
self.registerLine(self.InclPsi2SToJpsiPiPi_line)
self.registerLine(self.Bs2Psi2SPhiJpsiPiPi_line)
self.registerLine(self.Bu2Psi2SKJpsiPiPi_line)
self.registerLine(self.Bd2Psi2SKstarJpsiPiPi_line)
self.registerLine(self.Bd2Psi2SKsJpsiPiPi_line)
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[ 'WMu_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):
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.__confdict__ = config
############### MUON SELECTIONS ###################
self.selmuon = Selection("Mufor" + name,
Algorithm=self._muonFilter(),
RequiredSelections=[StdLooseMuons])
self.selmuonhighPT = Selection(
"MuhighPTfor" + name,
Algorithm=FilterDesktop(
Code=
"(TRCHI2DOF < %(TRCHI2)s) & (PT>1.2*GeV) & (MIPCHI2DV(PRIMARY)> 9.0)"
% self.__confdict__),
RequiredSelections=[self.selmuon])
self.selmuontight = Selection(
"Mutightfor" + name,
Algorithm=FilterDesktop(Code="(MIPCHI2DV(PRIMARY)> 100)"),
RequiredSelections=[self.selmuonhighPT])
self.selmuonnew = Selection(
"Munewfor" + name,
Algorithm=FilterDesktop(
Code="(MIPCHI2DV(PRIMARY)> 9.0) & (TRCHI2DOF < %(TRCHI2)s)" %
self.__confdict__),
RequiredSelections=[self.selmuon])
############### 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])
################ D0 -> 4H SELECTION ##########################
self.seld02k3pi = Selection(
"D02K3Pifor" + name,
Algorithm=self._D02K3PiFilter(),
RequiredSelections=[self.selKaon, StdLoosePions])
################ D+/Ds+ -> HHH SELECTIONS ##########################
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])
############ Lambda_c+ -> pKpi ########################
self.sellambdac = Selection(
"Lc2PKPifor" + name,
Algorithm=self._Lc2PKPiFilter(),
RequiredSelections=[self.selKaon, self.selPion, StdLooseProtons])
################ MAKE THE B CANDIDATES #################################
self.selb2D0MuX = makeCrossSectionb2DMuX(
'b2D0MuX' + name,
DecayDescriptors=['[B- -> D0 mu-]cc'],
MuSel=self.selmuonhighPT,
DSel=self.seld02kpi,
BVCHI2DOF=config['BVCHI2DOF'],
BDIRA=config['BDIRA'],
DZ=config['DZ'])
self.selb2D0MuXK3Pi = makeCrossSectionb2DMuX(
'b2D0MuXK3Pi' + name,
DecayDescriptors=['[B- -> D0 mu-]cc', '[B+ -> D0 mu+]cc'],
MuSel=self.selmuontight,
DSel=self.seld02k3pi,
BVCHI2DOF=config['BVCHI2DOF'],
BDIRA=config['BDIRA'],
DZ=config['DZ'])
self.selb2DpMuX = makeCrossSectionb2DMuX(
'b2DpMuX' + name,
DecayDescriptors=['[B0 -> D- mu+]cc', '[B0 -> D- mu-]cc'],
MuSel=self.selmuonnew,
DSel=self.seldp2kpipi,
BVCHI2DOF=config['BVCHI2DOF'],
BDIRA=config['BDIRA'],
DZ=config['DZ'])
self.selb2DsMuX = makeCrossSectionb2DMuX(
'b2DsMuX' + name,
DecayDescriptors=['[B0 -> D- mu+]cc', '[B0 -> D- mu-]cc'],
MuSel=self.selmuonnew,
DSel=self.selds2kkpi,
BVCHI2DOF=config['BVCHI2DOF'],
BDIRA=config['BDIRA'],
DZ=config['DZ'])
self.selb2LcMuX = makeCrossSectionb2DMuX(
'b2LcMuX' + name,
DecayDescriptors=[
'[Lambda_b0 -> Lambda_c+ mu-]cc',
'[Lambda_b0 -> Lambda_c+ mu+]cc'
],
MuSel=self.selmuonnew,
DSel=self.sellambdac,
BVCHI2DOF=config['BVCHI2DOF'],
BDIRA=config['BDIRA'],
DZ=config['DZ'])
################# DECLARE THE STRIPPING LINES #################################
self.b2D0MuXLine = StrippingLine('b2D0MuX' + name + 'Line',
prescale=1,
selection=self.selb2D0MuX)
self.b2DpMuXLine = StrippingLine('b2DpMuX' + name + 'Line',
prescale=1,
selection=self.selb2DpMuX)
self.b2DsMuXLine = StrippingLine('b2DsMuX' + name + 'Line',
prescale=1,
selection=self.selb2DsMuX)
self.b2D0MuXK3PiLine = StrippingLine('b2D0MuXK3Pi' + name + 'Line',
prescale=1,
selection=self.selb2D0MuXK3Pi)
self.b2LcMuXLine = StrippingLine('b2LcMuX' + name + 'Line',
prescale=1,
selection=self.selb2LcMuX)
############## REGISTER THE LINES #####################
self.registerLine(self.b2D0MuXLine)
self.registerLine(self.b2DpMuXLine)
self.registerLine(self.b2DsMuXLine)
self.registerLine(self.b2LcMuXLine)
self.registerLine(self.b2D0MuXK3PiLine)
def __init__(self, name, config):
self._name = name
self._config = config
LineBuilder.__init__(self, self._name, self._config)
# Make gamma, pion, muon and electrons
self.pion = Selection("PionFor{0}".format(name),
Algorithm=self._pionFilter(),
RequiredSelections=[StdLoosePions])
self.gamma = Selection("GammaFor{0}".format(name),
Algorithm=self._gammaFilter(),
RequiredSelections=[StdLooseAllPhotons])
self.highPTgamma = Selection("highPTGammaFor{0}".format(name),
Algorithm=self._highPTgammaFilter(),
RequiredSelections=[self.gamma])
self.veryhighPTgamma = Selection(
"veryhighPTGammaFor{0}".format(name),
Algorithm=self._veryhighPTgammaFilter(),
RequiredSelections=[self.highPTgamma])
self.kaon = Selection("KaonFor{0}".format(name),
Algorithm=self._kaonFilter(),
RequiredSelections=[StdLooseKaons])
self.muon = Selection("Muon{0}".format(name),
Algorithm=self._muonFilter(),
RequiredSelections=[StdLooseMuons])
self.dielectrons = DataOnDemand(
Location="Phys/StdDiElectronFromTracks/Particles")
# Make selections for decay
SetConfig = config['PromptHPi0']
PiPi0PromptSelection = self.makePromptCandidate(
self._name + 'PiPi0PromptSelection', '[D+ -> pi+ pi0]cc',
self.pion,
self.makeRes('Pi0+PiFor{0}'.format(name), 'pi0 -> J/psi(1S) gamma',
self.gamma, self.dielectrons, SetConfig), SetConfig)
KPi0PromptSelection = self.makePromptCandidate(
self._name + 'KPi0PromptSelection', '[D+ -> K+ pi0]cc', self.kaon,
self.makeRes('Pi0+KFor{0}'.format(name), 'pi0 -> J/psi(1S) gamma',
self.gamma, self.dielectrons, SetConfig), SetConfig)
SetConfig = config['PromptHEta']
PiEtaPromptSelection = self.makePromptCandidate(
self._name + 'PiEtaPromptSelection', '[D+ -> pi+ eta]cc',
self.pion,
self.makeRes('Eta+PiFor{0}'.format(name), 'eta -> pi+ pi- gamma',
self.highPTgamma, self.pion, SetConfig), SetConfig)
KEtaPromptSelection = self.makePromptCandidate(
self._name + 'KEtaPromptSelection', '[D+ -> K+ eta]cc', self.kaon,
self.makeRes('Eta+KFor{0}'.format(name), 'eta -> pi+ pi- gamma',
self.highPTgamma, self.pion, SetConfig), SetConfig)
SetConfig = config['PromptHEtaPrime']
PiEtaPrimePromptSelection = self.makePromptCandidate(
self._name + 'PiEtaPrimePromptSelection', '[D+ -> pi+ eta]cc',
self.pion,
self.makeRes('EtaPrime+PiFor{0}'.format(name),
'eta -> pi+ pi- gamma', self.veryhighPTgamma,
self.pion, SetConfig), SetConfig)
KEtaPrimePromptSelection = self.makePromptCandidate(
self._name + 'KEtaPrimePromptSelection', '[D+ -> K+ eta]cc',
self.kaon,
self.makeRes('EtaPrime+KFor{0}'.format(name),
'eta -> pi+ pi- gamma', self.veryhighPTgamma,
self.pion, SetConfig), SetConfig)
# For the SL mode (D2PiPi0 only)
SetConfig = config['SLHPi0']
PiPi0SLSelection = self.makePromptCandidate(
self._name + 'PiPi0SLSelection', '[D+ -> pi+ pi0]cc', self.pion,
self.makeRes('SLPi0+PiFor{0}'.format(name),
'pi0 -> J/psi(1S) gamma', self.gamma,
self.dielectrons, SetConfig), SetConfig)
SemiLeptonicSelection = self.makeSemiLeptonicCandidate(
self._name + 'SemiLeptonicSelection',
PiPi0SLSelection, #D candidates from prompt line
self.muon,
SetConfig)
# Create stripping lines
PiPi0PromptLine = StrippingLine(self._name + 'PiPi0PromptLine',
selection=PiPi0PromptSelection)
KPi0PromptLine = StrippingLine(self._name + 'KPi0PromptLine',
selection=KPi0PromptSelection)
PiEtaPromptLine = StrippingLine(self._name + 'PiEtaPromptLine',
selection=PiEtaPromptSelection)
KEtaPromptLine = StrippingLine(self._name + 'KEtaPromptLine',
selection=KEtaPromptSelection)
PiEtaPrimePromptLine = StrippingLine(
self._name + 'PiEtaPrimePromptLine',
selection=PiEtaPrimePromptSelection)
KEtaPrimePromptLine = StrippingLine(self._name + 'KEtaPrimePromptLine',
selection=KEtaPrimePromptSelection)
SemiLeptonicLine = StrippingLine(self._name + 'SemiLeptonicLine',
selection=SemiLeptonicSelection)
# Register lines
self.registerLine(PiPi0PromptLine)
self.registerLine(KPi0PromptLine)
self.registerLine(PiEtaPromptLine)
self.registerLine(KEtaPromptLine)
self.registerLine(PiEtaPrimePromptLine)
self.registerLine(KEtaPrimePromptLine)
self.registerLine(SemiLeptonicLine)
def __init__(self, name, config) :
LineBuilder.__init__(self, name, config)
dd_name = name+'DD'
ll_name = name+'LL'
ld_name = name+'LD'
dd_name_same = name+'DD'+'SameSign'
ll_name_same = name+'LL'+'SameSign'
ld_name_same = name+'LD'+'SameSign'
GECCode = {'Code' : "(recSummaryTrack(LHCb.RecSummary.nLongTracks, TrLONG) < %s)" % config['GEC_MaxTracks'],
'Preambulo' : ["from LoKiTracks.decorators import *"]}
self.pions = Pions
self.kaons = Kaons
self.makeKS2DD( 'KSfor'+dd_name, config )
self.makeKS2LL( 'KSfor'+ll_name, config )
self.makeKS2LD( 'KSfor'+ld_name, config )
self.makeB2KSDDhh( dd_name+"_Presel", config )
self.makeB2KSLLhh( ll_name+"_Presel", config )
self.makeB2KSLDhh( ld_name+"_Presel", config )
self.makeB2KSDDhh( dd_name_same+"_Presel", config )
self.makeB2KSLLhh( ll_name_same+"_Presel", config )
self.makeB2KSLDhh( ld_name_same+"_Presel", config )
# MVA algorithm on the top of the Presel
self.applyBDT( dd_name, config )
self.applyBDT( ll_name, config )
self.applyBDT( ld_name, config )
self.applyBDT( dd_name_same, config )
self.applyBDT( ll_name_same, config )
self.applyBDT( ld_name_same, config )
self.dd_line = StrippingLine(dd_name+"Line",
prescale = config['Prescale'],
postscale = config['Postscale'],
selection = self.selB2KSDDhhBDTCut,
HLT = "(HLT_PASS_RE('Hlt1TrackAllL0Decision') & HLT_PASS_RE('Hlt2Topo[234]Body.*Decision'))",
FILTER = GECCode
)
self.ll_line = StrippingLine(ll_name+"Line",
prescale = config['Prescale'],
postscale = config['Postscale'],
selection = self.selB2KSLLhhBDTCut,
HLT = "(HLT_PASS_RE('Hlt1TrackAllL0Decision') & HLT_PASS_RE('Hlt2Topo[234]Body.*Decision'))",
FILTER = GECCode
)
self.ld_line = StrippingLine(ld_name+"Line",
prescale = config['Prescale'],
postscale = config['Postscale'],
selection = self.selB2KSLDhhBDTCut,
HLT = "(HLT_PASS_RE('Hlt1TrackAllL0Decision') & HLT_PASS_RE('Hlt2Topo[234]Body.*Decision'))",
FILTER = GECCode
)
self.dd_line_same = StrippingLine(dd_name_same+"Line",
prescale = config['Prescale_SameSign'],
postscale = config['Postscale'],
selection = self.selB2KSDDhhBDTCut_SameSign,
HLT = "(HLT_PASS_RE('Hlt1TrackAllL0Decision') & HLT_PASS_RE('Hlt2Topo[234]Body.*Decision'))",
FILTER = GECCode
)
self.ll_line_same = StrippingLine(ll_name_same+"Line",
prescale = config['Prescale_SameSign'],
postscale = config['Postscale'],
selection = self.selB2KSLLhhBDTCut_SameSign,
HLT = "(HLT_PASS_RE('Hlt1TrackAllL0Decision') & HLT_PASS_RE('Hlt2Topo[234]Body.*Decision'))",
FILTER = GECCode
)
self.ld_line_same = StrippingLine(ld_name_same+"Line",
prescale = config['Prescale_SameSign'],
postscale = config['Postscale'],
selection = self.selB2KSLDhhBDTCut_SameSign,
HLT = "(HLT_PASS_RE('Hlt1TrackAllL0Decision') & HLT_PASS_RE('Hlt2Topo[234]Body.*Decision'))",
FILTER = GECCode
)
self.registerLine(self.dd_line)
self.registerLine(self.ll_line)
self.registerLine(self.ld_line)
self.registerLine(self.dd_line_same)
self.registerLine(self.ll_line_same)
self.registerLine(self.ld_line_same)
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 __init__(self, name, config):
"""Initialise a LineBuilder instance registered with this line.
Keyword arguments:
name -- String passed to the LineBuilder constructor
config -- Dictionary of cuts to apply
"""
self.name = name
self.config = config
# Initialise the parent LineBuilder
LineBuilder.__init__(self, self.name, self.config)
# Final state cut strings
track_cuts = [
"P > {0[TrackP]}",
"PT > {0[TrackPT]}",
"MIPCHI2DV(PRIMARY) > {0[TrackIPCHI2]}",
]
kaon_cuts = cut_string(track_cuts + ["PROBNNk > {0[ProbNNk]}"],
self.config)
pion_cuts = cut_string(track_cuts + ["PROBNNpi > {0[ProbNNpi]}"],
self.config)
proton_cuts = cut_string(track_cuts + ["PROBNNp > {0[ProbNNp]}"],
self.config)
# Create final state filters
self.kaons = Selection(name="KaonSelectionFor{0}".format(name),
Algorithm=FilterDesktop(
name="KaonFilterFor{0}".format(name),
Code=kaon_cuts),
RequiredSelections=[StdLooseANNKaons])
self.pions = Selection(name="PionSelectionFor{0}".format(name),
Algorithm=FilterDesktop(
name="PionFilterFor{0}".format(name),
Code=pion_cuts),
RequiredSelections=[StdLooseANNPions])
self.protons = Selection(name="ProtonSelectionFor{0}".format(name),
Algorithm=FilterDesktop(
name="ProtonFilterFor{0}".format(name),
Code=proton_cuts),
RequiredSelections=[StdLooseANNProtons])
# Lambda_c selection
lc = self.make_partial_lc("LcSelectionFor{0}".format(self.name))
# B+/B0 selection
b_combination_cuts = cut_string([
"AM - 10 > {0[BPartialMassMin]}", "AM + 10 < {0[BPartialMassMax]}",
"APT > {0[BPTSum]}"
], self.config)
b_mother_cuts = cut_string([
"M > {0[BPartialMassMin]}", "M < {0[BPartialMassMax]}",
"BPVIPCHI2() < {0[BBPVIPCHI2]}",
"VFASPF(VCHI2/VDOF) < {0[BVCHI2DOF]}",
"(CHILD(VFASPF(VZ), 1) - VFASPF(VZ)) > {0[BMinZ]}",
"BPVVDCHI2 > {0[BFDCHI2]}"
], self.config)
bd = self.make_partial_mother("BdSelectionFor{0}".format(self.name),
self.bd_decay,
[lc, self.pions, self.protons],
b_combination_cuts, b_mother_cuts)
bu = self.make_partial_mother("BuSelectionFor{0}".format(self.name),
self.bu_decay,
[lc, self.pions, self.protons],
b_combination_cuts, b_mother_cuts)
# Lambda_b selections
lb_combination_cuts = cut_string(
["AM + 20 < {0[LbPartialMassMax]}", "APT > {0[LbPTSum]}"],
self.config)
lb_mother_cuts = cut_string([
"M < {0[LbPartialMassMax]}", "BPVIPCHI2() < {0[LbBPVIPCHI2]}",
"VFASPF(VCHI2/VDOF) < {0[LbVCHI2DOF]}",
"(CHILD(VFASPF(VZ), 1) - VFASPF(VZ)) > {0[LbMinZ]}",
"BPVVDCHI2 > {0[LbFDCHI2]}"
], self.config)
# 1pi and 3pi modes have different mass thresholds
lb_1pi_combination_cuts = cut_string(
["AM - 20 > {0[LbToLc1piPartialMassMin]}", lb_combination_cuts],
self.config)
lb_3pi_combination_cuts = cut_string(
["AM - 20 > {0[LbToLc3piPartialMassMin]}", lb_combination_cuts],
self.config)
lb_1pi_mother_cuts = cut_string(
["M > {0[LbToLc1piPartialMassMin]}", lb_mother_cuts], self.config)
lb_3pi_mother_cuts = cut_string(
["M > {0[LbToLc3piPartialMassMin]}", lb_mother_cuts], self.config)
lb_1pi = self.make_partial_mother(
"Lb1PiSelectionFor{0}".format(self.name), self.lb_1pi_decay,
[lc, self.pions], lb_1pi_combination_cuts, lb_1pi_mother_cuts)
lb_3pi = self.make_partial_mother(
"Lb3PiSelectionFor{0}".format(self.name), self.lb_3pi_decay,
[lc, self.pions], lb_3pi_combination_cuts, lb_3pi_mother_cuts)
# Sigma_c selections
sc_combination_cuts = cut_string([
"AM - 20 > {0[ScPartialMassMin]}",
"AM + 20 < {0[ScPartialMassMax]}"
], self.config)
sc_mother_cuts = cut_string([
"M > {0[ScPartialMassMin]}", "M < {0[ScPartialMassMax]}",
"BPVIPCHI2() < {0[ScBPVIPCHI2]}",
"VFASPF(VCHI2/VDOF) < {0[ScVCHI2DOF]}",
"(CHILD(VFASPF(VZ), 1) - VFASPF(VZ)) > {0[ScMinZ]}"
], self.config)
sc_pip = self.make_partial_mother(
"ScPipSelectionFor{0}".format(self.name), self.sc_pip_decay,
[lc, self.pions], sc_combination_cuts, sc_mother_cuts)
sc_pim = self.make_partial_mother(
"ScPimSelectionFor{0}".format(self.name), self.sc_pim_decay,
[lc, self.pions], sc_combination_cuts, sc_mother_cuts)
# Lambda_c* selections
lcst_combination_cuts = cut_string([
"AM - 20 > {0[LcstPartialMassMin]}",
"AM + 20 < {0[LcstPartialMassMax]}"
], self.config)
lcst_mother_cuts = cut_string([
"M > {0[LcstPartialMassMin]}", "M < {0[LcstPartialMassMax]}",
"BPVIPCHI2() < {0[LcstBPVIPCHI2]}",
"VFASPF(VCHI2/VDOF) < {0[LcstVCHI2DOF]}",
"(CHILD(VFASPF(VZ), 1) - VFASPF(VZ)) > {0[LcstMinZ]}"
], self.config)
lcst = self.make_partial_mother(
"LcstSelectionFor{0}".format(self.name), self.lcst_decay,
[lc, self.pions], lcst_combination_cuts, lcst_mother_cuts)
#Make Full lines
b_combination_cuts_full = cut_string([
"AM - 20 > {0[BuMinWin]}", "AM + 20 < {0[BuMaxWin]}",
"sqrt(((ACHILD(CHILD(E,1),1)+ACHILD(E,2))**2)-((ACHILD(CHILD(PX,1),1)+ACHILD(PX,2))**2)-((ACHILD(CHILD(PY,1),1)+ACHILD(PY,2))**2)-((ACHILD(CHILD(PZ,1),1)+ACHILD(PZ,2))**2))-20>{0[LcMinWin]}",
"sqrt(((ACHILD(CHILD(E,1),1)+ACHILD(E,2))**2)-((ACHILD(CHILD(PX,1),1)+ACHILD(PX,2))**2)-((ACHILD(CHILD(PY,1),1)+ACHILD(PY,2))**2)-((ACHILD(CHILD(PZ,1),1)+ACHILD(PZ,2))**2))+20<{0[LcMaxWin]}"
], self.config)
b_mother_cuts_full = cut_string([
"M > {0[BuMinWin]}", "M < {0[BuMaxWin]}",
"sqrt(((CHILD(CHILD(E,1),1)+CHILD(E,2))**2)-((CHILD(CHILD(PX,1),1)+CHILD(PX,2))**2)-((CHILD(CHILD(PY,1),1)+CHILD(PY,2))**2)-((CHILD(CHILD(PZ,1),1)+CHILD(PZ,2))**2))>{0[LcMinWin]}",
"sqrt(((CHILD(CHILD(E,1),1)+CHILD(E,2))**2)-((CHILD(CHILD(PX,1),1)+CHILD(PX,2))**2)-((CHILD(CHILD(PY,1),1)+CHILD(PY,2))**2)-((CHILD(CHILD(PZ,1),1)+CHILD(PZ,2))**2))<{0[LcMaxWin]}"
], self.config)
bd_full = self.make_full_mother(
"BdSelectionFullFor{0}".format(self.name), self.bd_decay_full,
[bd, StdAllNoPIDsProtons], b_combination_cuts_full,
b_mother_cuts_full)
bu_full = self.make_full_mother(
"BuSelectionFullFor{0}".format(self.name), self.bu_decay_full,
[bu, StdAllNoPIDsProtons], b_combination_cuts_full,
b_mother_cuts_full)
lb_combination_cuts_full = cut_string([
"AM - 20 > {0[LbMinWin]}", "AM + 20 < {0[LbMaxWin]}",
"sqrt(((ACHILD(CHILD(E,1),1)+ACHILD(E,2))**2)-((ACHILD(CHILD(PX,1),1)+ACHILD(PX,2))**2)-((ACHILD(CHILD(PY,1),1)+ACHILD(PY,2))**2)-((ACHILD(CHILD(PZ,1),1)+ACHILD(PZ,2))**2))-20>{0[LcMinWin]}",
"sqrt(((ACHILD(CHILD(E,1),1)+ACHILD(E,2))**2)-((ACHILD(CHILD(PX,1),1)+ACHILD(PX,2))**2)-((ACHILD(CHILD(PY,1),1)+ACHILD(PY,2))**2)-((ACHILD(CHILD(PZ,1),1)+ACHILD(PZ,2))**2))+20<{0[LcMaxWin]}"
], self.config)
lb_mother_cuts_full = cut_string([
"M > {0[LbMinWin]}", "M < {0[LbMaxWin]}",
"sqrt(((CHILD(CHILD(E,1),1)+CHILD(E,2))**2)-((CHILD(CHILD(PX,1),1)+CHILD(PX,2))**2)-((CHILD(CHILD(PY,1),1)+CHILD(PY,2))**2)-((CHILD(CHILD(PZ,1),1)+CHILD(PZ,2))**2))>{0[LcMinWin]}",
"sqrt(((CHILD(CHILD(E,1),1)+CHILD(E,2))**2)-((CHILD(CHILD(PX,1),1)+CHILD(PX,2))**2)-((CHILD(CHILD(PY,1),1)+CHILD(PY,2))**2)-((CHILD(CHILD(PZ,1),1)+CHILD(PZ,2))**2))<{0[LcMaxWin]}"
], self.config)
lb_1pi_full = self.make_full_mother(
"Lb1PiSelectionFullFor{0}".format(self.name),
self.lb_1pi_decay_full, [lb_1pi, StdAllNoPIDsProtons],
lb_combination_cuts_full, lb_mother_cuts_full)
lb_3pi_full = self.make_full_mother(
"Lb3PiSelectionFullFor{0}".format(self.name),
self.lb_3pi_decay_full, [lb_3pi, StdAllNoPIDsProtons],
lb_combination_cuts_full, lb_mother_cuts_full)
sc_combination_cuts_full = cut_string([
"AM - 20 > {0[ScMinWin]}", "AM + 20 < {0[ScMaxWin]}",
"sqrt(((ACHILD(CHILD(E,1),1)+ACHILD(E,2))**2)-((ACHILD(CHILD(PX,1),1)+ACHILD(PX,2))**2)-((ACHILD(CHILD(PY,1),1)+ACHILD(PY,2))**2)-((ACHILD(CHILD(PZ,1),1)+ACHILD(PZ,2))**2))-20>{0[LcMinWin]}",
"sqrt(((ACHILD(CHILD(E,1),1)+ACHILD(E,2))**2)-((ACHILD(CHILD(PX,1),1)+ACHILD(PX,2))**2)-((ACHILD(CHILD(PY,1),1)+ACHILD(PY,2))**2)-((ACHILD(CHILD(PZ,1),1)+ACHILD(PZ,2))**2))+20<{0[LcMaxWin]}"
], self.config)
sc_mother_cuts_full = cut_string([
"M > {0[ScMinWin]}", "M < {0[ScMaxWin]}",
"sqrt(((CHILD(CHILD(E,1),1)+CHILD(E,2))**2)-((CHILD(CHILD(PX,1),1)+CHILD(PX,2))**2)-((CHILD(CHILD(PY,1),1)+CHILD(PY,2))**2)-((CHILD(CHILD(PZ,1),1)+CHILD(PZ,2))**2))>{0[LcMinWin]}",
"sqrt(((CHILD(CHILD(E,1),1)+CHILD(E,2))**2)-((CHILD(CHILD(PX,1),1)+CHILD(PX,2))**2)-((CHILD(CHILD(PY,1),1)+CHILD(PY,2))**2)-((CHILD(CHILD(PZ,1),1)+CHILD(PZ,2))**2))<{0[LcMaxWin]}"
], self.config)
sc_pip_full = self.make_full_mother(
"ScPipSelectionFullFor{0}".format(self.name),
self.sc_pip_decay_full, [sc_pip, StdAllNoPIDsProtons],
sc_combination_cuts_full, sc_mother_cuts_full)
sc_pim_full = self.make_full_mother(
"ScPimSelectionFullFor{0}".format(self.name),
self.sc_pim_decay_full, [sc_pim, StdAllNoPIDsProtons],
sc_combination_cuts_full, sc_mother_cuts_full)
lcst_combination_cuts_full = cut_string([
"AM - 20 > {0[LcstMinWin]}", "AM + 20 < {0[LcstMaxWin]}",
"sqrt(((ACHILD(CHILD(E,1),1)+ACHILD(E,2))**2)-((ACHILD(CHILD(PX,1),1)+ACHILD(PX,2))**2)-((ACHILD(CHILD(PY,1),1)+ACHILD(PY,2))**2)-((ACHILD(CHILD(PZ,1),1)+ACHILD(PZ,2))**2))-20>{0[LcMinWin]}",
"sqrt(((ACHILD(CHILD(E,1),1)+ACHILD(E,2))**2)-((ACHILD(CHILD(PX,1),1)+ACHILD(PX,2))**2)-((ACHILD(CHILD(PY,1),1)+ACHILD(PY,2))**2)-((ACHILD(CHILD(PZ,1),1)+ACHILD(PZ,2))**2))+20<{0[LcMaxWin]}"
], self.config)
lcst_mother_cuts_full = cut_string([
"M > {0[LcstMinWin]}", "M < {0[LcstMaxWin]}",
"sqrt(((CHILD(CHILD(E,1),1)+CHILD(E,2))**2)-((CHILD(CHILD(PX,1),1)+CHILD(PX,2))**2)-((CHILD(CHILD(PY,1),1)+CHILD(PY,2))**2)-((CHILD(CHILD(PZ,1),1)+CHILD(PZ,2))**2))>{0[LcMinWin]}",
"sqrt(((CHILD(CHILD(E,1),1)+CHILD(E,2))**2)-((CHILD(CHILD(PX,1),1)+CHILD(PX,2))**2)-((CHILD(CHILD(PY,1),1)+CHILD(PY,2))**2)-((CHILD(CHILD(PZ,1),1)+CHILD(PZ,2))**2))<{0[LcMaxWin]}"
], self.config)
lcst_full = self.make_full_mother(
"LcstSelectionFullFor{0}".format(self.name), self.lcst_decay_full,
[lcst, StdAllNoPIDsProtons], lcst_combination_cuts_full,
lcst_mother_cuts_full)
# Create the stripping lines, first partial..
bd_partial_line = self.make_line("Bd2LcppipiLc2Kpi", bd)
bu_partial_line = self.make_line("Bu2LcppipipiLc2Kpi", bu)
lb_partial_1pi_line = self.make_line("Lb2LcpiLc2Kpi", lb_1pi)
lb_partial_3pi_line = self.make_line("Lb2LcpipipiLc2Kpi", lb_3pi)
sc_partial_pip_line = self.make_line("Sc2LcpipLc2Kpi", sc_pip)
sc_partial_pim_line = self.make_line("Sc2LcpimLc2Kpi", sc_pim)
lcst_partial_line = self.make_line("Lcst2LcpipiLc2Kpi", lcst)
# .. then full
bd_full_line = self.make_line("Bd2LcppipiLc2pKpi", bd_full)
bu_full_line = self.make_line("Bu2LcppipipiLc2pKpi", bu_full)
lb_full_1pi_line = self.make_line("Lb2LcpiLc2pKpi", lb_1pi_full)
lb_full_3pi_line = self.make_line("Lb2LcpipipiLc2pKpi", lb_3pi_full)
sc_full_pip_line = self.make_line("Sc2LcpipLc2pKpi", sc_pip_full)
sc_full_pim_line = self.make_line("Sc2LcpimLc2pKpi", sc_pim_full)
lcst_full_line = self.make_line("Lcst2LcpipiLc2pKpi", lcst_full)
# Make the lines visible to the LineBuilder
self.registerLine(bu_partial_line)
self.registerLine(bd_partial_line)
self.registerLine(lb_partial_1pi_line)
self.registerLine(lb_partial_3pi_line)
self.registerLine(sc_partial_pip_line)
self.registerLine(sc_partial_pim_line)
self.registerLine(lcst_partial_line)
# Don't need to save the full reconstruction on DST, all tracks are
# stored anyway
#if self.config["MicroDST"]:
# self.registerLine(bu_full_line)
# self.registerLine(bd_full_line)
# self.registerLine(lb_full_1pi_line)
# self.registerLine(lb_full_3pi_line)
# self.registerLine(sc_full_pip_line)
# self.registerLine(sc_full_pim_line)
# self.registerLine(lcst_full_line)
self.registerLine(bu_full_line)
self.registerLine(bd_full_line)
self.registerLine(lb_full_1pi_line)
self.registerLine(lb_full_3pi_line)
self.registerLine(sc_full_pip_line)
self.registerLine(sc_full_pim_line)
self.registerLine(lcst_full_line)
def __init__( self, name, config ) :
LineBuilder.__init__( self, name, config )
# Define the cuts
_pT = '(PT>%(pT)s)'%config
_pTlow = '(PT>%(pTlow)s)'%config
_pTvlow = '(PT>%(pTvlow)s)'%config
_pTSingMuon10 = '(PT>%(SingMuon10_pT)s)'%config
_pTSingMuon48 = '(PT>%(SingMuon48_pT)s)'%config
#---------------------------#
# Single Muon Control Lines #
#---------------------------#
sel = makeFilter(name+'Mu10', StdAllLooseMuons, _pTSingMuon10)
self.registerLine(StrippingLine( name + 'Control10Line',
prescale = config[ 'SingMuon10_Prescale' ],
postscale = config[ 'WMu_Postscale' ],
HLT2 = config[ 'HLT2_Control10'],
checkPV = False,
selection = sel,
RequiredRawEvents = config['RawEvents'],
))
#-----------------------------------------------------------------
sel = makeFilter(name+'Mu48', StdAllLooseMuons, _pTSingMuon48)
self.registerLine(StrippingLine( name + 'Control4800Line',
prescale = config[ 'SingMuon48_Prescale' ],
postscale = config[ 'WMu_Postscale' ],
HLT2 = config[ 'HLT2_Control4800'],
checkPV = False,
selection = sel,
RequiredRawEvents = config['RawEvents'],
))
#------------#
# WMu signal #
#------------#
sel = makeFilter(name+'Wmu', StdAllLooseMuons, _pT)
self.registerLine(StrippingLine( name + 'Line',
prescale = config[ 'WMu_Prescale' ],
postscale = config[ 'WMu_Postscale' ],
checkPV = False,
selection = sel,
RequiredRawEvents = config['RawEvents'],
))
#-------------#
# WMu control #
#-------------#
sel = makeFilter(name+'WMuLow', StdAllLooseMuons, _pTlow)
self.registerLine(StrippingLine( name + 'LowLine',
prescale = config[ 'WMuLow_Prescale' ],
postscale = config[ 'WMu_Postscale' ],
checkPV = False,
selection = sel,
RequiredRawEvents = config['RawEvents'],
))
#----------------#
# WMu background #
#----------------#
sel = makeFilter(name+'SingleTrackNoBias', StdAllNoPIDsMuons, _pTlow)
self.registerLine(StrippingLine( name + 'SingleTrackNoBiasLine',
prescale = config[ 'WMu_Prescale' ],
postscale = config[ 'WMu_Postscale' ],
HLT1 = config[ 'HLT1_SingleTrackNoBias'],
checkPV = False,
selection = sel,
RequiredRawEvents = config['RawEvents'],
))
#---------------------------
sel = makeFilter(name+'SingleTrackNoBiasPS', StdAllNoPIDsMuons, _pTvlow)
self.registerLine(StrippingLine( name + 'SingleTrackNoBiasLinePS',
prescale = config[ 'STNB_Prescale' ],
postscale = config[ 'WMu_Postscale' ],
HLT1 = config[ 'HLT1_SingleTrackNoBias'],
checkPV = False,
selection = sel,
RequiredRawEvents = config['RawEvents'],
))
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
self.name = name
self.config = config
self.linesCfg = config['Lines']
self.dbug = config['Debug']
### Loops on the lines defined and get line titles
for lineName in self.linesCfg:
### Translate the line name to a dictionary
line = self.linesCfg[lineName]
### Test the prescale. Zero prescale means virtual line.
if self.getVariable(line, 'Prescale') != None:
if (self.getVariable(line, 'Prescale') != 0):
### Defines the filter desktop with the cuts
_tmpFilter = FilterDesktop(Code=self.compileCut(line))
### Binds the algorithm to a DaVinci Selection
_tmpAlgorithm = Selection(
self.name + lineName + 'Sel',
Algorithm=_tmpFilter,
RequiredSelections=[
DataOnDemand(
"Phys/" +
self.getVariable(line, "InputDiMuon") +
"/Particles")
])
### If a check on maxPV is required defines the proper filter
_tmpFilter = {}
if self.getVariable(line, 'maxPV') != None:
_tmpFilter = {
'Code':
"recSummary(LHCb.RecSummary.nPVs, 'Rec/Vertex/Primary')<"
+ str(self.getVariable(line, 'maxPV')),
'Preambulo': [
'from LoKiTracks.decorators import *',
'from LoKiNumbers.decorators import *',
'from LoKiCore.functions import *'
]
}
if self.dbug:
## debug cut writer
print "###################### DiMuonInh Debugger ########################"
print "## " + name + lineName + 'Line'
print "## Input: " + "Phys/" + self.getVariable(
line, "InputDiMuon") + "/Particles"
print "## Parsed Cut: " + self.compileCut(
line).replace(" &", " \n\t\t&")
### If a TOS check is required redefine _tmpAlgorithm to point to TOS filter
if self.getVariable(line, 'TOScut') != None:
_tmpPlainAlgorithm = _tmpAlgorithm
_tmpAlgorithm = self.filterTisTos(
name + lineName + "TOSFilter",
DiMuonInput=_tmpPlainAlgorithm,
myTisTosSpecs=self.getVariable(line, 'TOScut'))
if self.dbug:
print "##################################################################"
### StrippingLine
_tmpDiMuonLine = StrippingLine(
lineName, # name + lineName + 'Line',
prescale=self.getVariable(line, 'Prescale'),
FILTER=_tmpFilter,
checkPV=self.getVariable(line, 'checkPV'),
RequiredRawEvents=self.getVariable(
line, 'RequiredRawEvents'),
algos=[_tmpAlgorithm])
self.registerLine(_tmpDiMuonLine)
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
# Set up global event cuts.
# Conceptually these come first, although the place where they're
# inserted into the line is at the bottom of the code.
_globalEventCuts = "(recSummary (LHCb.RecSummary.nLongTracks, 'Rec/Track/Long') < %(LongTrackGEC)s )" % config
# Pick up standard kaons, pions
# Filter them for use as daughter particles:
self.dauPi = filterPions(name + 'FilteredPions')
self.dauK = filterKaons(name + 'FilteredKaons')
# Pick up standard Lambdac -> p K- pi+ then filter it to reduce rate:
self.filterLc = makeLc(name + 'FilterLc')
self.filterLcForControl = filterLcForControl(
name + 'FilterLcForControl', self.filterLc)
# Some generic cuts for Xicc. Vertex chi2 cut depends on number of daughters (2 dau => 1 NDF; 3 dau => 3 NDF; 4 dau => 5 NDF)
_strCutComb = '(APT>2000.0*MeV)'
_strCutMoth2 = '( (BPVDIRA > 0.999) & (VFASPF(VCHI2)<20.0) & (BPVVDCHI2 > 16) & (M < 4500*MeV) & (CHILD(VFASPF(VZ),1) - VFASPF(VZ) > 0.01*mm) )'
_strCutMoth3 = '( (BPVDIRA > 0.999) & (VFASPF(VCHI2)<30.0) & (BPVVDCHI2 > 16) & (M < 4500*MeV) & (CHILD(VFASPF(VZ),1) - VFASPF(VZ) > 0.01*mm) )'
_strCutMoth4 = '( (BPVDIRA > 0.999) & (VFASPF(VCHI2)<60.0) & (BPVVDCHI2 > 16) & (M < 4500*MeV) & (CHILD(VFASPF(VZ),1) - VFASPF(VZ) > 0.01*mm) )'
# Combine Lambda with pion to make Xi-
self.stdLambdaLL = DataOnDemand(
Location='Phys/StdLooseLambdaLL/Particles')
self.stdLambdaDD = DataOnDemand(
Location='Phys/StdLooseLambdaDD/Particles')
self.combineXiLL = makeXi(name + 'CombineXiLL', self.stdLambdaLL, 50,
35)
self.combineXiDD = makeXi(name + 'CombineXiDD', self.stdLambdaDD, 80,
50)
# Combine Xi- with pion(s) to make Xic0, Xic+
self.combineXicZero = makeXicZero(
name + "CombineXicZero",
[self.combineXiLL, self.combineXiDD, self.dauPi])
self.combineXicPlus = makeXicPlus(
name + "CombineXicPlus",
[self.combineXiLL, self.combineXiDD, self.dauPi])
# Combine Lc+ with a K and a pi to make a Xicc+ or Xicc++:
self.combineXicc1 = makeXicc(name + 'CombineXicc1',
[self.filterLc, self.dauPi, self.dauK],
'[Xi_cc+ -> Lambda_c+ K- pi+]cc',
_strCutComb, _strCutMoth3)
self.combineXicc2 = makeXicc(name + 'CombineXicc2',
[self.filterLc, self.dauPi, self.dauK],
'[Xi_cc++ -> Lambda_c+ K- pi+ pi+]cc',
_strCutComb, _strCutMoth4)
# Combine Xic0/+ with pion(s) to make Xicc+, Xicc++
self.combineXicc3 = makeXicc(name + 'CombineXicc3',
[self.combineXicZero, self.dauPi],
'[Xi_cc+ -> Xi_c0 pi+]cc', _strCutComb,
_strCutMoth2)
self.combineXicc4 = makeXicc(name + 'CombineXicc4',
[self.combineXicZero, self.dauPi],
'[Xi_cc++ -> Xi_c0 pi+ pi+]cc',
_strCutComb, _strCutMoth3)
self.combineXicc5 = makeXicc(name + 'CombineXicc5',
[self.combineXicPlus, self.dauPi],
'[Xi_cc+ -> Xi_c+ pi+ pi-]cc',
_strCutComb, _strCutMoth3)
self.combineXicc6 = makeXicc(name + 'CombineXicc6',
[self.combineXicPlus, self.dauPi],
'[Xi_cc++ -> Xi_c+ pi+]cc', _strCutComb,
_strCutMoth2)
# Control lines (to be prescaled!)
self.lineControl1 = StrippingLine(name + 'ControlLc',
prescale=config['controlPrescaleLc'],
postscale=1.0,
FILTER=_globalEventCuts,
selection=self.filterLcForControl)
self.lineControl2 = StrippingLine(
name + 'ControlXicZero',
prescale=config['controlPrescaleXic'],
postscale=1.0,
FILTER=_globalEventCuts,
selection=self.combineXicZero)
self.lineControl3 = StrippingLine(
name + 'ControlXicPlus',
prescale=config['controlPrescaleXic'],
postscale=1.0,
FILTER=_globalEventCuts,
selection=self.combineXicPlus)
# Physics lines
self.lineXicc1 = StrippingLine(name + 'XiccPlusToLcKPi',
prescale=config['signalPrescaleViaLc'],
postscale=1.0,
FILTER=_globalEventCuts,
selection=self.combineXicc1)
self.lineXicc2 = StrippingLine(name + 'XiccPlusPlusToLcKPiPi',
prescale=config['signalPrescaleViaLc'],
postscale=1.0,
FILTER=_globalEventCuts,
selection=self.combineXicc2)
self.lineXicc3 = StrippingLine(name + 'XiccPlusToXicZeroPi',
prescale=config['signalPrescaleViaXic'],
postscale=1.0,
FILTER=_globalEventCuts,
selection=self.combineXicc3)
self.lineXicc4 = StrippingLine(name + 'XiccPlusPlusToXicZeroPiPi',
prescale=config['signalPrescaleViaXic'],
postscale=1.0,
FILTER=_globalEventCuts,
selection=self.combineXicc4)
self.lineXicc5 = StrippingLine(name + 'XiccPlusToXicPlusPiPi',
prescale=config['signalPrescaleViaXic'],
postscale=1.0,
FILTER=_globalEventCuts,
selection=self.combineXicc5)
self.lineXicc6 = StrippingLine(name + 'XiccPlusPlusToXicPlusPi',
prescale=config['signalPrescaleViaXic'],
postscale=1.0,
FILTER=_globalEventCuts,
selection=self.combineXicc6)
self.registerLine(self.lineControl1)
self.registerLine(self.lineControl2)
self.registerLine(self.lineControl3)
self.registerLine(self.lineXicc1)
self.registerLine(self.lineXicc2)
self.registerLine(self.lineXicc3)
self.registerLine(self.lineXicc4)
self.registerLine(self.lineXicc5)
self.registerLine(self.lineXicc6)
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
# CHECK TRIGGER
self.TisTosPreFilter1Jpsi = selHlt1Jpsi(
'TisTosFilter1Jpsifor' + name,
HLT1TisTosSpecs=config['HLT1TisTosSpecs'],
HLT1PassOnAll=config['HLT1PassOnAll'])
self.TisTosPreFilter2Jpsi = selHlt2Jpsi(
'TisTosFilter2Jpsifor' + name,
hlt1Filter=self.TisTosPreFilter1Jpsi,
HLT2TisTosSpecs=config['HLT2TisTosSpecs'],
HLT2PassOnAll=config['HLT2PassOnAll'])
# CHECK FOR TAG-TRACKS
muCut = "((TRCHI2DOF < %(TrChi2Mu)s)) & (PT > %(TrPt)s) & (P > %(LongP)s) & (PIDmu > %(MuDLL)s)" % config
vmCut = "((TRCHI2DOF < %(TrChi2Mu)s)) & (PT > %(TrPt)s) & (P > %(TrP)s)" % config
self.longbothJpsi = longtrackFilter(name + 'LongJpsiBoth',
trackAlgo='LongMu',
partSource=StdLooseMuons,
muCut=muCut)
self.longMinusJpsi = chargeFilter(name + 'LongJpsiMinus',
trackAlgo='LongMu',
partSource=self.longbothJpsi,
charge=-1,
vmCut=vmCut,
muCut=muCut)
self.longPlusJpsi = chargeFilter(name + 'LongJpsiPlus',
trackAlgo='LongMu',
partSource=self.longbothJpsi,
charge=1,
vmCut=vmCut,
muCut=muCut)
# RECONSTRUCT PROBE-TRACKS
self.TrackingPreFilter = trackingPreFilter(
'TrackingPreFilter' + name,
[self.TisTosPreFilter2Jpsi, self.longbothJpsi])
self.VeloMuProtoPFilter = selMuonPParts('VeloMuon' + name,
self.TrackingPreFilter)
self.VeloMuPFilter = makeMyMuons('VeloMuon' + name,
self.VeloMuProtoPFilter)
self.veloMuonMinusJpsi = chargeFilter(name + 'MuonVeloJpsiMinus',
trackAlgo='VeloMuon',
partSource=self.VeloMuPFilter,
charge=-1,
vmCut=vmCut,
muCut=muCut)
self.veloMuonPlusJpsi = chargeFilter(name + 'MuonVeloJpsiPlus',
trackAlgo='VeloMuon',
partSource=self.VeloMuPFilter,
charge=1,
vmCut=vmCut,
muCut=muCut)
# TAG-AND-PROBE
self.JpsiMuMuTrackEff1 = makeResonanceVeloMuTrackEff(
name + "VeloMuJpsiSel1",
resonanceName='J/psi(1S)',
decayDescriptor='J/psi(1S) -> mu+ mu-',
plusCharge=self.veloMuonPlusJpsi,
minusCharge=self.longMinusJpsi,
mode=1,
TrChi2Mu=config['TrChi2Mu'],
TrPt=config['TrPt'],
TrP=config['TrP'],
MuDLL=config['MuDLL'],
MassPreComb=config['MassPreComb'],
VertChi2=config['VertChi2'],
MassPostComb=config['MassPostComb'],
JpsiPt=config['JpsiPt'])
self.JpsiMuMuTrackEff2 = makeResonanceVeloMuTrackEff(
name + "VeloMuJpsiSel2",
resonanceName='J/psi(1S)',
decayDescriptor='J/psi(1S) -> mu+ mu-',
plusCharge=self.longPlusJpsi,
minusCharge=self.veloMuonMinusJpsi,
mode=2,
TrChi2Mu=config['TrChi2Mu'],
TrPt=config['TrPt'],
TrP=config['TrP'],
MuDLL=config['MuDLL'],
MassPreComb=config['MassPreComb'],
VertChi2=config['VertChi2'],
MassPostComb=config['MassPostComb'],
JpsiPt=config['JpsiPt'])
self.nominal_line1 = StrippingLine(name + 'Line1',
prescale=config['Prescale'],
postscale=config['Postscale'],
algos=[self.JpsiMuMuTrackEff1])
self.nominal_line2 = StrippingLine(name + 'Line2',
prescale=config['Prescale'],
postscale=config['Postscale'],
algos=[self.JpsiMuMuTrackEff2])
self.registerLine(self.nominal_line1)
self.registerLine(self.nominal_line2)
def __init__(self, _name, config) :
LineBuilder.__init__(self, _name, config)
GECs = { "Code":"( recSummaryTrack(LHCb.RecSummary.nLongTracks, TrLONG) < %(GEC_nLongTrk)s )" %config ,
"Preambulo": ["from LoKiTracks.decorators import *"]}
self.KsLLCuts = " (PT> %(KS_LL_PTMIN)s *MeV)" \
" & (ADMASS('KS0') < %(KS_LL_MASS_WINDOW)s *MeV)"\
" & (BPVVD > %(KS_LL_FD_MIN)s *mm)" \
" & (BPVVDCHI2 > %(KS_LL_FDCHI2_MIN)s)" \
" & CHILDCUT((TRGHOSTPROB < %(GHOSTPROB_MAX)s),1)" \
" & CHILDCUT((TRGHOSTPROB < %(GHOSTPROB_MAX)s),2)" \
" & (VFASPF(VCHI2PDOF) < %(KS_LL_VCHI2NDOF_MAX)s)" \
" & (BPVDIRA > %(KS_LL_DIRA_MIN)s)" %config
self.KsDDCuts = " (PT> %(KS_DD_PTMIN)s *MeV)" \
" & (ADMASS('KS0') < %(KS_DD_MASS_WINDOW)s *MeV)"\
" & (BPVVD > %(KS_DD_FD_MIN)s *mm)" \
" & (BPVVDCHI2 > %(KS_DD_FDCHI2_MIN)s)" \
" & (VFASPF(VCHI2PDOF) < %(KS_DD_VCHI2NDOF_MAX)s)" \
" & (BPVDIRA > %(KS_DD_DIRA_MIN)s)" %config
self.KaonCuts = " (PT> %(K_PTMIN)s *MeV)" \
" & (PIDK > %(K_PIDK_MIN)s)"\
" & (MIPCHI2DV(PRIMARY) < %(K_IPCHI2_MAX)s)"\
" & (TRGHOSTPROB < %(GHOSTPROB_MAX)s)" %config
self.MuonCuts = " (PT> %(Mu_PTMIN)s *MeV)" \
" & (PIDmu > %(Mu_PIDmu_MIN)s)"\
" & (MIPCHI2DV(PRIMARY) < %(Mu_IPCHI2_MAX)s)"\
" & (TRGHOSTPROB < %(GHOSTPROB_MAX)s)" %config
self.PionCuts = " (PT> %(Pi_PTMIN)s *MeV)" \
" & (MIPCHI2DV(PRIMARY) < %(Pi_IPCHI2_MAX)s)"\
" & (TRGHOSTPROB < %(GHOSTPROB_MAX)s)" %config
self.LambdaCuts = " (PT> %(Lambda_PTMIN)s *MeV)" \
" & (ADMASS('Lambda0') < %(Lambda_MASS_WINDOW)s *MeV)"\
" & (BPVVD > %(Lambda_FD_MIN)s *mm)" \
" & (BPVVDCHI2 > %(Lambda_FDCHI2_MIN)s)" \
" & CHILDCUT((TRGHOSTPROB < %(GHOSTPROB_MAX)s),1)" \
" & CHILDCUT((TRGHOSTPROB < %(GHOSTPROB_MAX)s),2)" \
" & (VFASPF(VCHI2PDOF) < %(Lambda_VCHI2NDOF_MAX)s)" \
" & (BPVDIRA > %(Lambda_DIRA_MIN)s)" %config
self.KsLL = Selection( "KsLLFor" + _name,
Algorithm = FilterDesktop(name = "KsLLFilterFor"+_name, Code = self.KsLLCuts ),
RequiredSelections = [DataOnDemand(Location = 'Phys/StdLooseKsLL/Particles')])
self.KsDD = Selection( "KsDDFor" + _name,
Algorithm = FilterDesktop(name = "KsDDFilterFor"+_name, Code = self.KsDDCuts ),
RequiredSelections = [DataOnDemand(Location = 'Phys/StdLooseKsDD/Particles')])
self.Ks = MergedSelection("KsFor"+_name, RequiredSelections = [ self.KsLL, self.KsDD] )
self.Kaons = Selection( "KaonsFor" + _name,
Algorithm = FilterDesktop(name = "KaonFilterFor"+_name, Code = self.KaonCuts ),
RequiredSelections = [StdAllLooseKaons])
self.Muons = Selection( "MuonsFor" + _name,
Algorithm = FilterDesktop(name = "MuonFilterFor"+_name, Code = self.MuonCuts ),
RequiredSelections = [StdAllLooseMuons])
self.Pions = Selection( "PionsFor" + _name,
Algorithm = FilterDesktop(name = "PionFilterFor"+_name, Code = self.PionCuts ),
#RequiredSelections = [StdAllLoosePions])
RequiredSelections = [DataOnDemand(Location = 'Phys/StdAllLoosePions/Particles')])
self.LambdaDD = Selection( "LambdaDDFor" + _name,
Algorithm = FilterDesktop(name = "LambdaDDFilterFor"+_name, Code = self.LambdaCuts ),
RequiredSelections = [DataOnDemand(Location = 'Phys/StdLooseLambdaDD/Particles')])
self.LambdaLL = Selection( "LambdaLLFor" + _name,
Algorithm = FilterDesktop(name = "LambdaLLFilterFor"+_name, Code = self.LambdaCuts ),
RequiredSelections = [DataOnDemand(Location = 'Phys/StdLooseLambdaLL/Particles')])
self.Lambdas = MergedSelection("LambdasFor"+_name, RequiredSelections = [ self.LambdaLL, self.LambdaDD] )
####### phi(1020) #############
self.PhiToKK_Line = VMaker(_name+"_PhiToKK",[self.Kaons],"phi(1020) -> K+ K-",GECs,config,config["prescale_PhiToKK"])
self.registerLine(self.PhiToKK_Line)
self.PhiToMuMu_Line = VMaker(_name+"_PhiToMuMu",[self.Muons],"phi(1020) -> mu+ mu-",GECs,config,config["prescale_PhiToMuMu"])
self.registerLine(self.PhiToMuMu_Line)
self.PhiToKsKs_Line = VMaker(_name+"_PhiToKsKs",[self.Ks],"phi(1020) -> KS0 KS0",GECs,config,config["prescale_PhiToKsKs"])
self.registerLine(self.PhiToKsKs_Line)
########### J/psi(1S) ################
self.JPsiToKK_Line = VMaker(_name+"_JPsiToKK",[self.Kaons],"J/psi(1S) -> K+ K-",GECs,config,config["prescale_JPsiToKK"])
self.registerLine(self.JPsiToKK_Line)
self.JPsiToKsKs_Line = VMaker(_name+"_JPsiToKsKs",[self.Ks],"J/psi(1S) -> KS0 KS0",GECs,config,config["prescale_JPsiToKsKs"])
self.registerLine(self.JPsiToKsKs_Line)
########### D0 ################
self.D0ToKsKs_Line = VMaker(_name+"_D0ToKsKs",[self.Ks],"D0 -> KS0 KS0",GECs,config,config["prescale_D0ToKsKs"])
self.registerLine(self.D0ToKsKs_Line)
########### eta_c ################
self.EtaCToLL_Line = VMaker(_name+"_EtaCToLL",[self.Lambdas],"eta_c(1S) -> Lambda0 Lambda~0",GECs,config,config["prescale_EtaCToLL"])
self.registerLine(self.EtaCToLL_Line)
####### D -> phi(1020) pi #############
self.CombPhiForD = CombineParticles( name = "Comb_PhiForDToPhiPiKsKs",
DecayDescriptor = "phi(1020) -> KS0 KS0",
CombinationCut = "( (ACHILDCUT(CHILDCUT(ISLONG,1),1)) | (ACHILDCUT(CHILDCUT(ISLONG,1),2)) ) & (APT > %(Phi_PT_MIN)s *MeV) & (AM < %(Phi_MASS_MAX)s + 30*MeV) & (ACUTDOCACHI2(%(Phi_DOCACHI2_MAX)s,''))" %config,
MotherCut = "(M < %(Phi_MASS_MAX)s +20*MeV) & (VFASPF(VCHI2/VDOF) < %(Phi_VCHI2NDOF_MAX)s) & (MIPCHI2DV(PRIMARY) < %(Phi_IPCHI2_MAX)s)" %config)
self.SelPhiForD = Selection(name = "Sel_PhiForDToPhiPiKsKs",
Algorithm = self.CombPhiForD,
RequiredSelections = [self.Ks])
self.DToPhiPiKsKs_Line = VMaker(_name+"_DToPhiPiKsKs",[ self.SelPhiForD, self.Pions],"D_s+ -> phi(1020) pi+",GECs,config,config["prescale_DToPhiPiKsKs"])
self.registerLine(self.DToPhiPiKsKs_Line)
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
_KKK_inclName = name + '_KKK_incl'
_KpKpKp_inclName = name + '_KKK_samesign'
_pph_inclName = name + '_pph_incl'
self.selKKK = makeKKK_incl('KKKinclFor' + _KKK_inclName + 'Sel',
_h_PT=config['_h_PT'],
_h_P=config['_h_P'],
_h_IPCHI2=config['_h_IPCHI2'],
_h_TRCHI2DOF=config['_h_TRCHI2DOF'],
_h_TRGHP=config['_h_TRGHP'],
_3h_DOCA=config['_3h_DOCA'],
_3h_PTmax=config['_3h_PTmax'],
_3h_DIRA=config['_3h_DIRA'],
_3h_FDCHI2=config['_3h_FDCHI2'],
_3h_PVDOCAmin=config['_3h_PVDOCAmin'],
_3h_CHI2=config['_3h_CHI2'],
_3h_IPCHI2=config['_3h_IPCHI2'],
_3h_PT=config['_3h_PT'],
_3h_PTsum=config['_3h_PTsum'],
_3h_Psum=config['_3h_Psum'],
_3h_PVIPCHI2sum=config['_3h_PVIPCHI2sum'],
_3h_TRKCHIDOFmin=config['_3h_TRKCHIDOFmin'],
_3h_CORRMmax=config['_3h_CORRMmax'],
_3h_CORRMmin=config['_3h_CORRMmin'],
_3hKKK_Mmin=config['_3hKKK_Mmin'],
_3hKKK_Mmax=config['_3hKKK_Mmax'])
self.selKpKpKp = makeKpKpKp_incl(
'KpKpKpinclFor' + _KpKpKp_inclName + 'Sel',
_h_PT=config['_h_PT'],
_h_P=config['_h_P'],
_h_IPCHI2=config['_h_IPCHI2'],
_h_TRCHI2DOF=config['_h_TRCHI2DOF'],
_h_TRGHP=config['_h_TRGHP'],
_3h_DOCA=config['_3h_DOCA'],
_3h_PTmax=config['_3h_PTmax'],
_3h_DIRA=config['_3h_DIRA'],
_3h_FDCHI2=config['_3h_FDCHI2'],
_3h_PVDOCAmin=config['_3h_PVDOCAmin'],
_3h_CHI2=config['_3h_CHI2'],
_3h_IPCHI2=config['_3h_IPCHI2'],
_3h_PT=config['_3h_PT'],
_3h_PTsum=config['_3h_PTsum'],
_3h_Psum=config['_3h_Psum'],
_3h_PVIPCHI2sum=config['_3h_PVIPCHI2sum'],
_3h_TRKCHIDOFmin=config['_3h_TRKCHIDOFmin'],
_3h_CORRMmax=config['_3h_CORRMmax'],
_3h_CORRMmin=config['_3h_CORRMmin'],
_3hKKK_Mmin=config['_3hKKK_Mmin'],
_3hKKK_Mmax=config['_3hKKK_Mmax'])
self.selpph = makepph_incl('pphinclFor' + _pph_inclName + 'Sel',
_h_PT=config['_h_PT'],
_h_P=config['_h_P'],
_h_IPCHI2=config['_h_IPCHI2'],
_h_TRCHI2DOF=config['_h_TRCHI2DOF'],
_h_TRGHP=config['_h_TRGHP'],
_3h_DOCA=config['_3h_DOCA'],
_3h_PTmax=config['_3h_PTmax'],
_3h_DIRA=config['_3h_DIRA'],
_3h_FDCHI2=config['_3h_FDCHI2'],
_3h_PVDOCAmin=config['_3h_PVDOCAmin'],
_3h_CHI2=config['_3h_CHI2'],
_3h_IPCHI2=config['_3h_IPCHI2'],
_3h_PT=config['_3h_PT'],
_3h_PTsum=config['_3h_PTsum'],
_3h_Psum=config['_3h_Psum'],
_3h_PVIPCHI2sum=config['_3h_PVIPCHI2sum'],
_3h_TRKCHIDOFmin=config['_3h_TRKCHIDOFmin'],
_3h_CORRMmax=config['_3h_CORRMmax'],
_3h_CORRMmin=config['_3h_CORRMmin'],
_3hpph_deltaMmax=config['_3hpph_deltaMmax'],
_3hpph_deltaMmin=config['_3hpph_deltaMmin'])
self.algosKKK = []
self.algosKKK.append(self.selKKK)
self.algosKpKpKp = []
self.algosKpKpKp.append(self.selKpKpKp)
self.algospph = []
self.algospph.append(self.selpph)
self.lineKKK_incl = StrippingLine(
_KKK_inclName + 'Line',
prescale=config['KKK_inclLinePrescale'],
postscale=config['KKK_inclLinePostscale'],
algos=self.algosKKK,
EnableFlavourTagging=True,
FILTER=filter,
RelatedInfoTools=[{
'Type':
'RelInfoConeVariables',
'ConeAngle':
0.5,
'Variables':
['CONEANGLE', 'CONEMULT', 'CONEPASYM', 'CONEPTASYM'],
'Location':
'ConeIso05B',
"DaughterLocations": {
"[B+ -> ^K+ K+ K-]CC": "ConeIso05h1",
"[B+ -> K+ ^K+ K-]CC": "ConeIso05h2",
"[B+ -> K+ K+ ^K-]CC": "ConeIso05h3",
}
}, {
'Type':
'RelInfoConeVariables',
'ConeAngle':
1.0,
'Variables':
['CONEANGLE', 'CONEMULT', 'CONEPASYM', 'CONEPTASYM'],
'Location':
'ConeIso10B',
"DaughterLocations": {
"[B+ -> ^K+ K+ K-]CC": "ConeIso10h1",
"[B+ -> K+ ^K+ K-]CC": "ConeIso10h2",
"[B+ -> K+ K+ ^K-]CC": "ConeIso10h3",
}
}, {
'Type':
'RelInfoConeVariables',
'ConeAngle':
1.5,
'Variables':
['CONEANGLE', 'CONEMULT', 'CONEPASYM', 'CONEPTASYM'],
'Location':
'ConeIso15B',
"DaughterLocations": {
"[B+ -> ^K+ K+ K-]CC": "ConeIso15h1",
"[B+ -> K+ ^K+ K-]CC": "ConeIso15h2",
"[B+ -> K+ K+ ^K-]CC": "ConeIso15h3",
}
}, {
'Type':
'RelInfoConeVariables',
'ConeAngle':
2.0,
'Variables':
['CONEANGLE', 'CONEMULT', 'CONEPASYM', 'CONEPTASYM'],
'Location':
'ConeIso20B',
"DaughterLocations": {
"[B+ -> ^K+ K+ K-]CC": "ConeIso20h1",
"[B+ -> K+ ^K+ K-]CC": "ConeIso20h2",
"[B+ -> K+ K+ ^K-]CC": "ConeIso20h3",
}
}, {
'Type':
'RelInfoConeVariablesForEW',
'ConeAngle':
0.5,
'Variables': [
'EWCONEANGLE', 'EWCONENPX', 'EWCONENPY', 'EWCONENPZ',
'EWCONENMULT', 'EWCONENVPT', 'EWCONENSPT', 'EWCONENVP',
'EWCONENSP'
],
'Location':
'NConeIso05B',
"DaughterLocations": {
"[B+ -> ^K+ K+ K-]CC": "NConeIso05h1",
"[B+ -> K+ ^K+ K-]CC": "NConeIso05h2",
"[B+ -> K+ K+ ^K-]CC": "NConeIso05h3",
}
}, {
'Type':
'RelInfoConeVariablesForEW',
'ConeAngle':
1.0,
'Variables': [
'EWCONEANGLE', 'EWCONENPX', 'EWCONENPY', 'EWCONENPZ',
'EWCONENMULT', 'EWCONENVPT', 'EWCONENSPT', 'EWCONENVP',
'EWCONENSP'
],
'Location':
'NConeIso10B',
"DaughterLocations": {
"[B+ -> ^K+ K+ K-]CC": "NConeIso10h1",
"[B+ -> K+ ^K+ K-]CC": "NConeIso10h2",
"[B+ -> K+ K+ ^K-]CC": "NConeIso10h3",
}
}, {
'Type':
'RelInfoConeVariablesForEW',
'ConeAngle':
1.5,
'Variables': [
'EWCONEANGLE', 'EWCONENPX', 'EWCONENPY', 'EWCONENPZ',
'EWCONENMULT', 'EWCONENVPT', 'EWCONENSPT', 'EWCONENVP',
'EWCONENSP'
],
'Location':
'NConeIso15B',
"DaughterLocations": {
"[B+ -> ^K+ K+ K-]CC": "NConeIso15h1",
"[B+ -> K+ ^K+ K-]CC": "NConeIso15h2",
"[B+ -> K+ K+ ^K-]CC": "NConeIso15h3",
}
}, {
'Type':
'RelInfoConeVariablesForEW',
'ConeAngle':
2.0,
'Variables': [
'EWCONEANGLE', 'EWCONENPX', 'EWCONENPY', 'EWCONENPZ',
'EWCONENMULT', 'EWCONENVPT', 'EWCONENSPT', 'EWCONENVP',
'EWCONENSP'
],
'Location':
'NConeIso20B',
"DaughterLocations": {
"[B+ -> ^K+ K+ K-]CC": "NConeIso20h1",
"[B+ -> K+ ^K+ K-]CC": "NConeIso20h2",
"[B+ -> K+ K+ ^K-]CC": "NConeIso20h3",
}
}])
self.lineKpKpKp_incl = StrippingLine(
_KpKpKp_inclName + 'Line',
prescale=config['KpKpKp_inclLinePrescale'],
postscale=config['KpKpKp_inclLinePostscale'],
algos=self.algosKpKpKp,
EnableFlavourTagging=True,
FILTER=filter,
RelatedInfoTools=[{
'Type':
'RelInfoConeVariables',
'ConeAngle':
0.5,
'Variables':
['CONEANGLE', 'CONEMULT', 'CONEPASYM', 'CONEPTASYM'],
'Location':
'ConeIso05B',
"DaughterLocations": {
"[B+ -> ^K+ K+ K+]CC": "ConeIso05h1",
"[B+ -> K+ ^K+ K+]CC": "ConeIso05h2",
"[B+ -> K+ K+ ^K+]CC": "ConeIso05h3",
}
}, {
'Type':
'RelInfoConeVariables',
'ConeAngle':
1.0,
'Variables':
['CONEANGLE', 'CONEMULT', 'CONEPASYM', 'CONEPTASYM'],
'Location':
'ConeIso10B',
"DaughterLocations": {
"[B+ -> ^K+ K+ K+]CC": "ConeIso10h1",
"[B+ -> K+ ^K+ K+]CC": "ConeIso10h2",
"[B+ -> K+ K+ ^K+]CC": "ConeIso10h3",
}
}, {
'Type':
'RelInfoConeVariables',
'ConeAngle':
1.5,
'Variables':
['CONEANGLE', 'CONEMULT', 'CONEPASYM', 'CONEPTASYM'],
'Location':
'ConeIso15B',
"DaughterLocations": {
"[B+ -> ^K+ K+ K+]CC": "ConeIso15h1",
"[B+ -> K+ ^K+ K+]CC": "ConeIso15h2",
"[B+ -> K+ K+ ^K+]CC": "ConeIso15h3",
}
}, {
'Type':
'RelInfoConeVariables',
'ConeAngle':
2.0,
'Variables':
['CONEANGLE', 'CONEMULT', 'CONEPASYM', 'CONEPTASYM'],
'Location':
'ConeIso20B',
"DaughterLocations": {
"[B+ -> ^K+ K+ K+]CC": "ConeIso20h1",
"[B+ -> K+ ^K+ K+]CC": "ConeIso20h2",
"[B+ -> K+ K+ ^K+]CC": "ConeIso20h3",
}
}, {
'Type':
'RelInfoConeVariablesForEW',
'ConeAngle':
0.5,
'Variables': [
'EWCONEANGLE', 'EWCONENPX', 'EWCONENPY', 'EWCONENPZ',
'EWCONENMULT', 'EWCONENVPT', 'EWCONENSPT', 'EWCONENVP',
'EWCONENSP'
],
'Location':
'NConeIso05B',
"DaughterLocations": {
"[B+ -> ^K+ K+ K+]CC": "NConeIso05h1",
"[B+ -> K+ ^K+ K+]CC": "NConeIso05h2",
"[B+ -> K+ K+ ^K+]CC": "NConeIso05h3",
}
}, {
'Type':
'RelInfoConeVariablesForEW',
'ConeAngle':
1.0,
'Variables': [
'EWCONEANGLE', 'EWCONENPX', 'EWCONENPY', 'EWCONENPZ',
'EWCONENMULT', 'EWCONENVPT', 'EWCONENSPT', 'EWCONENVP',
'EWCONENSP'
],
'Location':
'NConeIso10B',
"DaughterLocations": {
"[B+ -> ^K+ K+ K+]CC": "NConeIso10h1",
"[B+ -> K+ ^K+ K+]CC": "NConeIso10h2",
"[B+ -> K+ K+ ^K+]CC": "NConeIso10h3",
}
}, {
'Type':
'RelInfoConeVariablesForEW',
'ConeAngle':
1.5,
'Variables': [
'EWCONEANGLE', 'EWCONENPX', 'EWCONENPY', 'EWCONENPZ',
'EWCONENMULT', 'EWCONENVPT', 'EWCONENSPT', 'EWCONENVP',
'EWCONENSP'
],
'Location':
'NConeIso15B',
"DaughterLocations": {
"[B+ -> ^K+ K+ K+]CC": "NConeIso15h1",
"[B+ -> K+ ^K+ K+]CC": "NConeIso15h2",
"[B+ -> K+ K+ ^K+]CC": "NConeIso15h3",
}
}, {
'Type':
'RelInfoConeVariablesForEW',
'ConeAngle':
2.0,
'Variables': [
'EWCONEANGLE', 'EWCONENPX', 'EWCONENPY', 'EWCONENPZ',
'EWCONENMULT', 'EWCONENVPT', 'EWCONENSPT', 'EWCONENVP',
'EWCONENSP'
],
'Location':
'NConeIso20B',
"DaughterLocations": {
"[B+ -> ^K+ K+ K+]CC": "NConeIso20h1",
"[B+ -> K+ ^K+ K+]CC": "NConeIso20h2",
"[B+ -> K+ K+ ^K+]CC": "NConeIso20h3",
}
}])
self.linepph_incl = StrippingLine(
_pph_inclName + 'Line',
prescale=config['pph_inclLinePrescale'],
postscale=config['pph_inclLinePostscale'],
algos=self.algospph,
EnableFlavourTagging=True,
FILTER=filter,
RelatedInfoTools=[{
'Type':
'RelInfoConeVariables',
'ConeAngle':
0.5,
'Variables':
['CONEANGLE', 'CONEMULT', 'CONEPASYM', 'CONEPTASYM'],
'Location':
'ConeIso05B',
"DaughterLocations": {
"[B+ -> ^p+ p~- K+]CC": "ConeIso05p1",
"[B+ -> p+ ^p~- K+]CC": "ConeIso05p2",
"[B+ -> p+ p~- ^K+]CC": "ConeIso05h",
}
}, {
'Type':
'RelInfoConeVariables',
'ConeAngle':
1.0,
'Variables':
['CONEANGLE', 'CONEMULT', 'CONEPASYM', 'CONEPTASYM'],
'Location':
'ConeIso10B',
"DaughterLocations": {
"[B+ -> ^p+ p~- K+]CC": "ConeIso10p1",
"[B+ -> p+ ^p~- K+]CC": "ConeIso10p2",
"[B+ -> p+ p~- ^K+]CC": "ConeIso10h",
}
}, {
'Type':
'RelInfoConeVariables',
'ConeAngle':
1.5,
'Variables':
['CONEANGLE', 'CONEMULT', 'CONEPASYM', 'CONEPTASYM'],
'Location':
'ConeIso15B',
"DaughterLocations": {
"[B+ -> ^p+ p~- K+]CC": "ConeIso15p1",
"[B+ -> p+ ^p~- K+]CC": "ConeIso15p2",
"[B+ -> p+ p~- ^K+]CC": "ConeIso15h",
}
}, {
'Type':
'RelInfoConeVariables',
'ConeAngle':
2.0,
'Variables':
['CONEANGLE', 'CONEMULT', 'CONEPASYM', 'CONEPTASYM'],
'Location':
'ConeIso20B',
"DaughterLocations": {
"[B+ -> ^p+ p~- K+]CC": "ConeIso20p1",
"[B+ -> p+ ^p~- K+]CC": "ConeIso20p2",
"[B+ -> p+ p~- ^K+]CC": "ConeIso20h",
}
}, {
'Type':
'RelInfoConeVariablesForEW',
'ConeAngle':
0.5,
'Variables': [
'EWCONEANGLE', 'EWCONENPX', 'EWCONENPY', 'EWCONENPZ',
'EWCONENMULT', 'EWCONENVPT', 'EWCONENSPT', 'EWCONENVP',
'EWCONENSP'
],
'Location':
'NConeIso05B',
"DaughterLocations": {
"[B+ -> ^p+ p~- K+]CC": "NConeIso05p1",
"[B+ -> p+ ^p~- K+]CC": "NConeIso05p2",
"[B+ -> p+ p~- ^K+]CC": "NConeIso05h",
}
}, {
'Type':
'RelInfoConeVariablesForEW',
'ConeAngle':
1.0,
'Variables': [
'EWCONEANGLE', 'EWCONENPX', 'EWCONENPY', 'EWCONENPZ',
'EWCONENMULT', 'EWCONENVPT', 'EWCONENSPT', 'EWCONENVP',
'EWCONENSP'
],
'Location':
'NConeIso10B',
"DaughterLocations": {
"[B+ -> ^p+ p~- K+]CC": "NConeIso10p1",
"[B+ -> p+ ^p~- K+]CC": "NConeIso10p2",
"[B+ -> p+ p~- ^K+]CC": "NConeIso10h",
}
}, {
'Type':
'RelInfoConeVariablesForEW',
'ConeAngle':
1.5,
'Variables': [
'EWCONEANGLE', 'EWCONENPX', 'EWCONENPY', 'EWCONENPZ',
'EWCONENMULT', 'EWCONENVPT', 'EWCONENSPT', 'EWCONENVP',
'EWCONENSP'
],
'Location':
'NConeIso15B',
"DaughterLocations": {
"[B+ -> ^p+ p~- K+]CC": "NConeIso15p1",
"[B+ -> p+ ^p~- K+]CC": "NConeIso15p2",
"[B+ -> p+ p~- ^K+]CC": "NConeIso15h",
}
}, {
'Type':
'RelInfoConeVariablesForEW',
'ConeAngle':
2.0,
'Variables': [
'EWCONEANGLE', 'EWCONENPX', 'EWCONENPY', 'EWCONENPZ',
'EWCONENMULT', 'EWCONENVPT', 'EWCONENSPT', 'EWCONENVP',
'EWCONENSP'
],
'Location':
'NConeIso20B',
"DaughterLocations": {
"[B+ -> ^p+ p~- K+]CC": "NConeIso20p1",
"[B+ -> p+ ^p~- K+]CC": "NConeIso20p2",
"[B+ -> p+ p~- ^K+]CC": "NConeIso20h",
}
}])
self.registerLine(self.lineKKK_incl)
self.registerLine(self.lineKpKpKp_incl)
self.registerLine(self.linepph_incl)
