ZmumuValidationExample Class Reference

#include <ZmumuValidationExample.h>

Collaboration diagram for ZmumuValidationExample:

Public Member Functions
	ZmumuValidationExample (std::list< std::string > const &s_fileNames, string s_treeName="DefaultParams", std::string const &s_outFileName="ZmumuValidationExampleOutput.root", bool isMC=false)
	~ZmumuValidationExample ()
void	loop (unsigned maxEvents=0)
void	SetPrintLevel (int newprintlevel=0)
void	SetEtaBins (int newbins=20)
void	SetPhiBins (int newbins=20)
void	writeToFile (int iteration)
void	DrawMap ()

Private Member Functions
void	loadChains ()
void	setBranchAddresses ()
void	bookHistograms ()
void	loopThroughEvents (unsigned int maxItr)
void	fillHistograms ()
void	correctMomentum (TH1 *h_corrections, TLorentzVector *muon_pos, TLorentzVector *muon_neg, int use_lambda)
void	fillEtaPhiHistogram (TH3 *hist, TLorentzVector *v_pos, TLorentzVector *v_neg, int use_lambda)
void	fillEtaHistogram (TH2 *hist, TLorentzVector *v_pos, TLorentzVector *v_neg, int use_lambda, int charge=0)
void	fillHistogram (TH1 *hist, TLorentzVector *v_pos, TLorentzVector *v_neg, int fill_lambda, int charge=0)
void	fillZd0EtaPhiHistogram (TH3 *hist, TLorentzVector *v_pos, TLorentzVector *v_neg, double z0_muon_p, double z0_muon_n)
void	fillZd0Histogram (TH1 *hist, double z0_muon_p, double z0_muon_n, int pn)
void	correctZd0 (TH1 *h_corrections, TLorentzVector *muon_pos, TLorentzVector *muon_neg, double &zd0_muon_p, double &zd0_muon_n)
void	profileZwithIterativeGaussFit (TH3 *hist, TH2 *mu_graph, TH2 *sigma_graph, int num_bins, TH2 *mu_err_graph=0, TH2 *sigma_err_graph=0)
void	profileYwithIterativeGaussFit (TH2 *hist, TH1 *mu_graph=0, TH1 *sigma_graph=0, int num_bins=1)
int	IterativeGaussFit (TH1 *hist, double &mu, double &mu_err, double &sigma, double &sigma_err)
void	fillQoverPtHistograms (TLorentzVector *v_pos, TLorentzVector *v_neg)
void	HistogramConditioning (TH1 *hist)
void	ResetHistograms ()
void	SymmetrizeHisto (TH2 *hist)

Private Attributes
const std::list< std::string >	m_fileNames
std::string	m_outfilename
TFile	m_file
TChain	m_eventChain
TChain	m_truthChain
int	m_eventCurrent {}
int	m_PrintLevel {}
int	m_EtaBins {}
int	m_PhiBins {}
bool	m_isMC {}
int	n_iteration {}
double	m_shift {}
double	m_factor {}
double	m_px_pos {}
double	m_py_pos {}
double	m_pz_pos {}
double	m_px_neg {}
double	m_py_neg {}
double	m_pz_neg {}
double	m_z0_pos {}
double	m_z0_neg {}
double	m_d0_pos {}
double	m_d0_neg {}
double	m_truth_px_pos {}
double	m_truth_py_pos {}
double	m_truth_pz_pos {}
double	m_truth_px_neg {}
double	m_truth_py_neg {}
double	m_truth_pz_neg {}
TBranch *	b_px_pos {}
TBranch *	b_py_pos {}
TBranch *	b_pz_pos {}
TBranch *	b_px_neg {}
TBranch *	b_py_neg {}
TBranch *	b_pz_neg {}
TBranch *	b_z0_pos {}
TBranch *	b_z0_neg {}
TBranch *	b_d0_pos {}
TBranch *	b_d0_neg {}
TBranch *	b_truth_px_pos {}
TBranch *	b_truth_py_pos {}
TBranch *	b_truth_pz_pos {}
TBranch *	b_truth_px_neg {}
TBranch *	b_truth_py_neg {}
TBranch *	b_truth_pz_neg {}
TH1 *	h_DELTA {}
TH1 *	h_pt {}
TH1 *	h_pt_pos {}
TH1 *	h_pt_neg {}
TH1 *	h_pt_truth {}
TH1 *	h_pt_pos_truth {}
TH1 *	h_pt_neg_truth {}
TH1 *	h_z0 {}
TH1 *	h_z0_pos {}
TH1 *	h_z0_neg {}
TH1 *	h_d0 {}
TH1 *	h_d0_pos {}
TH1 *	h_d0_neg {}
TH1 *	h_mass {}
TH1 *	pcorrected_mass {}
TH1 *	lambdacorrected_mass {}
TH3 *	pcorrected_mass_vs_etaphi {}
TH3 *	lambdacorrected_mass_vs_etaphi {}
TH2 *	etaphi_pos {}
TH2 *	etaphi_neg {}
TProfile2D *	prof_pt_vs_etaphi {}
TH3 *	delta_vs_etaphi {}
TH2 *	deltacorrections_vs_etaphi {}
TH2 *	deltacorrections_vs_etaphi_err {}
TH3 *	lambda_vs_etaphi {}
TH2 *	lambdacorrections_vs_etaphi {}
TH2 *	lambdacorrections_vs_etaphi_err {}
TH2 *	lambdacorrections_vs_etaphi_RMS {}
TH2 *	lambda_vs_eta {}
TH2 *	lambda_vs_eta_pos {}
TH2 *	lambda_vs_eta_neg {}
TH1 *	lambdacorrections_vs_eta {}
TH1 *	lambda {}
TH1 *	lambda_pos {}
TH1 *	lambda_neg {}
TH1 *	lambda_etaphi {}
TH1 *	lambda_etaphi_pos {}
TH1 *	lambda_etaphi_neg {}
TH1 *	lambda_eta {}
TH1 *	lambda_eta_pos {}
TH1 *	lambda_eta_neg {}
TH2 *	entries {}
TH3 *	z0delta_vs_etaphi {}
TH2 *	z0deltacorrections_vs_etaphi {}
TH2 *	z0deltacorrections_vs_etaphi_err {}
TH1 *	z0delta {}
TH1 *	z0delta_pos {}
TH1 *	z0delta_neg {}
TH1 *	z0delta_etaphi {}
TH1 *	z0delta_etaphi_pos {}
TH1 *	z0delta_etaphi_neg {}
TH3 *	d0delta_vs_etaphi {}
TH2 *	d0deltacorrections_vs_etaphi {}
TH2 *	d0deltacorrections_vs_etaphi_err {}
TH1 *	d0delta {}
TH1 *	d0delta_pos {}
TH1 *	d0delta_neg {}
TH1 *	d0delta_etaphi {}
TH1 *	d0delta_etaphi_pos {}
TH1 *	d0delta_etaphi_neg {}
TH3 *	delta_vs_etaphi_truth {}
TH2 *	deltacorrections_vs_etaphi_truth {}
TH2 *	deltacorrections_vs_etaphi_truth_err {}
TH3 *	lambda_vs_etaphi_truth {}
TH2 *	lambdacorrections_vs_etaphi_truth {}
TH2 *	lambdacorrections_vs_etaphi_truth_err {}
TH2 *	lambda_vs_eta_truth {}
TH1 *	lambdacorrections_vs_eta_truth {}
TH2 *	truth_mom_bias_vs_eta {}
TH1 *	truth_mom_biascorrections_vs_eta {}
TH2 *	truth_mass_bias_vs_eta {}
TH1 *	truth_mass_biascorrections_vs_eta {}
TH1 *	lambda_truth {}
TH1 *	lambda_truth_pos {}
TH1 *	lambda_truth_neg {}
TH1 *	delta_phi_truth {}
TH1 *	delta_eta_truth {}
TH2 *	delta_M2_vs_zpt_truth {}
TH2 *	delta_M2_vs_zpt {}
TProfile2D *	delta_M2_vs_etaphi_pos {}
TProfile2D *	delta_M2_vs_etaphi_neg {}
TH2 *	h_QoverPt {}
TH3 *	h_QoverPt3D {}
TCanvas *	TempCanvasIterGaussFit {}

Detailed Description

Definition at line 22 of file ZmumuValidationExample.h.

Constructor & Destructor Documentation

ZmumuValidationExample()

ZmumuValidationExample::ZmumuValidationExample	(	std::list< std::string > const &	s_fileNames,
		string	s_treeName = "DefaultParams",
		std::string const &	s_outFileName = "ZmumuValidationExampleOutput.root",
		bool	isMC = false )

Definition at line 16 of file ZmumuValidationExample.cxx.

                          : m_fileNames( s_fileNames )
                          , m_outfilename( s_outFileName )
                          , m_file( s_outFileName.c_str(), "RECREATE" )
                          , m_eventChain( s_treeName.c_str() )
                          , m_truthChain( "TruthParams" )
                          , m_PrintLevel(0)
                          , m_EtaBins(1)
                          , m_PhiBins(1)
                          , m_isMC(isMC)
                          , n_iteration(0)
 
{
   loadChains();
   setBranchAddresses();
   // bookHistograms();
   
   m_factor = 0.5; //factor to assign lambda corrections - nominal is 0.5
   m_shift = 0; //shift in Z mass in MeV - nominal is 0
   TempCanvasIterGaussFit = NULL;
}

~ZmumuValidationExample()

ZmumuValidationExample::~ZmumuValidationExample

(

)

Definition at line 41 of file ZmumuValidationExample.cxx.

{
   m_file.Close();
   
}

Member Function Documentation

bookHistograms()

void ZmumuValidationExample::bookHistograms ( )

private

Definition at line 111 of file ZmumuValidationExample.cxx.

