egammaAODFixesConfig Namespace Reference

Functions
	getfunc ()
	FixFromAMITag (flags)
	doFixTime (flags, relNum=None)
	runAODFix (flags, correctCluster=True, checkRelMerge=True)
	egammaAODFixesCfg (flags, correctCluster=True)

Function Documentation

doFixTime()

doFixTime	(		flags,
			relNum = None )

Definition at line 102 of file egammaAODFixesConfig.py.

def doFixTime(flags,relNum = None):
    return releaseInRange(flags,"Athena-23.0.12","Athena-23.0.200",relNum) or \
      releaseInRange(flags,"Athena-24.0.0","Athena-24.0.200",relNum) or \
      releaseInRange(flags,"Athena-25.0.0","Athena-25.0.200",relNum)
 

egammaAODFixesCfg()

egammaAODFixesCfg	(		flags,
			correctCluster = True )

Definition at line 155 of file egammaAODFixesConfig.py.

def egammaAODFixesCfg(flags, correctCluster = True):
 
    msg=logging.getLogger("egammaAODFixes")
    #first check if we need to apply this AODFix
    doFix, fixes = runAODFix(flags, correctCluster)
    msg.info('Decision for egamma AOD fix = %s',doFix)
    if not doFix:
        return None
    else: 
        if fixes:
            msg.info('Will apply fixes = %s', ', '.join(fixes))
        else:
            msg.info('Range is ok but there are no fix to apply')
            return None
 
    # I do this because there are in fact two AOD fixes here:
    # one for ambiguity links, one for timing issue (topoetcone + cluster fixes)
    # sometimes, the ambiguity link fix is not needed, need to now this
    getfunc().__name__ = " ".join(fixes)
 
    result=ComponentAccumulator()
 
    # No fix if nothing relevant in input
    hasElectrons = "Electrons" in flags.Input.Collections
    hasPhotons = "Photons" in flags.Input.Collections
    if not hasElectrons and not hasPhotons:
        return None
 
    # TO BE FIXED
    # if only one collection is present, this will crash
 
    #Use the AddressRemappingSvc to rename the input object
    from SGComps.AddressRemappingConfig import InputRenameCfg
    if hasElectrons:
        result.merge(InputRenameCfg("xAOD::ElectronContainer", "Electrons", "old_Electrons"))
        result.merge(InputRenameCfg("xAOD::ElectronAuxContainer", "ElectronsAux.", "old_ElectronsAux."))
    if hasPhotons:
        result.merge(InputRenameCfg("xAOD::PhotonContainer", "Photons", "old_Photons"))
        result.merge(InputRenameCfg("xAOD::PhotonAuxContainer", "PhotonsAux.", "old_PhotonsAux."))
 
    kwargs = dict()
    kwargs['CorrectCluster'] = 'egClusterL2_3Fix' in fixes
    kwargs['FixAmbiguityLinks'] = 'egammaAmbiguityLinksFix' in fixes
    kwargs['FixEGTopoetcone']= 'egammatopoIsoFix' in fixes
    if 'egClusterL2_3Fix' in fixes:
        # First some detector config
        # TO BE UNDERSTOOD : why is this explicitely needed here (without it : ERROR SG::ExcNoCondCont: Can't retrieve CondCont from ReadCondHandle for key ConditionStore+LArBadChannel. Can't retrieve.)
        from LArBadChannelTool.LArBadChannelConfig import LArBadChannelCfg
        result.merge(LArBadChannelCfg(flags))
        #from TileConditions.TileBadChannelsConfig import TileBadChannelsCondAlgCfg
        #result.merge( TileBadChannelsCondAlgCfg(flags, **kwargs) )
        from CaloBadChannelTool.CaloBadChanToolConfig import CaloBadChanToolCfg
        result.popToolsAndMerge( CaloBadChanToolCfg(flags) )
        from LArGeoAlgsNV.LArGMConfig import LArGMCfg
        result.merge(LArGMCfg(flags))
        # then the AODFix itself
        result.merge(InputRenameCfg("xAOD::CaloClusterContainer", "egammaClusters", "old_egammaClusters"))
        result.merge(InputRenameCfg("xAOD::CaloClusterAuxContainer", "egammaClustersAux.", "old_egammaClustersAux."))
        result.merge(InputRenameCfg("CaloClusterCellLinkContainer", "egammaClusters_links", "old_egammaClusters_links"))
        kwargs['CaloDetDescrManager'] = 'CaloDetDescrManager'
        from egammaTools.egammaSwToolConfig import egammaSwToolCfg
        kwargs['ClusterCorrectionTool'] =  result.popToolsAndMerge(egammaSwToolCfg(flags))
        from egammaMVACalib.egammaMVACalibConfig import egammaMVASvcCfg
        kwargs['MVACalibSvc'] = result.getPrimaryAndMerge(egammaMVASvcCfg(flags))
        kwargs['EGammaClustersOutputName'] = flags.Egamma.Keys.Output.CaloClusters
        kwargs['EGammaClustersInputName'] = f'old_{flags.Egamma.Keys.Output.CaloClusters}'
        
        kwargs['IsoLeakCorrectionTool'] = CompFactory.CP.IsolationCorrectionTool(
            LogLogFitForLeakage = True)
 
    #Re-run the required algorithms
    result.addEventAlgo(CompFactory.egammaAODFixes(**kwargs))
 
    return result
 
 
   

FixFromAMITag()

FixFromAMITag

(

flags

)

Definition at line 24 of file egammaAODFixesConfig.py.

