SlimmingHelper.SlimmingHelper Class Reference

Collaboration diagram for SlimmingHelper.SlimmingHelper:

Public Member Functions
	__init__ (self, inputName, flags, **kwargs)
	__setattr__ (self, name, value)
	CheckList (self, masterList)
	AppendContentToStream (self, Stream)
	GetItemList (self)
	BuildFinalItemList (self)
	GetWholeContentItems (self, collection)
	GetSmartItems (self, collectionName)
	GetKinematicsItems (self, collectionName)
	GetExtraItems (self, userInput)
	ValidateStaticContent (self, item)
	CheckDoubleTrigAuxInstruction (self, aux)

Public Attributes
	name = inputName
	FinalItemList = lockable_list()
	StaticContent = lockable_list()
	ExtraVariables = lockable_list()
	SmartCollections = lockable_list()
masterItemList.extend(self.GetWholeContentItems(item))	AllVariables = lockable_list()
dict	AppendToDictionary = {}
	flags = flags
bool	IncludeTriggerNavigation = True
bool	IncludeAdditionalTriggerContent = False
bool	IncludeMuonTriggerContent = False
bool	IncludeEGammaTriggerContent = False
bool	IncludeJetTriggerContent = False
bool	IncludeTrackingTriggerContent = False
bool	IncludeTauTriggerContent = False
bool	IncludeDiTauTriggerContent = False
bool	IncludeEtMissTriggerContent = False
bool	IncludeBJetTriggerContent = False
bool	IncludeBJetTriggerByYearContent = False
bool	IncludeBPhysTriggerContent = False
bool	IncludeMinBiasTriggerContent = False
str	IncludeFullTriggerEDMLevel = ""
bool	OverrideJetTriggerContentWithTLAContent = False
	NamesAndTypes = buildNamesAndTypes(kwargs["NamesAndTypes"])
	theHandler = ContentHandler(self.name+"Handler",self.NamesAndTypes)

Protected Attributes
bool	_locked = True

Detailed Description

Definition at line 78 of file SlimmingHelper.py.

Constructor & Destructor Documentation

__init__()

SlimmingHelper.SlimmingHelper.__init__	(		self,
			inputName,
			flags,
		**	kwargs )

Definition at line 79 of file SlimmingHelper.py.

        def __init__(self, inputName, flags, **kwargs):
                self.__dict__["_locked"] = False
                self.name = inputName
                self.FinalItemList = lockable_list() # The final item list that will be appended to the output stream
                self.StaticContent = lockable_list() # Content added explicitly via old-style content lists
                self.ExtraVariables = lockable_list() # Content added by users via variable names (dictionary type:[item1,item,..,N])
                # Smart slimming (only variables needed for CP + kinematics)
                self.SmartCollections = lockable_list()
                self.AllVariables = lockable_list() # Containers for which all branches should be kept
                self.AppendToDictionary = {}
                self.flags = flags
                self.IncludeTriggerNavigation = True
                self.IncludeAdditionalTriggerContent = False
                self.IncludeMuonTriggerContent = False
                self.IncludeEGammaTriggerContent = False
                self.IncludeJetTriggerContent = False
                self.IncludeTrackingTriggerContent = False
                self.IncludeTauTriggerContent = False
                self.IncludeDiTauTriggerContent = False
                self.IncludeEtMissTriggerContent = False
                self.IncludeBJetTriggerContent = False
                self.IncludeBJetTriggerByYearContent = False
                self.IncludeBPhysTriggerContent = False
                self.IncludeMinBiasTriggerContent = False
                self.IncludeFullTriggerEDMLevel = "" # Specify an AllowedOutputFormat from TriggerEDM.py
                self.OverrideJetTriggerContentWithTLAContent = False
                # Choice of whether user provided a typed container list or not (CA vs non-CA) 
                if "NamesAndTypes" in kwargs.keys(): self.NamesAndTypes = buildNamesAndTypes(kwargs["NamesAndTypes"])
                else: self.NamesAndTypes = buildNamesAndTypes()
                self.theHandler = ContentHandler(self.name+"Handler",self.NamesAndTypes)
 

Member Function Documentation

__setattr__()

SlimmingHelper.SlimmingHelper.__setattr__	(		self,
			name,
			value )

Definition at line 111 of file SlimmingHelper.py.

        def __setattr__(self,name,value):
                if self._locked is True:
                        msg.error("Attempting to Modify SlimmingHelper "+self.name+" After AppendContentToStream has Been Called")
                        raise RuntimeError("Late Modification to SlimmingHelper, do not modifiy after calling AppendContentToStream")
                elif type(value)==list:
                        self.__dict__[name] = lockable_list(value)
                else:
                        self.__dict__[name] = value
 

AppendContentToStream()

SlimmingHelper.SlimmingHelper.AppendContentToStream	(		self,
			Stream )

Definition at line 136 of file SlimmingHelper.py.

        def AppendContentToStream(self,Stream):
                # Check if the SlimmingHelper is locked. 
                # If it is, just loop over the items and append. 
                # If not, build the item list and then append.
                if self._locked is False:
                        self.BuildFinalItemList()
                for item in self.FinalItemList:
                        Stream.AddItem(item)
 

BuildFinalItemList()

SlimmingHelper.SlimmingHelper.BuildFinalItemList

(

self

)

