Commit f67fc9d2 authored by R D Schaffer's avatar R D Schaffer Committed by Graeme Stewart
Browse files

fix for nightly tests (AthenaPoolTest-00-10-13)

parent 9696f8e1
package AthenaPoolTest
author RD Schaffer <R.D.Schaffer@cern.ch>
private
use AtlasPolicy AtlasPolicy-*
use GaudiInterface GaudiInterface-* External
use AthenaKernel AthenaKernel-* Control
use StoreGate StoreGate-* Control
use EventInfo EventInfo-* Event
use EventInfoMgt EventInfoMgt-* Event
use AthenaBaseComps AthenaBaseComps-* Control
# Track test
use Identifier Identifier-* DetectorDescription
use TrkParameters TrkParameters-* Tracking/TrkEvent
use TrkParametersBase TrkParametersBase-* Tracking/TrkEvent
use TrkTrack TrkTrack-* Tracking/TrkEvent
use TrkMaterialOnTrack TrkMaterialOnTrack-* Tracking/TrkEvent
use TrkEventPrimitives TrkEventPrimitives-* Tracking/TrkEvent
use TrkCompetingRIOsOnTrack TrkCompetingRIOsOnTrack-* Tracking/TrkEvent
use TrkSurfaces TrkSurfaces-* Tracking/TrkDetDescr
use TrkVertexOnTrack TrkVertexOnTrack-* Tracking/TrkEvent
use GeoPrimitives GeoPrimitives-* DetectorDescription
#InDet RIO_OnTrack test
use InDetReadoutGeometry InDetReadoutGeometry-* InnerDetector/InDetDetDescr
use InDetPrepRawData InDetPrepRawData-* InnerDetector/InDetRecEvent
use InDetRIO_OnTrack InDetRIO_OnTrack-* InnerDetector/InDetRecEvent
use InDetCompetingRIOsOnTrack InDetCompetingRIOsOnTrack-* InnerDetector/InDetRecEvent
# InDet RDO test
use InDetRawData InDetRawData-* InnerDetector/InDetRawEvent
use InDetIdentifier InDetIdentifier-* InnerDetector/InDetDetDescr
# LAr test
use LArRecEvent LArRecEvent-* LArCalorimeter
use CaloIdentifier CaloIdentifier-* Calorimeter
use CaloEvent CaloEvent-* Calorimeter
# use CaloUtils CaloUtils-* Calorimeter
use CaloDetDescr CaloDetDescr-* Calorimeter
# AthenaPoolTest Data
use AthenaPoolTestData AthenaPoolTestData-* AtlasTest/DatabaseTest
# EventInfo test
use GeoModelInterfaces GeoModelInterfaces-* DetectorDescription/GeoModel
# AthenaPoolUtilities
use AthenaPoolUtilities AthenaPoolUtilities-* Database/AthenaPOOL
# Test infrastructure
use TestPolicy TestPolicy-*
apply_pattern component_library
library AthenaPoolTest " AthenaPoolTestDataReader.cxx \
AthenaPoolTestDataWriter.cxx \
AthenaPoolTestAttrWriter.cxx \
AthenaPoolTestAttrReader.cxx \
# # CaloClusterFakeWriter.cxx \
# # CaloClusterFakeReader.cxx \
InDetRawDataFakeReader.cxx \
InDetRawDataFakeWriter.cxx \
LArCellContFakeWriter.cxx \
LArCellContFakeReader.cxx \
EventInfoWriter.cxx \
EventInfoReader.cxx \
PileUpEventInfoWriter.cxx \
PileUpEventInfoReader.cxx \
TrkTrackFakeReader.cxx \
TrkTrackFakeWriter.cxx \
FakeTrackBuilder.cxx \
components/*.cxx "
apply_pattern declare_joboptions files="-s=../share *.py"
# Setup automatic testing which runs with gmake check
# We define here a macro which can be used to run the tests only on
# optimized mode.
macro test_pattern_opt_only "athenarun_test" \
debug ""
# Write/read out some simple objects:
# AthenaPoolTestWrite
apply_pattern athenarun_test name="AthenaPoolTestWrite" pre_script="../test/pre_check.sh AthenaPoolTestWrite " options="AthenaPoolTest/AthenaPoolTestWrite.py" post_script="../test/post_check_with_select.sh AthenaPoolTestWrite ^..AthenaPoolTestD "
# AthenaPoolTestRead
apply_pattern athenarun_test name="AthenaPoolTestRead" pre_script="../test/pre_check.sh AthenaPoolTestRead " options="AthenaPoolTest/AthenaPoolTestRead.py" post_script="../test/post_check_with_select.sh AthenaPoolTestRead AthenaPoolTestD "
# Ensure AthenaPoolTestRead test runs after AthenaPoolTestWrite test completes
macro_append AthenaPoolTestRead_test_dependencies " AthenaPoolTestWrite_test "
# Add on test of navigation still using simple objects:
# AthenaPoolTestWrite - Step2 - rewrite part in another file
apply_pattern athenarun_test name="AthenaPoolTestStep2Write" pre_script="../test/pre_check.sh AthenaPoolTestStep2Write " options="AthenaPoolTest/AthenaPoolTestStep2Write.py" post_script="../test/post_check_with_select.sh AthenaPoolTestStep2Write ^..AthenaPoolTestD "
macro_append AthenaPoolTestStep2Write_test_dependencies " AthenaPoolTestRead_test "
# AthenaPoolTestReadNav - read back from Step2 - part in one file,
# part in another file
apply_pattern athenarun_test name="AthenaPoolTestReadNav" pre_script="../test/pre_check.sh AthenaPoolTestReadNav " options="AthenaPoolTest/AthenaPoolTestReadNav.py" post_script="../test/post_check_with_select.sh AthenaPoolTestReadNav AthenaPoolTestD "
macro_append AthenaPoolTestReadNav_test_dependencies " AthenaPoolTestStep2Write_test "
# # Copy the Step2 file
# apply_pattern athenarun_test name="AthenaPoolTestCopy" pre_script="../test/pre_check.sh AthenaPoolTestCopy " options="AthenaPoolTest/AthenaPoolTestCopy.py" post_script="../test/post_check_with_select.sh AthenaPoolTestCopy ^..Stream1 "
# # Remove the Step2 file and read the copy
# apply_pattern athenarun_test name="AthenaPoolTestReadAfterCopy" pre_script="../test/pre_check.sh AthenaPoolTestReadAfterCopy SimplePoolFile1.root " options="AthenaPoolTest/AthenaPoolTestReadAfterCopy.py" post_script="../test/post_check_with_select.sh AthenaPoolTestReadAfterCopy AthenaPoolTestD "
# # Write/read out PileUpEventInfo:
# # PileUpEventInfoWrite
# apply_pattern athenarun_test name="PileUpEventInfoWrite" pre_script="../test/pre_check.sh PileUpEventInfoWrite " options="AthenaPoolTest/PileUpEventInfoWrite.py" post_script="../test/post_check_with_select.sh PileUpEventInfoWrite ^..PileUpEventInfo "
# # PileUpEventInfoRead
# apply_pattern athenarun_test name="PileUpEventInfoRead" pre_script="../test/pre_check.sh PileUpEventInfoRead " options="AthenaPoolTest/PileUpEventInfoRead.py" post_script="../test/post_check_with_select.sh PileUpEventInfoRead ^..PileUpEventInfo "
# Atlfast NOT YET WORKING
# AtlfastPoolWrite
# problems: apply_pattern athenarun_test name="AtlfastPoolWrite" pre_script="../test/pre_check.sh AtlfastPoolWrite " options="AthenaPoolTest/AtlfastPoolWriteOptions.py" post_script="../test/post_check_with_select.sh AtlfastPoolWrite "
# AtlfastPoolRead
#problems: apply_pattern athenarun_test name="AtlfastPoolRead" pre_script="../test/atlfast_write_pre_check.sh AtlfastPoolRead " options="AthenaPoolTest/AtlfastPoolReadOptions.py" post_script="../test/post_check_with_select.sh AtlfastPoolRead "
# Test write/read of indet rdos:
# InDetRawDataWriter
apply_pattern athenarun_test name="InDetRawDataWriter" pre_script="../test/pre_check.sh InDetRawDataWriter " options="AthenaPoolTest/InDetRawDataWriter_jobOptions.py" post_script="../test/post_check_with_select.sh InDetRawDataWriter InDetRawDataFak "
macro_append InDetRawDataWriter_test_dependencies " AthenaPoolTestReadNav_test "
# InDetRawDataRead
apply_pattern athenarun_test name="InDetRawDataRead" pre_script="../test/pre_check.sh InDetRawDataRead " options="AthenaPoolTest/InDetRawDataReader_jobOptions.py" post_script="../test/post_check_with_select.sh InDetRawDataRead InDetRawDataFak "
macro_append InDetRawDataRead_test_dependencies " InDetRawDataWriter_test "
# Test write/read of LAr cell
# LArCellContWriter
apply_pattern athenarun_test name="LArCellContWriter" pre_script="../test/pre_check.sh LArCellContWriter " options="AthenaPoolTest/LArCellContWriter_jobOptions.py" post_script="../test/post_check_with_select.sh LArCellContWriter LArCellContFake "
macro_append LArCellContWriter_test_dependencies " InDetRawDataRead_test "
# LArCellContRead
apply_pattern athenarun_test name="LArCellContRead" pre_script="../test/pre_check.sh LArCellContRead " options="AthenaPoolTest/LArCellContReader_jobOptions.py" post_script="../test/post_check_with_select.sh LArCellContRead LArCellContFake "
macro_append LArCellContRead_test_dependencies " LArCellContWriter_test "
# # Test of explicit collection write/read
# # LArCellContWriteReg
# apply_pattern $(test_pattern_opt_only) name="LArCellContWriteReg" pre_script="../test/pre_check.sh LArCellContWriteReg " options="AthenaPoolTest/LArCellContWriter_jobOptionsReg.py" post_script="../test/post_check_with_select.sh LArCellContWriteReg LArCellContFake "
# # LArCellContReadReg
# apply_pattern $(test_pattern_opt_only) name="LArCellContReadReg" pre_script="../test/pre_check.sh LArCellContReadReg " options="AthenaPoolTest/LArCellContReader_jobOptionsReg.py" post_script="../test/post_check_with_select.sh LArCellContReadReg LArCellContFake "
# #LFN test
# # LArCellContWriteStep1
# apply_pattern athenarun_test name="LArCellContWriteStep1" pre_script="../test/pre_check.sh LArCellContWriteStep1 " options="AthenaPoolTest/LArCellContWriter_jobOptionsStep1.py" post_script="../test/post_check_with_select.sh LArCellContWriteStep1 LArCellContFake "
# # LArCellContWriteStep2
# apply_pattern athenarun_test name="LArCellContWriteStep2" pre_script="../test/pre_check.sh LArCellContWriteStep2 " options="AthenaPoolTest/LArCellContWriter_jobOptionsStep2.py" post_script="../test/post_check_with_select.sh LArCellContWriteStep2 LArCellContFake "
# # LArCellContReadByLFN
# apply_pattern athenarun_test name="LArCellContReadByLFN" pre_script="../test/lfn_test_pre_check.sh LArCellContReadByLFN " options="AthenaPoolTest/LArCellContReader_jobOptionsByLFN.py" post_script="../test/post_check_with_select.sh LArCellContReadByLFN LArCellContFake "
# # write/read test of calo clusters
# # CaloClusterWriter
# apply_pattern athenarun_test name="CaloClusterWriter" pre_script="../test/pre_check.sh CaloClusterWriter" options="AthenaPoolTest/CaloClusterWriter_jobOptions.py" post_script="../test/post_check_with_select.sh CaloClusterWriter ^..CaloClusterFakeWriter"
# macro_append CaloClusterWriter_test_dependencies " LArCellContRead_test "
# # CaloClusterReader
# apply_pattern athenarun_test name="CaloClusterReader" pre_script="../test/pre_check.sh CaloClusterReader " options="AthenaPoolTest/CaloClusterReader_jobOptions.py" post_script="../test/post_check_with_select.sh CaloClusterReader ^..CaloClusterFakeWriter"
# macro_append CaloClusterReader_test_dependencies " CaloClusterWriter_test "
# # Test ElementLinks across files
# # CaloClusterStep1Writer
# apply_pattern athenarun_test name="CaloClusterStep1Writer" pre_script="../test/pre_check.sh CaloClusterStep1Writer" options="AthenaPoolTest/CaloClusterStep1Writer_jobOptions.py" post_script="../test/post_check_with_select.sh CaloClusterStep1Writer Fake "
# # CaloClusterStep2Writer
# apply_pattern athenarun_test name="CaloClusterStep2Writer" pre_script="../test/pre_check.sh CaloClusterStep2Writer" options="AthenaPoolTest/CaloClusterStep2Writer_jobOptions.py" post_script="../test/post_check_with_select.sh CaloClusterStep2Writer Fake "
# # CaloCluster2StepReader
# apply_pattern athenarun_test name="CaloCluster2StepReader" pre_script="../test/pre_check.sh CaloCluster2StepReader " options="AthenaPoolTest/CaloCluster2StepReader_jobOptions.py" post_script="../test/post_check_with_select.sh CaloCluster2StepReader Fake "
# # The following four tests are for writing explicit root collections with an extra ref
# # First write an implicit collection, then a second file and an explicit root collection
# # Then read back with standard ref - Step1, or extra ref - Step2
# # AthenaPoolTestWrite - write out implicit collection with athena pool test data
# apply_pattern athenarun_test name="AthenaPoolTestWrite2" pre_script="../test/pre_check.sh AthenaPoolTestWrite2 " options="AthenaPoolTest/AthenaPoolTestWrite.py" post_script="../test/post_check_with_select.sh AthenaPoolTestWrite2 ^..AthenaPoolTestD "
# # LArCellContWriteRegStep2 - write out explicit collection with LArCellCont
# apply_pattern $(test_pattern_opt_only) name="LArCellContWriteRegStep2" pre_script="../test/pre_check.sh LArCellContWriteRegStep2 " options="AthenaPoolTest/LArCellContWriter_jobOptionsRegStep2.py" post_script="../test/post_check_with_select.sh LArCellContWriteRegStep2 LArCellContFake "
# # LArCellContWriteRegStep3 - write out explicit collection with LArCellCont
# # in separate step
# apply_pattern $(test_pattern_opt_only) name="LArCellContWriteRegStep3" pre_script="../test/pre_check.sh LArCellContWriteRegStep3 " options="AthenaPoolTest/LArCellContWriter_jobOptionsRegStep3.py" post_script="../test/diff_check.sh LArCellContWriteRegStep3 LArCellContFake "
# # LArCellContReadRegStep1 - read in LArCellCont
# apply_pattern $(test_pattern_opt_only) name="LArCellContReadRegStep1" pre_script="../test/pre_check.sh LArCellContReadRegStep1 " options="AthenaPoolTest/LArCellContReader_jobOptionsRegStep1.py" post_script="../test/post_check_with_select.sh LArCellContReadRegStep1 LArCellContFake "
# # LArCellContReadRegStep2 - read in athena pool test data
# apply_pattern $(test_pattern_opt_only) name="LArCellContReadRegStep2" pre_script="../test/pre_check.sh LArCellContReadRegStep2 " options="AthenaPoolTest/LArCellContReader_jobOptionsRegStep2.py" post_script="../test/post_check_with_select.sh LArCellContReadRegStep2 LArCellContFake "
# Check for adding DetDescr tags to event info object:
# EventInfoWrite
apply_pattern athenarun_test name="EventInfoWrite" pre_script="../test/pre_check.sh EventInfoWrite " options="AthenaPoolTest/EventInfoWrite.py" post_script="../test/post_check_with_select.sh EventInfoWrite ^..[TE][av][ge][In][nt][fI][on][Mf][go][rW] "
# macro_append EventInfoWrite_test_dependencies " CaloClusterReader_test "
macro_append EventInfoWrite_test_dependencies " LArCellContRead_test "
# EventInfoWriteStep2
apply_pattern athenarun_test name="EventInfoWriteStep2" pre_script="../test/pre_check.sh EventInfoWriteStep2 " options="AthenaPoolTest/EventInfoWriteStep2.py" post_script="../test/post_check_with_select.sh EventInfoWriteStep2 ^..[TE][av][ge][In][nt][fI][on][Mf][go][rW] "
macro_append EventInfoWriteStep2_test_dependencies " EventInfoWrite_test "
# EventInfoWriteStep3
apply_pattern athenarun_test name="EventInfoWriteStep3" pre_script="../test/pre_check.sh EventInfoWriteStep3 " options="AthenaPoolTest/EventInfoWriteStep3.py" post_script="../test/post_check_with_select.sh EventInfoWriteStep3 ^..[TE][av][ge][In][nt][fI][on][Mf][go][rW] "
macro_append EventInfoWriteStep3_test_dependencies " EventInfoWriteStep2_test "
# EventInfoWriteStep4
apply_pattern athenarun_test name="EventInfoWriteStep4" pre_script="../test/pre_check.sh EventInfoWriteStep4 " options="AthenaPoolTest/EventInfoWriteStep4.py" post_script="../test/post_check_with_select.sh EventInfoWriteStep4 ^..[TE][av][ge][In][nt][fI][on][Mf][go][rW] "
macro_append EventInfoWriteStep4_test_dependencies " EventInfoWriteStep3_test "
# EventInfoWriteStep5
apply_pattern athenarun_test name="EventInfoWriteStep5" pre_script="../test/pre_check.sh EventInfoWriteStep5 " options="AthenaPoolTest/EventInfoWriteStep5.py" post_script="../test/post_check_with_select.sh EventInfoWriteStep5 ^..[TE][av][ge][In][nt][fI][on][Mf][go][rW] "
macro_append EventInfoWriteStep5_test_dependencies " EventInfoWriteStep4_test "
# EventInfoRead
apply_pattern athenarun_test name="EventInfoRead" pre_script="../test/pre_check.sh EventInfoRead " options="AthenaPoolTest/EventInfoRead.py" post_script="../test/post_check_with_select.sh EventInfoRead ^..[TE][av][ge][In][nt][fI][on][Mf][go][rW] "
macro_append EventInfoRead_test_dependencies " EventInfoWriteStep5_test "
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
/**
@mainpage
AthenaPoolTest is a package containing tests of I/O for
AthenaPOOL. The tests write and read data objects which are both
simple types and as well classes taken from the standard atlas
event. Different features of I/O are also tested, i.e.
- Back navigation from file to file: where a first file is written
and then read and a second file is written. When reading back the
EventSelector.BackNavigation property is set true and objects
from both files may be read
- Navigating element links across files: when objects in a
container in one file have element links to objects in a previously
written file, one can read objects from both files by opening the
second file and following the element links
- Use of Logical File Names (LFN) instead of Physical File Names
(PFN). One can add to the pool file catalog LFN for any file and
to read back one simply specifies the input collection as
LFN:<logical file name>
- Use of explicit event collections
- Adding of detector description tags to the EventInfo object
@section HowTheTestWork How the tests work
Currently the tests are run using the athenarun_test pattern. This
allows a pre and a post script to be run before/after an athena
jobOption file is run. The tests are set up in the requirements file
and run via "gmake check". They are also run in the nightly. Some of
these tests are run as kit validation tests in the package
JobTransforms.
Normally a complete test is composed of two or more jobs. For each job
the post script compares the output of an athena job with a standard
output which has been stored with the package in cvs. The comparison
currently allows one to specify which lines in the output to compare
as specified by a selection string, which is typically the algorithm
name which appears in the output.
@section TheTests The tests
The following tests are currently being run:
- AthenaPoolTest: Write/read out some simple objects
- Two jobOptions run:
- AthenaPoolTestWrite.py
- AthenaPoolTestRead.py
.
.
- Navigation tests: use back navigation, used in combination with
previous test
- Two jobOptions run:
- AthenaPoolTestStep2Write.py : rewrites part of the above write
into a second file
- AthenaPoolTestReadNav.py : read part from second file, part
from first file via navigation
.
.
- Write/read InDetRawData Identifiable Containers for pixel, sct
and trt
- Two jobOptions run:
- InDetRawDataWriter_jobOptions.py
- InDetRawDataReader_jobOptions.py
.
.
- Write/read LAr &Cell &Identifiable Containers
- Two jobOptions run:
- LArCellContWriter_jobOptions.py
- LArCellContReader_jobOptions.py
.
.
- Test of explicit collection write/read
- Two jobOptions run:
- LArCellContWriter_jobOptionsReg.py
- LArCellContReader_jobOptionsReg.py
.
.
- Write/read LAr &Cell &Identifiable Containers using LFNs - write
into two files and read then both one after the other.
- Three jobOptions run:
- LArCellContWriter_jobOptionsStep1.py
- LArCellContWriter_jobOptionsStep2.py
- LArCellContReader_jobOptionsByLFN.py
.
.
- Write/read CaloCluster Identifiable Containers
- Two jobOptions run:
- CaloClusterWriter_jobOptions.py
- CaloClusterReader_jobOptions.py
.
.
- Write/read test of Element Links: write LAr &Cell &Identifiable
Containers in one file, read this file and store Calo Clusters in
a second file with Element Links back to the LAr Cells the first
file. Then read back the CaloClusters and navigate back to the
LArCells.
- Three jobOptions run:
- CaloClusterStep1Writer_jobOptions.py
- CaloClusterStep2Writer_jobOptions.py
- CaloCluster2StepReader_jobOptions.py
.
.
- Write explicit root collections with an extra ref. That is one
first writes one file, reads the first file and writes a second
file and at the same time write an explicit collection with a
reference the data header in the second file. The collection also
has an extra ref as part of the tag attributes and this can be
used to navigate to the first file.
- Four jobOptions run:
- AthenaPoolTestWrite.py: write out implicit collection with athena pool test data
- LArCellContWriter_jobOptionsRegStep2.py: write out explicit collection with LArCellCont
- LArCellContReader_jobOptionsRegStep1.py: read in LArCellCont
- LArCellContReader_jobOptionsRegStep2.py: read in athena pool test data
.
.
- Check for adding DetDescr tags to event info object
- Five jobOptions run:
- EventInfoWrite.py: write out new tags into EventInfo
- EventInfoWriteStep2.py: read in EventInfo with tags and write dummy tags
- EventInfoWriteStep3.py: read in EventInfo with tags and write
dummy tags with override
- EventInfoWriteStep4.py: read in EventInfo with tags and write
dummy tags with override EventInfoTags
- EventInfoRead.py: read back EventInfo tags
.
.
.
@section requirements requirements
@include requirements
@section uses Packages used
@htmlinclude used_packages.html
*/
###############################################################
#
# Job options file
#
## @file AthenaPoolTestStep2Write.py
##
## @brief For Athena POOL test: write out AthenaPoolTest data objects
## in a second file to test navigation
##
## @author RD Schaffer <R.D.Schaffer@cern.ch>
#
#==============================================================
## basic job configuration
import AthenaCommon.AtlasUnixStandardJob
## get a handle to the default top-level algorithm sequence
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
## get a handle to the ApplicationManager
from AthenaCommon.AppMgr import theApp
## get a handle to the ServiceManager
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
from CLIDComps.CLIDCompsConf import ClassIDSvc
svcMgr += ClassIDSvc()
ClassIDSvc.CLIDDBFiles = ['CLIDSvc/clid.db']
from AthenaCommon.GlobalFlags import GlobalFlags
GlobalFlags.DetGeo.set_commis()
# Reading G4 simulated data from Pool
#GlobalFlags.DataSource.set_geant4()
#GlobalFlags.InputFormat.set_pool()
GlobalFlags.DataSource.set_data()
GlobalFlags.InputFormat.set_bytestream()
#--------------------------------------------------------------
# Load POOL support
#--------------------------------------------------------------
import AthenaPoolCnvSvc.ReadAthenaPool
import AthenaPoolCnvSvc.WriteAthenaPool
DetDescrVersion = "ATLAS-CommNF-00-00-00"
include ("AtlasGeoModel/SetGeometryVersion.py")
GeoModelSvc = Service( "GeoModelSvc" )
include ("AtlasGeoModel/GeoModelInit.py")
GeoModelSvc.MuonVersionOverride="MuonSpectrometer-R.01.01.Initial.Light"
#--------------------------------------------------------------
# Define the input parameters
#--------------------------------------------------------------
svcMgr.EventSelector.InputCollections = [ "rfio:/castor/cern.ch/grid/atlas/t0/perm/M4cosmics/0020897/ESD/M4.0020897.debug.L1TT-b00000011.ESD.v13002507.part0013._lumi0000._0001.1" ]
#--------------------------------------------------------------
# JobOptions for the loading of the AthenaSealSvc
#--------------------------------------------------------------
# Add in dictionary name:
#AthenaSealSvc.DictNames += [ "SealCLHEPDict" ]
# Check the dictionary in memory for completeness
svcMgr.AthenaSealSvc.CheckDictionary = True
#--------------------------------------------------------------
# Event related parameters
#--------------------------------------------------------------
theApp.EvtMax = -1
#--------------------------------------------------------------
# Output options
#--------------------------------------------------------------
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
Stream1 = AthenaPoolOutputStream( "Stream1" )
include( "AthenaPoolTestAthenaPool/AthenaPoolTestAthenaPool_joboptions.py" )
include( "InDetEventAthenaPool/InDetEventAthenaPool_joboptions.py" )
include ("CaloAthenaPool/CaloAthenaPool_joboptions.py")
theApp.Dlls += [ "MuonEventAthenaPoolPoolCnv" ]
# Run OutputStream as an algorithm
topSequence += AthenaPoolOutputStream( "Stream1" )
# Must make sure that no OutStream's have been declared
theApp.OutStream = [];
# Stream's output file
Stream1.WritingTool = "AthenaPoolOutputStreamTool"
Stream1.OutputFile = "SimplePoolFile2.root"
Stream1.OutputLevel = DEBUG
# Copy everything from the input and must force reading of all input
# objects
Stream1.TakeItemsFromInput = True
Stream1.ForceRead = True
# Turn off provenance - means that new copy does NOT point back to its
# input file, but it DOES retain the possibility to navigate to the
# files upstream of the input. Thus the output "replaces" the input in
# terms of back-navigation.
Stream1.ExtendProvenanceRecord = False
print Stream1.ItemList
#--------------------------------------------------------------
# Set output level threshold (2=DEBUG, 3=INFO, 4=WARNING, 5=ERROR, 6=FATAL )
#--------------------------------------------------------------
svcMgr.MessageSvc = Service( "MessageSvc" )
svcMgr.MessageSvc.OutputLevel = INFO
svcMgr.MessageSvc.debugLimit = 100000
svcMgr.AthenaSealSvc.OutputLevel = INFO
AthenaEventLoopMgr = Service( "AthenaEventLoopMgr" )
#AthenaEventLoopMgr.OutputLevel = DEBUG
# No stats printout
include( "AthenaPoolTest/NoStats_jobOptions.py" )
#==============================================================
#
# End of job options file
#
###############################################################
svcMgr.MessageSvc.Format = "% F%30W%S%7W%R%T %0W%M"
###############################################################
#
# Job options file
#
## @file LArCellContWriter_jobOptions.py
##
## @brief For Athena POOL test: write out LArCellContainers
##
## @author RD Schaffer <R.D.Schaffer@cern.ch>
#
#==============================================================
# MC Event Selector
include( "AthenaCommon/Atlas_Gen.UnixStandardJob.py" )
#--------------------------------------------------------------
# Load POOL support
#--------------------------------------------------------------
include( "AthenaPoolCnvSvc/WriteAthenaPool_jobOptions.py" )
#--------------------------------------------------------------
# JobOptions for the loading of the AthenaSealSvc
#--------------------------------------------------------------
include( "AthenaSealSvc/AthenaSealSvc_joboptions.py" )
# Dictionaries for AthenaSealSvc:
include( "EventInfo/EventInfoDict_joboptions.py" )
include( "AthenaPoolTestData/AthenaPoolTestDataDict_joboptions.py" )
# Add in dictionary name:
AthenaSealSvc = Service( "AthenaSealSvc" )
AthenaSealSvc.DictNames += [ "SealCLHEPDict" ]
# Check the dictionary in memory for completeness
#AthenaSealSvc.CheckDictionary = TRUE
#--------------------------------------------------------------
# Event related parameters
#--------------------------------------------------------------
theApp.EvtMax = 5
#--------------------------------------------------------------
# Application: AthenaPoolTest options
#--------------------------------------------------------------
theApp.Dlls += [ "AthenaPoolTest" ]
theApp.TopAlg += [ "AthenaPoolTestDataWriter" ]
AthenaPoolTestDataWriter = Algorithm( "AthenaPoolTestDataWriter" )
AthenaPoolTestDataWriter.PartialCreate = TRUE
#--------------------------------------------------------------
# Output options
#--------------------------------------------------------------
# LAr Hit
# Converters:
include( "EventAthenaPool/EventAthenaPool_joboptions.py" )
include( "AthenaPoolTestAthenaPool/AthenaPoolTestAthenaPool_joboptions.py" )
# ItemList:
include( "EventAthenaPool/EventAthenaPoolItemList_joboptions.py" )
include( "AthenaPoolTestAthenaPool/AthenaPoolTestAthenaPoolItemList_joboptions.py" )
print fullItemList
# Stream's output file
Stream1 = Algorithm( "Stream1" )
Stream1.OutputFile = "SimplePoolFile1.root"
# List of DO's to write out
Stream1.ItemList += fullItemList
#Stream1.ItemList += ["EventInfo#*"]
#Stream1.ItemList += ["IAthenaPoolTestCollection#*"]
#Stream1.ItemList += ["AthenaPoolTestMatrix#*"]
#--------------------------------------------------------------
# Set output level threshold (2=DEBUG, 3=INFO, 4=WARNING, 5=ERROR, 6=FATAL )