#include <PFMETBenchmark.h>

Public Member Functions
void	analyse ()
void	calculateQuantities (const reco::PFMETCollection &, const reco::GenParticleCollection &, const reco::CaloMETCollection &, const reco::METCollection &)
void	calculateQuantities (const reco::PFMETCollection &, const reco::GenParticleCollection &, const reco::CaloMETCollection &, const reco::METCollection &, const std::vector< reco::CaloJet >, const std::vector< reco::CaloJet >)
float	getCaloMET ()
float	getCaloMEX ()
float	getCaloMEY ()
float	getCaloPhi ()
float	getCaloSET ()
float	getDeltaCaloMET ()
float	getDeltaCaloPhi ()
float	getDeltaCaloSET ()
float	getDeltaPFMET ()
float	getDeltaPFPhi ()
float	getDeltaPFSET ()
float	getDeltaTCMET ()
float	getDeltaTCPhi ()
float	getDeltaTCSET ()
float	getPFMET ()
float	getPFMEX ()
float	getPFMEY ()
float	getPFPhi ()
float	getPFSET ()
float	getTCMET ()
float	getTCMEX ()
float	getTCMEY ()
float	getTCPhi ()
float	getTCSET ()
float	getTrueMET ()
float	getTruePhi ()
float	getTrueSET ()
double	mpi_pi (double angle)
	PFMETBenchmark ()
void	process (const reco::PFMETCollection &, const reco::GenParticleCollection &, const reco::CaloMETCollection &, const reco::METCollection &)
void	setup (std::string Filename, bool debug, bool plotAgainstReco=0, std::string benchmarkLabel_="ParticleFlow", DQMStore *dbe_store=NULL)
void	write ()
virtual	~PFMETBenchmark ()
Protected Attributes
PFBenchmarkAlgo *	algo_
DQMStore *	dbe_
bool	debug_
bool	plotAgainstReco_
Private Attributes
double	calo_met
double	calo_mex
double	calo_mey
double	calo_phi
double	calo_set
TFile *	file_
TH1F *	hCaloMET
TH2F *	hCaloMETvstrueMET
TH1F *	hCaloMEX
TH2F *	hCaloSETvsDeltaCaloMET
TH2F *	hCaloSETvsDeltaCaloSET
TH1F *	hDeltaCaloMET
TH2F *	hDeltaCaloMETvstrueMET
TH1F *	hDeltaCaloMEX
TH2F *	hDeltaCaloMEXvstrueSET
TH1F *	hDeltaCaloPhi
TH2F *	hDeltaCaloPhivstrueMET
TH1F *	hDeltaCaloSET
TH1F *	hDeltaMET
TH1F *	hDeltaMEX
TH2F *	hDeltaPFMETvstrueMET
TH2F *	hDeltaPFMEXvstrueSET
TH2F *	hDeltaPFPhivstrueMET
TH1F *	hDeltaPhi
TH1F *	hDeltaSET
TH1F *	hDeltaTCMET
TH2F *	hDeltaTCMETvstrueMET
TH1F *	hDeltaTCMEX
TH2F *	hDeltaTCMEXvstrueSET
TH1F *	hDeltaTCPhi
TH2F *	hDeltaTCPhivstrueMET
TH1F *	hDeltaTCSET
TH1F *	hMEX
TH1F *	hPFMET
TH2F *	hPFMETvstrueMET
TH2F *	hSETvsDeltaMET
TH2F *	hSETvsDeltaSET
TH1F *	hTCMET
TH2F *	hTCMETvstrueMET
TH1F *	hTCMEX
TH2F *	hTCSETvsDeltaTCMET
TH2F *	hTCSETvsDeltaTCSET
TH1F *	hTrueMET
std::string	outputFile_
TProfile *	profileCaloMETvsCaloMETresp
TProfile *	profileCaloSETvsCaloSETresp
TProfile *	profileMETvsMETresp
TProfile *	profileSETvsSETresp
TProfile *	profileTCMETvsTCMETresp
TProfile *	profileTCSETvsTCSETresp
double	rec_met
double	rec_mex
double	rec_mey
double	rec_phi
double	rec_set
double	tc_met
double	tc_mex
double	tc_mey
double	tc_phi
double	tc_set
double	true_met
double	true_mex
double	true_mey
double	true_phi
double	true_set

Detailed Description

Definition at line 40 of file PFMETBenchmark.h.

Constructor & Destructor Documentation

