GenXSecAnalyzer.h

Go to the documentation of this file.

#ifndef GENXSECANALYZER_H
#define GENXSECANALYZER_H

// $Revision://

// analyzer of a summary information product on filter efficiency for a user specified path
// meant for the generator filter efficiency calculation


// system include files
#include <memory>
#include <vector>
#include <map>

// user include files
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/one/EDAnalyzer.h"

#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/Run.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/LuminosityBlock.h"
#include "FWCore/Utilities/interface/InputTag.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "SimDataFormats/GeneratorProducts/interface/GenLumiInfoProduct.h"
#include "SimDataFormats/GeneratorProducts/interface/GenFilterInfo.h"
#include "SimDataFormats/GeneratorProducts/interface/LHERunInfoProduct.h"

//
// class declaration
//

class GenXSecAnalyzer : public edm::one::EDAnalyzer<edm::one::WatchRuns,edm::one::WatchLuminosityBlocks>{


public:
  explicit GenXSecAnalyzer(const edm::ParameterSet&);
  ~GenXSecAnalyzer() override;
  const double final_xsec_value() const {return xsec_.value();}
  const double final_xsec_error() const {return xsec_.error();}
  
private:

  void beginJob() override;
  void beginRun(edm::Run const&, edm::EventSetup const&) override;
  void beginLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) override;
  void analyze(const edm::Event&, const edm::EventSetup&) override;
  void endLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) override;
  void endRun(edm::Run const&, edm::EventSetup const&) override;
  void endJob() override;
  // computation of cross section after matching and before HepcFilter and GenFilter
  GenLumiInfoProduct::XSec compute(const GenLumiInfoProduct &);
  // combination of cross section from different MCs after matching (could be either before or after HepcFilter and GenFilter)
  void combine(GenLumiInfoProduct::XSec&, double&, const GenLumiInfoProduct::XSec&, const double&);
  void combine(double&, double&, double&, const double&, const double&, const double &);

  edm::EDGetTokenT<GenFilterInfo> genFilterInfoToken_;
  edm::EDGetTokenT<GenFilterInfo> hepMCFilterInfoToken_;
  edm::EDGetTokenT<GenLumiInfoProduct> genLumiInfoToken_;
  edm::EDGetTokenT<LHERunInfoProduct> lheRunInfoToken_;
  
  // ----------member data --------------------------

  int nMCs_;

  int hepidwtup_;

  // for weight before GenFilter and HepMCFilter and before matching
  double totalWeightPre_;
  double thisRunWeightPre_;

  // for weight after GenFilter and HepMCFilter and after matching
  double totalWeight_;
  double thisRunWeight_;

  // combined cross sections before HepMCFilter and GenFilter
  GenLumiInfoProduct::XSec xsecPreFilter_;

  // final combined cross sections
  GenLumiInfoProduct::XSec xsec_;

  // GenLumiInfo before HepMCFilter and GenFilter, this is used 
  // for computation
  GenLumiInfoProduct product_; 

  // statistics from additional generator filter, for computation
  // reset for each run
  GenFilterInfo  filterOnlyEffRun_;     

  // statistics from HepMC filter, for computation
  GenFilterInfo  hepMCFilterEffRun_;   

  // statistics from additional generator filter, for print-out only
  GenFilterInfo  filterOnlyEffStat_;     

  // statistics from HepMC filter, for print-out only
  GenFilterInfo  hepMCFilterEffStat_;   


  // the vector/map size is the number of LHE processes + 1
  // needed only for printouts, not used for computation
  // only printed out when combining the same physics process 
  // uncertainty-averaged cross sections before matching
  std::vector<GenLumiInfoProduct::XSec> xsecBeforeMatching_;
  // uncertainty-averaged cross sections after matching
  std::vector<GenLumiInfoProduct::XSec> xsecAfterMatching_; 
  // statistics from jet matching
  std::map<int, GenFilterInfo>  jetMatchEffStat_; 


  // the following vectors all have the same size
  // LHE or Pythia/Herwig cross section of previous luminosity block
  // vector size = number of processes, used for computation
  std::map<int, GenLumiInfoProduct::XSec> previousLumiBlockLHEXSec_;

 // LHE or Pythia/Herwig combined cross section of current luminosity block
 // updated for each luminosity block, initialized in every run
  // used for computation
  std::map<int, GenLumiInfoProduct::XSec> currentLumiBlockLHEXSec_;



};

#endif