topSequence += myCalibHitToCaloCellAlg_LAr
# myCalibHitToCaloCellAlg_Tile = CalibHitToCaloCellAlg( #OutputLevel = DEBUG,
# CalibHitToCaloCellToolName = myCalibHitToCaloCellTool_Tile )
# topSequence += myCalibHitToCaloCellAlg_Tile
# myCalibHitToCaloCellAlg_DM = CalibHitToCaloCellAlg( OutputLevel = DEBUG,
# CalibHitToCaloCellToolName = myCalibHitToCaloCellTool_DM,
# TruthCaloCellsOutputName = "TruthCellsDM",
# TruthCaloClustersOutputName = "TruthClustersDM",
# CaloCellMakerTools = [ theCaloCellContainerFinalizerTool ] )
# topSequence += myCalibHitToCaloCellAlg_DM
# Create a POOL output file with the StoreGate contents:
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
aodStream = MSMgr.NewPoolStream("StreamAOD",
"myAOD.withTruthClusters.pool.root")
aodStream.EvtConversionSvc = "AthenaPoolCnvSvc"
aodStream.AddItem("CaloCellContainer#*")
aodStream.AddItem("CaloCompactCellContainer#*")
aodStream.AddItem("CaloCalibrationHitContainer#*")
aodStream.AddItem("xAOD::CaloClusterContainer#*")
aodStream.AddItem("xAOD::CaloClusterAuxContainer#*")
aodStream.AddItem("CaloClusterCellLinkContainer#*")
aodStream.AddItem("xAOD::TrackParticleContainer#In*")
aodStream.AddItem("xAOD::TrackParticleAuxContainer#*")
aodStream.AddItem("xAOD::TruthParticleContainer#*")
aodStream.AddItem("xAOD::TruthParticleAuxContainer#*")
aodStream.AddItem("xAOD::ElectronContainer#*")
aodStream.AddItem("xAOD::ElectronAuxContainer#*")
aodStream.Print()
RDOFilePeeker(runArgs, ftkLog) # not sure what it does
# enable the detector flag
from AthenaCommon.DetFlags import DetFlags
DetFlags.all_setOn()
DetFlags.ALFA_setOff()
DetFlags.ZDC_setOff()
# other services
from AthenaCommon.AppMgr import ServiceMgr
from AthenaPoolCnvSvc.AthenaPoolCnvSvcConf import AthenaPoolCnvSvc
ServiceMgr += AthenaPoolCnvSvc()
import AthenaPoolCnvSvc.ReadAthenaPool
ServiceMgr.EventSelector.InputCollections = athenaCommonFlags.FilesInput(
)
# Add the FTK collections to the RDO
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
StreamRDO = AthenaPoolOutputStream("StreamRDO",
runArgs.outputRDO_FTKFile)
#StreamRDO.TakeItemsFromInput=True
StreamRDO.ForceRead = TRUE
StreamRDO.ItemList += ["FTK_RawTrackContainer#*"]
else:
# generate RDO file from scratch, this represents an RDO
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
StreamRDO = MSMgr.NewPoolStream("StreamRDO", runArgs.outputRDO_FTKFile)
StreamRDO.AddItem(["FTK_RawTrackContainer#*"])
StreamRDO.AddItem(["TrigInDetTrackCollection#*"])
else:
ftkLog.error('No output file for merge given')
raise RuntimeError, 'No output file for merge given'
alg += FTKMerger
OutputLevel=DEBUG,
EventInfoName="MyEvent",
dataROOTFileName=localDataFile,
dataROOTHistName="intperbx",
mcROOTFileName=localMCFile,
mcROOTHistName="mu_mc10a")
pass
# ====================================================================
# Define the test DPD output stream
# ====================================================================
# This stream HAS TO start with "StreamD2AODM_"! If the input was an (D)ESD(M), this should start with "StreamD2ESD(M)_".
# See this twiki for more information: https://twiki.cern.ch/twiki/bin/view/AtlasProtected/DPDNamingConvention
fileName = "DAOD_WithPileupWeight.pool.root"
streamName = "DAOD_TEST"
PielupStream = MSMgr.NewPoolStream(streamName, fileName)
# Only events that pass the filters listed below are written out
# AcceptAlgs = logical OR of filters
# RequireAlgs = logical AND of filters
#PileupStream.AcceptAlgs( [""] )
# ---------------------------------------------------
# Add the containers to the output stream
# ---------------------------------------------------
from PrimaryDPDMaker import PrimaryDPD_OutputDefinitions as dpdOutput
# Take all items from the input, except for the ones listed in the excludeList
# If the excludeList is empty, all containers from the input file (e.g. AOD)
# are copied to the output file.
excludeList = ["TrigMuonEFContainer#HLT_MuonEF"]
##
##-----------------------------------------------------------------------------
# ##########################################################################################
# Imports and initial setup
# ##########################################################################################
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
from PrimaryDPDMaker.PrimaryDPDHelpers import buildFileName
from PrimaryDPDMaker.PrimaryDPDFlags import primDPD
from LongLivedParticleDPDMaker.HipsFlags import primHIPsDESD
streamName = primDPD.WriteDESDM_EXOTHIPStream.StreamName
fileName = buildFileName( primDPD.WriteDESDM_EXOTHIPStream )
HIPsStream = MSMgr.NewPoolStream( streamName,fileName )
from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__xAODStringSkimmingTool as skimtool
from DerivationFrameworkCore.DerivationFrameworkCoreConf import DerivationFramework__DerivationKernel as kernel
HIPsFilterNames = [] # Filters should append their final selection algo names to this list
filtersToBookkeep = [] # Not sure what this does?
def HipTriggerSelectionString(flags):
cutString=""
if flags.triggers.__len__() >=1:
cutString+=flags.triggers[0]
if flags.triggers.__len__() >1:
for trigger in flags.triggers[1:]:
minNumberPassed = 1,
chargeMax = 0,
massMin = 30.0*Units.GeV
)
#====================================================================
# Define the test DPD output stream
#====================================================================
from D2PDMaker.D2PDHelpers import buildFileName
# This stream HAS TO start with "StreamD2AODM_"! If the input was an (D)ESD(M), this should start with "StreamD2ESD(M)_".
# See this twiki for more information: https://twiki.cern.ch/twiki/bin/view/AtlasProtected/DPDNamingConvention
streamName = "StreamD2AODM_MyZmumu"
fileName = D2PDFlags.OutputDirectoryName() + "MyD2PDExampleSimpleZmumuStream.pool.root"
ExampleSimpleZmumuStream = MSMgr.NewPoolStream( streamName, fileName )
# Only events that pass the filters listed below are written out
# AcceptAlgs = logical OR of filters
# RequireAlgs = logical AND of filters
ExampleSimpleZmumuStream.AcceptAlgs( ["D2PDParticleCombinerInExampleSimpleZmumuStream_ZmumuBoson"] )
#---------------------------------------------------
# Add the containers to the output stream
#---------------------------------------------------
from PrimaryDPDMaker import PrimaryDPD_OutputDefinitions as dpdOutput
# Take all items from the input, except for the ones listed in the excludeList
# If the excludeList is empty, all containers from the input file (e.g. AOD)
##################
### Output stream
##################
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
from PrimaryDPDMaker.PrimaryDPDHelpers import buildFileName
from PrimaryDPDMaker.PrimaryDPDFlags import primDPD
streamName = primDPD.WriteDESDM_PHOJETStream.StreamName
fileName = buildFileName( primDPD.WriteDESDM_PHOJETStream )
if primDPD.WriteDESDM_PHOJETStream.isVirtual or primDPD.isVirtual() :
StreamDESDM_PHOJET=MSMgr.NewVirtualStream( streamName, fileName )
pass
else:
StreamDESDM_PHOJET=MSMgr.NewPoolStream( streamName, fileName )
pass
StreamDESDM_PHOJET.AddRequireAlgs(["DESDM_PHOJETKernel"])
from PrimaryDPDMaker import PrimaryDPD_OutputDefinitions as dpdOutput
# Take all items from the input, except for the ones listed in the excludeList,
# list should be copied from AllCells but add back the thinned tracking info for egamma
ExcludeList=[]
#dpdOutput.addAllItemsFromInputExceptExcludeList(streamName,ExcludeList)
trackParticleAuxExclusions="-caloExtension.-cellAssociation.-clusterAssociation.-trackParameterCovarianceMatrices.-parameterX.-parameterY.-parameterZ.-parameterPX.-parameterPY.-parameterPZ.-parameterPosition"
trackParticleCollection='TrackParticleCandidate',
inputCollection='MuidMuonCollection')
pass
if D2PDFlags.WriteDAODM_HighMDiJetStream.ApplySlimming:
from PrimaryDPDMaker.PrimaryDPDMakerConf import SlimTrackInfo
thinSeqHighMassDiJetStream += SlimTrackInfo(
"SlimTrackParticlesInHighMassDiJetStream",
thinSvc='ThinningSvc/HighMassDiJetStreamThinning',
TrackPartContName='TrackParticleCandidate')
pass
#====================================================================
# Define the DAODM output stream
#====================================================================
HighMassDiJetStream = MSMgr.NewPoolStream(streamName, fileName)
# Only events that pass the filters listed below are written out
# AcceptAlgs = logical OR of filters
# RequireAlgs = logical AND of filters
HighMassDiJetStream.AcceptAlgs(["StreamHighMassDiJet_AcceptEvent"])
HighMassDiJetStream.AddOtherAlgsToBookkeep(algsToBookkeep)
#---------------------------------------------------
# Add the containers to the output stream
#---------------------------------------------------
from PrimaryDPDMaker import PrimaryDPD_OutputDefinitions as dpdOutput
# Take all items from the input, except for the ones listed in the excludeList
# If the excludeList is empty, all containers from the input file (e.g. AOD)
#from D2PDMaker.SUSYFilters import SetupMuonsStreamFilters #acceptAlgs=SetupMuonsStreamFilters(topSequence) from SUSYD3PDMaker.SUSYTriggerFilters import SetupSUSYTriggerFilters acceptAlgs = SetupSUSYTriggerFilters(topSequence) #==================================================================== # Define the test DPD output stream #==================================================================== from OutputStreamAthenaPool.MultipleStreamManager import MSMgr from D2PDMaker.D2PDHelpers import buildFileName from D2PDMaker.D2PDFlags import D2PDFlags # This stream HAS TO start with "StreamD2AODM_"! If the input was an (D)ESD(M), this should start with "StreamD2ESD(M)_". # See this twiki for more information: https://twiki.cern.ch/twiki/bin/view/AtlasProtected/DPDNamingConvention fileName = buildFileName(D2PDFlags.WriteDAOD_SUSYMuonsStream) streamName = D2PDFlags.WriteDAOD_SUSYMuonsStream.StreamName SUSYMuonStream = MSMgr.NewPoolStream(streamName, fileName) # Only events that pass the filters listed below are written out # AcceptAlgs = logical OR of filters # RequireAlgs = logical AND of filters SUSYMuonStream.AcceptAlgs(acceptAlgs) #--------------------------------------------------- # Add the containers to the output stream #--------------------------------------------------- from PrimaryDPDMaker import PrimaryDPD_OutputDefinitions as dpdOutput # Take all items from the input, except for the ones listed in the excludeList # If the excludeList is empty, all containers from the input file (e.g. AOD) # are copied to the output file. excludeList = [] excludeList = list(set(excludeList)) # This removes dublicates from the list
outputLinkCollection = 'CentralLooseElectronLinkCollectionInElLoose18Stream',
minNumberPassed = 1,
electronIsEM = egammaPID.ElectronLoose,
electronAuthor = egammaParameters.AuthorElectron,
clusterEtMin = 18.0*Units.GeV
)
algsToBookkeep.append( "ElectronLooseSelectorInElLoose18Stream" )
#====================================================================
# Define the test DPD output stream
#====================================================================
ElLoose18Stream = MSMgr.NewPoolStream( streamName, fileName )
# Only events that pass the filters listed below are written out
# AcceptAlgs = logical OR of filters
# RequireAlgs = logical AND of filters
ElLoose18Stream.AcceptAlgs( ["ElectronLooseSelectorInElLoose18Stream"] )
ElLoose18Stream.AddOtherAlgsToBookkeep( algsToBookkeep )
#---------------------------------------------------
# Add the containers to the output stream
#---------------------------------------------------
from PrimaryDPDMaker import PrimaryDPD_OutputDefinitions as dpdOutput
# Take all items from the input, except for the ones listed in the excludeList
# If the excludeList is empty, all containers from the input file (e.g. AOD)
# Imports and initial setup
# ##########################################################################################
# MJF: Needs attention and cleaning up - lots of PrimaryDPDMaker dependencies!
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
from LongLivedParticleDPDMaker.LongLivedDPDFlags import WriteRPVLLStream
from LongLivedParticleDPDMaker.PrimaryDPDFlags_RPVLLStream import primRPVLLDESDM
from PrimaryDPDMaker.PrimaryDPDHelpers import buildFileName
from PrimaryDPDMaker.PrimaryDPDFlags import primDPD
streamName = primDPD.WriteRPVLLStream.StreamName
fileName = buildFileName(primDPD.WriteRPVLLStream)
RPVLL = MSMgr.NewPoolStream(streamName, fileName)
# MJF: Possibly remove if not useful?
if primRPVLLDESDM.prescaleFlags.applyPrescale:
RPVLL.SetPrescale(primRPVLLDESDM.prescaleFlags.prescaleFactor)
RPVLLfilterNames = [
] # Filters should append their final selection algo names to this list
filtersToBookkeep = [] # Not sure what this does?
# ##########################################################################################
# Filter configuration
# ##########################################################################################
## For each analysis, include a job options file that defines the filter
## for that analysis and adds it to the top filter
from xAODEventFormatCnv.xAODEventFormatCnvConf import xAODMaker__EventFormatSvc
fmtsvc = xAODMaker__EventFormatSvc(FormatNames=[
'DataVector<DMTest::C_v1>',
'DMTest::CAuxContainer_v1',
'DMTest::C_v1',
'DMTest::CLinks_v1',
'DataVector<DMTest::CLinks_v1>',
'DMTest::CLinksAuxInfo_v1',
'DMTest::CLinksAuxContainer_v1',
])
ServiceMgr += fmtsvc
# Stream's output file
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
Thinned1_Augmented = MSMgr.NewPoolStream('Thinned1',
'xaodthinned1.root',
asAlg=True,
noTag=True)
Thinned1_Augmented.AddMetaDataItem('xAOD::EventFormat#EventFormat')
Thinned1 = Thinned1_Augmented.GetEventStream()
Thinned1.WritingTool.SubLevelBranchName = '<key>'
# List of DO's to write out
Thinned1.ItemList += fullItemList
ServiceMgr.AthenaPoolCnvSvc.PoolAttributes += ["DEFAULT_SPLITLEVEL='1'"]
# Avoid races when running tests in parallel.
FILECATALOG = 'xAODTestWriteThinned_catalog.xml'
include('DataModelRunTests/commonTrailer.py')
filter2e2mMuid = AthSequencer("H4l_2e2mMuidFilter")
# use sequencer to combine filters for 2e2m
filter2e2mMuid += H4lDPDMaker.H4lMuonFilter("H4l_2MuonMuidFilter",nMu=2,\
pTCuts=[6*Units.GeV,6*Units.GeV],\
etaCuts=[2.5,2.5],\
qualityCuts=["combined+lowpt","combined+lowpt"])
filter2e2mMuid += H4lDPDMaker.H4lElectronFilter("H4l_2ElectronFilter2",nElec=2,\
eTCuts=[6*Units.GeV,6*Units.GeV],\
etaCuts=[2.5,2.5],\
qualityCuts=["Loose","Loose"])
theJob += filter2e2mMuid
# The job starts here!
include("RecExCommon/RecExCommon_topOptions.py")
# define streams
streamOut = MSMgr.NewPoolStream("HSG2_DPD", "HSG2_DPD.pool.root")
streamOut.AcceptAlgs([
"H4l_4ElectronFilter", "H4l_4StacoMuonFilter", "H4l_4MuidMuonFilter",
"H4l_2e2mMuidFilter", "H4l_2e2mStacoFilter"
])
dpdOutHelper.addAllItemsFromInputExceptExcludeList("HSG2_DPD", [])
theApp.EvtMax = 100
outputCollection='MyWmunuLooseWmunuBosonCollection',
minNumberPassed=1,
missingEtMin=20.0 * Units.GeV,
massMin=64.0 * Units.GeV,
massMax=104.0 * Units.GeV)
#====================================================================
# Define the test DPD output stream
#====================================================================
from D2PDMaker.D2PDHelpers import buildFileName
# This stream HAS TO start with "StreamD2AODM_"! If the input was an (D)ESD(M), this should start with "StreamD2ESD(M)_".
# See this twiki for more information: https://twiki.cern.ch/twiki/bin/view/AtlasProtected/DPDNamingConvention
streamName = "StreamD2AODM_Wmunu"
fileName = D2PDFlags.OutputDirectoryName(
) + "MyD2PDExampleSimpleWmunuStream.pool.root"
ExampleSimpleWmunuStream = MSMgr.NewPoolStream(streamName, fileName)
# Only events that pass the filters listed below are written out
# AcceptAlgs = logical OR of filters
# RequireAlgs = logical AND of filters
ExampleSimpleWmunuStream.AcceptAlgs([
"MuonSelectorInExampleSimpleWmunuStream",
"D2PDLeptonNeutrinoCombinerInExampleSimpleWmunuStream_WmunuBoson"
])
#---------------------------------------------------
# Add the containers to the output stream
#---------------------------------------------------
from PrimaryDPDMaker import PrimaryDPD_OutputDefinitions as dpdOutput
# Take all items from the input, except for the ones listed in the excludeList
# Get the AssociationAlgorithm and schedule the AssociationTools
from AnalysisAssociationUtils.AnalysisAssociationUtilsConf import AssociationAlgorithm
topSequence += AssociationAlgorithm(
"ElectronAssociationAlgorithm",
inputCollection="ElectronAODCollection",
associationTools=[ToolSvc.ElectronDeltaRAssociationTool],
outputAssociationCollections=[
"ElectronMCTruthClassifierMatch", "ElectronDeltaRTruthMatch"
],
dumpStoreGate=True)
# This stream HAS TO start with "StreamD2AODM_"! If the input was an (D)ESD(M), this should start with "StreamD2ESD(M)_".
# See this twiki for more information: https://twiki.cern.ch/twiki/bin/view/AtlasProtected/DPDNamingConvention
streamName = "StreamD2AOD_MyMatchTest"
fileName = D2PDFlags.OutputDirectoryName() + "MyMatchTestStream.pool.root"
ExampleMatchStream = MSMgr.NewPoolStream(streamName, fileName)
#---------------------------------------------------
# Add the containers to the output stream
#---------------------------------------------------
from PrimaryDPDMaker import PrimaryDPD_OutputDefinitions as dpdOutput
# Take all items from the input, except for the ones listed in the excludeList
# If the excludeList is empty, all containers from the input file (e.g. AOD)
# are copied to the output file.
excludeList = []
excludeList = list(set(excludeList)) # This removes dublicates from the list
dpdOutput.addAllItemsFromInputExceptExcludeList(streamName, excludeList)
# Add the created match containers to the output file
ExampleMatchStream.AddItem(['INav4MomAssocs#ElectronMCTruthClassifierMatch'])
ExampleMatchStream.AddItem(['INav4MomAssocs#ElectronDeltaRTruthMatch'])
import AthenaCommon.SystemOfUnits as Units
## Include the job property flags for this package and from RecExCommon
from D2PDMaker.D2PDFlags import D2PDFlags
from RecExConfig.RecFlags import rec
## This handels multiple output streams
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
#====================================================================
# Define the test DPD output stream
#====================================================================
from D2PDMaker.D2PDHelpers import buildFileName
streamName = D2PDFlags.WriteExampleSimpleTestStream.StreamName
fileName = buildFileName(D2PDFlags.WriteExampleSimpleTestStream)
ExampleTestStream = MSMgr.NewPoolStream(streamName, fileName)
ExampleTestStream.AddItem('TruthParticleContainer#SpclMC')
ExampleTestStream.AddItem('MissingEtTruth#MET_Truth_PileUp')
ExampleTestStream.AddItem('MissingET#MET_RefFinal')
ExampleTestStream.AddItem('TrigDec::TrigDecision#TrigDecision')
ExampleTestStream.AddItem('MissingEtTruth#MET_Truth')
ExampleTestStream.AddItem('Analysis::MuonContainer#StacoMuonCollection')
ExampleTestStream.AddItem('CTP_Decision#CTP_Decision')
ExampleTestStream.AddItem('EventInfo#*')
ExampleTestStream.AddItem('Analysis::TauJetContainer#TauRecContainer')
ExampleTestStream.AddItem('JetCollection#Cone4TruthJets')
ExampleTestStream.AddItem('JetCollection#AntiKt4TruthJets')
ExampleTestStream.AddItem('JetCollection#Cone4H1TopoJets')
ExampleTestStream.AddItem('JetCollection#AntiKt4H1TopoJets')
ExampleTestStream.AddItem(
# from D2PDMaker.SUSYFilters import SetupEGammaStreamFilters # acceptAlgs=SetupEGammaStreamFilters(topSequence) from SUSYD3PDMaker.SUSYTriggerFilters import SetupSUSYTriggerFilters acceptAlgs = SetupSUSYTriggerFilters(topSequence) #==================================================================== # Define the test DPD output stream #==================================================================== from OutputStreamAthenaPool.MultipleStreamManager import MSMgr from D2PDMaker.D2PDHelpers import buildFileName from D2PDMaker.D2PDFlags import D2PDFlags # This stream HAS TO start with "StreamD2AODM_"! If the input was an (D)ESD(M), this should start with "StreamD2ESD(M)_". # See this twiki for more information: https://twiki.cern.ch/twiki/bin/view/AtlasProtected/DPDNamingConvention fileName = buildFileName(D2PDFlags.WriteDAOD_SUSYEGammaStream) streamName = D2PDFlags.WriteDAOD_SUSYEGammaStream.StreamName SUSYEGammaStream = MSMgr.NewPoolStream(streamName, fileName) # Only events that pass the filters listed below are written out # AcceptAlgs = logical OR of filters # RequireAlgs = logical AND of filters SUSYEGammaStream.AcceptAlgs(acceptAlgs) #--------------------------------------------------- # Add the containers to the output stream #--------------------------------------------------- from PrimaryDPDMaker import PrimaryDPD_OutputDefinitions as dpdOutput # Take all items from the input, except for the ones listed in the excludeList # If the excludeList is empty, all containers from the input file (e.g. AOD) # are copied to the output file. excludeList = [] excludeList = list(set(excludeList)) # This removes dublicates from the list
from RecExConfig.RecFlags import rec
rec.readAOD = True
rec.readRDO = False
from AthenaCommon.GlobalFlags import globalflags
globalflags.DetGeo = 'atlas'
globalflags.DataSource = 'data'
### Trigger Decision Tool
from AthenaCommon.AthenaCommonFlags import athenaCommonFlags
athenaCommonFlags.FilesInput = filelist
from TriggerJobOpts.TriggerFlags import TriggerFlags
TriggerFlags.configurationSourceList = ['ds']
from TriggerJobOpts.TriggerConfigGetter import TriggerConfigGetter
cfg = TriggerConfigGetter()
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
StreamDPD = MSMgr.NewPoolStream(
"StreamDPD", "/dataDisk/Reprocessed/00179939/slimEnhancedBias.pool.root")
StreamDPD.AddMetaDataItem(["IOVMetaDataContainer#*"])
StreamDPD.AddItem(["EventInfo#*"])
StreamDPD.AddItem([
"ElectronContainer#ElectronAODCollection",
"VxContainer#VxPrimaryCandidate", "MissingET#MET_RefFinal",
"egammaContainer#HLT_egamma_Electrons",
"egDetailContainer#HLT_egamma_Electrons", "JetCollection#AntiKt4TopoJets",
"JetMomentMap#AntiKt4TopoJets"
])
StreamDPD.AcceptAlgs(["OfflineElectronSelector"])
theLArRawChannelBuilderADC2EDataBase = LArRawChannelBuilderADC2EDataBase()
theLArRawChannelBuilder.ADCtoEnergyTools = [
theLArRawChannelBuilderADC2EDataBase
]
theLArRawChannelBuilderADC2EDataBase.ADC2MeVTool = theLArADC2MeVTool
theLArRawChannelBuilder += theLArRawChannelBuilderADC2EDataBase
from LArRecUtils.LArRecUtilsConf import LArOFPeakRecoTool
theLArOFPeakRecoTool = LArOFPeakRecoTool()
theLArOFPeakRecoTool.UseShape = True
ToolSvc += theLArOFPeakRecoTool
#"ESD" writing
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
StreamESD_Augmented = MSMgr.NewPoolStream("streamESD",
"esdout.pool.root",
asAlg=True)
StreamESD = StreamESD_Augmented.GetEventStream()
StreamESD.ItemList += ["EventInfo#*", "LArRawChannelContainer#*"]
#CaloD3PD writing
from CaloD3PDMaker.LArDigitD3PDObject import LArDigitD3PDObject
from EventCommonD3PDMaker.EventInfoD3PDObject import EventInfoD3PDObject
alg = MSMgr.NewRootStream("caloD3PD", CafJobOutputs[0])
#alg += EventInfoD3PDObject(10)
alg += LArDigitD3PDObject(2, sgkey="FREE")
#topSequence.caloD3PDAANTStream.ExistDataHeader=False
svcMgr.StoreGateSvc.Dump = True
jdmp2.OutputLevel = INFO
jetalg.Tools += [jdmp2]
ToolSvc += JetDumper("jdmp3")
jdmp3 = ToolSvc.jdmp3
jdmp3.ContainerName = "MyCopiedJets_Kt3Subjets"
jdmp3.Detail = 2
jdmp3.LineDetail = 3
jdmp3.MaxObject = 20
jdmp3.OutputLevel = INFO
jdmp3.ElementLinkMoments += ["Parent"]
jetalg.Tools += [jdmp3]
# Create a POOL output file with the StoreGate contents:
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
xaodStream = MSMgr.NewPoolStream( "StreamXAOD", "xAOD.root" )
# Set up its contents:
xaodStream.AddItem( "xAOD::JetContainer_v1#*" )
xaodStream.AddItem( "xAOD::JetAuxContainer_v1#*" )
xaodStream.AddMetaDataItem( "xAOD::EventFormat_v1#*" )
xaodStream.Print()
# Split all branches:
ServiceMgr.AthenaPoolCnvSvc.PoolAttributes += [
"DEFAULT_SPLITLEVEL='99'" ]
# Force POOL to just simply use the StoreGate keys as branch names:
ServiceMgr.AthenaPoolCnvSvc.SubLevelBranchName = "<key>"
#--------------------------------------------------------------
# Application:
#--------------------------------------------------------------
from DataModelTestDataCommon.DataModelTestDataCommonConf import \
DMTest__xAODTestWriteCInfo, \
DMTest__xAODTestDecor
from DataModelTestDataRead.DataModelTestDataReadConf import \
DMTest__xAODTestFilterCVec
topSequence += DMTest__xAODTestFilterCVec('xAODTestFilterCVec')
topSequence += DMTest__xAODTestWriteCInfo('xAODTestWriteCInfo', Offset=111)
topSequence += DMTest__xAODTestDecor('xAODTestDecor',
DoCVec=False,
DoCTrig=False)
# Stream's output file
Stream1_Augmented = MSMgr.NewPoolStream('Stream1',
'xaoddata_filt.root',
asAlg=True,
noTag=True)
Stream1_Augmented.AddMetaDataItem('xAOD::EventFormat#EventFormat')
Stream1 = Stream1_Augmented.GetEventStream()
Stream1.WritingTool.SubLevelBranchName = '<key>'
Stream1.ItemList += fullItemList # List of DO's to write out
# Avoid races when running tests in parallel.
FILECATALOG = 'xAODTestReadFilter_catalog.xml'
include('DataModelRunTests/commonTrailer.py')
TrackCollectionKey="CombinedMuonTracks")
desdAlignmentTriggerMuonSequence += filAlg_CT
pass
print topSequence
##====================================================================
## Define this Muon DPD output stream
##====================================================================
#WriteMuonAlignmentTriggerStream
streamName = primDPD.WriteDESDM_MSPerfStream.StreamName
fileName = buildFileName(primDPD.WriteDESDM_MSPerfStream)
if primDPD.WriteDESDM_MSPerfStream.isVirtual or primDPD.isVirtual():
AlignmentTriggerMuonStream = MSMgr.NewVirtualStream(streamName, fileName)
pass
else:
AlignmentTriggerMuonStream = MSMgr.NewPoolStream(streamName, fileName)
pass
if primDPDAlignTrigMu.ApplyThinning():
AlignmentTriggerMuonStream.AcceptAlgs(["muonTrkTrackThinTool_MS"])
AlignmentTriggerMuonStream.AcceptAlgs(["muonTrkTrackThinTool_CT"])
pass
if primDPDAlignTrigMu.ApplySkimming():
AlignmentTriggerMuonStream.AcceptAlgs(["EventSkimmingKernel"])
pass
#---------------------------------------------------
# Add the containers to the output stream
#---------------------------------------------------
#old way
#AlignmentTriggerMuonStream.Stream.TakeItemsFromInput = True
pTCuts=[0,10*Units.GeV],\
eTCuts=[10*Units.GeV,0],\
qualityCuts=["Loose","inMS"],\
types=["e","mu"],\
collections=["RobustLooseElectronCollection","MuidMuonCollection"],\
mass=5*Units.GeV)
theJob += mixedFilterStaco
theJob += mixedFilterMuid
# The job starts here!
rec.AutoConfiguration.append('FieldAndGeo')
#rec.AutoConfiguration.append('BeamType')
rec.AutoConfiguration.append('ConditionsTag')
rec.AutoConfiguration.append('RealOrSim')
include("RecExCommon/RecExCommon_topOptions.py")
# define streams
streamOut = MSMgr.NewPoolStream(
"HSG2_DPD", "/tmp/disimone/HSG2_DAOD_2lskim.00142383._000001.pool.root")
streamOut.AcceptAlgs([
"H4l_2ElectronFilter", "H4l_2StacoMuonFilter", "H4l_2MuidMuonFilter",
"H4lMixedFilterStaco", "H4lMixedFilterMuid"
])
dpdOutHelper.addAllItemsFromInputExceptExcludeList("HSG2_DPD", [])
theApp.EvtMax = 1000
'ViewVector<DataVector<DMTest::C_v1,DataModel_detail::NoBase> >',
'DMTest::C_v1',
'DMTest::CInfoAuxContainer_v1',
'DataVector<DMTest::G_v1>',
'DMTest::GAuxContainer_v1',
'DMTest::G_v1',
'DMTest::H_v1',
'DataVector<DMTest::H_v1>',
'ViewVector<DataVector<DMTest::H_v1,DataModel_detail::NoBase> >',
'DMTest::HAuxContainer_v1',
])
ServiceMgr += fmtsvc
# Stream's output file
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
Stream1_Augmented = MSMgr.NewPoolStream('Stream1', 'xaoddata.root', asAlg=True)
Stream1_Augmented.AddMetaDataItem('xAOD::EventFormat#EventFormat')
Stream1 = Stream1_Augmented.GetEventStream()
Stream1.WritingTool.SubLevelBranchName = '<key>'
# List of DO's to write out
Stream1.ItemList += fullItemList
ServiceMgr.AthenaPoolCnvSvc.PoolAttributes += ["DEFAULT_SPLITLEVEL='1'"]
#--------------------------------------------------------------
# Set output level threshold (2=DEBUG, 3=INFO, 4=WARNING, 5=ERROR, 6=FATAL )
#--------------------------------------------------------------
svcMgr.MessageSvc.OutputLevel = 3
svcMgr.MessageSvc.debugLimit = 100000
svcMgr.ClassIDSvc.OutputLevel = 3
# No stats printout
# Set up the reading of the input xAOD:
import AthenaPoolCnvSvc.ReadAthenaPool
svcMgr.EventSelector.InputCollections = ["xAOD.pool.root"]
# Access the algorithm sequence:
from AthenaCommon.AlgSequence import AlgSequence
theJob = AlgSequence()
from DerivationFrameworkMCTruth.DerivationFrameworkMCTruthConf import DerivationFramework__xAODtoHepMCCnvAlg
alg2 = DerivationFramework__xAODtoHepMCCnvAlg()
alg2.OutputLevel = INFO
theJob += alg2
# Do some additional tweaking:
from AthenaCommon.AppMgr import theApp
theApp.EvtMax = -1
ServiceMgr.MessageSvc.OutputLevel = INFO
ServiceMgr.MessageSvc.defaultLimit = 1000000
# Output
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
hepmcStream = MSMgr.NewPoolStream("StreamAOD", "test.pool.root")
# Additional type(s) created automatically by RecExCommon:
hepmcStream.AddItem("McEventCollection#McEventCollectionFromXAOD")
hepmcStream.AddItem("xAOD::TruthParticleContainer_v1#TruthParticle")
hepmcStream.AddItem("xAOD::TruthParticleAuxContainer_v1#TruthParticleAux.")
hepmcStream.AddItem("xAOD::TruthEventContainer_v1#TruthEvent")
hepmcStream.AddItem("xAOD::TruthEventAuxContainer_v1#TruthEventAux.")
hepmcStream.AddItem("xAOD::TruthVertexContainer_v1#TruthVertex")
hepmcStream.AddItem("xAOD::TruthVertexAuxContainer_v1#TruthVertexAux.")
combination_daod_2l = algsList[iAlg]
else:
combination_daod_2l += " or " + algsList[iAlg]
totalDecision_daod_2l = LogicalFilterCombiner("HSG2_2LDAODFilter",
cmdstring=combination_daod_2l)
theJob += totalDecision_daod_2l
## This handles multiple output streams
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
from PrimaryDPDMaker import PrimaryDPD_OutputDefinitions as dpdOutHelper
# define streams
from AthenaCommon.JobProperties import jobproperties
prodFlags = jobproperties.D2PDFlags
from PrimaryDPDMaker.PrimaryDPDHelpers import buildFileName
# Construct the stream and file names for the jp:
streamName = prodFlags.WriteDAOD_2LHSG2Stream.StreamName
fileName = buildFileName(prodFlags.WriteDAOD_2LHSG2Stream)
#streamOut = MSMgr.NewPoolStream("StreamDAOD_2LHSG2",runArgs.outputDAOD_2LHSG2File)
streamOut_daod_2l = MSMgr.NewPoolStream(streamName, fileName)
streamOut_daod_2l.AcceptAlgs([totalDecision_daod_2l.getName()])
streamOut_daod_2l.AddOtherAlgsToBookkeep(algsList)
dpdOutHelper.addAllItemsFromInputExceptExcludeList(streamName, [])
streamOut_daod_2l.AddMetaDataItem("EventBookkeeperCollection#*")
FTK_RDO_Creator.pmap_path = ftkBaseConfigDir + '/map_files/raw_12Libl.pmap'
FTK_RDO_Creator.loadHWConf_path = ftkBaseConfigDir + '/hwsdev_file/raw_12L.hw'
# The presence of the option FinalMerge
if FTK_MergeFromTowers:
FTK_RDO_Creator.NSubRegions = 1
FTK_RDO_Creator.FTKUnmergedFormatName = "FTKMergedTracksStream%u"
else:
FTK_RDO_Creator.NSubRegions = 4
# set a meaningful name for the PerfMon file
pmjp.PerfMonFlags.OutputFile = 'ntuple_FTKMerge.pmon.gz'
FTK_RDO_Creator.FTKToMergePaths = inputNTUP_FTKTMPFile
FTK_RDO_Creator.FTKMergedOutput = outputNTUP_FTKFile
alg += FTK_RDO_Creator
#StreamRDO = AthenaPoolOutputStream ( "StreamRDO" )
#StreamRDO.OutputFile = "InDetRecRDO.root"
#StreamRDO.ItemList += ['FTK_RawTrackContainer#*']
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
StreamRDO = MSMgr.NewPoolStream("StreamRDO", outputRDOfile)
StreamRDO.AddMetaDataItem(["IOVMetaDataContainer#*"])
#StreamRDO.AddItem( ["DataVector<FTK_RawTrack>#FTK_RDO_Tracks"] )
StreamRDO.AddItem(["FTK_RawTrackContainer#*"])
from RecExConfig.ObjKeyStore import objKeyStore
objKeyStore.addStreamRDO("FTK_RawTrackContainer", "FTK_RDO_Tracks")
# Set up the reading of a file:
FNAME = "AOD.pool.root"
include("AthenaPython/iread_file.py")
# Access the algorithm sequence:
from AthenaCommon.AlgSequence import AlgSequence
theJob = AlgSequence()
# Create a logger object:
from AthenaCommon.Logging import logging
logger = logging.getLogger("xAODTriggerCnv_jobOptions")
# Create a POOL output file with the StoreGate contents:
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
xaodStream = MSMgr.NewPoolStream("StreamAOD", "xAOD.pool.root")
# Create the xAOD RoIs:
from xAODTriggerCnv.xAODRoICreator import xAODRoICreator
xAODRoICreator()
# Create the xAOD trigger decision:
from xAODTriggerCnv.xAODTrigDecisionCreator import xAODTrigDecisionCreator
xAODTrigDecisionCreator()
# Add bunch configuration metadata to the file:
from xAODTriggerCnv.xAODBunchConfCreator import xAODBunchConfCreator
xAODBunchConfCreator()
# Additional type(s) created automatically by RecExCommon:
xaodStream.AddItem("xAOD::EventInfo_v1#EventInfo")
#from D2PDMaker.SUSYFilters import SetupJetsStreamFilters #acceptAlgs=SetupJetsStreamFilters(topSequence) from SUSYD3PDMaker.SUSYTriggerFilters import SetupSUSYTriggerFilters acceptAlgs = SetupSUSYTriggerFilters(topSequence) #==================================================================== # Define the test DPD output stream #==================================================================== from OutputStreamAthenaPool.MultipleStreamManager import MSMgr from D2PDMaker.D2PDHelpers import buildFileName from D2PDMaker.D2PDFlags import D2PDFlags # This stream HAS TO start with "StreamD2AODM_"! If the input was an (D)ESD(M), this should start with "StreamD2ESD(M)_". # See this twiki for more information: https://twiki.cern.ch/twiki/bin/view/AtlasProtected/DPDNamingConvention fileName = buildFileName(D2PDFlags.WriteDAOD_SUSYJetsStream) streamName = D2PDFlags.WriteDAOD_SUSYJetsStream.StreamName SUSYJetStream = MSMgr.NewPoolStream(streamName, fileName) # Only events that pass the filters listed below are written out # AcceptAlgs = logical OR of filters # RequireAlgs = logical AND of filters SUSYJetStream.AcceptAlgs(acceptAlgs) #--------------------------------------------------- # Add the containers to the output stream #--------------------------------------------------- from PrimaryDPDMaker import PrimaryDPD_OutputDefinitions as dpdOutput # Take all items from the input, except for the ones listed in the excludeList # If the excludeList is empty, all containers from the input file (e.g. AOD) # are copied to the output file. excludeList = [] dpdOutput.addAllItemsFromInputExceptExcludeList(streamName, excludeList)
mixedFilterMuid=H4lDPDMaker.H4lMixedFilter("H4lMixedFilterMuid", nLept=2,\
pTCuts=[0,10*Units.GeV],\
eTCuts=[10*Units.GeV,0],\
qualityCuts=[eQual,muQual],\
types=["e","mu"],\
collections=["RobustLooseElectronCollection","MuidMuonCollection"],\
mass=5*Units.GeV)
theJob += mixedFilterStaco
theJob += mixedFilterMuid
# The job starts here!
rec.AutoConfiguration.append('FieldAndGeo')
#rec.AutoConfiguration.append('BeamType')
rec.AutoConfiguration.append('ConditionsTag')
rec.AutoConfiguration.append('RealOrSim')
include("RecExCommon/RecExCommon_topOptions.py")
# define streams
streamOut = MSMgr.NewPoolStream("HSG2_DPD", OutputFile2L)
streamOut.AcceptAlgs([
"H4l_2ElectronFilter", "H4l_2StacoMuonFilter", "H4l_2MuidMuonFilter",
"H4lMixedFilterStaco", "H4lMixedFilterMuid"
])
dpdOutHelper.addAllItemsFromInputExceptExcludeList("HSG2_DPD", [])
theApp.EvtMax = evtMax
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
from PyUtils.MetaReaderPeeker import convert_itemList
inputObjects = convert_itemList(layout=None)
def __addInput(stream, skip=[]):
for element in inputObjects:
type_key = "%s#%s" % element
if type_key not in skip:
stream.AddItem(type_key)
elStream = MSMgr.NewPoolStream('elXAODStream', 'elXAOD.pool.root')
__addInput(elStream)
phStream = MSMgr.NewPoolRootStream('phXAODStream', 'phXAOD.pool.root')
tauStream = MSMgr.NewPoolRootStream('tauXAODStream', 'tauXAOD.pool.root')
from TrigNavTools.TrigNavToolsConfig import navigationThinningSvc
from DerivationFrameworkCore.DerivationFrameworkCoreConf import DerivationFramework__DerivationKernel
dk = DerivationFramework__DerivationKernel()
tokeep = {
'electron': [
'HLT_TrigElectronContainer_L2ElectronFex',
'HLT_TrigElectronContainer_L2IDCaloFex',
'HLT_xAOD__TrigElectronContainer_L2ElectronFex',