PFMETBenchmark::PFMETBenchmark ( )

Definition at line 34 of file PFMETBenchmark.cc.

: file_(0) {}

PFMETBenchmark::~PFMETBenchmark ( ) [virtual]

Definition at line 36 of file PFMETBenchmark.cc.

References file_.

                                {
  if(file_) file_->Close();
}

Member Function Documentation

void PFMETBenchmark::analyse ( )

Definition at line 433 of file PFMETBenchmark.cc.

Referenced by PFMETBenchmarkAnalyzer::endJob().

{
  //Define fit functions and histograms
  //TF1* func1 = new TF1("fit1", fitf, 0, 40, 4);
  //TF1* func2 = new TF1("fit2", fitf, 0, 40, 4);
  //TF1* func3 = new TF1("fit3", fitf, 0, 40, 4);
  //TF1* func4 = new TF1("fit4", fitf, 0, 40, 4);

  //fit gaussian to Delta MET corresponding to different slices in MET, store fit values (mean,sigma) in histos


  // Make the MET resolution versus SET plot
  /*
  TCanvas* canvas_MetResVsRecoSet = new TCanvas("MetResVsRecoSet", "MET Sigma vs Reco SET", 500,500);
  hsigmaPF->SetStats(0); 
  func1->SetLineColor(1); 
  func1->SetParNames("Noise", "Stochastic", "Constant", "Offset");
  func1->SetParameters(10.0, 0.8, 0.1, 100.0);
  hsigmaPF->Fit("fit1", "", "", 100.0, 900.0);
  func2->SetLineColor(2); 
  func2->SetParNames("Noise", "Stochastic", "Constant", "Offset");
  func2->SetParameters(10.0, 0.8, 0.1, 100.0);
  hsigmaCalo->Fit("fit2", "", "", 100.0, 900.0);
  func3->SetLineColor(4); 
  func3->SetParNames("Noise", "Stochastic", "Constant", "Offset");
  func3->SetParameters(10.0, 0.8, 0.1, 100.0);
  hrmsPF->Fit("fit3", "", "", 100.0, 900.0);
  func4->SetLineColor(6); 
  func4->SetParNames("Noise", "Stochastic", "Constant", "Offset");
  func4->SetParameters(10.0, 0.8, 0.1, 100.0);
  hrmsCalo->Fit("fit4", "", "", 100.0, 900.0);
  (hsigmaPF->GetYaxis())->SetRangeUser( 0.0, 50.0);
  hsigmaPF->SetLineWidth(2); 
  hsigmaPF->SetLineColor(1); 
  hsigmaPF->Draw();
  hsigmaCalo->SetLineWidth(2);
  hsigmaCalo->SetLineColor(2);
  hsigmaCalo->Draw("SAME");
  hrmsPF->SetLineWidth(2);
  hrmsPF->SetLineColor(4);
  hrmsPF->Draw("SAME");  
  hrmsCalo->SetLineWidth(2);
  hrmsCalo->SetLineColor(6);
  hrmsCalo->Draw("SAME");
  */

  // Make the SET response versus SET plot
  /*
  TCanvas* canvas_SetRespVsTrueSet = new TCanvas("SetRespVsTrueSet", "SET Response vs True SET", 500,500);
  profileSETvsSETresp->SetStats(0); 
  profileSETvsSETresp->SetStats(0); 
  (profileSETvsSETresp->GetYaxis())->SetRangeUser(-1.0, 1.0);
  profileSETvsSETresp->SetLineWidth(2); 
  profileSETvsSETresp->SetLineColor(4); 
  profileSETvsSETresp->Draw();
  profileCaloSETvsCaloSETresp->SetLineWidth(2); 
  profileCaloSETvsCaloSETresp->SetLineColor(2); 
  profileCaloSETvsCaloSETresp->Draw("SAME");
  */

  // Make the MET response versus MET plot
  /*
  TCanvas* canvas_MetRespVsTrueMet = new TCanvas("MetRespVsTrueMet", "MET Response vs True MET", 500,500);
  profileMETvsMETresp->SetStats(0); 
  profileMETvsMETresp->SetStats(0); 
  (profileMETvsMETresp->GetYaxis())->SetRangeUser(-1.0, 1.0);
  profileMETvsMETresp->SetLineWidth(2); 
  profileMETvsMETresp->SetLineColor(4); 
  profileMETvsMETresp->Draw();
  profileCaloMETvsCaloMETresp->SetLineWidth(2); 
  profileCaloMETvsCaloMETresp->SetLineColor(2); 
  profileCaloMETvsCaloMETresp->Draw("SAME");
  */

  //print the resulting plots to file
  /*
  canvas_MetResVsRecoSet->Print("MetResVsRecoSet.ps");
  canvas_SetRespVsTrueSet->Print("SetRespVsTrueSet.ps");
  canvas_MetRespVsTrueMet->Print("MetRespVsTrueMet.ps");  
  */
}