Definition at line 154 of file SlimmingHelper.py.

        def BuildFinalItemList(self):
                # Master item list: all items that must be passed to the ContentHandler for processing
                # This will now be filled
                masterItemList = []
                # All variables list: where all variables are requested, no variable lists are needed
                # This list ensures that variables are not added individually in such cases
                allVariablesList = []
                self.AllVariables += CompulsoryDynamicContent
                # Add all-variable collections
                if len(self.AllVariables)>0:
                        for item in self.AllVariables: masterItemList.extend(self.GetWholeContentItems(item))
                for item in masterItemList:
                        if "Aux." in item:
                                allVariablesList.append(item)
 
                # Trigger objects: add them by hand to the smart collection list (to keep the previous interface)
                triggerContent = False
 
                if (self.IncludeAdditionalTriggerContent is True):
                        triggerContent = True
 
                if (self.IncludeMuonTriggerContent is True):
                        triggerContent = True
                        self.SmartCollections.append("HLT_xAOD__MuonContainer_MuonEFInfo")
 
                if (self.IncludeEGammaTriggerContent is True):
                        triggerContent = True
                        self.SmartCollections.append("HLT_xAOD__PhotonContainer_egamma_Photons")
 
                if (self.IncludeJetTriggerContent is True):
                        triggerContent = True
                        self.SmartCollections.append("HLT_xAOD__JetContainer_a4tcemsubjesFS")
                        self.SmartCollections.append("HLT_AntiKt4EMPFlowJets_subresjesgscIS_ftf") # Run 3 jet collections
                        from DerivationFrameworkCore.JetTriggerFixContent import JetTriggerFixContent
                        for item in JetTriggerFixContent:
                                self.FinalItemList.append(item)
 
                if (self.IncludeTrackingTriggerContent is True):
                        triggerContent = True
                        self.SmartCollections.append("HLT_IDVertex_FS")
                        self.SmartCollections.append("HLT_IDTrack_FS_FTF")
 
                if (self.IncludeEtMissTriggerContent is True):
                        triggerContent = True
                        self.SmartCollections.append("HLT_xAOD__TrigMissingETContainer_TrigEFMissingET")
                        from DerivationFrameworkCore.EtMissTriggerFixContent import EtMissTriggerFixContent
                        for item in EtMissTriggerFixContent:
                                self.FinalItemList.append(item)
                if (self.IncludeDiTauTriggerContent is True):
                        triggerContent = True
                        self.SmartCollections.append("HLT_DiTauJets")
 
                if (self.IncludeTauTriggerContent is True):
                        triggerContent = True
                        if self.flags.Trigger.EDMVersion == 2: 
                            self.SmartCollections.append("HLT_xAOD__TauJetContainer_TrigTauRecMerged")
                        elif self.flags.Trigger.EDMVersion == 3:
                            self.SmartCollections.append("HLT_TrigTauRecMerged_MVA")
 
                if (self.IncludeBJetTriggerContent is True):
                        triggerContent = True
                        self.SmartCollections.append("HLT_xAOD__BTaggingContainer_HLTBjetFex")
 
                if (self.IncludeBJetTriggerByYearContent is True):
                        triggerContent = True
                        self.SmartCollections.append("HLT_BJetTriggerByYearContent")
 
                if (self.IncludeBPhysTriggerContent is True):
                        triggerContent = True
                        self.SmartCollections.append("HLT_xAOD__TrigBphysContainer_EFBMuMuFex")
 
                if (self.IncludeMinBiasTriggerContent is True):
                        triggerContent = True
                        self.SmartCollections.append("HLT_xAOD__TrigVertexCountsContainer_vertexcounts")
 
                if (self.IncludeFullTriggerEDMLevel):
                        triggerContent = True
                        self.SmartCollections.append("HLT_FULL_EDM")
 
                # Smart items
                if len(self.SmartCollections)>0:
                        for collection in self.SmartCollections:
                                masterItemList.extend(self.GetSmartItems(collection))
 
                # Run some basic tests to prevent clashes with CompulsoryContent content
                self.CheckList(masterItemList)
 
                # Add extra variables
                if len(self.ExtraVariables)>0:
                        for item in self.ExtraVariables:
                                masterItemList.extend(self.GetExtraItems(item))
 
                #Add on-the-fly containers to the dictionary
                for _cont,_type in ContainersOnTheFly(self.flags):
                        if _cont not in self.AppendToDictionary:
                                self.AppendToDictionary[_cont]=_type
 
                # Process the master list...
 
                # Main containers (this is a simple list of lines, one per container X collection)
                mainEntries = []
                # Aux items (this is a dictionary: collection name and list of aux variables)
                auxEntries = {}
                self.theHandler.AppendToDictionary = self.AppendToDictionary
                mainEntries,auxEntries = self.theHandler.GetContent(masterItemList,allVariablesList)
 
                # Add processed items to the stream
                excludedAuxData = "-clusterAssociation.-PseudoJet"
                excludedAuxEntries= [entry.strip("-") for entry in excludedAuxData.split(".")]
                for item in mainEntries:
                        self.FinalItemList.append(item)
                for item in auxEntries.keys():
                        theDictionary = self.NamesAndTypes.copy()
                        theDictionary.update (self.AppendToDictionary)
                        if item in theDictionary.keys():
                                if (theDictionary[item]=='xAOD::JetAuxContainer'):
                                        entry = "xAOD::JetAuxContainer#"+item+"."
                                elif (theDictionary[item]=='xAOD::ShallowAuxContainer'):
                                        entry = "xAOD::ShallowAuxContainer#"+item+"."
                                elif (theDictionary[item]=='xAOD::MissingETAuxAssociationMap'):
                                        entry = "xAOD::MissingETAuxAssociationMap#"+item+"."
                                elif (theDictionary[item]=='xAOD::JetTrigAuxContainer'):
                                        entry = "xAOD::JetTrigAuxContainer#"+item+"."
                                elif ("AuxInfo" in theDictionary[item]):
                                        entry = "xAOD::AuxInfoBase!#"+item+"."
                                else:
                                        entry = "xAOD::AuxContainerBase!#"+item+"."
                                for element in auxEntries[item]:
                                        #Skip anything that shouldn't be written out to a DAOD for tracks or jets
                                        if ('xAOD::TrackParticleContainer' in theDictionary[item]) and (element in excludedAuxEntries): continue
                                        if ('xAOD::JetAuxContainer' in theDictionary[item]) and (element in excludedAuxEntries): continue
                                        length = len(auxEntries[item])
                                        if (element==(auxEntries[item])[length-1]):
                                                entry += element
                                        else:
                                                entry += element+"."
                                if ('xAOD::TrackParticleContainer' in theDictionary[item] and auxEntries[item]==""):
                                        entry+=excludedAuxData
                                if ('xAOD::JetAuxContainer' in theDictionary[item] and auxEntries[item]=="" and self.CheckDoubleTrigAuxInstruction(item)):
                                        entry+=excludedAuxData
                                self.FinalItemList.append(entry)
 
                # Add compulsory items not covered by smart slimming (so no expansion)
                for item in CompulsoryContent:
                        self.FinalItemList.append(item)
 
                # non xAOD collections for MinBias
                if (self.IncludeMinBiasTriggerContent is True):
                        from DerivationFrameworkCore.MinBiasTrigger_nonxAOD_Content import MinBiasTrigger_nonxAOD_Content
                        for item in MinBiasTrigger_nonxAOD_Content:
                                self.FinalItemList.append(item)
 
                if (triggerContent and self.IncludeTriggerNavigation):
                        # Run2
                        for item in CompulsoryTriggerNavigation:
                                self.FinalItemList.append(item)
                        # Run3
                        from TrigDecisionTool.TrigDecisionToolHelpers import possible_keys
                        for item in possible_keys:
                                if item == "HLTNav_Summary": # This is not a compact navigation summary collection, unlike the others in this list
                                        continue
                                self.FinalItemList.append('xAOD::TrigCompositeContainer#'+item)
                                self.FinalItemList.append('xAOD::TrigCompositeAuxContainer#'+item+'Aux.')
 
                # Add non-xAOD and on-the-fly content (not covered by smart slimming so no expansion)
                badItemsWildcards = []
                badItemsXAOD = []
                for item in self.StaticContent:
                        if (self.ValidateStaticContent(item)=="OK"):
                                self.FinalItemList.append(item)
                        if (self.ValidateStaticContent(item)=="WILDCARD"):
                                badItemsWildcards.append(item)
                        if (self.ValidateStaticContent(item)=="XAOD"):
                                badItemsXAOD.append(item)
                if (len(badItemsWildcards)>0):
                        msg.error("These static items contain wildcards: not permitted")
                        print (badItemsWildcards)
                        raise RuntimeError("Static content list contains wildcards")
                if (len(badItemsXAOD)>0):
                        msg.error("These static items are xAOD collections: not permitted")
                        print (badItemsXAOD)
                        raise RuntimeError("Static content list contains xAOD collections")
                #Prevent any more modifications As they will be completely ignored, and hard to debug
                self.FinalItemList.lock()
                self.StaticContent.lock()
                self.ExtraVariables.lock()
                self.SmartCollections.lock()
                self.AllVariables.lock()
                self._locked=True
 

