python/DigitizationWriteMetaData.py (writeDigitizationMetadata): downgrade...

python/DigitizationWriteMetaData.py (writeDigitizationMetadata): downgrade warning message to info. Tagging Digitization-02-00-12 (Digitization-02-00-12)

	* python/DigitizationWriteMetaData.py (writeDigitizationMetadata):
	downgrade warning message to info.
	* Tagging Digitization-02-00-12

2016-09-07  John Chapman  <John.Chapman@cern.ch>

	* python/DigitizationFlags.py: add doBichselSimulation
	digitization flag - False by default. ATLPHYSVAL-430
	* Tagging Digitization-02-00-11

2016-07-29  John Chapman  <John.Chapman@cern.ch>

	* python/DigiAlgConfig.py (getStandardInDetPileUpTools): fix typo. ATLASSIM-3022
	* Tagging Digitization-02-00-10

2016-07-28  John Chapman  <John.Chapman@cern.ch>

	* python/DigiAlgConfig.py (getStandardInDetPileUpTools): add hook
	for PixelLightDigitizationTool obo Noemi Calace. ATLASSIM-3022.
...
(Long ChangeLog diff - truncated)


Former-commit-id: 241c7363977f609d9244564fffa32109bd32bae9

Simulation/Digitization/python/DigiAlgConfig.py

 # Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
 
 from AthenaCommon import CfgMgr
-from AthenaCommon import CfgGetter # import getService, getPrivateTool
+
+#####################################
+##     Test PileUpTool methods     ##
+#####################################
 
 def getTestPileUpTool(name="TestPileUpTool", **kwargs):
+    from AthenaCommon.Constants import *
     kwargs.setdefault('OutputLevel', VERBOSE )
     kwargs.setdefault('FirstXing', -300 )
     kwargs.setdefault('LastXing', +300 )
-    return CfgGetter.TestPileUpTool(name, **kwargs)
-
-
-def getTestPileUpToolsAlg(name="TestPileUpToolsAlg", **kwargs):
-    PileUpToolsList = [ "TestPileUpTool" ]
-    kwargs.setdefault('PileupTools', PileUpToolsList )
-    from PileUpComps.PileUpCompsConf import PileUpToolsAlg
-    return PileUpToolsAlg(name, **kwargs)
-
+    return CfgMgr.TestPileUpTool(name, **kwargs)
 
-def getTestDigitizationAlg(name="TestDigitizationAlg", **kwargs):
-    PileUpToolsList = [ "TestPileUpTool" ]
-    kwargs.setdefault('PileupTools', PileUpToolsList )
-    from PileUpComps.PileUpCompsConf import DigitizationAlg
-    return DigitizationAlg(name, **kwargs)
+def getTestFilterPileUpTool(name="TestFilterPileUpTool", **kwargs):
+    from AthenaCommon.Constants import *
+    kwargs.setdefault('OutputLevel', INFO )
+    kwargs.setdefault('DoFiltering', True )
+    return getTestPileUpTool(name, **kwargs)
 
 #####################################
 ## PileUpToolsList filling methods ##
@@ -85,6 +81,8 @@ def getStandardInDetPileUpTools():
     if DetFlags.digitize.pixel_on():
         if 'doFastPixelDigi' in digitizationFlags.experimentalDigi():
             PileUpToolsList += [ "PixelFastDigitizationTool" ]
+        elif 'doLightPixelDigi' in digitizationFlags.experimentalDigi():
+            PileUpToolsList += [ "PixelLightDigitizationTool" ]
         else:
             PileUpToolsList += [ "PixelDigitizationTool" ]
     if DetFlags.digitize.SCT_on():
@@ -209,6 +207,8 @@ def getStandardCaloPileUpTools():
     PileUpToolsList = []
     if DetFlags.digitize.LAr_on():
         PileUpToolsList += [ "LArPileUpTool" ]
+    if hasattr(DetFlags.digitize, 'HGTD_on') and DetFlags.digitize.HGTD_on():
+        PileUpToolsList += [ "HGTDPileUpTool" ]
     if DetFlags.digitize.Tile_on():
         PileUpToolsList += [ "TileHitVecToCntTool" ]
     return PileUpToolsList
