#include <PixelChargeInterpolationValidation.h>

Collaboration diagram for PixelCalib::PixelChargeInterpolationValidation:

Public Member Functions
	PixelChargeInterpolationValidation (const std::string &tag, const PixelChargeInterpolationParameters &model)

virtual	~PixelChargeInterpolationValidation ()

void	Fill (int Layer, double GeVTrkPt, double Phi, double CSphi, double MicronDigResPhi, double MicronResPhi, double MicronErrPhi, double PullPhi, double Eta, double CSeta, double MicronDigResEta, double MicronResEta, double MicronErrEta, double PullEta, double Charge)

void	Analyze (TDirectory *ref_file=0)

int	Write (TDirectory *file=0)

int	Read (TDirectory *file=0)

void	WriteErrorsFile (const std::string &name)

Private Types
enum	Indexes { LayerIndex = 0, AngleIndex = 1, ClustersizeIndex = 2 }

Private Member Functions
	PixelChargeInterpolationValidation (const PixelChargeInterpolationValidation &)

PixelChargeInterpolationValidation &	operator= (const PixelChargeInterpolationValidation &)

Private Attributes
PixelResidualHistograms *	m_eta

PixelResidualHistograms *	m_phi

PixelResidualHistograms *	m_etaDig

PixelResidualHistograms *	m_phiDig

PixelResidualHistograms *	m_etaPull

PixelResidualHistograms *	m_phiPull

PixelResidualHistograms *	m_etaErr

PixelResidualHistograms *	m_phiErr

PixelResidualHistograms *	m_eta_phi

PixelResidualHistograms *	m_phi_eta

PixelResidualHistograms *	m_etaDig_phi

PixelResidualHistograms *	m_phiDig_eta

PixelResidualHistograms *	m_etaPull_phi

PixelResidualHistograms *	m_phiPull_eta

PixelResidualHistograms *	m_etaErr_phi

PixelResidualHistograms *	m_phiErr_eta

PixelResidualHistograms *	m_charge_eta

PixelResidualHistograms *	m_charge_phi

std::vector< PixelResidualHistograms * >	m_eta_Layer

std::vector< PixelResidualHistograms * >	m_phi_Layer

std::vector< PixelResidualHistograms * >	m_etaDig_Layer

std::vector< PixelResidualHistograms * >	m_phiDig_Layer

std::vector< PixelResidualHistograms * >	m_etaPull_Layer

std::vector< PixelResidualHistograms * >	m_phiPull_Layer

std::vector< PixelResidualHistograms * >	m_phi_Clustersize

std::vector< PixelResidualHistograms * >	m_eta_Clustersize

std::vector< PixelResidualHistograms * >	m_phiDig_Clustersize

std::vector< PixelResidualHistograms * >	m_etaDig_Clustersize

std::vector< PixelResidualHistograms * >	m_phiErr_Clustersize

std::vector< PixelResidualHistograms * >	m_etaErr_Clustersize

std::vector< PixelResidualHistograms * >	m_phiPull_Clustersize

std::vector< PixelResidualHistograms * >	m_etaPull_Clustersize

std::vector< TH1F * >	m_etaClustersize

std::vector< TH1F * >	m_phiClustersize

TH2F *	m_eta_phi_correlation

TH2F *	m_CSeta_CSphi_correlation

TH2F *	m_ResEtaDig_vs_p

TH2F *	m_ResPhiDig_vs_p

std::string	m_name

Detailed Description

Definition at line 20 of file PixelChargeInterpolationValidation.h.

Member Enumeration Documentation

◆ Indexes

enum PixelCalib::PixelChargeInterpolationValidation::Indexes

private

Enumerator
LayerIndex
AngleIndex
ClustersizeIndex

Definition at line 92 of file PixelChargeInterpolationValidation.h.

                  {
         LayerIndex = 0,
         AngleIndex = 1,
         ClustersizeIndex = 2
     };

Constructor & Destructor Documentation

◆ PixelChargeInterpolationValidation() [1/2]

PixelCalib::PixelChargeInterpolationValidation::PixelChargeInterpolationValidation	(	const std::string &	tag,
		const PixelChargeInterpolationParameters &	model
	)

