PATObject.h

Go to the documentation of this file.

//
//

#ifndef DataFormats_PatCandidates_PATObject_h
#define DataFormats_PatCandidates_PATObject_h

#include "DataFormats/Common/interface/Ptr.h"
#include "DataFormats/Candidate/interface/CandidateFwd.h"
#include "DataFormats/Candidate/interface/Candidate.h"
#include <vector>
#include <string>
#include <iosfwd>

#include "DataFormats/PatCandidates/interface/TriggerObjectStandAlone.h"
#include "DataFormats/PatCandidates/interface/LookupTableRecord.h"

#include "DataFormats/HepMCCandidate/interface/GenParticle.h"

#include "DataFormats/PatCandidates/interface/UserData.h"
#include "DataFormats/Common/interface/OwnVector.h"

#include "DataFormats/PatCandidates/interface/CandKinResolution.h"

#include "DataFormats/PatCandidates/interface/throwMissingLabel.h"

#include "FWCore/MessageLogger/interface/MessageLogger.h"

namespace pat {

  namespace pat_statics {
    static const reco::CandidatePtrVector EMPTY_CPV;
    static const std::string EMPTY_STR("");
  }

  template <class ObjectType>
  class PATObject : public ObjectType {
    public:

      typedef  ObjectType             base_type;

      PATObject();
      PATObject(const ObjectType & obj);
      PATObject(const edm::RefToBase<ObjectType> & ref);
      PATObject(const edm::Ptr<ObjectType> & ref);
      virtual ~PATObject() {}
      // returns a clone                                  // NO: ObjectType can be an abstract type like reco::Candidate
      // virtual PATObject<ObjectType> * clone() const ;  //     for which the clone() can't be defined

      const reco::Candidate * originalObject() const;
      const edm::Ptr<reco::Candidate> & originalObjectRef() const;


