---

PFRootEventManager.h

Go to the documentation of this file.

#ifndef RecoParticleFlow_PFRootEvent_PFRootEventManager_h
#define RecoParticleFlow_PFRootEvent_PFRootEventManager_h

#include "SimDataFormats/HepMCProduct/interface/HepMCProduct.h"

#include "DataFormats/ParticleFlowReco/interface/PFRecHit.h"
#include "DataFormats/ParticleFlowReco/interface/PFRecHitFwd.h"

#include "DataFormats/ParticleFlowReco/interface/PFCluster.h"
#include "DataFormats/ParticleFlowReco/interface/PFClusterFwd.h"

#include "DataFormats/ParticleFlowReco/interface/PFTrajectoryPoint.h"

#include "DataFormats/ParticleFlowReco/interface/PFRecTrack.h"
#include "DataFormats/ParticleFlowReco/interface/PFRecTrackFwd.h"
#include "DataFormats/TrackReco/interface/Track.h"
#include "DataFormats/TrackReco/interface/TrackFwd.h"
#include "DataFormats/ParticleFlowReco/interface/GsfPFRecTrack.h"
#include "DataFormats/ParticleFlowReco/interface/GsfPFRecTrackFwd.h"

#include "DataFormats/ParticleFlowReco/interface/PFSimParticle.h"
#include "DataFormats/ParticleFlowReco/interface/PFSimParticleFwd.h"

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

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

#include "DataFormats/MuonReco/interface/MuonFwd.h"
#include "DataFormats/MuonReco/interface/Muon.h"

#include "DataFormats/ParticleFlowReco/interface/PFNuclearInteraction.h"

#include "DataFormats/ParticleFlowReco/interface/PFConversion.h"
#include "DataFormats/ParticleFlowReco/interface/PFConversionFwd.h"
#include "DataFormats/ParticleFlowReco/interface/PFV0.h"
#include "DataFormats/ParticleFlowReco/interface/PFV0Fwd.h"

#include "DataFormats/Candidate/interface/CandidateFwd.h"
#include "DataFormats/HepMCCandidate/interface/GenParticle.h"
#include "DataFormats/HepMCCandidate/interface/GenParticleFwd.h"
#include "PhysicsTools/CandUtils/interface/pdgIdUtils.h"

#include "DataFormats/EgammaReco/interface/BasicCluster.h"
#include "DataFormats/CaloTowers/interface/CaloTower.h"
#include "DataFormats/CaloTowers/interface/CaloTowerFwd.h"

#include "RecoParticleFlow/PFClusterAlgo/interface/PFClusterAlgo.h"
#include "RecoParticleFlow/PFBlockAlgo/interface/PFBlockAlgo.h"
#include "RecoParticleFlow/PFAlgo/interface/PFAlgo.h"

#include "RecoParticleFlow/PFRootEvent/interface/PFJetAlgorithm.h"
#include "RecoParticleFlow/Benchmark/interface/PFJetBenchmark.h"

#include "RecoParticleFlow/PFRootEvent/interface/FWLiteJetProducer.h"
#include "DataFormats/JetReco/interface/BasicJetCollection.h"
#include "DataFormats/JetReco/interface/PFJetCollection.h"
#include "DataFormats/JetReco/interface/PFJet.h"
#include "DataFormats/JetReco/interface/CaloJetCollection.h"

#include <TObject.h>
#include "TEllipse.h"
#include "TBox.h"

#include <string>
#include <map>
#include <set>
#include <vector>
#include <memory>

class TTree;
class TBranch;
class TFile;
class TCanvas;
class TH2F;
class TH1F;


class IO;


class PFBlockElement;

class EventColin;
class PFEnergyCalibration;
class PFEnergyResolution;

typedef std::pair<double, unsigned> simMatch;
typedef std::list< std::pair<double, unsigned> >::iterator ITM;


class PFRootEventManager {

 public:

  enum View_t { XY = 0, RZ = 1, EPE = 2, EPH = 3, NViews = 4 };
  enum Verbosity {SHUTUP = 0, VERBOSE};

  PFRootEventManager();
  
  PFRootEventManager(const char* file);

  virtual ~PFRootEventManager();
  
  virtual void write();
  
  void reset();

  std::string getGenParticleName(int partId,std::string &latexStringName) const;
  
                         
  void readOptions(const char* file, 
                   bool refresh=true,
                   bool reconnect=false);


  virtual void readSpecificOptions(const char* file) {}
  
