示例#1
0
def getMinBiasCache(name="MinBiasCache", **kwargs):
    from Digitization.DigitizationFlags import digitizationFlags
    from AthenaCommon.BeamFlags import jobproperties
    kwargs.setdefault('CollPerXing',
                      (digitizationFlags.numberOfLowPtMinBias() +
                       digitizationFlags.numberOfHighPtMinBias()))
    kwargs.setdefault('FractionOfCache1Collisions',
                      (digitizationFlags.numberOfLowPtMinBias() /
                       (digitizationFlags.numberOfLowPtMinBias() +
                        digitizationFlags.numberOfHighPtMinBias())))
    from Digitization import PileUpEventType
    kwargs.setdefault('PileUpEventType', PileUpEventType.MinimumBias
                      )  # may need to have a separate type in the future
    if (digitizationFlags.doXingByXingPileUp()
            or digitizationFlags.SignalPatternForSteppingCache.statusOn):
        kwargs.setdefault('Cache1ReadDownscaleFactor', 1)
    kwargs.setdefault('Cache1EventSelector',
                      getService('LowPtMinBiasEventSelector'))
    kwargs.setdefault('Cache2ReadDownscaleFactor', 1)
    kwargs.setdefault('Cache2EventSelector',
                      getService('HighPtMinBiasEventSelector'))
    kwargs.setdefault(
        'OccupationFraction',
        float(digitizationFlags.bunchSpacing.get_Value()) /
        float(jobproperties.Beam.bunchSpacing.get_Value()))

    kwargs.setdefault('RndmGenSvc', digitizationFlags.rndmSvc())
    kwargs.setdefault('RndmStreamName', "PileUpCollXingStream")
    return CfgMgr.SplitBkgStreamsCache(name, **kwargs)
示例#2
0
def BasicTRTFastDigitizationTool(name, **kwargs):

    from IOVDbSvc.CondDB import conddb
    if not conddb.folderRequested('/TRT/Calib/errors'):
        conddb.addFolderSplitOnline("TRT", "/TRT/Onl/Calib/errors",
                                    "/TRT/Calib/errors")
    if not conddb.folderRequested("/TRT/Calib/PID_vector"):
        conddb.addFolderSplitOnline("TRT", "/TRT/Onl/Calib/PID_vector",
                                    "/TRT/Calib/PID_vector")
    if not conddb.folderRequested("/TRT/Calib/ToT/ToTVectors"):
        conddb.addFolder("TRT_OFL", "/TRT/Calib/ToT/ToTVectors")
    if not conddb.folderRequested("/TRT/Calib/ToT/ToTValue"):
        conddb.addFolder("TRT_OFL", "/TRT/Calib/ToT/ToTValue")
    #choose random number service
    from Digitization.DigitizationFlags import digitizationFlags
    kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc())
    streamName = kwargs.setdefault("RandomStreamName", "FastTRTDigitization")
    # set rndm seeds
    if not digitizationFlags.rndmSeedList.checkForExistingSeed(streamName):
        digitizationFlags.rndmSeedList.addSeed(streamName, 45123, 94345)

    from Digitization.DigitizationFlags import digitizationFlags
    if digitizationFlags.doXingByXingPileUp():
        kwargs.setdefault("FirstXing", FastTRT_FirstXing())
        kwargs.setdefault("LastXing", FastTRT_LastXing())

    from AthenaCommon import CfgMgr
    return CfgMgr.TRTFastDigitizationTool(name, **kwargs)
def commonSCT_FastDigitizationConfig(name, **kwargs):

    # Setup the DCS folders and Svc used in the sctSiliconConditionsSvc
    from IOVDbSvc.CondDB import conddb
    if not conddb.folderRequested('/SCT/DCS/CHANSTAT'):
        conddb.addFolder("DCS_OFL", "/SCT/DCS/CHANSTAT")
    if not conddb.folderRequested('/SCT/DCS/MODTEMP'):
        conddb.addFolder("DCS_OFL", "/SCT/DCS/MODTEMP")
    if not conddb.folderRequested('/SCT/DCS/HV'):
        conddb.addFolder("DCS_OFL", "/SCT/DCS/HV")

    from AthenaCommon.AppMgr import ServiceMgr
    if not hasattr(ServiceMgr, "InDetSCT_DCSConditionsSvc"):
        from SCT_ConditionsServices.SCT_ConditionsServicesConf import SCT_DCSConditionsSvc
        InDetSCT_DCSConditionsSvc = SCT_DCSConditionsSvc(
            name="InDetSCT_DCSConditionsSvc")
        ServiceMgr += InDetSCT_DCSConditionsSvc

    kwargs.setdefault("ClusterMaker", "FastClusterMakerTool")

    # Import Digitization job properties
    from Digitization.DigitizationFlags import digitizationFlags
    # set the random service, stream name
    streamName = kwargs.setdefault("RndmEngine", "FastSCT_Digitization")
    kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc())
    # set rndm seeds
    if not digitizationFlags.rndmSeedList.checkForExistingSeed(streamName):
        digitizationFlags.rndmSeedList.addSeed(streamName, 49261510, 105132394)

    if digitizationFlags.doXingByXingPileUp():
        kwargs.setdefault("FirstXing", FastSCT_FirstXing())
        kwargs.setdefault("LastXing", FastSCT_LastXing())

    from AthenaCommon import CfgMgr
    return CfgMgr.SCT_FastDigitizationTool(name, **kwargs)
示例#4
0
def TileHitVecToCntTool(name="TileHitVecToCntTool", **kwargs):
    ## FIXME includes to be replaced by confGetter configuration.
    from AthenaCommon.Resilience import protectedInclude
    protectedInclude( "CaloDetMgrDetDescrCnv/CaloDetMgrDetDescrCnv_joboptions.py" )
    protectedInclude( "TileConditions/TileConditions_jobOptions.py" )
    kwargs.setdefault("TileHitVectors", ["TileHitVec" , "MBTSHits" ])
    kwargs.setdefault("TileInfoName", "TileInfo")
    kwargs.setdefault("TileHitContainer", "TileHitCnt")
    kwargs.setdefault("TileHitContainer_DigiHSTruth", "TileHitCnt_DigiHSTruth")
    kwargs.setdefault("DoHSTruthReconstruction", digitizationFlags.doDigiTruth())
    from AthenaCommon.DetFlags import DetFlags
    kwargs.setdefault("PileUp", DetFlags.pileup.Tile_on())

    from AthenaCommon.BeamFlags import jobproperties
    if jobproperties.Beam.beamType == 'cosmics':
        kwargs.setdefault("TriggerTimeTool", "CosmicTriggerTimeTool")
        kwargs.setdefault("HitTimeFlag", 2)
        kwargs.setdefault("UseTriggerTime", True)

    # Random number engine
    kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc())
    digitizationFlags.rndmSeedList.addSeed("Tile_HitVecToCnt", 4789899, 989240512)

    if digitizationFlags.doXingByXingPileUp(): # PileUpTool approach
        kwargs.setdefault("FirstXing", Tile_FirstXing() ) 
        kwargs.setdefault("LastXing",  Tile_LastXing() ) 

    return CfgMgr.TileHitVecToCntTool(name, **kwargs)