void PFMETBenchmark::calculateQuantities	(	const reco::PFMETCollection &	pfMets,
		const reco::GenParticleCollection &	genParticleList,
		const reco::CaloMETCollection &	caloMets,
		const reco::METCollection &	tcMets
	)

Definition at line 278 of file PFMETBenchmark.cc.

References abs, calo_met, calo_mex, calo_mey, calo_phi, calo_set, gather_cfg::cout, debug_, eta(), i, benchmark_cfg::pdgId, reco::LeafCandidate::phi(), reco::LeafCandidate::pt(), reco::LeafCandidate::px(), reco::LeafCandidate::py(), rec_met, rec_mex, rec_phi, rec_set, mathSSE::sqrt(), ntuplemaker::status, reco::MET::sumEt(), tc_met, tc_mex, tc_mey, tc_phi, tc_set, true_met, true_mex, true_mey, true_phi, and true_set.

Referenced by process().

{
  const reco::PFMET&    pfm = pfMets[0];
  const reco::CaloMET&  cm  = caloMets[0];
  const reco::MET&  tcm  = tcMets[0];

  double trueMEY  = 0.0;
  double trueMEX  = 0.0;;
  true_set  = 0.0;;

  //  for( genParticle = genParticleList.begin(); genParticle != genParticleList.end(); genParticle++ )
  for( unsigned i = 0; i < genParticleList.size(); i++ ) {
    if( genParticleList[i].status() == 1 && fabs(genParticleList[i].eta()) < 5.0 ) { 
      if( std::abs(genParticleList[i].pdgId()) == 12 ||
          std::abs(genParticleList[i].pdgId()) == 14 ||
          std::abs(genParticleList[i].pdgId()) == 16 || 
          std::abs(genParticleList[i].pdgId()) < 7   || 
          std::abs(genParticleList[i].pdgId()) == 21 ) {
        trueMEX += genParticleList[i].px();
        trueMEY += genParticleList[i].py();
      } else {
        true_set += genParticleList[i].pt();
      }
    }
  }
  true_mex = -trueMEX;
  true_mey = -trueMEY;
  true_met = sqrt( trueMEX*trueMEX + trueMEY*trueMEY );
  true_phi = atan2(trueMEY,trueMEX);
  rec_met  = pfm.pt();
  rec_mex  = pfm.px();
  rec_mex  = pfm.py();
  rec_phi  = pfm.phi();
  rec_set  = pfm.sumEt();
  calo_met = cm.pt();
  calo_mex = cm.px();
  calo_mey = cm.py();
  calo_phi = cm.phi();
  calo_set = cm.sumEt();
  tc_met = tcm.pt();
  tc_mex = tcm.px();
  tc_mey = tcm.py();
  tc_phi = tcm.phi();
  tc_set = tcm.sumEt();

  if (debug_) {
    cout << "  =========PFMET  " << rec_met  << ", " << rec_phi  << endl;
    cout << "  =========trueMET " << true_met << ", " << true_phi << endl;
    cout << "  =========CaloMET " << calo_met << ", " << calo_phi << endl;
    cout << "  =========TCMET " << tc_met << ", " << tc_phi << endl;
  }                     
}

void PFMETBenchmark::calculateQuantities	(	const reco::PFMETCollection &	,
		const reco::GenParticleCollection &	,
		const reco::CaloMETCollection &	,
		const reco::METCollection &	,
		const std::vector< reco::CaloJet >	,
		const std::vector< reco::CaloJet >
	)

float PFMETBenchmark::getCaloMET ( ) [inline]

Definition at line 76 of file PFMETBenchmark.h.

References calo_met.

{return calo_met;}

float PFMETBenchmark::getCaloMEX ( ) [inline]

Definition at line 77 of file PFMETBenchmark.h.

References calo_mex, and true_mex.

{return calo_mex-true_mex;}

float PFMETBenchmark::getCaloMEY ( ) [inline]

