/data/refman/pasoursint/CMSSW_4_1_8_patch13/src/RecoParticleFlow/PFRootEvent/interface/PFRootEventManager.h

Go to the documentation of this file.

#ifndef RecoParticleFlow_PFRootEvent_PFRootEventManager_h
#define RecoParticleFlow_PFRootEvent_PFRootEventManager_h

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

#include "DataFormats/Provenance/interface/EventAuxiliary.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/VertexReco/interface/VertexFwd.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/PFDisplacedTrackerVertex.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 "CommonTools/CandUtils/interface/pdgIdUtils.h"

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

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

#include "RecoParticleFlow/PFRootEvent/interface/PFJetAlgorithm.h"
#include "RecoParticleFlow/Benchmark/interface/PFJetBenchmark.h"
#include "RecoParticleFlow/Benchmark/interface/PFMETBenchmark.h"
#include "DQMOffline/PFTau/interface/PFCandidateManager.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 "DataFormats/METReco/interface/PFMETCollection.h"
#include "DataFormats/METReco/interface/PFMET.h"
#include "DataFormats/METReco/interface/CaloMETCollection.h"
#include "DataFormats/METReco/interface/CaloMET.h"
#include "DataFormats/METReco/interface/METCollection.h"
#include "DataFormats/METReco/interface/MET.h"

#include "RecoParticleFlow/PFRootEvent/interface/METManager.h"


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

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

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


class IO;


class PFBlockElement;

class EventColin;
class PFEnergyCalibration;
class PFEnergyCalibrationHF;
class PFEnergyResolution;

namespace pftools { 
  class PFClusterCalibration;
}

class METManager;