      const TriggerObjectStandAloneCollection & triggerObjectMatches() const { return triggerObjectMatchesEmbedded_; };
      const TriggerObjectStandAlone * triggerObjectMatch( const size_t idx = 0 ) const;
      const TriggerObjectStandAloneCollection triggerObjectMatchesByType( const trigger::TriggerObjectType triggerObjectType ) const;
      const TriggerObjectStandAloneCollection triggerObjectMatchesByType( const unsigned triggerObjectType ) const {
        return triggerObjectMatchesByType( trigger::TriggerObjectType( triggerObjectType ) );
      };
      // for backward compatibility
      const TriggerObjectStandAloneCollection triggerObjectMatchesByFilterID( const unsigned triggerObjectType ) const {
        return triggerObjectMatchesByType( trigger::TriggerObjectType( triggerObjectType ) );
      };
      const TriggerObjectStandAlone * triggerObjectMatchByType( const trigger::TriggerObjectType triggerObjectType, const size_t idx = 0 ) const;
      const TriggerObjectStandAlone * triggerObjectMatchByType( const unsigned triggerObjectType, const size_t idx = 0 ) const {
        return triggerObjectMatchByType( trigger::TriggerObjectType( triggerObjectType ), idx );
      };
      // for backward compatibility
      const TriggerObjectStandAlone * triggerObjectMatchByFilterID( const unsigned triggerObjectType, const size_t idx = 0 ) const {
        return triggerObjectMatchByType( trigger::TriggerObjectType( triggerObjectType ), idx );
      };
      const TriggerObjectStandAloneCollection triggerObjectMatchesByCollection( const std::string & coll ) const;
      // for RooT command line
      const TriggerObjectStandAloneCollection triggerObjectMatchesByCollection( const char * coll ) const {
        return triggerObjectMatchesByCollection( std::string( coll ) );
      };
      const TriggerObjectStandAlone * triggerObjectMatchByCollection( const std::string & coll, const size_t idx = 0 ) const;
      // for RooT command line
      const TriggerObjectStandAlone * triggerObjectMatchByCollection( const char * coll, const size_t idx = 0 ) const {
        return triggerObjectMatchByCollection( std::string( coll ), idx );
      };
      const TriggerObjectStandAloneCollection triggerObjectMatchesByCondition( const std::string & nameCondition ) const;
      // for RooT command line
      const TriggerObjectStandAloneCollection triggerObjectMatchesByCondition( const char * nameCondition ) const {
        return triggerObjectMatchesByCondition( std::string( nameCondition ) );
      };
      const TriggerObjectStandAlone * triggerObjectMatchByCondition( const std::string & nameCondition, const size_t idx = 0 ) const;
      // for RooT command line
      const TriggerObjectStandAlone * triggerObjectMatchByCondition( const char * nameCondition, const size_t idx = 0 ) const {
        return triggerObjectMatchByCondition( std::string( nameCondition ), idx );
      };
      const TriggerObjectStandAloneCollection triggerObjectMatchesByAlgorithm( const std::string & nameAlgorithm, const bool algoCondAccepted = true ) const;
      // for RooT command line
      const TriggerObjectStandAloneCollection triggerObjectMatchesByAlgorithm( const char * nameAlgorithm, const bool algoCondAccepted = true ) const {
        return triggerObjectMatchesByAlgorithm( std::string( nameAlgorithm ), algoCondAccepted );
      };
      // for the cut string parser
      const TriggerObjectStandAloneCollection triggerObjectMatchesByAlgorithm( const std::string & nameAlgorithm, const unsigned algoCondAccepted ) const {
        return triggerObjectMatchesByAlgorithm( nameAlgorithm, bool( algoCondAccepted ) );
      };
      // for RooT command line and the cut string parser
      const TriggerObjectStandAloneCollection triggerObjectMatchesByAlgorithm( const char * nameAlgorithm, const unsigned algoCondAccepted ) const {
        return triggerObjectMatchesByAlgorithm( std::string( nameAlgorithm ), bool( algoCondAccepted ) );
      };
      const TriggerObjectStandAlone * triggerObjectMatchByAlgorithm( const std::string & nameAlgorithm, const bool algoCondAccepted = true, const size_t idx = 0 ) const;
      // for RooT command line
      const TriggerObjectStandAlone * triggerObjectMatchByAlgorithm( const char * nameAlgorithm, const bool algoCondAccepted = true, const size_t idx = 0 ) const {
        return triggerObjectMatchByAlgorithm( std::string( nameAlgorithm ), algoCondAccepted, idx );
      };
      // for the cut string parser
      const TriggerObjectStandAlone * triggerObjectMatchByAlgorithm( const std::string & nameAlgorithm, const unsigned algoCondAccepted, const size_t idx = 0 ) const {
        return triggerObjectMatchByAlgorithm( nameAlgorithm, bool( algoCondAccepted ), idx );
      };
      // for RooT command line and the cut string parser
      const TriggerObjectStandAlone * triggerObjectMatchByAlgorithm( const char * nameAlgorithm, const unsigned algoCondAccepted, const size_t idx = 0 ) const {
        return triggerObjectMatchByAlgorithm( std::string( nameAlgorithm ), bool( algoCondAccepted ), idx );
      };
      const TriggerObjectStandAloneCollection triggerObjectMatchesByFilter( const std::string & labelFilter ) const;
      // for RooT command line
      const TriggerObjectStandAloneCollection triggerObjectMatchesByFilter( const char * labelFilter ) const {
        return triggerObjectMatchesByFilter( std::string( labelFilter ) );
      };
      const TriggerObjectStandAlone * triggerObjectMatchByFilter( const std::string & labelFilter, const size_t idx = 0 ) const;
      // for RooT command line
      const TriggerObjectStandAlone * triggerObjectMatchByFilter( const char * labelFilter, const size_t idx = 0 ) const {
        return triggerObjectMatchByFilter( std::string( labelFilter ), idx );
      };
      const TriggerObjectStandAloneCollection triggerObjectMatchesByPath( const std::string & namePath, const bool pathLastFilterAccepted = false, const bool pathL3FilterAccepted = true ) const;
      // for RooT command line
      const TriggerObjectStandAloneCollection triggerObjectMatchesByPath( const char * namePath, const bool pathLastFilterAccepted = false, const bool pathL3FilterAccepted = true ) const {
        return triggerObjectMatchesByPath( std::string( namePath ), pathLastFilterAccepted, pathL3FilterAccepted );
      };
      // for the cut string parser
      const TriggerObjectStandAloneCollection triggerObjectMatchesByPath( const std::string & namePath, const unsigned pathLastFilterAccepted, const unsigned pathL3FilterAccepted = 1 ) const {
        return triggerObjectMatchesByPath( namePath, bool( pathLastFilterAccepted ), bool( pathL3FilterAccepted ) );
      };
      // for RooT command line and the cut string parser
      const TriggerObjectStandAloneCollection triggerObjectMatchesByPath( const char * namePath, const unsigned pathLastFilterAccepted, const unsigned pathL3FilterAccepted = 1 ) const {
        return triggerObjectMatchesByPath( std::string( namePath ), bool( pathLastFilterAccepted ), bool( pathL3FilterAccepted ) );
      };
      const TriggerObjectStandAlone * triggerObjectMatchByPath( const std::string & namePath, const bool pathLastFilterAccepted = false, const bool pathL3FilterAccepted = true, const size_t idx = 0 ) const;
      // for RooT command line
      const TriggerObjectStandAlone * triggerObjectMatchByPath( const char * namePath, const bool pathLastFilterAccepted = false, const bool pathL3FilterAccepted = true, const size_t idx = 0 ) const {
        return triggerObjectMatchByPath( std::string( namePath ), pathLastFilterAccepted, pathL3FilterAccepted, idx );
      };
      // for the cut string parser
      const TriggerObjectStandAlone * triggerObjectMatchByPath( const std::string & namePath, const unsigned pathLastFilterAccepted, const unsigned pathL3FilterAccepted = 1, const size_t idx = 0 ) const {
        return triggerObjectMatchByPath( namePath, bool( pathLastFilterAccepted ), bool( pathL3FilterAccepted ), idx );
      };
      // for RooT command line and the cut string parser
      const TriggerObjectStandAlone * triggerObjectMatchByPath( const char * namePath, const unsigned pathLastFilterAccepted, const unsigned pathL3FilterAccepted = 1, const size_t idx = 0 ) const {
        return triggerObjectMatchByPath( std::string( namePath ), bool( pathLastFilterAccepted ), bool( pathL3FilterAccepted ), idx );
      };
      void addTriggerObjectMatch( const TriggerObjectStandAlone & trigObj ) { triggerObjectMatchesEmbedded_.push_back( trigObj ); };
      void unpackTriggerObjectPathNames( const edm::TriggerNames &names ) {
        for (std::vector<TriggerObjectStandAlone>::iterator it = triggerObjectMatchesEmbedded_.begin(), ed = triggerObjectMatchesEmbedded_.end(); it != ed; ++it) it->unpackPathNames(names);
      }