CheckDoubleTrigAuxInstruction()

SlimmingHelper.SlimmingHelper.CheckDoubleTrigAuxInstruction	(		self,
			aux )

Definition at line 659 of file SlimmingHelper.py.

        def CheckDoubleTrigAuxInstruction(self, aux):
                if self.IncludeFullTriggerEDMLevel and 'HLT_AntiKt4EMPFlowJets_subresjesgscIS_ftf_bJetsAux' in aux:
                        return False
                return True

CheckList()

SlimmingHelper.SlimmingHelper.CheckList	(		self,
			masterList )

Definition at line 121 of file SlimmingHelper.py.

        def CheckList(self,masterList):
                conflicted_items=[]
                for item in CompulsoryContent:
                        if item.endswith("#*"):
                                compare_str=item[:-2].replace("xAOD::","")
                                for m_item in masterList:
                                        if m_item.startswith(compare_str) and m_item.replace("Aux.","") not in CompulsoryDynamicContent:
                                                conflicted_items.append(m_item)
                if len(conflicted_items)!=0:
                        msg.error("Slimming list contains " +str(conflicted_items)+" which are already included in compulsory content: please remove these items from slimming list")
                        raise RuntimeError("Conflict in Slimming List and Compulsory Content")
 
 

GetExtraItems()

SlimmingHelper.SlimmingHelper.GetExtraItems	(		self,
			userInput )

Definition at line 624 of file SlimmingHelper.py.

        def GetExtraItems(self,userInput):
                # Build up a content list in the same style as is produced by the PrintStats
                splitup = userInput.split(".")
                auxContainerName = splitup[0]+"Aux"
                items = []
                items.append(splitup[0])
                auxLine = ""
                length = len(splitup)
                for string in splitup:
                        if string==splitup[0]:
                                auxLine = auxContainerName+"."
                                continue
                        if string==splitup[length-1]:
                                auxLine = auxLine+string
                        else:
                                auxLine = auxLine+string+"."
                items.append(auxLine)
                return items
 

GetItemList()

SlimmingHelper.SlimmingHelper.GetItemList

(

self

)

Definition at line 146 of file SlimmingHelper.py.

        def GetItemList(self):
                # Check if the SlimmingHelper is locked. 
                # If it is, just return the item list. 
                # If not, build the item list and then return it.
                if self._locked is False:
                        self.BuildFinalItemList()
                return(self.FinalItemList)
 

GetKinematicsItems()

SlimmingHelper.SlimmingHelper.GetKinematicsItems	(		self,
			collectionName )

Definition at line 617 of file SlimmingHelper.py.

        def GetKinematicsItems(self,collectionName):
                # Content lines in the same style as is produced by the PrintStats
                kinematicsLine = collectionName+"Aux."+"pt.eta.phi.m"
                items = [collectionName,kinematicsLine]
                return items
 

GetSmartItems()

SlimmingHelper.SlimmingHelper.GetSmartItems	(		self,
			collectionName )

