Functions
	LArDelay_OFCCaliCfg (flags)
	LArDelay_OFCCali_PoolDumpCfg (flags)

Variables
	ConfigFlags = initConfigFlags()
	Dir
	Type
	RunNumbers
	Database
	Files
	ROOTFile
	POOLFile
	DBConnection
	GlobalTag
	AtlasVersion
	cfg = MainServicesCfg(ConfigFlags)
	DBInstance

Function Documentation

◆ LArDelay_OFCCali_PoolDumpCfg()

python.LArCalib_Delay_OFCCaliConfig.LArDelay_OFCCali_PoolDumpCfg ( flags )

Definition at line 264 of file LArCalib_Delay_OFCCaliConfig.py.

def LArDelay_OFCCali_PoolDumpCfg(flags):
 
    #Get basic services and cond-algos
    from LArCalibProcessing.LArCalibBaseConfig import LArCalibBaseCfg
    result=LArCalibBaseCfg(flags)
 
    bcKey = "LArBadChannelSC" if flags.LArCalib.isSC else "LArBadChannel"   
 
    #CondProxyProvider
    from EventSelectorAthenaPool.CondProxyProviderConfig import CondProxyProviderCfg
    result.merge (CondProxyProviderCfg (flags, flags.LArCalib.Input.Files))
 
    #ROOT ntuple writing:
    rootfile=flags.LArCalib.Output.ROOTFile
    rootfile2=flags.LArCalib.Output.ROOTFile2
    if rootfile:
        result.addEventAlgo(CompFactory.LArCaliWaves2Ntuple(KeyList = ["CaliWave",] if flags.LArCalib.isSC else ["LArCaliWave",],
                                                            NtupleName  = "CALIWAVE",
                                                            AddFEBTempInfo = False,
                                                            SaveDerivedInfo = True,
                                                            ApplyCorrection = True,
                                                            BadChanKey = bcKey,
                                                            AddCalib=True,
                                                            SaveJitter=True if flags.LArCalib.CaliWave.Nsteps >= 24 else False,
                                                            isSC=flags.LArCalib.isSC
                                                        ))
 
        if not rootfile2:
           result.addEventAlgo(CompFactory.LArOFC2Ntuple(ContainerKey = "LArOFC",
                                                      AddFEBTempInfo  = False,
                                                      BadChanKey = bcKey,
                                                      AddCalib=True,
                                                      isSC=flags.LArCalib.isSC
                                                  ))
 
        import os
        if os.path.exists(rootfile):
            os.remove(rootfile)
        result.addService(CompFactory.NTupleSvc(Output = [ "FILE1 DATAFILE='"+rootfile+"' OPT='NEW'" ]))
        result.setAppProperty("HistogramPersistency","ROOT")
 
    if rootfile2:
        if rootfile == rootfile2:
           result.addEventAlgo(CompFactory.LArOFC2Ntuple(ContainerKey = "LArOFC",
                                                   AddFEBTempInfo  = False,
                                                   NtupleFile = "FILE1",
                                                   BadChanKey = bcKey,
                                                   AddCalib=True,
                                                   isSC=flags.LArCalib.isSC
                                               ))
        else:
           result.addEventAlgo(CompFactory.LArOFC2Ntuple(ContainerKey = "LArOFC",
                                                   AddFEBTempInfo  = False,
                                                   NtupleFile = "FILE2",
                                                   BadChanKey = bcKey,
                                                   AddCalib=True,
                                                   isSC=flags.LArCalib.isSC
                                               ))
 
           import os
           if os.path.exists(rootfile2):
               os.remove(rootfile2)
           if not rootfile:   
               result.addService(CompFactory.NTupleSvc(Output = [ "FILE2 DATAFILE='"+rootfile2+"' OPT='NEW'" ]))
           else:   
               result.getService("NTupleSvc").Output += [ "FILE2 DATAFILE='"+rootfile2+"' OPT='NEW'" ]
           result.setAppProperty("HistogramPersistency","ROOT")
 
 
    return result
 
 

◆ LArDelay_OFCCaliCfg()

python.LArCalib_Delay_OFCCaliConfig.LArDelay_OFCCaliCfg ( flags )

