topSequence = AlgSequence()

from Pythia_i.Pythia_iConf import Pythia
topSequence += Pythia()

#-------------------------------------------------------------
# define your physics process here
# Declare the Pythia to be the Generator to be used
topSequence.Pythia.PythiaCommand += ["pysubs msel 6"]
#selection of the subprocess gg -> ttbar
topSequence.Pythia.PythiaCommand += ["pysubs msub 81 1"]
topSequence.Pythia.PythiaCommand += ["pysubs msub 82 1"]

#-------------------------------------------------------------

#-------------------------------------------------------------
# Pool Persistency
#-------------------------------------------------------------
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream

# EventInfo Converters
include("EventAthenaPool/EventAthenaPool_joboptions.py")
PoolSvc = Service("PoolSvc")
Stream1 = AthenaPoolOutputStream("Stream1")
Stream1.ItemList += ["EventInfo#*"]
Stream1.ItemList += ["McEventCollection#*"]
Stream1.ForceRead = TRUE
Stream1.OutputFile = "McEvent.root"
#PoolSvc.Output    = "McEvent.root"
#==============================================================
Exemplo n.º 2
0
#theApp.Dlls                += [ "RootHistCnv" ]
# Change the following line to "ROOT" for ROOT persistency
theApp.HistogramPersistency = "ROOT"
#--------------------------------------------------------------
# NTuple output file
#--------------------------------------------------------------
#RootHistSvc = Service( "RootHistSvc" )
#HbookHistSvc.NPAWC = 1500000
#HistogramPersistencySvc = Service( "HistogramPersistencySvc" )
#HistogramPersistencySvc.OutputFile  = "histo.root"
svcMgr.NTupleSvc.Output = [ "FILE1  DATAFILE='pythiaB.root'  OPT='NEW'  TYP='ROOT'" ]

###############################################################
# Add POOL persistency

from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
include( "GeneratorObjectsAthenaPool/GeneratorObjectsAthenaPool_joboptions.py" )

Stream1 = AthenaPoolOutputStream( "Stream1" )
Stream1.OutputFile = "pythiaB.pool.root"
# 2101 = EventInfo
# 133273 = MCTruth (HepMC)
Stream1.ItemList += [ "2101#*", "133273#*" ]
Stream1.AcceptAlgs = [ "BSignalFilter" ]

#==============================================================
#
# End of job options file
#
###############################################################
    0.01, 0.01, 56.0
]  # mm  x, y, z. Default taken from: Simulation/G4Sim/MCTruth/MCTruth/VertexPositioner.hh
EventBoost.GaussianMean += [0.0, 0.0, 0.0]  # mm  x, y, z
EventBoost.DoFlatVertexSmearing = False
EventBoost.FlatSmearingBoundaryMin += [-0.01, -0.01, -0.01]  #mm  x, y, z
EventBoost.FlatSmearingBoundaryMax += [0.01, 0.01, 0.01]  #mm  x, y, z
EventBoost.OutputLevel = 3

######### Streams & persistency #########
##################################################
# Setup output stream.                           #
##################################################
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
myOutStream = AthenaPoolOutputStream("myOutStream")
myOutStream.EvtConversionSvc = "AthenaPoolCnvSvc"
myOutStream.OutputFile = "boosted.pool.root"
myOutStream.ItemList += ["EventInfo#*", "McEventCollection#*"]
myOutStream.ForceRead = TRUE

##################################################
# Do consistency checks                          #
##################################################

#from TruthExamples.TruthExamplesConf import TestHepMC
#job += TestHepMC()
#job.TestHepMC.EnergyDifference = 0.001*GeV # tolerance on energy conservation
#job.TestHepMC.OutputLevel = WARNING

##################################################
# Make CBNT                                      #
##################################################
#--------------------------------------------------------------
# JobOptions for the loading of the AthenaSealSvc
#--------------------------------------------------------------

# Check the dictionary in memory for completeness
#include( "AthenaSealSvc/AthenaSealSvc_joboptions.py" )
svcMgr.AthenaSealSvc.CheckDictionary = True

#--------------------------------------------------------------
# Output options
#--------------------------------------------------------------

# Stream's output file
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
Stream1 = AthenaPoolOutputStream("Stream1")
Stream1.OutputFile = "SimplePoolFile.root"
# List of DO's to write out
Stream1.ItemList += ["CaloCellContainer#*"]
Stream1.ItemList += ["EventInfo#*"]
#--------------------------------------------------------------
# Set output level threshold (2=DEBUG, 3=INFO, 4=WARNING, 5=ERROR, 6=FATAL )
#--------------------------------------------------------------

svcMgr.MessageSvc.OutputLevel = WARNING
svcMgr.MessageSvc.debugLimit = 100000
svcMgr.MessageSvc.errorLimit = 100000
#svcMgr.ClassIDSvc.OutputLevel     = DEBUG
LArCellContFakeWriter.OutputLevel = DEBUG

AthenaEventLoopMgr = Service("AthenaEventLoopMgr")
AthenaEventLoopMgr.OutputLevel = INFO
#--------------------------------------------------------------
# Private Application Configuration options
#--------------------------------------------------------------

## schedule a noop algorithm: it just print where it is
from PerfMonTests.PerfMonTestsConf import PerfMonTest__NoopAlg
topSequence += PerfMonTest__NoopAlg("NoopAlg")

