ORUtils Namespace Reference

Classes
class	AltMuJetOverlapTool
	Implements mu-jet OR optimized for high-pt muons in boosted and highly radiative (jetty) topologies. More...
class	BaseOverlapTool
	Common base class tool for overlap tools. More...
class	BJetHelper
	Helper class for b-jet decorations. More...
class	DeltaRMatcher
	Encapsulates the delta-R matching strategy. More...
class	DeltaROverlapTool
	A simple overlap finder that uses a dR match. More...
class	EleEleOverlapTool
	A tool implementing the recommended ele-ele overlap removal. More...
class	EleJetOverlapTool
	A tool implementing the recommended ele-jet overlap removal. More...
class	EleMuSharedTrkOverlapTool
	Tool for removing overlaps between electrons and muons that share a track or are DR matched. More...
class	IOverlapRemovalTool
	Interface for the overlap removal tool. More...
class	IOverlapTool
	Interface class for overlap removal tools. More...
class	IParticleAssociator
	Interface for a class which checks for a match between IParticles. More...
class	MuJetGhostDRMatcher
	Matches a muon to a jet via ghost association or a delta-R. More...
class	MuJetOverlapTool
	A tool implementing the recommended mu-jet overlap removal. More...
class	ObjLinkOverlapTool
	A generic tool which finds overlaps using ElementLinks. More...
struct	ORFlags
	A struct of global config options used to simplify the config helper interface. More...
class	OverlapDecorationHelper
	Encapsulates the code needed to access and set overlap-related decorations. More...
class	OverlapLinkHelper
	Helper class for setting links between overlapping objects. More...
class	OverlapRemovalTool
	top-level tool for performing overlap removal. More...
class	SlidingDeltaRMatcher
	DR matching strategy where cone decreases with pt. More...
class	TauAntiTauJetOverlapTool
	A tool implementing a specialized tau-jet overlap removal. More...
class	TauJetOverlapTool
	A tool implementing the recommended tau-jet overlap removal. More...
class	TauLooseEleOverlapTool
	A tool implementing the recommended tau-electron overlap removal. More...
class	TauLooseMuOverlapTool
	A tool implementing the recommended tau-muon overlap removal. More...
class	ToolBox
	A container and helper class for overlap removal tools. More...

Functions
StatusCode	recommendedTools (const ORFlags &flags, ToolBox &toolBox)
	Pre-configured standard recommended OR tools. More...

Function Documentation

recommendedTools()

StatusCode ORUtils::recommendedTools	(	const ORFlags &	flags,
		ToolBox &	toolBox
	)

Pre-configured standard recommended OR tools.

This function provides the tool configuration corresponding to the updated overlap removal recommendations as summarized in this ASG meeting by Will Buttinger: https://indico.cern.ch/event/457238/

The tools are returned uninitialized; the user can override properties and initialize all the tools with a call to ToolBox::initialize.

This function uses the ORFlags object to communicate common configuration options and the ToolBox design based on AnaToolHandle.

Users can replace overlap tools with their own configured versions by setting ToolBox handles prior to calling this method. Right now the way to do that would be with something like this:

ORUtils::ToolBox toolBox;
toolBox.tauEleORT =
  ORUtils::ToolBox::OverlapHandle_t("ORUtils::DeltaROverlapTool/TauEleORT");
CHECK( toolBox.tauEleORT.setProperty(...) );
CHECK( ORUtils::recommendedTools(flags, toolBox) );

Note that the config function will still set the 'global' properties on your custom tool (e.g. input label). I'm assuming this is the behavior users would want.

Parameters

[in]	flags	An ORFlags object containing config options.
[out]	toolBox	Container to be filled with tools.