{
   // initialize histograms here
  
  const int fnEtaBins = m_EtaBins;
  const int fnPhiBins = m_PhiBins;
  const int fnQoverPtBins = 100;
  
  const double eta_bound = 2.5;
  const double phi_bound = M_PI;
  const double p_bound = 0.5;
  const double pt_bound = 15;
  
  const double z_bound = 0.4; //mm
  const double d_bound = 0.15; //mm
  
  h_DELTA = new TH1F("h_DELTA",";#delta [GeV]",200,-50,50);
  
  h_pt =    new TH1F("Pt","p_{T} of both #mu; p_{T} [GeV]",    100, 0., 100.);
  h_pt_pos =    new TH1F("Pt_Pos","p_{T} of #mu^{+}; p_{T} [GeV]", 100, 0., 100.);
  h_pt_neg =    new TH1F("Pt_Neg","p_{T} of #mu^{-}; p_{T} [GeV]", 100, 0., 100.);
 
  h_z0     =    new TH1F("h_z0","z_{0}: longitudinal impact param.; z_{0} [mm]",    100, -150., 150.);
  h_z0_pos =    new TH1F("h_z0_Pos","z_{0} of #mu^{+};z_{0} [mm]",100, -150., 150.);
  h_z0_neg =    new TH1F("h_z0_Neg","z_{0} of #mu^{-};z_{0} [mm]",100, -150., 150.);
  h_d0     =    new TH1F("h_d0","d_{0}: transvers. impact param.; d_{0} [mm]",    100, -0.08, 0.08);
  h_d0_pos =    new TH1F("h_d0_Pos","d_{0} of #mu^{+};d_{0} [mm]",100, -0.08, 0.08);
  h_d0_neg =    new TH1F("h_d0_Neg","d_{0} of #mu^{-};d_{0} [mm]",100, -0.08, 0.08);
 
  h_mass =     new TH1F("ZMass",";Mass [GeV]",100,70,110);
 
//  pcorrected_mass =    new TH1F("PCorrectedZMass",";Mass [GeV]",100,70,110);
//  lambdacorrected_mass = new TH1F("LambdaCorrectedZMass",";Mass [GeV]",100,70,110);
 
//  pcorrected_mass_vs_etaphi =      new TH3F("ZMassVsEtaPhi_P",";#eta;#phi;Mass [GeV]", fnEtaBins,-eta_bound,eta_bound, fnPhiBins,-phi_bound,phi_bound, 100,70,110);
//  lambdacorrected_mass_vs_etaphi = new TH3F("ZMassVsEtaPhi_Lambda",";#eta;#phi;Mass [GeV]", fnEtaBins,-eta_bound,eta_bound, fnPhiBins,-phi_bound,phi_bound, 100,70,110);  
  
//  etaphi_pos =        new TH2F("MuonEtaPhi_Positive",";#eta;#phi", fnEtaBins,-eta_bound,eta_bound, fnPhiBins,-phi_bound,phi_bound);
//  etaphi_neg =        new TH2F("MuonEtaPhi_Negative",";#eta;#phi", fnEtaBins,-eta_bound,eta_bound, fnPhiBins,-phi_bound,phi_bound);
 
//  prof_pt_vs_etaphi =     new TProfile2D("AvgPtVsEtaPhi",";#eta;#phi;<p_{T}>", fnEtaBins,-eta_bound,eta_bound, fnPhiBins,-phi_bound,phi_bound);
 
  //z0 histograms ----------------------------
 
  entries    = new TH2F("entries","Entries per #eta-#phi bin;#eta;#phi;entries", fnEtaBins,-eta_bound,eta_bound, fnPhiBins,-phi_bound,phi_bound);
  
  z0delta_vs_etaphi =  new TH3F("Delta_z0_VsEtaPhi",";#eta;#phi;#delta_{z_{0}} [mm]", fnEtaBins,-eta_bound,eta_bound, fnPhiBins,-phi_bound,phi_bound, 50,-z_bound,z_bound);    
 
  z0deltacorrections_vs_etaphi =    new TH2D("z0CorrectionVsEtaPhi",";#eta;#phi;#delta_{z_{0}} [mm]", fnEtaBins,-eta_bound,eta_bound, fnPhiBins,-phi_bound,phi_bound);
 
  z0deltacorrections_vs_etaphi_err = new TH2D("z0CorrectionVsEtaPhi_Err",";#eta;#phi;#delta_{z_{0}}", fnEtaBins,-eta_bound,eta_bound, fnPhiBins,-phi_bound,phi_bound);
 
 
  z0delta =  new TH1D("Delta_z0", ";#delta_{z_{0}} [mm]", 100,-z_bound,z_bound);
 
  z0delta_pos =  new TH1D("Delta_z0_Pos",";#delta_{z_{0}} [mm]", 100,-z_bound,z_bound);
 
  z0delta_neg =  new TH1D("Delta_z0_Neg",";#delta_{z_{0}} [mm]", 100,-z_bound,z_bound);
 
  z0delta_etaphi =    new TH1D("Delta_z0_etaphi",";#delta_{z_{0}} [mm]", 100,-z_bound,z_bound);
 
  z0delta_etaphi_pos =    new TH1D("Delta_z0_etaphi_Pos",";#delta_{z_{0}} [mm]", 100,-z_bound,z_bound);
 
  z0delta_etaphi_neg =    new TH1D("Delta_z0_etaphi_Neg",";#delta_{z_{0}} [mm]", 100,-z_bound,z_bound);
 
  //d0 Histograms------------------------------------------------------------------
 
  d0delta_vs_etaphi =  new TH3F("Delta_d0_VsEtaPhi",";#eta;#phi;#delta_{d_{0}} [mm]", fnEtaBins,-eta_bound,eta_bound, fnPhiBins,-phi_bound,phi_bound, 50,-d_bound, d_bound);
 
  d0deltacorrections_vs_etaphi =    new TH2D("d0CorrectionVsEtaPhi",";#eta;#phi;#delta_{d_{0}} [mm]", fnEtaBins,-eta_bound,eta_bound, fnPhiBins,-phi_bound,phi_bound);
 
  d0deltacorrections_vs_etaphi_err = new TH2D("d0CorrectionVsEtaPhi_Err",";#eta;#phi;#delta_{d_{0}}", fnEtaBins,-eta_bound,eta_bound, fnPhiBins,-phi_bound,phi_bound);
 
  d0delta =  new TH1D("Delta_d0", ";#delta_{d_{0}} [mm]", 100,-d_bound,d_bound);
 
  d0delta_pos =  new TH1D("Delta_d0_Pos",";#delta_{d_{0}} [mm]", 100,-d_bound,d_bound);
 
  d0delta_neg =  new TH1D("Delta_d0_Neg",";#delta_{d_{0}} [mm]", 100,-d_bound,d_bound);
 
  d0delta_etaphi =    new TH1D("Delta_d0_etaphi",";#delta_{d_{0}} [mm]", 100,-d_bound,d_bound);
 
  d0delta_etaphi_pos =    new TH1D("Delta_d0_etaphi_Pos",";#delta_{d_{0}} [mm]", 100,-d_bound,d_bound);
 
  d0delta_etaphi_neg =    new TH1D("Delta_d0_etaphi_Neg",";#delta_{d_{0}} [mm]", 100,-d_bound,d_bound);
    
  //delta - charge symmetric -----------------
  delta_vs_etaphi =              new TH3F("DeltaPVsEtaPhi",";#eta;#phi;#delta_{r}", fnEtaBins,-eta_bound,eta_bound, fnPhiBins,-phi_bound,phi_bound, 100,-p_bound,p_bound);
 
  deltacorrections_vs_etaphi =            new TH2D("PCorrectionVsEtaPhi",";#eta;#phi;#delta_{r}", fnEtaBins,-eta_bound,eta_bound, fnPhiBins,-phi_bound,phi_bound);
  
  deltacorrections_vs_etaphi_err =        new TH2D("PCorrectionVsEtaPhi_Err",";#eta;#phi;#delta_{r}", fnEtaBins,-eta_bound,eta_bound, fnPhiBins,-phi_bound,phi_bound);
  
  //lambda * pT - charge anti-symmetric -----------------
  lambda_vs_etaphi =                new TH3F("LambdaVsEtaPhi",";#eta;#phi;#delta_{sagitta} [TeV^{-1}]", fnEtaBins,-eta_bound,eta_bound, fnPhiBins,-phi_bound,phi_bound, 100,-pt_bound,pt_bound);
 
  lambdacorrections_vs_etaphi =      new TH2D("LambdaCorrectionVsEtaPhi",";#eta;#phi;#delta_{sagitta} [TeV^{-1}]", fnEtaBins,-eta_bound,eta_bound, fnPhiBins,-phi_bound,phi_bound);
  lambdacorrections_vs_etaphi_err =      new TH2D("LambdaCorrectionVsEtaPhi_Err",";#eta;#phi;#delta_{sagitta} [TeV^{-1}]", fnEtaBins,-eta_bound,eta_bound, fnPhiBins,-phi_bound,phi_bound);
  lambdacorrections_vs_etaphi_RMS =             new TH2D("LambdaCorrectionVsEtaPhi_RMS",";#eta;#phi;RMS #delta_{sagitta} [GeV^{-1}]", fnEtaBins,-eta_bound,eta_bound, fnPhiBins,-phi_bound,phi_bound);
 
  //lambda * pT - charge anti-symmetric -----------------
  lambda_vs_eta =              new TH2F("LambdaVsEta",";#eta;#delta_{sagitta} [TeV^{-1}]", fnEtaBins,-eta_bound,eta_bound, 100,-pt_bound,pt_bound);
  lambda_vs_eta_pos =              new TH2F("LambdaVsEta_Pos", ";#eta;#delta_{sagitta} [TeV^{-1}]", fnEtaBins,-eta_bound,eta_bound, 100,-pt_bound,pt_bound);
  lambda_vs_eta_neg =              new TH2F("LambdaVsEta_Neg", ";#eta;#delta_{sagitta} [TeV^{-1}]", fnEtaBins,-eta_bound,eta_bound, 100,-pt_bound,pt_bound);
 
  lambdacorrections_vs_eta  =           new TH1D("LambdaCorrectionVsEta",";#eta;#delta_{sagitta} [TeV^{-1}]", fnEtaBins,-eta_bound,eta_bound);
 
  lambda =                        new TH1D("Lambda",    ";#delta_{sagitta} [TeV^{-1}]", 100,-pt_bound,pt_bound);
  lambda_pos =                        new TH1D("Lambda_Pos",";#delta_{sagitta} [TeV^{-1}]", 100,-pt_bound,pt_bound);
  lambda_neg =                        new TH1D("Lambda_Neg",";#delta_{sagitta} [TeV^{-1}]", 100,-pt_bound,pt_bound);
 
  lambda_eta =                    new TH1D("Lambda_eta",   ";#delta_{sagitta} [TeV^{-1}]", 100,-pt_bound,pt_bound);
  lambda_eta_pos =                    new TH1D("Lambda_eta_Pos",";#delta_{sagitta} [TeV^{-1}]", 100,-pt_bound,pt_bound);
  lambda_eta_neg =                    new TH1D("Lambda_eta_Neg",";#delta_{sagitta} [TeV^{-1}]", 100,-pt_bound,pt_bound);
 
  lambda_etaphi =                  new TH1D("Lambda_etaphi",    ";#delta_{sagitta} [TeV^{-1}]", 100,-pt_bound,pt_bound);
  lambda_etaphi_pos =                  new TH1D("Lambda_etaphi_Pos",";#delta_{sagitta} [TeV^{-1}]", 100,-pt_bound,pt_bound);
  lambda_etaphi_neg =                  new TH1D("Lambda_etaphi_Neg",";#delta_{sagitta} [TeV^{-1}]", 100,-pt_bound,pt_bound);
 
  if (m_isMC) {
 
    h_pt_truth =               new TH1D("Pt_Truth",     ";p_{T} [GeV]",500,0,500);
    h_pt_pos_truth =               new TH1D("Pt_Pos_Truth",";p_{T} [GeV]",500,0,500);
    h_pt_neg_truth =               new TH1D("Pt_Neg_Truth",";p_{T} [GeV]",500,0,500);
 
    delta_vs_etaphi_truth =             new TH3F("DeltaPVsEtaPhi_Truth",";#eta;#phi;#delta_{r}", fnEtaBins,-eta_bound,eta_bound, fnPhiBins,-phi_bound,phi_bound, 100,-p_bound,p_bound);
    deltacorrections_vs_etaphi_truth =       new TH2D("PCorrectionVsEtaPhi_Truth",";#eta;#phi;#delta_{sagitta} [TeV^{-1}]", fnEtaBins,-eta_bound,eta_bound, fnPhiBins,-phi_bound,phi_bound);    
    deltacorrections_vs_etaphi_truth_err =   new TH2D("PCorrectionVsEtaPhi_Truth_Err",";#eta;#phi;#delta_{sagitta} [TeV^{-1}]", fnEtaBins,-eta_bound,eta_bound, fnPhiBins,-phi_bound,phi_bound);    
 
    lambda_vs_etaphi_truth =           new TH3F("LambdaVsEtaPhi_Truth",";#eta;#phi;#delta_{sagitta} [TeV^{-1}]", fnEtaBins,-eta_bound,eta_bound, fnPhiBins,-phi_bound,phi_bound, 100,-pt_bound,pt_bound);
    lambdacorrections_vs_etaphi_truth =      new TH2D("LambdaCorrectionVsEtaPhi_Truth",";#eta;#phi;#delta_{sagitta} [TeV^{-1}]", fnEtaBins,-eta_bound,eta_bound, fnPhiBins,-phi_bound,phi_bound);
    lambdacorrections_vs_etaphi_truth_err =  new TH2D("LambdaCorrectionVsEtaPhi_Truth_Err",";#eta;#phi;#delta_{sagitta} [TeV^{-1}]", fnEtaBins,-eta_bound,eta_bound, fnPhiBins,-phi_bound,phi_bound);
 
    lambda_vs_eta_truth =                 new TH2F("LambdaVsEta_Truth",";#eta;#delta_{sagitta} [TeV^{-1}]", fnEtaBins,-eta_bound,eta_bound, 100,-pt_bound,pt_bound);
    lambdacorrections_vs_eta_truth =       new TH1D("LambdaCorrectionVsEta_Truth",";#eta;#delta_{sagitta} [TeV^{-1}]", fnEtaBins,-eta_bound,eta_bound);
 
    truth_mom_bias_vs_eta =                 new TH2F("TruthMomentumBiasVsEta",";#eta;#delta_{sagitta} [TeV^{-1}]", fnEtaBins,-eta_bound,eta_bound, 100,-pt_bound,pt_bound);
    truth_mom_biascorrections_vs_eta =       new TH1D("TruthMomentumBiasCorrectionVsEta",";#eta;#delta_{sagitta} [TeV^{-1}]", fnEtaBins,-eta_bound,eta_bound);
 
    truth_mass_bias_vs_eta =           new TH2F("TruthMassBiasVsEta",";#eta;#delta_{sagitta} [TeV^{-1}]", fnEtaBins,-eta_bound,eta_bound, 100,-pt_bound,pt_bound);
    truth_mass_biascorrections_vs_eta =      new TH1D("TruthMassBiasCorrectionVsEta",";#eta;#delta_{sagitta} [TeV^{-1}]", fnEtaBins,-eta_bound,eta_bound);
 
    lambda_truth =               new TH1D("Lambda_Truth",    ";#delta_{sagitta} [TeV^{-1}]", 100,-pt_bound,pt_bound);
    lambda_truth_pos =               new TH1D("Lambda_Truth_Pos",";#delta_{sagitta} [TeV^{-1}]", 100,-pt_bound,pt_bound);
    lambda_truth_neg =               new TH1D("Lambda_Truth_Neg",";#delta_{sagitta} [TeV^{-1}]", 100,-pt_bound,pt_bound);
 
    delta_phi_truth =                 new TH1D("DeltaPhi_Truth",";#phi_{Truth} - #phi_{Rec}", 100,-0.01,0.01);          
    
    delta_eta_truth =                 new TH1D("DeltaEta_Truth",";#eta_{Truth} - #eta_{Rec}", 100,-0.01,0.01);
 
    delta_M2_vs_zpt_truth =             new TH2D("delta_M2_vs_zpt_truth",";Z p_{T} [GeV]; #Delta (M^2)", 100,0,100, 100, -1.0, 1.0 );
    delta_M2_vs_zpt =                     new TH2D("delta_M2_vs_zpt",";Z p_{T} [GeV]; #Delta (M^2)", 100,0,100, 100, -1.0, 1.0 );
 
    delta_M2_vs_etaphi_pos =           new TProfile2D("delta_M2_vs_etaphi_pos",";#eta;#phi; #Delta (M^2)", 20,-2.5,2.5, 20, -3.14, 3.14 );
    delta_M2_vs_etaphi_neg =           new TProfile2D("delta_M2_vs_etaphi_neg",";#eta;#phi; #Delta (M^2)", 20,-2.5,2.5, 20, -3.14, 3.14 );
 
  }
   
  // Histograms of q/pt
  h_QoverPt = new TH2F("h_QoverPt","q/p_{T} whole ID", 2*fnPhiBins, -phi_bound, phi_bound, fnQoverPtBins, -1/pt_bound, 1/pt_bound);
  h_QoverPt->GetXaxis()->SetTitle("#phi [rad]");
  h_QoverPt->GetYaxis()->SetTitle("q/p_{T} [GeV^{-1}]");
  
  h_QoverPt3D = new TH3F("h_QoverPt3D", "q/p_{T} whole ID", 
             fnEtaBins,      -eta_bound,  eta_bound,
             2*fnPhiBins,    -phi_bound,  phi_bound, 
             fnQoverPtBins, -1/pt_bound, 1/pt_bound);
  h_QoverPt3D->GetXaxis()->SetTitle("#eta");
  h_QoverPt3D->GetYaxis()->SetTitle("#phi [rad]");
  h_QoverPt3D->GetZaxis()->SetTitle("q/p_{T} [GeV^{-1}]");
}