#---------------------------------------------------------------
# Pool Persistency
#---------------------------------------------------------------
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
outStream = AthenaPoolOutputStream("OutStream")
outStream.ItemList = ["EventInfo#McEventInfo"]

if not 'OUTPUT' in dir():
    OUTPUT = "my.data.pool"
    pass
outStream.OutputFile = OUTPUT

## somehow better configure the AthenaPoolCnvSvc for our small
## persistency output job
svcMgr.AthenaPoolCnvSvc.CommitInterval = 1000

svcMgr.MessageSvc.OutputLevel = ERROR
#==============================================================
#
# End of job options file
#
###############################################################
myAtRndmGenSvc.EventReseeding = False
ServiceMgr += myAtRndmGenSvc

## Add an action
from G4AtlasApps.SimFlags import simFlags
simFlags.OptionalUserActionList.addAction(
    'G4UA::MaterialStepRecorderTool'['Run', 'Event', 'Step'])

############### The Material hit collection ##################

from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
# --- check dictionary
ServiceMgr.AthenaSealSvc.CheckDictionary = True
# --- commit interval (test)
ServiceMgr.AthenaPoolCnvSvc.OutputLevel = DEBUG
ServiceMgr.AthenaPoolCnvSvc.CommitInterval = 10
MaterialStream = AthenaPoolOutputStream('MaterialStream')
MaterialStream.OutputFile = "MaterialStepCollection.root"
MaterialStream.ItemList += ['Trk::MaterialStepCollection#*']

##############################################################

include("G4AtlasApps/G4Atlas.flat.configuration.py")

## Populate alg sequence
from AthenaCommon.CfgGetter import getAlgorithm
topSeq += getAlgorithm("G4AtlasAlg", tryDefaultConfigurable=True)

include("InDetSLHC_Example/postInclude.SLHC_Setup.py")
#--- End jobOptions.GeantinoMapping.py file  ------------------------------
Exemplo n.º 7
0
from AthenaServices.AthenaServicesConf import ToyNextPassFilterTool
ToolSvc += ToyNextPassFilterTool(NPasses=3)

#services that need to be reinit
ServiceMgr.MultipleEventLoopMgr.ToBeReinitialized = ["StoreGateSvc", "DetectorStore"]

#
# I/O stuff
#
ServiceMgr.EventSelector.InputCollections = [     
    "root://eosatlas.cern.ch//eos/atlas/atlascerngroupdisk/proj-sit/digitization/RTT/mc10/mc10_7TeV.005008.CavernInput.merge.HITS.e4_e607_s951_s952_tid170551_00/HITS.170551._000011.pool.root.1" ]

include( "AthenaPoolCnvSvc/WriteAthenaPool_jobOptions.py" )
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
Stream1 = AthenaPoolOutputStream( "Stream1" )
Stream1.OutputFile = "MultiplePassFile.root"; # ** mandatory parameter ** // The output file name
Stream1.ItemList=["EventInfo#*", "McEventCollection#*"]

#--------------------------------------------------------------
#--- Monitoring and Debug printouts
#--------------------------------------------------------------

MessageSvc.OutputLevel      = INFO
Stream1.OutputLevel = DEBUG
#StoreGateSvc.Dump=1
#StoreGateSvc.OutputLevel=DEBUG

from AthenaCommon.AppMgr import theAuditorSvc
from GaudiAud.GaudiAudConf import ChronoAuditor
theAuditorSvc += ChronoAuditor()
from AthenaCommon.AppMgr import ServiceMgr
if not hasattr(ServiceMgr, 'PileUpMergeSvc'):
    from PileUpTools.PileUpToolsConf import PileUpMergeSvc
    ServiceMgr += PileUpMergeSvc()


# Pool input (Change this to use a different file)
from AthenaCommon.AppMgr import ServiceMgr
if not hasattr(ServiceMgr, 'EventSelector'):
   import AthenaPoolCnvSvc.ReadAthenaPool
ServiceMgr.EventSelector.InputCollections = PoolHitsInput

# Pool Output
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
Stream1 = AthenaPoolOutputStream("Stream1")
Stream1.OutputFile = PoolHITsOutput
Stream1.ItemList+=["EventInfo#*"];
Stream1.ItemList+=["LArHitContainer#*"];


# the LAr and Calo detector description package
include( "CaloDetMgrDetDescrCnv/CaloDetMgrDetDescrCnv_joboptions.py" )
include( "LArDetMgrDetDescrCnv/LArDetMgrDetDescrCnv_joboptions.py" )
# Pool Converters
include( "LArAthenaPool/LArAthenaPool_joboptions.py" )

#algorithm
from AthenaCommon.AlgSequence import AlgSequence 
topSequence = AlgSequence()

from LArDigitization.LArDigitizationConf import LArHitMerger
Exemplo n.º 9
0
#--------------------------------------------------------------
# AthenaRoot Persistency
#--------------------------------------------------------------
include('GeneratorObjectsAthenaPool/GeneratorObjectsAthenaPool_joboptions.py')
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
Stream1 = AthenaPoolOutputStream("Stream1")
# 2101   == EventInfo
# 133273 == MC Truth (HepMC)
# 54790518 == HijigEventParams
Stream1.ItemList += ["2101#*"]
Stream1.ItemList += ["133273#*"]
Stream1.ItemList += ["54790518#*"]
Stream1.OutputFile = "hijing.flow.p_pb.pool.root"

