def makeD2MuMuMuMu(name, inputSel): """ D --> 4 mu selection """ from Configurables import OfflineVertexFitter D2MuMuMuMu = CombineParticles("Combine" + name) D2MuMuMuMu.DecayDescriptor = "D0 -> mu+ mu- mu+ mu-" D2MuMuMuMu.addTool(OfflineVertexFitter) D2MuMuMuMu.ParticleCombiners.update({"": "OfflineVertexFitter"}) D2MuMuMuMu.DaughtersCuts = { "mu+" : "(TRCHI2DOF < 3.0 ) "\ " & (MIPCHI2DV(PRIMARY)> 4.)"\ " & (TRGHOSTPROB<0.3) "\ " & (P> 3000.*MeV)"} D2MuMuMuMu.CombinationCut = "(ADAMASS('D0')<300*MeV) "\ "& (AMAXDOCA('')<0.2*mm) " D2MuMuMuMu.MotherCut = "(VFASPF(VCHI2/VDOF)<12.) "\ "& (BPVVDZ > 0.) " \ "& (MIPCHI2DV(PRIMARY) < 25. )" return Selection(name, Algorithm=D2MuMuMuMu, RequiredSelections=inputSel)
def makeBu(name): """ detached Bu-->JPsiK selection. Selection is aligned to the Bs2MuMu selection. Please contact Johannes Albrecht if you think of prescaling this line! Arguments: name : name of the Selection. """ from Configurables import OfflineVertexFitter SelDJPsi = makeDetachedJPsi(name) PreselBu2JPsiKCommon = CombineParticles("PreselBu2JPsiKCommon") PreselBu2JPsiKCommon.DecayDescriptor = " [B+ -> J/psi(1S) K+]cc " PreselBu2JPsiKCommon.addTool(OfflineVertexFitter()) PreselBu2JPsiKCommon.VertexFitters.update({"": "OfflineVertexFitter"}) PreselBu2JPsiKCommon.OfflineVertexFitter.useResonanceVertex = False PreselBu2JPsiKCommon.ReFitPVs = True PreselBu2JPsiKCommon.DaughtersCuts = { "K+": "(ISLONG) & (TRCHI2DOF < 5 ) &(MIPCHI2DV(PRIMARY)>25)& (PT>250*MeV) " } PreselBu2JPsiKCommon.CombinationCut = "(ADAMASS('B+') < 500*MeV)" PreselBu2JPsiKCommon.MotherCut = "(BPVIPCHI2()< 25)& (VFASPF(VCHI2)<45) " _kaons = DataOnDemand(Location='Phys/StdNoPIDsKaons/Particles') return Selection("SelBu2JPsiK", Algorithm=PreselBu2JPsiKCommon, RequiredSelections=[SelDJPsi, _kaons])
def makeTau2pmm(name): """ Please contact Jon Harrison if you think of prescaling this line! Arguments: name : name of the Selection. """ Tau2PMuMu = CombineParticles("Comine" + name) Tau2PMuMu.DecayDescriptors = [ " [ tau+ -> p+ mu+ mu- ]cc", " [ tau+ -> p~- mu+ mu+ ]cc", " [ Lambda_c+ -> p+ mu+ mu- ]cc", " [ Lambda_c+ -> p~- mu+ mu+ ]cc" ] Tau2PMuMu.DaughtersCuts = { "mu+" : " ( PT > 300 * MeV ) & ( TRCHI2DOF < 3 ) & ( BPVIPCHI2 () > 9 ) "\ "& ( PIDmu > -5 ) & ( (PIDmu - PIDK) > 0 ) & ( TRGHOSTPROB < 0.3 )", "p+" : " ( PT > 300 * MeV ) & ( TRCHI2DOF < 3 ) & ( BPVIPCHI2 () > 9 ) "\ "& (PIDp>10) & ( TRGHOSTPROB < 0.3 )"} Tau2PMuMu.CombinationCut = "( (ADAMASS('tau+')<150*MeV) | (ADAMASS('Lambda_c+')<150*MeV) )" Tau2PMuMu.MotherCut = """ ( VFASPF(VCHI2) < 15 ) & ( (BPVLTIME () * c_light) > 100 * micrometer ) & ( BPVIPCHI2() < 225 ) """ _stdLooseMuons = DataOnDemand(Location="Phys/StdLooseMuons/Particles") _stdLooseProtons = DataOnDemand(Location="Phys/StdLooseProtons/Particles") return Selection(name, Algorithm=Tau2PMuMu, RequiredSelections=[_stdLooseMuons, _stdLooseProtons])
def makeNoMuID(name, mupt=0, kspt=0): """ default K0s2mumu selection object starts from Phys/StdNoPIDsMuons Please contact Diego Martinez Santos if you think of prescaling this line! Arguments: name : name of the Selection. """ from Configurables import OfflineVertexFitter K0s2MuMuNoMuID = CombineParticles("Comine" + name) K0s2MuMuNoMuID.DecayDescriptor = "KS0 -> pi+ pi-" # Set the OfflineVertexFitter to keep the 4 tracks and not the J/Psi Kstar: K0s2MuMuNoMuID.addTool(OfflineVertexFitter) K0s2MuMuNoMuID.ParticleCombiners.update({"": "OfflineVertexFitter"}) K0s2MuMuNoMuID.OfflineVertexFitter.useResonanceVertex = False K0s2MuMuNoMuID.ReFitPVs = True K0s2MuMuNoMuID.DaughtersCuts = { "pi+": "(MIPCHI2DV(PRIMARY)> 100.)&(TRCHI2DOF < 5 ) & (PT >" + str(mupt) + " * MeV )" } K0s2MuMuNoMuID.CombinationCut = "(ADAMASS('KS0')<100*MeV)"\ "& (AMAXDOCA('')<0.3*mm)" K0s2MuMuNoMuID.MotherCut = "((BPVDIRA>0) & ((BPVVDSIGN*M/P) > 0.1*89.53*2.9979e-01) & (MIPDV(PRIMARY)<0.4*mm) & (M>400) & (M<600) & (PT > " + str( kspt) + " * MeV))" _stdNoPIDsPions = DataOnDemand(Location="Phys/StdNoPIDsPions/Particles") return Selection(name, Algorithm=K0s2MuMuNoMuID, RequiredSelections=[_stdNoPIDsPions])
def makeJetGroup(self, name, config): JetGroup = CombineParticles("Combine" + name) JetGroup.DecayDescriptor = "H_10 -> CELLjet CELLjet" JetGroup.ParticleCombiners = {"": "LoKi::VertexFitter"} JetGroup.addTool(LoKi__VertexFitter, name="LoKi::VertexFitter") vfitter = getattr(JetGroup, "LoKi::VertexFitter") vfitter.Jets = "" JetGroup.DaughtersCuts = { "CELLjet": " (PT > %(min_jet_pT)s ) " % config } JetGroup.CombinationCut = "AALLSAMEBPV " JetGroup.MotherCut = "ALL" ## TOS_HLT2 on-demand hlt = config['TOS_HLT2'] if hlt: JetGroup.MotherCut += '& (TOS("%s", "Hlt2TriggerTisTos"))' % hlt requiredSelections = [DataOnDemand(Location="Phys/StdJets/Particles")] return Selection("Sel" + name, Algorithm=JetGroup, RequiredSelections=requiredSelections)
def makeBs2D0KS0(name,BIPCHI2,BVCHI2,BPVDLS,BsCombMassMin,BsCombMassMax,BsMassMin,BsMassMax,D0MassMin,D0MassMax,DTF_CHI2NDOF): """ Create and return a Bs -> D0 KS selection """ SelStdLooseKsDD = DataOnDemand(Location = 'Phys/StdLooseKsDD/Particles') SelStdLooseKsLL = DataOnDemand(Location = 'Phys/StdLooseKsLL/Particles') SelStdLooseKs = MergedSelection("KSFor"+name, RequiredSelections = [ SelStdLooseKsDD, SelStdLooseKsLL ] ) SelStdLooseD0 = DataOnDemand(Location = 'Phys/StdLooseD02KPi/Particles') _motherCuts = "(VFASPF(VCHI2/VDOF) < %(BVCHI2)s)" \ "& (BPVDLS > %(BPVDLS)s)" \ "& (M > %(BsMassMin)s*MeV)" \ "& (M < %(BsMassMax)s*MeV)" \ "& (BPVIPCHI2() < %(BIPCHI2)s)" \ "& (DTF_CHI2NDOF(True) < %(DTF_CHI2NDOF)s)" % locals() _combinationCut = "(AM > %(BsCombMassMin)s*MeV)" \ "& (AM < %(BsCombMassMax)s*MeV)" % locals() _daughterCut = "(M > %(D0MassMin)s*MeV)" \ "& (M < %(D0MassMax)s*MeV)" \ "& (MAXTREE(ABSID=='K+',PIDK) > 0)" % locals() _Bs = CombineParticles('_'+name) _Bs.DecayDescriptor = "B0 -> D0 KS0" _Bs.CombinationCut = _combinationCut _Bs.MotherCut = _motherCuts _Bs.DaughtersCuts = {"D0" : _daughterCut} return Selection ( name, Algorithm = _Bs, RequiredSelections = [SelStdLooseD0,SelStdLooseKs])
def makeB2pMu(name): """ Please contact Johannes Albrecht if you think of prescaling this line! Arguments: name : name of the Selection. """ from Configurables import OfflineVertexFitter Bs2pMu = CombineParticles("Combine" + name) Bs2pMu.DecayDescriptor = "[B_s0 -> p+ mu-]cc" #Bs2pMu.addTool( OfflineVertexFitter ) #Bs2pMu.VertexFitters.update( { "" : "OfflineVertexFitter"} ) #Bs2pMu.OfflineVertexFitter.useResonanceVertex = False #Bs2pMu.ReFitPVs = True Bs2pMu.DaughtersCuts = { "mu+": "(MIPCHI2DV(PRIMARY)> 25.)&(TRCHI2DOF < 4 )", "p+": "(MIPCHI2DV(PRIMARY)> 25.)&(TRCHI2DOF < 4 )" } Bs2pMu.CombinationCut = "(ADAMASS('B_s0')<600*MeV)"\ "& (AMAXDOCA('')<0.3*mm)" Bs2pMu.MotherCut = "(VFASPF(VCHI2/VDOF)<9) "\ "& (ADMASS('B_s0') < 600*MeV )"\ "& (BPVDIRA > 0) "\ "& (BPVVDCHI2> 225)"\ "& (BPVIPCHI2()< 25) " _stdLooseMuons = DataOnDemand(Location="Phys/StdLooseMuons/Particles") _stdLooseProtons = DataOnDemand(Location="Phys/StdLooseProtons/Particles") return Selection(name, Algorithm=Bs2pMu, RequiredSelections=[_stdLooseMuons, _stdLooseProtons])
def makeDetachedJPsiLoose(name): """ loose detached JPsi selection to monitor selection, systematics from cuts, etc. prescaled Arguments: name : name of the Selection. """ from Configurables import OfflineVertexFitter DetachedJPsiLoose = CombineParticles("Combine" + name) DetachedJPsiLoose.DecayDescriptor = "J/psi(1S) -> mu+ mu-" # Set the OfflineVertexFitter to keep the 4 tracks and not the J/Psi Kstar: DetachedJPsiLoose.addTool(OfflineVertexFitter()) DetachedJPsiLoose.VertexFitters.update({"": "OfflineVertexFitter"}) DetachedJPsiLoose.OfflineVertexFitter.useResonanceVertex = False DetachedJPsiLoose.ReFitPVs = True DetachedJPsiLoose.DaughtersCuts = { "mu+" : "(TRCHI2DOF < 10 ) "\ "& (MIPCHI2DV(PRIMARY)> 9.)"} DetachedJPsiLoose.CombinationCut = "(ADAMASS('J/psi(1S)')<120*MeV) "\ "& (AMAXDOCA('')<0.5*mm)" DetachedJPsiLoose.MotherCut = "(VFASPF(VCHI2)<25) "\ "& (ADMASS('J/psi(1S)') < 120*MeV )"\ "& (BPVDIRA > 0) "\ "& (BPVVDCHI2>100)" _stdLooseMuons = DataOnDemand(Location="Phys/StdLooseMuons/Particles") return Selection(name, Algorithm=DetachedJPsiLoose, RequiredSelections=[_stdLooseMuons])
def makePromptJPsi(name): """ Prompt variant of the detached JPsi selection for B--> JPsi X calibration and normalization channels. Selection is aligned to the Bs2MuMu selection. heavily prescaled Arguments: name : name of the Selection. """ from Configurables import OfflineVertexFitter PromptJPsi = CombineParticles("Combine" + name) PromptJPsi.DecayDescriptor = "J/psi(1S) -> mu+ mu-" # Set the OfflineVertexFitter to keep the 4 tracks and not the J/Psi Kstar: PromptJPsi.addTool(OfflineVertexFitter()) PromptJPsi.VertexFitters.update({"": "OfflineVertexFitter"}) PromptJPsi.OfflineVertexFitter.useResonanceVertex = False PromptJPsi.ReFitPVs = True PromptJPsi.DaughtersCuts = {"mu+": "(TRCHI2DOF < 4 ) "} PromptJPsi.CombinationCut = "(ADAMASS('J/psi(1S)')<100*MeV) "\ "& (AMAXDOCA('')<0.3*mm)" PromptJPsi.MotherCut = "(VFASPF(VCHI2)<15) "\ "& (ADMASS('J/psi(1S)') < 100*MeV )" _stdLooseMuons = DataOnDemand(Location="Phys/StdLooseMuons/Particles") return Selection(name, Algorithm=PromptJPsi, RequiredSelections=[_stdLooseMuons])
def makeD2MuMuMuMu(name): """ D --> 4 mu selection should become inclusive bb-->4 mu selection ?? """ from Configurables import OfflineVertexFitter D2MuMuMuMu = CombineParticles("Combine" + name) D2MuMuMuMu.DecayDescriptor = "D0 -> mu+ mu- mu+ mu-" # Set the OfflineVertexFitter to keep the 4 tracks and not the J/Psi Kstar: D2MuMuMuMu.addTool(OfflineVertexFitter()) D2MuMuMuMu.VertexFitters.update({"": "OfflineVertexFitter"}) D2MuMuMuMu.OfflineVertexFitter.useResonanceVertex = False D2MuMuMuMu.ReFitPVs = True D2MuMuMuMu.DaughtersCuts = { "mu+" : "(TRCHI2DOF < 5 ) "\ " & (MIPCHI2DV(PRIMARY)> 9.)"} D2MuMuMuMu.CombinationCut = "(ADAMASS('D0')<1000*MeV) "\ "& (AMAXDOCA('')<0.3*mm) " D2MuMuMuMu.MotherCut = "(VFASPF(VCHI2/VDOF)<10) "\ "& (BPVDIRA > 0.9998) "\ "& (BPVVDCHI2>48.)"\ " & (M>864.83) & (M<2868.47)"\ "& (BPVIPCHI2()< 30) " _stdLooseMuons = DataOnDemand(Location="Phys/StdLooseMuons/Particles") return Selection(name, Algorithm=D2MuMuMuMu, RequiredSelections=[_stdLooseMuons])
def makeDefault(name,inputSel) : """ B --> 4 mu selection should become inclusive bb-->4 mu selection ?? """ from Configurables import OfflineVertexFitter Detached4mu = CombineParticles("Combine"+name) Detached4mu.DecayDescriptor = "B_s0 -> mu+ mu- mu+ mu-" # Set the OfflineVertexFitter to keep the 4 tracks and not the J/Psi Kstar: Detached4mu.addTool( OfflineVertexFitter ) Detached4mu.ParticleCombiners.update( { "" : "OfflineVertexFitter"} ) Detached4mu.OfflineVertexFitter.useResonanceVertex = False Detached4mu.ReFitPVs = True Detached4mu.DaughtersCuts = { "mu+" : "(TRCHI2DOF < 2.5 ) "\ " & (MIPCHI2DV(PRIMARY)> 9.)"} Detached4mu.CombinationCut = "(ADAMASS('B_s0')<1000*MeV) "\ "& (AMAXDOCA('')<0.3*mm)" Detached4mu.MotherCut = "(VFASPF(VCHI2/VDOF)<9) "\ "& (BPVDIRA > 0) "\ "& (BPVVDCHI2>100)"\ " & (M>4366.3) & (M<6366.3)"\ "& (BPVIPCHI2()< 25) " return Selection (name, Algorithm = Detached4mu, RequiredSelections = inputSel)
def makeB2TauMu(name): """ Please contact Johannes Albrecht if you think of prescaling this line! Arguments: name : name of the Selection. """ from Configurables import OfflineVertexFitter Bs2TauMu = CombineParticles("Combine"+name) Bs2TauMu.DecayDescriptors = ["[B_s0 -> tau+ mu-]cc","[B_s0 -> tau+ mu+]cc"] # Set the OfflineVertexFitter to keep the 4 tracks and not the J/Psi Kstar: Bs2TauMu.addTool( OfflineVertexFitter ) Bs2TauMu.ParticleCombiners.update( { "" : "OfflineVertexFitter"} ) Bs2TauMu.OfflineVertexFitter.useResonanceVertex = False #Bs2TauMu.ReFitPVs = True Bs2TauMu.DaughtersCuts = { "mu+" : "(MIPCHI2DV(PRIMARY)> 25.)&(TRCHI2DOF < 3 ) & (TRGHOSTPROB<0.3)"} Bs2TauMu.CombinationCut = "(ADAMASS('B_s0')<1200*MeV)"\ "& (AMAXDOCA('')<0.3*mm)" Bs2TauMu.MotherCut = "(VFASPF(VCHI2/VDOF)<9) "\ "& (ADMASS('B_s0') < 1200*MeV )"\ "& (BPVDIRA > 0) "\ "& (BPVVDCHI2> 225)"\ "& (BPVIPCHI2()< 25) " from CommonParticles import StdLooseDetachedTau, StdLooseDipion _stdLooseMuons = DataOnDemand(Location = "Phys/StdLooseMuons/Particles") _stdLooseDetachedTaus= DataOnDemand(Location = "Phys/StdLooseDetachedTau3pi/Particles") return Selection (name, Algorithm = Bs2TauMu, RequiredSelections = [ _stdLooseMuons,_stdLooseDetachedTaus])
def makeXibc2JpsiKp (localname, _RequiredSelections, config=default_config['CONFIG'], controlLine=False): myXibc = CombineParticles(localname+"Xibc2JpsipK"); myXibc.DecayDescriptor = "[Xi_bc0 -> J/psi(1S) p+ K-]cc" if (controlLine == True): myXibc.CombinationCut = ("(AM > %(JpsiKp_MassMin)s ) & " "(AM < %(JpsiKp_MassLbThreshold)s) " )%config else: myXibc.CombinationCut = ("(AM > %(JpsiKp_MassLbThreshold)s ) & " "(AM < %(JpsiKp_MassMax)s ) " )%config myXibc.MotherCut = ("(VFASPF(VCHI2/VDOF)< %(JpsiKp_MaxVertexChi2)s) & " "(BPVLTIME()> %(JpsiKp_MinTAU)s)" ) %config myXibc.DaughtersCuts = {"J/psi(1S)" : ("(PT > %(JpsiKp_Jpsi_MinPT)s) & "+ "(ADMASS('J/psi(1S)') < %(JpsiKp_Jpsi_MassWin)s) &"+ "(MAXTREE(TRGHP, ISBASIC) < %(JpsiKp_mu_MaxTrackGhostProb)s) &"+ "(MINTREE('mu+'==ABSID,PIDmu) > %(JpsiKp_mu_MinPIDmu)s )" ) %config, "p+" : ("(PT > %(JpsiKp_p_MinPt)s) &"+ " (PROBNNp > %(JpsiKp_p_MinProbNNp)s) &"+ " (TRGHP < %(JpsiKp_p_MaxTrackGhostProb)s) &" + " (TRPCHI2 > %(JpsiKp_p_MinTrackPvalue)s) & "+ " (P > %(JpsiKp_p_MinP)s )" ) %config, "K-" : ("(PT > %(JpsiKp_K_MinPT)s) &"+ "(PROBNNk > %(JpsiKp_K_MinProbNNk)s) &"+ "(TRGHP < %(JpsiKp_K_MaxTrackGhostProb)s )&" + "(TRPCHI2 > %(JpsiKp_K_MinTrackPvalue)s) & "+ "(P > %(JpsiKp_K_MinP)s)") %config} return Selection(localname + "Xibc2JpsipKSel", Algorithm=myXibc, RequiredSelections = _RequiredSelections)
def makeDs2PhiPi(name, config): """ Please contact Johannes Albrecht if you think of prescaling this line! Arguments: name : name of the Selection. """ Ds2PhiPi = CombineParticles("Comine" + name) Ds2PhiPi.DecayDescriptor = " [ D_s+ -> pi+ mu+ mu- ]cc " Ds2PhiPi.DaughtersCuts = { "pi+": " ( PT > 300 * MeV ) & ( TRGHOSTPROB < %(TrackGhostProb)s ) & ( TRCHI2DOF < 3 ) & ( BPVIPCHI2 () > 9 ) " % config, "mu+": " ( PT > 300 * MeV ) & ( TRGHOSTPROB < %(TrackGhostProb)s ) & ( TRCHI2DOF < 3 ) & ( BPVIPCHI2 () > 9 ) " % config } Ds2PhiPi.CombinationCut = "(ADAMASS('D_s+')<250*MeV) & in_range ( 970 * MeV , AM23 , 1070 * MeV )" Ds2PhiPi.MotherCut = """ ( VFASPF(VCHI2) < 15 ) & ( (BPVLTIME () * c_light) >100 * micrometer ) & ( BPVIPCHI2() < 225 ) """ _stdLoosePions = DataOnDemand(Location="Phys/StdLoosePions/Particles") _stdLooseMuons = DataOnDemand(Location="Phys/StdLooseMuons/Particles") return Selection(name, Algorithm=Ds2PhiPi, RequiredSelections=[_stdLooseMuons, _stdLoosePions])
def makeBd2InflatonKst(name, SelInflatonLong): """ detached Bd -> Inflaton K* selection. Arguments: name : name of the Selection. """ from Configurables import OfflineVertexFitter _kstar = DataOnDemand(Location='Phys/StdLooseDetachedKst2Kpi/Particles') Bd2InflatonKst = CombineParticles("Combine" + name) Bd2InflatonKst.DecayDescriptor = "[B0 -> KS0 K*(892)0]cc" Bd2InflatonKst.addTool(OfflineVertexFitter) #Bd2InflatonKst.VertexFitters.update( { "" : "OfflineVertexFitter"} ) Bd2InflatonKst.ParticleCombiners.update({"": "OfflineVertexFitter"}) Bd2InflatonKst.OfflineVertexFitter.useResonanceVertex = False Bd2InflatonKst.ReFitPVs = True Bd2InflatonKst.DaughtersCuts = {"K*(892)0": "MIPCHI2DV(PRIMARY)> 25."} Bd2InflatonKst.CombinationCut = "(ADAMASS('B0') < 500*MeV)" Bd2InflatonKst.MotherCut = "(BPVIPCHI2()< 50) & (VFASPF(VCHI2)<100)& (D2DVVDDOT(1) > 0.3*mm)" return Selection("Sel" + name, Algorithm=Bd2InflatonKst, RequiredSelections=[SelInflatonLong, _kstar])
def makeTau23Mu(name, config): """ Please contact Johannes Albrecht if you think of prescaling this line! Arguments: name : name of the Selection. """ Tau2MuMuMu = CombineParticles("Comine" + name) Tau2MuMuMu.DecayDescriptor = " [ tau+ -> mu+ mu+ mu- ]cc" Tau2MuMuMu.DaughtersCuts = { "mu+" : " ( PT > 300 * MeV ) & ( TRGHOSTPROB < %(TrackGhostProb)s ) & ( TRCHI2DOF < 3 ) "\ "& ( BPVIPCHI2 () > 9 ) " % config} Tau2MuMuMu.CombinationCut = "(ADAMASS('tau+')<400*MeV)" Tau2MuMuMu.MotherCut = """ ( VFASPF(VCHI2) < 15 ) & ( (BPVLTIME () * c_light) > 100 * micrometer ) & ( BPVIPCHI2() < 225 ) """ _stdLooseMuons = DataOnDemand(Location="Phys/StdLooseMuons/Particles") return Selection(name, Algorithm=Tau2MuMuMu, RequiredSelections=[_stdLooseMuons])
def makeLambdac (localname, _RequiredSelections, config=default_config): _lambdacCP = CombineParticles(localname+"lambdacAlgorithm") _lambdacCP.DecayDescriptor = "[Lambda_c+ -> p+ pi+ K-]cc" _lambdacCP.DaughtersCuts = { "p+" : ("(TRPCHI2 > %(Protons4Lambdac_TRPCHI2)s) & " + " (PIDp > %(Protons4Lambdac_PIDp)s) & " + " (PT > %(Protons4Lambdac_PT)s) & " + " (P > %(Protons4Lambdac_minP)s) & " + " (PIDp - PIDK > %(Protons4Lambdac_PIDp-PIDK)s)" ) % config, "K-" : ("(TRPCHI2 > %(Kaon4Lambdac_TRPCHI2)s) &"+ "(PIDK > %(Kaon4Lambdac_PIDK)s) & "+ "(P > %(Kaon4Lambdac_minP)s) & "+ "(PT > %(Kaon4Lambdac_PT)s)" ) % config, "pi+" : ("(MIPCHI2DV(PRIMARY)> %(Pions4Lambdac_MINIPCHI2)s) &"+ " (TRPCHI2 > %(Pion4Lambdac_TRPCHI2)s) &"+ " (PIDK < %(Pion4Lambdac_PIDK)s) &"+ "(PT > %(Pion4Lambdac_PT)s)") % config } _lambdacCP.CombinationCut = ("(ADAMASS('Lambda_c+') < %(Lambdac_MassWindowLarge)s) & " + "(APT > %(Lambdac_MinAPT)s) & " + "(ADOCAMAX('') < %(Lambdac_MaxADOCA)s)" ) % config _lambdacCP.MotherCut = ("(VFASPF(VCHI2/VDOF) < %(Lambdac_ENDVERTEXCHI2)s) & "+ "(ADMASS('Lambda_c+') < %(Lambdac_MassWindowTight)s) & "+ "(BPVDIRA > %(Lambdac_BPVDIRA)s) & "+ "(BPVLTIME('PropertimeFitter/properTime:PUBLIC')>%(Lambdac_minTAU)s)" ) % config return Selection (name = localname + 'LcSelection', Algorithm=_lambdacCP, RequiredSelections = _RequiredSelections);
def SelWDiJets(name, conf, desc, sel_W, TOS_HLT2=None): """ Create the combination of W + DiJets """ ## Create CombineParticle, with caveat on jet combining. DiJet = CombineParticles("Combine" + name) DiJet.ParticleCombiners = {"": "LoKi::VertexFitter"} DiJet.addTool(LoKi__VertexFitter, name="LoKi::VertexFitter") vfitter = getattr(DiJet, "LoKi::VertexFitter") vfitter.Jets = "" ## Apply cuts, with TOS optionally # Asking AT LEAST one of the jet to be TOSed by given trigger. ccut = "AALLSAMEBPV "\ "& ( dr_13 > %(dr_lepton_jet)s )"\ "& ( dr_23 > %(dr_lepton_jet)s )" %conf if TOS_HLT2: cut_tos = "(TOS('%s','Hlt2TriggerTisTos'))" % TOS_HLT2 cut_tosjet = '(ACHILDCUT({0}, 1) | ACHILDCUT({0}, 2))'.format(cut_tos) ccut += ('&' + cut_tosjet) DiJet.Preambulo = preambulo DiJet.DecayDescriptor = desc DiJet.DaughtersCuts = {"CELLjet": "(PT > %(min_jet_pT)s)" % conf} DiJet.CombinationCut = ccut DiJet.MotherCut = "ALL" return Selection(name, Algorithm=DiJet, RequiredSelections=[sel_W, StdJets])
def makeB2ee(name): """ Please contact Johannes Albrecht if you think of prescaling this line! Arguments: name : name of the Selection. """ from Configurables import OfflineVertexFitter Bs2ee = CombineParticles("Combine" + name) Bs2ee.DecayDescriptor = "B_s0 -> e+ e-" # Set the OfflineVertexFitter to keep the 4 tracks and not the J/Psi Kstar: Bs2ee.addTool(OfflineVertexFitter) Bs2ee.ParticleCombiners.update({"": "OfflineVertexFitter"}) Bs2ee.OfflineVertexFitter.useResonanceVertex = False #Bs2ee.ReFitPVs = True Bs2ee.DaughtersCuts = {"e+": "(MIPCHI2DV(PRIMARY)> 25.)&(TRCHI2DOF < 4 )"} Bs2ee.CombinationCut = "(ADAMASS('B_s0')<1200*MeV)"\ "& (AMAXDOCA('')<0.3*mm)" Bs2ee.MotherCut = "(VFASPF(VCHI2/VDOF)<9) "\ "& (ADMASS('B_s0') < 1200*MeV )"\ "& (BPVDIRA > 0) "\ "& (BPVVDCHI2> 225)"\ "& (BPVIPCHI2()< 25) " _stdLooseElectrons = DataOnDemand( Location="Phys/StdLooseElectrons/Particles") return Selection(name, Algorithm=Bs2ee, RequiredSelections=[_stdLooseElectrons])
def makeBd2InflatonRho(name, SelInflatonLong, SelRho) : """ detached Bd -> Inflaton rho selection. Arguments: name : name of the Selection. """ from Configurables import OfflineVertexFitter Bd2InflatonRho = CombineParticles("Combine"+name) Bd2InflatonRho.DecayDescriptor = "B0 -> KS0 rho(770)0" Bd2InflatonRho.addTool( OfflineVertexFitter ) #Bd2InflatonRho.VertexFitters.update( { "" : "OfflineVertexFitter"} ) Bd2InflatonRho.ParticleCombiners.update( { "" : "OfflineVertexFitter"} ) Bd2InflatonRho.OfflineVertexFitter.useResonanceVertex = False Bd2InflatonRho.ReFitPVs = True Bd2InflatonRho.DaughtersCuts = { "rho(770)0" : "MIPCHI2DV(PRIMARY)> 25."} Bd2InflatonRho.CombinationCut = "(ADAMASS('B0') < 500*MeV)" Bd2InflatonRho.MotherCut = "(BPVIPCHI2()< 50) & (VFASPF(VCHI2)<100)& (D2DVVDDOT(1) > 0.3*mm)" return Selection( "Sel"+name, Algorithm = Bd2InflatonRho, RequiredSelections=[SelInflatonLong, SelRho] )
def makeDetachedJPsi(name): """ detached JPsi selection for B--> JPsi X calibration and normalization channels. Please contact Flavio Archilli if you think of prescaling this line! Arguments: name : name of the Selection. """ from Configurables import OfflineVertexFitter DetachedJPsi = CombineParticles("Combine" + name) DetachedJPsi.DecayDescriptor = "J/psi(1S) -> e+ e-" DetachedJPsi.addTool(OfflineVertexFitter) DetachedJPsi.ParticleCombiners.update({"": "OfflineVertexFitter"}) DetachedJPsi.OfflineVertexFitter.useResonanceVertex = False DetachedJPsi.ReFitPVs = True DetachedJPsi.DaughtersCuts = { "e+" : "(TRCHI2DOF < 4 ) "\ "& (MIPCHI2DV(PRIMARY)> 25.) "\ "& (PIDe > 2) "} DetachedJPsi.CombinationCut = "(ADAMASS('J/psi(1S)')<1000*MeV) "\ "& (AMAXDOCA('')<0.3*mm)" DetachedJPsi.MotherCut = "(VFASPF(VCHI2)<9) "\ "& (ADMASS('J/psi(1S)') < 1000*MeV )"\ "& (BPVDIRA > 0) "\ "& (BPVVDCHI2>169)" _stdLooseElectrons = DataOnDemand( Location="Phys/StdLooseElectrons/Particles") return Selection(name, Algorithm=DetachedJPsi, RequiredSelections=[_stdLooseElectrons])
def makeDs23Pi(name): """ Please contact Johannes Albrecht if you think of prescaling this line! Arguments: name : name of the Selection. """ from Configurables import OfflineVertexFitter Ds2PiPiPi = CombineParticles("Comine" + name) Ds2PiPiPi.DecayDescriptor = " [ D_s+ -> pi+ pi+ pi- ]cc " Ds2PiPiPi.DaughtersCuts = { "pi+": " ( PT > 300 * MeV ) & ( TRCHI2DOF < 4 ) & ( BPVIPCHI2 () > 9 ) " } Ds2PiPiPi.CombinationCut = "(ADAMASS('D_s+')<80*MeV)" Ds2PiPiPi.MotherCut = """ ( VFASPF(VCHI2) < 15 ) & ( (BPVLTIME () * c_light) > 100 * micrometer ) & ( BPVIPCHI2() < 225 ) """ _stdLoosePions = DataOnDemand(Location="Phys/StdLoosePions/Particles") return Selection(name, Algorithm=Ds2PiPiPi, RequiredSelections=[_stdLoosePions])
def makeDefault(name) : """ default Bs2mumu selection object (tighter selection a la roadmap) starts from Phys/StdNoPIDsMuons Please contact Johannes Albrecht if you think of prescaling this line! Arguments: name : name of the Selection. """ from Configurables import OfflineVertexFitter Bs2MuMuNoMuID = CombineParticles("Comine"+name) Bs2MuMuNoMuID.DecayDescriptor = "B_s0 -> mu+ mu-" # Set the OfflineVertexFitter to keep the 4 tracks and not the J/Psi Kstar: Bs2MuMuNoMuID.addTool( OfflineVertexFitter() ) Bs2MuMuNoMuID.VertexFitters.update( { "" : "OfflineVertexFitter"} ) Bs2MuMuNoMuID.OfflineVertexFitter.useResonanceVertex = False Bs2MuMuNoMuID.ReFitPVs = True Bs2MuMuNoMuID.DaughtersCuts = { "mu+" : "(MIPCHI2DV(PRIMARY)> 25.)&(TRCHI2DOF < 4 )" } Bs2MuMuNoMuID.CombinationCut = "(ADAMASS('B_s0')<600*MeV)"\ "& (AMAXDOCA('')<0.3*mm)" Bs2MuMuNoMuID.MotherCut = "(VFASPF(VCHI2/VDOF)<9) "\ "& (ADMASS('B_s0') < 600*MeV )"\ "& (BPVDIRA > 0) "\ "& (BPVVDCHI2> 225)"\ "& (BPVIPCHI2()< 25) " _stdNoPIDsMuons = DataOnDemand(Location = "Phys/StdNoPIDsMuons/Particles") return Selection (name, Algorithm = Bs2MuMuNoMuID, RequiredSelections = [ _stdNoPIDsMuons])
def makeDownstream(name): """ very very detached dimuon selection with downstream tracks """ from Configurables import OfflineVertexFitter Detached2mu = CombineParticles("Combine" + name) Detached2mu.DecayDescriptor = "KS0 -> mu+ mu-" Detached2mu.addTool(OfflineVertexFitter) #Detached2mu.VertexFitters.update( { "" : "OfflineVertexFitter"} ) Detached2mu.ParticleCombiners.update({"": "OfflineVertexFitter"}) Detached2mu.OfflineVertexFitter.useResonanceVertex = False Detached2mu.ReFitPVs = True Detached2mu.DaughtersCuts = { "mu+" : "(TRCHI2DOF < 4 ) "\ " & (MIPCHI2DV(PRIMARY)> 150)"\ "& (PT > 125*MeV) "\ "& (PIDmu > -4)"} Detached2mu.CombinationCut = " (AMAXDOCA('')<0.2*mm)" #"(ADAMASS('B_s0')<1000*MeV) "\ Detached2mu.MotherCut = "(VFASPF(VCHI2/VDOF)<12) "\ "& (M>250)"\ "& (BPVDIRA > 0) "\ "& (BPVVDCHI2>1000)"\ "& (BPVVD>200)" _stdLooseDownMuons = DataOnDemand( Location="Phys/StdLooseDownMuons/Particles") return Selection(name, Algorithm=Detached2mu, RequiredSelections=[_stdLooseDownMuons])
def makeBs2mmWide(name): """ Bs2mumu selection object (tighter selection a la roadmap) with muon Id and wide mass window (1.2GeV) starts from Phys/StdLooseMuons Please contact Johannes Albrecht if you think of prescaling this line! Arguments: name : name of the Selection. """ from Configurables import OfflineVertexFitter Bs2MuMuWideMass = CombineParticles("Combine" + name) Bs2MuMuWideMass.DecayDescriptor = "B_s0 -> mu+ mu-" Bs2MuMuWideMass.addTool(OfflineVertexFitter()) Bs2MuMuWideMass.VertexFitters.update({"": "OfflineVertexFitter"}) Bs2MuMuWideMass.OfflineVertexFitter.useResonanceVertex = False Bs2MuMuWideMass.ReFitPVs = True Bs2MuMuWideMass.DaughtersCuts = { "mu+": "(MIPCHI2DV(PRIMARY)> 25.)&(TRCHI2DOF < 4 )" } Bs2MuMuWideMass.CombinationCut = "(ADAMASS('B_s0')<1200*MeV)"\ "& (AMAXDOCA('')<0.3*mm)" Bs2MuMuWideMass.MotherCut = "(VFASPF(VCHI2/VDOF)<9) "\ "& (ADMASS('B_s0') < 1200*MeV )"\ "& (BPVDIRA > 0) "\ "& (BPVVDCHI2> 225)"\ "& (BPVIPCHI2()< 25) " _stdLooseMuons = DataOnDemand(Location="Phys/StdLooseMuons/Particles") return Selection(name, Algorithm=Bs2MuMuWideMass, RequiredSelections=[_stdLooseMuons])
def makeBu2InflatonK(name, SelInflatonLong): """ detached Bu -> Inflaton K selection. Arguments: name : name of the Selection. """ from Configurables import OfflineVertexFitter Bu2InflatonK = CombineParticles("Combine" + name) Bu2InflatonK.DecayDescriptor = " [B+ -> KS0 K+]cc " Bu2InflatonK.addTool(OfflineVertexFitter) #Bu2InflatonK.VertexFitters.update( { "" : "OfflineVertexFitter"} ) Bu2InflatonK.ParticleCombiners.update({"": "OfflineVertexFitter"}) Bu2InflatonK.OfflineVertexFitter.useResonanceVertex = False Bu2InflatonK.ReFitPVs = True Bu2InflatonK.DaughtersCuts = { "K+": "(ISLONG) & (TRCHI2DOF < 3 ) &(MIPCHI2DV(PRIMARY)>25)& (PT>250*MeV) " } Bu2InflatonK.CombinationCut = "(ADAMASS('B+') < 500*MeV)" Bu2InflatonK.MotherCut = "(BPVIPCHI2()< 50)& (VFASPF(VCHI2)<100)& (D2DVVDDOT(1) > 0.3*mm)" _kaons = DataOnDemand(Location='Phys/StdLooseKaons/Particles') return Selection("Sel" + name, Algorithm=Bu2InflatonK, RequiredSelections=[SelInflatonLong, _kaons])
def makeDetachedJPsi(name): """ detached JPsi selection for B--> JPsi X calibration and normalization channels. Selection is aligned to the Bs2MuMu selection. Please contact Johannes Albrecht if you think of prescaling this line! Arguments: name : name of the Selection. """ from Configurables import OfflineVertexFitter DetachedJPsi = CombineParticles("Combine" + name) DetachedJPsi.DecayDescriptor = "J/psi(1S) -> mu+ mu-" # Set the OfflineVertexFitter to keep the 4 tracks and not the J/Psi Kstar: DetachedJPsi.addTool(OfflineVertexFitter()) DetachedJPsi.VertexFitters.update({"": "OfflineVertexFitter"}) DetachedJPsi.OfflineVertexFitter.useResonanceVertex = False DetachedJPsi.ReFitPVs = True DetachedJPsi.DaughtersCuts = { "mu+" : "(TRCHI2DOF < 4 ) "\ "& (MIPCHI2DV(PRIMARY)> 25.)"} DetachedJPsi.CombinationCut = "(ADAMASS('J/psi(1S)')<100*MeV) "\ "& (AMAXDOCA('')<0.3*mm)" DetachedJPsi.MotherCut = "(VFASPF(VCHI2)<9) "\ "& (ADMASS('J/psi(1S)') < 100*MeV )"\ "& (BPVDIRA > 0) "\ "& (BPVVDCHI2>169)" _stdLooseMuons = DataOnDemand(Location="Phys/StdLooseMuons/Particles") return Selection(name, Algorithm=DetachedJPsi, RequiredSelections=[_stdLooseMuons])
def makeBs2InflatonPhi(name, SelInflatonLong): """ detached Bs -> Inflaton Phi selection. Arguments: name : name of the Selection. """ from Configurables import OfflineVertexFitter _phi = DataOnDemand(Location='Phys/StdLooseDetachedPhi2KK/Particles') Bs2InflatonPhi = CombineParticles("Combine" + name) Bs2InflatonPhi.DecayDescriptor = "B_s0 -> KS0 phi(1020)" Bs2InflatonPhi.addTool(OfflineVertexFitter) #Bs2InflatonPhi.VertexFitters.update( { "" : "OfflineVertexFitter"} ) Bs2InflatonPhi.ParticleCombiners.update({"": "OfflineVertexFitter"}) Bs2InflatonPhi.OfflineVertexFitter.useResonanceVertex = False Bs2InflatonPhi.ReFitPVs = True Bs2InflatonPhi.DaughtersCuts = {"phi(1020)": "MIPCHI2DV(PRIMARY)> 25."} Bs2InflatonPhi.CombinationCut = "(ADAMASS('B_s0') < 500*MeV)" Bs2InflatonPhi.MotherCut = "(BPVIPCHI2()< 50)& (VFASPF(VCHI2)<100)& (D2DVVDDOT(1) > 0.3*mm)" return Selection("Sel" + name, Algorithm=Bs2InflatonPhi, RequiredSelections=[SelInflatonLong, _phi])
def makeJPsi2mumu(name, MuonPT, MuonIPCHI2, JPsiPT, JPsiVCHI2): """ Create and return a JPsi -> Mu Mu Selection object. Starts from DataOnDemand 'Phys/StdLooseMuons/Particles'. Arguments: name : name of the Selection. MuonPT : Minimum transverse momentum of Mu (MeV). MuonIPCHI2 : Minimum impact parameter chi2 of Mu. JPsiPT : Minimum transverse momentum of JPsi (MeV). JPsiVCHI2 : Maximum JPsi vertex chi2 per degree of freedom. """ MuCuts = "(TRCHI2DOF < 5 )"\ "& (MIPCHI2DV(PRIMARY)> %(MuonIPCHI2)s)"\ "& (PT > %(MuonPT)s *MeV)" % locals() MotherCuts = "(VFASPF(VCHI2/VDOF)< %(JPsiVCHI2)s)"\ "& (PT > %(JPsiPT)s *MeV)"\ "& (ADMASS('J/psi(1S)') < 100*MeV )" % locals() _JPsi = CombineParticles("_" + name) _JPsi.DecayDescriptor = "J/psi(1S) -> mu+ mu-" _JPsi.DaughtersCuts = {"mu+": MuCuts} _JPsi.CombinationCut = "(ADAMASS('J/psi(1S)')<100*MeV) "\ "& (AMAXDOCA('')<0.3*mm)" _JPsi.MotherCut = MotherCuts _stdLooseMuons = DataOnDemand(Location="Phys/StdLooseMuons/Particles") return Selection(name, Algorithm=_JPsi, RequiredSelections=[_stdLooseMuons])
def makeTau2eMuMu(name): """ Please contact Johannes Albrecht if you think of prescaling this line! Arguments: name : name of the Selection. """ from Configurables import OfflineVertexFitter Tau2eMuMu = CombineParticles("Comine" + name) Tau2eMuMu.DecayDescriptors = [ " [ tau+ -> e+ mu+ mu- ]cc", " [ tau+ -> mu+ mu+ e- ]cc" ] Tau2eMuMu.DaughtersCuts = { "mu+": " ( PT > 300 * MeV ) & ( TRCHI2DOF < 4 ) & ( BPVIPCHI2 () > 9 ) ", "e+": " ( PT > 300 * MeV ) & ( TRCHI2DOF < 4 ) & ( BPVIPCHI2 () > 9 ) " } Tau2eMuMu.CombinationCut = "(ADAMASS('tau+')<200*MeV)" Tau2eMuMu.MotherCut = """ ( VFASPF(VCHI2) < 15 ) & ( (BPVLTIME ( 225 ) * c_light) > 100 * micrometer ) & ( BPVIPCHI2() < 225 ) """ _stdLooseMuons = DataOnDemand(Location="Phys/StdLooseMuons/Particles") _stdLooseElectrons = DataOnDemand( Location="Phys/StdLooseElectrons/Particles") return Selection(name, Algorithm=Tau2eMuMu, RequiredSelections=[_stdLooseMuons, _stdLooseElectrons])
def build_mc_unbiased_selection(decayDesc, arrow = '==>') : preamble = [ "from LoKiPhysMC.decorators import *" , "from LoKiPhysMC.functions import mcMatch" ] decayDesc.set_carets(False) decayDescCC = decayDesc.copy() decayDescCC.cc = True algname = decayDesc.get_full_alias() + '_MCSel' if algname in selections : return selections[algname] if not decayDesc.daughters : alg = FilterDesktop(algname + '_Filter') if decayDesc.particle.name in mcbasicinputs : inputsel = mcbasicinputs[decayDesc.particle.name] else : conj = decayDesc.conjugate() if conj.particle.name in mcbasicinputs : inputsel = mcbasicinputs[conj.particle.name] else : raise ValueError("Can't find MC basic input for particle " + repr(decayDesc.particle.name)) alg.Code = 'mcMatch({0!r})'.format(decayDescCC.to_string(arrow)) alg.Preambulo = preamble sel = Selection(algname, Algorithm = alg, RequiredSelections = [inputsel]) selections[algname] = sel return sel inputs = [] daughtercuts = {} for daughter in decayDescCC.daughters : originaldaughtercc = daughter.cc daughter.cc = True sel = build_mc_unbiased_selection(daughter, arrow) daughter.cc = originaldaughtercc inputs.append(sel) #daughter.caret = True #daughtercuts[daughter.particle.name] = 'mcMatch({0!r})'.format(decayDescCC.to_string(arrow)) #daughter.caret = False #comb = nCombiners[len(decayDesc.daughters)](algname + '_Comb') comb = CombineParticles(algname + '_Comb') # CombineParticles uses small cc, so set ishead = False comb.DecayDescriptors = [decayDesc.to_string(depth = 1, ishead = False)] comb.MotherCut = 'mcMatch({0!r})'.format(decayDescCC.to_string(arrow)) comb.Preambulo = preamble comb.DaughtersCuts = daughtercuts sel = Selection(algname, Algorithm = comb, RequiredSelections = inputs) selections[algname] = sel return sel
year = "2016" magnetPolarity = "Down" ###################################################################################################### # if you are setting something wrong, it should die here... if year not in [ "2016" ]: raise RuntimeError(year + " is not a valid year") if magnetPolarity not in ["Up", "Down"]: raise RuntimeError(magnetPolarity + " is not a valid magnet polarity") ###################################################################################################### from Configurables import CombineParticles KsPiPi= CombineParticles("KsPiPi") KsPiPi.DecayDescriptor = "KS0 -> pi+ pi-" KsPiPi.CombinationCut = "ADAMASS('KS0')<100*MeV" KsPiPi.MotherCut = "(VFASPF(VCHI2/VDOF)<10)" KsPiPi.DaughtersCuts = { "pi+" : "ALL", "pi-" : "ALL" } KsPiPi.MotherCut = "(M > 400) & (M < 600) & (BPVVDCHI2 > 100.) & (VFASPF(VCHI2/VDOF) < 10)" from PhysSelPython.Wrappers import Selection from StandardParticles import StdNoPIDsDownPions, StdLoosePions LooseKsPiPi = Selection("SelLooseKsPiPi", Algorithm = KsPiPi, RequiredSelections = [StdNoPIDsDownPions ]) #RequiredSelections = [StdLoosePions]) from PhysSelPython.Wrappers import SelectionSequence SeqKsPiPi = SelectionSequence('SeqKsPiPi', TopSelection = LooseKsPiPi) KsPiPiTuple = DecayTreeTuple("KsPiPiTuple") # input locations KsPiPiTuple.Inputs = [ LooseKsPiPi.outputLocation() ]
def execute(simulation=True, turbo=True, decay_descriptor="J/psi(1S) -> mu- mu+"): # Configure all the unpacking, algorithms, tags and input files appConf = ApplicationMgr() appConf.ExtSvc+= ['ToolSvc', 'DataOnDemandSvc', LoKiSvc()] ConfigTarFileAccessSvc().File = 'config.tar' dv = DaVinci() dv.DataType = "2012" lhcbApp = LHCbApp() lhcbApp.Simulation = simulation CondDB().Upgrade = False dtt = DecayTreeTuple("Early2015") if turbo: tesla_prefix = "Hlt2DiMuonJPsi" dtt.Inputs = ["/Event/"+tesla_prefix+"/Particles"] dtt.InputPrimaryVertices = "/Event/"+tesla_prefix+"/Primary" dtt.WriteP2PVRelations = False else: LHCbApp().DDDBtag = "dddb-20140729" polarity = "u" LHCbApp().CondDBtag = "sim-20140730-vc-m%s100"%polarity muons = AutomaticData(Location="Phys/StdAllLooseMuons/Particles") jpsi = CombineParticles('MyJPsi') jpsi.DecayDescriptors = [decay_descriptor] jpsi.CombinationCut = "(AM < 7100.0 *GeV)" jpsi.DaughtersCuts = {"": "ALL", "mu+": "ALL", "mu-": "ALL"} jpsi.MotherCut = "(VFASPF(VCHI2/VDOF) < 999999.0)" code = """ ('J/psi(1S)' == ID) & in_range(2.990*GeV, M, 3.210*GeV) & DECTREE('%s') & CHILDCUT(1, HASMUON & ISMUON) & CHILDCUT(2, HASMUON & ISMUON) & (MINTREE('mu+' == ABSID, PT) > 700*MeV) & (MAXTREE(ISBASIC & HASTRACK, TRCHI2DOF) < 5) & (MINTREE(ISBASIC & HASTRACK, CLONEDIST) > 5000) & (VFASPF(VPCHI2) > 0.5/100) & (abs(BPV(VZ)) < 0.5*meter) & (BPV(vrho2) < (10*mm)**2) """%(decay_descriptor) # similar to the HLT2 line code = """ (ADMASS('J/psi(1S)')< 120*MeV) & DECTREE('%s') & (PT>0*MeV) & (MAXTREE('mu-'==ABSID,TRCHI2DOF) < 4) & (MINTREE('mu-'==ABSID,PT)> 0*MeV) & (VFASPF(VCHI2PDOF)< 25) """%(decay_descriptor) filter_jpsi = FilterDesktop("MyFilterJPsi", Code=code, Preambulo=["vrho2 = VX**2 + VY**2"], ReFitPVs=True, #IgnoreP2PVFromInputLocations=True, #WriteP2PVRelations=True ) jpsi_sel = Selection("SelMyJPsi", Algorithm=jpsi, RequiredSelections=[muons]) filter_jpsi_sel = Selection("SelFilterMyJPsi", Algorithm=filter_jpsi, RequiredSelections=[jpsi_sel]) jpsi_seq = SelectionSequence("SeqMyJPsi", TopSelection=filter_jpsi_sel) dtt.Inputs = [jpsi_seq.outputLocation()] # Overwriting default list of TupleTools dtt.ToolList = ["TupleToolKinematic", "TupleToolPid", "TupleToolEventInfo", "TupleToolMCBackgroundInfo", "TupleToolMCTruth", #"MCTupleToolHierarchy", #"MCTupleToolPID", "TupleToolGeometry", "TupleToolTISTOS", # with turbo this crashes #"TupleToolTrackInfo", "TupleToolTrigger", ] tlist = ["L0HadronDecision", "L0MuonDecision", "L0DiMuonDecision", "L0ElectronDecision", "L0PhotonDecision", "Hlt1DiMuonHighMassDecision", "Hlt1DiMuonLowMassDecision", "Hlt1TrackMuonDecision", "Hlt1TrackAllL0Decision", "Hlt2DiMuonJPsiDecision", "Hlt2SingleMuonDecision", ] dtt.addTool(TupleToolTrigger, name="TupleToolTrigger") dtt.addTool(TupleToolTISTOS, name="TupleToolTISTOS") # Get trigger info dtt.TupleToolTrigger.Verbose = True dtt.TupleToolTrigger.TriggerList = tlist dtt.TupleToolTISTOS.Verbose = True dtt.TupleToolTISTOS.TriggerList = tlist from Configurables import TupleToolMCTruth, MCTupleToolHierarchy dtt.addTool(TupleToolMCBackgroundInfo, name="TupleToolMCBackgroundInfo") dtt.TupleToolMCBackgroundInfo.Verbose = True dtt.addTool(MCTupleToolHierarchy, name="MCTupleToolHierarchy") dtt.MCTupleToolHierarchy.Verbose = True dtt.addTool(TupleToolMCTruth, name="TupleToolMCTruth") dtt.TupleToolMCTruth.Verbose = True if turbo: assoc_seq = TeslaTruthUtils.associateSequence(tesla_prefix, False) ChargedPP2MC(tesla_prefix+"ProtoAssocPP").OutputLevel = 1 assoc_seq.Members.insert(0, PatLHCbID2MCParticle()) from Configurables import MuonCoord2MCParticleLink muon_coords = MuonCoord2MCParticleLink("TeslaMuonCoordLinker") assoc_seq.Members.insert(1, muon_coords) TrackAssociator("TeslaAssocTr").DecideUsingMuons = True relations = TeslaTruthUtils.getRelLoc(tesla_prefix) else: relations = "Relations/Rec/ProtoP/Charged" TeslaTruthUtils.makeTruth(dtt, relations, ["MCTupleToolKinematic", "MCTupleToolHierarchy", "MCTupleToolPID", ] ) dtt.Decay = mark(2, mark(3, decay_descriptor)) #"J/psi(1S) -> ^mu- ^mu+" dtt.addBranches({"X": "^(%s)"%(decay_descriptor), "muplus": mark(3, decay_descriptor),#"J/psi(1S) -> mu- ^mu+", "muminus": mark(2, decay_descriptor),#"J/psi(1S) -> ^mu- mu+", }) x_preamble = ["DZ = VFASPF(VZ) - BPV(VZ)", ] x_vars = {"ETA": "ETA", "Y": "Y", "PHI": "PHI", "VPCHI2": "VFASPF(VPCHI2)", "DELTAZ": "DZ", # DZ * M / PZ / c with c in units of mm/s # XXX should this be the PDG mass or measured mass? #"TZ": "DZ*M / PZ / 299792458000.0", #seconds "TZ": "DZ*3096.916 / PZ/299792458000.0*(10**12)", #ps "minpt": "MINTREE('mu+' == ABSID, PT)", "minclonedist": "MINTREE(ISBASIC & HASTRACK, CLONEDIST)", "maxtrchi2dof": "MAXTREE(ISBASIC & HASTRACK, TRCHI2DOF)", } muon_vars = {"ETA": "ETA", "Y": "Y", "PHI": "PHI", "CHARGE": "Q", "CLONEDIST": "CLONEDIST", "TRCHI2DOF": "TRCHI2DOF", } loki_X = dtt.X.addTupleTool("LoKi::Hybrid::TupleTool/LoKi_X") loki_X.Variables = x_vars loki_X.Preambulo = x_preamble loki_mup = dtt.muplus.addTupleTool("LoKi::Hybrid::TupleTool/LoKi_MuPlus") loki_mup.Variables = muon_vars #dtt.muplus.addTupleTool("TupleToolGeometry") loki_mum = dtt.muminus.addTupleTool("LoKi::Hybrid::TupleTool/LoKi_MuMinus") loki_mum.Variables = muon_vars #dtt.muminus.addTupleTool("TupleToolGeometry") dv.TupleFile = "DVNtuples.root" if turbo: dv.UserAlgorithms = [assoc_seq, dtt] else: assocpp = ChargedPP2MC("TimsChargedPP2MC") assocpp.OutputLevel = 1 dv.UserAlgorithms = [jpsi_seq.sequence(), assocpp, dtt]
############### # Stripping filter strippingFilter = LoKi__HDRFilter( 'StripPassFilter', Code="HLT_PASS('Stripping"+line+"Decision')", Location="/Event/Strip/Phys/DecReports" ) evtPreselectors.append(strippingFilter) # Muons and kaons looseMuons = DataOnDemand(Location = 'Phys/StdLooseMuons/Particles') looseKaons = DataOnDemand(Location = 'Phys/StdLooseKaons/Particles') loosePions = DataOnDemand(Location = 'Phys/StdLoosePions/Particles') # Select Phi recoPhi = CombineParticles("Phi2KK") recoPhi.DecayDescriptor = 'phi(1020) -> K+ K-' recoPhi.DaughtersCuts = {"K+": "(ISLONG) & (TRCHI2DOF < 3 ) & (TRGHOSTPROB<0.3) & ( BPVIPCHI2 () > 9 ) & (PT>300*MeV) & (PIDK > 5)", "K-": "(ISLONG) & (TRCHI2DOF < 3 ) & (TRGHOSTPROB<0.3) & ( BPVIPCHI2 () > 9 ) & (PT>300*MeV) & (PIDK > 5)"} recoPhi.CombinationCut = "(ADAMASS('phi(1020)')<10*MeV)" recoPhi.MotherCut = " ( VFASPF(VCHI2) < 10 ) & (MIPCHI2DV(PRIMARY)> 16.)" # Very loose version for testing # recoPhi = CombineParticles("Phi2KK") # recoPhi.DecayDescriptor = 'phi(1020) -> K+ K-' # recoPhi.DaughtersCuts = {"K+": "(ISLONG) & (TRCHI2DOF < 3 ) & (TRGHOSTPROB<0.3) & ( BPVIPCHI2 () > 9 ) & (PT>300*MeV) & (PIDK > -5)", # "K-": "(ISLONG) & (TRCHI2DOF < 3 ) & (TRGHOSTPROB<0.3) & ( BPVIPCHI2 () > 9 ) & (PT>300*MeV) & (PIDK > -5)"} # recoPhi.CombinationCut = "(ADAMASS('phi(1020)')<35*MeV)" # recoPhi.MotherCut = " ( VFASPF(VCHI2) < 25 ) & (MIPCHI2DV(PRIMARY)> 4.)" phi_selection = Selection('SelPhi2KK', Algorithm = recoPhi, RequiredSelections = [ looseKaons ]) # Select Tau
Phi.DecayDescriptor = 'phi(1020) -> KS0 KS0' #Cuts from the stripping line Phi.CombinationCut = "( (ACHILDCUT(CHILDCUT(ISLONG,1),1)) | (ACHILDCUT(CHILDCUT(ISLONG,1),2)) ) & (APT > %(Phi_PT_MIN)s *MeV) & (ADAMASS('phi(1020)')<%(Phi_MASS_RANGE)s +30*MeV) & (ACUTDOCACHI2(%(Phi_DOCACHI2_MAX)s,''))" %config Phi.MotherCut = "(ADMASS('phi(1020)')<%(Phi_MASS_RANGE)s*MeV) & (VFASPF(VCHI2/VDOF) < %(Phi_VCHI2NDOF_MAX)s)" %config Phi_Sel = Selection(name = "Sel_Phi2KsKs", Algorithm = Phi, RequiredSelections = [Ks])#[StdLooseKsDD,StdLooseKsLL]) Ds = CombineParticles("Ds2PhiPi") Ds.DecayDescriptor = '[D_s+ -> phi(1020) pi+]cc' Ds.DaughtersCuts = { '' : 'ALL' , 'phi(1020)' : '(ALL)' , 'pi+' : '(PT >150 *MeV) & (BPVIPCHI2() > 1.0) & ( TRCHI2DOF < 5 )& (TRGHOSTPROB<0.3)'} Ds.CombinationCut = "(ADAMASS('D_s+')<180*MeV)" Ds.MotherCut = "(VFASPF(VCHI2/VDOF) < 25.0)& (((BPVVDCHI2 > 16.0)|(BPVLTIME() > 0.150 * picosecond)))"#& (BPVDIRA > 35.0*mrad)" Ds.MotherCut += "&(ADMASS('D_s+')<150*MeV)" %config Ds_Sel = Selection(name = "Sel_Ds2PhiPi", Algorithm = Ds, RequiredSelections = [Phi_Sel, Pions]) Ds_sequence = SelectionSequence('SeqDs2PhiPi', TopSelection = Ds_Sel ) #This filter is used just to speed up the process, nothing happens if there
def configure ( inputdata , ## the list of input files catalogs = [] , ## xml-catalogs (filled by GRID) castor = False , ## use the direct access to castor/EOS ? params = {} ) : ## configure Track <--> MC relation table import LoKiPhysMC.Track2MC_Configuration import LoKiMC.MC ## import DaVinci from Configurables import DaVinci, GaudiSequencer ## delegate the actual configurtaion to DaVinci dv = DaVinci ( DataType = '2011' , InputType = 'MDST', Lumi = True, Simulation = True, DDDBtag="MC11-20111102", CondDBtag="sim-20111111-vc-md100", HistogramFile = "mcd02kpi_tracks7_histo.root", TupleFile = "mcd02kpi_tracks7_ntuple.root", PrintFreq = 1000) from Configurables import DecayTreeTuple, FilterDesktop, TupleToolGeometry, CombineParticles from Configurables import MCDecayTreeTuple, TupleToolMCTruth, MCTupleToolHierarchy from PhysSelPython.Wrappers import AutomaticData, Selection, SelectionSequence, DataOnDemand from Configurables import CheckPV # First using CombineParticle to create the D0 ################################################################################ #from StandardParticles import StdAllNoPIDsPions, StdAllNoPIDsKaons _pions = DataOnDemand(Location='Phys/StdAllNoPIDsPions/Particles') _kaons = DataOnDemand(Location='Phys/StdAllNoPIDsKaons/Particles') _d2kpi = CombineParticles("d2kpi") _d2kpi.DecayDescriptor = "[D0 -> K- pi+]cc" _d2kpi.DaughtersCuts = { "K-" : "(PT > 500.0) & (0.0 < PIDK)", "pi+" : "(PT > 500.0) & (5.0 > PIDK)", "K+" : "(PT > 500.0) & (0.0 < PIDK)", "pi-" : "(PT > 500.0) & (5.0 > PIDK) " } _d2kpi.MotherCut = "(VFASPF(VCHI2/VDOF)<10)" _d2kpi.CombinationCut = "(ADAMASS('D0') < 50.0)" _d2kpi.Preambulo = [ "from LoKiPhysMC.decorators import *" , "from PartProp.Nodes import CC" ] #_d2kpi.ReFitPVs = True SelD2KPi = Selection( "SelD2KPi", Algorithm= _d2kpi, RequiredSelections=[_pions,_kaons] ) SeqD2KPi = SelectionSequence('SeqD2KPi',TopSelection = SelD2KPi) # Now the CheckPV method to filter algorithms c = CheckPV("OnePV") c.MinPVs = 1 # And a sequencer to put them together gseq = GaudiSequencer() gseq.Members = [ c, SeqD2KPi.sequence() ] ## define the input data setData ( inputdata , catalogs , castor ) ## get/create application manager gaudi = appMgr() # ## modify/update the configuration: # ## (1) create the algorithm alg = TrackFilter( 'TrackFilter' ) #seq = createSequencer() ## (2) replace the list of top level algorithm by # new list, which contains only *THIS* algorithm gaudi.setAlgorithms( [ gseq, alg ] ) return SUCCESS
from os import environ import GaudiKernel.SystemOfUnits as Units from Gaudi.Configuration import * from Configurables import CombineParticles, PhysDesktop from Configurables import LoKi__Hybrid__PlotTool as PlotTool importOptions("$DAVINCIROOT/options/DaVinciCommon.opts") ApplicationMgr().TopAlg += ["GaudiSequencer/TutorialSeq"] jpsi2mumu = CombineParticles("Jpsi2MuMu") jpsi2mumu.addTool(PhysDesktop()) jpsi2mumu.PhysDesktop.InputLocations = ["Phys/StdLooseMuons"] jpsi2mumu.DecayDescriptor = "J/psi(1S) -> mu+ mu-" jpsi2mumu.DaughtersCuts = {"mu+": "ALL", "mu-": "ALL"} jpsi2mumu.CombinationCut = "ADAMASS('J/psi(1S)')<30" jpsi2mumu.MotherCut = "(VFASPF(VCHI2/VDOF)<100)" GaudiSequencer("TutorialSeq").Members.append(jpsi2mumu) phi2kk = CombineParticles("Phi2KK") phi2kk.addTool(PhysDesktop()) phi2kk.PhysDesktop.InputLocations = ["Phys/StdLooseKaons"] phi2kk.DecayDescriptor = "phi(1020) -> K+ K-" phi2kk.CombinationCut = "ADAMASS('phi(1020)')<50" phi2kk.MotherCut = "(VFASPF(VCHI2/VDOF)<100)" GaudiSequencer("TutorialSeq").Members.append(phi2kk) bs2jpsiphi = CombineParticles("Bs2JpsiPhi") bs2jpsiphi.addTool(PhysDesktop()) bs2jpsiphi.PhysDesktop.InputLocations = ["Phys/Jpsi2MuMu", "Phys/Phi2KK"] bs2jpsiphi.DecayDescriptor = "B_s0 -> phi(1020) J/psi(1S)"