def CaloD3PD(alg=None, file='calo.root', tuplename='calo'): # Core algorithm # By default the user of this function should have created an algorithm # already. But for backwards compatibility let the function create its own # algorithm if needed... if not alg: from OutputStreamAthenaPool.MultipleStreamManager import MSMgr alg = MSMgr.NewRootStream(tuplename, file) alg += EventInfoD3PDObject(10) # alg += AllCaloCellD3PDObject (10) alg += SelCaloCellD3PDObject(10) # alg += EMCellD3PDObject (10) # alg += HECCellD3PDObject (10) # alg += FCALCellD3PDObject (10) # alg += TileCellD3PDObject (10) alg += CaloInfoD3PDObject(10) alg += ClusterD3PDObject(10) lardigit_sgkey = 'LArDigitContainer_Thinned' if testSGKey('LArDigitContainer', lardigit_sgkey): alg += LArDigitD3PDObject(2, sgkey=lardigit_sgkey) return alg
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 mu_D3PD(alg=None, file='tile.root', tuplename='calo'): if not alg: from OutputStreamAthenaPool.MultipleStreamManager import MSMgr alg = MSMgr.NewRootStream(tuplename, file) alg += TileD3PDMaker.TileD3PDObject.TileCellD3PDObject(10) alg += TileD3PDMaker.TileD3PDObject.TileMBTSD3PDObject(10) alg += TileD3PDMaker.TileD3PDObject.TileStacoMuonD3PDObject(10) alg += TileD3PDMaker.TileD3PDObject.TileEventD3PDObject(10) return alg
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') # apply skim SMDYEED3PDStream.AddAcceptAlgs(["SMWZ_JPsieeFilter"]) # add cut flow information from EventCommonD3PDMaker.CutFlowMetadataConfig import CutFlowMetadataConfig SMDYEED3PDStream.MetadataTools += [CutFlowMetadataConfig(SMDYEED3PDStream)] # Silence tool warnings:
D3PDMakerFlags.TruthWriteHadrons = True # add specific truth jets include("PhysicsD3PDMaker/MyJetMake.py") #configure MuonScatteringAngleSignificanceTool include("JetTagD3PDMaker/MuonScatteringSigToolConfig.py") ### Jason include("BTagging/BTagging_LoadTools.py") include("BTagging/BTagging_jobOptions.py") # Create the D3PD streams: from OutputStreamAthenaPool.MultipleStreamManager import MSMgr SMWZSOFTD3PDStream = MSMgr.NewRootStream(streamName, fileName, "physics") # Now add all the content to this stream: from PhysicsD3PDMaker.SMWZD3PD import SMWZD3PD if not 'SMWZsoftD3PD_args' in globals(): SMWZsoftD3PD_args = {} SMWZD3PD(SMWZSOFTD3PDStream, doSoftQCD=False, **SMWZsoftD3PD_args) # Silence tool warnings: from AthenaCommon.AppMgr import ToolSvc if not hasattr(ToolSvc, "TrigDecisionTool"): from TrigDecisionTool.TrigDecisionToolConf import Trig__TrigDecisionTool ToolSvc += Trig__TrigDecisionTool("TrigDecisionTool") pass ToolSvc.TrigDecisionTool.Navigation.OutputLevel = ERROR
rec.doApplyAODFix.set_Value_and_Lock(False) include("RecExCommon/RecExCommon_topOptions.py") #### #### #### #### #### #### #### #### #### # # Define the D3PD Stream # #### #### #### #### #### #### #### #### #### ## //////////////////////////////////////////////// ## Define the D3PD Stream from OutputStreamAthenaPool.MultipleStreamManager import MSMgr alg = MSMgr.NewRootStream("EFLOWD3PDSTREAM", "Test_eflowD3PD_16Dec_WithSplitShower_10Evts.root", "eflowD3PD") # algs to run prior to dumping from eflowD3PDMaker.eflowD3PDMakerConf import eflowClusterSelector eflowClusSelector = eflowClusterSelector() topSequence += eflowClusSelector from eflowRec.eflowTrackToCaloTrackExtrapolatorTool import eflowTrackToCaloTrackExtrapolatorToolDefault TrackToCaloTrackExtrapolatorToolDefault = eflowTrackToCaloTrackExtrapolatorToolDefault( ) #### #### #### #### #### #### #### #### #### # # Configure the D3PD #
EgammaD3PDStream_msg = logging.getLogger( 'EgammaD3PD_prodJobOFragment' ) # Check if the configuration makes sense: if prodFlags.WriteEgammaD3PD.isVirtual: EgammaD3PDStream_msg.error( "The Egamma D3PD stream can't be virtual! " + "It's a configuration error!" ) raise NameError( "Egamma D3PD set to be a virtual stream" ) pass #configure MuonScatteringAngleSignificanceTool include("JetTagD3PDMaker/MuonScatteringSigToolConfig.py") # Construct the stream and file names for the SUSY D3PD: streamName = prodFlags.WriteEgammaD3PD.StreamName fileName = buildFileName( prodFlags.WriteEgammaD3PD ) EgammaD3PDStream_msg.info( "Configuring EgammaD3PD with streamName '%s' and fileName '%s'" % \ ( streamName, fileName ) ) # Create the D3PD streams: from OutputStreamAthenaPool.MultipleStreamManager import MSMgr EgammaD3PDStream = MSMgr.NewRootStream( streamName, fileName, "egamma", asAlg=True ) EgammaTriggerD3PDStream = MSMgr.NewRootStream( streamName + ":" + streamName + "D3PDTrigDec", fileName, "egammaTrigDec", asAlg=True) # Now add all the content to this stream: from D3PDMakerConfig.egammaD3PD import egammaD3PD egammaD3PD_args = globals().get('egammaD3PD_args', {}) egammaD3PD( EgammaD3PDStream, EgammaTriggerD3PDStream, **egammaD3PD_args )
def backgroundD3PD(alg=None, level=10, file='background.root', tuplename='background', flags=BackgroundD3PDMakerFlags, **kw): preseq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()) if (not hasattr(topSequence, 'BeamBackgroundFiller') and not hasattr(preseq, 'BeamBackgroundFiller')): if cfgKeyStore.isInInput("Trk::SegmentCollection", "ConvertedMBoySegments"): from RecBackgroundAlgs import RecBackgroundAlgsConf preseq += RecBackgroundAlgsConf.BeamBackgroundFiller() if (not hasattr(topSequence, 'BeamBackgroundFillerMoore') and not hasattr(preseq, 'BeamBackgroundFillerMoore')): if cfgKeyStore.isInInput("Trk::SegmentCollection", "MooreSegments"): from RecBackgroundAlgs.RecBackgroundAlgsConf import BeamBackgroundFiller BeamBackgroundFillerMoore = BeamBackgroundFiller( 'BeamBackgroundFillerMoore', muonSegmentContainerKey='MooreSegments', BeamBackgroundKey='BeamBackgroundDataMoore') preseq += BeamBackgroundFillerMoore # The core algorithm if not alg: from OutputStreamAthenaPool.MultipleStreamManager import MSMgr alg = MSMgr.NewRootStream(tuplename, file) #Event level info alg += EventInfoD3PDObject(**_args(1, 'EventInfo', kw)) if globalflags.DataSource == "data": alg += LBLengthD3PDObject(**_args(0, 'LBLength', kw)) if rec.doTruth(): from TruthD3PDMaker.GenEventD3PDObject import GenEventD3PDObject alg += GenEventD3PDObject(**_args(0, 'GenEvent', kw)) if rec.doTrigger(): alg += TrigDecisionD3PDObject(**_args(2, 'TrigDecision', kw)) addTrigConfMetadata(alg) bcToolType = "" if globalflags.DataSource == "data": bcToolType = "LHC" addBunchStructureMetadata(alg, bcToolType) alg += BGCodeD3PDObject(**_args(2, 'BGCode', kw)) if flags.AddTriggerBits(): alg += getBkgdTriggerBitsD3PDObject([]) alg += BackgroundWordD3PDObject(**_args(0, 'BkgWord', kw)) if flags.doLUCID(): alg += Lucid_RawDataD3PDObject(**_args(0, 'Lucid', kw)) alg += RawInfoSummaryForTagD3PDObject(**_args(0, 'SumForTag', kw)) alg += MBTSD3PDObject(**_args(0, 'MBTS', kw)) alg += LArCollisionTimeD3PDObject(**_args(0, 'LArTimeDiff', kw)) if flags.doMet(): alg += MissingETD3PDObject(**_args(1, 'MET_RefFinal', kw, sgkey='MET_RefFinal', prefix='MET_RefFinal', allowMissing=True)) alg += MuonD3PDObject( **_args(0, 'Muon', kw, sgkey='MuonCollection', prefix='mu_', include=[ "Isolation", "Quality", "MuonTimingFillerTool", "MuonTileTimeTool", "ChamberT0" ], allowMissing=True)) alg += MuonD3PDObject( **_args(0, 'MuidMuon', kw, sgkey='MuidMuonCollection', prefix='mu_muid_', include=[ "Isolation", "Quality", "MuonTimingFillerTool", "MuonTileTimeTool", "ChamberT0" ], allowMissing=True)) alg += MuonD3PDObject( **_args(0, 'StacoMuon', kw, sgkey='StacoMuonCollection', prefix='mu_staco_', include=[ "Isolation", "Quality", "MuonTimingFillerTool", "MuonTileTimeTool", "ChamberT0" ], allowMissing=True)) if flags.doCaloMuon(): alg += MuonD3PDObject( **_args(0, 'CaloMuon', kw, sgkey='CaloMuonCollection', prefix='mu_calo_', include=[ "Isolation", "Quality", "MuonTimingFillerTool", "MuonTileTimeTool", "ChamberT0" ], allowMissing=True)) alg += MuonSegmentD3PDObject(**_args( 1, 'MuonSeg', kw, sgkey='MuonSegments', prefix='museg_', # MooreSegmentT0 takes the default time # MuonboySegmentT0 recalculates time (see MuonSegmentD3PDObject.py and MuonSegmentT0FillerTool.cxx) include=['MooreSegmentT0'], exclude=['MuonboySegmentT0'], allowMissing=True)) alg += MuonSegmentD3PDObject(**_args(1, 'MooreSeg', kw, sgkey='MooreSegments', prefix='mooreseg_', include=['MooreSegmentT0'], exclude=['MuonboySegmentT0'], allowMissing=True)) alg += MuonSegmentD3PDObject(**_args(1, 'MboySeg', kw, sgkey='ConvertedMBoySegments', prefix='mboyseg_', include=['MuonboySegmentT0'], exclude=['MooreSegmentT0'], allowMissing=True)) if flags.doMuGirlSeg(): alg += MuonSegmentD3PDObject(**_args(1, 'MuGirlSeg', kw, sgkey='MuGirlSegments', prefix='mgseg_', include=['MooreSegmentT0'], exclude=['MuonboySegmentT0'], allowMissing=True)) if flags.doTrk(): alg += xAODTrackParticleD3PDObject( **_args(0, 'TrackParticle', kw, prefix='trk_')) if flags.doMuonHits(): alg += MdtPrepDataD3PDObject(0) alg += RpcPrepDataD3PDObject(0) alg += CscPrepDataD3PDObject(0) alg += TgcPrepDataD3PDObject(0) alg += TgcPrepDataD3PDObject(**_args(0, 'TGC_MeasurementsPriorBC', kw, sgkey='TGC_MeasurementsPriorBC', prefix='tgcPriorBC_', label='TgcPrepDataPriorBC')) alg += TgcPrepDataD3PDObject(**_args(0, 'TGC_MeasurementsNextBC', kw, sgkey='TGC_MeasurementsNextBC', prefix='tgcNextBC_', label='TgcPrepDataNextBC')) if flags.doCaloJet(): #alg += JetD3PDObject (**_args(4,'AntiKt4TopoEMJets', kw, sgkey='AntiKt4TopoEMJets', prefix='AntiKt4TopoEM_', include='BeamBackground' )) if cfgKeyStore.isInInput("Trk::SegmentCollection", "ConvertedMBoySegments"): alg += JetD3PDObject( **_args(4, 'AntiKt4TopoEMJets', kw, sgkey='AntiKt4TopoEMJets', prefix='AntiKt4TopoEM_', include=['BeamBackground'], exclude=[ 'JetVertexFraction', 'JVtx', 'ActiveArea', 'TruthMF', 'TracksMoments' ], BeamBackground_BeamBackgroundKey='BeamBackgroundData')) else: alg += JetD3PDObject( **_args(4, 'AntiKt4TopoEMJets', kw, sgkey='AntiKt4TopoEMJets', prefix='AntiKt4TopoEM_', exclude=[ 'JetVertexFraction', 'JVtx', 'ActiveArea', 'TruthMF', 'TracksMoments' ])) else: alg += JetD3PDObject( **_args(4, 'AntiKt4TrackJets', kw, sgkey='AntiKt4TrackJets', prefix='AntiKt4Track_', exclude=[ 'JetVertexFraction', 'JVtx', 'ActiveArea', 'TruthMF', 'TracksMoments' ])) alg += PrimaryxAODVertexD3PDObject(0) if flags.doBeamBkgd(): #alg += BeamBackgroundD3PDObject(1) if cfgKeyStore.isInInput("Trk::SegmentCollection", "ConvertedMBoySegments"): alg += BeamBackgroundD3PDObject( **_args(1, 'BeamBackgroundData', kw, sgkey='BeamBackgroundData', prefix='bb_', bbJetIndex_Target='AntiKt4TopoEM_', bbClusterIndex_Target='cl_')) if cfgKeyStore.isInInput("Trk::SegmentCollection", "MooreSegments"): alg += BeamBackgroundD3PDObject( **_args(1, 'BeamBackgroundData', kw, sgkey='BeamBackgroundDataMoore', prefix='bbMoore_', bbJetIndex_Target='AntiKt4TopoEM_', bbClusterIndex_Target='cl_')) if flags.doBCM(): alg += BcmRdoFlatD3PDObject(**_args(0, 'BCMRdo', kw)) if flags.doZDC(): if globalflags.DataSource == "data": alg += ZdcD3PDObject(10) if flags.doPixelClus(): from InDetD3PDMaker.PixelClusterD3PDObject import PixelClusterD3PDObject alg += PixelClusterD3PDObject(0) if flags.doCaloClus(): from CaloSysD3PDMaker.ClusterD3PDObject import ClusterD3PDObject alg += ClusterD3PDObject(1) return alg
# Check if the configuration makes sense: if prodFlags.WriteJetMetWZD3PD.isVirtual: JetMetWZD3PDStream_msg.error( "The Qcd D3PD stream can't be virtual! " + "It's a configuration error!" ) raise NameError( "Qcd D3PD set to be a virtual stream" ) pass # Construct the stream and file names for the Qcd D3PD: streamName = prodFlags.WriteJetMetWZD3PD.StreamName fileName = buildFileName( prodFlags.WriteJetMetWZD3PD ) JetMetWZD3PDStream_msg.info( "Configuring JetMetWZD3PD with streamName '%s' and fileName '%s'" % \ ( streamName, fileName ) ) # Create the D3PD stream itself: from OutputStreamAthenaPool.MultipleStreamManager import MSMgr JetMetWZD3PDStream = MSMgr.NewRootStream( streamName, fileName, "qcd" ) # Now add all the content to this stream: from QcdD3PDMaker.QcdD3PD import QcdD3PD QcdD3PD( JetMetWZD3PDStream ) ### large-R jets from RecExConfig.ObjKeyStore import objKeyStore if objKeyStore.isInInput("CaloClusterContainer","CaloCalTopoCluster"): preseq = AlgSequence (D3PDMakerFlags.PreD3PDAlgSeqName()) from QcdD3PDMaker.JSjets import createJSJets from QcdD3PDMaker.JSD3PD import JSD3PD from QcdD3PDMaker.GroomedJetsConfig import getGroomedJetsConfig dictsConfig = getGroomedJetsConfig() for dC in dictsConfig:
import AthenaPoolCnvSvc.ReadAthenaPool svcMgr.EventSelector.InputCollections = [ "/afs/cern.ch/atlas/project/PAT/xAODs/r5534/valid2.117050.PowhegPythia_P2011C_ttbar.digit.AOD.e2657_s1933_s1964_r5534/AOD.01482225._000107.pool.root.1" ] # ==================================================================== # Define your output root file using MultipleStreamManager # ==================================================================== from OutputStreamAthenaPool.MultipleStreamManager import MSMgr rootStreamName = "MyFirstHistoStream" rootFileName = "myHistosAth.root" MyFirstHistoXAODStream = MSMgr.NewRootStream(rootStreamName, rootFileName) rootDirName = "/Hists" # Now, import the new histogram manager and histogram tool from HistogramUtils.HistogramManager import HistogramManager as HistMgr from HistogramUtils.HistogramTool import HistogramTool as HistTool histMgr = HistMgr( "MyHistMgr", RootStreamName=rootStreamName, RootDirName=rootDirName, ) # Import the 1-d and 2-d histograms from ROOT from ROOT import TH1F, TH2F # Adding a few histograms to the histogram manager # Note the different methods of doing this (they are all equivalent) histMgr += (TH1F("ept", "p_{t}^{e}", 50, 0.0,
from AthenaCommon.GlobalFlags import jobproperties jobproperties.AthenaCommonFlags.PoolAODOutput = "%s.aod.pool.root" % outfile jobproperties.AthenaCommonFlags.PoolESDOutput = "%s.esd.pool.root" % outfile jobproperties.Rec.RootNtupleOutput = "%s.cbnt.root" % outfile include("RecExCond/RecExCommon_flags.py") include("RecExCommon/RecExCommon_topOptions.py") tuple_name = "%s.D3PD.root" % outfile from ForwardDetectorsD3PDMaker.ForwardDetectorsD3PDMakerFlags import jobproperties if jobproperties.ForwardDetectorsD3PDMakerFlags.FileName.statusOn: tuple_name = jobproperties.ForwardDetectorsD3PDMakerFlags.FileName() pass # Create the D3PD stream: from OutputStreamAthenaPool.MultipleStreamManager import MSMgr alg = MSMgr.NewRootStream("ForwardDetectorsD3PD", tuple_name) ##Event Info from EventCommonD3PDMaker.EventInfoD3PDObject import EventInfoD3PDObject alg += EventInfoD3PDObject(10) ##ZDC ##Energy and time information from ForwardDetectorsD3PDMaker.ZdcD3PDObject import ZdcD3PDObject from ForwardDetectorsD3PDMaker.ZdcDigitsD3PDObject import ZdcDigitsD3PDObject if globalflags.DataSource == "data": alg += ZdcD3PDObject(10) alg += ZdcDigitsD3PDObject(10) pass
def egammaD3PD(alg=None, trigalg=None, level=10, file='egamma.root', tuplename='egamma', **kw): preseq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()) createxAOD(preseq) if not cfgKeyStore.isInInput('xAOD::ElectronContainer', 'AllElectrons'): preseq += MergeElectrons() # Core algorithm # By default the user of this function should have created an algorithm already. # But for backwards compatibility let the function create its own algorithm if # needed... if not alg: from OutputStreamAthenaPool.MultipleStreamManager import MSMgr alg = MSMgr.NewRootStream(tuplename, file) alg += EventInfoD3PDObject(**_args(level, 'EventInfo', kw)) # Segregate trigger decision flags in a separate tree. if not trigalg: from OutputStreamAthenaPool.MultipleStreamManager import MSMgr trigalg = MSMgr.NewRootStream(tuplename + ':' + tuplename + 'TrigDec', FileName=file, TreeName=tuplename + 'TrigDec') trigalg += EventInfoD3PDObject(0) alg.Stream.trigDecisionTree = trigalg # Add bunch structure metadata. from TriggerD3PDMaker.BunchStructureMetadata \ import addBunchStructureMetadata addBunchStructureMetadata(alg) alg += LArCollisionTimeD3PDObject(**_args(level, 'LArCollisionTime', kw)) alg += ElectronD3PDObject(**_args( level, 'Electron', kw, EgammaJetSignedIPAndPTRel_target='jet_')) alg += PhotonD3PDObject(**_args(level, 'Photon', kw)) # # Additional muon variables for Zg skims. # if not MuonD3PDObject.allBlocknames().has_key("MuonScatteringAngleSignificance"): # from AthenaCommon.AppMgr import ToolSvc # muonScatteringSigTool=None # if hasattr(ToolSvc, "MuonScatteringSigTool"): # muonScatteringSigTool=ToolSvc.MuonScatteringSigTool # from JetTagD3PDMaker import MuonScatteringAngleSignificanceFillerTool # MuonD3PDObject.defineBlock (100, "MuonScatteringAngleSignificance", # MuonScatteringAngleSignificanceFillerTool, # ScatteringSigTool=muonScatteringSigTool) alg += MuonD3PDObject(**_args( 10, 'Muons', kw, sgkey='StacoMuonCollection,Muons', prefix='mu_', include=[ "EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex", "L2CBInfoIndex", "L1InfoIndex", "MuonScatteringAngleSignificance" ], exclude=["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"], allowMissing=True)) alg += JetD3PDObject( **_args(0, 'Jet', kw, include=['JetQual', 'DQMoments'])) alg += MBTSD3PDObject(**_args(level, 'MBTS', kw)) alg += MBTSTimeD3PDObject(**_args(level, 'MBTSTime', kw)) # alg += MBTSTriggerBitsD3PDObject (**_args (level, 'MBTSTriggerBits', kw)) # alg += ZDCTriggerBitsD3PDObject (**_args (level, 'ZDCTriggerBits', kw)) alg += CollisionDecisionD3PDObject(**_args(level, 'CollisionDecision', kw)) alg += MissingETD3PDObject(**_args(level, 'MissingET', kw, sgkey='MET_Core_AntiKt4EMTopo', prefix='MET_RefFinal_')) if D3PDMakerFlags.DoTrigger(): from TriggerD3PDMaker.TrigDecisionD3PDObject \ import TrigDecisionD3PDObject alg += TrigDecisionD3PDObject(**_args(2, 'TrigDecision', kw)) #TrigEgammaD3PDObjects (alg, **_args (1, 'TrigEgamma', kw, # TrigEMCluster_level = 2)) # from TriggerD3PDMaker.EnergySumROID3PDObject import EnergySumROID3PDObject # from TrigMissingETD3PDMaker.TrigMETD3PDObject import TrigMETD3PDObject # alg += EnergySumROID3PDObject(**_args (level, 'EnergySumROI', kw, # prefix = "trig_L1_esum_", # allowMissing = True)) # # The LVL2 information: # alg += TrigMETD3PDObject(**_args( level, 'TrigMETL2', kw, # prefix = "trig_L2_met_", # sgkey = "HLT_T2MissingET" )) # if cfgKeyStore.isInInputFile( "TrigMissingETContainer", "HLT_L2MissingET_FEB" ): # alg += TrigMETD3PDObject(**_args( level, 'TrigMETL2_FEB', kw, # prefix = "trig_L2_feb_met_", # sgkey = "HLT_L2MissingET_FEB" )) # # The EF information: # alg += TrigMETD3PDObject(**_args ( level, 'TrigMETEF', kw, # prefix = "trig_EF_met_", # sgkey = "HLT_TrigEFMissingET" )) # from TriggerD3PDMaker.BGCodeD3PDObject import BGCodeD3PDObject # alg += BGCodeD3PDObject (**_args (2, 'BGCode', kw)) # May be missing in single-beam data. alg += PrimaryxAODVertexD3PDObject(**_args( 1, 'PrimaryVertex', kw, #allowMissing = True, sgkey=D3PDMakerFlags.VertexSGKey(), prefix='vxp_', storeVertexTrackIndexAssociation=False, storeVertexTrackAssociation=True, storeDiagonalCovarianceAsErrors=True)) if rec.doTruth(): from MuonD3PDMaker.TruthMuonD3PDObject import TruthMuonD3PDObject alg += TruthMuonD3PDObject(**_args(level, 'TruthMuon', kw)) alg += TruthEventD3PDObject(**_args(1, 'TruthEvent', kw)) alg += TruthParticleD3PDObject(**_args(level, 'TruthParticle', kw)) # alg.MetadataTools += [LBMetadataConfig()] # if D3PDMakerFlags.FilterCollCand(): # from CaloD3PDMaker.CollisionFilterAlg import CollisionFilterAlg # alg.filterSeq += CollisionFilterAlg (tuplename + '_CollCandFilter') return alg
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 SMWZLightD3PD(SMZMUMUD3PDStream, stdElectronContainer='HighPtElectrons', stacoMuonContainer='LowPtStacoMuons', muidMuonContainer='LowPtMuidMuons', photonContainer='HighPtPhotons', jetContainer='HighPtJets') # apply skim SMZMUMUD3PDStream.AddAcceptAlgs( ["SMWZ_ZmumuStacoFilter", "SMWZ_ZmumuMuidFilter"])
VertexD3PDAnalysisFlags.useJets = False VertexD3PDAnalysisFlags.useTaus = False include("TrackD3PDMaker/VertexGroupD3PD_loadConfig.py") ### Semi-automatic configuration steps ## The following needs to be given as preExec ## (it has to be set before including RecExCommon) #if VertexD3PDAnalysisFlags.useAllVertexCollections: # #Need to enable algorithms in IDRE # from InDetRecExample.InDetJobProperties import InDetFlags # InDetFlags.doVertexFindingForMonitoring.set_Value_and_Lock(True) ### Setup algorithm if vtxprodFlags.WriteIDVTXLUMID3PD.isVirtual: raise NameError("IDVTXLUMID set to be a virtual stream") pass streamName = vtxprodFlags.WriteIDVTXLUMID3PD.StreamName fileName = buildFileName(vtxprodFlags.WriteIDVTXLUMID3PD) from OutputStreamAthenaPool.MultipleStreamManager import MSMgr VertexLumiD3PDMaker = MSMgr.NewRootStream( vtxprodFlags.WriteIDVTXLUMID3PD.StreamName, fileName, VertexD3PDAnalysisKeys.D3PDTreeName()) ### Add objects to the algorithm from TrackD3PDMaker.VertexGroupD3PD import VertexGroupD3PD VertexGroupD3PD(VertexLumiD3PDMaker, **(VertexD3PDAnalysisFlags.D3PDMakerExtraDict()))
# Construct the stream and file names for the SMTRILEP D3PD: streamName = prodFlags.WriteSMTRILEPD3PD.StreamName fileName = buildFileName(prodFlags.WriteSMTRILEPD3PD) SMTRILEPD3PDStream_msg.info( "Configuring SMTRILEPD3PD with streamName '%s' and fileName '%s'" % \ ( streamName, fileName ) ) # add specific truth jets #include ("PhysicsD3PDMaker/MyJetMake.py") #configure MuonScatteringAngleSignificanceTool #include("JetTagD3PDMaker/MuonScatteringSigToolConfig.py") # Create the D3PD streams: from OutputStreamAthenaPool.MultipleStreamManager import MSMgr SMTRILEPD3PDStream = MSMgr.NewRootStream(streamName, fileName, "physics") # Now add all the content to this stream: #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
def physicsD3PD(alg=None, trigalg=None, file='physics.root', tuplename='physics', **kw): # Core algorithm # By default the user of this function should have created an algorithm already. # But for backwards compatibility let the function create its own algorithm if # needed... if not alg: from OutputStreamAthenaPool.MultipleStreamManager import MSMgr alg = MSMgr.NewRootStream(tuplename, file) alg += EventInfoD3PDObject(**_args(10, 'EventInfo', kw)) # Segregate trigger decision flags in a separate tree. if not trigalg: from OutputStreamAthenaPool.MultipleStreamManager import MSMgr trigalg = MSMgr.NewRootStream(tuplename + ':' + tuplename + 'TrigDec', FileName=file, TreeName=tuplename + 'TrigDec') trigalg += EventInfoD3PDObject(0) alg.Stream.trigDecisionTree = trigalg # Add bunch structure metadata. from TriggerD3PDMaker.BunchStructureMetadata \ import addBunchStructureMetadata addBunchStructureMetadata(alg) # Make track jets, but we can only do this if we have vertices. if testSGKey('VxContainer', 'VxPrimaryCandidate'): from D3PDMakerConfig.createTrackJets import createTrackJets createTrackJets(AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName())) alg += JetD3PDObject(**_args( -1, 'TrackJet', kw, prefix='trackjet_', sgkey='AntiKtZ5TrackJets')) k = 'Electron_EgammaTrackJetSignedIPAndPTRel_target' if not kw.has_key(k): kw[k] = 'trackjet_' alg += LArCollisionTimeD3PDObject(**_args(10, 'LArCollisionTime', kw)) # Electron/Photon blocks alg += ElectronD3PDObject( **_args(10, 'Electron', kw, EgammaJetSignedIPAndPTRel_target='jet_antikt4h1topo_')) alg += PhotonD3PDObject( **_args(10, 'Photon', kw, ConversionVertexTrackIndex_target='trk')) if testSGKey('ElectronContainer', D3PDMakerFlags.GSFElectronSGKey()): alg += GSFElectronD3PDObject( **_args(level, 'GSFElectron', kw, sgkey=D3PDMakerFlags.GSFElectronSGKey(), prefix='el_gsf_')) # Muon blocks alg += MuonD3PDObject(**_args(10, 'MuidMuon', kw, sgkey='MuidMuonCollection', prefix='mu_muid_', allowMissing=True)) alg += MuonD3PDObject(**_args(10, 'StacoMuon', kw, sgkey='StacoMuonCollection', prefix='mu_staco_', allowMissing=True)) alg += MuonD3PDObject(**_args( 10, 'Muons', kw, sgkey='Muons', prefix='mu_', allowMissing=True)) # Tau block alg += TauD3PDObject(**_args(1, 'Tau', kw)) # Jet blocks alg += JetD3PDObject(**_args(9, 'AK4TopoJet', kw, sgkey='AntiKt4TopoEMJets,' + 'AntiKt4TopoJets,' + 'AntiKt4H1TopoJets', prefix='jet_antikt4h1topo_', ConstitIndex_Target='cl_', exclude=['Constituents'], allowMissing=True)) alg += JetD3PDObject(**_args(6, 'AK4TowerJet', kw, sgkey='AntiKt4TowerAODJets,' + 'AntiKt4TowerJets,' + 'AntiKt4H1TowerJets', prefix='jet_antikt4h1tower_', exclude=['Constituents'], allowMissing=True)) alg += JetD3PDObject(**_args(6, 'AK6TowerJet', kw, sgkey='AntiKt6TowerAODJets,' + 'AntiKt6TowerJets,' + 'AntiKt6H1TowerJets', prefix='jet_antikt6h1tower_', exclude=['Constituents'], allowMissing=True)) #alg += JetD3PDObject (**_args ( 9, 'AK4TopoJetLC', kw, # sgkey='AntiKt4LCTopoJets', prefix='jet_antikt4lctopo_')) #alg += JetD3PDObject (**_args ( 9, 'AK6TopoJetLC', kw, # sgkey='AntiKt6LCTopoMyJets', prefix='jet_antikt6lctopo_')) #alg += JetD3PDObject (**_args ( 9, 'AK6TopoJetH1', kw, # sgkey='AntiKt6H1TopoMyJets', prefix='jet_antikt6h1topo_')) # MET blocks alg += MissingETD3PDObject(**_args(10, 'MissingET', kw, allowMissing=True)) alg += MissingETGoodnessD3PDObject(**_args(2, 'METGoodness', kw)) # track and cluster blocks alg += ClusterD3PDObject(**_args(1, 'Cluster', kw)) alg += EMClusterD3PDObject(**_args(2, 'EMCluster', kw)) # Many of these are just being set to the defaults --- that's because # they're being changed in TrigEgamma... alg += TrackParticleD3PDObject( **_args(3, 'TrackParticle', kw, TruthParticleTarget='mc_', storeTruthInfo=True, trackParametersAtGlobalPerigeeLevelOfDetails=3, storeDiagonalCovarianceAsErrors=True)) # MBTS alg += MBTSD3PDObject(**_args(10, 'MBTS', kw)) alg += MBTSTimeD3PDObject(**_args(10, 'MBTSTime', kw)) alg += MBTSTriggerBitsD3PDObject(**_args(10, 'MBTSTriggerBits', kw)) alg += CollisionDecisionD3PDObject(**_args(10, 'CollisionDecision', kw)) # ZDC alg += ZDCTriggerBitsD3PDObject(**_args(10, 'ZDCTriggerBits', kw)) # Primary vertex block - May be missing in single-beam data. alg += PrimaryVertexD3PDObject( **_args(1, 'PrimaryVertex', kw, allowMissing=True, sgkey=D3PDMakerFlags.VertexSGKey(), prefix='vxp_', storeVertexTrackAssociation=True, storeDiagonalCovarianceAsErrors=True)) # Truth if rec.doTruth(): from MuonD3PDMaker.TruthMuonD3PDObject import TruthMuonD3PDObject alg += TruthMuonD3PDObject(**_args(2, 'TruthMuon', kw)) alg += GenEventD3PDObject(**_args(1, 'GenEvent', kw)) alg += TruthParticleD3PDObject(**_args(1, 'TruthParticle', kw)) alg += JetD3PDObject(**_args(3, 'AK4TruthJet', kw, sgkey='AntiKt4TruthJets', prefix='jet_antikt4truth_', allowMissing=True)) #alg += JetD3PDObject (**_args ( 3, 'AK6Ttruth', kw, # sgkey='AntiKt6TruthJets', # prefix='jet_antikt6truth_')) # Trigger if D3PDMakerFlags.DoTrigger(): from TriggerD3PDMaker.TrigDecisionD3PDObject \ import TrigDecisionD3PDObject alg += TrigDecisionD3PDObject(**_args(2, 'TrigDecision', kw)) TrigEgammaD3PDObjects(alg, **_args(1, 'TrigEgamma', kw)) alg += egammaTriggerBitsD3PDObject(**_args(2, 'EgammaTriggerBits', kw)) alg += MuonTriggerBitsD3PDObject(**_args(2, 'MuonTriggerBits', kw)) alg += METD3PDTriggerBitsObject(**_args(2, 'METTriggerBits', kw)) from TriggerD3PDMaker.EnergySumROID3PDObject import EnergySumROID3PDObject from TrigMissingETD3PDMaker.TrigMETD3PDObject import TrigMETD3PDObject alg += EnergySumROID3PDObject(**_args( 2, 'EnergySumROI', kw, prefix="trig_L1_esum_", allowMissing=True)) # The LVL2 information: alg += TrigMETD3PDObject(**_args( 2, 'TrigMETL2', kw, prefix="trig_L2_met_", sgkey="HLT_T2MissingET")) # The EF information: alg += TrigMETD3PDObject(**_args(2, 'TrigMETEF', kw, prefix="trig_EF_met_", sgkey="HLT_TrigEFMissingET")) from TriggerD3PDMaker.BGCodeD3PDObject import BGCodeD3PDObject alg += BGCodeD3PDObject(**_args(2, 'BGCode', kw)) # Event metadata alg.MetadataTools += [LBMetadataConfig()] if D3PDMakerFlags.FilterCollCand(): from CaloD3PDMaker.CollisionFilterAlg import CollisionFilterAlg alg.filterSeq += CollisionFilterAlg(tuplename + '_CollCandFilter') return alg
HSG5D3PD_msg.error( "The HSG5 WH unboosted D3PD stream can't be virtual! " + "It's a configuration error!" ) raise NameError( "HSG5 D3PD set to be a virtual stream" ) pass # Create the D3PD streams: from OutputStreamAthenaPool.MultipleStreamManager import MSMgr # Construct the stream and file names for the SMWZ D3PD: streamName = prodFlags.WriteHSG5WHUD3PD.StreamName fileName = buildFileName( prodFlags.WriteHSG5WHUD3PD ) HSG5D3PD_msg.info( "Configuring HSG5D3PD with streamName '%s' and fileName '%s'" % \ ( streamName, fileName ) ) HSG5D3PD_Stream = MSMgr.NewRootStream( streamName, fileName, "physics" ) # create stream #from PhysicsD3PDMaker.SMWZD3PD import SMWZD3PD #SMWZD3PD( HSG5D3PD_Stream ) if 'IS_SIMULATION' in inputFileSummary['evt_type']: from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags D3PDMakerFlags.TruthWriteHadrons.set_Value_and_Lock(True) # set flags from HSG5DPDUtils.HSG5Flags import HSG5WHUFlags HSG5WHUFlags.doTaus = True HSG5WHUFlags.doPhotons = True
include("TileSimEx/jobOptions_TileTB_Sim.py") if not 'doD3PD' in dir(): doD3PD = True if not 'doHitNtuple' in dir(): doHitNtuple = True theApp.HistogramPersistency = "ROOT" if doD3PD: from OutputStreamAthenaPool.MultipleStreamManager import MSMgr alg = MSMgr.NewRootStream("AANT", "tiletb%s.d3pd.root" % FileSuffix, "truth") topSeq.AANTAANTStream.WriteInputDataHeader = False topSeq.AANTAANTStream.ExistDataHeader = False from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags D3PDMakerFlags.TruthSGKey = 'TruthEvent' from TruthD3PDMaker.TruthD3PDMakerKeys import TruthD3PDKeys from TruthD3PDMaker.TruthD3PDMakerFlags import TruthD3PDFlags from TruthD3PDAnalysis.GenObjectsFilterTool import * from TruthD3PDMaker.GenVertexD3PDObject import GenVertexD3PDObject alg += GenVertexD3PDObject(10, filter=AllTrackFilterTool()) from TruthD3PDMaker.GenParticleD3PDObject import GenParticleD3PDObject alg += GenParticleD3PDObject(10, filter=AllTrackFilterTool())
def BTaggingD3PD(alg=None, file=JetTagD3PDKeys.D3PDFileName(), algname=JetTagD3PDKeys.D3PDAlgName(), **kw): print "printing additional d3pd properties from dictionary" print kw if not alg: from OutputStreamAthenaPool.MultipleStreamManager import MSMgr alg = MSMgr.NewRootStream(JetTagD3PDKeys.D3PDAlgName(), JetTagD3PDKeys.D3PDFileName(), JetTagD3PDKeys.D3PDTupleName()) selectedJetCollections = [] if len(JetTagD3PDFlags.JetCollections()) != 0: from JetTagD3PDMaker.JetTagJetD3PDObject import getJetTagJetD3PDObject for jetcoll in JetTagD3PDFlags.JetCollections(): filteredcoll = jetcoll + JetTagD3PDKeys.FilteredJetCollectionPostfix( ) ### you can add specific selection for a certain jet collection as argument to the function bellow ### otherwise the one specified by JetTagD3PDFlags will be used alg += getJetTagJetD3PDObject(**_args( jetcoll, kw, filteredsgkey=filteredcoll, origsgkey=jetcoll)) selectedJetCollections.append(filteredcoll) else: print "Warning: you didn't specify any jet collection for the JetTag D3PD" if len(selectedJetCollections) != 0: ### add muon in jets object if JetTagD3PDFlags.AddMuonInJetsObject(): from JetTagD3PDMaker.JetTagMuonInJetD3PDObject import getJetTagMuonInJetObject alg += getJetTagMuonInJetObject( **_args("muon1injet", kw, level=10, jetCollections=selectedJetCollections)) if JetTagD3PDFlags.AddSecondMuonCollection(): alg += getJetTagMuonInJetObject( **_args("muon2injet", kw, level=10, jetCollections=selectedJetCollections, prefix=JetTagD3PDKeys.Muon2InJetPrefix(), object_name='JetTagMuon2InJetD3PDObject', label=JetTagD3PDKeys.Muon2InJetGetterLabel(), muonsName="SecondMuons")) ### add electron in jets object if JetTagD3PDFlags.AddElectronInJetsObject(): from JetTagD3PDMaker.JetTagElectronInJetD3PDObject import getJetTagElectronInJetD3PDObject alg += getJetTagElectronInJetD3PDObject( **_args("electroninjet", kw, level=10, jetCollections=selectedJetCollections)) ### add photon in jets object if JetTagD3PDFlags.AddPhotonInJetsObject(): from JetTagD3PDMaker.JetTagPhotonInJetD3PDObject import getJetTagPhotonInJetD3PDObject alg += getJetTagPhotonInJetD3PDObject( **_args("photoninjet", kw, level=10, jetCollections=selectedJetCollections)) ### add VxOnJetAxis object if JetTagD3PDFlags.AddVxOnJetAxisInJetsObject(): from JetTagD3PDMaker.JetTagVxOnJetAxisD3PDObject import getJetTagVxOnJetAxisD3PDObject alg += getJetTagVxOnJetAxisD3PDObject( **_args("vxonjetaxis", kw, level=0, jetCollections=selectedJetCollections)) ### add TwoTrackVertex object if JetTagD3PDFlags.AddTwoTrackVertexInJetsObject(): from JetTagD3PDMaker.JetTagTwoTrackVertexD3PDObject import getJetTagTwoTrackVertexD3PDObject alg += getJetTagTwoTrackVertexD3PDObject( **_args("twotrackvertex", kw, level=0, jetCollections=selectedJetCollections)) ### add MSVVtxInfo object if JetTagD3PDFlags.AddMSVVtxInfoInJetsObject(): from JetTagD3PDMaker.JetTagMSVVtxInJetD3PDObject import getJetTagMSVVtxInfoInJetD3PDObject alg += getJetTagMSVVtxInfoInJetD3PDObject( **_args("msvvtxinfo", kw, level=1, jetCollections=selectedJetCollections)) ### add event info object if JetTagD3PDFlags.AddEventInfoObject(): from JetTagD3PDMaker.JetTagEventInfoD3PDObject import getJetTagEventInfoD3PDObject alg += getJetTagEventInfoD3PDObject(**_args("eventinfo", kw, level=1)) ### add pileup event info object if rec.doTruth and JetTagD3PDFlags.AddPileUpEventInfoObject(): from TruthD3PDMaker.PileUpInfoD3PDObject import PileUpInfoD3PDObject alg += PileUpInfoD3PDObject(0, "pileupinfo", "pileupinfo_", allowMissing=True) ### add track object if JetTagD3PDFlags.AddTrackObject(): from JetTagD3PDMaker.JetTagTrackD3PDObject import getJetTagTrackD3PDObject alg += getJetTagTrackD3PDObject(**_args("track", kw)) ### add MET objects for MET in JetTagD3PDFlags.METObjects(): from JetTagD3PDMaker.JetTagMETD3PDObject import getJetTagMETD3PDObject alg += getJetTagMETD3PDObject(**_args(MET, kw, sgkey=MET)) ### add event shape objects from QcdD3PDMaker.QcdEventShapeD3PDObject import EventShapeD3PDObject alg += EventShapeD3PDObject(level=0) ### add pixel clusters object if JetTagD3PDFlags.AddPixelClusterObject(): from JetTagD3PDMaker.JetTagClustersD3PDObject import getJetTagClusterD3PDObject alg += getJetTagClusterD3PDObject(**_args("pixelcluster", kw, level=0)) ### add primary vertex object if JetTagD3PDFlags.AddPrimaryVertexObject(): from JetTagD3PDMaker.JetTagPrimaryVertexD3PDObject import getJetTagPrimaryVertexD3PDObject alg += getJetTagPrimaryVertexD3PDObject(**_args("pv", kw)) ### add beam spot object if JetTagD3PDFlags.AddBeamSpotObject(): from TrackD3PDMaker.BeamSpotD3PDObject import BeamSpotD3PDObject alg += BeamSpotD3PDObject(10) ### add muid object if JetTagD3PDFlags.AddMuonMuidObject(): from MuonD3PDMaker.MuonD3PDObject import MuonD3PDObject _modifyMuonObject(MuonD3PDObject) alg += MuonD3PDObject(**_args( 'MuonMuid', kw, level=10, sgkey='MuidMuonCollection', prefix='mu_muid_', allowMissing=True, exclude=["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"], include=[ "BtagMuonTrackMatchingBlock", "EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex", "L2CBInfoIndex", "L1InfoIndex" ])) if JetTagD3PDFlags.AddMuonStacoObject(): from MuonD3PDMaker.MuonD3PDObject import MuonD3PDObject _modifyMuonObject(MuonD3PDObject) alg += MuonD3PDObject(**_args( 'MuonStaco', kw, level=10, sgkey='StacoMuonCollection', prefix='mu_staco_', allowMissing=True, exclude=["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"], include=[ "BtagMuonTrackMatchingBlock", "EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex", "L2CBInfoIndex", "L1InfoIndex" ])) ### add truth info with a filter if rec.doTruth and JetTagD3PDFlags.AddGenObjects(): from AthenaCommon.AppMgr import ToolSvc from TruthD3PDAnalysis.TruthD3PDAnalysisConf import D3PD__GenObjectsFilterTool jetTagGenObjectsFilterTool = D3PD__GenObjectsFilterTool( "JetTagGenObjectsFilterTool") ToolSvc += jetTagGenObjectsFilterTool jetTagGenObjectsFilterTool.SelectTruthTracks = False jetTagGenObjectsFilterTool.PtMin = JetTagD3PDFlags.MCPtMinCut() jetTagGenObjectsFilterTool.EtaMax = JetTagD3PDFlags.MCEtaCut() jetTagGenObjectsFilterTool.RemoveEmptyEvents = not JetTagD3PDFlags.MCEmptyEvents( ) jetTagGenObjectsFilterTool.RemoveDummyEvents = not JetTagD3PDFlags.MCDummyEvents( ) if not JetTagD3PDFlags.MCPileUp(): jetTagGenObjectsFilterTool.RemoveInTimePileUp = True jetTagGenObjectsFilterTool.Remove2BCPileUp = True jetTagGenObjectsFilterTool.Remove800nsPileUp = True jetTagGenObjectsFilterTool.RemoveCavernBkg = True jetTagGenObjectsFilterTool.RemoveEmptyEvents = True jetTagGenObjectsFilterTool.RemoveDummyEvents = True if JetTagD3PDFlags.AddGenEventObjects(): from TruthD3PDMaker.GenEventD3PDObject import GenEventD3PDObject alg += GenEventD3PDObject(**_args("genevent", kw, level=10, filter = jetTagGenObjectsFilterTool, pileup_CollectionGetterRegistry=\ alg.name()+'_CollectionGetterRegistry' ) ) if JetTagD3PDFlags.AddGenVertexObjects(): from TruthD3PDMaker.GenVertexD3PDObject import GenVertexD3PDObject alg += GenVertexD3PDObject(**_args( "genvertex", kw, level=10, filter=jetTagGenObjectsFilterTool)) if JetTagD3PDFlags.AddGenParticleObjects(): from TruthD3PDMaker.GenParticleD3PDObject import GenParticleD3PDObject alg += GenParticleD3PDObject(**_args( "genparticle", kw, level=10, filter=jetTagGenObjectsFilterTool)) if JetTagD3PDFlags.AddTruthTrackObjects(): jetTagTruthTrackObjectsFilterTool = D3PD__GenObjectsFilterTool( "JetTagTruthTrackObjectsFilterTool") ToolSvc += jetTagTruthTrackObjectsFilterTool jetTagTruthTrackObjectsFilterTool.SelectTruthTracks = True jetTagTruthTrackObjectsFilterTool.PtMin = JetTagD3PDFlags.MCPtMinCut( ) jetTagTruthTrackObjectsFilterTool.EtaMax = JetTagD3PDFlags.MCEtaCut( ) jetTagTruthTrackObjectsFilterTool.RemoveEmptyEvents = not JetTagD3PDFlags.MCEmptyEvents( ) jetTagTruthTrackObjectsFilterTool.RemoveDummyEvents = not JetTagD3PDFlags.MCDummyEvents( ) if not JetTagD3PDFlags.MCPileUp(): jetTagTruthTrackObjectsFilterTool.RemoveInTimePileUp = True jetTagTruthTrackObjectsFilterTool.Remove2BCPileUp = True jetTagTruthTrackObjectsFilterTool.Remove800nsPileUp = True jetTagTruthTrackObjectsFilterTool.RemoveCavernBkg = True jetTagTruthTrackObjectsFilterTool.RemoveEmptyEvents = True jetTagTruthTrackObjectsFilterTool.RemoveDummyEvents = True from TruthD3PDMaker.GenParticleD3PDObject import GenTruthTrackD3PDObject alg += GenTruthTrackD3PDObject( **_args("truthtrack", kw, level=10, filter=jetTagTruthTrackObjectsFilterTool)) ### add trigger if JetTagD3PDFlags.AddTriggerObject(): from TriggerD3PDMaker.TrigDecisionD3PDObject import TrigDecisionD3PDObject alg += TrigDecisionD3PDObject(**_args("trigdecision", kw, level=2)) from TriggerD3PDMaker.TrigConfMetadata import addTrigConfMetadata addTrigConfMetadata(alg) if JetTagD3PDFlags.AddTriggerBits(): from JetTagD3PDMaker.JetTagTriggerBitsD3PDObject import getJetTagTriggerBitsD3PDObject alg += getJetTagTriggerBitsD3PDObject( JetTagD3PDFlags.TriggerBitsList()) if JetTagD3PDFlags.AddJetTriggerObject(): from TrigJetD3PDMaker.TrigJetD3PD import TrigJetD3PDObjects TrigJetD3PDObjects(alg, level=10, addNaviInfo=True, addConfigInfo=False) if JetTagD3PDFlags.AddBJetTriggerObject(): from TrigBJetD3PDMaker.TrigBJetD3PD import TrigBJetD3PDObjects bjettriglevel = 1 if JetTagD3PDFlags.AddTrigL2IDTracks( ) or JetTagD3PDFlags.AddTrigEFIDTracks(): bjettriglevel = 11 TrigBJetD3PDObjects(alg, level=bjettriglevel, doAddL2ID=JetTagD3PDFlags.AddTrigL2IDTracks(), doAddEFID=JetTagD3PDFlags.AddTrigEFIDTracks()) if JetTagD3PDFlags.AddPixCond(): if hasattr(ServiceMgr, "PixelConditionsSummarySvc"): from JetTagD3PDMaker.JetTagPixModCondD3PDObject import getJetTagPixModCondD3PDObject alg += getJetTagPixModCondD3PDObject( PixSummarySvc=ServiceMgr.PixelConditionsSummarySvc) else: print "Warning: JetTagPixModCondD3PDObject requested but PixelConditionsSummarySvc not configured" #### add fat jets and subjets if JetTagD3PDFlags.AddFatJets(): from JetTagD3PDMaker.JetTagJSD3PDObjects import JSD3PD_Tool for xx in JetTagD3PDKeys.FatJetsList(): if xx[0] != None and xx[1] != None: jsD3PD = JSD3PD_Tool(xx) jsD3PD.addToAlg(alg) ### add skiming if JetTagD3PDFlags.SkimD3PD(): __muonAssocObjects = ["Muons"] if JetTagD3PDFlags.AddSecondMuonCollection(): __muonAssocObjects = ["Muons", "Muons2"] from JetTagD3PDMaker.JetTagD3PDMakerConf import D3PD__JetTagD3PDEventFilter JetTagD3PDEventFilter = D3PD__JetTagD3PDEventFilter( "JetTagD3PDEventFilter", UseMuonFilter=JetTagD3PDFlags.UseMuonEventFilter(), UseJetFilter=JetTagD3PDFlags.UseJetEventFilter(), JetCollections=selectedJetCollections, JetPtCut=JetTagD3PDFlags.FilterJetPtCut(), JetEtaCut=JetTagD3PDFlags.FilterJetEtaCut(), JetWithMuonPtCut=JetTagD3PDFlags.FilterJetWithMuonPtCut(), SoftMuonPtCut=JetTagD3PDFlags.FilterMuonInJetPtCut(), MinNumberOfJets=JetTagD3PDFlags.FilterMinNJets(), MinNumberOfJetsWithMuon=JetTagD3PDFlags.FilterMinNJetsMuon(), MuonAssocObjects=__muonAssocObjects, MuonCollections=JetTagD3PDFlags.FilterMuonCollections(), MuonPtCut=JetTagD3PDFlags.FilterMuonPtCut(), MuonEtaCut=JetTagD3PDFlags.FilterMuonEtaCut(), MuonIsTightCut=JetTagD3PDFlags.FilterMuonTightCut(), MinNumberOfMuons=JetTagD3PDFlags.FilterMinNumberOfMuons()) alg.filterSeq += JetTagD3PDEventFilter from EventCommonD3PDMaker.LBMetadataConfig import LBMetadataConfig alg.MetadataTools += [LBMetadataConfig()] return alg
#if DetFlags.writeRDOPool.Tile_on(): # streamRDO.ItemList+=['TileDigitsContainer#TileDigitsCnt'] svcMgr.MessageSvc.OutputLevel = OutputLevel svcMgr.AthenaPoolCnvSvc.MaxFileSizes = ['16000000000'] #-------------------------------------------------------------- # Creating ntuples #-------------------------------------------------------------- theApp.HistogramPersistency = 'ROOT' if doD3PD: from OutputStreamAthenaPool.MultipleStreamManager import MSMgr alg = MSMgr.NewRootStream('D3PD', D3PDOutput, 'truth') if 'TruthSGKey' in dir(): from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags D3PDMakerFlags.TruthSGKey = TruthSGKey from TruthD3PDMaker.TruthD3PDMakerKeys import TruthD3PDKeys from TruthD3PDMaker.TruthD3PDMakerFlags import TruthD3PDFlags from TruthD3PDAnalysis.GenObjectsFilterTool import * from TruthD3PDMaker.GenVertexD3PDObject import GenVertexD3PDObject alg += GenVertexD3PDObject(10, filter=AllTrackFilterTool()) from TruthD3PDMaker.GenParticleD3PDObject import GenParticleD3PDObject alg += GenParticleD3PDObject(10, filter=AllTrackFilterTool())
def VertexGroupD3PD(alg=None, file=VertexD3PDAnalysisKeys.D3PDFileName(), treeName=VertexD3PDAnalysisKeys.D3PDTreeName(), **kw): print '[TrackD3PDMaker.VertexGroupD3PD] Vertex group D3PD settings:' print 'VertexD3PDAnalysisFlags' print VertexD3PDAnalysisFlags print 'VertexD3PDAnalysisKeys' print VertexD3PDAnalysisKeys if not alg: ## Create a new algorithm from OutputStreamAthenaPool.MultipleStreamManager import MSMgr alg = MSMgr.NewRootStream(treeName, file) ## General event information (custom options prefix: 'ei_') if VertexD3PDAnalysisFlags.useEventInfo(): from EventCommonD3PDMaker.EventInfoD3PDObject import EventInfoD3PDObject alg += EventInfoD3PDObject(**_args('ei_', kw, level=0, prefix='ei_')) ## Trigger information (custom options prefix: 'trig_') if VertexD3PDAnalysisFlags.useTrigger(): from TriggerJobOpts.TriggerConfigGetter import TriggerConfigGetter cfg = TriggerConfigGetter("ReadPool") from TriggerD3PDMaker.defineTriggerBits import defineTriggerBits from TriggerD3PDMaker.TrigConfMetadata import addTrigConfMetadata from TriggerD3PDMaker.TrigDecisionD3PDObject import TrigDecisionD3PDObject alg += TrigDecisionD3PDObject(**_args('trig_', kw, level=2)) addTrigConfMetadata(alg) if VertexD3PDAnalysisFlags.useTriggerRaw(): from TriggerJobOpts.TriggerConfigGetter import TriggerConfigGetter cfg = TriggerConfigGetter("ReadPool") from TriggerD3PDMaker.defineTriggerBits import defineTriggerBits from TriggerD3PDMaker.TrigConfMetadata import addTrigConfMetadata #Setup custom D3PD object with raw trigger info only (e.g. calibration_vdM streams) from D3PDMakerCoreComps.D3PDObject import make_Void_D3PDObject import TriggerD3PDMaker TrigDecisionD3PDObjectRaw = make_Void_D3PDObject( "trigRaw_", "TrigDecisionD3PDObjectRaw", default_name="TrigDecisionFillerRaw") if not VertexD3PDAnalysisFlags.useTrigger(): TrigDecisionD3PDObjectRaw.defineBlock( 0, "TriggerRawInfo", TriggerD3PDMaker.TrigDecisionFillerTool, SaveLVL1Raw=True, SaveHLTRaw=True, SaveBGCode=True) else: TrigDecisionD3PDObjectRaw.defineBlock( 0, "TriggerRawInfo", TriggerD3PDMaker.TrigDecisionFillerTool, SaveHLTRaw=True, SaveBGCode=True) #Finally add object to algorithms alg += TrigDecisionD3PDObjectRaw(**_args('trig_', kw, level=0)) if not VertexD3PDAnalysisFlags.useTrigger(): #unless we've already added it, add meta-data as well addTrigConfMetadata(alg) ## Beam background information (custom options prefix: 'bkg_') if VertexD3PDAnalysisFlags.useBackgroundWord(): from BackgroundD3PDMaker.BackgroundWordD3PDObject import BackgroundWordD3PDObject alg += BackgroundWordD3PDObject(**_args('bkg_', kw, level=0)) ## Tracks and V0 information (custom options prefix: 'trk_', and 'v0_') if VertexD3PDAnalysisFlags.useTracks(): labelDefaultVtx = VertexD3PDAnalysisKeys.LabelDefaultVtx() prefixDefaultVtx = labelDefaultVtx + '_' #Add trailing '_' import TrackD3PDMaker from TrackD3PDMaker.TrackD3PDMakerFlags import TrackD3PDFlags from TrackD3PDMaker.TrackD3PDObject import TrackD3PDObject from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags from TruthD3PDMaker.TruthD3PDMakerFlags import TruthD3PDFlags from TruthD3PDMaker.TruthD3PDMakerKeys import TruthD3PDKeys VtxD3PD_Track_Exclude = ['vx_weight'] TrackD3PDMaker.PerigeeUnbiasedIPAtPVFillerTool.DoBiased = False #Switch off biased perigee TrackParticleD3PDObjectForVertex = TrackD3PDObject( _label='trk', _prefix='trk_', _sgkey=D3PDMakerFlags.TrackSGKey(), _object_name='TrackParticleD3PDObjectForVertex', typeName='Rec::TrackParticleContainer', vertexTarget=labelDefaultVtx, vertexPrefix=prefixDefaultVtx, vertexSGKey='VxPrimaryCandidate', truthTarget=TruthD3PDFlags.GenParticleAssocLabel(), truthPrefix=TruthD3PDKeys.GenParticlePrefix(), detailedTruthPrefix='', # 'mc_detailed_' SGKeyForTruth=D3PDMakerFlags.TrackSGKey(), truthMapKey='TrackParticleTruthCollection', detailedTruthMapKey='', #'DetailedTrackTruth' flags=TrackD3PDFlags) alg += TrackParticleD3PDObjectForVertex( **_args('trk_', kw, level=8, exclude=VtxD3PD_Track_Exclude)) if VertexD3PDAnalysisFlags.useSecondaryVertex(): from TrackD3PDMaker.V0D3PDObject import V0D3PDObject alg += V0D3PDObject(**_args('v0_', kw, level=10)) ## Store beamspot information (custom option perfix: 'bs_') if VertexD3PDAnalysisFlags.useBeamspot(): from TrackD3PDMaker.BeamSpotD3PDObject import BeamSpotD3PDObject alg += BeamSpotD3PDObject(**_args('bs_', kw, level=0)) ## Store vertex information (custom options prefix: 'vtx_' or 'vtx' for BuildVertexD3PDObject) from TrackD3PDMaker.VertexD3PDObject import PrimaryVertexD3PDObject from TrackD3PDMaker.VertexD3PDObject import BuildVertexD3PDObject from InDetRecExample.InDetKeys import InDetKeys from InDetRecExample.InDetJobProperties import InDetFlags #First dump existing content labelDefaultVtx = VertexD3PDAnalysisKeys.LabelDefaultVtx() prefixDefaultVtx = labelDefaultVtx + '_' #Add trailing '_' VtxDefaultD3PDObj = BuildVertexD3PDObject( **_args('vtx', kw, _prefix=prefixDefaultVtx, _label=labelDefaultVtx, _sgkey=InDetKeys.PrimaryVertices(), trackTarget='trk', trackPrefix='trk_', trackType='Rec::TrackParticleContainer')) alg += VtxDefaultD3PDObj(**_args('vtx_', kw, level=10)) #Then also dump the other vertex collections if VertexD3PDAnalysisFlags.useAllVertexCollections: #Use non BC and split collections (sorry, no customization of parameters here) if not InDetFlags.doSplitVertexFindingForMonitoring(): #raise NameError('Requesting split vertices but algorith has not run!') #pass print( '[TrackD3PDMaker.VertexGroupD3PD] WARNING: Requested split vertices, but algorithm has not run! Skipped.' ) else: SplitPrimaryVertexD3PDObject = BuildVertexD3PDObject( _prefix='vxsplit_', _label='vxsplit', _sgkey=InDetKeys.PrimaryVerticesSplitStream(), trackTarget='trk', trackPrefix='trk_', trackType='Rec::TrackParticleContainer') alg += SplitPrimaryVertexD3PDObject(8) #Then store also non beamspot constrained ones if not InDetFlags.doVertexFindingForMonitoring(): #raise NameError('Requesting NBC vertices but algorith has not run!') #pass print( '[TrackD3PDMaker.VertexGroupD3PD] WARNING: Requested non beamspot constrained vertices, but algorithm has not run! Skipped.' ) else: NoBeamConstraintPrimaryVertexD3PDObject = BuildVertexD3PDObject( _prefix='vxnbc_', _label='vxnbc', _sgkey=InDetKeys.PrimaryVerticesWithoutBeamConstraint(), trackTarget='trk', trackPrefix='trk_', trackType='Rec::TrackParticleContainer') alg += NoBeamConstraintPrimaryVertexD3PDObject(8) ## Store truth-level information (custom options prefix: 'tuthVtx_', 'truthEvt_', 'truthPart_') if VertexD3PDAnalysisFlags.useTruth(): from TruthD3PDAnalysis.TruthD3PDAnalysisConf import D3PD__GenObjectsFilterTool trackGenObjectsFilterTool = D3PD__GenObjectsFilterTool( "trackGenObjectsFilterTool") from AthenaCommon.AppMgr import ToolSvc ToolSvc += trackGenObjectsFilterTool if (VertexD3PDAnalysisFlags.filterTightTruth()): trackGenObjectsFilterTool.SelectTruthTracks = True trackGenObjectsFilterTool.PtMin = VertexD3PDAnalysisKeys.TruthTrackCutPtMin( ) trackGenObjectsFilterTool.EtaMax = VertexD3PDAnalysisKeys.TruthTrackCutEtaMax( ) trackGenObjectsFilterTool.RemoveEmptyEvents = True trackGenObjectsFilterTool.RemoveDummyEvents = True trackGenObjectsFilterTool.RemoveInTimePileUp = False trackGenObjectsFilterTool.Remove2BCPileUp = True trackGenObjectsFilterTool.Remove800nsPileUp = True trackGenObjectsFilterTool.RemoveCavernBkg = False trackGenObjectsFilterTool.AddOnlyFirstVertex = VertexD3PDAnalysisKeys.TruthAddOnlyFirstVertex( ) else: #Use a more inclusive truth policy trackGenObjectsFilterTool.SelectTruthTracks = False trackGenObjectsFilterTool.PtMin = VertexD3PDAnalysisKeys.TruthTrackCutPtMin( ) trackGenObjectsFilterTool.EtaMax = VertexD3PDAnalysisKeys.TruthTrackCutEtaMax( ) trackGenObjectsFilterTool.RemoveEmptyEvents = True trackGenObjectsFilterTool.RemoveDummyEvents = True trackGenObjectsFilterTool.AddOnlyFirstVertex = VertexD3PDAnalysisKeys.TruthAddOnlyFirstVertex( ) from TruthD3PDMaker.GenEventD3PDObject import GenEventD3PDObject alg += GenEventD3PDObject( **_args('truthEvt_', kw, level=10, filter=trackGenObjectsFilterTool, pileup_CollectionGetterRegistry=alg.name() + '_CollectionGetterRegistry')) from TruthD3PDMaker.GenVertexD3PDObject import GenVertexD3PDObject alg += GenVertexD3PDObject(**_args( 'truthVtx_', kw, level=1, filter=trackGenObjectsFilterTool)) from TruthD3PDMaker.GenParticleD3PDObject import GenParticleD3PDObject alg += GenParticleD3PDObject(**_args( 'truthPart_', kw, level=10, filter=trackGenObjectsFilterTool)) from TruthD3PDMaker.GenParticleD3PDObject import GenTruthTrackD3PDObject alg += GenTruthTrackD3PDObject(**_args('truthTrack_', kw, level=0)) ## Dump higher level objects # Missing Energy (custom options prefix with VertexD3PDAnalysisKeys.MetCollections+'_') if VertexD3PDAnalysisFlags.useMET(): for MET in VertexD3PDAnalysisKeys.MetCollections(): VtxD3PD_Met_Key = MET VtxD3PD_Met_Prefix = MET.replace('_', '') + '_' VtxD3PD_Met_Level = 0 #Only basic info VtxD3PD_Met_Exclude = ['MET_Regions', 'L1_', 'L2_', 'EF_'] from MissingETD3PDMaker.MissingETD3PDObject import RefFinalMETD3PDObject VtxD3PD_Met_Obj = RefFinalMETD3PDObject( **_args(MET + '_', kw, level=VtxD3PD_Met_Level, sgkey=VtxD3PD_Met_Key, prefix=VtxD3PD_Met_Prefix, exclude=VtxD3PD_Met_Exclude)) alg += VtxD3PD_Met_Obj #Muons (custom options prefix VtxD3PD_Muon_Prefix -- see below [e.g. muid_, staco_, ...]) if VertexD3PDAnalysisFlags.useMuons(): from MuonD3PDMaker.MuonD3PDObject import MuonD3PDObject for Muon in VertexD3PDAnalysisKeys.MuonCollections(): VtxD3PD_Muon_Key = Muon VtxD3PD_Muon_Prefix = Muon + '_' if VtxD3PD_Muon_Key == 'MuidMuonCollection': VtxD3PD_Muon_Prefix = 'muid_' elif VtxD3PD_Muon_Key == 'StacoMuonCollection': VtxD3PD_Muon_Prefix = 'staco_' VtxD3PD_Muon_Level = 0 #Only basic info VtxD3PD_Muon_Exclude = [ 'EFCBInfo', 'EFMGInfo', 'EFMEInfo', 'L2CBInfo', 'L1Info', 'L1_', 'L2_', 'EF_' ] VtxD3PD_Muon_Obj = MuonD3PDObject( **_args(VtxD3PD_Muon_Prefix, kw, level=VtxD3PD_Muon_Level, sgkey=VtxD3PD_Muon_Key, prefix=VtxD3PD_Muon_Prefix, allowMissing=True, exclude=VtxD3PD_Muon_Exclude)) alg += VtxD3PD_Muon_Obj #Electrons (custom options prefix: 'el_') if VertexD3PDAnalysisFlags.useElectrons(): from egammaD3PDMaker.ElectronD3PDObject import ElectronD3PDObject alg += ElectronD3PDObject(**_args('el_', kw, prefix='el_', level=0)) #Photons (custom options prefix: 'ph_') if VertexD3PDAnalysisFlags.usePhotons(): from egammaD3PDMaker.PhotonD3PDObject import PhotonD3PDObject alg += PhotonD3PDObject(**_args('ph_', kw, prefix='ph_', level=0)) #Jets, JVF, b-jets (custom options prefix: 'jet_') if VertexD3PDAnalysisFlags.useJets(): from JetD3PDMaker.JetD3PDObject import JetD3PDObject from JetTagD3PDMaker.JetTagD3PDMakerKeys import JetTagD3PDKeys from JetTagD3PDMaker.AddBTagD3PDInfo import addBTagInfoToJetObject addBTagInfoToJetObject(JetD3PDObject, btagLevelOffset=0) VtxD3PD_Jet_Include = [ 'Kinematics', 'JetVertexFraction', 'JVtx', 'EMFraction', 'TrueFlavorComponents', JetTagD3PDKeys.BTagWeightsBlockName() ] for JET in VertexD3PDAnalysisKeys.JetCollections(): VtxD3PD_Jet_Prefix = JET.replace('_', '') + '_' if len(VertexD3PDAnalysisKeys.JetCollections()) == 1: #only 1 element, simplify prefix VtxD3PD_Jet_Prefix = 'jet_' alg += JetD3PDObject(**_args('jet_', kw, sgkey=JET, prefix=VtxD3PD_Jet_Prefix, level=0, include=VtxD3PD_Jet_Include)) #Taus if VertexD3PDAnalysisFlags.useTaus(): from TauD3PDMaker.TauD3PDObject import TauD3PDObject VtxD3PD_Tau_Include = ['TauPriVtx'] alg += TauD3PDObject(**_args( 'tau_', kw, prefix='tau_', level=0, include=VtxD3PD_Tau_Include)) ## Return algorithm return alg
from D3PDMakerCoreComps.D3PDObject import make_Void_D3PDObject from TileD3PDMaker import TileAssocFillerTool def MuonCellFiller(name): return TileAssocFillerTool(name, ContainerName = 'muonCells', BranchName = '_index') MuonCellD3PDObject = make_Void_D3PDObject( 'muons_muonCells', 'MuonCellD3PDObject' ) MuonCellD3PDObject.defineBlock(0, 'MuonCellDump', MuonCellFiller) # Finally create an output stream and specify what is dumped from OutputStreamAthenaPool.MultipleStreamManager import MSMgr alg = MSMgr.NewRootStream( 'tileD3PD', outputFile ) alg += TileEventD3PDObject(10) alg += TileTrackD3PDObject(10) alg += TileCellD3PDObject(10) alg += MuonCellD3PDObject(10) alg += TileMuonD3PDObject(10) print "==============> D3PD ATTRIBUTES SET <==============" ################### ###OTHER STUFF ### ################### ## TRIGGER #from MuonD3PDMaker.MuonTriggerBitsD3PDObject import MuonTriggerBitsD3PDObject
D3PDMakerFlags.DoPAU = False D3PDMakerFlags.DoTrigger = True #FPP: patch to run D3PD with the merged L2EF (must add new flags in D3PDMakerConfig/python/D3PDMakerFlags.py) D3PDMakerFlags.ElectronEFTrigPattern = "EF_[0-9]?e[0-9]+.*|HLT_[0-9]?e[0-9]+.*" D3PDMakerFlags.ElectronL2TrigPattern = "L2_[0-9]?e[0-9]+.*" D3PDMakerFlags.PhotonEFTrigPattern = "EF_[0-9]?g[0-9]+.*|HLT_[0-9]?e[0-9]+.*" D3PDMakerFlags.PhotonL2TrigPattern = "L2_[0-9]?g[0-9]+.*" D3PDMakerFlags.egammaL1TrigPattern = "" D3PDMakerFlags.MuonEFTrigPattern = 'EF_2?mu.*|EF_L1ItemStreamer_L1_2?MU.*|HLT_2?mu.*|HLT_L1ItemStreamer_L1_2?MU.*' from PhotonAnalysisUtils.PhotonAnalysisUtilsFlags import PAUflags PAUflags.DoReRunJetFinding = False # Create the D3PD stream(s): from OutputStreamAthenaPool.MultipleStreamManager import MSMgr d3pdalg = MSMgr.NewRootStream(streamName, fileName, "trigger") #trigalg = MSMgr.NewRootStream( streamName + ":" + streamName + "TrigDec", # fileName, "triggerDec" ) #d3pdalg.Stream.trigDecisionTree = trigalg ## ## Basic event information: ## from EventCommonD3PDMaker.EventInfoD3PDObject import EventInfoD3PDObject d3pdalg += EventInfoD3PDObject(2) #trigalg += EventInfoD3PDObject( 0, exclude = [ "eventMu", "eventType" ] ) if triggerAvailable: from TriggerD3PDMaker.BGCodeD3PDObject import BGCodeD3PDObject d3pdalg += BGCodeD3PDObject(0) pass
from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() ################################################################################################### #D3PD maker setup ################################################################################################### ## D3PD Maker import D3PDMakerCoreComps import EventCommonD3PDMaker from D3PDMakerCoreComps.D3PDObject import D3PDObject from EventCommonD3PDMaker.EventInfoD3PDObject import EventInfoD3PDObject from OutputStreamAthenaPool.MultipleStreamManager import MSMgr from ForwardDetectorsD3PDMaker.AlfaD3PDObject import AlfaD3PDObject alg = MSMgr.NewRootStream( "AlfaD3PD", OutputRootFile , "AlfaD3PDTree" ) alg += EventInfoD3PDObject(10) alg += AlfaD3PDObject(0) from ForwardDetectorsD3PDMaker import AlfaEventHeaderFillerTool if globalflags.DataSource == "data": from ForwardDetectorsD3PDMaker.AlfaDCSMetadata import addAlfaDcsMetadata AlfaEventHeaderFillerTool.DataType = 1 addAlfaDcsMetadata(alg) elif globalflags.DataSource == "geant4": from ForwardDetectorsD3PDMaker.AlfaTruthInfoD3PDObject import AlfaTruthInfoD3PDObject AlfaEventHeaderFillerTool.DataType = 0 alg += AlfaTruthInfoD3PDObject(0) #--------------------------------------------------------------
def HSG5D3PD (alg = None, file = 'hsg5.root', tuplename = 'physics', streamname = 'd3pdstream', flags=HSG5Flags, **kw): if flags.doTaus(): # tau from TauD3PDMaker.TauD3PDObject import TauD3PDObject # define associations if flags.doPhotons() and not PhotonD3PDObject.allBlocknames().has_key('RecoveryMatch'): from PhotonD3PDMaker.PhotonRecoveryAssociation import PhotonRecoveryAssociation PhotonRecoveryAssoc = PhotonRecoveryAssociation(PhotonD3PDObject, 'ElectronContainer', D3PDMakerFlags.ElectronSGKey(), prefix = 'el_', blockname = 'RecoveryMatch', target = 'ph_ElectronRecovered_') # define track and cluster filters preseq = AlgSequence (D3PDMakerFlags.PreD3PDAlgSeqName()) if flags.doGoodTracks() and not hasattr( preseq, "GoodTracks" ): filter1 = makeTrackFilterAlg(TracksName = D3PDMakerFlags.TrackSGKey(), OutputTracksName='GoodTracks', ptCut=0.,nSCTPix=4) preseq += filter1 if flags.doHighPtTracks() and not hasattr( preseq, "HighPtTracks" ): filter2 = makeTrackFilterAlg(TracksName = D3PDMakerFlags.TrackSGKey(), OutputTracksName='HighPtTracks', ptCut=5000.,nSCTPix=4) preseq += filter2 if flags.doHighPtClusters() and not hasattr( preseq, "HighPtClusters" ): filter3 = makeClusterFilter(InputName = D3PDMakerFlags.ClusterSGKey(), OutputName = 'HighPtClusters', ptCut=10000.) preseq += filter3 if flags.doHighPtEMClusters() and not hasattr( preseq, "HighPtEMClusters" ): filter4 = makeClusterFilter(InputName = D3PDMakerFlags.EMTopoClusterSGKey(), OutputName = 'HighPtEMClusters', ptCut=10000.) preseq += filter4 # perform recoil calculation if flags.doHadronicRecoil(): from HadronicRecoil.HadronicRecoilConf import HadronicRecoil__ElectronSelector from HadronicRecoil.HadronicRecoilConf import HadronicRecoil__MuonSelector from HadronicRecoil.HadronicRecoilConf import HadronicRecoil__EflowSelector from HadronicRecoil.HadronicRecoilConf import HadronicRecoil__RecoilCalculation from HadronicRecoil.HadronicRecoilConf import HadronicRecoil__EflowRecoil if not hasattr( preseq, "HadronicRecoil::ElectronSelector" ): preseq += HadronicRecoil__ElectronSelector() if not hasattr( preseq, "HadronicRecoil::MuonSelector" ): preseq += HadronicRecoil__MuonSelector() if not hasattr( preseq, "HadronicRecoil::EflowSelector" ): preseq += HadronicRecoil__EflowSelector() if not hasattr( preseq, "HadronicRecoil::RecoilCalculation" ): preseq += HadronicRecoil__RecoilCalculation( ConeSizes = [0.20] ) if not hasattr( preseq, "EflowRecoil_20" ): preseq += HadronicRecoil__EflowRecoil("EflowRecoil_20", TrackRough = "RoughRecoil_track_20", TrackUE = "ueCorrection_track_20", TrackRef = "RefinedRecoil_track_20", ClusNoTrackRough = "RoughRecoil_clusNoTrack_20", ClusNoTrackUE = "ueCorrection_clusNoTrack_20", ClusNoTrackRef = "RefinedRecoil_clusNoTrack_20", RoughRecoil_out = "RoughRecoil_Eflow_20", ueCorrection_out = "ueCorrection_Eflow_20", RefinedRecoil_out= "RefinedRecoil_Eflow_20", MET_out = "MET_HR_Eflow_20" ) # now configure the D3PD if not alg: alg = MSMgr.NewRootStream(StreamName = streamname, FileName = file, TreeName = tuplename) alg += EventInfoD3PDObject (**_args (10, 'EventInfo', kw)) alg += LArCollisionTimeD3PDObject (**_args (10, 'LArCollisionTime', kw)) from TriggerD3PDMaker.BunchStructureMetadata import addBunchStructureMetadata addBunchStructureMetadata (alg) # Eta rings of energy # FIXME brian crashing aod running if not rec.readAOD: from CaloD3PDMaker.RapgapD3PDObject import EtaRingsNonTileD3PDObject from CaloD3PDMaker.RapgapD3PDObject import EtaRingsD3PDObject alg += EtaRingsNonTileD3PDObject ( **_args ( 0, 'EtaRings', kw) ) alg += EtaRingsD3PDObject ( **_args ( 0, 'EtaRings', kw) ) # Electron/Photon blocks alg += ElectronD3PDObject (**_args (10, 'Electron', kw)) if testSGKey ('ElectronContainer', D3PDMakerFlags.GSFElectronSGKey()): alg += GSFElectronD3PDObject (**_args (10, 'GSFElectron', kw, sgkey = D3PDMakerFlags.GSFElectronSGKey(), prefix = 'el_gsf_')) if flags.doPhotons(): print "adding photons" alg += PhotonD3PDObject (**_args (10, 'Photon', kw)) # Muon blocks ### add the scattering significance filler - to be removed when added in the MuonD3PDMaker if not MuonD3PDObject.allBlocknames().has_key("MuonScatteringAngleSignificance"): from AthenaCommon.AppMgr import ToolSvc muonScatteringSigTool=None if hasattr(ToolSvc, "MuonScatteringSigTool"): muonScatteringSigTool=ToolSvc.MuonScatteringSigTool from JetTagD3PDMaker import MuonScatteringAngleSignificanceFillerTool MuonD3PDObject.defineBlock (100, "MuonScatteringAngleSignificance", MuonScatteringAngleSignificanceFillerTool, ScatteringSigTool=muonScatteringSigTool) alg += MuonD3PDObject (**_args (10, 'MuidMuon', kw, sgkey='MuidMuonCollection', prefix='mu_muid_', include = ["EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex", "L2CBInfoIndex", "L1InfoIndex"], exclude = ["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"], allowMissing = True )) alg += MuonD3PDObject (**_args (10, 'StacoMuon', kw, sgkey='StacoMuonCollection', prefix='mu_staco_', include = ["EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex", "L2CBInfoIndex", "L1InfoIndex"], exclude = ["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"], allowMissing = True )) from AthenaCommon.KeyStore import CfgItemList if CfgItemList("KeyStore_inputFile").has_item("Analysis::MuonContainer#Muons"): alg += MuonD3PDObject (**_args (10, 'Muons', kw, sgkey='Muons', prefix='mu_muons_', include = ["EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex", "L2CBInfoIndex", "L1InfoIndex"], exclude = ["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"], allowMissing = True )) alg += MuonD3PDObject (**_args (0, 'CaloMuon', kw, sgkey='CaloMuonCollection', prefix='mu_calo_', include = ["MuonHitSummary", "Authors", "Likelihood", "Isolation", "CaloEnergyLoss", "Quality"] )) # Tau block if flags.doTaus(): alg += TauD3PDObject (**_args ( 1, 'Tau', kw)) # track and cluster blocks # ... all clusters, very low LOD alg += ClusterD3PDObject (**_args ( 0, 'Clusters1', kw, exclude='SamplingBasics')) # ... higher LOD for pt>10 GeV if flags.doHighPtClusters(): alg += ClusterD3PDObject (**_args ( 2, 'Clusters2', kw, sgkey = 'HighPtClusters', prefix = 'clpt10_')) if flags.doHighPtEMClusters(): alg += ClusterD3PDObject (**_args ( 3, 'Clusters3', kw, sgkey = 'HighPtEMClusters', prefix = 'emclpt10_')) from TrackD3PDMaker.TrackD3PDObject import TrackD3PDObject # ... good tracks only (nSCT>3; no pt cut) # use standard level of track info for 'GoodTracks' if flags.doGoodTracks(): # use standard level of track info for 'GoodTracks' alg += TrackParticleD3PDObject (**_args ( 3, 'Tracks1', kw, sgkey = 'GoodTracks', label = 'trk', prefix = 'trk_')) # ... high-pt tracks (nSCT>3; pt>5 GeV) if flags.doHighPtTracks(): from TrackD3PDMaker.TrackD3PDMakerFlags import TrackD3PDFlags as highPtFlags highPtFlags.doTruth = True highPtFlags.storeDiagonalCovarianceAsErrors = True highPtFlags.storeHitTruthMatching = True highPtFlags.storePixelHitsOnTrack = False highPtFlags.storePixelHolesOnTrack = False highPtFlags.storePixelOutliersOnTrack = False highPtFlags.storeSCTHitsOnTrack = False highPtFlags.storeSCTHolesOnTrack = False highPtFlags.storeSCTOutliersOnTrack = False highPtFlags.storeTRTHitsOnTrack = False highPtFlags.storeTRTHolesOnTrack = False highPtFlags.storeTRTOutliersOnTrack = False highPtFlags.storeTrackFitQuality = True highPtFlags.storeTrackMomentum = True highPtFlags.storeTrackSummary = True highPtFlags.storeTrackSummary.IDOutliers = True highPtFlags.storeTrackSummary.PixelInfoPlus = True highPtFlags.storeTrackSummary.SCTInfoPlus = True highPtFlags.storeTrackSummary.TRTInfoPlus = True highPtFlags.storeTrackSummary.InfoPlus = True highPtFlags.trackParametersAtBeamSpotLevelOfDetails = 0 highPtFlags.trackParametersAtGlobalPerigeeLevelOfDetails = 2 highPtFlags.trackParametersAtPrimaryVertexLevelOfDetails = 3 HighPtTrackParticleD3PDObject = TrackD3PDObject(_label='trkpt5', _prefix='trkpt5_', _sgkey='HighPtTracks', typeName='Rec::TrackParticleContainer', flags=highPtFlags) alg += HighPtTrackParticleD3PDObject(**_args ( 3, 'Tracks2', kw, sgkey = 'HighPtTracks', label = 'trkpt5', prefix = 'trkpt5_')) # Jet blocks from JetTagD3PDMaker.JetTagD3PDMakerFlags import JetTagD3PDFlags # include list modified for HSG5D3PD includelist = JetTagD3PDFlags.StdInfoInclude() from JetTagD3PDMaker.JetTagD3PDMakerKeys import JetTagD3PDKeys includelist += [JetTagD3PDKeys.BTagWeightsBlockName()] #includelist += [JetTagD3PDKeys.JetFitterInfoBaseBlockName()] #includelist += [JetTagD3PDKeys.JetFitterTagInfoBlockName()] #includelist += [JetTagD3PDKeys.IP3DInfoBaseBlockName()] #includelist += [JetTagD3PDKeys.IP3DIPInfoBaseBlockName()] #includelist += [JetTagD3PDKeys.JetFitterCombInfoBaseBlockName()] includelist += [JetTagD3PDKeys.JetTrackAssocBlockName()] includelist += [JetTagD3PDKeys.JetTrackBlockName()] includelist += [JetTagD3PDKeys.IPInfoPlusTrackAssocBlockName()] includelist += [JetTagD3PDKeys.IPInfoPlusTrackBlockName()] includelist += ['ConstituentScale'] jetkw = kw if not jetkw.has_key ( 'AK4TopoEMJet_'+JetTagD3PDKeys.JetTrackAssocBlockName()+'_target'): jetkw['AK4TopoEMJet_'+JetTagD3PDKeys.JetTrackAssocBlockName()+'_target']= "trk" if not jetkw.has_key ( 'AK4TopoEMJet_'+JetTagD3PDKeys.IPInfoPlusTrackAssocBlockName()+'_target'): jetkw['AK4TopoEMJet_'+JetTagD3PDKeys.IPInfoPlusTrackAssocBlockName()+'_target']= "trk" alg += JetD3PDObject (**_args ( 3, 'AK4TopoEMJet', jetkw, sgkey='AntiKt4TopoEMJets', prefix='jet_AntiKt4TopoEM_', include = includelist, JetVertexFraction_FromUD=True, JetVertexFraction_FillFullJVF=True, allowMissing = True)) alg += JetD3PDObject (**_args ( 3, 'AK6TopoEMJet', kw, sgkey='AntiKt6TopoEMJets', prefix='jet_AntiKt6TopoEM_', include = [JetTagD3PDFlags.StdInfoInclude(),'ConstituentScale'], JetVertexFraction_FromUD=True, JetVertexFraction_FillFullJVF=True, allowMissing = True)) alg += JetD3PDObject (**_args ( 3, 'AK4LCTopoJet', kw, sgkey='AntiKt4LCTopoJets', prefix='jet_AntiKt4LCTopo_', exclude=['Layer'], include=['ConstituentScale'], JetVertexFraction_FromUD=True, JetVertexFraction_FillFullJVF=True, allowMissing = True)) alg += JetD3PDObject (**_args ( 3, 'AK6LCTopoJet', kw, sgkey='AntiKt6LCTopoJets', prefix='jet_AntiKt6LCTopo_', exclude=['Layer'], include=['ConstituentScale'], JetVertexFraction_FromUD=True, JetVertexFraction_FillFullJVF=True, allowMissing = True)) from TopInputsD3PDMaker.HforD3PDObject import HforD3PDObject alg += HforD3PDObject(**_args (0, 'HforInfo', kw)) # MET blocks # a whole mess to remove x,y components separately for all flavours if flags.doAllMissingET() : alg += MissingETD3PDObject (**_args (10, 'MissingET', kw, exclude=['MET_Base', 'MET_Base0', 'MET_Truth_Int', 'MET_RefFinal_Comps','MET_Calib_Comps','MET_CellOut_Comps', 'MET_CorrTopo_Comps','MET_Cryo_Comps','MET_CryoCone_Comps', 'MET_Final_Comps','MET_LocHadTopo_Comps', 'MET_LocHadTopoObj_Comps', 'MET_Muid_Comps','MET_Muid_Spectro_Comps','MET_Muid_Track_Comps', 'MET_MuonBoy_Comps','MET_MuonBoy_Spectro_Comps','MET_MuonBoy_Track_Comps', 'MET_Muons_Comps','MET_Muons_Spectro_Comps','MET_Muons_Track_Comps', 'MET_MuonMuid_Comps', 'MET_Muon_Comps','MET_Muon_Isol_Muid_Comps', 'MET_Muon_Isol_Staco_Comps','MET_Muon_NonIsol_Muid_Comps', 'MET_Muon_NonIsol_Staco_Comps','MET_Muon_Total_Muid_Comps', 'MET_Muon_Total_Staco_Comps','MET_RefEle_Comps', 'MET_RefEle_em_Comps','MET_RefGamma_Comps', 'MET_RefGamma_em_Comps','MET_RefJet_Comps', 'MET_RefJet_em_Comps','MET_RefMuon_Comps', 'MET_RefMuon_Muid_Comps','MET_RefMons_Comps','MET_RefMuon_Staco_Comps', 'MET_RefMuon_Track_Muid_Comps','MET_RefMuon_Track_Staco_Comps', 'MET_RefMuon_Track_em_Comps','MET_RefMuon_Track_Comps', 'MET_RefMuons_Track_Comps', 'MET_RefMuon_em_Comps','MET_RefTau_Comps', 'MET_RefTau_em_Comps','MET_SoftJets_Comps', 'MET_SoftJets_em_Comps','MET_Topo_Comps', 'MET_TopoObj_Comps','MET_Track_Comps','MET_Comps', 'MET_Track_Weights','MET_Cluster_Weights'], allowMissing=True)) else : alg += MissingETD3PDObject(0, sgkey = "MET_RefFinal", prefix = "MET_RefFinal") # MuonBoy terms used in RefFinal alg += MissingETD3PDObject(0, sgkey = "MET_MuonBoy", prefix = "MET_MuonBoy") alg += MissingETD3PDObject(0, sgkey = "MET_RefMuon", prefix = "MET_RefMuon") alg += MissingETD3PDObject(0, sgkey = "MET_CellOut_Eflow", prefix = "MET_CellOut_Eflow") # terms needed to calculate RefFinal with Muid instead of Staco alg += MissingETD3PDObject(0, sgkey = "MET_RefMuon_Muid", prefix = "MET_RefMuon_Muid") alg += MissingETD3PDObject(0, sgkey = "MET_MuonMuid", prefix = "MET_MuonMuid") alg += MissingETD3PDObject(0, sgkey = "MET_Muid", prefix = "MET_Muid") alg += MissingETD3PDObject(0, sgkey = "MET_CellOut_Eflow_Muid", prefix = "MET_CellOut_Eflow_Muid") # terms needed to calculate RefFinal with third chain instead of Staco from AthenaCommon.KeyStore import CfgItemList keystore = CfgItemList("KeyStore_inputFile") if keystore.has_item("MissingET#MET_Muons"): alg += MissingETD3PDObject(0, sgkey = "MET_Muons", prefix = "MET_Muons") if keystore.has_item("MissingET#MET_RefMuons"): alg += MissingETD3PDObject(0, sgkey = "MET_RefMuons", prefix = "MET_RefMuons") if keystore.has_item("MissingET#MET_CellOut_Eflow_Muons"): alg += MissingETD3PDObject(0, sgkey = "MET_CellOut_Eflow_Muons", prefix = "MET_CellOut_Eflow_Muons") # I have no idea what these are for alg += MissingETD3PDObject(0, sgkey = "MET_SoftJets", prefix = "MET_SoftJets") alg += MissingETD3PDObject(0, sgkey = "MET_RefFinal_em", prefix = "MET_RefFinal_em") alg += MissingETD3PDObject(0, sgkey = "MET_CellOut_em", prefix = "MET_CellOut_em") alg += MissingETD3PDObject(0, sgkey = "MET_SoftJets_em", prefix = "MET_SoftJets_em") # HadronicRecoil blocks if flags.doHadronicRecoil(): alg += ElectronD3PDObject(0, sgkey = "HR_selectedElectrons", prefix = "hr_el_") alg += MuonD3PDObject( 0, sgkey = "HR_selectedMuons", prefix = "hr_mu_" ) alg += MissingETD3PDObject(0, sgkey = "RoughRecoil_20", prefix = "hr_roughRecoil_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject(0, sgkey = "ueCorrection_20", prefix = "hr_ueCorrection_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject(0, sgkey = "RefinedRecoil_20", prefix = "hr_corrRecoil_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject(0, sgkey = "MET_HR_20", prefix = "hr_MET_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject(0, sgkey = "RoughRecoil_track_20", prefix = "hr_roughRecoil_track_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject(0, sgkey = "ueCorrection_track_20", prefix = "hr_ueCorrection_track_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject(0, sgkey = "RefinedRecoil_track_20", prefix = "hr_corrRecoil_track_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject(0, sgkey = "MET_HR_track_20", prefix = "hr_MET_track_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject(0, sgkey = "RoughRecoil_clusNoTrack_20", prefix = "hr_roughRecoil_clusNoTrack_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject(0, sgkey = "ueCorrection_clusNoTrack_20", prefix = "hr_ueCorrection_clusNoTrack_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject(0, sgkey = "RefinedRecoil_clusNoTrack_20", prefix = "hr_corrRecoil_clusNoTrack_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject(0, sgkey = "MET_HR_clusNoTrack_20", prefix = "hr_MET_clusNoTrack_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject(0, sgkey = "RoughRecoil_Eflow_20", prefix = "hr_roughRecoil_Eflow_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject(0, sgkey = "ueCorrection_Eflow_20", prefix = "hr_ueCorrection_Eflow_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject(0, sgkey = "RefinedRecoil_Eflow_20", prefix = "hr_corrRecoil_Eflow_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject(0, sgkey = "MET_HR_Eflow_20", prefix = "hr_MET_Eflow_20", exclude=['MET_Regions','MET_Comps'] ) """ # track and cluster blocks # ... all clusters, very low LOD alg += ClusterD3PDObject (**_args ( 0, 'Clusters1', kw, exclude='SamplingBasics')) # ... higher LOD for pt>10 GeV if flags.doHighPtClusters(): alg += ClusterD3PDObject (**_args ( 2, 'Clusters2', kw, sgkey = 'HighPtClusters', prefix = 'clpt10_')) if flags.doHighPtEMClusters(): alg += ClusterD3PDObject (**_args ( 3, 'Clusters3', kw, sgkey = 'HighPtEMClusters', prefix = 'emclpt10_')) from TrackD3PDMaker.TrackD3PDObject import TrackD3PDObject # ... good tracks only (nSCT>3; no pt cut) # use standard level of track info for 'GoodTracks' if flags.doGoodTracks(): # use standard level of track info for 'GoodTracks' alg += TrackParticleD3PDObject (**_args ( 3, 'Tracks1', kw, sgkey = 'GoodTracks', label = 'trk', prefix = 'trk_')) # ... high-pt tracks (nSCT>3; pt>5 GeV) if flags.doHighPtTracks(): from TrackD3PDMaker.TrackD3PDMakerFlags import TrackD3PDFlags as highPtFlags highPtFlags.doTruth = True highPtFlags.storeDiagonalCovarianceAsErrors = True highPtFlags.storeHitTruthMatching = True highPtFlags.storePixelHitsOnTrack = False highPtFlags.storePixelHolesOnTrack = False highPtFlags.storePixelOutliersOnTrack = False highPtFlags.storeSCTHitsOnTrack = False highPtFlags.storeSCTHolesOnTrack = False highPtFlags.storeSCTOutliersOnTrack = False highPtFlags.storeTRTHitsOnTrack = False highPtFlags.storeTRTHolesOnTrack = False highPtFlags.storeTRTOutliersOnTrack = False highPtFlags.storeTrackFitQuality = True highPtFlags.storeTrackMomentum = True highPtFlags.storeTrackSummary = True highPtFlags.storeTrackSummary.IDOutliers = True highPtFlags.storeTrackSummary.PixelInfoPlus = True highPtFlags.storeTrackSummary.SCTInfoPlus = True highPtFlags.storeTrackSummary.TRTInfoPlus = True highPtFlags.storeTrackSummary.InfoPlus = True highPtFlags.trackParametersAtBeamSpotLevelOfDetails = 0 highPtFlags.trackParametersAtGlobalPerigeeLevelOfDetails = 2 highPtFlags.trackParametersAtPrimaryVertexLevelOfDetails = 3 HighPtTrackParticleD3PDObject = TrackD3PDObject(_label='trkpt5', _prefix='trkpt5_', _sgkey='HighPtTracks', typeName='Rec::TrackParticleContainer', flags=highPtFlags) alg += HighPtTrackParticleD3PDObject(**_args ( 3, 'Tracks2', kw, sgkey = 'HighPtTracks', label = 'trkpt5', prefix = 'trkpt5_')) """ # Primary vertex block - May be missing in single-beam data. alg += PrimaryVertexD3PDObject (**_args (1, 'PrimaryVertex', kw, allowMissing = True, sgkey = D3PDMakerFlags.VertexSGKey(), prefix = 'vxp_')) # MBTS alg += MBTSD3PDObject (**_args (10, 'MBTS', kw)) alg += MBTSTimeD3PDObject (**_args (10, 'MBTSTime', kw)) alg += MBTSTriggerBitsD3PDObject (**_args (10, 'MBTSTriggerBits', kw)) #alg += CollisionDecisionD3PDObject(**_args (10, 'CollisionDecision', kw)) # Truth if rec.doTruth(): from TruthD3PDMaker.TruthParticleD3PDObject import TruthParticleD3PDObject from MuonD3PDMaker.TruthMuonD3PDObject import TruthMuonD3PDObject alg += TruthMuonD3PDObject (**_args ( 2, 'TruthMuon', kw)) alg += GenEventD3PDObject (**_args ( 1, 'GenEvent', kw)) alg += TruthParticleD3PDObject(**_args ( 1, 'TruthParticle', kw)) # TruthJets alg += JetD3PDObject (**_args ( 1, 'AK4TruthJet', kw, sgkey='AntiKt4TruthJets',prefix='jet_AntiKt4Truth_', allowMissing = True)) alg += JetD3PDObject (**_args ( 1, 'AK6TruthJet', kw, sgkey='AntiKt6TruthJets', prefix='jet_AntiKt6Truth_', allowMissing = True)) alg += JetD3PDObject (**_args ( 1, 'AK4TruthJetALL', kw, sgkey='AntiKt4TruthJets_ALL', prefix='jet_AntiKt4TruthALL_', allowMissing = True)) alg += JetD3PDObject (**_args ( 1, 'AK6TruthJetALL', kw, sgkey='AntiKt6TruthJets_ALL', prefix='jet_AntiKt6TruthALL_', allowMissing = True)) alg += JetD3PDObject (**_args ( 1, 'AK4TruthJetWZ', kw, sgkey='AntiKt4TruthJets_WZ', prefix='jet_AntiKt4TruthWZ_', allowMissing = True)) alg += JetD3PDObject (**_args ( 1, 'AK6TruthJetWZ', kw, sgkey='AntiKt6TruthJets_WZ', prefix='jet_AntiKt6TruthWZ_', allowMissing = True)) if not rec.doTruth(): alg += BeamSpotD3PDObject(10) from TrigMissingETD3PDMaker.TrigMETD3PD import TrigMETD3PDObjects TrigMETD3PDObjects(alg,10) # Trigger if D3PDMakerFlags.DoTrigger(): alg += SMWZTriggerBitsD3PDObject (**_args (10, 'SMWZTriggerBits', kw)) # Trigger Decision + metadata alg += TrigDecisionD3PDObject (**_args(10, 'TrigDecision', kw)) addTrigConfMetadata(alg) # Bunch group info alg += BGCodeD3PDObject (**_args (2, 'BGCode', kw)) # Egamma and Mu TrigEgammaD3PDObjects (alg, 1) TrigMuonD3PDObjects( alg, 1) # Esum #alg += EnergySumROID3PDObject(**_args (2, 'EnergySumROI', kw, # prefix = "trig_L1_esum_")) # The LVL2 information: #alg += TrigMETD3PDObject(**_args( 2, 'TrigMETL2', kw, # prefix = "trig_L2_met_", # sgkey = "HLT_T2MissingET" )) # The EF information: #alg += TrigMETD3PDObject(**_args ( 2, 'TrigMETEF', kw, # prefix = "trig_EF_met_", # sgkey = "HLT_TrigEFMissingET" )) # Event metadata alg.MetadataTools += [LBMetadataConfig()] # Invoke routine to write GSCFactor and WidthFraction jet moments #addSTRUCTCalib('AntiKt4LCTopoJets', input='Topo', mainParam=0.4) #addSTRUCTCalib('AntiKt6LCTopoJets', input='Topo', mainParam=0.6) #addSTRUCTCalib('AntiKt4TopoEMJets', input='Topo', mainParam=0.4) #addSTRUCTCalib('AntiKt6TopoEMJets', input='Topo', mainParam=0.6) if D3PDMakerFlags.FilterCollCand(): from CaloD3PDMaker.CollisionFilterAlg import CollisionFilterAlg alg.filterSeq += CollisionFilterAlg (tuplename + '_CollCandFilter') return alg
myPath = "/afs/cern.ch/atlas/project/PAT/xAODs/r5534/valid2.117050.PowhegPythia_P2011C_ttbar.digit.AOD.e2657_s1933_s1964_r5534/AOD.01482225._000107.pool.root.1" jp.AthenaCommonFlags.FilesInput = [myPath] #from AthenaCommon.AlgSequence import AlgSequence #topSequence = AlgSequence() include("RecExCommon/AnalysisCommon_topOptions.py") streamName = "MyFirstHistoStream" fileName = "myHistosAth.pool.root" rootStreamName = streamName rootDirName = "/Hists" from OutputStreamAthenaPool.MultipleStreamManager import MSMgr MyFirstHistoXAODStream = MSMgr.NewRootStream(streamName, fileName) if not hasattr(ServiceMgr, 'THistSvc'): print 'Ahhhhhhhh' ServiceMgr.THistSvc.OutputLevel = VERBOSE # ==================================================================== # Create a subsequence: # Only when the first algorithm returns isEventAccepted, # the rest of this sub-sequence is executed # ==================================================================== from AthenaCommon.AlgSequence import AthSequencer subSeqMyAthAnalysis = AthSequencer("MyFirstAnalysisSubSeq") topSequence += subSeqMyAthAnalysis
def SMWZLightD3PD (alg = None, file = 'smlight.root', tuplename = 'physics', streamname = 'd3pdstream', stdElectronContainer = 'None', gsfElectronContainer = 'None', stacoMuonContainer = 'None', muidMuonContainer = 'None', photonContainer = 'None', jetContainer = 'None', clusterContainer = 'None', tauContainer = 'None', trackContainer = 'None', **kw): preseq = AlgSequence (D3PDMakerFlags.PreD3PDAlgSeqName()) # perform recoil calculation import HadronicRecoil.Configurables as hrc preseq = hrc.add_hadronic_recoil_filters(preseq) # configure the D3PD if not alg: alg = MSMgr.NewRootStream(StreamName = streamname, FileName = file, TreeName = tuplename) alg += EventInfoD3PDObject (**_args (10, 'EventInfo', kw)) alg += LArCollisionTimeD3PDObject (**_args (10, 'LArCollisionTime', kw)) from TriggerD3PDMaker.BunchStructureMetadata import addBunchStructureMetadata addBunchStructureMetadata (alg) # Electron/Photon blocks if stdElectronContainer != 'None': alg += ElectronD3PDObject (**_args (10, 'Electron', kw, sgkey = stdElectronContainer, prefix = 'el_', exclude = ['EMTrackFit','EMTrackFitDetailsBrem', 'EMTrackFitDetailsRefit', 'EMTrackFitDetailsRefitCov'], allowMissing = True )) if (gsfElectronContainer != 'None') and testSGKey ('ElectronContainer', gsfElectronContainer): alg += GSFElectronD3PDObject (**_args (1, 'GSFElectron', kw, sgkey = gsfElectronContainer, prefix = 'el_gsf_', exclude = ['EMTrackFit','EMTrackFitDetailsBrem', 'EMTrackFitDetailsRefit', 'EMTrackFitDetailsRefitCov'], allowMissing = True )) D3PDMakerFlags.DoPAU = False if photonContainer != 'None': alg += PhotonD3PDObject (**_args (10, 'Photon', kw, sgkey = photonContainer, prefix = 'ph_', exclude = ['OQRecalc'], allowMissing = True )) # Muon blocks # ... add the scattering significance filler - to be removed when added in the MuonD3PDMaker if not MuonD3PDObject.allBlocknames().has_key("MuonScatteringAngleSignificance"): from AthenaCommon.AppMgr import ToolSvc muonScatteringSigTool=None if hasattr(ToolSvc, "MuonScatteringSigTool"): muonScatteringSigTool=ToolSvc.MuonScatteringSigTool from JetTagD3PDMaker import MuonScatteringAngleSignificanceFillerTool MuonD3PDObject.defineBlock (100, "MuonScatteringAngleSignificance", MuonScatteringAngleSignificanceFillerTool, ScatteringSigTool=muonScatteringSigTool) if stacoMuonContainer != 'None': alg += MuonD3PDObject (**_args (10, 'StacoMuon', kw, sgkey=stacoMuonContainer, prefix='mu_staco_', include = ['EFCBInfoIndex', 'EFMGInfoIndex', 'EFMEInfoIndex', 'MuonScatteringAngleSignificance'], exclude = ['EFCBInfo', 'EFMGInfo', 'EFMEInfo', 'L2CBInfo', 'L1Info', 'MuonTimingFillerTool'], allowMissing = True )) if muidMuonContainer != 'None': alg += MuonD3PDObject (**_args (10, 'MuidMuon', kw, sgkey=muidMuonContainer, prefix='mu_muid_', include = ['EFCBInfoIndex', 'EFMGInfoIndex', 'EFMEInfoIndex', 'MuonScatteringAngleSignificance'], exclude = ['EFCBInfo', 'EFMGInfo', 'EFMEInfo', 'L2CBInfo', 'L1Info', 'MuonTimingFillerTool'], allowMissing = True )) # Jet block from JetTagD3PDMaker.JetTagD3PDMakerFlags import JetTagD3PDFlags from JetTagD3PDMaker.JetTagD3PDMakerKeys import JetTagD3PDKeys if jetContainer != 'None': alg += JetD3PDObject (**_args ( 3, 'AK4TopoEMJet', kw, sgkey=jetContainer, allowMissing=True, prefix='jet_AntiKt4TopoEM_', JetVertexFraction_FromUD=True, JetVertexFraction_FillFullJVF=True, include = [ JetTagD3PDKeys.BTagWeightsBlockName(), JetTagD3PDKeys.TruthInfoBlockName() ] )) # Tau block if tauContainer != 'None': alg += TauD3PDObject (**_args ( 0, 'Tau', kw, allowMissing=True, sgkey=tauContainer )) # HF overlap removal (ALPGEN) from TopInputsD3PDMaker.HforD3PDObject import HforD3PDObject alg += HforD3PDObject(**_args (0, 'HforInfo', kw)) # MET blocks # a whole mess to remove x,y components separately for all flavours alg += MissingETD3PDObject (**_args (10, 'MissingET', kw, exclude=['MET_Base','MET_Base0','MET_Truth', 'MET_RefFinal_Comps','MET_RefFinal_Regions', 'MET_LocHadTopo_Comps','MET_LocHadTopo_Regions', 'MET_CellOut_Comps','MET_CellOut_Regions', 'MET_Calib', 'MET_CorrTopo', 'MET_Cryo', 'MET_CryoCone', 'MET_Final', 'MET_LocHadTopoObj', 'MET_Muid', 'MET_Muid_Spectro', 'MET_Muid_Track', 'MET_MuonBoy', 'MET_MuonBoy_Spectro', 'MET_MuonBoy_Track', 'MET_MuonMuid', 'MET_Muon', 'MET_Muon_Isol_Muid', 'MET_Muon_Isol_Staco', 'MET_Muon_NonIsol_Muid', 'MET_Muon_NonIsol_Staco', 'MET_Muon_Total_Muid', 'MET_Muon_Total_Staco', 'MET_RefEle_Comps','MET_RefEle_Regions', 'MET_RefEle_em_Comps','MET_RefEle_em_Regions', 'MET_RefGamma_Comps','MET_RefGamma_Regions', 'MET_RefGamma_em_Comps','MET_RefGamma_em_Regions', 'MET_RefJet_Comps','MET_RefJet_Regions', 'MET_RefJet_em_Comps','MET_RefJet_em_Regions', 'MET_RefMuon_Comps','MET_RefMuon_Regions', 'MET_RefMuon_Muid_Comps','MET_RefMuon_Muid_Regions', 'MET_RefMuon_Staco_Comps','MET_RefMuon_Staco_Regions', 'MET_RefMuon_Track_Muid_Comps','MET_RefMuon_Track_Muid_Regions', 'MET_RefMuon_Track_Staco_Comps','MET_RefMuon_Track_Staco_Regions', 'MET_RefMuon_Track_em_Comps','MET_RefMuon_Track_em_Regions', 'MET_RefMuon_Track_Comps','MET_RefMuon_Track_Regions', 'MET_RefMuon_em_Comps','MET_RefMuon_em_Regions', 'MET_RefTau_Comps','MET_RefTau_Regions', 'MET_RefTau_em_Comps','MET_RefTau_em_Regions', 'MET_SoftJets_Comps','MET_SoftJets_Regions', 'MET_SoftJets_em_Comps','MET_SoftJets_em_Regions', 'MET_Topo', 'MET_TopoObj_Comps','MET_TopoObj_Regions', 'MET_Track_Comps','MET_Track_Regions', 'MET_Comps', 'MET_Track_Weights','MET_Cluster_Weights', 'MET_Regions','MET_Composition'], allowMissing=True )) # HadronicRecoil blocks alg += ElectronD3PDObject(0, sgkey = 'HR_selectedElectrons', prefix = 'hr_el_',allowMissing=True ) alg += MuonD3PDObject( 0, sgkey = 'HR_selectedMuons', prefix = 'hr_mu_', allowMissing=True ) # ... DR = 0.15 alg += MissingETD3PDObject( 0, sgkey = 'RoughRecoil_15', prefix = 'hr_roughRecoil_15', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'ueCorrection_15', prefix = 'hr_ueCorrection_15', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'RefinedRecoil_15', prefix = 'hr_corrRecoil_15', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'MET_HR_15', prefix = 'hr_MET_15', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'RoughRecoil_Eflow_15', prefix = 'hr_roughRecoil_Eflow_15', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'ueCorrection_Eflow_15', prefix = 'hr_ueCorrection_Eflow_15', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'RefinedRecoil_Eflow_15', prefix = 'hr_corrRecoil_Eflow_15', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'MET_HR_Eflow_15', prefix = 'hr_MET_Eflow_15', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = "RoughRecoil_track_15", prefix = "hr_roughRecoil_track_15", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "ueCorrection_track_15", prefix = "hr_ueCorrection_track_15", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_track_15", prefix = "hr_corrRecoil_track_15", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "MET_HR_track_15", prefix = "hr_MET_track_15", exclude=['MET_Regions','MET_Comps'] ) # ... DR = 0.20 alg += MissingETD3PDObject( 0, sgkey = 'RoughRecoil_20', prefix = 'hr_roughRecoil_20', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'ueCorrection_20', prefix = 'hr_ueCorrection_20', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'RefinedRecoil_20', prefix = 'hr_corrRecoil_20', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'MET_HR_20', prefix = 'hr_MET_20', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'RoughRecoil_track_20', prefix = 'hr_roughRecoil_track_20', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'ueCorrection_track_20', prefix = 'hr_ueCorrection_track_20', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'RefinedRecoil_track_20', prefix = 'hr_corrRecoil_track_20', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'MET_HR_track_20', prefix = 'hr_MET_track_20', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'RoughRecoil_clusNoTrack_20', prefix = 'hr_roughRecoil_clusNoTrack_20', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'ueCorrection_clusNoTrack_20', prefix = 'hr_ueCorrection_clusNoTrack_20', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'RefinedRecoil_clusNoTrack_20', prefix = 'hr_corrRecoil_clusNoTrack_20', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'MET_HR_clusNoTrack_20', prefix = 'hr_MET_clusNoTrack_20', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'RoughRecoil_Eflow_20', prefix = 'hr_roughRecoil_Eflow_20', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'ueCorrection_Eflow_20', prefix = 'hr_ueCorrection_Eflow_20', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'RefinedRecoil_Eflow_20', prefix = 'hr_corrRecoil_Eflow_20', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'MET_HR_Eflow_20', prefix = 'hr_MET_Eflow_20', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) # ... DR = 0.25 alg += MissingETD3PDObject( 0, sgkey = 'RoughRecoil_25', prefix = 'hr_roughRecoil_25', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'ueCorrection_25', prefix = 'hr_ueCorrection_25', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'RefinedRecoil_25', prefix = 'hr_corrRecoil_25', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'MET_HR_25', prefix = 'hr_MET_25', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'RoughRecoil_Eflow_25', prefix = 'hr_roughRecoil_Eflow_25', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'ueCorrection_Eflow_25', prefix = 'hr_ueCorrection_Eflow_25', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'RefinedRecoil_Eflow_25', prefix = 'hr_corrRecoil_Eflow_25', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'MET_HR_Eflow_25', prefix = 'hr_MET_Eflow_25', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = "RoughRecoil_track_25", prefix = "hr_roughRecoil_track_25", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "ueCorrection_track_25", prefix = "hr_ueCorrection_track_25", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_track_25", prefix = "hr_corrRecoil_track_25", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "MET_HR_track_25", prefix = "hr_MET_track_25", exclude=['MET_Regions','MET_Comps'] ) # HR using truth leptons if rec.doTruth(): ## ... DR = 0.15 alg += MissingETD3PDObject( 0, sgkey = "RoughRecoil_TruthLep_15", prefix = "hr_roughRecoil_trLep_15", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "ueCorrection_TruthLep_15", prefix = "hr_ueCorrection_trLep_15", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_15", prefix = "hr_corrRecoil_trLep_15", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_15", prefix = "hr_MET_trLep_15", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RoughRecoil_TruthLep_Eflow_15", prefix = "hr_roughRecoil_trLep_Eflow_15", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "ueCorrection_TruthLep_Eflow_15", prefix = "hr_ueCorrection_trLep_Eflow_15", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_Eflow_15", prefix = "hr_corrRecoil_trLep_Eflow_15", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_Eflow_15", prefix = "hr_MET_trLep_Eflow_15", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RoughRecoil_TruthLep_track_15", prefix = "hr_roughRecoil_trLep_track_15", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "ueCorrection_TruthLep_track_15", prefix = "hr_ueCorrection_trLep_track_15", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_track_15", prefix = "hr_corrRecoil_trLep_track_15", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_track_15", prefix = "hr_MET_trLep_track_15", exclude=['MET_Regions','MET_Comps'] ) ## ... DR = 0.20 alg += MissingETD3PDObject( 0, sgkey = "RoughRecoil_TruthLep_20", prefix = "hr_roughRecoil_trLep_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "ueCorrection_TruthLep_20", prefix = "hr_ueCorrection_trLep_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_20", prefix = "hr_corrRecoil_trLep_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_20", prefix = "hr_MET_trLep_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RoughRecoil_TruthLep_Eflow_20", prefix = "hr_roughRecoil_trLep_Eflow_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "ueCorrection_TruthLep_Eflow_20", prefix = "hr_ueCorrection_trLep_Eflow_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_Eflow_20", prefix = "hr_corrRecoil_trLep_Eflow_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_Eflow_20", prefix = "hr_MET_trLep_Eflow_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RoughRecoil_TruthLep_track_20", prefix = "hr_roughRecoil_trLep_track_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "ueCorrection_TruthLep_track_20", prefix = "hr_ueCorrection_trLep_track_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_track_20", prefix = "hr_corrRecoil_trLep_track_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_track_20", prefix = "hr_MET_trLep_track_20", exclude=['MET_Regions','MET_Comps'] ) ## ... DR = 0.25 alg += MissingETD3PDObject( 0, sgkey = "RoughRecoil_TruthLep_25", prefix = "hr_roughRecoil_trLep_25", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "ueCorrection_TruthLep_25", prefix = "hr_ueCorrection_trLep_25", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_25", prefix = "hr_corrRecoil_trLep_25", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_25", prefix = "hr_MET_trLep_25", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RoughRecoil_TruthLep_Eflow_25", prefix = "hr_roughRecoil_trLep_Eflow_25", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "ueCorrection_TruthLep_Eflow_25", prefix = "hr_ueCorrection_trLep_Eflow_25", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_Eflow_25", prefix = "hr_corrRecoil_trLep_Eflow_25", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_Eflow_25", prefix = "hr_MET_trLep_Eflow_25", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RoughRecoil_TruthLep_track_25", prefix = "hr_roughRecoil_trLep_track_25", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "ueCorrection_TruthLep_track_25", prefix = "hr_ueCorrection_trLep_track_25", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_track_25", prefix = "hr_corrRecoil_trLep_track_25", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_track_25", prefix = "hr_MET_trLep_track_25", exclude=['MET_Regions','MET_Comps'] ) # Cluster block # ... all clusters, very low LOD if clusterContainer != 'None': alg += ClusterD3PDObject (**_args ( 0, 'Clusters', kw, sgkey = clusterContainer, exclude='SamplingBasics', allowMissing=True )) # Track block # ... good tracks only (nSCT>=6; no pt cut) if trackContainer != 'None': alg += TrackParticleD3PDObject (**_args ( 3, 'Tracks', kw, sgkey = trackContainer, label = 'trk', prefix = 'trk_', allowMissing=True )) # Primary vertex block - May be missing in single-beam data. alg += PrimaryVertexD3PDObject (**_args (1, 'PrimaryVertex', kw, sgkey = D3PDMakerFlags.VertexSGKey(), prefix = 'vxp_', allowMissing=True )) # Truth if rec.doTruth(): from TruthD3PDMaker.TruthParticleD3PDObject import TruthParticleD3PDObject from MuonD3PDMaker.TruthMuonD3PDObject import TruthMuonD3PDObject alg += TruthMuonD3PDObject (**_args ( 2, 'TruthMuon', kw)) from AthenaCommon.AppMgr import ToolSvc from TruthD3PDAnalysis.TruthD3PDAnalysisConf import D3PD__GenObjectsFilterTool # ... remove empty GenEvents smlightGenEvtFilterTool = D3PD__GenObjectsFilterTool( "smlightGenEvtFilterTool" ) ToolSvc += smlightGenEvtFilterTool smlightGenEvtFilterTool.RemoveDummyEvents = True smlightGenEvtFilterTool.RemoveInTimePileUp = True smlightGenEvtFilterTool.Remove2BCPileUp = True smlightGenEvtFilterTool.Remove800nsPileUp = True smlightGenEvtFilterTool.RemoveCavernBkg = True smlightGenEvtFilterTool.RemoveEmptyEvents = True from TruthD3PDMaker.GenEventD3PDObject import GenEventD3PDObject alg += GenEventD3PDObject (**_args ( 0, 'GenEvent', kw, filter = smlightGenEvtFilterTool )) # ... leptonic W/Z truth information smlightLepWZFilterTool = D3PD__GenObjectsFilterTool( "smlightLepWZFilterTool" ) ToolSvc += smlightLepWZFilterTool smlightLepWZFilterTool.RemoveInTimePileUp = True smlightLepWZFilterTool.Remove2BCPileUp = True smlightLepWZFilterTool.Remove800nsPileUp = True smlightLepWZFilterTool.RemoveCavernBkg = True smlightLepWZFilterTool.RemoveEmptyEvents = True smlightLepWZFilterTool.RemoveDummyEvents = True smlightLepWZFilterTool.RemoveUnrequestedParticles=True smlightLepWZFilterTool.KeepLeptonicWZBosons=True smlightLepWZFilterTool.KeepLeptonicWZBosonDecayChains=True smlightLepWZFilterTool.KeepLeptonicWZBosonsParents=True from TruthD3PDMaker.GenParticleD3PDObject import GenParticleD3PDObject alg += GenParticleD3PDObject( **_args(10, "lepwzgenparticle", kw, prefix='mclepwzpart_', filter = smlightLepWZFilterTool, label = "LepWZTruthD3PDObject", exclude = ["GenPartProdVertexAssoc","GenPartDecayVertexAssoc"], GenParticle_WriteMotherType=False, GenParticle_WriteMotherBarcode=False, GenPartMotherAssoc_target="LepWZTruthD3PDObject", GenPartChildAssoc_target="LepWZTruthD3PDObject" ) ) if not rec.doTruth(): alg += BeamSpotD3PDObject(10) # Trigger if D3PDMakerFlags.DoTrigger(): # RedefineTriggerBits(alg, 'EF*') # alg += SMWZLightTriggerBitsD3PDObject (**_args (10, 'SMWZLightTriggerBits', kw)) # metadata addTrigConfMetadata(alg) # Bunch group info alg += BGCodeD3PDObject (**_args (2, 'BGCode', kw)) # Egamma EF information alg += EFElectronD3PDObject(0, name='trig_EF_el_', sgkey='HLT_egamma_Electrons,HLT_egamma', prefix='trig_EF_el_', exclude=['Author','IsEM','IsEMCuts'], include=['Triggers'], allowMissing = True) # alg += EFPhotonD3PDObject(0, name='trig_EF_ph_', # sgkey='HLT_egamma_Photons,HLT_egamma', # prefix='trig_EF_ph_', # exclude=['Author','Conversion0','IsEM','IsEMCuts'], # include=['Triggers'], # allowMissing = True) # Muon EF information alg += TrigMuonEFInfoD3PDObject(0, include=['Decision'], exclude=['TrackDetails','SpectrometerTrackBasics','ExtrapolatedTrackBasics'], allowMissing = True) alg += TrigMuonEFInfoD3PDObject(0, name = "trig_EF_trigmugirl_", sgkey = "HLT_eMuonEFInfo", prefix = "trig_EF_trigmugirl_", exclude=['TrackDetails','SpectrometerTrackBasics','ExtrapolatedTrackBasics'], include=['Decision'], allowMissing = True) # MET EF information # alg += TrigMETD3PDObject(**_args ( 0, 'TrigMETEF', kw, # prefix = "trig_EF_met_", # sgkey = "HLT_TrigEFMissingET" )) # Event metadata alg.MetadataTools += [LBMetadataConfig()] if D3PDMakerFlags.FilterCollCand(): from CaloD3PDMaker.CollisionFilterAlg import CollisionFilterAlg alg.filterSeq += CollisionFilterAlg (tuplename + '_CollCandFilter') return alg
# Check if the configuration makes sense: if prodFlags.WriteMinBiasD3PD.isVirtual: MinBiasD3PDStream_msg.error("The MinBias D3PD stream can't be virtual! " + "It's a configuration error!") raise NameError("MinBias D3PD set to be a virtual stream") # Construct the stream and file names: streamName = prodFlags.WriteMinBiasD3PD.StreamName fileName = buildFileName(prodFlags.WriteMinBiasD3PD) MinBiasD3PDStream_msg.info( "Configuring MinBias D3PD with streamName '%s' and fileName '%s'" % \ ( streamName, fileName ) ) # Create the D3PD stream: from OutputStreamAthenaPool.MultipleStreamManager import MSMgr MinBiasD3PDStream = MSMgr.NewRootStream(streamName, fileName, "MinBiasTree") def MinBiasD3PD(d3pdalg=None, file='minbias.root', tuplename='MinBiasD3PD', streamname='d3pdstream', **kw): # MinBias flags from MinBiasD3PDMaker.MinBiasD3PDMakerFlags import minbiasD3PDflags from IOVDbSvc.CondDB import conddb from AthenaCommon.GlobalFlags import globalflags if minbiasD3PDflags.doPixelTracklets(): MinBiasD3PDStream_msg.info(
if not 'JetTagD3PD_redoTagging' in dir(): JetTagD3PD_redoTagging = True if not 'JetTagD3PD_JetFitterCharm' in dir(): JetTagD3PD_JetFitterCharm = True if not 'JetTagD3PD_MV3' in dir(): JetTagD3PD_MV3 = True include("JetTagD3PDMaker/JetTagD3PD_prodFragmentCore.py") from AthenaCommon.JobProperties import jobproperties btagprodFlags = jobproperties.D3PDProdFlags from PrimaryDPDMaker.PrimaryDPDHelpers import buildFileName if btagprodFlags.WriteBTAGEFFD3PD.isVirtual: raise NameError("BTAGD3PD set to be a virtual stream") pass streamName = btagprodFlags.WriteBTAGEFFD3PD.StreamName fileName = buildFileName(btagprodFlags.WriteBTAGEFFD3PD) from OutputStreamAthenaPool.MultipleStreamManager import MSMgr alg = MSMgr.NewRootStream(btagprodFlags.WriteBTAGEFFD3PD.StreamName, fileName, JetTagD3PDKeys.D3PDTupleName()) from JetTagD3PDMaker.BTaggingD3PD import BTaggingD3PD BTaggingD3PD(alg, **(JetTagD3PDFlags.D3PDPropDict())) include("JetTagD3PDMaker/JetTagD3PD_prodFragmentPostStream.py")
def MinBiasD3PD(d3pdalg=None, file='minbias.root', tuplename='MinBiasD3PD', streamname='d3pdstream', **kw): # MinBias flags from MinBiasD3PDMaker.MinBiasD3PDMakerFlags import minbiasD3PDflags from IOVDbSvc.CondDB import conddb from AthenaCommon.GlobalFlags import globalflags if minbiasD3PDflags.doPixelTracklets(): MinBiasD3PDStream_msg.info( ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> TRACKLETS") pass ## Don't do truth on data if globalflags.DataSource == 'data': minbiasD3PDflags.doMBTruth = False pass #-------------------------------------------------------------- # Configure Beam spot service #-------------------------------------------------------------- # from AthenaCommon.GlobalFlags import globalflags # if globalflags.DataSource == 'data': # include("InDetBeamSpotService/BeamCondSvc.py") # conddb.addOverride("/Indet/Beampos", #minbiasD3PDflags.BSDBFolderName()) # pass #-------------------------------------------------------------- # Configure the MinBiasD3PDMaker #-------------------------------------------------------------- import TrackD3PDMaker import TrigMbD3PDMaker import TriggerD3PDMaker import D3PDMakerCoreComps import EventCommonD3PDMaker ## Event Info from EventCommonD3PDMaker.EventInfoD3PDObject import EventInfoD3PDObject ## Trigger part from TrigMbD3PDMaker.BcmRdoD3PDObject import BcmRdoD3PDObject from TrigMbD3PDMaker.CtpRdoD3PDObject import CtpRdoD3PDObject from TrigMbD3PDMaker.CtpDecisionD3PDObject import CtpDecisionD3PDObject from TrigMbD3PDMaker.MbtsContainerD3PDObject import MbtsContainerD3PDObject from TrigMbD3PDMaker.MbtsLvl2D3PDObject import MbtsLvl2D3PDObject from TrigMbD3PDMaker.SpLvl2D3PDObject import SpLvl2D3PDObject from TrigMbD3PDMaker.TrtLvl2D3PDObject import TrtLvl2D3PDObject from TrigMbD3PDMaker.TrkCntsEfD3PDObject import TrkCntsEfD3PDObject from TriggerD3PDMaker.TrigDecisionD3PDObject import TrigDecisionD3PDObject from TriggerD3PDMaker.TrigConfMetadata import addTrigConfMetadata ## Tracking part #-- TrackD3PDMaker Flags from TrackD3PDMaker.TrackD3PDMakerFlags import TrackD3PDFlags TrackD3PDFlags.doTruth.set_Value_and_Lock(minbiasD3PDflags.doMBTruth()) TrackD3PDFlags.storeDiagonalCovarianceAsErrors.set_Value_and_Lock(True) TrackD3PDFlags.storeHitTruthMatching.set_Value_and_Lock( minbiasD3PDflags.doMBTruth()) TrackD3PDFlags.storeDetailedTruth.set_Value_and_Lock( minbiasD3PDflags.doMBTruth()) TrackD3PDFlags.storePullsAndResiduals.set_Value_and_Lock(False) TrackD3PDFlags.storeBLayerHitsOnTrack.set_Value_and_Lock(False) TrackD3PDFlags.storePixelHitsOnTrack.set_Value_and_Lock(True) TrackD3PDFlags.storeSCTHitsOnTrack.set_Value_and_Lock(True) TrackD3PDFlags.storeTRTHitsOnTrack.set_Value_and_Lock(True) TrackD3PDFlags.storeBLayerOutliersOnTrack.set_Value_and_Lock(False) TrackD3PDFlags.storePixelOutliersOnTrack.set_Value_and_Lock(True) TrackD3PDFlags.storeSCTOutliersOnTrack.set_Value_and_Lock(True) TrackD3PDFlags.storeTRTOutliersOnTrack.set_Value_and_Lock(True) TrackD3PDFlags.storeBLayerHolesOnTrack.set_Value_and_Lock(False) TrackD3PDFlags.storePixelHolesOnTrack.set_Value_and_Lock(True) TrackD3PDFlags.storeSCTHolesOnTrack.set_Value_and_Lock(True) TrackD3PDFlags.storeTRTHolesOnTrack.set_Value_and_Lock(True) TrackD3PDFlags.storeVertexAssociation.set_Value_and_Lock(False) TrackD3PDFlags.storeTrackPredictionAtBLayer.set_Value_and_Lock(True) TrackD3PDFlags.storeTrackInfo.set_Value_and_Lock(True) TrackD3PDFlags.storeTrackFitQuality.set_Value_and_Lock(True) TrackD3PDFlags.storeTrackSummary.set_Value_and_Lock(True) TrackD3PDFlags.storeTrackSummary.IDHits = True TrackD3PDFlags.storeTrackSummary.IDHoles = True TrackD3PDFlags.storeTrackSummary.IDSharedHits = True TrackD3PDFlags.storeTrackSummary.IDOutliers = True TrackD3PDFlags.storeTrackSummary.PixelInfoPlus = False TrackD3PDFlags.storeTrackSummary.SCTInfoPlus = False TrackD3PDFlags.storeTrackSummary.TRTInfoPlus = False TrackD3PDFlags.storeTrackSummary.InfoPlus = False TrackD3PDFlags.storeTrackSummary.MuonHits = False TrackD3PDFlags.storeTrackSummary.MuonHoles = False TrackD3PDFlags.storeTrackSummary.ExpectBLayer = True TrackD3PDFlags.storeTrackSummary.HitSum = True TrackD3PDFlags.storeTrackSummary.HoleSum = True TrackD3PDFlags.storeTrackSummary.HitPattern = True TrackD3PDFlags.storeTrackSummary.SiHits = False TrackD3PDFlags.storeTrackSummary.TRTRatio = False TrackD3PDFlags.storeTrackSummary.PixeldEdx = True # HI TrackD3PDFlags.storeTrackSummary.ElectronPID = False TrackD3PDFlags.trackParametersAtGlobalPerigeeLevelOfDetails.set_Value_and_Lock( 3) TrackD3PDFlags.trackParametersAtPrimaryVertexLevelOfDetails.set_Value_and_Lock( 3) TrackD3PDFlags.trackParametersAtBeamSpotLevelOfDetails.set_Value_and_Lock( 3) TrackD3PDFlags.storeTrackUnbiasedIPAtPV.set_Value_and_Lock(False) TrackD3PDFlags.storeTrackMomentum.set_Value_and_Lock(True) TrackD3PDFlags.vertexPositionLevelOfDetails.set_Value_and_Lock(3) TrackD3PDFlags.storeVertexFitQuality.set_Value_and_Lock(True) TrackD3PDFlags.storeVertexKinematics.set_Value_and_Lock(True) TrackD3PDFlags.storeVertexPurity.set_Value_and_Lock( minbiasD3PDflags.doMBTruth()) TrackD3PDFlags.storeVertexTrackAssociation.set_Value_and_Lock(False) TrackD3PDFlags.storeVertexTrackIndexAssociation.set_Value_and_Lock(True) #-- Enhanced vertex info configuration from TrackD3PDMaker.VertexD3PDAnalysisFlags import VertexD3PDAnalysisFlags VertexD3PDAnalysisFlags.useEventInfo = False # No Evt Info reread in Vtx VertexD3PDAnalysisFlags.useTruth = minbiasD3PDflags.doMBTruth() VertexD3PDAnalysisFlags.useAllVertexCollections = True VertexD3PDAnalysisFlags.useTracks = False #Already included in the MinBias D3PD VertexD3PDAnalysisFlags.useBeamspot = False # Already included in the MinBias D3PD VertexD3PDAnalysisFlags.useBackgroundWord = True # Components mostly included, just to be safe VertexD3PDAnalysisFlags.useTrigger = False # Already included in the MinBias D3PD VertexD3PDAnalysisFlags.useSecondaryVertex = False VertexD3PDAnalysisFlags.useMET = False VertexD3PDAnalysisFlags.useElectrons = False VertexD3PDAnalysisFlags.useMuons = False VertexD3PDAnalysisFlags.usePhotons = False VertexD3PDAnalysisFlags.useJets = False VertexD3PDAnalysisFlags.useTaus = False #-- TrackD3PDMaker configuration from TrackD3PDMaker.TruthTrackD3PDObject import TruthTrackD3PDObject from TrackD3PDMaker.TruthVertexD3PDObject import TruthVertexD3PDObject from TrackD3PDMaker.TrackD3PDObject import TrackParticleD3PDObject from TrackD3PDMaker.TrackD3PDObject import PixelTrackD3PDObject from TrackD3PDMaker.TrackD3PDObject import SCTTrackD3PDObject from TrackD3PDMaker.TrackD3PDObject import TRTTrackD3PDObject from TrackD3PDMaker.TrackD3PDObject import ResolvedTracksD3PDObject from TrackD3PDMaker.VertexD3PDObject import PrimaryVertexD3PDObject from TrackD3PDMaker.VertexD3PDObject import BuildVertexD3PDObject SecVertexD3PDObject = BuildVertexD3PDObject( _prefix='secVx_', _label='secVx', _sgkey='SecVertices', trackTarget='trk', trackPrefix='trk_', trackType='Rec::TrackParticleContainer') from TrackD3PDMaker.V0D3PDObject import V0D3PDObject from TrackD3PDMaker.BeamSpotD3PDObject import BeamSpotD3PDObject ## MinBias part from MinBiasD3PDMaker.UnassociatedHitsD3PDObject import UnassociatedHitsD3PDObject if not d3pdalg: d3pdalg = MSMgr.NewRootStream(StreamName=streamname, FileName=file, TreeName=tuplename) ## Add blocks to the tree # d3pdalg += EventInfoD3PDObject(10, prefix='ei_') d3pdalg += EventInfoD3PDObject(10) d3pdalg += TrackParticleD3PDObject(10) d3pdalg += PrimaryVertexD3PDObject(10) if minbiasD3PDflags.doBeamSpot(): d3pdalg += BeamSpotD3PDObject(10) if minbiasD3PDflags.doUnassociatedHits(): d3pdalg += UnassociatedHitsD3PDObject(10) if minbiasD3PDflags.doTrigger(): d3pdalg += CtpRdoD3PDObject(10) d3pdalg += CtpDecisionD3PDObject(10) d3pdalg += MbtsContainerD3PDObject(10) d3pdalg += TrigDecisionD3PDObject(10) addTrigConfMetadata(d3pdalg) if minbiasD3PDflags.doDetailedTrigger(): d3pdalg += BcmRdoD3PDObject(10) d3pdalg += MbtsLvl2D3PDObject(10) d3pdalg += SpLvl2D3PDObject(10) d3pdalg += TrtLvl2D3PDObject(10) d3pdalg += TrkCntsEfD3PDObject(10) if minbiasD3PDflags.doMBTruth(): d3pdalg += TruthTrackD3PDObject(10) d3pdalg += TruthVertexD3PDObject(10) if minbiasD3PDflags.doPixelTracklets(): d3pdalg += PixelTrackD3PDObject(10) if minbiasD3PDflags.doSCTTracklets(): d3pdalg += SCTTrackD3PDObject(10) if minbiasD3PDflags.doTRTTracklets(): d3pdalg += TRTTrackD3PDObject(10) if minbiasD3PDflags.doResolvedTracklets(): d3pdalg += ResolvedTracksD3PDObject(10) if minbiasD3PDflags.doV0s(): d3pdalg += V0D3PDObject(10, sgkey="V0Candidates") d3pdalg += SecVertexD3PDObject(10) if minbiasD3PDflags.doLucid(): from TrigMbD3PDMaker.LucidRawD3PDObject import LucidRawD3PDObject d3pdalg += LucidRawD3PDObject(10) if globalflags.DataSource == 'geant4': from TrigMbD3PDMaker.LucidDigitD3PDObject import LucidDigitD3PDObject d3pdalg += LucidDigitD3PDObject(10) if minbiasD3PDflags.doZDC() and globalflags.DataSource == "data": ##ZDC object from ForwardDetectorsD3PDMaker.ZdcD3PDObject import ZdcD3PDObject from ForwardDetectorsD3PDMaker.ZdcDigitsD3PDObject import ZdcDigitsD3PDObject d3pdalg += ZdcD3PDObject(10) d3pdalg += ZdcDigitsD3PDObject(10) from CaloD3PDMaker.MBTSTimeD3PDObject import MBTSTimeD3PDObject d3pdalg += MBTSTimeD3PDObject(10) from TrackD3PDMaker.VertexGroupD3PD import VertexGroupD3PD VertexGroupD3PD(d3pdalg) def _args(level, name, kwin, **kw): kw = kw.copy() kw['level'] = level for (k, v) in kwin.items(): if k.startswith(name + '_'): kw[k[len(name) + 1:]] = v return kw #-------------------------------------------------------------- # Clusters #-------------------------------------------------------------- from CaloD3PDMaker.ClusterD3PDObject import ClusterD3PDObject if minbiasD3PDflags.doClusterHad(): # define clusters from CaloD3PDMaker import ClusterMomentFillerTool as CMFT myMoments = [ CMFT.CENTER_LAMBDA, 'center_lambda', CMFT.LATERAL, 'lateral', CMFT.LONGITUDINAL, 'longitudinal', CMFT.ISOLATION, 'isolation', CMFT.SIGNIFICANCE, 'significance', CMFT.CELL_SIGNIFICANCE, 'cellSignificance', CMFT.CELL_SIG_SAMPLING, 'cellSigSampling' ] d3pdalg += ClusterD3PDObject(**_args(0, 'CaloCalTopoCluster', kw, prefix='cl_had_', include='Moments', Kinematics_WriteE=True, Moments_Moments=myMoments)) if minbiasD3PDflags.doClusterEM(): d3pdalg += ClusterD3PDObject(**_args(0, 'CaloCalTopoCluster', kw, prefix='cl_em_', Kinematics_WriteE=True, Kinematics_SignalState=0)) #-------------------------------------------------------------- # Alfa #-------------------------------------------------------------- if globalflags.DataSource == "data": IOVDbSvc = Service("IOVDbSvc") from IOVDbSvc.CondDB import conddb ####for other possible servers see dbreplica.config in Athena # #installation # IOVDbSvc.dbConnection="oracle://ATLAS_COOLPROD;schema=ATLAS_COOLOFL_DCS;dbname=COMP200" if not conddb.folderRequested('/RPO/DCS/BLM'): conddb.addFolder("DCS_OFL", "/RPO/DCS/BLM") if not conddb.folderRequested('/RPO/DCS/FECONFIGURATION'): conddb.addFolder("DCS_OFL", "/RPO/DCS/FECONFIGURATION") if not conddb.folderRequested('/RPO/DCS/HVCHANNEL'): conddb.addFolder("DCS_OFL", "/RPO/DCS/HVCHANNEL") if not conddb.folderRequested('/RPO/DCS/LOCALMONITORING'): conddb.addFolder("DCS_OFL", "/RPO/DCS/LOCALMONITORING") if not conddb.folderRequested('/RPO/DCS/MOVEMENT'): conddb.addFolder("DCS_OFL", "/RPO/DCS/MOVEMENT") if not conddb.folderRequested('/RPO/DCS/RADMON'): conddb.addFolder("DCS_OFL", "/RPO/DCS/RADMON") if not conddb.folderRequested('/RPO/DCS/TRIGGERRATES'): conddb.addFolder("DCS_OFL", "/RPO/DCS/TRIGGERRATES") if not conddb.folderRequested('/RPO/DCS/TRIGGERSETTINGS'): conddb.addFolder("DCS_OFL", "/RPO/DCS/TRIGGERSETTINGS") if jobproperties.Rec.doAlfa: from ForwardDetectorsD3PDMaker.AlfaD3PDObject import AlfaD3PDObject # d3pdalg += EventInfoD3PDObject(10) d3pdalg += AlfaD3PDObject(0) from ForwardDetectorsD3PDMaker import AlfaEventHeaderFillerTool if globalflags.DataSource == "data": AlfaEventHeaderFillerTool.DataType = 1 from ForwardDetectorsD3PDMaker.AlfaDCSMetadata import addAlfaDcsMetadata addAlfaDcsMetadata(d3pdalg) elif globalflags.DataSource == "geant4": AlfaEventHeaderFillerTool.DataType = 0