示例#5
0
def commonPixelFastDigitizationConfig(name,**kwargs):

    kwargs.setdefault("ClusterMaker", "FastClusterMakerTool")

    # Import Digitization job properties
    from Digitization.DigitizationFlags import digitizationFlags
    # set the random service, stream name
    streamName = kwargs.setdefault("RndmEngine", "FastPixelDigitization")
    kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc() )
    # set rndm seeds
    if not digitizationFlags.rndmSeedList.checkForExistingSeed(streamName):
        digitizationFlags.rndmSeedList.addSeed(streamName, 10513239, 492615104 )

    if digitizationFlags.doXingByXingPileUp():
        kwargs.setdefault("FirstXing", FastPixel_FirstXing())
        kwargs.setdefault("LastXing",  FastPixel_LastXing() )

    # SiLorentzAngleTool for PixelFastDigitizationTool
    from AthenaCommon.AppMgr import ToolSvc
    if not hasattr(ToolSvc, "PixelLorentzAngleTool"):
        from SiLorentzAngleTool.PixelLorentzAngleToolSetup import PixelLorentzAngleToolSetup
        pixelLorentzAngleToolSetup = PixelLorentzAngleToolSetup()
    kwargs.setdefault("LorentzAngleTool", ToolSvc.PixelLorentzAngleTool)

    from AthenaCommon import CfgMgr
    return CfgMgr.PixelFastDigitizationTool(name,**kwargs)
示例#6
0
def BCM_DigitizationTool(name="BCM_DigitizationTool", **kwargs):

    from Digitization.DigitizationFlags import digitizationFlags
    kwargs.setdefault("HitCollName", "BCMHits")

    if not digitizationFlags.doInDetNoise.get_Value():
        kwargs.setdefault("ModNoise", [0., 0., 0., 0., 0., 0., 0., 0.])
    else:
        kwargs.setdefault(
            "ModNoise",
            [90.82, 90.82, 90.82, 90.82, 90.82, 90.82, 90.82, 90.82])
    kwargs.setdefault("ModSignal",
                      [450.0, 450.0, 450.0, 450.0, 450.0, 450.0, 450.0, 450.0])
    kwargs.setdefault("NinoThr",
                      [330.0, 330.0, 330.0, 330.0, 330.0, 330.0, 330.0, 330.0])
    kwargs.setdefault("EffDistanceParam", 4.0)
    kwargs.setdefault("EffSharpnessParam", 0.11)
    kwargs.setdefault("TimeDelay", 9.0)

    kwargs.setdefault("MIPDeposit", 0.33)  # BCM with diamond
    #kwargs.setdefault("MIPDeposit", 0.25) # BCM with graphite

    kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc())
    digitizationFlags.rndmSeedList.addSeed("BCM_Digitization", 49261510,
                                           105132394)

    if digitizationFlags.doXingByXingPileUp():
        kwargs.setdefault("FirstXing", BCM_FirstXing())
        kwargs.setdefault("LastXing", BCM_LastXing())

    from AthenaCommon import CfgMgr
    return CfgMgr.BCM_DigitizationTool(name, **kwargs)
示例#7
0
def BichselSimTool(name="BichselSimTool", **kwargs):
    kwargs.setdefault("DeltaRayCut", 117.)
    kwargs.setdefault("nCols", 5)
    kwargs.setdefault("LoopLimit", 100000)
    kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc())
    kwargs.setdefault("RndmEngine", "PixelDigitization")
    return CfgMgr.BichselSimTool(name, **kwargs)
示例#8
0
def commonSCT_DigitizationConfig(name, **kwargs):

    from Digitization.DigitizationFlags import digitizationFlags
    # If noise is turned off:
    if not digitizationFlags.doInDetNoise.get_Value():
        kwargs.setdefault("OnlyHitElements", True)

    kwargs.setdefault("InputObjectName", "SCT_Hits")
    kwargs.setdefault("EnableHits", True)
    kwargs.setdefault("BarrelOnly", False)

    # Use of random disabled cells
    #kwargs.setdefault("RandomDisabledCells", True)

    # Set FixedTime for cosmics for use in SurfaceChargesGenerator
    from AthenaCommon.BeamFlags import jobproperties
    if jobproperties.Beam.beamType == "cosmics":
        kwargs.setdefault("CosmicsRun", True)
        kwargs.setdefault("FixedTime", 10)

    # write out SCT1_RawData
    #kwargs.setdefault("WriteSCT1_RawData", False)

    kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc())
    streamName = "SCT_Digitization"  # FIXME ideally random stream name would be configurable
    if not digitizationFlags.rndmSeedList.checkForExistingSeed(streamName):
        digitizationFlags.rndmSeedList.addSeed(streamName, 49261510, 105132394)

    if digitizationFlags.doXingByXingPileUp():
        kwargs.setdefault("FirstXing", SCT_FirstXing())
        kwargs.setdefault("LastXing", SCT_LastXing())

    from AthenaCommon import CfgMgr
    return CfgMgr.SCT_DigitizationTool(name, **kwargs)
示例#9
0
def getCavernCache(name="CavernCache", **kwargs):
    from Digitization.DigitizationFlags import digitizationFlags
    from AthenaCommon.BeamFlags import jobproperties
    kwargs.setdefault('CollPerXing', digitizationFlags.numberOfCavern())
    kwargs.setdefault('CollDistribution', "Fixed")
    from Digitization import PileUpEventType
    kwargs.setdefault('PileUpEventType', PileUpEventType.Cavern)
    if (digitizationFlags.doXingByXingPileUp()
            or digitizationFlags.SignalPatternForSteppingCache.statusOn):
        kwargs.setdefault('ReadDownscaleFactor', 1)
    # Cavern Background Cache Should Ignore Bunch Structure
    OccupationFraction = float(
        digitizationFlags.bunchSpacing.get_Value()) / float(
            jobproperties.Beam.bunchSpacing.get_Value())
    if digitizationFlags.BeamIntensityPattern.statusOn:
        kwargs.setdefault('IgnoreBeamInt',
                          digitizationFlags.cavernIgnoresBeamInt.get_Value())
        if digitizationFlags.cavernIgnoresBeamInt.get_Value():
            OccupationFraction = 1.0
    kwargs.setdefault('OccupationFraction', OccupationFraction)
    kwargs.setdefault('EventSelector', getService('cavernEventSelector'))

    kwargs.setdefault('RndmGenSvc', digitizationFlags.rndmSvc())
    kwargs.setdefault('RndmStreamName', "PileUpCollXingStream")
    #Use BkgStreamsStepCaches when using the StepArrayBM and BkgStreamsCache otherwise
    if digitizationFlags.SignalPatternForSteppingCache.statusOn:
        return CfgMgr.BkgStreamsStepCache(name, **kwargs)
    else:
        return CfgMgr.BkgStreamsCache(name, **kwargs)
