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'