@@ -378,68 +378,59 @@ def getStandardPileUpToolsAlg(name="StandardPileUpToolsAlg", **kwargs):
     kwargs.setdefault('PileUpTools', getStandardPileUpToolsList() )
     from Digitization.DigitizationFlags import digitizationFlags
     if digitizationFlags.doXingByXingPileUp():
-        from PileUpComps.PileUpCompsConf import PileUpToolsAlg
-        return PileUpToolsAlg(name, **kwargs)
+        return CfgMgr.PileUpToolsAlg(name, **kwargs)
     else:
-        from PileUpComps.PileUpCompsConf import DigitizationAlg
-        return DigitizationAlg(name, **kwargs)
+        return CfgMgr.DigitizationAlg(name, **kwargs)
 
 def getFastPileUpToolsAlg(name="FastPileUpToolsAlg", **kwargs):
     kwargs.setdefault('PileUpTools', getFastPileUpToolsList() )
-    from Digitization.DigitizationFlags import digitizationFlags
-    if digitizationFlags.doXingByXingPileUp():
-        from PileUpComps.PileUpCompsConf import PileUpToolsAlg
-        return PileUpToolsAlg(name, **kwargs)
-    else:
-        from PileUpComps.PileUpCompsConf import DigitizationAlg
-        return DigitizationAlg(name, **kwargs)
+    return getStandardPileUpToolsAlg(name, **kwargs)
 
 def getSplitPileUpToolsAlg(name="SplitPileUpToolsAlg", **kwargs):
     kwargs.setdefault('PileUpTools', getSplitPileUpToolsList() )
-    from Digitization.DigitizationFlags import digitizationFlags
-    if digitizationFlags.doXingByXingPileUp():
-        from PileUpComps.PileUpCompsConf import PileUpToolsAlg
-        return PileUpToolsAlg(name, **kwargs)
-    else:
-        from PileUpComps.PileUpCompsConf import DigitizationAlg
-        return DigitizationAlg(name, **kwargs)
+    return getStandardPileUpToolsAlg(name, **kwargs)
 
 def getStandardSignalOnlyTruthPileUpToolsAlg(name="StandardSignalOnlyTruthPileUpToolsAlg", **kwargs):
     kwargs.setdefault('PileUpTools', getStandardSignalOnlyTruthPileUpToolsList() )
-    from Digitization.DigitizationFlags import digitizationFlags
-    if digitizationFlags.doXingByXingPileUp():
-        from PileUpComps.PileUpCompsConf import PileUpToolsAlg
-        return PileUpToolsAlg(name, **kwargs)
-    else:
-        from PileUpComps.PileUpCompsConf import DigitizationAlg
-        return DigitizationAlg(name, **kwargs)
+    return getStandardPileUpToolsAlg(name, **kwargs)
 
 def getStandardInTimeOnlyTruthPileUpToolsAlg(name="StandardInTimeOnlyTruthPileUpToolsAlg", **kwargs):
     kwargs.setdefault('PileUpTools', getStandardInTimeOnlyTruthPileUpToolsList() )
-    from Digitization.DigitizationFlags import digitizationFlags
-    if digitizationFlags.doXingByXingPileUp():
-        from PileUpComps.PileUpCompsConf import PileUpToolsAlg
-        return PileUpToolsAlg(name, **kwargs)
-    else:
-        from PileUpComps.PileUpCompsConf import DigitizationAlg
-        return DigitizationAlg(name, **kwargs)
+    return getStandardPileUpToolsAlg(name, **kwargs)
 
 def getSplitNoMergePileUpToolsAlg(name="SplitNoMergePileUpToolsAlg", **kwargs):
     kwargs.setdefault('PileUpTools', getSplitNoMergePileUpToolsList() )
-    from PileUpComps.PileUpCompsConf import DigitizationAlg
-    return DigitizationAlg(name, **kwargs)
+    return getStandardPileUpToolsAlg(name, **kwargs)
 
 def getSplitNoMergeSFPileUpToolsAlg(name="SplitNoMergeSFPileUpToolsAlg", **kwargs):
     kwargs.setdefault('PileUpTools', getSplitNoMergeSFPileUpToolsList() )