示例#10
0
def getArrayBM(name="ArrayBM", **kwargs):
    from Digitization.DigitizationFlags import digitizationFlags
    kwargs.setdefault('IntensityPattern', digitizationFlags.BeamIntensityPattern.get_Value())
    kwargs.setdefault('RandomSvc', digitizationFlags.rndmSvc() )
    digitizationFlags.rndmSeedList.addSeed( "BEAMINT", 678, 91011 )

    from PileUpComps.PileUpCompsConf import ArrayBM
    return ArrayBM(name, **kwargs)
def Ibl3DBichselChargeTool(name="Ibl3DBichselChargeTool", **kwargs):
    kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc())
    kwargs.setdefault("RndmEngine", "PixelDigitization")
    kwargs.setdefault("doBichsel", _doBichsel)
    kwargs.setdefault("doBichselBetaGammaCut", 0.7)  # dEdx not quite consistent below this
    kwargs.setdefault("doDeltaRay", False)  # needs validation
    kwargs.setdefault("BichselSimTool", "BichselSimTool")
    return CfgMgr.Ibl3DBichselChargeTool(name, **kwargs)
def PixelECBichselChargeTool(name="PixelECBichselChargeTool", **kwargs):
    kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc())
    kwargs.setdefault("RndmEngine", "PixelDigitization")
    kwargs.setdefault("doBichsel", _doBichsel)
    # kwargs.setdefault("doBichsel", False)
    kwargs.setdefault("doBichselBetaGammaCut", 0.7)  # dEdx not quite consistent below this
    kwargs.setdefault("BichselSimTool", "BichselSimTool")
    return CfgMgr.PixelECBichselChargeTool(name, **kwargs)
示例#13
0
def PixelECBichselChargeTool(name="PixelECBichselChargeTool", **kwargs):
    kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc())
    kwargs.setdefault("RndmEngine", "PixelDigitization")
    kwargs.setdefault("doBichsel", hasattr(digitizationFlags, "doBichselSimulation") and digitizationFlags.doBichselSimulation())
    kwargs.setdefault("doBichselBetaGammaCut", 0.7)   # dEdx not quite consistent below this
    kwargs.setdefault("doPU", True)
    kwargs.setdefault("BichselSimTool", "BichselSimTool")
    return CfgMgr.PixelECBichselChargeTool(name, **kwargs)
def RD53SimTool(name="RD53SimTool", **kwargs):
    kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc())
    kwargs.setdefault("RndmEngine", "PixelDigitization")
    kwargs.setdefault("BarrelAnalogthreshold", [-1, -1, -1, -1, -1])
    kwargs.setdefault("EndcapAnalogthreshold", [-1, -1, -1, -1])
    kwargs.setdefault("BarrelToTthreshold", [-1, -1, -1, -1, -1])
    kwargs.setdefault("EndcapToTthreshold", [-1, -1, -1, -1])
    return CfgMgr.RadDam__RD53SimTool(name, **kwargs)
示例#15
0
def IblPlanarBichselChargeTool(name="IblPlanarBichselChargeTool", **kwargs):
    kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc())
    kwargs.setdefault("RndmEngine", "PixelDigitization")
    kwargs.setdefault("doBichsel", hasattr(digitizationFlags, "doBichselSimulation") and digitizationFlags.doBichselSimulation())
    kwargs.setdefault("doBichselBetaGammaCut", 0.7)   # dEdx not quite consistent below this
    kwargs.setdefault("doDeltaRay", False)            # needs validation
    kwargs.setdefault("doPU", True)
    kwargs.setdefault("BichselSimTool", "BichselSimTool")
    return CfgMgr.IblPlanarBichselChargeTool(name, **kwargs)
def EnergyDepositionTool(name="EnergyDepositionTool", **kwargs):
    kwargs.setdefault("DeltaRayCut", 117.)
    kwargs.setdefault("nCols", 5)
    kwargs.setdefault("LoopLimit", 100000)
    kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc())
    kwargs.setdefault("RndmEngine", "PixelDigitization")
    kwargs.setdefault("doBichsel", hasattr(digitizationFlags, "doBichselSimulation") and digitizationFlags.doBichselSimulation())
    kwargs.setdefault("doBichselBetaGammaCut", 0.7)   # dEdx not quite consistent below this
    kwargs.setdefault("doDeltaRay", False)            # needs validation
    kwargs.setdefault("doPU", True)
    return CfgMgr.RadDam__EnergyDepositionTool(name, **kwargs)
def PixelBarrelBichselChargeTool(name="PixelBarrelBichselChargeTool", **kwargs):
    kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc())
    kwargs.setdefault("RndmEngine", "PixelDigitization")
    kwargs.setdefault("doBichsel", _doBichsel)
    # kwargs.setdefault("doBichsel", False)
    kwargs.setdefault("doBichselBetaGammaCut", 0.7)  # dEdx not quite consistent below this
    kwargs.setdefault("doDeltaRay", False)  # needs validation
    kwargs.setdefault("BichselSimTool", "BichselSimTool")
    # kwargs.setdefault("OutputFileName", digitizationFlags.BichselOutputFileName())
    # kwargs.setdefault("doHITPlots", True)
    return CfgMgr.PixelBarrelBichselChargeTool(name, **kwargs)
示例#18
0
def SpecialPixelGenerator(name="SpecialPixelGenerator", **kwargs):
    from AthenaCommon.BeamFlags import jobproperties
    if jobproperties.Beam.beamType == "cosmics" :
        # random noise probability
        kwargs.setdefault("SpmNoiseProb", 1e-5)
        kwargs.setdefault("SpmNoBumpProb", 5e-4)
        kwargs.setdefault("SpmDisableProb", 2e-5)
        #kwargs.setdefault("SpmBadTOTProb", 5e-4)
    kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc())
    kwargs.setdefault("RndmEngine", "PixelDigitization")
    return CfgMgr.SpecialPixelGenerator(name, **kwargs)