correctMomentum()

void ZmumuValidationExample::correctMomentum ( TH1 * h_corrections, TLorentzVector * muon_pos, TLorentzVector * muon_neg, int use_lambda )

private

Definition at line 574 of file ZmumuValidationExample.cxx.

{   
  double temp_pt_pos = muon_pos->Pt();
  double temp_pt_neg = muon_neg->Pt();
 
  // positive muon
  double correction = h_corrections->GetBinContent(h_corrections->FindBin(muon_pos->Eta(), muon_pos->Phi()));
  if (use_lambda) {
    
    double pt_true = muon_pos->Pt();
    //double pt_true = muon_pos->Pt()/(1+(+1)*correction*muon_pos->Pt()/1000000.0);
 
    muon_pos->SetXYZM(muon_pos->Px()/(1+correction*pt_true/1000000.0),
              muon_pos->Py()/(1+correction*pt_true/1000000.0),
              muon_pos->Pz()/(1+correction*pt_true/1000000.0),
              muon_pos->M());    
    if (m_PrintLevel >= 3) {
      cout << " ** correctMomentum ** mu+ (eta,phi) (" << muon_pos->Eta() << ", " << muon_pos->Phi() << ") " 
       << " bin = " << h_corrections->FindBin(muon_pos->Eta(), muon_pos->Phi())
       << " correction = " << correction 
       << endl;
    }
  } 
  else {
    // mainly for delta corrections
    muon_pos->SetXYZM(muon_pos->Px()*(1-correction),
              muon_pos->Py()*(1-correction),
              muon_pos->Pz()*(1-correction),
              muon_pos->M());    
  }
  
  // negative muon
  correction = h_corrections->GetBinContent(h_corrections->FindBin(muon_neg->Eta(), muon_neg->Phi()));
  if (use_lambda) {
 
    double pt_true = muon_neg->Pt();
    //double pt_true = muon_neg->Pt()/(1+(+1)*correction*muon_neg->Pt()/1000000.0);
 
    muon_neg->SetXYZM(muon_neg->Px()/(1-correction*pt_true/1000000.0),
              muon_neg->Py()/(1-correction*pt_true/1000000.0),
              muon_neg->Pz()/(1-correction*pt_true/1000000.0),
              muon_neg->M());    
    if (m_PrintLevel >= 3) {
      cout << " ** correctMomentum ** mu- (eta,phi) (" << muon_neg->Eta() << ", " << muon_neg->Phi() << ") " 
       << " bin = " << h_corrections->FindBin(muon_neg->Eta(), muon_neg->Phi())
       << " correction = " << correction 
       << endl;
    }
  } 
  else {
    // mainly for delta corrections
    muon_neg->SetXYZM(muon_neg->Px()*(1-correction),
              muon_neg->Py()*(1-correction),
              muon_neg->Pz()*(1-correction),
              muon_neg->M());    
  }
 
  if (m_PrintLevel >= 3) {
    cout << " ** correctMomentum ** mu+ Pt: " << temp_pt_pos << " --> " << muon_pos->Pt() << " Delta = " << 100*(muon_pos->Pt()-temp_pt_pos)/temp_pt_pos << " %"<< endl
     << "                       mu- Pt: " << temp_pt_neg << " --> " << muon_neg->Pt() << " Delta = " << 100*(muon_neg->Pt()-temp_pt_neg)/temp_pt_neg << " %"<< endl;
  }
 
 
  return;
}

correctZd0()

void ZmumuValidationExample::correctZd0 ( TH1 * h_corrections, TLorentzVector * muon_pos, TLorentzVector * muon_neg, double & zd0_muon_p, double & zd0_muon_n )

private

Definition at line 705 of file ZmumuValidationExample.cxx.

{   
  double correction = h_corrections->GetBinContent(h_corrections->FindBin(muon_pos->Eta(), muon_pos->Phi()));
//  std::cout << "Pos Cor" << correction << std::endl; 
 
    zd0_muon_p = zd0_muon_p + correction ;
 
  correction = h_corrections->GetBinContent(h_corrections->FindBin(muon_neg->Eta(), muon_neg->Phi()));
    zd0_muon_n = zd0_muon_n + correction ;
//  std::cout << "Neg Cor" << correction << std::endl; 
    
}

DrawMap()

void ZmumuValidationExample::DrawMap

(

)

Definition at line 1259 of file ZmumuValidationExample.cxx.

{
  this->SymmetrizeHisto(lambdacorrections_vs_etaphi);
 
  lambdacorrections_vs_etaphi->DrawCopy("colz");
 
   return;
}

fillEtaHistogram()

void ZmumuValidationExample::fillEtaHistogram ( TH2 * hist, TLorentzVector * v_pos, TLorentzVector * v_neg, int use_lambda, int charge = 0 )

private

Definition at line 661 of file ZmumuValidationExample.cxx.

{
   double z_mass = 91187.6 + m_shift;   //MeV
   double mass = ((*v_pos) + (*v_neg)).M();
   double delta_M2 = (mass*mass - z_mass*z_mass)/(z_mass*z_mass);
   
   if (use_lambda) {
     if (charge == 0 || charge == +1) hist->Fill(v_pos->Eta(), +1*m_factor*delta_M2/v_pos->Pt()*1000000.0 );
     if (charge == 0 || charge == -1) hist->Fill(v_neg->Eta(), -1*m_factor*delta_M2/v_neg->Pt()*1000000.0 );
     
   } else { 
     hist->Fill(v_pos->Eta(), +1*delta_M2/2);
     hist->Fill(v_neg->Eta(), +1*delta_M2/2);   
   }
}

fillEtaPhiHistogram()

void ZmumuValidationExample::fillEtaPhiHistogram ( TH3 * hist, TLorentzVector * v_pos, TLorentzVector * v_neg, int use_lambda )

private

Definition at line 642 of file ZmumuValidationExample.cxx.

{
   double z_mass = 91187.6 + m_shift;   //MeV
   double mass = ((*v_pos) + (*v_neg)).M();
   double delta_M2 = (mass*mass - z_mass*z_mass)/(z_mass*z_mass);
 
   if (use_lambda) { 
     // to estimate the correction factor from: pt -> pt /(1+q pt delta_sagitta): q DeltaM2/pt
     hist->Fill(v_pos->Eta(), v_pos->Phi(), +1*m_factor*delta_M2/v_pos->Pt()*1000000.0);     
     hist->Fill(v_neg->Eta(), v_neg->Phi(), -1*m_factor*delta_M2/v_neg->Pt()*1000000.0);
     
   } else { 
     hist->Fill(v_pos->Eta(), v_pos->Phi(), +1*delta_M2/2);
     hist->Fill(v_neg->Eta(), v_neg->Phi(), +1*delta_M2/2);   
   }
}

fillHistogram()

void ZmumuValidationExample::fillHistogram ( TH1 * hist, TLorentzVector * v_pos, TLorentzVector * v_neg, int fill_lambda, int charge = 0 )

private

Definition at line 678 of file ZmumuValidationExample.cxx.

{
   double z_mass = 91187.6 + m_shift;   //MeV
   double mass = ((*v_pos) + (*v_neg)).M();
   double delta_M2 = (mass*mass - z_mass*z_mass)/(z_mass*z_mass);
   
   if (fill_lambda) {
     if (charge == 0 || charge == +1) hist->Fill( +1*m_factor*delta_M2/v_pos->Pt()*1000000.0 );
     if (charge == 0 || charge == -1) hist->Fill( -1*m_factor*delta_M2/v_neg->Pt()*1000000.0 );
     
   } else { 
     hist->Fill(+1*delta_M2/2);
     hist->Fill(+1*delta_M2/2);   
   }
}

fillHistograms()

void ZmumuValidationExample::fillHistograms ( )

private

Definition at line 358 of file ZmumuValidationExample.cxx.

