def CutFlowMetadataConfig(d3pdalg):
from AthenaCommon.AppMgr import ServiceMgr
from EventBookkeeperTools.EventBookkeeperToolsConf import CutFlowSvc
# Add the cut flow service if it's not in the job yet:
if not hasattr(ServiceMgr, "CutFlowSvc"):
ServiceMgr += CutFlowSvc()
# Create a separate D3PDSvc:
_d3pdSvcName = "CutFlowD3PDSvc"
if not hasattr(ServiceMgr, _d3pdSvcName):
from D3PDMakerRoot.D3PDMakerRootConf import D3PD__RootD3PDSvc
ServiceMgr += D3PD__RootD3PDSvc(_d3pdSvcName)
_d3pdSvc = getattr(ServiceMgr, _d3pdSvcName)
_d3pdSvc.MasterTree = ""
_d3pdSvc.IndexMajor = ""
# Now create the metadata tool with the correct configuration:
import EventCommonD3PDMaker
return EventCommonD3PDMaker.CutFlowMetadataTool("CutFlowMetadataTool",
MetaKey='CutFlow',
D3PDSvc=_d3pdSvc,
MetaDir=d3pdalg.TuplePath +
"Meta")
def addTrigCostData(mode = "COST", fileName = "trig_cost.root", costConfigL2 = False, costConfigEF = False, costConfigHLT = True):
# Set up a logger:
from AthenaCommon.Logging import logging
addTrigCostData_msg = logging.getLogger( 'addTrigCostData' )
# Construct the stream and file names for the Trigger D3PD:
streamName = "StreamNTUP_TRIG" + mode
addTrigCostData_msg.info( "Configuring Trigger Cost D3PD from bytestream with streamName '%s' and fileName '%s'" % ( streamName, fileName ) )
# Create the D3PD stream(s):
# We dont actually use the default stream!
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
d3pdalg = MSMgr.NewRootStream( streamName, fileName, "dummy" )
# As we are running from bytestream, need to disable data headers.
from AthenaCommon.AlgSequence import AlgSequence
theJob = AlgSequence()
fullStreamName = "StreamNTUP_TRIG" + mode + "AANTStream"
if hasattr(theJob, fullStreamName):
streamRef = getattr( theJob, fullStreamName )
streamRef.ExistDataHeader = False
streamRef.WriteInputDataHeader = False
# The tool needs a special D3PDSvc in which the indexing is turned off for the TTree-s:
_costD3PDSvcName = "TrigCostD3PDSvc_" + mode
from AthenaCommon.AppMgr import ServiceMgr
if not hasattr( ServiceMgr, _costD3PDSvcName ):
from D3PDMakerRoot.D3PDMakerRootConf import D3PD__RootD3PDSvc
ServiceMgr += D3PD__RootD3PDSvc( _costD3PDSvcName )
else:
addTrigCostData_msg.info( "The private D3PDSvc for the cost monitoring TTree already exists" )
_costD3PDSvc = getattr( ServiceMgr, _costD3PDSvcName )
_costD3PDSvc.MasterTree = ""
_costD3PDSvc.IndexMajor = ""
# Add the tool:
_costD3PDToolName = "TrigCostD3PDMakerTool_" + mode
_tuplePath = "/StreamNTUP_TRIG" + mode + "/trig_cost"
if not _costD3PDToolName in [ t.name() for t in d3pdalg.MetadataTools ]:
import TrigCostD3PDMaker
_trigCostTool = TrigCostD3PDMaker.TrigCostD3PDMakerTool( _costD3PDToolName, D3PDSvc = _costD3PDSvc, dir = _tuplePath )
_trigCostTool.mode = mode
if (costConfigL2 == True):
_trigCostTool.keyEvent = "HLT_TrigMonEventCollection_OPI_L2_monitoring_event"
_trigCostTool.prefix = "TrigCostL2_"
elif (costConfigEF == True):
_trigCostTool.keyEvent = "HLT_TrigMonEventCollection_OPI_EF_monitoring_event"
_trigCostTool.prefix = "TrigCostEF_"
elif (costConfigHLT == True):
_trigCostTool.keyEvent = "HLT_TrigMonEventCollection_OPI_HLT_monitoring_event"
_trigCostTool.prefix = "TrigCostHLT_"
d3pdalg.MetadataTools += [ _trigCostTool ]
if (mode != "EBWEIGHT"):
from TrigCostD3PDMaker.TrigCostConfMetadata import addTrigCostConfMetadata
addTrigCostConfMetadata( d3pdalg, costConfigL2, costConfigEF, costConfigHLT, _tuplePath )
def addAlfaDcsMetadata( d3pdalg = None ): """Helper function that adds the necessary tool(s) and service(s) to the job to save the trigger configuration metadata to the output D3PD file. Arguments: d3pdalg: The D3PD::MakerAlg that is creating the D3PD. If not specified, the configuration is saved in a file called TrigConfig.root """ # Create a logger for the function: if "logger" in dir(): orig_logger = logger from AthenaCommon.Logging import logging logger = logging.getLogger( "addAlfaDcsMetadata" ) # Let the user know what we're doing: logger.info( "Adding ALFA DCS metadata to the D3PD" ) # The tool needs a special D3PDSvc in which the indexing is turned off # for the TTree-s: _d3pdSvcName = "AlfaDcsD3PDSvc" from AthenaCommon.AppMgr import ServiceMgr if not hasattr( ServiceMgr, _d3pdSvcName ): from D3PDMakerRoot.D3PDMakerRootConf import D3PD__RootD3PDSvc ServiceMgr += D3PD__RootD3PDSvc( _d3pdSvcName ) ServiceMgr.AlfaDcsD3PDSvc.MasterTree = "" ServiceMgr.AlfaDcsD3PDSvc.IndexMajor = "" else: logger.info( "The private D3PDSvc for the metadata TTree already exists" ) _d3pdSvc = getattr( ServiceMgr, _d3pdSvcName ) # If no D3PD::MakerAlg has been provided, create a dummy one: if d3pdalg == None: logger.warning( "No D3PD MakerAlg given to function!" ) logger.warning( "The DCS data will be saved into file: " + "\"AlfaDCS.root\"" ) from AthenaCommon.AlgSequence import AlgSequence theJob = AlgSequence() import D3PDMakerCoreComps d3pdalg = D3PDMakerCoreComps.MakerAlg( "AlfaDCSAlg", theJob, file = "AlfaDCS.root", D3PDSvc = _d3pdSvc ) # Add the metadata tool: _d3pdToolName = "AlfaMetaDataTool" if not _d3pdToolName in [ t.name() for t in d3pdalg.MetadataTools ]: import ForwardDetectorsD3PDMaker d3pdalg.MetadataTools += [ ForwardDetectorsD3PDMaker.AlfaMetaDataTool( _d3pdToolName, D3PDSvc = _d3pdSvc, MetaDataDir=d3pdalg.TuplePath+"Meta") ] else: logger.info( "AlfaMetaDataTool was already added to the D3PD::MakerAlg" ) # Restore the original logger if necessary: if "orig_logger" in dir(): logger = orig_logger return
streamName = prodFlags.WriteSMDYEED3PD.StreamName
fileName = buildFileName(prodFlags.WriteSMDYEED3PD)
SMDYEED3PDStream_msg.info( "Configuring SMDYEED3PD with streamName '%s' and fileName '%s'" % \
( streamName, fileName ) )
#### add specific containers
include("PhysicsD3PDMaker/LowPtElectronPairSelector.py")
include("PhysicsD3PDMaker/PhotonSelector.py")
include("PhysicsD3PDMaker/MuonSelector.py")
include("PhysicsD3PDMaker/JetSelector.py")
include("PhysicsD3PDMaker/TauSelector.py")
# Configure branches
from AthenaCommon.AppMgr import ServiceMgr
from D3PDMakerRoot.D3PDMakerRootConf import D3PD__RootD3PDSvc
ServiceMgr += D3PD__RootD3PDSvc("SMDYEE_D3PDSvc")
ServiceMgr.SMDYEE_D3PDSvc.VetoedNames = [
"L1_.*", "L2_.*", "EF_m.*", "EF_2m.*", "EF_j.*", "EF_2j.*", "EF_tau.*"
]
ServiceMgr.SMDYEE_D3PDSvc.VetoedNames += ["trig_EF_trigmu.*"]
ServiceMgr.SMDYEE_D3PDSvc.VetoedNames += ["MET.*", ".*etx.*", ".*ety.*"]
# Create the D3PD streams:
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
SMDYEED3PDStream = MSMgr.NewRootStream(streamName, fileName, "physics")
SMDYEED3PDStream.D3PDSvc = ServiceMgr.SMDYEE_D3PDSvc
# Now add all the content to this stream:
from PhysicsD3PDMaker.SMWZLightD3PD import SMWZLightD3PD
SMWZLightD3PD(SMDYEED3PDStream, stdElectronContainer='LowPtElectrons')
def addTrigConfMetadata(d3pdalg=None,
useTrigConfEventSummaries=False,
doCostL2=False,
doCostEF=False,
doCostHLT=False,
saveKeys=True,
tuplePath=""):
"""Helper function that adds the necessary tool(s) and service(s) to the
job to save the trigger configuration metadata to the output D3PD
file.
Arguments:
d3pdalg: The D3PD::MakerAlg that is creating the D3PD. If not specified,
the configuration is saved in a file called TrigConfig.root
useTrigConfEventSummaries: Set true when running in AtlasP1HLT or trigger BS
to gather detailed configuration from TrigConfEvent
summary objects (TrigCost running).
"""
# Create a logger for the function:
if "logger" in dir(): orig_logger = logger
from AthenaCommon.Logging import logging
logger = logging.getLogger("addTrigConfMetadata")
# Let the user know what we're doing:
logger.info("Adding trigger configuration metadata to the D3PD")
# The tool needs a special D3PDSvc in which the indexing is turned off
# for the TTree-s:
_d3pdSvcName = "TrigConfD3PDSvc"
from AthenaCommon.AppMgr import ServiceMgr
if not hasattr(ServiceMgr, _d3pdSvcName):
from D3PDMakerRoot.D3PDMakerRootConf import D3PD__RootD3PDSvc
ServiceMgr += D3PD__RootD3PDSvc(_d3pdSvcName)
ServiceMgr.TrigConfD3PDSvc.MasterTree = ""
ServiceMgr.TrigConfD3PDSvc.IndexMajor = ""
else:
logger.info(
"The private D3PDSvc for the metadata TTree already exists")
_d3pdSvc = getattr(ServiceMgr, _d3pdSvcName)
# If no D3PD::MakerAlg has been provided, create a dummy one:
if d3pdalg == None:
logger.warning("No D3PD MakerAlg given to function!")
logger.warning("The trigger configuration will be saved into file: " +
"\"TrigConfig.root\"")
from AthenaCommon.AlgSequence import AlgSequence
theJob = AlgSequence()
import D3PDMakerCoreComps
d3pdalg = D3PDMakerCoreComps.MakerAlg("trigConf",
theJob,
file="TrigConfig.root",
D3PDSvc=_d3pdSvc)
# Add the metadata tool:
_d3pdToolName = "TrigConfMetadataTool"
if not _d3pdToolName in [t.name() for t in d3pdalg.MetadataTools]:
import TriggerD3PDMaker
if (tuplePath == ""):
tuplePath = d3pdalg.TuplePath
_trigConfTool = TriggerD3PDMaker.TrigConfMetadataTool(
_d3pdToolName, D3PDSvc=_d3pdSvc, ConfigDir=tuplePath + "Meta")
_trigConfTool.UseTrigConfEventSummaries = useTrigConfEventSummaries
if useTrigConfEventSummaries:
# Figure out if old or new style HLT if using CostMon to get correct storegate key
# Old key fomat was HLT_OPI_HLT_monitoring_config
if (doCostL2 == True or doCostEF == True or doCostHLT == True):
logger.info(
"TrigConfMetadataTool will use passed arguments [L2=" +
str(doCostL2) + ",EF=" + str(doCostEF) + ",HLT=" +
str(doCostHLT) + "]")
if (doCostL2 == True or doCostEF == True):
_trigConfTool.keyConfig = "HLT_TrigMonConfigCollection_OPI_EF_monitoring_config"
elif (doCostHLT == True):
_trigConfTool.keyConfig = "HLT_TrigMonConfigCollection_OPI_HLT_monitoring_config"
else:
logger.info(
"TrigConfMetadataTool will use TriggerFlags flags for config"
)
from TriggerJobOpts.TriggerFlags import TriggerFlags
if TriggerFlags.doHLT() and not (TriggerFlags.doEF()
or TriggerFlags.doLVL2()):
_trigConfTool.keyConfig = "HLT_TrigMonConfigCollection_OPI_HLT_monitoring_config"
elif TriggerFlags.doEF() or TriggerFlags.doLVL2():
_trigConfTool.keyConfig = "HLT_TrigMonConfigCollection_OPI_EF_monitoring_config"
logger.info("TrigConfMetadataTool will use the StoreGate key " +
_trigConfTool.keyConfig)
d3pdalg.MetadataTools += [_trigConfTool]
else:
logger.info(
"TrigConfMetadataTool was already added to the D3PD::MakerAlg")
# Add the DB key filler object:
if saveKeys == True:
_dbKeysFillerName = "TrigDBKeysFiller"
if not hasattr(d3pdalg, _dbKeysFillerName):
from TriggerD3PDMaker.TrigDBKeysD3PDObject import TrigDBKeysD3PDObject
d3pdalg += TrigDBKeysD3PDObject(0)
else:
logger.info(
"TrigDBKeysD3PDObject already added to the D3PD::MakerAlg")
# Restore the original logger if necessary:
if "orig_logger" in dir(): logger = orig_logger
return
def __init__(self,
name,
seq=topSequence,
file=None,
stream=None,
tuplename=None,
TuplePath=None,
preD3PDAlgSeqName=D3PDMakerFlags.PreD3PDAlgSeqName(),
streamNameRoot=None,
clevel=D3PDMakerFlags.CompressionLevel(),
**kwargs):
"""MakerAlg constructor. See the class documentation for a full description.
"""
if streamNameRoot == None:
streamNameRoot = 'D3PD'
# Work around initialization order issue.
if seq:
seq.__iadd__(D3PDMakerCoreComps.DummyInitAlg(name + 'DummyInit'),
index=0)
# If the tuple path wasn't supplied, build it from the other args.
if TuplePath == None:
# tuple name defaults to the algorithm name.
if tuplename == None:
tuplename = name
if stream == None:
# If no stream was given, infer it from the file.
# This creates the stream if needed.
if file == None:
raise TypeError("Neither stream nor file specified "
"for tuple %s" % tuplename)
stream = _stream_from_file(file, seq, tuplename,
streamNameRoot, clevel)
TuplePath = '/%s/%s' % (stream, tuplename)
# Create the algorithm Configurable.
D3PDMakerCoreCompsConf.D3PD__MakerAlg.__init__(self,
name,
TuplePath=TuplePath,
**kwargs)
# Ensure configuration parameters are set.
if (D3PDMakerFlags.AutoFlush() != -1
and self.D3PDSvc.getFullName() == 'D3PD::RootD3PDSvc'):
from D3PDMakerRoot.D3PDMakerRootConf import D3PD__RootD3PDSvc
rootsvc = D3PD__RootD3PDSvc()
rootsvc.AutoFlush = D3PDMakerFlags.AutoFlush()
from AthenaCommon.AppMgr import ServiceMgr
ServiceMgr += rootsvc
# Add to the supplied sequence.
if seq:
# But first, add a sequence for algorithms that should run
# before D3PD making, if it's not already there.
preseq = AlgSequence(preD3PDAlgSeqName)
if not hasattr(seq, preD3PDAlgSeqName):
seq += [preseq]
# We don't want to do filtering in the presequence.
preseq.StopOverride = True
# Now set up another sequence for filtering.
# Unlike the presequence, there should be a unique one of these
# per algorithm. We also need to break out an additional
# sequence to which users can add, and to wrap the whole
# thing in a sequence to prevent a failed filter
# decision from stopping other algorithms.
# Like this:
#
# ALG_FilterAlgorithmsWrap (StopOverride = True)
# ALG_FilterAlgorithmsHolder
# ALG_FilterAlgorithms
# ALG
# Dummy alg, to reset filter flag
suffix = D3PDMakerFlags.FilterAlgSeqSuffix()
wrap = AlgSequence(name + suffix + 'Wrap', StopOverride=True)
holder = AlgSequence(name + suffix + 'Holder')
self.filterSeq = AlgSequence(name + suffix)
holder += self.filterSeq
holder += self
wrap += holder
wrap += PyAthena.Alg(name + 'Dummy')
seq += wrap
# Create a unique collection getter registry tool for this tree.
from AthenaCommon.AppMgr import ToolSvc
self._registry = \
D3PDMakerCoreComps.CollectionGetterRegistryTool (self.name() +
'_CollectionGetterRegistry')
ToolSvc += self._registry
return
streamName = prodFlags.WriteSMZMUMUD3PD.StreamName
fileName = buildFileName(prodFlags.WriteSMZMUMUD3PD)
SMZMUMUD3PDStream_msg.info( "Configuring SMZMUMUD3PD with streamName '%s' and fileName '%s'" % \
( streamName, fileName ) )
#### add specific containers
include("PhysicsD3PDMaker/ElectronSelector.py")
include("PhysicsD3PDMaker/PhotonSelector.py")
include("PhysicsD3PDMaker/LowPtMuonPairSelector.py")
include("PhysicsD3PDMaker/JetSelector.py")
include("PhysicsD3PDMaker/TauSelector.py")
# Configure branches
from AthenaCommon.AppMgr import ServiceMgr
from D3PDMakerRoot.D3PDMakerRootConf import D3PD__RootD3PDSvc
ServiceMgr += D3PD__RootD3PDSvc("SMZMUMU_D3PDSvc")
ServiceMgr.SMZMUMU_D3PDSvc.VetoedNames = [
"L1_.*", "L2_.*", "EF_e.*", "EF_2e.*", "EF_g.*", "EF_j.*", "EF_2j.*",
"EF_tau.*"
]
ServiceMgr.SMZMUMU_D3PDSvc.VetoedNames += ["trig_EF_el.*"]
ServiceMgr.SMZMUMU_D3PDSvc.VetoedNames += [".*etx.*", ".*ety.*"]
# Create the D3PD streams:
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
SMZMUMUD3PDStream = MSMgr.NewRootStream(streamName, fileName, "physics")
SMZMUMUD3PDStream.D3PDSvc = ServiceMgr.SMZMUMU_D3PDSvc
# Now add all the content to this stream:
from PhysicsD3PDMaker.SMWZLightD3PD import SMWZLightD3PD
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
#from PhysicsD3PDMaker.SMWZD3PD import SMWZD3PD
#SMWZD3PD( SMTRILEPD3PDStream )
#h ok
### add specific containers
# Will need to redefine these ourselves...
include("PhysicsD3PDMaker/SMTRILEP_ElectronSelector.py")
include("PhysicsD3PDMaker/SMTRILEP_PhotonSelector.py")
include("PhysicsD3PDMaker/SMTRILEP_MuonSelector.py")
include("PhysicsD3PDMaker/SMTRILEP_JetSelector.py")
#include ("PhysicsD3PDMaker/TauSelector.py")
# Configure branches
from AthenaCommon.AppMgr import ServiceMgr
from D3PDMakerRoot.D3PDMakerRootConf import D3PD__RootD3PDSvc
ServiceMgr += D3PD__RootD3PDSvc("SMTRILEP_D3PDSvc")
#ServiceMgr.SMTRILEP_D3PDSvc.VetoedNames = [ "EF_j.*","EF_2j.*","EF_tau.*" ]
ServiceMgr.SMTRILEP_D3PDSvc.VetoedNames = [
"^L1_.*",
"^L2_.*",
"EF_j.*",
"EF_2j.*",
"EF_tau.*",
"EF_xe.*",
"EF_eb.*",
]
ServiceMgr.SMTRILEP_D3PDSvc.VetoedNames += [
".*etx.*", ".*ety.*", "IPEstimate.*"
]
include("PhysicsD3PDMaker/SMTRILEP_VetoBranches.py")
def addBunchStructureMetadata(d3pdalg=None, source=""):
# Create a logger for the function:
if "logger" in dir(): orig_logger = logger
from AthenaCommon.Logging import logging
logger = logging.getLogger("addBunchStructureMetadata")
# Let the user know what we're doing:
logger.info("Adding bunch configuration metadata to the D3PD")
# The tool needs a special D3PDSvc in which the indexing is turned off
# for the TTree-s:
_d3pdSvcName = "BCD3PDSvc"
from AthenaCommon.AppMgr import ServiceMgr
if not hasattr(ServiceMgr, _d3pdSvcName):
from D3PDMakerRoot.D3PDMakerRootConf import D3PD__RootD3PDSvc
ServiceMgr += D3PD__RootD3PDSvc(_d3pdSvcName)
_d3pdSvc = getattr(ServiceMgr, _d3pdSvcName)
_d3pdSvc.MasterTree = ""
_d3pdSvc.IndexMajor = ""
else:
logger.info(
"The private D3PDSvc for the metadata TTree already exists")
_d3pdSvc = getattr(ServiceMgr, _d3pdSvcName)
# If no D3PD::MakerAlg has been provided, create a dummy one:
if d3pdalg == None:
logger.warning("No D3PD MakerAlg given to function!")
logger.warning("The bunch configuration will be saved into file: " +
"\"BunchConfig.root\"")
from AthenaCommon.AlgSequence import AlgSequence
theJob = AlgSequence()
import D3PDMakerCoreComps
d3pdalg = D3PDMakerCoreComps.MakerAlg("bunchConf",
theJob,
file="BunchConfig.root",
D3PDSvc=_d3pdSvc)
# Add the metadata tool:
_d3pdToolName = "BunchStructureMetadataTool"
if not _d3pdToolName in [t.name() for t in d3pdalg.MetadataTools]:
import TriggerD3PDMaker
from TrigBunchCrossingTool.BunchCrossingConfProvider import BunchCrossingConfProvider
d3pdalg.MetadataTools += [
TriggerD3PDMaker.BunchStructureMetadataTool( _d3pdToolName,
D3PDSvc = _d3pdSvc,
ConfigDir = d3pdalg.TuplePath + \
"Meta",
BCConfProvider = \
BunchCrossingConfProvider( source ) )
]
else:
logger.info(
"BunchStructureMetadataTool was already added to the D3PD::MakerAlg"
)
# Add the DB key filler object:
_configIdFillerName = "BunchConfigIDFiller"
if not hasattr(d3pdalg, _configIdFillerName):
from TriggerD3PDMaker.BunchConfigIDD3PDObject import BunchConfigIDD3PDObject
d3pdalg += BunchConfigIDD3PDObject(source)(0)
else:
logger.info(
"BunchConfigIDD3PDObject already added to the D3PD::MakerAlg")
# Restore the original logger if necessary:
if "orig_logger" in dir(): logger = orig_logger
return
fileName = buildFileName(prodFlags.WriteSMWMUNUD3PD)
SMWMUNUD3PDStream_msg.info( "Configuring SMWMUNUD3PD with streamName '%s' and fileName '%s'" % \
( streamName, fileName ) )
# add specific containers
include("PhysicsD3PDMaker/ElectronSelector.py")
include("PhysicsD3PDMaker/PhotonSelector.py")
include("PhysicsD3PDMaker/MuonSelector.py")
include("PhysicsD3PDMaker/JetSelector.py")
include("PhysicsD3PDMaker/TauSelector.py")
# Configure branches
from AthenaCommon.AppMgr import ServiceMgr
from D3PDMakerRoot.D3PDMakerRootConf import D3PD__RootD3PDSvc
ServiceMgr += D3PD__RootD3PDSvc("SMWMUNU_D3PDSvc")
ServiceMgr.SMWMUNU_D3PDSvc.VetoedNames = [
"L1_.*", "L2_.*", "EF_e.*", "EF_2e.*", "EF_g.*", "EF_j.*", "EF_2j.*",
"EF_tau.*"
]
ServiceMgr.SMWMUNU_D3PDSvc.VetoedNames += ["trig_EF_el.*"]
ServiceMgr.SMWMUNU_D3PDSvc.VetoedNames += [".*etx.*", ".*ety.*"]
# Create the D3PD streams:
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
SMWMUNUD3PDStream = MSMgr.NewRootStream(streamName, fileName, "physics")
SMWMUNUD3PDStream.D3PDSvc = ServiceMgr.SMWMUNU_D3PDSvc
# Now add all the content to this stream:
from PhysicsD3PDMaker.SMWZLightD3PD import SMWZLightD3PD
def _TruthTauDecayAssocHook(c, prefix, *args, **kw):
assoc = getattr(c, c.name() + '_child_TruthTauDecayAssociation', None)
if assoc:
indexer = getattr(assoc, assoc.name() + 'Index')
indexer.Target = prefix
return
tauTruth.defineHook(_TruthTauDecayAssocHook)
phTruth = simpleTruthParticleD3PDObject('SimplePhotonContainer',
'ph_',
skipDressing=True)
alg += elTruth(0, 'ElTruthParticle', sgkey='SimpleElectronContainer')
alg += muTruth(0, 'MuTruthParticle', sgkey='SimpleMuonContainer')
alg += tauTruth(0, 'TauTruthParticle', sgkey='SimpleTauContainer')
alg += phTruth(0, 'PhotonTruthParticle', sgkey='SimplePhotonContainer')
# To explicitly list variables to keep or exclude in final D3PD
from AthenaCommon.AppMgr import ServiceMgr
from D3PDMakerRoot.D3PDMakerRootConf import D3PD__RootD3PDSvc
ServiceMgr += D3PD__RootD3PDSvc("MyD3PDVetoSvc")
ServiceMgr.MyD3PDVetoSvc.VetoedNames = [
'timestamp', 'timestamp_ns', 'lbn', 'bcid', 'detmask0', 'detmask1',
'actualIntPerXing', 'averageIntPerXing', 'el_pdgId', 'mu_pdgId',
'tau_pdgId', 'ph_pdgId', 'ph_charge'
] # These are just stupid
alg.D3PDSvc = ServiceMgr.MyD3PDVetoSvc
streamName = prodFlags.WriteSMLIGHTD3PD.StreamName
fileName = buildFileName(prodFlags.WriteSMLIGHTD3PD)
SMLIGHTD3PDStream_msg.info( "Configuring SMLIGHTD3PD with streamName '%s' and fileName '%s'" % \
( streamName, fileName ) )
#### add specific containers
include("PhysicsD3PDMaker/ElectronSelector.py")
include("PhysicsD3PDMaker/PhotonSelector.py")
include("PhysicsD3PDMaker/MuonSelector.py")
include("PhysicsD3PDMaker/JetSelector.py")
include("PhysicsD3PDMaker/TauSelector.py")
# Configure branches
from AthenaCommon.AppMgr import ServiceMgr
from D3PDMakerRoot.D3PDMakerRootConf import D3PD__RootD3PDSvc
ServiceMgr += D3PD__RootD3PDSvc("SMLIGHT_D3PDSvc")
ServiceMgr.SMLIGHT_D3PDSvc.VetoedNames = [
"L1_.*", "L2_.*", "EF_j.*", "EF_2j.*", "EF_tau.*"
]
ServiceMgr.SMLIGHT_D3PDSvc.VetoedNames += [".*etx.*", ".*ety.*"]
# Create the D3PD streams:
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
SMLIGHTD3PDStream = MSMgr.NewRootStream(streamName, fileName, "physics")
SMLIGHTD3PDStream.D3PDSvc = ServiceMgr.SMLIGHT_D3PDSvc
# Now add all the content to this stream:
from PhysicsD3PDMaker.SMWZLightD3PD import SMWZLightD3PD
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
SMWZLightD3PD(SMLIGHTD3PDStream,
stdElectronContainer='HighPtElectrons',
CommonD3PDStream_msg.info( "Configuring CommonD3PD with streamName '%s' and fileName '%s'" % \
( streamName, fileName ) )
from RecExConfig.RecAlgsFlags import recAlgs
recAlgs.doMissingET.set_Value_and_Lock(True)
# Create the D3PD streams:
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
CommonD3PDStream = MSMgr.NewRootStream(streamName, fileName, "physics")
CommonTriggerD3PDStream = MSMgr.NewRootStream(
streamName + ":" + streamName + "TrigDec", fileName, "physicsTrigDec")
# Configure branches
from AthenaCommon.AppMgr import ServiceMgr
from D3PDMakerRoot.D3PDMakerRootConf import D3PD__RootD3PDSvc
ServiceMgr += D3PD__RootD3PDSvc("COMMON_D3PDSvc")
include("D3PDMakerConfig/CommonD3PD_VetoBranches.py")
ServiceMgr.COMMON_D3PDSvc.VetoedNames += CommonD3PD_VetoBranches
CommonD3PDStream.D3PDSvc = ServiceMgr.COMMON_D3PDSvc
# Now add all the content to this stream:
from D3PDMakerConfig.commonD3PD import commonD3PD
commonD3PD_args = globals().get('commonD3PD_args', {})
commonD3PD(CommonD3PDStream, CommonTriggerD3PDStream, **commonD3PD_args)
from D3PDMakerConfig.CommonJSD3PD import CommonJSD3PD
for xx in groomedJetKeys:
print "cccccc xx = ", xx
if xx[0] != None and xx[1] != None:
CommonJSD3PD(xx, CommonD3PDStream)