示例#19
0
def PixelNoisyCellGenerator(name="PixelNoisyCellGenerator", **kwargs):
    from AthenaCommon.BeamFlags import jobproperties
    kwargs.setdefault("MergeCharge", True)
    NoiseShape = [0.00596, 0.03491, 0.07058, 0.11991, 0.17971, 0.24105, 0.29884, 0.35167, 0.39912, 0.44188, 0.48016, 0.51471, 0.54587, 0.57405, 0.59958, 0.62288, 0.64411, 0.66360, 0.68159, 0.69823, 0.71362, 0.72781, 0.74096, 0.75304, 0.76415, 0.77438, 0.78383, 0.79256, 0.80066, 0.80821, 0.81547, 0.82246, 0.82918, 0.83501, 0.84054, 0.84576, 0.85078, 0.85558, 0.86018, 0.86455, 0.86875, 0.87273, 0.87653, 0.88020, 0.88369, 0.88705, 0.89027, 0.89336, 0.89633, 0.89921, 0.90195, 0.90460, 0.90714, 0.90961, 0.91198, 0.91426, 0.91644, 0.91853, 0.92055, 0.92250, 0.92435, 0.92611, 0.92782, 0.92947, 0.93105, 0.93257, 0.93404, 0.93547, 0.93688, 0.93822, 0.93953, 0.94079, 0.94201, 0.94318, 0.94432, 0.94542, 0.94649, 0.94751, 0.94851, 0.94949, 0.95045, 0.95137, 0.95227, 0.95314, 0.95399, 0.95483, 0.95563, 0.95646, 0.95729, 0.95812, 0.95896, 0.95980, 0.96063, 0.96144, 0.96224, 0.96301, 0.96377, 0.96451, 0.96521, 0.96590, 0.96657, 0.96722, 0.96787, 0.96849, 0.96911, 0.96971, 0.97031, 0.97090, 0.97148, 0.97204, 0.97260, 0.97314, 0.97367, 0.97421, 0.97474, 0.97525, 0.97576, 0.97627, 0.97676, 0.97722, 0.97769, 0.97815, 0.97861, 0.97906, 0.97950, 0.97992, 0.98033, 0.98073, 0.98111, 0.98147, 0.98182, 0.98216, 0.98249, 0.98281, 0.98312, 0.98343, 0.98374, 0.98402, 0.98430, 0.98456, 0.98482, 0.98507, 0.98532, 0.98555, 0.98579, 0.98602, 0.98624, 0.98646, 0.98668, 0.98690, 0.98711, 0.98732, 0.98753, 0.98773, 0.98793, 0.98813, 0.98832, 0.98851, 0.98870, 0.98888, 0.98907, 0.98925, 0.98943, 0.98961, 0.98979, 0.98996, 0.99014, 0.99031, 0.99048, 0.99064, 0.99081, 0.99098, 0.99114, 0.99131, 0.99147, 0.99163, 0.99179, 0.99194, 0.99210, 0.99225, 0.99240, 0.99256, 0.99271, 0.99286, 0.99300, 0.99315, 0.99329, 0.99344, 0.99358, 0.99372, 0.99386, 0.99400, 0.99414, 0.99427, 0.99440, 0.99453, 0.99466, 0.99479, 0.99491, 0.99503, 0.99515, 0.99527, 0.99538, 0.99549, 0.99560, 0.99571, 0.99582, 0.99592, 0.99602, 0.99613, 0.99623, 0.99633, 0.99643, 0.99653, 0.99662, 0.99672, 0.99682, 0.99691, 0.99701, 0.99710, 0.99719, 0.99728, 0.99737, 0.99746, 0.99755, 0.99764, 0.99772, 0.99781, 0.99790, 0.99798, 0.99806, 0.99814, 0.99823, 0.99831, 0.99839, 0.99847, 0.99855, 0.99863, 0.99871, 0.99879, 0.99887, 0.99895, 0.99902, 0.99910, 0.99918, 0.99925, 0.99933, 0.99940, 0.99948, 0.99955, 0.99963, 0.99971, 0.99978, 0.99985, 0.99993, 1.00000]
    kwargs.setdefault("NoiseShape",NoiseShape)
    #print "Noise Shape = ",NoiseShape
    kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc())
    kwargs.setdefault("RndmEngine", "PixelDigitization")
    if jobproperties.Beam.beamType != "cosmics" :
         kwargs.setdefault("RndNoiseProb", 1.e-10)
    return CfgMgr.PixelNoisyCellGenerator(name, **kwargs)
def SpecialPixelGenerator(name="SpecialPixelGenerator", **kwargs):
    from AthenaCommon.BeamFlags import jobproperties

    if jobproperties.Beam.beamType == "cosmics":
        # random noise probability
        kwargs.setdefault("SpmNoiseProb", 1e-5)
        kwargs.setdefault("SpmNoBumpProb", 5e-4)
        kwargs.setdefault("SpmDisableProb", 2e-5)
        # kwargs.setdefault("SpmBadTOTProb", 5e-4)
    kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc())
    kwargs.setdefault("RndmEngine", "PixelDigitization")
    return CfgMgr.SpecialPixelGenerator(name, **kwargs)
def CalibSvc(name="CalibSvc", **kwargs):
    kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc())
    kwargs.setdefault("RndmEngine", "PixelDigitization")
    from AthenaCommon.BeamFlags import jobproperties
    from AthenaCommon.Resilience import protectedInclude

    protectedInclude("PixelConditionsServices/PixelCalibSvc_jobOptions.py")
    from IOVDbSvc.CondDB import conddb

    conddb.addFolderSplitMC("PIXEL", "/PIXEL/ReadoutSpeed", "/PIXEL/ReadoutSpeed")
    if jobproperties.Beam.beamType == "cosmics":
        kwargs.setdefault("UsePixMapCondDB", True)
    return CfgMgr.CalibSvc(name, **kwargs)