#==============================================================
#
# End of job options file
#
###############################################################
Exemplo n.º 10
0
topSequence += ObjectThinner

####### If the data contains the Truth, then do this, uncomment this lines
# Make Truth Jet on the Fly if there is truth in this data
#from JetRec.JetGetters import *
#from JetRec.JetRecFlags import jetFlags
#jetFlags.inputFileType = 'GEN'
#make_StandardJetGetter('Cone',0.4,'Truth').jetAlgorithmHandle()

# Slim the McEventCollection
#include ( "DPDUtils/TruthSlimming.py" )
#################### End the treatment of the Truth ########

from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
StreamDPD = AthenaPoolOutputStream("StreamDPD")
StreamDPD.OutputFile = "D2PD.pool.root"

#Metadata and luminosity block
StreamDPD.ItemList += ["IOVMetaDataContainer#*"]
StreamDPD.ItemList += ["LumiBlockCollection#*"]

#Event Level
StreamDPD.ItemList += ['EventInfo#*']
StreamDPD.ItemList += ['PileUpEventInfo#*']
StreamDPD.ItemList += ['EventStreamInfo#*']
StreamDPD.ItemList += ['MergedEventInfo#*']

# Inner Detector TrackParticles -
# for Inner detector TrackParticles associated to Electrons/Photons/Muons/TauJets
StreamDPD.ItemList += ['Rec::TrackParticleContainer#TrackParticleCandidate']
Exemplo n.º 11
0
    FTKDumpCond = FTKDumpCondAlgo("FTKDumpCondAlgo" , OutputLevel=INFO)
    FTKDumpCond.IBLMode = runArgs.IBLMode
    FTKDumpCond.DumpBadModules = False
    FTKDumpCond.DumpGlobalToLocalMap = False
    FTKDumpCond.DumpModulePositions = True

    alg += FTKDumpCond

else :
    alg += FTKRoadFinder
    alg += FTKTrackFitter

if not FTKTrackFitter.doTrackFile :
    from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
    Stream1 = AthenaPoolOutputStream( "Stream1" )
    Stream1.OutputFile = "FTKSimulationOutput.pool.root"
    Stream1.ItemList += [
        "FTKAthTrackContainer#*",
        "FTKTrackFitterStats#*",
        "TrigInDetTrackCollection#*"
        ]

## Post-include
if hasattr(runArgs,"postInclude"):
    for fragment in runArgs.postInclude:
        include(fragment)

## Post-exec
if hasattr(runArgs,"postExec"):
    ftkLog.info("transform post-exec")
    for cmd in runArgs.postExec:
Exemplo n.º 12
0
    AANTupleStream.ExistDataHeader = False
    AANTupleStream.OutputLevel = VERBOSE

HistogramPersistencySvc = Service("HistogramPersistencySvc")
HistogramPersistencySvc.OutputFile = "histo.root"

#---------------------------------------------------------------
# Pool Persistency
#---------------------------------------------------------------

if not doNotWritePOOL:
    from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
    include(
        "GeneratorObjectsAthenaPool/GeneratorObjectsAthenaPool_joboptions.py")

    Stream1 = AthenaPoolOutputStream("Stream1")
    Stream1.OutputFile = "athena.evgen.root"
    # 2101 = EventInfo
    # 133273 = MCTruth (HepMC)
    Stream1.ItemList += ["2101#*", "133273#*"]
    Stream1.AcceptAlgs = ["BSignalFilter"]

    include("AthenaSealSvc/AthenaSealSvc_joboptions.py")
    AthenaSealSvc.CheckDictionary = TRUE

#==============================================================
#
# End of job options file
#
###############################################################
#services that need to be reinit
ServiceMgr.MultipleEventLoopMgr.ToBeReinitialized = ["StoreGateSvc", "DetectorStore"]

#
# I/O stuff
#
ServiceMgr.EventSelector.InputCollections = [
    "root://eosatlas//eos/atlas/atlascerngroupdisk/proj-sit/digitization/RTT/mc10/mc10_7TeV.005008.CavernInput.merge.HITS.e4_e607_s951_s952_tid170551_00/HITS.170551._000011.pool.root.1" ]
# Set up for seeking.
ServiceMgr.EventSelector.CollectionType = "SeekableROOT"

include( "AthenaPoolCnvSvc/WriteAthenaPool_jobOptions.py" )
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
Stream1 = AthenaPoolOutputStream( "Stream1" )
Stream1.OutputFile = "MultiplePassFile.root"; # ** mandatory parameter ** // The output file name
Stream1.ForceRead=TRUE  #force read of output data objs
Stream1.ItemList=["EventInfo#*", "McEventCollection#*"]

#--------------------------------------------------------------
#--- Monitoring and Debug printouts
#--------------------------------------------------------------

MessageSvc.OutputLevel      = INFO
Stream1.OutputLevel = DEBUG
#StoreGateSvc.Dump=1
#StoreGateSvc.OutputLevel=DEBUG