-    from PileUpComps.PileUpCompsConf import DigitizationAlg
-    return DigitizationAlg(name, **kwargs)
+    return getStandardPileUpToolsAlg(name, **kwargs)
 
 def getSplitNoMergeFSPileUpToolsAlg(name="SplitNoMergeFSPileUpToolsAlg", **kwargs):
     kwargs.setdefault('PileUpTools', getSplitNoMergeFSPileUpToolsList() )
-    from PileUpComps.PileUpCompsConf import DigitizationAlg
-    return DigitizationAlg(name, **kwargs)
+    return getStandardPileUpToolsAlg(name, **kwargs)
 
 def getSplitNoMergeFFPileUpToolsAlg(name="SplitNoMergeFFPileUpToolsAlg", **kwargs):
     kwargs.setdefault('PileUpTools', getSplitNoMergeFFPileUpToolsList() )
-    from PileUpComps.PileUpCompsConf import DigitizationAlg
-    return DigitizationAlg(name, **kwargs)
+    return getStandardPileUpToolsAlg(name, **kwargs)
+
+def getTestPileUpToolsAlg(name="TestPileUpToolsAlg", **kwargs):
+    PileUpToolsList = [ "TestPileUpTool" ]
+    kwargs.setdefault('PileUpTools', PileUpToolsList )
+    from AthenaCommon.Constants import *
+    kwargs.setdefault('OutputLevel', DEBUG )
+    return getStandardPileUpToolsAlg(name, **kwargs)
+
+def getTestFilterPileUpToolsAlg(name="TestFilterPileUpToolsAlg", **kwargs):
+    PileUpToolsList = [ "TestFilterPileUpTool" ]
+    kwargs.setdefault('PileUpTools', PileUpToolsList )
+    from AthenaCommon.Constants import *
+    kwargs.setdefault('OutputLevel', DEBUG )
+    return getStandardPileUpToolsAlg(name, **kwargs)
+
+def getTestTruthJetFilterPileUpToolsAlg(name="TestTruthJetFilterPileUpToolsAlg", **kwargs):
+    PileUpToolsList = [ "MergeTruthJetsFilterTool" ]
+    kwargs.setdefault('PileUpTools', PileUpToolsList )
+    from AthenaCommon.Constants import *
+    kwargs.setdefault('OutputLevel', DEBUG )
+    return getStandardPileUpToolsAlg(name, **kwargs)

Simulation/Digitization/python/DigiOutput.py

@@ -136,6 +136,9 @@ def getStreamRDO_ItemList(log):
                 StreamRDO_ItemList+=["LArDigitContainer#*"]
             else:
                 StreamRDO_ItemList+=["LArDigitContainer#LArDigitContainer_MC_Thinned"]
+    if hasattr(DetFlags.digitize, 'HGTD_on') and DetFlags.digitize.HGTD_on():
+        if DetFlags.writeRDOPool.HGTD_on():
+            StreamRDO_ItemList+=["LArHitContainer#HGTDDigitContainer_MC"]
     if DetFlags.digitize.Tile_on():
         if DetFlags.writeRDOPool.Tile_on():
             StreamRDO_ItemList+=["TileRawChannelContainer#*"]

Simulation/Digitization/python/DigitizationConfigDb.py