      const pat::LookupTableRecord       & efficiency(const std::string &name) const ;
      std::vector<std::pair<std::string,pat::LookupTableRecord> > efficiencies() const ;
      const std::vector<std::string> & efficiencyNames() const { return efficiencyNames_; }
      const std::vector<pat::LookupTableRecord> & efficiencyValues() const { return efficiencyValues_; }
      void setEfficiency(const std::string &name, const pat::LookupTableRecord & value) ;

      reco::GenParticleRef      genParticleRef(size_t idx=0) const {
            if (idx >= genParticlesSize()) return reco::GenParticleRef();
            return genParticleEmbedded_.empty() ? genParticleRef_[idx] : reco::GenParticleRef(&genParticleEmbedded_, idx);
      }
      // implementation note: uint8_t instead of bool, because the string parser doesn't allow bool currently
      reco::GenParticleRef      genParticleById(int pdgId, int status, uint8_t autoCharge=0) const ;

      const reco::GenParticle * genParticle(size_t idx=0)    const {
            reco::GenParticleRef ref = genParticleRef(idx);
            return ref.isNonnull() ? ref.get() : 0;
      }
      size_t genParticlesSize() const {
            return genParticleEmbedded_.empty() ? genParticleRef_.size() : genParticleEmbedded_.size();
      }
      std::vector<reco::GenParticleRef> genParticleRefs() const ;

      void setGenParticleRef(const reco::GenParticleRef &ref, bool embed=false) ;
      void addGenParticleRef(const reco::GenParticleRef &ref) ;
      void setGenParticle( const reco::GenParticle &particle ) ;
      void embedGenParticle() ;

      bool hasOverlaps(const std::string &label) const ;
      const reco::CandidatePtrVector & overlaps(const std::string &label) const ;
      const std::vector<std::string> & overlapLabels() const { return overlapLabels_; }
      void setOverlaps(const std::string &label, const reco::CandidatePtrVector & overlaps) ;

      template<typename T> const T * userData(const std::string &key) const {
          const pat::UserData * data = userDataObject_(key);
          return (data != nullptr ? data->template get<T>() : nullptr);

      }
      bool hasUserData(const std::string &key) const {
          return (userDataObject_(key) != nullptr);
      }
      const std::string & userDataObjectType(const std::string &key) const {
          const pat::UserData * data = userDataObject_(key);
          return (data != nullptr ? data->typeName() : pat_statics::EMPTY_STR);
      };
      const std::vector<std::string> & userDataNames() const  { return userDataLabels_; }

      const void * userDataBare(const std::string &key) const {
          const pat::UserData * data = userDataObject_(key);
          return (data != nullptr ? data->bareData() : nullptr);
      }

      template<typename T>
      void addUserData( const std::string & label, const T & data, bool transientOnly=false ) {
        userDataLabels_.push_back(label);
        userDataObjects_.push_back(pat::UserData::make<T>(data, transientOnly));
      }

      void addUserDataFromPtr( const std::string & label, const edm::Ptr<pat::UserData> & data ) {
        userDataLabels_.push_back(label);
        userDataObjects_.push_back(data->clone());
      }

      float userFloat( const std::string & key ) const;
      std::vector<float> userFloatRange( const std::string& key ) const;
      float userFloat( const char* key ) const { return userFloat( std::string(key) ); }
      
      void addUserFloat( const  std::string & label, float data, const bool overwrite = false );
      const std::vector<std::string> & userFloatNames() const  { return userFloatLabels_; }
      bool hasUserFloat( const std::string & key ) const {
        auto it = std::lower_bound(userFloatLabels_.cbegin(), userFloatLabels_.cend(), key); 
        return ( it != userFloatLabels_.cend() && *it == key );
      }
      bool hasUserFloat( const char* key ) const {return hasUserFloat( std::string(key) );}

      int32_t userInt( const std::string & key ) const;
      std::vector<int> userIntRange( const std::string& key ) const;
      void addUserInt( const std::string & label,  int32_t data );
      const std::vector<std::string> & userIntNames() const  { return userIntLabels_; }
      bool hasUserInt( const std::string & key ) const {
        auto it = std::lower_bound(userIntLabels_.cbegin(), userIntLabels_.cend(), key);
        return ( it != userIntLabels_.cend() && *it == key );
      }

      reco::CandidatePtr userCand( const std::string & key ) const;
      void addUserCand( const std::string & label,  const reco::CandidatePtr & data, const bool overwrite = false );
      const std::vector<std::string> & userCandNames() const  { return userCandLabels_; }
      bool hasUserCand( const std::string & key ) const {
        auto it = std::lower_bound(userCandLabels_.cbegin(), userCandLabels_.cend(), key);
        return ( it != userCandLabels_.cend() && *it == key );
      }

      // === New Kinematic Resolutions
      const pat::CandKinResolution & getKinResolution(const std::string &label="") const ;

