def makeDecayTreeTuple( location, decay, alg_name, tuple_name ): tuple = DecayTreeTuple( alg_name ) dectype = alg_name[-2:] #triggerList = list(l0hlt1List) #if 'KK' == dectype: # for trigger in hlt2List_KK: # triggerList.append( trigger + 'Decision') #elif 'Pi' == dectype: # for trigger in hlt2List_Pi: # triggerList.append( trigger + 'Decision') #elif 'RS' == dectype or 'WS' == dectype: # for trigger in hlt2List_KPi: # triggerList.append( trigger + 'Decision') print alg_name, triggerList #tuple = DecayTreeTuple('TupleKK') tuple.ToolList = [ "TupleToolPropertime", "TupleToolKinematic", #"TupleToolPropertime/MyPropertimeTool", "TupleToolGeometry", "TupleToolEventInfo", "TupleToolPrimaries", "TupleToolTISTOS", #"TupleToolTrigger", "TupleToolPid", "TupleToolTrackInfo", "TupleToolRecoStats", #"TupleToolGeneration" ] #tuple.addTool( TupleToolPropertime( name="MyPropertimeTool" ) ) #tuple.MyPropertimeTool.ToolName = "PropertimeFitter/MyPropertimeFitter" #tuple.MyPropertimeTool.ExtraName = "MassConstraint" #tuple.MyPropertimeTool.addTool( PropertimeFitter( name = "MyPropertimeFitter" ) ) #tuple.MyPropertimeTool.MyPropertimeFitter.applyBMassConstraint = True tuple.Inputs = [ location ]#_strippingOutput] #tuple.InputLocations = [ location ]#_strippingOutput] tuple.Decay = decay #tuple.Decay = "[D0 -> ^K- ^pi+]CC" tuple.TupleName = tuple_name #tuple.TupleName = "D0KKTuple" tuple.addTool( TupleToolPropertime() ) tuple.TupleToolPropertime.FitToPV = True #tuple.addTool( TupleToolTrigger() ) #tuple.TupleToolTrigger.TriggerList = triggerList #tuple.TupleToolTrigger.VerboseL0 = True #tuple.TupleToolTrigger.VerboseHlt1 = True #tuple.TupleToolTrigger.VerboseHlt2 = True #tuple.TupleToolTrigger.Verbose = True tuple.addTool( TupleToolTISTOS() ) tuple.TupleToolTISTOS.VerboseL0 = True tuple.TupleToolTISTOS.VerboseHlt1 = True tuple.TupleToolTISTOS.VerboseHlt2 = True tuple.TupleToolTISTOS.Verbose = True tuple.TupleToolTISTOS.TriggerList = triggerList return tuple
# fltrs = LoKi_Filters( # STRIP_Code = "HLT_PASS('StrippingPhiToKSKS_PhiToKsKsLineDecision')") from Configurables import FitDecayTrees, DecayTreeTuple, TupleToolDecayTreeFitter, TupleToolDecay, TupleToolTrigger, TupleToolTISTOS, TupleToolPropertime, PropertimeFitter, TupleToolKinematic, TupleToolGeometry, TupleToolEventInfo, TupleToolPrimaries, TupleToolPid, TupleToolTrackInfo, TupleToolRecoStats, TupleToolMCTruth, LoKi__Hybrid__TupleTool, LoKi__Hybrid__EvtTupleTool from Configurables import LoKi__LifetimeFitter tuple = DecayTreeTuple("TuplePhi2KsKs") #Give DecayTreeTuple the location of your stripped candidates #If you apply a selection, this will be the output of a selection sequence object. tuple.Inputs = [Ds_sequence.outputLocation()] tuple.ToolList = ['TupleToolKinematic', 'TupleToolEventInfo', 'TupleToolTrackInfo', 'TupleToolPid', 'TupleToolGeometry', 'TupleToolAngles', ] tuple.InputPrimaryVertices = '/Event/Charm/Rec/Vertex/Primary' # # Other event infos tuple.addTupleTool('LoKi::Hybrid::EvtTupleTool/LoKi_Evt') tuple.LoKi_Evt.VOID_Variables = { "nTracks" : "CONTAINS('/Event/Charm/Rec/Track/Best')", "nPVs" : "CONTAINS('/Event/Charm/Rec/Vertex/Primary')" }
def makeTuple(self): """ Make tuple """ from Configurables import FitDecayTrees, DecayTreeTuple, TupleToolDecayTreeFitter, TupleToolDecay, TupleToolTrigger, TupleToolTISTOS, TupleToolPropertime, PropertimeFitter, TupleToolKinematic, TupleToolGeometry, TupleToolEventInfo, TupleToolPrimaries, TupleToolPid, TupleToolTrackInfo, TupleToolRecoStats, TupleToolMCTruth, LoKi__Hybrid__TupleTool, LoKi__Hybrid__EvtTupleTool tuple = DecayTreeTuple('Tuple'+self.name) # I can put as an argument a name if I use more than a DecayTreeTuple tuple.Inputs = [ self.sequence.outputLocation() ] tuple.Decay = self.dec tuple.ToolList = ['TupleToolKinematic', 'TupleToolEventInfo', 'TupleToolTrackInfo', 'TupleToolPid', 'TupleToolGeometry', 'TupleToolAngles', # Helicity angle # 'TupleToolPropertime', #proper time TAU of reco particles ] tuple.InputPrimaryVertices = '/Event/Charm/Rec/Vertex/Primary' # Other event infos tuple.addTupleTool('LoKi::Hybrid::EvtTupleTool/LoKi_Evt') tuple.LoKi_Evt.VOID_Variables = { #"nSPDHits" : " CONTAINS('Raw/Spd/Digits') " , 'nTracks' : " CONTAINS ('Charm/Rec/Track/Best') " , } # # Other variables # tuple.addTupleTool('LoKi::Hybrid::TupleTool/LoKi_All') # tuple.LoKi_All.Variables = { # 'BPVIPCHI2' : 'BPVIPCHI2()', # 'BPVDIRA' : 'BPVDIRA', # 'BPVLTFITCHI2' : 'BPVLTFITCHI2()', # } tuple.addBranches(self.branches) tuple.phi.addTupleTool("LoKi::Hybrid::TupleTool/LoKi_phi") tuple.phi.LoKi_phi.Variables = { 'DOCAMAX' : 'DOCAMAX', "MassDiff_Phi" : "DMASS('phi(1020)')", "BPVDIRA" : "BPVDIRA", "IPS_Phi" : "MIPCHI2DV(PRIMARY)", "VFASPF_CHI2DOF" : "VFASPF(VCHI2/VDOF)", "VFASPF_CHI2" : "VFASPF(VCHI2)", "BPVIPCHI2" : "BPVIPCHI2()", "ADOCA" : "DOCA(1,2)", "ADOCACHI2" : "DOCACHI2(1,2)", "DTF_CHI2_PV" : "DTF_CHI2( True, 'phi(1020)' )", "DTF_NDOF_PV" : "DTF_NDOF( True, 'phi(1020)' )", "DTF_M_PV" : "DTF_FUN ( M, True, 'phi(1020)' )", "DTF_M_Ks1_PV" : "DTF_FUN ( CHILD(M,1), True, 'phi(1020)' )", "DTF_M_Ks2_PV" : "DTF_FUN ( CHILD(M,2), True, 'phi(1020)' )", # "DTF_CTAU_Ks1" : "DTF_CTAU(1, False, 'phi(1020)' )", # "DTF_CTAU_Ks2" : "DTF_CTAU(2, False, 'phi(1020)' )", } def mySharedConf_Ks(branch): atool=branch.addTupleTool('LoKi::Hybrid::TupleTool/LoKi_Ks') atool.Variables = { "BPVDIRA" : "BPVDIRA", "VFASPF_CHI2DOF" : "VFASPF(VCHI2/VDOF)", "VFASPF_CHI2" : "VFASPF(VCHI2)", "BPVIPCHI2" : "BPVIPCHI2()", "BPVVD" : "BPVVD", "BPVVDCHI2" : "BPVVDCHI2", "ADOCA" : "DOCA(1,2)", "ADOCACHI2" : "DOCACHI2(1,2)", 'BPVLTIME' : 'BPVLTIME()', } PropertimeTool = branch.addTupleTool("TupleToolPropertime/Propertime_Ks") mySharedConf_Ks(tuple.Ks1) mySharedConf_Ks(tuple.Ks2) def mySharedConf_pi(branch): atool=branch.addTupleTool('LoKi::Hybrid::TupleTool/LoKi_pi') atool.Variables = { 'TRCHI2DOF' : 'TRCHI2DOF', 'TRGHOSTPROB' : 'TRGHOSTPROB', } mySharedConf_pi(tuple.pi1) mySharedConf_pi(tuple.pi2) mySharedConf_pi(tuple.pi3) mySharedConf_pi(tuple.pi4) # Triggers: tuple.phi.addTupleTool('TupleToolTISTOS/TISTOS') tuple.phi.TISTOS.TriggerList = trigger_list tuple.phi.TISTOS.VerboseL0 = True tuple.phi.TISTOS.VerboseHlt1 = True tuple.phi.TISTOS.VerboseHlt2 = True if dataSample.isMC: from Configurables import MCDecayTreeTuple, MCTupleToolKinematic, TupleToolMCTruth, MCTupleToolHierarchy, MCTupleToolReconstructed, MCTupleToolAngles, TupleToolMCBackgroundInfo tuple.addTupleTool('TupleToolMCTruth/MCTruth') tuple.MCTruth.ToolList = ['MCTupleToolKinematic', 'MCTupleToolHierarchy', 'MCTupleToolReconstructed', 'MCTupleToolAngles', ] tuple.phi.addTupleTool( "TupleToolMCBackgroundInfo") self.sequence.sequence().Members += [tuple]
tupleB = DecayTreeTuple("bae-muon-data") tupleB.Inputs = [SeqB.outputLocation()] tupleB.Decay = "[B+ -> ^K+ ^(J/psi(1S) -> ^mu+ ^mu-)]CC" tupleB.ToolList = [ "TupleToolKinematic" , "TupleToolEventInfo" , "TupleToolRecoStats" , "TupleToolTrigger", "TupleToolPid", "TupleToolPrimaries", "TupleToolAngles", "TupleToolEventInfo", "TupleToolGeometry", "TupleToolKinematic", "TupleToolPropertime", "TupleToolRecoStats", "TupleToolTrackInfo", "TupleToolTISTOS", "TupleToolBremInfo", "TupleToolPhotonInfo"#, ,"TupleToolTrackIsolation" , "TupleToolANNPID" # , "TupleBuKmmFit" ] # Probably need to add many more Tools. tupleB.addBranches ({ "Kplus" : "[B+ -> ^K+ (J/psi(1S) -> mu+ mu-)]CC", "Jpsi" : "[B+ -> K+ ^(J/psi(1S) -> mu+ mu-)]CC",
############################################################ ## Make tuple ############################################################ from Configurables import FitDecayTrees, DecayTreeTuple, TupleToolDecayTreeFitter, TupleToolDecay, TupleToolTrigger, TupleToolTISTOS, TupleToolPropertime, PropertimeFitter, TupleToolKinematic, TupleToolGeometry, TupleToolEventInfo, TupleToolPrimaries, TupleToolPid, TupleToolTrackInfo, TupleToolRecoStats, TupleToolMCTruth, TupleToolMCBackgroundInfo, LoKi__Hybrid__TupleTool, LoKi__Hybrid__EvtTupleTool from DecayTreeTuple.Configuration import * tuple = DecayTreeTuple() # I can put as an argument a name if I use more than a DecayTreeTuple tuple.Inputs = [ tau_sequence.outputLocation() ] tuple.Decay = dec tuple.ToolList = ['TupleToolKinematic', 'TupleToolEventInfo', 'TupleToolTrackInfo', 'TupleToolPid', 'TupleToolGeometry', 'TupleToolAngles', # Helicity angle #'TupleToolP2VV', # various angles, not useful in my analysis because only default values 'TupleToolPropertime', #proper time TAU of reco particles #'TupleToolPrimaries', #num primary vertices and coords ] # Track isolation tuple.addTupleTool('TupleToolTrackIsolation/TrackIsolation') tuple.TrackIsolation.MinConeAngle = 0.5 tuple.TrackIsolation.MaxConeAngle = 1. tuple.TrackIsolation.StepSize = 0.1 # Other event infos tuple.addTupleTool('LoKi::Hybrid::EvtTupleTool/LoKi_Evt') tuple.LoKi_Evt.VOID_Variables = { "nSPDHits" : " CONTAINS('Raw/Spd/Digits') " ,
tuple2 = MCDecayTreeTuple("MCTeslaTuple") tuple2.Inputs = ['/Event/Tesla/Particles'] tuple2.Decay = tuple.Decay from Configurables import DataOnDemandSvc, L0SelReportsMaker, L0DecReportsMaker DataOnDemandSvc().AlgMap["HltLikeL0/DecReports"] = L0DecReportsMaker() DataOnDemandSvc().AlgMap["HltLikeL0/SelReports"] = L0SelReportsMaker() from Configurables import L0Conf L0Conf().FullL0MuonDecoding = True L0Conf().EnableL0DecodingOnDemand = True L0Conf().EnsureKnownTCK=False tuple3 = DecayTreeTuple("StrippingTuple") tuple3.Inputs = ['/Event/AllStreams/Phys/FullDSTDiMuonJpsi2MuMuDetachedLine/Particles'] tuple3.Decay = tuple.Decay tuple3.ToolList = tuple.ToolList tuple3.addTool(TupleToolTrigger, name="TupleToolTrigger") tuple3.addTool(TupleToolTISTOS, name="TupleToolTISTOS") tuple3.TupleToolTrigger.Verbose = True tuple3.TupleToolTrigger.TriggerList = tlist tuple3.TupleToolTISTOS.Verbose = True tuple3.TupleToolTISTOS.TriggerList = tlist tuple4 = MCDecayTreeTuple("MCStrippingTuple") tuple4.Inputs = ['/Event/AllStreams/Phys/FullDSTDiMuonJpsi2MuMuDetachedLine/Particles'] tuple4.Decay = tuple.Decay #DaVinci().UserAlgorithms += [ tuple2 ] #DaVinci().TupleFile = "DVNtuples.root"
def addTuple(name="", decay="", addendum="", head="/Event/Phys/", dtf=True, resonant=True, shortname="", verbose=[] ): from Configurables import DecayTreeTuple, PrintDecayTree, FilterDesktop, GaudiSequencer, PrintHeader, TESCheck if shortname == "": shortname = name shortname = shortname+"_Tuple"+addendum shortname = shortname.replace("MCMC","MC") seq = GaudiSequencer("Seq"+shortname) if ( not "/"==head[-1] ): head = head+'/' location = head+name+"/Particles" from Configurables import LoKi__HDRFilter if ( "/Event/Phys/" == head ): filter = TESCheck("Check"+shortname,Inputs = [ location ], Stop = False) else : # I am not running the selection, hence the stripping decision must be here filter = LoKi__HDRFilter( "Check"+shortname, Code = "HLT_PASS('Stripping"+name+"Decision')", Location="/Event/Strip/Phys/DecReports" ) #filter.OutputLevel = 1 seq.Members += [ filter ] # PrintHeader(), tuple = DecayTreeTuple(shortname) isMDST = (addendum.upper()=="MDST") if (isMDST): RIT = head.replace("/Phys","") print "RootInTES set to", RIT tuple.RootInTES = RIT tuple.Inputs = [ "Phys/"+name+"/Particles" ] else : tuple.Inputs = [ location ] # tuple.OutputLevel = 1 tuple.ToolList = [] tuple.Decay = decay tg = tuple.addTupleTool("TupleToolGeometry") if not isMDST: tg.FillMultiPV = True tlist = [] if ("e+" in decay): tlist = electronLines() elif ("mu+" in decay): tlist = muonLines() if ( False ): tlist = allLines() print tlist if ( Jpsi2MuMu != decay ): bpsi = (decay.replace("^","")).replace("(J/psi(1S)","^(J/psi(1S)") else : bpsi = "^("+decay.replace("^","")+")" print "J/psi branch is `` ", bpsi, "''" tuple.Branches["Psi"] = bpsi # sort out kstars if "892" in decay: bkstar = (decay.replace("^","")).replace("(K*(892)","^(K*(892)") tuple.Branches["Kstar"] = bkstar Kstar = tuple.addTupleTool("TupleToolDecay/Kstar") from Configurables import TupleToolTISTOS tistos = TupleToolTISTOS(TriggerList = tlist , VerboseHlt1 = True, VerboseHlt2 = True, VerboseL0 = True) Psi = tuple.addTupleTool("TupleToolDecay/Psi") Psi.addTool(tistos) Psi.ToolList += [ "TupleToolTISTOS" ] # if (not isMDST): # vi = tuple.Psi.addTupleTool("TupleToolVtxIsoln") # vi.InputParticles = [ "/Event/Phys/MyGoodPions" ] if ( Jpsi2MuMu == decay ): if (dtf): pvfit = tuple.Psi.addTupleTool("TupleToolDecayTreeFitter/PVFit") # fit with all constraints I can think of pvfit.Verbose = True pvfit.constrainToOriginVertex = True else: B = tuple.addTupleTool("TupleToolDecay/B") if ( Bs2JpsiPhi==decay ): p2vv = B.addTupleTool("TupleToolP2VV") p2vv.Calculator = "Bs2JpsiPhiAngleCalculator" elif ( "K*(892)0" in decay and not Bd2MuMuKstSS==decay ): p2vv = B.addTupleTool("TupleToolP2VV") p2vv.Calculator = "Bd2KstarMuMuAngleCalculator" if (Lambdab2Jpsippi==decay ): B.addTupleTool("TupleToolDalitz") if ('Xi_b-' in decay ): bh = 'Xi_b-' elif ('Xi_b~+' in decay ): bh = 'Xi_b~+' elif ('Lambda_b0' in decay ): bh = 'Lambda_b0' elif ('B0' in decay): bh = 'B0' elif ('B+' in decay ): bh = 'B+' elif ('B_s0' in decay ): bh = 'B_s0' if ('CC' in decay): bh = '['+bh+']cc' print "Branch will be ``", bh+" : "+decay.replace("^",""), "''" tuple.Branches["B"] = "^("+decay.replace("^","")+")" # This is needed for ConstB bhh = bh.replace('[','').replace(']cc','') if (('pi0' not in decay) and ('KS0' not in decay) and ('Lambda0' not in decay)): # B.ToolList += [ "TupleToolAngles"] tta = tuple.addTupleTool("TupleToolAngles") if (not resonant): tta.WRTMother = False # if (( 'K*(892)0' in decay) or ('phi' in decay)): tuple.B.ToolList += [ "TupleToolP2VV" ] # really wants a VV if (dtf): FullFit = B.addTupleTool("TupleToolDecayTreeFitter/FullFit") FullFit.Verbose = True # fills daughters FullFit.constrainToOriginVertex = True FullFit.daughtersToConstrain += [ "J/psi(1S)" ] # even non resonant if ("ConstBFit" in verbose): ConstBFit = B.addTupleTool("TupleToolDecayTreeFitter/ConstBFit") ConstBFit.Verbose = True ConstBFit.constrainToOriginVertex = True ConstBFit.daughtersToConstrain += [ "J/psi(1S)", bhh ] # constrain B as well ConstBFit.UpdateDaughters = True # Maurizio's daughters for d in [ 'KS0', 'pi0', 'Lambda0' ]: if d in decay: FullFit.daughtersToConstrain += [ d ] if ( "ConstBFit" in verbose ): ConstBFit.daughtersToConstrain += [ d ] if (not resonant): NoPsiFit = B.addTupleTool("TupleToolDecayTreeFitter/NoPsiFit") NoPsiFit.Verbose = True NoPsiFit.constrainToOriginVertex = True if (not resonant): #b constraint for calculating qsq ConstBNoPsiFit = B.addTupleTool("TupleToolDecayTreeFitter/ConstBNoPsiFit") ConstBNoPsiFit.Verbose = True ConstBNoPsiFit.constrainToOriginVertex = True ConstBNoPsiFit.daughtersToConstrain += [ bhh ] # constrain B as well ConstBNoPsiFit.UpdateDaughters = True # Maurizio's daughters #if (resonant and ('KS0' in decay or "pi0" in decay or 'Lambda0' in decay)): # OnlyPsiFit = B.addTupleTool("TupleToolDecayTreeFitter/OnlyPsiFit") # OnlyPsiFit.Verbose = True # OnlyPsiFit.constrainToOriginVertex = True # OnlyPsiFit.daughtersToConstrain += [ "J/psi(1S)" ] if ('phi' in decay): substitute1 = { 'Beauty -> Meson (Strange -> ^K+ K-)': 'pi+' } from Configurables import TupleToolDecayTreeFitter subDTF = TupleToolDecayTreeFitter("SubPipKm", Verbose=False, daughtersToConstrain = [ "J/psi(1S)" ], constrainToOriginVertex=True, Substitutions=substitute1) B.addTool(subDTF) B.ToolList += [ "TupleToolDecayTreeFitter/SubPipKm" ] B.addTool(subDTF) substitute2 = { 'Beauty -> Meson (Strange -> K+ ^K-)': 'pi-' } B.addTool(subDTF.clone("SubKpPim",Substitutions=substitute2)) B.ToolList += [ "TupleToolDecayTreeFitter/SubKpPim" ] if ( Lambdab2Jpsippi==decay ): substitute1 = { 'Beauty -> Meson p+ ^pi-': 'K-', 'Beauty -> Meson p~- ^pi+': 'K+' } from Configurables import TupleToolDecayTreeFitter B.addTupleTool(TupleToolDecayTreeFitter("SubpK", Verbose=False, daughtersToConstrain = [ "J/psi(1S)" ], constrainToOriginVertex=True, Substitutions=substitute1)) substitute2 = { 'Beauty -> Meson ^p+ pi-': 'K+', 'Beauty -> Meson ^p~- pi+': 'K-' } B.addTupleTool(TupleToolDecayTreeFitter("SubKpi", Verbose=False, daughtersToConstrain = [ "J/psi(1S)" ], constrainToOriginVertex=True, Substitutions=substitute2)) if ("ConstBFit" in verbose): ConstBSubFit = B.addTupleTool("TupleToolDecayTreeFitter/ConstBSubFit") ConstBSubFit.Substitutions=substitute1 # substitute and then constrain ConstBSubFit.Verbose = True ConstBSubFit.constrainToOriginVertex = True ConstBSubFit.daughtersToConstrain += [ "J/psi(1S)", bhh ] # constrain B as well ConstBSubFit.UpdateDaughters = True # Maurizio's daughters if ( Bd2JpsiKS0==decay ): substitute1 = { 'Beauty -> Meson (Strange -> ^pi+ pi-)' : 'K+' } substitute2 = { 'Beauty -> Meson (Strange -> pi+ ^pi-)' : 'K-' } from Configurables import TupleToolDecayTreeFitter B.addTupleTool(TupleToolDecayTreeFitter("PsiKppim", Verbose=False, daughtersToConstrain = [ "J/psi(1S)" ], constrainToOriginVertex=True, Substitutions=substitute1)) B.addTupleTool(TupleToolDecayTreeFitter("PsiKmpip", Verbose=False, daughtersToConstrain = [ "J/psi(1S)" ], constrainToOriginVertex=True, Substitutions=substitute2)) if ( Bu2JpsiK == decay): substitute2 = { 'Beauty -> Meson ^K+': 'pi+', 'Beauty -> Meson ^K-': 'pi-' } subDTF2 = B.addTupleTool(TupleToolDecayTreeFitter("Subpi", Verbose=False, daughtersToConstrain = [ "J/psi(1S)" ], constrainToOriginVertex=True, Substitutions=substitute2)) if ( Bu2eeK == decay or Bu2MuMuK == decay or Bu2MueK == decay or Bu2eMuK == decay): if Bu2eeK == decay : substitute1 = { "Beauty -> ( J/psi(1S) -> ^e+ X- ) Strange " : "pi+" , "Beauty -> ( J/psi(1S) -> ^e- X+ ) Strange " : "pi-" } elif Bu2MuMuK == decay : substitute1 = { "Beauty -> ( J/psi(1S) -> ^mu+ X- ) Strange " : "pi+" , "Beauty -> ( J/psi(1S) -> ^mu- X+ ) Strange " : "pi-" } elif Bu2MueK == decay : substitute1 = { "Beauty -> ( J/psi(1S) -> ^e+ X- ) Strange " : "pi+" , "Beauty -> ( J/psi(1S) -> ^mu- X+ ) Strange " : "pi-" } elif Bu2eMuK == decay : substitute1 = { "Beauty -> ( J/psi(1S) -> ^mu+ X- ) Strange " : "pi+" , "Beauty -> ( J/psi(1S) -> ^e- X+ ) Strange " : "pi-" } from Configurables import TupleToolDecayTreeFitter subDTF = B.addTupleTool(TupleToolDecayTreeFitter("Subpipi", Verbose=False, constrainToOriginVertex=True, Substitutions=substitute1, UpdateDaughters = True)) # Maurizio's daughters """ if (('KS0' in decay) or ("K*(892)" in decay) or ("Lambda0" in decay)): mh = tuple.addTupleTool("TupleToolMassHypo") if ("KS0" in decay): mh.PIDReplacements = { "pi+" : "p+" } #if ("K*(892)" in decay): # mh.PIDReplacements = { "pi-" : "K+" } if ("Lambda0" in decay): mh.PIDReplacements = { "p+" : "pi+" } """ B.addTool(tistos) B.ToolList += [ "TupleToolTISTOS" ] rs = tuple.addTupleTool("TupleToolRecoStats") rs.Verbose = ("RecoStats" in verbose) ei = tuple.addTupleTool("TupleToolEventInfo") ei.Verbose = ("EventInfo" in verbose) # gives GpsYear, month, day, etc ki = tuple.addTupleTool("TupleToolKinematic") # gives _AtVtx_P ki.Verbose= ("Kinematic" in verbose) tuple.addTupleTool("TupleToolPrimaries") ti = tuple.addTupleTool("TupleToolTrackInfo") ti.Verbose = ("TrackInfo" in verbose) # gives many more chi2 if ( "TrackPosition" in verbose): # extrapolates to TT, IT tp1 = tuple.addTupleTool("TupleToolTrackPosition/TupleToolTrackPositionTT") tp2 = tuple.addTupleTool("TupleToolTrackPosition/TupleToolTrackPositionIT") tp1.ExtraName = "TT" tp2.ExtraName = "IT" tp2.Z = 7800 pid = tuple.addTupleTool("TupleToolPid") pid.Verbose = ("Pid" in verbose) # many more vars in RICH if ("Pid" in verbose) : tuple.addTupleTool("TupleToolANNPID") tuple.addTupleTool("TupleToolL0Calo") if ('e+' in decay): brem = tuple.addTupleTool("TupleToolBremInfo") #isolation if "iso" in verbose : # lines from Greg Ciezarek from configIso import configIso configIso() # this is work in progress #will be comitted to SVN properly at a future date as of 3/4/14 from Configurables import TupleToolApplyIsolation tuple.B.addTool(TupleToolApplyIsolation, name="TupleToolApplyIsolationHard") tuple.B.TupleToolApplyIsolationHard.OutputSuffix="_Hard" tuple.B.TupleToolApplyIsolationHard.WeightsFile="weightsHard.xml" tuple.B.ToolList+=["TupleToolApplyIsolation/TupleToolApplyIsolationHard"] tuple.B.addTool(TupleToolApplyIsolation, name="TupleToolApplyIsolationSoft") tuple.B.TupleToolApplyIsolationSoft.OutputSuffix="_Soft" tuple.B.TupleToolApplyIsolationSoft.WeightsFile="weightsSoft.xml" tuple.B.ToolList+=["TupleToolApplyIsolation/TupleToolApplyIsolationSoft"] vtxiso = tuple.B.addTupleTool("TupleToolVtxIsoln") tuple.B.TupleToolApplyIsolationHard.OutputLevel = 3 tuple.B.TupleToolApplyIsolationSoft.OutputLevel = 3 tuple.addTupleTool("TupleToolPropertime") if ( "/Event/Phys/" == head): # not reading stripping output tts = tuple.addTupleTool("TupleToolStripping") tuple.addTupleTool("TupleToolPhotonInfo") tuple.addTupleTool("TupleToolPi0Info") # tuple.OutputLevel = 1 if ( addendum == "MC" ): # it's MC! tmc = tuple.addTupleTool("TupleToolMCTruth") #tmc.addTupleTool("MCTupleToolKinematic") tmc.addTupleTool("MCTupleToolHierarchy") tuple.addTupleTool("TupleToolMCBackgroundInfo") if (isMDST): seq.Members += [ #PrintDecayTree( Inputs = [ location]), EventNodeKiller(Nodes=["DAQ"] ) ] if ( addendum == "MC" ): # it's not MC! from Configurables import TrackSmearState as SMEAR smear = SMEAR() # seq.Members += [ smear ] elif (not isMDST): # it's not mdst from Configurables import TrackScaleState as SCALER scaler = SCALER('StateScale') # seq.Members += [ scaler ] seq.Members += [ # PrintDecayTree( Inputs = [ location]), tuple ] return [ seq ]
from Gaudi.Configuration import * # # DecayTreeTuple # from Configurables import DecayTreeTuple, LoKi__Hybrid__TupleTool, TupleToolDecay, TupleToolTrigger, TupleToolTISTOS, TupleToolTagging from Configurables import FitDecayTrees, TupleToolGeometry tuple = DecayTreeTuple('Lb2JpsiLTree') tuple.Inputs = [ 'Phys/Bs2Jpsif0' ] tuple.TupleName = "mytree" tuple.ToolList = [ "TupleToolGeometry", "TupleToolKinematic", "TupleToolEventInfo", # "TupleToolTISTOS", "TupleToolPid", "TupleToolTrackInfo", # "TupleToolTagging" ] tistos = TupleToolTISTOS("tistos") tistos.VerboseL0 = 1 tistos.VerboseHlt1 = 1 tistos.VerboseHlt2 = 1 tistos.TriggerList = [ 'L0DiMuonDecision', 'L0HCALDecision', 'L0MuonDecision', 'L0MuonHighDecision', 'Hlt1SingleMuonNoIPL0Decision', 'Hlt1DiMuonHighMassDecision',
sc = StrippingConf( Streams = [ AllStreams ], MaxCandidates = 2000 ) tuple = DecayTreeTuple("Jpsi_Tuple") tuple.Inputs = ["Phys/B2XMuMu_InclDiMuHighQ2Line/Particles/"] tuple.ToolList = [ "TupleToolKinematic" , "TupleToolEventInfo" , "TupleToolRecoStats" , "TupleToolMCTruth" , "TupleToolMCBackgroundInfo" # , "TupleBuKmmFit" ] tuple.addBranches ({ "muplus" : "B0 -> ^mu+ mu-", "muminus" : "B0 -> mu+ ^mu-", "Dimuon" : "B0 : B0 -> mu+ mu-", }) LoKi_All=tuple.addTupleTool("LoKi::Hybrid::TupleTool/LoKi_All") LoKi_All.Variables = { 'MINIPCHI2' : "MIPCHI2DV(PRIMARY)", 'MINIP' : "MIPDV(PRIMARY)", 'IPCHI2_OWNPV' : "BPVIPCHI2()",
_B.DecayDescriptors = [ "[B+ -> J/psi(1S) K+]cc" ] _BdecaySelection = Selection( "TurboB", Algorithm = _B, RequiredSelections = [subsel,kaons] ) SeqB = SelectionSequence('SeqB', TopSelection = _BdecaySelection) # Here we just put the output candidates in an Tuple tupleB = DecayTreeTuple("Bplus_Tuple") tupleB.Inputs = [SeqB.outputLocation()] tupleB.Decay = "[B+ -> ^K+ ^(J/psi(1S) -> ^mu+ ^mu-)]CC" tupleB.ToolList = [ "TupleToolKinematic" , "TupleToolEventInfo" , "TupleToolRecoStats" # , "TupleBuKmmFit" ] # Probably need to add many more Tools. tupleB.addBranches ({ "Kplus" : "[B+ -> ^K+ (J/psi(1S) -> mu+ mu-)]CC", "Jpsi" : "[B+ -> K+ ^(J/psi(1S) -> mu+ mu-)]CC", "muplus" : "[B+ -> K+ (J/psi(1S) -> ^mu+ mu-)]CC", "muminus" : "[B+ -> K+ (J/psi(1S) -> mu+ ^mu-)]CC", "Bplus" : "[B+ -> K+ J/psi(1S)]CC", }) LoKi_All=tupleB.addTupleTool("LoKi::Hybrid::TupleTool/LoKi_All")
def execute(stripRun, stripConf, stripLine, dataType, hltReport, tupleDecay, evtMax, mag, outputType="ntuple", strippingStream = "Charm"): #0 "pi" "pi" #1 "mu" "mu" #2 "K" "pi" #3 "e" "mu" #4 "K" "mu" stripLines = { "kkpi":0, "kpipi":1, "pipipi":2, "kpipios":3, "kkk":4, "kkpios":5, "hhh":6, } lineNumber = stripLines[stripLine] # Now build the stream from StrippingConf.StrippingStream import StrippingStream ss = StrippingStream("ByTom") from StrippingSelections import StrippingD2hhh_conf line = False if stripConf == "default" or stripConf == "def": from StrippingArchive import Utils D2HHHConf, default_config = Utils.lineBuilderAndConf("stripping20","D2hhh") def_str_no_pre = default_config for key, val in def_str_no_pre.iteritems(): if "Prescale" in key: def_str_no_pre[key] = 1.0 D2HHHConf = StrippingD2hhh_conf.D2hhhConf('D2hhh',def_str_no_pre) D2hhhLines = D2HHHConf.lines() for line in D2hhhLines : print line.name(), line.outputLocation() ss.appendLines( [D2hhhLines[lineNumber]] ) stripOutputLoc = D2hhhLines[lineNumber].outputLocation() else: raise ValueError("Unknown value of stripConf: %s"%stripConf) from StrippingConf.Configuration import StrippingConf conf = StrippingConf( Streams = [ ss ] ) from Configurables import StrippingReport sr = StrippingReport(Selections = conf.selections()) MessageSvc().Format = "% F%60W%S%7W%R%T %0W%M" from Configurables import DaVinci from Configurables import LoKi__HDRFilter as StripFilter strfilter = StripFilter( 'StripPassFilter', Code="HLT_PASS('"+D2hhhLines[lineNumber].name()+"Decision')", Location="/Event/Strip/Phys/DecReports" ) #strfilter = StripFilter( 'StripPassFilter', Code="HLT_PASS('StrippingD2hhh_PPPLineDecision')", Location="/Event/Strip/Phys/DecReports" ) DaVinci().EventPreFilters += [strfilter] DaVinci().PrintFreq = 500 DaVinci().HistogramFile = 'DV_histos.root' DaVinci().TupleFile = "DPiPiPi_NTuple.root" DaVinci().EvtMax = evtMax storeExp = StoreExplorerAlg() storeExp.Load = 1 storeExp.PrintFreq = 10.0 #DaVinci().appendToMainSequence( [ storeExp ] ) if stripRun: #from Configurables import bankKiller #bk = bankKiller( "KillHltBanks", BankTypes = [ "Evt/Strip/Phys/DecReports", "Evt/AllStreams" ] ) #DaVinci().appendToMainSequence( [ bk ] ) from Configurables import EventNodeKiller enk = EventNodeKiller() enk.Nodes=[ "Event/Strip/Phys/DecReports", "Event/AllStreams"] DaVinci().appendToMainSequence( [ enk ] ) #DaVinci().appendToMainSequence( [ storeExp ] ) DaVinci().appendToMainSequence( [ conf.sequence() ] ) DaVinci().appendToMainSequence( [ sr ] ) if hltReport: from Configurables import ReadHltReport DaVinci().appendToMainSequence( [ ReadHltReport() ] ) DaVinci().InputType = 'MDST' DaVinci().RootInTES = "/Event/Charm" a = "->" if dataType == "MC10": DaVinci().DataType = "2010" DaVinci().Simulation = True DaVinci().DDDBtag = "head-20101206" if mag == "up": DaVinci().CondDBtag = "sim-20101210-vc-mu100" elif mag == "down": DaVinci().CondDBtag = "sim-20101210-vc-md100" DaVinci().Lumi = False elif dataType == "MC11": DaVinci().DataType = "2011" DaVinci().Simulation = True DaVinci().DDDBtag = "MC11-20111102" if mag == "up": DaVinci().CondDBtag = "sim-20111111-vc-mu100" elif mag == "down": DaVinci().CondDBtag = "sim-20111111-vc-md100" DaVinci().Lumi = False elif dataType == "MC11a": DaVinci().DataType = "2011" DaVinci().Simulation = True DaVinci().DDDBtag = "MC11-20111102" if mag == "up": DaVinci().CondDBtag = "sim-20111111-vc-mu100" elif mag == "down": DaVinci().CondDBtag = "sim-20111111-vc-md100" DaVinci().Lumi = False elif dataType == "MC2012": DaVinci().DataType = "2012" DaVinci().Simulation = True DaVinci().DDDBtag = "Sim08-20130503-1" if mag == "up": DaVinci().CondDBtag = "Sim08-20130503-1-vc-mu100" elif mag == "down": DaVinci().CondDBtag = "Sim08-20130503-1-vc-md100" DaVinci().Lumi = False elif dataType == "MC2011": DaVinci().DataType = "2011" DaVinci().Simulation = True DaVinci().DDDBtag = "Sim08-20130503" if mag == "up": DaVinci().CondDBtag = "Sim08-20130503-vc-mu100" elif mag == "down": DaVinci().CondDBtag = "Sim08-20130503-vc-md100" DaVinci().Lumi = False elif dataType == "data2012": a = "->" DaVinci().DataType = "2012" DaVinci().Simulation = False #DaVinci().DDDBtag = "dddb-20130111" #if mag == "up": #DaVinci().CondDBtag = "cond-20130114" #elif mag == "down": #DaVinci().CondDBtag = "cond-20130114" DaVinci().Lumi = True elif dataType == "data2011": a = "->" DaVinci().DataType = "2011" DaVinci().Simulation = False #DaVinci().DDDBtag = "dddb-20130111" #if mag == "up": #DaVinci().CondDBtag = "cond-20130114" #elif mag == "down": #DaVinci().CondDBtag = "cond-20130114" DaVinci().Lumi = True elif dataType == "data": sys.exit("correct the dataType to include the year") from Configurables import DecayTreeTuple from Configurables import TupleToolTISTOS from Configurables import TupleToolMassHypo, TupleToolSubMass if outputType in ["ntuple", "nt", "tuple", "root"]: print "stripOutputLoc:",stripOutputLoc dttuple = DecayTreeTuple( "DPiPiPi_NTuple" ) dttuple.ToolList = ["TupleToolGeometry", "TupleToolEventInfo", "TupleToolKinematic", #"TupleToolPrimaries", "TupleToolPropertime", "TupleToolAngles", "TupleToolPid", #"TupleToolRICHPid", "TupleToolDecay", #"TupleToolTrigger", #"TupleToolTrackPosition", #"TupleToolTrackInfo", #"TupleToolRecoStats", "TupleToolDira", "TupleToolDalitz", "TupleToolSubMass", ] dttuple.Inputs = [ stripOutputLoc ] print "tuple input :",dttuple.Inputs print "number of events:", DaVinci().EvtMax #[D+ -> pi- pi+ pi+]CC if tupleDecay == "pipipi": dttuple.Decay = "[D+ "+a+" ^pi- ^pi+ ^pi+]CC" dttuple.addBranches ({ "D": "[D+ "+a+" pi- pi+ pi+]CC", "x1": "[D+ "+a+" ^pi- pi+ pi+]CC", "x2": "[D+ "+a+" pi- ^pi+ pi+]CC", "x3": "[D+ "+a+" pi- pi+ ^pi+]CC", }) elif tupleDecay == "kpipios": dttuple.Decay = "[D+ "+a+" ^pi- ^pi+ ^K+]CC" dttuple.addBranches ({ "D": "[D+ "+a+" pi- pi+ K+]CC", "x1": "[D+ "+a+" ^pi- pi+ K+]CC", "x2": "[D+ "+a+" pi- ^pi+ K+]CC", "x3": "[D+ "+a+" pi- pi+ ^K+]CC", }) elif tupleDecay == "ds2phipi": dttuple.Decay = "[D+ "+a+" ^mu+ ^mu- ^pi+]CC" dttuple.addBranches ({ "D": "[D+ "+a+" mu+ mu- pi+]CC", "x1": "[D+ "+a+" ^mu+ mu- pi+]CC", "x2": "[D+ "+a+" mu+ ^mu- pi+]CC", "x3": "[D+ "+a+" mu+ mu- ^pi+]CC", }) #if tupleDecay == "eta": #dttuple.Decay = "[(D+ "+a+" ^(eta "+a+" ^pi+ ^pi-) ^pi+),(D- "+a+" ^(eta "+a+" ^pi+ ^pi-) ^pi-)]" #dttuple.addBranches ({ #"D": "[(D+ "+a+" (eta "+a+" pi+ pi-) pi+),(D- "+a+" (eta "+a+" pi+ pi-) pi-)]", #"eta": "[(D+ "+a+" ^(eta "+a+" ^pi+ ^pi-) ^pi+),(D- "+a+" ^(eta "+a+" ^pi+ ^pi-) ^pi-)]", #"pip": "[(D+ "+a+" (eta "+a+" ^pi+ pi-) pi+),(D- "+a+" (eta "+a+" ^pi+ pi-) pi-)]", #"pim": "[(D+ "+a+" (eta "+a+" pi+ ^pi-) pi+),(D- "+a+" (eta "+a+" pi+ ^pi-) pi-)]", #"pi": "[(D+ "+a+" (eta "+a+" pi+ pi-) ^pi+),(D- "+a+" (eta "+a+" pi+ pi-) ^pi-)]", #}) dttuple.TupleName = "DPiPiPi_NTuple" ttmhk = TupleToolMassHypo("KaonHypo") ttmhk.PIDReplacements = { "pi+" : "K+"} #ttmhk.CC = True dttuple.D.addTool(ttmhk) dttuple.D.ToolList += ["TupleToolMassHypo/KaonHypo"] ttmhm = TupleToolMassHypo("MuonHypo") ttmhm.PIDReplacements = { "pi+" : "mu+"} #ttmhm.CC = True dttuple.D.addTool(ttmhm) dttuple.D.ToolList += ["TupleToolMassHypo/MuonHypo"] dttuple.addTool(TupleToolTISTOS()) dttuple.TupleToolTISTOS.VerboseL0 = True dttuple.TupleToolTISTOS.VerboseHlt1 = True dttuple.TupleToolTISTOS.VerboseHlt2 = True dttuple.TupleToolTISTOS.Verbose = True dttuple.ToolList += ["TupleToolTISTOS"] dttuple.TupleToolTISTOS.TriggerList = [ "L0CALODecision", "L0ElectronDecision", "L0PhotonDecision", "L0HadronDecision", "L0MuonDecision", "Hlt1TrackMuonDecision", "Hlt1TrackAllL0Decision", "Hlt2Topo2BodyBBDTDecision", "Hlt2Topo3BodyBBDTDecision", "Hlt2Topo4BodyBBDTDecision", 'Hlt2CharmHadD2HHHDecision', ] #+ [ trigger_name+"Decision" for trigger_name in # ["L0CALO","L0ElectronNoSPD","L0PhotonNoSPD","L0HadronNoSPD","L0MuonNoSPD","L0DiMuonNoSPD","L0Electron","L0ElectronHi","L0Photon","L0PhotonHi","L0Hadron","L0Muon","L0DiMuon","L0HighSumETJet","L0B1gas","L0B2gas",]\ # + ["Hlt1MBMicroBiasVelo","Hlt1Global","Hlt1DiMuonHighMass","Hlt1DiMuonLowMass","Hlt1SingleMuonNoIP","Hlt1SingleMuonHighPT","Hlt1TrackAllL0","Hlt1TrackMuon","Hlt1TrackPhoton","Hlt1Lumi","Hlt1LumiMidBeamCrossing","Hlt1MBNoBias","Hlt1MBMicroBiasVeloRateLimited","Hlt1MBMicroBiasTStation","Hlt1MBMicroBiasTStationRateLimited","Hlt1L0Any","Hlt1L0AnyRateLimited","Hlt1L0AnyNoSPD","Hlt1L0AnyNoSPDRateLimited","Hlt1NoPVPassThrough","Hlt1DiProton","Hlt1DiProtonLowMult","Hlt1BeamGasNoBeamBeam1","Hlt1BeamGasNoBeamBeam2","Hlt1BeamGasBeam1","Hlt1BeamGasBeam2","Hlt1BeamGasCrossingEnhancedBeam1","Hlt1BeamGasCrossingEnhancedBeam2","Hlt1BeamGasCrossingForcedReco","Hlt1ODINTechnical","Hlt1Tell1Error","Hlt1VeloClosingMicroBias","Hlt1BeamGasCrossingParasitic","Hlt1ErrorEvent","Hlt1SingleElectronNoIP","Hlt1TrackForwardPassThrough","Hlt1TrackForwardPassThroughLoose","Hlt1CharmCalibrationNoBias","Hlt1L0HighSumETJet","Hlt1BeamGasCrossingForcedRecoFullZ","Hlt1BeamGasHighRhoVertices","Hlt1VertexDisplVertex","Hlt1TrackAllL0Tight","Hlt1HighPtJetsSinglePV","Hlt1L0PU","Hlt1L0CALO",]\ # + ["Hlt2SingleElectronTFLowPt","Hlt2SingleElectronTFHighPt","Hlt2DiElectronHighMass","Hlt2DiElectronB","Hlt2B2HHLTUnbiased","Hlt2Topo2BodySimple","Hlt2Topo3BodySimple","Hlt2Topo4BodySimple","Hlt2Topo2BodyBBDT","Hlt2Topo3BodyBBDT","Hlt2Topo4BodyBBDT","Hlt2TopoMu2BodyBBDT","Hlt2TopoMu3BodyBBDT","Hlt2TopoMu4BodyBBDT","Hlt2TopoE2BodyBBDT","Hlt2TopoE3BodyBBDT","Hlt2TopoE4BodyBBDT","Hlt2IncPhi","Hlt2IncPhiSidebands","Hlt2CharmHadD02HHKsLL","Hlt2Dst2PiD02PiPi","Hlt2Dst2PiD02MuMu","Hlt2Dst2PiD02KMu","Hlt2Dst2PiD02KPi","Hlt2PassThrough","Hlt2Transparent","Hlt2Forward","Hlt2DebugEvent","Hlt2CharmHadD02HH_D02PiPi","Hlt2CharmHadD02HH_D02PiPiWideMass","Hlt2CharmHadD02HH_D02KK","Hlt2CharmHadD02HH_D02KKWideMass","Hlt2CharmHadD02HH_D02KPi","Hlt2CharmHadD02HH_D02KPiWideMass","Hlt2ExpressJPsi","Hlt2ExpressJPsiTagProbe","Hlt2ExpressLambda","Hlt2ExpressKS","Hlt2ExpressDs2PhiPi","Hlt2ExpressBeamHalo","Hlt2ExpressDStar2D0Pi","Hlt2ExpressHLT1Physics","Hlt2Bs2PhiGamma","Hlt2Bs2PhiGammaWideBMass","Hlt2Bd2KstGamma","Hlt2Bd2KstGammaWideKMass","Hlt2Bd2KstGammaWideBMass","Hlt2CharmHadD2KS0H_D2KS0Pi","Hlt2CharmHadD2KS0H_D2KS0K","Hlt2CharmRareDecayD02MuMu","Hlt2B2HH","Hlt2MuonFromHLT1","Hlt2SingleMuon","Hlt2SingleMuonHighPT","Hlt2SingleMuonLowPT","Hlt2DiProton","Hlt2DiProtonTF","Hlt2DiProtonLowMult","Hlt2DiProtonLowMultTF","Hlt2CharmSemilepD02HMuNu_D02KMuNuWS","Hlt2CharmSemilepD02HMuNu_D02PiMuNuWS","Hlt2CharmSemilepD02HMuNu_D02KMuNu","Hlt2CharmSemilepD02HMuNu_D02PiMuNu","Hlt2TFBc2JpsiMuX","Hlt2TFBc2JpsiMuXSignal","Hlt2DisplVerticesLowMassSingle","Hlt2DisplVerticesHighMassSingle","Hlt2DisplVerticesDouble","Hlt2DisplVerticesSinglePostScaled","Hlt2DisplVerticesHighFDSingle","Hlt2DisplVerticesSingleDown","Hlt2CharmSemilepD2HMuMu","Hlt2CharmSemilepD2HMuMuWideMass","Hlt2B2HHPi0_Merged","Hlt2CharmHadD2HHH","Hlt2CharmHadD2HHHWideMass","Hlt2DiMuon","Hlt2DiMuonLowMass","Hlt2DiMuonJPsi","Hlt2DiMuonJPsiHighPT","Hlt2DiMuonPsi2S","Hlt2DiMuonB","Hlt2DiMuonZ","Hlt2DiMuonDY1","Hlt2DiMuonDY2","Hlt2DiMuonDY3","Hlt2DiMuonDY4","Hlt2DiMuonDetached","Hlt2DiMuonDetachedHeavy","Hlt2DiMuonDetachedJPsi","Hlt2DiMuonNoPV","Hlt2TriMuonDetached","Hlt2TriMuonTau","Hlt2CharmSemilepD02HHMuMu","Hlt2CharmSemilepD02HHMuMuWideMass","Hlt2CharmHadD02HHHH","Hlt2CharmHadD02HHHHWideMass","Hlt2ErrorEvent","Hlt2Global","Hlt2diPhotonDiMuon","Hlt2LowMultMuon","Hlt2LowMultHadron","Hlt2LowMultPhoton","Hlt2LowMultElectron","Hlt2SingleTFElectron","Hlt2SingleTFVHighPtElectron","Hlt2B2HHLTUnbiasedDetached","Hlt2CharmHadLambdaC2KPPi","Hlt2SingleMuonVHighPT","Hlt2CharmSemilepD02HMuNu_D02KMuNuTight","Hlt2CharmHadMinBiasLambdaC2KPPi","Hlt2CharmHadMinBiasD02KPi","Hlt2CharmHadMinBiasD02KK","Hlt2CharmHadMinBiasDplus2hhh","Hlt2CharmHadMinBiasLambdaC2LambdaPi","Hlt2DisplVerticesSingle","Hlt2DisplVerticesDoublePostScaled","Hlt2DisplVerticesSingleHighMassPostScaled","Hlt2DisplVerticesSingleHighFDPostScaled","Hlt2DisplVerticesSingleMVPostScaled","Hlt2RadiativeTopoTrackTOS","Hlt2RadiativeTopoPhotonL0","Hlt2DiMuonPsi2SHighPT","Hlt2DoubleDiMuon","Hlt2DiMuonAndMuon","Hlt2DiMuonAndGamma","Hlt2DiMuonAndD0","Hlt2DiMuonAndDp","Hlt2DiMuonAndDs","Hlt2DiMuonAndLc","Hlt2CharmSemilepD02HHMuMuHardHadronsSoftMuons","Hlt2CharmSemilepD02HHMuMuHardHadronsSoftMuonsWideMass","Hlt2CharmSemilepD02HHMuMuHardHadronsAndMuons","Hlt2CharmSemilepD02HHMuMuHardHadronsAndMuonsWideMass","Hlt2TopoRad2BodyBBDT","Hlt2TopoRad2plus1BodyBBDT","Hlt2Lumi","Hlt2LowMultHadron_nofilter","Hlt2LowMultElectron_nofilter","Hlt2CharmHadD02HHKsDD","Hlt2CharmHadD2KS0KS0","Hlt2CharmHadD2KS0KS0WideMass","Hlt2ExpressD02KPi","Hlt2CharmHadLambdaC2KPPiWideMass","Hlt2CharmHadLambdaC2KPK","Hlt2CharmHadLambdaC2KPKWideMass","Hlt2CharmHadLambdaC2PiPPi","Hlt2CharmHadLambdaC2PiPPiWideMass","Hlt2CharmHadLambdaC2PiPK","Hlt2CharmHadLambdaC2PiPKWideMass","Hlt2CharmHadD2KS0H_D2KS0DDPi","Hlt2CharmHadD2KS0H_D2KS0DDK","Hlt2DiPhi","Hlt2CharmHadD02HHHHDstNoHltOne_4pi","Hlt2CharmHadD02HHHHDstNoHltOne_4piWideMass","Hlt2CharmHadD02HHHHDstNoHltOne_K3pi","Hlt2CharmHadD02HHHHDstNoHltOne_K3piWideMass","Hlt2CharmHadD02HHHHDstNoHltOne_KKpipi","Hlt2CharmHadD02HHHHDstNoHltOne_KKpipiWideMass","Hlt2CharmHadD02HHHHDstNoHltOne_2K2pi","Hlt2CharmHadD02HHHHDstNoHltOne_2K2piWideMass","Hlt2CharmHadD02HHHHDstNoHltOne_3Kpi","Hlt2CharmHadD02HHHHDstNoHltOne_3KpiWideMass","Hlt2CharmHadD02HHHHDstNoHltOne_Ch2","Hlt2CharmHadD02HHHHDstNoHltOne_Ch2WideMass","Hlt2CharmSemilep3bodyD2PiMuMu","Hlt2CharmSemilep3bodyD2PiMuMuSS","Hlt2CharmSemilep3bodyD2KMuMu","Hlt2CharmSemilep3bodyD2KMuMuSS","Hlt2CharmSemilep3bodyLambdac2PMuMu","Hlt2CharmSemilep3bodyLambdac2PMuMuSS","Hlt2LambdaC_LambdaC2Lambda0LLPi","Hlt2LambdaC_LambdaC2Lambda0LLK","Hlt2LambdaC_LambdaC2Lambda0DDPi","Hlt2LambdaC_LambdaC2Lambda0DDK","Hlt2RadiativeTopoTrack","Hlt2RadiativeTopoPhoton","Hlt2CharmHadD02HHHHDst_4pi","Hlt2CharmHadD02HHHHDst_4piWideMass","Hlt2CharmHadD02HHHHDst_K3pi","Hlt2CharmHadD02HHHHDst_K3piWideMass","Hlt2CharmHadD02HHHHDst_KKpipi","Hlt2CharmHadD02HHHHDst_KKpipiWideMass","Hlt2CharmHadD02HHHHDst_2K2pi","Hlt2CharmHadD02HHHHDst_2K2piWideMass","Hlt2CharmHadD02HHHHDst_3Kpi","Hlt2CharmHadD02HHHHDst_3KpiWideMass","Hlt2CharmHadD02HHHHDst_Ch2","Hlt2CharmHadD02HHHHDst_Ch2WideMass","Hlt2CharmSemilepD02PiPiMuMu","Hlt2CharmSemilepD02KKMuMu","Hlt2CharmSemilepD02KPiMuMu","Hlt2CharmHadD02HHHH_4pi","Hlt2CharmHadD02HHHH_4piWideMass","Hlt2CharmHadD02HHHH_K3pi","Hlt2CharmHadD02HHHH_K3piWideMass","Hlt2CharmHadD02HHHH_KKpipi","Hlt2CharmHadD02HHHH_KKpipiWideMass","Hlt2CharmHadD02HHHH_2K2pi","Hlt2CharmHadD02HHHH_2K2piWideMass","Hlt2CharmHadD02HHHH_3Kpi","Hlt2CharmHadD02HHHH_3KpiWideMass","Hlt2CharmHadD02HHHH_Ch2","Hlt2CharmHadD02HHHH_Ch2WideMass","Hlt2DiMuonDetachedPsi2S","Hlt2CharmHadD02HHXDst_hhX","Hlt2CharmHadD02HHXDst_hhXWideMass","Hlt2LowMultD2KPi","Hlt2LowMultD2KPiPi","Hlt2LowMultD2K3Pi","Hlt2LowMultChiC2HH","Hlt2LowMultChiC2HHHH","Hlt2LowMultD2KPiWS","Hlt2LowMultD2KPiPiWS","Hlt2LowMultD2K3PiWS","Hlt2LowMultChiC2HHWS","Hlt2LowMultChiC2HHHHWS","Hlt2LowMultDDInc","Hlt2DisplVerticesSingleLoosePS","Hlt2DisplVerticesSingleHighFD","Hlt2DisplVerticesSingleVeryHighFD","Hlt2DisplVerticesSingleHighMass","Hlt2DisplVerticesSinglePS","Hlt2DisplVerticesDoublePS","Hlt2CharmHadD2HHHKsLL","Hlt2CharmHadD2HHHKsDD","Hlt2KshortToMuMuPiPi","Hlt2LowMultChiC2PP","Hlt2LowMultDDIncCP","Hlt2LowMultDDIncVF","Hlt2LowMultLMR2HH","Hlt2HighPtJets","Hlt2ChargedHyperon_Xi2Lambda0LLPi","Hlt2ChargedHyperon_Xi2Lambda0LLMu","Hlt2ChargedHyperon_Omega2Lambda0LLK","Hlt2ChargedHyperon_Xi2Lambda0DDPi","Hlt2ChargedHyperon_Xi2Lambda0DDMu","Hlt2ChargedHyperon_Omega2Lambda0DDK","Hlt2CharmHadD02HHXDst_BaryonhhX","Hlt2CharmHadD02HHXDst_BaryonhhXWideMass","Hlt2CharmHadD02HHXDst_BaryonhhXWithKSLL","Hlt2CharmHadD02HHXDst_BaryonhhXWithKSLLWideMass","Hlt2CharmHadD02HHXDst_BaryonhhXWithLambda0LL","Hlt2CharmHadD02HHXDst_BaryonhhXWithLambda0LLWideMass","Hlt2CharmHadD02HHXDst_BaryonhhXWithKSDD","Hlt2CharmHadD02HHXDst_BaryonhhXWithKSDDWideMass","Hlt2CharmHadD02HHXDst_BaryonhhXWithLambda0DD","Hlt2CharmHadD02HHXDst_BaryonhhXWithLambda0DDWideMass","Hlt2CharmHadD02HHXDst_LeptonhhX","Hlt2CharmHadD02HHXDst_LeptonhhXWideMass","Hlt2CharmHadD02HHXDst_LeptonhhXWithKSLL","Hlt2CharmHadD02HHXDst_LeptonhhXWithKSLLWideMass","Hlt2CharmHadD02HHXDst_LeptonhhXWithLambda0LL","Hlt2CharmHadD02HHXDst_LeptonhhXWithLambda0LLWideMass","Hlt2CharmHadD02HHXDst_LeptonhhXWithKSDD","Hlt2CharmHadD02HHXDst_LeptonhhXWithKSDDWideMass","Hlt2CharmHadD02HHXDst_LeptonhhXWithLambda0DD","Hlt2CharmHadD02HHXDst_LeptonhhXWithLambda0DDWideMass"] # ] from Configurables import LoKi__Hybrid__TupleTool LoKi_DTFMASS = LoKi__Hybrid__TupleTool("LoKi_DTFMASS") LoKi_DTFMASS.Variables = { "DTF_CHI2" : "DTF_CHI2( True )", "DTF_NDOF" : "DTF_NDOF( True )", "DTF_D_M" : "DTF_FUN ( M , True )", "DTF_D_MM" : "DTF_FUN ( MM , True )", "DTF_D_P" : "DTF_FUN ( P , True )", "DTF_D_PT" : "DTF_FUN ( PT , True )", "DTF_D_PE" : "DTF_FUN ( E , True )", "DTF_D_PX" : "DTF_FUN ( PX , True )", "DTF_D_PY" : "DTF_FUN ( PY , True )", "DTF_D_PZ" : "DTF_FUN ( PZ , True )", "DTF_x1_M" : "DTF_FUN ( CHILD(M,1) , True )", "DTF_x1_MM" : "DTF_FUN ( CHILD(MM,1) , True )", "DTF_x1_P" : "DTF_FUN ( CHILD(P,1) , True )", "DTF_x1_PT" : "DTF_FUN ( CHILD(PT,1) , True )", "DTF_x1_PE" : "DTF_FUN ( CHILD(E,1) , True )", "DTF_x1_PX" : "DTF_FUN ( CHILD(PX,1) , True )", "DTF_x1_PY" : "DTF_FUN ( CHILD(PY,1) , True )", "DTF_x1_PZ" : "DTF_FUN ( CHILD(PZ,1) , True )", "DTF_x2_M" : "DTF_FUN ( CHILD(M,2) , True )", "DTF_x2_MM" : "DTF_FUN ( CHILD(MM,2) , True )", "DTF_x2_P" : "DTF_FUN ( CHILD(P,2) , True )", "DTF_x2_PT" : "DTF_FUN ( CHILD(PT,2) , True )", "DTF_x2_PE" : "DTF_FUN ( CHILD(E,2) , True )", "DTF_x2_PX" : "DTF_FUN ( CHILD(PX,2) , True )", "DTF_x2_PY" : "DTF_FUN ( CHILD(PY,2) , True )", "DTF_x2_PZ" : "DTF_FUN ( CHILD(PZ,2) , True )", "DTF_x3_M" : "DTF_FUN ( CHILD(M,3) , True )", "DTF_x3_MM" : "DTF_FUN ( CHILD(MM,3) , True )", "DTF_x3_P" : "DTF_FUN ( CHILD(P,3) , True )", "DTF_x3_PT" : "DTF_FUN ( CHILD(PT,3) , True )", "DTF_x3_PE" : "DTF_FUN ( CHILD(E,3) , True )", "DTF_x3_PX" : "DTF_FUN ( CHILD(PX,3) , True )", "DTF_x3_PY" : "DTF_FUN ( CHILD(PY,3) , True )", "DTF_x3_PZ" : "DTF_FUN ( CHILD(PZ,3) , True )", } dttuple.D.ToolList+=["LoKi::Hybrid::TupleTool/LoKi_DTFMASS"] dttuple.D.addTool(LoKi_DTFMASS) if "MC" in dataType: from Configurables import TupleToolMCBackgroundInfo dttuple.addTool(TupleToolMCBackgroundInfo, name="TupleToolMCBackgroundInfo") dttuple.TupleToolMCBackgroundInfo.Verbose=True dttuple.addTool(TupleToolMCTruth, name="truth") dttuple.truth.ToolList += ["MCTupleToolHierarchy", "MCTupleToolKinematic"] dttuple.ToolList+=["TupleToolMCBackgroundInfo/TupleToolMCBackgroundInfo"] dttuple.ToolList+=["TupleToolMCTruth/truth"] DaVinci().appendToMainSequence( [ dttuple ] ) elif outputType == "dst": from Configurables import SelDSTWriter if stripRun: dst_Sel = AutomaticData(Location = stripOutputLoc) else: dst_Sel = AutomaticData(Location = "/Event/"+strippingStream+"/" + stripOutputLoc) dst_Filter = FilterDesktop('dst_Filter', Code = "ALL") dst_FilterSel = Selection(name = line.name().replace("Stripping",""), Algorithm = dst_Filter, RequiredSelections = [ dst_Sel ]) dst_Seq = SelectionSequence('lsdata', TopSelection = dst_FilterSel, ) dstw = SelDSTWriter("DSTWriter") dstw.OutputFileSuffix = "PiPiPi" #dstw.CopyProtoParticles = False dstw.SelectionSequences = [dst_Seq] #dstw.CopyL0DUReport = False #dstw.CopyHltDecReports = False #dstw.CopyMCTruth = True #dstw.CopyBTags = True DaVinci().appendToMainSequence( [ dstw.sequence() ] )
Bu_Kmumu = Selection ("Sel"+name, Algorithm = _stripfilter, RequiredSelections = [stripsel]) seq = SelectionSequence("seq", TopSelection = Bu_Kmumu) tuple = DecayTreeTuple("Jpsi_Tuple") tuple.Inputs = [stripsel.outputLocation()] tuple.ToolList = [ "TupleToolKinematic" , "TupleToolEventInfo" , "TupleToolRecoStats" , "TupleToolMCTruth" , "TupleToolMCBackgroundInfo" , "TupleBuKmmFit" ] tuple.addBranches ({ "Kplus" : "[B+ -> ^K+ (J/psi(1S) -> mu+ mu-)]CC", "Jpsi" : "[B+ -> K+ ^(J/psi(1S) -> mu+ mu-)]CC", "muplus" : "[B+ -> K+ (J/psi(1S) -> ^mu+ mu-)]CC", "muminus" : "[B+ -> K+ (J/psi(1S) -> mu+ ^mu-)]CC", "Bplus" : "[B+ -> K+ J/psi(1S)]CC", }) LoKi_All=tuple.addTupleTool("LoKi::Hybrid::TupleTool/LoKi_All") LoKi_All.Variables = { 'MINIPCHI2' : "MIPCHI2DV(PRIMARY)",
def execute_option_file(path): # ================= BEGIN EDIT AREA ======================= tuplename = "Bu2LLK_meLine" simulation_inputstring = "/Event/AllStreams/Phys/Bu2LLK_meLine/Particles" data_inputstring = "/Event/Leptonic/Phys/Bu2LLK_meLine/Particles" decaydescriptor = "[B+ -> ^[J/psi(1S) -> ^mu+ ^e-]CC ^K+]CC" branches = { # Dictionary for the branches to write in the tuple "B" : "[B+ -> [J/psi(1S) -> mu+ e-]CC K+]CC", "Psi" : "[B+ -> ^[J/psi(1S) -> mu+ e-]CC K+]CC", "muplus" : "[B+ -> [J/psi(1S) -> ^mu+ e-]CC K+]CC", "eminus" : "[B+ -> [J/psi(1S) -> mu+ ^e-]CC K+]CC", "Kplus" : "[B+ -> [J/psi(1S) -> mu+ mu-]CC ^K+]CC" } toollist = [ "TupleToolBremInfo" #Bremsstrahlung information , "TupleToolGeometry" #geometry of vertex locations (ENDVERTEX, OWNPV, IP_OWNPV, FD_OWNPV, DIRA_OWNPV) , "TupleToolKinematic" #kinematic variables (inv. mass MM, kin. mass M/sqrt(E^2-p^2), P, PX/Y/Z/E, PT) , "TupleToolEventInfo" #Event information such as run number, polarity, GPS time etc. , "TupleToolPropertime" #proper lifetime of reconstructed particles , "TupleToolAngles" #decay angles of charged tracks , "TupleToolTrigger" , "TupleToolTrackInfo" #GhostProb of track and track type (TYPE) - 0 = unknown, 1 = velo track... , "TupleToolPrimaries" #Number and coordinates of all primary vertices , "TupleToolDira" , "TupleToolTrackPosition" #Plot the X/Y position at a given Z (default: 2500 = TTstation) , "TupleToolRecoStats" , "TupleToolBremInfo" #Bremsstrahlung information , "TupleToolIsolationTwoBody" #degree of isolation of two particles with common mother from Bsmumu , "TupleToolANNPID" #V2,V3,... ProbNN variables #, "TupleToolCaloHypo" #, "TupleToolL0Calo" ] # ================= END EDIT AREA ======================= # ================= BEGIN DO NOT EDIT HERE ======================= from Configurables import GaudiSequencer MySequencer = GaudiSequencer('Sequence') #Check whether it is a DST or MDST file import os.path extension = os.path.splitext(path)[1] print extension if extension.lower() == ".dst": DaVinci().InputType = 'DST' elif extension.lower() == ".mdst": DaVinci().InputType = 'MDST' else: raise Exception("Extension {extension} of {path} does not match .mdst or .dst".format(extension, path)) #Kill some nodes if micro dst-file if DaVinci().InputType == 'MDST': from Configurables import EventNodeKiller eventNodeKiller = EventNodeKiller('DAQkiller') eventNodeKiller.Nodes = ['/Event/DAQ','/Event/pRec'] MySequencer.Members+=[eventNodeKiller] #DecayTreeTuple -> Fills information about particles, vertices and daughters ntuple = DecayTreeTuple(tuplename) if DaVinci().Simulation is True: # for MC ntuple.Inputs = [simulation_inputstring] elif DaVinci().Simulation is False: # for Tuple ntuple.Inputs = [data_inputstring] else: raise Exception(" `DaVinci().Simulation` not set.") ntuple.Decay = decaydescriptor ntuple.addBranches(branches) ntuple.TupleName = "DecayTree" #Tools added to the ToolList can not be modified i.e. no other options than the defaults can be used ntuple.ToolList = toollist MySequencer.Members.append(ntuple) # ================= BEGIN EDIT TUPLETOOLS WITH OPTIONS ================== # LOKI TupleTool LoKi = ntuple.addTupleTool("LoKi::Hybrid::TupleTool") LoKi.Variables = { "ETA" : "ETA", "PHI" : "PHI" #Azimuthal angle } #Isolation tool from Alex weightsfolder = "" if(True): from Configurables import TupleToolApplyIsolation ntuple.B.addTupleTool(TupleToolApplyIsolation, name="TupleToolApplyIsolationHard") ntuple.B.TupleToolApplyIsolationHard.OutputSuffix="_Hard" ntuple.B.TupleToolApplyIsolationHard.WeightsFile= weightsfolder+"weightsHard.xml" ntuple.B.addTupleTool(TupleToolApplyIsolation, name="TupleToolApplyIsolationSoft") ntuple.B.TupleToolApplyIsolationSoft.OutputSuffix="_Soft" ntuple.B.TupleToolApplyIsolationSoft.WeightsFile= weightsfolder+"weightsSoft.xml" ntuple.B.addTupleTool("TupleToolVtxIsoln") #ntuple.B.TupleToolApplyIsolationHard.OutputLevel = 3 #ntuple.B.TupleToolApplyIsolationSoft.OutputLevel = 3 ################################ ### DaVinci configuration #### ################################ DaVinci().UserAlgorithms = [MySequencer] DaVinci().MoniSequence += [ntuple] DaVinci().EvtMax = 200 DaVinci().SkipEvents = 0 DaVinci().Lumi = True
def execute_option_file(): B2JpsiK = DecayTreeTuple('B2JpsiK') B2JpsiK.ToolList = [ "TupleToolGeometry" , "TupleToolKinematic" , "TupleToolEventInfo" , "TupleToolPropertime" , "TupleToolTrigger" , "TupleToolTISTOS" , "TupleToolPid" , "TupleToolTrackInfo" , "TupleToolPrimaries" , "TupleToolDira" , "TupleToolTrackIsolation" , "TupleToolTrackPosition" , "TupleToolRecoStats" ] if DaVinci().Simulation is True: B2JpsiK.ToolList +=[ "TupleToolMCBackgroundInfo" , "TupleToolMCTruth" ] L0Triggers = ["L0MuonDecision", "L0DiMuonDecision", "L0HadronDecision", "L0ElectronDecision", "L0PhotonDecision" ] ## ['Muon', 'DiMuon', ' Hadron', 'Electron', 'Photon','PhotonHi','ElectronHi'] Hlt1Triggers = [ "Hlt1TrackAllL0Decision", "Hlt1TrackMuonDecision" ,"Hlt1TrackPhotonDecision" ,"Hlt1DiMuonLowMassDecision" ,"Hlt1DiMuonHighMassDecision"] Hlt2Triggers = [ ## muon lines "Hlt2SingleMuonDecision", "Hlt2SingleMuonLowPTDecision", "Hlt2SingleMuonHighPTDecision", "Hlt2DiMuonDecision", "Hlt2DiMuonLowMassDecision", "Hlt2DiMuonJPsiDecision", "Hlt2DiMuonJPsiHighPTDecision", "Hlt2DiMuonPsi2SDecision", "Hlt2DiMuonDetachedDecision", "Hlt2DiMuonDetachedJPsiDecision", "Hlt2DiMuonDetachedHeavyDecision", "Hlt2TriMuonTauDecision", ## hadron/Topo lines "Hlt2B2HHDecision", "Hlt2DiMuonBDecision", "Hlt2DiMuonZDecision", "Hlt2TopoMu2BodyBBDTDecision", "Hlt2TopoMu3BodyBBDTDecision", "Hlt2TopoMu4BodyBBDTDecision", "Hlt2Topo2BodyBBDTDecision", "Hlt2Topo3BodyBBDTDecision", "Hlt2Topo4BodyBBDTDecision", ##others "Hlt2PassThroughDecision", "Hlt2TransparentDecision", ## inclusive decisions "Hlt2DiMuonDY.*Decision","Hlt2TopoE.*Decision", "Hlt2Topo.*Decision", "Hlt2Charm.*Decision", "Hlt2DiElectron.*Decision" ] triggerList = L0Triggers + Hlt1Triggers + Hlt2Triggers B2JpsiK.addTool(TupleToolTISTOS) B2JpsiK.TupleToolTISTOS.VerboseL0 = True B2JpsiK.TupleToolTISTOS.VerboseHlt1 = True B2JpsiK.TupleToolTISTOS.VerboseHlt2 = True B2JpsiK.TupleToolTISTOS.FillL0 = True B2JpsiK.TupleToolTISTOS.FillHlt1 = True B2JpsiK.TupleToolTISTOS.FillHlt2 = True B2JpsiK.TupleToolTISTOS.OutputLevel = INFO B2JpsiK.TupleToolTISTOS.TriggerList = triggerList if DaVinci().Simulation is True: # for MC B2JpsiK.Inputs = ["/Event/AllStreams/Phys/Bs2MuMuLinesBu2JPsiKLine/Particles"] elif DaVinci().Simulation is False: # for Data B2JpsiK.Inputs = ["/Event/Dimuon/Phys/Bs2MuMuLinesBu2JPsiKLine/Particles"] else: raise Exception(" `DaVinci().Simulation` not set.") B2JpsiK.Decay = "[B+ -> ^(J/psi(1S) -> ^mu+ ^mu-) ^K+]CC" B2JpsiK.addBranches({ "Bplus" : "[B+ -> (J/psi(1S) -> mu+ mu-) K+]CC", "Jpsi" : "[B+ -> ^(J/psi(1S) -> mu+ mu-) K+]CC", "muplus" : "[B+ -> (J/psi(1S) -> ^mu+ mu-) K+]CC", "muminus" : "[B+ -> (J/psi(1S) -> mu+ ^mu-) K+]CC", "Kplus" : "[B+ -> (J/psi(1S) -> mu+ mu-) ^K+]CC" }) B2JpsiK.TupleName = "default" fitter = B2JpsiK.Bplus.addTupleTool("TupleToolDecayTreeFitter/FIX_JPSI") fitter.constrainToOriginVertex = False fitter.daughtersToConstrain = [ "J/psi(1S)" ] fitter.Verbose = True ################################ ### DaVinci configuration #### ################################ DaVinci().InputType = 'DST' DaVinci().UserAlgorithms = [B2JpsiK] DaVinci().MoniSequence += [B2JpsiK] DaVinci().EvtMax = -1 DaVinci().Lumi = True
_otherd2kkpi.Preambulo = [ "from LoKiPhysMC.decorators import *", "from PartProp.Nodes import CC" ] selD2KKPiOther = Selection("DsMinusCandidates", Algorithm = _otherd2kkpi, RequiredSelections=[_otherKaons, _otherPions], OutputBranch="NewEvent/Phys") #selD2KKPiOther.OutputLevel = 1 seqD2KKPiOther = SelectionSequence('MCFilterOther', TopSelection = selD2KKPiOther) othertuple = DecayTreeTuple("Ds2KKPiTuple", RootInTES='/Event/NewEvent') othertuple.Decay = "[D_s+ -> K- K+ pi+]CC" #othertuple.Inputs = [seqD2KKPi.outputLocation()] othertuple.Inputs = ['Phys/SelD2KKPiOther/Particles'] othertuple.ToolList = [] from Configurables import MCMatchObjP2MCRelator othertuple.addTupleTool('TupleToolKinematic') othertuple.addTupleTool('TupleToolPropertime') mcTruth = othertuple.addTupleTool("TupleToolMCTruth") mcTruth.IP2MCPAssociatorTypes = ['MCMatchObjP2MCRelator/MyMCMatcher'] mcTruth.addTool(MCMatchObjP2MCRelator, name='MCMatchObjP2MCRelator') mcTruth.MCMatchObjP2MCRelator.RelTableLocations = ['/Event/NewEvent/Relations/NewEvent/Rec/ProtoP/Charged'] #tuple.addTupleTool("TupleToolPropertime")
def execute_option_file(path): from Configurables import GaudiSequencer MySequencer = GaudiSequencer('Sequence') #Check whether it is a DST or MDST file import os.path extension = os.path.splitext(path)[1] print extension if extension.lower() == ".dst": DaVinci().InputType = 'DST' elif extension.lower() == ".mdst": DaVinci().InputType = 'MDST' else: raise Exception("Extension {extension} of {path} does not match .mdst or .dst".format(extension, path)) #Kill some nodes if micro dst-file if DaVinci().InputType == 'MDST': from Configurables import EventNodeKiller eventNodeKiller = EventNodeKiller('DAQkiller') eventNodeKiller.Nodes = ['DAQ','pRec'] MySequencer.Members+=[eventNodeKiller] #DecayTreeTuple data = DecayTreeTuple('Bu2LLK_mmLine') data.ToolList = [ "TupleToolGeometry" , "TupleToolKinematic" , "TupleToolEventInfo" , "TupleToolPropertime" , "TupleToolTrigger" , "TupleToolTISTOS" , "TupleToolPid" , "TupleToolTrackInfo" , "TupleToolPrimaries" , "TupleToolDira" , "TupleToolTrackPosition" , "TupleToolRecoStats" ] if DaVinci().InputType != 'MDST': data.ToolList += ["TupleToolTrackIsolation"] if DaVinci().Simulation is True: data.ToolList +=[ "TupleToolMCBackgroundInfo" , "TupleToolMCTruth" ] L0Triggers = ["L0MuonDecision", "L0DiMuonDecision", "L0HadronDecision", "L0ElectronDecision", "L0PhotonDecision" ] ## ['Muon', 'DiMuon', ' Hadron', 'Electron', 'Photon','PhotonHi','ElectronHi'] Hlt1Triggers = [ "Hlt1TrackAllL0Decision", "Hlt1TrackMuonDecision" ,"Hlt1TrackPhotonDecision" ,"Hlt1DiMuonLowMassDecision" ,"Hlt1DiMuonHighMassDecision"] Hlt2Triggers = [ ## muon lines "Hlt2SingleMuonDecision", "Hlt2SingleMuonLowPTDecision", "Hlt2SingleMuonHighPTDecision", "Hlt2DiMuonDecision", "Hlt2DiMuonLowMassDecision", "Hlt2DiMuonJPsiDecision", "Hlt2DiMuonJPsiHighPTDecision", "Hlt2DiMuonPsi2SDecision", "Hlt2DiMuonDetachedDecision", "Hlt2DiMuonDetachedJPsiDecision", "Hlt2DiMuonDetachedHeavyDecision", "Hlt2TriMuonTauDecision", ## hadron/Topo lines "Hlt2B2HHDecision", "Hlt2DiMuonBDecision", "Hlt2DiMuonZDecision", "Hlt2TopoMu2BodyBBDTDecision", "Hlt2TopoMu3BodyBBDTDecision", "Hlt2TopoMu4BodyBBDTDecision", "Hlt2Topo2BodyBBDTDecision", "Hlt2Topo3BodyBBDTDecision", "Hlt2Topo4BodyBBDTDecision", ##others "Hlt2PassThroughDecision", "Hlt2TransparentDecision", ## inclusive decisions "Hlt2DiMuonDY.*Decision","Hlt2TopoE.*Decision", "Hlt2Topo.*Decision", "Hlt2Charm.*Decision", "Hlt2DiElectron.*Decision" ] triggerList = L0Triggers + Hlt1Triggers + Hlt2Triggers data.addTool(TupleToolTISTOS) data.TupleToolTISTOS.VerboseL0 = True data.TupleToolTISTOS.VerboseHlt1 = True data.TupleToolTISTOS.VerboseHlt2 = True data.TupleToolTISTOS.FillL0 = True data.TupleToolTISTOS.FillHlt1 = True data.TupleToolTISTOS.FillHlt2 = True data.TupleToolTISTOS.OutputLevel = INFO data.TupleToolTISTOS.TriggerList = triggerList if DaVinci().Simulation is True: # for MC data.Inputs = ["/Event/AllStreams/Phys/Bu2LLK_mmLine/Particles"] elif DaVinci().Simulation is False: # for Tuple data.Inputs = ["/Event/Leptonic/Phys/Bu2LLK_mmLine/Particles"] else: raise Exception(" `DaVinci().Simulation` not set.") data.Decay = "[B+ -> ^(J/psi(1S) -> ^mu+ ^mu-) ^K+]CC" data.addBranches({ "B" : "[B+ -> (J/psi(1S) -> mu+ mu-) K+]CC", "Psi" : "[B+ -> ^(J/psi(1S) -> mu+ mu-) K+]CC", "muplus" : "[B+ -> (J/psi(1S) -> ^mu+ mu-) K+]CC", "muminus" : "[B+ -> (J/psi(1S) -> mu+ ^mu-) K+]CC", "Kplus" : "[B+ -> (J/psi(1S) -> mu+ mu-) ^K+]CC" }) data.TupleName = "DecayTree" #DecayTreeFitter fitter = data.B.addTupleTool("TupleToolDecayTreeFitter/FIX_JPSI") fitter.constrainToOriginVertex = False fitter.daughtersToConstrain = [ "J/psi(1S)" ] fitter.Verbose = True #Isolation data.B.addTool(TupleToolApplyIsolation, name="TupleToolApplyIsolationHard") data.B.TupleToolApplyIsolationHard.OutputSuffix="_Hard" data.B.TupleToolApplyIsolationHard.WeightsFile="weightsHard.xml" data.B.ToolList+=["TupleToolApplyIsolation/TupleToolApplyIsolationHard"] data.B.addTool(TupleToolApplyIsolation, name="TupleToolApplyIsolationSoft") data.B.TupleToolApplyIsolationSoft.OutputSuffix="_Soft" data.B.TupleToolApplyIsolationSoft.WeightsFile="weightsSoft.xml" data.B.ToolList+=["TupleToolApplyIsolation/TupleToolApplyIsolationSoft"] vtxiso = data.B.addTupleTool("TupleToolVtxIsoln") #data.B.TupleToolApplyIsolationHard.OutputLevel = 3 #data.B.TupleToolApplyIsolationSoft.OutputLevel = 3 MySequencer.Members.append(data) #EventTuple for simulation """ if DaVinci().Simulation is True: etuple = EventTuple() etuple.ToolList=["TupleToolEventInfo"] MySequencer.Members.append(etuple) """ #DDDB and CondDB-Tags for DATA (needs to be set for Simulation in runfile.py according to generation->see bookkeeping!) #Always use the latest tags for the given datatype from (the newest are currently not in the database yet, therefore take the default ones!) """ if DaVinci().Simulation is False: if DaVinci().DataType == '2012': DaVinci().CondDBtag = "dddb-20150522-2" DaVinci().DDDBtag = "cond-20150409-1" elif DaVinci().DataType == '2011': DaVinci().CondDBtag = "dddb-20150522-1" DaVinci().DDDBtag = "cond-20150409" """ ################################ ### DaVinci configuration #### ################################ DaVinci().UserAlgorithms = [MySequencer] DaVinci().MoniSequence += [data] DaVinci().EvtMax = -1 DaVinci().Lumi = True
from DecayTreeTuple.Configuration import * #from Configurables import ( ANNGlobalPID__ChargedProtoANNPIDTrainingTuple ) #pidtuple = ANNGlobalPID__ChargedProtoANNPIDTrainingTuple("ANNPID") #pidtuple.NTupleLUN = "ANNPIDTUPLE" #DaVinci().UserAlgorithms += [ pidtuple ] from Configurables import (DecayTreeTuple, LoKi__Hybrid__TupleTool) tuple = DecayTreeTuple("ANNPID") tuple.Decay = "[pi+]cc" tuple.NTupleLUN = "ANNPIDTUPLE" tuple.Inputs = [ 'Phys/StdAllNoPIDsPions/Particles', 'Phys/StdNoPIDsUpPions/Particles', 'Phys/StdNoPIDsDownPions/Particles' ] tuple.ToolList = ["TupleToolANNPIDTraining", "TupleToolGeometry"] #lokiT = tuple.addTupleTool( LoKi__Hybrid__TupleTool, name = "LokiTool" ) #lokiT.Variables = { "MIPCHI2_PRIMARY" : "MIPCHI2DV(PRIMARY)" } DaVinci().UserAlgorithms += [tuple] DaVinci().EvtMax = -1 DaVinci().PrintFreq = 1000 #DaVinci().SkipEvents = 100000 DaVinci().InputType = 'DST' DaVinci().Simulation = True DaVinci().DataType = "2011" NTupleSvc().Output += [ "ANNPIDTUPLE DATAFILE='ProtoPIDANN.MC.tuples.root' TYP='ROOT' OPT='NEW'"
def execute_option_file(): Tuple = DecayTreeTuple('Bu2LLK_eeLine2') Tuple.ToolList = [ "TupleToolGeometry" , "TupleToolKinematic" , "TupleToolEventInfo" , "TupleToolPropertime" , "TupleToolTrigger" , "TupleToolTISTOS" , "TupleToolPid" , "TupleToolTrackInfo" , "TupleToolPrimaries" , "TupleToolDira" , "TupleToolTrackIsolation" , "TupleToolTrackPosition" , "TupleToolRecoStats" ] if DaVinci().Simulation is True: Tuple.ToolList +=[ "TupleToolMCBackgroundInfo" , "TupleToolMCTruth" ] L0Triggers = ["L0MuonDecision", "L0DiMuonDecision", "L0HadronDecision", "L0ElectronDecision", "L0PhotonDecision" ] ## ['Muon', 'DiMuon', ' Hadron', 'Electron', 'Photon','PhotonHi','ElectronHi'] Hlt1Triggers = [ "Hlt1TrackAllL0Decision", "Hlt1TrackMuonDecision" ,"Hlt1TrackPhotonDecision" ,"Hlt1DiMuonLowMassDecision" ,"Hlt1DiMuonHighMassDecision"] Hlt2Triggers = [ ## muon lines "Hlt2SingleMuonDecision", "Hlt2SingleMuonLowPTDecision", "Hlt2SingleMuonHighPTDecision", "Hlt2DiMuonDecision", "Hlt2DiMuonLowMassDecision", "Hlt2DiMuonJPsiDecision", "Hlt2DiMuonJPsiHighPTDecision", "Hlt2DiMuonPsi2SDecision", "Hlt2DiMuonDetachedDecision", "Hlt2DiMuonDetachedJPsiDecision", "Hlt2DiMuonDetachedHeavyDecision", "Hlt2TriMuonTauDecision", ## hadron/Topo lines "Hlt2B2HHDecision", "Hlt2DiMuonBDecision", "Hlt2DiMuonZDecision", "Hlt2TopoMu2BodyBBDTDecision", "Hlt2TopoMu3BodyBBDTDecision", "Hlt2TopoMu4BodyBBDTDecision", "Hlt2Topo2BodyBBDTDecision", "Hlt2Topo3BodyBBDTDecision", "Hlt2Topo4BodyBBDTDecision", ##others "Hlt2PassThroughDecision", "Hlt2TransparentDecision", ## inclusive decisions "Hlt2DiMuonDY.*Decision","Hlt2TopoE.*Decision", "Hlt2Topo.*Decision", "Hlt2Charm.*Decision", "Hlt2DiElectron.*Decision" ] triggerList = L0Triggers + Hlt1Triggers + Hlt2Triggers Tuple.addTool(TupleToolTISTOS) Tuple.TupleToolTISTOS.VerboseL0 = True Tuple.TupleToolTISTOS.VerboseHlt1 = True Tuple.TupleToolTISTOS.VerboseHlt2 = True Tuple.TupleToolTISTOS.FillL0 = True Tuple.TupleToolTISTOS.FillHlt1 = True Tuple.TupleToolTISTOS.FillHlt2 = True Tuple.TupleToolTISTOS.OutputLevel = INFO Tuple.TupleToolTISTOS.TriggerList = triggerList if DaVinci().Simulation is True: # for MC Tuple.Inputs = ["/Event/Leptonic/Phys/Bu2LLK_eeLine2/Particles"] elif DaVinci().Simulation is False: # for Tuple Tuple.Inputs = ["/Event/Leptonic/Phys/Bu2LLK_eeLine2/Particles"] else: raise Exception(" `DaVinci().Simulation` not set.") Tuple.Decay = "[B+ -> ^(J/psi(1S) -> ^e+ ^e-) ^K+]CC" Tuple.addBranches({ "B" : "[B+ -> (J/psi(1S) -> e+ e-) K+]CC", "Psi" : "[B+ -> ^(J/psi(1S) -> e+ e-) K+]CC", "eplus" : "[B+ -> (J/psi(1S) -> ^e+ e-) K+]CC", "eminus" : "[B+ -> (J/psi(1S) -> e+ ^e-) K+]CC", "Kplus" : "[B+ -> (J/psi(1S) -> e+ e-) ^K+]CC" }) Tuple.TupleName = "DecayTree" #DecayTreeFitter fitter = Tuple.B.addTupleTool("TupleToolDecayTreeFitter/FIX_JPSI") fitter.constrainToOriginVertex = False fitter.daughtersToConstrain = [ "J/psi(1S)" ] fitter.Verbose = True #Isolation Tuple.B.addTool(TupleToolApplyIsolation, name="TupleToolApplyIsolationHard") Tuple.B.TupleToolApplyIsolationHard.OutputSuffix="_Hard" Tuple.B.TupleToolApplyIsolationHard.WeightsFile="weightsHard.xml" Tuple.B.ToolList+=["TupleToolApplyIsolation/TupleToolApplyIsolationHard"] Tuple.B.addTool(TupleToolApplyIsolation, name="TupleToolApplyIsolationSoft") Tuple.B.TupleToolApplyIsolationSoft.OutputSuffix="_Soft" Tuple.B.TupleToolApplyIsolationSoft.WeightsFile="weightsSoft.xml" Tuple.B.ToolList+=["TupleToolApplyIsolation/TupleToolApplyIsolationSoft"] vtxiso = Tuple.B.addTupleTool("TupleToolVtxIsoln") #Tuple.B.TupleToolApplyIsolationHard.OutputLevel = 3 #Tuple.B.TupleToolApplyIsolationSoft.OutputLevel = 3 ################################ ### DaVinci configuration #### ################################ DaVinci().InputType = 'DST' DaVinci().UserAlgorithms = [Tuple] DaVinci().MoniSequence += [Tuple] DaVinci().EvtMax = -1 DaVinci().Lumi = True
from Gaudi.Configuration import * from PhysSelPython.Wrappers import Selection, SelectionSequence, DataOnDemand from Configurables import DecayTreeTuple, FitDecayTrees, TupleToolRecoStats, TupleToolTrigger, TupleToolTISTOS, CondDB from DecayTreeTuple.Configuration import * tuple = DecayTreeTuple("Jpsi_Tuple") tuple.Inputs = ["/Event/Dimuon/Phys/B2XMuMu_Line/Particles"] tuple.ToolList = [ "TupleToolKinematic" , "TupleToolEventInfo" , "TupleToolRecoStats" , "TupleBuKmmFit" ] tuple.addBranches ({ "Bplus" : "[B+ -> K+ ( J/psi(1S) -> mu+ mu-)]CC", "Kplus" : "[B+ -> ^K+ ( J/psi(1S) -> mu+ mu-)]CC", "Jpsi" : "[B+ -> K+ ^( J/psi(1S) -> mu+ mu-)]CC", "muplus" : "[B+ -> K+ ( J/psi(1S) -> ^mu+ mu-)]CC", "muminus" : "[B+ -> K+ ( J/psi(1S) -> mu+ ^mu-)]CC", }) LoKi_All = tuple.addTupleTool("LoKi::Hybrid::TupleTool/LoKi_All") LoKi_All.Variables = { 'MINIPCHI2' : "MIPCHI2DV(PRIMARY)", 'MINIP' : "MIPDV(PRIMARY)", 'IPCHI2_OWNPV' : "BPVIPCHI2()", 'IP_OWNPV' : "BPVIP()"
def decay_tree_tuple(name, decay, mothers, intermediate, daughters, inputs, mc): """Return a configured DecayTreeTuple instance. A DecayTreeTuple is configured with the given decay descriptor. The mothers dictionary is used to give exclusive tools to vertices, and it should be, as daughters, a dictionary of tuple branch names to branch descriptors. A typical method call might look like decay_tree_tuple( 'TupleDstToD0pi_D0ToKpi', '[D*(2010)+ -> K- pi+]CC', { 'Dst': '[D*(2010) -> (D0 -> K- pi+) pi+]CC', 'D0': '[D*(2010) -> ^(D0 -> K- pi+) pi+]CC' }, { 'D0_K': '[D*(2010) -> (D0 -> ^K- pi+) pi+]CC', 'D0_pi': '[D*(2010) -> (D0 -> K- ^pi+) pi+]CC', 'Dst_pi': '[D*(2010) -> (D0 -> K- pi+) ^pi+]CC' }, 'Phys/StrippingLineName/Particles' ) Keyword arguments: name -- TDirectory the DecayTreeTuple TTree will be saved in decay -- Decay descriptor mothers -- Branch descriptors to be added to the tuple as mothers; decaying particles daughters -- Branch descriptors to be added to the tuple as daughters; final state particles inputs -- str of list of str, as the value of DecayTreeTuple.Inputs mc -- Extra MC information is included if True """ # Define tuple tools to add tools = [ "TupleToolPropertime", 'TupleToolEventInfo', ] # Extra variables, added using LoKi hybrid tuple tools basic_loki_vars = { 'ETA': 'ETA', 'PHI': 'PHI', 'PT': 'PT', 'ID': 'ID', 'P': 'P', 'Loki_BPVIPCHI2': 'BPVIPCHI2()', 'Loki_MIPCHI2DV': 'MIPCHI2DV(PRIMARY)', } intermediate_loki_vars = { 'Loki_AM34': 'LoKi.Particles.PFunA(AM34)', 'Loki_AM4': 'LoKi.Particles.PFunA(AM4)', 'Loki_BPVDIRA': "BPVDIRA", 'Loki_acosBPVDIRA': "acos(BPVDIRA)", } daughter_loki_vars = { 'PIDK': 'PIDK', 'PIDe': 'PIDe', 'PIDmu': 'PIDmu', 'PIDp': 'PIDp', 'Loki_TRACKCHI2NDOF': 'TRCHI2DOF', 'Loki_TRACKGHOSTPROB': 'TRGHOSTPROB', } mother_loki_vars = { 'M': 'M', 'Loki_BPVVDCHI2': 'BPVVDCHI2', 'Loki_BPVIPCHI2': 'BPVIPCHI2()', 'Loki_DOCAMAX': 'DOCAMAX', 'Loki_AMAXDOCA': "LoKi.Particles.PFunA(AMAXDOCA(''))", 'Loki_AMINDOCA': "LoKi.Particles.PFunA(AMINDOCA(''))", 'Loki_DOCACHI2MAX': 'DOCACHI2MAX', 'Loki_VCHI2NDOF': 'VFASPF(VCHI2/VDOF)', 'Loki_VX': 'VFASPF(VX)', 'Loki_VY': 'VFASPF(VY)', 'Loki_VZ': 'VFASPF(VZ)', 'Loki_SUMPT': 'SUMTREE(PT, ISBASIC)', 'Loki_BPVLTIME': "BPVLTIME()", } # Template DecayTreeTuple t = DecayTreeTuple(name) # Providing str will throw an exception, so wrap it in a list try: t.Inputs = inputs except ValueError: t.Inputs = [inputs] t.Decay = decay # Merge the mother and daughter dictionaries t.addBranches( dict(mothers.items() + intermediate.items() + daughters.items())) # Tools for all branches t.ToolList = tools # Verbose reconstruction information t.addTupleTool('TupleToolANNPID').ANNPIDTunes = ["MC15TuneV1"] # t.addTupleTool('TupleToolRecoStats') # MC truth information if mc: if has_turbo_inputs(t): print 'Adding MC truth information for Turbo' from TeslaTools import TeslaTruthUtils relations = TeslaTruthUtils.getRelLoc("") print 'relations = {}'.format(relations) toollist = ['MCTupleToolPrompt'] rels = [relations] MCTruth = TupleToolMCTruth() #MCTruth.OutputLevel = 1 MCTruth = t.addTupleTool('TupleToolMCTruth') MCTruth.ToolList = toollist MCTruth.addTool(DaVinciSmartAssociator) MCTruth.DaVinciSmartAssociator.RedoNeutral = False MCTruth.DaVinciSmartAssociator.addTool(P2MCPFromProtoP) MCTruth.DaVinciSmartAssociator.P2MCPFromProtoP.Locations = rels MCTruth.addTool(MCMatchObjP2MCRelator) MCTruth.MCMatchObjP2MCRelator.RelTableLocations = rels MCTruth.DaVinciSmartAssociator.addTool(BackgroundCategory) MCTruth.DaVinciSmartAssociator.BackgroundCategory.addTool( P2MCPFromProtoP) MCTruth.DaVinciSmartAssociator.BackgroundCategory.vetoNeutralRedo = True MCTruth.DaVinciSmartAssociator.BackgroundCategory.P2MCPFromProtoP.Locations = rels bkgcat = t.addTupleTool('TupleToolMCBackgroundInfo') bkgcat.addTool(BackgroundCategory) bkgcat.OutputLevel = 10 bkgcat.BackgroundCategory.vetoNeutralRedo = True bkgcat.BackgroundCategory.addTool(P2MCPFromProtoP) bkgcat.BackgroundCategory.P2MCPFromProtoP.Locations = rels t.OutputLevel = 10 else: print 'Adding MC truth information' t.addTupleTool('TupleToolMCTruth') t.addTupleTool('TupleToolMCBackgroundInfo') # Extra information from LoKi hybrid_tt = t.addTupleTool('LoKi::Hybrid::TupleTool/basicLoKiTT') hybrid_tt.Variables = basic_loki_vars hybrid_tt.Preambulo = ['from LoKiTracks.decorators import TrIDC'] # Add mother-specific varaibles to each mother branch for mother in mothers: branch = getattr(t, mother) branch.addTupleTool('LoKi::Hybrid::TupleTool/{0}LoKiTT'.format( mother)).Variables = mother_loki_vars # For some unknown reason this doesn't work with Turbo candidates, so # the information for them has to be added to every branch DictTuple = branch.addTupleTool(LoKi__Hybrid__Dict2Tuple, name="DTFTuple") DictTuple.addTool(DTFDict, name="DTF") DictTuple.Source = "LoKi::Hybrid::DTFDict/DTF" DictTuple.NumVar = 6 * (len(mothers) + len(intermediate) + len(daughters)) # configure the DecayTreeFitter in the usual way DictTuple.DTF.constrainToOriginVertex = True DictTuple.DTF.daughtersToConstrain = ['D0'] DictTuple.DTF.addTool(LoKi__Hybrid__DictOfFunctors, name="dict") DictTuple.DTF.Source = "LoKi::Hybrid::DictOfFunctors/dict" DictTuple.DTF.dict.Variables = { "DTFDict_{}_PT".format(mother): "PT", "DTFDict_{}_ETA".format(mother): "ETA", "DTFDict_{}_PHI".format(mother): "PHI", "DTFDict_{}_P".format(mother): "P", "DTFDict_{}_M".format(mother): "M", } for part, decay in intermediate.items() + daughters.items(): DictTuple.DTF.dict.Variables["DTFDict_{}_PT".format( part)] = "CHILD(PT,'{}')".format(decay) DictTuple.DTF.dict.Variables["DTFDict_{}_ETA".format( part)] = "CHILD(ETA,'{}')".format(decay) DictTuple.DTF.dict.Variables["DTFDict_{}_PHI".format( part)] = "CHILD(PHI,'{}')".format(decay) DictTuple.DTF.dict.Variables["DTFDict_{}_P".format( part)] = "CHILD(P,'{}')".format(decay) DictTuple.DTF.dict.Variables["DTFDict_{}_M".format( part)] = "CHILD(M,'{}')".format(decay) # Add intermediate-specific varaibles to each mother branch mom_int = mother_loki_vars.copy() mom_int.update(intermediate_loki_vars) for mother in intermediate: branch = getattr(t, mother) branch.addTupleTool('LoKi::Hybrid::TupleTool/{0}LoKiTT'.format( mother)).Variables = mom_int # For some unknown reason this doesn't work with Turbo candidates, so # the information for them has to be added to every branch for daughter in daughters: branch = getattr(t, daughter) branch.addTupleTool('LoKi::Hybrid::TupleTool/{0}LoKiTT'.format( daughter)).Variables = daughter_loki_vars return t
from PhysSelPython.Wrappers import SelectionSequence SeqKsPiPi = SelectionSequence('SeqKsPiPi', TopSelection = LooseKsPiPi) KsPiPiTuple = DecayTreeTuple("KsPiPiTuple") # input locations KsPiPiTuple.Inputs = [ LooseKsPiPi.outputLocation() ] # decay descriptors KsPiPiTuple.Decay = "KS0 -> ^pi+ ^pi-" # define the tools and configure them KsPiPiTuple.ToolList = [ "TupleToolKinematic" ,"TupleToolGeometry" ,"TupleToolPid" ,"TupleToolANNPID" #,"TupleToolTrackInfo" ,"TupleToolRecoStats" ,"TupleToolTrigger" ,"TupleToolPrimaries" ] KsPiPiTuple.addTupleTool("TupleToolTrackInfo/TupleToolTrackInfo") KsPiPiTuple.TupleToolTrackInfo.Verbose = True # define the list of triggers that could have fired... KsPiPiTuple.addTupleTool("LoKi::Hybrid::TupleTool/LoKiTool") KsPiPiTuple.LoKiTool.Variables = { "eta" : "ETA", "phi" : "PHI", "LV01" : "LV01" }
tuple2.Decay = tuple.Decay from Configurables import DataOnDemandSvc, L0SelReportsMaker, L0DecReportsMaker DataOnDemandSvc().AlgMap["HltLikeL0/DecReports"] = L0DecReportsMaker() DataOnDemandSvc().AlgMap["HltLikeL0/SelReports"] = L0SelReportsMaker() from Configurables import L0Conf L0Conf().FullL0MuonDecoding = True L0Conf().EnableL0DecodingOnDemand = True L0Conf().EnsureKnownTCK = False tuple3 = DecayTreeTuple("StrippingTuple") tuple3.Inputs = [ '/Event/AllStreams/Phys/FullDSTDiMuonJpsi2MuMuDetachedLine/Particles' ] tuple3.Decay = tuple.Decay tuple3.ToolList = tuple.ToolList tuple3.addTool(TupleToolTrigger, name="TupleToolTrigger") tuple3.addTool(TupleToolTISTOS, name="TupleToolTISTOS") tuple3.TupleToolTrigger.Verbose = True tuple3.TupleToolTrigger.TriggerList = tlist tuple3.TupleToolTISTOS.Verbose = True tuple3.TupleToolTISTOS.TriggerList = tlist tuple4 = MCDecayTreeTuple("MCStrippingTuple") tuple4.Inputs = [ '/Event/AllStreams/Phys/FullDSTDiMuonJpsi2MuMuDetachedLine/Particles' ] tuple4.Decay = tuple.Decay #DaVinci().UserAlgorithms += [ tuple2 ] #DaVinci().TupleFile = "DVNtuples.root"
from DecayTreeTuple.Configuration import * from FlavourTagging.Tunings import applyTuning ntuple = DecayTreeTuple("TaggingTest") descriptor_B = "[B0 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^(K*(892)0 -> ^K+ ^pi-)]CC" ntuple.Inputs = ['Dimuon/Phys/BetaSBd2JpsiKstarDetachedLine/Particles'] ntuple.Decay = descriptor_B ntuple.addBranches({'B0': descriptor_B}) ntuple.ReFitPVs = True ntuple.ToolList = [ "TupleToolKinematic", "TupleToolPropertime", "TupleToolPrimaries", "TupleToolPid" ] # Configure TupleToolTagging tt_tagging = ntuple.addTupleTool("TupleToolTagging") tt_tagging.UseFTfromDST = False tt_tagging.OutputLevel = INFO tt_tagging.Verbose = True btag = tt_tagging.addTool(BTaggingTool, 'MyBTaggingTool') applyTuning(btag, tuning_version="Summer2019Optimisation_v1_Run2" ) # apply most recent tuning #applyTuning(btag) # apply default tuning tt_tagging.TaggingToolName = btag.getFullName() tt_tagging.AddTagPartsInfo = True # DaVinci configuration
from StandardParticles import StdNoPIDsPions, StdNoPIDsKaons, StdNoPIDsProtons, StdNoPIDsMuons from GaudiKernel.SystemOfUnits import MeV, GeV, cm, mm from Configurables import DecayTreeTuple, FitDecayTrees, TupleToolRecoStats, TupleToolTrigger, TupleToolSubMass from Configurables import TupleToolTISTOS, CondDB, SelDSTWriter from Configurables import TupleToolTrackInfo, TupleToolRICHPid, TupleToolGeometry, TupleToolPid from Configurables import TupleToolANNPID from Configurables import TupleToolSLTruth from Configurables import TupleToolTauMuDiscrVarsLcMassConstraint from DecayTreeTuple.Configuration import * tupleB = DecayTreeTuple("tupleout") tupleB.Inputs = ["/Event/Semileptonic/Phys/b2LcMuXB2DMuForTauMuLine/Particles"] tupleB.Decay = "[B- -> ^(Lambda_c+ -> ^p+ ^K- ^pi+) ^mu-]CC" tupleB.ToolList = [ "TupleToolKinematic", "TupleToolEventInfo", "TupleToolRecoStats" ] # Probably need to add many more Tools. tupleB.addBranches({ "Lb": "[B- -> (Lambda_c+ -> p+ K- pi+) mu-]CC", "Lc": "[B- -> ^Lambda_c+ mu-]CC", "p": "[B- -> (Lambda_c+ -> ^p+ K- pi+) mu-]CC", "pi": "[B- -> (Lambda_c+ -> p+ K- ^pi+) mu-]CC", "K": "[B- -> (Lambda_c+ -> p+ ^K- pi+) mu-]CC", "mu": "[B- -> (Lambda_c+ -> p+ K- pi+) ^mu-]CC" }) l0_lines = ['L0HadronDecision', 'L0MuonDecision', 'L0ElectronDecision'] hlt1_lines = ['Hlt1TrackMVADecision', 'Hlt1TwoTrackMVADecision']
def __apply_configuration__(self): from Configurables import (GaudiSequencer, CombineParticles, OfflineVertexFitter) from PhysSelPython.Wrappers import Selection, SelectionSequence, DataOnDemand seq = self.getProp("Sequencer") if seq == None: raise RuntimeError("ERROR : Sequence not set") if self.getProp("RunSelection"): # STD particles from StandardParticles import StdNoPIDsPions, StdNoPIDsKaons # phi -> K+ K- Phi2KKName = self.__sel_name__ + "_Phi2KK" Phi2KK = CombineParticles(Phi2KKName) Phi2KK.DecayDescriptor = "phi(1020) -> K+ K-" Phi2KK.CombinationCut = "(ADAMASS('phi(1020)')<75*MeV)" Phi2KK.MotherCut = "(ADMASS('phi(1020)')<50*MeV) & (BPVVDCHI2>60) & (MIPDV(PRIMARY)<0.5) & (VFASPF(VCHI2) < 20)" Phi2KK.DaughtersCuts = { "K+": "(PT>300*MeV) & (P>2*GeV) & (MIPDV(PRIMARY) < 0.5) & (BPVIPCHI2() > 20)", "K-": "(PT>300*MeV) & (P>2*GeV) & (MIPDV(PRIMARY) < 0.5) & (BPVIPCHI2() > 20)" } self.setOptions(Phi2KK) Phi2KKSel = Selection(Phi2KKName + 'Sel', Algorithm=Phi2KK, RequiredSelections=[StdNoPIDsKaons]) # Bs -> J/psi phi Ds2piPhiName = self.__sel_name__ Ds2piPhi = CombineParticles(Ds2piPhiName) Ds2piPhi.DecayDescriptor = "[D_s+ -> pi+ phi(1020)]cc" Ds2piPhi.addTool(OfflineVertexFitter) Ds2piPhi.ParticleCombiners.update({"": "OfflineVertexFitter"}) Ds2piPhi.OfflineVertexFitter.useResonanceVertex = True Ds2piPhi.CombinationCut = "(ADAMASS('D_s+')<75*MeV)" Ds2piPhi.MotherCut = "(ADMASS('D_s+')<50*MeV) & (BPVDIRA>0.9999) & (BPVVDCHI2>85) & (MIPDV(PRIMARY)<0.1) & (VFASPF(VCHI2) < 10)" Ds2piPhi.DaughtersCuts = { "pi+": "(PT>300*MeV) & (P>2*GeV) & (MIPDV(PRIMARY) >0.1) & (BPVIPCHI2() > 20)" } self.setOptions(Ds2piPhi) Ds2piPhiSel = Selection( Ds2piPhiName + 'Sel', Algorithm=Ds2piPhi, RequiredSelections=[Phi2KKSel, StdNoPIDsPions]) # Selection Sequence selSeq = SelectionSequence(self.__sel_name__ + 'Seq', TopSelection=Ds2piPhiSel) # Run the selection sequence. seq.Members += [selSeq.sequence()] # Particle Monitoring plots if self.getProp("RunMonitors"): from Configurables import ParticleMonitor plotter = ParticleMonitor(self.__sel_name__ + "Plots") if self.getProp("RunSelection"): plotter.Inputs = ['Phys/' + self.__sel_name__ + 'Sel'] else: plotter.Inputs = self.getProp("Candidates") plotter.PeakCut = "(ADMASS('D_s+')<100*MeV)" plotter.SideBandCut = "(ADMASS('D_s+')>100*MeV)" plotter.PlotTools = self.getProp("PlotTools") self.setOptions(plotter) seq.Members += [plotter] # Make a DST ? if self.getProp("MakeSelDST"): # Prescale from Configurables import DeterministicPrescaler scaler = DeterministicPrescaler( self.__sel_name__ + 'PreScale', AcceptFraction=self.getProp("DSTPreScaleFraction")) seq.Members += [scaler] # Write the DST MyDSTWriter = SelDSTWriter(self.__sel_name__ + "DST", SelectionSequences=[selSeq], OutputPrefix=self.__sel_name__) seq.Members += [MyDSTWriter.sequence()] # MC Performance checking ? if self.getProp("MCChecks"): from Configurables import ParticleEffPurMoni mcPerf = ParticleEffPurMoni(Ds2piPhiName + "MCPerf") mcPerf.Inputs = ['Phys/' + self.__sel_name__ + 'Sel'] self.setOptions(mcPerf) seq.Members += [mcPerf] # Ntuple ? if self.getProp("MakeNTuple"): outputLevel = INFO from Configurables import ( DecayTreeTuple, TupleToolDecay, TupleToolMCTruth, TupleToolMCBackgroundInfo, TupleToolGeometry, TupleToolKinematic, TupleToolPrimaries, TupleToolEventInfo, MCTupleToolHierarchy, MCTupleToolKinematic, TupleToolPid, TupleToolTrackInfo, TupleToolVtxIsoln, LoKi__Hybrid__TupleTool) Tuple = DecayTreeTuple(Ds2piPhiName + "Tuple") Tuple.Inputs = ["Phys/" + Ds2piPhiName] Tuple.Decay = "[D_s+ -> ^pi+ (^phi(1020) => ^K+ ^K-)]cc" Tuple.Branches = { "pion": "[D_s+ -> ^pi+ (phi(1020) => K+ K-)]cc", "kaonplus": "[D_s+ -> pi+ (phi(1020) => ^K+ K-)]cc", "kaonminus": "[D_s+ -> pi+ (phi(1020) => K+ ^K-)]cc", "phi": "[D_s+ -> pi+ (^phi(1020) => K+ K-)]cc", "D_s": "[D_s+]cc :[D_s+ -> pi+ (phi(1020) => K+ K-)]cc" } Tuple.addTool(TupleToolDecay, name='pion') Tuple.addTool(TupleToolDecay, name='phi') Tuple.addTool(TupleToolDecay, name='kaonplus') Tuple.addTool(TupleToolDecay, name='kaonminus') Tuple.addTool(TupleToolDecay, name='D_s') # k+ specific kaonplusLoKiTool = LoKi__Hybrid__TupleTool('kaonplusLoKiTool') kaonplusLoKiTool.Variables = { "LOKI_PIDK": "PIDK", "LOKI_PIDe": "PIDe", "LOKI_PIDpi": "PIDpi", "LOKI_PIDp": "PIDp", "LOKI_PIDmu": "PIDmu", "LOKI_PIDK_PIDpi": "PIDK-PIDpi", "LOKI_PIDK_PIDe": "PIDK-PIDe", "LOKI_PIDK_PIDmu": "PIDK-PIDmu", "LOKI_PIDK_PIDp": "PIDK-PIDp" } Tuple.kaonplus.addTool(kaonplusLoKiTool, name='kaonplusLoKiTool') Tuple.kaonplus.ToolList = [ 'LoKi::Hybrid::TupleTool/kaonplusLoKiTool' ] # k- specific kaonminusLoKiTool = LoKi__Hybrid__TupleTool('kaonminusLoKiTool') kaonminusLoKiTool.Variables = { "LOKI_PIDK": "PIDK", "LOKI_PIDe": "PIDe", "LOKI_PIDpi": "PIDpi", "LOKI_PIDp": "PIDp", "LOKI_PIDmu": "PIDmu", "LOKI_PIDK_PIDpi": "PIDK-PIDpi", "LOKI_PIDK_PIDe": "PIDK-PIDe", "LOKI_PIDK_PIDmu": "PIDK-PIDmu", "LOKI_PIDK_PIDp": "PIDK-PIDp" } Tuple.kaonminus.addTool(kaonminusLoKiTool, name='kaonminusLoKiTool') Tuple.kaonminus.ToolList = [ 'LoKi::Hybrid::TupleTool/kaonminusLoKiTool' ] # pi+ specific pionLoKiTool = LoKi__Hybrid__TupleTool('pionLoKiTool') pionLoKiTool.Variables = { "LOKI_PIDK": "PIDK", "LOKI_PIDe": "PIDe", "LOKI_PIDpi": "PIDpi", "LOKI_PIDp": "PIDp", "LOKI_PIDmu": "PIDmu", "LOKI_PIDpi_PIDK": "PIDpi-PIDK", "LOKI_PIDpi_PIDe": "PIDpi-PIDe", "LOKI_PIDpi_PIDmu": "PIDpi-PIDmu", "LOKI_PIDpi_PIDp": "PIDpi-PIDp" } Tuple.pion.addTool(pionLoKiTool, name='pionLoKiTool') Tuple.pion.ToolList = ['LoKi::Hybrid::TupleTool/pionLoKiTool'] # phi specific phiLoKiTool = LoKi__Hybrid__TupleTool('phiLoKiTool') phiLoKiTool.Variables = {} Tuple.phi.addTool(phiLoKiTool, name='phiLoKiTool') Tuple.phi.ToolList = ['LoKi::Hybrid::TupleTool/phiLoKiTool'] # D_s specific DsLoKiTool = LoKi__Hybrid__TupleTool('DsLoKiTool') DsLoKiTool.Variables = {} Tuple.D_s.addTool(DsLoKiTool, name='DsLoKiTool') Tuple.D_s.ToolList = ["LoKi::Hybrid::TupleTool/DsLoKiTool"] # Common to all particles LoKiTool = LoKi__Hybrid__TupleTool('LoKiTool') LoKiTool.Variables = { "LOKI_ABSID": "ABSID", "LOKI_BPVIPCHI2": "BPVIPCHI2()", "LOKI_BPVDIRA": "BPVDIRA", "LOKI_BPVLTFITCHI2": "BPVLTFITCHI2('PropertimeFitter/properTime:PUBLIC')", "LOKI_BPVLTCHI2": "BPVLTCHI2('PropertimeFitter/properTime:PUBLIC')", "LOKI_BPVLTIME": "BPVLTIME('PropertimeFitter/properTime:PUBLIC')", "LOKI_BPVVDCHI2": "BPVVDCHI2", "LOKI_ID": "ID", "LOKI_MIPDV_PRIMARY": "MIPDV(PRIMARY)", "LOKI_MIPCHI2DV_PRIMARY": "MIPCHI2DV(PRIMARY)", "LOKI_MM": "MM", "LOKI_M": "M", "LOKI_P": "P", "LOKI_PT": "PT", "LOKI_TRCHI2": "TRCHI2", "LOKI_TRCHI2DOF": "TRCHI2DOF", "LOKI_VFASPF_VCHI2": "VFASPF(VCHI2)", "LOKI_VFASPF_VDOF": "VFASPF(VDOF)" } Tuple.addTool(LoKiTool, name='LoKiTool') Tuple.ToolList = [ "LoKi::Hybrid::TupleTool/LoKiTool", "TupleToolEventInfo", "TupleToolGeometry", "TupleToolKinematic", "TupleToolMCBackgroundInfo", "TupleToolPid", "TupleToolPrimaries", "TupleToolTrackInfo", "TupleToolVtxIsoln", "TupleToolMCTruth" ] Tuple.addTool(TupleToolEventInfo) Tuple.TupleToolEventInfo.OutputLevel = outputLevel Tuple.addTool(TupleToolGeometry) Tuple.TupleToolGeometry.OutputLevel = outputLevel Tuple.addTool(TupleToolKinematic) Tuple.TupleToolKinematic.OutputLevel = outputLevel Tuple.addTool(TupleToolMCBackgroundInfo) Tuple.TupleToolMCBackgroundInfo.OutputLevel = outputLevel Tuple.addTool(MCTupleToolHierarchy) Tuple.MCTupleToolHierarchy.OutputLevel = outputLevel Tuple.addTool(TupleToolMCTruth) Tuple.TupleToolMCTruth.OutputLevel = outputLevel Tuple.TupleToolMCTruth.addTool(MCTupleToolKinematic()) Tuple.TupleToolMCTruth.addTool(MCTupleToolHierarchy()) Tuple.TupleToolMCTruth.ToolList = [ "MCTupleToolKinematic", "MCTupleToolHierarchy" ] Tuple.TupleToolMCTruth.MCTupleToolKinematic.StoreKineticInfo = True Tuple.TupleToolMCTruth.MCTupleToolKinematic.StoreVertexInfo = True Tuple.TupleToolMCTruth.MCTupleToolKinematic.StorePropertimeInfo = True Tuple.TupleToolMCTruth.MCTupleToolKinematic.OutputLevel = outputLevel Tuple.addTool(TupleToolPid) Tuple.TupleToolPid.OutputLevel = outputLevel Tuple.addTool(TupleToolPrimaries) Tuple.TupleToolPrimaries.OutputLevel = outputLevel Tuple.addTool(TupleToolTrackInfo) Tuple.TupleToolTrackInfo.OutputLevel = outputLevel Tuple.addTool(TupleToolVtxIsoln) Tuple.TupleToolVtxIsoln.OutputLevel = outputLevel seq.Members += [Tuple] Tuple.NTupleLUN = "DSPHIPI" from Configurables import NTupleSvc NTupleSvc().Output = [ "DSPHIPI DATAFILE='DsToPhiPi.root' TYP='ROOT' OPT='NEW'" ]
def execute_option_file(path): # ================= BEGIN EDIT AREA ======================= tuplename = "Bu2LLK_meLine" simulation_inputstring = "/Event/AllStreams/Phys/Bu2LLK_meLine/Particles" data_inputstring = "/Event/Leptonic/Phys/Bu2LLK_meLine/Particles" decaydescriptor = "[B+ -> ^[J/psi(1S) -> ^mu+ ^e-]CC ^K+]CC" branches = { # Dictionary for the branches to write in the tuple "B" : "[B+ -> [J/psi(1S) -> mu+ e-]CC K+]CC", "Psi" : "[B+ -> ^[J/psi(1S) -> mu+ e-]CC K+]CC", "muplus" : "[B+ -> [J/psi(1S) -> ^mu+ e-]CC K+]CC", "eminus" : "[B+ -> [J/psi(1S) -> mu+ ^e-]CC K+]CC", "Kplus" : "[B+ -> [J/psi(1S) -> mu+ mu-]CC ^K+]CC" } #Tools added to the ToolList can not be modified i.e. no other options than the defaults can be used #use data.addTupleTool('<tool>') in the corresponding section below if you also want to modify the specific tool toollist = [ "TupleToolGeometry" #geometry of vertex locations (ENDVERTEX, OWNPV, IP_OWNPV, FD_OWNPV, DIRA_OWNPV) , "TupleToolKinematic" #kinematic variables (inv. mass MM, kin. mass M/sqrt(E^2-p^2), P, PX/Y/Z/E, PT) , "TupleToolEventInfo" #Event information such as run number, polarity, GPS time etc. #, "TupleToolPropertime" #proper lifetime of reconstructed particles , "TupleToolAngles" #decay angles of charged tracks (i.e. angle in mothers frame, name: CosTheta) #, "TupleToolTrigger" #Saves trigger decision (I prefer to use TupleToolTISTOS) , "TupleToolTISTOS" #Trigger on/independent of signal , "TupleToolTrackInfo" #GhostProb of track and track type (TYPE) - 0 = unknown, 1 = velo track... , "TupleToolPrimaries" #Number and coordinates of all primary vertices , "TupleToolDira" #Angle between secondary minus primary vertex and the mother momentum #, "TupleToolTrackPosition" #Extrapolate track to given z-position (option .Z, default=2500. which is TT) , "TupleToolRecoStats" #Fills reconstruction information like nTracks, nSPDHits, nMuonTracks from RecSummary , "TupleToolBremInfo" #Bremsstrahlung information ] # ================= END EDIT AREA ======================= # ================= BEGIN DO NOT EDIT HERE ======================= from Configurables import GaudiSequencer MySequencer = GaudiSequencer('Sequence') #Check whether it is a DST or MDST file import os.path extension = os.path.splitext(path)[1] print extension if extension.lower() == ".dst": DaVinci().InputType = 'DST' elif extension.lower() == ".mdst": DaVinci().InputType = 'MDST' else: raise Exception("Extension {extension} of {path} does not match .mdst or .dst".format(extension, path)) #Kill some nodes if micro dst-file if DaVinci().InputType == 'MDST': from Configurables import EventNodeKiller eventNodeKiller = EventNodeKiller('DAQkiller') eventNodeKiller.Nodes = ['/Event/DAQ','/Event/pRec'] MySequencer.Members+=[eventNodeKiller] #DecayTreeTuple -> Fills information about particles, vertices and daughters ntuple = DecayTreeTuple(tuplename) ntuple.ToolList = toollist if DaVinci().InputType != 'MDST': ntuple.ToolList += ["TupleToolTrackIsolation"] if DaVinci().Simulation is True: ntuple.ToolList +=["TupleToolMCBackgroundInfo"] #Sets the background category MCTruth=ntuple.addTupleTool("TupleToolMCTruth") #Saves information of MC particle associated to the current particle (you can add tools to it itself!) MCTruth.addTupleTool("MCTupleToolHierarchy") #True IDs of mother and grandmother particles if DaVinci().Simulation is True: # for MC ntuple.Inputs = [simulation_inputstring] elif DaVinci().Simulation is False: # for Tuple ntuple.Inputs = [data_inputstring] else: raise Exception(" `DaVinci().Simulation` not set.") ntuple.Decay = decaydescriptor ntuple.addBranches(branches) ntuple.TupleName = "DecayTree" MySequencer.Members.append(ntuple) # ================= END DO NOT EDIT HERE ======================= # ================= BEGIN EDIT TUPLETOOLS WITH OPTIONS ================== # LOKI TupleTool LoKi = ntuple.addTupleTool("LoKi::Hybrid::TupleTool") LoKi.Variables = { "ETA" : "ETA", #Pseudorapidity "PHI" : "PHI" #Azimuthal angle } # PID TupleTool if(True): pid = ntuple.addTupleTool("TupleToolPid") #PID information for charged particles pid.Verbose = True #More information like isMuonLoose etc. #TISTOS TupleTool if(True): from Configurables import TupleToolTISTOS L0Triggers = ["L0MuonDecision", "L0DiMuonDecision", "L0HadronDecision", "L0ElectronDecision", "L0PhotonDecision" ] ## ['Muon', 'DiMuon', ' Hadron', 'Electron', 'Photon','PhotonHi','ElectronHi'] Hlt1Triggers = [ "Hlt1TrackAllL0Decision", "Hlt1TrackMuonDecision" ,"Hlt1TrackPhotonDecision" ,"Hlt1DiMuonLowMassDecision" ,"Hlt1DiMuonHighMassDecision"] Hlt2Triggers = [ ## muon lines "Hlt2SingleMuonDecision", "Hlt2SingleMuonLowPTDecision", "Hlt2SingleMuonHighPTDecision", "Hlt2DiMuonDecision", "Hlt2DiMuonLowMassDecision", "Hlt2DiMuonJPsiDecision", "Hlt2DiMuonJPsiHighPTDecision", "Hlt2DiMuonPsi2SDecision", "Hlt2DiMuonDetachedDecision", "Hlt2DiMuonDetachedJPsiDecision", "Hlt2DiMuonDetachedHeavyDecision", "Hlt2TriMuonTauDecision", ## hadron/Topo lines "Hlt2B2HHDecision", "Hlt2DiMuonBDecision", "Hlt2DiMuonZDecision", "Hlt2TopoMu2BodyBBDTDecision", "Hlt2TopoMu3BodyBBDTDecision", "Hlt2TopoMu4BodyBBDTDecision", "Hlt2TopoE2BodyBBDTDecision", "Hlt2TopoE3BodyBBDTDecision", "Hlt2TopoE4BodyBBDTDecision", "Hlt2Topo2BodyBBDTDecision", "Hlt2Topo3BodyBBDTDecision", "Hlt2Topo4BodyBBDTDecision", ##others "Hlt2PassThroughDecision", "Hlt2TransparentDecision", ## inclusive decisions "Hlt2DiMuonDY.*Decision","Hlt2TopoE.*Decision", "Hlt2Topo.*Decision", "Hlt2Charm.*Decision", "Hlt2DiElectron.*Decision" ] triggerList = L0Triggers + Hlt1Triggers + Hlt2Triggers ntuple.addTool(TupleToolTISTOS) ntuple.TupleToolTISTOS.VerboseL0 = True ntuple.TupleToolTISTOS.VerboseHlt1 = True ntuple.TupleToolTISTOS.VerboseHlt2 = True ntuple.TupleToolTISTOS.FillL0 = True ntuple.TupleToolTISTOS.FillHlt1 = True ntuple.TupleToolTISTOS.FillHlt2 = True ntuple.TupleToolTISTOS.OutputLevel = INFO ntuple.TupleToolTISTOS.TriggerList = triggerList #DecayTreeFitter if(False): fitter = ntuple.B.addTupleTool("TupleToolDecayTreeFitter/FIX_JPSI") fitter.constrainToOriginVertex = False fitter.daughtersToConstrain = [ "J/psi(1S)" ] fitter.Verbose = True #Isolation if(True): from Configurables import TupleToolApplyIsolation ntuple.B.addTupleTool(TupleToolApplyIsolation, name="TupleToolApplyIsolationHard") ntuple.B.TupleToolApplyIsolationHard.OutputSuffix="_Hard" ntuple.B.TupleToolApplyIsolationHard.WeightsFile="weightsHard.xml" #ntuple.B.ToolList+=["TupleToolApplyIsolation/TupleToolApplyIsolationHard"] ntuple.B.addTupleTool(TupleToolApplyIsolation, name="TupleToolApplyIsolationSoft") ntuple.B.TupleToolApplyIsolationSoft.OutputSuffix="_Soft" ntuple.B.TupleToolApplyIsolationSoft.WeightsFile="weightsSoft.xml" #ntuple.B.ToolList+=["TupleToolApplyIsolation/TupleToolApplyIsolationSoft"] ntuple.B.addTupleTool("TupleToolVtxIsoln") #ntuple.B.TupleToolApplyIsolationHard.OutputLevel = 3 #ntuple.B.TupleToolApplyIsolationSoft.OutputLevel = 3 #Settings for TupleToolTrackHits (some only are necessary for MDST-files because of other locations of the clusters) if(True): #Change this value if you don't want to use this tool from Configurables import TupleToolTrackHits, STOfflinePosition trackhits = ntuple.addTupleTool("TupleToolTrackHits") trackhits.Verbose = True if DaVinci().InputType == 'MDST': from Configurables import MeasurementProvider ntuple.addTool(MeasurementProvider('MeasProvider')) ntuple.MeasProvider.RootInTES = "/Event/Leptonic/" #Change Leptonic for your stream-name in case of MDST trackhits.MeasurementProvider = ntuple.MeasProvider itClusterPosition = STOfflinePosition('ToolSvc.ITClusterPosition') #avoid crashes from missing IT channels itClusterPosition.DetType = 'IT' # ================= END EDIT TUPLETOOLS WITH OPTIONS ================== #DDDB and CondDB-Tags for DATA (needs to be set for Simulation in runfile.py according to generation->see bookkeeping!) #Always use the latest tags for the given datatype from (the newest are currently not in the database yet, therefore take the default ones!) """ if DaVinci().Simulation is False: if DaVinci().DataType == '2012': DaVinci().CondDBtag = "dddb-20150522-2" DaVinci().DDDBtag = "cond-20150409-1" elif DaVinci().DataType == '2011': DaVinci().CondDBtag = "dddb-20150522-1" DaVinci().DDDBtag = "cond-20150409" """ ################################ ### DaVinci configuration #### ################################ DaVinci().UserAlgorithms = [MySequencer] DaVinci().MoniSequence += [ntuple] DaVinci().EvtMax = -1 DaVinci().Lumi = True
def __apply_configuration__(self) : from Configurables import ( GaudiSequencer, CombineParticles ) from PhysSelPython.Wrappers import Selection, SelectionSequence, DataOnDemand if not self.isPropertySet("Sequencer") : raise RuntimeError("ERROR : Sequence not set") seq = self.getProp("Sequencer") if self.getProp("RunSelection") : # STD particles from StandardParticles import StdLooseMuons # J/psi -> mu mu JPsiMuMuName = self.__sel_name__ JPsiMuMu = CombineParticles(JPsiMuMuName) JPsiMuMu.DecayDescriptor = "J/psi(1S) -> mu+ mu- " JPsiMuMu.CombinationCut = "(ADAMASS('J/psi(1S)') < 150*MeV)" JPsiMuMu.MotherCut = "(ADMASS('J/psi(1S)') < 130*MeV) & (VFASPF(VCHI2/VDOF)<6) & (PT > 2500*MeV)" JPsiMuMu.DaughtersCuts = {"mu+" : "(PT>1400*MeV)"\ "& (P>5*GeV)"\ "& (TRCHI2DOF<2.0)"\ "& (PPINFO(LHCb.ProtoParticle.MuonBkgLL,-10000)<-2.5)"\ "& (PPINFO(LHCb.ProtoParticle.MuonMuLL,-10000)>-10)"} self.setOptions(JPsiMuMu) JPsiMuMuSel = Selection( JPsiMuMuName+'Sel', Algorithm = JPsiMuMu, RequiredSelections = [StdLooseMuons] ) # Selection Sequence selSeq = SelectionSequence( self.__sel_name__+'Seq', TopSelection = JPsiMuMuSel ) # Run the selection sequence. seq.Members += [selSeq.sequence()] # Particle Monitoring plots if self.getProp("RunMonitors") : from Configurables import ( ParticleMonitor ) plotter = ParticleMonitor(self.__sel_name__+"Plots") if self.getProp("RunSelection") : plotter.Inputs = [ 'Phys/'+self.__sel_name__+'Sel' ] else: musel = "(PT>1400*MeV) & (P>5*GeV) & (TRCHI2DOF<2.0) & "\ "(PPINFO(LHCb.ProtoParticle.MuonBkgLL,-10000)<-2.5) & "\ "(PPINFO(LHCb.ProtoParticle.MuonMuLL,-10000)>-10)" _code = "( ( INTREE( ('mu+'==ID) & "+musel+" ) ) | ( INTREE( ('mu-'==ID) & "+musel+" ) ) )" from Configurables import FilterDesktop filter = FilterDesktop( name = self.__sel_name__+"RICHFiltered", Code = _code, Inputs = self.getProp("Candidates") ) plotter.Inputs = [ 'Phys/'+filter.name() ] seq.Members += [filter] plotter.PeakCut = "(ADMASS('J/psi(1S)')<20*MeV)" # Considering sigma = 13 plotter.SideBandCut = "(ADMASS('J/psi(1S)')>20*MeV)" # Considering sigma = 13 plotter.PlotTools = self.getProp("PlotTools") self.setOptions(plotter) seq.Members += [plotter] # Make a DST ? if self.getProp("MakeSelDST"): # Prescale from Configurables import DeterministicPrescaler scaler = DeterministicPrescaler( self.__sel_name__+'PreScale', AcceptFraction = self.getProp("DSTPreScaleFraction") ) seq.Members += [scaler] # Write the DST MyDSTWriter = SelDSTWriter( self.__sel_name__+"DST", SelectionSequences = [ selSeq ], OutputPrefix = self.__sel_name__ ) seq.Members += [MyDSTWriter.sequence()] # MC Performance checking ? if self.getProp("MCChecks") : from Configurables import ParticleEffPurMoni mcPerf = ParticleEffPurMoni(JPsiMuMuName+"MCPerf") mcPerf.Inputs = ['Phys/'+self.__sel_name__+'Sel'] self.setOptions(mcPerf) seq.Members += [mcPerf] # Ntuple ? if self.getProp("MakeNTuple") : from Configurables import ( DecayTreeTuple, TupleToolDecay, LoKi__Hybrid__FilterCriterion, LoKi__Hybrid__TupleTool, TupleToolMCBackgroundInfo, BackgroundCategory, TupleToolTrigger, TupleToolMCTruth, MCTupleToolKinematic, MCTupleToolHierarchy, TupleToolVtxIsoln, TupleToolP2VV ) JPsiMuMuTree = DecayTreeTuple( JPsiMuMuName + 'Tuple') JPsiMuMuTree.Inputs = [ 'Phys/'+JPsiMuMuName] JPsiMuMuTree.Decay = 'J/psi(1S) -> ^mu+ ^mu- ' # set some names for ntuple branchs MyBranch_jpsi = "jpsi" MyBranch_mup = "mup" MyBranch_mum = "mum" # label the branches for the particle tools JPsiMuMuTree.Branches = { MyBranch_jpsi : "J/psi(1S) : J/psi(1S) -> mu+ mu- ", MyBranch_mup : "J/psi(1S) -> ^mu+ mu- ", MyBranch_mum : "J/psi(1S) -> mu+ ^mu- ", } JPsiMuMuTree.ToolList = [ "TupleToolEventInfo" , "TupleToolGeneration" , "TupleToolMCTruth" , "TupleToolMCBackgroundInfo" , "MCTupleToolKinematic" , "TupleToolPrimaries" , "TupleToolVtxIsoln" , "TupleToolTrackInfo" , "TupleToolPid" , "TupleToolGeometry" , "TupleToolKinematic" , "TupleToolPropertime" , "TupleToolPid" , "TupleToolPrimaries" , "TupleToolTrigger" ] JPsiMuMuTree.addTool(BackgroundCategory()) JPsiMuMuTree.BackgroundCategory.SoftPhotonCut = 2000 JPsiMuMuTree.OutputLevel = INFO JPsiMuMuTree.addTool(TupleToolTrigger()) JPsiMuMuTree.TupleToolTrigger.VerboseL0 = True JPsiMuMuTree.addTool(TupleToolMCTruth()) JPsiMuMuTree.TupleToolMCTruth.addTool(MCTupleToolKinematic()) JPsiMuMuTree.TupleToolMCTruth.addTool(MCTupleToolHierarchy()) JPsiMuMuTree.TupleToolMCTruth.ToolList = [ "MCTupleToolKinematic" , "MCTupleToolHierarchy" ] JPsiMuMuTree.TupleToolMCTruth.MCTupleToolKinematic.StoreKineticInfo = True JPsiMuMuTree.TupleToolMCTruth.MCTupleToolKinematic.StoreVertexInfo = True JPsiMuMuTree.TupleToolMCTruth.MCTupleToolKinematic.StorePropertimeInfo = False JPsiMuMuTree.addTool(TupleToolVtxIsoln( OutputLevel = 6 )) JPsiMuMuTree.TupleToolVtxIsoln.IP = 2.0 JPsiMuMuTree.TupleToolVtxIsoln.InputParticles = [ "Phys/StdLooseMuons"] seq.Members += [JPsiMuMuTree] JPsiMuMuTree.NTupleLUN = "JPSIMUMU" from Configurables import NTupleSvc NTupleSvc().Output = ["JPSIMUMU DATAFILE='JpsiMuMu_Presel.root' TYP='ROOT' OPT='NEW'"]
def ConfigureTuples(): from JetAccessoriesMC.ConfigurationHelpers import ConfigureDoD tables = ConfigureDoD() from Configurables import TupleToolJetRelations, DecayTreeTuple HepMCAllJetTuple = DecayTreeTuple("HepMCAllJetTuple") HepMCAllJetTuple.InputLocations = ['Phys/StdHepMCAllJets/Particles'] HepMCAllJetTuple.Decay = "CELLjet" HepMCAllJetTuple.ToolList = [ 'TupleToolKinematic', 'TupleToolEventInfo', 'LoKi__Hybrid__TupleTool/LoKiTool' ] from JetAccessoriesMC.ConfigurationHelpers import addRelationTuple addRelationTuple(HepMCAllJetTuple, tables['StdHepMCAllJetsPartonic'], InvertTable=True, ReverseMatching=True) addRelationTuple(HepMCAllJetTuple, tables['StdHepMCAllJetsPartonic'], InvertTable=True, ReverseMatching=False) addRelationTuple(HepMCAllJetTuple, tables['StdHepMCJets2StdJetsDeltaR'], InvertTable=False, ReverseMatching=True, extraName='DeltaR') addRelationTuple(HepMCAllJetTuple, tables['StdHepMCJets2StdJetsDeltaR'], InvertTable=False, ReverseMatching=False, extraName='DeltaR') addRelationTuple(HepMCAllJetTuple, tables['StdHepMCAllJets2StdJetsmeasured'], InvertTable=False, ReverseMatching=True) addRelationTuple(HepMCAllJetTuple, tables['StdHepMCAllJets2StdJetsmeasured'], InvertTable=False, ReverseMatching=False) addRelationTuple(HepMCAllJetTuple, tables['StdHepMCAllJets2StdJetsMCtrue'], InvertTable=False, ReverseMatching=True) addRelationTuple(HepMCAllJetTuple, tables['StdHepMCAllJets2StdJetsMCtrue'], InvertTable=False, ReverseMatching=False) from Configurables import LoKi__Hybrid__TupleTool LoKiTool = LoKi__Hybrid__TupleTool('LoKiTool') LoKiTool.Variables = {"ETA": "ETA", "PHI": "PHI", "Y": "Y"} HepMCAllJetTuple.addTool(LoKiTool) DaVinci().UserAlgorithms += [HepMCAllJetTuple] HepMCJetTuple = DecayTreeTuple("HepMCJetTuple") #,OutputLevel = VERBOSE) HepMCJetTuple.InputLocations = ['Phys/StdHepMCJets/Particles'] HepMCJetTuple.Decay = "CELLjet" HepMCJetTuple.ToolList = [ 'TupleToolKinematic', 'TupleToolEventInfo', 'LoKi__Hybrid__TupleTool/LoKiTool' ] addRelationTuple(HepMCJetTuple, tables['StdHepMCJets2StdJetsmeasured'], InvertTable=False, ReverseMatching=True, extraName='Measured') HepMCJetTuple.StdHepMCJets2StdJetsRevMeasured.ExtraWeights = { 'OverlapMeasured': tables['StdHepMCJets2StdJetsmeasured'].OutputTable, 'OverlapMCtrue': tables['StdHepMCJets2StdJetsMCtrue'].OutputTable } addRelationTuple(HepMCJetTuple, tables['StdHepMCJets2StdJetsMCtrue'], InvertTable=False, ReverseMatching=True, extraName='MCtrue') HepMCJetTuple.StdHepMCJets2StdJetsRevMCtrue.ExtraWeights = { 'OverlapMeasured': tables['StdHepMCJets2StdJetsmeasured'].OutputTable, 'OverlapMCtrue': tables['StdHepMCJets2StdJetsMCtrue'].OutputTable } addRelationTuple(HepMCJetTuple, tables['StdHepMCJets2StdJetsDeltaR'], InvertTable=False, ReverseMatching=False, extraName='DeltaR') HepMCJetTuple.StdHepMCJets2StdJetsDeltaR.ExtraWeights = { 'OverlapMeasured': tables['StdHepMCJets2StdJetsmeasured'].OutputTable, 'OverlapMCtrue': tables['StdHepMCJets2StdJetsMCtrue'].OutputTable } HepMCJetTuple.addTool(LoKiTool) DaVinci().UserAlgorithms += [HepMCJetTuple]
DaVinci().DDDBtag = "dddb-20170721-3" DaVinci().CondDBtag = "sim-20170721-2-vc-md100" ##### BASE DTT ########## from Configurables import DecayTreeTuple from DecayTreeTuple.Configuration import * dtt = DecayTreeTuple("BaseTuple") dtt.ToolList = ["TupleToolEventInfo", "TupleToolPrimaries", "TupleToolRecoStats", "TupleToolCPU", "TupleToolKinematic", "TupleToolPid", "TupleToolAngles", "TupleToolDira", "TupleToolL0Data", "TupleToolDalitz", "TupleToolPhotonInfo", "TupleToolParticleStats", "TupleToolCaloHypo", # MC tuple tools 'TupleToolMCTruth', 'MCTupleToolEventType', 'MCTupleToolPrimaries', 'TupleToolMCBackgroundInfo'] # verbose TupleTools dtt_geo = dtt.addTupleTool("TupleToolGeometry") dtt_geo.Verbose = True dtt_trk = dtt.addTupleTool("TupleToolTrackInfo") dtt_trk.Verbose = True
"DTF_CTAUS" : "DTF_CTAUSIGNIFICANCE( 0, True )", "DTF_CHI2NDOF" : "DTF_CHI2NDOF( True )", "DTF_CTAUERR" : "DTF_CTAUERR( 0, True )", "DTF_MASS_constr1" : "DTF_FUN ( M , True , strings(['J/psi(1S)']) )" , "DTF_MASS_constr2" : "DTF_FUN ( M , True , strings(['psi(2S)']) )" , "DTF_VCHI2NDOF" : "DTF_FUN ( VFASPF(VCHI2/VDOF) , True )", } LoKi_Mu = LoKi__Hybrid__TupleTool("LoKi_Mu") LoKi_Mu.Variables = { "NSHAREDMU" : "NSHAREDMU" # this apparently no longer exists or runs } tuple_B2psiomega = DecayTreeTuple("Tuple") tuple_B2psiomega.Inputs = [ location ] tuple_B2psiomega.ToolList = tupletools[:] # tuple_B2psiomega.Decay = '[B0 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^(omega(782) -> ^pi+ ^pi- ^(pi0 -> ^gamma ^gamma ) )]CC' tuple_B2psiomega.Decay = '[B0 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^(omega(782) -> ^pi+ ^pi- ^pi0 )]CC' tuple_B2psiomega.Branches = { # 'B' : "[ B0 --> (J/psi(1S) -> mu+ mu- ...) (omega(782) -> pi+ pi- (pi0 -> gamma gamma ) ) ]CC", # 'Jpsi' : "[ B0 --> ^(J/psi(1S) -> mu+ mu- ...) (omega(782) -> pi+ pi- (pi0 -> gamma gamma ) ) ]CC", # 'muplus' : "[ B0 --> (J/psi(1S) -> ^mu+ mu- ...) (omega(782) -> pi+ pi- (pi0 -> gamma gamma ) ) ]CC", # 'muminus' : "[ B0 --> (J/psi(1S) -> mu+ ^mu- ...) (omega(782) -> pi+ pi- (pi0 -> gamma gamma ) ) ]CC", # 'omega' : "[ B0 --> (J/psi(1S) -> mu+ mu- ...) ^(omega(782) -> pi+ pi- (pi0 -> gamma gamma ) ) ]CC", # 'piplus' : "[ B0 --> (J/psi(1S) -> mu+ mu- ...) (omega(782) -> ^pi+ pi- (pi0 -> gamma gamma ) ) ]CC", # 'piminus' : "[ B0 --> (J/psi(1S) -> mu+ mu- ...) (omega(782) -> pi+ ^pi- (pi0 -> gamma gamma ) ) ]CC", # 'pizero' : "[ B0 --> (J/psi(1S) -> mu+ mu- ...) (omega(782) -> pi+ pi- ^(pi0 -> gamma gamma ) ) ]CC", # 'gamma1' : "[ B0 --> (J/psi(1S) -> mu+ mu- ...) (omega(782) -> pi+ pi- (pi0 -> ^gamma gamma ) ) ]CC", # 'gamma2' : "[ B0 --> (J/psi(1S) -> mu+ mu- ...) (omega(782) -> pi+ pi- (pi0 -> gamma ^gamma ) ) ]CC", # 'B' : "[ B0 --> (J/psi(1S) -> mu+ mu- ...) (omega(782) -> pi+ pi- pi0 ) ]CC",
inclmumu = Selection ("Sel"+name, Algorithm = stripfilter, RequiredSelections = [stripsel]) seq = SelectionSequence("seq", TopSelection = inclmumu) tuple = DecayTreeTuple("Incl_Tuple") tuple.Inputs = [stripsel.outputLocation()] tuple.ToolList = [ "TupleToolKinematic" , "TupleToolEventInfo" , "TupleToolRecoStats" , "TupleToolMCBackgroundInfo" , "TupleToolGeometry" , "TupleToolPid" , "TupleToolPropertime" , "TupleToolPrimaries" , "TupleToolTrackInfo" ] MCtruth = tuple.addTupleTool("TupleToolMCTruth") MCtruth.addTupleTool("LoKi::Hybrid::MCTupleTool/LoKi_Photos").Variables = { "nPhotons" : "MCNINTREE(('gamma' == MCABSID))", "photons_TRUEP_X" : "MCSUMTREE(MCPX,('gamma' == MCABSID))", "photons_TRUEP_Y" : "MCSUMTREE(MCPY,('gamma' == MCABSID))", "photons_TRUEP_Z" : "MCSUMTREE(MCPZ,('gamma' == MCABSID))", "photons_TRUEP_E" : "MCSUMTREE(MCE,('gamma'==MCABSID))" } tuple.addBranches ({
tupleB.Inputs = [SeqB.outputLocation()] tupleB.Decay = "[B+ -> ^(J/psi(1S) -> ^mu+ ^mu-) ^K+]CC" tupleB.ToolList = [ "TupleToolKinematic", "TupleToolEventInfo", "TupleToolRecoStats", "TupleToolMCBackgroundInfo", "TupleToolMCBackgroundInfo", #comment out for data "TupleToolMCTruth", #comment out for data "TupleToolTrigger", "TupleToolPid", "TupleToolPrimaries", "TupleToolAngles", "TupleToolEventInfo", "TupleToolGeometry", "TupleToolKinematic", "TupleToolPropertime", "TupleToolRecoStats", "TupleToolTrackInfo", "TupleToolTISTOS", "TupleToolBremInfo", "TupleToolPhotonInfo" #, , "TupleToolTrackIsolation", "TupleToolANNPID" ] # Probably need to add many more Tools. tupleB.addBranches({ "Kplus": "[B+ -> ^K+ (J/psi(1S) -> mu+ mu-)]CC", "Jpsi": "[B+ -> K+ ^(J/psi(1S) -> mu+ mu-)]CC",
TupleToolRecoStats, TupleToolMCTruth, LoKi__Hybrid__TupleTool, LoKi__Hybrid__EvtTupleTool, ) tuple = DecayTreeTuple("TupleJPsi2KsKs") # Give DecayTreeTuple the location of your stripped candidates # If you apply a selection, this will be the output of a selection sequence object. tuple.Inputs = [seq.outputLocation()] tuple.ToolList = [ "TupleToolKinematic", "TupleToolEventInfo", "TupleToolTrackInfo", "TupleToolPid", "TupleToolGeometry", "TupleToolAngles", ] tuple.InputPrimaryVertices = "/Event/Charm/Rec/Vertex/Primary" # # Other event infos tuple.addTupleTool("LoKi::Hybrid::EvtTupleTool/LoKi_Evt") tuple.LoKi_Evt.VOID_Variables = { "nTracks": "CONTAINS('/Event/Charm/Rec/Track/Best')", "nPVs": "CONTAINS('/Event/Charm/Rec/Vertex/Primary')", }
from GaudiKernel.SystemOfUnits import MeV, GeV, cm, mm from Configurables import DecayTreeTuple, FitDecayTrees, TupleToolRecoStats, TupleToolTrigger, TupleToolSubMass from Configurables import TupleToolTISTOS, CondDB, SelDSTWriter from Configurables import TupleToolTrackInfo, TupleToolRICHPid, TupleToolGeometry, TupleToolPid from Configurables import TupleToolANNPID from Configurables import TupleToolSLTruth from Configurables import TupleToolTauMuDiscrVarsLcMassConstraint from DecayTreeTuple.Configuration import * tupleB = DecayTreeTuple("tupleout") tupleB.Inputs = ["/Event/Semileptonic/Phys/b2LcMuXB2DMuForTauMuLine/Particles"] tupleB.Decay = "[B+ -> ^(Lambda_c+ -> ^p+ ^K- ^pi+) ^mu+]CC" tupleB.ToolList = [ "TupleToolKinematic", "TupleToolEventInfo", "TupleToolRecoStats" #, "TupleToolGeometry" #,"TupleToolSLTruth" ] # Probably need to add many more Tools. tupleB.addBranches({ "Lb": "[B+ -> (Lambda_c+ -> p+ K- pi+) mu+]CC", "Lc": "[B+ -> ^Lambda_c+ mu+]CC", "p": "[B+ -> (Lambda_c+ -> ^p+ K- pi+) mu+]CC", "pi": "[B+ -> (Lambda_c+ -> p+ K- ^pi+) mu+]CC", "K": "[B+ -> (Lambda_c+ -> p+ ^K- pi+) mu+]CC", "mu": "[B+ -> (Lambda_c+ -> p+ K- pi+) ^mu+]CC" }) l0_lines = ['L0HadronDecision', 'L0MuonDecision', 'L0ElectronDecision'] hlt1_lines = ['Hlt1TrackMVADecision', 'Hlt1TwoTrackMVADecision']
LoKi_psi = LoKi__Hybrid__TupleTool("LoKi_psi") LoKi_psi.Variables = { "q_PV_constr_B_constr" : "DTF_FUN ( M , True , 'B+' )" , "q_PV_constr" : "DTF_FUN ( M , True )" , "q_B_constr" : "DTF_FUN ( M , False , 'B+' )" , "q_no_constr" : "DTF_FUN ( M , False )" , } LoKi_Mu = LoKi__Hybrid__TupleTool("LoKi_Mu") LoKi_Mu.Variables = { "NSHAREDMU" : "NSHAREDMU" } tuple_B2Kmumu = DecayTreeTuple("Tuple_B2Kmumu") tuple_B2Kmumu.Inputs = [ location ] tuple_B2Kmumu.ToolList = tupletools[:] tuple_B2Kmumu.Decay = '[B+ -> ^(J/psi(1S) -> ^mu+ ^mu-) ^K+]CC' tuple_B2Kmumu.Branches = { "B" : "[B+ -> (J/psi(1S) -> mu+ mu-) K+]CC", "Kplus" : "[B+ -> (J/psi(1S) -> mu+ mu-) ^K+]CC", "psi" : "[B+ -> ^(J/psi(1S) -> mu+ mu-) K+]CC", "muplus" : "[B+ -> (J/psi(1S) -> ^mu+ mu-) K+]CC", "muminus": "[B+ -> (J/psi(1S) -> mu+ ^mu-) K+]CC", } for particle in ["B", "Kplus", "psi", "muplus", "muminus"]: tuple_B2Kmumu.addTool(TupleToolDecay, name = particle) # List of the reconstructed tuples tuples = [ tuple_B2Kmumu ]
print "stripOutputLoc:",stripOutputLoc from DecayTreeTuple.Configuration import * dttuple = DecayTreeTuple( "DPiPiPi_NTuple" ) dttuple.ToolList = ["TupleToolGeometry", "TupleToolEventInfo", "TupleToolKinematic", "TupleToolPrimaries", "TupleToolPropertime", "TupleToolAngles", "TupleToolPid", "TupleToolRICHPid", "TupleToolDecay", "TupleToolTrigger", "TupleToolTISTOS", "TupleToolTrackInfo", "TupleToolRecoStats", "TupleToolDira", "TupleToolDalitz", "TupleToolSubMass", ] dttuple.Inputs = [ stripOutputLoc ] print "tuple input :",dttuple.Inputs print "number of events:", DaVinci().EvtMax a = "->"
def execute_option_file(path): # ================= BEGIN EDIT AREA ======================= tuplename = "Bu2LLK_meLine" simulation_inputstring = "/Event/AllStreams/Phys/Bu2LLK_meLine/Particles" data_inputstring = "/Event/Leptonic/Phys/Bu2LLK_meLine/Particles" decaydescriptor = "[B+ -> ^[J/psi(1S) -> ^mu+ ^e-]CC ^K+]CC" branches = { # Dictionary for the branches to write in the tuple "B" : "[B+ -> [J/psi(1S) -> mu+ e-]CC K+]CC", "Psi" : "[B+ -> ^[J/psi(1S) -> mu+ e-]CC K+]CC", "muplus" : "[B+ -> [J/psi(1S) -> ^mu+ e-]CC K+]CC", "eminus" : "[B+ -> [J/psi(1S) -> mu+ ^e-]CC K+]CC", "Kplus" : "[B+ -> [J/psi(1S) -> mu+ mu-]CC ^K+]CC" } toollist = [ "TupleToolBremInfo" #Bremsstrahlung information #, "TupleToolGeometry" #geometry of vertex locations (ENDVERTEX, OWNPV, IP_OWNPV, FD_OWNPV, DIRA_OWNPV) , "TupleToolKinematic" #kinematic variables (inv. mass MM, kin. mass M/sqrt(E^2-p^2), P, PX/Y/Z/E, PT) #, "TupleToolEventInfo" #Event information such as run number, polarity, GPS time etc. #, "TupleToolPropertime" #proper lifetime of reconstructed particles #, "TupleToolAngles" #decay angles of charged tracks #, "TupleToolTrigger" #, "TupleToolTrackInfo" #GhostProb of track and track type (TYPE) - 0 = unknown, 1 = velo track... #, "TupleToolPrimaries" #Number and coordinates of all primary vertices #, "TupleToolDira" #, "TupleToolTrackPosition" #Plot the X/Y position at a given Z (default: 2500 = TTstation) #, "TupleToolRecoStats" #, "TupleToolIsolationTwoBody" #degree of isolation of two particles with common mother from Bsmumu #, "TupleToolANNPID" #V2,V3,... ProbNN variables #, "TupleToolCaloHypo" #, "TupleToolL0Calo" ] # ================= END EDIT AREA ======================= # ================= BEGIN DO NOT EDIT HERE ======================= from Configurables import GaudiSequencer MySequencer = GaudiSequencer('Sequence') #Check whether it is a DST or MDST file import os.path extension = os.path.splitext(path)[1] print extension if extension.lower() == ".dst": DaVinci().InputType = 'DST' elif extension.lower() == ".mdst": DaVinci().InputType = 'MDST' else: raise Exception("Extension {extension} of {path} does not match .mdst or .dst".format(extension, path)) #Kill some nodes if micro dst-file if DaVinci().InputType == 'MDST': from Configurables import EventNodeKiller eventNodeKiller = EventNodeKiller('DAQkiller') eventNodeKiller.Nodes = ['/Event/DAQ','/Event/pRec'] MySequencer.Members+=[eventNodeKiller] #DecayTreeTuple -> Fills information about particles, vertices and daughters ntuple = DecayTreeTuple(tuplename) if DaVinci().Simulation is True: # for MC ntuple.Inputs = [simulation_inputstring] elif DaVinci().Simulation is False: # for Tuple ntuple.Inputs = [data_inputstring] else: raise Exception(" `DaVinci().Simulation` not set.") ntuple.Decay = decaydescriptor ntuple.addBranches(branches) ntuple.TupleName = "DecayTree" #Tools added to the ToolList can not be modified i.e. no other options than the defaults can be used ntuple.ToolList = toollist MySequencer.Members.append(ntuple) # ================= END DO NOT EDIT HERE ======================= if DaVinci().Simulation is True: from Configurables import BackgroundCategory backgroundinfo = ntuple.addTupleTool("TupleToolMCBackgroundInfo") #Fills the background category backgroundinfo.addTool(BackgroundCategory('BackgroundCategory')) backgroundinfo.BackgroundCategory.SoftPhotonCut = 100000000000. #Ignores all photons MCTruth=ntuple.addTupleTool("TupleToolMCTruth") #Saves information of MC particle associated to the current particle (you can add tools to it itself!) MCTruth.addTupleTool("MCTupleToolHierarchy") #True IDs of mother and grandmother particles # ================= BEGIN EDIT TUPLETOOLS WITH OPTIONS ================== # LOKI TupleTool LoKi = ntuple.addTupleTool("LoKi::Hybrid::TupleTool") LoKi.Variables = { "ETA" : "ETA", "PHI" : "PHI" #Azimuthal angle } #Track isolation if(False): if DaVinci().InputType != 'MDST': ntuple.ToolList += ["TupleToolTrackIsolation"] # PID TupleTool if(True): pid = ntuple.addTupleTool("TupleToolPid") #PID information for charged particles pid.Verbose = True #More information like isMuonLoose etc. #TISTOS TupleTool if(False): from Configurables import TupleToolTISTOS L0Triggers = ["L0MuonDecision", "L0DiMuonDecision", "L0HadronDecision", "L0ElectronDecision", "L0PhotonDecision" ] ## ['Muon', 'DiMuon', ' Hadron', 'Electron', 'Photon','PhotonHi','ElectronHi'] Hlt1Triggers = [ "Hlt1TrackAllL0Decision", "Hlt1TrackMuonDecision" ,"Hlt1TrackPhotonDecision" ,"Hlt1DiMuonLowMassDecision" ,"Hlt1DiMuonHighMassDecision"] Hlt2Triggers = [ ## muon lines "Hlt2SingleMuonDecision", "Hlt2SingleMuonLowPTDecision", "Hlt2SingleMuonHighPTDecision", "Hlt2DiMuonDecision", "Hlt2DiMuonLowMassDecision", "Hlt2DiMuonJPsiDecision", "Hlt2DiMuonJPsiHighPTDecision", "Hlt2DiMuonPsi2SDecision", "Hlt2DiMuonDetachedDecision", "Hlt2DiMuonDetachedJPsiDecision", "Hlt2DiMuonDetachedHeavyDecision", "Hlt2TriMuonTauDecision", ## hadron/Topo lines "Hlt2B2HHDecision", "Hlt2DiMuonBDecision", "Hlt2DiMuonZDecision", "Hlt2TopoMu2BodyBBDTDecision", "Hlt2TopoMu3BodyBBDTDecision", "Hlt2TopoMu4BodyBBDTDecision", "Hlt2TopoE2BodyBBDTDecision", "Hlt2TopoE3BodyBBDTDecision", "Hlt2TopoE4BodyBBDTDecision", "Hlt2Topo2BodyBBDTDecision", "Hlt2Topo3BodyBBDTDecision", "Hlt2Topo4BodyBBDTDecision", ##others "Hlt2PassThroughDecision", "Hlt2TransparentDecision", ## inclusive decisions "Hlt2DiMuonDY.*Decision","Hlt2TopoE.*Decision", "Hlt2Topo.*Decision", "Hlt2Charm.*Decision", "Hlt2DiElectron.*Decision" ] triggerList = L0Triggers + Hlt1Triggers + Hlt2Triggers ntuple.addTupleTool("TupleToolTISTOS") ntuple.TupleToolTISTOS.VerboseL0 = True ntuple.TupleToolTISTOS.VerboseHlt1 = True ntuple.TupleToolTISTOS.VerboseHlt2 = True ntuple.TupleToolTISTOS.FillL0 = True ntuple.TupleToolTISTOS.FillHlt1 = True ntuple.TupleToolTISTOS.FillHlt2 = True ntuple.TupleToolTISTOS.OutputLevel = INFO ntuple.TupleToolTISTOS.TriggerList = triggerList #DecayTreeFitter if(False): fitter = ntuple.B.addTupleTool("TupleToolDecayTreeFitter/FIX_JPSI") fitter.constrainToOriginVertex = False fitter.daughtersToConstrain = [ "J/psi(1S)" ] fitter.Verbose = True #Isolation tool from Alex weightsfolder = "./" if(False): from Configurables import TupleToolApplyIsolation ntuple.B.addTupleTool(TupleToolApplyIsolation, name="TupleToolApplyIsolationHard") ntuple.B.TupleToolApplyIsolationHard.OutputSuffix="_Hard" ntuple.B.TupleToolApplyIsolationHard.WeightsFile= weightsfolder+"weightsHard.xml" ntuple.B.addTupleTool(TupleToolApplyIsolation, name="TupleToolApplyIsolationSoft") ntuple.B.TupleToolApplyIsolationSoft.OutputSuffix="_Soft" ntuple.B.TupleToolApplyIsolationSoft.WeightsFile= weightsfolder+"weightsSoft.xml" ntuple.B.addTupleTool("TupleToolVtxIsoln") #ntuple.B.TupleToolApplyIsolationHard.OutputLevel = 3 #ntuple.B.TupleToolApplyIsolationSoft.OutputLevel = 3 #Tool from B2ee if(False): from Configurables import TupleToolMuonVariables ntuple.addTupleTool("TupleToolMuonVariables") if DaVinci().InputType == 'MDST': ntuple.TupleToolMuonVariables.TrackContainer = "/Event/Leptonic/Rec/Track/Best" #Change in case of MDST! ntuple.TupleToolMuonVariables.BDTSRootFile = weightsfolder+"HflatBDTS_7Dec.root" ntuple.TupleToolMuonVariables.BDTSXMLFile = weightsfolder+"TMVA_7Dec.weights.xml" #Settings for TupleToolTrackHits (some only are necessary for MDST-files because of other locations of the clusters) if(True): #Change this value if you don't want to use this tool from Configurables import TupleToolTrackHits, STOfflinePosition trackhits = ntuple.addTupleTool("TupleToolTrackHits") trackhits.Verbose = True if DaVinci().InputType == 'MDST': from Configurables import MeasurementProvider ntuple.addTool(MeasurementProvider('MeasProvider')) ntuple.MeasProvider.RootInTES = "/Event/Leptonic/" #Change Leptonic for your stream-name in case of MDST trackhits.MeasurementProvider = ntuple.MeasProvider itClusterPosition = STOfflinePosition('ToolSvc.ITClusterPosition') #avoid crashes from missing IT channels itClusterPosition.DetType = 'IT' #Settings for TupleToolAllPhotons (only works for fullDST files) #Should be always added to only one branch if(DaVinci().InputType == 'DST'): if(True): from Configurables import TupleToolAllPhotons, STOfflinePosition allphotons = ntuple.eminus.addTupleTool("TupleToolAllPhotons") allphotons.MCTruth = True allphotons.PhotonsLocation = "/Event/Phys/StdVeryLooseAllPhotons/Particles" itClusterPosition = STOfflinePosition('ToolSvc.ITClusterPosition') #avoid crashes from missing IT channels itClusterPosition.DetType = 'IT' #allphotons.PhotonsLocation = "/Event/Phys/StdLooseAllPhotons/Particles" #Settings for TupleToolBremRemover #Should be always added to specific branches if(True): from Configurables import TupleToolBremRemover bremremover = ntuple.eminus.addTupleTool("TupleToolBremRemover") if DaVinci().Simulation is True: bremremover.TRUEP = True #TupleToolTrackKink: Refits the track and outputs kink as point with highest Chi2 variation (should be run last because of the refit) if(False): ntuple.eminus.addTupleTool("TupleToolTrackKink") # ================= END EDIT TUPLETOOLS WITH OPTIONS ================== ################################ ### DaVinci configuration #### ################################ DaVinci().UserAlgorithms = [MySequencer] DaVinci().MoniSequence += [ntuple] DaVinci().EvtMax = -1 DaVinci().SkipEvents = 0 DaVinci().Lumi = True
def makeTuple(self): """ Make tuple """ from Configurables import ( FitDecayTrees, DecayTreeTuple, TupleToolDecayTreeFitter, TupleToolDecay, TupleToolTrigger, TupleToolTISTOS, TupleToolPropertime, PropertimeFitter, TupleToolKinematic, TupleToolGeometry, TupleToolEventInfo, TupleToolPrimaries, TupleToolPid, TupleToolTrackInfo, TupleToolRecoStats, TupleToolMCTruth, LoKi__Hybrid__TupleTool, LoKi__Hybrid__EvtTupleTool, ) tuple = DecayTreeTuple( "Tuple" + self.name ) # I can put as an argument a name if I use more than a DecayTreeTuple tuple.Inputs = [self.sequence.outputLocation()] tuple.Decay = self.dec tuple.ToolList = [ "TupleToolKinematic", "TupleToolEventInfo", "TupleToolTrackInfo", "TupleToolPid", "TupleToolGeometry", "TupleToolAngles", # Helicity angle # 'TupleToolPropertime', #proper time TAU of reco particles ] # Other event infos tuple.addTupleTool("LoKi::Hybrid::EvtTupleTool/LoKi_Evt") if dataSample.isMC: tuple.LoKi_Evt.VOID_Variables = { # "nSPDHits" : " CONTAINS('Raw/Spd/Digits') " , "nTracks": "TrSOURCE('Rec/Track/Best') >> TrSIZE", "nPVs": "CONTAINS('Rec/Vertex/Primary')", } else: tuple.LoKi_Evt.VOID_Variables = { # "nSPDHits" : " CONTAINS('Raw/Spd/Digits') " , "nTracks": "CONTAINS('/Event/Charm/Rec/Track/Best')", "nPVs": "CONTAINS('/Event/Charm/Rec/Vertex/Primary')", } # # Other variables # tuple.addTupleTool('LoKi::Hybrid::TupleTool/LoKi_All') # tuple.LoKi_All.Variables = { # 'BPVIPCHI2' : 'BPVIPCHI2()', # 'BPVDIRA' : 'BPVDIRA', # 'BPVLTFITCHI2' : 'BPVLTFITCHI2()', # } tuple.addBranches(self.branches) tuple.phi.addTupleTool("LoKi::Hybrid::TupleTool/LoKi_phi") tuple.phi.LoKi_phi.Variables = { "DOCAMAX": "DOCAMAX", "MassDiff_Phi": "DMASS('phi(1020)')", "BPVDIRA": "BPVDIRA", "IPS_Phi": "MIPCHI2DV(PRIMARY)", "VFASPF_CHI2DOF": "VFASPF(VCHI2/VDOF)", "VFASPF_CHI2": "VFASPF(VCHI2)", "BPVIPCHI2": "BPVIPCHI2()", "ADOCA": "DOCA(1,2)", "ADOCACHI2": "DOCACHI2(1,2)", "DTF_CTAU_Ks1": "DTF_CTAU(1, True, strings('KS0') )", "DTF_CTAU_Ks2": "DTF_CTAU(2, True, strings('KS0') )", "DTF_DT": "DTF_CTAU(1, True, strings('KS0') )- DTF_CTAU(2, True, strings('KS0') )", "DTF_ADT": "abs(DTF_CTAU(1, True, strings('KS0') )- DTF_CTAU(2, True, strings('KS0') ))", } def mySharedConf_Ks(branch): atool = branch.addTupleTool("LoKi::Hybrid::TupleTool/LoKi_Ks") atool.Variables = { "BPVDIRA": "BPVDIRA", "VFASPF_CHI2DOF": "VFASPF(VCHI2/VDOF)", "VFASPF_CHI2": "VFASPF(VCHI2)", "BPVIPCHI2": "BPVIPCHI2()", "BPVVD": "BPVVD", "BPVVDCHI2": "BPVVDCHI2", "ADOCA": "DOCA(1,2)", "ADOCACHI2": "DOCACHI2(1,2)", "BPVLTIME": "BPVLTIME()", } PropertimeTool = branch.addTupleTool("TupleToolPropertime/Propertime_Ks") mySharedConf_Ks(tuple.Ks1) mySharedConf_Ks(tuple.Ks2) def mySharedConf_pi(branch): atool = branch.addTupleTool("LoKi::Hybrid::TupleTool/LoKi_pi") atool.Variables = {"TRCHI2DOF": "TRCHI2DOF", "TRGHOSTPROB": "TRGHOSTPROB"} mySharedConf_pi(tuple.pi1) mySharedConf_pi(tuple.pi2) mySharedConf_pi(tuple.pi3) mySharedConf_pi(tuple.pi4) # Triggers: tuple.phi.addTupleTool("TupleToolTISTOS/TISTOS") tuple.phi.TISTOS.TriggerList = trigger_list tuple.phi.TISTOS.VerboseL0 = True tuple.phi.TISTOS.VerboseHlt1 = True tuple.phi.TISTOS.VerboseHlt2 = True if dataSample.isMC: from Configurables import ( MCDecayTreeTuple, MCTupleToolKinematic, TupleToolMCTruth, MCTupleToolHierarchy, MCTupleToolReconstructed, MCTupleToolAngles, TupleToolMCBackgroundInfo, ) tuple.addTupleTool("TupleToolMCTruth/MCTruth") tuple.MCTruth.ToolList = [ "MCTupleToolKinematic", "MCTupleToolHierarchy", "MCTupleToolReconstructed", "MCTupleToolAngles", ] tuple.phi.addTupleTool("TupleToolMCBackgroundInfo") self.sequence.sequence().Members += [tuple]
tupleB.Decay = decay tupleB.ToolList = [ "TupleToolKinematic" , "TupleToolEventInfo" , "TupleToolRecoStats" ,"TupleToolMCBackgroundInfo",#comment out for data "TupleToolMCTruth", #comment out for data "TupleToolTrigger", "TupleToolPid", "TupleToolPrimaries", "TupleToolAngles", "TupleToolEventInfo", "TupleToolGeometry", "TupleToolKinematic", "TupleToolPropertime", "TupleToolRecoStats", "TupleToolTrackInfo", "TupleToolTISTOS", "TupleToolBremInfo", "TupleToolPhotonInfo"#, ,"TupleToolTrackIsolation" , "TupleToolANNPID" ] # Probably need to add many more Tools.
def execute_option_file(path): from Configurables import GaudiSequencer MySequencer = GaudiSequencer('Sequence') #Check whether it is a DST or MDST file import os.path extension = os.path.splitext(path)[1] print extension if extension.lower() == ".dst": DaVinci().InputType = 'DST' elif extension.lower() == ".mdst": DaVinci().InputType = 'MDST' else: raise Exception("Extension {extension} of {path} does not match .mdst or .dst".format(extension, path)) #Kill some nodes if micro dst-file if DaVinci().InputType == 'MDST': from Configurables import EventNodeKiller eventNodeKiller = EventNodeKiller('DAQkiller') eventNodeKiller.Nodes = ['/Event/DAQ','/Event/pRec'] MySequencer.Members+=[eventNodeKiller] #Create DecayTreeTuple -> Fills information about particles, vertices and daughters data = DecayTreeTuple('Bu2LLK_meLine') #Set root "folder" for MDST - better don't do this as it most likely causes a crash #Instead set RootInTES for the particular Tool (e.g. TupleToolTrackHits that needs it) #if DaVinci().InputType == 'MDST': # data.RootInTES = "/Event/Leptonic" if DaVinci().Simulation is True: # for MC data.Inputs = ["/Event/AllStreams/Phys/Bu2LLK_meLine/Particles"] elif DaVinci().Simulation is False: # for Tuple data.Inputs = ["/Event/Leptonic/Phys/Bu2LLK_meLine/Particles"] else: raise Exception(" `DaVinci().Simulation` not set.") data.Decay = "[B+ -> ^[J/psi(1S) -> ^mu+ ^e-]CC ^K+]CC" data.addBranches({ "B" : "[B+ -> [J/psi(1S) -> mu+ e-]CC K+]CC", "Psi" : "[B+ -> ^[J/psi(1S) -> mu+ e-]CC K+]CC", "muplus" : "[B+ -> [J/psi(1S) -> ^mu+ e-]CC K+]CC", "eminus" : "[B+ -> [J/psi(1S) -> mu+ ^e-]CC K+]CC", "Kplus" : "[B+ -> [J/psi(1S) -> mu+ mu-]CC ^K+]CC" }) data.TupleName = "DecayTree" #TupleTools #Tools added to the ToolList can not be modified i.e. no other options than the defaults can be used data.ToolList = [ ] #Settings for TupleToolTrackHits (some only are necessary for MDST-files because of other locations of the clusters) if(True): #Change this value if you don't want to use this tool from Configurables import TupleToolTrackHits, STOfflinePosition trackhits = data.addTupleTool("TupleToolTrackHits") if DaVinci().InputType == 'MDST': from Configurables import MeasurementProvider data.addTool(MeasurementProvider('MeasProvider')) data.MeasProvider.RootInTES = "/Event/Leptonic/" #Change Leptonic for your stream-name in case of MDST trackhits.MeasurementProvider = data.MeasProvider itClusterPosition = STOfflinePosition('ToolSvc.ITClusterPosition') #avoid crashes from missing IT channels itClusterPosition.DetType = 'IT' MySequencer.Members.append(data) ################################ ### DaVinci configuration #### ################################ DaVinci().UserAlgorithms = [MySequencer] DaVinci().MoniSequence += [data] DaVinci().EvtMax = 5000 DaVinci().Lumi = True DaVinci().SkipEvents = 0
"B": "[B+ -> ( J/psi(1S) -> mu- mu+ ) pi+ ]CC", "Jpsi": "[B+ -> ^(J/psi(1S) -> mu- mu+) pi+]CC", "mu_prim": "[B+ -> (J/psi(1S) -> mu- ^mu+) pi+]CC", "mu_sec": "[B+ -> (J/psi(1S) -> ^mu- mu+) pi+]CC", "pi": "[B+ -> (J/psi(1S) -> mu- mu+) ^pi+]CC", } tuple.ToolList = [ "TupleToolKinematic", "TupleToolPid", "TupleToolGeometry", "TupleToolPrimaries", "TupleToolTrackInfo", "TupleToolEventInfo", "TupleToolAngles", "TupleToolANNPID", "TupleToolMCBackgroundInfo", "TupleToolMCTruth", "TupleToolTrigger", "TupleToolDira", "TupleToolEventInfo", "TupleToolPropertime", "TupleToolRecoStats", ] trigger_list = [ 'L0MuonDecision', 'L0DiMuonDecision', 'L0HadronDecision', 'Hlt1TrackAllL0Decision', 'Hlt1TrackMuonDecision', 'Hlt1TrackMVADecision', 'Hlt1TwoTrackMVADecision', 'Hlt1TrackMVALooseDecision', 'Hlt1TwoTrackMVALooseDecision', 'Hlt2TopoMu2BodyBBDTDecision', 'Hlt2TopoMu3BodyBBDTDecision', 'Hlt2Topo2BodyDecision',
# Use same tags as Gauss (from Gauss/options/Gauss-2012.py) LHCbApp().DDDBtag = "dddb-20180726-2" LHCbApp().CondDBtag = "sim-20160321-2-vc-md100" LHCbApp().Simulation = True # we did not run Moore, so force the TCK check to false. L0Conf().EnsureKnownTCK = False tup = DecayTreeTuple('electrons') tup.Decay = '[e-]CC' #tup.setDescriptorTemplate('${eminus}[e-]CC') tup.Inputs = ["Phys/StdAllLooseElectrons/Particles"] #tup.ReFitPVs = True tup.ToolList = [] tup.addTupleTool("TupleToolKinematic") # Momenta tup.addTupleTool("TupleToolBremInfo") # Info on photon that was BremAdded tup.addTupleTool("TupleToolCaloInfo") # (custom) dump of ECAL clusters tup.addTupleTool( "TupleToolInfoAtCalo") # (custom) info on extrapolated position at ECAL mctruthtool = tup.addTupleTool("TupleToolMCTruth") mctruthtool.ToolList += ["MCTupleToolPhotonDaughters" ] # (custom) info of MC bremphoton daughters nobremtool = tup.addTupleTool('LoKi::Hybrid::TupleTool/nobremtool') nobremtool.Variables = { 'nobrem_P': 'PPINFO(504,-100,-200)', 'nobrem_PT': 'PPINFO(505,-100,-200)', }
LoKi_B = LoKi__Hybrid__TupleTool("LoKi_B") LoKi_B.Variables = { "ETA": "ETA", "PHI": "PHI", "FDCHI2": "BPVVDCHI2", "FDS": "BPVDLS", "DIRA": "BPVDIRA", "pi0veto": "CHILDFUN ( PINFO( 25030 , -1 ) , 'gamma' == ABSID ) ", } LoKi_Mu = LoKi__Hybrid__TupleTool("LoKi_Mu") LoKi_Mu.Variables = {"NSHAREDMU": "NSHAREDMU"} tuple_B2Kmumu = DecayTreeTuple("Tuple") tuple_B2Kmumu.Inputs = [location] tuple_B2Kmumu.ToolList = tupletools[:] tuple_B2Kmumu.Decay = '[Lambda_b0 -> ^(chi_c1(1P) -> ^(J/psi(1S) -> ^mu+ ^mu-) ^gamma) ^p+ ^K-]CC' tuple_B2Kmumu.Branches = { "Lambda_b0": "[Lambda_b0 -> (chi_c1(1P) -> (J/psi(1S) -> mu+ mu-) gamma) p+ K-]CC", "chi_c": "[Lambda_b0 -> ^(chi_c1(1P) -> (J/psi(1S) -> mu+ mu-) gamma) p+ K-]CC", "Jpsi": "[Lambda_b0 -> (chi_c1(1P) -> ^(J/psi(1S) -> mu+ mu-) gamma) p+ K-]CC", "gamma": "[Lambda_b0 -> (chi_c1(1P) -> (J/psi(1S) -> mu+ mu-) ^gamma) p+ K-]CC", "muplus": "[Lambda_b0 -> (chi_c1(1P) -> (J/psi(1S) -> ^mu+ mu-) gamma) p+ K-]CC", "muminus": "[Lambda_b0 -> (chi_c1(1P) -> (J/psi(1S) -> mu+ ^mu-) gamma) p+ K-]CC", "proton":
#PROBNNmu not available in 2015 Turbo(++) from Configurables import CondDB CondDB(LatestGlobalTagByDataType=the_year) ## (5) fill tuple from Configurables import DecayTreeTuple, TupleToolPrimaries tuple = DecayTreeTuple("DecayTree") tuple.Inputs = [StripSel1.outputLocation()] tuple.Decay = decay tuple.ToolList = [ "TupleToolKinematic", "TupleToolPid", "TupleToolANNPID", "TupleToolPropertime", "TupleToolGeometry", "TupleToolPrimaries", "TupleToolTrackInfo", "TupleToolEventInfo", "TupleToolRecoStats" #, ] tuple.Branches = { "B": "[B+ -> ( J/psi(1S) -> mu- mu+ ) pi+ ]CC", "Jpsi": "[B+ -> ^(J/psi(1S) -> mu- mu+) pi+]CC", "mu_prim": "[B+ -> (J/psi(1S) -> mu- ^mu+) pi+]CC", "mu_sec": "[B+ -> (J/psi(1S) -> ^mu- mu+) pi+]CC", "pi": "[B+ -> (J/psi(1S) -> mu- mu+) ^pi+]CC", } ######################################################################## from Configurables import TupleToolGeometry tuple.addTool(TupleToolGeometry, name="TupleToolGeometry")