Definition at line 50 of file OverlapRemovalInit.cxx.

  {
    // Master tool
    tbox.masterTool.setTypeAndName("ORUtils::OverlapRemovalTool/" +
                                   flags.masterName);
 
    // El-el
    if(flags.doElectrons && flags.doEleEleOR && tbox.eleEleORT.empty()) {
      tbox.eleEleORT.setTypeAndName("ORUtils::EleEleOverlapTool/" +
                                    flags.masterName + ".EleEleORT");
    }
 
    // El-mu
    if(flags.doElectrons && flags.doMuons && tbox.eleMuORT.empty()) {
      tbox.eleMuORT.setTypeAndName("ORUtils::EleMuSharedTrkOverlapTool/" +
                                   flags.masterName + ".EleMuORT");
    }
    // El-jet
    if(flags.doElectrons && flags.doJets && tbox.eleJetORT.empty()) {
      tbox.eleJetORT.setTypeAndName("ORUtils::EleJetOverlapTool/" +
                                    flags.masterName + ".EleJetORT");
      ORT_CHECK( tbox.eleJetORT.setProperty("BJetLabel", flags.bJetLabel) );
      ORT_CHECK( tbox.eleJetORT.setProperty("MaxElePtForBJetAwareOR", flags.maxElePtForBJetAwareOR) );
      ORT_CHECK( tbox.eleJetORT.setProperty("UseSlidingDR", flags.boostedLeptons) );
    }
    // Mu-jet
    if(flags.doMuons && flags.doJets && tbox.muJetORT.empty()) {
      tbox.muJetORT.setTypeAndName("ORUtils::MuJetOverlapTool/" +
                                   flags.masterName + ".MuJetORT");
      ORT_CHECK( tbox.muJetORT.setProperty("BJetLabel", flags.bJetLabel) );
      ORT_CHECK( tbox.muJetORT.setProperty("UseSlidingDR", flags.boostedLeptons) );
    }
 
    // Tau-ele overlap tool
    if(flags.doTaus && flags.doElectrons && tbox.tauEleORT.empty()) {
      tbox.tauEleORT.setTypeAndName("ORUtils::DeltaROverlapTool/" +
                                    flags.masterName + ".TauEleORT");
      ORT_CHECK( tbox.tauEleORT.setProperty("DR", 0.2) );
    }
    // Tau-mu overlap tool
    if(flags.doTaus && flags.doMuons && tbox.tauMuORT.empty()) {
      tbox.tauMuORT.setTypeAndName("ORUtils::DeltaROverlapTool/" +
                                   flags.masterName + ".TauMuORT");
      ORT_CHECK( tbox.tauMuORT.setProperty("DR", 0.2) );
    }
    // Tau-jet overlap tool
    if(flags.doTaus && flags.doJets && tbox.tauJetORT.empty()) {
      tbox.tauJetORT.setTypeAndName("ORUtils::DeltaROverlapTool/" +
                                    flags.masterName + ".TauJetORT");
      ORT_CHECK( tbox.tauJetORT.setProperty("DR", 0.2) );
    }
 
    // Pho-ele overlap tool
    if(flags.doPhotons && flags.doElectrons && tbox.phoEleORT.empty()) {
      tbox.phoEleORT.setTypeAndName("ORUtils::DeltaROverlapTool/" +
                                    flags.masterName + ".PhoEleORT");
    }
    // Pho-mu overlap tool
    if(flags.doPhotons && flags.doMuons && tbox.phoMuORT.empty()) {
      tbox.phoMuORT.setTypeAndName("ORUtils::DeltaROverlapTool/" +
                                   flags.masterName + ".PhoMuORT");
    }
    // Pho-jet overlap tool
    if(flags.doPhotons && flags.doJets && tbox.phoJetORT.empty()) {
      tbox.phoJetORT.setTypeAndName("ORUtils::DeltaROverlapTool/" +
                                    flags.masterName + ".PhoJetORT");
    }
 
    // Ele-fatjet overlap tool
    if(flags.doElectrons && flags.doFatJets && tbox.eleFatJetORT.empty()) {
      tbox.eleFatJetORT.setTypeAndName("ORUtils::DeltaROverlapTool/" +
                                       flags.masterName + ".EleFatJetORT");
      ORT_CHECK( tbox.eleFatJetORT.setProperty("DR", 1.0) );
    }
 
    // Jet-fatjet overlap tool
    if(flags.doJets && flags.doFatJets && tbox.jetFatJetORT.empty()) {
      tbox.jetFatJetORT.setTypeAndName("ORUtils::DeltaROverlapTool/" +
                                       flags.masterName + ".JetFatJetORT");
      ORT_CHECK( tbox.jetFatJetORT.setProperty("DR", 1.0) );
    }
 
    // Overlap tool common properties
    for(auto hptr : tbox.getOverlapTools()) {
      ORT_CHECK( hptr->setProperty("LinkOverlapObjects", flags.linkOverlapObjects) );
    }
 
    // Global common properties
    ORT_CHECK( tbox.setGlobalProperty("InputLabel", flags.inputLabel) );
    ORT_CHECK( tbox.setGlobalProperty("OutputLabel", flags.outputLabel) );
    ORT_CHECK( tbox.setGlobalProperty("OutputPassValue", flags.outputPassValue) );
 
    return StatusCode::SUCCESS;
  }