python.LArDigitizationConfig Namespace Reference

Functions
	useLArFloat (flags)
	LArRangeEMCfg (flags, name="LArRangeEM", **kwargs)
	LArRangeHECCfg (flags, name="LArRangeHEC", **kwargs)
	LArRangeFCALCfg (flags, name="LArRangeFCAL", **kwargs)
	LArPileUpToolCfg (flags, name="LArPileUpTool", **kwargs)
	LArHitEMapToDigitAlgCfg (flags, name="LArHitEMapToDigitAlg", **kwargs)
	LArOutputCfg (flags)
	LArDigitizationBasicCfg (flags, **kwargs)
	LArDigitizationCfg (flags, **kwargs)
	LArOverlayDigitizationBasicCfg (flags, name="digitmaker1", **kwargs)
	LArOverlayCfg (flags, **kwargs)
	LArAutoCorrNoiseCondSCAlgCfg (flags, **kwargs)
	LArSCL1MakerCfg (flags, **kwargs)
	LArTriggerDigitizationBasicCfg (flags, **kwargs)
	LArTriggerDigitizationCfg (flags, **kwargs)
	LArOverlayTriggerDigitizationBasicCfg (flags, **kwargs)
	LArSuperCellOverlayCfg (flags, **kwargs)

Detailed Description

Define functions for LAr Digitization with ComponentAccumulator

Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration

Function Documentation

LArAutoCorrNoiseCondSCAlgCfg()

python.LArDigitizationConfig.LArAutoCorrNoiseCondSCAlgCfg	(		flags,
		**	kwargs )

Definition at line 295 of file LArDigitizationConfig.py.

def LArAutoCorrNoiseCondSCAlgCfg(flags, **kwargs):
    acc = ComponentAccumulator()
 
    requiredConditions=["AutoCorrSC"]
    from LArConfiguration.LArElecCalibDBConfig import LArElecCalibDBMCSCCfg
    acc.merge(LArElecCalibDBMCSCCfg(flags,requiredConditions))
    kwargs.setdefault("LArAutoCorrObjKey", "LArAutoCorrSC") # Provided by LArFlatConditionsAlg<LArAutoCorrSC>
 
    from LArCabling.LArCablingConfig import LArOnOffIdMappingSCCfg
    acc.merge(LArOnOffIdMappingSCCfg(flags))
    kwargs.setdefault("LArOnOffIdMappingObjKey", 'LArOnOffIdMapSC')
    kwargs.setdefault("nSampl", flags.LAr.ROD.nSamples + 2) # See ATLASSIM-5483
    kwargs.setdefault("isSuperCell", True)
    kwargs.setdefault("LArAutoCorrNoiseObjKey", "LArAutoCorrNoiseSC") # output
    acc.addCondAlgo(CompFactory.LArAutoCorrNoiseCondAlg(name="LArAutoCorrNoiseSCCondAlg", **kwargs))
    return acc
 
 

LArDigitizationBasicCfg()

python.LArDigitizationConfig.LArDigitizationBasicCfg	(		flags,
		**	kwargs )

Return ComponentAccumulator with LAr digitization configuration

Definition at line 240 of file LArDigitizationConfig.py.

def LArDigitizationBasicCfg(flags, **kwargs):
    """Return ComponentAccumulator with LAr digitization configuration"""
    acc = ComponentAccumulator()
    if "PileUpTools" not in kwargs:
        PileUpTools = acc.popToolsAndMerge(LArPileUpToolCfg(flags))
        kwargs["PileUpTools"] = PileUpTools
    acc.merge(PileUpToolsCfg(flags, **kwargs))
 
    acc.merge(LArHitEMapToDigitAlgCfg(flags))
    if flags.LAr.ROD.NNRawChannelBuilding:
        acc.merge(LArNNRawChannelBuilderCfg(flags))
    elif flags.LAr.ROD.OFFCRawChannelBuilding:
        acc.merge(LArOFFCRawChannelBuilderCfg(flags))
    else:
        acc.merge(LArRawChannelBuilderAlgCfg(flags))
 
    if flags.Digitization.AddCaloDigiThinned:
        acc.merge(LArDigitThinnerCfg(flags))
    return acc
 
 

LArDigitizationCfg()