Definition at line 30 of file PixelChargeInterpolationValidation.cxx.

                                                                     :
     m_eta(0), 
     m_phi(0), 
     m_etaDig(0), 
     m_phiDig(0), 
     m_etaPull(0), 
     m_phiPull(0),
     m_etaErr(0), 
     m_phiErr(0),
     m_eta_phi(0), 
     m_phi_eta(0), 
     m_etaDig_phi(0), 
     m_phiDig_eta(0), 
     m_etaPull_phi(0), 
     m_phiPull_eta(0),
     m_etaErr_phi(0), 
     m_phiErr_eta(0), 
     m_charge_eta(0), 
     m_charge_phi(0), 
     m_name(tag){
  
     std::vector<float> *layers = getLayersBins();
     std::vector<float> clustersizeEta = model.getClusterSizeYBins();
     clustersizeEta.insert(clustersizeEta.begin(),0.5);
     clustersizeEta.push_back(100);
     std::vector<float> clustersizePhi = model.getClusterSizeXBins();
     clustersizePhi.insert(clustersizePhi.begin(),0.5);
     clustersizePhi.push_back(100);
  
     std::vector<float> phibins_Layer;
     for(int i  = -60; i <= 60; i+=2) phibins_Layer.push_back(i);
     std::vector<float> etabins_Layer;
     for(float i  = -2.5; i <= 2.5; i+=0.125) etabins_Layer.push_back(i);
     std::vector<float> ptbins_Layer;
     int ntot = 9;
     double start = 0.1;
     double end = 10E3;
     ptbins_Layer.reserve(ntot+1);
 for(int i  = 0; i < ntot+1; i++){
         ptbins_Layer.push_back( start * pow( end/start, double(i)/double(ntot) ) );
     }
  
  
  
     std::vector<std::string> binsnames(3);
     std::vector<std::vector <float> > binsvectors(3);
  
     binsnames[LayerIndex] = "Layer";
     binsnames[AngleIndex] = "#eta_{i}";
     binsnames[ClustersizeIndex] = "ClusterSize";
     
     binsvectors[LayerIndex] = *layers;
     binsvectors[AngleIndex] = etabins_Layer;
     binsvectors[ClustersizeIndex] = std::move(clustersizeEta);
  
     m_eta = new PixelResidualHistograms(std::string("ResEta"),
             std::string("Local y residuals - Analog position"),
             500,100,binsvectors,binsnames);
  
     m_etaDig = new PixelResidualHistograms(std::string("ResEtaDig"),
             std::string("Local y residuals - Center position"),
             500,100,binsvectors,binsnames);
         
     m_etaPull = new PixelResidualHistograms(std::string("PullEta"),
             std::string("Local y pulls - Analog position"),
             10.,100,binsvectors,binsnames);
     
     m_etaErr = new PixelResidualHistograms(std::string("ErrEta"),
             std::string("Local y errors - Cluster uncertainty"),
             1000,250,binsvectors,binsnames);    
             
     m_phi_eta = new PixelResidualHistograms(std::string("ResPhiEta"),
             std::string("Local x residuals - Analog position"),
             150, 100, binsvectors,binsnames);
  
     m_phiDig_eta = new PixelResidualHistograms(std::string("ResPhiDigEta"),
             std::string("Local x residuals - Center position"),
             150, 100, binsvectors,binsnames);
         
     m_phiPull_eta = new PixelResidualHistograms(std::string("PullPhiEta"),
             std::string("Local x pulls - Analog position"),
             10.,100,binsvectors,binsnames);
     
     m_phiErr_eta = new PixelResidualHistograms(std::string("ErrPhiEta"),
             std::string("Local x errors - Cluster uncertainty"),
             100,100,binsvectors,binsnames);
             
     m_charge_eta     = new PixelResidualHistograms(std::string("ChargeEta"),
             std::string("Charge"),
           600000,600,binsvectors,binsnames);
     
     binsnames[AngleIndex] = "#phi_{i} [#circ]";
  
     binsvectors[AngleIndex] = phibins_Layer;
     binsvectors[ClustersizeIndex] = std::move(clustersizePhi);
  
     m_phi = new PixelResidualHistograms(std::string("ResPhi"),
             std::string("Local x residuals - Analog position"),
             150, 100, binsvectors,binsnames);
  
     m_phiDig = new PixelResidualHistograms(std::string("ResPhiDig"),
             std::string("Local x residuals - Center position"),
             150, 100, binsvectors,binsnames);
         
     m_phiPull = new PixelResidualHistograms(std::string("PullPhi"),
             std::string("Local x pulls - Analog position"),
             10.,100,binsvectors,binsnames);
     
     m_phiErr = new PixelResidualHistograms(std::string("ErrPhi"),
             std::string("Local x errors - Cluster uncertainty"),
             100,100,binsvectors,binsnames);
             
     m_eta_phi = new PixelResidualHistograms(std::string("ResEtaPhi"),
             std::string("Local y residuals - Analog position"),
             500,100,binsvectors,binsnames);
  
     m_etaDig_phi = new PixelResidualHistograms(std::string("ResEtaDigPhi"),
             std::string("Local y residuals - Center position"),
             500,100,binsvectors,binsnames);
         
     m_etaPull_phi = new PixelResidualHistograms(std::string("PullEtaPhi"),
             std::string("Local y pulls - Analog position"),
             10.,100,binsvectors,binsnames);
     
     m_etaErr_phi = new PixelResidualHistograms(std::string("ErrEtaPhi"),
             std::string("Local y errors - Cluster uncertainty"),
             1000,250,binsvectors,binsnames);
             
     m_charge_phi = new PixelResidualHistograms(std::string("ChargePhi"),
             std::string("Charge"),
           600000,600,binsvectors,binsnames);
     
     std::vector<std::string> binsnames_Layer(2);
     std::vector<std::vector <float> > binsvectors_Layer(2);
     
     binsnames_Layer[0] = "p_{T} [GeV]";
     binsnames_Layer[1] = "#eta_{i}";
     
     binsvectors_Layer[0] = std::move(ptbins_Layer);
     binsvectors_Layer[1] = etabins_Layer;
  
     for(int i = 0 ; i < NLAYERS; i++){
         
         std::cout << "layers " << NLAYERS << " " << i << std::endl;
     
         std::ostringstream name;
         std::ostringstream title;       
         name << "ResEta_Layer" << i;
         title << "Local y resolution - Layer " << i ;
         m_eta_Layer.push_back(
                 new PixelResidualHistograms(name.str(),
                  ( title.str() + " - Analog position").c_str(),
                 500, 100, binsvectors_Layer, binsnames_Layer)
                 );
         m_etaDig_Layer.push_back(
                 new PixelResidualHistograms( (name.str() + "Dig").c_str(),
                  ( title.str() + " - Center position").c_str(),
                 500, 100, binsvectors_Layer, binsnames_Layer)
                 );
         m_etaPull_Layer.push_back(
                 new PixelResidualHistograms( (name.str() + "Pull").c_str(),
                 ( title.str() + " - Pulls").c_str(),
                 10., 100, binsvectors_Layer, binsnames_Layer)
                 );
     }
  
     
     binsnames_Layer[1] = "#phi_{i} [#circ]";
     binsvectors_Layer[1] = phibins_Layer;
  
     for(int i = 0 ; i < NLAYERS; i++){
         std::ostringstream name;
         std::ostringstream title;       
         name << "ResPhi_Layer" << i;
         title << "Local x resolution - Layer " << i ;
         m_phi_Layer.push_back(
                 new PixelResidualHistograms(name.str(),
                  ( title.str() + " - Analog position").c_str(),
                 150, 100, binsvectors_Layer, binsnames_Layer)
                 );
         m_phiDig_Layer.push_back(
                 new PixelResidualHistograms( (name.str() + "Dig").c_str(),
                  ( title.str() + " - Center position").c_str(),
                 150, 100, binsvectors_Layer, binsnames_Layer)
                 );
         m_phiPull_Layer.push_back(
                 new PixelResidualHistograms( (name.str() + "Pull").c_str(),
                 ( title.str() + " - Pulls").c_str(),
                 10., 100, binsvectors_Layer, binsnames_Layer)
                 );
     }
  
     std::vector<std::string> binsnames_Clustersize(1);
     std::vector<std::vector <float> > binsvectors_Clustersize(1);
  
     binsnames_Clustersize[0] = "#eta_{i}";
     binsvectors_Clustersize[0] = etabins_Layer;
  
     for(int i = 0 ; i < NCLUSSIZES; i++){
         std::ostringstream name;
         std::ostringstream title;       
         name << "ResEta_Clustersize" << i+1;
         title << "Local y resolution - Clustersize " << i+1;
         m_eta_Clustersize.push_back(
                 new PixelResidualHistograms(name.str(),
                  ( title.str() + " - Analog position").c_str(),
                 400, 100, binsvectors_Clustersize, binsnames_Clustersize)
                 );
         m_etaDig_Clustersize.push_back(
                 new PixelResidualHistograms( (name.str() + "Dig").c_str(),
                  ( title.str() + " - Center position").c_str(),
                 400, 100, binsvectors_Clustersize, binsnames_Clustersize)
                 );
         m_etaErr_Clustersize.push_back(
                 new PixelResidualHistograms( (name.str() + "Err").c_str(),
                  ( title.str() + " - Cluster uncertainty").c_str(),
                 1000, 250, binsvectors_Clustersize, binsnames_Clustersize)
                 );
         m_etaPull_Clustersize.push_back(
                 new PixelResidualHistograms( (name.str() + "Pull").c_str(),
                  ( title.str() + " - Pull").c_str(),
                 10., 100., binsvectors_Clustersize, binsnames_Clustersize)
                 );
         std::ostringstream namecs;
         std::ostringstream titlecs;     
         namecs << "Eta_Clustersize" << i+1;
         titlecs << "#eta_{i} distribution - Clustersize " << i+1 ;
         m_etaClustersize.push_back(
                 new TH1F(namecs.str().c_str(), titlecs.str().c_str(),
                     etabins_Layer.size(), etabins_Layer[0],
                     etabins_Layer[etabins_Layer.size()-1])
                     );
     }
  
  
     binsnames_Clustersize[0] = "#phi_{i} [#circ]";
     binsvectors_Clustersize[0] = std::move(phibins_Layer);
  
     for(int i = 0 ; i < NCLUSSIZES; i++){
         std::ostringstream name;
         std::ostringstream title;       
         name << "ResPhi_Clustersize" << i+1;
         title << "Local x resolution - Clustersize " << i+1;
         m_phi_Clustersize.push_back(
                 new PixelResidualHistograms(name.str(),
                  ( title.str() + " - Analog position").c_str(),
                 150, 100, binsvectors_Clustersize, binsnames_Clustersize)
                 );
         m_phiDig_Clustersize.push_back(
                 new PixelResidualHistograms( (name.str() + "Dig").c_str(),
                  ( title.str() + " - Center position").c_str(),
                 150, 100, binsvectors_Clustersize, binsnames_Clustersize)
                 );
         m_phiErr_Clustersize.push_back(
                 new PixelResidualHistograms( (name.str() + "Err").c_str(),
                  ( title.str() + " - Cluster uncertainty").c_str(),
                 100, 100, binsvectors_Clustersize, binsnames_Clustersize)
                 );
         m_phiPull_Clustersize.push_back(
                 new PixelResidualHistograms( (name.str() + "Pull").c_str(),
                  ( title.str() + " - Pull").c_str(),
                 10., 100., binsvectors_Clustersize, binsnames_Clustersize)
                 );
         std::ostringstream namecs;
         std::ostringstream titlecs;     
         namecs << "Phi_Clustersize" << i+1;
         titlecs << "#phi_{i} distribution - Clustersize " << i+1 ;
         m_phiClustersize.push_back(
                 new TH1F(namecs.str().c_str(), titlecs.str().c_str(),
                     400, -100,100)
                     );
     }
  
     m_eta_phi_correlation = new TH2F("eta_phi_correlation",
                 "#phi_{i} #eta_{i} correlation", 100, -100,100, 100, -2.5, 2.5);
  
     m_eta_phi_correlation->GetYaxis()->SetTitle("#eta_{i}");
     m_eta_phi_correlation->GetXaxis()->SetTitle("#phi_{i}");
  
     m_CSeta_CSphi_correlation = new TH2F("CSeta_CSphi_correlation",
                 "#Deltarow #Deltacolumn  correlation", 10, 0,10, 10, 0, 10);
  
     m_CSeta_CSphi_correlation->GetYaxis()->SetTitle("#eta_{i}");
     m_CSeta_CSphi_correlation->GetXaxis()->SetTitle("#phi_{i}");
  
  
     double ptbins_Layerpointer[101];
     int ntot2 = 100;
     double start2 = 0.1;
     double end2 = 10E3;
     for(int i  = 0; i < ntot2+1; i++){
         ptbins_Layerpointer[i] = start2 * pow( end2/start2, double(i)/double(ntot2) );
     }
     m_ResEtaDig_vs_p = new TH2F("ResEtaDig_vs_p",
                 "Local y residuals vs p_{T}",
             100, ptbins_Layerpointer, 100, -1000, 1000);
     m_ResPhiDig_vs_p = new TH2F("ResPhiDig_vs_p", "Local x residuals vs p_{T}",
                 100, ptbins_Layerpointer, 100, -400, 400);
  
  
     delete layers;
  
 }