Definition at line 78 of file PFMETBenchmark.h.

References calo_mey, and true_mey.

{return calo_mey-true_mey;}

float PFMETBenchmark::getCaloPhi ( ) [inline]

Definition at line 79 of file PFMETBenchmark.h.

References calo_phi.

{return calo_phi;}

float PFMETBenchmark::getCaloSET ( ) [inline]

Definition at line 80 of file PFMETBenchmark.h.

References calo_set.

{return calo_set;}

float PFMETBenchmark::getDeltaCaloMET ( ) [inline]

Definition at line 89 of file PFMETBenchmark.h.

References calo_met, and true_met.

{return calo_met - true_met;}

float PFMETBenchmark::getDeltaCaloPhi ( ) [inline]

Definition at line 90 of file PFMETBenchmark.h.

References calo_phi, mpi_pi(), and true_phi.

{return mpi_pi(calo_phi - true_phi);}

float PFMETBenchmark::getDeltaCaloSET ( ) [inline]

Definition at line 91 of file PFMETBenchmark.h.

References calo_set, and true_set.

{return calo_set - true_set;}

float PFMETBenchmark::getDeltaPFMET ( ) [inline]

Definition at line 86 of file PFMETBenchmark.h.

References rec_met, and true_met.

{return rec_met - true_met;}

float PFMETBenchmark::getDeltaPFPhi ( ) [inline]

Definition at line 87 of file PFMETBenchmark.h.

References mpi_pi(), rec_phi, and true_phi.

{return mpi_pi(rec_phi - true_phi);}

float PFMETBenchmark::getDeltaPFSET ( ) [inline]

Definition at line 88 of file PFMETBenchmark.h.

References rec_set, and true_set.

{return rec_set - true_set;}

float PFMETBenchmark::getDeltaTCMET ( ) [inline]

Definition at line 92 of file PFMETBenchmark.h.

References tc_met, and true_met.

{return tc_met - true_met;}

float PFMETBenchmark::getDeltaTCPhi ( ) [inline]

Definition at line 93 of file PFMETBenchmark.h.

References mpi_pi(), tc_phi, and true_phi.

{return mpi_pi(tc_phi - true_phi);}

float PFMETBenchmark::getDeltaTCSET ( ) [inline]

Definition at line 94 of file PFMETBenchmark.h.

References tc_set, and true_set.

{return tc_set - true_set;}

float PFMETBenchmark::getPFMET ( ) [inline]

Definition at line 71 of file PFMETBenchmark.h.

References rec_met.

{return rec_met;}

float PFMETBenchmark::getPFMEX ( ) [inline]

Definition at line 72 of file PFMETBenchmark.h.

References rec_mex, and true_mex.

{return rec_mex-true_mex;}

float PFMETBenchmark::getPFMEY ( ) [inline]

Definition at line 73 of file PFMETBenchmark.h.

References rec_mey, and true_mey.

{return rec_mey-true_mey;}

float PFMETBenchmark::getPFPhi ( ) [inline]

Definition at line 74 of file PFMETBenchmark.h.

References rec_phi.

{return rec_phi;}

float PFMETBenchmark::getPFSET ( ) [inline]

Definition at line 75 of file PFMETBenchmark.h.

References rec_set.

{return rec_set;}

float PFMETBenchmark::getTCMET ( ) [inline]

Definition at line 81 of file PFMETBenchmark.h.

References tc_met.

{return tc_met;}

float PFMETBenchmark::getTCMEX ( ) [inline]

Definition at line 82 of file PFMETBenchmark.h.

References tc_mex, and true_mex.

{return tc_mex-true_mex;}

float PFMETBenchmark::getTCMEY ( ) [inline]

Definition at line 83 of file PFMETBenchmark.h.

References tc_mey, and true_mey.

{return tc_mey-true_mey;}

float PFMETBenchmark::getTCPhi ( ) [inline]

Definition at line 84 of file PFMETBenchmark.h.

References tc_phi.

{return tc_phi;}

float PFMETBenchmark::getTCSET ( ) [inline]

Definition at line 85 of file PFMETBenchmark.h.

References tc_set.

{return tc_set;}

float PFMETBenchmark::getTrueMET ( ) [inline]

Definition at line 68 of file PFMETBenchmark.h.

References true_met.

{return true_met;}

float PFMETBenchmark::getTruePhi ( ) [inline]

Definition at line 69 of file PFMETBenchmark.h.