      bool hasKinResolution(const std::string &label="") const ;

      void setKinResolution(const pat::CandKinResolution &resol, const std::string &label="") ;

      double resolEta(const std::string &label="") const { return getKinResolution(label).resolEta(this->p4()); }

      double resolTheta(const std::string &label="") const { return getKinResolution(label).resolTheta(this->p4()); }

      double resolPhi(const std::string &label="") const { return getKinResolution(label).resolPhi(this->p4()); }

      double resolE(const std::string &label="") const { return getKinResolution(label).resolE(this->p4()); }

      double resolEt(const std::string &label="") const { return getKinResolution(label).resolEt(this->p4()); }

      double resolP(const std::string &label="") const { return getKinResolution(label).resolP(this->p4()); }

      double resolPt(const std::string &label="") const { return getKinResolution(label).resolPt(this->p4()); }

      double resolPInv(const std::string &label="") const { return getKinResolution(label).resolPInv(this->p4()); }

      double resolPx(const std::string &label="") const { return getKinResolution(label).resolPx(this->p4()); }

      double resolPy(const std::string &label="") const { return getKinResolution(label).resolPy(this->p4()); }

      double resolPz(const std::string &label="") const { return getKinResolution(label).resolPz(this->p4()); }

      double resolM(const std::string &label="") const { return getKinResolution(label).resolM(this->p4()); }



    protected:
      // reference back to the original object
      edm::Ptr<reco::Candidate> refToOrig_;

      TriggerObjectStandAloneCollection triggerObjectMatchesEmbedded_;

      std::vector<pat::LookupTableRecord> efficiencyValues_;
      std::vector<std::string> efficiencyNames_;

      std::vector<reco::GenParticleRef> genParticleRef_;
      std::vector<reco::GenParticle>    genParticleEmbedded_;

      std::vector<std::string> overlapLabels_;
      std::vector<reco::CandidatePtrVector> overlapItems_;

      std::vector<std::string>      userDataLabels_;
      pat::UserDataCollection       userDataObjects_;
      // User float values
      std::vector<std::string>      userFloatLabels_;
      std::vector<float>            userFloats_;
      // User int values
      std::vector<std::string>      userIntLabels_;
      std::vector<int32_t>          userInts_;
      // User candidate matches
      std::vector<std::string>        userCandLabels_;
      std::vector<reco::CandidatePtr> userCands_;

      std::vector<pat::CandKinResolution> kinResolutions_;
      std::vector<std::string>            kinResolutionLabels_;

    private:
      const pat::UserData *  userDataObject_(const std::string &key) const ;
  };


  template <class ObjectType> PATObject<ObjectType>::PATObject() {
  }

  template <class ObjectType> PATObject<ObjectType>::PATObject(const ObjectType & obj) :
    ObjectType(obj),
    refToOrig_() {
  }

  template <class ObjectType> PATObject<ObjectType>::PATObject(const edm::RefToBase<ObjectType> & ref) :
    ObjectType(*ref),
    refToOrig_(ref.id(), ref.get(), ref.key()) // correct way to convert RefToBase=>Ptr, if ref is guaranteed to be available
                                               // which happens to be true, otherwise the line before this throws ex. already
      {
      }

  template <class ObjectType> PATObject<ObjectType>::PATObject(const edm::Ptr<ObjectType> & ref) :
    ObjectType(*ref),
    refToOrig_(ref) {
  }

  template <class ObjectType> const reco::Candidate * PATObject<ObjectType>::originalObject() const {
    if (refToOrig_.isNull()) {
      // this object was not produced from a reference, so no link to the
      // original object exists -> return a 0-pointer
      return 0;
    } else if (!refToOrig_.isAvailable()) {
      throw edm::Exception(edm::errors::ProductNotFound) << "The original collection from which this PAT object was made is not present any more in the event, hence you cannot access the originating object anymore.";
    } else {
      return refToOrig_.get();
    }
  }

  template <class ObjectType>
  const edm::Ptr<reco::Candidate> & PATObject<ObjectType>::originalObjectRef() const { return refToOrig_; }

  template <class ObjectType>
  const TriggerObjectStandAlone * PATObject<ObjectType>::triggerObjectMatch( const size_t idx ) const {
    if ( idx >= triggerObjectMatches().size() ) return 0;
    TriggerObjectStandAloneRef ref( &triggerObjectMatchesEmbedded_, idx );
    return ref.isNonnull() ? ref.get() : 0;
  }

  template <class ObjectType>
  const TriggerObjectStandAloneCollection PATObject<ObjectType>::triggerObjectMatchesByType( const trigger::TriggerObjectType triggerObjectType ) const {
    TriggerObjectStandAloneCollection matches;
    for ( size_t i = 0; i < triggerObjectMatches().size(); ++i ) {
      if ( triggerObjectMatch( i ) != 0 && triggerObjectMatch( i )->hasTriggerObjectType( triggerObjectType ) ) matches.push_back( *( triggerObjectMatch( i ) ) );
    }
    return matches;
  }

