def configure(self): mlog = logging.getLogger('TileHitGetterTool::configure:') mlog.info('entering') # get handle to upstream object try: from TileSimAlgs.TileHitGetterTool import TileHitGetterTool theTileHitGetterTool = TileHitGetterTool() except Exception: mlog.error("could not get handle to TileHitGetterTool Quit") traceback.print_exc() return False if not theTileHitGetterTool.usable(): if not self.ignoreConfigError(): mlog.error("TileHitGetterTool unusable. Quit.") return False else: mlog.error("TileHitGetterTool unusable. Continue nevertheless") # Instantiation of the C++ algorithm try: from TileSimAlgs.TileSimAlgsConf import TileHitVecToCntTool except Exception: mlog.error("could not import TileSimAlgs.TileHitVecToCntTool") traceback.print_exc() return False theTileHitVecToCntTool = TileHitVecToCntTool() self._TileHitVecToCntToolHandle = theTileHitVecToCntTool # Configure TileHitVecToCntTool here # Check TileDigitizationCosmics_jobOptions.py, # TileDigitization_jobOptions.py, TileSimAlgs_jobOptions.py and # TileTBDigitization_jobOptions.py for full configurability theTileHitVecToCntTool.TileHitVectors = ["TileHitVec", "MBTSHits"] theTileHitVecToCntTool.TileInfoName = "TileInfo" # sets output key theTileHitVecToCntTool.TileHitContainer = self.outputKey() # set the range of bunch crossing times that # TileHitVectToCntTool is interested in theTileHitVecToCntTool.FirstXing = -200 theTileHitVecToCntTool.LastXing = 150 # 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 to topSequence") # get a handle on topalg from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() topSequence.PileUpToolsAlg.PileUpTools += [theTileHitVecToCntTool] return True
def configure(self): mlog = logging.getLogger( 'TileCosmicMuon::configure:' ) mlog.info ('entering') # Instantiation of the C++ algorithm try: from TileCosmicAlgs.TileCosmicAlgsConf import TileMuonFitter except Exception: mlog.error("could not import TileCosmicAlgs.TileMuonFitter") mlog.error (traceback.format_exc()) return False theTileMuonFitter=TileMuonFitter() self._TileMuonFitter = theTileMuonFitter # sets output key theTileMuonFitter.TileCosmicMuonKey=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 to topSequence") from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() topSequence += theTileMuonFitter return True
def _AddOPIToESD(self): log = logging.getLogger("HLTTriggerResultGetter.py") if rec.doESD(): from PyUtils.MetaReaderPeeker import metadata if 'stream' in metadata: stream = metadata['stream'] log.debug("the stream found in 'metadata' is " + stream) if "express" in stream: from TrigEDMConfig.TriggerEDM import getTypeAndKey, EDMDetails type, key = getTypeAndKey( "TrigOperationalInfo#HLT_EXPRESS_OPI_HLT") if 'collection' in EDMDetails[type]: colltype = EDMDetails[type]['collection'] log.info( "Adding HLT_EXPRESS_OPI_HLT to ESD for stream " + stream) from RecExConfig.ObjKeyStore import objKeyStore objKeyStore.addStreamESD(colltype, key) return True else: log.warning( "Could not determine stream of bytestream file, not adding HLT_EXPRESS_OPI_HLT to ESD." ) return False
def configure(self): mlog = logging.getLogger('TileRawChannelFromHitsGetter::configure:') mlog.info('entering') # get handle to upstream object try: from TileSimAlgs.TileRawChannelFromHitsGetter import TileRawChannelFromHitsGetter theTileRawChannelFromHitsGetter = TileRawChannelFromHitsGetter() except Exception: mlog.error( "could not get handle to TileRawChannelFromHitsGetter Quit") traceback.print_exc() return False if not theTileRawChannelFromHitsGetter.usable(): if not self.ignoreConfigError(): mlog.error("TileRawChannelFromHitsGetter unusable. Quit.") return False else: mlog.error( "TileRawChannelFromHitsGetter unusable. Continue nevertheless" ) # Instantiation of the C++ algorithm try: from TileSimAlgs.TileSimAlgsConf import TileHitToRawChannel except Exception: mlog.error("could not import TileSimAlgs.TileHitToRawChannel") traceback.print_exc() return False theTileHitToRawChannel = TileHitToRawChannel() self._TileHitToRawChannelHandle = theTileHitToRawChannel # Configure TileHitToRawChannel here # Check TileRawChannel_jobOptions.py for full configurability theTileHitToRawChannel.TileHitContainer = "TileHitCnt" theTileHitToRawChannel.TileInfoName = "TileInfo" theTileHitToRawChannel.DeltaT = -1 # sets output key theTileHitToRawChannel.TileRawChannelContainer = 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 to topSequence") # get a handle on topalg from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() topSequence += theTileHitToRawChannel return True
def configure(self): mlog = logging.getLogger('TileHitGetter::configure:') mlog.info('entering') # get handle to upstream object try: from TileSimAlgs.TileHitGetter import TileHitGetter theTileHitGetter = TileHitGetter() except: mlog.error("could not get handle to TileHitGetter Quit") print traceback.format_exc() return False if not theTileHitGetter.usable(): if not self.ignoreConfigError(): mlog.error("TileHitGetter unusable. Quit.") return False else: mlog.error("TileHitGetter unusable. Continue nevertheless") # Instantiation of the C++ algorithm try: from TileSimAlgs.TileSimAlgsConf import TileHitVecToCnt except: mlog.error("could not import TileSimAlgs.TileHitVecToCnt") print traceback.format_exc() return False theTileHitVecToCnt = TileHitVecToCnt() self._TileHitVecToCntHandle = theTileHitVecToCnt # Configure TileHitVecToCnt here # Check TileDigitizationCosmics_jobOptions.py, # TileDigitization_jobOptions.py, TileSimAlgs_jobOptions.py and # TileTBDigitization_jobOptions.py for full configurability theTileHitVecToCnt.TileHitVectors = ["TileHitVec", "MBTSHits"] theTileHitVecToCnt.TileInfoName = "TileInfo" # sets output key theTileHitVecToCnt.TileHitContainer = 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 to topSequence") # get a handle on topalg from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() topSequence += theTileHitVecToCnt return True
def configure(self): mlog = logging.getLogger( 'TileL2FromRawChGetter::configure:' ) mlog.info ('entering') # get handle to upstream object try: from TileL2Algs.TileL2FromRawChGetter import TileL2FromRawChGetter theTileL2FromRawChGetter=TileL2FromRawChGetter() except Exception: mlog.error("could not get handle to TileL2FromRawChGetter Quit") traceback.print_exc() return False if not theTileL2FromRawChGetter.usable(): if not self.ignoreConfigError(): mlog.error("TileL2FromRawChGetter unusable. Quit.") return False else: mlog.error("TileL2FromRawChGetter unusable. Continue nevertheless") # Instantiation of the C++ algorithm try: from TileL2Algs.TileL2AlgsConf import TileRawChannelToL2 except Exception: mlog.error("could not import TileL2Algs.TileRawChannelToL2") traceback.print_exc() return False theTileRawChannelToL2=TileRawChannelToL2() self._TileRawChannelToL2Handle = theTileRawChannelToL2 # sets output key from Digitization.DigitizationFlags import digitizationFlags if digitizationFlags.PileUpPremixing and 'OverlayMT' in digitizationFlags.experimentalDigi(): from OverlayCommonAlgs.OverlayFlags import overlayFlags theTileRawChannelToL2.TileL2Container = overlayFlags.bkgPrefix() + self.outputKey() else: theTileRawChannelToL2.TileL2Container = 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 to topSequence") from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() topSequence += theTileRawChannelToL2 return True
def configure(self): mlog = logging.getLogger('TileCellFromCellIDCGetter::configure:') mlog.info('entering') # get handle to upstream object try: from TileRecAlgs.TileCellFromCellIDCGetter import TileCellFromCellIDCGetter theTileCellFromCellIDCGetter = TileCellFromCellIDCGetter() except: mlog.error( "could not get handle to TileCellFromCellIDCGetter Quit") print traceback.format_exc() return False if not theTileCellFromCellIDCGetter.usable(): if not self.ignoreConfigError(): mlog.error("TileCellFromCellIDCGetter unusable. Quit.") return False else: mlog.error( "TileCellFromCellIDCGetter unusable. Continue nevertheless" ) # Instantiation of the C++ algorithm try: from TileRecAlgs.TileRecAlgsConf import TileCellIDCToCell except: mlog.error("could not import TileRecAlgs.TileCellIDCToCell") print traceback.format_exc() return False theTileCellIDCToCell = TileCellIDCToCell() self._TileCellIDCToCellHandle = theTileCellIDCToCell # Configure TileCellIDCToCell here # Check TileByteStream/ReadTileCellBS_jobOptions.py for full configurability theTileCellIDCToCell.TileCellIDC = "TileCellIDC" theTileCellIDCToCell.TileInfoName = "TileInfo" # sets output key theTileCellIDCToCell.TileCellContainer = 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 to topSequence") from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() topSequence += theTileCellIDCToCell return True
def configure(self): mlog = logging.getLogger( 'TileTTL1FromDigitsGetter::configure:' ) mlog.info ('entering') # get handle to upstream object try: from TileRecAlgs.TileTTL1FromDigitsGetter import TileTTL1FromDigitsGetter theTileTTL1FromDigitsGetter=TileTTL1FromDigitsGetter() except: mlog.error("could not get handle to TileTTL1FromDigitsGetter Quit") print traceback.format_exc() return False if not theTileTTL1FromDigitsGetter.usable(): if not self.ignoreConfigError(): mlog.error("TileTTL1FromDigitsGetter unusable. Quit.") return False else: mlog.error("TileTTL1FromDigitsGetter unusable. Continue nevertheless") # Instantiation of the C++ algorithm try: from TileRecAlgs.TileRecAlgsConf import TileDigitsToTTL1 except: mlog.error("could not import TileRecAlgs.TileDigitsToTTL1") print traceback.format_exc() return False theTileDigitsToTTL1=TileDigitsToTTL1() self._TileDigitsToTTL1Handle = theTileDigitsToTTL1 ; # Configure TileDigitsToTTL1 here theTileDigitsToTTL1.TileDigitsContainer="TileDigitsCnt" theTileDigitsToTTL1.TileInfoName="TileInfo" # sets output key theTileDigitsToTTL1.TileTTL1Container=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 to topSequence") from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() topSequence += theTileDigitsToTTL1; return True
def configure(self): builder = createTruthParticlesBuilder( name=self._outputKey + "Builder", inMcEvtCollection=self._inputMcEvent, outTruthParticles=self._outputKey, selectSignalType=self._truthType) self._seq += builder mlog = logging.getLogger(self.__class__.__name__) mlog.info( " Recorded the %s ESD TruthParticle shadow collection - will be recreated on the fly " % (self.outputKey(), )) objKeyStore.addStreamESD("TruthParticleContainer", self.outputKey()) return True
def configure(self): mlog = logging.getLogger( 'DetStatusMapGetter::configure :' ) mlog.info ('entering') # now configure the algorithm try: from DetectorStatus.DetectorStatusConf import DetStatusAlg except Exception: mlog.error("could not import DetStatusAlg") mlog.error (traceback.format_exc()) return False # sets up cond db # still use old include for time being from AthenaCommon.Include import include include("DetectorStatus/DetStatusSvc_CondDB.py") # instantiate algorithm with default properties theDetStatusAlg=DetStatusAlg(Write=True) self._DetStatusAlgHandle = theDetStatusAlg # register output in objKeyStore from RecExConfig.ObjKeyStore import objKeyStore # output both in ESD and AOD objKeyStore.addStreamESD(self.outputType(),self.outputKey()) objKeyStore.addStreamAOD(self.outputType(),self.outputKey()) # now add algorithm to topSequence # this should always come at the end mlog.info(" now adding to topSequence") from __main__ import topSequence topSequence += theDetStatusAlg return True
def _AddOPIToESD(self): log = logging.getLogger("HLTTriggerResultGetter.py") if rec.doESD(): from RecExConfig.InputFilePeeker import inputFileSummary if inputFileSummary.has_key('bs_metadata') and inputFileSummary['bs_metadata'].has_key('Stream'): stream=inputFileSummary['bs_metadata']['Stream'] log.debug("the stream found in 'bs_metadata' is "+stream) if "express" in stream: from TrigEDMConfig.TriggerEDM import getTypeAndKey,EDMDetails type,key=getTypeAndKey("TrigOperationalInfo#HLT_EXPRESS_OPI_HLT") if EDMDetails[type].has_key('collection'): colltype = EDMDetails[type]['collection'] log.info("Adding HLT_EXPRESS_OPI_HLT to ESD for stream "+stream) from RecExConfig.ObjKeyStore import objKeyStore objKeyStore.addStreamESD(colltype, key) return True else: log.warning("Could not determine stream of bytestream file, not adding HLT_EXPRESS_OPI_HLT to ESD.") return False
from AthenaCommon.Logging import logging mlog = logging.getLogger('RDOtoESD_Lucid: ') from AthenaCommon.GlobalFlags import globalflags from RecExConfig.RecFlags import rec from RecExConfig.ObjKeyStore import objKeyStore if rec.doESD: if DetFlags.readRDOPool.Lucid_on(): include("LUCID_RawDataByteStreamCnv/LUCID_DigitRawDataCnv.py") if globalflags.DataSource() == 'geant4': objKeyStore.addStreamESD("LUCID_DigitContainer", "Lucid_Digits") objKeyStore.addStreamESD("LUCID_RawDataContainer", "Lucid_RawData")
def configure(self): log = logging.getLogger("HLTTriggerResultGetter.py") from RecExConfig.ObjKeyStore import objKeyStore # set EDMDecodingVersion EDMDecodingVersion() # Set AODFULL for data unless it was set explicitly already if TriggerFlags.AODEDMSet.isDefault() and globalflags.DataSource( ) == 'data': TriggerFlags.AODEDMSet = 'AODFULL' from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() log.info("BS unpacking (TF.readBS): %d", TriggerFlags.readBS()) if TriggerFlags.readBS(): if TriggerFlags.EDMDecodingVersion() <= 2: bs = ByteStreamUnpackGetterRun2() # noqa: F841 else: bs = ByteStreamUnpackGetter() # noqa: F841 xAODContainers = {} # if not recAlgs.doTrigger(): #only convert when running on old data if TriggerFlags.EDMDecodingVersion() == 1: xaodcnvrt = xAODConversionGetter() xAODContainers = xaodcnvrt.xaodlist if recAlgs.doTrigger() or TriggerFlags.doTriggerConfigOnly(): if TriggerFlags.EDMDecodingVersion() <= 2: tdt = TrigDecisionGetterRun2() # noqa: F841 else: tdt = TrigDecisionGetter() # noqa: F841 # Temporary hack to add Run-3 navigation to ESD and AOD if (rec.doESD() or rec.doAOD()) and TriggerFlags.EDMDecodingVersion() == 3: # The hack with wildcards is needed for BS->ESD because we don't know the exact keys # of HLT navigation containers before unpacking them from the BS event. objKeyStore._store['streamESD'].allowWildCard(True) objKeyStore._store['streamAOD'].allowWildCard(True) objKeyStore.addManyTypesStreamESD([ 'xAOD::TrigCompositeContainer#HLTNav*', 'xAOD::TrigCompositeAuxContainer#HLTNav*' ]) objKeyStore.addManyTypesStreamAOD([ 'xAOD::TrigCompositeContainer#HLTNav*', 'xAOD::TrigCompositeAuxContainer#HLTNav*' ]) # TrigJetRec additions if rec.doWriteESD(): objKeyStore.addStreamESD("JetKeyDescriptor", "JetKeyMap") objKeyStore.addStreamESD("JetMomentMap", "TrigJetRecMomentMap") if rec.doWriteAOD(): objKeyStore.addStreamAOD("JetKeyDescriptor", "JetKeyMap") objKeyStore.addStreamAOD("JetMomentMap", "TrigJetRecMomentMap") # ID truth if not rec.readESD() and (not rec.readAOD()) and TriggerFlags.doID() \ and rec.doTruth(): try: from TrigInDetTruthAlgs.TrigInDetTruthAlgsConfig import \ TrigIDTruthMaker topSequence += TrigIDTruthMaker() except Exception: log.warning("Couldn't set up the trigger ID truth maker") pass if rec.doESD() or rec.doAOD(): from TrigEDMConfig.TriggerEDM import getTrigIDTruthList objKeyStore.addManyTypesStreamESD( getTrigIDTruthList(TriggerFlags.ESDEDMSet())) objKeyStore.addManyTypesStreamAOD( getTrigIDTruthList(TriggerFlags.AODEDMSet())) if (rec.doESD() or rec.doAOD()) and TriggerFlags.writeL1TopoValData(): objKeyStore.addManyTypesStreamESD([ 'xAOD::TrigCompositeContainer#HLT_xAOD__TrigCompositeContainer_L1TopoValData', 'xAOD::TrigCompositeAuxContainer#HLT_xAOD__TrigCompositeContainer_L1TopoValDataAux.' ]) objKeyStore.addManyTypesStreamAOD([ 'xAOD::TrigCompositeContainer#HLT_xAOD__TrigCompositeContainer_L1TopoValData', 'xAOD::TrigCompositeAuxContainer#HLT_xAOD__TrigCompositeContainer_L1TopoValDataAux.' ]) log.debug( "HLT_xAOD__TrigCompositeContainer_L1TopoValData(Aux.) for L1Topo validation added to the data." ) if rec.doAOD() or rec.doWriteAOD(): # schedule the RoiDescriptorStore conversion # log.warning( "HLTTriggerResultGetter - setting up RoiWriter" ) roiWriter = RoiWriter() # Add fictional input to ensure data dependency in AthenaMT roiWriter.ExtraInputs += [("TrigBSExtractionOutput", "StoreGateSvc+TrigBSExtractionOutput")] topSequence += roiWriter # write out the RoiDescriptorStores from TrigEDMConfig.TriggerEDMRun2 import TriggerRoiList objKeyStore.addManyTypesStreamAOD(TriggerRoiList) #Are we adding operational info objects in ESD? added = self._AddOPIToESD() if added: log.debug( "Operational Info object HLT_EXPRESS_OPI_HLT with extra information about express stream prescaling added to the data." ) # ESD objects definitions _TriggerESDList = {} from TrigEDMConfig.TriggerEDM import getTriggerEDMList # we have to store xAOD containers in the root file, NOT AOD, # if the xAOD container list is not empty if (xAODContainers): _TriggerESDList.update(xAODContainers) else: _TriggerESDList.update( getTriggerEDMList(TriggerFlags.ESDEDMSet(), TriggerFlags.EDMDecodingVersion())) log.info( "ESD content set according to the ESDEDMSet flag: %s and EDM version %d", TriggerFlags.ESDEDMSet(), TriggerFlags.EDMDecodingVersion()) # AOD objects choice _TriggerAODList = {} #from TrigEDMConfig.TriggerEDM import getAODList _TriggerAODList.update( getTriggerEDMList(TriggerFlags.AODEDMSet(), TriggerFlags.EDMDecodingVersion())) log.info( "AOD content set according to the AODEDMSet flag: %s and EDM version %d", TriggerFlags.AODEDMSet(), TriggerFlags.EDMDecodingVersion()) log.debug("ESD EDM list: %s", _TriggerESDList) log.debug("AOD EDM list: %s", _TriggerAODList) # Highlight what is in AOD list but not in ESD list, as this can cause # the "different number of entries in branch" problem, when it is in the # AOD list but the empty container per event is not created # Just compares keys of dicts, which are the class names, not their string keys in StoreGate not_in = [ element for element in _TriggerAODList if element not in _TriggerESDList ] if (len(not_in) > 0): log.warning("In AOD list but not in ESD list: ") log.warning(not_in) else: log.info("AOD list is subset of ESD list - good.") def _addSlimming(stream, edm): from TrigNavTools.TrigNavToolsConfig import navigationThinningSvc edmlist = list(y.split('-')[0] for x in edm.values() for y in x) #flatten names svc = navigationThinningSvc({ 'name': 'HLTNav_%s' % stream, 'mode': 'cleanup', 'result': 'HLTResult_HLT', 'features': edmlist }) from OutputStreamAthenaPool.CreateOutputStreams import registerTrigNavThinningSvc registerTrigNavThinningSvc(stream, svc) log.info("Configured slimming of HLT for %s", stream) print(svc) # noqa: ATL901 del edmlist if TriggerFlags.doNavigationSlimming() and rec.readRDO( ) and rec.doWriteAOD(): _addSlimming('StreamAOD', _TriggerESDList) #Use ESD item list also for AOD! log.info("configured navigation slimming for AOD output") if TriggerFlags.doNavigationSlimming() and rec.readRDO( ) and rec.doWriteESD(): _addSlimming('StreamESD', _TriggerESDList) log.info("configured navigation slimming for ESD output") objKeyStore.addManyTypesStreamESD(_TriggerESDList) objKeyStore.addManyTypesStreamAOD(_TriggerAODList) return True
class SimpleCookedObjGetter(Configured): _outputType = "SimpleCookedObj" _output = {_outputType: "SimpleCookedObjBlaBlaDict"} def configure(self): mlog = logging.getLogger('Py:SimpleCookedObjGetter::configure %s:' % self.__class__) # work indeed # from __main__ import include # include("RecExAlgs/SimpleCookedObjMaker_jobOptions.py") # get handle to upstream object try: from RecExAlgs.SimpleRawObjGetter import SimpleRawObjGetter except ImportError, err: mlog.error("could not import SimpleRawObjGetter. Quit") return False theSimpleRawObjGetter = SimpleRawObjGetter() if not theSimpleRawObjGetter.usable(): if not self.ignoreConfigError(): mlog.error("SimpleRawObjGetter unusable. Quit.") return False else: mlog.error( "SimpleRawObjGetter unusable. Continue nevertheless") # get handle to tools # now configure the algorithm, part of this could be done in a separate class # cannot have same name try: from RecExAlgs.RecExAlgsConf import SimpleCookedObjMaker except ImportError: mlog.error("could not import SimpleCookedObjMaker. Quit") return False theSimpleCookedObjMaker = SimpleCookedObjMaker() self._SimpleCookedObjMakerHandle = theSimpleCookedObjMaker theSimpleCookedObjMaker.CookedMessage = "From SimpleCookedObjGetter.py" # # sets output key # these two lines are completely equivalent #self.SimpleCookedObjMakerHandle().CookedObjOutputName=self.outputKey() theSimpleCookedObjMaker.CookedObjOutputName = self.outputKey() # register output in objKeyStore # should eventually specify there that object to be written in a stream from RecExConfig.ObjKeyStore import objKeyStore objKeyStore.addStreamESD(self.outputType(), self.outputKey()) # if only transient store # objKeyStore.addTransient(self.outputType(),self.outputKey()) # can alter upstream alg property here, not recommended # theSimpleRawObjGetter.SimpleRawObjMakerHandle().RawMessage= "from SimpleCookedObjGetter" theSimpleCookedObjMaker.RawObjNames = [ theSimpleRawObjGetter.outputKey() ] # now add algorithm to topSequence # this should always come at the end mlog.info(" now adding to topSequence") from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() topSequence += self.SimpleCookedObjMakerHandle() return True
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") traceback.print_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") LArOnOffIdMapping() # Set up cabling cond algo # now configure the algorithm # cannot have same name try: from LArCellRec.LArCellRecConf import LArNoisyROAlg,LArNoisyROTool except: mlog.error("could not import LArNoisyROAlg or LArNoisyROTool") traceback.print_exc() return False theLArNoisyROTool=LArNoisyROTool(CellQualityCut=larNoisyROFlags.CellQualityCut(), BadChanPerFEB=larNoisyROFlags.BadChanPerFEB(), BadFEBCut=larNoisyROFlags.BadFEBCut(), MNBLooseCut=larNoisyROFlags.MNBLooseCut(), MNBTightCut=larNoisyROFlags.MNBTightCut(), MNBTight_PsVetoCut=larNoisyROFlags.MNBTight_PsVetoCut() ) theLArNoisyROAlg=LArNoisyROAlg() theLArNoisyROAlg.Tool=theLArNoisyROTool self._LArNoisyROMakerHandle = theLArNoisyROAlg theLArNoisyROAlg.OutputKey=self.outputKey() if globalflags.DataSource()=='geant4': theLArNoisyROAlg.isMC = True # register output in objKeyStore from RecExConfig.ObjKeyStore import objKeyStore objKeyStore.addStreamESD(self.outputType(),self.outputKey()) objKeyStore.addTransient(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
def configure(self): mlog = logging.getLogger('TileDigitsGetter::configure:') mlog.info('entering') # get handle to upstream object try: from TileSimAlgs.TileDigitsGetter import TileDigitsGetter theTileDigitsGetter = TileDigitsGetter() except Exception: mlog.error("could not get handle to TileDigitsGetter Quit") traceback.print_exc() return False if not theTileDigitsGetter.usable(): if not self.ignoreConfigError(): mlog.error("TileDigitsGetter unusable. Quit.") return False else: mlog.error("TileDigitsGetter unusable. Continue nevertheless") from TileConditions.TileInfoConfigurator import TileInfoConfigurator tileInfoConfigurator = TileInfoConfigurator() tileInfoConfigurator.setupCOOLPHYPULSE() # Instantiation of the C++ algorithm try: from TileSimAlgs.TileSimAlgsConf import TileDigitsMaker except Exception: mlog.error("could not import TileSimAlgs.TileDigitsMaker") traceback.print_exc() return False theTileDigitsMaker = TileDigitsMaker() self._TileDigitsMakerHandle = theTileDigitsMaker from Digitization.DigitizationFlags import digitizationFlags theTileDigitsMaker.DoHSTruthReconstruction = digitizationFlags.doDigiTruth( ) # Configure TileDigitsMaker here # Check TileDigitization_jobOptions.py for full configurability theTileDigitsMaker.TileHitContainer = "TileHitCnt" theTileDigitsMaker.TileHitContainer_DigiHSTruth = "TileHitCnt_DigiHSTruth" theTileDigitsMaker.TileInfoName = "TileInfo" theTileDigitsMaker.CalibrationRun = False # Save integer numbers in digits vector if not pile-up premixing theTileDigitsMaker.IntegerDigits = not digitizationFlags.PileUpPremixing( ) from TileConditions.TileConditionsConf import TileCondToolNoiseSample theTileDigitsMaker.TileCondToolNoiseSample = TileCondToolNoiseSample( TileOnlineSampleNoise='') # sets output key if digitizationFlags.PileUpPremixing and 'OverlayMT' in digitizationFlags.experimentalDigi( ): from OverlayCommonAlgs.OverlayFlags import overlayFlags theTileDigitsMaker.TileDigitsContainer = overlayFlags.bkgPrefix( ) + self.outputKey() else: theTileDigitsMaker.TileDigitsContainer = 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 to topSequence") # get a handle on topalg from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() topSequence += theTileDigitsMaker return True
from TrigFTKTrackConverter.TrigFTKTrackConverterConf import TrigFTKClusterConverterTool ClusterConvTool = TrigFTKClusterConverterTool(UsePixelCalibSvc=False) ToolSvc += ClusterConvTool print "Output file", OutputNTUP_FTKIPFile wrapper = FTKRegionalWrapper(OutputLevel=DEBUG, PMapPath=pmap_path, RMapPath=rmap_path, OutFileName=OutputNTUP_FTKIPFile, WriteClustersToESD=True, SaveHits=True, Clustering=True, TrigFTKClusterConverterTool=ClusterConvTool) wrapper.IBLMode = 1 wrapper.HitInputTool = FTKSGInput wrapper.Clustering = True theJob += wrapper from RecExConfig.ObjKeyStore import objKeyStore objKeyStore.addStreamESD("InDet::SCT_ClusterContainer", "FTK_SCT_Cluster") objKeyStore.addStreamESD("InDet::PixelClusterContainer", "FTK_Pixel_Clusters") objKeyStore.addStreamESD("Trk::PRD_MultiTruthCollection", "PRD_MultiTruthSCT_FTK") objKeyStore.addStreamESD("PRD_MultiTruthCollection", "PRD_MultiTruthSCT_FTK") objKeyStore.addStreamESD("PRD_MultiTruthCollection", "PRD_MultiTruthPixel_FTK") print theJob ###############################################################
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
def configure(self): mlog = logging.getLogger('CaloTowerCmbGetter::configure :') mlog.info('scheduled to output %s', self.output()) # get handle to upstream object # handle tile # handle LAr theCaloCellGetter = self.getInputGetter\ (jp.CaloRecFlags.clusterCellGetterName()) # now configure the algorithm, part of this could be done in a separate class # cannot have same name try: from CaloRec.CaloRecConf import CaloTowerAlgorithm theCaloTowerAlgorithm = CaloTowerAlgorithm("CmbTowerBldr") except: mlog.error("could not import CaloRec.CaloTowerAlgorithm") print traceback.format_exc() return False self._CaloTowerAlgorithmHandle = theCaloTowerAlgorithm # configure CaloTowerAlgorithm here try: from TileRecUtils.TileRecUtilsConf import TileTowerBuilderTool theTileTowerBuilderTool = TileTowerBuilderTool("TileCmbTwrBldr") except: mlog.error("could not get handle to TileTowerBuilderTool Quit") print traceback.format_exc() return False # add the tool to list of tool ( should use ToolHandle eventually) theCaloTowerAlgorithm.TowerBuilderTools += [ theTileTowerBuilderTool.getFullName() ] try: from LArRecUtils.LArRecUtilsConf import LArTowerBuilderTool, LArFCalTowerBuilderTool theLArTowerBuilderTool = LArTowerBuilderTool("LArCmbTwrBldr") theLArFCalTowerBuilderTool = LArFCalTowerBuilderTool( "LArFCalCmbTwrBldr") except: mlog.error( "could not get handle to LArTowerBuilderTool or LArFCalTowerBuilderTool. Quit" ) print traceback.format_exc() return False theCaloTowerAlgorithm.TowerBuilderTools += [ theLArTowerBuilderTool.getFullName() ] theCaloTowerAlgorithm.TowerBuilderTools += [ theLArFCalTowerBuilderTool.getFullName() ] theCaloTowerAlgorithm.NumberOfPhiTowers = 64 theCaloTowerAlgorithm.NumberOfEtaTowers = 100 theCaloTowerAlgorithm.EtaMin = -5.0 theCaloTowerAlgorithm.EtaMax = 5.0 theLArTowerBuilderTool.CellContainerName = theCaloCellGetter.outputKey( ) theLArTowerBuilderTool.IncludedCalos = ["LAREM", "LARHEC"] theLArFCalTowerBuilderTool.CellContainerName = theCaloCellGetter.outputKey( ) theLArFCalTowerBuilderTool.MinimumEt = 0 * MeV theTileTowerBuilderTool.CellContainerName = theCaloCellGetter.outputKey( ) theTileTowerBuilderTool.DumpTowers = False theTileTowerBuilderTool.DumpWeightMap = False # add tool to alg . From now on theCaloClusterBuilderSW will point # on a COPY of the tool, so property cannot be further modified ! theCaloTowerAlgorithm += theLArTowerBuilderTool theCaloTowerAlgorithm += theLArFCalTowerBuilderTool theCaloTowerAlgorithm += theTileTowerBuilderTool # FIXME TowerSpy missing # # sets output key theCaloTowerAlgorithm.TowerContainerName = 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 to topSequence") from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() topSequence += theCaloTowerAlgorithm return True
def configure(self): mlog = logging.getLogger( 'TileDigitsGetter::configure:' ) mlog.info ('entering') # get handle to upstream object try: from TileSimAlgs.TileDigitsGetter import TileDigitsGetter theTileDigitsGetter=TileDigitsGetter() except: mlog.error("could not get handle to TileDigitsGetter Quit") print traceback.format_exc() return False if not theTileDigitsGetter.usable(): if not self.ignoreConfigError(): mlog.error("TileDigitsGetter unusable. Quit.") return False else: mlog.error("TileDigitsGetter unusable. Continue nevertheless") from TileConditions.TileInfoConfigurator import TileInfoConfigurator tileInfoConfigurator = TileInfoConfigurator() tileInfoConfigurator.setupCOOLPHYPULSE() # Instantiation of the C++ algorithm try: from TileSimAlgs.TileSimAlgsConf import TileDigitsMaker except: mlog.error("could not import TileSimAlgs.TileDigitsMaker") print traceback.format_exc() return False theTileDigitsMaker=TileDigitsMaker() self._TileDigitsMakerHandle = theTileDigitsMaker ; theTileDigitsMaker.TileHitContainer_DigiHSTruth="TileHitCnt_DigiHSTruth" from Digitization.DigitizationFlags import digitizationFlags theTileDigitsMaker.DoHSTruthReconstruction = digitizationFlags.doDigiTruth() # Configure TileDigitsMaker here # Check TileDigitization_jobOptions.py for full configurability theTileDigitsMaker.TileHitContainer="TileHitCnt" theTileDigitsMaker.TileInfoName="TileInfo" theTileDigitsMaker.CalibrationRun=False # Random number engine theTileDigitsMaker.RndmSvc=digitizationFlags.rndmSvc() digitizationFlags.rndmSeedList.addSeed("Tile_DigitsMaker", 4789899, 989240512) # Save integer numbers in digits vector if not pile-up premixing theTileDigitsMaker.IntegerDigits = not digitizationFlags.PileUpPremixing() # sets output key theTileDigitsMaker.TileDigitsContainer=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 to topSequence") # get a handle on topalg from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() topSequence += theTileDigitsMaker; return True
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
def configure(self): mlog = logging.getLogger('CaloTopoTowerGetter::configure :') mlog.info('scheduled to output %s', self.output()) # get handle to upstream CaloCells theCaloCellGetter = self.getInputGetter\ (jp.CaloRecFlags.clusterCellGetterName()) # ----- get handle to upstream tower objects try: from CaloRec.CaloTowerCmbGetter import CaloTowerCmbGetter theCaloTowerCmbGetter = CaloTowerCmbGetter() except Exception: mlog.error("could not get handle to CaloTowerCmbGetter Quit") print(traceback.format_exc()) return False if not theCaloTowerCmbGetter.usable(): if not self.ignoreConfigError(): mlog.error("CaloTowerCmbGetter unusable. Quit.") return False else: mlog.error( "CaloTowerCmbGetter unusable. Continue nevertheless") # ------ get handle to upstream topo cluster object try: from CaloRec.CaloClusterTopoGetter import CaloClusterTopoGetter theCaloClusterTopoGetter = CaloClusterTopoGetter() except Exception: mlog.error("could not get handle to CaloClusterTopoGetter Quit") print(traceback.format_exc()) return False if not theCaloClusterTopoGetter.usable(): if not self.ignoreConfigError(): mlog.error("theCaloClusterTopoGetter unusable. Quit.") return False else: mlog.error( "theCaloClusterTopoGetter unusable. Continue nevertheless") # ------ get handle to upstream topo cluster object try: from CaloRec.CaloClusterTopoGetter import CaloClusterTopoGetter CaloClusterTopoGetter() from CaloRec.CaloCell2ClusterMapperGetters import CaloCell2TopoClusterMapperGetter theCaloCell2TopoClusterMapperGetter = CaloCell2TopoClusterMapperGetter( ) except Exception: mlog.error( "could not get handle to CaloCell2TopoClusterMapperGetter Quit" ) print(traceback.format_exc()) return False if not theCaloCell2TopoClusterMapperGetter.usable(): if not self.ignoreConfigError(): mlog.error( "theCaloCell2TopoClusterMapperGetter unusable. Quit.") return False else: mlog.error( "theCaloCell2TopoClusterMapperGetter 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 CaloTopoTowerAlgorithm theCaloTopoTowerAlgorithm = CaloTopoTowerAlgorithm("TopoTowerBldr") except Exception: mlog.error("could not import CaloRec.CaloTopoTowerAlgorithm") print(traceback.format_exc()) return False self._CaloTopoTowerAlgorithmHandle = theCaloTopoTowerAlgorithm # configure CaloTopoTowerAlgorithm here try: from CaloUtils.CaloUtilsConf import CaloTopoTowerBuilderTool theCaloTopoTowerBuilderTool = CaloTopoTowerBuilderTool( "TopoTowerTwrBldr") except Exception: mlog.error("could not get handle to CaloTopoTowerBuilderTool Quit") print(traceback.format_exc()) return False theCaloTopoTowerAlgorithm.TowerBuilderTools += [ theCaloTopoTowerBuilderTool.getFullName() ] ######################## # extra cuts which can be applied at the topo tower level # set input keys theCaloTopoTowerAlgorithm.InputTowerContainerName = theCaloTowerCmbGetter.outputKey( ) theCaloTopoTowerAlgorithm.ClusterContainerName = theCaloClusterTopoGetter.outputKey( ) theCaloTopoTowerAlgorithm.CellContainerName = theCaloCellGetter.outputKey( ) theCaloTopoTowerAlgorithm.Cell2ClusterMapName = theCaloCell2TopoClusterMapperGetter.outputKey( ) # sets output key theCaloTopoTowerAlgorithm.OutputTowerContainerName = self.outputKey() theCaloTopoTowerAlgorithm.MinimumCellEnergy = -1000000000.0 theCaloTopoTowerAlgorithm.MinimumClusterEnergy = -1000000000.0 theCaloTopoTowerAlgorithm.CellEnergySignificance = -1. # noise tool theCaloTopoTowerAlgorithm.UseCaloNoiseTool = False ######################## # add tool to alg . From now on theCaloClusterBuilderSW will point # on a COPY of the tool, so property cannot be further modified ! theCaloTopoTowerAlgorithm += theCaloTopoTowerBuilderTool # 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 to topSequence") from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() topSequence += theCaloTopoTowerAlgorithm return True
def configure(self): log = logging.getLogger("HLTTriggerResultGetter.py") from RecExConfig.ObjKeyStore import objKeyStore # set EDMDecodingVersion EDMDecodingVersion() # Set AODFULL for data unless it was set explicitly already if TriggerFlags.AODEDMSet.isDefault() and globalflags.DataSource()=='data': TriggerFlags.AODEDMSet = 'AODFULL' from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() log.info("BS unpacking (TF.readBS): %d" % TriggerFlags.readBS() ) if TriggerFlags.readBS(): bs = ByteStreamUnpackGetter() xAODContainers = {} # if not recAlgs.doTrigger(): #only convert when running on old data if TriggerFlags.EDMDecodingVersion()==1: xaodcnvrt = xAODConversionGetter() xAODContainers = xaodcnvrt.xaodlist if recAlgs.doTrigger() or TriggerFlags.doTriggerConfigOnly(): tdt = TrigDecisionGetter() # TrigJetRec additions if rec.doWriteESD(): objKeyStore.addStreamESD("JetKeyDescriptor","JetKeyMap") objKeyStore.addStreamESD("JetMomentMap","TrigJetRecMomentMap") if rec.doWriteAOD(): objKeyStore.addStreamAOD("JetKeyDescriptor","JetKeyMap") objKeyStore.addStreamAOD("JetMomentMap","TrigJetRecMomentMap") # ID truth if not rec.readESD() and (not rec.readAOD()) and TriggerFlags.doID() \ and rec.doTruth(): try: from TrigInDetTruthAlgs.TrigInDetTruthAlgsConfig import \ TrigIDTruthMaker topSequence += TrigIDTruthMaker() except Exception: log.warning( "Couldn't set up the trigger ID truth maker" ) pass if rec.doESD() or rec.doAOD(): from TrigEDMConfig.TriggerEDM import getTrigIDTruthList objKeyStore.addManyTypesStreamESD(getTrigIDTruthList(TriggerFlags.ESDEDMSet())) objKeyStore.addManyTypesStreamAOD(getTrigIDTruthList(TriggerFlags.AODEDMSet())) if (rec.doESD() or rec.doAOD()) and TriggerFlags.writeL1TopoValData(): objKeyStore.addManyTypesStreamESD(['xAOD::TrigCompositeContainer#HLT_xAOD__TrigCompositeContainer_L1TopoValData', 'xAOD::TrigCompositeAuxContainer#HLT_xAOD__TrigCompositeContainer_L1TopoValDataAux.']) objKeyStore.addManyTypesStreamAOD(['xAOD::TrigCompositeContainer#HLT_xAOD__TrigCompositeContainer_L1TopoValData', 'xAOD::TrigCompositeAuxContainer#HLT_xAOD__TrigCompositeContainer_L1TopoValDataAux.']) log.debug("HLT_xAOD__TrigCompositeContainer_L1TopoValData(Aux.) for L1Topo validation added to the data.") if rec.doAOD() or rec.doWriteAOD(): # schedule the RoiDescriptorStore conversion # log.warning( "HLTTriggerResultGetter - setting up RoiWriter" ) topSequence += RoiWriter() # write out the RoiDescriptorStores from TrigEDMConfig.TriggerEDM import TriggerRoiList objKeyStore.addManyTypesStreamAOD( TriggerRoiList ) #Are we adding operational info objects in ESD? added=self._AddOPIToESD() if added: log.debug("Operational Info object HLT_EXPRESS_OPI_HLT with extra information about express stream prescaling added to the data.") # ESD objects definitions _TriggerESDList = {} from TrigEDMConfig.TriggerEDM import getTriggerEDMList # we have to store xAOD containers in the root file, NOT AOD, # if the xAOD container list is not empty if(xAODContainers): _TriggerESDList.update( xAODContainers ) else: _TriggerESDList.update( getTriggerEDMList(TriggerFlags.ESDEDMSet(), TriggerFlags.EDMDecodingVersion()) ) log.info("ESD content set according to the ESDEDMSet flag: %s and EDM version %d" % (TriggerFlags.ESDEDMSet() ,TriggerFlags.EDMDecodingVersion()) ) # AOD objects choice _TriggerAODList = {} #from TrigEDMConfig.TriggerEDM import getAODList _TriggerAODList.update( getTriggerEDMList(TriggerFlags.AODEDMSet(), TriggerFlags.EDMDecodingVersion()) ) log.info("AOD content set according to the AODEDMSet flag: %s and EDM version %d" % (TriggerFlags.AODEDMSet(),TriggerFlags.EDMDecodingVersion()) ) log.debug("ESD EDM list: %s", _TriggerESDList) log.debug("AOD EDM list: %s", _TriggerAODList) # Highlight what is in AOD list but not in ESD list, as this can cause # the "different number of entries in branch" problem, when it is in the # AOD list but the empty container per event is not created # Just compares keys of dicts, which are the class names, not their string keys in StoreGate not_in = [ element for element in _TriggerAODList if element not in _TriggerESDList ] if (len(not_in)>0): log.warning("In AOD list but not in ESD list: ") log.warning(not_in) else: log.info("AOD list is subset of ESD list - good.") def _addSlimming(stream, thinningSvc, edm): from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() from TrigNavTools.TrigNavToolsConf import HLT__StreamTrigNavSlimming, HLT__TrigNavigationSlimming from TrigNavTools.TrigNavToolsConfig import navigationSlimming edmlist = list(y.split('-')[0] for x in edm.values() for y in x) #flatten names # from HLT result drop unrecorded features # slimmerHLT = HLT__StreamTrigNavSlimming('HLTNavSlimmer_%s'%stream) slimmerHLT = HLT__TrigNavigationSlimming('TrigNavigationSlimmer_%s'%stream) tHLT = navigationSlimming({'name':'HLTNav_%s'%stream, 'mode':'cleanup', 'ThinningSvc':thinningSvc, 'result':'HLTResult_HLT', 'features':edmlist}) #tHLT.SlimmingTool.OutputLevel=DEBUG tHLT.ActInPlace=True slimmerHLT.ThinningTool = tHLT print slimmerHLT.ThinningTool topSequence += slimmerHLT log.info("Configured slimming of HLT") del edmlist from AthenaCommon.AppMgr import ServiceMgr as svcMgr from AthenaServices.Configurables import ThinningSvc, createThinningSvc _doSlimming = True if _doSlimming and rec.readRDO() and rec.doWriteAOD(): if not hasattr(svcMgr, 'ThinningSvc'): # if the default is there it is configured for AODs svcMgr += ThinningSvc(name='ThinningSvc', Streams=['StreamAOD']) _addSlimming('StreamAOD', svcMgr.ThinningSvc, _TriggerESDList ) #Use ESD item list also for AOD! log.info("configured navigation slimming for AOD output") if _doSlimming and rec.readRDO() and rec.doWriteESD(): #rec.doWriteESD() and not rec.readESD(): if not hasattr(svcMgr, 'ESDThinningSvc'): svcMgr += ThinningSvc(name='ESDThinningSvc', Streams=['StreamESD']) # the default is configured for AODs _addSlimming('StreamESD', svcMgr.ESDThinningSvc, _TriggerESDList ) log.info("configured navigation slimming for ESD output") objKeyStore.addManyTypesStreamESD( _TriggerESDList ) objKeyStore.addManyTypesStreamAOD( _TriggerAODList ) return True
def configure(self): mlog = logging.getLogger('TileMuGetter::configure:') mlog.info('entering') # get handle to upstream object try: from TileMuId.TileMuGetter import TileMuGetter theTileMuGetter = TileMuGetter() except: mlog.error("could not get handle to TileMuGetter Quit") print traceback.format_exc() return False if not theTileMuGetter.usable(): if not self.ignoreConfigError(): mlog.error("TileMuGetter unusable. Quit.") return False else: mlog.error("TileMuGetter unusable. Continue nevertheless") # Instantiation of the C++ algorithm try: from TileMuId.TileMuIdConf import TileLookForMuAlg except: mlog.error("could not import TileMuId.TileLookForMuAlg") print traceback.format_exc() return False theTileLookForMuAlg = TileLookForMuAlg() self._TileLookForMuAlgHandle = theTileLookForMuAlg # Configure TileLookForMuAlg here # As in TileMuId_cosmics_jobOptions.py, check also # jobOptions_TileMuId.py and TileMuId_jobOptions.py #========== TILELOOKFORMUALG == theTileLookForMuAlg.CellsNames = "AllCalo" #=== thresholds in MeV ==================== # upper values are calculated considering muon with pt<=9GeV/c theTileLookForMuAlg.LowerTresh0MeV = 80.0 theTileLookForMuAlg.LowerTresh1MeV = 80.0 theTileLookForMuAlg.LowerTresh2MeV = 80.0 theTileLookForMuAlg.LowerTreshScinMeV = 160.0 #scintillators in eta=+-1.1 implemented as +-A5 # but eff/fakes still to be studied and settings to be optimized # tmp fix for cosmics (no rejection vs fake is needed ) theTileLookForMuAlg.UpperTresh2MeV = [ 2370.0, 2100.0, 900.0, 1050.0, 1050.0, 1110.0, 1590.0, 1110.0, 1050.0, 1050.0, 900.0, 2100.0, 2370.0 ] theTileLookForMuAlg.UpperTresh1MeV = [ 1680.0, 1500.0, 1440.0, 1380.0, 1050.0, 390.0, 1110.0, 1860.0, 1890.0, 1800.0, 1860.0, 1890.0, 1770.0, 1980.0, 2550.0, 2550.0, 1980.0, 1770.0, 1890.0, 1860.0, 1800.0, 1890.0, 1860.0, 1110.0, 390.0, 1050.0, 1380.0, 1440.0, 1500.0, 1680.0 ] theTileLookForMuAlg.UpperTresh0MeV = [ 1680.0, 1380.0, 1230.0, 1140.0, 210.0, 900.0, 960.0, 840.0, 930.0, 840.0, 840.0, 750.0, 870.0, 960.0, 1350.0, 1350.0, 960.0, 870.0, 750.0, 840.0, 840.0, 930.0, 840.0, 960.0, 900.0, 210.0, 1140.0, 1230.0, 1380.0, 1680.0 ] #======================== patterns for the muon search============ # 13*6 and 30*6 values: # for instance: starting from the 7th cell in the 3rd layer # check the 16th and 17th in the 2nd layer etc. theTileLookForMuAlg.From3to2 = [ 5, 0, 1, 2, 3, 4, 5, 2, 3, 4, 5, 6, 2, 6, 7, 0, 0, 0, 3, 7, 8, 9, 0, 0, 3, 9, 10, 11, 0, 0, 2, 12, 13, 0, 0, 0, 2, 14, 15, 0, 0, 0, 2, 16, 17, 0, 0, 0, 3, 18, 19, 20, 0, 0, 3, 20, 21, 22, 0, 0, 2, 22, 23, 0, 0, 0, 5, 23, 24, 25, 26, 27, 5, 25, 26, 27, 28, 29 ] theTileLookForMuAlg.From2to1 = [ 2, 1, 2, 0, 0, 0, 3, 1, 2, 3, 0, 0, 3, 2, 3, 4, 0, 0, 3, 3, 4, 5, 0, 0, 2, 4, 5, 0, 0, 0, 1, 5, 0, 0, 0, 0, 1, 6, 0, 0, 0, 0, 1, 7, 0, 0, 0, 0, 1, 8, 0, 0, 0, 0, 1, 9, 0, 0, 0, 0, 1, 10, 0, 0, 0, 0, 1, 11, 0, 0, 0, 0, 1, 12, 0, 0, 0, 0, 1, 13, 0, 0, 0, 0, 1, 14, 0, 0, 0, 0, 1, 15, 0, 0, 0, 0, 1, 16, 0, 0, 0, 0, 1, 17, 0, 0, 0, 0, 1, 18, 0, 0, 0, 0, 1, 19, 0, 0, 0, 0, 1, 20, 0, 0, 0, 0, 1, 21, 0, 0, 0, 0, 1, 22, 0, 0, 0, 0, 1, 23, 0, 0, 0, 0, 1, 24, 0, 0, 0, 0, 2, 24, 25, 0, 0, 0, 3, 24, 25, 26, 0, 0, 3, 25, 26, 27, 0, 0, 3, 26, 27, 28, 0, 0, 2, 27, 28, 0, 0, 0 ] # sets output key theTileLookForMuAlg.TileMuTagsOutputName = 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 to topSequence") from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() topSequence += theTileLookForMuAlg return True
def configure(self): from AthenaCommon.Logging import logging mlog = logging.getLogger('CaloCellGetter_DigiHSTruth::configure:') mlog.info('entering') doStandardCellReconstruction = True from CaloRec.CaloCellFlags import jobproperties # get handle to upstream object # handle tile if doStandardCellReconstruction: from LArROD.LArRODFlags import larRODFlags # 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 Exception: 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 if rec.doLArg(): from LArCabling.LArCablingAccess import LArOnOffIdMapping LArOnOffIdMapping() try: from LArCellRec.LArCellRecConf import LArCellBuilderFromLArRawChannelTool theLArCellBuilder = LArCellBuilderFromLArRawChannelTool( "LArCellBuilder_DigiHSTruth") theLArCellBuilder.RawChannelsName = "LArRawChannels_DigiHSTruth" except Exception: mlog.error( "could not get handle to LArCellBuilderFromLArRawChannel Quit" ) print(traceback.format_exc()) return False if jobproperties.CaloCellFlags.doLArCreateMissingCells(): theLArCellBuilder.addDeadOTX = True # add the tool to list of tool ( should use ToolHandle eventually) theCaloCellMaker += theLArCellBuilder theCaloCellMaker.CaloCellMakerToolNames += [theLArCellBuilder] if rec.doTile(): 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" theCaloCellMaker += theTileCellBuilder theCaloCellMaker.CaloCellMakerToolNames += [ theTileCellBuilder ] except Exception: 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( "CaloCellContainerFinalizerTool_DigiHSTruth") theCaloCellMaker += theCaloCellContainerFinalizerTool theCaloCellMaker.CaloCellMakerToolNames += [ theCaloCellContainerFinalizerTool ] # # Mergeing of calo cellcontainer with sparse raw channel container with improved energies # doLArMerge = False if doLArMerge: try: from LArCellRec.LArCellRecConf import LArCellMerger theLArCellMerger = LArCellMerger() except Exception: mlog.error("could not get handle to LArCellMerge Quit") print(traceback.format_exc()) return False theLArCellMerger.RawChannelsName = larRODFlags.RawChannelFromDigitsContainerName( ) theCaloCellMaker += 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 Exception: mlog.error( "could not get handle to LArCellNoiseMaskingTool Quit") print(traceback.format_exc()) return False if doSporadicMask: try: from LArBadChannelTool.LArBadChannelToolConf import LArBadChannelMasker theLArSporadicNoiseMasker = LArBadChannelMasker( "LArSporadicNoiseMasker") except Exception: mlog.error("could not access bad channel tool Quit") print(traceback.format_exc()) return False theLArSporadicNoiseMasker.DoMasking = True theLArSporadicNoiseMasker.ProblemsToMask = [ "sporadicBurstNoise" ] ToolSvc += theLArSporadicNoiseMasker theLArCellNoiseMaskingTool.MaskingSporadicTool = theLArSporadicNoiseMasker if doNoiseMask: try: from LArBadChannelTool.LArBadChannelToolConf import LArBadChannelMasker theLArNoiseMasker = LArBadChannelMasker("LArNoiseMasker") except Exception: mlog.error("could not access bad channel tool Quit") print(traceback.format_exc()) return False 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 theCaloCellMaker += theLArCellNoiseMaskingTool theCaloCellMaker.CaloCellMakerToolNames += [ theLArCellNoiseMaskingTool ] # # masking of Feb problems # doBadFebMasking = False 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 Exception: mlog.error("could not get handle to LArBadFebMaskingTool Quit") print(traceback.format_exc()) return False theCaloCellMaker += theLArBadFebMaskingTool theCaloCellMaker.CaloCellMakerToolNames += [ theLArBadFebMaskingTool ] # # emulate gain pathologies on MC # doGainPathology = False if jobproperties.CaloCellFlags.doLArCellGainPathology.statusOn and jobproperties.CaloCellFlags.doLArCellGainPathology( ): if globalflags.DataSource() == 'geant4': doGainPathology = True if doGainPathology: try: from LArCellRec.LArCellRecConf import LArCellGainPathology theLArCellGainPathology = LArCellGainPathology() except Exception: mlog.error("could not get handle to LArCellGainPatholog< Quit") print(traceback.format_exc()) return False theCaloCellMaker += 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 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 Exception: 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 Exception: mlog.error("could not get handle to MisCalibTool Quit") print(traceback.format_exc()) return False theCaloCellMaker += theMisCalibTool theCaloCellMaker.CaloCellMakerToolNames += [theMisCalibTool] # # Pedestal shift correction # doPedestalCorr = False if jobproperties.CaloCellFlags.doPedestalCorr.statusOn: if jobproperties.CaloCellFlags.doPedestalCorr() and ( jobproperties.CaloCellFlags.doPileupOffsetBCIDCorr): doPedestalCorr = True mlog.info("Apply cell level pedestal shift correction") if doPedestalCorr: try: from CaloCellCorrection.CaloCellPedestalCorrDefault import CaloCellPedestalCorrDefault theCaloCellPedestalCorr = CaloCellPedestalCorrDefault() theCaloCellMaker += theCaloCellPedestalCorr theCaloCellMaker.CaloCellMakerToolNames += [ theCaloCellPedestalCorr ] except Exception: 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.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 Exception: 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 Exception: 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 Exception: mlog.error( "could not get handle to CaloCellContainerCorrectorTool/MBAverageTool Quit" ) print(traceback.format_exc()) return False theCaloCellMaker += 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 Exception: mlog.error( "could not get handle to CaloCellNeighborsAverageCorr Quit" ) print(traceback.format_exc()) return False theCaloCellMaker += 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 Exception: mlog.error("could not get handle to LArCellDeadOTXCorr Quit") print(traceback.format_exc()) theCaloCellMaker += 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() # FIXME # theCaloCellContainerCheckerTool.OutputLevel=DEBUG theCaloCellMaker += 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()) # Also note that we produce it as a transient output. objKeyStore.addTransient(self.outputType(), self.outputKey()) from TileRecUtils.TileDQstatusAlgDefault import TileDQstatusAlgDefault TileDQstatusAlgDefault() # 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
#----------------------------------------------------------------------------- # TAG #----------------------------------------------------------------------------- # for LAr EC timing stuff... if rec.doLArg(): include("LArCellRec/LArCollisionTime_jobOptions.py") #Configure Algorithm to fill the tags from EventTagRawAlgs.EventTagRawAlgsConf import * from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() risftwriter = RawInfoSummaryForTagWriter() if rec.doInDet(): risftwriter.IDTrackKey = InDetKeys.Tracks() #MBTS threshold risftwriter.MBTS_Threshold = (60.0 / 222.0) topSequence += risftwriter # store the object in the ESD from RecExConfig.ObjKeyStore import objKeyStore objKeyStore.addStreamESD("RawInfoSummaryForTag", "RawInfoSummaryForTag") objKeyStore.addStreamAOD("RawInfoSummaryForTag", "RawInfoSummaryForTag")
#InDetESDList+=["Rec::TrackParticleContainer#FTK_TrackParticle"] #InDetESDList+=["TrackCollection#FTK_Trk_Tracks"] #InDetESDList+=["TrigInDetTrackCollection#FTK_LVL2_Tracks"] #InDetESDList+=["TrackCollection#FTKConv_Trk_Tracks"] # #from InDetRecExample.InDetKeys import InDetKeys #fullESDList+= CfgItemList( # "InDetEsd", # items = InDetESDList # ) include("RecExCond/RecExCommon_flags.py") from RecExConfig.ObjKeyStore import objKeyStore # FTK Add track containers objKeyStore.addStreamESD("Rec::TrackParticleContainer", "FTK_TrackParticles") objKeyStore.addStreamESD("TrackCollection", "FTK_Trk_Tracks") objKeyStore.addStreamESD("TrigInDetTrackCollection", "FTK_LVL2_Tracks") objKeyStore.addStreamESD("Rec::TrackParticleContainer", "FTK_TrackParticles_Refit") objKeyStore.addStreamESD("TrackCollection", "FTK_Trk_Tracks_Refit") objKeyStore.addStreamESD("TrigInDetTrackCollection", "FTK_LVL2_Tracks_Refit") # Truth related collections objKeyStore.addStreamESD("PRD_MultiTruthCollection", "PRD_MultiTruthPixel_FTK") objKeyStore.addStreamESD("PRD_MultiTruthCollection", "PRD_MultiTruthSCT_FTK") objKeyStore.addStreamESD("DetailedTrackTruthCollection", "FTK_Trk_Tracks_RefitDetailedTruthCollection") objKeyStore.addStreamESD("TrackTruthCollection", "FTK_Trk_Tracks_RefitTruthCollection") objKeyStore.addStreamESD("InDet::PixelClusterContainer", "FTK_Pixel_Clusters") objKeyStore.addStreamESD("InDet::SCT_ClusterContainer", "FTK_SCT_Cluster")
def configure(self): mlog = logging.getLogger('TileTTL1FromHitsGetter::configure:') mlog.info('entering') # get handle to upstream object try: from TileSimAlgs.TileTTL1FromHitsGetter import TileTTL1FromHitsGetter theTileTTL1FromHitsGetter = TileTTL1FromHitsGetter() except Exception: mlog.error("could not get handle to TileTTL1FromHitsGetter Quit") traceback.print_exc() return False if not theTileTTL1FromHitsGetter.usable(): if not self.ignoreConfigError(): mlog.error("TileTTL1FromHitsGetter unusable. Quit.") return False else: mlog.error( "TileTTL1FromHitsGetter unusable. Continue nevertheless") # Instantiation of the C++ algorithm try: from TileSimAlgs.TileSimAlgsConf import TileHitToTTL1 except Exception: mlog.error("could not import TileSimAlgs.TileHitToTTL1") traceback.print_exc() return False theTileHitToTTL1 = TileHitToTTL1() self._TileHitToTTL1 = theTileHitToTTL1 # Configure TileHitToTTL1 here # Check TileTTL1_jobOptions.py for full configurability theTileHitToTTL1.TileHitContainer = "TileHitCnt" theTileHitToTTL1.TileInfoName = "TileInfo" # sets output key from Digitization.DigitizationFlags import digitizationFlags if digitizationFlags.PileUpPremixing and 'OverlayMT' in digitizationFlags.experimentalDigi( ): from OverlayCommonAlgs.OverlayFlags import overlayFlags theTileHitToTTL1.TileTTL1Container = overlayFlags.bkgPrefix( ) + self.outputKey() theTileHitToTTL1.TileMBTSTTL1Container = overlayFlags.bkgPrefix( ) + "TileTTL1MBTS" else: theTileHitToTTL1.TileTTL1Container = self.outputKey() theTileHitToTTL1.TileMBTSTTL1Container = "TileTTL1MBTS" # 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 to topSequence") # get a handle on topalg from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() topSequence += theTileHitToTTL1 return True