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
def MakeDecayTreeTulple(name, location, decay_channel, TupleToolList): # create the tuple dtt = DecayTreeTuple(name) dtt.Inputs = [location] dtt.Decay = decay_channel # AddToople tool if TupleToolList is not None and len(TupleToolList) > 0: for TupleTool in TupleToolList: ok_module = TestModule(TupleTool) if ok_module: dtt.addTupleTool(TupleTool) else: print "Cannot add TupleTool {}, did you import it ?".format( TupleTool) return dtt
"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" } tuple_B2Kmumu = DecayTreeTuple("Tuple") tuple_B2Kmumu.Inputs = [ location ] tuple_B2Kmumu.ToolList = tupletools[:] tuple_B2Kmumu.Decay = '[B0 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^(omega(782) -> ^pi+ ^pi- ^pi0)]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" : "[Lambda_b0 -> (chi_c1(1P) -> (J/psi(1S) -> mu+ mu-) gamma) ^p+ K-]CC", "kaon" : "[Lambda_b0 -> (chi_c1(1P) -> (J/psi(1S) -> mu+ mu-) gamma) p+ ^K-]CC", } for particle in ["Lambda_b0", "chi_c", "Jpsi", "gamma", "muplus", "muminus", "proton", "kaon"]: tuple_B2Kmumu.addTool(TupleToolDecay, name = particle) # List of the reconstructed tuples tuples = [ tuple_B2Kmumu
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
"Jpsi" : "[B+ -> K+ ^(J/psi(1S) -> mu+ mu-)]CC", "lplus" : "[B+ -> K+ (J/psi(1S) -> ^mu+ mu-)]CC", "lminus" : "[B+ -> K+ (J/psi(1S) -> mu+ ^mu-)]CC", "Bplus" : "[B+ -> K+ J/psi(1S)]CC", }) if LeptonType == "Electrons": decay = "[B+ -> ^(J/psi(1S) -> ^e+ ^e-) ^K+]CC" tupleB.addBranches ({ "Kplus" : "[B+ -> ^K+ (J/psi(1S) -> e+ e-)]CC", "Jpsi" : "[B+ -> K+ ^(J/psi(1S) -> e+ e-)]CC", "lplus" : "[B+ -> K+ (J/psi(1S) -> ^e+ e-)]CC", "lminus" : "[B+ -> K+ (J/psi(1S) -> e+ ^e-)]CC", "Bplus" : "[B+ -> K+ J/psi(1S)]CC", }) tupleB.Decay = decay tupleB.ToolList = [ "TupleToolKinematic" , "TupleToolEventInfo" , "TupleToolRecoStats" ,"TupleToolMCBackgroundInfo",#comment out for data "TupleToolMCTruth", #comment out for data "TupleToolTrigger", "TupleToolPid", "TupleToolPrimaries", "TupleToolAngles", "TupleToolEventInfo", "TupleToolGeometry",
from PhysSelPython.Wrappers import Selection from StandardParticles import StdNoPIDsDownPions, StdLoosePions LooseKsPiPi = Selection("SelLooseKsPiPi", Algorithm = KsPiPi, RequiredSelections = [StdNoPIDsDownPions ]) #RequiredSelections = [StdLoosePions]) from PhysSelPython.Wrappers import SelectionSequence SeqKsPiPi = SelectionSequence('SeqKsPiPi', TopSelection = LooseKsPiPi) KsPiPiTuple = DecayTreeTuple("KsPiPiTuple") # input locations KsPiPiTuple.Inputs = [ LooseKsPiPi.outputLocation() ] # 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
) # create a selection using the substitution algorithm selSub = Selection( 'Dst2D0pi_D02pipi_Sel', Algorithm=subs, RequiredSelections=strippingSels ) # in order to add the selection into the program make a sequence selSeq = SelectionSequence('SelSeq', TopSelection=selSub) # Create an ntuple to capture D*+ decays from the new selection dtt = DecayTreeTuple('TupleDstToD0pi_D0Topipi') dtt.Inputs = [selSeq.outputLocation()] dtt.Decay = '[D*(2010)+ -> ^(D0 -> ^pi- ^pi+) ^pi+]CC' # Configure DaVinci # add our new selection and the tuple into the sequencer seq = GaudiSequencer('MyTupleSeq') seq.Members += [selSeq.sequence()] seq.Members += [dtt] DaVinci().appendToMainSequence([seq]) DaVinci().InputType = 'DST' DaVinci().TupleFile = 'DVntuple.root' DaVinci().PrintFreq = 1000 DaVinci().DataType = '2016' DaVinci().Simulation = True # Only ask for luminosity information when not using simulated data
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
from Gaudi.Configuration import * from Configurables import GaudiSequencer from Configurables import DaVinci simulation=False from Configurables import EventNodeKiller eventNodeKiller = EventNodeKiller('DAQkiller') eventNodeKiller.Nodes = ['DAQ','pRec'] #MySequencer.Members+=[eventNodeKiller] from Configurables import DecayTreeTuple from DecayTreeTuple.Configuration import * tuple=DecayTreeTuple() tuple.Decay="[B0 -> ^(K*(892)0 -> ^K+ ^pi-) ^(eta_prime -> ^pi- ^pi+ ^(eta -> ^gamma ^gamma))]CC" tuple.Branches={"B0":"[B0 -> (K*(892)0 -> K+ pi-) (eta_prime -> pi- pi+ (eta -> gamma gamma))]CC"} tuple.Inputs=["/Event/Bhadron/Phys/B2XEtaB2etapKstarLine/Particles"] tuple.ToolList += [ "TupleToolGeometry" , "TupleToolDira" , "TupleToolAngles" , "TupleToolPid" , "TupleToolKinematic" , "TupleToolPropertime" , "TupleToolPrimaries" , "TupleToolEventInfo" , "TupleToolTrackInfo" , "TupleToolVtxIsoln" , "TupleToolPhotonInfo" #, "TupleToolMCTruth"
noPIDsKaons = DataOnDemand(Location = 'Phys/StdNoPIDsKaons') BhhSel = Selection("BhhSel" , Algorithm = Bhh , RequiredSelections = [noPIDsKaons]) BhhNBSel = Selection("BhhNBSel" , Algorithm = BhhNB , RequiredSelections = [ BhhSel ] ) SelSeqBhh = SelectionSequence("SeqBhh" , TopSelection = BhhNBSel) SeqBhh = SelSeqBhh.sequence() ######################################################################## # # NTupling # from Configurables import DecayTreeTuple tupleBhh = DecayTreeTuple("tupleBhh") tupleBhh.InputLocations = [SelSeqBhh.outputLocation()] tupleBhh.Decay = "B_s0 -> K+ K-" tupleBhh.ToolList += [ "TupleToolGeometry" , "TupleToolKinematic" , "TupleToolPrimaries" , "TupleToolTrackInfo" , "TupleToolPid" , "TupleToolEventInfo" , "TupleToolPropertime" ,"LoKi::Hybrid::TupleTool/LoKiTupleBhh" ] from Configurables import LoKi__Hybrid__TupleTool LoKiTupleBhh = LoKi__Hybrid__TupleTool("LoKiTupleBhh") LoKiTupleBhh.Variables = { "Charge" : "Q" , "DOCA" : "DOCA(1,2)",
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'" ]
# Try and make B->J/psi K _B = CombineParticles() _B.DaughtersCuts = { "K+" : "(PT>500*MeV)&(MIPCHI2DV(PRIMARY) > 9)" } _B.MotherCut = "(DMASS('B+')<5000*MeV) & (VFASPF(VCHI2)/VFASPF(VDOF)<5.0) & (BPVDIRA > 0.999)" #need to check these cuts _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("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",
TimingAuditor().addTool(SequencerTimerTool, name="TIMER") TimingAuditor().TIMER.NameSize = 60 MessageSvc().Format = "% F%60W%S%7W%R%T %0W%M" # database DaVinci().DDDBtag = "dddb-20120831" DaVinci().CondDBtag = "cond-20121008" # input file importOptions("$STRIPPINGSELECTIONSROOT/tests/data/Reco14_Run125113.py") from Configurables import DecayTreeTuple Tup = DecayTreeTuple("Tup") Tup.Inputs = ["Phys/B2DstMuNuInclLine/Particles"] Tup.Decay = "[B~0 -> ^(D*(2010)+ -> ^(D0 -> ^K- ^pi+) ^pi+) ^mu-]CC" Tup.Branches = { "B": "[B~0 -> (D*(2010)+ -> (D0 -> K- pi+) pi+) mu-]CC", "Dst": "[B~0 -> ^(D*(2010)+ -> (D0 -> K- pi+) pi+) mu-]CC", "D0": "[B~0 -> (D*(2010)+ -> ^(D0 -> K- pi+) pi+) mu-]CC", "Slowpi": "[B~0 -> (D*(2010)+ -> (D0 -> K- pi+) ^pi+) mu-]CC", "mu": "[B~0 -> (D*(2010)+ -> (D0 -> K- pi+) pi+) ^mu-]CC" } DaVinci().appendToMainSequence([Tup]) TupWS = DecayTreeTuple("Tup") TupWS.Inputs = ["Phys/B2DstMuNuInclWSLine/Particles"] TupWS.Decay = "[B~0 -> ^(D*(2010)- -> ^(D0 -> ^K- ^pi+) ^pi-) ^mu-]CC" TupWS.Branches = { "B": "[B~0 -> (D*(2010)- -> (D0 -> K- pi+) pi-) mu-]CC", "Dst": "[B~0 -> ^(D*(2010)- -> (D0 -> K- pi+) pi-) mu-]CC",
CallgrindProfile, BTaggingTool, MessageSvc, ) from Gaudi.Configuration import INFO, DEBUG, WARNING 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"
from Configurables import DaVinci, LHCbApp from Configurables import DecayTreeTuple, TupleToolDecay, L0Conf from DecayTreeTuple.Configuration import * from Gaudi.Configuration import * # 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
############################################################################################## enablePacking = True from Configurables import DecayTreeTuple, FitDecayTrees, TupleToolRecoStats, TupleToolTrigger, TupleToolSubMass from Configurables import TupleToolTISTOS, CondDB, SelDSTWriter, TupleToolL0Calo from Configurables import TupleToolTrackInfo, TupleToolRICHPid, TupleToolGeometry, TupleToolPid from Configurables import TupleToolANNPID from Configurables import TupleToolSLTruth from Configurables import TupleToolMCTruth from Configurables import TupleToolPropertime from Configurables import TupleToolTauMuDiscrVarsLcMassConstraint from DecayTreeTuple.Configuration import * tupleB = DecayTreeTuple("tupleout") tupleB.Inputs = ["Phys/b2LcMuXB2DMuForTauMuLine/Particles"] tupleB.Decay = "[B- -> ^(Lambda_c+ -> ^p+ ^K- ^pi+) ^mu-]CC" tupleB.ToolList += [ "TupleToolKinematic", "TupleToolEventInfo", "TupleToolRecoStats", "TupleToolGeometry", "TupleToolMCBackgroundInfo" #comment out for data , "TupleToolMCTruth" #comment out for data , "TupleToolSLTruth", "TupleToolL0Calo" #for Calorimeter info ] # Probably need to add many more Tools. tupleB.addBranches({ "Lb": "[B- -> (Lambda_c+ -> p+ K- pi+) mu-]CC",
DataOnDemand(Location=selBSelectionSequence.outputLocation())]) selABSelectionSequence = SelectionSequence('FakeBs', TopSelection = selectionAB) from Configurables import FitDecayTrees fitD2KKP = FitDecayTrees ( "fitD2KKP" , Code = "DECTREE('B_s0 -> (D_s+ -> K+ K- pi+) (D_s- -> K- K+ pi-)')", MassConstraints = [ 'D_s+', 'D_s-' ], ) fitD2KKP.Inputs = [selABSelectionSequence.outputLocation()] from Configurables import P2MCPFromProtoP, BackgroundCategory fakebstuple = DecayTreeTuple("out") fakebstuple.Decay = "'[B_s0 -> ^D_s- ^D_s+]CC'" fakebstuple.Inputs = ['Phys/fitD2KKP'] #fakebstuple.addTupleTool("TupleToolPropertime") #bkgcat = fakebstuple.addTupleTool("TupleToolMCBackgroundInfo") #bkgcat.IBackgroundCategoryTypes = ['BackgroundCategory/MyBC'] #bkgcat.addTool(BackgroundCategory, name='MyBC') #bkgcat.MyBC.addTool(P2MCPFromProtoP, name='P2MCPFromProtoP') #bkgcat.MyBC.P2MCPFromProtoP.Locations = ['MergedEvent/Relations/MergedEvent/Rec/ProtoP/Charged', 'Relations/Rec/ProtoP/Charged'] #bkgcat.MyBC.P2MCPFromProtoP.MCParticleDefaultLocation = 'MergedEvent/MC/Particles' #fakebstuple.OutputLevel = 2 from Configurables import MCMatchObjP2MCRelator merge = MergeEvent() merge.addTool(MCMatchObjP2MCRelator, name='MyRelator') merge.MyRelator.RelTableLocations = ['/Event/NewEvent/Relations/NewEvent/Rec/ProtoP/Charged'] #merge.OutputLevel = 1
from DecayTreeTuple.Configuration import * from Configurables import DecayTreeTuple, LoKi__Hybrid__TupleTool, TupleToolDecay, TupleToolTrigger, TupleToolTISTOS, TupleToolSelResults, TupleToolTrackInfo, TupleToolEventInfo, TupleToolVtxIsoln, TupleToolTrackIsolation, TupleToolAngles, TupleToolRecoStats # Stream and stripping line we want to use stream = 'AllStreams' line = 'D2XMuMu_PiOSLine' # Create an ntuple to capture D*+ decays from the StrippingLine line dtt = DecayTreeTuple('D2PimumuOSTuple') dtt.Inputs = ['/Event/{0}/Phys/{1}/Particles'.format(stream, line)] dtt.Decay = '[D+ -> ^pi+ ^mu+ ^mu-]CC' dtt.ToolList += [ "TupleToolGeometry", "TupleToolKinematic", "TupleToolPropertime", "TupleToolPrimaries", "TupleToolPid", "TupleToolEventInfo", "TupleToolTrackInfo", "TupleToolTrigger", "TupleToolAngles" # , "TupleToolVtxIsoln" , "TupleToolTrackIsolation", "TupleToolTrigger", "TupleToolTISTOS", "TupleToolEventInfo", "TupleToolRecoStats" ]
, "Hlt2Topo4BodyBBDTDecision" , "Hlt2TopoMu4BodyBBDTDecision" , "Hlt2IncPhiSidebandsDecision" , "Hlt2B2HHDecision" ] # Get trigger info tuple.addTool(TupleToolTrigger, name="TupleToolTrigger") tuple.TupleToolTrigger.Verbose = True tuple.TupleToolTrigger.TriggerList = tlist # Get TISTOS info tuple.addTool(TupleToolTISTOS, name="TupleToolTISTOS") tuple.TupleToolTISTOS.Verbose = True tuple.TupleToolTISTOS.TriggerList = tlist # Decay descriptor tuple.Decay = "[B_s0 -> ^(phi(1020) -> ^K+ ^K-) ^(f_0(980) -> ^K+ ^K-)]CC" #tuple.Decay = "[B0 -> ^(phi(1020) -> ^K+ ^K-) ^(rho(770)0 -> ^pi+ ^pi-)]CC" # original # Rename f_0(980) branch to KK tuple.addBranches({ "KK" : " [B_s0 -> (phi(1020) -> K+ K-) ^(f_0(980) -> K+ K-)]CC " }) # LOKI Vairables from Configurables import LoKi__Hybrid__TupleTool LoKiVariables2 = LoKi__Hybrid__TupleTool('LoKiVariables2') LoKiVariables2.Variables = { "LOKI_Mass" : "DTF_FUN(M, True)", "LOKI_Chi2" : "DTF_CHI2(True)", "LOKI_ndof" : "DTF_NDOF(True)", "LOKI_MassError2" : "DTF_FUN(M2ERR2, True)", "LOKI_DTF_CTAU" : "DTF_CTAU( 0, True )", "LOKI_DTF_CTAUS" : "DTF_CTAUSIGNIFICANCE( 0, True )",
from DecayTreeTuple.Configuration import * from Configurables import DecayTreeTuple, LoKi__Hybrid__TupleTool, TupleToolDecay, TupleToolTrigger, TupleToolTISTOS, TupleToolSelResults, TupleToolTrackInfo, TupleToolEventInfo, TupleToolVtxIsoln, TupleToolTrackIsolation, TupleToolAngles, TupleToolRecoStats # Stream and stripping line we want to use stream = 'AllStreams' line = 'D2XMuMu_KOSLine' # Create an ntuple to capture D*+ decays from the StrippingLine line dtt = DecayTreeTuple('D2KmumuOSTuple') dtt.Inputs = ['/Event/{0}/Phys/{1}/Particles'.format(stream, line)] dtt.Decay = '[D+ -> ^K+ ^mu+ ^mu-]CC' dtt.ToolList += [ "TupleToolGeometry" , "TupleToolKinematic" , "TupleToolPropertime" , "TupleToolPrimaries" , "TupleToolPid" , "TupleToolEventInfo" , "TupleToolTrackInfo" , "TupleToolTrigger" , "TupleToolAngles" # , "TupleToolVtxIsoln" , "TupleToolTrackIsolation" , "TupleToolTrigger" , "TupleToolTISTOS" , "TupleToolEventInfo" , "TupleToolRecoStats" ] dtt.addTool(TupleToolTISTOS("TupleToolTISTOS"))
"PE_proton_constr2" : "DTF_FUN ( CHILD( E, 2) , True , strings(['J/psi(1S)', 'chi_c2(1P)']) )", "PX_kaon_constr2" : "DTF_FUN ( CHILD(PX, 3) , True , strings(['J/psi(1S)', 'chi_c2(1P)']) )", "PY_kaon_constr2" : "DTF_FUN ( CHILD(PY, 3) , True , strings(['J/psi(1S)', 'chi_c2(1P)']) )", "PZ_kaon_constr2" : "DTF_FUN ( CHILD(PZ, 3) , True , strings(['J/psi(1S)', 'chi_c2(1P)']) )", "PE_kaon_constr2" : "DTF_FUN ( CHILD( E, 3) , True , strings(['J/psi(1S)', 'chi_c2(1P)']) )", } 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" : "[Lambda_b0 -> (chi_c1(1P) -> (J/psi(1S) -> mu+ mu-) gamma) ^p+ K-]CC", "kaon" : "[Lambda_b0 -> (chi_c1(1P) -> (J/psi(1S) -> mu+ mu-) gamma) p+ ^K-]CC", } for particle in ["Lambda_b0", "chi_c", "Jpsi", "gamma", "muplus", "muminus", "proton", "kaon"]: tuple_B2Kmumu.addTool(TupleToolDecay, name = particle) # List of the reconstructed tuples tuples = [ tuple_B2Kmumu
"TupleToolMCTruth", "TupleToolRICHPid", "TupleToolKinematic", "TupleToolPrimaries", "TupleToolEventInfo", "TupleToolTrackInfo", "TupleToolAngles", "TupleToolPropertime", "TupleToolVtxIsoln", "TupleToolMCBackgroundInfo" ] decay="[B+ -> ^(eta_prime -> ^(rho(770)0 -> ^pi+ ^pi-) ^gamma ) ^K+]CC" tuple.Decay =decay #DecayTreeFitter Tool tuple.Branches = { 'B' : "^("+decay.replace("^","")+")" } from Configurables import TupleToolDecay tuple.addTool(TupleToolDecay, name = 'B') tuple.B.ToolList+=["TupleToolTISTOS"] tuple.B.addTool( TupleToolTISTOS , name="TupleToolTISTOS") tuple.B.TupleToolTISTOS.VerboseHlt1 = True tuple.B.TupleToolTISTOS.VerboseHlt2 = True tuple.B.TupleToolTISTOS.VerboseL0 = True tuple.B.TupleToolTISTOS.TriggerList = myTriggerList from Configurables import TupleToolDecayTreeFitter
'Hlt2TopoMu3BodyBBDTDecision', 'Hlt2TopoMu4BodyBBDTDecision', 'Hlt2TransparentDecision', 'Hlt2DiMuonUnbiasedJPsiDecision' ] tuple.addTool(TupleToolGeometry) tuple.TupleToolGeometry.Verbose = True #tuple.TupleToolTISTOS.UseAutomaticTriggerList = True tuple.addTool(TupleToolTagging) tuple.TupleToolTagging.Verbose = True #from FlavourTagging.Tunings import TuneTool #TuneTool(tuple,'Xmass_2011') ########################################################################################################################### tuple.Decay = '[Lambda_b0 -> (^J/psi(1S) -> ^mu+ ^mu-) (^Lambda(1520)0 -> ^p+ ^K-)]cc' tuple.Branches = { "Bs" : "[Lambda_b0]cc : [Lambda_b0 -> (J/psi(1S) -> mu+ mu-) (Lambda(1520)0 -> p+ K-) ]cc", "R" : "[Lambda_b0 -> (J/psi(1S) -> mu+ mu-) (^Lambda(1520)0 -> p+ K-)]cc", "H1" : "[Lambda_b0 -> (J/psi(1S) -> mu+ mu-) (Lambda(1520)0 -> ^p+ K-) ]cc", "H2" : "[Lambda_b0 -> (J/psi(1S) -> mu+ mu-) (Lambda(1520)0 -> p+ ^K-)]cc", "J_psi_1S" : "[Lambda_b0 -> (^J/psi(1S) -> mu+ mu-) (Lambda(1520)0 -> p+ K-)]cc" } tuple.ToolList += [ "TupleToolMCTruth", "TupleToolMCBackgroundInfo" ]
CombinationCut=dstar_comb, MotherCut=dstar_mother ) dstar_sel = Selection( 'Sel_Dstar', Algorithm=dstar, RequiredSelections=[d0_sel, Pions] ) dstar_seq = SelectionSequence('Dstar_Seq', TopSelection=dstar_sel) # Create an ntuple dtt = DecayTreeTuple('TupleDstToD0pi_D0ToKK') dtt.Inputs = dstar_seq.outputLocations() dtt.Decay = '[D*(2010)+ -> ^D0 ^pi+]CC' DaVinci().UserAlgorithms += [dstar_seq.sequence(), dtt] # DaVinci configuration DaVinci().InputType = 'DST' DaVinci().TupleFile = 'DVntuple.root' DaVinci().PrintFreq = 1000 DaVinci().DataType = '2016' DaVinci().Simulation = True # Only ask for luminosity information when not using simulated data DaVinci().Lumi = not DaVinci().Simulation DaVinci().EvtMax = 1000 IOHelper().inputFiles([('root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/MC/2016/ALLSTREAMS.DST/00062514/0000/00062514_00000008_7.AllStreams.dst')], clear=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'"]
sstream.OutputLevel = 2 sc.appendStream(sstream) #--------------------------- # Run fixing XmumuLine #--------------------------- from Configurables import PromptNeutrinoTupleTool stripping_line = 'B2XMuMu_Line' stream = 'AllStreams' tuple = DecayTreeTuple('PromptNeutrinoTupleTool') tuple.OutputLevel = INFO tuple.Inputs = ['/Event/{0}/Phys/{1}/Particles'.format(stream, stripping_line)] tuple.Decay = "[B+ -> ^( J/psi(1S) -> ^mu- ^mu+ ) ^pi+]CC" 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", } tuple.ToolList = [ "TupleToolKinematic", "TupleToolPid", "TupleToolGeometry", "TupleToolPrimaries", "TupleToolTrackInfo", "TupleToolEventInfo",
AcceptBadEvents = False, BadEventSelection = filterBadEvents) DaVinci().appendToMainSequence([event_node_killer,sc.sequence()]) ##################Creating NTuples##################################### from Configurables import DecayTreeTuple from Configurables import TupleToolL0Calo from DecayTreeTuple.Configuration import * line = 'B2XEtaLb2pKetapLine' tuple=DecayTreeTuple() tuple.Decay="[Lambda_b0 -> ^p+ ^K- ^(eta_prime -> ^pi- ^pi+ ^gamma)]CC" tuple.Branches={"Lambda_b0":"[Lambda_b0 -> p+ K- (eta_prime -> pi- pi+ gamma)]CC"} tuple.Inputs=['/Event/Phys/{0}/Particles'.format(line)] tuple.addTool(TupleToolL0Calo()) tuple.TupleToolL0Calo.TriggerClusterLocation="/Event/Trig/L0/Calo" tuple.TupleToolL0Calo.WhichCalo="HCAL" tuple.ToolList += [ "TupleToolGeometry" , "TupleToolDira" , "TupleToolAngles" # , "TupleToolL0Calo" , "TupleToolPid" , "TupleToolKinematic" , "TupleToolPropertime"
dstar = CombineParticles('Combine_Dstar', DecayDescriptor='[D*(2010)+ -> D0 pi+]cc', DaughtersCuts=dstar_daughters, CombinationCut=dstar_comb, MotherCut=dstar_mother) dstar_sel = Selection('Sel_Dstar', Algorithm=dstar, RequiredSelections=[d0_sel, Pions]) dstar_seq = SelectionSequence('Dstar_Seq', TopSelection=dstar_sel) # Create an ntuple dtt = DecayTreeTuple('TupleDstToD0pi_D0ToKpi') dtt.Inputs = dstar_seq.outputLocations() dtt.Decay = '[D*(2010)+ -> D0 pi+]CC' DaVinci().UserAlgorithms += [dstar_seq.sequence(), dtt] # DaVinci configuration DaVinci().InputType = 'DST' DaVinci().TupleFile = 'DVntuple.root' DaVinci().PrintFreq = 1000 DaVinci().DataType = '2012' DaVinci().Simulation = True # Only ask for luminosity information when not using simulated data DaVinci().Lumi = not DaVinci().Simulation DaVinci().EvtMax = 10000 # Use the local input data IOHelper().inputFiles([('root://eoslhcb.cern.ch/'
] tuple.addTool(TupleToolGeometry, name="TupleToolGeometry") tuple.TupleToolGeometry.Verbose = True tuple.addTool(TupleToolTrackInfo, name="TupleToolTrackInfo") tuple.TupleToolTrackInfo.Verbose = True tuple.addTool(TupleToolPid, name="TupleToolPid") tuple.TupleToolPid.Verbose = True #tuple.UseLabXSyntax = True #tuple.Decay = " [B0 -> ^[ D0 -> ^K- ^pi+ ]CC ^[ K*(892)0 -> ^K+ ^pi- ]CC]CC " #tuple.Decay = " [B0 -> ^(D0 -> ^K- ^pi+) ^(K*(892)0 -> ^K+ ^pi-) ]CC " tuple.Decay = "[B0 -> ^( D0 -> ^K+ ^K- ) ^( rho(770)0 -> ^pi+ ^pi- ) ]CC " tuple.addBranches({ "B": " [B0 -> ( D0 -> K+ K- ) ( rho(770)0 -> pi+ pi- ) ]CC ", "D": " [B0 -> ^( D0 -> K+ K- ) ( rho(770)0 -> pi+ pi- ) ]CC ", "D0p": " [B0 -> ( D0 -> ^K+ K- ) ( rho(770)0 -> pi+ pi- ) ]CC ", "D0m": " [B0 -> ( D0 -> K+ ^K- ) ( rho(770)0 -> pi+ pi- ) ]CC ", "pip": " [B0 -> ( D0 -> K+ K- ) ( rho(770)0 -> ^pi+ pi- ) ]CC ", "pim": " [B0 -> ( D0 -> K+ K- ) ( rho(770)0 -> pi+ ^pi- ) ]CC ", "rho": " [B0 -> ( D0 -> K+ K- ) ^( rho(770)0 -> pi+ pi- ) ]CC "
"PE_proton_constr1" : "DTF_FUN ( CHILD( E, 2) , True , strings(['J/psi(1S)']) )", "PX_kaon_constr1" : "DTF_FUN ( CHILD(PX, 3) , True , strings(['J/psi(1S)']) )", "PY_kaon_constr1" : "DTF_FUN ( CHILD(PY, 3) , True , strings(['J/psi(1S)']) )", "PZ_kaon_constr1" : "DTF_FUN ( CHILD(PZ, 3) , True , strings(['J/psi(1S)']) )", "PE_kaon_constr1" : "DTF_FUN ( CHILD( E, 3) , True , strings(['J/psi(1S)']) )", } 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 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^p+ ^K-]CC' tuple_B2Kmumu.Branches = { "Lambda_b0" : "[Lambda_b0 -> (J/psi(1S) -> mu+ mu-) p+ K-]CC", "Jpsi" : "[Lambda_b0 -> ^(J/psi(1S) -> mu+ mu-) p+ K-]CC", "muplus" : "[Lambda_b0 -> (J/psi(1S) -> ^mu+ mu-) p+ K-]CC", "muminus" : "[Lambda_b0 -> (J/psi(1S) -> mu+ ^mu-) p+ K-]CC", "proton" : "[Lambda_b0 -> (J/psi(1S) -> mu+ mu-) ^p+ K-]CC", "kaon" : "[Lambda_b0 -> (J/psi(1S) -> mu+ mu-) p+ ^K-]CC", } for particle in ["Lambda_b0", "Jpsi", "muplus", "muminus", "proton", "kaon"]: tuple_B2Kmumu.addTool(TupleToolDecay, name = particle) # List of the reconstructed tuples tuples = [ tuple_B2Kmumu ]
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]
tuple.Jpsi.JpsiTISTOS.Verbose = True tuple.Jpsi.JpsiTISTOS.TriggerList = list tuple.Kplus.ToolList += ["TupleToolTISTOS/KplusTISTOS"] tuple.Kplus.addTool(TupleToolTISTOS, name="KplusTISTOS") tuple.Kplus.KplusTISTOS.Verbose = True tuple.Kplus.KplusTISTOS.TriggerList = list tuple.muplus.ToolList += ["TupleToolTISTOS/muplusTISTOS"] tuple.muplus.addTool(TupleToolTISTOS, name="muplusTISTOS") tuple.muplus.muplusTISTOS.Verbose = True tuple.muplus.muplusTISTOS.TriggerList = list tuple.muminus.ToolList += ["TupleToolTISTOS/muminusTISTOS"] tuple.muminus.addTool(TupleToolTISTOS, name="muminusTISTOS") tuple.muminus.muminusTISTOS.Verbose = True tuple.muminus.muminusTISTOS.TriggerList = list tuple.Decay = '[B+ -> ^(J/psi(1S) -> ^e+ ^e-) ^K+]CC' from Configurables import DaVinci DaVinci().TupleFile = "BuKll.root" DaVinci().EvtMax = -1 DaVinci().DataType = '2011' DaVinci().Simulation = False DaVinci().Lumi = True #CondDB().UseOracle = True CondDB(LatestGlobalTagByDataType='2011') _myseq = GaudiSequencer("myseq") _myseq.Members += [tuple] DaVinci().UserAlgorithms = [_myseq]
'Hlt2TopoMu3BodyBBDTDecision', 'Hlt2TopoMu4BodyBBDTDecision', 'Hlt2TransparentDecision', 'Hlt2DiMuonUnbiasedJPsiDecision' ] tuple.addTool(TupleToolGeometry) tuple.TupleToolGeometry.Verbose = True #tuple.TupleToolTISTOS.UseAutomaticTriggerList = True #tuple.addTool(TupleToolTagging) #tuple.TupleToolTagging.Verbose = True #from FlavourTagging.Tunings import TuneTool #TuneTool(tuple,'Xmass_2011') ########################################################################################################################### tuple.Decay = '[Lambda_b0 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^(Lambda0 -> ^p+ ^pi-)]CC' tuple.Branches = { "Bs" : "^[Lambda_b0 -> (J/psi(1S) -> mu+ mu-) (Lambda0 -> p+ pi-)]CC", "R" : "[Lambda_b0 -> (J/psi(1S) -> mu+ mu-) ^(Lambda0 -> p+ pi-)]CC", "H1" : "[Lambda_b0 -> (J/psi(1S) -> mu+ mu-) (Lambda0 -> ^p+ pi-)]CC", "H2" : "[Lambda_b0 -> (J/psi(1S) -> mu+ mu-) (Lambda0 -> p+ ^pi-)]CC", "J_psi_1S" : "[Lambda_b0 -> ^(J/psi(1S) -> mu+ mu-) (Lambda0 -> p+ pi-)]CC" } tuple.ToolList += [ "TupleToolMCTruth", "TupleToolMCBackgroundInfo" ] from Configurables import TupleToolMCTruth, MCTupleToolP2VV
from Gaudi.Configuration import * from Configurables import DaVinci from Configurables import GaudiSequencer simulation=False stream='Bhadron' line='StrippingB2XEtaLb2pKeta3piLine' from Configurables import DecayTreeTuple from DecayTreeTuple.Configuration import * tuple=DecayTreeTuple() tuple.Decay="[Lambda_b0 -> ^p+ ^K- ^(eta -> ^pi+ ^pi- ^(pi0 -> ^gamma ^gamma))]CC" tuple.Branches={"Lambda_b0":"[Lambda_b0 -> p+ K- (eta -> pi+ pi- (pi0 -> gamma gamma))]CC"} tuple.Inputs=['Phys/{0}/Particles'.format(line)] tuple.ToolList += [ "TupleToolGeometry" , "TupleToolDira" , "TupleToolAngles" , "TupleToolPid" , "TupleToolKinematic" , "TupleToolPropertime" , "TupleToolPrimaries" , "TupleToolEventInfo" , "TupleToolTrackInfo" , "TupleToolVtxIsoln" , "TupleToolPhotonInfo" #, "TupleToolMCTruth" #, "TupleToolMCBackgroundInfo" , "TupleToolCaloHypo"
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')", } # Other variables tuple.addTupleTool("LoKi::Hybrid::TupleTool/LoKi_All") tuple.LoKi_All.Variables = {"Eta": "ETA", "Phi": "PHI"} # Tell DecayTreeTuple the structure of your decay, you must put ^ in front # of particles that you want to write out (apart from head). J/psi->mu+mu- # is a CP eigenstate so we don't need []CC here. tuple.Decay = "[J/psi(1S) -> ^(KS0 -> ^pi+ ^pi-) ^(KS0 -> ^pi+ ^pi-)]CC" tuple.Branches = { "JPsi": "[J/psi(1S) -> (KS0 -> pi+ pi-) (KS0 -> pi+ pi-)]CC", "Ks1": "[J/psi(1S) -> ^(KS0 -> pi+ pi-) (KS0 -> pi+ pi-)CC", "Ks2": "[J/psi(1S) -> (KS0 -> pi+ pi-) ^(KS0 -> pi+ pi-)]CC", "pi1": "[J/psi(1S) -> (KS0 -> ^pi+ pi-) (KS0 -> pi+ pi-)]CC", "pi2": "[J/psi(1S) -> (KS0 -> pi+ ^pi-) (KS0 -> pi+ pi-)]CC", "pi3": "[J/psi(1S) -> (KS0 -> pi+ pi-) (KS0 -> ^pi+ pi-)]CC", "pi4": "[J/psi(1S) -> (KS0 -> pi+ pi-) (KS0 -> pi+ ^pi-)]CC", } tuple.addBranches(tuple.Branches) tuple.JPsi.addTupleTool("LoKi::Hybrid::TupleTool/LoKi_JPsi") tuple.JPsi.LoKi_JPsi.Variables = {
TurboConf().PersistReco = True pions = DataOnDemand('Phys/StdAllNoPIDsPions/Particles') ks0 = CombineParticles('Ks0Topipi', DecayDescriptors=['[KS0 -> pi+ pi+]cc'], CombinationCut=("AM < 320*MeV"), #parent MotherCut="ALL") ks0_sel = Selection( 'Sel_Ks0Topipi', Algorithm=ks0, RequiredSelections=[pions] ) ks0_selseq = SelectionSequence( 'SelSeq_Ks0Topipi', TopSelection=ks0_sel ) dtt_ks0 = DecayTreeTuple('TupleKs0Topipi') dtt_ks0.Inputs = ks0_selseq.outputLocations() dtt_ks0.Decay = '[KS0 -> ^pi+ ^pi+]CC' dtt_ks0.addBranches({ 'Ks0': '[KS0 -> pi+ pi+]CC', 'pi1': '[KS0 -> ^pi+ pi+]CC', 'pi2': '[KS0 -> pi+ ^pi+]CC' }) DaVinci().UserAlgorithms = [ks0_selseq.sequence(), dtt_ks0] DaVinci().DataType = '2016' DaVinci().EvtMax = 1000 DaVinci().TupleFile = 'PersistRecoTuple_ks0_pipi.root'
#printer.addTool( PrintDecayTreeTool, name = "PrintDecay" ) #printer.PrintDecay.Information = "Name M P Px Py Pz Pt chi2" #printer.Inputs = TupleInputs #--------------------------- # Configure lines and Decay #--------------------------- tuple = DecayTreeTuple('DetachedN') TupleInputs = [] for line in B2Lambda0MuLines: TupleInputs.append(line.outputLocation()) tuple.Inputs = TupleInputs tuple.OutputLevel = INFO tuple.Decay = "[B- -> ^(Lambda0 -> ^mu- ^pi+) ^mu-]CC" tuple.addBranches({ "B": "[B- -> (Lambda0 -> mu- pi+) mu-]CC", "N": "[B- -> ^(Lambda0 -> mu- pi+) mu-]CC", "mu_prim": "[B- -> (Lambda0 -> mu- pi+) ^mu-]CC", "mu_sec": "[B- -> (Lambda0 -> ^mu- pi+) mu-]CC", "pi": "[B- -> (Lambda0 -> mu- ^pi+) mu-]CC" }) #--------------------------- # Define nTuple Variables #--------------------------- tuple.ToolList = [ "TupleToolKinematic", "TupleToolPid",
from GaudiConf import IOHelper from Configurables import DaVinci, DecayTreeTuple from DecayTreeTuple.Configuration import * # Stream and stripping line we want to use stream = 'AllStreams' line = 'D2hhCompleteEventPromptDst2D2RSLine' # Create an ntuple to capture D*+ decays from the StrippingLine line dtt = DecayTreeTuple('TupleDstToD0pi_D0ToKpi') dtt.Inputs = ['/Event/{0}/Phys/{1}/Particles'.format(stream, line)] # Note that we mark all particles, otherwise the branches won't work dtt.Decay = '[D*(2010)+ -> ^(D0 -> ^K- ^pi+) ^pi+]CC' track_tool = dtt.addTupleTool('TupleToolTrackInfo') track_tool.Verbose = True dtt.addTupleTool('TupleToolPrimaries') dtt.addBranches({ 'Dstar': '[D*(2010)+ -> (D0 -> K- pi+) pi+]CC', 'D0': '[D*(2010)+ -> ^(D0 -> K- pi+) pi+]CC', 'Kminus': '[D*(2010)+ -> (D0 -> ^K- pi+) pi+]CC', 'piplus': '[D*(2010)+ -> (D0 -> K- ^pi+) pi+]CC', 'pisoft': '[D*(2010)+ -> (D0 -> K- pi+) ^pi+]CC' }) dtt.D0.addTupleTool('TupleToolPropertime') # Configure DaVinci DaVinci().UserAlgorithms += [dtt] DaVinci().InputType = 'DST' DaVinci().TupleFile = 'DVntuple.root'
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] for tup in tuples: tup.ReFitPVs = True
from Gaudi.Configuration import * from Configurables import (DaVinci, GaudiSequencer) 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"
from GaudiConf import IOHelper from Configurables import ( DaVinci, DecayTreeTuple, ) from DecayTreeTuple.Configuration import * # Stream and stripping line we want to use stream = 'AllStreams' line = 'D2hhPromptDst2D2KKLine' # Create an ntuple to capture D*+ decays from the StrippingLine line dtt = DecayTreeTuple('TupleDstToD0pi_D0ToKK') dtt.Inputs = ['/Event/{0}/Phys/{1}/Particles'.format(stream, line)] dtt.Decay = '[D*(2010)+ -> ^(D0 -> ^K- ^K+) ^pi+]CC' # add a kinematic fitter dtt.addBranches({ 'Dstar': '[D*(2010)+ -> (D0 -> K- K+) pi+]CC', }) dtt.Dstar.addTupleTool('TupleToolDecayTreeFitter/ConsD') dtt.Dstar.ConsD.constrainToOriginVertex = True dtt.Dstar.ConsD.Verbose = True dtt.Dstar.ConsD.daughtersToConstrain = ['D0'] # add another fitter, this time we will change a mass hypothesis dtt.Dstar.addTupleTool('TupleToolDecayTreeFitter/ConsDKpi') dtt.Dstar.ConsDKpi.constrainToOriginVertex = True dtt.Dstar.ConsDKpi.Verbose = True dtt.Dstar.ConsDKpi.daughtersToConstrain = ['D0']
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 ] for tup in tuples:
"nPVs" : "CONTAINS('/Event/Charm/Rec/Vertex/Primary')" } # Other variables tuple.addTupleTool('LoKi::Hybrid::TupleTool/LoKi_All') tuple.LoKi_All.Variables = { 'Eta' : 'ETA', 'Phi' : 'PHI', } #Tell DecayTreeTuple the structure of your decay, you must put ^ in front #of particles that you want to write out (apart from head). J/psi->mu+mu- # is a CP eigenstate so we don't need []CC here. tuple.Decay = '[D_s+ -> ^(phi(1020) -> ^(KS0 -> ^pi+ ^pi-) ^(KS0 -> ^pi+ ^pi-)) ^pi+]CC' tuple.Branches = {'Ds' : '[D_s+ -> (phi(1020) -> (KS0 -> pi+ pi-) (KS0 -> pi+ pi-)) pi+]CC', 'phi' : '[D_s+ -> ^(phi(1020) -> (KS0 -> pi+ pi-) (KS0 -> pi+ pi-)) pi+]CC', 'Ks1' : '[D_s+ -> (phi(1020) -> ^(KS0 -> pi+ pi-) (KS0 -> pi+ pi-)) pi+]CC', 'Ks2' : '[D_s+ -> (phi(1020) -> (KS0 -> pi+ pi-) ^(KS0 -> pi+ pi-)) pi+]CC', 'pi1' : '[D_s+ -> (phi(1020) -> (KS0 -> ^pi+ pi-) (KS0 -> pi+ pi-)) pi+]CC', 'pi2' : '[D_s+ -> (phi(1020) -> (KS0 -> pi+ ^pi-) (KS0 -> pi+ pi-)) pi+]CC', 'pi3' : '[D_s+ -> (phi(1020) -> (KS0 -> pi+ pi-) (KS0 -> ^pi+ pi-)) pi+]CC', 'pi4' : '[D_s+ -> (phi(1020) -> (KS0 -> pi+ pi-) (KS0 -> pi+ ^pi-)) pi+]CC', 'pis' : '[D_s+ -> (phi(1020) -> (KS0 -> pi+ pi-) (KS0 -> pi+ pi-)) ^pi+]CC', } tuple.addBranches(tuple.Branches) tuple.Ds.addTupleTool("LoKi::Hybrid::TupleTool/LoKi_Ds")
'Hlt2TopoMu3BodyBBDTDecision', 'Hlt2TopoMu4BodyBBDTDecision', 'Hlt2TransparentDecision', 'Hlt2DiMuonUnbiasedJPsiDecision' ] tuple.addTool(TupleToolGeometry) tuple.TupleToolGeometry.Verbose = True #tuple.TupleToolTISTOS.UseAutomaticTriggerList = True #tuple.addTool(TupleToolTagging) #tuple.TupleToolTagging.Verbose = True #from FlavourTagging.Tunings import TuneTool #TuneTool(tuple,'Xmass_2011') ########################################################################################################################### tuple.Decay = '[Lambda_b0 -> (^J/psi(1S) -> ^mu+ ^mu-) (^Lambda0 -> ^pi+ ^pi-)]cc' tuple.Branches = { "Bs" : "[Lambda_b0]cc : [Lambda_b0 -> (J/psi(1S) -> mu+ mu-) (Lambda0 -> pi+ pi-)]cc", "R" : "[Lambda_b0 -> (J/psi(1S) -> mu+ mu-) (^Lambda0 -> pi+ pi-)]cc", "H1" : "[Lambda_b0 -> (J/psi(1S) -> mu+ mu-) (Lambda0 -> ^pi+ pi-)]cc", "H2" : "[Lambda_b0 -> (J/psi(1S) -> mu+ mu-) (Lambda0 -> pi+ ^pi-)]cc", "J_psi_1S" : "[Lambda_b0 -> (^J/psi(1S) -> mu+ mu-) (Lambda0 -> pi+ pi-)]cc" } tuple.addTool(TupleToolDecay, name="Bs") tuple.Bs.ToolList = [ "TupleToolPropertime" ] tuple.addTool(TupleToolDecay, name="J_psi_1S") tuple.Bs.addTool(tistos) tuple.Bs.ToolList+=["TupleToolTISTOS/tistos"]
from Configurables import DecayTreeTuple dtt = DecayTreeTuple( 'SwimmingDTT', ## print histos HistoPrint=True, ## N-tuple LUN NTupleLUN="DTT", ## input particles from selection: Inputs=[particlePath], ## Primary vertices from mDST P2PVInputLocations=[p2PVLocation], UseP2PVRelations=True, WriteP2PVRelations=False, ) dtt.Decay = "B_s0 -> (^J/psi(1S) => ^mu+ ^mu-) (^phi(1020) -> ^K+ ^K-)" if mDST: dtt.RootInTES = locationRoot from DecayTreeTuple.Configuration import * ## Add appropriate tools dtt.addBranches( {"B": "B_s0 : B_s0 -> (J/psi(1S) => mu+ mu-) (phi(1020) -> K+ K-)"}) dtt.B.addTupleTool('TupleToolPropertime') ttsi = dtt.B.addTupleTool('TupleToolSwimmingInfo/TriggerInfo') ttsis = dtt.B.addTupleTool('TupleToolSwimmingInfo/StrippingInfo') ttsi.ReportsLocation = selectionPath + '/P2TPRelations' ttsis.ReportsLocation = selectionPath + '/P2TPRelations' ttsis.ReportStage = "Stripping"
# Get trigger info tuple.addTool(TupleToolTrigger, name="TupleToolTrigger") tuple.TupleToolTrigger.Verbose = True tuple.TupleToolTrigger.TriggerList = tlist # Get TISTOS info tuple.addTool(TupleToolTISTOS, name="TupleToolTISTOS") tuple.TupleToolTISTOS.Verbose = True tuple.TupleToolTISTOS.TriggerList = tlist if IsMC: tuple.addTool(TupleToolTrackIsolation, name="TupleToolTrackIsolation") tuple.TupleToolTrackIsolation.Verbose = True tuple.ToolList+=["TupleToolTrackIsolation/TupleToolTrackIsolation"] tuple.Decay = "[B0 -> ^(phi(1020) -> ^K+ ^K-) ^(rho(770)0 -> ^pi+ ^pi-)]CC" if myDecayType == 1: tuple.Decay = "[B_s0 -> ^(phi(1020) -> ^K+ ^K-) ^(rho(770)0 -> ^pi+ ^pi-)]CC" elif myDecayType ==2 : tuple.Decay = "[B_s0 -> ^(phi(1020) -> ^K+ ^K-) ^(f_0(980) -> ^pi+ ^pi-)]CC" elif myDecayType == 3: tuple.Decay = "[B_s0 -> ^(phi(1020) -> ^K+ ^K-) ^(phi(1020) -> ^K+ ^K-)]CC" if myDecayType == 1: tuple.addBranches({ "Bs" : "^([B_s0 -> (phi(1020) -> K+ K-) (rho(770)0 -> pi+ pi-)]CC)", "f0" : " [B_s0 -> (phi(1020) -> K+ K-) ^(rho(770)0 -> pi+ pi-)]CC " }) elif myDecayType == 2: tuple.addBranches({ "Bs" : "^([B_s0 -> (phi(1020) -> K+ K-) (f_0(980) -> pi+ pi-)]CC)",
####################################################################### # # Decay Tree tuple # from Configurables import DecayTreeTuple decaytuple = DecayTreeTuple("OriginalPionsTuple") decaytuple.InputLocations = [_seqPions.outputLocation() ] decaytuple.ToolList += [ "TupleToolGeometry" , "TupleToolKinematic" , "TupleToolTrackInfo" , "TupleToolPid" ] decaytuple.Decay = "[pi+]cc" from Configurables import TupleToolTrigger decaytuple.addTool( TupleToolTrigger, name='TupleToolTrigger' ) decaytuple.TupleToolTrigger.Verbose = True decaytuple.TupleToolTrigger.UseAutomaticTriggerList = False decaytuple.TupleToolTrigger.TriggerList =[ "Hlt1MBNoBiasDecision", "Hlt1MBMicroBiasRZVeloDecision", "Hlt1MBMicroBiasTStationDecision", ] decaytuple.ToolList += [ "TupleToolTrigger" ] decaytuple4 = DecayTreeTuple("OriginalKaonsTuple") decaytuple4.InputLocations = [_seqKaons.outputLocation() ]
# Create the actual Stripping configurable filterBadEvents = ProcStatusCheck() sc = StrippingConf(Streams=[custom_stream], MaxCandidates=2000, AcceptBadEvents=False, BadEventSelection=filterBadEvents) # The output is placed directly into Phys, so we only need to # define the stripping line here line = 'D2hhCompleteEventPromptDst2D2RSLine' # Create an ntuple to capture D*+ decays from the StrippingLine line dtt = DecayTreeTuple('TupleDstToD0pi_D0ToKpi') dtt.Inputs = ['/Event/Phys/{0}/Particles'.format(line)] dtt.Decay = '[D*(2010)+ -> (D0 -> K- pi+) pi+]CC' # Configure DaVinci # Important: The selection sequence needs to be inserted into # the Gaudi sequence for the stripping to run DaVinci().appendToMainSequence([event_node_killer, sc.sequence()]) DaVinci().UserAlgorithms += [dtt] DaVinci().InputType = 'DST' DaVinci().TupleFile = 'DVntuple.root' DaVinci().PrintFreq = 1000 DaVinci().DataType = '2012' DaVinci().Simulation = True # Only ask for luminosity information when not using simulated data DaVinci().Lumi = not DaVinci().Simulation DaVinci().EvtMax = 5000
from Configurables import DecayTreeTuple from DecayTreeTuple.Configuration import * # Stream and stripping line we want to use stream = 'AllStreams' line = 'D2hhPromptDst2D2KKLine' # Create an ntuple to capture D*+ decays from the StrippingLine line dtt = DecayTreeTuple('TupleDstToD0pi_D0ToKK') dtt.Inputs = ['/Event/{0}/Phys/{1}/Particles'.format(stream, line)] #Phys/{0}/Particles'.format(line)] # for microDST #dtt.Decay = '[D*(2010)+ -> (D0 -> K- K+) pi+]CC' # written like this means tuple tools only runs on the D*(2010)+, to select particles to store information on mark them with a ^, e.g.: dtt.Decay = '[D*(2010)+ -> ^(D0 -> ^K- ^K+) ^pi+]CC' # but this not ideal as we may only want to run some tools on D and some on children, use Branches below # CC means "and also equivalent C conjugated decay" ? # Additional tuple tools: track_tool = dtt.addTupleTool('TupleToolTrackInfo') # Only need to store a tool in a variable if you want to configure it: track_tool.Verbose = True # 'Verbose' - further information dtt.addTupleTool('TupleToolPrimaries') dtt.addBranches({'Dstar' :'[D*(2010)+ -> (D0 -> K- K+) pi+]CC', 'D0' :'[D*(2010)+ -> ^(D0 -> K- K+) pi+]CC', 'Kminus' :'[D*(2010)+ -> (D0 -> ^K- K+) pi+]CC', 'Kplus' :'[D*(2010)+ -> (D0 -> K- ^K+) pi+]CC', 'pisoft' :'[D*(2010)+ -> (D0 -> K- K+) ^pi+]CC'}) # and mark particles which we want to use in dtt.Decay (with ^ ?)!! # Alternativley, use setDescriptorTemplate() to do all this in one line: #dtt.setDescriptorTemplate('${Dstar}[D*(2010)+ -> ${D0}(D0 -> ${Kminus}K- ${Kplus}K+) ${pisoft}pi+]CC') # sets up both dtt.Decay and Branches # Access branches with dtt.PARTICLENAME dtt.D0.addTupleTool('TupleToolPropertime') # e.g. of adding tuple tools to specific particles ''' All tuple tools start with DecayTreeTuple here: https://gitlab.cern.ch/lhcb/Analysis/tree/master/Phys DecayTreeTuple for the more general tools;
tuple.Jpsi.JpsiTISTOS.Verbose = True tuple.Jpsi.JpsiTISTOS.TriggerList = list tuple.Kplus.ToolList += [ "TupleToolTISTOS/KplusTISTOS" ] tuple.Kplus.addTool( TupleToolTISTOS, name = "KplusTISTOS" ) tuple.Kplus.KplusTISTOS.Verbose = True tuple.Kplus.KplusTISTOS.TriggerList = list tuple.muplus.ToolList += [ "TupleToolTISTOS/muplusTISTOS" ] tuple.muplus.addTool( TupleToolTISTOS, name = "muplusTISTOS" ) tuple.muplus.muplusTISTOS.Verbose = True tuple.muplus.muplusTISTOS.TriggerList = list tuple.muminus.ToolList += [ "TupleToolTISTOS/muminusTISTOS" ] tuple.muminus.addTool( TupleToolTISTOS, name = "muminusTISTOS" ) tuple.muminus.muminusTISTOS.Verbose = True tuple.muminus.muminusTISTOS.TriggerList = list tuple.Decay = '[B+ -> ^(J/psi(1S) -> ^mu+ ^mu-) ^K+]CC' from Configurables import DaVinci DaVinci().TupleFile = "BuKll.root" DaVinci().EvtMax = -1 DaVinci().DataType = '2011' DaVinci().Simulation = False DaVinci().Lumi = True #CondDB().UseOracle = True CondDB( LatestGlobalTagByDataType = '2011' ) _myseq = GaudiSequencer("myseq") _myseq.Members += [ tuple] DaVinci().UserAlgorithms = [_myseq]
tuple.B0.addTool(TupleToolApplyIsolation, name="TupleToolApplyIsolation") # TISTOS tools tuple.B0.ToolList += [ "TupleToolTISTOS" ] tuple.B0.addTool( TupleToolTISTOS, name = "TupleToolTISTOS" ) tuple.B0.TupleToolTISTOS.Verbose = True tuple.B0.TupleToolTISTOS.TriggerList = list tuple.muplus.ToolList += [ "TupleToolTISTOS" ] tuple.muplus.addTool( TupleToolTISTOS, name = "TupleToolTISTOS" ) tuple.muplus.TupleToolTISTOS.Verbose = True tuple.muplus.TupleToolTISTOS.TriggerList = list tuple.muminus.ToolList += [ "TupleToolTISTOS" ] tuple.muminus.addTool( TupleToolTISTOS, name = "TupleToolTISTOS" ) tuple.muminus.TupleToolTISTOS.Verbose = True tuple.muminus.TupleToolTISTOS.TriggerList = list tuple.Decay = "[B0 -> ^mu+ ^mu-]CC" from Configurables import DaVinci DaVinci().TupleFile = "TupleToolSignalMC.root" DaVinci().EvtMax = -1 DaVinci().DataType = '2012' DaVinci().Simulation = True DaVinci().Lumi = False #CondDB().UseOracle = True #DaVinci().DDDBtag = "dddb-20120831" #DaVinci().CondDBtag = "sim-20121025-vc-md100" myseq = GaudiSequencer("myseq") myseq.Members += [ eventNodeKiller ] myseq.Members += [ sc.sequence() ] myseq.Members += [ seq.sequence() ]
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 ]
SelSeqMuMu = SelectionSequence("SeqMuMu", TopSelection=mumuNBSel) SelSeqMuMuAll = SelectionSequence("SeqMuMuAll", TopSelection=mumuSel) SeqJPsi = SelSeqJPsi.sequence() SeqMuMu = SelSeqMuMu.sequence() SeqMuMuAll = SelSeqMuMuAll.sequence() ######################################################################## # # NTupling # from Configurables import DecayTreeTuple tupleMuMu = DecayTreeTuple("tupleMuMu") tupleMuMu.InputLocations = [SelSeqMuMu.outputLocation()] tupleMuMu.Decay = "J/psi(1S) -> ^mu+ ^mu-" tupleMuMu.ToolList += [ "TupleToolGeometry", "TupleToolKinematic", "TupleToolPrimaries", "TupleToolTrackInfo", "TupleToolPid", "TupleToolEventInfo", "TupleToolPropertime", "LoKi::Hybrid::TupleTool/LoKiTupleMuMu" ] from Configurables import LoKi__Hybrid__TupleTool LoKiTupleMuMu = LoKi__Hybrid__TupleTool("LoKiTupleMuMu") LoKiTupleMuMu.Variables = { "Charge": "Q", "DOCA": "DOCA(1,2)", "DOCAMAX": "DOCAMAX", "NetOut": "INFO(LHCb.Particle.LastGlobal+1, -999)", "NetProb": "INFO(LHCb.Particle.LastGlobal+2, -999)" }
from Configurables import DecayTreeTuple from DecayTreeTuple.Configuration import * from Configurables import DaVinci # Stream and stripping line we want to use stream = 'AllStreams' line = 'D2hhPromptDst2D2KKLine' # Create an ntuple to capture D*+ decays from the StrippingLine line dtt = DecayTreeTuple('TupleDstToD0pi_D0ToKK') dtt.Inputs = ['/Event/{0}/Phys/{1}/Particles'.format(stream, line)] dtt.Decay = '[D*(2010)+ -> (D0 -> K- K+) pi+]CC' # Configure DaVinci DaVinci().UserAlgorithms += [dtt] DaVinci().InputType = 'DST' DaVinci().TupleFile = 'DVntuple.root' DaVinci().PrintFreq = 1000 DaVinci().DataType = '2016' DaVinci().Simulation = True # Only ask for luminosity information when not using simulated data DaVinci().Lumi = not DaVinci().Simulation DaVinci().EvtMax = -1 DaVinci().CondDBtag = 'sim-20161124-2-vc-md100' DaVinci().DDDBtag = 'dddb-20150724'
] tuple.Bplus.ToolList += [ "TupleToolTISTOS" ] tuple.Bplus.addTool( TupleToolTISTOS, name = "TupleToolTISTOS" ) tuple.Bplus.TupleToolTISTOS.Verbose = True tuple.Bplus.TupleToolTISTOS.TriggerList = list tuple.Jpsi.ToolList += [ "TupleToolTISTOS" ] tuple.Jpsi.addTool( TupleToolTISTOS, name = "TupleToolTISTOS" ) tuple.Jpsi.TupleToolTISTOS.Verbose = True tuple.Jpsi.TupleToolTISTOS.TriggerList = list tuple.Kplus.ToolList += [ "TupleToolTISTOS" ] tuple.Kplus.addTool( TupleToolTISTOS, name = "TupleToolTISTOS" ) tuple.Kplus.TupleToolTISTOS.Verbose = True tuple.Kplus.TupleToolTISTOS.TriggerList = list tuple.Decay = '[B+ -> ^(J/psi(1S) -> ^e+ ^e-) ^K+]CC' from Configurables import DaVinci DaVinci().TupleFile = "BuKll.root" DaVinci().EvtMax = -1 DaVinci().DataType = '2012' DaVinci().Simulation = False DaVinci().Lumi = True #CondDB().UseOracle = True CondDB( LatestGlobalTagByDataType = '2012' ) _myseq = GaudiSequencer("myseq") #_myseq.Members += [ DecayTreeFitterB] _myseq.Members += [ tuple] DaVinci().UserAlgorithms = [_myseq]
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": "[Lambda_b0 -> (chi_c1(1P) -> (J/psi(1S) -> mu+ mu-) gamma) ^p+ K-]CC",
####################################################################### # # Decay Tree tuple # from Configurables import DecayTreeTuple decaytuple = DecayTreeTuple("OriginalPionsTuple") decaytuple.InputLocations = [_seqPions.outputLocation() ] decaytuple.ToolList += [ "TupleToolGeometry" , "TupleToolKinematic" , "TupleToolTrackInfo" , "TupleToolPid" ] decaytuple.Decay = "[pi+]cc" decaytuple2 = DecayTreeTuple("SmearedPionsTuple") decaytuple2.InputLocations = [_seqPions2.outputLocation() ] decaytuple2.ToolList += [ "TupleToolGeometry" , "TupleToolKinematic" , "TupleToolTrackInfo" , "TupleToolPid" ] decaytuple2.Decay = "[pi+]cc" ####################################################################### # # Configure the application