{
  
  const double muon_mass = ParticleConstants::muonMassInMeV;  //MeV
  
  //create lorentz vectors for both muons
  TLorentzVector* vec_pos = new TLorentzVector(); 
  TLorentzVector* vec_neg = new TLorentzVector();
 
  //corrected z0 for both muons
  double corrected_z0_pos;
  double corrected_z0_neg;
  double corrected_d0_pos;
  double corrected_d0_neg;
 
  vec_pos->SetXYZM(m_px_pos, m_py_pos, m_pz_pos, muon_mass);
  vec_neg->SetXYZM(m_px_neg, m_py_neg, m_pz_neg, muon_mass);
  
  entries->Fill(vec_pos->Eta(),vec_pos->Phi(),1);
  entries->Fill(vec_neg->Eta(),vec_neg->Phi(),1);
  
  fillHistogram( lambda,      vec_pos,  vec_neg,  1);
  fillHistogram( lambda_pos,  vec_pos,  vec_neg,  1, +1);
  fillHistogram( lambda_neg,  vec_pos,  vec_neg,  1, -1);
  
  //z0 etaphi
  if ( m_d0_neg != 0  &&  m_d0_pos != 0){
     // setting original z0values
     corrected_z0_pos = m_z0_pos;
     corrected_z0_neg = m_z0_neg;
     // filling test histograms before correction
     fillZd0Histogram( z0delta, corrected_z0_pos, corrected_z0_neg, 0);
     fillZd0Histogram( z0delta_pos, corrected_z0_pos, corrected_z0_neg, 1);  
     fillZd0Histogram( z0delta_neg, corrected_z0_pos, corrected_z0_neg, -1);
     // adding correction to z0_pos/neg or d0_pos/neg
     correctZd0(z0deltacorrections_vs_etaphi, vec_pos, vec_neg, corrected_z0_pos, corrected_z0_neg);
     // filling the main histogram to fit in the next step
     fillZd0EtaPhiHistogram(z0delta_vs_etaphi, vec_pos, vec_neg, corrected_z0_pos, corrected_z0_neg);
     // filling test histograms after correction
     fillZd0Histogram( z0delta_etaphi, corrected_z0_pos, corrected_z0_neg, 0);
     fillZd0Histogram( z0delta_etaphi_pos, corrected_z0_pos, corrected_z0_neg, 1);
     fillZd0Histogram( z0delta_etaphi_neg, corrected_z0_pos, corrected_z0_neg, -1);
  }
 
  //d0 etaphi
  if ( m_d0_neg != 0  &&  m_d0_pos != 0){
     // setting original d0values
     corrected_d0_pos = m_d0_pos;
     corrected_d0_neg = m_d0_neg;
     // filling test histograms before correction
     fillZd0Histogram( d0delta, corrected_d0_pos, corrected_d0_neg, 0);
     fillZd0Histogram( d0delta_pos, corrected_d0_pos, corrected_d0_neg, 1);
     fillZd0Histogram( d0delta_neg, corrected_d0_pos, corrected_d0_neg, -1);
     // adding correction to z0_pos/neg or d0_pos/neg
     correctZd0(d0deltacorrections_vs_etaphi, vec_pos, vec_neg, corrected_d0_pos, corrected_d0_neg);
     // filling the main histogram to fit in the next step
     fillZd0EtaPhiHistogram(d0delta_vs_etaphi, vec_pos, vec_neg, corrected_d0_pos, corrected_d0_neg);
     // filling test histograms after correction
     fillZd0Histogram( d0delta_etaphi, corrected_d0_pos, corrected_d0_neg, 0);
     fillZd0Histogram( d0delta_etaphi_pos, corrected_d0_pos, corrected_d0_neg, 1);
     fillZd0Histogram( d0delta_etaphi_neg, corrected_d0_pos, corrected_d0_neg, -1);
  }
      
  //fill truth histograms on first iteration without correcting momentum
  if (m_isMC && n_iteration == 1) {  
 
    TLorentzVector* vec_truth_pos = new TLorentzVector();
    TLorentzVector* vec_truth_neg = new TLorentzVector();
 
    vec_truth_pos->SetXYZM(m_truth_px_pos, m_truth_py_pos, m_truth_pz_pos, muon_mass);
    vec_truth_neg->SetXYZM(m_truth_px_neg, m_truth_py_neg, m_truth_pz_neg, muon_mass);
 
    double z_mass = 91187.6;   //MeV
    double mass = ((*vec_pos) + (*vec_neg)).M();
    double mass_truth = ((*vec_truth_pos) + (*vec_truth_neg)).M();
 
    double delta_M2 = (mass*mass - z_mass*z_mass)/(z_mass*z_mass);
    double delta_M2_truth = (mass*mass - mass_truth*mass_truth)/(mass_truth*mass_truth);
    double delta_M2_truth_bias = (mass_truth*mass_truth - z_mass*z_mass)/(z_mass*z_mass);
 
    h_pt_truth->Fill(vec_truth_pos->Pt()/1000.0);
    h_pt_truth->Fill(vec_truth_neg->Pt()/1000.0);
    h_pt_pos_truth->Fill(vec_truth_pos->Pt()/1000.0);
    h_pt_neg_truth->Fill(vec_truth_neg->Pt()/1000.0);
    
    //truth momentum bias
    double d_bias_truth_pos = +1/vec_truth_pos->Pt()*(1 - vec_truth_pos->P()/vec_pos->P())*1000000.0;
    double d_bias_truth_neg = -1/vec_truth_neg->Pt()*(1 - vec_truth_neg->P()/vec_neg->P())*1000000.0;
 
    truth_mom_bias_vs_eta->Fill(vec_truth_pos->Eta(), d_bias_truth_pos);
    truth_mom_bias_vs_eta->Fill(vec_truth_neg->Eta(), d_bias_truth_neg);
 
    //Z mass/method bias
    double d_mass_bias_truth_pos = +1*delta_M2_truth_bias/vec_truth_pos->Pt()*1000000.0;
    double d_mass_bias_truth_neg = -1*delta_M2_truth_bias/vec_truth_neg->Pt()*1000000.0;
 
    truth_mass_bias_vs_eta->Fill(vec_truth_pos->Eta(), d_mass_bias_truth_pos);
    truth_mass_bias_vs_eta->Fill(vec_truth_neg->Eta(), d_mass_bias_truth_neg);
 
    //lambda corrections
    double d_lambda_truth_pos = +1*delta_M2_truth/vec_truth_pos->Pt()*1000000.0;
    double d_lambda_truth_neg = -1*delta_M2_truth/vec_truth_neg->Pt()*1000000.0;
      
    lambda_vs_etaphi_truth->Fill(vec_truth_pos->Eta(), vec_truth_pos->Phi(), d_lambda_truth_pos);
    lambda_vs_etaphi_truth->Fill(vec_truth_neg->Eta(), vec_truth_neg->Phi(), d_lambda_truth_neg);
 
    lambda_vs_eta_truth->Fill(vec_truth_pos->Eta(), d_lambda_truth_pos);
    lambda_vs_eta_truth->Fill(vec_truth_neg->Eta(), d_lambda_truth_neg);
 
    lambda_truth->Fill( d_lambda_truth_pos );
    lambda_truth->Fill( d_lambda_truth_neg );
    
    lambda_truth_pos->Fill( d_lambda_truth_pos );
    lambda_truth_neg->Fill( d_lambda_truth_neg );
    
    //delta corrections
    double delta_truth_pos =  (vec_truth_pos->P() - vec_pos->P())/vec_truth_pos->P();
    double delta_truth_neg =  (vec_truth_neg->P() - vec_neg->P())/vec_truth_neg->P();
    
    delta_vs_etaphi_truth->Fill(vec_truth_pos->Eta(), vec_truth_pos->Phi(), delta_truth_pos);
    delta_vs_etaphi_truth->Fill(vec_truth_neg->Eta(), vec_truth_neg->Phi(), delta_truth_neg);
 
    //check eta/phi biases
    delta_phi_truth->Fill(vec_truth_pos->Phi() - vec_pos->Phi());
    delta_phi_truth->Fill(vec_truth_neg->Phi() - vec_neg->Phi());
 
    delta_eta_truth->Fill(vec_truth_pos->Eta() - vec_pos->Eta());
    delta_eta_truth->Fill(vec_truth_neg->Eta() - vec_neg->Eta());
 
    //other checks
    double zpt_truth = ((*vec_truth_pos) + (*vec_truth_neg)).Pt();
    
    h_DELTA->Fill(delta_M2/(vec_pos->Pt() - vec_neg->Pt())*1000000);
    //h_DELTA->Fill(delta_M2/(vec_truth_pos->Pt() - vec_truth_neg->Pt())*1000000);
            
    delta_M2_vs_zpt_truth->Fill(zpt_truth/1000.0,delta_M2_truth); 
    delta_M2_vs_zpt->Fill(zpt_truth/1000.0,delta_M2); 
  
    delta_M2_vs_etaphi_pos->Fill(vec_pos->Eta(), vec_pos->Phi(), delta_M2);
    delta_M2_vs_etaphi_neg->Fill(vec_neg->Eta(), vec_neg->Phi(), delta_M2);
 
    delete vec_truth_pos;
    delete vec_truth_neg;
 
  } // end if of MC and truth info
 
  //-----------------------------------------------------------------
  //apply lambda momentum corrections in eta/phi
  correctMomentum( lambdacorrections_vs_etaphi, vec_pos, vec_neg, 1);
 
  fillHistogram( lambda_etaphi,      vec_pos,  vec_neg,  1);
  fillHistogram( lambda_etaphi_pos,  vec_pos,  vec_neg,  1, +1);
  fillHistogram( lambda_etaphi_neg,  vec_pos,  vec_neg,  1, -1);
 
  //fill histograms
  fillEtaPhiHistogram( lambda_vs_etaphi, vec_pos, vec_neg, 1);
 
  // fill q/pt histograms
  fillQoverPtHistograms (vec_pos, vec_neg);
 
  //-----------------------------------------------------------------
 
  //reset muon vectors and use original values
  vec_pos->SetXYZM(m_px_pos, m_py_pos, m_pz_pos, muon_mass);
  vec_neg->SetXYZM(m_px_neg, m_py_neg, m_pz_neg, muon_mass);
  
  //apply delta momentum corrections in eta/phi
  correctMomentum( deltacorrections_vs_etaphi,  vec_pos, vec_neg, 0);
  //fill histograms
  fillEtaPhiHistogram( delta_vs_etaphi, vec_pos, vec_neg, 0);
 
  //-----------------------------------------------------------------
 
  //reset muon vectors and use original values
  vec_pos->SetXYZM(m_px_pos, m_py_pos, m_pz_pos, muon_mass);
  vec_neg->SetXYZM(m_px_neg, m_py_neg, m_pz_neg, muon_mass);
 
  //apply lambda momentum corrections in eta
  correctMomentum( lambdacorrections_vs_eta,  vec_pos, vec_neg, 1);
 
  fillHistogram( lambda_eta,   vec_pos,  vec_neg,  1);
  fillHistogram( lambda_eta_pos,  vec_pos,  vec_neg,  1, +1);
  fillHistogram( lambda_eta_neg,  vec_pos,  vec_neg,  1, -1);
   
  //fill histograms
  fillEtaHistogram( lambda_vs_eta,      vec_pos,  vec_neg,  1);  
  fillEtaHistogram( lambda_vs_eta_pos,  vec_pos,  vec_neg,  1, +1);      
  fillEtaHistogram( lambda_vs_eta_neg,  vec_pos,  vec_neg,  1, -1);      
  
  //check corrected pt/mass distributions at each iteration
  h_pt->Fill(vec_pos->Pt()/1000.0);
  h_pt->Fill(vec_neg->Pt()/1000.0);
  h_pt_pos->Fill(vec_pos->Pt()/1000.0);
  h_pt_neg->Fill(vec_neg->Pt()/1000.0);
   
  h_mass->Fill(((*vec_pos)+(*vec_neg)).M()/1000.0);
  
  //check z0 distributions
  h_z0->Fill(m_z0_pos);
  h_z0->Fill(m_z0_neg);
  h_z0_pos->Fill(m_z0_pos);
  h_z0_neg->Fill(m_z0_neg);
  //check d0 distributions
  h_d0->Fill(m_d0_pos);
  h_d0->Fill(m_d0_neg);
  h_d0_pos->Fill(m_d0_pos);
  h_d0_neg->Fill(m_d0_neg);
  //-----------------------------------------------------------------
 
  delete vec_pos;
  delete vec_neg;
   
  return;
}

fillQoverPtHistograms()

void ZmumuValidationExample::fillQoverPtHistograms ( TLorentzVector * v_pos, TLorentzVector * v_neg )

private

Definition at line 695 of file ZmumuValidationExample.cxx.

{
  h_QoverPt->Fill((*v_pos).Phi(),  1000/(*v_pos).Pt());  // 1000 is for MeV to GeV
  h_QoverPt->Fill((*v_neg).Phi(), -1000/(*v_neg).Pt());
 
  h_QoverPt3D->Fill((*v_pos).Eta(), (*v_pos).Phi(),  1000/(*v_pos).Pt());  // 1000 is for MeV to GeV
  h_QoverPt3D->Fill((*v_neg).Eta(), (*v_neg).Phi(), -1000/(*v_neg).Pt());
  return;
}

fillZd0EtaPhiHistogram()

void ZmumuValidationExample::fillZd0EtaPhiHistogram ( TH3 * hist, TLorentzVector * v_pos, TLorentzVector * v_neg, double z0_muon_p, double z0_muon_n )

private

Definition at line 718 of file ZmumuValidationExample.cxx.

{
   double deltazd0 = -(zd0_muon_p - zd0_muon_n);
   hist->Fill(v_pos->Eta(),v_pos->Phi(), deltazd0);
   hist->Fill(v_neg->Eta(),v_neg->Phi(), -1.*deltazd0);
}

fillZd0Histogram()

void ZmumuValidationExample::fillZd0Histogram ( TH1 * hist, double z0_muon_p, double z0_muon_n, int pn )

private

Definition at line 725 of file ZmumuValidationExample.cxx.

{
    double deltazd0 = (zd0_muon_p - zd0_muon_n);
    if (pn == +1) hist->Fill(deltazd0);
    if (pn == -1) hist->Fill(-1.*deltazd0);
    if (pn == 0) {
        hist->Fill(-1.*deltazd0);
        hist->Fill(deltazd0);
    }
}

HistogramConditioning()

void ZmumuValidationExample::HistogramConditioning ( TH1 * hist )

private

Definition at line 1367 of file ZmumuValidationExample.cxx.

{
  if (m_PrintLevel>=3) cout << " ** HistogramConditioning ** START ** hist = " << hist->GetName() << endl; 
 
  double MinEntriesMPB = 15;
  Int_t NGroupBins = 2;
 
  // goal:
  // make sure that the most populated bin has a minimum number of entries
  Int_t  MostPopulatedBin = (hist->GetMaximumBin());
  double EntriesMPB = hist->GetBinContent(MostPopulatedBin);
  if (EntriesMPB < MinEntriesMPB) {
    // check the entries of the neighbour channels
    if ((EntriesMPB + hist->GetBinContent(MostPopulatedBin+1) + hist->GetBinContent(MostPopulatedBin-1)) > MinEntriesMPB) {
      NGroupBins = 2;
    }
    else {
      NGroupBins = 3;
    }
 
    // now find the first divisor (factor of ) the original number of bins
    Bool_t DivisorFound = false;
    while (!DivisorFound) {
      if ( hist->GetNbinsX() % NGroupBins == 0) {
    DivisorFound = true;
      }
      else {
    DivisorFound = false;
    NGroupBins++;
      }
    }
    Int_t NBinsWas = hist->GetNbinsX();
    hist = hist->Rebin(NGroupBins);
    if (m_PrintLevel>=1) cout << " ** HistogramConditioning ** histogram had to be rebinned by: " << NGroupBins 
                  << " NBins was: " << NBinsWas << " and now is: " << hist->GetNbinsX() << endl;
 
  }
    
 
  return;
}

IterativeGaussFit()

int ZmumuValidationExample::IterativeGaussFit ( TH1 * hist, double & mu, double & mu_err, double & sigma, double & sigma_err )

private

Definition at line 1099 of file ZmumuValidationExample.cxx.