def BasicPixelDigitizationTool(name="PixelDigitizationTool", **kwargs):
    from AthenaCommon import CfgGetter
    kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc())
    streamName = kwargs.setdefault("RndmEngine", "PixelDigitization")
    if not digitizationFlags.rndmSeedList.checkForExistingSeed(streamName):
        digitizationFlags.rndmSeedList.addSeed(streamName, 10513239, 492615104 )
    from AthenaCommon.BeamFlags import jobproperties
    from AthenaCommon.Resilience import protectedInclude
    from AthenaCommon.Include import include
    from AthenaCommon.AppMgr import ServiceMgr
    from AthenaCommon.CfgGetter import getService
    protectedInclude( "PixelConditionsServices/SpecialPixelMapSvc_jobOptions.py" )
    include.block( "PixelConditionsServices/SpecialPixelMapSvc_jobOptions.py" )
    protectedInclude( "PixelConditionsServices/PixelDCSSvc_jobOptions.py" )
    include.block( "PixelConditionsServices/PixelDCSSvc_jobOptions.py" )
    protectedInclude("PixelConditionsServices/PixelCalibSvc_jobOptions.py")
    from IOVDbSvc.CondDB import conddb
    conddb.addFolderSplitMC("PIXEL","/PIXEL/ReadoutSpeed","/PIXEL/ReadoutSpeed")
    PixelCablingSvc = getService("PixelCablingSvc")
    ServiceMgr += PixelCablingSvc
    print  PixelCablingSvc
    if not hasattr(ServiceMgr, "PixelSiPropertiesSvc"):
      from SiLorentzAngleSvc.LorentzAngleSvcSetup import lorentzAngleSvc
      from SiPropertiesSvc.SiPropertiesSvcConf import SiPropertiesSvc
      pixelSiPropertiesSvc = SiPropertiesSvc(name = "PixelSiPropertiesSvc",DetectorName="Pixel",SiConditionsServices = lorentzAngleSvc.pixelSiliconConditionsSvc)
      ServiceMgr += pixelSiPropertiesSvc
    kwargs.setdefault("InputObjectName", "PixelHits")
    procTools = []
    chargeTools = [] #Tools in array for flexibility
    feSimTools = []
    if GeometryFlags.isSLHC():
      procTools += ['PixelRadDamDiodeCrossTalkGenerator']
      chargeTools += ['RadDamSensorSimPlanarTool']
      feSimTools += ['RadDamRD53SimTool']
    else:
      procTools += ['PixelRadDamDiodeCrossTalkGenerator']
      procTools += ['PixelRadDamChargeSmearer']
      procTools += ['PixelRadDamNoisyCellGenerator']
      procTools += ['PixelRadDamRandomDisabledCellGenerator']
      chargeTools += ['RadDamSensorSimPlanarTool']
      chargeTools += ['RadDamSensorSim3DTool']
      feSimTools += ['RadDamFEI4SimTool']
      feSimTools += ['RadDamFEI3SimTool']
    kwargs.setdefault("PixelProcessorTools", procTools)
    kwargs.setdefault("ChargeTools", chargeTools)
    kwargs.setdefault("FrontEndSimTools", feSimTools)
    kwargs.setdefault("EnergyDepositionTool", "RadDamEnergyDepositionTool")
    if digitizationFlags.doXingByXingPileUp(): # PileUpTool approach
        kwargs.setdefault("FirstXing", Pixel_FirstXing() )
        kwargs.setdefault("LastXing", Pixel_LastXing() )
    return CfgMgr.RadDam__PixelDigitizationTool(name, **kwargs)
def FrontEndSimTool(name="FrontEndSimTool", **kwargs):
    kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc())
    kwargs.setdefault("RndmEngine", "PixelDigitization")
    from AthenaCommon.BeamFlags import jobproperties
    if jobproperties.Beam.beamType == "cosmics" :
      kwargs.setdefault("UseComTime", True)
      kwargs.setdefault("TimeJitter", 25.0)
      kwargs.setdefault("TimeBCN",8.0)
      kwargs.setdefault("TimeZero", 100.0)
    else:
      kwargs.setdefault("TimeBCN",1.0)
      kwargs.setdefault("TimeZero", 5.0)
    kwargs.setdefault("TimePerBCO", 25.0)
    return CfgMgr.RadDam__FrontEndSimTool(name, **kwargs)
def BasicPixelDigitizationTool(name="PixelDigitizationTool", **kwargs):
    from AthenaCommon import CfgGetter

    kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc())
    streamName = kwargs.setdefault("RndmEngine", "PixelDigitization")
    if not digitizationFlags.rndmSeedList.checkForExistingSeed(streamName):
        digitizationFlags.rndmSeedList.addSeed(streamName, 10513239, 492615104)
    from AthenaCommon.BeamFlags import jobproperties
    from AthenaCommon.Resilience import protectedInclude
    from AthenaCommon.Include import include

    protectedInclude("PixelConditionsServices/SpecialPixelMapSvc_jobOptions.py")
    include.block("PixelConditionsServices/SpecialPixelMapSvc_jobOptions.py")
    protectedInclude("PixelConditionsServices/PixelDCSSvc_jobOptions.py")
    include.block("PixelConditionsServices/PixelDCSSvc_jobOptions.py")
    from AthenaCommon.AppMgr import ServiceMgr

    if not hasattr(ServiceMgr, "PixelSiPropertiesSvc"):
        from SiLorentzAngleSvc.LorentzAngleSvcSetup import lorentzAngleSvc
        from SiPropertiesSvc.SiPropertiesSvcConf import SiPropertiesSvc

        pixelSiPropertiesSvc = SiPropertiesSvc(
            name="PixelSiPropertiesSvc",
            DetectorName="Pixel",
            SiConditionsServices=lorentzAngleSvc.pixelSiliconConditionsSvc,
        )
        ServiceMgr += pixelSiPropertiesSvc
    kwargs.setdefault("InputObjectName", "PixelHits")
    kwargs.setdefault("EnableNoise", digitizationFlags.doInDetNoise.get_Value())
    # Start of special cosmics tuning:
    if jobproperties.Beam.beamType == "cosmics":
        kwargs.setdefault("CosmicsRun", True)
        kwargs.setdefault("UseComTime", True)
    else:
        # For LVL1Latency, ToTMinCut, ApplyDupli and LowTOTduplication, first component [0] is always for IBL, even for run 1 production.
        # The order is IBL, BL, L1, L2, EC, DBM
        # For IBL and DBM, values of LVL1Latency and LowToTDupli are superseded by values driven by HitDiscCnfg settings, in PixelDigitizationTool.cxx
        LVL1Latency = [16, 150, 255, 255, 255, 16]
        kwargs.setdefault("LVL1Latency", LVL1Latency)
        ToTMinCut = [0, 4, 4, 4, 4, 0]
        kwargs.setdefault("ToTMinCut", ToTMinCut)
        ApplyDupli = [True, True, True, True, True, True]
        kwargs.setdefault("ApplyDupli", ApplyDupli)
        LowTOTduplication = [0, 7, 7, 7, 7, 0]
        kwargs.setdefault("LowTOTduplication", LowTOTduplication)
    if digitizationFlags.doXingByXingPileUp():  # PileUpTool approach
        kwargs.setdefault("FirstXing", Pixel_FirstXing())
        kwargs.setdefault("LastXing", Pixel_LastXing())
    return CfgMgr.PixelDigitizationTool(name, **kwargs)
def FEI3SimTool(name="FEI3SimTool", **kwargs):
    kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc())
    kwargs.setdefault("RndmEngine", "PixelDigitization")
    kwargs.setdefault("BarrelAnalogthreshold", [-1, -1, -1, -1])    # first argument is dummy
    kwargs.setdefault("EndcapAnalogthreshold", [-1, -1, -1])
    kwargs.setdefault("BarrelToTthreshold", [-1, 5, 5, 5])    # first argument is dummy
    kwargs.setdefault("EndcapToTthreshold", [ 5, 5, 5])
    kwargs.setdefault("BarrelLatency", [ -1, 151, 256, 256])
    kwargs.setdefault("EndcapLatency", [256, 256, 256])
    kwargs.setdefault("BarrelHitDuplication", [False, False, False, False])
    kwargs.setdefault("EndcapHitDuplication", [False, False, False])
    kwargs.setdefault("BarrelSmallHitToT", [-1, -1, -1, -1])
    kwargs.setdefault("EndcapSmallHitToT", [-1, -1, -1])
    kwargs.setdefault("TimingTune", 2015)
    return CfgMgr.RadDam__FEI3SimTool(name, **kwargs)