python.LArDigitizationConfig.LArDigitizationCfg	(		flags,
		**	kwargs )

Return ComponentAccumulator with LAr digitization and Output

Definition at line 261 of file LArDigitizationConfig.py.

def LArDigitizationCfg(flags, **kwargs):
    """Return ComponentAccumulator with LAr digitization and Output"""
    acc = LArDigitizationBasicCfg(flags, **kwargs)
    acc.merge(LArOutputCfg(flags))
    return acc
 
 

LArHitEMapToDigitAlgCfg()

python.LArDigitizationConfig.LArHitEMapToDigitAlgCfg	(		flags,
			name = "LArHitEMapToDigitAlg",
		**	kwargs )

Return ComponentAccumulator with configured LArHitEMapToDigitAlg

Definition at line 164 of file LArDigitizationConfig.py.

def LArHitEMapToDigitAlgCfg(flags, name="LArHitEMapToDigitAlg", **kwargs):
    """Return ComponentAccumulator with configured LArHitEMapToDigitAlg"""
    acc = LArGMCfg(flags)
 
    #The LArHitEMapToDigit needs: Noise, fSampl, Pedestal,Shape ADC2MeV
    # AutoCorrNoise, the list of bad FEBs and the cabling
    acc.merge(LArADC2MeVCondAlgCfg(flags))
    acc.merge(LArBadFebCfg(flags))
    acc.merge(LArBadChannelCfg(flags))
    if flags.Overlay.DataOverlay:
        kwargs.setdefault("ShapeKey", "LArShape")
        #kwargs.setdefault("AutoCorrNoiseKey", "LArAutoCorr")
    if not flags.Digitization.DoCaloNoise:
        requiredConditons=["fSampl", "Pedestal", "Shape"]
    else:
        requiredConditons=["Noise", "fSampl", "Pedestal", "Shape"]
    acc.merge(LArElecCalibDBCfg(flags,requiredConditons))
 
    if not flags.Common.isOverlay:
        acc.merge(LArAutoCorrNoiseCondAlgCfg(flags))
        #kwargs.setdefault('AutoCorrNoiseKey','LArAutoCorr')
 
    if "ProblemsToMask" not in kwargs:
        kwargs["ProblemsToMask"] = ["deadReadout", "deadPhys"]
    # defaults
    if flags.Common.isOverlay:
        # Some noise needs to be added during MC Overlay
        # No noise should be added during Data Overlay
        kwargs.setdefault("NoiseOnOff", not flags.Overlay.DataOverlay)
    else :
        kwargs.setdefault("NoiseOnOff", flags.Digitization.DoCaloNoise)
    kwargs.setdefault("DoDigiTruthReconstruction", flags.Digitization.EnableCaloHSTruthRecoInputs)
    kwargs.setdefault("RandomSeedOffset", flags.Digitization.RandomSeedOffset)
    if (not flags.Digitization.HighGainFCal) and (not flags.Common.isOverlay):
        kwargs.setdefault("HighGainThreshFCAL", 0)
        kwargs.setdefault("GainRangeFCAL",[int(CaloGain.LARMEDIUMGAIN),int(CaloGain.LARLOWGAIN)])
    if (not flags.Digitization.HighGainEMECIW) and (not flags.Common.isOverlay):
        kwargs.setdefault("HighGainThreshEMECIW", 0)
        kwargs.setdefault("GainRangeEMECIW",[int(CaloGain.LARMEDIUMGAIN),int(CaloGain.LARLOWGAIN)])
    kwargs.setdefault("RndmEvtOverlay", flags.Common.isOverlay)
    if flags.Common.ProductionStep == ProductionStep.PileUpPresampling:
        kwargs.setdefault("DigitContainer", flags.Overlay.BkgPrefix + "LArDigitContainer_MC")
    else:
        kwargs.setdefault("DigitContainer", "LArDigitContainer_MC") # FIXME - should not be hard-coded
    # if doing MC+MC overlay
    if flags.Common.isOverlay and flags.Input.isMC:
          kwargs.setdefault("isMcOverlay", True)
    kwargs.setdefault("Nsamples", flags.LAr.ROD.nSamples)
    kwargs.setdefault("firstSample", #Need to set a negative value to include preceeding samples
                      -flags.LAr.ROD.nPreceedingSamples if flags.LAr.ROD.nPreceedingSamples!=0 else flags.LAr.ROD.FirstSample)
    LArHitEMapToDigitAlg = CompFactory.LArHitEMapToDigitAlg
    acc.addEventAlgo(LArHitEMapToDigitAlg(name, **kwargs))
    return acc
 

