---

MuIsoDeposit.h

Go to the documentation of this file.

#ifndef MuIsoDeposit_H
#define MuIsoDeposit_H

#ifndef USE_MUISODEPOSIT_REQUIRED
#error THIS FILE IS NOT SUPPOSED TO BE INCLUDED: USE "DataFormats/RecoCandidate/interface/IsoDeposit.h" instead
#error THIS FILE IS HERE FOR BKW COMPATIBILITY ONLY
//#include "DataFormats/RecoCandidate/interface/IsoDeposit.h"

#else

#include "DataFormats/TrackReco/interface/Track.h"
#include "DataFormats/TrackReco/interface/TrackFwd.h"
#include "DataFormats/MuonReco/interface/Direction.h"
#include "DataFormats/Math/interface/Vector3D.h"
#include <map>
#include <cmath>
#include <string>
#include <vector>


namespace reco { 
  namespace muisodeposit {
    struct AbsVeto {
      virtual ~AbsVeto() { }
      virtual bool veto(double eta, double phi, float value) const = 0;
      virtual void centerOn(double eta, double phi) {
        throw cms::Exception("Not Implemented") << "This AbsVeto implementation (" << typeid(this).name() << ") does not support the centerOn(eta,phi) method";
      }
    };
    typedef std::vector<AbsVeto*> AbsVetos;
  } 
}

namespace reco {

  class MuIsoDeposit {
  public:

    typedef ::muonisolation::Direction Direction;
    typedef muisodeposit::AbsVeto AbsVeto;
    typedef muisodeposit::AbsVetos AbsVetos;

    // old style vetos
    struct Veto  { 
      Direction vetoDir; float dR; 
      Veto() {}
      Veto(Direction dir, double d):vetoDir(dir), dR(d) {}
    };
    typedef std::vector<Veto> Vetos;

    MuIsoDeposit(const std::string type="", double eta=0, double phi=0); 
    MuIsoDeposit(const std::string type, const Direction & muonDirection);

    virtual ~MuIsoDeposit(){};

    const std::string getType() const {return theType;}

    const Direction & direction() const { return theDirection; }
    double eta() const {return theDirection.eta();}
    double phi() const {return theDirection.phi();}

    const Veto & veto() const { return  theVeto; }
    void setVeto(const Veto & aVeto) { theVeto = aVeto; }

    void addDeposit(double dr, double deposit); // FIXME - temporary for backward compatibility
    void addDeposit(const Direction & depDir, double deposit);

    double depositWithin( 
        double coneSize,                                        //dR in which deposit is computed
        const Vetos & vetos = Vetos(),                          //additional vetos 
        bool skipDepositVeto = false                            //skip exclusion of veto 
        ) const;

      double depositWithin( Direction dir,
        double coneSize,                                        //dR in which deposit is computed
        const Vetos & vetos = Vetos(),                          //additional vetos 
        bool skipDepositVeto = false                            //skip exclusion of veto 
        ) const;

        std::pair<double,int> depositAndCountWithin( 
        double coneSize,                                        //dR in which deposit is computed
        const Vetos & vetos = Vetos(),                          //additional vetos 
        double threshold = -1e+36,                              //threshold on counted deposits
        bool skipDepositVeto = false                            //skip exclusion of veto 
        ) const;

        std::pair<double,int> depositAndCountWithin( 
        Direction dir,                                          //wrt another direction
        double coneSize,                                        //dR in which deposit is computed
        const Vetos & vetos = Vetos(),                          //additional vetos 
        double threshold = -1e+36,                              //threshold on deposits
        bool skipDepositVeto = false                            //skip exclusion of veto 
        ) const;

    double depositWithin( 
        double coneSize,                            //dR in which deposit is computed
        const AbsVetos & vetos,                     //additional vetos 
        bool skipDepositVeto = false                //skip exclusion of veto 
        ) const;

        std::pair<double,int> depositAndCountWithin( 
                double coneSize,                            //dR in which deposit is computed
        const AbsVetos & vetos,                     //additional vetos 
        bool skipDepositVeto = false                //skip exclusion of veto 
        ) const;

 
    double muonEnergy() const {return theMuonTag;}

    void addMuonEnergy(double et) { theMuonTag += et;}

    std::string print() const;

    /* Let's try to avoid this if we can...
    const std::multimap<muonisolation::Direction::Distance, float>&
      depositsMap() const { return theDeposits; } 
    */
   
    class const_iterator {
        public:
            const const_iterator & operator++() { ++it_; cacheReady_ = false; return *this; }
            const const_iterator * operator->() const { return this; }
            float dR() const { return it_->first.deltaR; }
            float eta() const { if (!cacheReady_) doDir(); return cache_.eta(); }
            float phi() const { if (!cacheReady_) doDir(); return cache_.phi(); }
            float value() const { return it_->second; }
            bool  operator!=(const const_iterator &it2) { return it2.it_ != it_; }
            friend class MuIsoDeposit;
        private:
            void doDir() const { cache_ = parent_->direction() + it_->first; cacheReady_ = true; } 
            const_iterator(const MuIsoDeposit* parent, std::multimap<muonisolation::Direction::Distance, float>::const_iterator it) : 
                parent_(parent), it_(it), cache_(), cacheReady_(false) { } 
            const reco::MuIsoDeposit* parent_;
            mutable std::multimap<muonisolation::Direction::Distance, float>::const_iterator it_;
            mutable Direction cache_;
            mutable bool      cacheReady_;
    };
    const_iterator begin() const { return const_iterator(this, theDeposits.begin()); } 
    const_iterator end() const { return const_iterator(this, theDeposits.end()); } 
  private:

    std::string theType;  

    Direction theDirection;

    Veto      theVeto;
    
    float theMuonTag; 

    typedef muonisolation::Direction::Distance Distance;
    typedef std::multimap<Distance, float> DepositsMultimap;
//    struct Closer { bool operator()(const Distance&, const Distance& ) const; };
//    typedef std::multimap<Distance, double, Closer> DepositsMultimap;
    DepositsMultimap theDeposits;
  };

}

#endif //USE_MUISODEPOSIT_REQUIRED
#endif

---