示例#26
0
def getBeamHaloCache(name="BeamHaloCache", **kwargs):
    from Digitization.DigitizationFlags import digitizationFlags
    kwargs.setdefault('IgnoreBeamLumi', True )
    kwargs.setdefault('CollPerXing', digitizationFlags.numberOfBeamHalo() )
    from Digitization import PileUpEventType
    kwargs.setdefault('PileUpEventType', PileUpEventType.HaloGas )
    kwargs.setdefault('CollDistribution', "Poisson" )
    kwargs.setdefault('ReadDownscaleFactor',  1 )
    kwargs.setdefault('EventSelector', "BeamHaloEventSelector" )

    kwargs.setdefault('RndmGenSvc', digitizationFlags.rndmSvc() )
    kwargs.setdefault('RndmStreamName', "PileUpCollXingStream" )
    #Use BkgStreamsStepCaches when using the StepArrayBM and BkgStreamsCache otherwise
    if digitizationFlags.SignalPatternForSteppingCache.statusOn:
        return CfgMgr.BkgStreamsStepCache(name, **kwargs)
    else:
        return CfgMgr.BkgStreamsCache(name, **kwargs)
示例#27
0
def getHighPtMinBiasCache(name="HighPtMinBiasCache", **kwargs):
    from Digitization.DigitizationFlags import digitizationFlags
    from AthenaCommon.BeamFlags import beamFlags
    kwargs.setdefault('CollPerXing', digitizationFlags.numberOfHighPtMinBias() )
    from Digitization import PileUpEventType
    kwargs.setdefault('PileUpEventType', PileUpEventType.HighPtMinimumBias ) # may need to have a separate type in the future
    kwargs.setdefault('ReadDownscaleFactor', 1 )
    kwargs.setdefault('EventSelector', getService('HighPtMinBiasEventSelector') )
    kwargs.setdefault('OccupationFraction', float(digitizationFlags.bunchSpacing.get_Value())/float(beamFlags.bunchSpacing.get_Value()) )

    kwargs.setdefault('RndmGenSvc', digitizationFlags.rndmSvc() )
    kwargs.setdefault('RndmStreamName', "PileUpCollXingStream" )
    #Use BkgStreamsStepCaches when using the StepArrayBM and BkgStreamsCache otherwise
    if digitizationFlags.SignalPatternForSteppingCache.statusOn:
        return CfgMgr.BkgStreamsStepCache(name, **kwargs)
    else:
        return CfgMgr.BkgStreamsCache(name, **kwargs)
示例#28
0
def TimeSvc(name="TimeSvc", **kwargs):
    kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc())
    kwargs.setdefault("RndmEngine", "PixelDigitization")
    timeBCN = 5
    timePerBCO = 25.0
    if digitizationFlags.bunchSpacing.get_Value() > 0:
        timeBCN = max(int(digitizationFlags.bunchSpacing.get_Value()/timePerBCO),timeBCN)
    from AthenaCommon.BeamFlags import jobproperties
    if jobproperties.Beam.beamType == "cosmics" :
        ## Timing for cosmics run
        kwargs.setdefault("TimeJitter", 25.)
        kwargs.setdefault("TimeZero", 100.)
        timeBCN = 8
    else:
        kwargs.setdefault("TimeZero", 5.)
        timeBCN = 1
    kwargs.setdefault("TimePerBCO", 25.0)
    kwargs.setdefault("TimeBCN",timeBCN)
    return CfgMgr.TimeSvc(name, **kwargs)
def TimeSvc(name="TimeSvc", **kwargs):
    kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc())
    kwargs.setdefault("RndmEngine", "PixelDigitization")
    timeBCN = 5
    timePerBCO = 25.0
    if digitizationFlags.bunchSpacing.get_Value() > 0:
        timeBCN = max(int(digitizationFlags.bunchSpacing.get_Value() / timePerBCO), timeBCN)
    from AthenaCommon.BeamFlags import jobproperties

    if jobproperties.Beam.beamType == "cosmics":
        ## Timing for cosmics run
        kwargs.setdefault("TimeJitter", 25.0)
        kwargs.setdefault("TimeZero", 100.0)
        timeBCN = 8
    else:
        kwargs.setdefault("TimeZero", 5.0)
        timeBCN = 1
    kwargs.setdefault("TimePerBCO", 25.0)
    kwargs.setdefault("TimeBCN", timeBCN)
    return CfgMgr.TimeSvc(name, **kwargs)
示例#30
0
def commonSCT_FastDigitizationConfig(name,**kwargs):

    # Setup the DCS folders and tool used in the sctSiliconConditionsTool
    from SCT_ConditionsTools.SCT_DCSConditionsToolSetup import SCT_DCSConditionsToolSetup
    sct_DCSConditionsToolSetup = SCT_DCSConditionsToolSetup()
    sct_DCSConditionsToolSetup.setup()

    kwargs.setdefault("ClusterMaker", "FastClusterMakerTool")

    # Import Digitization job properties
    from Digitization.DigitizationFlags import digitizationFlags
    # set the random service, stream name
    streamName = kwargs.setdefault("RndmEngine", "FastSCT_Digitization")
    kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc() )
    # set rndm seeds
    if not digitizationFlags.rndmSeedList.checkForExistingSeed(streamName):
        digitizationFlags.rndmSeedList.addSeed(streamName, 49261510, 105132394 )

    if digitizationFlags.doXingByXingPileUp():
        kwargs.setdefault("FirstXing", FastSCT_FirstXing())
        kwargs.setdefault("LastXing",  FastSCT_LastXing() )

    # Set up SCT_SiliconConditionsTool
    from SCT_ConditionsTools.SCT_SiliconConditionsToolSetup import SCT_SiliconConditionsToolSetup
    sct_SiliconConditionsToolSetup = SCT_SiliconConditionsToolSetup()
    sct_SiliconConditionsToolSetup.setDcsTool(sct_DCSConditionsToolSetup.getTool())
    sct_SiliconConditionsToolSetup.setup()
    # Set up SCT_SiPropertiesTool
    from SiPropertiesTool.SCT_SiPropertiesToolSetup import SCT_SiPropertiesToolSetup
    sct_SiPropertiesToolSetup = SCT_SiPropertiesToolSetup()
    sct_SiPropertiesToolSetup.setSiliconTool(sct_SiliconConditionsToolSetup.getTool())
    sct_SiPropertiesToolSetup.setup()

    # SiLorentzAngleTool for SCT_FastDigitizationTool
    from AthenaCommon.AppMgr import ToolSvc
    from SiLorentzAngleTool.SCTLorentzAngleToolSetup import SCTLorentzAngleToolSetup
    sctLorentzAngleToolSetup = SCTLorentzAngleToolSetup()
    kwargs.setdefault("LorentzAngleTool", sctLorentzAngleToolSetup.SCTLorentzAngleTool)

    from AthenaCommon import CfgMgr
    return CfgMgr.SCT_FastDigitizationTool(name,**kwargs)
