PFBlockAlgo.h

Go to the documentation of this file.

#ifndef RecoParticleFlow_PFProducer_PFBlockAlgo_h
#define RecoParticleFlow_PFProducer_PFBlockAlgo_h 

#include <set>
#include <vector>
#include <iostream>

// #include "FWCore/Framework/interface/Handle.h"
#include "DataFormats/Common/interface/Handle.h"
// #include "FWCore/Framework/interface/OrphanHandle.h"
#include "DataFormats/Common/interface/OrphanHandle.h"


#include "DataFormats/ParticleFlowReco/interface/PFClusterFwd.h"
#include "DataFormats/ParticleFlowReco/interface/PFRecTrackFwd.h"
#include "DataFormats/ParticleFlowReco/interface/PFCluster.h"
#include "DataFormats/ParticleFlowReco/interface/PFRecTrack.h"
#include "DataFormats/ParticleFlowReco/interface/PFDisplacedTrackerVertex.h" // gouzevitch
#include "DataFormats/ParticleFlowReco/interface/PFConversionFwd.h"
#include "DataFormats/ParticleFlowReco/interface/PFConversion.h"
#include "DataFormats/ParticleFlowReco/interface/PFV0Fwd.h"
#include "DataFormats/ParticleFlowReco/interface/PFV0.h"
#include "DataFormats/ParticleFlowReco/interface/GsfPFRecTrack.h"
#include "DataFormats/ParticleFlowReco/interface/GsfPFRecTrackFwd.h"
#include "DataFormats/ParticleFlowReco/interface/PFBrem.h"
#include "DataFormats/ParticleFlowReco/interface/PFTrajectoryPoint.h"

#include "DataFormats/ParticleFlowReco/interface/PFBlockElement.h"
#include "DataFormats/ParticleFlowReco/interface/PFBlock.h"
#include "DataFormats/ParticleFlowReco/interface/PFBlockFwd.h"

// Glowinski & Gouzevitch
#include "DataFormats/ParticleFlowReco/interface/PFRecHit.h"             
#include "RecoParticleFlow/PFProducer/interface/KDTreeLinkerBase.h" 
// !Glowinski & Gouzevitch

// #include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h"

#include "RecoParticleFlow/PFProducer/interface/PFMuonAlgo.h"
#include "RecoParticleFlow/PFProducer/interface/PhotonSelectorAlgo.h"
#include "RecoParticleFlow/PFProducer/interface/PFBlockElementSCEqual.h"
#include "RecoParticleFlow/PFClusterTools/interface/PFResolutionMap.h"

#include "DataFormats/MuonReco/interface/MuonFwd.h"
#include "DataFormats/MuonReco/interface/Muon.h"
#include "DataFormats/EgammaReco/interface/SuperClusterFwd.h"
#include "DataFormats/EgammaReco/interface/SuperCluster.h"
#include "DataFormats/GsfTrackReco/interface/GsfTrackFwd.h"
#include "DataFormats/GsfTrackReco/interface/GsfTrack.h"
#include "DataFormats/EgammaReco/interface/ElectronSeedFwd.h"
#include "DataFormats/EgammaReco/interface/ElectronSeed.h"
#include "DataFormats/EgammaCandidates/interface/PhotonFwd.h"
#include "DataFormats/EgammaCandidates/interface/Photon.h"
#include "DataFormats/ParticleFlowReco/interface/PFBlockElementSuperCluster.h"

#include "RecoParticleFlow/PFClusterTools/interface/ClusterClusterMapping.h"

#include "RecoParticleFlow/PFProducer/interface/PFBlockLink.h"

#include "RecoParticleFlow/PFProducer/interface/BlockElementLinkerBase.h"
#include "RecoParticleFlow/PFProducer/interface/BlockElementImporterBase.h"

#include <map>
#include <unordered_map>

namespace std {
  template<>
    struct hash<std::pair<size_t,size_t> > {
    typedef std::pair<size_t,size_t> arg_type;
    typedef std::size_t value_type;
    value_type operator()(const arg_type& arg) const {
      return arg.first ^ (arg.second << 1);
    }
  };
  template<>
    struct equal_to<std::pair<size_t,size_t> > {
    typedef std::pair<size_t,size_t> arg_type;    
    bool operator()(const arg_type& arg1, const arg_type& arg2) const {
      return (arg1.first == arg2.first && arg1.second == arg2.second);
    }
  };
}


class PFBlockAlgo {

 public:
  // the element list should **always** be a list of (smart) pointers
  typedef std::vector<std::unique_ptr<reco::PFBlockElement> > ElementList;
  typedef std::unique_ptr<BlockElementImporterBase> ImporterPtr;
  typedef std::unique_ptr<BlockElementLinkerBase> LinkTestPtr;  
  typedef std::unique_ptr<KDTreeLinkerBase> KDTreePtr;
  typedef ElementList::iterator IE;
  typedef ElementList::const_iterator IEC;  
  typedef reco::PFBlockCollection::const_iterator IBC;
  
  PFBlockAlgo();

  ~PFBlockAlgo();
    
  void setLinkers(const std::vector<edm::ParameterSet>&);

  void setImporters(const std::vector<edm::ParameterSet>&,
            edm::ConsumesCollector&);
  
  // update event setup info of all linkers
  void updateEventSetup(const edm::EventSetup&);

  // run all of the importers and build KDtrees
  void buildElements(const edm::Event&);
  
  void findBlocks();

  void setDebug( bool debug ) {debug_ = debug;}
  
  /*   const  reco::PFBlockCollection& blocks() const {return *blocks_;} */
  const std::auto_ptr< reco::PFBlockCollection >& blocks() const 
    {return blocks_;}
  
  std::auto_ptr< reco::PFBlockCollection > transferBlocks() {return blocks_;}

  
  
 private:
  // flattened version of topological
  // association of block elements
  IE associate( ElementList& elems,
        std::unordered_map<std::pair<size_t,size_t>,PFBlockLink>& links,
        reco::PFBlock& );

  void packLinks(reco::PFBlock& block, 
         const std::unordered_map<std::pair<size_t,size_t>,PFBlockLink>& links) const; 
  
  inline bool linkPrefilter(const reco::PFBlockElement* last, 
                const reco::PFBlockElement* next) const;

  inline void link( const reco::PFBlockElement* el1, 
            const reco::PFBlockElement* el2, 
            PFBlockLink::Type& linktype, 
            reco::PFBlock::LinkTest& linktest,
            double& dist) const;
      
  std::auto_ptr< reco::PFBlockCollection >    blocks_;
  
  // the test elements will be transferred to the blocks
  ElementList     elements_; 
  
  bool   debug_;
  
  friend std::ostream& operator<<(std::ostream&, const PFBlockAlgo&);
  bool useHO_;

  std::vector<ImporterPtr> _importers;

  const std::unordered_map<std::string,reco::PFBlockElement::Type> 
    _elementTypes;
  std::vector<LinkTestPtr> _linkTests;
  
  std::vector<KDTreePtr> _kdtrees;
};

#include "DataFormats/ParticleFlowReco/interface/PFBlockElementGsfTrack.h"
#include "DataFormats/ParticleFlowReco/interface/PFBlockElementBrem.h"
#include "DataFormats/ParticleFlowReco/interface/PFBlockElementTrack.h"
#include "DataFormats/ParticleFlowReco/interface/PFBlockElementCluster.h"
#include "DataFormats/ParticleFlowReco/interface/PFLayer.h"

#endif