◆ ~PixelChargeInterpolationValidation()

PixelCalib::PixelChargeInterpolationValidation::~PixelChargeInterpolationValidation ( )

virtual

Definition at line 337 of file PixelChargeInterpolationValidation.cxx.

                                                                        {
  
     delete m_phi;
     delete m_eta;
     delete m_phiDig;
     delete m_etaDig;
     delete m_phiPull; 
     delete m_etaPull; 
     delete m_phiErr;
     delete m_etaErr;
     delete m_phi_eta;
     delete m_eta_phi;
     delete m_phiDig_eta;
     delete m_etaDig_phi;
     delete m_phiPull_eta; 
     delete m_etaPull_phi; 
     delete m_phiErr_eta;
     delete m_etaErr_phi;
     delete m_charge_eta;
     delete m_charge_phi;
  
     m_phi = 0;
     m_eta = 0;
     m_phiDig = 0;
     m_etaDig = 0;
     m_phiPull = 0; 
     m_etaPull = 0; 
     m_phiErr = 0; 
     m_etaErr = 0;
     m_phi_eta = 0;
     m_eta_phi = 0;
     m_phiDig_eta = 0;
     m_etaDig_phi = 0;
     m_phiPull_eta = 0; 
     m_etaPull_phi = 0; 
     m_phiErr_eta = 0; 
     m_etaErr_phi = 0;   
     m_charge_eta = 0;
     m_charge_phi = 0;
  
     for(int i = 0 ; i < NLAYERS; i++){
         delete m_eta_Layer[i];
         delete m_etaDig_Layer[i];
         delete m_etaPull_Layer[i];
         delete m_phi_Layer[i];
         delete m_phiDig_Layer[i];
         delete m_phiPull_Layer[i];
         
         m_eta_Layer[i] = 0;
         m_etaDig_Layer[i] = 0;
         m_etaPull_Layer[i] = 0;
         m_phi_Layer[i] = 0;
         m_phiDig_Layer[i] = 0;
         m_phiPull_Layer[i] = 0;
     }
  
     for(int i = 0 ; i < NCLUSSIZES; i++){
         delete m_eta_Clustersize[i];
         delete m_etaDig_Clustersize[i];
         delete m_etaPull_Clustersize[i];
         delete m_etaErr_Clustersize[i];
         delete m_phi_Clustersize[i];
         delete m_phiDig_Clustersize[i];
         delete m_phiPull_Clustersize[i];
         delete m_phiErr_Clustersize[i];
         m_eta_Clustersize[i] = 0;
         m_etaDig_Clustersize[i] = 0;
         m_etaPull_Clustersize[i] = 0;
         m_etaErr_Clustersize[i] = 0;
         m_phi_Clustersize[i] = 0;
         m_phiDig_Clustersize[i] = 0;
         m_phiPull_Clustersize[i] = 0;
         m_phiErr_Clustersize[i] = 0;
         delete m_phiClustersize[i]; m_phiClustersize[i] = 0;
         delete m_etaClustersize[i]; m_etaClustersize[i] = 0;
     }
  
     delete m_eta_phi_correlation; m_eta_phi_correlation = 0;
     delete m_CSeta_CSphi_correlation; m_CSeta_CSphi_correlation = 0;
     delete m_ResEtaDig_vs_p; m_ResEtaDig_vs_p = 0;
     delete m_ResPhiDig_vs_p; m_ResPhiDig_vs_p = 0;
  
  
 }