{
  
  //constants for fitting algorithm
  const int iteration_limit = 20;
  const float percent_limit = 0.01;
  const float fit_range_multiplier = 1.5;
  const int fDebug = 0;
  
  double last_mu;
  double last_sigma;
  double current_mu;
  double current_sigma;
  double mu_percent_diff;
  double sigma_percent_diff;
  
  if (!hist) {
    if (fDebug) std::cout<< "Error in  Anp::IterativeGaussFit(): Histogram to be fit is missing" <<std::endl;
    return 1;
  }  
  
  this->HistogramConditioning(hist);
 
  TF1* fit_func = new TF1("fit_func","gaus");
 
  int bad_fit = hist->Fit(fit_func,"QN");
 
  if (fDebug && bad_fit) std::cout <<"BAD INITIAL FIT: "<< hist->GetTitle() << std::endl;
 
  last_mu = fit_func->GetParameter(1); 
  last_sigma = fit_func->GetParameter(2);
 
  if (bad_fit) last_mu = hist->GetMean();
 
  // check as well that the last_mu is reasonable
  if (fabs(last_mu - hist->GetMean()) > 5*hist->GetBinWidth(1)) last_mu =  hist->GetMean();  
 
  fit_func->SetRange(last_mu-fit_range_multiplier*last_sigma,last_mu+fit_range_multiplier*last_sigma);
 
  int iteration = 0;
 
  while ( iteration < iteration_limit ) {
 
    iteration++;
 
    double FitRangeLower = last_mu-fit_range_multiplier*last_sigma;
    double FitRangeUpper = last_mu+fit_range_multiplier*last_sigma;
 
    // if range is to narrow --> broaden it
    if ((FitRangeUpper-FitRangeLower)/hist->GetBinWidth(1) < 4) {
      FitRangeLower -= hist->GetBinWidth(1);
      FitRangeUpper += hist->GetBinWidth(1);
    }
 
    fit_func->SetRange(FitRangeLower, FitRangeUpper);
    if (m_PrintLevel >= 3) cout << " ** IterativeGaussFit ** fit iter # " << iteration 
                << "   new fit range: " << FitRangeLower << " --> " << FitRangeUpper << endl; 
 
 
 
    bad_fit = hist->Fit(fit_func, "RQN");
 
    if (fDebug && bad_fit) std::cout<<" ** BAD FIT ** : bin "<< hist->GetTitle() <<"  iteration "<<iteration<<std::endl;
 
    current_mu = fit_func->GetParameter(1); 
    current_sigma = fit_func->GetParameter(2);
 
    //std::cout<<"Iteration: "<<iteration<<" Current: "<<current_mu<<" "<<current_sigma<<" Last: "<<last_mu<<" "<<last_sigma<<std::endl;
 
    float average_mu = (last_mu+current_mu)/2;
    float average_sigma = (last_sigma+current_sigma)/2;
 
    if (average_mu == 0) {
      if ( fDebug ) std::cout<<" Average mu = 0 in bin "<< hist->GetTitle() <<std::endl;
      average_mu = current_mu;
    } 
 
    if (average_sigma == 0) {
      if ( fDebug ) std::cout<<"Average sigma = 0; Fit Problem in "<< hist->GetTitle() <<". "<<last_sigma<<" "<<current_sigma<<std::endl;
      average_sigma = current_sigma;
    }
 
    mu_percent_diff = fabs((last_mu-current_mu)/average_mu);
    sigma_percent_diff = fabs((last_sigma-current_sigma)/average_sigma);
 
    if ( mu_percent_diff < percent_limit && sigma_percent_diff < percent_limit ) break;
 
    if (iteration != iteration_limit) { //necessary?
      last_mu = current_mu;
      last_sigma = current_sigma;
    }    
    // check as well that the last_mu is reasonable
    if (fabs(last_mu - hist->GetMean()) > 5*hist->GetBinWidth(1)) {
      if (m_PrintLevel >= 3) cout << " ** IterativeGaussFit ** fit iter # " << iteration
                  << " ** WARNING ** last_mu looks bad: " << last_mu
                  << "    this iter mu: " << fit_func->GetParameter(1)
                  << "    proposed mu: " << hist->GetMean() 
                  << endl;
      last_mu =  hist->GetMean();  
    } 
  }
 
  if (iteration == iteration_limit) {
    if (fDebug ) std::cout<<"WARNING: Fit did not converge to < "<<percent_limit*100<<"% in "<< hist->GetTitle() <<" in "<<iteration_limit<<" iterations. Percent Diffs: "<<mu_percent_diff*100<<"% (Mu),"<<" "<<sigma_percent_diff*100<<"% (Sigma)"<<std::endl;
    //possibly return a value other than 0 to indicate not converged?
  }
 
  mu = current_mu;
  mu_err = fit_func->GetParError(1);
  sigma = current_sigma;
  sigma_err = fit_func->GetParError(2);
  
  hist->GetListOfFunctions()->Add(fit_func);
 
  if (m_PrintLevel >= 1 ) {
    cout << " ** IterativeGaussFit ** fit result: histo name " << hist->GetName() << "    title: " << hist->GetTitle()  << endl
     << "    mu = " << mu << " +- " << mu_err << endl
     << " sigma = " << sigma << " +- " << sigma_err 
     << endl;
    if (TempCanvasIterGaussFit == NULL) {
      TempCanvasIterGaussFit = new TCanvas ("TempCanvasIterGaussFit","Iter Gauss fit", 400, 400);
    }
    hist->DrawCopy();
    TempCanvasIterGaussFit->Update();
    hist->Print();
    string input = "";
    cout << " ** IterativeGaussFit ** Please type RETURN to continue:\n>";
    getline(cin, input);
  }
  
  return 0;
}

loadChains()

void ZmumuValidationExample::loadChains ( )

private

Definition at line 51 of file ZmumuValidationExample.cxx.

{
   std::cout << "Input Files:" << std::endl;
 
   std::list<std::string>::const_iterator theEnd = m_fileNames.end();
   for( std::list<std::string>::const_iterator itr = m_fileNames.begin()
      ; itr != theEnd
      ; ++itr
      )
   {
      std::cout <<"  "<< *itr << std::endl;
      
      m_eventChain.Add( itr->c_str() );
      if (m_isMC) m_truthChain.Add( itr->c_str() );
   }
   
   return;
}    

loop()

void ZmumuValidationExample::loop

(

unsigned

maxEvents = 0

)

Definition at line 288 of file ZmumuValidationExample.cxx.

{
   std::cout << "  TrkValidation::loop()" << std::endl;
   n_iteration++;
   
   //clear histograms to be fit
   this->ResetHistograms();
 
   unsigned int const nEvents = m_eventChain.GetEntries();
   unsigned int const maxItr = ( maxEvents > 0 && maxEvents < nEvents ) ? maxEvents : nEvents;
 
   //loop through events and fill histograms
   if (m_PrintLevel >= 1) cout << " ** ZmumuValidationExample::loop ** start loop on events ... " << endl;
   loopThroughEvents( maxItr );
   
   if (m_PrintLevel >= 1) cout<< " ** ZmumuValidationExample::loop ** Fitting histograms" << endl;
   
   //Fit corrections and add to previous corrections
   profileZwithIterativeGaussFit(lambda_vs_etaphi,lambdacorrections_vs_etaphi, lambdacorrections_vs_etaphi_RMS, 1, lambdacorrections_vs_etaphi_err);
   profileZwithIterativeGaussFit(delta_vs_etaphi,deltacorrections_vs_etaphi, 0, 1,deltacorrections_vs_etaphi_err);
   profileYwithIterativeGaussFit(lambda_vs_eta,lambdacorrections_vs_eta);
   
   profileZwithIterativeGaussFit(z0delta_vs_etaphi,z0deltacorrections_vs_etaphi, 0, 1, z0deltacorrections_vs_etaphi_err);
   profileZwithIterativeGaussFit(d0delta_vs_etaphi,d0deltacorrections_vs_etaphi, 0, 1, d0deltacorrections_vs_etaphi_err);
   
   if (m_isMC && n_iteration == 1) {  
     profileZwithIterativeGaussFit(lambda_vs_etaphi_truth,  lambdacorrections_vs_etaphi_truth, 0, 1, lambdacorrections_vs_etaphi_truth_err);
     profileZwithIterativeGaussFit(delta_vs_etaphi_truth,  deltacorrections_vs_etaphi_truth, 0, 1, deltacorrections_vs_etaphi_truth_err);
     
     profileYwithIterativeGaussFit(lambda_vs_eta_truth, lambdacorrections_vs_eta_truth);     
     profileYwithIterativeGaussFit(truth_mom_bias_vs_eta, truth_mom_biascorrections_vs_eta);     
     profileYwithIterativeGaussFit(truth_mass_bias_vs_eta, truth_mass_biascorrections_vs_eta);     
   }
 
  writeToFile(n_iteration);
  
  return;
}

loopThroughEvents()

void ZmumuValidationExample::loopThroughEvents ( unsigned int maxItr )

private

Definition at line 331 of file ZmumuValidationExample.cxx.

{
   std::cout << "  Looping over " << maxItr << " events"<< std::endl;
       
   for( unsigned int eventItr = 0
      ; eventItr != maxItr
      ; ++eventItr
      )
   {
      if( eventItr % 10000 == 0 )
      {
     std::cout << "  Processing event " << eventItr << " of " << maxItr << std::endl;
      }
        
      if( !m_eventChain.LoadTree(eventItr) || (m_isMC && !m_truthChain.LoadTree(eventItr)) ) 
     continue;
         
      if( !m_eventChain.GetEntry(eventItr) || (m_isMC && !m_truthChain.GetEntry(eventItr)) )
     continue;
         
      fillHistograms();
   }
   
   return;
}

profileYwithIterativeGaussFit()

void ZmumuValidationExample::profileYwithIterativeGaussFit ( TH2 * hist, TH1 * mu_graph = 0, TH1 * sigma_graph = 0, int num_bins = 1 )

private

Definition at line 990 of file ZmumuValidationExample.cxx.

{
 
  if (!hist) {
    std::cout << "Error in ProfileYwithIterativeGaussFit(): Histogram not found" <<std::endl;
    return;
  }
 
  if (num_bins < 1 ) {
    std::cout << "Error in ProfileYwithIterativeGaussFit(): Invalid number of bins to integrate over." <<std::endl;
    return;
  }
 
  const int minEntries = 50;
  const int fDebug = 0; 
 
  int num_bins_x = hist->GetXaxis()->GetNbins();
  
  if (mu_graph) mu_graph->Rebin(num_bins);
  if (sigma_graph) sigma_graph->Rebin(num_bins);
  
  double* errs_mu = new double[num_bins_x/num_bins + 2]; // +2 for overflow!! 
  double* errs_sigma = new double[num_bins_x/num_bins + 2];
 
  errs_mu[0] = 0;
  errs_mu[num_bins_x/num_bins + 1] = 0;
 
  errs_sigma[0] = 0;
  errs_sigma[num_bins_x/num_bins + 1] = 0;
 
  double min_sigma = 0;
  double max_sigma = 0; 
  double min_mu = 0;
  double max_mu = 0;
 
  int num_skipped = 0;
 
  TH1D* current_proj;
 
  for (int i = 1; i < (num_bins_x + (num_bins == 1)); i+=num_bins) {
 
    int index = i/num_bins;
    if (num_bins == 1) index--;
 
    current_proj = hist->ProjectionY(Form("%s_projection_%i",hist->GetName(),index),i,i+num_bins-1);
 
    double mu, mu_err, sigma, sigma_err;
 
    if(current_proj->GetEntries() < minEntries) {
      mu = 0;
      mu_err = 0;
      sigma = 0;
      sigma_err = 0;
      num_skipped++;
      if ( fDebug ) std::cout<<"WARNING: Not enough entries in bin "<<index<<std::endl;
    } else {
    
      IterativeGaussFit(current_proj, mu, mu_err, sigma, sigma_err);
 
      if (sigma > max_sigma || max_sigma == 0) max_sigma = sigma;
      if (sigma < min_sigma || min_sigma == 0) min_sigma = sigma;
      if (mu > max_mu || max_mu == 0) max_mu = mu;
      if (mu < min_mu || min_mu == 0) min_mu = mu;
 
    }
    
    double value_x = (hist->GetXaxis()->GetBinLowEdge(i) + hist->GetXaxis()->GetBinUpEdge(i+num_bins-1))/2;
 
    //Important!! Use Fill to increment the graph with each iteration, or SetBinContent to replace contents...
 
    //if (sigma_graph) sigma_graph->SetBinContent(i, sigma);
    //if (mu_graph) mu_graph->SetBinContent(i, mu);
 
    if (sigma_graph) sigma_graph->Fill(value_x, sigma);
    if (mu_graph) mu_graph->Fill(value_x, mu);
   
    errs_mu[index + 1] = mu_err;
    errs_sigma[index + 1] = sigma_err;
    
    delete current_proj;
  }
  
  if (sigma_graph) {
    sigma_graph->SetError(errs_sigma);
    //sigma_graph->SetMaximum(max_sigma+0.15*(max_sigma - min_sigma));
    //sigma_graph->SetMinimum(min_sigma-0.15*(max_sigma - min_sigma));
    sigma_graph->GetYaxis()->SetTitleOffset(1.5);
    sigma_graph->GetYaxis()->SetTitle(hist->GetYaxis()->GetTitle());
    sigma_graph->GetXaxis()->SetTitle(hist->GetXaxis()->GetTitle());
    sigma_graph->SetTitle("");
  }
  
  if (mu_graph) {
    mu_graph->SetError(errs_mu);
    //mu_graph->SetMaximum(max_mu+0.15*(max_mu - min_mu));
    //mu_graph->SetMinimum(min_mu-0.15*(max_mu - min_mu));
    mu_graph->GetYaxis()->SetTitleOffset(1.5);
    mu_graph->GetYaxis()->SetTitle(hist->GetYaxis()->GetTitle());
    mu_graph->GetXaxis()->SetTitle(hist->GetXaxis()->GetTitle());
    mu_graph->SetTitle("");
  }
  
  if (fDebug && num_skipped)  std::cout<<" Number of skipped bins: "<<num_skipped<<std::endl;
  
  return;
 
}