  void connect(const char* infilename="");

  void setAddresses();
  
  virtual bool processEntry(int entry);

  bool readFromSimulation(int entry);

  bool isHadronicTau() const;

  bool countChargedAndPhotons() const;
  
  int chargeValue(const int& pdgId) const;
   
  
  void PreprocessRecTracks( reco::PFRecTrackCollection& rectracks); 
  void PreprocessRecTracks( reco::GsfPFRecTrackCollection& rectracks); 
  
  void PreprocessRecHits( reco::PFRecHitCollection& rechits, 
                          bool findNeighbours);
  
  void setRecHitNeigbours( reco::PFRecHit& rh, 
                           const std::map<unsigned, unsigned>& detId2index );

  //  bool readFromRealData(int entry);

  void clustering();

  void particleFlow();

  void reconstructGenJets();   

  void reconstructCaloJets();   
  
  void reconstructPFJets();
  

  void reconstructFWLiteJets(const reco::CandidatePtrVector& Candidates,
                             std::vector<ProtoJet>& output);

  void mcTruthMatching( std::ostream& out,
                        const reco::PFCandidateCollection& candidates,
                        std::vector< std::list <simMatch> >& candSimMatchTrack,
                        std::vector< std::list <simMatch> >&  candSimMatchEcal) const;

  double tauBenchmark( const reco::PFCandidateCollection& candidates);


  void fillOutEventWithClusters(const reco::PFClusterCollection& clusters);

  void fillOutEventWithPFCandidates(const reco::PFCandidateCollection& pfCandidates );

  void fillOutEventWithSimParticles(const reco::PFSimParticleCollection& ptcs);

  void fillOutEventWithCaloTowers(const CaloTowerCollection& cts);

  void fillOutEventWithBlocks(const reco::PFBlockCollection& blocks);
  


  void   print(  std::ostream& out = std::cout,
                 int maxNLines = -1 ) const;


  TTree* tree() {return tree_;}

  // protected:

  // expand environment variable in a string
  std::string  expand(const std::string& oldString) const;

  void   printRecHit(const reco::PFRecHit& rh, 
                     const char* seed="    ",
                     std::ostream& out = std::cout) const;
  
  void   printCluster(const reco::PFCluster& cluster,
                      std::ostream& out = std::cout) const;

  

  void printGenParticles(std::ostream& out = std::cout,
                         int maxNLines = -1) const;
                         
  
  /*   /// is inside cut G?  */
  /*   bool   insideGCut(double eta, double phi) const; */
  
  bool trackInsideGCut( const reco::PFTrack& track ) const;
  
  void fillRecHitMask( std::vector<bool>& mask, 
                       const reco::PFRecHitCollection& rechits ) const;
                       
  void fillClusterMask( std::vector<bool>& mask, 
                        const reco::PFClusterCollection& clusters ) const;

  void fillTrackMask( std::vector<bool>& mask, 
                      const reco::PFRecTrackCollection& tracks ) const;
  void fillTrackMask( std::vector<bool>& mask, 
                      const reco::GsfPFRecTrackCollection& tracks ) const;
                       
  const reco::PFSimParticle& 
    closestParticle( reco::PFTrajectoryPoint::LayerType  layer, 
                     double eta, double phi, 
                     double& peta, double& pphi, double& pe) const;
                     
  
  const  reco::PFBlockCollection& blocks() const { return *pfBlocks_; }

  
  int eventNumber()   {return iEvent_;}

  /*   std::vector<int> getViewSizeEtaPhi() {return viewSizeEtaPhi_;} */
  /*   std::vector<int> getViewSize()       {return viewSize_;} */
  
  void readCMSSWJets();
  
  
  
  // data members -------------------------------------------------------

  int         iEvent_;
  
  IO*         options_;      
  
  TTree*      tree_;          
  
  TTree*      outTree_;

  EventColin* outEvent_;

  TH1F*            h_deltaETvisible_MCEHT_;

  TH1F*            h_deltaETvisible_MCPF_;
 

  // MC branches --------------------------
  
  TBranch*   hitsBranch_;          
  
  TBranch*   rechitsECALBranch_;          
  
  TBranch*   rechitsHCALBranch_;          
  
  TBranch*   rechitsPSBranch_;          

  TBranch*   clustersECALBranch_;          
  
  TBranch*   clustersHCALBranch_;          
   
  TBranch*   clustersPSBranch_;          

  TBranch*   clustersIslandBarrelBranch_;