Definition at line 353 of file SlimmingHelper.py.

        def GetSmartItems(self,collectionName):
                # Look up what is needed for this container type
                items = []
                if collectionName not in FullListOfSmartContainers(self.flags):
                        raise RuntimeError("Smart slimming container "+collectionName+" does not exist or does not have a smart slimming list")
                if collectionName=="EventInfo":
                        from DerivationFrameworkCore.EventInfoContent import EventInfoContent
                        items.extend(EventInfoContent)
                elif collectionName=="Electrons":
                        from DerivationFrameworkEGamma.ElectronsCPContent import ElectronsCPContent
                        items.extend(ElectronsCPContent)
                elif collectionName=="LRTElectrons":
                        from DerivationFrameworkEGamma.LargeD0ElectronsCPContent import LargeD0ElectronsCPContent
                        items.extend(LargeD0ElectronsCPContent)
                elif collectionName=="Photons":
                        from DerivationFrameworkEGamma.PhotonsCPContent import PhotonsCPContent
                        items.extend(PhotonsCPContent)
                elif collectionName=="Muons":
                        if not self.flags:
                            raise RuntimeError("We're in the era of component accumulator. Please setup your job with CA if you want to have muons")
                        from DerivationFrameworkMuons.MuonsCommonConfig import MuonCPContentCfg
                        items.extend(MuonCPContentCfg(self.flags))
                elif collectionName=="MuonsLRT":
                        if not self.flags:
                            raise RuntimeError("We're in the era of component accumulator. Please setup your job with CA if you want to have muons")
                        from DerivationFrameworkMuons.MuonsCommonConfig import MuonCPContentLRTCfg
                        items.extend(MuonCPContentLRTCfg(self.flags))
                elif collectionName=="TauJets":
                        from DerivationFrameworkTau.TauJetsCPContent import TauJetsCPContent
                        items.extend(TauJetsCPContent)
                elif collectionName=="DiTauJets":
                        from DerivationFrameworkTau.DiTauJetsCPContent import DiTauJetsCPContent
                        items.extend(DiTauJetsCPContent)
                elif collectionName=="DiTauJetsLowPt":
                        from DerivationFrameworkTau.DiTauJetsCPContent import DiTauJetsLowPtCPContent
                        items.extend(DiTauJetsLowPtCPContent)
                elif collectionName=="TauJets_MuonRM":
                        from DerivationFrameworkTau.TauJets_LepRMCPContent import TauJets_MuonRMCPContent
                        if "TauJets_MuonRM" not in self.AppendToDictionary:
                                self.AppendToDictionary["TauJets_MuonRM"]                          = 'xAOD::TauJetContainer'
                                self.AppendToDictionary["TauJets_MuonRMAux"]                       = 'xAOD::TauJetAuxContainer'
                                self.AppendToDictionary["TauTracks_MuonRM"]                        = 'xAOD::TauTrackContainer'
                                self.AppendToDictionary["TauTracks_MuonRMAux"]                     = 'xAOD::TauTrackAuxContainer'
                                self.AppendToDictionary["TauSecondaryVertices_MuonRM"]             = 'xAOD::VertexContainer'
                                self.AppendToDictionary["TauSecondaryVertices_MuonRMAux"]          = 'xAOD::VertexAuxContainer'
                                self.AppendToDictionary["TauNeutralParticleFlowObjects_MuonRM"]    = 'xAOD::PFOContainer'
                                self.AppendToDictionary["TauNeutralParticleFlowObjects_MuonRMAux"] = 'xAOD::PFOAuxContainer'
                        items.extend(TauJets_MuonRMCPContent)
                elif collectionName=="TauJets_EleRM":
                        from DerivationFrameworkTau.TauJets_LepRMCPContent import TauJets_EleRMCPContent
                        items.extend(TauJets_EleRMCPContent)
                elif collectionName=="MET_Baseline_AntiKt4EMTopo":
                        from DerivationFrameworkJetEtMiss.MET_Baseline_AntiKt4EMTopoCPContent import MET_Baseline_AntiKt4EMTopoCPContent
                        items.extend(MET_Baseline_AntiKt4EMTopoCPContent)
                elif collectionName=="MET_Baseline_AntiKt4EMPFlow":
                        from DerivationFrameworkJetEtMiss.MET_Baseline_AntiKt4EMPFlowCPContent import MET_Baseline_AntiKt4EMPFlowCPContent
                        items.extend(MET_Baseline_AntiKt4EMPFlowCPContent)
                elif collectionName=="AntiKt2TruthJets":
                        from DerivationFrameworkJetEtMiss.AntiKt2TruthJetsCPContent import AntiKt2TruthJetsCPContent
                        items.extend(AntiKt2TruthJetsCPContent)
                elif collectionName=="AntiKt4TruthJets":
                        from DerivationFrameworkJetEtMiss.AntiKt4TruthJetsCPContent import AntiKt4TruthJetsCPContent
                        items.extend(AntiKt4TruthJetsCPContent)
                elif collectionName=="AntiKt4TruthWZJets":
                        from DerivationFrameworkJetEtMiss.AntiKt4TruthWZJetsCPContent import AntiKt4TruthWZJetsCPContent
                        items.extend(AntiKt4TruthWZJetsCPContent)
                elif collectionName=="AntiKt4TruthDressedWZJets":
                        from DerivationFrameworkJetEtMiss.AntiKt4TruthDressedWZJetsCPContent import AntiKt4TruthDressedWZJetsCPContent
                        items.extend(AntiKt4TruthDressedWZJetsCPContent)
                elif collectionName=="AntiKt2LCTopoJets":
                        from DerivationFrameworkJetEtMiss.AntiKt2LCTopoJetsCPContent import AntiKt2LCTopoJetsCPContent
                        items.extend(AntiKt2LCTopoJetsCPContent)
                elif collectionName=="AntiKt4LCTopoJets":
                        from DerivationFrameworkJetEtMiss.AntiKt4LCTopoJetsCPContent import AntiKt4LCTopoJetsCPContent
                        items.extend(AntiKt4LCTopoJetsCPContent)
                elif collectionName=="AntiKt4EMTopoJets":
                        from DerivationFrameworkJetEtMiss.AntiKt4EMTopoJetsCPContent import AntiKt4EMTopoJetsCPContent
                        items.extend(AntiKt4EMTopoJetsCPContent)
                        from DerivationFrameworkFlavourTag.BTaggingContent import BTaggingStandardContent
                        items.extend(BTaggingStandardContent(self.flags, "AntiKt4EMTopoJets"))
                elif collectionName=="AntiKt4EMTopoLowPtJets":
                        from DerivationFrameworkJetEtMiss.AntiKt4EMTopoLowPtJetsCPContent import AntiKt4EMTopoLowPtJetsCPContent
                        items.extend(AntiKt4EMTopoLowPtJetsCPContent)
                elif collectionName=="AntiKt4EMTopoNoPtCutJets":
                        from DerivationFrameworkJetEtMiss.AntiKt4EMTopoNoPtCutJetsCPContent import AntiKt4EMTopoNoPtCutJetsCPContent
                        items.extend(AntiKt4EMTopoNoPtCutJetsCPContent)
                elif collectionName=="AntiKt4EMPFlowJets":
                        from DerivationFrameworkJetEtMiss.AntiKt4EMPFlowJetsCPContent import AntiKt4EMPFlowJetsCPContent
                        items.extend(AntiKt4EMPFlowJetsCPContent)
                        from DerivationFrameworkFlavourTag.BTaggingContent import BTaggingStandardContent
                        items.extend(BTaggingStandardContent(self.flags, "AntiKt4EMPFlowJets"))
                elif collectionName=="AntiKt4EMPFlowJets_FTAG_expert":
                        from DerivationFrameworkFlavourTag.BTaggingContent import BTaggingExpertContent
                        items.extend(BTaggingExpertContent(self.flags, "AntiKt4EMPFlowJets"))
                elif collectionName=="AntiKt4EMPFlowLowPtJets":
                        from DerivationFrameworkJetEtMiss.AntiKt4EMPFlowLowPtJetsCPContent import AntiKt4EMPFlowLowPtJetsCPContent
                        items.extend(AntiKt4EMPFlowLowPtJetsCPContent)
                elif collectionName=="AntiKt4EMPFlowByVertexJets":
                        from DerivationFrameworkJetEtMiss.AntiKt4EMPFlowByVertexJetsCPContent import AntiKt4EMPFlowByVertexJetsCPContent
                        items.extend(AntiKt4EMPFlowByVertexJetsCPContent)
                elif collectionName=="AntiKt4UFOCSSKJets":
                        from DerivationFrameworkJetEtMiss.AntiKt4UFOCSSKJetsCPContent import AntiKt4UFOCSSKJetsCPContent
                        items.extend(AntiKt4UFOCSSKJetsCPContent)
                        from DerivationFrameworkFlavourTag.BTaggingContent import BTaggingStandardContent
                        items.extend(BTaggingStandardContent(self.flags, "AntiKt4UFOCSSKJets"))
                elif collectionName=="AntiKt4UFOCSSKJets_FTAG_expert":
                        from DerivationFrameworkFlavourTag.BTaggingContent import BTaggingExpertContent
                        items.extend(BTaggingExpertContent(self.flags, "AntiKt4UFOCSSKJets"))
                elif collectionName=="AntiKt4UFOCSSKLowPtJets":
                        from DerivationFrameworkJetEtMiss.AntiKt4UFOCSSKLowPtJetsCPContent import AntiKt4UFOCSSKLowPtJetsCPContent
                        items.extend(AntiKt4UFOCSSKLowPtJetsCPContent)
                elif collectionName=="AntiKt10TruthJets":
                        from DerivationFrameworkJetEtMiss.AntiKt10TruthJetsCPContent import AntiKt10TruthJetsCPContent
                        items.extend(AntiKt10TruthJetsCPContent)
                elif collectionName=="AntiKt10TruthWZJets":
                        from DerivationFrameworkJetEtMiss.AntiKt10TruthWZJetsCPContent import AntiKt10TruthWZJetsCPContent
                        items.extend(AntiKt10TruthWZJetsCPContent)
                elif collectionName=="AntiKt10LCTopoJets":
                        from DerivationFrameworkJetEtMiss.AntiKt10LCTopoJetsCPContent import AntiKt10LCTopoJetsCPContent
                        items.extend(AntiKt10LCTopoJetsCPContent)
                elif collectionName=="AntiKt10TrackCaloClusterJets":
                        from DerivationFrameworkJetEtMiss.AntiKt10TrackCaloClusterJetsCPContent import AntiKt10TrackCaloClusterJetsCPContent
                        items.extend(AntiKt10TrackCaloClusterJetsCPContent)
                elif collectionName=="AntiKt10UFOCSSKJets":
                        from DerivationFrameworkJetEtMiss.AntiKt10UFOCSSKJetsCPContent import AntiKt10UFOCSSKJetsCPContent
                        items.extend(AntiKt10UFOCSSKJetsCPContent)
                elif collectionName=="AntiKt10UFOCHSJets":
                        from DerivationFrameworkJetEtMiss.AntiKt10UFOCHSJetsCPContent import AntiKt10UFOCHSJetsCPContent
                        items.extend(AntiKt10UFOCHSJetsCPContent)
                elif collectionName=="AntiKt10TruthTrimmedPtFrac5SmallR20Jets":
                        from DerivationFrameworkJetEtMiss.AntiKt10TruthTrimmedPtFrac5SmallR20JetsCPContent import AntiKt10TruthTrimmedPtFrac5SmallR20JetsCPContent
                        items.extend(AntiKt10TruthTrimmedPtFrac5SmallR20JetsCPContent)
                elif collectionName=="AntiKt10LCTopoTrimmedPtFrac5SmallR20Jets":
                        from DerivationFrameworkJetEtMiss.AntiKt10LCTopoTrimmedPtFrac5SmallR20JetsCPContent import AntiKt10LCTopoTrimmedPtFrac5SmallR20JetsCPContent
                        items.extend(AntiKt10LCTopoTrimmedPtFrac5SmallR20JetsCPContent)
                elif collectionName=="AntiKt10TrackCaloClusterTrimmedPtFrac5SmallR20Jets":
                        from DerivationFrameworkJetEtMiss.AntiKt10TrackCaloClusterTrimmedPtFrac5SmallR20JetsCPContent import AntiKt10TrackCaloClusterTrimmedPtFrac5SmallR20JetsCPContent
                        if "AntiKt10TrackCaloClusterTrimmedPtFrac5SmallR20Jets" not in self.AppendToDictionary:
                                self.AppendToDictionary["AntiKt10TrackCaloClusterTrimmedPtFrac5SmallR20Jets"]='xAOD::JetContainer'
                                self.AppendToDictionary["AntiKt10TrackCaloClusterTrimmedPtFrac5SmallR20JetsAux"]='xAOD::JetAuxContainer'
                        items.extend(AntiKt10TrackCaloClusterTrimmedPtFrac5SmallR20JetsCPContent)
                elif collectionName=="AntiKt10TruthSoftDropBeta100Zcut10Jets":
                        from DerivationFrameworkJetEtMiss.AntiKt10TruthSoftDropBeta100Zcut10JetsCPContent import AntiKt10TruthSoftDropBeta100Zcut10JetsCPContent
                        items.extend(AntiKt10TruthSoftDropBeta100Zcut10JetsCPContent)
                elif collectionName=="AntiKt10TruthDressedWZSoftDropBeta100Zcut10Jets":
                        from DerivationFrameworkJetEtMiss.AntiKt10TruthDressedWZSoftDropBeta100Zcut10JetsCPContent import AntiKt10TruthDressedWZSoftDropBeta100Zcut10JetsCPContent
                        items.extend(AntiKt10TruthDressedWZSoftDropBeta100Zcut10JetsCPContent)
                elif collectionName=="AntiKt10UFOCHSSoftDropBeta100Zcut10Jets":
                        from DerivationFrameworkJetEtMiss.AntiKt10UFOCHSSoftDropBeta100Zcut10JetsCPContent import AntiKt10UFOCHSSoftDropBeta100Zcut10JetsCPContent
                        items.extend(AntiKt10UFOCHSSoftDropBeta100Zcut10JetsCPContent)
                elif collectionName=="AntiKt10UFOCSSKSoftDropBeta100Zcut10Jets":
                        from DerivationFrameworkJetEtMiss.AntiKt10UFOCSSKSoftDropBeta100Zcut10JetsCPContent import AntiKt10UFOCSSKSoftDropBeta100Zcut10JetsCPContent
                        items.extend(AntiKt10UFOCSSKSoftDropBeta100Zcut10JetsCPContent)
                        from DerivationFrameworkFlavourTag.BTaggingContent import BTaggingLargeRContent
                        items.extend(BTaggingLargeRContent(self.flags, "AntiKt10UFOCSSKSoftDropBeta100Zcut10Jets"))
                elif collectionName=="AntiKtVR30Rmax4Rmin02PV0TrackJets":
                        from DerivationFrameworkJetEtMiss.AntiKtVR30Rmax4Rmin02PV0TrackJetsCPContent import AntiKtVR30Rmax4Rmin02PV0TrackJetsCPContent
                        items.extend(AntiKtVR30Rmax4Rmin02PV0TrackJetsCPContent)
                elif collectionName=="InDetTrackParticles":
                        from DerivationFrameworkInDet.InDetTrackParticlesCPContent import InDetTrackParticlesCPContent
                        items.extend(InDetTrackParticlesCPContent)
                        if self.flags.GeoModel.Run >= LHCPeriod.Run4:
                            from DerivationFrameworkInDet.InDetTrackParticlesCPContentRun4 import InDetTrackParticlesCPContentRun4
                            items.extend(InDetTrackParticlesCPContentRun4)
                elif collectionName=="InDetPseudoTrackParticles":
                        from DerivationFrameworkInDet.InDetPseudoTrackParticlesCPContent import InDetPseudoTrackParticlesCPContent
                        items.extend(InDetPseudoTrackParticlesCPContent)
                elif collectionName=="InDetReplacedWithPseudoTrackParticles":
                        from DerivationFrameworkInDet.InDetReplacedWithPseudoTrackParticlesCPContent import InDetReplacedWithPseudoTrackParticlesCPContent
                        items.extend(InDetReplacedWithPseudoTrackParticlesCPContent)
                elif collectionName=="InDetReplacedWithPseudoFromBTrackParticles":
                        from DerivationFrameworkInDet.InDetReplacedWithPseudoFromBTrackParticlesCPContent import InDetReplacedWithPseudoFromBTrackParticlesCPContent
                        items.extend(InDetReplacedWithPseudoFromBTrackParticlesCPContent)
                elif collectionName=="InDetReplacedWithPseudoNotFromBTrackParticles":
                        from DerivationFrameworkInDet.InDetReplacedWithPseudoNotFromBTrackParticlesCPContent import InDetReplacedWithPseudoNotFromBTrackParticlesCPContent
                        items.extend(InDetReplacedWithPseudoNotFromBTrackParticlesCPContent)
                elif collectionName=="InDetPlusPseudoTrackParticles":
                        from DerivationFrameworkInDet.InDetPlusPseudoTrackParticlesCPContent import InDetPlusPseudoTrackParticlesCPContent
                        items.extend(InDetPlusPseudoTrackParticlesCPContent)
                elif collectionName=="InDetPlusPseudoFromBTrackParticles":
                        from DerivationFrameworkInDet.InDetPlusPseudoFromBTrackParticlesCPContent import InDetPlusPseudoFromBTrackParticlesCPContent
                        items.extend(InDetPlusPseudoFromBTrackParticlesCPContent)
                elif collectionName=="InDetPlusPseudoNotFromBTrackParticles":
                        from DerivationFrameworkInDet.InDetPlusPseudoNotFromBTrackParticlesCPContent import InDetPlusPseudoNotFromBTrackParticlesCPContent
                        items.extend(InDetPlusPseudoNotFromBTrackParticlesCPContent)
                elif collectionName=="InDetNoFakesTrackParticles":
                        from DerivationFrameworkInDet.InDetNoFakesTrackParticlesCPContent import InDetNoFakesTrackParticlesCPContent
                        items.extend(InDetNoFakesTrackParticlesCPContent)
                elif collectionName=="InDetNoFakesFromBTrackParticles":
                        from DerivationFrameworkInDet.InDetNoFakesFromBTrackParticlesCPContent import InDetNoFakesFromBTrackParticlesCPContent
                        items.extend(InDetNoFakesFromBTrackParticlesCPContent)
                elif collectionName=="InDetNoFakesNotFromBTrackParticles":
                        from DerivationFrameworkInDet.InDetNoFakesNotFromBTrackParticlesCPContent import InDetNoFakesNotFromBTrackParticlesCPContent
                        items.extend(InDetNoFakesNotFromBTrackParticlesCPContent)
                elif collectionName=="InDetSiSPSeededTracksParticles":
                        from DerivationFrameworkInDet.InDetSiSPSeededTracksParticlesCPContent import InDetSiSPSeededTracksParticlesCPContent
                        items.extend(InDetSiSPSeededTracksParticlesCPContent)
                elif collectionName=="InDetLargeD0TrackParticles":
                        from DerivationFrameworkInDet.InDetLargeD0TrackParticlesCPContent import InDetLargeD0TrackParticlesCPContent
                        items.extend(InDetLargeD0TrackParticlesCPContent)
                elif collectionName=="PrimaryVertices":
                        from DerivationFrameworkInDet.PrimaryVerticesCPContent import PrimaryVerticesCPContent
                        items.extend(PrimaryVerticesCPContent)
                        if self.flags.GeoModel.Run >= LHCPeriod.Run4:
                            from DerivationFrameworkInDet.PrimaryVerticesCPContentRun4 import PrimaryVerticesCPContentRun4
                            items.extend(PrimaryVerticesCPContentRun4)
                elif self.IncludeAdditionalTriggerContent is True:
                        from DerivationFrameworkCore.AdditionalTriggerContent import AdditionalTriggerContent
                        items.extend(AdditionalTriggerContent)
                elif collectionName=="HLT_xAOD__MuonContainer_MuonEFInfo":
                        from DerivationFrameworkMuons.MuonTriggerContent import MuonTriggerContent
                        items.extend(MuonTriggerContent)
                elif collectionName=="HLT_xAOD__PhotonContainer_egamma_Photons":
                        from DerivationFrameworkCore.EGammaTriggerContent import EGammaTriggerContent
                        items.extend(EGammaTriggerContent)
                elif collectionName=="HLT_xAOD__JetContainer_a4tcemsubjesFS":
                        from DerivationFrameworkCore.JetTriggerContent import JetTriggerContent
                        items.extend(JetTriggerContent)
                elif collectionName=="HLT_IDVertex_FS":
                        from DerivationFrameworkCore.TrackingTriggerContent import TrackingTriggerContent
                        items.extend(TrackingTriggerContent)
                elif collectionName=="HLT_IDTrack_FS_FTF":
                        from DerivationFrameworkCore.TrackingTriggerContent import TrackingTriggerContent
                        items.extend(TrackingTriggerContent)
                elif collectionName=="HLT_xAOD__TrigMissingETContainer_TrigEFMissingET":
                        from DerivationFrameworkCore.EtMissTriggerContent import EtMissTriggerContent
                        items.extend(EtMissTriggerContent)
                elif collectionName=="HLT_xAOD__TauJetContainer_TrigTauRecMerged":
                        from DerivationFrameworkCore.TauTriggerContent import TauTriggerContentRun2
                        items.extend(TauTriggerContentRun2)
                elif collectionName=="HLT_TrigTauRecMerged_MVA":
                        from DerivationFrameworkCore.TauTriggerContent import TauTriggerContentRun3
                        items.extend(TauTriggerContentRun3)
                elif collectionName=="HLT_DiTauJets":
                        from DerivationFrameworkCore.DiTauTriggerContent import DiTauTriggerContent
                        items.extend(DiTauTriggerContent)
                elif collectionName=="HLT_xAOD__BTaggingContainer_HLTBjetFex":
                        from DerivationFrameworkFlavourTag.BJetTriggerContent import BJetTriggerContent
                        items.extend(BJetTriggerContent)
                elif collectionName=="HLT_xAOD__TrigBphysContainer_EFBMuMuFex":
                        from DerivationFrameworkCore.BPhysTriggerContent import BPhysTriggerContent
                        items.extend(BPhysTriggerContent)
                elif collectionName=="HLT_xAOD__TrigVertexCountsContainer_vertexcounts":
                        from DerivationFrameworkCore.MinBiasTriggerContent import MinBiasTriggerContent
                        items.extend(MinBiasTriggerContent)
                elif collectionName=="HLT_AntiKt4EMPFlowJets_subresjesgscIS_ftf":
                        from DerivationFrameworkCore.JetTriggerContentRun3 import JetTriggerContentRun3
                        from DerivationFrameworkCore.JetTriggerContentRun3TLA import JetTriggerContentRun3TLA
                        if not self.OverrideJetTriggerContentWithTLAContent:
                                items.extend(JetTriggerContentRun3)
                        else:
                                items.extend(JetTriggerContentRun3TLA)
                elif collectionName=="HLT_BJetTriggerByYearContent":
                        from FTagAnalysisAlgorithms.BJetTriggerByYearContent import getBJetTriggerContent
                        items.extend(getBJetTriggerContent(self.flags))
                elif collectionName=="HLT_FULL_EDM":
                        from DerivationFrameworkTrigger.TrigSlimmingHelper import addTrigEDMSetToOutput
                        items.extend(addTrigEDMSetToOutput(self.flags, self, edmSet=self.IncludeFullTriggerEDMLevel))
 
                else:
                        raise RuntimeError("Smart slimming container "+collectionName+" does not exist or does not have a smart slimming list")
                return items
 