LArOutputCfg()

python.LArDigitizationConfig.LArOutputCfg

(

flags

)

Return ComponentAccumulator with Output for LAr. Not standalone.

Definition at line 218 of file LArDigitizationConfig.py.

def LArOutputCfg(flags):
    """Return ComponentAccumulator with Output for LAr. Not standalone."""
    acc = ComponentAccumulator()
    if flags.Output.doWriteRDO:
        ItemList = []
        if flags.Digitization.AddCaloDigi:
            ItemList.append("LArDigitContainer#*")
        elif flags.Common.ProductionStep == ProductionStep.PileUpPresampling:
            ItemList.append("LArDigitContainer#" + flags.Overlay.BkgPrefix + "LArDigitContainer_MC")
        elif flags.Digitization.AddCaloDigiThinned:
            ItemList.append("LArDigitContainer#LArDigitContainer_MC_Thinned")
        if flags.Common.ProductionStep != ProductionStep.PileUpPresampling:
            ItemList.append("LArRawChannelContainer#LArRawChannels")
        if flags.Overlay.DataOverlay:
            ItemList.append("LArFebHeaderContainer#LArFebHeader")
        if flags.Digitization.EnableTruth:
            ItemList.append("CaloCalibrationHitContainer#*")
            acc.merge(TruthDigitizationOutputCfg(flags))
        acc.merge(OutputStreamCfg(flags, "RDO", ItemList))
    return acc
 
 

LArOverlayCfg()

python.LArDigitizationConfig.LArOverlayCfg	(		flags,
		**	kwargs )

Return ComponentAccumulator with LAr overlay and Output

Definition at line 288 of file LArDigitizationConfig.py.

def LArOverlayCfg(flags, **kwargs):
    """Return ComponentAccumulator with LAr overlay and Output"""
    acc = LArOverlayDigitizationBasicCfg(flags, **kwargs)
    acc.merge(LArOutputCfg(flags))
    return acc
 
 

LArOverlayDigitizationBasicCfg()

python.LArDigitizationConfig.LArOverlayDigitizationBasicCfg	(		flags,
			name = "digitmaker1",
		**	kwargs )

Return ComponentAccumulator with LAr Overlay digitization configuration

Definition at line 268 of file LArDigitizationConfig.py.

def LArOverlayDigitizationBasicCfg(flags, name="digitmaker1", **kwargs):
    """Return ComponentAccumulator with LAr Overlay digitization configuration"""
    acc = ComponentAccumulator()
 
    if "LArPileUpTool" not in kwargs:
        kwargs["LArPileUpTool"] = acc.popToolsAndMerge(LArPileUpToolCfg(flags))
 
    if flags.Concurrency.NumThreads > 0:
        kwargs.setdefault('Cardinality', flags.Concurrency.NumThreads)
 
    LArHitEMapMaker = CompFactory.LArHitEMapMaker
    acc.addEventAlgo(LArHitEMapMaker(name, **kwargs))
    acc.merge(LArHitEMapToDigitAlgCfg(flags))
 
    acc.merge(LArRawChannelBuilderAlgCfg(flags))
    if flags.Digitization.AddCaloDigiThinned:
        acc.merge(LArDigitThinnerCfg(flags))
    return acc
 
 

LArOverlayTriggerDigitizationBasicCfg()

python.LArDigitizationConfig.LArOverlayTriggerDigitizationBasicCfg	(		flags,
		**	kwargs )

Return ComponentAccumulator with LAr Overlay Trigger Tower

Definition at line 392 of file LArDigitizationConfig.py.