from AthenaCommon.AppMgr import theAuditorSvc
from GaudiAud.GaudiAudConf import ChronoAuditor
theAuditorSvc += ChronoAuditor()
#--------------------------------------------------------------
# Output options
# LAr Hit
# Converters:
include("EventAthenaPool/EventAthenaPool_joboptions.py")
#include( "AFP_EventAthenaPool/AFP_EventAthenaPool_joboptions.py" )

# ItemList:
include("EventAthenaPool/EventAthenaPoolItemList_joboptions.py")
#include( "AFP_EventAthenaPool/AFP_EventAthenaPoolItemList_joboptions.py" )

print fullItemList

from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
Stream1 = AthenaPoolOutputStream("Stream1")
Stream1.OutputFile = strOutputRootFile

# List of DO's to write out - we don't use fullItemList, just list a
# few we want
#Stream1.ItemList   += fullItemList
Stream1.ItemList += ["EventInfo#*",
                     "McEventCollection#TruthEvent"]  # mc truth (hepmc)
#Stream1.ItemList+= ["AFP_TDDigiCollection#*"]
Stream1.ItemList += ["AFP_TDLocRecoEvCollection#*"]
#Stream1.ItemList+= ["AFP_SiDigiCollection#*"]
Stream1.ItemList += ["AFP_SIDLocRecoEvCollection#*"]

#--------------------------------------------------------------
# Set output level threshold (2=DEBUG, 3=INFO, 4=WARNING, 5=ERROR, 6=FATAL )
MessageSvc = Service("MessageSvc")
MessageSvc.OutputLevel = 3
Exemplo n.º 15
0
    "zLimits -4000. 4000.",  # required for shape=cylinder 
    #  "ptLimits 0. 0.",       # lower and upper limits.  The upper limit is optional
    #  "phiLimits 0. 0.",      # lower and upper limits.  The upper limit is optional
    #  "etaLimits 0. 0.",      # lower and upper limits.  The upper limit is optional
    "rLimits 650. 1950."
]  # required for shape=cylinder
#  "weightLimits 0. 0."]   # lower and upper limits.  The upper limit is optional

topSequence += BeamHaloGenerator
print BeamHaloGenerator

# Required when monitoring plots are enabled.
theApp.HistogramPersistency = "ROOT"

if not hasattr(ServiceMgr, 'THistSvc'):
    from GaudiSvc.GaudiSvcConf import THistSvc
    ServiceMgr += THistSvc()

ServiceMgr.THistSvc.Output += [
    "BeamHalo DATAFILE='BeamHalo.root' OPT='RECREATE'"
]

# For debugging
from TruthExamples.TruthExamplesConf import DumpMC
topSequence += DumpMC()

from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
Stream1 = AthenaPoolOutputStream("StreamEVGEN")
Stream1.OutputFile = "evgen.pool.root"
Stream1.ItemList += ['EventInfo#*', 'McEventCollection#*']
Exemplo n.º 16
0
StreamDPD.ItemList =  ['EventInfo#*', 'TrackRecordCollection#*']
StreamDPD.ItemList += ['ElectronContainer#ElectronAODCollection']
StreamDPD.ItemList += ['egDetailContainer#egDetailAOD']
StreamDPD.ItemList += ['MissingET#MET_RefFinal']
StreamDPD.ItemList += ['MissingET#MET_LocHadObj']
StreamDPD.ItemList += ['CaloClusterContainer#CaloCalTopoCluster']
StreamDPD.ItemList += ['Analysis::MuonContainer#StacoMuonCollection']
StreamDPD.ItemList += ['JetCollection#Kt4LCTopoJets']
StreamDPD.ItemList += ['JetKeyDescriptor#JetKeyMap']
StreamDPD.ItemList += ['JetCollection#Kt4TruthJets']
StreamDPD.ItemList += ['Rec::TrackParticleContainer#TrackParticleCandidate']
StreamDPD.ItemList += ['Rec::TrackParticleContainer#StacoTrackParticles']
StreamDPD.ItemList += ['TruthParticleContainer#SpclMC']
StreamDPD.ItemList += ['McEventCollection#GEN_AOD']

StreamDPD.OutputFile = "SkimmedThin.AOD.pool.root"
#StreamDPD.OutputFile = outFileName
StreamDPD.ForceRead=TRUE;  #force read of output data objs
StreamDPD.AcceptAlgs=["ttbarFilter"]


ChronoStatSvc = Service( "ChronoStatSvc" )
ChronoStatSvc.ChronoDestinationCout = True

ChronoStatSvc.PrintUserTime     = True
ChronoStatSvc.PrintSystemTime   = True
ChronoStatSvc.PrintEllapsedTime = True
AthenaPoolCnvSvc = Service( "AthenaPoolCnvSvc" )
AthenaPoolCnvSvc.UseDetailChronoStat = True

MessageSvc = Service("MessageSvc")
Exemplo n.º 17
0
if not hasattr(ServiceMgr, 'EventSelector'):
    import AthenaPoolCnvSvc.ReadAthenaPool

ServiceMgr.EventSelector.InputCollections = PoolHitsInput

ServiceMgr.EventSelector.SkipEvents = SkipEvents

if DetFlags.writeRDOPool.any_on():
    # Pool Output
    from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
    Stream1 = AthenaPoolOutputStream("Stream1")
    Stream1.ItemList += ["EventInfo#*"]
    Stream1.ItemList += ["TBEventInfo#*"]
    Stream1.ItemList += ["McEventCollection#*"]

    Stream1.OutputFile = PoolRDOOutput