GetWholeContentItems()

SlimmingHelper.SlimmingHelper.GetWholeContentItems	(		self,
			collection )

Definition at line 348 of file SlimmingHelper.py.

        def GetWholeContentItems(self,collection):
                items = [collection,collection+"Aux."]
                return items
 

ValidateStaticContent()

SlimmingHelper.SlimmingHelper.ValidateStaticContent	(		self,
			item )

Definition at line 644 of file SlimmingHelper.py.

        def ValidateStaticContent(self,item):
                # No wildcards
                if ("*" in item):
                        return "WILDCARD"
                # No xAOD containers
                sep = item.split("#")
                if ("xAOD::" in item and sep[1] in self.NamesAndTypes.keys()):
                        return "XAOD"
                return "OK"
 

Member Data Documentation

_locked

bool SlimmingHelper.SlimmingHelper._locked = True

protected

Definition at line 342 of file SlimmingHelper.py.

AllVariables

SlimmingHelper.SlimmingHelper.AllVariables = lockable_list()

Definition at line 87 of file SlimmingHelper.py.

AppendToDictionary

SlimmingHelper.SlimmingHelper.AppendToDictionary = {}

Definition at line 88 of file SlimmingHelper.py.

ExtraVariables

SlimmingHelper.SlimmingHelper.ExtraVariables = lockable_list()