// NEW
namespace fwlite {
  class ChainEvent;
}

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();
  
  void initializeEventInformation();

  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="");

  int eventToEntry(int run, int lumi, int event) const;
  
  virtual bool processEvent(int run, int lumi, int event); 

  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 pfCandCompare(int);

  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;

  void   printMCCalib(  std::ofstream& out ) const;


  TTree* tree() {return tree_;}

  // protected:

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

  void printRecHits(const reco::PFRecHitCollection& rechits, 
                    const PFClusterAlgo& clusterAlgo,
                    std::ostream& out = std::cout) const;

  void   printRecHit(const reco::PFRecHit& rh, unsigned index, 
                     const char* seed="    ",
                     std::ostream& out = std::cout) const;
  
  void   printClusters(const reco::PFClusterCollection& clusters,
                      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();  
  
  bool eventAccepted() const;

  bool highPtJet( double ptMin ) const; 

  bool highPtPFCandidate( double ptMin, 
                          reco::PFCandidate::ParticleType type = reco::PFCandidate::X) const;

  edm::InputTag stringToTag(const std::vector< std::string >& tagname); 
  // data members -------------------------------------------------------

  int         iEvent_;
  
  IO*         options_;      
  
  fwlite::ChainEvent* ev_;

  TTree*      tree_;          
  
  TTree*      outTree_;

  EventColin* outEvent_;

  TH1F*            h_deltaETvisible_MCEHT_;

  TH1F*            h_deltaETvisible_MCPF_;
 


  // branches --------------------------
  
  TBranch*   eventAuxiliaryBranch_;

  edm::EventAuxiliary*      eventAuxiliary_;

  edm::Handle<reco::PFRecHitCollection> rechitsECALHandle_;
  edm::InputTag rechitsECALTag_;
  reco::PFRecHitCollection rechitsECAL_;

  edm::Handle<reco::PFRecHitCollection> rechitsHCALHandle_;
  edm::InputTag rechitsHCALTag_;
  reco::PFRecHitCollection rechitsHCAL_;

  edm::Handle<reco::PFRecHitCollection> rechitsHFEMHandle_;
  edm::InputTag rechitsHFEMTag_;
  reco::PFRecHitCollection rechitsHFEM_;

  edm::Handle<reco::PFRecHitCollection> rechitsHFHADHandle_;
  edm::InputTag rechitsHFHADTag_;
  reco::PFRecHitCollection rechitsHFHAD_;

  std::vector< reco::PFRecHitCollection > rechitsCLEANEDV_;
  std::vector< edm::Handle<reco::PFRecHitCollection> > rechitsCLEANEDHandles_;
  std::vector< edm::InputTag > rechitsCLEANEDTags_;
  reco::PFRecHitCollection rechitsCLEANED_;

  edm::Handle<reco::PFRecHitCollection> rechitsPSHandle_;
  edm::InputTag rechitsPSTag_;
  reco::PFRecHitCollection rechitsPS_;

  edm::Handle<reco::PFClusterCollection> clustersECALHandle_;
  edm::InputTag clustersECALTag_;
  std::auto_ptr< reco::PFClusterCollection > clustersECAL_;

  edm::Handle<reco::PFClusterCollection> clustersHCALHandle_;
  edm::InputTag clustersHCALTag_;
  std::auto_ptr< reco::PFClusterCollection > clustersHCAL_;

  edm::Handle<reco::PFClusterCollection> clustersHFEMHandle_;
  edm::InputTag clustersHFEMTag_;
  std::auto_ptr< reco::PFClusterCollection > clustersHFEM_;

  edm::Handle<reco::PFClusterCollection> clustersHFHADHandle_;
  edm::InputTag clustersHFHADTag_;
  std::auto_ptr< reco::PFClusterCollection > clustersHFHAD_;

  edm::Handle<reco::PFClusterCollection> clustersPSHandle_;
  edm::InputTag clustersPSTag_;
  std::auto_ptr< reco::PFClusterCollection > clustersPS_;

  edm::Handle<CaloTowerCollection> caloTowersHandle_;
  edm::InputTag caloTowersTag_;
  CaloTowerCollection     caloTowers_;

  reco::CandidatePtrVector caloTowersPtrs_;


  edm::Handle<reco::VertexCollection> primaryVerticesHandle_;
  edm::InputTag primaryVerticesTag_;
  reco::VertexCollection primaryVertices_;

  edm::Handle<reco::PFRecTrackCollection> recTracksHandle_;
  edm::Handle<reco::PFRecTrackCollection> displacedRecTracksHandle_;
  edm::InputTag recTracksTag_;
  edm::InputTag displacedRecTracksTag_;
  reco::PFRecTrackCollection    recTracks_;
  reco::PFRecTrackCollection    displacedRecTracks_;

  edm::Handle<reco::GsfPFRecTrackCollection> gsfrecTracksHandle_;
  edm::InputTag gsfrecTracksTag_;
  reco::GsfPFRecTrackCollection  gsfrecTracks_; 
  
  edm::Handle<reco::GsfPFRecTrackCollection> convBremGsfrecTracksHandle_;
  edm::InputTag convBremGsfrecTracksTag_;
  reco::GsfPFRecTrackCollection  convBremGsfrecTracks_; 

  edm::Handle<reco::TrackCollection> stdTracksHandle_;
  edm::InputTag stdTracksTag_;
  reco::TrackCollection    stdTracks_;
  
  edm::Handle<reco::MuonCollection> muonsHandle_;
  edm::InputTag muonsTag_;
  reco::MuonCollection  muons_;

  edm::Handle<reco::PFConversionCollection> conversionHandle_;
  edm::InputTag conversionTag_;
  reco::PFConversionCollection conversion_;
  
  edm::Handle<reco::PFV0Collection> v0Handle_;
  edm::InputTag v0Tag_;
  reco::PFV0Collection v0_;

  edm::Handle<reco::PFDisplacedTrackerVertexCollection> pfNuclearTrackerVertexHandle_;
  edm::InputTag pfNuclearTrackerVertexTag_;
  reco::PFDisplacedTrackerVertexCollection pfNuclearTrackerVertex_;

  edm::Handle<reco::PFSimParticleCollection> trueParticlesHandle_;
  edm::InputTag trueParticlesTag_;
  reco::PFSimParticleCollection trueParticles_;

  edm::Handle<edm::HepMCProduct> MCTruthHandle_;
  edm::InputTag MCTruthTag_;
  edm::HepMCProduct MCTruth_;
  
  edm::Handle<reco::GenParticleRefVector> genParticlesforJetsHandle_;
  edm::InputTag genParticlesforJetsTag_;
  reco::GenParticleRefVector genParticlesforJets_;
  
  reco::GenJetCollection genJets_;

  edm::Handle<reco::GenParticleCollection> genParticlesforMETHandle_;
  edm::InputTag genParticlesforMETTag_;
  reco::GenParticleCollection genParticlesCMSSW_;

  reco::CandidatePtrVector genParticlesforJetsPtrs_;

  std::auto_ptr< reco::PFBlockCollection >   pfBlocks_;

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

  reco::PFJetCollection pfJets_;

  std::vector<ProtoJet> caloJets_;

  edm::Handle<reco::PFJetCollection> pfJetsHandle_;
  edm::InputTag pfJetsTag_;
  reco::PFJetCollection pfJetsCMSSW_;

  edm::Handle<reco::GenJetCollection> genJetsHandle_;
  edm::InputTag genJetsTag_;
  reco::GenJetCollection genJetsCMSSW_;

  edm::Handle< std::vector<reco::CaloJet> >caloJetsHandle_;
  edm::InputTag caloJetsTag_;
  std::vector<reco::CaloJet> caloJetsCMSSW_;

  edm::Handle< std::vector<reco::CaloJet> > corrcaloJetsHandle_;
  edm::InputTag corrcaloJetsTag_;
  std::vector<reco::CaloJet> corrcaloJetsCMSSW_;

  reco::PFMETCollection pfMets_;

  reco::CaloMETCollection caloMets_;

  reco::METCollection tcMets_;

  edm::Handle<reco::CaloMETCollection> caloMetsHandle_;
  edm::InputTag caloMetsTag_;
  reco::CaloMETCollection caloMetsCMSSW_;

  edm::Handle<reco::METCollection> tcMetsHandle_;
  edm::InputTag tcMetsTag_;
  reco::METCollection tcMetsCMSSW_;

  edm::Handle<reco::PFMETCollection> pfMetsHandle_;
  edm::InputTag pfMetsTag_;
  reco::PFMETCollection pfMetsCMSSW_;

  edm::Handle<reco::PFCandidateCollection> pfCandidateHandle_;
  edm::InputTag pfCandidateTag_;
  reco::PFCandidateCollection pfCandCMSSW_;

  TFile*     file_; 

  std::vector<std::string> inFileNames_;

  TFile*     outFile_;

  std::string     outFileName_;   

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

  PFClusterAlgo   clusterAlgoHCAL_;

  PFClusterAlgo   clusterAlgoHFEM_;

  PFClusterAlgo   clusterAlgoHFHAD_;

  PFClusterAlgo   clusterAlgoPS_;


  PFBlockAlgo     pfBlockAlgo_;

  PFAlgo          pfAlgo_;

  // ------------------- benchmarks -------------------------------
  
  PFJetBenchmark PFJetBenchmark_;

  double MET1cut;
  double DeltaMETcut;
  double DeltaPhicut;

  PFCandidateManager   pfCandidateManager_;
  bool                 doPFCandidateBenchmark_;

  PFJetAlgorithm  jetAlgo_;
  
  FWLiteJetProducer jetMaker_;


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

  bool                     printRecHits_;
  double                   printRecHitsEMin_;

  bool                     printClusters_;
  double                   printClustersEMin_;

  bool                     printPFBlocks_;

  bool                     printPFCandidates_; 
  double                   printPFCandidatesPtMin_; 

  bool                     printPFJets_;
  double                   printPFJetsPtMin_;
  
  bool                     printSimParticles_;
  double                   printSimParticlesPtMin_;

  bool                     printGenParticles_;
  double                   printGenParticlesPtMin_;

  // 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   doCompare_;

  bool   doJets_;

  bool   doMet_;  

  bool JECinCaloMet_;

  int    jetAlgoType_;

  bool   doTauBenchmark_;

  bool   tauBenchmarkDebug_;
  
  bool   doPFJetBenchmark_;

  bool doPFMETBenchmark_; 

  bool   debug_;  

  bool   findRecHitNeighbours_;

  
  bool   jetsDebug_;
      

  bool  fastsim_;

  bool   usePFConversions_;  

  bool   usePFV0s_;

  bool   usePFNuclearInteractions_;

  bool useConvBremGsfTracks_;

  bool useConvBremPFRecTracks_;

  bool useAtHLT;

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

  /*   TDatabasePDG*   pdgTable_; */

  // Needed for single particle calibration rootTuple
  boost::shared_ptr<pftools::PFClusterCalibration> clusterCalibration_;
  boost::shared_ptr<PFEnergyCalibration> calibration_;
  boost::shared_ptr<PFEnergyCalibrationHF> thepfEnergyCalibrationHF_;

  std::ofstream* calibFile_; 
  
  std::auto_ptr<METManager>   metManager_; 
  
  typedef std::map<int, int>  EventToEntry;
  typedef std::map<int, EventToEntry> LumisMap;
  typedef std::map<int, LumisMap> RunsMap;
  RunsMap  mapEventToEntry_;
};
#endif