def FixFromAMITag(flags):
    doFixFromAMITags = []
    
 
    msg=logging.getLogger("listOfRecoReleases")
    from PyUtils.AMITagHelperConfig import inputAMITags
    listOfTags = inputAMITags(flags)
    listOfRecoTags = []
    nr = 0
    nf = 0
    for ie,e in enumerate(listOfTags):
        # no idea why it can return an empty string...
        msg.debug('tag %s at position %i',e,ie)
        if not len(e):
            continue
        if e[0] == 'r':
            nr += 1
            listOfRecoTags.append(e)
        if e[0] == 'f':
            nf += 1
            listOfRecoTags.append(e)
 
    msg.info('List of tags %s %s %s',' '.join(listOfTags),', of reco tags ',' '.join(listOfRecoTags))
    # use case : a DRAW file was produced at T0 (f-tag), and recoed in reprocessing (r-tag)
    if nf >= 1 and nr >= 1:
        msg.info('Both r- and f-tags are present, will remove the f ones')
    listOfRecoTags = [ e for e in listOfRecoTags if e[0] == 'r' ]
    listOfRecoTags_noMerge = [ ]
    has_been_merged = False
    
 
    if not listOfRecoTags:
        msg.info("no reco tags")
        doFixFromAMITags.append((True,True))
        return doFixFromAMITags, listOfRecoTags
 
 
    filename_merging = PathResolver.FindCalibFile("egammaAlgs/Merging_reco_tag.pkl") 
    for e in listOfRecoTags:
        msg.info('Testing %s',e)
        with open(filename_merging, "rb") as f:
            releases = pickle.load(f)
            if e in releases:
                msg.info('it is a merging tag; skip')
                has_been_merged = True
                continue
        if not  has_been_merged:
            listOfRecoTags_noMerge.append(e)
 
        
    if not listOfRecoTags_noMerge: 
        msg.info("no reco tags after merge removal")
        doFixFromAMITags.append((True,True))
        return doFixFromAMITags, listOfRecoTags_noMerge
    
    listOfRecoTags_noMerge_set= set(listOfRecoTags_noMerge)
    msg.info('remaining tag after removing merge tag %s',listOfRecoTags_noMerge)
    
    filename_timingTag = PathResolver.FindCalibFile("egammaAlgs/Timing_fix_reco_tag.pkl") 
    filename_AmbiguityTag = PathResolver.FindCalibFile("egammaAlgs/Ambiguity_fix_reco_tag.pkl") 
    
    doFix_timing = False
    doFix_amb = False
    with open(filename_timingTag, "rb") as f:
        TimingTag = pickle.load(f)
        if(not listOfRecoTags_noMerge_set.intersection(TimingTag)):
            doFix_timing = True
    with open(filename_AmbiguityTag, "rb") as f:
        AmbiguityTag = pickle.load(f)
        if(listOfRecoTags_noMerge_set.intersection(AmbiguityTag)):
            doFix_amb = True
    
            
    doFixFromAMITags.append((doFix_timing,doFix_amb))
        
    return  doFixFromAMITags,listOfRecoTags_noMerge
 
 

getfunc()

getfunc

(

)

Definition at line 12 of file egammaAODFixesConfig.py.

def getfunc():
    from inspect import currentframe, getframeinfo
    caller = currentframe().f_back
    func_name = getframeinfo(caller)[2]
    caller = caller.f_back
    func = caller.f_locals.get(
            func_name, caller.f_globals.get(
                func_name))
 
    return func
 
@AccumulatorCache

runAODFix()

runAODFix	(		flags,
			correctCluster = True,
			checkRelMerge = True )

Definition at line 107 of file egammaAODFixesConfig.py.

def runAODFix(flags, correctCluster = True, checkRelMerge = True):
 
    msg=logging.getLogger("GetDecisionToRunAODFix")
 
    ALToFix = "egammaAmbiguityLinksFix" not in flags.Input.AODFixesDone
    TimeToFix = "egammatopoIsoFix" not in flags.Input.AODFixesDone
 
    if flags.GeoModel.Run >= LHCPeriod.Run3:
        doFix_meta = doFixTime(flags) and TimeToFix
    else:
        doFix_meta=False
        checkRelMerge=False #no need to cross-check when a run 2 or run 1 are used
    doAmbiguityFix_meta = releaseInRange(flags,"Athena-24.0.0","Athena-24.0.83") and ALToFix
 
    doFix = doFix_meta or doAmbiguityFix_meta
    doFix_time = doFix_meta
    doAmbiguityFix = doAmbiguityFix_meta
 
 
    if checkRelMerge:
        doFixFromAMITags = []
        doFixFromAMITags, inputReleaseFromAMITags = FixFromAMITag(flags)
        if inputReleaseFromAMITags:
            msg.info('doFix from AMI tags = %s',doFixFromAMITags)
            for ie, e in enumerate(doFixFromAMITags):
                if e[0] != doFix_time or e[1] != doAmbiguityFix:
                    msg.warning('Inconsistent information from AMI reco tag release %s and input release %s', \
                                inputReleaseFromAMITags[ie],flags.Input.Release)
                    if ie ==0:
                        msg.warning('if no flag , will use the info collected from AMI')
                        doFix_time = e[0] and TimeToFix
                        doAmbiguityFix = e[1] and ALToFix
                        doFix = doFix_time or doAmbiguityFix    
 
    fixes = set()
    if doFix:
        if doAmbiguityFix:
            fixes.add('egammaAmbiguityLinksFix')
        # no timing cut in HI reco, so not these fixes
        if doFix_time and not flags.Reco.EnableHI:
            fixes.add('egammatopoIsoFix')
            if correctCluster:
                fixes.add('egClusterL2_3Fix')
        else:
            doFix = doAmbiguityFix
 
    return doFix, fixes