def Tuples(): """ Simple class-like method to return DecayTreeTuple which can be used to do quick-check on the output DST. Usage: >> from StrippingSelections.StrippingQEE import StrippingDitau >> DaVinci().appendToMainSequence( StrippingDitau.Tuples() ) >> DaVinci().TupleFile = 'tuple.root' """ import re from DecayTreeTuple.Configuration import DecayTreeTuple, EventTuple seq = GaudiSequencer('TupleSeq') seq.ModeOR = True seq.ShortCircuit = False for lname, decays in lines_decays.iteritems(): for process, desc in decays.iteritems(): desc = re.sub(r' ([a-z])', r' ^\1', desc) # regex insert ^ desc = desc.replace('cc', 'CC') # different between CombineP & DTT # ## Extra complication for cand with RIF, such that the input location # after isolation filter is not at default line location, but on the # last algo's location. Otherwise the tuple will pick up candidates # before isolation filtering. root = 'Phys/Ditau%sLine' % lname # if 'noiso' not in root: # root = root.replace('Line','isoLine') # tup = DecayTreeTuple('Tup_' + process, NTupleDir='Ditau', TupleName=process) tup.Inputs = [root + '/Particles'] tup.Decay = desc tup.ToolList = [ 'TupleToolKinematic', ] tool = tup.addTupleTool('TupleToolConeIsolation') tool.MinConeSize = 0.5 tool.MaxConeSize = 0.5 tool = tup.addTupleTool('LoKi::Hybrid::TupleTool') tool.Variables = { 'CONEPX1': "RELINFO('%s/IsoPlus' , 'CONEPX')" % root, 'CONEPX2': "RELINFO('%s/IsoMinus', 'CONEPX')" % root, 'CONEPY1': "RELINFO('%s/IsoPlus' , 'CONEPY')" % root, 'CONEPY2': "RELINFO('%s/IsoMinus', 'CONEPY')" % root, 'CONEPT1': "RELINFO('%s/IsoPlus' , 'CONEPT')" % root, 'CONEPT2': "RELINFO('%s/IsoMinus', 'CONEPT')" % root, } seq.Members.append(tup) return [seq]
# "Jpsi" : "^(J/psi(1S) -> mu- mu+)", # "muplus" : "J/psi -> mu- ^mu+", # "muminus" : "J/psi -> ^mu- mu+" # }) ### Bplus tools ### Jpsi tools #BJpsiKS.Jpsi.addTupleTool("TupleToolDownEff") ################################################################ ################################################################ Seq1 = GaudiSequencer("Seq1") Seq1.Members += [ SeqKsPiPi.sequence(), KsPiPiTuple ] Seq1.Members += [ SeqLambdaPPi.sequence(), LambdaPPiTuple ] Seq1.ShortCircuit = False Seq1.ModeOR = True # ###################################################################################################### DaVinci().MainOptions = "" DaVinci().UserAlgorithms = [Seq1] ######################################################################## DaVinci().EvtMax = -1 DaVinci().DataType = "2016" DaVinci().PrintFreq = 100 DaVinci().Lumi = False DaVinci().InputType = "DST" if simulation is True: DaVinci().Simulation = True DaVinci().Lumi = False DaVinci().InputType = "DST"
particlesAndCuts = { "/Event/AllStreams/Phys/FullDSTDiMuonJpsi2MuMuDetachedLine/Particles" : "ALL" } from PhysSelPython.Wrappers import Selection, SelectionSequence, AutomaticData from Configurables import FilterDesktop myInputParticlesList = [] myParticlesFilterList = [] myParticlesList = [] myParticlesSeqList = [] myParticlesLocationList = [] from Configurables import GaudiSequencer filterSeq = GaudiSequencer( 'FilterSeq' ) filterSeq.ModeOR = True mainSeq = GaudiSequencer( 'MainSeq' ) mainSeq.MeasureTime = True mainSeq.IgnoreFilterPassed = False codeIN = "" for particles, cuts in particlesAndCuts.iteritems(): codeIN = codeIN.replace("||","|") codeIN += "(CONTAINS( '"+str(particles)+"' )>0) || " myParticlesName = particles.split("/")[-2] myInputParticlesList += [ AutomaticData( Location = particles ) ]
def configureSequences(self, withMC, handleLumi, vetoHltErrorEvents): brunelSeq = GaudiSequencer("BrunelSequencer") brunelSeq.Context = self.getProp("Context") ApplicationMgr().TopAlg += [ brunelSeq ] brunelSeq.Members += [ "ProcessPhase/Init" ] physicsSeq = GaudiSequencer( "PhysicsSeq" ) # Treatment of luminosity events if handleLumi: lumiSeq = GaudiSequencer("LumiSeq") # Prepare the FSR if self.getProp("WriteFSR"): self.setOtherProps(LumiAlgsConf(),["Context","DataType","InputType","Simulation"]) lumiCounters = GaudiSequencer("LumiCounters") lumiSeq.Members += [ lumiCounters ] LumiAlgsConf().LumiSequencer = lumiCounters # Trigger masks changed in 2016, see LHCBPS-1486 if self.getProp( "DataType" ) in self.Run1DataTypes or self.getProp( "DataType" ) in [ "2015" ]: physFilterRequireMask = [ 0x0, 0x4, 0x0 ] lumiFilterRequireMask = [ 0x0, 0x2, 0x0 ] else: physFilterRequireMask = [ 0x0, 0x0, 0x80000000 ] lumiFilterRequireMask = [ 0x0, 0x0, 0x40000000 ] # Filter out Lumi only triggers from further processing, but still write to output from Configurables import HltRoutingBitsFilter physFilter = HltRoutingBitsFilter( "PhysFilter", RequireMask = physFilterRequireMask ) physicsSeq.Members += [ physFilter ] lumiFilter = HltRoutingBitsFilter( "LumiFilter", RequireMask = lumiFilterRequireMask ) lumiSeq.Members += [ lumiFilter, physFilter ] lumiSeq.ModeOR = True # Sequence to be executed if physics sequence not called (nano events) notPhysSeq = GaudiSequencer("NotPhysicsSeq") notPhysSeq.ModeOR = True notPhysSeq.Members = [ physFilter ] brunelSeq.Members += [ lumiSeq, notPhysSeq ] # Hlt decreports decoders from DAQSys.Decoders import DecoderDB from Configurables import LoKi__HDRFilter, AddToProcStatus hltStages = ('Hlt1',) if self.getProp('OnlineMode') else ('Hlt1', 'Hlt2') hltDecoders = [] hltErrorFilters = [] hltFilters = [] for stage in hltStages: decoder = DecoderDB["HltDecReportsDecoder/%sDecReportsDecoder" % stage].setup() hltDecoders += [decoder] # decode DecReports # identifies events that are not of type ErrorEvent errorFilterCode = "HLT_PASS_RE('%s(?!ErrorEvent).*Decision')" % stage hltErrorFilter = LoKi__HDRFilter('%sErrorFilter' % stage, Code = errorFilterCode, Location = decoder.OutputHltDecReportsLocation) hltErrorFilters += [decoder, hltErrorFilter] # and apply filter filterCode = self.getProp(stage + "FilterCode") if filterCode: hltFilter = LoKi__HDRFilter('%sFilter' % stage, Code = filterCode, Location = decoder.OutputHltDecReportsLocation) hltFilters += [decoder, hltFilter] # Do not process events flagged as error in Hlt, but still write procstatus if vetoHltErrorEvents: """ By Patrick Koppenburg, 16/6/2011 """ # Make a sequence that selects HltErrorEvents hltErrorFilterSeq = GaudiSequencer("HltErrorFilterSeq") if handleLumi: hltErrorFilterSeq.Members = [ physFilter ] # protect against lumi (that doesn't have decreports) hltErrorFilterSeq.Members += hltErrorFilters # Sequence to be executed if HltErrorFilter is failing to set ProcStatus hltErrorSeq = GaudiSequencer("HltErrorSeq", ModeOR = True, ShortCircuit = True) # anti-logic addToProc = AddToProcStatus("HltErrorProc", Reason = "HltError", Subsystem = "Hlt") # write a procstatus hltErrorSeq.Members += [hltErrorFilterSeq, addToProc] # only run if hltErrorFilterSeq fails brunelSeq.Members += [hltErrorSeq] # add this sequece to Brunel _before_ physseq physicsSeq.Members += [hltErrorFilterSeq] # take good events in physics seq # Filter events based on HLT decisions if filters were specified if hltFilters: hltFilterSeq = GaudiSequencer("HltFilterSeq") hltFilterSeq.Members = hltFilters physicsSeq.Members += [hltFilterSeq] # Convert Calo ReadoutStatus to ProcStatus caloBanks=GaudiSequencer("CaloBanksHandler") caloDetectors = [det for det in ['Spd','Prs','Ecal','Hcal'] if det in self.getProp("Detectors")] CaloDigitConf(ReadoutStatusConvert=True,Sequence=caloBanks,Detectors=caloDetectors) physicsSeq.Members += [caloBanks] # Decode L0 (and HLT if not already done) trgSeq = GaudiSequencer("DecodeTriggerSeq") l0TrgSeq = GaudiSequencer("L0TriggerSeq") if self.getProp( "DataType" ) not in [ "2008", "2009" ]: trgSeq.Members += hltDecoders trgSeq.Members += [ l0TrgSeq ] physicsSeq.Members += [ trgSeq ] L0Conf().L0Sequencer = l0TrgSeq if self.getProp("RecL0Only"): # Setup L0 filtering if requested, runs L0 before Reco L0Conf().FilterL0FromRaw = True self.setOtherProps( L0Conf(), ["DataType"] ) else: L0Conf().DecodeL0DU = True if not self.isPropertySet("MainSequence"): if withMC: mainSeq = self.DefaultMCSequence else: mainSeq = self.DefaultSequence self.MainSequence = mainSeq physicsSeq.Members += self.getProp("MainSequence") from Configurables import ProcessPhase outputPhase = ProcessPhase("Output") brunelSeq.Members += [ physicsSeq ] brunelSeq.Members += [ outputPhase ]
def _configureForOnline(self): # DecodeRawEvent().DataOnDemand=False writer=InputCopyStream( self.writerName ) DstConf().setProp("SplitRawEventOutput", self.getProp("RawFormatVersion")) # Use RawEventJuggler to create the Turbo stream raw event format tck = "0x409f0045" # DUMMY TurboBanksSeq=GaudiSequencer("TurboBanksSeq") RawEventJuggler().TCK=tck RawEventJuggler().Input="Moore" RawEventJuggler().Output=self.getProp("RawFormatVersion") RawEventJuggler().Sequencer=TurboBanksSeq RawEventJuggler().WriterOptItemList=writer RawEventJuggler().KillExtraNodes=True RawEventJuggler().KillExtraBanks=True RawEventJuggler().KillExtraDirectories = True self.teslaSeq.Members += [TurboBanksSeq] # Begin Lumi configuration lumiSeq = GaudiSequencer("LumiSeq") # # Add ODIN decoder to LumiSeq *** from DAQSys.Decoders import DecoderDB CreateODIN=DecoderDB["createODIN"].setup() #******************************** # # Main algorithm config lumiCounters = GaudiSequencer("LumiCounters") lumiCounters.Members+=[CreateODIN] lumiSeq.Members += [ lumiCounters ] LumiAlgsConf().LumiSequencer = lumiCounters LumiAlgsConf().OutputLevel = self.getProp('OutputLevel') LumiAlgsConf().InputType = "MDF" # # Filter out Lumi only triggers from further processing, but still write to output # Trigger masks changed in 2016, see LHCBPS-1486 physFilterRequireMask = [] lumiFilterRequireMask = [] if self.getProp( "DataType" ) in ["2012","2015"]: # 2012 needed for nightlies tests. physFilterRequireMask = [ 0x0, 0x4, 0x0 ] lumiFilterRequireMask = [ 0x0, 0x2, 0x0 ] else: physFilterRequireMask = [ 0x0, 0x0, 0x80000000 ] lumiFilterRequireMask = [ 0x0, 0x0, 0x40000000 ] from Configurables import HltRoutingBitsFilter physFilter = HltRoutingBitsFilter( "PhysFilter", RequireMask = physFilterRequireMask ) lumiFilter = HltRoutingBitsFilter( "LumiFilter", RequireMask = lumiFilterRequireMask ) lumiSeq.Members += [ lumiFilter, physFilter ] lumiSeq.ModeOR = True # from Configurables import RecordStream FSRWriter = RecordStream( "FSROutputStreamDstWriter") FSRWriter.OutputLevel = INFO # # Sequence to be executed if physics sequence not called (nano events) notPhysSeq = GaudiSequencer("NotPhysicsSeq") notPhysSeq.ModeOR = True notPhysSeq.Members = [ physFilter ] writer.AcceptAlgs += ["LumiSeq","NotPhysicsSeq"] self.teslaSeq.Members += [lumiSeq, notPhysSeq]
##################### BuTuple ############################# BuTuple.Branches = {"Bplus": "[B+]cc : [B+ -> (J/psi(1S) => mu+ mu-) K+]cc"} BuTuple.addTool(TupleToolDecay, name="Bplus") BuTuple.Bplus.ToolList += ["LoKi::Hybrid::TupleTool/LoKi_SpecificToB"] BuTuple.Bplus.addTool(LoKi_SpecificToB) BuTuple.addTool(TupleToolGeometry) BuTuple.Bplus.addTool(TupleToolTISTOS) BuTuple.Bplus.TupleToolTISTOS.addTool(TriggerTisTos, "TriggerTisTos") BuTuple.Bplus.TupleToolTISTOS.TriggerTisTos.TOSFracMuon = 0. BuTuple.Bplus.ToolList += ["TupleToolTISTOS"] ########################################################### ########################################################### TupleSeq.ModeOR = True TupleSeq.ShortCircuit = False ########################################################### seqB2JpsiX.Members += [TupleSeq] seqB2JpsiX.ModeOR = True seqB2JpsiX.ShortCircuit = False from Configurables import EventTuple, TupleToolTrigger evtTuple = EventTuple() evtTuple.ToolList += ["TupleToolEventInfo", "TupleToolTrigger"] #DaVinci().EvtMax = -1 DaVinci().EvtMax = 5000 DaVinci().SkipEvents = -1 DaVinci().DataType = '2011'