def LArOverlayTriggerDigitizationBasicCfg(flags, **kwargs):
    """Return ComponentAccumulator with LAr Overlay Trigger Tower"""
    acc = LArOverlayDigitizationBasicCfg(flags)
    acc.merge(CaloTriggerTowerCfg(flags))
 
    kwargs.setdefault("NoiseOnOff", flags.Digitization.DoCaloNoise)
    kwargs.setdefault("RandomSeedOffset", flags.Digitization.RandomSeedOffset)
    kwargs.setdefault("PileUp", True)
    kwargs.setdefault("EmTTL1ContainerName", flags.Overlay.SigPrefix + "LArTTL1EM")
    kwargs.setdefault("HadTTL1ContainerName", flags.Overlay.SigPrefix + "LArTTL1HAD")
 
    if flags.Concurrency.NumThreads > 0:
        kwargs.setdefault('Cardinality', flags.Concurrency.NumThreads)
 
    acc.addEventAlgo(CompFactory.LArTTL1Maker(**kwargs))
    return acc
 
 

LArPileUpToolCfg()

python.LArDigitizationConfig.LArPileUpToolCfg	(		flags,
			name = "LArPileUpTool",
		**	kwargs )

Return ComponentAccumulator with configured LArPileUpTool

Definition at line 84 of file LArDigitizationConfig.py.

def LArPileUpToolCfg(flags, name="LArPileUpTool", **kwargs):
    """Return ComponentAccumulator with configured LArPileUpTool"""
    acc = LArGMCfg(flags)
 
    # add new conditions for LArXTalkWeight
    acc.merge(LArXTalkWeightCondAlgCfg(flags))
 
    # defaults
    if flags.Common.isOverlay:
        # Some noise needs to be added during MC Overlay
        # No noise should be added during Data Overlay
        kwargs.setdefault("NoiseOnOff", not flags.Overlay.DataOverlay)
    kwargs.setdefault("NoiseOnOff", flags.Digitization.DoCaloNoise) # For other jobs go with the noise flag setting.
    kwargs.setdefault("DoDigiTruthReconstruction", flags.Digitization.EnableCaloHSTruthRecoInputs)
    kwargs.setdefault("RandomSeedOffset", flags.Digitization.RandomSeedOffset)
    if flags.Digitization.PileUp:
        intervals = []
        if flags.Digitization.DoXingByXingPileUp:
            kwargs.setdefault("FirstXing", -751)
            kwargs.setdefault("LastXing", 101)
        else:
            intervals += [acc.popToolsAndMerge(LArRangeEMCfg(flags))]
            intervals += [acc.popToolsAndMerge(LArRangeHECCfg(flags))]
            intervals += [acc.popToolsAndMerge(LArRangeFCALCfg(flags))]
        kwargs.setdefault("PileUpMergeSvc", acc.getPrimaryAndMerge(PileUpMergeSvcCfg(flags, Intervals=intervals)))
    else:
        kwargs.setdefault("PileUpMergeSvc", '')
    kwargs.setdefault("RndmEvtOverlay", flags.Common.isOverlay)
    # if doing MC+MC overlay
    if flags.Common.isOverlay and flags.Input.isMC:
        kwargs.setdefault("isMcOverlay", True)
 
    # cosmics digitization
    if flags.Beam.Type is BeamType.Cosmics:
        kwargs.setdefault("UseTriggerTime", True)
        acc.addEventAlgo(CompFactory.CosTriggerTimeAlg())
    if flags.Digitization.PileUp or flags.Common.isOverlay:
        kwargs.setdefault("PileUp", True)
    kwargs.setdefault("useLArFloat", useLArFloat(flags))
    if useLArFloat(flags):
        acc.merge(InputOverwriteCfg("LArHitContainer","LArHitEMB","LArHitFloatContainer","LArHitEMB"))
        acc.merge(InputOverwriteCfg("LArHitContainer","LArHitEMEC","LArHitFloatContainer","LArHitEMEC"))
        acc.merge(InputOverwriteCfg("LArHitContainer","LArHitHEC","LArHitFloatContainer","LArHitHEC"))
        acc.merge(InputOverwriteCfg("LArHitContainer","LArHitFCAL","LArHitFloatContainer","LArHitFCAL"))
        if flags.Common.isOverlay:
            from SGComps.SGInputLoaderConfig import SGInputLoaderCfg
            acc.merge(SGInputLoaderCfg(flags, [
                "LArHitFloatContainer#LArHitEMB",
                "LArHitFloatContainer#LArHitEMEC",
                "LArHitFloatContainer#LArHitFCAL",
                "LArHitFloatContainer#LArHitHEC",
            ]))
    else:
        if flags.Common.isOverlay and not flags.Sim.DoFullChain:
            from SGComps.SGInputLoaderConfig import SGInputLoaderCfg
            acc.merge(SGInputLoaderCfg(flags, [
                "LArHitContainer#LArHitEMB",
                "LArHitContainer#LArHitEMEC",
                "LArHitContainer#LArHitFCAL",
                "LArHitContainer#LArHitHEC",
            ]))
 
    if flags.Common.isOverlay:
        kwargs.setdefault("OnlyUseContainerName", False)
        if flags.Overlay.IgnoreBkgInputs:
            kwargs.setdefault("InputDigitContainer", "")
        elif flags.Input.isMC:
            kwargs.setdefault("InputDigitContainer", f"{flags.Overlay.BkgPrefix}LArDigitContainer_MC")
        else:
            kwargs.setdefault("InputDigitContainer", f"{flags.Overlay.BkgPrefix}LArDigitContainer_data")
 
        if kwargs["InputDigitContainer"]:
            from SGComps.SGInputLoaderConfig import SGInputLoaderCfg
            acc.merge(SGInputLoaderCfg(flags, [f'LArDigitContainer#{kwargs["InputDigitContainer"]}']))
    else:
        kwargs.setdefault("OnlyUseContainerName", flags.Digitization.PileUp)
    LArPileUpTool = CompFactory.LArPileUpTool
    acc.setPrivateTools(LArPileUpTool(name, **kwargs))
    return acc
 