#--- Initial checks  -------------------------------------------
#print job configuration
DetFlags.Print()
#check job configuration
if not (DetFlags.geometry.any_on()):
    AthError("this digitization job needs some DetFlags.geometry On")
if not (DetFlags.digitize.any_on()):
    AthError("this *digitization* job needs some DetFlags.digitize On")
if not (DetFlags.writeRDOPool.any_on()):
    log.warning("this digitization job will not write any RDO object")

#--- GeoModel stuff -------------------------------------------
from AthenaCommon.GlobalFlags import globalflags
Exemplo n.º 18
0
    # Jan24,06 turns ON decays charm and  bottom but not pi0, lambda, ...
    "ihpr2 12 2",
    # Turns ON retaining of particle history - truth information:
    "ihpr2 21 1"
]

#---------------------------------------------------------------
# Pool Persistency
#---------------------------------------------------------------
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream

#--- Stream1 ---
Stream1 = AthenaPoolOutputStream("Stream1")

theApp.Dlls += ["GeneratorObjectsAthenaPoolPoolCnv"]
PoolSvc = Service("PoolSvc")

# 2101 == EventInfo
# 133273 == MCTruth (HepMC)
# 54790518 == HijigEventParams
Stream1.ItemList += ["2101#*"]
Stream1.ItemList += ["133273#*"]
Stream1.ItemList += ["54790518#*"]

Stream1.OutputFile = "hijing.pool.root"
#==============================================================
#
# End of job options file
#
###############################################################
Exemplo n.º 19
0
from AthenaCommon.AppMgr import ServiceMgr

include("AthenaCommon/Atlas_Gen.UnixStandardJob.py")
include("PartPropSvc/PartPropSvc.py")

# AthenaPool converters
include("EventAthenaPool/EventAthenaPool_joboptions.py")
include("GeneratorObjectsAthenaPool/GeneratorObjectsAthenaPool_joboptions.py")

#include( "AthenaPoolCnvSvc/WriteAthenaPool_jobOptions.py" )
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream

Stream1 = AthenaPoolOutputStream("StreamEVGEN")

Stream1.ItemList += ["EventInfo#*", "McEventCollection#*"]
Stream1.OutputFile = "mc13.007903.cavernbg_sf05_25ns.evgen._0001.pool.root"

from CavernBkgGenerator.CavernBkgGeneratorConf import MuonBackgroundConverter

topSequence += MuonBackgroundConverter("MuonBackgroundConverter")

MuonCavern = topSequence.MuonBackgroundConverter

# The following is needed to load the Athena Random
# Number Generation Service.
from AthenaServices.AthenaServicesConf import AtRndmGenSvc

ServiceMgr += AtRndmGenSvc("AtRndmGenSvc", Seeds=["SINGLE 2040160768 790101"])

# AtRndmGenSvc.ReadFromFile = true;
ServiceMgr.AtRndmGenSvc.OutputLevel = DEBUG
Exemplo n.º 20
0
#--------------------------------------------------------------
# EventLoop
#--------------------------------------------------------------
from AthenaCommon.ConcurrencyFlags import jobproperties as jp
nThreads = jp.ConcurrencyFlags.NumThreads()
if nThreads > 0:
    EventLoop = Service("AthenaHiveEventLoopMgr")
else:
    EventLoop = Service("AthenaEventLoopMgr")
EventLoop.UseSecondaryEventNumber = True
svcMgr += EventLoop

#--------------------------------------------------------------
# Output options
#--------------------------------------------------------------
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
Stream = AthenaPoolOutputStream( "Stream" )
Stream.OutputFile  = "OutputRDO.root"
Stream.ItemList =  [ 'xAOD::EventInfo#EventInfo', 'xAOD::EventAuxInfo#EventInfoAux.' ]

#--------------------------------------------------------------
# Set output level threshold (2=DEBUG, 3=INFO, 4=WARNING, 5=ERROR, 6=FATAL )
#--------------------------------------------------------------
svcMgr.MessageSvc = Service( "MessageSvc" )
svcMgr.MessageSvc.OutputLevel = WARNING
svcMgr.MessageSvc.debugLimit  = 100000

# No stats printout
include( "AthenaPoolTest/NoStats_jobOptions.py" )
Exemplo n.º 21
0
## Add an action
from G4AtlasApps.SimFlags import simFlags
simFlags.OptionalUserActionList.addAction('G4UA::MaterialStepRecorderTool')

# suppress the enormous amount of MC output
from TruthExamples.TruthExamplesConf import DumpMC
DumpMC.VerboseOutput = False

############### The Material hit collection ##################

from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
# --- commit interval (test)
ServiceMgr.AthenaPoolCnvSvc.OutputLevel = DEBUG
MaterialStream = AthenaPoolOutputStream('MaterialStream')
MaterialStream.OutputFile = outPath + "MaterStepFile.root"
MaterialStream.ItemList += ['MaterialStepVector#*']

##############################################################

include("G4AtlasApps/G4Atlas.flat.configuration.py")

## Populate alg sequence
from AthenaCommon.CfgGetter import getAlgorithm
topSeq += getAlgorithm("G4AtlasAlg", tryDefaultConfigurable=True)