References true_phi.

{return true_phi;}

float PFMETBenchmark::getTrueSET ( ) [inline]

Definition at line 70 of file PFMETBenchmark.h.

References true_set.

{return true_set;}

double PFMETBenchmark::mpi_pi ( double angle )

Definition at line 627 of file PFMETBenchmark.cc.

References angle(), pi, and pi2.

Referenced by getDeltaCaloPhi(), getDeltaPFPhi(), and getDeltaTCPhi().

                                   {

  const double pi = 3.14159265358979323;
  const double pi2 = pi*2.;
  while(angle>pi) angle -= pi2;
  while(angle<-pi) angle += pi2;
  return angle;

}

void PFMETBenchmark::process	(	const reco::PFMETCollection &	pfMets,
		const reco::GenParticleCollection &	genParticleList,
		const reco::CaloMETCollection &	caloMets,
		const reco::METCollection &	tcMets
	)

Definition at line 197 of file PFMETBenchmark.cc.

References calculateQuantities(), calo_met, calo_mex, calo_mey, calo_phi, calo_set, gather_cfg::cout, debug_, hCaloMET, hCaloMETvstrueMET, hCaloMEX, hCaloSETvsDeltaCaloMET, hCaloSETvsDeltaCaloSET, hDeltaCaloMET, hDeltaCaloMETvstrueMET, hDeltaCaloMEX, hDeltaCaloMEXvstrueSET, hDeltaCaloPhi, hDeltaCaloPhivstrueMET, hDeltaCaloSET, hDeltaMET, hDeltaMEX, hDeltaPFMETvstrueMET, hDeltaPFMEXvstrueSET, hDeltaPFPhivstrueMET, hDeltaPhi, hDeltaSET, hDeltaTCMET, hDeltaTCMETvstrueMET, hDeltaTCMEX, hDeltaTCMEXvstrueSET, hDeltaTCPhi, hDeltaTCPhivstrueMET, hDeltaTCSET, hMEX, hPFMET, hPFMETvstrueMET, hSETvsDeltaMET, hSETvsDeltaSET, hTCMET, hTCMETvstrueMET, hTCMEX, hTCSETvsDeltaTCMET, hTCSETvsDeltaTCSET, hTrueMET, profileCaloMETvsCaloMETresp, profileCaloSETvsCaloSETresp, profileMETvsMETresp, profileSETvsSETresp, profileTCMETvsTCMETresp, profileTCSETvsTCSETresp, rec_met, rec_mex, rec_mey, rec_phi, rec_set, tc_met, tc_mex, tc_mey, tc_phi, tc_set, true_met, true_mex, true_mey, true_phi, and true_set.

