# 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)