profileZwithIterativeGaussFit()

void ZmumuValidationExample::profileZwithIterativeGaussFit ( TH3 * hist, TH2 * mu_graph, TH2 * sigma_graph, int num_bins, TH2 * mu_err_graph = 0, TH2 * sigma_err_graph = 0 )

private

Definition at line 862 of file ZmumuValidationExample.cxx.

{
  if (!hist) {
    cout<< "ProfileZwithIterativeGaussFit(): No histogram supplied!"<<endl;
    return;
  }
 
  int minEntries = 50;
  int fDebug = 0;
 
  int num_bins_x = hist->GetXaxis()->GetNbins();
  int num_bins_y = hist->GetYaxis()->GetNbins();
 
  double num_not_converged = 0;
  int num_skipped = 0;
 
  double max_sigma = 0;
  double min_sigma = 0;
 
  double max_mu = 0;
  double min_mu = 0;
 
  TH1D* current_proj;
 
  for (int i = 1; i < num_bins_x+(num_bins==1); i+=num_bins) {
 
  for (int j = 1; j < num_bins_y+(num_bins==1); j+=num_bins) {
 
    int index = i/num_bins;
    int index_y = j/num_bins;
 
    current_proj = hist->ProjectionZ(Form("%s_GaussProjection_%i_%i",hist->GetName(),index, index_y),i,i+num_bins-1,j,j+num_bins-1);
    current_proj->SetTitle(Form("%s - Bin %i x %i",hist->GetName(), index,index_y));
 
    double current_mu,current_err_mu, current_sigma, current_err_sigma;
 
    if(current_proj->GetEntries() < minEntries) {
      if (m_PrintLevel >= 1) cout << " ** profileZwithIterativeGaussFit ** fitting " << hist->GetName() << "  bin (" << index << ", " << index_y << ") "
                  << " Not enough entries " << current_proj->GetEntries() << " < " << minEntries << endl;
       //current_mu = -999;
       current_mu = 0;
       current_sigma = 0;
       current_err_mu = 1;
       current_err_sigma = 1;
       
       if (fDebug) std::cout<<"WARNING: Only "<<current_proj->GetEntries()<<" entries in bin "<<index<<","<<index_y<< " in histogram " <<hist->GetName()<< std::endl;
       num_skipped++;
 
    } else {
      if (m_PrintLevel >= 1) cout << " ** profileZwithIterativeGaussFit ** fitting " << hist->GetName() << "  bin (" << index << ", " << index_y << ") " << endl;
      
      IterativeGaussFit(current_proj, current_mu, current_err_mu, current_sigma, current_err_sigma);
 
      if (current_sigma > max_sigma || max_sigma == 0) max_sigma = current_sigma;
      if (current_sigma < min_sigma || min_sigma == 0) min_sigma = current_sigma;
      if (current_mu > max_mu || max_mu == 0) max_mu = current_mu;
      if (current_mu < min_mu || min_mu == 0) min_mu = current_mu;
 
    }//end if entries < minEntries
 
    float x_coord = (hist->GetXaxis()->GetBinLowEdge(i) + hist->GetXaxis()->GetBinUpEdge(i+num_bins-1))/2;
    float y_coord = (hist->GetYaxis()->GetBinLowEdge(j) + hist->GetYaxis()->GetBinUpEdge(j+num_bins-1))/2;
 
    if (sigma_graph) sigma_graph->Fill(x_coord,y_coord,current_sigma);
    if (mu_graph) mu_graph->Fill(x_coord,y_coord,current_mu);
        
    //should probably be replace bin content, not fill?
    if (sigma_err_graph) sigma_err_graph->Fill(x_coord,y_coord,current_err_sigma);
    if (mu_err_graph) mu_err_graph->Fill(x_coord,y_coord,current_err_mu);
 
    delete current_proj;
    
  } //end loop on j (y)
  } //end loop on i (x)
  
  if (mu_graph) {
    mu_graph->GetXaxis()->SetTitle(hist->GetXaxis()->GetTitle());
    mu_graph->GetYaxis()->SetTitle(hist->GetYaxis()->GetTitle());
    mu_graph->GetYaxis()->SetTitleOffset(1);
    mu_graph->GetZaxis()->SetTitle(hist->GetZaxis()->GetTitle());
    mu_graph->GetZaxis()->SetTitleOffset(1.2);
    mu_graph->SetTitle( "" );
    //mu_graph->SetMaximum(max_mu + 0.1* (max_mu-min_mu));
    //mu_graph->SetMinimum(min_mu - 0.1* (max_mu-min_mu));
  }
  
  if (sigma_graph) {
    sigma_graph->GetXaxis()->SetTitle(hist->GetXaxis()->GetTitle());
    sigma_graph->GetYaxis()->SetTitle(hist->GetYaxis()->GetTitle());
    sigma_graph->GetYaxis()->SetTitleOffset(1);
    sigma_graph->GetZaxis()->SetTitle(hist->GetZaxis()->GetTitle());
    sigma_graph->GetZaxis()->SetTitleOffset(1.2);
    sigma_graph->SetTitle( "" );
    //sigma_graph->SetMaximum(max_sigma + 0.1* (max_sigma-min_sigma));
    //sigma_graph->SetMinimum(min_sigma - 0.1* (max_sigma-min_sigma));
  }
 
  if (mu_err_graph) {
    mu_err_graph->GetXaxis()->SetTitle(hist->GetXaxis()->GetTitle());
    mu_err_graph->GetYaxis()->SetTitle(hist->GetYaxis()->GetTitle());
    mu_err_graph->GetYaxis()->SetTitleOffset(1);
    mu_err_graph->GetZaxis()->SetTitle(Form("Error of fit #mu: %s",hist->GetZaxis()->GetTitle()));
    mu_err_graph->GetZaxis()->SetTitleOffset(1.2);
    mu_err_graph->SetTitle(hist->GetTitle());
    //mu_err_graph->SetMaximum(max_mu + 0.1* (max_mu-min_mu));
    //mu_err_graph->SetMinimum(min_mu - 0.1* (max_mu-min_mu));
  }
 
  if (sigma_err_graph) {
    sigma_err_graph->GetXaxis()->SetTitle(hist->GetXaxis()->GetTitle());
    sigma_err_graph->GetYaxis()->SetTitle(hist->GetYaxis()->GetTitle());
    sigma_err_graph->GetYaxis()->SetTitleOffset(1);
    sigma_err_graph->GetZaxis()->SetTitle(Form("Error of fit #sigma: %s",hist->GetZaxis()->GetTitle()));
    sigma_err_graph->GetZaxis()->SetTitleOffset(1.2);
    sigma_err_graph->SetTitle(hist->GetTitle());
    //sigma_err_graph->SetMaximum(max_mu + 0.1* (max_mu-min_mu));
    //sigma_err_graph->SetMinimum(min_mu - 0.1* (max_mu-min_mu));
  }
  
 
  if (num_not_converged || num_skipped) std::cout<<"Fit Results for histogram: "<< hist->GetName()<<std::endl;
  if (num_not_converged) std::cout<<"Non Convergent Bin Fraction: "<<num_not_converged<< " / " <<num_bins_x*num_bins_y - num_skipped<<std::endl;
  if (num_skipped) std::cout<<"Number skipped bins: "<<num_skipped<< " / " <<num_bins_x*num_bins_y<<std::endl;
 
  return;
}

ResetHistograms()

void ZmumuValidationExample::ResetHistograms ( )

private

Definition at line 1269 of file ZmumuValidationExample.cxx.

{
   delta_vs_etaphi->Reset();
   
   //
   entries->Reset();
   z0delta_vs_etaphi->Reset();
 
   z0delta->Reset();
   z0delta_pos->Reset();
   z0delta_neg->Reset();
   z0delta_etaphi->Reset();
   z0delta_etaphi_pos->Reset();
   z0delta_etaphi_neg->Reset();
 
   d0delta_vs_etaphi->Reset();
 
   d0delta->Reset();
   d0delta_pos->Reset();
   d0delta_neg->Reset();
   d0delta_etaphi->Reset();
   d0delta_etaphi_pos->Reset();
   d0delta_etaphi_neg->Reset();
   //
   
   h_DELTA->Reset();
   h_pt->Reset();
   h_pt_pos->Reset();
   h_pt_neg->Reset();
   h_mass->Reset();
 
   delta_vs_etaphi->Reset();
 
   deltacorrections_vs_etaphi->Reset();
   deltacorrections_vs_etaphi_err->Reset();
  
   lambda_vs_etaphi->Reset();
   lambdacorrections_vs_etaphi->Reset();
   lambdacorrections_vs_etaphi_err->Reset();
 
   lambda_vs_eta->Reset();
   lambda_vs_eta_pos->Reset();
   lambda_vs_eta_neg->Reset();
 
   lambdacorrections_vs_eta->Reset();
 
   lambda->Reset();
   lambda_pos->Reset();
   lambda_neg->Reset();
 
   lambda_eta->Reset();
   lambda_eta_pos->Reset();
   lambda_eta_neg->Reset();
 
   lambda_etaphi->Reset();
   lambda_etaphi_pos->Reset();
   lambda_etaphi_neg->Reset();
 
   // impact param histos
   h_z0->Reset();
   h_z0_pos->Reset();
   h_z0_neg->Reset();
   h_d0->Reset();
   h_d0_pos->Reset();
   h_d0_neg->Reset();
 
   return;
}

setBranchAddresses()

void ZmumuValidationExample::setBranchAddresses ( )

private

Definition at line 74 of file ZmumuValidationExample.cxx.

{
   // set branch addresses for event tree
   m_eventChain.SetBranchAddress( "Positive_Px",  &m_px_pos,  &b_px_pos); 
   m_eventChain.SetBranchAddress( "Positive_Py",  &m_py_pos,  &b_py_pos);   
   m_eventChain.SetBranchAddress( "Positive_Pz",  &m_pz_pos,  &b_pz_pos);
 
   m_eventChain.SetBranchAddress( "Negative_Px",  &m_px_neg,  &b_px_neg); 
   m_eventChain.SetBranchAddress( "Negative_Py",  &m_py_neg,  &b_py_neg);   
   m_eventChain.SetBranchAddress( "Negative_Pz",  &m_pz_neg,  &b_pz_neg);
 
   m_eventChain.SetBranchAddress( "Positive_z0",  &m_z0_pos,  &b_z0_pos);
   m_eventChain.SetBranchAddress( "Positive_d0",  &m_d0_pos,  &b_d0_pos);
   
   m_eventChain.SetBranchAddress( "Negative_z0",  &m_z0_neg,  &b_z0_neg);
   m_eventChain.SetBranchAddress( "Negative_d0",  &m_d0_neg,  &b_d0_neg);
 
   if (m_isMC) {
   
     m_truthChain.SetBranchAddress("Positive_Px",  &m_truth_px_pos,  &b_truth_px_pos);
     m_truthChain.SetBranchAddress("Positive_Py",  &m_truth_py_pos,  &b_truth_py_pos);
     m_truthChain.SetBranchAddress("Positive_Pz",  &m_truth_pz_pos,  &b_truth_pz_pos);
                                                 
     m_truthChain.SetBranchAddress("Negative_Px",  &m_truth_px_neg,  &b_truth_px_neg);
     m_truthChain.SetBranchAddress("Negative_Py",  &m_truth_py_neg,  &b_truth_py_neg);
     m_truthChain.SetBranchAddress("Negative_Pz",  &m_truth_pz_neg,  &b_truth_pz_neg);
   }
 
   return;   
}

SetEtaBins()

void ZmumuValidationExample::SetEtaBins

(

int

newbins = 20

)

Definition at line 1241 of file ZmumuValidationExample.cxx.

{
  m_EtaBins = newbins;
  if (m_EtaBins < 1) m_EtaBins = 1;
  if (m_EtaBins > 100) m_EtaBins = 100;
  return;
}

SetPhiBins()

void ZmumuValidationExample::SetPhiBins

(

int

newbins = 20

)

Definition at line 1250 of file ZmumuValidationExample.cxx.

{
  m_PhiBins = newbins;
  if (m_PhiBins < 1) m_PhiBins = 1;
  if (m_PhiBins > 100) m_PhiBins = 100;
  return;
}

SetPrintLevel()

void ZmumuValidationExample::SetPrintLevel

(

int

newprintlevel = 0

)

Definition at line 1233 of file ZmumuValidationExample.cxx.