from InDetIBL_Example.SLHC_Setup import SLHC_Setup
SLHC_Setup = SLHC_Setup()

#--- End jobOptions.GeantinoMapping.py file  ------------------------------
Exemplo n.º 22
0
    include("InDetRawDataByteStreamCnv/PixelWriteBS_jobOptions.py")

# ------------------------------------------------------------
# persistency
# ------------------------------------------------------------

if doWriteESD or doWriteAOD or ('doCopyRDO' in dir() and doCopyRDO):
    # --- load setup
    from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
    # --- check dictionary
    ServiceMgr.AthenaSealSvc.CheckDictionary = True

    if doWriteESD:
        # --- create stream
        StreamESD = AthenaPoolOutputStream("StreamESD")
        StreamESD.OutputFile = "InDetRecESD.root"
        # --- save MC collection if truth turned on
        if InDetFlags.doTruth():
            StreamESD.ItemList += ["McEventCollection#*"]
        # ---- load list of objects
        include("InDetRecExample/WriteInDetESD.py")

    if doWriteAOD:
        # --- create stream
        StreamAOD = AthenaPoolOutputStream("StreamAOD")
        StreamAOD.OutputFile = "InDetRecAOD.root"
        # --- save MC collection if truth turned on
        if InDetFlags.doTruth():
            StreamAOD.ItemList += ["McEventCollection#*"]
        # --- load list of objects
        include("InDetRecExample/WriteInDetAOD.py")
Exemplo n.º 23
0
job.Pythia.PythiaCommand += [
    "grav 1 2", "grav 2 1111", "grav 3 7000", "grav 4 3500", "grav 5 350",
    "grav 6 3500", "grav 7 2.5E+1", "grav 8 0"
]

job.Pythia.PythiaCommand += [
    "pyinit pylistf 1", "pyinit dumpr 0 3", "pystat 1"
]

#----------------------------------------------------------------
from TruthExamples.TruthExamplesConf import DumpMC
#job += DumpMC()

#---------------------------------------------------------------
# Ntuple service output
#---------------------------------------------------------------

from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
#from AthenaServices.AthenaServicesConf import AthenaOutputStream
from PoolSvc.PoolSvcConf import PoolSvc
from AthenaPoolCnvSvc.AthenaPoolCnvSvcConf import AthenaPoolCnvSvc

Stream1 = AthenaPoolOutputStream("StreamEVGEN")
Stream1.ItemList += ["EventInfo#*", "McEventCollection#*"]
Stream1.OutputFile = "Pythia_Graviton.pool.root"
#==============================================================
#
# End of job options file
#
###############################################################
job.Pythia.PythiaCommand += [
    "pydat3 mdme 89 1 0",  #enu
    "pydat3 mdme 90 1 0"
]  #munu

from TruthExamples.TruthExamplesConf import PrintMC
job += PrintMC()
job.PrintMC.FirstEvent = 1
job.PrintMC.LastEvent = 3

#---------------------------------------------------------------
# Pool Persistency
#---------------------------------------------------------------
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
Stream1 = AthenaPoolOutputStream("StreamEVGEN")
Stream1.OutputFile = "matchig.pool.root"
Stream1.ItemList += ['EventInfo#*', 'McEventCollection#*']

#---------------------------------------------------------------
# Ntuple service output
#---------------------------------------------------------------

#include( 'CBNT_Athena/CBNT_AthenaAware_jobOptions.py' )
#include( 'CBNT_Athena/CBNT_EventInfo_jobOptions.py' )
#include( 'RecExCommon/CBNT_Truth_jobOptions.py' )

#theApp.CreateSvc += ['AthenaSealSvc']
#ServiceMgr += CfgMgr.AthenaSealSvc()

#---------------------------------------------------------------
# AANT persistency
Exemplo n.º 25
0
## get a handle on the ServiceManager
from AthenaCommon.AppMgr import ServiceMgr as svcMgr

#Explicitly specify the output file catalog
from PoolSvc.PoolSvcConf import PoolSvc
svcMgr += PoolSvc()
svcMgr.PoolSvc.WriteCatalog = "xmlcatalog_file:Catalog1.xml"

from AthenaPoolCnvSvc.AthenaPoolCnvSvcConf import AthenaPoolCnvSvc
svcMgr += AthenaPoolCnvSvc()
svcMgr.AthenaPoolCnvSvc.CommitInterval = 10

from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream

Stream1 = AthenaPoolOutputStream("Stream1")
Stream1.OutputFile = "HLT.root"
# ** mandatory parameter ** // The output file name
Stream1.ItemList += ["TrigDec::TrigDecision#TrigDecision"]
Stream1.ItemList += ["TrigConf::HLTAODConfigData#AODConfig"]
Stream1.ItemList += ["TrigConf::Lvl1AODConfigData#AODConfig"]
Stream1.ItemList += ["TrigConf::Lvl1AODPrescaleConfigData#AODConfig"]

theApp.Dlls += ["TrigEventAthenaPoolPoolCnv"]