  template <class ObjectType>
  const TriggerObjectStandAlone * PATObject<ObjectType>::triggerObjectMatchByType( const trigger::TriggerObjectType triggerObjectType, const size_t idx ) const {
    std::vector< size_t > refs;
    for ( size_t i = 0; i < triggerObjectMatches().size(); ++i ) {
      if ( triggerObjectMatch( i ) != 0 && triggerObjectMatch( i )->hasTriggerObjectType( triggerObjectType ) ) refs.push_back( i );
    }
    if ( idx >= refs.size() ) return 0;
    TriggerObjectStandAloneRef ref( &triggerObjectMatchesEmbedded_, refs.at( idx ) );
    return ref.isNonnull() ? ref.get() : 0;
  }

  template <class ObjectType>
  const TriggerObjectStandAloneCollection PATObject<ObjectType>::triggerObjectMatchesByCollection( const std::string & coll ) const {
    TriggerObjectStandAloneCollection matches;
    for ( size_t i = 0; i < triggerObjectMatches().size(); ++i ) {
      if ( triggerObjectMatch( i ) != 0 && triggerObjectMatch( i )->hasCollection( coll ) ) matches.push_back( *( triggerObjectMatch( i ) ) );
    }
    return matches;
  }

  template <class ObjectType>
  const TriggerObjectStandAlone * PATObject<ObjectType>::triggerObjectMatchByCollection( const std::string & coll, const size_t idx ) const {
    std::vector< size_t > refs;
    for ( size_t i = 0; i < triggerObjectMatches().size(); ++i ) {
      if ( triggerObjectMatch( i ) != 0 && triggerObjectMatch( i )->hasCollection( coll ) ) {
        refs.push_back( i );
      }
    }
    if ( idx >= refs.size() ) return 0;
    TriggerObjectStandAloneRef ref( &triggerObjectMatchesEmbedded_, refs.at( idx ) );
    return ref.isNonnull() ? ref.get() : 0;
  }

  template <class ObjectType>
  const TriggerObjectStandAloneCollection PATObject<ObjectType>::triggerObjectMatchesByCondition( const std::string & nameCondition ) const {
    TriggerObjectStandAloneCollection matches;
    for ( size_t i = 0; i < triggerObjectMatches().size(); ++i ) {
      if ( triggerObjectMatch( i ) != 0 && triggerObjectMatch( i )->hasConditionName( nameCondition ) ) matches.push_back( *( triggerObjectMatch( i ) ) );
    }
    return matches;
  }

  template <class ObjectType>
  const TriggerObjectStandAlone * PATObject<ObjectType>::triggerObjectMatchByCondition( const std::string & nameCondition, const size_t idx ) const {
    std::vector< size_t > refs;
    for ( size_t i = 0; i < triggerObjectMatches().size(); ++i ) {
      if ( triggerObjectMatch( i ) != 0 && triggerObjectMatch( i )->hasConditionName( nameCondition ) ) refs.push_back( i );
    }
    if ( idx >= refs.size() ) return 0;
    TriggerObjectStandAloneRef ref( &triggerObjectMatchesEmbedded_, refs.at( idx ) );
    return ref.isNonnull() ? ref.get() : 0;
  }

  template <class ObjectType>
  const TriggerObjectStandAloneCollection PATObject<ObjectType>::triggerObjectMatchesByAlgorithm( const std::string & nameAlgorithm, const bool algoCondAccepted ) const {
    TriggerObjectStandAloneCollection matches;
    for ( size_t i = 0; i < triggerObjectMatches().size(); ++i ) {
      if ( triggerObjectMatch( i ) != 0 && triggerObjectMatch( i )->hasAlgorithmName( nameAlgorithm, algoCondAccepted ) ) matches.push_back( *( triggerObjectMatch( i ) ) );
    }
    return matches;
  }

  template <class ObjectType>
  const TriggerObjectStandAlone * PATObject<ObjectType>::triggerObjectMatchByAlgorithm( const std::string & nameAlgorithm, const bool algoCondAccepted, const size_t idx ) const {
    std::vector< size_t > refs;
    for ( size_t i = 0; i < triggerObjectMatches().size(); ++i ) {
      if ( triggerObjectMatch( i ) != 0 && triggerObjectMatch( i )->hasAlgorithmName( nameAlgorithm, algoCondAccepted ) ) refs.push_back( i );
    }
    if ( idx >= refs.size() ) return 0;
    TriggerObjectStandAloneRef ref( &triggerObjectMatchesEmbedded_, refs.at( idx ) );
    return ref.isNonnull() ? ref.get() : 0;
  }

  template <class ObjectType>
  const TriggerObjectStandAloneCollection PATObject<ObjectType>::triggerObjectMatchesByFilter( const std::string & labelFilter ) const {
    TriggerObjectStandAloneCollection matches;
    for ( size_t i = 0; i < triggerObjectMatches().size(); ++i ) {
      if ( triggerObjectMatch( i ) != 0 && triggerObjectMatch( i )->hasFilterLabel( labelFilter ) ) matches.push_back( *( triggerObjectMatch( i ) ) );
    }
    return matches;
  }