◆ PixelChargeInterpolationValidation() [2/2]

PixelCalib::PixelChargeInterpolationValidation::PixelChargeInterpolationValidation ( const PixelChargeInterpolationValidation & )

private

Member Function Documentation

◆ Analyze()

void PixelCalib::PixelChargeInterpolationValidation::Analyze ( TDirectory * ref_file = 0 )

Definition at line 674 of file PixelChargeInterpolationValidation.cxx.

                                                                     {
  
     if(ref_file == 0) return;
  
     /*
     PixelResidualHistograms *eta_reference = 0;
     PixelResidualHistograms *phi_reference = 0;
     PixelResidualHistograms *eta_referencePerLayer = 0;
     PixelResidualHistograms *phi_referencePerLayer = 0;
     PixelResidualHistograms *eta_referencePerAngle = 0;
     PixelResidualHistograms *phi_referencePerAngle = 0;
     PixelResidualProfiles* phi_referenceProfileLayer = 0;
     PixelResidualProfiles* eta_referenceProfileLayer = 0;
     PixelResidualProfiles* phiPt_referenceProfileLayer = 0;
     PixelResidualProfiles* etaPt_referenceProfileLayer = 0;
     PixelResidualHistograms* phi_referencePerPt = 0;
     PixelResidualHistograms* eta_referencePerPt = 0;
     PixelResidualHistograms* phi_referencePerCs = 0;
     PixelResidualHistograms* eta_referencePerCs = 0;
     std::string ref_name = std::string("Reference ");
  
     if(ref_file != 0 ){
         eta_reference = m_etaVector->Clone();
         eta_reference->Read(ref_file);
         phi_reference = m_phiVector->Clone();
         phi_reference->Read(ref_file);
         eta_referencePerLayer = m_etaPerLayer->Clone();
         eta_referencePerLayer->Read(ref_file);
         phi_referencePerLayer = m_phiPerLayer->Clone();
         phi_referencePerLayer->Read(ref_file);
         eta_referencePerAngle = m_etaPerAngle->Clone();
         eta_referencePerAngle->Read(ref_file);
         phi_referencePerAngle = m_phiPerAngle->Clone();
         phi_referencePerAngle->Read(ref_file);
         phi_referenceProfileLayer = m_phivsAnglePerLayer->Clone();
         phi_referenceProfileLayer->Read(ref_file);
         eta_referenceProfileLayer = m_etavsAnglePerLayer->Clone();
         eta_referenceProfileLayer->Read(ref_file);
         phiPt_referenceProfileLayer = m_phivsPtPerLayer->Clone();
         phiPt_referenceProfileLayer->Read(ref_file);
         etaPt_referenceProfileLayer = m_etavsPtPerLayer->Clone();
         etaPt_referenceProfileLayer->Read(ref_file);
         phi_referencePerPt = m_phiPerPt->Clone();
         phi_referencePerPt->Read(ref_file);
         eta_referencePerPt = m_etaPerPt->Clone();
         eta_referencePerPt->Read(ref_file);
         phi_referencePerCs = m_phiPerCs->Clone();
         phi_referencePerCs->Read(ref_file);
         eta_referencePerCs = m_etaPerCs->Clone();
         eta_referencePerCs->Read(ref_file);
     }else{
         eta_reference = m_etaDigVector;
         phi_reference = m_phiDigVector;
         eta_referencePerLayer = m_etaDigPerLayer;
         phi_referencePerLayer = m_phiDigPerLayer;
         eta_referencePerAngle = m_etaDigPerAngle;
         phi_referencePerAngle = m_phiDigPerAngle;
         phi_referenceProfileLayer = m_phiDigvsAnglePerLayer;
         eta_referenceProfileLayer = m_etaDigvsAnglePerLayer;
         phiPt_referenceProfileLayer = m_phiDigvsPtPerLayer;
         etaPt_referenceProfileLayer = m_etaDigvsPtPerLayer;
         phi_referencePerPt = m_phiDigPerPt;
         eta_referencePerPt = m_phiDigPerPt;
         phi_referencePerCs = m_phiDigPerCs;
         eta_referencePerCs = m_etaDigPerCs;
         ref_name = std::string("Digital ");
     }
  
     m_etaVector->Analyze(eta_reference, ref_name);
     m_phiVector->Analyze(phi_reference, ref_name);
     m_etaPerLayer->Analyze(eta_referencePerLayer, ref_name);
     m_phiPerLayer->Analyze(phi_referencePerLayer, ref_name);
     m_etaPerAngle->Analyze(eta_referencePerAngle, ref_name);
     m_phiPerAngle->Analyze(phi_referencePerAngle, ref_name);
  
     //m_phivsAnglePerLayer->Analyze(phi_referenceProfileLayer, ref_name);
     //m_etavsAnglePerLayer->Analyze(eta_referenceProfileLayer, ref_name);
  
     //m_phivsPtPerLayer->Analyze(phiPt_referenceProfileLayer, ref_name,std::string("log"));
     //m_etavsPtPerLayer->Analyze(etaPt_referenceProfileLayer, ref_name,std::string("log"));
     m_phiPerPt->Analyze(phi_referencePerPt, ref_name);
     m_etaPerPt->Analyze(eta_referencePerPt, ref_name);
  
     m_phiPerCs->Analyze(phi_referencePerCs, ref_name);
     m_etaPerCs->Analyze(eta_referencePerCs, ref_name);
  
     if(ref_file != 0 ){ 
         delete eta_reference;
         delete phi_reference;
         delete eta_referencePerLayer;
         delete phi_referencePerLayer;
         delete eta_referencePerAngle;
         delete phi_referencePerAngle;
         delete phi_referenceProfileLayer;
         delete eta_referenceProfileLayer;
         delete phiPt_referenceProfileLayer;
         delete etaPt_referenceProfileLayer;
         delete phi_referencePerPt;
         delete eta_referencePerPt;
         delete phi_referencePerCs;
         delete eta_referencePerCs;
     }
  
     phi_reference = 0;
     eta_reference = 0;
     phi_referencePerLayer = 0;
     eta_referencePerLayer = 0;
     phi_referencePerAngle = 0;
     eta_referencePerAngle = 0;
     phi_referenceProfileLayer = 0;
     eta_referenceProfileLayer = 0;
     phiPt_referenceProfileLayer = 0;
     etaPt_referenceProfileLayer = 0;
     phi_referencePerPt = 0;
     eta_referencePerPt = 0;
     phi_referencePerCs = 0;
     eta_referencePerCs = 0;
     */
  
 }