Definition at line 84 of file SlimmingHelper.py.

FinalItemList

SlimmingHelper.SlimmingHelper.FinalItemList = lockable_list()

Definition at line 82 of file SlimmingHelper.py.

flags

SlimmingHelper.SlimmingHelper.flags = flags

Definition at line 89 of file SlimmingHelper.py.

IncludeAdditionalTriggerContent

bool SlimmingHelper.SlimmingHelper.IncludeAdditionalTriggerContent = False

Definition at line 91 of file SlimmingHelper.py.

IncludeBJetTriggerByYearContent

bool SlimmingHelper.SlimmingHelper.IncludeBJetTriggerByYearContent = False

Definition at line 100 of file SlimmingHelper.py.

IncludeBJetTriggerContent

bool SlimmingHelper.SlimmingHelper.IncludeBJetTriggerContent = False

Definition at line 99 of file SlimmingHelper.py.

IncludeBPhysTriggerContent

bool SlimmingHelper.SlimmingHelper.IncludeBPhysTriggerContent = False

Definition at line 101 of file SlimmingHelper.py.

IncludeDiTauTriggerContent

bool SlimmingHelper.SlimmingHelper.IncludeDiTauTriggerContent = False

Definition at line 97 of file SlimmingHelper.py.

IncludeEGammaTriggerContent