  template <class ObjectType>
  const TriggerObjectStandAlone * PATObject<ObjectType>::triggerObjectMatchByFilter( const std::string & labelFilter, const size_t idx ) const {
    std::vector< size_t > refs;
    for ( size_t i = 0; i < triggerObjectMatches().size(); ++i ) {
      if ( triggerObjectMatch( i ) != 0 && triggerObjectMatch( i )->hasFilterLabel( labelFilter ) ) refs.push_back( i );
    }
    if ( idx >= refs.size() ) return 0;
    TriggerObjectStandAloneRef ref( &triggerObjectMatchesEmbedded_, refs.at( idx ) );
    return ref.isNonnull() ? ref.get() : 0;
  }

  template <class ObjectType>
  const TriggerObjectStandAloneCollection PATObject<ObjectType>::triggerObjectMatchesByPath( const std::string & namePath, const bool pathLastFilterAccepted, const bool pathL3FilterAccepted ) const {
    TriggerObjectStandAloneCollection matches;
    for ( size_t i = 0; i < triggerObjectMatches().size(); ++i ) {
      if ( triggerObjectMatch( i ) != 0 && triggerObjectMatch( i )->hasPathName( namePath, pathLastFilterAccepted, pathL3FilterAccepted ) ) matches.push_back( *( triggerObjectMatch( i ) ) );
    }
    return matches;
  }

  template <class ObjectType>
  const TriggerObjectStandAlone * PATObject<ObjectType>::triggerObjectMatchByPath( const std::string & namePath, const bool pathLastFilterAccepted, const bool pathL3FilterAccepted, const size_t idx ) const {
    std::vector< size_t > refs;
    for ( size_t i = 0; i < triggerObjectMatches().size(); ++i ) {
      if ( triggerObjectMatch( i ) != 0 && triggerObjectMatch( i )->hasPathName( namePath, pathLastFilterAccepted, pathL3FilterAccepted ) ) refs.push_back( i );
    }
    if ( idx >= refs.size() ) return 0;
    TriggerObjectStandAloneRef ref( &triggerObjectMatchesEmbedded_, refs.at( idx ) );
    return ref.isNonnull() ? ref.get() : 0;
  }

  template <class ObjectType>
  const pat::LookupTableRecord &
  PATObject<ObjectType>::efficiency(const std::string &name) const {
    // find the name in the (sorted) list of names
    auto it = std::lower_bound(efficiencyNames_.cbegin(), efficiencyNames_.cend(), name);
    if ((it == efficiencyNames_.end()) || (*it != name)) {
        throw cms::Exception("Invalid Label") << "There is no efficiency with name '" << name << "' in this PAT Object\n";
    }
    return efficiencyValues_[std::distance(efficiencyNames_.cbegin(),it)];
  }

  template <class ObjectType>
  std::vector<std::pair<std::string,pat::LookupTableRecord> >
  PATObject<ObjectType>::efficiencies() const {
    std::vector<std::pair<std::string,pat::LookupTableRecord> > ret;
    std::vector<std::string>::const_iterator itn = efficiencyNames_.begin(), edn = efficiencyNames_.end();
    std::vector<pat::LookupTableRecord>::const_iterator itv = efficiencyValues_.begin();
    for ( ; itn != edn; ++itn, ++itv) {
        ret.emplace_back( *itn, *itv);
    }
    return ret;
  }

  template <class ObjectType>
  void PATObject<ObjectType>::setEfficiency(const std::string &name, const pat::LookupTableRecord & value) {
    // look for the name, or to the place where we can insert it without violating the alphabetic order
    auto it = std::lower_bound(efficiencyNames_.begin(), efficiencyNames_.end(), name);
    const auto dist = std::distance(efficiencyNames_.begin(),it);
    if (it == efficiencyNames_.end()) { // insert at the end
        efficiencyNames_.push_back(name);
        efficiencyValues_.push_back(value);
    } else if (*it == name) {           // replace existing
        efficiencyValues_[dist] = value;
    } else {                            // insert in the middle :-(
        efficiencyNames_. insert(it, name);
        efficiencyValues_.insert( efficiencyValues_.begin() + dist, value );
    }
  }

  template <class ObjectType>
  void PATObject<ObjectType>::setGenParticleRef(const reco::GenParticleRef &ref, bool embed) {
          genParticleRef_ = std::vector<reco::GenParticleRef>(1,ref);
          genParticleEmbedded_.clear();
          if (embed) embedGenParticle();
  }

  template <class ObjectType>
  void PATObject<ObjectType>::addGenParticleRef(const reco::GenParticleRef &ref) {
      if (!genParticleEmbedded_.empty()) { // we're embedding
          if (ref.isNonnull()) genParticleEmbedded_.push_back(*ref);
      } else {
          genParticleRef_.push_back(ref);
      }
  }

  template <class ObjectType>
  void PATObject<ObjectType>::setGenParticle( const reco::GenParticle &particle ) {
      genParticleEmbedded_.clear();
      genParticleEmbedded_.push_back(particle);
      genParticleRef_.clear();
  }

  template <class ObjectType>
  void PATObject<ObjectType>::embedGenParticle() {
      genParticleEmbedded_.clear();
      for (std::vector<reco::GenParticleRef>::const_iterator it = genParticleRef_.begin(); it != genParticleRef_.end(); ++it) {
          if (it->isNonnull()) genParticleEmbedded_.push_back(**it);
      }
      genParticleRef_.clear();
  }

