Functions
def	LArPileUpAutoCorrCfg (flags)

Variables
	ConfigFlags = initConfigFlags()

	Files

	RunNumbers

	Database

	SubDet

	BadChannelDB

	BadChannelTag

	ROOTFile

	DatabaseInstance

	DBConnection

	GlobalTag

	AtlasVersion

	Ncoll

	Nsamples

	cfg = MainServicesCfg(ConfigFlags)

Function Documentation

◆ LArPileUpAutoCorrCfg()

def python.LArCalib_PileUpAutoCorrConfig.LArPileUpAutoCorrCfg ( flags )

Definition at line 7 of file LArCalib_PileUpAutoCorrConfig.py.

 def LArPileUpAutoCorrCfg(flags):
  
     #Get basic services and cond-algos
     from LArCalibProcessing.LArCalibBaseConfig import LArCalibBaseCfg,chanSelStr
     result=LArCalibBaseCfg(flags)
  
     from IOVDbSvc.IOVDbSvcConfig import addFolders
  
     #load fsampl, MinBias Average and PulseShape 32 samples from OFLP200
     if flags.LArCalib.isSC:
        from LArConfiguration.LArElecCalibDBConfig import LArElecCalibDBMCSCCfg
        # for the SC we need uA2MeV also from MC, because the one used for data are weighted with E->ET conversion
        result.merge(LArElecCalibDBMCSCCfg(flags,["fSamplSC","ShapeSC","MinBiasSC","uA2MeVSC"]))
     else:
        result.merge(addFolders(flags,"/LAR/ElecCalibMC/Shape",detDb="LAR_OFL", db="OFLP200",tag="LARElecCalibMCShapeLArPileupShape-RUN2-2018",className="LArShape32MC",modifiers="<key>LArShapeMC</key>"))
        result.merge(addFolders(flags,"/LAR/ElecCalibMC/fSampl",detDb="LAR_OFL", db="OFLP200",tag="LARElecCalibMCfSampl-G4101-20371-FTFP_BERT_BIRK_v2",className="LArfSamplMC"))
        result.merge(addFolders(flags,"/LAR/ElecCalibMC/MinBias",detDb="LAR_OFL", db="OFLP200",tag="LARElecCalibMCMinBias-mc16-Epos-A3-s3687",className="LArMinBiasMC"))
  
        result.addCondAlgo(CompFactory.LArMCSymCondAlg())
  
        LArShapeSymAlg =  CompFactory.getComp("LArSymConditionsAlg<LArShape32MC, LArShape32Sym>")
        result.addCondAlgo(LArShapeSymAlg(ReadKey="LArShapeMC",WriteKey="LArShapeSym"))
  
        LArfSamplSymAlg =  CompFactory.getComp("LArSymConditionsAlg<LArfSamplMC, LArfSamplSym>")
        result.addCondAlgo(LArfSamplSymAlg(ReadKey="LArfSampl", WriteKey="LArfSamplSym"))
  
        LArMinBiasSymAlg =  CompFactory.getComp("LArSymConditionsAlg<LArMinBiasMC, LArMinBiasSym>")    
        result.addCondAlgo(LArMinBiasSymAlg(ReadKey="LArMinBias",WriteKey="LArMinBiasSym"))
  
     from LArCalibProcessing.utils import FolderTagResolver
     FolderTagResolver._globalTag=flags.IOVDb.GlobalTag
     if flags.LArCalib.isSC:
        FolderTagResolver._defaultSuffix="-UPD3-00"
     rs=FolderTagResolver(dbname="sqlite://;schema=%s;dbname=CONDBR2"%flags.LArCalib.Input.Database)
     AutoCorrTag=rs.getFolderTag(flags.LArCalib.AutoCorr.Folder)
     # FIXME these tags has to be re-enabled in 2024 also for main readout:
     #if flags.LArCalib.isSC:
     PedestalTag=rs.getFolderTag(flags.LArCalib.Pedestal.Folder)
     RampTag=rs.getFolderTag(flags.LArCalib.Ramp.Folder)
     MpMcTag=rs.getFolderTag(flags.LArCalib.MphysOverMcal.Folder)
     rsac=FolderTagResolver(dbname="COOLOFL_LAR/CONDBR2")
     PhysAutoCorrTag= rsac.getFolderTag(flags.LArCalib.PhysAutoCorr.Folder)
     nColl=flags.LArCalib.OFC.Ncoll
     if (nColl>0 and "mu" not in PhysAutoCorrTag):
         #Insert mu in tag-name:
         elems=PhysAutoCorrTag.split("-")
         PhysAutoCorrTag="-".join([elems[0]+"_mu_%i"%nColl,]+elems[1:])
         del elems
  
     del rs
  
     result.merge(addFolders(flags,flags.LArCalib.AutoCorr.Folder,detDb=flags.LArCalib.Input.Database, tag=AutoCorrTag, modifiers=chanSelStr(flags)+"<key>LArAutoCorr</key>", 
                             className="LArAutoCorrComplete"))
     # FIXME these folders has to be re-enabled in 2024 also for Main readout:
     #if flags.LArCalib.isSC:
     result.merge(addFolders(flags,flags.LArCalib.Pedestal.Folder,detDb=flags.LArCalib.Input.Database, tag=PedestalTag, modifiers=chanSelStr(flags)+"<key>LArPedestal</key>", 
                         className="LArPedestalComplete"))
     result.merge(addFolders(flags,flags.LArCalib.Ramp.Folder,detDb=flags.LArCalib.Input.Database, tag=RampTag, modifiers=chanSelStr(flags), 
                         className="LArRampComplete"))
     result.merge(addFolders(flags,flags.LArCalib.MphysOverMcal.Folder,detDb=flags.LArCalib.Input.Database, tag=MpMcTag, modifiers=chanSelStr(flags), 
                         className="LArMphysOverMcalComplete"))
  
     #Need ADC2MeV values for AutoCorrCondAlg ... 
     #use current production values as input conditions
     if flags.LArCalib.isSC:
        requiredConditions=["DAC2uA","HVScaleCorr"]
     else:   
        #requiredConditions=["DAC2uA","uA2MeV","HVScaleCorr","Ramp","Pedestal","MphysOverMcal"]
        # in 2024 put:
        requiredConditions=["DAC2uA","uA2MeV","HVScaleCorr"]
     if flags.LArCalib.isSC:
        from LArConfiguration.LArElecCalibDBConfig import LArElecCalibDBSCCfg
        result.merge(LArElecCalibDBSCCfg(flags,requiredConditions))
        mapKey="LArOnOffIdMapSC"
        bcKey = "LArBadChannelSC"
        uAKey = "LAruA2MeVSC"
        DACKey = "LArDAC2uASC"
        HVKey = "LArHVScaleCorrSC"
     else:
        from LArConfiguration.LArElecCalibDBConfig import LArElecCalibDBCfg
        result.merge(LArElecCalibDBCfg(flags,requiredConditions))
        mapKey="LArOnOffIdMap"
        bcKey = "LArBadChannel"
        uAKey = "LAruA2MeV"
        DACKey = "LArDAC2uA"
        HVKey = "LArHVScaleCorr"
  
     result.addCondAlgo(CompFactory.LArADC2MeVCondAlg(UseFEBGainTresholds=False,LArOnOffIdMappingKey=mapKey,CompleteDetector=False,LAruA2MeVKey=uAKey,LArDAC2uAKey=DACKey,LArHVScaleCorrKey=HVKey,isSuperCell=flags.LArCalib.isSC))
  
     theLArAutoCorrTotalCondAlg=CompFactory.LArAutoCorrTotalCondAlg()
     theLArAutoCorrTotalCondAlg.Nsamples=flags.LArCalib.OFC.Nsamples  
     from AthenaCommon.SystemOfUnits import ns
     theLArAutoCorrTotalCondAlg.deltaBunch=int(flags.Beam.BunchSpacing/( 25.*ns)+0.5)
     theLArAutoCorrTotalCondAlg.isSuperCell=flags.LArCalib.isSC
     theLArAutoCorrTotalCondAlg.isMC=False
     theLArAutoCorrTotalCondAlg.LArAutoCorrObjKey="LArAutoCorr"
     theLArAutoCorrTotalCondAlg.LArAutoCorrTotalObjKey="LArPhysAutoCorr"  
     theLArAutoCorrTotalCondAlg.LArOnOffIdMappingObjKey=mapKey
     theLArAutoCorrTotalCondAlg.LArPedestalObjKey="LArPedestal"
     if flags.LArCalib.isSC:
        theLArAutoCorrTotalCondAlg.LArShapeObjKey = "LArShapeSC"
        theLArAutoCorrTotalCondAlg.LArfSamplObjKey = "LArfSamplSC"
        theLArAutoCorrTotalCondAlg.LArMinBiasObjKey = "LArMinBiasSC"
  
     result.addCondAlgo(theLArAutoCorrTotalCondAlg)
     
     result.addEventAlgo(CompFactory.LArAutoCorrAlgToDB(GroupingType=flags.LArCalib.GroupingType,
                                                        NMinbias=nColl,isSC=flags.LArCalib.isSC))
  
     
     #Ntuple writing
     rootfile=flags.LArCalib.Output.ROOTFile
     if rootfile != "":
         result.addEventAlgo(CompFactory.LArAutoCorr2Ntuple(ContainerKey="LArPhysAutoCorr",OffId=True,isSC=flags.LArCalib.isSC,
                                                            BadChanKey=bcKey, AddCalib=True))
         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 RegistrationServices.OutputConditionsAlgConfig import OutputConditionsAlgCfg
     result.merge(OutputConditionsAlgCfg(flags,
                                         outputFile=flags.LArCalib.Output.POOLFile,
                                         ObjectList=["LArAutoCorrComplete#LArPhysAutoCorr#"+flags.LArCalib.PhysAutoCorr.Folder,],
                                         IOVTagList=[PhysAutoCorrTag,],
                                         Run1=flags.LArCalib.IOVStart,
                                         Run2=flags.LArCalib.IOVEnd
                                     ))
  
  
     #RegistrationSvc    
     result.addService(CompFactory.IOVRegistrationSvc(RecreateFolders = False))
     result.getService("IOVDbSvc").DBInstance=""
  
  
     #MC Event selector since we have no input data file 
     from McEventSelector.McEventSelectorConfig import McEventSelectorCfg
     result.merge(McEventSelectorCfg(flags,
                                     RunNumber = flags.LArCalib.Input.RunNumbers[0],
                                     EventsPerRun      = 1,
                                     FirstEvent        = 1,
                                     InitialTimeStamp  = 0,
                                     TimeStampInterval = 1))
  
  
     from PerfMonComps.PerfMonCompsConfig import PerfMonMTSvcCfg
     result.merge(PerfMonMTSvcCfg(flags))
  
     return result
  
  
  
  