Generic Isolation

Complete: 4

Goals of this page

Introduce generic modules to produce isolation variables with configurable algorithms

Contents

Isolation of reconstructed objects is a useful variable in many analyses to discriminate signal from background. For instance, high pt leptons that are far from other reconstructed objects in the tracker or in the calorimeter are likely to be from a true signal decay and not from a jet in a background event.

Isolation can be computed for different reconstructed objects in the event (e.g. tracks, leptons, tau-objects). In order to study the isolation, the object has to be compared with another collection in the event (which can be the same collection).

We present a proposal for a generic tool that computes the isolation variable for each element of a given input collection. Different isolation algorithms are supported.

The isolation modules are organized as the following:

  • the isolation algorithm(s) with no dependency on Framework (so to assure compatibility with FWLite) are in the new package CMS.PhysicsTools/IsolationAlgos

Generic module description

The generic module is a template producer:

 template <typename C1, typename C2, typename Alg, 
            typename Setup = typename helper::IsolationAlgorithmSetup<Alg>::type>
  class IsolationProducer : public edm::EDProducer { ... };

The template parameters represent:

  • The input collection (C1), i.e. isolation must be computed for objects in the C1 collection;
  • The isolation algorithm (Alg);
  • Another collection of objects (C2) needed by the isolation algorithm; C2 can be the same as C1;
  • An alghorithm setup helper (Setup) needed to initialize the algorithm with EventSetup (for instance, to set BField).

The product stored in the event is an AssociationVector between the input collection and a vector of the isolation values:

  typedef edm::AssociationVector<edm::RefProd<C1>, std::vector<value_type> > 
    IsolationCollection;

Update for release 1.6.8 and 1.8.x NEW

In releases 1.8.x, backported also to 1.6.8, there is an additional isolation producer module that saves a simplified collection type. The module is defined in the namespace reco::modulesNew, and has very simplar interface:

    template <typename C1, typename C2, typename Alg, 
         typename OutputCollection = edm::ValueMap<float>,
         typename Setup = typename helper::IsolationAlgorithmSetup<Alg>::type>
    class IsolationProducer : public edm::EDProducer 

The output collection is by default of type edm::ValueMap, which is the base class of the newly proposed Association map. Multiple isolation collections can be easily merged via:

  module leptonIsolations = ValueMapFloatMerger {
    VInputTag src = { muonIsolations, electronIsolations }
  }

pt isolation algorithm

A standard isolation algorithm is available. It relies on the sum of the pt of the C2 objects in a cone around the object from the C1 collection. For instance, the object from C1 is a muon and C2 is a collection of Tracks. We have implemented this algorithm in a template module. The template parameters represent:

  • The type (T1) of the object from the C1 collection;
  • The C2 collection needed by the isolation algorithm; C2 can be the same as C1.

The algorithm interface (with no dependency on the Framework) is implemented as below:

  template <typename T1, typename C2>
  class PtIsolationAlgo {
     public:
     typedef double value_type;
     PtIsolationAlgo() { }
     PtIsolationAlgo( double dRMin, double dRMax, double dzMax,
           double d0Max, double ptMin ) :
       dRMin_( dRMin ), dRMax_( dRMax ), dzMax_( dzMax ),
       d0Max_( d0Max ), ptMin_( ptMin ) { }
     double operator()(const T1 &, const C2 &) const;

     private:
     double dRMin_, dRMax_, dzMax_, d0Max_, ptMin_;
  };

It requires:

  • a constructor to set parameters like cone sizes, etc.
  • the typedef value_type as the type of the isolation variable returned
  • an operator () that computes the actual isolation from an object of type T1 ad a collection of type C2

A proper adapter is defined in IsolationAlgos to handle parameters to the module via an edm::ParameterSet :

  template<typename T, typename C> 
  struct ParameterAdapter<PtIsolationAlgo<T, C> > { 
     static PtIsolationAlgo<T, C> make( const edm::ParameterSet & cfg ) {
     return PtIsolationAlgo<T, C>( cfg.template getParameter<double>( "dRMin" ), 
               cfg.template getParameter<double>( "dRMax" ),
               cfg.template getParameter<double>( "dzMax" ),
               cfg.template getParameter<double>( "d0Max" ),
               cfg.template getParameter<double>( "ptMin" ) );
        }
    };