LArRangeEMCfg()

python.LArDigitizationConfig.LArRangeEMCfg	(		flags,
			name = "LArRangeEM",
		**	kwargs )

Return a PileUpXingFoldertool for ElectroMagnetic calorimeter

Definition at line 46 of file LArDigitizationConfig.py.

def LArRangeEMCfg(flags, name="LArRangeEM", **kwargs):
    """Return a PileUpXingFoldertool for ElectroMagnetic calorimeter"""
    # bunch crossing range in ns
    kwargs.setdefault("FirstXing", -751)
    kwargs.setdefault("LastXing", 101)
    if useLArFloat(flags):
        kwargs.setdefault("ItemList", ["LArHitFloatContainer#LArHitEMB",
                                       "LArHitFloatContainer#LArHitEMEC"])
    else:
        kwargs.setdefault("ItemList", ["LArHitContainer#LArHitEMB",
                                       "LArHitContainer#LArHitEMEC"])
    return PileUpXingFolderCfg(flags, name, **kwargs)
 
 

LArRangeFCALCfg()

python.LArDigitizationConfig.LArRangeFCALCfg	(		flags,
			name = "LArRangeFCAL",
		**	kwargs )

Return a PileUpXingFoldertool for Forward Calorimeters

Definition at line 72 of file LArDigitizationConfig.py.

def LArRangeFCALCfg(flags, name="LArRangeFCAL", **kwargs):
    """Return a PileUpXingFoldertool for Forward Calorimeters"""
    # bunch crossing range in ns
    kwargs.setdefault("FirstXing", -551)
    kwargs.setdefault("LastXing", 101)
    if useLArFloat(flags):
        kwargs.setdefault("ItemList", ["LArHitFloatContainer#LArHitFCAL"])
    else:
        kwargs.setdefault("ItemList", ["LArHitContainer#LArHitFCAL"])
    return PileUpXingFolderCfg(flags, name, **kwargs)
 
 

LArRangeHECCfg()

python.LArDigitizationConfig.LArRangeHECCfg	(		flags,
			name = "LArRangeHEC",
		**	kwargs )

Return a PileUpXingFoldertool for Hadronic End-Cap

Definition at line 60 of file LArDigitizationConfig.py.

def LArRangeHECCfg(flags, name="LArRangeHEC", **kwargs):
    """Return a PileUpXingFoldertool for Hadronic End-Cap"""
    # bunch crossing range in ns
    kwargs.setdefault("FirstXing", -676)
    kwargs.setdefault("LastXing", 101)
    if useLArFloat(flags):
        kwargs.setdefault("ItemList", ["LArHitFloatContainer#LArHitHEC"])
    else:
        kwargs.setdefault("ItemList", ["LArHitContainer#LArHitHEC"])
    return PileUpXingFolderCfg(flags, name, **kwargs)
 
 