bool SlimmingHelper.SlimmingHelper.IncludeEGammaTriggerContent = False

Definition at line 93 of file SlimmingHelper.py.

IncludeEtMissTriggerContent

bool SlimmingHelper.SlimmingHelper.IncludeEtMissTriggerContent = False

Definition at line 98 of file SlimmingHelper.py.

IncludeFullTriggerEDMLevel

SlimmingHelper.SlimmingHelper.IncludeFullTriggerEDMLevel = ""

Definition at line 103 of file SlimmingHelper.py.

IncludeJetTriggerContent

bool SlimmingHelper.SlimmingHelper.IncludeJetTriggerContent = False

Definition at line 94 of file SlimmingHelper.py.

IncludeMinBiasTriggerContent

bool SlimmingHelper.SlimmingHelper.IncludeMinBiasTriggerContent = False

Definition at line 102 of file SlimmingHelper.py.

IncludeMuonTriggerContent

bool SlimmingHelper.SlimmingHelper.IncludeMuonTriggerContent = False

Definition at line 92 of file SlimmingHelper.py.

IncludeTauTriggerContent

bool SlimmingHelper.SlimmingHelper.IncludeTauTriggerContent = False

Definition at line 96 of file SlimmingHelper.py.

IncludeTrackingTriggerContent

