# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
# $Id$
import CaloD3PDMaker
from D3PDMakerCoreComps.D3PDObject import make_SG_D3PDObject
CellD3PDObject = make_SG_D3PDObject("CaloCellContainer", "AllCalo", "cells_",
"CellD3PDObject")
CellD3PDObject.defineBlock(0, 'Kinematics', CaloD3PDMaker.CellFillerTool)
#
# D3PD object saving the CTP_RDO information into the D3PD
# Note that this can only be used on ESD files (or if back-navigation
# is active...)
#
import D3PDMakerCoreComps
from D3PDMakerCoreComps.D3PDObject import D3PDObject
from D3PDMakerCoreComps.D3PDObject import make_SG_D3PDObject
import TriggerD3PDMaker
# This object can only be used on (D)ESD files, when the CTP_RDO object is
# available:
from RecExConfig.ObjKeyStore import cfgKeyStore
if cfgKeyStore.isInInput("CTP_RDO", "CTP_RDO"):
_haveRDO = True
else:
_haveRDO = False
from AthenaCommon.Logging import logging
_mlog = logging.getLogger("CTPD3PDObject")
_mlog.warning("No CTP_RDO object in input; skipping.")
CTPD3PDObject = make_SG_D3PDObject("CTP_RDO",
"CTP_RDO",
"ctp_",
"CTPD3PDObject",
default_allowMissing=not _haveRDO)
if _haveRDO:
CTPD3PDObject.defineBlock(0, "RDOInfo", TriggerD3PDMaker.CTP_RDOFillerTool)
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
import MissingETD3PDMaker
import D3PDMakerCoreComps
from D3PDMakerCoreComps.D3PDObject import make_SG_D3PDObject
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
from MissingETD3PDMaker.MissingETD3PDMakerFlags import *
from MissingETD3PDMaker.MissingETD3PDMakerConf import *
MissingETGoodnessD3PDObject = \
make_SG_D3PDObject ('MissingET',
MissingETD3PDMakerFlags.METRefFinalSGKey(),
'MET_Goodness_',
'MissingETGoodnessD3PDObject')
def _goodnessHook (c, **kw):
# MissingETGoodness creates a JetBadChanCorrTool, but doesn't use the
# standard configuration code, so the require THistSvc entry
# doesn't get made. Work around.
from JetMomentTools.SetupJetMomentTools import getJetBadChanCorrTool
getJetBadChanCorrTool ('Kt', 0.4, 'Topo')
from AthenaCommon.AlgSequence import AlgSequence
from MissingETGoodness.METGoodnessGetter import METGoodnessGetter
METGoodnessGetter (AlgSequence (D3PDMakerFlags.PreD3PDAlgSeqName()))
return
MissingETGoodnessD3PDObject.defineHook (_goodnessHook)
MissingETGoodnessD3PDObject.defineBlock ( 2, 'Goodness', MissingETD3PDMaker.MissingETGoodnessFillerTool )
#### Jet Collection Info Object
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
# $Id: EnergySumROID3PDObject.py 504811 2012-06-10 13:09:39Z krasznaa $
#
# D3PD object saving the LVL1 EnergySum RoI information into the D3PD
#
from D3PDMakerCoreComps.D3PDObject import make_SG_D3PDObject
import TriggerD3PDMaker
EnergySumROID3PDObject = \
make_SG_D3PDObject( "LVL1_ROI", "LVL1_ROI", "trig_L1_esum_",
"EnergySumROID3PDObject",
default_getterClass = \
TriggerD3PDMaker.EnergySum_ROIGetterTool,
default_allowMissing = True )
EnergySumROID3PDObject.defineBlock(0,
"ThrInfo",
TriggerD3PDMaker.EnergySum_ROIFillerTool,
WriteThrInfo=True)
EnergySumROID3PDObject.defineBlock(1,
"DecodedInfo",
TriggerD3PDMaker.EnergySum_ROIFillerTool,
WriteDecodedInfo=True)
EnergySumROID3PDObject.defineBlock(2,
"RoIWord",
TriggerD3PDMaker.EnergySum_ROIFillerTool,
WriteRoIWord=True)
from D3PDMakerCoreComps.D3PDObject import DeferArg
import EventCommonD3PDMaker
import CaloD3PDMaker
import JetD3PDMaker
#
# Useful options:
# Specify bbJetIndex_Target to fill indices of beam background jets in the jet collection.
# Specify bbClusterIndex_Target to fill indices of beam background clusters in the cluster collection.
#
BeamBackgroundD3PDObject = \
make_SG_D3PDObject ('BeamBackgroundData',
'BeamBackgroundData',
'bb_', 'BeamBackgroundD3PDObject')
BeamBackgroundD3PDObject.defineBlock(
0, 'decision', BackgroundD3PDMaker.BeamBackgroundDecisionFillerTool)
ClusterAssoc = ContainedVectorMultiAssociation(
BeamBackgroundD3PDObject,
BackgroundD3PDMaker.BeamBackgroundClusterAssociationTool,
blockname="bbClusterInfo",
prefix="cl_")
ClusterAssoc.defineBlock(1,
"clus",
BackgroundD3PDMaker.BeamBackgroundClusterFillerTool,
BeamBackgroundKey=DeferArg('sgkey'))
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
# $Id$
import CaloSysD3PDMaker
from D3PDMakerCoreComps.D3PDObject import make_SG_D3PDObject
CaloInfoD3PDObject = make_SG_D3PDObject("CaloCellContainer", "AllCalo", "ccc_",
"CaloInfoD3PDObject")
CaloInfoD3PDObject.defineBlock(0,
'ALL',
CaloSysD3PDMaker.CaloInfoFillerTool,
PosNeg=0)
CaloInfoEtD3PDObject = make_SG_D3PDObject("CaloCellContainer", "AllCalo",
"cccEt_", "CaloInfoEtD3PDObject")
CaloInfoEtD3PDObject.defineBlock(0,
'AllEt',
CaloSysD3PDMaker.CaloInfoFillerTool,
prefix='Et_',
PosNeg=0,
DoEt=1)
# if the energies are summed for each side
CaloInfoEtD3PDObject.defineBlock(0,
'Pos',
CaloSysD3PDMaker.CaloInfoFillerTool,
prefix='p_',
PosNeg=1,
tileMuonFilter.MuonEtaCut = 1.7
tileMuonFilter.IsoCone = 0.4
tileMuonFilter.ErelCut = 0.1
tileMuonFilter.MuonCellR = 0.4 #radius of the cone around muon track to save the cells
tileMuonFilter.TrackTools = TrackTools
tileMuonFilter.DumpLArCells = False
algSequence += tileMuonFilter
# FILLERS #####################
# Event Filler
from TileD3PDMaker import TileEventFillerTool
TileEventFillerTool.LevelOfDetails = 4
from D3PDMakerCoreComps.D3PDObject import make_SG_D3PDObject
TileEventD3PDObject = make_SG_D3PDObject( "xAOD::EventInfo", D3PDMakerFlags.EventInfoSGKey(), 'evt_', "TileEventD3PDObject" )
TileEventD3PDObject.defineBlock(0, 'EventDump', TileD3PDMaker.TileEventFillerTool)
# Track Filler
from TileD3PDMaker import TileTrackFillerTool
TileTrackFillerTool.LevelOfDetails = 1
TileTrackFillerTool.TrackTools = TrackTools
TileTrackFillerTool.TrackParType = 0 ; #track parameters per 0: sampling 1: layer
TileTrackFillerTool.TrackToVertexTool = TrackToVertexTool
def tileTrackFiller(name, prefix, object_name):
tileTrackGetter = SGDataVectorGetterTool('track_getter',
TypeName = 'xAOD::TrackParticleContainer',
SGKey = 'SelectedTracks')
return VectorFillerTool(name,
Prefix = prefix,
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
from D3PDMakerCoreComps.D3PDObject import make_SG_D3PDObject
import ForwardDetectorsD3PDMaker
AfpSIDSimHitD3PDObject = make_SG_D3PDObject("AtlasHitsVector<AFP_SIDSimHit>",
"AFP_SIDSimHitCollection",
"afp_sidsim_",
"AfpSIDSimHitD3PDObject")
AfpSIDSimHitD3PDObject.defineBlock(
0, 'AFP_SIDSimHitCollection',
ForwardDetectorsD3PDMaker.AfpSIDSimHitCollectionFillerTool)
AfpTDSimHitD3PDObject = make_SG_D3PDObject("AtlasHitsVector<AFP_TDSimHit>",
"AFP_TDSimHitCollection",
"afp_tdsim_",
"AfpTDSimHitD3PDObject")
AfpTDSimHitD3PDObject.defineBlock(
0, 'AFP_TDSimHitCollection',
ForwardDetectorsD3PDMaker.AfpTDSimHitCollectionFillerTool)
AfpSIDDigiD3PDObject = make_SG_D3PDObject("AtlasHitsVector<AFP_SiDigi>",
"AFP_SiDigiCollection",
"afp_siddigi_",
"AfpSIDDigiD3PDObject")
AfpSIDDigiD3PDObject.defineBlock(
0, 'AFP_SiDigiCollection',
ForwardDetectorsD3PDMaker.AfpSIDDigiCollectionFillerTool)
AfpTDDigiD3PDObject = make_SG_D3PDObject("AtlasHitsVector<AFP_TDDigi>",
"AFP_TDDigiCollection", "afp_tddigi_",
import TriggerD3PDMaker
# This object can only be used on (D)ESD files, when the MuCTPI_RDO object is
# available:
from RecExConfig.ObjKeyStore import cfgKeyStore
if cfgKeyStore.isInInputFile("MuCTPI_RDO", "MUCTPI_RDO"):
_haveRDO = True
else:
_haveRDO = False
from AthenaCommon.Logging import logging
_mlog = logging.getLogger("MuCTPID3PDObject")
_mlog.warning("No MuCTPI_RDO object in input; skipping.")
MuCTPID3PDObject = make_SG_D3PDObject("MuCTPI_RDO",
"MUCTPI_RDO",
"muctpi_",
"MuCTPID3PDObject",
default_allowMissing=not _haveRDO)
if _haveRDO:
# Make sure the cabling services are configured:
import TrigT1RPCRecRoiSvc.TrigT1RPCRecRoiConfig
import TrigT1TGCRecRoiSvc.TrigT1TGCRecRoiConfig
# Define the blocks:
MuCTPID3PDObject.defineBlock(0,
"RDOInfo",
TriggerD3PDMaker.MuCTPI_RDOFillerTool,
WriteRawInfo=True)
MuCTPID3PDObject.defineBlock(1,
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
import MissingETD3PDMaker
import D3PDMakerCoreComps
from D3PDMakerCoreComps.D3PDObject import D3PDObject
from D3PDMakerCoreComps.D3PDObject import make_SG_D3PDObject
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
from MissingETD3PDMaker.MissingETD3PDMakerFlags import *
Atlfast1MissingETD3PDObject = \
make_SG_D3PDObject ('MissingET',
D3PDMakerFlags.MissingETSGKey(),
'MET_RefFinal_',
'Atlfast1MissingETD3PDObject')
Atlfast1MissingETD3PDObject.defineBlock(0, 'MET_RefFinal_',
MissingETD3PDMaker.MissingETFillerTool)
TruthMETD3PDObject = \
make_SG_D3PDObject ('MissingEtTruth',
MissingETD3PDMakerFlags.METTruthSGKey(),
'MET_Truth_',
'TruthMETD3PDObject')
TruthMETD3PDObject.defineBlock(
1, 'MET_Truth_NonInt_', MissingETD3PDMaker.MissingETTruthNonIntFillerTool)
TruthMETD3PDObject.defineBlock(
3, 'MET_Truth_Int_', MissingETD3PDMaker.MissingETD3PDMakerConf.
D3PD__MissingETTruthIntFillerTool)
from D3PDMakerCoreComps.D3PDObject import make_SG_D3PDObject
import EventCommonD3PDMaker
def _streamsName():
try:
from RecExConfig.InputFilePeeker import inputFileSummary
streams=inputFileSummary['stream_names'][0]
return streams + '_SkimDecisionsContainer'
except:
from AthenaCommon.Logging import logging
log = logging.getLogger ('SkimDecisionD3PDObject')
log.warn ('Unable to get stream_names from inputFileSummary')
return ''
SkimDecisionVectorD3PDObject = \
make_SG_D3PDObject ('SkimDecisionCollection',
_streamsName(),
'SkimDecision',
'SkimDecisionVectorD3PDObject')
SkimDecisionVectorD3PDObject.defineBlock \
(0, 'SkimDecision',
EventCommonD3PDMaker.SkimDecisionVectorFillerTool,
DoAllSkimDecisions = True,
SkimDecisionNames = [])
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
# $Id: BackgroundWordD3PDObject.py 351806 2011-03-15 10:05:36Z krasznaa $
#
# @file BackgroundD3PDMaker/python/BackgroundWordD3PDObject.py
# @author Mark Tibbets <*****@*****.**>
# @date Mar, 2011
# @brief D3PD object for EventInfo Background Word.
#
import D3PDMakerCoreComps
import BackgroundD3PDMaker
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
from D3PDMakerCoreComps.D3PDObject import make_SG_D3PDObject
BackgroundWordD3PDObject = \
make_SG_D3PDObject ('EventInfo',
D3PDMakerFlags.EventInfoSGKey(),
'bkgword_', 'BackgroundWordD3PDObject')
BackgroundWordD3PDObject.defineBlock(
0, 'BackgroundWord', BackgroundD3PDMaker.BackgroundWordFillerTool)
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
# $Id: RawInfoSummaryForTagD3PDObject.py 351806 2011-03-15 10:05:36Z krasznaa $
#
# @file BackgroundD3PDMaker/python/RawInfoSummaryForTagD3PDObject.py
# @author Mark Tibbets <*****@*****.**>
# @date Feb, 2011
# @brief D3PD object for RawInfoSummaryForTag.
#
import D3PDMakerCoreComps
import BackgroundD3PDMaker
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
from D3PDMakerCoreComps.D3PDObject import make_SG_D3PDObject
RawInfoSummaryForTagD3PDObject = \
make_SG_D3PDObject ('RawInfoSummaryForTag',
'RawInfoSummaryForTag',
'rawtag_', 'RawInfoSummaryForTagD3PDObject')
RawInfoSummaryForTagD3PDObject.defineBlock (0, 'RawTagInDetSP',
BackgroundD3PDMaker.RawTagInDetSPFillerTool)
from AthenaCommon.AlgSequence import AlgSequence
from RecExConfig.ObjKeyStore import cfgKeyStore
# We can only do this if we have the cell container.
if cfgKeyStore.isInInput('CaloCellContainer', 'AllCalo'):
_haveCells = True
else:
_haveCells = False
from AthenaCommon.Logging import logging
mlog = logging.getLogger('LArCollisionTimeD3PDObject')
mlog.warning('No AllCalo cell container; skipping.')
LArCollisionTimeD3PDObject = \
make_SG_D3PDObject ('LArCollisionTime',
D3PDMakerFlags.LArCollisionTimeSGKey(),
'lar_', 'LArCollisionTimeD3PDObject',
default_allowMissing = not _haveCells)
if _haveCells:
def _larCollTimeAlgHook(c,
seq=AlgSequence(
D3PDMakerFlags.PreD3PDAlgSeqName()),
*args,
**kw):
LArCollisionTimeGetter(seq)
return
LArCollisionTimeD3PDObject.defineHook(_larCollTimeAlgHook)
# $Id: TrigOperationalInfoD3PDObject.py 338058 2010-12-20 13:20:43Z krasznaa $
#
# D3PD object capable of saving the names of the chains which caused an event to
# end up in the express stream. Should only be useful for producing first trigger
# efficiency plots out of express stream data.
#
from D3PDMakerCoreComps.D3PDObject import make_SG_D3PDObject
import TriggerD3PDMaker
# This object can only be used on express stream (D)ESD files. So let's check
# whether the source object is available, because most of the time it isn't.
from RecExConfig.ObjKeyStore import cfgKeyStore
if cfgKeyStore.isInInput( "TrigOperationalInfoCollection", "HLT_EXPRESS_OPI_EF" ):
_haveOpInfo = True
else:
_haveOpInfo = False
from AthenaCommon.Logging import logging
_mlog = logging.getLogger( "TrigOperationalInfoD3PDObject" )
_mlog.warning( "No TrigOperationalInfoCollection object in input; skipping." )
TrigOperationalInfoD3PDObject = make_SG_D3PDObject( "TrigOperationalInfoCollection",
"HLT_EXPRESS_OPI_EF",
"trig_express_",
"TrigOperationalInfoD3PDObject",
default_allowMissing = not _haveOpInfo )
if _haveOpInfo:
TrigOperationalInfoD3PDObject.defineBlock( 0, "ExpressChains",
TriggerD3PDMaker.TrigOperationalInfoFillerTool )
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
# $Id: JetETROID3PDObject.py 504811 2012-06-10 13:09:39Z krasznaa $
#
# D3PD object saving the LVL1 JetET information into the D3PD
#
from D3PDMakerCoreComps.D3PDObject import make_SG_D3PDObject
import TriggerD3PDMaker
JetETROID3PDObject = \
make_SG_D3PDObject( "LVL1_ROI", "LVL1_ROI", "trig_L1_jetet_",
"JetETROID3PDObject",
default_getterClass = \
TriggerD3PDMaker.JetET_ROIGetterTool,
default_allowMissing = True )
JetETROID3PDObject.defineBlock(0,
"ThrInfo",
TriggerD3PDMaker.JetET_ROIFillerTool,
WriteThrInfo=True)
JetETROID3PDObject.defineBlock(1,
"DecodedInfo",
TriggerD3PDMaker.JetET_ROIFillerTool,
WriteDecodedInfo=True)
JetETROID3PDObject.defineBlock(2,
"RoIWord",
TriggerD3PDMaker.JetET_ROIFillerTool,
WriteRoIWord=True)
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
import MissingETD3PDMaker
from D3PDMakerCoreComps.D3PDObject import make_SG_D3PDObject
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
METD3PDObject = make_SG_D3PDObject('MissingET',
D3PDMakerFlags.MissingETSGKey(), 'met_',
'METD3PDObject')
METD3PDObject.defineBlock(0, 'MET', MissingETD3PDMaker.MissingETFillerTool)
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
from D3PDMakerCoreComps.D3PDObject import make_SG_D3PDObject
import ForwardDetectorsD3PDMaker
AlfaTruthInfoD3PDObject = make_SG_D3PDObject("McEventCollection", "TruthEvent",
"alfamc_",
"AlfaTruthInfoD3PDObject")
AlfaTruthInfoD3PDObject.defineBlock(
0, 'ALFA_McEventCollection',
ForwardDetectorsD3PDMaker.AlfaTruthInfoFillerTool)
# $Id$
#
# @file MissingETD3PDMaker/python/MissingETD3PDObject.py
# @author scott snyder <*****@*****.**>
# @date Aug, 2014
# @brief Simple xAOD missing ET dumper.
#
from D3PDMakerCoreComps.D3PDObject import make_SG_D3PDObject
#from D3PDMakerCoreComps.D3PDObject import DeferArg
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
import D3PDMakerCoreComps
import MissingETD3PDMaker
MissingETD3PDObject = make_SG_D3PDObject('xAOD::MissingETContainer_v1',
D3PDMakerFlags.MissingETSGKey(),
'met_', 'MissingETD3PDObject')
def _metLevel(req_lod, blockargs, objargs):
blockargs['Getter'].SGKey = objargs['sgkey']
return req_lod >= 0
MissingETD3PDObject.defineBlock(
_metLevel,
'MET',
MissingETD3PDMaker.MissingETContainerFillerTool,
Getter=D3PDMakerCoreComps.SGObjGetterTool(
'METAssocGetter', SGKey='', TypeName='xAOD::MissingETContainer_v1'),
)
# @file EventCommonD3PDMaker/python/EventInfoD3PDObject.py
# @author scott snyder <*****@*****.**>
# @date Aug, 2009
# @brief Define EventInfo D3PD object.
#
from RecExConfig.RecFlags import rec
import D3PDMakerCoreComps
import EventCommonD3PDMaker
from D3PDMakerCoreComps.D3PDObject import make_SG_D3PDObject
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
# Create the object type.
EventInfoD3PDObject = make_SG_D3PDObject( 'xAOD::EventInfo_v1',
D3PDMakerFlags.EventInfoSGKey(),
'',
'EventInfoD3PDObject' )
######
# Define blocks.
# Event ID information.
EventInfoD3PDObject.defineBlock (
0, 'eventID',
D3PDMakerCoreComps.AuxDataFillerTool,
Vars = ['RunNumber = runNumber',
'EventNumber = eventNumber',
'timestamp = timeStamp',
'timestamp_ns = timeStampNSOffset',
'lbn = lumiBlock',
#
# @file CaloD3PDMaker/python/LArNoisROD3PDObject.py
# @author Laurent Duflot <duflot at lal.in2p3.fr>
# @date Apr, 2010
# @brief D3PD object for LAr noisy FEB
#
import CaloD3PDMaker
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
from D3PDMakerCoreComps.D3PDObject import make_SG_D3PDObject
from RecExConfig.ObjKeyStore import cfgKeyStore
LArNoisyROD3PDObject = \
make_SG_D3PDObject ('LArNoisyROSummary',
# D3PDMakerFlags.LArNoisyROSGKey(),
'LArNoisyROSummary',
'larnro_',
'LArNoisyROD3PDObject',
default_allowMissing = True)
LArNoisyROD3PDObject.defineBlock(0,
'Basic',
CaloD3PDMaker.LArNoisyROFillerTool,
SaveNB=True,
SaveFEBID=False,
SavePAID=False)
LArNoisyROD3PDObject.defineBlock(1,
'FEBIDs',
CaloD3PDMaker.LArNoisyROFillerTool,
SaveNB=False,
SaveFEBID=True,
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
# $Id$
import CaloD3PDMaker
from D3PDMakerCoreComps.D3PDObject import make_SG_D3PDObject
TileHitInfoD3PDObject = make_SG_D3PDObject("AtlasHitsVector<TileHit>",
"TileHitVec", "Tile_",
"TileHitInfoInfoD3PDObject")
TileHitInfoD3PDObject.defineBlock(0,
'TileHitInfo',
CaloD3PDMaker.TileHitInfoFillerTool,
TimeMin=-12.5,
TimeMax=12.5,
TimeOut=99990.)
def getJetCollectionD3PDObject(objectname = 'JetCollectionD3PDObject', prefix = 'jet_'):
return make_SG_D3PDObject('JetCollection','','jet_', objectname)
#
# @file BackgroundD3PDMaker/python/Lucid_RawDataD3PDObject.py
# @author Mark Tibbets <*****@*****.**>
# @date Feb, 2011
# @brief D3PD object for LUCID_RawData.
#
import D3PDMakerCoreComps
import BackgroundD3PDMaker
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
from D3PDMakerCoreComps.D3PDObject import make_SG_D3PDObject
from RecExConfig.ObjKeyStore import cfgKeyStore
if cfgKeyStore.isInInput( "LUCID_RawDataContainer", "Lucid_RawData" ):
_haveLucid = True
else:
_haveLucid = False
from AthenaCommon.Logging import logging
_mlog = logging.getLogger( "Lucid_RawDataD3PDObject" )
_mlog.warning( "No LUCID_RawDataContainer object in input; skipping." )
Lucid_RawDataD3PDObject = \
make_SG_D3PDObject ('LUCID_RawDataContainer',
'Lucid_RawData',
'lucid_', 'Lucid_RawDataD3PDObject',
default_allowMissing = not _haveLucid )
if _haveLucid:
Lucid_RawDataD3PDObject.defineBlock (0, 'LucidPMTHits',
BackgroundD3PDMaker.LucidPMTHitFillerTool)
# @date Mar, 2010
# @brief D3PD object for collision decision flags.
#
import CaloD3PDMaker
import EventCommonD3PDMaker
from CaloD3PDMaker.CollisionDecisionGetter import CollisionDecisionGetter
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
from D3PDMakerCoreComps.D3PDObject import make_SG_D3PDObject
from AthenaCommon.AlgSequence import AlgSequence
CollisionDecisionD3PDObject = \
make_SG_D3PDObject ('SkimDecisionCollection',
'DESD_COLLCAND_SkimDecisionsContainer',
'collcand_', 'CollisionDecisionD3PDObject')
def _collDecisionAlgHook (c,
seq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()),
*args, **kw):
CollisionDecisionGetter (seq)
return
CollisionDecisionD3PDObject.defineHook (_collDecisionAlgHook)
CollisionDecisionD3PDObject.defineBlock \
(0, 'CollisionDecision',
EventCommonD3PDMaker.SkimDecisionFillerTool,
Flags = ["Accept_CaloTimeFilterInCollisionStream:passCaloTime:"
"True if the calorimeter time requirement has passed.",
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
# $Id: ZdcRecoD3PDObject.py 538891 2013-02-25 04:56:06Z leite $
from D3PDMakerCoreComps.D3PDObject import make_SG_D3PDObject
import ForwardDetectorsD3PDMaker
ZdcRecoD3PDObject = make_SG_D3PDObject("ZdcDigitsCollection",
"ZdcDigitsCollection", "ZdcReco_",
"ZdcRecoD3PDObject")
ZdcRecoD3PDObject.defineBlock(0, 'ZdcDigitsCollection',
ForwardDetectorsD3PDMaker.ZdcRecoFillerTool)
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
import D3PDMakerCoreComps
from D3PDMakerCoreComps.D3PDObject import D3PDObject
from D3PDMakerCoreComps.D3PDObject import (make_SG_D3PDObject, make_SGDataVector_D3PDObject)
from math import pi
import CaloSysD3PDMaker
AllSCD3PDObject = make_SG_D3PDObject( "CaloCellContainer",
"AllCalo",
"sc_",
"SCD3PDObject" )
AllSCD3PDObject.defineBlock( 0, 'Basic', CaloSysD3PDMaker.SCFillerTool )
def _hookForSCD3PDObject_(c, *arg, **kw ):
basFiller = getattr(c, c.name() + '_Basic', None)
print "getattr(c, c.name()) / Type= ", type(basFiller)
if "CaloEtaCut" in kw.keys():
basFiller.CaloEtaCut = kw["CaloEtaCut"]
if "CaloPhiCut" in kw.keys():
basFiller.CaloPhiCut = kw["CaloPhiCut"]
if "CaloLayers" in kw.keys():
basFiller.CaloLayers = kw["CaloLayers"]
if "CaloDetectors" in kw.keys():
basFiller.CaloDetectors = kw["CaloDetectors"]
if "TileDLayerOption" in kw.keys():
basFiller.TileDLayerOption = kw["TileDLayerOption"]
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
from D3PDMakerCoreComps.D3PDObject import make_SG_D3PDObject
import ForwardDetectorsD3PDMaker
AlfaD3PDObject = make_SG_D3PDObject("ALFA_CLinkEvent", "ALFA_CLinkEvent",
"alfa_", "AlfaD3PDObject")
AlfaD3PDObject.defineBlock(0, 'ALFA_CLinkEvent_EH',
ForwardDetectorsD3PDMaker.AlfaEventHeaderFillerTool)
AlfaD3PDObject.defineBlock(
0, 'ALFA_CLinkEvent_TD',
ForwardDetectorsD3PDMaker.AlfaTrackingDataFillerTool)
AlfaSimHitD3PDObject = make_SG_D3PDObject("AtlasHitsVector<ALFA_Hit>",
"ALFA_HitCollection", "alfa_simhit_",
"AlfaSimHitD3PDObject")
AlfaSimHitD3PDObject.defineBlock(
0, 'ALFA_HitCollection',
ForwardDetectorsD3PDMaker.AlfaHitCollectionFillerTool)