{
  m_PrintLevel = newprintlevel;
  if (m_PrintLevel < 0) m_PrintLevel = 0;
  return;
}

SymmetrizeHisto()

void ZmumuValidationExample::SymmetrizeHisto ( TH2 * hist )

private

Definition at line 1339 of file ZmumuValidationExample.cxx.

{
  double RangeUpper = hist->GetBinContent(hist->GetMaximumBin());
  double RangeLower = hist->GetBinContent(hist->GetMinimumBin());
 
  double NewRangeUpper = RangeUpper;
  double NewRangeLower = -RangeUpper;
 
  if (RangeUpper < - RangeLower) {
    NewRangeUpper = -RangeLower;
    NewRangeLower =  RangeLower;
  }
 
  NewRangeUpper *= 1.01; // increase a bit the scale just to make sure everything fits in
  NewRangeLower *= 1.01;
 
  if (m_PrintLevel >= 3) {
    cout <<  " ** SymmetrizeHisto ** old range: " << RangeLower << " --> " << RangeUpper << endl;
    cout <<  "                       new range: " << NewRangeLower << " --> " << NewRangeUpper << endl;
  }
 
  hist->SetMaximum(NewRangeUpper);
  hist->SetMinimum(NewRangeLower);
  
  return;
}

writeToFile()

void ZmumuValidationExample::writeToFile

(

int

iteration

)

Definition at line 740 of file ZmumuValidationExample.cxx.

{
 
  m_file.cd(); 
 
  if (m_isMC && iteration == 1) {
 
    h_pt_truth->Write(); 
    h_pt_pos_truth->Write(); 
    h_pt_neg_truth->Write(); 
  
    deltacorrections_vs_etaphi_truth->Write();
    deltacorrections_vs_etaphi_truth_err->Write();
 
    lambdacorrections_vs_etaphi_truth->Write();
    lambdacorrections_vs_etaphi_truth_err->Write();
    
    lambdacorrections_vs_eta_truth->Write();
    lambda_vs_eta_truth->Write();
      
    truth_mom_biascorrections_vs_eta->Write();
    truth_mom_bias_vs_eta->Write();  
 
    truth_mass_biascorrections_vs_eta->Write();
    truth_mass_bias_vs_eta->Write();   
 
    lambda_truth->Write();
    lambda_truth_pos->Write();
    lambda_truth_neg->Write();
    
    delta_phi_truth->Write();
    delta_eta_truth->Write();
    
    delta_M2_vs_zpt_truth->Write();
    delta_M2_vs_zpt->Write();
    
    delta_M2_vs_etaphi_pos->Write();
    delta_M2_vs_etaphi_neg->Write();
 
  }
  
  if (iteration > 0) {
    m_file.mkdir(Form("Iteration%i",iteration));
    m_file.cd(Form("Iteration%i",iteration));
  }
 
  h_pt->Write(); 
  h_pt_pos->Write(); 
  h_pt_neg->Write(); 
  h_mass->Write();
  
  h_z0->Write();
  h_z0_pos->Write();
  h_z0_neg->Write();
  h_d0->Write();
  h_d0_pos->Write();
  h_d0_neg->Write();
 
  deltacorrections_vs_etaphi->Write(); 
  deltacorrections_vs_etaphi_err->Write(); 
 
  entries->Write();
  
  lambdacorrections_vs_etaphi->Write();
  lambdacorrections_vs_etaphi_err->Write();
  lambdacorrections_vs_etaphi_RMS->Write();
  lambdacorrections_vs_eta->Write();
  
  lambda_vs_eta->Write();
  lambda_vs_etaphi->Write();
  
  lambda_vs_eta_pos->Write();
  lambda_vs_eta_neg->Write();
  
  lambda->Write();   
  lambda_pos->Write();
  lambda_neg->Write();
  
  lambda_eta->Write();
  lambda_eta_pos->Write();
  lambda_eta_neg->Write();
 
  lambda_etaphi->Write();
  lambda_etaphi_pos->Write();
  lambda_etaphi_neg->Write();
  
  z0delta_vs_etaphi->Write();
  z0deltacorrections_vs_etaphi->Write();
  z0deltacorrections_vs_etaphi_err->Write();
 
  z0delta->Write();
  z0delta_pos->Write();
  z0delta_neg->Write();
 
 
  z0delta_etaphi->Write();
  z0delta_etaphi_pos->Write();
  z0delta_etaphi_neg->Write();
 
  d0delta_vs_etaphi->Write();
  d0deltacorrections_vs_etaphi->Write();
  d0deltacorrections_vs_etaphi_err->Write();
 
  d0delta->Write();
  d0delta_pos->Write();
  d0delta_neg->Write();
 
  d0delta_etaphi->Write();
  d0delta_etaphi_pos->Write();
  d0delta_etaphi_neg->Write();
  
  //cout<< "MEAN: " <<h_DELTA->GetMean()<<endl;
  h_DELTA->Write();
 
  //
  h_QoverPt->Write();
  h_QoverPt3D->Write();
  // delta_vs_etaphi->Write();
}

Member Data Documentation

b_d0_neg

TBranch* ZmumuValidationExample::b_d0_neg {}

private

Definition at line 83 of file ZmumuValidationExample.h.

{};

b_d0_pos

TBranch* ZmumuValidationExample::b_d0_pos {}

private

Definition at line 82 of file ZmumuValidationExample.h.

{};

b_px_neg

TBranch* ZmumuValidationExample::b_px_neg {}

private

Definition at line 76 of file ZmumuValidationExample.h.

{};

b_px_pos

TBranch* ZmumuValidationExample::b_px_pos {}

private

Definition at line 72 of file ZmumuValidationExample.h.

{};

b_py_neg

TBranch* ZmumuValidationExample::b_py_neg {}

private

Definition at line 77 of file ZmumuValidationExample.h.

{};

b_py_pos

TBranch* ZmumuValidationExample::b_py_pos {}

private

Definition at line 73 of file ZmumuValidationExample.h.

{};

b_pz_neg

TBranch* ZmumuValidationExample::b_pz_neg {}

private

Definition at line 78 of file ZmumuValidationExample.h.

{};      

b_pz_pos

TBranch* ZmumuValidationExample::b_pz_pos {}

private

Definition at line 74 of file ZmumuValidationExample.h.

{};

b_truth_px_neg

TBranch* ZmumuValidationExample::b_truth_px_neg {}

private

Definition at line 89 of file ZmumuValidationExample.h.

{};

b_truth_px_pos

TBranch* ZmumuValidationExample::b_truth_px_pos {}

private

Definition at line 85 of file ZmumuValidationExample.h.

{};

b_truth_py_neg

TBranch* ZmumuValidationExample::b_truth_py_neg {}

private

Definition at line 90 of file ZmumuValidationExample.h.

{};

b_truth_py_pos

TBranch* ZmumuValidationExample::b_truth_py_pos {}

private

Definition at line 86 of file ZmumuValidationExample.h.

{};

b_truth_pz_neg

TBranch* ZmumuValidationExample::b_truth_pz_neg {}

private

Definition at line 91 of file ZmumuValidationExample.h.

{};   

b_truth_pz_pos

TBranch* ZmumuValidationExample::b_truth_pz_pos {}

private

Definition at line 87 of file ZmumuValidationExample.h.

{};

b_z0_neg

TBranch* ZmumuValidationExample::b_z0_neg {}

private

Definition at line 81 of file ZmumuValidationExample.h.

{};

b_z0_pos

TBranch* ZmumuValidationExample::b_z0_pos {}

private

Definition at line 80 of file ZmumuValidationExample.h.

{};

d0delta

TH1* ZmumuValidationExample::d0delta {}

private

Definition at line 180 of file ZmumuValidationExample.h.

{};

d0delta_etaphi

TH1* ZmumuValidationExample::d0delta_etaphi {}

private

Definition at line 184 of file ZmumuValidationExample.h.

{};

d0delta_etaphi_neg

TH1* ZmumuValidationExample::d0delta_etaphi_neg {}

private

Definition at line 186 of file ZmumuValidationExample.h.

{};

d0delta_etaphi_pos

TH1* ZmumuValidationExample::d0delta_etaphi_pos {}

private

Definition at line 185 of file ZmumuValidationExample.h.

{};

d0delta_neg

TH1* ZmumuValidationExample::d0delta_neg {}

private

Definition at line 182 of file ZmumuValidationExample.h.

{};

d0delta_pos

TH1* ZmumuValidationExample::d0delta_pos {}

private

Definition at line 181 of file ZmumuValidationExample.h.

{};

d0delta_vs_etaphi

TH3* ZmumuValidationExample::d0delta_vs_etaphi {}

private

Definition at line 175 of file ZmumuValidationExample.h.

{};         

d0deltacorrections_vs_etaphi

TH2* ZmumuValidationExample::d0deltacorrections_vs_etaphi {}

private

Definition at line 177 of file ZmumuValidationExample.h.

{};

d0deltacorrections_vs_etaphi_err

TH2* ZmumuValidationExample::d0deltacorrections_vs_etaphi_err {}

private

Definition at line 178 of file ZmumuValidationExample.h.

{};

delta_eta_truth

TH1* ZmumuValidationExample::delta_eta_truth {}

private

Definition at line 212 of file ZmumuValidationExample.h.

{};

delta_M2_vs_etaphi_neg

TProfile2D* ZmumuValidationExample::delta_M2_vs_etaphi_neg {}

private

Definition at line 218 of file ZmumuValidationExample.h.

{}; 

delta_M2_vs_etaphi_pos

TProfile2D* ZmumuValidationExample::delta_M2_vs_etaphi_pos {}

private

Definition at line 217 of file ZmumuValidationExample.h.

{}; 

delta_M2_vs_zpt

TH2* ZmumuValidationExample::delta_M2_vs_zpt {}

private

Definition at line 215 of file ZmumuValidationExample.h.

{};

delta_M2_vs_zpt_truth

TH2* ZmumuValidationExample::delta_M2_vs_zpt_truth {}

private

Definition at line 214 of file ZmumuValidationExample.h.

{}; 

delta_phi_truth

TH1* ZmumuValidationExample::delta_phi_truth {}

private

Definition at line 210 of file ZmumuValidationExample.h.

{};

delta_vs_etaphi

TH3* ZmumuValidationExample::delta_vs_etaphi {}

private

Definition at line 127 of file ZmumuValidationExample.h.

{};         

delta_vs_etaphi_truth

TH3* ZmumuValidationExample::delta_vs_etaphi_truth {}

private

Definition at line 189 of file ZmumuValidationExample.h.

{};     

deltacorrections_vs_etaphi

TH2* ZmumuValidationExample::deltacorrections_vs_etaphi {}

private

Definition at line 129 of file ZmumuValidationExample.h.

{}; 

deltacorrections_vs_etaphi_err

TH2* ZmumuValidationExample::deltacorrections_vs_etaphi_err {}

private

Definition at line 131 of file ZmumuValidationExample.h.

{}; 

deltacorrections_vs_etaphi_truth

TH2* ZmumuValidationExample::deltacorrections_vs_etaphi_truth {}

private

Definition at line 190 of file ZmumuValidationExample.h.

{}; 

deltacorrections_vs_etaphi_truth_err

TH2* ZmumuValidationExample::deltacorrections_vs_etaphi_truth_err {}

private

Definition at line 191 of file ZmumuValidationExample.h.

{}; 

entries

TH2* ZmumuValidationExample::entries {}

private

Definition at line 159 of file ZmumuValidationExample.h.

{};

etaphi_neg

TH2* ZmumuValidationExample::etaphi_neg {}

private

Definition at line 122 of file ZmumuValidationExample.h.

{};

etaphi_pos

TH2* ZmumuValidationExample::etaphi_pos {}

private

Definition at line 121 of file ZmumuValidationExample.h.

{};

h_d0

TH1* ZmumuValidationExample::h_d0 {}

private

Definition at line 110 of file ZmumuValidationExample.h.

{};

h_d0_neg

TH1* ZmumuValidationExample::h_d0_neg {}

private

Definition at line 112 of file ZmumuValidationExample.h.

{};

h_d0_pos

TH1* ZmumuValidationExample::h_d0_pos {}

private

Definition at line 111 of file ZmumuValidationExample.h.

{};

h_DELTA

TH1* ZmumuValidationExample::h_DELTA {}

private

Definition at line 97 of file ZmumuValidationExample.h.

{}; 

h_mass

TH1* ZmumuValidationExample::h_mass {}

private

Definition at line 114 of file ZmumuValidationExample.h.

{}; 

h_pt

TH1* ZmumuValidationExample::h_pt {}

private

Definition at line 99 of file ZmumuValidationExample.h.

{}; 

h_pt_neg

TH1* ZmumuValidationExample::h_pt_neg {}

private

Definition at line 101 of file ZmumuValidationExample.h.

{};

h_pt_neg_truth

TH1* ZmumuValidationExample::h_pt_neg_truth {}

private

Definition at line 105 of file ZmumuValidationExample.h.

{};

h_pt_pos

TH1* ZmumuValidationExample::h_pt_pos {}

private

Definition at line 100 of file ZmumuValidationExample.h.

{};

h_pt_pos_truth