bool SlimmingHelper.SlimmingHelper.IncludeTrackingTriggerContent = False

Definition at line 95 of file SlimmingHelper.py.

IncludeTriggerNavigation

SlimmingHelper.SlimmingHelper.IncludeTriggerNavigation = True

Definition at line 90 of file SlimmingHelper.py.

name

SlimmingHelper.SlimmingHelper.name = inputName

Definition at line 81 of file SlimmingHelper.py.

NamesAndTypes

SlimmingHelper.SlimmingHelper.NamesAndTypes = buildNamesAndTypes(kwargs["NamesAndTypes"])

Definition at line 106 of file SlimmingHelper.py.

OverrideJetTriggerContentWithTLAContent

bool SlimmingHelper.SlimmingHelper.OverrideJetTriggerContentWithTLAContent = False

Definition at line 104 of file SlimmingHelper.py.

SmartCollections

SlimmingHelper.SlimmingHelper.SmartCollections = lockable_list()

Definition at line 86 of file SlimmingHelper.py.

StaticContent

SlimmingHelper.SlimmingHelper.StaticContent = lockable_list()

Definition at line 83 of file SlimmingHelper.py.

theHandler

SlimmingHelper.SlimmingHelper.theHandler = ContentHandler(self.name+"Handler",self.NamesAndTypes)

Definition at line 108 of file SlimmingHelper.py.

---

The documentation for this class was generated from the following file:

• SlimmingHelper.py