#--------------------------------------------------------------
# Set output level threshold (2=DEBUG, 3=INFO, 4=WARNING, 5=ERROR, 6=FATAL)
#--------------------------------------------------------------
svcMgr.MessageSvc.OutputLevel = 3
svcMgr.PoolSvc.OutputLevel = 2
svcMgr.AthenaPoolCnvSvc.OutputLevel = 2
Stream1.OutputLevel = 2
Exemplo n.º 26
0
#services that need to be reinit
ServiceMgr.MultipleEventLoopMgr.ToBeReinitialized = [
    "StoreGateSvc", "DetectorStore"
]

#
# I/O stuff
#
ServiceMgr.EventSelector.InputCollections = [
    "root://eosatlas.cern.ch//eos/atlas/atlascerngroupdisk/proj-sit/digitization/RTT/mc10/mc10_7TeV.005008.CavernInput.merge.HITS.e4_e607_s951_s952_tid170551_00/HITS.170551._000011.pool.root.1"
]

include("AthenaPoolCnvSvc/WriteAthenaPool_jobOptions.py")
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
Stream1 = AthenaPoolOutputStream("Stream1")
Stream1.OutputFile = "MultiplePassFile.root"
# ** mandatory parameter ** // The output file name
Stream1.ItemList = ["EventInfo#*", "McEventCollection#*"]

#--------------------------------------------------------------
#--- Monitoring and Debug printouts
#--------------------------------------------------------------

MessageSvc.OutputLevel = INFO
Stream1.OutputLevel = DEBUG
#StoreGateSvc.Dump=1
#StoreGateSvc.OutputLevel=DEBUG

from AthenaCommon.AppMgr import theAuditorSvc
from GaudiAud.GaudiAudConf import ChronoAuditor
theAuditorSvc += ChronoAuditor()
job += CopyMcEventCollection()

#--------------------------------------------------------------
# Output options
#--------------------------------------------------------------

from StoreGate.StoreGateConf import StoreGateSvc
ServiceMgr += StoreGateSvc("StoreGateSvc")
ServiceMgr.StoreGateSvc.Dump = True

from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
outStream = AthenaPoolOutputStream("OverlayOutputStream")
outStream.Store = ServiceMgr.StoreGateSvc

# Stream's output file
outStream.OutputFile = "InDetOverlayOut.pool.root"

#FIXME: ### FIXME: this does not work because I and O stores are separate.
#FIXME: # Copy everything from the input and must force reading of all input
#FIXME: # objects
#FIXME: #outStream.ForceRead          = True
#FIXME: #outStream.TakeItemsFromInput = True  # Need to set this to False if an explicit list is to be used

# Can use an explicit list to avoid broken classes. Requires TakeItemsFromInput=False.

outStream.ItemList = []

# Define output stream
outStream.ItemList += ["EventInfo#*"]  #FIXME: not InDet-specific
outStream.ItemList += ["PileUpEventInfo#*"]  #FIXME: not InDet-specific
outStream.ItemList += ["McEventCollection#*"]  #FIXME: not InDet-specific
job.Pyquench.nuclearA = 208
job.Pyquench.minBiasYN = False
job.Pyquench.bimpact = 0.
job.Pyquench.ptmin = 100.
job.Pyquench.sqrtSNN = 5520.

# Number of events to be processed (default is 10)
theApp.EvtMax = 50

#---------------------------------------------------------------
# Pool Persistency
#---------------------------------------------------------------
include("GeneratorObjectsAthenaPool/GeneratorObjectsAthenaPool_joboptions.py")

include("AthenaSealSvc/AthenaSealSvc_joboptions.py")
AthenaSealSvc.CheckDictionary = TRUE

from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
Stream1 = AthenaPoolOutputStream("StreamEVGEN")
#Stream1.ForceRead=TRUE
Stream1.OutputFile = "r1040b0pyquench.root"
# 2101 = EventInfo
# 133273 = MCTruth (HepMC)
Stream1.ItemList += ["2101#*", "133273#*"]

#==============================================================
#
# End of job options file
#
###############################################################
include("EventOverlayJobTransforms/MuonMcSignal_jobOptions.py")

include("EventOverlayJobTransforms/LArMcSignal_jobOptions.py")

include("EventOverlayJobTransforms/TileMcSignal_jobOptions.py")

include("EventOverlayJobTransforms/L1Signal_jobOptions.py")

from OverlayCommonAlgs.OverlayCommonAlgsConf import UpdateEventInfo
job += UpdateEventInfo()
job.UpdateEventInfo.InfoType = "McEventInfo"

# The output - signal
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
signalStream = AthenaPoolOutputStream("StreamRDO_MC")
signalStream.OutputFile = SignalCollection
signalStream.Store = "TemporaryStore"

signalStream.ItemList += [
    "EventInfo#*", "EventStreamInfo#*", "PileUpEventInfo#*"
]

if DetFlags.overlay.Truth_on():
    signalStream.ItemList += ["McEventCollection#*", "TrackRecordCollection#*"]
    if DetFlags.overlay.CSC_on():
        signalStream.ItemList += ["CscSimDataCollection#CSC_SDO"]
    if DetFlags.overlay.MDT_on():
        signalStream.ItemList += ["MuonSimDataCollection#MDT_SDO"]
    if DetFlags.overlay.RPC_on():
        signalStream.ItemList += ["MuonSimDataCollection#RPC_SDO"]
    if DetFlags.overlay.TGC_on():