LArSCL1MakerCfg()

python.LArDigitizationConfig.LArSCL1MakerCfg	(		flags,
		**	kwargs )

Return ComponentAccumulator for LArSCL1Maker

Definition at line 313 of file LArDigitizationConfig.py.

def LArSCL1MakerCfg(flags, **kwargs):
    """Return ComponentAccumulator for LArSCL1Maker"""
    acc = ComponentAccumulator()
    if flags.Common.isOverlay:
        acc.merge(LArOverlayDigitizationBasicCfg(flags))
    else:
        acc.merge(LArDigitizationBasicCfg(flags))
 
    kwargs.setdefault("LArHitEMapKey", "StoreGateSvc+LArHitEMap") # Provided by LArPileUpTool
 
    from LArRecUtils.LArADC2MeVSCCondAlgConfig import LArADC2MeVSCCondAlgCfg
    acc.merge(LArADC2MeVSCCondAlgCfg(flags))
    kwargs.setdefault("LArADC2MeVKey", "ConditionStore+LArADC2MeVSC") # Provided by LArADC2MeVSCCondAlg
 
    from LArCabling.LArCablingConfig import LArOnOffIdMappingSCCfg
    acc.merge(LArOnOffIdMappingSCCfg(flags))
    # '<prefix>/LAR/IdentifierOfl/OnOffIdMap_SC</prefix> <tag>LARIdentifierOflOnOffIdMap_SC-000</tag>' Do we need to add this override in the IOVDbSvc or just add the conditions properly in the Run3 conditions global tag???
    kwargs.setdefault("ScCablingKey", "ConditionStore+LArOnOffIdMapSC") # Provided by LArOnOffMappingAlgSC
 
    requiredConditions=["fSamplSC","ShapeSC","PedestalSC","NoiseSC"]
    from LArConfiguration.LArElecCalibDBConfig import LArElecCalibDBMCSCCfg
    acc.merge(LArElecCalibDBMCSCCfg(flags,requiredConditions))
    kwargs.setdefault("FracSKey", "ConditionStore+LArfSamplSC") # Provided by LArFlatConditionsAlg<LArfSamplSC>
    kwargs.setdefault("ShapeKey", "ConditionStore+LArShapeSC") # Provided by LArFlatConditionsAlg<LArShapeSC>
    kwargs.setdefault("PedestalKey", "ConditionStore+LArPedestalSC") # Provided by LArFlatConditionsAlg<LArPedestalSC>
    kwargs.setdefault("LArNoiseKey", "ConditionStore+LArNoiseSC") # Provided by LArFlatConditionsAlg<LArNoiseSC>
 
    acc.merge(LArAutoCorrNoiseCondSCAlgCfg(flags))
    kwargs.setdefault("LArAutoCorrKey", "ConditionStore+LArAutoCorrNoiseSC") # Provided by LArAutoCorrNoiseCondAlg/LArAutoCorrNoiseSCCondAlg
    kwargs.setdefault("NSamples", flags.LAr.ROD.nSamples + 2)  # For consistency with LArAutoCorrNoiseSC - see ATLASSIM-5483
    from RngComps.RngCompsConfig import AthRNGSvcCfg
    kwargs.setdefault("RndmSvc",
                      acc.getPrimaryAndMerge(AthRNGSvcCfg(flags)))
    if flags.Common.ProductionStep == ProductionStep.PileUpPresampling:
        kwargs.setdefault("SCL1ContainerName", f"{flags.Overlay.BkgPrefix}LArDigitSCL2") # Output - why L2??
    if flags.Common.isOverlay:
        kwargs.setdefault("BkgDigitKey", f"{flags.Overlay.BkgPrefix}LArDigitSCL2")
 
        from SGComps.SGInputLoaderConfig import SGInputLoaderCfg
        acc.merge(SGInputLoaderCfg(flags, [f'LArDigitContainer#{kwargs["BkgDigitKey"]}']))
    kwargs.setdefault("SCL1ContainerName","LArDigitSCL2") # Output - why L2??
    acc.addEventAlgo(CompFactory.LArSCL1Maker(**kwargs))
    return acc
 
 

