python.LArCalib_RampConfig Namespace Reference

Functions
	LArRampCfg (flags)

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

Function Documentation

LArRampCfg()

python.LArCalib_RampConfig.LArRampCfg

(

flags

)

Definition at line 7 of file LArCalib_RampConfig.py.

def LArRampCfg(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(flags.LArCalib.Input.CoolOflP1Replica)
    pedestalTag=tagResolver.getFolderTag(flags.LArCalib.Pedestal.Folder)
    caliOFCTag=tagResolver.getFolderTag(flags.LArCalib.OFCCali.Folder)
    rampTag=tagResolver.getFolderTag(flags.LArCalib.Ramp.Folder)
    del tagResolver
    print("rampTag",rampTag)
 
 
    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.OFCCali.Folder,detDb=flags.LArCalib.Input.Database2, tag=caliOFCTag, modifiers=chanSelStr(flags)))
    
 
    if not flags.LArCalib.isSC:
       if flags.LArCalib.Input.isRawData:
          result.addEventAlgo(CompFactory.LArRawDataReadingAlg(LArRawChannelKey="", LArDigitKey=digKey, LArFebHeaderKey="LArFebHeader",
                                                               #OutputLevel=2,
                                                               SubCaloPreselection=flags.LArCalib.Input.SubDet,
                                                               PosNegPreselection=flags.LArCalib.Preselection.Side,
                                                               BEPreselection=flags.LArCalib.Preselection.BEC,
                                                               FTNumPreselection=flags.LArCalib.Preselection.FT))
          from LArCalibProcessing.LArCalib_CalibDigitsMakerConfig import LArCalibDigitsMakerCfg
          result.merge(LArCalibDigitsMakerCfg(flags,DigitsKey=digKey,ntrigg=flags.LArCalib.OFC.Ncoll))
       else:
          result.addEventAlgo(CompFactory.LArRawCalibDataReadingAlg(LArAccCalibDigitKey=digKey,
                                                              LArFebHeaderKey="LArFebHeader",
                                                              #OutputLevel = 2,
                                                              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":
          from LArCalibProcessing.LArStripsXtalkCorrConfig import LArStripsXtalkCorrCfg
          result.merge(LArStripsXtalkCorrCfg(flags,[digKey,]))
 
          theLArCalibShortCorrector = CompFactory.LArCalibShortCorrector(KeyList = [digKey,])
          result.addEventAlgo(theLArCalibShortCorrector)
    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, LATOMEDecoder = theLArLATOMEDecoder))
 
    pass
 
 
    bcKey = "LArBadChannelSC" if flags.LArCalib.isSC else "LArBadChannel"     
 
 
    theLArRampBuilder = CompFactory.LArRampBuilder()
    theLArRampBuilder.KeyList      = [digKey,]
    theLArRampBuilder.SubtractDac0 = False
    if flags.LArCalib.isSC:
       theLArRampBuilder.ProblemsToMask=["deadCalib","deadReadout","deadPhys","maskedOSUM","OffOFCs","transmissionErrorFibre",]
    else:
       theLArRampBuilder.ProblemsToMask=["deadCalib","deadReadout","deadPhys","almostDead","short"]
 
    theLArRampBuilder.RecoType = "OF"
    theLArRampBuilder.PeakOFTool=CompFactory.LArOFPeakRecoTool(UseShape = False,OutputLevel=2)
 
    theLArRampBuilder.DAC0         = 4294967294
    theLArRampBuilder.StoreRawRamp = True
    theLArRampBuilder.StoreRecRamp = True
    theLArRampBuilder.Polynom      = 1    
    theLArRampBuilder.RampRange    = 3600 # Check on the raw data ADC sample before ped subtraction and pulse reconstruction to include point in fit
    theLArRampBuilder.correctBias  = False
    #theLArRampBuilder.ConsecutiveADCs = 0
    theLArRampBuilder.minDAC = 10      # minimum DAC value to use in fit
    theLArRampBuilder.KeyOutput = "LArRamp"
    theLArRampBuilder.DeadChannelCut = -9999
    theLArRampBuilder.GroupingType = flags.LArCalib.GroupingType
    #theLArRampBuilder.LongNtuple = False
 
    theLArRampBuilder.isSC = flags.LArCalib.isSC
    theLArRampBuilder.BadChanKey = bcKey
 
    if "HEC" in flags.LArCalib.Input.SubDet:
        theLArRampBuilder.isHEC = True
        theLArRampBuilder.HECKey = "LArHEC_PAmap"
        result.merge(addFolders(flags,'/LAR/ElecCalibOfl/HecPAMap',flags.LArCalib.Input.CoolOflP1Replica))
    
    result.addEventAlgo(theLArRampBuilder)
 
 
    # Bad-channel patching 
    if flags.LArCalib.CorrectBadChannels:
        LArRampPatcher=CompFactory.getComp("LArCalibPatchingAlg<LArRampComplete>")
        theLArRampPatcher=LArRampPatcher("LArRampPatcher")
        theLArRampPatcher.ContainerKey="LArRamp"
        theLArRampPatcher.BadChanKey=bcKey
        theLArRampPatcher.PatchMethod="PhiAverage"
        theLArRampPatcher.SuperCells=flags.LArCalib.isSC
   
        if flags.LArCalib.isSC:
          theLArRampPatcher.ProblemsToPatch=["deadCalib","deadReadout","deadPhys","maskedOSUM","OffOFCs","transmissionErrorFibre"]
          theLArRampPatcher.OnOffMap="LArOnOffIdMapSC"
          theLArRampPatcher.CalibLineKey="LArCalibIdMapSC"
        else:  
          theLArRampPatcher.ProblemsToPatch=["deadCalib","deadReadout","deadPhys","almostDead","short"]
        theLArRampPatcher.UseCorrChannels=False
        result.addEventAlgo(theLArRampPatcher)
 
    # Validation + CB patching 
    if flags.LArCalib.doValidation:
       
       if flags.LArCalib.isSC:
         fldr="/LAR/ElecCalibFlatSC/Ramp"
         rmpFlt=CompFactory.getComp("LArFlatConditionsAlg<LArRampSC>")("RampFltVal")
       else:  
         fldr="/LAR/ElecCalibFlat/Ramp"
         rmpFlt=CompFactory.getComp("LArFlatConditionsAlg<LArRampFlat>")("RampFltVal")
       result.merge(addFolders(flags,fldr,"LAR_ONL"))
       condLoader=result.getCondAlgo("CondInputLoader")
       condLoader.Load.add(("CondAttrListCollection",fldr))
 
       rmpFlt.ReadKey=fldr
       rmpFlt.WriteKey="LArRampRef"
       result.addCondAlgo(rmpFlt)
 
       from LArCalibDataQuality.Thresholds import rampThr, rampThrFEB
       from AthenaCommon.Constants import WARNING
 
       theRampValidationAlg=CompFactory.LArRampValidationAlg("RampVal")
       theRampValidationAlg.RampTolerance=rampThr
       theRampValidationAlg.RampToleranceFEB=rampThrFEB
       if flags.LArCalib.isSC:
          theRampValidationAlg.ProblemsToMask=["deadCalib","deadReadout","deadPhys","maskedOSUM",
                                               "OffOFCs","transmissionErrorFibre"]
       else:   
          theRampValidationAlg.ProblemsToMask=["deadReadout","deadCalib","deadPhys","almostDead",
                                               "highNoiseHG","highNoiseMG","highNoiseLG"]
       theRampValidationAlg.KeyList=["LArRamp"+digKey,]
       if flags.LArCalib.isSC:
          theRampValidationAlg.PatchMissingFEBs = False
          theRampValidationAlg.CheckCompletness = False
       else:   
          theRampValidationAlg.PatchMissingFEBs=True
       theRampValidationAlg.UseCorrChannels=False
       theRampValidationAlg.ValidationKey="LArRamp"
       theRampValidationAlg.ReferenceKey="LArRampRef"
  
       theRampValidationAlg.MsgLevelForDeviations=WARNING
       theRampValidationAlg.ListOfDevFEBs="rampFebs.txt"
 
       theRampValidationAlg.BadChanKey =  bcKey
       theRampValidationAlg.SuperCells = flags.LArCalib.isSC 
 
       if flags.LArCalib.isSC:
          theRampValidationAlg.CablingKey = "LArOnOffIdMapSC"
          theRampValidationAlg.CalibLineKey = "LArCalibIdMapSC"
 
       result.addEventAlgo(theRampValidationAlg)
 
    #Output (POOL + sqlite) file writing:
    from RegistrationServices.OutputConditionsAlgConfig import OutputConditionsAlgCfg
    result.merge(OutputConditionsAlgCfg(flags,
                                        outputFile=flags.LArCalib.Output.POOLFile,
                                        ObjectList=["LArRampComplete#LArRamp#"+flags.LArCalib.Ramp.Folder,],
                                        IOVTagList=[rampTag,],
                                        Run1=flags.LArCalib.IOVStart,
                                        Run2=flags.LArCalib.IOVEnd
                                    ))
 
    #RegistrationSvc    
    result.addService(CompFactory.IOVRegistrationSvc(RecreateFolders = False))
 
 
    #ROOT ntuple writing:
    rootfile=flags.LArCalib.Output.ROOTFile
    
    ntupKey = digKey
    if flags.LArCalib.isSC:
        ntupKey = "HIGH" # Modification to avoid problems in LArRampBuilder
    if rootfile != "":
        result.addEventAlgo(CompFactory.LArRamps2Ntuple( ContainerKey = ["LArRamp"+ntupKey], #for RawRamp
                                                         AddFEBTempInfo = False,
                                                         RealGeometry = True,
                                                         OffId = True,
                                                         AddCalib = True,
                                                         RawRamp = True,
                                                         SaveAllSamples =  True,
                                                         BadChanKey = bcKey,
                                                         ApplyCorr=True,
                                                         isSC = flags.LArCalib.isSC
                                                     ))
        if flags.LArCalib.Output.SaveAverages:
           result.addEventAlgo(CompFactory.LArAverages2Ntuple( "LArAverages2Ntuple"+digKey,
                                                               ContainerKey = "SC" if flags.LArCalib.isSC else digKey, 
                                                               BadChanKey = bcKey,
                                                               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")
        pass # end if ROOT ntuple writing
 
 
    from PerfMonComps.PerfMonCompsConfig import PerfMonMTSvcCfg
    result.merge(PerfMonMTSvcCfg(flags))
 
    return result
 
 

Variable Documentation

AtlasVersion

python.LArCalib_RampConfig.AtlasVersion

Definition at line 265 of file LArCalib_RampConfig.py.

cfg

python.LArCalib_RampConfig.cfg = MainServicesCfg(ConfigFlags)

Definition at line 274 of file LArCalib_RampConfig.py.

ConfigFlags

python.LArCalib_RampConfig.ConfigFlags = initConfigFlags()

Definition at line 251 of file LArCalib_RampConfig.py.

Database

python.LArCalib_RampConfig.Database

Definition at line 259 of file LArCalib_RampConfig.py.

DBConnection

python.LArCalib_RampConfig.DBConnection

Definition at line 263 of file LArCalib_RampConfig.py.

DBInstance

python.LArCalib_RampConfig.DBInstance

Definition at line 276 of file LArCalib_RampConfig.py.

Dir

python.LArCalib_RampConfig.Dir

Definition at line 254 of file LArCalib_RampConfig.py.

Files

python.LArCalib_RampConfig.Files

Definition at line 258 of file LArCalib_RampConfig.py.

GlobalTag

python.LArCalib_RampConfig.GlobalTag

Definition at line 264 of file LArCalib_RampConfig.py.

POOLFile

python.LArCalib_RampConfig.POOLFile

Definition at line 260 of file LArCalib_RampConfig.py.

ROOTFile

python.LArCalib_RampConfig.ROOTFile

Definition at line 261 of file LArCalib_RampConfig.py.

RunNumbers

python.LArCalib_RampConfig.RunNumbers

Definition at line 256 of file LArCalib_RampConfig.py.

SubDet

python.LArCalib_RampConfig.SubDet

Definition at line 257 of file LArCalib_RampConfig.py.

Type

python.LArCalib_RampConfig.Type

Definition at line 255 of file LArCalib_RampConfig.py.