def configureL0FromRawBank(trunk):
"""
Build L0 Muon, Calo candidates and L0DUReport from raw banks on-demand. Puts data in trunk + <standard locations>
"""
from Configurables import L0Conf
L0Conf().FullL0MuonDecoding = True
L0Conf().EnableL0DecodingOnDemand = True
from Configurables import (L0MuonCandidatesFromRaw,
L0CaloCandidatesFromRaw, L0DUFromRawAlg)
locationRoot = fixTrunk(trunk)
name = trunkName(trunk)
DataOnDemandSvc().AlgMap[locationRoot +
"Trig/L0/MuonBCSU"] = L0MuonCandidatesFromRaw(
name="L0MuonFromRaw" + name,
RootInTES=locationRoot)
DataOnDemandSvc().AlgMap[locationRoot +
"Trig/L0/FullCalo"] = L0CaloCandidatesFromRaw(
name="L0CaloFromRaw" + name,
RootInTES=locationRoot)
DataOnDemandSvc().AlgMap[locationRoot +
"Trig/L0/L0DUReport"] = L0DUFromRawAlg(
name="L0DUFromRaw" + name,
RootInTES=locationRoot)
def configureDigiL0(self, seq, tae):
if tae == "":
# L0 trigger Simulation
from Configurables import L0Conf
L0Conf().L0Sequencer = seq
L0Conf().SimulateL0 = True
self.setOtherProps(L0Conf(), ["DataType"])
else:
raise RuntimeError("TAE not implemented for L0")
def _decReports(self):
"""
Make L0 reports look just like HLT reports
"""
from Configurables import L0SelReportsMaker, L0DecReportsMaker
DataOnDemandSvc().AlgMap["HltLikeL0/DecReports"] = L0DecReportsMaker(
OutputLevel=4)
DataOnDemandSvc().AlgMap["HltLikeL0/SelReports"] = L0SelReportsMaker(
OutputLevel=4)
from Configurables import L0Conf
L0Conf().FullL0MuonDecoding = True
L0Conf().EnableL0DecodingOnDemand = True
def __apply_configuration__(self):
#print "WAAAAAAAAAAAAAHHHHHHHHHHHHHHHH"
############## Set other properties ###########
self._safeSet(LHCbApp(), [
'EvtMax', 'SkipEvents', 'Simulation', 'DataType', 'CondDBtag',
'DDDBtag'
])
ApplicationMgr().AppName = "L0App within Moore"
############## The raw event ##################
from Configurables import DataOnDemandSvc
dod = DataOnDemandSvc()
if dod not in ApplicationMgr().ExtSvc:
ApplicationMgr().ExtSvc.append(dod)
DecodeRawEvent().DataOnDemand = True
importOptions("$L0TCK/L0DUConfig.opts")
self._setRawEventLocations()
############## The L0 Part ###################
from DAQSys.Decoders import DecoderDB
l0du = DecoderDB["L0DUFromRawTool"]
l0du.Properties["StatusOnTES"] = False
#configure L0 Sequence
l0seq = GaudiSequencer("L0")
ApplicationMgr().TopAlg += [l0seq]
L0TCK = '0x%s' % self.getProp('TCK')[-4:]
L0Conf().setProp("TCK", L0TCK)
L0Conf().setProp("L0Sequencer", l0seq)
self.setOtherProps(L0Conf(), ["DataType"])
if (self.getProp("ReplaceL0Banks")):
L0Conf().setProp("ReplaceL0BanksWithEmulated", True)
else:
L0Conf().setProp("SimulateL0", True)
#done, that was quite easy, now for the output files
self._configureOutput()
def configureFilter(self):
"""
Set up the filter sequence to selectively write out events
"""
filterDets = self.getProp("FilterSequence")
for det in filterDets:
if det not in self.KnownFilterSubdets:
log.warning("Unknown subdet '%s' in FilterSequence" % det)
filterSeq = ProcessPhase("Filter", ModeOR=True)
filterSeq.DetectorList += filterDets
if "L0" in filterDets:
from Configurables import L0Conf
L0Conf().FilterSequencer = GaudiSequencer("FilterL0Seq")
if "ODIN" in filterDets:
from Configurables import OdinTypesFilter
odinFilter = OdinTypesFilter()
GaudiSequencer("FilterODINSeq").Members += [odinFilter]
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 defineOptions(self):
# Kept for Dirac backward compatibility
if self.getProp( "NoWarnings" ) :
log.warning("Brunel().NoWarnings=True property is obsolete and maintained for Dirac compatibility. Please use Brunel().ProductionMode=True instead")
self.setProp( "ProductionMode", True )
# Special settings for production
if self.getProp( "ProductionMode" ) :
if not self.isPropertySet( "OutputLevel" ) :
self.setProp("OutputLevel", ERROR)
if not LHCbApp().isPropertySet( "TimeStamp" ) :
LHCbApp().setProp( "TimeStamp", True )
if not self.isPropertySet( "PrintFreq" ) :
self.setProp("PrintFreq", 1000)
# HC does not exist in Run 1, so use appropriate split output
if self.getProp( "DataType" ) in self.Run1DataTypes :
if not self.isPropertySet( "SplitRawEventOutput" ) :
self.setProp( "SplitRawEventOutput", 4.0 )
# Online mode
if self.getProp( "OnlineMode" ) :
if not self.isPropertySet("Histograms") :
self.setProp("Histograms","Online")
if not CondDB().isPropertySet("Online") :
CondDB().setProp("Online", True)
inputType = self.getProp( "InputType" ).upper()
if inputType not in self.KnownInputTypes:
raise TypeError( "Invalid inputType '%s'"%inputType )
outputType = self.getProp( "OutputType" ).upper()
histOpt = self.getProp("Histograms")
if histOpt not in self.KnownHistograms:
raise RuntimeError("Unknown Histograms option '%s'"%histOpt)
withMC = self.getProp("WithMC")
if withMC:
if inputType in [ "MDF" ]:
log.warning( "WithMC = True, but InputType = '%s'. Forcing WithMC = False"%inputType )
withMC = False # Force it, MDF never contains MC truth
if outputType in [ "RDST" ]:
log.warning( "WithMC = True, but OutputType = '%s'. Forcing WithMC = False"%inputType )
withMC = False # Force it, RDST never contains MC truth
if self.getProp("WriteFSR") and self.getProp("PackType").upper() in ["MDF"]:
if hasattr( self, "WriteFSR" ): log.warning("Don't know how to write FSR to MDF output file")
self.setProp("WriteFSR", False)
if self.getProp( "MergeGenFSR") and not self.getProp( "Simulation" ):
if hasattr( self, "MergeGenFSR" ): log.warning("Cannot MergeGenFSR on real data")
self.setProp( "MergeGenFSR", False )
# Do not look for Hlt errors in data without HltDecReports bank
if self.getProp( "DataType" ) in [ "2008", "2009" ]:
self.setProp( "VetoHltErrorEvents", False )
# For simulation, change the default but allow to override
if self.getProp( "Simulation" ) and not hasattr( self, "VetoHltErrorEvents" ):
self.setProp( "VetoHltErrorEvents", False )
# Flag to handle or not LumiEvents
handleLumi = inputType in ["MDF"] and not withMC and not self.getProp('UseDBSnapshot')
# Top level configuration for skipping tracking
if self.getProp("SkipTracking"):
if inputType in ["MDF", "DIGI" ]:
raise RuntimeError( "Cannot skip tracking if tracks not present on the input file" )
if withMC:
raise RuntimeError( "SkipTracking not (yet) supported for simulation input" )
if( self.getProp("DataType") is "Upgrade"):
raise RuntimeError( "SkipTracking not (yet) supported for Upgrade configurations" )
ApplicationMgr().ExtSvc += [ "DataOnDemandSvc" ] # to decode the tracks from the DST
DstConf().setProp("EnableUnpack", ["Tracking"] )
# veto Hlt Error Events
vetoHltErrorEvents = self.getProp("VetoHltErrorEvents")
self.configureSequences( withMC, handleLumi, vetoHltErrorEvents )
self.configureInit( inputType )
self.configureInput( inputType )
self.configureOutput( outputType, withMC, handleLumi )
if withMC:
# Create associators for checking and for DST
from Configurables import ProcessPhase
ProcessPhase("MCLinks").DetectorList += self.getProp("MCLinksSequence")
# Unpack Sim data
GaudiSequencer("MCLinksUnpackSeq").Members += [ "UnpackMCParticle"]
# particle gun uses MCVertex to fake a reconstructed one
# unpacking again would lead to crash
if "pGun" not in self.getProp("SpecialData"):
GaudiSequencer("MCLinksUnpackSeq").Members += [ "UnpackMCVertex" ]
else:
# Cannot run trigger on pGun events...
L0Conf().EnsureKnownTCK=False
GaudiSequencer("MCLinksTrSeq").Members += [ "TrackAssociator" ]
GaudiSequencer("MCLinksCaloSeq").Members += [ "CaloDigit2MCLinks2Table", "CaloClusterMCTruth", "CaloHypoMCTruth" ]
# activate all configured checking (uses MC truth)
self.configureCheck( histOpt == "Expert" )
# data on demand needed to pack RichDigitSummary for DST, when reading unpacked DIGI
# Also needed to unpack MCHit containers when expert checking enabled
ApplicationMgr().ExtSvc += [ "DataOnDemandSvc" ]
# ROOT persistency for histograms
ApplicationMgr().HistogramPersistency = "ROOT"
from Configurables import RootHistCnv__PersSvc
RootHistCnv__PersSvc('RootHistCnv').ForceAlphaIds = True
if histOpt == "None" or histOpt == "":
# HistogramPersistency still needed to read in CaloPID DLLs.
# so do not set ApplicationMgr().HistogramPersistency = "NONE"
return
# Pass expert checking option to RecSys and RecMoni
if histOpt == "Expert":
DstConf().EnablePackingChecks = True
# Use a default histogram file name if not already set
if not HistogramPersistencySvc().isPropertySet( "OutputFile" ):
histosName = self.getProp("DatasetName")
if histosName == "": histosName = "Brunel"
if self.getProp( "RecL0Only" ): histosName += '-L0Yes'
if (self.evtMax() > 0): histosName += '-' + str(self.evtMax()) + 'ev'
if histOpt == "Expert": histosName += '-expert'
histosName += '-histos.root'
HistogramPersistencySvc().OutputFile = histosName
#reconfigure decoders to point to default location, if required!
if DecodeRawEvent().isPropertySet("OverrideInputs") and DecodeRawEvent().getProp("OverrideInputs") is not None:
#do nothing, it's been configured by someone else!
pass
elif self.isPropertySet("SplitRawEventInput") and self.getProp("SplitRawEventInput") is not None:
#print "WAAAAH Overriding RawEvent Locations"
DecodeRawEvent().setProp("OverrideInputs",self.getProp("SplitRawEventInput"))
elif inputType in [ "MDF", "DIGI", "XDIGI" ]:
#set to the default of what comes out of Moore
DecodeRawEvent().setProp("OverrideInputs","Moore")
#remember that the default is a long list of locations,
#starting with places which only exist _after_ brunel has run!
# Following needed to build RecSummary, even if tracking is skipped.
if self.getProp("SkipTracking"):
from TrackSys import RecoTracking
RecoTracking.DecodeTracking(["FastVelo"])
from Configurables import L0Conf
from Configurables import NTupleSvc
from Configurables import PrChecker2
from Configurables import LoKi__Hybrid__MCTool
from Gaudi.Configuration import GaudiSequencer
# As we haven't ran Moore
L0Conf().EnsureKnownTCK = False
# Required to avoid Loki issues when running PrChecker2
myFactory = LoKi__Hybrid__MCTool("MCHybridFactory")
myFactory.Modules = ["LoKiMC.decorators"]
PrChecker2("PrChecker2").addTool(myFactory)
GaudiSequencer("CheckPatSeq").Members = [
"PrChecker",
"PrChecker2",
"TrackIPResolutionChecker",
"TrackIPResolutionCheckerNT",
"VPClusterMonitor"
]
NTupleSvc().Output += ["FILE1 DATAFILE='Brunel-tuples.root' TYP='ROOT' OPT='NEW'"]
from GaudiKernel.ProcessJobOptions import importOptions from Gaudi.Configuration import * from Configurables import Boole, LHCbApp, CondDB #, GaudiSequencer from Configurables import MCFTDepositCreator, MCFTDigitCreator, FTClusterCreator #from Configurables import MCFTDepositMonitor, MCFTDigitMonitor, FTClusterMonitor from Configurables import FTRawBankEncoder, FTRawBankDecoder from Configurables import L0Conf, DDDBConf L0Conf().TCK = '0x002A' #CondDB().Upgrade = True DDDBConf( ).DbRoot = "/afs/cern.ch/user/o/ogruenbe/public/FT_upgrade/test_DDDBupgrade_FT_v20/lhcb.xml" #DDDBConf().DbRoot = "/afs/cern.ch/user/c/cogneras/scratch0/DDDBUpgrade-v20/lhcb.xml" LHCbApp().DDDBtag = "dddb-20130408" LHCbApp().CondDBtag = "simcond-20121001-vc-md100" #-- Event input #DDDBConf().DbRoot = "/afs/cern.ch/user/o/ogruenbe/public/FT_upgrade/test_DDDBupgrade_FT_v20/lhcb.xml" #DDDBConf().DbRoot = "/afs/cern.ch/user/o/ogruenbe/public/FT_upgrade/test_DDDB_FT_v20/lhcb.xml" #DDDBConf().DbRoot = "/afs/cern.ch/user/c/cogneras/public/forFT/DDDB/lhcb.xml" #DDDBConf().DbRoot = "/afs/cern.ch/user/s/szczypka/public/upgrade/forFT/DDDB/lhcb.xml" #LHCbApp().DDDBtag = "dddb-20130408" #LHCbApp().CondDBtag = "simcond-20121001-vc-md100" #Datasetname="Bs_mumu_v6_nu325" #Datasetname="Bs_mumu_v6_nu65" #Datasetname="MiniBias_v6_nu325" #Datasetname="MiniBias_v6_nu65"
# to make a digi file out of an xdst. # Author : SciFi usual suspects # Version : this file was written for Boole v28r1 # Questions : Please contact [email protected] ################################################################################### from Gaudi.Configuration import * from Configurables import Boole, LHCbApp, DDDBConf, CondDB from Boole.Configuration import * from Configurables import L0Conf L0Conf().TCK = '0x0037' CondDB().Upgrade = True LHCbApp().DDDBtag = "dddb-20131025" LHCbApp().CondDBtag = "sim-20130830-vc-md100" LHCbApp().Simulation = True CondDB().AllLocalTagsByDataType = [ "VP_UVP+RICH_2019+UT_UUT", "FT_StereoAngle5" ] importOptions("$APPCONFIGOPTS/Boole/Default.py") importOptions("$APPCONFIGOPTS/Boole/xdigi.py") from Configurables import Boole Boole().DetectorLink = ['VP', 'UT', 'FT', 'Tr', 'Magnet'] Boole().DetectorDigi = ['VP', 'UT', 'FT', 'Magnet'] Boole().DetectorMoni = ['VP', 'UT', 'FT', 'Magnet'] Boole().DataType = "Upgrade"
from TeslaTools import TeslaTruthUtils
seq = TeslaTruthUtils.associateSequence("Tesla", False)
relations = TeslaTruthUtils.getRelLoc("Tesla")
TeslaTruthUtils.makeTruth(
tuple, relations,
["MCTupleToolKinematic", "MCTupleToolHierarchy", "MCTupleToolPID"])
tuple2 = MCDecayTreeTuple("MCTeslaTuple")
tuple2.Inputs = ['/Event/Tesla/Particles']
tuple2.Decay = tuple.Decay
from Configurables import DataOnDemandSvc, L0SelReportsMaker, L0DecReportsMaker
DataOnDemandSvc().AlgMap["HltLikeL0/DecReports"] = L0DecReportsMaker()
DataOnDemandSvc().AlgMap["HltLikeL0/SelReports"] = L0SelReportsMaker()
from Configurables import L0Conf
L0Conf().FullL0MuonDecoding = True
L0Conf().EnableL0DecodingOnDemand = True
L0Conf().EnsureKnownTCK = False
tuple3 = DecayTreeTuple("StrippingTuple")
tuple3.Inputs = [
'/Event/AllStreams/Phys/FullDSTDiMuonJpsi2MuMuDetachedLine/Particles'
]
tuple3.Decay = tuple.Decay
tuple3.ToolList = tuple.ToolList
tuple3.addTool(TupleToolTrigger, name="TupleToolTrigger")
tuple3.addTool(TupleToolTISTOS, name="TupleToolTISTOS")
tuple3.TupleToolTrigger.Verbose = True
tuple3.TupleToolTrigger.TriggerList = tlist
tuple3.TupleToolTISTOS.Verbose = True
tuple3.TupleToolTISTOS.TriggerList = tlist
def configureMoni(self, moniDets):
# Set up monitoring
histOpt = self.getProp("Histograms").capitalize()
if histOpt not in self.KnownHistOptions:
raise RuntimeError("Unknown Histograms option '%s'" % histOpt)
from Configurables import BooleInit, MemoryTool
booleInit = BooleInit()
booleInit.addTool(MemoryTool(), name="BooleMemory")
booleInit.BooleMemory.HistoTopDir = "Boole/"
booleInit.BooleMemory.HistoDir = "MemoryTool"
if "Velo" in moniDets:
from Configurables import VeloSimMoni, VeloDigit2MCHitLinker, VeloDigiMoni, VeloRawClustersMoni
GaudiSequencer("MoniVeloSeq").Members += [
VeloSimMoni(),
VeloDigit2MCHitLinker(),
VeloDigiMoni(),
VeloRawClustersMoni()
]
if self.getProp("DataType") == "Upgrade":
from Configurables import VeloMonitorSpilloverSubtr
GaudiSequencer("MoniVeloSeq").Members += [
VeloMonitorSpilloverSubtr()
]
if True == self.getProp("VeloTell1Processing"):
GaudiSequencer("MoniVeloSeq").Members.remove(
VeloDigit2MCHitLinker())
GaudiSequencer("MoniVeloSeq").Members.remove(VeloDigiMoni())
if "IT" in moniDets or "TT" in moniDets:
from Configurables import (MCSTDepositMonitor, MCSTDigitMonitor,
STDigitMonitor, ST__STClusterMonitor,
STEffChecker, MCParticle2MCHitAlg,
MCParticleSelector)
from GaudiKernel.SystemOfUnits import GeV
if "IT" in moniDets:
mcDepMoni = MCSTDepositMonitor("MCITDepositMonitor", DetType="IT")
mcDigitMoni = MCSTDigitMonitor("MCITDigitMonitor", DetType="IT")
digitMoni = STDigitMonitor("ITDigitMonitor", DetType="IT")
clusMoni = ST__STClusterMonitor("ITClusterMonitor", DetType="IT")
mcp2MCHit = MCParticle2MCHitAlg(
"MCP2ITMCHitAlg",
MCHitPath="MC/IT/Hits",
OutputData="/Event/MC/Particles2MCITHits")
effCheck = STEffChecker("ITEffChecker", DetType="IT")
effCheck.addTool(MCParticleSelector)
effCheck.MCParticleSelector.zOrigin = 50.0
effCheck.MCParticleSelector.pMin = 1.0 * GeV
effCheck.MCParticleSelector.betaGammaMin = 1.0
GaudiSequencer("MoniITSeq").Members += [
mcDepMoni, mcDigitMoni, digitMoni, clusMoni, mcp2MCHit,
effCheck
]
if self.getProp("DataType") == "Upgrade":
from Configurables import STSpilloverSubtrMonitor
GaudiSequencer("MoniITSeq").Members += [
STSpilloverSubtrMonitor("ITSpilloverSubtrMonitor",
DetType="IT")
]
if histOpt == "Expert":
mcDepMoni.FullDetail = True
mcDigitMoni.FullDetail = True
clusMoni.FullDetail = True
effCheck.FullDetail = True
if "TT" in moniDets:
mcDepMoni = MCSTDepositMonitor("MCTTDepositMonitor")
mcDigitMoni = MCSTDigitMonitor("MCTTDigitMonitor")
digitMoni = STDigitMonitor("TTDigitMonitor")
clusMoni = ST__STClusterMonitor("TTClusterMonitor")
mcp2MCHit = MCParticle2MCHitAlg(
"MCP2TTMCHitAlg",
MCHitPath="MC/TT/Hits",
OutputData="/Event/MC/Particles2MCTTHits")
effCheck = STEffChecker("TTEffChecker")
effCheck.addTool(MCParticleSelector)
effCheck.MCParticleSelector.zOrigin = 50.0
effCheck.MCParticleSelector.pMin = 1.0 * GeV
effCheck.MCParticleSelector.betaGammaMin = 1.0
GaudiSequencer("MoniTTSeq").Members += [
mcDepMoni, mcDigitMoni, digitMoni, clusMoni, mcp2MCHit,
effCheck
]
if self.getProp("DataType") == "Upgrade":
from Configurables import STSpilloverSubtrMonitor
GaudiSequencer("MoniTTSeq").Members += [
STSpilloverSubtrMonitor("TTSpilloverSubtrMonitor",
DetType="TT")
]
if histOpt == "Expert":
mcDepMoni.FullDetail = True
mcDigitMoni.FullDetail = True
clusMoni.FullDetail = True
effCheck.FullDetail = True
if "OT" in moniDets:
from Configurables import MCOTDepositMonitor
GaudiSequencer("MoniOTSeq").Members += [MCOTDepositMonitor()]
if histOpt == "Expert":
importOptions("$OTMONITORROOT/options/Boole.opts")
if "Rich" in moniDets:
from Configurables import Rich__MC__Digi__DigitQC
GaudiSequencer("MoniRichSeq").Members += [
Rich__MC__Digi__DigitQC("RiDigitQC")
]
if "Calo" in moniDets:
from Configurables import CaloDigitChecker
importOptions("$CALOMONIDIGIOPTS/CaloDigitChecker.opts")
GaudiSequencer("MoniCaloSeq").Members += [
CaloDigitChecker("SpdCheck"),
CaloDigitChecker("PrsCheck"),
CaloDigitChecker("EcalCheck"),
CaloDigitChecker("HcalCheck")
]
if "Muon" in moniDets:
from Configurables import MuonDigitChecker
GaudiSequencer("MoniMuonSeq").Members += ["MuonDigitChecker"]
if "L0" in moniDets:
from Configurables import L0Conf
L0Conf().MoniSequencer = GaudiSequencer("MoniL0Seq")
def configureLink(self, linkDets, moniDets):
"""
Set up the MC links sequence
"""
doWriteTruth = ("DIGI" in self.getProp("Outputs")) and (
self.getProp("DigiType").capitalize() != "Minimal")
if "Velo" in linkDets or "Velo" in moniDets or "Tr" in linkDets:
seq = GaudiSequencer("LinkVeloSeq")
from Configurables import DecodeVeloRawBuffer
decodeVelo = DecodeVeloRawBuffer()
decodeVelo.DecodeToVeloClusters = True
decodeVelo.DecodeToVeloLiteClusters = False
seq.Members += [decodeVelo]
seq.Members += ["VeloCluster2MCHitLinker"]
seq.Members += ["VeloCluster2MCParticleLinker"]
if "VeloPix" in linkDets or "VeloPix" in moniDets:
from Configurables import VeloPixDigit2MCHitLinker, VeloPixDigit2MCParticleLinker, VeloPixCluster2MCHitLinker, VeloPixCluster2MCParticleLinker
seq = GaudiSequencer("LinkVeloPixSeq")
seq.Members += [
VeloPixDigit2MCHitLinker("VeloPixDigit2MCHitLinker")
]
seq.Members += [
VeloPixDigit2MCParticleLinker("VeloPixDigit2MCParticleLinker")
]
seq.Members += [
VeloPixCluster2MCHitLinker("VeloPixCluster2MCHitLinker")
]
seq.Members += [
VeloPixCluster2MCParticleLinker(
"VeloPixCluster2MCParticleLinker")
]
if "TT" in linkDets or "IT" in linkDets or "TT" in moniDets or "IT" in moniDets or "Tr" in linkDets:
from Configurables import STDigit2MCHitLinker, STCluster2MCHitLinker, STCluster2MCParticleLinker
if "TT" in linkDets or "TT" in moniDets:
seq = GaudiSequencer("LinkTTSeq")
seq.Members += [STDigit2MCHitLinker("TTDigitLinker")]
seq.Members += [STCluster2MCHitLinker("TTClusterLinker")]
seq.Members += [STCluster2MCParticleLinker("TTTruthLinker")]
if "IT" in linkDets or "IT" in moniDets:
seq = GaudiSequencer("LinkITSeq")
seq.Members += [
STDigit2MCHitLinker("ITDigitLinker", DetType="IT")
]
seq.Members += [
STCluster2MCHitLinker("ITClusterLinker", DetType="IT")
]
seq.Members += [
STCluster2MCParticleLinker("ITTruthLinker", DetType="IT")
]
if "OT" in linkDets or "OT" in moniDets or "Tr" in linkDets:
seq = GaudiSequencer("LinkOTSeq")
seq.Members += ["OTMCDepositLinker"]
seq.Members += ["OTMCHitLinker"]
seq.Members += ["OTMCParticleLinker"]
if "Tr" in linkDets and doWriteTruth:
seq = GaudiSequencer("LinkTrSeq")
if "VeloPix" in linkDets:
seq.Members += ["BuildMCTrackWithVeloPixInfo"]
else:
seq.Members += ["BuildMCTrackInfo"]
if "Rich" in linkDets and doWriteTruth:
seq = GaudiSequencer("LinkRichSeq")
seq.Members += ["Rich::MC::MCRichDigitSummaryAlg"]
if "Calo" in linkDets or "Calo" in moniDets:
from Configurables import CaloDigitsFromRaw, CaloReCreateMCLinks, CaloDigitMCTruth
seq = GaudiSequencer("LinkCaloSeq")
seq.Members += [CaloDigitsFromRaw("EcalFromRaw")]
seq.Members += [CaloDigitsFromRaw("HcalFromRaw")]
recreateLinks = CaloReCreateMCLinks()
recreateLinks.Digits = ["Raw/Ecal/Digits", "Raw/Hcal/Digits"]
recreateLinks.MCDigits = ["MC/Ecal/Digits", "MC/Hcal/Digits"]
seq.Members += [recreateLinks]
seq.Members += [CaloDigitMCTruth("EcalDigitMCTruth")]
hcalTruth = CaloDigitMCTruth("HcalDigitMCTruth")
hcalTruth.Input = "Raw/Hcal/Digits"
hcalTruth.Detector = "/dd/Structure/LHCb/DownstreamRegion/Hcal"
seq.Members += [hcalTruth]
if "Muon" in linkDets and doWriteTruth:
seq = GaudiSequencer("LinkMuonSeq")
seq.Members += ["MuonDigit2MCParticleAlg"]
seq.Members += ["MuonTileDigitInfo"]
if "L0" in linkDets and doWriteTruth:
from Configurables import L0Conf
L0Conf().LinkSequencer = GaudiSequencer("LinkL0Seq")
Moore().CondDBtag = "sim-20131023-vc-md100"
from GaudiConf import IOHelper
IOHelper().inputFiles( [ "PFN:root://castorlhcb.cern.ch//castor/cern.ch/user/s/sbenson/TempTestFiles/00026133_00000013_1.allstreams.dst" ] )
from Configurables import Hlt__Service
Hlt__Service().Pedantic = False
from Configurables import DataOnDemandSvc
from Configurables import DstConf, CaloDstUnPackConf
CaloDstUnPackConf().Enable=True
DstConf().EnableUnpack= ["Reconstruction","Stripping"]
from Configurables import L0MuonAlg
L0MuonAlg("L0Muon").L0DUConfigProviderType="L0DUConfigProvider"
from Configurables import L0Conf
L0Conf().EnableL0DecodingOnDemand = True
L0Conf().FastL0DUDecoding = True
L0Conf().DecodeL0DU = True
L0Conf().TCK = '0x0045'
#from Configurables import Hlt2Conf
#Hlt2Conf().Hlt1TrackOption = "Rerun"
import GaudiPython
from Gaudi.Configuration import ApplicationMgr
from Configurables import LoKiSvc
appMgr = ApplicationMgr()
#
from Configurables import EventNodeKiller
enk = EventNodeKiller('KillTrigRawEvent')