◆ Fill()

void PixelCalib::PixelChargeInterpolationValidation::Fill	(	int	Layer,
		double	GeVTrkPt,
		double	Phi,
		double	CSphi,
		double	MicronDigResPhi,
		double	MicronResPhi,
		double	MicronErrPhi,
		double	PullPhi,
		double	Eta,
		double	CSeta,
		double	MicronDigResEta,
		double	MicronResEta,
		double	MicronErrEta,
		double	PullEta,
		double	Charge
	)

Definition at line 598 of file PixelChargeInterpolationValidation.cxx.

                                                                                                                   {
  
         std::vector< float >parameters(3);
     parameters[LayerIndex] = Layer;
     parameters[AngleIndex] = Eta;
     parameters[ClustersizeIndex] = CSeta;
     m_eta->Fill(float(ResEta),parameters);
     m_etaDig->Fill(float(digResEta),parameters);
     m_etaPull->Fill(float(PullEta),parameters);
     m_etaErr->Fill(float(ErrEta), parameters);
     m_phi_eta->Fill(float(ResPhi),parameters);
     m_phiDig_eta->Fill(float(digResPhi),parameters);
     m_phiPull_eta->Fill(float(PullPhi),parameters);
     m_phiErr_eta->Fill(float(ErrPhi), parameters);
     m_charge_eta->Fill(float(Charge), parameters);
  
     parameters[AngleIndex] = Phi;
     parameters[ClustersizeIndex] = CSphi;
     m_phi->Fill(float(ResPhi),parameters);
     m_phiDig->Fill(float(digResPhi),parameters);
     m_phiPull->Fill(float(PullPhi),parameters);
     m_phiErr->Fill(float(ErrPhi), parameters);
     m_eta_phi->Fill(float(ResEta),parameters);
     m_etaDig_phi->Fill(float(digResEta),parameters);
     m_etaPull_phi->Fill(float(PullEta),parameters);
     m_etaErr_phi->Fill(float(ErrEta), parameters);
     m_charge_phi->Fill(float(Charge), parameters);
  
     if( Layer < NLAYERS){ 
                 std::vector< float >parameters_Layer(2);
         if(GeVTrkPt < 10E10) parameters_Layer[0] = GeVTrkPt;
         else parameters_Layer[0] = 1.;
  
         parameters_Layer[1] = Eta;
         m_eta_Layer[Layer]->Fill(float(ResEta),parameters_Layer);
         m_etaDig_Layer[Layer]->Fill(float(digResEta),parameters_Layer);
         m_etaPull_Layer[Layer]->Fill(float(PullEta), parameters_Layer);
  
         parameters_Layer[1] = Phi;
         m_phi_Layer[Layer]->Fill(float(ResPhi),parameters_Layer);
         m_phiDig_Layer[Layer]->Fill(float(digResPhi),parameters_Layer);
         m_phiPull_Layer[Layer]->Fill(float(PullPhi), parameters_Layer);
     }
  
     std::vector< float >parameters_Clustersize(1);
  
     if( int(CSeta)-1 < NCLUSSIZES){ 
         parameters_Clustersize[0] = Eta;
         m_eta_Clustersize[int(CSeta)-1]->Fill(float(ResEta),parameters_Clustersize);
         m_etaDig_Clustersize[int(CSeta)-1]->Fill(float(digResEta),parameters_Clustersize);
         m_etaErr_Clustersize[int(CSeta)-1]->Fill(float(ErrEta),parameters_Clustersize);
         m_etaPull_Clustersize[int(CSeta)-1]->Fill(float(PullEta),parameters_Clustersize);
         m_etaClustersize[int(CSeta)-1]->Fill(Eta);
     }
     if( int(CSphi)-1 < NCLUSSIZES){
         parameters_Clustersize[0] = Phi;
         m_phi_Clustersize[int(CSphi)-1]->Fill(float(ResPhi),parameters_Clustersize);
         m_phiDig_Clustersize[int(CSphi)-1]->Fill(float(digResPhi),parameters_Clustersize);
         //std::cout << ErrPhi << " " << CSphi << " " << Phi << std::endl;
         m_phiErr_Clustersize[int(CSphi)-1]->Fill(float(ErrPhi),parameters_Clustersize);
         m_phiPull_Clustersize[int(CSphi)-1]->Fill(float(PullPhi),parameters_Clustersize);
         m_phiClustersize[int(CSphi)-1]->Fill(Phi);
     }
  
     m_eta_phi_correlation->Fill(Phi,Eta);
     m_CSeta_CSphi_correlation->Fill(Phi,Eta);
     m_ResEtaDig_vs_p->Fill(GeVTrkPt,digResEta);
     m_ResPhiDig_vs_p->Fill(GeVTrkPt,digResPhi);
     return;
  
 }