  TBranch* caloTowersBranch_;
  
  TBranch*   recTracksBranch_;          
  
  TBranch*   stdTracksBranch_;          
  
  TBranch*   gsfrecTracksBranch_;

  TBranch*   muonsBranch_; 
  
  TBranch*   nuclearBranch_; 

  TBranch*   conversionBranch_; 

  TBranch*   v0Branch_;


  TBranch*   trueParticlesBranch_;          

  TBranch*   MCTruthBranch_;          

  TBranch*   genParticlesforJetsBranch_;

  TBranch*   caloTowerBaseCandidatesBranch_;
  
  TBranch*   genJetBranch_;
  
  TBranch*   recCaloBranch_;
  
  TBranch*   recPFBranch_;

  
  
  reco::PFRecHitCollection rechitsECAL_;

  reco::PFRecHitCollection rechitsHCAL_;

  reco::PFRecHitCollection rechitsPS_;

  std::auto_ptr< reco::PFClusterCollection > clustersECAL_;

  std::auto_ptr< reco::PFClusterCollection > clustersHCAL_;

  std::auto_ptr< reco::PFClusterCollection > clustersPS_;

  std::vector<reco::BasicCluster>  clustersIslandBarrel_;
  
  CaloTowerCollection     caloTowers_;

  reco::CandidatePtrVector caloTowersPtrs_;

  reco::PFRecTrackCollection    recTracks_;

  reco::GsfPFRecTrackCollection  gsfrecTracks_; 
  
  reco::TrackCollection    stdTracks_;
  
    reco::MuonCollection  muons_;

  reco::PFNuclearInteractionCollection nuclear_;

  reco::PFConversionCollection conversion_;
  
  reco::PFV0Collection v0_;

  reco::PFSimParticleCollection trueParticles_;

  edm::HepMCProduct MCTruth_;
  
  std::auto_ptr< reco::PFBlockCollection >   pfBlocks_;

  std::auto_ptr< reco::PFCandidateCollection > pfCandidates_;
  
  reco::CandidatePtrVector pfCandidatesPtrs_;

  reco::GenParticleRefVector genParticlesforJets_;
  
  reco::CandidatePtrVector genParticlesforJetsPtrs_;

/*   /// calo tower base candidates (input for calo jets) */
/*   reco::CandidateCollection caloTowerBaseCandidates_; */

  reco::PFJetCollection pfJets_;

  reco::GenJetCollection genJets_;

  std::vector<ProtoJet> caloJets_;

  reco::PFJetCollection pfJetsCMSSW_;

  reco::GenJetCollection genJetsCMSSW_;

  std::vector<reco::CaloJet> caloJetsCMSSW_;
  TFile*     file_; 

  std::string     inFileName_;   

  TFile*     outFile_;

  std::string     outFileName_;   

  // algos --------------------------------------------------------
  
  PFClusterAlgo   clusterAlgoECAL_;

  PFClusterAlgo   clusterAlgoHCAL_;

  PFClusterAlgo   clusterAlgoPS_;


  PFBlockAlgo     pfBlockAlgo_;

  PFAlgo          pfAlgo_;

  PFJetBenchmark PFJetBenchmark_;

  PFJetAlgorithm  jetAlgo_;
  
  FWLiteJetProducer jetMaker_;


  //----------------- print flags --------------------------------

  bool                     printRecHits_;

  bool                     printClusters_;

  bool                     printPFBlocks_;

  bool                     printPFCandidates_; 

  bool                     printPFJets_;
  
  bool                     printSimParticles_;

  bool                     printGenParticles_;

  // print MC truth matching with PFCandidate yes/no
  bool                     printMCTruthMatching_;

  int                      verbosity_;

  //----------------- filter ------------------------------------
  
  unsigned                 filterNParticles_;
  
  bool                     filterHadronicTaus_;

  std::vector<int>         filterTaus_;

  // --------

  bool   doClustering_;

  bool   doParticleFlow_;

  bool   doJets_;
  
  int    jetAlgoType_;

  bool   doTauBenchmark_;

  bool   tauBenchmarkDebug_;
  
  bool   doPFJetBenchmark_;

  bool   debug_;  

  bool   findRecHitNeighbours_;

  
  bool   jetsDebug_;
      

  bool  fastsim_;

  bool   useNuclear_;

  bool   useConversions_;  

  bool   useV0_;

  // MC Truth tools              ---------------------------------------

  /*   TDatabasePDG*   pdgTable_; */

};
#endif

---