topAlg += PrintMC()
#--------------------------------------------------------------
# Event related parameters
#--------------------------------------------------------------
# Number of events to be processed (default is 10)
theApp.EvtMax = 10
#--------------------------------------------------------------
# Algorithms Private Options
#--------------------------------------------------------------
Pythia = topAlg.Pythia
Pythia.PythiaCommand = ["pyinit user madgraph"]


from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
Stream1 = AthenaPoolOutputStream( "StreamEVGEN" )
Stream1.OutputFile = "baur.pool.root"
Stream1.ItemList += [ 'EventInfo#*', 'McEventCollection#*' ]
###############################################################


#
###############################################################
#from AthenaCommon.AppMgr import ServiceMgr
#ServiceMgr.EventSelector.RunNumber = runArgs.runNumber
#ServiceMgr.EventSelector.FirstEvent = runArgs.firstEvent
#----------------------------------------------------------------
# Ntuple service output
#----------------------------------------------------------------

#---------------------------------------------------------------
# Ntuple service output
topAlg = AlgSequence("TopAlg")
#from Pythia_i.Pythia_iConf import Pythia

include("MC09JobOptions/MC9_Pythia_Common.py")

Pythia.PythiaCommand = [
    "pyinit user protos", "pydat1 parj 90 20000.", "pydat3 mdcy 15 1 0"
]

# ... Tauola
include("MC09JobOptions/MC9_Tauola_Fragment.py")

# ... Photos
include("MC09JobOptions/MC9_Photos_Fragment.py")

#from TruthExamples.TruthExamplesConf import DumpMC
#topAlg += DumpMC()

#---------------------------------------------------------------
# Pool Persistency
#---------------------------------------------------------------
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
Stream1 = AthenaPoolOutputStream("StreamEVGEN")
Stream1.OutputFile = "protos.pool.root"
Stream1.ItemList += ['EventInfo#*', 'McEventCollection#*']

#
# End of job options file
#
###############################################################
Exemplo n.º 32
0
ServiceMgr += myAtRndmGenSvc

## add the material step recording action
SimFlags.OptionalUserActionList.addAction('G4UA::MaterialStepRecorderTool',
                                          ['Run', 'Event', 'Step'])

############### The Material hit collection ##################

from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
# --- check dictionary
ServiceMgr.AthenaSealSvc.CheckDictionary = True
# --- commit interval (test)
ServiceMgr.AthenaPoolCnvSvc.OutputLevel = DEBUG
ServiceMgr.AthenaPoolCnvSvc.CommitInterval = 10
MaterialStream = AthenaPoolOutputStream('MaterialStream')
MaterialStream.OutputFile = "MaterialStepFile.root"
MaterialStream.ItemList += ['Trk::MaterialStepCollection#*']

##############################################################

include("G4AtlasApps/G4Atlas.flat.configuration.py")

# Add the beam effects algorithm
from AthenaCommon.CfgGetter import getAlgorithm
topSeq += getAlgorithm("BeamEffectsAlg", tryDefaultConfigurable=True)

## Populate alg sequence
topSeq += getAlgorithm("G4AtlasAlg", tryDefaultConfigurable=True)

#--- End jobOptions.GeantinoMapping.py file  ------------------------------
    "root://eosatlas//eos/atlas/atlascerngroupdisk/proj-sit/digitization/RTT/mc10/mc10_7TeV.005008.CavernInput.merge.HITS.e4_e607_s951_s952_tid170551_00/HITS.170551._000111.pool.root.1" ]
ServiceMgr += getConfigurable("EventSelectorAthenaPool")("MinBiasSelector" )

ServiceMgr.MinBiasSelector.InputCollections = [ 
    "root://eosatlas//eos/atlas/atlascerngroupdisk/proj-sit/digitization/RTT/mc10/mc10_7TeV.105001.pythia_minbias.merge.HITS.e577_s932_s952_tid170554_00/HITS.170554._000034.pool.root.1",
    "root://eosatlas//eos/atlas/atlascerngroupdisk/proj-sit/digitization/RTT/mc10/mc10_7TeV.105001.pythia_minbias.merge.HITS.e577_s932_s952_tid170554_00/HITS.170554._000043.pool.root.1" ]
ServiceMgr.EventMixer.OutputRunNumber=54321
ServiceMgr.EventMixer.EventNumbers=[1, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 47]

#--------------------------------------------------------------
#---   Output stream configuration
#--------------------------------------------------------------
include( "AthenaPoolCnvSvc/WriteAthenaPool_jobOptions.py" )
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
Stream1 = AthenaPoolOutputStream( "Stream1" )
Stream1.OutputFile = "MixedFile.root"; # ** mandatory parameter ** // The output file name
Stream1.ForceRead=TRUE;  #force read of output data objs
Stream1.ItemList=["MergedEventInfo#*",
                  "EventInfo#*",
                  "McEventCollection#*",
		  "SiHitCollection#SCT_Hits",
		  "SiHitCollection/PixelHits"]; #SYNTAX ERROR: / not #

#--------------------------------------------------------------
#--- Monitoring and Debug printouts
#--------------------------------------------------------------

MessageSvc.OutputLevel      = INFO
ServiceMgr.EventMixer.OutputLevel      = VERBOSE
MessageSvc.setVerbose += [ "MixingEventSelector::TriggerList" ]
Stream1.OutputLevel = DEBUG