◆ operator=()

PixelChargeInterpolationValidation& PixelCalib::PixelChargeInterpolationValidation::operator= ( const PixelChargeInterpolationValidation & )

private

◆ Read()

int PixelCalib::PixelChargeInterpolationValidation::Read ( TDirectory * file = 0 )

Definition at line 425 of file PixelChargeInterpolationValidation.cxx.

                                                             {
  
  
     TDirectory *current = gDirectory;
     if(file !=0) file->cd();
     TDirectory *globaldir = (TDirectory *)gDirectory->Get("Validation");
     globaldir->cd();
     int readhistos = 0;
     readhistos += m_phi->Read();
     readhistos += m_eta->Read();
     readhistos += m_phiDig->Read();
     readhistos += m_etaDig->Read();
     readhistos += m_phiPull->Read(); 
     readhistos += m_etaPull->Read(); 
     readhistos += m_phiErr->Read(); 
     readhistos += m_etaErr->Read();
     readhistos += m_phi_eta->Read();
     readhistos += m_eta_phi->Read();
     readhistos += m_phiDig_eta->Read();
     readhistos += m_etaDig_phi->Read();
     readhistos += m_phiPull_eta->Read(); 
     readhistos += m_etaPull_phi->Read(); 
     readhistos += m_phiErr_eta->Read(); 
     readhistos += m_etaErr_phi->Read();
     readhistos += m_charge_eta->Read();
     readhistos += m_charge_phi->Read();
     for(int i = 0 ; i < NLAYERS; i++){
         m_eta_Layer[i]->Read();
         m_etaDig_Layer[i]->Read();
         m_etaPull_Layer[i]->Read();
         m_phi_Layer[i]->Read();
         m_phiDig_Layer[i]->Read();
         m_phiPull_Layer[i]->Read();
     }
     for(int i = 0 ; i < NCLUSSIZES; i++){
         m_eta_Clustersize[i]->Read();
         m_etaDig_Clustersize[i]->Read();
         m_etaErr_Clustersize[i]->Read();
         m_etaPull_Clustersize[i]->Read();
         m_phi_Clustersize[i]->Read();
         m_phiDig_Clustersize[i]->Read();
         m_phiErr_Clustersize[i]->Read();
         m_phiErr_Clustersize[i]->Read();
         //m_phiClustersize[i]->Read();
         //m_etaClustersize[i]->Read();
     }
     //m_eta_phi_correlation
     //m_CSeta_CSphi_correlation
  
     current->cd();
     return readhistos;
 }