  template <class ObjectType>
  std::vector<reco::GenParticleRef> PATObject<ObjectType>::genParticleRefs() const {
        if (genParticleEmbedded_.empty()) return genParticleRef_;
        std::vector<reco::GenParticleRef> ret(genParticleEmbedded_.size());
        for (size_t i = 0, n = ret.size(); i < n; ++i) {
            ret[i] = reco::GenParticleRef(&genParticleEmbedded_, i);
        }
        return ret;
  }

  template <class ObjectType>
  reco::GenParticleRef PATObject<ObjectType>::genParticleById(int pdgId, int status, uint8_t autoCharge) const {
        // get a vector, avoiding an unneeded copy if there is no embedding
        const std::vector<reco::GenParticleRef> & vec = (genParticleEmbedded_.empty() ? genParticleRef_ : genParticleRefs());
        for (std::vector<reco::GenParticleRef>::const_iterator ref = vec.begin(), end = vec.end(); ref != end; ++ref) {
            if (ref->isNonnull()) {
                const reco::GenParticle & g = **ref;
                if ((status != 0) && (g.status() != status)) continue;
                if (pdgId == 0) {
                    return *ref;
                } else if (!autoCharge) {
                    if (pdgId == g.pdgId()) return *ref;
                } else if (abs(pdgId) == abs(g.pdgId())) {
                    // I want pdgId > 0 to match "correct charge" (for charged particles)
                    if (g.charge() == 0) return *ref;
                    else if ((this->charge() == 0) && (pdgId == g.pdgId())) return *ref;
                    else if (g.charge()*this->charge()*pdgId > 0) return *ref;
                }
            }
        }
        return reco::GenParticleRef();
  }

  template <class ObjectType>
  bool PATObject<ObjectType>::hasOverlaps(const std::string &label) const {
        auto match = std::lower_bound(overlapLabels_.cbegin(), overlapLabels_.cend(), label);
        return ( match != overlapLabels_.end() && *match == label );
  }

  template <class ObjectType>
  const reco::CandidatePtrVector & PATObject<ObjectType>::overlaps(const std::string &label) const {
        
        auto match = std::lower_bound(overlapLabels_.cbegin(), overlapLabels_.cend(), label);
        if( match == overlapLabels_.cend() || *match != label ) return pat_statics::EMPTY_CPV;
        return overlapItems_[std::distance(overlapLabels_.begin(),match)];
  }

  template <class ObjectType>
  void PATObject<ObjectType>::setOverlaps(const std::string &label, const reco::CandidatePtrVector & overlaps) {
      
        auto match = std::lower_bound(overlapLabels_.begin(), overlapLabels_.end(), label);
        const auto dist = std::distance(overlapLabels_.begin(),match);
        if ( match == overlapLabels_.end() || *match != label ) {
          overlapLabels_.insert(match,label);
          overlapItems_.insert(overlapItems_.begin()+dist,overlaps);
        } else {
          overlapItems_[dist] = overlaps;
        }        
  }

  template <class ObjectType>
  const pat::UserData * PATObject<ObjectType>::userDataObject_( const std::string & key ) const
  {
    auto it = std::lower_bound(userDataLabels_.cbegin(),userDataLabels_.cend(),key);
    if ( it != userDataLabels_.cend() && *it == key) {
      return &userDataObjects_[std::distance(userDataLabels_.cbegin(),it)];
    }
    return nullptr;
  }

  template <class ObjectType>
  float PATObject<ObjectType>::userFloat( const std::string &key ) const
  {
    auto it = std::lower_bound(userFloatLabels_.cbegin(),userFloatLabels_.cend(),key);
    if( it != userFloatLabels_.cend() && *it == key ) {
      return userFloats_[std::distance(userFloatLabels_.cbegin(),it)];
    }
    throwMissingLabel("UserFloat",key,userFloatLabels_);
    return std::numeric_limits<float>::quiet_NaN();
  }

  template<class ObjectType>
  std::vector<float> PATObject<ObjectType>::userFloatRange( const std::string& key ) const {
    auto range = std::equal_range(userFloatLabels_.cbegin(),userFloatLabels_.cend(),key);
    std::vector<float> result;
    result.reserve(std::distance(range.first,range.second));
    for( auto it = range.first; it != range.second; ++it ) {
      result.push_back(userFloats_[std::distance(userFloatLabels_.cbegin(),it)]);
    }
    return result;
  }

  template <class ObjectType>
  void PATObject<ObjectType>::addUserFloat( const std::string & label,
                        float data,
                                            const bool overwrite )
  {
    auto it = std::lower_bound(userFloatLabels_.begin(),userFloatLabels_.end(),label);
    const auto dist = std::distance(userFloatLabels_.begin(),it);
    if( it == userFloatLabels_.end() || *it != label ) {      
      userFloatLabels_.insert(it,label);
      userFloats_.insert(userFloats_.begin()+dist,data);
    } else if( *it == label  ) {
      //create a range by adding behind the first entry
      userFloats_.insert(userFloats_.begin()+dist+1, data); 
    }
  }


  template <class ObjectType>
  int PATObject<ObjectType>::userInt( const std::string & key ) const
  {
    auto it = std::lower_bound(userIntLabels_.cbegin(), userIntLabels_.cend(), key);
    if ( it != userIntLabels_.cend() && *it == key ) {
      return userInts_[std::distance(userIntLabels_.cbegin(),it)];
    }
    throwMissingLabel("UserInt",key,userIntLabels_);
    return std::numeric_limits<int>::max();
  }