@@ -18,6 +18,9 @@ addTool("Digitization.PileUpConfig.getCavernCache"                   , "CavernCa
 addTool("Digitization.PileUpConfig.getBeamGasCache"                  , "BeamGasCache")
 addTool("Digitization.PileUpConfig.getBeamHaloCache"                 , "BeamHaloCache")
 
+addTool("Digitization.DigiAlgConfig.getTestPileUpTool"               , "TestPileUpTool")
+addTool("Digitization.DigiAlgConfig.getTestFilterPileUpTool"         , "TestFilterPileUpTool")
+
 addService("Digitization.RunDependentConfig.getLumiProfileSvc"       , "LumiProfileSvc")
 addService("Digitization.RunDependentConfig.getNoProfileSvc"         , "NoProfileSvc")
 addService("Digitization.RunDependentConfig.getEvtIdModifierSvc"     , "EvtIdModifierSvc")
@@ -33,5 +36,8 @@ addAlgorithm("Digitization.DigiAlgConfig.getSplitNoMergePileUpToolsAlg"  , "Spli
 addAlgorithm("Digitization.DigiAlgConfig.getSplitNoMergeSFPileUpToolsAlg"  , "SplitNoMergeSFPileUpToolsAlg")
 addAlgorithm("Digitization.DigiAlgConfig.getSplitNoMergeFSPileUpToolsAlg"  , "SplitNoMergeFSPileUpToolsAlg")
 addAlgorithm("Digitization.DigiAlgConfig.getSplitNoMergeFFPileUpToolsAlg"  , "SplitNoMergeFFPileUpToolsAlg")
+addAlgorithm("Digitization.DigiAlgConfig.getTestPileUpToolsAlg"      , "TestPileUpToolsAlg")
+addAlgorithm("Digitization.DigiAlgConfig.getTestFilterPileUpToolsAlg"      , "TestFilterPileUpToolsAlg")
+addAlgorithm("Digitization.DigiAlgConfig.getTestTruthJetFilterPileUpToolsAlg" , "TestTruthJetFilterPileUpToolsAlg")
 
 addService("Digitization.PileUpMergeSvcConfig.getPileUpMergeSvc"     , "PileUpMergeSvc")

Simulation/Digitization/python/DigitizationFlags.py

@@ -418,6 +418,15 @@ class doXingByXingPileUp(JobProperty):
     allowedTypes=['bool']
     StoredValue=False
 
+#
+class doBichselSimulation(JobProperty):
+    """ Should the Bichsel model be used in Pixel and SCT
+    Digitization.
+    """
+    statusOn=False
+    allowedTypes=['bool']
+    StoredValue=False
+
 class IOVDbGlobalTag(JobProperty):
     """ This overrides the default IOVDbGlobalTag which
         corresponds to the detector description in
@@ -781,8 +790,8 @@ jobproperties.add_Container(Digitization)
 # We want always the following flags in the container
 list_jobproperties=[doInDetNoise,doCaloNoise,doMuonNoise,doFwdNoise,doRadiationDamage,\
                     rndmSvc,rndmSeedList,rndmSeedOffset1,rndmSeedOffset2,readSeedsFromFile,\
-                    rndmSeedInputFile,physicsList,overrideMetadata,IOVDbGlobalTag,SimG4VersionUsed,\
-                    numberOfCollisions,\
+                    rndmSeedInputFile,physicsList,overrideMetadata,doBichselSimulation,\
+                    IOVDbGlobalTag,SimG4VersionUsed,numberOfCollisions,\
                     doLowPtMinBias,numberOfLowPtMinBias,LowPtMinBiasInputCols,\
                     doHighPtMinBias,numberOfHighPtMinBias,HighPtMinBiasInputCols,\
                     doCavern,numberOfCavern,cavernInputCols,\

Simulation/Digitization/python/DigitizationReadMetaData.py

@@ -269,7 +269,7 @@ def signalMetaDataCheck(metadatadict):
     if not skipCheck('SimulatedDetectors'):
         if 'SimulatedDetectors' in simkeys:
             logDigitizationReadMetadata.debug("Switching off subdetectors which were not simulated")
-            possibleSubDetectors=['pixel','SCT','TRT','BCM','Lucid','ZDC','ALFA','AFP','FwdRegion','LAr','Tile','MDT','CSC','TGC','RPC','Micromegas','sTGC','Truth']
+            possibleSubDetectors=['pixel','SCT','TRT','BCM','Lucid','ZDC','ALFA','AFP','FwdRegion','LAr','HGTD','Tile','MDT','CSC','TGC','RPC','Micromegas','sTGC','Truth']
             switchedOffSubDetectors=[]
             for subdet in possibleSubDetectors:
                 if not subdet in metadatadict['SimulatedDetectors']:

Simulation/Digitization/python/DigitizationWriteMetaData.py

@@ -186,11 +186,11 @@ def writeDigitizationMetadata():
 
     ## Digitized detector flags: add each enabled detector to the DigitizedDetectors list
     digiDets = []
-    for det in ['pixel','SCT','TRT','BCM','Lucid','ZDC','ALFA','AFP','FwdRegion','LAr','Tile','MDT','CSC','TGC','RPC','Micromegas','sTGC','Truth','LVL1']:
+    for det in ['pixel','SCT','TRT','BCM','Lucid','ZDC','ALFA','AFP','FwdRegion','LAr','HGTD','Tile','MDT','CSC','TGC','RPC','Micromegas','sTGC','Truth','LVL1']:
         attrname = det+"_on"
         checkfn = getattr(DetFlags.digitize, attrname, None)
         if checkfn is None:
-            logDigitizationWriteMetadata.warning("No attribute '%s' found on DetFlags.digitize" % attrname)
+            logDigitizationWriteMetadata.info("No attribute '%s' found on DetFlags.digitize" % attrname)
             continue
         if checkfn():
             digiDets.append(det)

Simulation/Digitization/python/PileUpMergeSvcConfig.py

@@ -2,7 +2,7 @@
 
 from AthenaCommon import CfgMgr
 from AthenaCommon import CfgGetter
-
+#FIXME no need for all these getPrivateTool calls.
 def getPileUpMergeSvc(name="PileUpMergeSvc", **kwargs):
     from Digitization.DigitizationFlags import digitizationFlags
     if not digitizationFlags.doXingByXingPileUp(): # PileUpTool approach
@@ -22,7 +22,7 @@ def getPileUpMergeSvc(name="PileUpMergeSvc", **kwargs):
             IntervalsList += [ CfgGetter.getPrivateTool("ZdcRange",       checkType=True) ]
         if DetFlags.pileup.ALFA_on():
             IntervalsList += [ CfgGetter.getPrivateTool("ALFARange",      checkType=True) ]
-        if hasattr(DetFlags.pileup, 'AFP_on') and DetFlags.pileup.AFP_on(): # temp protection
+        if DetFlags.pileup.AFP_on():
             IntervalsList += [ CfgGetter.getPrivateTool("AFPRange",      checkType=True) ]
         ## Inner Detector Digitization
         if DetFlags.pileup.BCM_on():
@@ -48,6 +48,8 @@ def getPileUpMergeSvc(name="PileUpMergeSvc", **kwargs):
             IntervalsList += [ CfgGetter.getPrivateTool("LArRangeEM",     checkType=True) ]
             IntervalsList += [ CfgGetter.getPrivateTool("LArRangeHEC",    checkType=True) ]
             IntervalsList += [ CfgGetter.getPrivateTool("LArRangeFCAL",   checkType=True) ]
+        if hasattr(DetFlags.pileup, 'HGTD_on') and DetFlags.pileup.HGTD_on(): # No HGTD in Overlay samples (yet!)
+            IntervalsList += [ CfgGetter.getPrivateTool("LArRangeHGTD",   checkType=True) ]
         if DetFlags.pileup.Tile_on():
             IntervalsList += [ CfgGetter.getPrivateTool("TileRange",      checkType=True) ]
         ## Muon System Digitization

Simulation/Digitization/share/ConfigDigitization.py

@@ -10,6 +10,8 @@ checkDetFlagConfiguration()
 from AthenaCommon.AppMgr import ServiceMgr
 if not hasattr(ServiceMgr, 'EventSelector'):
     import AthenaPoolCnvSvc.ReadAthenaPool
+if hasattr(ServiceMgr, 'PoolSvc'):
+    ServiceMgr.PoolSvc.MaxFilesOpen = 0 # Never close Input Files
 from AthenaCommon.AthenaCommonFlags import athenaCommonFlags
 if not athenaCommonFlags.DoFullChain:
     ServiceMgr.EventSelector.InputCollections = athenaCommonFlags.PoolHitsInput()

Simulation/Digitization/share/Digitization.py

@@ -45,6 +45,8 @@ else :
     #DetFlags.AFP_setOn()
     #DetFlags.FwdRegion_setOn()
     DetFlags.Calo_setOn()
+    if hasattr(DetFlags, 'HGTD_setOff'):
+        DetFlags.HGTD_setOff()
     DetFlags.Muon_setOn()
     DetFlags.Truth_setOn()
     DetFlags.LVL1_setOn()