An example of a concrete implementation of the IsolationProducer is provided. It computes the pt -based isolation using two collections of Candidates. The implementation is the following:

  typedef 
  IsolationProducer<reco::CandidateCollection, 
                    reco::CandidateCollection,
                    PtIsolationAlgo<reco::Candidate, 
                                    reco::CandidateCollection> > 
    CandPtIsolationProducer;

Further generalization of the algorithm are possible, like templating w.r.t. the metric used to determine the cone (ΔR or 3D angle).

Calorimeter isolation algorithm

Another algorithm calculates the isolation with respect to energy depositions in the calorimeter. This algorithm is organized very similar to the pt algorithm discussed above. It calculates for each input <S1> the sum of ET of all <T2> objects. All objects within a hollow cone, defined by the parameters dRMin and dRMax in the configuration file, are summed up. The type of the input source and the type of the collection containing the calorimeter information is defined by a plugin. For example, the isolation for muons with respect to calorimeter towers can be calculated using the MuonCalIsolationProducer plugin:

typedef IsolationProducer<reco::MuonCollection, CaloTowerCollection,
           CalIsolationAlgo<reco::Muon, CaloTowerCollection>,
           helper::BFieldIsolationAlgorithmSetup<CalIsolationAlgo<reco::Muon, CaloTowerCollection> > > 
                             MuonCalIsolationProducer;

The elements of the source <S1>, in the above case muons, can be extrapolated to the calorimeter surface using the SteppingHelixPropagation algorithm. The parameters, together with the isolation cone properties, can be selected in the configuration file:

module MuonCalIsolation = MuonCalIsolationProducer{          
   # Source and Swarm collection
   InputTag src  = globalMuons
   InputTag elements = towerMaker

   # isolation cone parameters:
   double dRMin = 0.0
   double dRMax  = 0.3
   bool PropagateToCal = false
   
   # Propagate the source to the calorimeter:
   # dimensions of target cylinder in cm (full tracker: r=112, z=+/- 270)
        double CalRadius =   112. #cm
        double CalMinZ = -270. #cm
        double CalMaxZ =  270. #cm
        bool IgnoreMaterial = false #Should CMS.SteppingHelixPropagator take into account material?
}

The output type of the isolation algorithms is in general given by the typename value_type. In this case a double:

template <typename T1, typename C2> class CalIsolationAlgo {
public:
  typedef double value_type;
  double operator()(const T1 &, const C2 &) const;
 ...
}
The result of the calorimeter isolation algorithm, or more precisely it's operator (), is the sum of <T2> elements that fulfill the requirements defined in the configuratiuon file. In this example, this is the sum of the transverse energy of all calorimeter towers, within the cone with radius r with dRMin < r < dRMax.

The result of the isolation producer is the IsolationCollection, which is an AssociationVector of pairs, that contain the reference to each source object as well as the result of the isolation algorithm for that source. For the above example the pairs would consist out of a muon and it's calorimeter isolation.

typedef edm::AssociationVector<edm::RefProd<C1>, 
             std::vector<value_type> > IsolationCollection;

Review Status

Editor/Reviewer and date Comments
Main.fabozzi page author
Main.llista - 10 Dec 2007 review and update to 1.6.8
Main.auterman - 31 May 2007 added documentation of the calorimeter isolation algorithm

Responsible: Main.fabozzi
Last reviewed by:

Edit | Attach | Watch | Print version | History: r15 < r14 < r13 < r12 < r11 | Backlinks | Raw View | WYSIWYG | More topic actions
Topic revision: r15 - 2008-02-19 - VyacheslavKrutelyov



 
    • Cern Search Icon Cern Search
    • TWiki Search Icon TWiki Search
    • Google Search Icon Google Search

    CMSPublic All webs login

This site is powered by the TWiki collaboration platform Powered by PerlCopyright & 2008-2019 by the contributing authors. All material on this collaboration platform is the property of the contributing authors.
Ideas, requests, problems regarding TWiki? Send feedback