Referenced by PFMETBenchmarkAnalyzer::analyze().

                                                                {
  calculateQuantities(pfMets, genParticleList, caloMets, tcMets);
  if (debug_) {
    cout << "  =========PFMET  " << rec_met  << ", " << rec_phi  << endl;
    cout << "  =========GenMET " << true_met << ", " << true_phi << endl;
    cout << "  =========CaloMET " << calo_met << ", " << calo_phi << endl;
    cout << "  =========TCMET " << tc_met << ", " << tc_phi << endl;
  }                     
  // fill histograms
  hTrueMET->Fill(true_met);
  // delta Pt or E quantities
  // PF
  hDeltaMET->Fill( rec_met - true_met );
  hMEX->Fill( rec_mex );
  hMEX->Fill( rec_mey );
  hDeltaMEX->Fill( rec_mex - true_mex );
  hDeltaMEX->Fill( rec_mey - true_mey );
  hDeltaPhi->Fill( rec_phi - true_phi );
  hDeltaSET->Fill( rec_set - true_set );
  if( true_met > 5.0 ) hSETvsDeltaMET->Fill( rec_set, rec_met - true_met );
  else                 hSETvsDeltaMET->Fill( rec_set, rec_mex - true_mex );
  hSETvsDeltaSET->Fill( rec_set, rec_set - true_set );
  if( true_met > 5.0 ) profileMETvsMETresp->Fill(true_met, (rec_met-true_met)/true_met);
  profileSETvsSETresp->Fill(true_set, (rec_set-true_set)/true_set);

  hDeltaPFMETvstrueMET->Fill(true_met, rec_met - true_met);
  hDeltaPFPhivstrueMET->Fill(true_met, rec_phi - true_phi);
  hPFMETvstrueMET->Fill(true_met, rec_met);
  hPFMET->Fill(rec_met);

  hDeltaPFMEXvstrueSET->Fill(true_set, rec_mex - true_mex);
  hDeltaPFMEXvstrueSET->Fill(true_set, rec_mey - true_mey);

  // Calo
  hDeltaCaloMET->Fill( calo_met - true_met );
  hCaloMEX->Fill( calo_mex );
  hCaloMEX->Fill( calo_mey );
  hDeltaCaloMEX->Fill( calo_mex - true_mex);
  hDeltaCaloMEX->Fill( calo_mey - true_mey);
  hDeltaCaloPhi->Fill( calo_phi - true_phi );
  hDeltaCaloSET->Fill( calo_set - true_set );
  if( true_met > 5.0 ) hCaloSETvsDeltaCaloMET->Fill( calo_set, calo_met - true_met );
  else                 hCaloSETvsDeltaCaloMET->Fill( calo_set, calo_mex - true_mex);
  hCaloSETvsDeltaCaloSET->Fill( calo_set, calo_set - true_set );
  if( true_met > 5.0 ) profileCaloMETvsCaloMETresp->Fill(true_met, (calo_met-true_met)/true_met);
  profileCaloSETvsCaloSETresp->Fill(true_set, (calo_set-true_set)/true_set);

  hDeltaCaloMETvstrueMET->Fill(true_met, calo_met - true_met);
  hDeltaCaloPhivstrueMET->Fill(true_met, calo_phi - true_phi);
  hCaloMETvstrueMET->Fill(true_met, calo_met);
  hCaloMET->Fill(calo_met);

  hDeltaCaloMEXvstrueSET->Fill(true_set, calo_mex - true_mex);
  hDeltaCaloMEXvstrueSET->Fill(true_set, calo_mey - true_mey);

  // TC
  hDeltaTCMET->Fill( tc_met - true_met );
  hTCMET->Fill( tc_met );
  hTCMEX->Fill( tc_mex );
  hTCMEX->Fill( tc_mey );
  hDeltaTCMEX->Fill( tc_mex - true_mex);
  hDeltaTCMEX->Fill( tc_mey - true_mey);
  hDeltaTCPhi->Fill( tc_phi - true_phi );
  hDeltaTCSET->Fill( tc_set - true_set );
  if( true_met > 5.0 ) hTCSETvsDeltaTCMET->Fill( tc_set, tc_met - true_met );
  else                 hTCSETvsDeltaTCMET->Fill( tc_set, tc_mex - true_mex);
  hTCSETvsDeltaTCSET->Fill( tc_set, tc_set - true_set );
  if( true_met > 5.0 ) profileTCMETvsTCMETresp->Fill(true_met, (tc_met-true_met)/true_met);
  profileTCSETvsTCSETresp->Fill(true_set, (tc_set-true_set)/true_set);

  hDeltaTCMETvstrueMET->Fill( true_met, tc_met - true_met);
  hDeltaTCPhivstrueMET->Fill( true_met, tc_phi - true_phi);
  hDeltaTCMEXvstrueSET->Fill( true_set, tc_mex - true_mex);
  hDeltaTCMEXvstrueSET->Fill( true_set, tc_mey - true_mey);
  hTCMETvstrueMET->Fill( true_met, tc_met );

}

void PFMETBenchmark::setup	(	std::string	Filename,
		bool	debug,
		bool	plotAgainstReco = `0`,
		std::string	benchmarkLabel_ = `"ParticleFlow"`,
		DQMStore *	dbe_store = `NULL`
	)

Referenced by PFMETBenchmarkAnalyzer::PFMETBenchmarkAnalyzer().

void PFMETBenchmark::write ( void )

Definition at line 40 of file PFMETBenchmark.cc.

References gather_cfg::cout, dbe_, file_, outputFile_, and DQMStore::save().

Referenced by PFMETBenchmarkAnalyzer::endJob().

                           {
   // Store the DAQ Histograms 
  if (outputFile_.size() != 0) {
    if (dbe_)
          dbe_->save(outputFile_.c_str());
    // use bare Root if no DQM (FWLite applications)
    else if (file_) {
       file_->Write(outputFile_.c_str());
       cout << "Benchmark output written to file " << outputFile_.c_str() << endl;
       file_->Close();
       }
  }
  else 
    cout << "No output file specified ("<<outputFile_<<"). Results will not be saved!" << endl;
    
}