def __init__(self, name = "EFCaloHypoNoiseConfig",ef_thr=20*GeV,etaMin=0,etaMax=10):
super( EFCaloHypoNoiseConfig, self ).__init__( name )
self.Etcut = ef_thr
self.BadFEBCut=3
if 'COMP200' not in conddb.GetInstance() and not conddb.isMC:
if not hasattr(svcMgr.ToolSvc, "KnownBADFEBsTool"):
theBadFebTool=LArBadChanTool("KnownBADFEBsTool")
theBadFebTool.CoolMissingFEBsFolder="/LAR/BadChannels/KnownBADFEBs"
havefolder=False
for fld in conddb.iovdbsvc.Folders:
if "KnownBADFEBs" in fld: havefolder=True
pass
if not havefolder:
conddb.addFolder("LAR_ONL","/LAR/BadChannels/KnownBADFEBs")
svcMgr.ToolSvc+=theBadFebTool
else:
theBadFebTool=svcMgr.ToolSvc.KnownBADFEBsTool
if not hasattr(svcMgr.ToolSvc, "KnownMNBFEBsTool"):
theMNBFebTool=LArBadChanTool("KnownMNBFEBsTool")
theMNBFebTool.CoolMissingFEBsFolder="/LAR/BadChannels/KnownMNBFEBs"
havefolder=False
for fld in conddb.iovdbsvc.Folders:
if "KnownMNBFEBs" in fld: havefolder=True
pass
if not havefolder:
conddb.addFolder("LAR_ONL","/LAR/BadChannels/KnownMNBFEBs")
svcMgr.ToolSvc+=theMNBFebTool
else:
theMNBFebTool=svcMgr.ToolSvc.KnownMNBFEBsTool
theLArNoisyROTool=LArNoisyROTool(SaturatedCellTightCut=20,MNBLooseCut=5,MNBTightCut=17,KnownBADFEBsTool=theBadFebTool,KnownMNBFEBsTool=theMNBFebTool)
else:
theLArNoisyROTool=LArNoisyROTool(SaturatedCellTightCut=20,MNBLooseCut=5,MNBTightCut=17)
self.NoiseTool = theLArNoisyROTool
def make_bad_channel_tool(name, badfebs=[]):
from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool
febfile = ''
if badfebs:
febfile = name + '.badfebs'
f = open(febfile, 'w')
for (feb, err) in badfebs:
print >> f, feb[0], feb[1], feb[2], feb[3], err
f.close()
return LArBadChanTool(name,
ReadFromASCII=True,
WriteEmptyFolders=True,
CoolFolder='',
ComplementaryCoolFolder='',
CoolMissingFEBsFolder='',
FEBfile=febfile)
include.block("TrigT2CaloCommon/CaloCellMasking.py")
from AthenaCommon.AppMgr import ToolSvc #if not already imported
from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool, LArBadChannelMasker
ToolSvc += LArBadChanTool("MyBadChanTool")
ToolSvc.MyBadChanTool.ReadFromASCII = False #Not necessary if you have already produced a database file
ToolSvc.MyBadChanTool.ComplementaryCoolFolder = "/LAR/BadChannels/BadChannelsOnl"
#ToolSvc.MyBadChanTool.OutputLevel=VERBOSE
#ToolSvc.MyBadChanTool.OutputLevel=DEBUG
#The masker tool name must be "LArBadChannelMasker", the same as retrieved in LArCellCont.cxx
ToolSvc += LArBadChannelMasker("LArBadChannelMasker")
ToolSvc.LArBadChannelMasker.ProblemsToMask = [
"unstable", "short", "highNoiseHG", "highNoiseMG", "highNoiseLG",
"problematicForUnknownReason"
] #See LArBadChanBitPacking.cxx for the list of strings that can be used.
ToolSvc.LArBadChannelMasker.DoMasking = True #Masking can easily be turned on and off here.
#ToolSvc.LArBadChannelMasker.OutputLevel=DEBUG
ToolSvc.LArBadChannelMasker.TheLArBadChanTool = ToolSvc.MyBadChanTool #Tell the Masker to use the LArBadChanTool that was just configured.
#IOVDbSvc=theApp.service('IOVDbSvc')
#if ( svcMgr.IOVDbSvc.GlobalTag!="COMCOND-002-00" and svcMgr.IOVDbSvc.GlobalTag!="COMCOND-003-00" and svcMgr.IOVDbSvc.GlobalTag!="COMCOND-004-00" and svcMgr.IOVDbSvc.GlobalTag!="COMCOND-005-00" ):
#else:
if not conddb.folderRequested('/LAR/BadChannels/BadChannels'):
conddb.addFolder(LArDB, "/LAR/BadChannels/BadChannels")
conddb.addFolder(LArDB, "/LAR/BadChannels/BadChannelsOnl")
from TileConditions.TileInfoConfigurator import TileInfoConfigurator
tIC = TileInfoConfigurator()
tIC.setupCOOL()
# Correction #
# #
######################################################################
# Not done on splitted caliwaves yet
if CorrectBadChannels:
from LArCalibUtils.LArCalibUtilsConf import LArCalibPatchingAlg_LArCaliWaveContainer_
theLArCaliWavePatcher = LArCalibPatchingAlg_LArCaliWaveContainer_(
"LArCaliWavePatcher")
theLArCaliWavePatcher.ContainerKey = KeyOutput
#theLArCaliWavePatcher.PatchMethod="PhiNeighbor" ##take the first neigbour
theLArCaliWavePatcher.PatchMethod = "PhiAverage" ##do an aveage in phi after removing bad and empty event
theLArCaliWavePatcher.OutputLevel = INFO
from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool
theLArBadChannelTool = LArBadChanTool()
theLArBadChannelTool.OutputLevel = DEBUG
theLArBadChannelTool.CoolFolder = BadChannelsFolder
theLArBadChannelTool.CoolMissingFEBsFolder = MissingFEBsFolder
ToolSvc += theLArBadChannelTool
from LArBadChannelTool.LArBadChannelToolConf import LArBadChannelMasker
theLArRCBMasker = LArBadChannelMasker("LArRCBMasker")
theLArRCBMasker.DoMasking = True
theLArRCBMasker.ProblemsToMask = [
"deadCalib",
"deadReadout",
"deadPhys",
"almostDead",
"short",
]
from CaloRec.CaloRecConf import CBNTAA_CaloCell
CBNT_LArCell = CBNTAA_CaloCell("CBNT_LArCell")
CBNT_AthenaAware += CBNT_LArCell
from CaloIdentifier import SUBCALO
CBNT_LArCell.CaloNums = [SUBCALO.LAREM, SUBCALO.LARHEC, SUBCALO.LARFCAL]
# cell by cell info
CBNT_LArCell.MaxNCells = 200000
CBNT_LArCell.Suffix = "LAr"
CBNT_LArCell.SaveDetInfo = True
CBNT_LArCell.SaveTimeInfo = True
CBNT_LArCell.SaveId = True
CBNT_LArCell.SaveQualityInfo = True
CBNT_LArCell.CellSigmaCut = 3.
from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool
from AthenaCommon.AppMgr import ToolSvc
ToolSvc += LArBadChanTool()
from CaloTools.CaloNoiseToolDefault import CaloNoiseToolDefault
theCaloNoiseTool = CaloNoiseToolDefault()
ToolSvc += theCaloNoiseTool
CBNT_LArCell.NoiseTool = theCaloNoiseTool
#CBNT for digits
from LArROD.LArRODConf import CBNTAA_LArDigits
theCBNTAA_LArDigits = CBNTAA_LArDigits("CBNTAA_LArDigits")
theCBNTAA_LArDigits.MaxChannels = 200000
theCBNTAA_LArDigits.NEvents = -1
theCBNTAA_LArDigits.DumpIterResults = True
theCBNTAA_LArDigits.SaveId = True
theCBNTAA_LArDigits.SaveSCAAddress = False
theCBNTAA_LArDigits.DumpCut = 0
theCBNTAA_LArDigits.ContainerKey = "LArDigitContainer_Thinned"
from AthenaCommon.GlobalFlags import GlobalFlags
#need this set_data() uncommented for real data, commented for monte carlo
GlobalFlags.DataSource.set_data()
include( "RecExCond/AllDet_detDescr.py")
if MissingETData.UseCaloNoiseTool == True:
from CaloTools.CaloNoiseToolDefault import CaloNoiseToolDefault
theCaloNoiseTool=CaloNoiseToolDefault()
from AthenaCommon.AppMgr import ToolSvc
ToolSvc+=theCaloNoiseTool
MissingETData.CaloNoiseTool = theCaloNoiseTool
#theCaloNoiseTool.OutputLevel = 1
if MissingETData.UseBadChannelTool == True:
from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool
theLArBadChanTool=LArBadChanTool("LArBadChanTool")
theLArBadChanTool.OutputLevel=DEBUG
#can put in bad channels by hand in text files by setting this true and specifying names of text files, see LArBadChanTool documentation
theLArBadChanTool.ReadFromASCII=False
#have to specify the these names iff ReadFromASCII=True
#theLArBadChanTool.EMBAfile = 'EMBA.txt'
#theLArBadChanTool.EMBCfile = 'EMBC.txt'
#theLArBadChanTool.EMECAfile = 'EMECA.txt'
#theLArBadChanTool.EMECCfile = 'EMECC.txt'
#theLArBadChanTool.HECAfile = 'HECA.txt'
#theLArBadChanTool.HECCfile = 'HECC.txt'
#theLArBadChanTool.FCALAfile = 'FCALA.txt'
#theLArBadChanTool.FCALCfile = 'FCALC.txt'
#theLArBadChanTool.FEBfile = 'FEB.txt'
ToolSvc+=theLArBadChanTool
MissingETData.BadChannelTool = theLArBadChanTool
pass
##LAr####################################################################################
#preopts
#conddb.addFolderWithTag('LAR_OFL','/LAR/BadChannelsOfl/BadChannels','LArBadChannelsOflBadChannels-IOVDEP-00',forceData=True)
#conddb.addFolderWithTag('LAR_OFL','/LAR/BadChannelsOfl/MissingFEBs','LArBadChannelsOflMissingFEBs-IOVDEP-00',forceData=True)
#if not hasattr (ServiceMgr.ToolSvc, 'LArBadChanTool'):
# from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool
# ServiceMgr.ToolSvc += LArBadChanTool()
# ServiceMgr.ToolSvc.LArBadChanTool.CoolFolder="/LAR/BadChannelsOfl/BadChannels"
# ServiceMgr.ToolSvc.LArBadChanTool.CoolMissingFEBsFolder="/LAR/BadChannelsOfl/MissingFEBs"
conddb.blockFolder('/LAR/BadChannels/BadChannels')
conddb.addFolderWithTag('LAR_OFL',
'/LAR/BadChannels/BadChannels',
'LArBadChannelsBadChannels-IOVDEP-01',
force=True)
conddb.blockFolder('/LAR/BadChannels/MissingFEBs')
conddb.addFolderWithTag('LAR_OFL',
'/LAR/BadChannels/MissingFEBs',
'LArBadChannelsMissingFEBs-IOVDEP-01',
force=True)
if not hasattr(ServiceMgr.ToolSvc, 'LArBadChanTool'):
from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool
ServiceMgr.ToolSvc += LArBadChanTool()
ServiceMgr.ToolSvc.LArBadChanTool.CoolFolder = "/LAR/BadChannels/BadChannels"
ServiceMgr.ToolSvc.LArBadChanTool.CoolMissingFEBsFolder = "/LAR/BadChannels/MissingFEBs"
##Tile####################################################################################
pass
##Muons###################################################################################
#from MDT_Digitization.MDT_DigitizationConf import MdtDigitizationTool as mdt
#mdt.UseDeadChamberSvc = True
# --- for athena online running ---
if 'EventBlockSize' not in dir():
EventBlockSize = 0
###### LAr FEBMon Tool Configuration ###############
from LArMonTools.LArMonToolsConf import LArFEBMon
conddb.addFolder('LAR', '/LAR/Configuration/DSPThreshold/Thresholds')
theLArFEBMon = LArFEBMon(name="LArFEBMon",
ProcessNEvents=EventBlockSize,
IgnoreMissingHeaderPS=False,
IgnoreMissingHeaderEMB=False)
ToolSvc += theLArFEBMon
LArMon.AthenaMonTools += [theLArFEBMon]
# BadChannelTool configuration
from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool
theLArBadChannelTool = LArBadChanTool()
theLArBadChannelTool.ReadFromASCII = False
ToolSvc += theLArBadChannelTool
ToolSvc.LArFEBMon.LArBadChannelTool = theLArBadChannelTool
#to change an option later, do e.g
#ToolSvc.LArFEBMon.maxOfTimingHisto =100
#ToolSvc.LArFEBMon.OutputLevel =DEBUG
## get a handle to the ApplicationManager, to the ServiceManager and to the ToolSvc
from AthenaCommon.AppMgr import (theApp, ServiceMgr as svcMgr,ToolSvc)
BadChanTag=join(split(BadChanFolder, '/'),'') + TagPostfix
FEBTag=join(split(FEBFolder, '/'),'') + TagPostfix
DBConnection = "<dbConnection>sqlite://;schema=BadChannels.db;dbname=CONDBR2</dbConnection>"
DBBadChanFolder = BadChanFolder + "<tag>" + BadChanTag + "</tag>" + DBConnection
DBFebFolder = FEBFolder + "<tag>" + FEBTag + "</tag>" + DBConnection
svcMgr.IOVDbSvc.Folders+=[DBBadChanFolder]
svcMgr.IOVDbSvc.Folders+=[DBFebFolder]
#svcMgr.IOVDbSvc.Folders+=["/LAR/BadChannels/BadChannels<tag>LARBadChannelsBadChannels-M6-01</tag><dbConnection>sqlite://;schema=BadChannels.db;dbname=CONDBR2</dbConnection>" ]
#svcMgr.IOVDbSvc.Folders+=["/LAR/BadChannels/MissingFEBs<tag>LARBadChannelsMissingFEBs-M6-01</tag><dbConnection>sqlite://;schema=BadChannels.db;dbname=CONDBR2</dbConnection>" ]
#conddb.addFolder("LAR","/LAR/BadChannels/BadChannels")
svcMgr.IOVDbSvc.GlobalTag=GlobalTag
from LArBadChannelTool.LArBadChannelToolConf import LArBadChannelToolTest
theLArBadChannels=LArBadChannelToolTest()
#theLArBadChannels.FileName="bc_out.txt"
topSequence+=theLArBadChannels
from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool
theLArBadChannelTool=LArBadChanTool()
theLArBadChannelTool.OutputLevel=DEBUG
theLArBadChannelTool.DumpCache = True
theLArBadChannelTool.CoolMissingFEBsFolder = "/LAR/BadChannels/MissingFEBs" # read missing FEBs folder
#theLArBadChannelTool.CoolMissingFEBsFolder = "" # deactivate missing FEBs folder
ToolSvc+=theLArBadChannelTool
## theByteStreamInputSvc.FullFileName=["/home/wlampl/LArOFIter/ramp/inputs/daq.Ramp.0029146.No.Streaming.LB0000.EB-EMBA._0001.data"]
## theByteStreamInputSvc.MaxBadEvents=0
#That's the dumper, keep for now
from LArCalibTest.LArCalibTestConf import DumpCaloBadChannels
theDumper = DumpCaloBadChannels()
theDumper.FileName = "list.txt"
topSequence += theDumper
#Thats the registration algo
#from LArBadChannelTool.LArBadChannelToolConf import LArBadChannelDBAlg
#topSequence += LArBadChannelDBAlg( "BadChanAlg" )
from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool
theLArBadChannelTool = LArBadChanTool()
theLArBadChannelTool.ReadFromASCII = False
theLArBadChannelTool.DumpCache = True
#theLArBadChannelTool.ASCIIFileName="/home/wlampl/LArCondPatcher/dead_dummy.txt"
#theLArBadChannelTool.EMBAfile ="/afs/cern.ch/user/t/todorov/scratch0/testarea/rel_5/LArCalorimeter/LArBadChannelTool/share/noisePb_29142.txt"
#theLArBadChannelTool.EMBCfile ="/afs/cern.ch/user/t/todorov/scratch0/testarea/rel_5/LArCalorimeter/LArBadChannelTool/share/noisePb_29142.txt"
theLArBadChannelTool.OutputLevel = DEBUG
ToolSvc += theLArBadChannelTool
svcMgr.IOVDbSvc.Folders += [
"/LAR/BadChannels/BadChannels<tag>LARBadChannelsBadChannels-M6-01</tag><dbConnection>sqlite://;schema=BadChannels.db;dbname=CONDBR2</dbConnection>"
]
svcMgr.IOVDbSvc.Folders += [
"/LAR/BadChannels/MissingFEBs<tag>LARBadChannelsMissingFEBs-M6-01</tag><dbConnection>sqlite://;schema=BadChannels.db;dbname=CONDBR2</dbConnection>"
]
svcMgr.IOVDbSvc.GlobalTag = "CONDBR2-ES1PA-2014-01"
if 'EventBlockSize' not in dir():
EventBlockSize = 0
###### LAr Coverage Tool Configuration ###############
from LArMonTools.LArMonToolsConf import LArCoverage
theLArCoverage = LArCoverage(name="LArCoverage",
ProcessNEvents=EventBlockSize,
LArDigitContainerKey=LArMonFlags.LArDigitKey(),
LArBadChannelMask=theLArBadChannelsMasker,
Nevents=40)
ToolSvc += theLArCoverage
LArMon.AthenaMonTools += [theLArCoverage]
# BadChannelTool configuration
from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool
theLArBadChannelTool = LArBadChanTool()
theLArBadChannelTool.ReadFromASCII = False
ToolSvc += theLArBadChannelTool
ToolSvc.LArCoverage.LArBadChannelTool = theLArBadChannelTool
# KnownMNBFEBsTool configuration
if 'COMP200' not in conddb.GetInstance():
theMNBFebTool = LArBadChanTool("KnownMNBFEBsTool")
theMNBFebTool.CoolMissingFEBsFolder = "/LAR/BadChannels/KnownMNBFEBs"
ToolSvc += theMNBFebTool
ToolSvc.LArCoverage.LArKnownMNBFEBsTool = theMNBFebTool
# CaloNoiseTool configuration
from CaloTools.CaloNoiseToolDefault import CaloNoiseToolDefault
theLArCoverageCaloNoiseTool = CaloNoiseToolDefault()
ToolSvc += theLArCoverageCaloNoiseTool
svcMgr.EventSelector.FirstLB = LBNumber
## get a handle to the default top-level algorithm sequence
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
## get a handle to the ApplicationManager, to the ServiceManager and to the ToolSvc
from AthenaCommon.AppMgr import (theApp, ServiceMgr as svcMgr,ToolSvc)
if "sqlite" in dir():
conddb.addFolder("","/LAR/BadChannelsOfl/MissingFEBs<db>sqlite://;schema="+sqlite+";dbname="+DBInstance+"</db><tag>LARBadChannelsOflMissingFEBs-RUN2-UPD3-01</tag>")
else:
conddb.addFolder("LAR_OFL","/LAR/BadChannelsOfl/MissingFEBs")#<tag>LARBadChannelsMissingFEBs-empty</tag>")
svcMgr.IOVDbSvc.GlobalTag="CONDBR2-ES1PA-2017-04"
from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool
theLArBadChannelTool=LArBadChanTool()
theLArBadChannelTool.CoolFolder=""
theLArBadChannelTool.CoolMissingFEBsFolder="/LAR/BadChannelsOfl/MissingFEBs"
ToolSvc+=theLArBadChannelTool
from LArBadChannelTool.LArBadChannelToolConf import LArBadFeb2Ascii
theLArBadFeb2Ascii=LArBadFeb2Ascii()
theLArBadFeb2Ascii.FileName=OutputFile
topSequence+=theLArBadFeb2Ascii
def configure(self):
from AthenaCommon.Logging import logging
mlog = logging.getLogger('CaloCellGetter_DigiHSTruth::configure:')
mlog.info('entering')
from CaloRec.CaloCellFlags import jobproperties
doStandardCellReconstruction = True
# get handle to upstream object
# handle tile
if doStandardCellReconstruction:
# handle LAr
import traceback
try:
from LArROD.LArRawChannelGetter_DigiHSTruth import LArRawChannelGetter_DigiHSTruth
theLArRawChannelGetter = LArRawChannelGetter_DigiHSTruth()
except:
mlog.error(
"could not get handle to LArRawChannel_DigiHSTruth Quit")
print traceback.format_exc()
return False
if not theLArRawChannelGetter.usable():
if not self.ignoreConfigError():
mlog.error(
"LArRawChannelGetter_DigiHSTruth unusable. Quit.")
return False
else:
mlog.error(
"LArRawChannelGetter_DigiHSTruth unusable. Continue nevertheless"
)
# now configure the algorithm, part of this could be done in a separate class
# cannot have same name
try:
from CaloRec.CaloRecConf import CaloCellMaker
except:
mlog.error("could not import CaloRec.CaloCellMaker")
print traceback.format_exc()
return False
theCaloCellMaker = CaloCellMaker("CaloCellMaker_DigiHSTruth")
self._CaloCellMakerHandle = theCaloCellMaker
from AthenaCommon.AppMgr import ToolSvc
if doStandardCellReconstruction:
# configure CaloCellMaker here
# check LArCellMakerTool_jobOptions.py for full configurability
# FIXME
from RecExConfig.RecFlags import rec
if rec.doLArg():
try:
from LArCellRec.LArCellRecConf import LArCellBuilderFromLArRawChannelTool
theLArCellBuilder = LArCellBuilderFromLArRawChannelTool(
"LArCellBuilder_DigiHSTruth")
theLArCellBuilder.RawChannelsName = "LArRawChannels_DigiHSTruth"
except:
mlog.error(
"could not get handle to LArCellBuilderFromLArRawChannel Quit"
)
print traceback.format_exc()
return False
if jobproperties.CaloCellFlags.doLArCreateMissingCells():
# bad channel tools
try:
from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool
theLArBadChannelTool = LArBadChanTool()
except:
mlog.error("could not access bad channel tool Quit")
print traceback.format_exc()
return False
ToolSvc += theLArBadChannelTool
theLArCellBuilder.addDeadOTX = True
theLArCellBuilder.badChannelTool = theLArBadChannelTool
# add the tool to list of tool ( should use ToolHandle eventually)
ToolSvc += theLArCellBuilder
theCaloCellMaker.CaloCellMakerToolNames += [theLArCellBuilder]
from AthenaCommon.GlobalFlags import globalflags
try:
from TileRecUtils.TileRecUtilsConf import TileCellBuilder
theTileCellBuilder = TileCellBuilder(
"TileCellBuilder_DigiHSTruth")
theTileCellBuilder.TileRawChannelContainer = "TileRawChannelCnt_DigiHSTruth"
theTileCellBuilder.E4prContainer = "E4prContainer2_DigiHSTruth"
theTileCellBuilder.MBTSContainer = "MBTSContainer2_DigiHSTruth"
theTileCellBuilder.TileDSPRawChannelContainer = "TileRawChannelCnt_DigiHSTruth"
if not hasattr(ToolSvc, "TileBeamInfoProvider"):
from TileRecUtils.TileRecUtilsConf import TileBeamInfoProvider
ToolSvc += TileBeamInfoProvider()
ToolSvc += theTileCellBuilder
theCaloCellMaker.CaloCellMakerToolNames += [
theTileCellBuilder
]
except:
mlog.error("could not get handle to TileCellBuilder Quit")
print traceback.format_exc()
return False
#
# CaloCellContainerFinalizerTool : closing container and setting up iterators
#
from CaloRec.CaloRecConf import CaloCellContainerFinalizerTool
theCaloCellContainerFinalizerTool = CaloCellContainerFinalizerTool()
ToolSvc += theCaloCellContainerFinalizerTool
theCaloCellMaker.CaloCellMakerToolNames += [
theCaloCellContainerFinalizerTool
]
from RecExConfig.RecFlags import rec
#
# masking of noisy and sporadic noisy cells in LAr
#
doNoiseMask = False
if jobproperties.CaloCellFlags.doLArNoiseMasking.statusOn and jobproperties.CaloCellFlags.doLArNoiseMasking(
):
doNoiseMask = True
doSporadicMask = False
if jobproperties.CaloCellFlags.doLArSporadicMasking.statusOn and jobproperties.CaloCellFlags.doLArSporadicMasking(
):
doSporadicMask = True
if doNoiseMask or doSporadicMask:
try:
from LArCellRec.LArCellRecConf import LArCellNoiseMaskingTool
theLArCellNoiseMaskingTool = LArCellNoiseMaskingTool()
except:
mlog.error(
"could not get handle to LArCellNoiseMaskingTool Quit")
print traceback.format_exc()
return False
# bad channel tools
try:
from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool
theLArBadChannelTool = LArBadChanTool()
except:
mlog.error("could not access bad channel tool Quit")
print traceback.format_exc()
return False
ToolSvc += theLArBadChannelTool
if doSporadicMask:
try:
from LArBadChannelTool.LArBadChannelToolConf import LArBadChannelMasker
theLArSporadicNoiseMasker = LArBadChannelMasker(
"LArSporadicNoiseMasker")
except:
mlog.error("could not access bad channel tool Quit")
print traceback.format_exc()
return False
theLArSporadicNoiseMasker.TheLArBadChanTool = theLArBadChannelTool
theLArSporadicNoiseMasker.DoMasking = True
theLArSporadicNoiseMasker.ProblemsToMask = [
"sporadicBurstNoise"
]
ToolSvc += theLArSporadicNoiseMasker
theLArCellNoiseMaskingTool.MaskingSporadicTool = theLArSporadicNoiseMasker
if doNoiseMask:
try:
from LArBadChannelTool.LArBadChannelToolConf import LArBadChannelMasker
theLArNoiseMasker = LArBadChannelMasker("LArNoiseMasker")
except:
mlog.error("could not access bad channel tool Quit")
print traceback.format_exc()
return False
theLArNoiseMasker.TheLArBadChanTool = theLArBadChannelTool
theLArNoiseMasker.DoMasking = True
theLArNoiseMasker.ProblemsToMask = [
"highNoiseHG", "highNoiseMG", "highNoiseLG", "deadReadout",
"deadPhys"
]
ToolSvc += theLArNoiseMasker
theLArCellNoiseMaskingTool.MaskingTool = theLArNoiseMasker
theLArCellNoiseMaskingTool.maskNoise = doNoiseMask
theLArCellNoiseMaskingTool.maskSporadic = doSporadicMask
# quality cut for sporadic noise masking
theLArCellNoiseMaskingTool.qualityCut = 4000
ToolSvc += theLArCellNoiseMaskingTool
theCaloCellMaker.CaloCellMakerToolNames += [
theLArCellNoiseMaskingTool
]
#
# emulate gain pathologies on MC
#
doGainPathology = False
if jobproperties.CaloCellFlags.doLArCellGainPathology.statusOn and jobproperties.CaloCellFlags.doLArCellGainPathology(
):
from AthenaCommon.GlobalFlags import globalflags
if globalflags.DataSource() == 'geant4':
doGainPathology = True
if doGainPathology:
try:
from LArCellRec.LArCellRecConf import LArCellGainPathology
theLArCellGainPathology = LArCellGainPathology()
except:
mlog.error("could not get handle to LArCellGainPatholog< Quit")
print traceback.format_exc()
return False
ToolSvc += theLArCellGainPathology
theCaloCellMaker.CaloCellMakerToolNames += [
theLArCellGainPathology
]
# lar miscalibration if MC only (should be done after finalisation)
if not jobproperties.CaloCellFlags.doLArCellEmMisCalib.statusOn:
# the flag has not been set, so decide a reasonable default
# this is the old global flags should use the new one as
# soon as monitoring does
doLArCellEmMisCalib = True
else:
doLArCellEmMisCalib = jobproperties.CaloCellFlags.doLArCellEmMisCalib(
)
if doLArCellEmMisCalib:
mlog.info("LArCellEmMisCalibTool requested")
else:
mlog.info("LArCellEmMisCalibTool explicitly not requested")
if doLArCellEmMisCalib:
try:
from LArCellRec.LArCellRecConf import LArCellEmMiscalib
theLArCellEmMiscalib = LArCellEmMiscalib("LArCellEmMiscalib")
except:
mlog.error("could not get handle to LArCellEmMisCalib Quit")
print traceback.format_exc()
return False
# examples on how to change miscalibration. Default values are 0.005 and 0.007
# theLArCellEmMiscalib.SigmaPerRegion = 0.005;
# theLArCellEmMiscalib.SigmaPerCell = 0.005;
ToolSvc += theLArCellEmMiscalib
try:
from CaloRec.CaloRecConf import CaloCellContainerCorrectorTool
from CaloIdentifier import SUBCALO
theMisCalibTool = CaloCellContainerCorrectorTool(
"MisCalibTool",
CaloNums=[SUBCALO.LAREM],
CellCorrectionToolNames=[theLArCellEmMiscalib])
except:
mlog.error("could not get handle to MisCalibTool Quit")
print traceback.format_exc()
return False
ToolSvc += theMisCalibTool
theCaloCellMaker.CaloCellMakerToolNames += [theMisCalibTool]
#
# Pedestal shift correction
#
doPedestalCorr = False
if jobproperties.CaloCellFlags.doPedestalCorr.statusOn:
from AthenaCommon.GlobalFlags import globalflags
if jobproperties.CaloCellFlags.doPedestalCorr() and (
globalflags.DataSource() == 'data'
or jobproperties.CaloCellFlags.doPileupOffsetBCIDCorr):
doPedestalCorr = True
mlog.info("Apply cell level pedestal shift correction")
import os
#if doPedestalCorr and os.getenv("CMTPATH") and "AtlasTrigger" in os.getenv("CMTPATH"):
if doPedestalCorr:
try:
from CaloCellCorrection.CaloCellPedestalCorrDefault import CaloCellPedestalCorrDefault
theCaloCellPedestalCorr = CaloCellPedestalCorrDefault()
ToolSvc += theCaloCellPedestalCorr
theCaloCellMaker.CaloCellMakerToolNames += [
theCaloCellPedestalCorr
]
except:
mlog.error("could not get handle to CaloCellPedestalCorr")
print traceback.format_exc()
#
# Correction for MinBias energy shift for MC pileup reco
#
doMinBiasAverage = False
if jobproperties.CaloCellFlags.doMinBiasAverage.statusOn:
from AthenaCommon.GlobalFlags import globalflags
from AthenaCommon.BeamFlags import jobproperties
if jobproperties.CaloCellFlags.doMinBiasAverage(
) and globalflags.DataSource() == 'geant4' and (
not jobproperties.Beam.zeroLuminosity()):
doMinBiasAverage = True
if doMinBiasAverage:
try:
from CaloTools.CaloMBAverageToolDefault import CaloMBAverageToolDefault
theCaloMBAverageTool = CaloMBAverageToolDefault()
except:
mlog.error("could not get handle to CaloMBAverageTool Quit")
print traceback.format_exc()
return False
ToolSvc += theCaloMBAverageTool
try:
from CaloCellCorrection.CaloCellCorrectionConf import CaloCellMBAverageCorr
theCaloCellMBAverageCorr = CaloCellMBAverageCorr(
"CaloCellMBAverageCorr")
theCaloCellMBAverageCorr.CaloMBAverageTool = theCaloMBAverageTool
except:
mlog.error(
"could not get handle to CaloCellMBAverageCorr Quit")
print traceback.format_exc()
return False
ToolSvc += theCaloCellMBAverageCorr
try:
from CaloRec.CaloRecConf import CaloCellContainerCorrectorTool
from CaloIdentifier import SUBCALO
theMBAverageTool = CaloCellContainerCorrectorTool(
"MBAverageTool",
CaloNums=[SUBCALO.NSUBCALO],
CellCorrectionToolNames=[theCaloCellMBAverageCorr])
except:
mlog.error(
"could not get handle to CaloCellContainerCorrectorTool/MBAverageTool Quit"
)
print traceback.format_exc()
return False
ToolSvc += theMBAverageTool
theCaloCellMaker.CaloCellMakerToolNames += [theMBAverageTool]
#
# Correction for dead cells, where we average the energy density of neighbor cells
#
doNeighborsAverage = False
if jobproperties.CaloCellFlags.doDeadCellCorr.statusOn:
if jobproperties.CaloCellFlags.doDeadCellCorr():
doNeighborsAverage = True
if doNeighborsAverage:
try:
from CaloCellCorrection.CaloCellCorrectionConf import CaloCellNeighborsAverageCorr
theCaloCellNeighborsAverageCorr = CaloCellNeighborsAverageCorr(
"CaloCellNeighborsAverageCorr")
theCaloCellNeighborsAverageCorr.testMode = False
except:
mlog.error(
"could not get handle to CaloCellNeighborsAverageCorr Quit"
)
print traceback.format_exc()
return False
ToolSvc += theCaloCellNeighborsAverageCorr
theCaloCellMaker.CaloCellMakerToolNames += [
theCaloCellNeighborsAverageCorr
]
#
# correction for missing Febs based on L1 readout
doLArDeadOTXCorr = False
if jobproperties.CaloCellFlags.doLArDeadOTXCorr.statusOn and jobproperties.CaloCellFlags.doLArCreateMissingCells.statusOn:
if jobproperties.CaloCellFlags.doLArDeadOTXCorr(
) and jobproperties.CaloCellFlags.doLArCreateMissingCells(
) and doStandardCellReconstruction:
if rec.doTrigger():
doLArDeadOTXCorr = True
else:
mlog.warning(
"Trigger is switched off. Can't run deadOTX correction."
)
if doLArDeadOTXCorr:
try:
from LArCellRec.LArCellDeadOTXCorrToolDefault import LArCellDeadOTXCorrToolDefault
theLArCellDeadOTXCorr = LArCellDeadOTXCorrToolDefault()
except:
mlog.error("could not get handle to LArCellDeadOTXCorr Quit")
print traceback.format_exc()
ToolSvc += theLArCellDeadOTXCorr
theCaloCellMaker.CaloCellMakerToolNames += [theLArCellDeadOTXCorr]
# make lots of checks (should not be necessary eventually)
# to print the check add:
from CaloRec.CaloRecConf import CaloCellContainerCheckerTool
theCaloCellContainerCheckerTool = CaloCellContainerCheckerTool()
ToolSvc += theCaloCellContainerCheckerTool
theCaloCellMaker.CaloCellMakerToolNames += [
theCaloCellContainerCheckerTool
]
# sets output key
theCaloCellMaker.CaloCellsOutputName = self.outputKey()
# register output in objKeyStore
from RecExConfig.ObjKeyStore import objKeyStore
objKeyStore.addStreamESD(self.outputType(), self.outputKey())
# now add algorithm to topSequence
# this should always come at the end
mlog.info(" now adding CaloCellMaker to topSequence")
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
topSequence += theCaloCellMaker
return True
def getLArPileUpTool(name='LArPileUpTool', **kwargs): ## useLArFloat()=True,isOverlay()=False,outputKey='LArDigitContainer_MC'):
from AthenaCommon.Logging import logging
mlog = logging.getLogger( 'LArPileUpToolDefault:' )
mlog.info(" ---- in getLArPileUpTool " )
# the LAr and Calo detector description package
## FIXME includes to be replaced by confGetter configuration.
if not isOverlay():
from AthenaCommon.Resilience import protectedInclude
protectedInclude( "CaloDetMgrDetDescrCnv/CaloDetMgrDetDescrCnv_joboptions.py" )
protectedInclude( "LArDetDescr/LArDetDescr_joboptions.py" )
protectedInclude("LArConditionsCommon/LArConditionsCommon_MC_jobOptions.py")
from Digitization.DigitizationFlags import digitizationFlags
kwargs.setdefault('NoiseOnOff', digitizationFlags.doCaloNoise.get_Value() )
kwargs.setdefault('RndmSvc', digitizationFlags.rndmSvc.get_Value() )
digitizationFlags.rndmSeedList.addSeed("LArDigitization", 1234, 5678 )
kwargs.setdefault('DoDigiTruthReconstruction',digitizationFlags.doDigiTruth())
if digitizationFlags.doXingByXingPileUp():
kwargs.setdefault('FirstXing', -751 )
kwargs.setdefault('LastXing', 101 )
from LArDigitization.LArDigitizationFlags import jobproperties
# check if using high gain for Fcal or not
if (not jobproperties.LArDigitizationFlags.useFcalHighGain()) and (not isOverlay()):
mlog.info("do not use high gain in Fcal digitization ")
kwargs.setdefault('HighGainThreshFCAL', 0 )
else:
mlog.info("use high gain in Fcal digitization or overlay job")
# check if using high gain for EMEC IW or not
if (not jobproperties.LArDigitizationFlags.useEmecIwHighGain()) and (not isOverlay()):
mlog.info("do not use high gain in EMEC IW digitization ")
kwargs.setdefault('HighGainThreshEMECIW',0)
kwargs.setdefault('RndmEvtOverlay', isOverlay() )
kwargs.setdefault('DigitContainer', 'LArDigitContainer_MC' ) ##FIXME - should not be hard-coded
# if doing MC+MC overlay
from AthenaCommon.GlobalFlags import globalflags
if isOverlay() and globalflags.DataSource() == 'geant4':
kwargs.setdefault('isMcOverlay',True)
from LArROD.LArRODFlags import larRODFlags
kwargs.setdefault('Nsamples', larRODFlags.nSamples() )
kwargs.setdefault('firstSample', larRODFlags.firstSample() )
if isOverlay() :
kwargs.setdefault('RandomDigitContainer', 'LArDigitContainer_MC' )
# ADC2MeVTool
mlog.info(" ---- set LArADC2MeVToolDefault")
kwargs.setdefault('ADC2MeVTool', 'LArADC2MeVToolDefault')
# Tool for noise autocorrelation generation
kwargs.setdefault('AutoCorrNoiseTool', 'LArAutoCorrNoiseToolDefault')
# bad channel masking
from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool
theLArBadChannelTool=LArBadChanTool()
from AthenaCommon.AppMgr import ToolSvc
ToolSvc+=theLArBadChannelTool
from LArBadChannelTool.LArBadChannelToolConf import LArBadChannelMasker
theLArRCBMasker=LArBadChannelMasker("LArRCBMasker")
theLArRCBMasker.TheLArBadChanTool = theLArBadChannelTool
theLArRCBMasker.DoMasking=True
theLArRCBMasker.ProblemsToMask=[
"deadReadout","deadPhys"]
ToolSvc+=theLArRCBMasker
kwargs.setdefault('MaskingTool', theLArRCBMasker )
kwargs.setdefault('BadChannelTool', theLArBadChannelTool )
# CosmicTriggerTimeTool for cosmics digitization
from AthenaCommon.BeamFlags import jobproperties
if jobproperties.Beam.beamType == "cosmics" :
from CommissionUtils.CommissionUtilsConf import CosmicTriggerTimeTool
theTriggerTimeTool = CosmicTriggerTimeTool()
ToolSvc += theTriggerTimeTool
kwargs.setdefault('UseTriggerTime', True )
kwargs.setdefault('TriggerTimeToolName', theTriggerTimeTool )
# pileup configuration "algorithm" way
if not digitizationFlags.doXingByXingPileUp():
from AthenaCommon.DetFlags import DetFlags
if DetFlags.pileup.LAr_on() or isOverlay():
kwargs.setdefault('PileUp', True )
kwargs.setdefault('useLArFloat', useLArFloat() )
if useLArFloat():
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
from SGComps.SGCompsConf import AddressRemappingSvc
AddressRemappingSvc = AddressRemappingSvc()
svcMgr += AddressRemappingSvc
from AthenaCommon.ConfigurableDb import getConfigurable
svcMgr += getConfigurable( "ProxyProviderSvc" )()
svcMgr.ProxyProviderSvc.ProviderNames += [ "AddressRemappingSvc" ]
svcMgr.AddressRemappingSvc.TypeKeyOverwriteMaps = [ "LArHitContainer#LArHitEMB->LArHitFloatContainer#LArHitEMB" ,
"LArHitContainer#LArHitEMEC->LArHitFloatContainer#LArHitEMEC",
"LArHitContainer#LArHitHEC->LArHitFloatContainer#LArHitHEC",
"LArHitContainer#LArHitFCAL->LArHitFloatContainer#LArHitFCAL"]
svcMgr.AddressRemappingSvc.ProxyDict="ActiveStoreSvc"
return CfgMgr.LArPileUpTool(name, **kwargs)
def LArCellDeadOTXCorrToolDefault(name='LArCellDeadOTXCorr'):
import traceback
try:
from LArCellRec.LArCellRecConf import LArCellDeadOTXCorr
theLArCellDeadOTXCorr = LArCellDeadOTXCorr(name)
except:
mlog.error("could not get handle to LArCellDeadOTXCorr Quit")
print traceback.format_exc()
return False
try:
from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool
theLArBadChannelTool = LArBadChanTool()
except:
mlog.error("could not access bad channel tool Quit")
print traceback.format_exc()
return False
from AthenaCommon.AppMgr import ToolSvc
ToolSvc += theLArBadChannelTool
theLArCellDeadOTXCorr.badChannelTool = theLArBadChannelTool
from AthenaCommon.GlobalFlags import globalflags
ignoredTTs = []
deadOTXCorrDbFolder = "/LAR/CellCorrOfl/deadOTX"
if globalflags.DataSource() == 'data':
#deadOTXCorrDbTag = "<tag>LARCellCorrOflDeadOTX-UPD1-00</tag>"
#deadOTXCorrDbConnection = "<dbConnection>oracle://ATLAS_COOLPROD;schema=ATLAS_COOLOFL_LAR;dbname=COMP200</dbConnection>"
ignoredTTs = [0x11d0101]
from AthenaCommon.BeamFlags import jobproperties
if jobproperties.Beam.beamType() == "cosmics":
theLArCellDeadOTXCorr.useL1CaloDB = False
else:
theLArCellDeadOTXCorr.useL1CaloDB = True
else:
#deadOTXCorrDbTag = "<tag>LARCellCorrOflDeadOTX-000-00</tag>"
#deadOTXCorrDbConnection = "<dbConnection>oracle://ATLAS_COOLPROD;schema=ATLAS_COOLOFL_LAR;dbname=OFLP200</dbConnection>"
theLArCellDeadOTXCorr.useL1CaloDB = False
theLArCellDeadOTXCorr.triggerNoiseCut = [2., 0.265, 0.45, 0.16, 0.87]
theLArCellDeadOTXCorr.ignoredTTs = ignoredTTs
theLArCellDeadOTXCorr.COOLFolder = deadOTXCorrDbFolder
theLArCellDeadOTXCorr.detStoreKey = "deadOTXCorrCtes"
from IOVDbSvc.CondDB import conddb
#conddb.addFolder("", deadOTXCorrDbConnection + deadOTXCorrDbFolder + deadOTXCorrDbTag)
conddb.addFolder("LAR_OFL", deadOTXCorrDbFolder)
if theLArCellDeadOTXCorr.useL1CaloDB:
# Setup the L1CaloCondSvc
from AthenaCommon.AppMgr import ServiceMgr
from TrigT1CaloCondSvc.TrigT1CaloCondSvcConf import L1CaloCondSvc
ServiceMgr += L1CaloCondSvc()
L1CaloDb = ""
if not 'L1CaloDbConnection' in dir():
if 'L1CaloSqliteDB' in dir():
L1CaloDbConnection = "<dbConnection>sqlite://;schema=" + L1CaloSqliteDB + ";dbname=L1CALO</dbConnection>"
else:
L1CaloDb = "TRIGGER"
L1CaloDbConnection = ""
L1CaloDbTag = "<tag>HEAD</tag>"
L1CaloFolderList = []
L1CaloFolderList += [
"/TRIGGER/L1Calo/V1/Calibration/Physics/PprChanCalib"
]
for l1calofolder in L1CaloFolderList:
if not conddb.folderRequested(l1calofolder):
conddb.addFolder(
L1CaloDb, L1CaloDbConnection + l1calofolder + L1CaloDbTag)
return theLArCellDeadOTXCorr
from AthenaCommon.AppMgr import (theApp, ServiceMgr as svcMgr, ToolSvc)
theApp.EvtMax = 1
## theByteStreamInputSvc=svcMgr.ByteStreamInputSvc
## theByteStreamInputSvc.FullFileName=["/home/wlampl/LArOFIter/ramp/inputs/daq.Ramp.0029146.No.Streaming.LB0000.EB-EMBA._0001.data"]
## theByteStreamInputSvc.MaxBadEvents=0
from LArCalibTest.LArCalibTestConf import DumpCaloBadChannels
theDumper = DumpCaloBadChannels()
theDumper.FileName = "list.txt"
topSequence += theDumper
from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool
theLArBadChannelTool = LArBadChanTool()
theLArBadChannelTool.ReadFromASCII = True
theLArBadChannelTool.ASCIIFileName = "/home/wlampl/LArCondPatcher/dead_dummy.txt"
theLArBadChannelTool.OutputLevel = DEBUG
ToolSvc += theLArBadChannelTool
svcMgr += CfgMgr.AthenaEventLoopMgr(OutputLevel=WARNING)
from AthenaCommon.AppMgr import theAuditorSvc
from AthenaCommon.ConfigurableDb import getConfigurable
theAuditorSvc += getConfigurable("MemStatAuditor")(OutputLevel=WARNING)
theAuditorSvc += getConfigurable("ChronoAuditor")()
theAuditorSvc += getConfigurable("NameAuditor")()
###########################################################################
BadChannelsFolder = "/LAR/BadChannelsOfl/BadChannels"
MissingFEBsFolder = "/LAR/BadChannelsOfl/MissingFEBs"
from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool
theLArBadChanTool = LArBadChanTool(
CoolFolder=BadChannelsFolder,
CoolMissingFEBsFolder=MissingFEBsFolder,
)
ToolSvc += theLArBadChanTool
# Set an int property
#BadChanTest.MyInt = 42
#--------------------------------------------------------------
# Algorithms Tool Usage Private Options (advanced and optional)
#--------------------------------------------------------------
# Import configurable for using our HelloTool
#from AthExHelloWorld.AthExHelloWorldConf import HelloTool
from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool
# Setup a public tool so that it can be used (again, note name)
#ToolSvc += HelloTool( "PublicHello" )
#ToolSvc.PublicHello.MyMessage = "A Public Message!"
ToolSvc += LArBadChanTool("BadChanTool")
#ToolSvc.BadChanTool.EMBAfile = "noisePb_29142.txt"
ToolSvc.BadChanTool.EMBAfile = "badchannels.txt"
ToolSvc.BadChanTool.EMBCfile = "badchannels.txt"
ToolSvc.BadChanTool.OutputLevel = DEBUG
# Tell "HelloWorld" to use this tool ("MyPublicHelloTool" is a
# ToolHandle property of LArBadChannelToolTest)
#HelloWorld.MyPublicHelloTool = ToolSvc.PublicHello
BadChanTest.BadChannelTool = ToolSvc.BadChanTool
#==============================================================
#
# End of job options file
#
###############################################################
topSequence = AlgSequence() ## get a handle to the ApplicationManager, to the ServiceManager and to the ToolSvc from AthenaCommon.AppMgr import (theApp, ServiceMgr as svcMgr,ToolSvc) theApp.EvtMax=1 #Thats the registration algo from LArBadChannelTool.LArBadChannelToolConf import LArBadChannelDBAlg theLArDBAlg=LArBadChannelDBAlg() theLArDBAlg.WritingMode = 1 theLArDBAlg.FEBFolder=Folder topSequence += theLArDBAlg from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool theLArBadChannelTool=LArBadChanTool() theLArBadChannelTool.ReadFromASCII=True theLArBadChannelTool.CoolFolder="" theLArBadChannelTool.CoolMissingFEBsFolder = ""#FEBFolder theLArBadChannelTool.FEBfile = InputFile #theLArBadChannelTool.WriteEmptyFolders = False theLArBadChannelTool.OutputLevel=DEBUG ToolSvc+=theLArBadChannelTool OutputList=[ "AthenaAttributeList#"+Folder ] FEBTag=join(split(Folder, '/'),'') + TagPostfix OutputTagList=[FEBTag] WriteIOV=True from RegistrationServices.OutputConditionsAlg import OutputConditionsAlg
def configure(self):
from AthenaCommon.Logging import logging
mlog = logging.getLogger('CaloCellGetter::configure:')
mlog.info('entering')
doStandardCellReconstruction = True
from CaloRec.CaloCellFlags import jobproperties
if not jobproperties.CaloCellFlags.doFastCaloSim.statusOn:
doFastCaloSim = False
mlog.info("doFastCaloSim not set, so not using it")
else:
doFastCaloSim = jobproperties.CaloCellFlags.doFastCaloSim()
if doFastCaloSim:
mlog.info("doFastCaloSim requested")
doStandardCellReconstruction = False
if jobproperties.CaloCellFlags.doFastCaloSimAddCells():
doStandardCellReconstruction = True
mlog.info(
"doFastCaloSimAddCells requested: FastCaloSim is added to fullsim calorimeter"
)
else:
mlog.info(
"doFastCaloSimAddCells not requested: Stand alone FastCaloSim is running"
)
else:
mlog.info("doFastCaloSim explicitly not requested")
# get handle to upstream object
# handle tile
if doStandardCellReconstruction:
# handle LAr
import traceback
try:
from LArROD.LArRODFlags import larRODFlags
from AthenaCommon.GlobalFlags import globalflags
if larRODFlags.readDigits() and globalflags.DataSource(
) == 'data':
from AthenaCommon.KeyStore import CfgItemList
CfgItemList("KeyStore_inputFile").removeItem(
"LArRawChannelContainer#LArRawChannels")
if (not larRODFlags.readDigits()
) and globalflags.InputFormat() == 'bytestream':
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
try:
if not "LArRawChannelContainer/LArRawChannels" in svcMgr.ByteStreamAddressProviderSvc.TypeNames:
svcMgr.ByteStreamAddressProviderSvc.TypeNames += [
"LArRawChannelContainer/LArRawChannels"
]
except:
mlog.warning(
"Cannot remove LArRawChannelContainer/LArRawChannels from bytestream list"
)
from LArROD.LArRawChannelGetter import LArRawChannelGetter
theLArRawChannelGetter = LArRawChannelGetter()
except:
mlog.error("could not get handle to LArRawChannel Quit")
print traceback.format_exc()
return False
if not theLArRawChannelGetter.usable():
if not self.ignoreConfigError():
mlog.error("LArRawChannelGetter unusable. Quit.")
return False
else:
mlog.error(
"LArRawChannelGetter unusable. Continue nevertheless")
# writing of thinned digits
if jobproperties.CaloCellFlags.doLArThinnedDigits.statusOn and jobproperties.CaloCellFlags.doLArThinnedDigits(
):
from AthenaCommon.GlobalFlags import globalflags
if globalflags.DataSource() == 'data':
try:
from LArROD.LArDigits import DefaultLArDigitThinner
LArDigitThinner = DefaultLArDigitThinner(
'LArDigitThinner'
) # automatically added to topSequence
LArDigitThinner.InputContainerName = "FREE"
LArDigitThinner.OutputContainerName = "LArDigitContainer_Thinned"
except Exception:
treatException("Problem with LArDigitThinner ")
# now configure the algorithm, part of this could be done in a separate class
# cannot have same name
try:
from CaloRec.CaloRecConf import CaloCellMaker
except:
mlog.error("could not import CaloRec.CaloCellMaker")
print traceback.format_exc()
return False
theCaloCellMaker = CaloCellMaker()
self._CaloCellMakerHandle = theCaloCellMaker
from AthenaCommon.AppMgr import ToolSvc
if doStandardCellReconstruction:
# configure CaloCellMaker here
# check LArCellMakerTool_jobOptions.py for full configurability
# FIXME
from RecExConfig.RecFlags import rec
if rec.doLArg():
try:
from LArCellRec.LArCellRecConf import LArCellBuilderFromLArRawChannelTool
theLArCellBuilder = LArCellBuilderFromLArRawChannelTool()
except:
mlog.error(
"could not get handle to LArCellBuilderFromLArRawChannel Quit"
)
print traceback.format_exc()
return False
if jobproperties.CaloCellFlags.doLArCreateMissingCells():
# bad channel tools
try:
from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool
theLArBadChannelTool = LArBadChanTool()
except:
mlog.error("could not access bad channel tool Quit")
print traceback.format_exc()
return False
ToolSvc += theLArBadChannelTool
theLArCellBuilder.addDeadOTX = True
theLArCellBuilder.badChannelTool = theLArBadChannelTool
# add the tool to list of tool ( should use ToolHandle eventually)
ToolSvc += theLArCellBuilder
theCaloCellMaker.CaloCellMakerToolNames += [theLArCellBuilder]
if rec.doTile():
from AthenaCommon.GlobalFlags import globalflags
if globalflags.DataSource(
) == 'data' and globalflags.InputFormat() == 'bytestream':
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
try:
svcMgr.ByteStreamCnvSvc.ROD2ROBmap = ["-1"]
if not "TileDigitsContainer/TileDigitsCnt" in svcMgr.ByteStreamAddressProviderSvc.TypeNames:
svcMgr.ByteStreamAddressProviderSvc.TypeNames += [
"TileBeamElemContainer/TileBeamElemCnt",
"TileDigitsContainer/TileDigitsCnt",
"TileL2Container/TileL2Cnt",
"TileLaserObject/TileLaserObj",
"TileMuonReceiverContainer/TileMuRcvCnt"
]
except:
mlog.warning(
"Cannot add TileDigitsContainer/TileDigitsCnt et al. to bytestream list"
)
# set options for TileRawChannelMaker
from TileRecUtils.TileRecFlags import jobproperties
jobproperties.TileRecFlags.TileRunType = 1
# physics run type
# reading of digits can be disabled before calling CaloCellGetter
# if this is not done, but digits are not available in BS file
# reading of digits is automatically disabled at start of run
if jobproperties.TileRecFlags.readDigits() \
and not (jobproperties.TileRecFlags.doTileFlat \
or jobproperties.TileRecFlags.doTileFit \
or jobproperties.TileRecFlags.doTileFitCool \
or jobproperties.TileRecFlags.doTileOpt \
or jobproperties.TileRecFlags.doTileOF1 \
or jobproperties.TileRecFlags.doTileOpt2 \
or jobproperties.TileRecFlags.doTileOptATLAS \
or jobproperties.TileRecFlags.doTileMF):
from AthenaCommon.BeamFlags import jobproperties
# run Opt filter with iterations by default, both for cosmics and collisions before 2011
# run Opt filter without iterations for collisions in 2011 and later
if not 'doTileOpt2' in dir():
from RecExConfig.AutoConfiguration import GetRunNumber
rn = GetRunNumber()
if rn > 0 and rn < 171194:
doTileOpt2 = True
elif jobproperties.Beam.beamType() == 'collisions':
doTileOpt2 = False
# use OF without iterations for collisions
else:
doTileOpt2 = True
# always run OF with iterations for cosmics
# jobproperties.TileRecFlags.calibrateEnergy=True; # use pCb for RawChannels
# please, note that time correction and best phase are used only for collisions
if doTileOpt2:
jobproperties.TileRecFlags.doTileOpt2 = True
# run optimal filter with iterations
jobproperties.TileRecFlags.doTileOptATLAS = False
# disable optimal filter without iterations
jobproperties.TileRecFlags.correctAmplitude = False
# don't do parabolic correction
if jobproperties.Beam.beamType() == 'collisions':
jobproperties.TileRecFlags.correctTime = True
# apply time correction in physics runs
jobproperties.TileRecFlags.BestPhaseFromCOOL = False
# best phase is not needed for iterations
else:
jobproperties.TileRecFlags.doTileOpt2 = False
# disable optimal filter with iterations
jobproperties.TileRecFlags.doTileOptATLAS = True
# run optimal filter without iterations
jobproperties.TileRecFlags.correctAmplitude = True
# apply parabolic correction
if jobproperties.Beam.beamType() == 'collisions':
jobproperties.TileRecFlags.correctTime = False
# don't need time correction if best phase is used
jobproperties.TileRecFlags.BestPhaseFromCOOL = True
# use best phase stored in DB
try:
from TileRecUtils.TileRawChannelGetter import TileRawChannelGetter
theTileRawChannelGetter = TileRawChannelGetter()
except:
mlog.error("could not load TileRawChannelGetter Quit")
print traceback.format_exc()
return False
try:
from TileRecAlgs.TileRecAlgsConf import TileDigitsFilter
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
topSequence += TileDigitsFilter()
except:
mlog.error("Could not configure TileDigitsFilter")
try:
from TileRecUtils.TileRecUtilsConf import TileCellBuilder
theTileCellBuilder = TileCellBuilder()
from TileRecUtils.TileRecFlags import jobproperties
theTileCellBuilder.TileRawChannelContainer = jobproperties.TileRecFlags.TileRawChannelContainer(
)
if not hasattr(ToolSvc, "TileBeamInfoProvider"):
from TileRecUtils.TileRecUtilsConf import TileBeamInfoProvider
ToolSvc += TileBeamInfoProvider()
if globalflags.DataSource(
) == 'data' and globalflags.InputFormat() == 'bytestream':
if jobproperties.TileRecFlags.readDigits():
# everything is already corrected at RawChannel level
theTileCellBuilder.correctTime = False
theTileCellBuilder.correctAmplitude = False
else:
ToolSvc.TileBeamInfoProvider.TileRawChannelContainer = "TileRawChannelCnt"
# by default parameters are tuned for opt.filter without iterations
theTileCellBuilder.correctTime = jobproperties.TileRecFlags.correctTime(
)
theTileCellBuilder.correctAmplitude = jobproperties.TileRecFlags.correctAmplitude(
)
theTileCellBuilder.AmpMinForAmpCorrection = jobproperties.TileRecFlags.AmpMinForAmpCorrection(
)
if jobproperties.TileRecFlags.TimeMaxForAmpCorrection(
) <= jobproperties.TileRecFlags.TimeMinForAmpCorrection(
):
from AthenaCommon.BeamFlags import jobproperties
mlog.info(
"adjusting min/max time of parabolic correction for %s"
% jobproperties.Beam.bunchSpacing)
halfBS = jobproperties.Beam.bunchSpacing.get_Value(
) / 2.
jobproperties.TileRecFlags.TimeMinForAmpCorrection = -halfBS
jobproperties.TileRecFlags.TimeMaxForAmpCorrection = halfBS
if jobproperties.TileRecFlags.TimeMaxForAmpCorrection(
) > jobproperties.TileRecFlags.TimeMinForAmpCorrection(
):
theTileCellBuilder.TimeMinForAmpCorrection = jobproperties.TileRecFlags.TimeMinForAmpCorrection(
)
theTileCellBuilder.TimeMaxForAmpCorrection = jobproperties.TileRecFlags.TimeMaxForAmpCorrection(
)
ToolSvc += theTileCellBuilder
theCaloCellMaker.CaloCellMakerToolNames += [
theTileCellBuilder
]
except:
mlog.error("could not get handle to TileCellBuilder Quit")
print traceback.format_exc()
return False
if doFastCaloSim:
mlog.info('configuring FastCaloSim here')
try:
from FastCaloSim.FastCaloSimConf import EmptyCellBuilderTool
theEmptyCellBuilderTool = EmptyCellBuilderTool()
ToolSvc += theEmptyCellBuilderTool
theCaloCellMaker.CaloCellMakerToolNames += [
theEmptyCellBuilderTool
]
print theEmptyCellBuilderTool
mlog.info("configure EmptyCellBuilderTool worked")
except:
mlog.error("could not get handle to EmptyCellBuilderTool Quit")
print traceback.format_exc()
return False
try:
from FastCaloSim.FastCaloSimFactory import FastCaloSimFactory
theFastShowerCellBuilderTool = FastCaloSimFactory()
ToolSvc += theFastShowerCellBuilderTool
theCaloCellMaker.CaloCellMakerToolNames += [
theFastShowerCellBuilderTool
]
mlog.info("configure FastShowerCellBuilderTool worked")
except:
mlog.error(
"could not get handle to FastShowerCellBuilderTool Quit")
print traceback.format_exc()
return False
doFastCaloSimNoise = jobproperties.CaloCellFlags.doFastCaloSimNoise(
)
if doFastCaloSimNoise:
try:
from FastCaloSim.FastCaloSimConf import AddNoiseCellBuilderTool
theAddNoiseCellBuilderTool = AddNoiseCellBuilderTool()
from CaloTools.CaloNoiseToolDefault import CaloNoiseToolDefault
theCaloNoiseTool = CaloNoiseToolDefault()
from AthenaCommon.AppMgr import ToolSvc
ToolSvc += theCaloNoiseTool
theAddNoiseCellBuilderTool.CaloNoiseTool = theCaloNoiseTool.getFullName(
)
print theAddNoiseCellBuilderTool
ToolSvc += theAddNoiseCellBuilderTool
theCaloCellMaker.CaloCellMakerToolNames += [
theAddNoiseCellBuilderTool
]
mlog.info("configure AddNoiseCellBuilderTool worked")
except:
mlog.error(
"could not get handle to AddNoiseCellBuilderTool Quit")
print traceback.format_exc()
return False
#
# CaloCellContainerFinalizerTool : closing container and setting up iterators
#
from CaloRec.CaloRecConf import CaloCellContainerFinalizerTool
theCaloCellContainerFinalizerTool = CaloCellContainerFinalizerTool()
ToolSvc += theCaloCellContainerFinalizerTool
theCaloCellMaker.CaloCellMakerToolNames += [
theCaloCellContainerFinalizerTool
]
#
# Mergeing of calo cellcontainer with sparse raw channel container with improved energies
#
doLArMerge = False
if globalflags.DataSource(
) == 'data' and jobproperties.CaloCellFlags.doLArRawChannelMerge.statusOn and jobproperties.CaloCellFlags.doLArRawChannelMerge(
):
from LArROD.LArRODFlags import larRODFlags
if larRODFlags.readDigits() and larRODFlags.keepDSPRaw():
doLArMerge = True
if doLArMerge:
try:
from LArCellRec.LArCellRecConf import LArCellMerger
theLArCellMerger = LArCellMerger()
except:
mlog.error("could not get handle to LArCellMerge Quit")
print traceback.format_exc()
return False
theLArCellMerger.RawChannelsName = larRODFlags.RawChannelFromDigitsContainerName(
)
ToolSvc += theLArCellMerger
theCaloCellMaker.CaloCellMakerToolNames += [theLArCellMerger]
#
# masking of noisy and sporadic noisy cells in LAr
#
doNoiseMask = False
if jobproperties.CaloCellFlags.doLArNoiseMasking.statusOn and jobproperties.CaloCellFlags.doLArNoiseMasking(
):
doNoiseMask = True
doSporadicMask = False
if jobproperties.CaloCellFlags.doLArSporadicMasking.statusOn and jobproperties.CaloCellFlags.doLArSporadicMasking(
):
doSporadicMask = True
if doNoiseMask or doSporadicMask:
try:
from LArCellRec.LArCellRecConf import LArCellNoiseMaskingTool
theLArCellNoiseMaskingTool = LArCellNoiseMaskingTool()
except:
mlog.error(
"could not get handle to LArCellNoiseMaskingTool Quit")
print traceback.format_exc()
return False
# bad channel tools
try:
from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool
theLArBadChannelTool = LArBadChanTool()
except:
mlog.error("could not access bad channel tool Quit")
print traceback.format_exc()
return False
ToolSvc += theLArBadChannelTool
if doSporadicMask:
try:
from LArBadChannelTool.LArBadChannelToolConf import LArBadChannelMasker
theLArSporadicNoiseMasker = LArBadChannelMasker(
"LArSporadicNoiseMasker")
except:
mlog.error("could not access bad channel tool Quit")
print traceback.format_exc()
return False
theLArSporadicNoiseMasker.TheLArBadChanTool = theLArBadChannelTool
theLArSporadicNoiseMasker.DoMasking = True
theLArSporadicNoiseMasker.ProblemsToMask = [
"sporadicBurstNoise"
]
ToolSvc += theLArSporadicNoiseMasker
theLArCellNoiseMaskingTool.MaskingSporadicTool = theLArSporadicNoiseMasker
if doNoiseMask:
try:
from LArBadChannelTool.LArBadChannelToolConf import LArBadChannelMasker
theLArNoiseMasker = LArBadChannelMasker("LArNoiseMasker")
except:
mlog.error("could not access bad channel tool Quit")
print traceback.format_exc()
return False
theLArNoiseMasker.TheLArBadChanTool = theLArBadChannelTool
theLArNoiseMasker.DoMasking = True
theLArNoiseMasker.ProblemsToMask = [
"highNoiseHG", "highNoiseMG", "highNoiseLG", "deadReadout",
"deadPhys"
]
ToolSvc += theLArNoiseMasker
theLArCellNoiseMaskingTool.MaskingTool = theLArNoiseMasker
theLArCellNoiseMaskingTool.maskNoise = doNoiseMask
theLArCellNoiseMaskingTool.maskSporadic = doSporadicMask
# quality cut for sporadic noise masking
theLArCellNoiseMaskingTool.qualityCut = 4000
ToolSvc += theLArCellNoiseMaskingTool
theCaloCellMaker.CaloCellMakerToolNames += [
theLArCellNoiseMaskingTool
]
#
# masking of Feb problems
#
doBadFebMasking = False
if jobproperties.CaloCellFlags.doLArBadFebMasking.statusOn and jobproperties.CaloCellFlags.doLArBadFebMasking(
):
from AthenaCommon.GlobalFlags import globalflags
if globalflags.DataSource() == 'data':
doBadFebMasking = True
if doBadFebMasking:
try:
from LArCellRec.LArCellRecConf import LArBadFebMaskingTool
theLArBadFebMaskingTool = LArBadFebMaskingTool()
if (
rec.doExpressProcessing()
or athenaCommonFlags.isOnline()
): # In online or express processing, EventInfo::LArError is triggered if >=4 FEB with data corrupted
theLArBadFebMaskingTool.minFebInError = 4
except:
mlog.error("could not get handle to LArBadFebMaskingTool Quit")
print traceback.format_exc()
return False
ToolSvc += theLArBadFebMaskingTool
# bad channel tools
try:
from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool
theLArBadChannelTool = LArBadChanTool()
except:
mlog.error("could not access bad channel tool Quit")
print traceback.format_exc()
return False
ToolSvc += theLArBadChannelTool
theLArBadFebMaskingTool.badChannelTool = theLArBadChannelTool
theCaloCellMaker.CaloCellMakerToolNames += [
theLArBadFebMaskingTool
]
#
# emulate gain pathologies on MC
#
doGainPathology = False
if jobproperties.CaloCellFlags.doLArCellGainPathology.statusOn and jobproperties.CaloCellFlags.doLArCellGainPathology(
):
from AthenaCommon.GlobalFlags import globalflags
if globalflags.DataSource() == 'geant4':
doGainPathology = True
if doGainPathology:
try:
from LArCellRec.LArCellRecConf import LArCellGainPathology
theLArCellGainPathology = LArCellGainPathology()
except:
mlog.error("could not get handle to LArCellGainPatholog< Quit")
print traceback.format_exc()
return False
ToolSvc += theLArCellGainPathology
theCaloCellMaker.CaloCellMakerToolNames += [
theLArCellGainPathology
]
# lar miscalibration if MC only (should be done after finalisation)
if not jobproperties.CaloCellFlags.doLArCellEmMisCalib.statusOn:
# the flag has not been set, so decide a reasonable default
# this is the old global flags should use the new one as
# soon as monitoring does
from AthenaCommon.GlobalFlags import globalflags
if globalflags.DataSource() == 'data':
doLArCellEmMisCalib = False
mlog.info(
"jobproperties.CaloCellFlags.doLArMisCalib not set and real data: do not apply LArCellEmMisCalibTool"
)
else:
doLArCellEmMisCalib = True
mlog.info(
"jobproperties.CaloCellFlags.doLArMisCalib not set and Monte Carlo: apply LArCellEmMisCalibTool"
)
else:
doLArCellEmMisCalib = jobproperties.CaloCellFlags.doLArCellEmMisCalib(
)
if doLArCellEmMisCalib:
mlog.info("LArCellEmMisCalibTool requested")
else:
mlog.info("LArCellEmMisCalibTool explicitly not requested")
if doLArCellEmMisCalib:
try:
from LArCellRec.LArCellRecConf import LArCellEmMiscalib
theLArCellEmMiscalib = LArCellEmMiscalib("LArCellEmMiscalib")
except:
mlog.error("could not get handle to LArCellEmMisCalib Quit")
print traceback.format_exc()
return False
# examples on how to change miscalibration. Default values are 0.005 and 0.007
# theLArCellEmMiscalib.SigmaPerRegion = 0.005;
# theLArCellEmMiscalib.SigmaPerCell = 0.005;
ToolSvc += theLArCellEmMiscalib
try:
from CaloRec.CaloRecConf import CaloCellContainerCorrectorTool
from CaloIdentifier import SUBCALO
theMisCalibTool = CaloCellContainerCorrectorTool(
"MisCalibTool",
CaloNums=[SUBCALO.LAREM],
CellCorrectionToolNames=[theLArCellEmMiscalib])
except:
mlog.error("could not get handle to MisCalibTool Quit")
print traceback.format_exc()
return False
ToolSvc += theMisCalibTool
theCaloCellMaker.CaloCellMakerToolNames += [theMisCalibTool]
#
# Pedestal shift correction
#
doPedestalCorr = False
if jobproperties.CaloCellFlags.doPedestalCorr.statusOn:
from AthenaCommon.GlobalFlags import globalflags
if jobproperties.CaloCellFlags.doPedestalCorr() and (
globalflags.DataSource() == 'data'
or jobproperties.CaloCellFlags.doPileupOffsetBCIDCorr):
doPedestalCorr = True
mlog.info("Apply cell level pedestal shift correction")
import os
if doPedestalCorr:
try:
from CaloCellCorrection.CaloCellPedestalCorrDefault import CaloCellPedestalCorrDefault
theCaloCellPedestalCorr = CaloCellPedestalCorrDefault()
ToolSvc += theCaloCellPedestalCorr
theCaloCellMaker.CaloCellMakerToolNames += [
theCaloCellPedestalCorr
]
except:
mlog.error("could not get handle to CaloCellPedestalCorr")
print traceback.format_exc()
#
# HV correction for offline reprocessing, reading HV from Cool-DCS database
#
doHVCorr = False
from AthenaCommon.DetFlags import DetFlags
if DetFlags.dcs.LAr_on():
if jobproperties.CaloCellFlags.doLArHVCorr.statusOn:
from AthenaCommon.GlobalFlags import globalflags
if jobproperties.CaloCellFlags.doLArHVCorr(
) and globalflags.DataSource() == 'data':
doHVCorr = True
mlog.info(
"Redoing HV correction at cell level from COOL/DCS database"
)
if doHVCorr:
from LArCellRec.LArCellHVCorrDefault import LArCellHVCorrDefault
theLArCellHVCorr = LArCellHVCorrDefault()
try:
from CaloRec.CaloRecConf import CaloCellContainerCorrectorTool
from CaloIdentifier import SUBCALO
theHVCorrTool = CaloCellContainerCorrectorTool(
"HVCorrTool",
CaloNums=[SUBCALO.LAREM, SUBCALO.LARHEC, SUBCALO.LARFCAL],
CellCorrectionToolNames=[theLArCellHVCorr])
except:
mlog.error("could not get handle to HVCorrTool Quit")
print traceback.format_exc()
return False
ToolSvc += theHVCorrTool
theCaloCellMaker.CaloCellMakerToolNames += [theHVCorrTool]
#
# correction to undo online calibration and apply new LAr electronics calibration for ADC->MeV conversion
#
doLArRecalibration = False
if jobproperties.CaloCellFlags.doLArRecalibration.statusOn:
from AthenaCommon.GlobalFlags import globalflags
from LArConditionsCommon.LArCondFlags import larCondFlags
if jobproperties.CaloCellFlags.doLArRecalibration(
) and globalflags.DataSource() == 'data' and (
not larCondFlags.SingleVersion()):
doLArRecalibration = True
mlog.info("Redoing LAr electronics calibration for ADC->MeV")
if doLArRecalibration:
# get tool for cell recalibration
try:
from LArCellRec.LArCellRecConf import LArCellRecalibration
theLArCellRecalibration = LArCellRecalibration(
"LArCellRecalibration")
except:
mlog.error("could not get handle to LArCellRecalibration Quit")
print traceback.format_exc()
return False
ToolSvc += theLArCellRecalibration
# get new ADC2MeVTool
try:
from LArRecUtils.LArADC2MeVToolDefault import LArADC2MeVToolDefault
theLArADC2MeVToolDefault = LArADC2MeVToolDefault()
except:
mlog.error(
"Could not get handle to LArADC2MeVToolDefault Quit")
print traceback.format_exc()
return False
ToolSvc += theLArADC2MeVToolDefault
# get old ADC2MeVTool
try:
from LArRecUtils.LArADC2MeVToolOnline import LArADC2MeVToolOnline
theLArADC2MeVToolOnline = LArADC2MeVToolOnline()
except:
mlog.error("Could not get handle to LArADC2MeVToolOnline Quit")
print traceback.format_exc()
return False
ToolSvc += theLArADC2MeVToolOnline
theLArCellRecalibration.adc2MeVTool = theLArADC2MeVToolDefault
theLArCellRecalibration.adc2MeVToolOnline = theLArADC2MeVToolOnline
try:
from CaloRec.CaloRecConf import CaloCellContainerCorrectorTool
from CaloIdentifier import SUBCALO
theLArRecalibrationTool = CaloCellContainerCorrectorTool(
"LArRecalibrationTool",
CaloNums=[SUBCALO.LAREM, SUBCALO.LARHEC, SUBCALO.LARFCAL],
CellCorrectionToolNames=[theLArCellRecalibration])
except:
mlog.error("could not get handle to HVCorrTool Quit")
print traceback.format_exc()
return False
ToolSvc += theLArRecalibrationTool
theCaloCellMaker.CaloCellMakerToolNames += [
theLArRecalibrationTool
]
#
# Correction for MinBias energy shift for MC pileup reco
#
doMinBiasAverage = False
if jobproperties.CaloCellFlags.doMinBiasAverage.statusOn:
from AthenaCommon.GlobalFlags import globalflags
from AthenaCommon.BeamFlags import jobproperties
if jobproperties.CaloCellFlags.doMinBiasAverage(
) and globalflags.DataSource() == 'geant4' and (
not jobproperties.Beam.zeroLuminosity()):
doMinBiasAverage = True
if doMinBiasAverage:
try:
from CaloTools.CaloMBAverageToolDefault import CaloMBAverageToolDefault
theCaloMBAverageTool = CaloMBAverageToolDefault()
except:
mlog.error("could not get handle to CaloMBAverageTool Quit")
print traceback.format_exc()
return False
ToolSvc += theCaloMBAverageTool
try:
from CaloCellCorrection.CaloCellCorrectionConf import CaloCellMBAverageCorr
theCaloCellMBAverageCorr = CaloCellMBAverageCorr(
"CaloCellMBAverageCorr")
theCaloCellMBAverageCorr.CaloMBAverageTool = theCaloMBAverageTool
except:
mlog.error(
"could not get handle to CaloCellMBAverageCorr Quit")
print traceback.format_exc()
return False
ToolSvc += theCaloCellMBAverageCorr
try:
from CaloRec.CaloRecConf import CaloCellContainerCorrectorTool
from CaloIdentifier import SUBCALO
theMBAverageTool = CaloCellContainerCorrectorTool(
"MBAverageTool",
CaloNums=[SUBCALO.NSUBCALO],
CellCorrectionToolNames=[theCaloCellMBAverageCorr])
except:
mlog.error(
"could not get handle to CaloCellContainerCorrectorTool/MBAverageTool Quit"
)
print traceback.format_exc()
return False
ToolSvc += theMBAverageTool
theCaloCellMaker.CaloCellMakerToolNames += [theMBAverageTool]
#
# Correction for dead cells, where we average the energy density of neighbor cells
#
doNeighborsAverage = False
if jobproperties.CaloCellFlags.doDeadCellCorr.statusOn:
if jobproperties.CaloCellFlags.doDeadCellCorr():
doNeighborsAverage = True
if doNeighborsAverage:
try:
from CaloCellCorrection.CaloCellCorrectionConf import CaloCellNeighborsAverageCorr
theCaloCellNeighborsAverageCorr = CaloCellNeighborsAverageCorr(
"CaloCellNeighborsAverageCorr")
theCaloCellNeighborsAverageCorr.testMode = False
except:
mlog.error(
"could not get handle to CaloCellNeighborsAverageCorr Quit"
)
print traceback.format_exc()
return False
ToolSvc += theCaloCellNeighborsAverageCorr
theCaloCellMaker.CaloCellMakerToolNames += [
theCaloCellNeighborsAverageCorr
]
#
# correction for missing Febs based on L1 readout
doLArDeadOTXCorr = False
if jobproperties.CaloCellFlags.doLArDeadOTXCorr.statusOn and jobproperties.CaloCellFlags.doLArCreateMissingCells.statusOn:
if jobproperties.CaloCellFlags.doLArDeadOTXCorr(
) and jobproperties.CaloCellFlags.doLArCreateMissingCells(
) and doStandardCellReconstruction:
if rec.doTrigger():
doLArDeadOTXCorr = True
else:
mlog.warning(
"Trigger is switched off. Can't run deadOTX correction."
)
if doLArDeadOTXCorr:
try:
from LArCellRec.LArCellDeadOTXCorrToolDefault import LArCellDeadOTXCorrToolDefault
theLArCellDeadOTXCorr = LArCellDeadOTXCorrToolDefault()
except:
mlog.error("could not get handle to LArCellDeadOTXCorr Quit")
print traceback.format_exc()
ToolSvc += theLArCellDeadOTXCorr
theCaloCellMaker.CaloCellMakerToolNames += [theLArCellDeadOTXCorr]
doCaloEnergyRescaler = False
if jobproperties.CaloCellFlags.doCaloCellEnergyCorr(
) and globalflags.DataSource(
) == 'data' and not athenaCommonFlags.isOnline():
try:
from CaloCellCorrection.CaloCellCorrectionConf import CaloCellEnergyRescaler
theCCERescalerTool = CaloCellEnergyRescaler()
theCCERescalerTool.Folder = "/LAR/CellCorrOfl/EnergyCorr"
ToolSvc += theCCERescalerTool
from IOVDbSvc.CondDB import conddb
# conddb.addFolder("","/LAR/CellCorrOfl/EnergyCorr<tag>EnergyScale-00</tag><db>sqlite://;schema=escale.db;dbname=COMP200</db>")
conddb.addFolder("LAR_OFL", "/LAR/CellCorrOfl/EnergyCorr")
ToolSvc += theCCERescalerTool
theCaloCellMaker.CaloCellMakerToolNames += [theCCERescalerTool]
except:
mlog.error(
"could not get handle to CaloCellEnergyRescaler Quit")
print traceback.format_exc()
return False
pass
if jobproperties.CaloCellFlags.doCaloCellTimeCorr(
) and globalflags.DataSource(
) == 'data' and not athenaCommonFlags.isOnline():
try:
from CaloRec.CaloRecConf import CaloCellContainerCorrectorTool
from CaloCellCorrection.CaloCellCorrectionConf import CaloCellTimeCorrTool
theLArTimeCorr = CaloCellTimeCorrTool()
theLArTimeCorr.Folder = "/LAR/TimeCorrectionOfl/CellTimeOffset"
ToolSvc += theLArTimeCorr
from IOVDbSvc.CondDB import conddb
# conddb.addFolder("","/LAR/TimeCorrectionOfl/CellTimeOffset<tag>LARTimeCorrectionOflCellTimeOffset-empty</tag><db>sqlite://;schema=timecorr.db;dbname=COMP200</db>")
conddb.addFolder("LAR_OFL",
"/LAR/TimeCorrectionOfl/CellTimeOffset")
theCaloTimeCorrTool = CaloCellContainerCorrectorTool(
"LArTimeCorrTool",
CellCorrectionToolNames=[theLArTimeCorr])
ToolSvc += theCaloTimeCorrTool
theCaloCellMaker.CaloCellMakerToolNames += [
theCaloTimeCorrTool
]
except:
mlog.error("could not get handle to CaloCellTimeCorrTool Quit")
print traceback.format_exc()
return False
pass
# make lots of checks (should not be necessary eventually)
# to print the check add:
from CaloRec.CaloRecConf import CaloCellContainerCheckerTool
theCaloCellContainerCheckerTool = CaloCellContainerCheckerTool()
# FIXME
# theCaloCellContainerCheckerTool.OutputLevel=DEBUG
ToolSvc += theCaloCellContainerCheckerTool
theCaloCellMaker.CaloCellMakerToolNames += [
theCaloCellContainerCheckerTool
]
#
# sets output key
theCaloCellMaker.CaloCellsOutputName = self.outputKey()
# register output in objKeyStore
from RecExConfig.ObjKeyStore import objKeyStore
objKeyStore.addStreamESD(self.outputType(), self.outputKey())
# now add algorithm to topSequence
# this should always come at the end
mlog.info(" now adding CaloCellMaker to topSequence")
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
topSequence += theCaloCellMaker
return True
PoolSvc.ReadCatalog += ["prfile:poolcond/PoolCat_comcond_castor.xml"]
theApp.EvtMax = 1
svcMgr.EventSelector.RunNumber = RunNumber
from LArCalibUtils.LArCalibUtilsConf import LArCalibPatchingAlg_LArCaliWaveContainer_
theLArCaliWavePatcher = LArCalibPatchingAlg_LArCaliWaveContainer_(
"LArCaliWavePatcher")
theLArCaliWavePatcher.ContainerKey = "LArCaliWave"
theLArCaliWavePatcher.NewContainerKey = "LArCaliWaveOut"
theLArCaliWavePatcher.PatchMethod = "PhiNeighbor"
theLArCaliWavePatcher.OutputLevel = DEBUG
topSequence += theLArCaliWavePatcher
from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool
theLArBadChannelTool = LArBadChanTool()
theLArBadChannelTool.OutputLevel = DEBUG
ToolSvc += theLArBadChannelTool
from LArBadChannelTool.LArBadChannelToolConf import LArBadChannelMasker
theLArRCBMasker = LArBadChannelMasker("LArRCBMasker")
theLArRCBMasker.DoMasking = True
theLArRCBMasker.ProblemsToMask = [
"deadCalib",
"deadReadout",
"deadPhys",
"almostDead",
"short",
]
ToolSvc += theLArRCBMasker
theLArCaliWavePatcher.MaskingTool = theLArRCBMasker
if IOVEndLB <= 0:
svcMgr.EventSelector.FirstEvent = 1
else:
svcMgr.EventSelector.FirstEvent = 0
svcMgr.EventSelector.FirstLB = IOVEndLB
## get a handle to the default top-level algorithm sequence
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
## get a handle to the ApplicationManager, to the ServiceManager and to the ToolSvc
from AthenaCommon.AppMgr import (theApp, ServiceMgr as svcMgr, ToolSvc)
conddb.addFolder("", folderStr + tagStr + dbStr)
#conddb.addFolder("LAR_OFL","/LAR/BadChannelsOfl/MissingFEBs")
svcMgr.IOVDbSvc.GlobalTag = "CONDBR2-ES1PA-2014-01"
from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool
theLArBadChannelTool = LArBadChanTool()
theLArBadChannelTool.CoolFolder = folderStr
theLArBadChannelTool.CoolMissingFEBsFolder = ""
ToolSvc += theLArBadChannelTool
from LArBadChannelTool.LArBadChannelToolConf import LArBadChannel2Ascii
theLArBadChannels2Ascii = LArBadChannel2Ascii()
theLArBadChannels2Ascii.FileName = OutputFile
theLArBadChannels2Ascii.WithMissing = False
theLArBadChannels2Ascii.ExecutiveSummaryFile = ""
topSequence += theLArBadChannels2Ascii
def configure(self):
from AthenaCommon.Logging import logging
mlog = logging.getLogger('LArNoisyROSummaryGetter::configure:')
mlog.info('entering')
# get handle to upstream CaloCell object
import traceback
try:
from CaloRec.CaloCellGetter import CaloCellGetter
theCaloCellGetter = CaloCellGetter()
except:
mlog.error("could not get handle to CaloCell Quit")
print traceback.format_exc()
return False
if not theCaloCellGetter.usable():
if not self.ignoreConfigError():
mlog.error("CaloCellGetter unusable. Quit.")
return False
else:
mlog.error("CaloCellGetter unusable. Continue nevertheless")
# now configure the algorithm
# cannot have same name
try:
from LArCellRec.LArCellRecConf import LArNoisyROAlg, LArNoisyROTool
except:
mlog.error("could not import LArNoisyROAlg or LArNoisyROTool")
print traceback.format_exc()
return False
from AthenaCommon.AppMgr import ToolSvc
# Noise and MNB Febs from COOL only for data
from AthenaCommon.GlobalFlags import globalflags
from IOVDbSvc.CondDB import conddb
if globalflags.DataSource.get_Value() != 'geant4' and (
'COMP200' not in conddb.GetInstance()):
from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool
theBadFebTool = LArBadChanTool("KnownBADFEBsTool")
theBadFebTool.CoolMissingFEBsFolder = "/LAR/BadChannels/KnownBADFEBs"
ToolSvc += theBadFebTool
theMNBFebTool = LArBadChanTool("KnownMNBFEBsTool")
theMNBFebTool.CoolMissingFEBsFolder = "/LAR/BadChannels/KnownMNBFEBs"
ToolSvc += theMNBFebTool
theLArNoisyROTool = LArNoisyROTool(
PrintSummary=True,
CellQualityCut=larNoisyROFlags.CellQualityCut(),
BadChanPerFEB=larNoisyROFlags.BadChanPerFEB(),
BadFEBCut=larNoisyROFlags.BadFEBCut(),
MNBLooseCut=larNoisyROFlags.MNBLooseCut(),
MNBTightCut=larNoisyROFlags.MNBTightCut(),
MNBTight_PsVetoCut=larNoisyROFlags.MNBTight_PsVetoCut(),
KnownBADFEBsTool=theBadFebTool,
KnownMNBFEBsTool=theMNBFebTool)
else:
theLArNoisyROTool = LArNoisyROTool(
PrintSummary=True,
CellQualityCut=larNoisyROFlags.CellQualityCut(),
BadChanPerFEB=larNoisyROFlags.BadChanPerFEB(),
BadFEBCut=larNoisyROFlags.BadFEBCut(),
)
pass
theLArNoisyROAlg = LArNoisyROAlg()
theLArNoisyROAlg.Tool = theLArNoisyROTool
self._LArNoisyROMakerHandle = theLArNoisyROAlg
theLArNoisyROAlg.OutputKey = self.outputKey()
# register output in objKeyStore
from RecExConfig.ObjKeyStore import objKeyStore
objKeyStore.addStreamESD(self.outputType(), self.outputKey())
# now add algorithm to topSequence
# this should always come at the end
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
topSequence += theLArNoisyROAlg
return True
topSequence += theLArRampBuilder
######################################################################
# #
# Correction #
# #
######################################################################
if CorrectBadChannels:
from LArCalibUtils.LArCalibUtilsConf import LArCalibPatchingAlg_LArRampComplete_
theLArRampPatcher = LArCalibPatchingAlg_LArRampComplete_("LArRampPatcher")
theLArRampPatcher.ContainerKey = KeyOutput
theLArRampPatcher.PatchMethod = "PhiAverage"
from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool
theLArBadChannelTool = LArBadChanTool()
ToolSvc += theLArBadChannelTool
theLArRampPatcher.MaskingTool = theLArRCBMasker
theLArRampPatcher.UseCorrChannels = False
topSequence += theLArRampPatcher
if (ApplyAdHocCorrection):
from LArCalibUtils.LArCalibUtilsConf import LArRampAdHocPatchingAlg
LArRampAdHocPatchingAlg = LArRampAdHocPatchingAlg(
"LArRampAdHocPatchingAlg")
LArRampAdHocPatchingAlg.ContainerKey = KeyOutput
if ('ChannelsToBePatchedHG' in dir() and 'PatchesToBeAppliedHG' in dir()):
if (len(ChannelsToBePatchedHG)
and len(ChannelsToBePatchedHG) == len(PatchesToBeAppliedHG)):
LArRampAdHocPatchingAlg.ChannelsToBePatchedHG = ChannelsToBePatchedHG
## get a handle to the default top-level algorithm sequence
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
## get a handle to the ApplicationManager, to the ServiceManager and to the ToolSvc
from AthenaCommon.AppMgr import (theApp, ServiceMgr as svcMgr, ToolSvc)
theApp.EvtMax = 10
from LArBadChannelTool.LArBadChannelToolConf import LArBadChannelTimingAlg
theTester = LArBadChannelTimingAlg()
theTester.ReallyCheck = True
topSequence += theTester
from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool
theLArBadChannelTool = LArBadChanTool()
theLArBadChannelTool.ReadFromASCII = False
theLArBadChannelTool.DumpCache = False
#theLArBadChannelTool.EMBAfile = "badchan1.txt"
theLArBadChannelTool.EMBCfile = "badchan1.txt"
theLArBadChannelTool.OutputLevel = DEBUG
ToolSvc += theLArBadChannelTool
svcMgr.IOVDbSvc.Folders += [
"/LAR/ElecCalib/BadChannels<tag>TestTag</tag><dbConnection>sqlite://;schema=BadChannels.db;dbname=CONDBR2</dbConnection>"
]
svcMgr += CfgMgr.AthenaEventLoopMgr(OutputLevel=WARNING)
## get a handle to the ApplicationManager, to the ServiceManager and to the ToolSvc from AthenaCommon.AppMgr import (theApp, ServiceMgr as svcMgr, ToolSvc) theApp.EvtMax = 1 #Thats the registration algo from LArBadChannelTool.LArBadChannelToolConf import LArBadChannelDBAlg theLArDBAlg = LArBadChannelDBAlg() theLArDBAlg.WritingMode = 0 theLArDBAlg.DBFolder = Folder theLArDBAlg.OutputLevel = DEBUG topSequence += theLArDBAlg from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool theLArBadChannelTool = LArBadChanTool() theLArBadChannelTool.ReadFromASCII = True theLArBadChannelTool.EMECAfile = InputFile theLArBadChannelTool.HECAfile = InputFile theLArBadChannelTool.FCALAfile = InputFile theLArBadChannelTool.EMECCfile = InputFile theLArBadChannelTool.HECCfile = InputFile theLArBadChannelTool.FCALCfile = InputFile theLArBadChannelTool.EMBAfile = InputFile theLArBadChannelTool.EMBCfile = InputFile theLArBadChannelTool.CoolFolder = "" theLArBadChannelTool.CoolMissingFEBsFolder = ""
def configure(self):
mlog = logging.getLogger('Py:LArRawChannelGetter::configure %s:' %
self.__class__)
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
from AthenaCommon.AppMgr import ToolSvc
# get LArDigitGetter in MC case
from AthenaCommon.DetFlags import DetFlags
if DetFlags.digitize.LAr_on():
try:
from LArDigitization.LArDigitGetter import LArDigitGetter
theLArDigitGetter = LArDigitGetter()
except Exception as configException:
print configException
mlog.error("could not get handle to LArDigitGetter Quit")
return False
if not theLArDigitGetter.usable():
mlog.error("LArDigitGetter unusable. Quite")
return False
from LArROD.LArRODFlags import larRODFlags
from AthenaCommon.GlobalFlags import globalflags
if globalflags.DataSource() == 'data' or larRODFlags.forceIter():
# ADC2MeV tool
from LArRecUtils.LArADC2MeVToolDefault import LArADC2MeVToolDefault
theADC2MeVTool = LArADC2MeVToolDefault()
ToolSvc += theADC2MeVTool
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
# Data case
if larRODFlags.readDigits():
from AthenaCommon.GlobalFlags import globalflags
if globalflags.InputFormat() == 'bytestream':
if not "LArDigitContainer/FREE" in svcMgr.ByteStreamAddressProviderSvc.TypeNames:
svcMgr.ByteStreamAddressProviderSvc.TypeNames += [
"LArDigitContainer/FREE"
]
if not larRODFlags.keepDSPRaw():
if "LArRawChannelContainer/LArRawChannels" in svcMgr.ByteStreamAddressProviderSvc.TypeNames:
svcMgr.ByteStreamAddressProviderSvc.TypeNames.remove(
"LArRawChannelContainer/LArRawChannels")
else:
if not "LArRawChannelContainer/LArRawChannels" in svcMgr.ByteStreamAddressProviderSvc.TypeNames:
svcMgr.ByteStreamAddressProviderSvc.TypeNames += [
"LArRawChannelContainer/LArRawChannels"
]
if globalflags.DetGeo() == 'ctbh6' or globalflags.DetGeo(
) == 'ctbh8':
from LArROD.LArRODConf import LArRawChannelBuilder
theLArRawChannelBuilder = LArRawChannelBuilder()
topSequence += theLArRawChannelBuilder
return True
from LArROD.LArRODConf import LArRawChannelBuilderDriver
theLArRawChannelBuilder = LArRawChannelBuilderDriver(
"LArRawChannelBuilder")
topSequence += theLArRawChannelBuilder
if larRODFlags.keepDSPRaw():
theLArRawChannelBuilder.LArRawChannelContainerName = larRODFlags.RawChannelFromDigitsContainerName(
)
# bad channel masking if required
if not larRODFlags.doBuildBadChannel():
# The first tool filters out bad channels
from LArROD.LArRODConf import LArRawChannelBuilderToolBadChannelTool
theLArRawChannelBuilderToolBadChannel = LArRawChannelBuilderToolBadChannelTool(
)
from LArBadChannelTool.LArBadChannelToolConf import LArBadChannelMasker
theLArRCBMasker = LArBadChannelMasker("LArRCBMasker")
theLArRCBMasker.DoMasking = True
theLArRCBMasker.ProblemsToMask = [
"deadReadout", "deadPhys", "almostDead", "short",
"lowNoiseHG", "highNoiseHG", "unstableNoiseHG",
"lowNoiseMG", "highNoiseMG", "unstableNoiseMG",
"lowNoiseLG", "highNoiseLG", "unstableNoiseLG"
]
#ToolSvc+=theLArRCBMasker
from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool
ToolSvc += LArBadChanTool()
theLArRawChannelBuilderToolBadChannel.BadChannelMask = theLArRCBMasker
theLArRawChannelBuilder.BuilderTools += [
theLArRawChannelBuilderToolBadChannel
]
ToolSvc += theLArRawChannelBuilderToolBadChannel
# Pulse reconstruction
# main method: OFC iteration
from LArROD.LArRODConf import LArRawChannelBuilderToolOFCIter
theLArRawChannelBuilderToolOFCIter = LArRawChannelBuilderToolOFCIter(
)
theLArRawChannelBuilderToolOFCIter.minSample = 2
theLArRawChannelBuilderToolOFCIter.maxSample = 12
theLArRawChannelBuilderToolOFCIter.minADCforIterInSigma = 4 # ADCmax at least 4 sigma above noise for iteration
theLArRawChannelBuilderToolOFCIter.minADCforIter = 15 # min adc for iteration (only if no pedestalRMS found)
theLArRawChannelBuilderToolOFCIter.defaultPhase = 0 # starting delay, also the fixed delay for ADC below min.
theLArRawChannelBuilderToolOFCIter.ECut = 250. # Energy to save quality
theLArRawChannelBuilder.BuilderTools += [
theLArRawChannelBuilderToolOFCIter
]
theLArRawChannelBuilder += theLArRawChannelBuilderToolOFCIter
# no fallback when emulating exactly DSP computation
if not larRODFlags.doDSP():
# fallback(1): cubic method
from LArROD.LArRODConf import LArRawChannelBuilderToolCubic
theLArRawChannelBuilderToolCubic = LArRawChannelBuilderToolCubic(
)
theLArRawChannelBuilderToolCubic.minADCforCubic = 30
theLArRawChannelBuilder.BuilderTools += [
theLArRawChannelBuilderToolCubic
]
theLArRawChannelBuilder += theLArRawChannelBuilderToolCubic
# fallback(2) averageing
from LArROD.LArRODConf import LArRawChannelBuilderToolAverage
theLArRawChannelBuilderToolAverage = LArRawChannelBuilderToolAverage(
)
theLArRawChannelBuilderToolAverage.NScan = 0
theLArRawChannelBuilder.BuilderTools += [
theLArRawChannelBuilderToolAverage
]
theLArRawChannelBuilder += theLArRawChannelBuilderToolAverage
# Pedestal
# main method from database
from LArROD.LArRODConf import LArRawChannelBuilderPedestalDataBase
theLArRawChannelBuilderPedestalDataBase = LArRawChannelBuilderPedestalDataBase(
)
theLArRawChannelBuilderPedestalDataBase.LArPedestalKey = "Pedestal"
theLArRawChannelBuilder.PedestalTools = [
theLArRawChannelBuilderPedestalDataBase
]
theLArRawChannelBuilder += theLArRawChannelBuilderPedestalDataBase
# no fallback when emulating exactly DSP computation
if not larRODFlags.doDSP():
# fallback. sample 0
from LArROD.LArRODConf import LArRawChannelBuilderPedestalSampleZero
theLArRawChannelBuilderPedestalSampleZero = LArRawChannelBuilderPedestalSampleZero(
)
theLArRawChannelBuilder.PedestalTools += [
theLArRawChannelBuilderPedestalSampleZero
]
theLArRawChannelBuilder += theLArRawChannelBuilderPedestalSampleZero
# ADC to energy
# main method from database
from LArROD.LArRODConf import LArRawChannelBuilderADC2EDataBase
theLArRawChannelBuilderADC2EDataBase = LArRawChannelBuilderADC2EDataBase(
)
theLArRawChannelBuilder.ADCtoEnergyTools = [
theLArRawChannelBuilderADC2EDataBase
]
theLArRawChannelBuilderADC2EDataBase.ADC2MeVTool = theADC2MeVTool
theLArRawChannelBuilder += theLArRawChannelBuilderADC2EDataBase
# no fallback when emulating exactly DSP computation
if not larRODFlags.doDSP():
# fallback, constant conversion factors
from LArROD.LArRODConf import LArRawChannelBuilderADC2EConstants
theLArRawChannelBuilderADC2EConstants = LArRawChannelBuilderADC2EConstants(
)
theLArRawChannelBuilder.ADCtoEnergyTools += [
theLArRawChannelBuilderADC2EConstants
]
theLArRawChannelBuilder += theLArRawChannelBuilderADC2EConstants
#more tools to be configured
from LArRecUtils.LArRecUtilsConf import LArOFPeakRecoTool
theLArOFPeakRecoTool = LArOFPeakRecoTool()
from LArConditionsCommon.LArCondFlags import larCondFlags
theLArOFPeakRecoTool.UseShape = larCondFlags.useShape()
if larCondFlags.LArCoolChannelSelection.statusOn:
if len(larCondFlags.LArCoolChannelSelection()) > 0:
theLArOFPeakRecoTool.forceHighGain = larCondFlags.useOFCOnlyCoolChannelSelection(
)
ToolSvc += theLArOFPeakRecoTool
#
# adjust default timing to match first sample information written in cool from Lar online configuration
#
nominalPeakSample = 2
if globalflags.DataSource() == 'data':
from LArConditionsCommon.LArCool import larcool
if (larcool is not None):
nominalPeakSample = larcool.firstSample()
# don't use ramp intercept in calibration if gain type is not auto
if larcool.gainType() > 0:
mlog.info(
" Gain Type: %d don't use intercept in ADC to Energy ramp calibration",
larcool.gainType())
theLArRawChannelBuilderADC2EDataBase.UseHighGainRampIntercept = False
theLArRawChannelBuilderADC2EDataBase.UseMedGainRampIntercept = False
theLArRawChannelBuilderADC2EDataBase.UseLowGainRampIntercept = False
else:
mlog.info(
" Gain Type: %d use intercept in ADC to energy ramp calibraion ",
larcool.gainType())
if (nominalPeakSample > 1):
theLArRawChannelBuilder.DefaultShiftTimeSample = nominalPeakSample - 2
else:
theLArRawChannelBuilder.DefaultShiftTimeSample = 0
theLArRawChannelBuilder.DataLocation = "FREE"
else:
from AthenaCommon.GlobalFlags import globalflags
if globalflags.InputFormat() == 'bytestream':
if not "LArRawChannelContainer/LArRawChannels" in svcMgr.ByteStreamAddressProviderSvc.TypeNames:
svcMgr.ByteStreamAddressProviderSvc.TypeNames += [
"LArRawChannelContainer/LArRawChannels"
]
# In the case of DSP monitoring and reading rawchannels, need to give a different name to the LArRawChannels container
# read from the bytestream ...
# This name has to be coherent with the name in LArMonTools/LArRODMonTool_jobOptions.py
if larRODFlags.doDSP() and larRODFlags.readRawChannels(
): #Reading LArRawChannel
print "Reading RawChannels in DSP physics mode"
# !!! The name of the LArRawChannels container read from the Bytestream is LArRawChannels_fB !!!
if not "LArRawChannelContainer/LArRawChannels_fB" in svcMgr.ByteStreamAddressProviderSvc.TypeNames:
svcMgr.ByteStreamAddressProviderSvc.TypeNames += [
"LArRawChannelContainer/LArRawChannels_fB"
]
print svcMgr.ByteStreamAddressProviderSvc.TypeNames
else:
# MC Case
try:
from AthenaCommon import CfgGetter
topSequence += CfgGetter.getAlgorithm(
"LArRawChannelBuilder", tryDefaultConfigurable=True)
except Exception as cfgException:
print cfgException
mlog.error("Failed to retrieve LArRawChannelBuilder. Quit")
return False
return True