Definition at line 6 of file LArCalib_Delay_OFCCaliConfig.py.

def LArDelay_OFCCaliCfg(flags):
 
    #Get basic services and cond-algos
    from LArCalibProcessing.LArCalibBaseConfig import LArCalibBaseCfg,chanSelStr
    result=LArCalibBaseCfg(flags)
 
    #Add ByteStream reading
    from ByteStreamCnvSvc.ByteStreamConfig import ByteStreamReadCfg
    result.merge(ByteStreamReadCfg(flags))
 
    #Calibration runs are taken in fixed gain. 
    #The SG key of the digit-container is name of the gain
    gainStrMap={0:"HIGH",1:"MEDIUM",2:"LOW"}
    digKey=gainStrMap[flags.LArCalib.Gain]
 
    from LArCalibProcessing.utils import FolderTagResolver
    FolderTagResolver._globalTag=flags.IOVDb.GlobalTag
    tagResolver=FolderTagResolver()
    pedestalTag=tagResolver.getFolderTag(flags.LArCalib.Pedestal.Folder)
    caliWaveTag=tagResolver.getFolderTag(flags.LArCalib.CaliWave.Folder)
    caliOFCTag=tagResolver.getFolderTag(flags.LArCalib.OFCCali.Folder)
    acTag=tagResolver.getFolderTag(flags.LArCalib.AutoCorr.Folder)
    del tagResolver
    
    from IOVDbSvc.IOVDbSvcConfig import addFolders
    result.merge(addFolders(flags,flags.LArCalib.Pedestal.Folder,detDb=flags.LArCalib.Input.Database, tag=pedestalTag, modifiers=chanSelStr(flags),
                            className="LArPedestalComplete"))
    result.merge(addFolders(flags,flags.LArCalib.AutoCorr.Folder,detDb=flags.LArCalib.Input.Database, tag=acTag,modifiers=chanSelStr(flags)))
    
 
    if not flags.LArCalib.isSC:
       if flags.LArCalib.Input.isRawData:
          result.addEventAlgo(CompFactory.LArRawDataReadingAlg(LArRawChannelKey="", LArDigitKey=digKey, LArFebHeaderKey="LArFebHeader"))
          from LArCalibProcessing.LArCalib_CalibDigitsMakerConfig import LArCalibDigitsMakerCfg
          result.merge(LArCalibDigitsMakerCfg(flags,digKey))
       else:
          result.addEventAlgo(CompFactory.LArRawCalibDataReadingAlg(LArAccCalibDigitKey=digKey,
                                                              LArFebHeaderKey="LArFebHeader",
                                                              SubCaloPreselection=flags.LArCalib.Input.SubDet,
                                                              PosNegPreselection=flags.LArCalib.Preselection.Side,
                                                              BEPreselection=flags.LArCalib.Preselection.BEC,
                                                              FTNumPreselection=flags.LArCalib.Preselection.FT))
    
       from LArROD.LArFebErrorSummaryMakerConfig import LArFebErrorSummaryMakerCfg
       result.merge(LArFebErrorSummaryMakerCfg(flags))
       result.getEventAlgo("LArFebErrorSummaryMaker").CheckAllFEB=False
 
       if flags.LArCalib.Input.SubDet == "EM":
          theLArCalibShortCorrector = CompFactory.LArCalibShortCorrector(KeyList = [digKey,])
          result.addEventAlgo(theLArCalibShortCorrector)
 
          from LArCalibProcessing.LArStripsXtalkCorrConfig import LArStripsXtalkCorrCfg
          result.merge(LArStripsXtalkCorrCfg(flags,[digKey,]))
    else:
       digKey="SC"
       theLArLATOMEDecoder = CompFactory.LArLATOMEDecoder("LArLATOMEDecoder")
       if flags.LArCalib.Input.isRawData:
          result.addEventAlgo(CompFactory.LArRawSCDataReadingAlg(adcCollKey = digKey, adcBasCollKey = "", etCollKey = "",
                                                               etIdCollKey = "", LATOMEDecoder = theLArLATOMEDecoder))
          from LArCalibProcessing.LArCalib_CalibDigitsMakerConfig import LArCalibDigitsMakerCfg
          result.merge(LArCalibDigitsMakerCfg(flags,digKey))
 
       else:   
          # this needs also legacy  maps
          from LArCabling.LArCablingConfig import LArCalibIdMappingCfg,LArOnOffIdMappingCfg
          result.merge(LArOnOffIdMappingCfg(flags))
          result.merge(LArCalibIdMappingCfg(flags))
          result.addEventAlgo(CompFactory.LArRawSCCalibDataReadingAlg(LArSCAccCalibDigitKey = digKey, 
                                                                      CalibCablingKeyLeg="LArCalibLineMap",
                                                                      OnOffMapLeg="LArOnOffIdMap",
                                                                      LATOMEDecoder = theLArLATOMEDecoder, ))
 
    bcKey = "LArBadChannelSC" if flags.LArCalib.isSC else "LArBadChannel"     
 
    theLArCaliWaveBuilder = CompFactory.LArCaliWaveBuilder()
    theLArCaliWaveBuilder.KeyList= [digKey,]
    theLArCaliWaveBuilder.KeyOutput="LArCaliWave"
    theLArCaliWaveBuilder.GroupingType     = flags.LArCalib.GroupingType
    theLArCaliWaveBuilder.SubtractPed      = True
    theLArCaliWaveBuilder.NSteps           = flags.LArCalib.CaliWave.Nsteps
    theLArCaliWaveBuilder.CheckEmptyPhases = not flags.LArCalib.isSC 
    theLArCaliWaveBuilder.NBaseline        = 0 # to avoid the use of the baseline when Pedestal are missing
    theLArCaliWaveBuilder.UseDacAndIsPulsedIndex = False # should have an impact only for HEC
    theLArCaliWaveBuilder.RecAllCells      = False
    theLArCaliWaveBuilder.isSC             = flags.LArCalib.isSC
    result.addEventAlgo(theLArCaliWaveBuilder)
    
 
    if flags.LArCalib.Input.SubDet == "HEC" or flags.LArCalib.Input.SubDet == "HECFCAL": 
        theLArCaliWaveBuilder.KeyOutput="LArCaliWave_multi"
        theLArCaliWaveSelector = CompFactory.LArCaliWaveSelector("LArCaliWaveSelector")
        theLArCaliWaveSelector.KeyList         = ["LArCaliWave_multi",]
        theLArCaliWaveSelector.KeyOutput       = "LArCaliWave"
        theLArCaliWaveSelector.GroupingType    = flags.LArCalib.GroupingType
        if flags.LArCalib.Gain==0: #HIGH gain 
            theLArCaliWaveSelector.SelectionList = [ "HEC/0/0/460","HEC/1/0/460","HEC/2/0/230","HEC/3/0/230" ] 
            theLArCaliWaveSelector.SelectionList += [ "FCAL/0/0/500","FCAL/1/0/500","FCAL/2/0/500","FCAL/3/0/500" ]
 
        elif flags.LArCalib.Gain==1: #MEDIUM gain
            theLArCaliWaveSelector.SelectionList = [ "HEC/0/1/3600","HEC/1/1/3600","HEC/2/1/1800","HEC/3/1/1800"]
            theLArCaliWaveSelector.SelectionList += [ "FCAL/0/1/5000","FCAL/1/1/5000","FCAL/2/1/5000","FCAL/3/1/5000" ]
   
        elif flags.LArCalib.Gain==2: #LOW gain
            theLArCaliWaveSelector.SelectionList = [ "HEC/0/2/24000","HEC/1/2/24000","HEC/2/2/18000","HEC/3/2/18000" ]
            theLArCaliWaveSelector.SelectionList += [ "FCAL/0/2/40000","FCAL/1/2/40000","FCAL/2/2/40000","FCAL/3/2/40000" ]
      
        result.addEventAlgo(theLArCaliWaveSelector)
    pass
 
    if flags.LArCalib.CorrectBadChannels:
        theLArCaliWavePatcher=CompFactory.getComp("LArCalibPatchingAlg<LArCaliWaveContainer>")("LArCaliWavePatch")
        theLArCaliWavePatcher.ContainerKey = "LArCaliWave"
        theLArCaliWavePatcher.BadChanKey = bcKey 
        theLArCaliWavePatcher.SuperCells = flags.LArCalib.isSC 
        #theLArCaliWavePatcher.PatchMethod="PhiNeighbor" ##take the first neigbour
        theLArCaliWavePatcher.PatchMethod = "PhiAverage" 
        if flags.LArCalib.isSC:
           theLArCaliWavePatcher.ProblemsToPatch = [
            "deadCalib","deadReadout","deadPhys","maskedOSUM","OffOFCs","transmissionErrorFibre",]
           theLArCaliWavePatcher.OnOffMap="LArOnOffIdMapSC" 
           theLArCaliWavePatcher.CalibLineKey="LArCalibIdMapSC"
        else:
           theLArCaliWavePatcher.ProblemsToPatch = [
            "deadCalib","deadReadout","deadPhys","almostDead","short", ]
 
        result.addEventAlgo(theLArCaliWavePatcher)
    pass
 
    if flags.LArCalib.doValidation:
       
       result.merge(addFolders(flags,flags.LArCalib.CaliWave.Folder+"<key>LArCaliWaveRef</key>","LAR_OFL"))
 
       from LArCalibDataQuality.Thresholds import cwAmpThr,cwFWHMThr,cwAmpThrFEB,cwFWHMThrFEB
       from AthenaCommon.Constants import WARNING
 
       theCaliWaveValidationAlg=CompFactory.LArCaliWaveValidationAlg("CaliWaveVal")
       if flags.LArCalib.isSC:
          theCaliWaveValidationAlg.ProblemsToMask=["deadCalib","deadReadout","deadPhys","maskedOSUM",
                                                   "OffOFCs","transmissionErrorFibre",]
       else:   
          theCaliWaveValidationAlg.ProblemsToMask=["deadReadout","deadCalib","deadPhys","almostDead",
                                                   "highNoiseHG","highNoiseMG","highNoiseLG"]
       theCaliWaveValidationAlg.ValidationKey="LArCaliWave"
       theCaliWaveValidationAlg.ReferenceKey="LArCaliWaveRef"
       theCaliWaveValidationAlg.MsgLevelForDeviations=WARNING
       theCaliWaveValidationAlg.ListOfDevFEBs="caliWaveFebs.txt"
       theCaliWaveValidationAlg.AmplitudeTolerance=cwAmpThr
       theCaliWaveValidationAlg.CaliWaveFWHMTolerance=cwFWHMThr
       theCaliWaveValidationAlg.AmplitudeToleranceFEB=cwAmpThrFEB
       theCaliWaveValidationAlg.CaliWaveFWHMToleranceFEB=cwFWHMThrFEB
       theCaliWaveValidationAlg.TimeShiftDetection=True
       theCaliWaveValidationAlg.PatchMissingFEBs=True
       theCaliWaveValidationAlg.UseCorrChannels=False
       theCaliWaveValidationAlg.BadChanKey =  bcKey
       theCaliWaveValidationAlg.SuperCells =  flags.LArCalib.isSC
 
       if flags.LArCalib.isSC:
          theCaliWaveValidationAlg.CablingKey = "LArOnOffIdMapSC"
          theCaliWaveValidationAlg.CalibLineKey = "LArCalibIdMapSC"
 
       result.addEventAlgo(theCaliWaveValidationAlg)
 
    
    if flags.LArCalib.doOFCCali:
 
       LArCaliOFCAlg = CompFactory.LArOFCAlg("LArCaliOFCAlg")
       LArCaliOFCAlg.ReadCaliWave = True
       LArCaliOFCAlg.KeyList   = [ "LArCaliWave" ]
       LArCaliOFCAlg.Nphase    = 50
       LArCaliOFCAlg.Dphase    = 1
       LArCaliOFCAlg.Ndelay    = 24
       LArCaliOFCAlg.Nsample   = 5
       LArCaliOFCAlg.Normalize = True
       LArCaliOFCAlg.TimeShift = False
       LArCaliOFCAlg.TimeShiftByIndex = -1
       LArCaliOFCAlg.Verify    = True
       LArCaliOFCAlg.FillShape = False
       #LArCaliOFCAlg.DumpOFCfile = "LArOFCCali.dat"
       LArCaliOFCAlg.GroupingType = flags.LArCalib.GroupingType
       LArCaliOFCAlg.isSC = flags.LArCalib.isSC
       LArCaliOFCAlg.DecoderTool=CompFactory.LArAutoCorrDecoderTool(isSC=flags.LArCalib.isSC)
       result.addEventAlgo(LArCaliOFCAlg)
 
 
    #ROOT ntuple writing:
    rootfile=flags.LArCalib.Output.ROOTFile
    rootfile2=flags.LArCalib.Output.ROOTFile2
    if rootfile != "":
        result.addEventAlgo(CompFactory.LArCaliWaves2Ntuple(KeyList = ["LArCaliWave",],
                                                            NtupleName  = "CALIWAVE",
                                                            AddFEBTempInfo = False,
                                                            RealGeometry = True,
                                                            SaveDerivedInfo = True,
                                                            ApplyCorrection = True,
                                                            isSC = flags.LArCalib.isSC,
                                                            BadChanKey = bcKey,
                                                            OffId=True,
                                                            AddCalib=True,
                                                            SaveJitter=True if flags.LArCalib.CaliWave.Nsteps >= 24 else False
                                                        ))
 
        import os
        if os.path.exists(rootfile):
            os.remove(rootfile)
        result.addService(CompFactory.NTupleSvc(Output = [ "FILE1 DATAFILE='"+rootfile+"' OPT='NEW'" ]))
        result.setAppProperty("HistogramPersistency","ROOT")
        pass # end if ROOT ntuple writing
 
    if rootfile2 != "" and flags.LArCalib.doOFCCali:
        result.addEventAlgo(CompFactory.LArOFC2Ntuple(ContainerKey = "LArOFC",
                                                   AddFEBTempInfo  = False,
                                                   NtupleFile = "FILE2",
                                                   BadChanKey = bcKey,
                                                   isSC = flags.LArCalib.isSC,
                                                   AddCalib=True
                                               ))
 
        import os
        if os.path.exists(rootfile2):
           os.remove(rootfile2)
        if rootfile == "":   
           result.addService(CompFactory.NTupleSvc(Output = [ "FILE2 DATAFILE='"+rootfile2+"' OPT='NEW'" ]))
        else:   
           result.getService("NTupleSvc").Output += [ "FILE2 DATAFILE='"+rootfile2+"' OPT='NEW'" ]
        result.setAppProperty("HistogramPersistency","ROOT")
        pass # end if ROOT ntuple writing
 
 
    #Get the current folder tag by interrogating the database:
    from LArCalibProcessing.utils import FolderTagResolver
    tagResolver=FolderTagResolver()
    caliWaveTag=tagResolver.getFolderTag(flags.LArCalib.CaliWave.Folder)
    caliOFCTag=tagResolver.getFolderTag(flags.LArCalib.OFCCali.Folder)
    del tagResolver
 
 
    #Output (POOL + sqlite) file writing:
    from RegistrationServices.OutputConditionsAlgConfig import OutputConditionsAlgCfg
    result.merge(OutputConditionsAlgCfg(flags,
                                        outputFile=flags.LArCalib.Output.POOLFile,
                                        ObjectList=["LArCaliWaveContainer#LArCaliWave#"+flags.LArCalib.CaliWave.Folder,],
                                        IOVTagList=[caliWaveTag,],
                                        Run1=flags.LArCalib.IOVStart,
                                        Run2=flags.LArCalib.IOVEnd
                                    ))
    if flags.LArCalib.doOFCCali:
       result.getEventAlgo("OutputConditionsAlg").ObjectList += ["LArOFCComplete#LArOFC#"+flags.LArCalib.OFCCali.Folder]
       result.getEventAlgo("OutputConditionsAlg").IOVTagList += [caliOFCTag]
 
    #RegistrationSvc    
    result.addService(CompFactory.IOVRegistrationSvc(RecreateFolders = False))
 
 
    from PerfMonComps.PerfMonCompsConfig import PerfMonMTSvcCfg
    result.merge(PerfMonMTSvcCfg(flags))
 
    return result
 