def PixelNoisyCellGenerator(name="PixelNoisyCellGenerator", **kwargs):
    from AthenaCommon.BeamFlags import jobproperties

    kwargs.setdefault("MergeCharge", True)
    NoiseShape = [
        0.00596,
        0.03491,
        0.07058,
        0.11991,
        0.17971,
        0.24105,
        0.29884,
        0.35167,
        0.39912,
        0.44188,
        0.48016,
        0.51471,
        0.54587,
        0.57405,
        0.59958,
        0.62288,
        0.64411,
        0.66360,
        0.68159,
        0.69823,
        0.71362,
        0.72781,
        0.74096,
        0.75304,
        0.76415,
        0.77438,
        0.78383,
        0.79256,
        0.80066,
        0.80821,
        0.81547,
        0.82246,
        0.82918,
        0.83501,
        0.84054,
        0.84576,
        0.85078,
        0.85558,
        0.86018,
        0.86455,
        0.86875,
        0.87273,
        0.87653,
        0.88020,
        0.88369,
        0.88705,
        0.89027,
        0.89336,
        0.89633,
        0.89921,
        0.90195,
        0.90460,
        0.90714,
        0.90961,
        0.91198,
        0.91426,
        0.91644,
        0.91853,
        0.92055,
        0.92250,
        0.92435,
        0.92611,
        0.92782,
        0.92947,
        0.93105,
        0.93257,
        0.93404,
        0.93547,
        0.93688,
        0.93822,
        0.93953,
        0.94079,
        0.94201,
        0.94318,
        0.94432,
        0.94542,
        0.94649,
        0.94751,
        0.94851,
        0.94949,
        0.95045,
        0.95137,
        0.95227,
        0.95314,
        0.95399,
        0.95483,
        0.95563,
        0.95646,
        0.95729,
        0.95812,
        0.95896,
        0.95980,
        0.96063,
        0.96144,
        0.96224,
        0.96301,
        0.96377,
        0.96451,
        0.96521,
        0.96590,
        0.96657,
        0.96722,
        0.96787,
        0.96849,
        0.96911,
        0.96971,
        0.97031,
        0.97090,
        0.97148,
        0.97204,
        0.97260,
        0.97314,
        0.97367,
        0.97421,
        0.97474,
        0.97525,
        0.97576,
        0.97627,
        0.97676,
        0.97722,
        0.97769,
        0.97815,
        0.97861,
        0.97906,
        0.97950,
        0.97992,
        0.98033,
        0.98073,
        0.98111,
        0.98147,
        0.98182,
        0.98216,
        0.98249,
        0.98281,
        0.98312,
        0.98343,
        0.98374,
        0.98402,
        0.98430,
        0.98456,
        0.98482,
        0.98507,
        0.98532,
        0.98555,
        0.98579,
        0.98602,
        0.98624,
        0.98646,
        0.98668,
        0.98690,
        0.98711,
        0.98732,
        0.98753,
        0.98773,
        0.98793,
        0.98813,
        0.98832,
        0.98851,
        0.98870,
        0.98888,
        0.98907,
        0.98925,
        0.98943,
        0.98961,
        0.98979,
        0.98996,
        0.99014,
        0.99031,
        0.99048,
        0.99064,
        0.99081,
        0.99098,
        0.99114,
        0.99131,
        0.99147,
        0.99163,
        0.99179,
        0.99194,
        0.99210,
        0.99225,
        0.99240,
        0.99256,
        0.99271,
        0.99286,
        0.99300,
        0.99315,
        0.99329,
        0.99344,
        0.99358,
        0.99372,
        0.99386,
        0.99400,
        0.99414,
        0.99427,
        0.99440,
        0.99453,
        0.99466,
        0.99479,
        0.99491,
        0.99503,
        0.99515,
        0.99527,
        0.99538,
        0.99549,
        0.99560,
        0.99571,
        0.99582,
        0.99592,
        0.99602,
        0.99613,
        0.99623,
        0.99633,
        0.99643,
        0.99653,
        0.99662,
        0.99672,
        0.99682,
        0.99691,
        0.99701,
        0.99710,
        0.99719,
        0.99728,
        0.99737,
        0.99746,
        0.99755,
        0.99764,
        0.99772,
        0.99781,
        0.99790,
        0.99798,
        0.99806,
        0.99814,
        0.99823,
        0.99831,
        0.99839,
        0.99847,
        0.99855,
        0.99863,
        0.99871,
        0.99879,
        0.99887,
        0.99895,
        0.99902,
        0.99910,
        0.99918,
        0.99925,
        0.99933,
        0.99940,
        0.99948,
        0.99955,
        0.99963,
        0.99971,
        0.99978,
        0.99985,
        0.99993,
        1.00000,
    ]
    kwargs.setdefault("NoiseShape", NoiseShape)
    # print "Noise Shape = ",NoiseShape
    kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc())
    kwargs.setdefault("RndmEngine", "PixelDigitization")
    if jobproperties.Beam.beamType != "cosmics":
        kwargs.setdefault("RndNoiseProb", 1.0e-10)
    return CfgMgr.PixelNoisyCellGenerator(name, **kwargs)
示例#32
0
def PixelChargeSmearer(name="PixelChargeSmearer", **kwargs):
    kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc())
    kwargs.setdefault("RndmEngine", "PixelDigitization")
    kwargs.setdefault("ThermalNoise", 160.0)
    return CfgMgr.PixelChargeSmearer(name, **kwargs)
示例#33
0
from PileUpComps.PileUpCompsConf import BkgStreamsCache
from Digitization import PileUpEventType
from EventSelectorAthenaPool.EventSelectorAthenaPoolConf import EventSelectorAthenaPool

from Digitization.DigitizationFlags import digitizationFlags
PileUpEventLoopMgr.OrigSelector = "EventSelector"
minBiasCache = BkgStreamsCache("MinBiasCache")
if hasattr(digitizationFlags, 'numberOfNDMinBias'):
    minBiasCache.CollPerXing = digitizationFlags.numberOfNDMinBias()
elif hasattr(digitizationFlags, 'numberOfLowPtMinBias'):
    minBiasCache.CollPerXing = digitizationFlags.numberOfLowPtMinBias()
else:
    raise AttributeError(
        "These job options require digitization jobproperties not present in this release! This job will crash."
    )
minBiasCache.RndmGenSvc = digitizationFlags.rndmSvc()
minBiasCache.RndmStreamName = pupStream
minBiasCache.PileUpEventType = PileUpEventType.MinimumBias
minBiasCache.ReadDownscaleFactor = 10  # read one new event every event

from EventSelectorAthenaPool.EventSelectorAthenaPoolConf import EventSelectorAthenaPool
minBiasEvtSel = EventSelectorAthenaPool("minBiasEventSelector")
if hasattr(digitizationFlags, 'NDMinBiasInputCols'):
    minBiasEvtSel.InputCollections = digitizationFlags.NDMinBiasInputCols()