LArSuperCellOverlayCfg()

python.LArDigitizationConfig.LArSuperCellOverlayCfg	(		flags,
		**	kwargs )

Definition at line 410 of file LArDigitizationConfig.py.

def LArSuperCellOverlayCfg(flags, **kwargs):
    acc = LArSCL1MakerCfg(flags)
    from LArROD.LArSuperCellBuilderConfig import LArSuperCellBuilderAlgCfg, LArSuperCellBCIDAlgCfg
    acc.merge(LArSuperCellBuilderAlgCfg(flags))
    acc.merge(LArSuperCellBCIDAlgCfg(flags))
    acc.merge(OutputStreamCfg(flags, "RDO", ["CaloCellContainer#SCell"]))
    return acc

LArTriggerDigitizationBasicCfg()

python.LArDigitizationConfig.LArTriggerDigitizationBasicCfg	(		flags,
		**	kwargs )

Return ComponentAccumulator for LAr Trigger Tower

Definition at line 358 of file LArDigitizationConfig.py.

def LArTriggerDigitizationBasicCfg(flags, **kwargs):
    """Return ComponentAccumulator for LAr Trigger Tower"""
    acc = LArDigitizationBasicCfg(flags)
    acc.merge(CaloTriggerTowerCfg(flags))
 
    kwargs.setdefault("NoiseOnOff", flags.Digitization.DoCaloNoise)
    kwargs.setdefault("RandomSeedOffset", flags.Digitization.RandomSeedOffset)
    kwargs.setdefault("PileUp", flags.Digitization.PileUp)
    if flags.Common.ProductionStep == ProductionStep.PileUpPresampling:
        kwargs.setdefault("EmTTL1ContainerName", flags.Overlay.BkgPrefix + "LArTTL1EM")
        kwargs.setdefault("HadTTL1ContainerName", flags.Overlay.BkgPrefix + "LArTTL1HAD")
    acc.addEventAlgo(CompFactory.LArTTL1Maker(**kwargs))
    if flags.GeoModel.Run >= LHCPeriod.Run3:
        acc.merge(LArSCL1MakerCfg(flags))
        if flags.Common.ProductionStep is not ProductionStep.PileUpPresampling:
            from LArROD.LArSuperCellBuilderConfig import LArSuperCellBuilderAlgCfg, LArSuperCellBCIDAlgCfg
            acc.merge(LArSuperCellBuilderAlgCfg(flags))
            acc.merge(LArSuperCellBCIDAlgCfg(flags))
    return acc
 
 

LArTriggerDigitizationCfg()

python.LArDigitizationConfig.LArTriggerDigitizationCfg	(		flags,
		**	kwargs )

Return ComponentAccumulator for LAr Trigger Tower and Output

Definition at line 379 of file LArDigitizationConfig.py.

def LArTriggerDigitizationCfg(flags, **kwargs):
    """Return ComponentAccumulator for LAr Trigger Tower and Output"""
    acc = LArTriggerDigitizationBasicCfg(flags)
    acc.merge(LArOutputCfg(flags))
    acc.merge(OutputStreamCfg(flags, "RDO", ["LArTTL1Container#*"]))
    if flags.GeoModel.Run >= LHCPeriod.Run3:
        if flags.Common.ProductionStep == ProductionStep.PileUpPresampling:
            acc.merge(OutputStreamCfg(flags, "RDO", ["LArDigitContainer#" + flags.Overlay.BkgPrefix + "LArDigitSCL2"]))
        else:
            acc.merge(OutputStreamCfg(flags, "RDO", ["CaloCellContainer#SCell"]))
    return acc
 
 

useLArFloat()

python.LArDigitizationConfig.useLArFloat

(

flags

)

Return bool for simplified transient LArHit with float E,time

Definition at line 34 of file LArDigitizationConfig.py.

def useLArFloat(flags):
    """Return bool for simplified transient LArHit with float E,time"""
    # temporary, remapping to LArHitFloat does not seeem to work
    # with this scheme... => larger memory usage
    if flags.Digitization.DoXingByXingPileUp or flags.Common.isOverlay:
        return False
    # check for fast chain, running digitisation from hits in memory
    if flags.Sim.DoFullChain:
        return False
    return False