◆ Write()

int PixelCalib::PixelChargeInterpolationValidation::Write ( TDirectory * file = 0 )

Definition at line 480 of file PixelChargeInterpolationValidation.cxx.

                                                                  {
  
     TDirectory *current = gDirectory;
     TDirectory *globaldir;
     if(writedir != 0) writedir->cd();
     globaldir = gDirectory->mkdir("Validation");
     globaldir->cd();
     int writtenhistos = 0;
     writtenhistos +=  m_phi->Write(true);
     writtenhistos +=  m_eta->Write(true);
     writtenhistos +=  m_phiDig->Write(true);
     writtenhistos +=  m_etaDig->Write(true);
     writtenhistos +=  m_phiPull->Write(true);
     writtenhistos +=  m_etaPull->Write(true);
     writtenhistos +=  m_phiErr->Write(true);
     writtenhistos +=  m_etaErr->Write(true);
     writtenhistos +=  m_phi_eta->Write(true);
     writtenhistos +=  m_eta_phi->Write(true);
     writtenhistos +=  m_phiDig_eta->Write(true);
     writtenhistos +=  m_etaDig_phi->Write(true);
     writtenhistos +=  m_phiPull_eta->Write(true);
     writtenhistos +=  m_etaPull_phi->Write(true);
     writtenhistos +=  m_phiErr_eta->Write(true);
     writtenhistos +=  m_etaErr_phi->Write(true);
     writtenhistos +=  m_charge_eta->Write(true);
     writtenhistos +=  m_charge_phi->Write(true);
  
     for(int i = 0 ; i < NLAYERS; i++){
         m_eta_Layer[i]->Write(true);
         m_etaDig_Layer[i]->Write(true);
         m_etaPull_Layer[i]->Write(true);
         m_phi_Layer[i]->Write(true);
         m_phiDig_Layer[i]->Write(true);
         m_phiPull_Layer[i]->Write(true);
     }
     for(int i = 0 ; i < NCLUSSIZES; i++){
         m_eta_Clustersize[i]->Write(true);
         m_etaDig_Clustersize[i]->Write(true);
         m_etaErr_Clustersize[i]->Write(true);
         m_etaPull_Clustersize[i]->Write(true);
         m_phi_Clustersize[i]->Write(true);
         m_phiDig_Clustersize[i]->Write(true);
         m_phiErr_Clustersize[i]->Write(true);
         m_phiPull_Clustersize[i]->Write(true);
         m_phiClustersize[i]->Write();
         m_etaClustersize[i]->Write();
     }
  
     m_eta_phi_correlation->Write();
     m_CSeta_CSphi_correlation->Write();
     m_ResEtaDig_vs_p->Write();
     m_ResPhiDig_vs_p->Write();
  
     current->cd();
     return writtenhistos;   
 }