elif hasattr(digitizationFlags, 'LowPtMinBiasInputCols'):
    minBiasEvtSel.InputCollections = digitizationFlags.LowPtMinBiasInputCols()
else:
    raise AttributeError(
        "These job options require digitization jobproperties not present in this release! This job will crash."
    )
minBiasEvtSel.KeepInputFilesOpen = kfOpen
示例#34
0
    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
示例#35
0
def PixelCellDiscriminator(name="PixelCellDiscriminator", **kwargs):
    kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc())
    kwargs.setdefault("RndmEngine", "PixelDigitization")
    return CfgMgr.PixelCellDiscriminator(name, **kwargs)
示例#36
0
def PixelRandomDisabledCellGenerator(name="PixelRandomDisabledCellGenerator", **kwargs):
    kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc())
    kwargs.setdefault("RndmEngine", "PixelDigitization")
    return CfgMgr.PixelRandomDisabledCellGenerator(name, **kwargs)
示例#37
0
def BasicPixelDigitizationTool(name="PixelDigitizationTool", **kwargs):
    from AthenaCommon import CfgGetter
    kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc())
    streamName = kwargs.setdefault("RndmEngine", "PixelDigitization")
    if not digitizationFlags.rndmSeedList.checkForExistingSeed(streamName):
        digitizationFlags.rndmSeedList.addSeed(streamName, 10513239, 492615104 )
    from AthenaCommon.BeamFlags import jobproperties
    from AthenaCommon.Resilience import protectedInclude
    from AthenaCommon.Include import include
    from AthenaCommon.AppMgr import ServiceMgr
    protectedInclude( "PixelConditionsServices/SpecialPixelMapSvc_jobOptions.py" )
    include.block( "PixelConditionsServices/SpecialPixelMapSvc_jobOptions.py" )
    protectedInclude( "PixelConditionsServices/PixelDCSSvc_jobOptions.py" )
    include.block( "PixelConditionsServices/PixelDCSSvc_jobOptions.py" )
    protectedInclude("PixelConditionsServices/PixelCalibSvc_jobOptions.py")
    from IOVDbSvc.CondDB import conddb
    conddb.addFolderSplitMC("PIXEL","/PIXEL/ReadoutSpeed","/PIXEL/ReadoutSpeed")
    kwargs.setdefault("PixelCablingSvc","PixelCablingSvc")
    if not hasattr(ServiceMgr, "PixelSiPropertiesSvc"):
        from SiLorentzAngleSvc.LorentzAngleSvcSetup import lorentzAngleSvc
        from SiPropertiesSvc.SiPropertiesSvcConf import SiPropertiesSvc
        pixelSiPropertiesSvc = SiPropertiesSvc(name = "PixelSiPropertiesSvc",DetectorName="Pixel",SiConditionsServices = lorentzAngleSvc.pixelSiliconConditionsSvc)
        ServiceMgr += pixelSiPropertiesSvc
    kwargs.setdefault("InputObjectName", "PixelHits")
    pixTools = []
    pixTools += ['PixelDiodeCrossTalkGenerator']
    pixTools += ['PixelChargeSmearer']
    if digitizationFlags.doInDetNoise.get_Value():
        pixTools += ['PixelNoisyCellGenerator']
    pixTools += ['PixelGangedMerger']
    pixTools += ['SpecialPixelGenerator']
    pixTools += ['PixelRandomDisabledCellGenerator']
    pixTools += ['PixelCellDiscriminator']
    kwargs.setdefault("PixelTools", pixTools)
    # Start of special cosmics tuning:
    if jobproperties.Beam.beamType == "cosmics" :
        kwargs.setdefault("UseComTime", True)
    if GeometryFlags.isSLHC():
        LVL1Latency = [255, 255, 255, 255, 255, 16, 255]
        ToTMinCut = [0, 0, 0, 0, 0, 0, 0]
        ApplyDupli = [False, False, False, False, False, False, False]
        LowTOTduplication = [0, 0, 0, 0, 0, 0, 0]
        kwargs.setdefault("LVL1Latency", LVL1Latency)
        kwargs.setdefault("ToTMinCut", ToTMinCut)
        kwargs.setdefault("ApplyDupli", ApplyDupli)
        kwargs.setdefault("LowTOTduplication", LowTOTduplication)
    else:
        # For LVL1Latency, ToTMinCut, ApplyDupli and LowTOTduplication, first component [0] is always for IBL, even for run 1 production.
        # The order is IBL, BL, L1, L2, EC, DBM
        # For IBL and DBM, values of LVL1Latency and LowToTDupli are superseded by values driven by HitDiscCnfg settings, in PixelDigitizationTool.cxx
        LVL1Latency = [16, 150, 255, 255, 255, 16]
        ToTMinCut = [0, 6, 6, 6, 6, 0]
        ApplyDupli = [True, False, False, False, False, False]
        LowTOTduplication = [0, 7, 7, 7, 7, 0]
        kwargs.setdefault("LVL1Latency", LVL1Latency)
        kwargs.setdefault("ToTMinCut", ToTMinCut)
        kwargs.setdefault("ApplyDupli", ApplyDupli)
        kwargs.setdefault("LowTOTduplication", LowTOTduplication)
    if digitizationFlags.doXingByXingPileUp(): # PileUpTool approach
        kwargs.setdefault("FirstXing", Pixel_FirstXing() )
        kwargs.setdefault("LastXing", Pixel_LastXing() )
    return CfgMgr.PixelDigitizationTool(name, **kwargs)
示例#38
0
def DBMChargeTool(name="DBMChargeTool", **kwargs):
    kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc())
    kwargs.setdefault("RndmEngine", "PixelDigitization")
    return CfgMgr.DBMChargeTool(name, **kwargs)
def PixelChargeSmearer(name="PixelChargeSmearer", **kwargs):
    kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc())
    kwargs.setdefault("RndmEngine", "PixelDigitization")
    kwargs.setdefault("ThermalNoise", 160.0)
    return CfgMgr.PixelChargeSmearer(name, **kwargs)
def PixelCellDiscriminator(name="PixelCellDiscriminator", **kwargs):
    kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc())
    kwargs.setdefault("RndmEngine", "PixelDigitization")
    kwargs.setdefault("doITk", GeometryFlags.isSLHC())
    return CfgMgr.PixelCellDiscriminator(name, **kwargs)
def DBMChargeTool(name="DBMChargeTool", **kwargs):
    kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc())
    kwargs.setdefault("RndmEngine", "PixelDigitization")
    return CfgMgr.DBMChargeTool(name, **kwargs)
def PixelRandomDisabledCellGenerator(name="PixelRandomDisabledCellGenerator", **kwargs):
    kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc())
    kwargs.setdefault("RndmEngine", "PixelDigitization")
    return CfgMgr.PixelRandomDisabledCellGenerator(name, **kwargs)