TH1* ZmumuValidationExample::h_pt_pos_truth {}

private

Definition at line 104 of file ZmumuValidationExample.h.

{};

h_pt_truth

TH1* ZmumuValidationExample::h_pt_truth {}

private

Definition at line 103 of file ZmumuValidationExample.h.

{};

h_QoverPt

TH2* ZmumuValidationExample::h_QoverPt {}

private

Definition at line 221 of file ZmumuValidationExample.h.

{}; 

h_QoverPt3D

TH3* ZmumuValidationExample::h_QoverPt3D {}

private

Definition at line 222 of file ZmumuValidationExample.h.

{}; 

h_z0

TH1* ZmumuValidationExample::h_z0 {}

private

Definition at line 107 of file ZmumuValidationExample.h.

{};

h_z0_neg

TH1* ZmumuValidationExample::h_z0_neg {}

private

Definition at line 109 of file ZmumuValidationExample.h.

{};

h_z0_pos

TH1* ZmumuValidationExample::h_z0_pos {}

private

Definition at line 108 of file ZmumuValidationExample.h.

{};

lambda

TH1* ZmumuValidationExample::lambda {}

private

Definition at line 146 of file ZmumuValidationExample.h.

{};

lambda_eta

TH1* ZmumuValidationExample::lambda_eta {}

private

Definition at line 154 of file ZmumuValidationExample.h.

{};

lambda_eta_neg

TH1* ZmumuValidationExample::lambda_eta_neg {}

private

Definition at line 156 of file ZmumuValidationExample.h.

{};

lambda_eta_pos

TH1* ZmumuValidationExample::lambda_eta_pos {}

private

Definition at line 155 of file ZmumuValidationExample.h.

{};

lambda_etaphi

TH1* ZmumuValidationExample::lambda_etaphi {}

private

Definition at line 150 of file ZmumuValidationExample.h.

{};

lambda_etaphi_neg

TH1* ZmumuValidationExample::lambda_etaphi_neg {}

private

Definition at line 152 of file ZmumuValidationExample.h.

{};

lambda_etaphi_pos

TH1* ZmumuValidationExample::lambda_etaphi_pos {}

private

Definition at line 151 of file ZmumuValidationExample.h.

{};

lambda_neg

TH1* ZmumuValidationExample::lambda_neg {}

private

Definition at line 148 of file ZmumuValidationExample.h.

{};

lambda_pos

TH1* ZmumuValidationExample::lambda_pos {}

private

Definition at line 147 of file ZmumuValidationExample.h.

{};

lambda_truth

TH1* ZmumuValidationExample::lambda_truth {}

private

Definition at line 206 of file ZmumuValidationExample.h.

{};

lambda_truth_neg

TH1* ZmumuValidationExample::lambda_truth_neg {}

private

Definition at line 208 of file ZmumuValidationExample.h.

{};

lambda_truth_pos

TH1* ZmumuValidationExample::lambda_truth_pos {}

private

Definition at line 207 of file ZmumuValidationExample.h.

{};

lambda_vs_eta

TH2* ZmumuValidationExample::lambda_vs_eta {}

private

Definition at line 140 of file ZmumuValidationExample.h.

{};   

lambda_vs_eta_neg

TH2* ZmumuValidationExample::lambda_vs_eta_neg {}

private

Definition at line 142 of file ZmumuValidationExample.h.

{};

lambda_vs_eta_pos

TH2* ZmumuValidationExample::lambda_vs_eta_pos {}

private

Definition at line 141 of file ZmumuValidationExample.h.

{};

lambda_vs_eta_truth

TH2* ZmumuValidationExample::lambda_vs_eta_truth {}

private

Definition at line 197 of file ZmumuValidationExample.h.

{};       

lambda_vs_etaphi

TH3* ZmumuValidationExample::lambda_vs_etaphi {}

private

Definition at line 134 of file ZmumuValidationExample.h.

{};         

lambda_vs_etaphi_truth

TH3* ZmumuValidationExample::lambda_vs_etaphi_truth {}

private

Definition at line 193 of file ZmumuValidationExample.h.

{};    

lambdacorrected_mass

TH1* ZmumuValidationExample::lambdacorrected_mass {}

private

Definition at line 116 of file ZmumuValidationExample.h.

{};

lambdacorrected_mass_vs_etaphi

TH3* ZmumuValidationExample::lambdacorrected_mass_vs_etaphi {}

private

Definition at line 119 of file ZmumuValidationExample.h.

{};

lambdacorrections_vs_eta

TH1* ZmumuValidationExample::lambdacorrections_vs_eta {}

private

Definition at line 144 of file ZmumuValidationExample.h.

{};

lambdacorrections_vs_eta_truth

TH1* ZmumuValidationExample::lambdacorrections_vs_eta_truth {}

private

Definition at line 198 of file ZmumuValidationExample.h.

{};

lambdacorrections_vs_etaphi

TH2* ZmumuValidationExample::lambdacorrections_vs_etaphi {}

private

Definition at line 136 of file ZmumuValidationExample.h.

{};

lambdacorrections_vs_etaphi_err

TH2* ZmumuValidationExample::lambdacorrections_vs_etaphi_err {}

private

Definition at line 137 of file ZmumuValidationExample.h.

{};

lambdacorrections_vs_etaphi_RMS

TH2* ZmumuValidationExample::lambdacorrections_vs_etaphi_RMS {}

private

Definition at line 138 of file ZmumuValidationExample.h.

{};

lambdacorrections_vs_etaphi_truth

TH2* ZmumuValidationExample::lambdacorrections_vs_etaphi_truth {}

private

Definition at line 194 of file ZmumuValidationExample.h.

{};

lambdacorrections_vs_etaphi_truth_err

TH2* ZmumuValidationExample::lambdacorrections_vs_etaphi_truth_err {}

private

Definition at line 195 of file ZmumuValidationExample.h.

{};

m_d0_neg

double ZmumuValidationExample::m_d0_neg {}

private

Definition at line 59 of file ZmumuValidationExample.h.

{};

m_d0_pos

double ZmumuValidationExample::m_d0_pos {}

private

Definition at line 58 of file ZmumuValidationExample.h.

{};

m_EtaBins

int ZmumuValidationExample::m_EtaBins {}

private

Definition at line 36 of file ZmumuValidationExample.h.

{};

m_eventChain

TChain ZmumuValidationExample::m_eventChain

private

Definition at line 31 of file ZmumuValidationExample.h.

m_eventCurrent

int ZmumuValidationExample::m_eventCurrent {}

private

Definition at line 34 of file ZmumuValidationExample.h.

{};

m_factor

double ZmumuValidationExample::m_factor {}

private

Definition at line 43 of file ZmumuValidationExample.h.

{};

m_file

TFile ZmumuValidationExample::m_file

private

Definition at line 29 of file ZmumuValidationExample.h.

m_fileNames

const std::list<std::string> ZmumuValidationExample::m_fileNames

private

Definition at line 26 of file ZmumuValidationExample.h.

m_isMC

bool ZmumuValidationExample::m_isMC {}

private

Definition at line 40 of file ZmumuValidationExample.h.

{};

m_outfilename

std::string ZmumuValidationExample::m_outfilename

private

Definition at line 27 of file ZmumuValidationExample.h.

m_PhiBins

int ZmumuValidationExample::m_PhiBins {}

private

Definition at line 37 of file ZmumuValidationExample.h.

{};

m_PrintLevel

int ZmumuValidationExample::m_PrintLevel {}

private

Definition at line 35 of file ZmumuValidationExample.h.

{};

m_px_neg

double ZmumuValidationExample::m_px_neg {}

private

Definition at line 52 of file ZmumuValidationExample.h.

{};

m_px_pos

double ZmumuValidationExample::m_px_pos {}

private

Definition at line 48 of file ZmumuValidationExample.h.

{};

m_py_neg

double ZmumuValidationExample::m_py_neg {}

private

Definition at line 53 of file ZmumuValidationExample.h.

{};

m_py_pos

double ZmumuValidationExample::m_py_pos {}

private

Definition at line 49 of file ZmumuValidationExample.h.

{};

m_pz_neg

double ZmumuValidationExample::m_pz_neg {}

private

Definition at line 54 of file ZmumuValidationExample.h.

{};

m_pz_pos

double ZmumuValidationExample::m_pz_pos {}

private

Definition at line 50 of file ZmumuValidationExample.h.

{};

m_shift

double ZmumuValidationExample::m_shift {}

private

Definition at line 42 of file ZmumuValidationExample.h.

{};

m_truth_px_neg

double ZmumuValidationExample::m_truth_px_neg {}

private

Definition at line 65 of file ZmumuValidationExample.h.

{};

m_truth_px_pos

double ZmumuValidationExample::m_truth_px_pos {}

private

Definition at line 61 of file ZmumuValidationExample.h.

{};

m_truth_py_neg

double ZmumuValidationExample::m_truth_py_neg {}

private

Definition at line 66 of file ZmumuValidationExample.h.

{};

m_truth_py_pos

double ZmumuValidationExample::m_truth_py_pos {}

private

Definition at line 62 of file ZmumuValidationExample.h.

{};   

m_truth_pz_neg

double ZmumuValidationExample::m_truth_pz_neg {}

private

Definition at line 67 of file ZmumuValidationExample.h.

{};

m_truth_pz_pos

double ZmumuValidationExample::m_truth_pz_pos {}

private

Definition at line 63 of file ZmumuValidationExample.h.

{};

m_truthChain

TChain ZmumuValidationExample::m_truthChain

private

Definition at line 32 of file ZmumuValidationExample.h.

m_z0_neg

double ZmumuValidationExample::m_z0_neg {}

private

Definition at line 57 of file ZmumuValidationExample.h.

{};

m_z0_pos

double ZmumuValidationExample::m_z0_pos {}

private

Definition at line 56 of file ZmumuValidationExample.h.

{};

n_iteration

int ZmumuValidationExample::n_iteration {}

private

Definition at line 41 of file ZmumuValidationExample.h.

{};         

pcorrected_mass

TH1* ZmumuValidationExample::pcorrected_mass {}

private

Definition at line 115 of file ZmumuValidationExample.h.

{}; 

pcorrected_mass_vs_etaphi

TH3* ZmumuValidationExample::pcorrected_mass_vs_etaphi {}

private

Definition at line 118 of file ZmumuValidationExample.h.

{}; 

prof_pt_vs_etaphi

TProfile2D* ZmumuValidationExample::prof_pt_vs_etaphi {}

private

Definition at line 124 of file ZmumuValidationExample.h.

{};

TempCanvasIterGaussFit

TCanvas* ZmumuValidationExample::TempCanvasIterGaussFit {}

private

Definition at line 227 of file ZmumuValidationExample.h.

{};

truth_mass_bias_vs_eta

TH2* ZmumuValidationExample::truth_mass_bias_vs_eta {}

private

Definition at line 203 of file ZmumuValidationExample.h.

{};

truth_mass_biascorrections_vs_eta

TH1* ZmumuValidationExample::truth_mass_biascorrections_vs_eta {}

private

Definition at line 204 of file ZmumuValidationExample.h.

{};

truth_mom_bias_vs_eta

TH2* ZmumuValidationExample::truth_mom_bias_vs_eta {}

private

Definition at line 200 of file ZmumuValidationExample.h.

{};       

truth_mom_biascorrections_vs_eta

TH1* ZmumuValidationExample::truth_mom_biascorrections_vs_eta {}

private

Definition at line 201 of file ZmumuValidationExample.h.

{};

z0delta

TH1* ZmumuValidationExample::z0delta {}

private

Definition at line 166 of file ZmumuValidationExample.h.

{};

z0delta_etaphi

TH1* ZmumuValidationExample::z0delta_etaphi {}

private

Definition at line 170 of file ZmumuValidationExample.h.

{};

z0delta_etaphi_neg

TH1* ZmumuValidationExample::z0delta_etaphi_neg {}

private

Definition at line 172 of file ZmumuValidationExample.h.

{};

z0delta_etaphi_pos

TH1* ZmumuValidationExample::z0delta_etaphi_pos {}

private

Definition at line 171 of file ZmumuValidationExample.h.

{};

z0delta_neg

TH1* ZmumuValidationExample::z0delta_neg {}

private

Definition at line 168 of file ZmumuValidationExample.h.

{};

z0delta_pos

TH1* ZmumuValidationExample::z0delta_pos {}

private

Definition at line 167 of file ZmumuValidationExample.h.

{};

z0delta_vs_etaphi

TH3* ZmumuValidationExample::z0delta_vs_etaphi {}

private

Definition at line 161 of file ZmumuValidationExample.h.

{};         

z0deltacorrections_vs_etaphi

TH2* ZmumuValidationExample::z0deltacorrections_vs_etaphi {}

private

Definition at line 163 of file ZmumuValidationExample.h.

{};

z0deltacorrections_vs_etaphi_err

TH2* ZmumuValidationExample::z0deltacorrections_vs_etaphi_err {}

private

Definition at line 164 of file ZmumuValidationExample.h.

{};

---

The documentation for this class was generated from the following files:

• ZmumuValidationExample.h
• ZmumuValidationExample.cxx