◆ WriteErrorsFile()

void PixelCalib::PixelChargeInterpolationValidation::WriteErrorsFile ( const std::string & name )

Definition at line 539 of file PixelChargeInterpolationValidation.cxx.

                                                                              {
  
     // Let's write resolutions into text file (see:
     // void PixelClusterOnTrackErrorData::Print(std::string file) const
     PixelClusterOnTrackErrorData *parameters = new PixelClusterOnTrackErrorData();
  
     TProfile *etaModel = m_eta_Clustersize[0]->GetRMSProfile("#eta_{i}");
     TProfile *phiModel = m_phi_Clustersize[0]->GetRMSProfile("#phi_{i} [#circ]");
     //int ncsx = m_phi_Clustersize.size();
     //int ncsy = m_eta_Clustersize.size(); // number of cluster size (x-direction) bins
     int ncsx = 4;
     int ncsy = 4;
     int neta = etaModel->GetNbinsX(); // number of eta values bins
     int nalpha = phiModel->GetNbinsX(); // number of incidence angle bins
     int ntotbins = ncsx + ncsy + neta + nalpha;
  
   std::vector<float> values;
   values.reserve(ntotbins);
     int globalindex = 0;
   for (int i=0; i<ncsx && globalindex<ntotbins; i++, globalindex++) {
     values.push_back(i+0.5);
   }
     for (int i=0; i<ncsy && globalindex<ntotbins; i++, globalindex++) {
         values.push_back(i+0.5);
   }
     values.push_back(-2.5);
     for (int i=1; i<neta && globalindex<ntotbins; i++, globalindex++) {
         values.push_back(etaModel->GetBinLowEdge(i+1));
   }
     values.push_back(-180);
     for (int i=1; i<nalpha && globalindex<ntotbins; i++, globalindex++) {
         values.push_back(phiModel->GetBinLowEdge(i+1));
   }
     parameters->setParameters(ncsx, ncsy, neta, nalpha,0,std::move(values));    
  
     int ntotyconstnx = ncsx * nalpha;
     globalindex = 0;
     for(int i = 0; i < nalpha && globalindex < ntotyconstnx; i++)
         for(int j = 0; j < ncsx && globalindex < ntotyconstnx; j++, globalindex++){
             double value = m_phi_Clustersize[j]->GetRMSProfile("#phi_{i} [#circ]")->GetBinContent(i+1)/1000;
             if (value == 0) value = (j+1)*50/sqrt(12)/1000;
             parameters->setPixelBarrelPhiError(globalindex,value);
         }
     int ntotyconstny = ncsx * ncsy * neta;
     globalindex = 0;
     for(int i = 0; i < neta && globalindex < ntotyconstny; i++)
         for(int j = 0; j < ncsx && globalindex < ntotyconstny; j++)
             for(int k = 0; k < ncsy  && globalindex < ntotyconstny; k++, globalindex++){
                 double value = m_eta_Clustersize[k]->GetRMSProfile("#eta_{i}")->GetBinContent(i+1)/1000;
                 if (value == 0) value = (k+1)*400/sqrt(12)/1000;
                 parameters->setPixelBarrelEtaError(globalindex,value);
             }
     parameters->Print(name);
  
         delete parameters;
 }