  template<class ObjectType>
  std::vector<int> PATObject<ObjectType>::userIntRange( const std::string& key ) const{
    auto range = std::equal_range(userIntLabels_.cbegin(),userIntLabels_.cend(),key);
    std::vector<int> result;
    result.reserve(std::distance(range.first,range.second));
    for( auto it = range.first; it != range.second; ++it ) {
      result.push_back(userInts_[std::distance(userIntLabels_.cbegin(),it)]);
    }
    return result;
  }

  template <class ObjectType>
  void PATObject<ObjectType>::addUserInt( const std::string &label,
                                          int data )
  {
    auto it = std::lower_bound(userIntLabels_.begin(),userIntLabels_.end(),label);
    const auto dist = std::distance(userIntLabels_.begin(),it);
    if( it == userIntLabels_.end() || *it != label ) { 
      userIntLabels_.insert(it,label);
      userInts_.insert(userInts_.begin()+dist,data);
    } else if( *it == label ) {
      //create a range by adding behind the first entry
      userInts_.insert(userInts_.begin()+dist+1,data);
    }
  }

  template <class ObjectType>
  reco::CandidatePtr PATObject<ObjectType>::userCand( const std::string & key ) const
  {
    auto it = std::lower_bound(userCandLabels_.cbegin(), userCandLabels_.cend(), key);
    if (it != userCandLabels_.cend()) {
      return userCands_[std::distance(userCandLabels_.begin(),it)];
    }
    return reco::CandidatePtr();
  }

  template <class ObjectType>
  void PATObject<ObjectType>::addUserCand( const std::string &label,
                       const reco::CandidatePtr & data,
                                           const bool overwrite )
  {
    auto it = std::lower_bound(userCandLabels_.begin(),userCandLabels_.end(),label);
    const auto dist = std::distance(userCandLabels_.begin(),it);
    if( it == userCandLabels_.end() || *it != label ) {      
      userCandLabels_.insert(it,label);
      userCands_.insert(userCands_.begin()+dist,data);
    } else if( overwrite && *it == label ) {
      userCands_[dist] = data;
    } else {
      edm::LogWarning("addUserCand") 
        << "Attempting to add userCand " << label << " failed, Ptr exists already!";
    }    
  }


  template <class ObjectType>
  const pat::CandKinResolution & PATObject<ObjectType>::getKinResolution(const std::string &label) const {
    const bool has_unlabelled = (kinResolutionLabels_.size()+1 == kinResolutions_.size());
    if (label.empty()) {
        if ( has_unlabelled ) {
            return kinResolutions_[0];
        } else {
            throw cms::Exception("Missing Data", "This object does not contain an un-labelled kinematic resolution");
        }
    } else {
        auto match = std::lower_bound(kinResolutionLabels_.cbegin(), kinResolutionLabels_.cend(), label);
        const auto dist = std::distance(kinResolutionLabels_.begin(),match);
        const size_t increment = ( has_unlabelled ? 1 : 0 );
        if ( match == kinResolutionLabels_.end() || *match != label ) {
            cms::Exception ex("Missing Data");
            ex << "This object does not contain a kinematic resolution with name '" << label << "'.\n";
            ex << "The known labels are: " ;
            for (std::vector<std::string>::const_iterator it = kinResolutionLabels_.cbegin(); it != kinResolutionLabels_.cend(); ++it) {
                ex << "'" << *it << "' ";
            }
            ex << "\n";
            throw ex;
        } else {           
            return kinResolutions_[dist+increment];          
        }
    }
  }

  template <class ObjectType>
  bool PATObject<ObjectType>::hasKinResolution(const std::string &label) const {
    if (label.empty()) {
        return (kinResolutionLabels_.size()+1 == kinResolutions_.size());
    } else {
        auto match = std::lower_bound(kinResolutionLabels_.cbegin(), kinResolutionLabels_.cend(), label);
        return ( match != kinResolutionLabels_.cend() && *match == label );
    }
  }

  template <class ObjectType>
  void PATObject<ObjectType>::setKinResolution(const pat::CandKinResolution &resol, const std::string &label) {
    const bool has_unlabelled = (kinResolutionLabels_.size()+1 == kinResolutions_.size());
    if (label.empty()) {
        if (has_unlabelled) {
            // There is already an un-labelled object. Replace it
            kinResolutions_[0] = resol;
        } else {
            // Insert. Note that the un-labelled is always the first, so we need to insert before begin()
            // (for an empty vector, this should not cost more than push_back)
            kinResolutions_.insert(kinResolutions_.begin(), resol);
        }
    } else {
        auto match = std::lower_bound(kinResolutionLabels_.begin(), kinResolutionLabels_.end(), label);
        const auto dist = std::distance(kinResolutionLabels_.begin(),match);
        const size_t increment = ( has_unlabelled ? 1 : 0 );
        if ( match != kinResolutionLabels_.end() && *match == label ) {
            // Existing object: replace
            kinResolutions_[dist+increment] = resol;
        } else {
            kinResolutionLabels_.insert(match,label);
            kinResolutions_.insert(kinResolutions_.begin()+dist+increment,resol);
        }
    }
  }




}

#endif