PixelCalib::PixelResidualHistograms Class Reference

#include <PixelResidualHistograms.h>

Collaboration diagram for PixelCalib::PixelResidualHistograms:

Public Member Functions
	PixelResidualHistograms (const std::string &name, const std::string &title, double limits, int nbins, const std::vector< std::vector< float > > &binnage, const std::vector< std::string > &binnames)
virtual	~PixelResidualHistograms ()
void	SetAxisTitle (const std::string &title)
void	Fill (float residual, const std::vector< float > &parameters)
int	Write (bool writebins=false)
int	Read ()
TH1D *	GetHisto (const int i)
TProfile *	GetMeanProfile (const std::string &binname)
TProfile *	GetRMSProfile (const std::string &binname)
TProfile *	GetProfile (const int binnumber, bool RMS=false, bool savebins=false)
TH1D *	GetGlobalHisto ()
std::vector< TCanvas * > *	DrawProfiles (int color, int marker, float labely=0, std::vector< TCanvas * > *canvasvector=0, const std::string &name="")

Private Member Functions
	PixelResidualHistograms (const PixelResidualHistograms &)
PixelResidualHistograms &	operator= (const PixelResidualHistograms &)
	PixelResidualHistograms ()

Private Attributes
MultiHisto< TH1D > *	m_HistogramsVector
std::vector< TProfile * > *	m_MeanProfilesVector
std::vector< TProfile * > *	m_RMSProfilesVector
TH1D *	m_GlobalHisto
std::vector< std::string >	m_binnames
std::vector< std::vector< float > >	m_binnage
std::string	m_axisName

Detailed Description

Definition at line 21 of file PixelResidualHistograms.h.

Constructor & Destructor Documentation

PixelResidualHistograms() [1/3]

PixelCalib::PixelResidualHistograms::PixelResidualHistograms	(	const std::string &	name,
		const std::string &	title,
		double	limits,
		int	nbins,
		const std::vector< std::vector< float > > &	binnage,
		const std::vector< std::string > &	binnames
	)

Definition at line 25 of file PixelResidualHistograms.cxx.

                                                              :
    m_HistogramsVector(0),
    m_MeanProfilesVector(0),
    m_RMSProfilesVector(0),
    m_GlobalHisto(0),
    m_binnames(binnames),
    m_binnage(binnage),
    m_axisName(""){
 
    TH1D *Histomodel = new TH1D(name.c_str(),title.c_str(),nbins,-limits,limits);
    m_HistogramsVector =  new MultiHisto<TH1D>(*Histomodel,m_binnames,m_binnage);
 
    SetAxisTitle(title);
 
    m_MeanProfilesVector = new std::vector<TProfile*>(m_binnames.size());
    m_RMSProfilesVector = new std::vector<TProfile*>(m_binnames.size());
 
    delete Histomodel;
    Histomodel = 0;
 
}

~PixelResidualHistograms()

PixelCalib::PixelResidualHistograms::~PixelResidualHistograms ( )

virtual

Definition at line 54 of file PixelResidualHistograms.cxx.

                                                 {
 
    delete m_HistogramsVector;
    delete m_MeanProfilesVector;
    delete m_RMSProfilesVector;
 
    m_HistogramsVector = 0;
    m_MeanProfilesVector = 0;
    m_RMSProfilesVector = 0;
 
}

PixelResidualHistograms() [2/3]

PixelCalib::PixelResidualHistograms::PixelResidualHistograms ( const PixelResidualHistograms &  )

private

PixelResidualHistograms() [3/3]

PixelCalib::PixelResidualHistograms::PixelResidualHistograms ( )

inlineprivate

Definition at line 88 of file PixelResidualHistograms.h.

{};

Member Function Documentation

DrawProfiles()

std::vector< TCanvas * > * PixelCalib::PixelResidualHistograms::DrawProfiles	(	int	color,
		int	marker,
		float	labely = 0,
		std::vector< TCanvas * > *	canvasvector = 0,
		const std::string &	name = ""
	)

Definition at line 284 of file PixelResidualHistograms.cxx.

                                                                   {
 
    SetAtlasStyle();    
    std::string drawoptions = "Psame";
    std::string legend = name;
    if(canvasvector == 0){
        drawoptions = "P";
        canvasvector = new std::vector<TCanvas*>();
        for(unsigned int i = 0; i < 2 * m_MeanProfilesVector->size(); i++){
            TCanvas *c1 = new TCanvas();
            c1->UseCurrentStyle();
            canvasvector->push_back(c1);
        }
    }else if( canvasvector->size() != 2 * m_MeanProfilesVector->size() ) return 0;
 
 
    TProfile *swap = 0;
    for(unsigned int i = 0; i < m_MeanProfilesVector->size(); i++){
        // mean profile!
        (*canvasvector)[i]->cd();
        swap = GetProfile(i,false);
        swap->UseCurrentStyle();
        swap->SetLineColor(color);
        swap->SetMarkerColor(color);
        swap->SetMarkerStyle(marker);
        swap->Draw(drawoptions.c_str());
        swap->GetYaxis()->SetTitleOffset(1.2);
        double maximum = swap->GetMaximum();
        double minimum = swap->GetMinimum();
        swap->SetMaximum(maximum + fabs(minimum) + fabs(maximum));
        swap->SetMinimum(minimum - fabs(maximum) - fabs(minimum));
        
 
        if(drawoptions == "P"){
            size_t found = std::string(swap->GetTitle()).find("p_{T}");
            if(found != std::string::npos) (*canvasvector)[i]->SetLogx();
            (*canvasvector)[i]->SetGridy();
            DrawTitleLatex(swap->GetTitle(), 0.2,0.87);
            (*canvasvector)[i]->SetName(swap->GetName());
        }
        if(labely != 0){
            if(legend == "") legend = swap->GetTitle();
            DrawLegendLatex(legend.c_str(),marker,0.7,labely,color,0.04);
        }
 
        // rms profile!
        int i2 = i+m_MeanProfilesVector->size();
        (*canvasvector)[i2]->cd();
        swap = GetProfile(i,true);
        swap->UseCurrentStyle();
        swap->SetLineColor(color);
        swap->SetMarkerColor(color);
        swap->SetMarkerStyle(marker);
        swap->Draw(drawoptions.c_str());
        swap->GetYaxis()->SetTitleOffset(1.2);
        swap->SetMaximum(2*fabs(swap->GetMaximum()));
        
 
        if(drawoptions == "P"){
            size_t found = std::string(swap->GetTitle()).find("p_{T}");
            if(found != std::string::npos) (*canvasvector)[i2]->SetLogx();
            (*canvasvector)[i2]->SetGridy();
            DrawTitleLatex(swap->GetTitle(), 0.2,0.87);
            (*canvasvector)[i2]->SetName(swap->GetName());
        }
        if(labely != 0){
            if(legend == "") legend = swap->GetTitle();
            DrawLegendLatex(legend.c_str(),marker,0.7,labely,color,0.04);
        }
 
    }
 
    swap = 0;
    return canvasvector;
}

Fill()

void PixelCalib::PixelResidualHistograms::Fill	(	float	residual,
		const std::vector< float > &	parameters
	)

Definition at line 68 of file PixelResidualHistograms.cxx.

                                                                                      {
    m_HistogramsVector->Fill(residual,1,parameters);
}

GetGlobalHisto()

TH1D * PixelCalib::PixelResidualHistograms::GetGlobalHisto

(

)

Definition at line 157 of file PixelResidualHistograms.cxx.

                                             {
 
 
    if( m_GlobalHisto != 0) return m_GlobalHisto;
 
    TH1 *swap = m_HistogramsVector->GetHisto(0);
    double limits = swap->GetXaxis()->GetXmax();
    int nbins = swap->GetNbinsX();
    std::string name = m_HistogramsVector->GetName() + std::string("_global");
    std::string title = m_HistogramsVector->GetTitle();
 
    m_GlobalHisto = new TH1D(name.c_str(), title.c_str(),
                nbins,-limits,limits);
    m_GlobalHisto->GetXaxis()->SetTitle(title.c_str());
 
    for(unsigned int i = 0 ; i < m_HistogramsVector->GetNhistos(); i++){
        swap = GetHisto(i);
        m_GlobalHisto->Add(swap);
    }
 
    return m_GlobalHisto;
 
}

GetHisto()

TH1D * PixelCalib::PixelResidualHistograms::GetHisto

(

const int

i

)

Definition at line 131 of file PixelResidualHistograms.cxx.

                                             {
    return m_HistogramsVector->GetHisto(i);
}

GetMeanProfile()

TProfile * PixelCalib::PixelResidualHistograms::GetMeanProfile

(

const std::string &

binname

)

Definition at line 137 of file PixelResidualHistograms.cxx.

                                                                         {
 
    for(unsigned int i = 0; i < m_binnames.size(); i++)
        if(m_binnames[i] == binname) return GetProfile(i,false);
    return 0;
 
}

GetProfile()

TProfile * PixelCalib::PixelResidualHistograms::GetProfile	(	const int	binnumber,
		bool	RMS = false,
		bool	savebins = false
	)

Definition at line 183 of file PixelResidualHistograms.cxx.

                                                                                        {
 
    // check if it has already been calculated!
    if(RMS && (*m_RMSProfilesVector)[binnumber] != 0)
        return (*m_RMSProfilesVector)[binnumber];
    else if( (*m_MeanProfilesVector)[binnumber] != 0)
        return (*m_MeanProfilesVector)[binnumber];
 
    // Allocate the new TProfile
    int nProfileBins = ( m_binnage[binnumber] ).size() - 1;
    float* xbins = new float[nProfileBins+1];
    std::string Xvar_name = m_binnames[binnumber];
    std::string Xvar_name_s = Xvar_name;
    size_t found0 = Xvar_name_s.find('#');
    if(found0 != std::string::npos) Xvar_name_s.erase(Xvar_name_s.begin(), Xvar_name_s.begin()+found0+1);
    size_t found1 = Xvar_name_s.find('_');
    if(found1 != std::string::npos) Xvar_name_s.erase(Xvar_name_s.begin()+found1,Xvar_name_s.end());
    for(int i = 0 ; i < nProfileBins+1 ; i++)
        xbins[i] = (m_binnage[binnumber])[i];
    std::string name = std::string(m_HistogramsVector->GetName());
    std::string title = std::string(m_HistogramsVector->GetTitle());
    std::string RMSname = name + std::string("_RMS_vs_") + Xvar_name_s;
    std::string RMStitle = std::string("Resolution of ") +
            title + std::string(" vs ") + Xvar_name;
    name = name + std::string("_Mean_vs_") + Xvar_name_s;
    title = std::string("Mean of ") + title + std::string(" vs ") + Xvar_name;
 
    TProfile  *theMeanProfile = new TProfile( name.c_str(), title.c_str(),
            nProfileBins, xbins);
    TProfile  *theRMSProfile = new TProfile( RMSname.c_str(), RMStitle.c_str(),
            nProfileBins, xbins);
 
    theMeanProfile->GetXaxis()->SetTitle( Xvar_name.c_str() );
    theRMSProfile->GetXaxis()->SetTitle( Xvar_name.c_str() );
    theMeanProfile->GetYaxis()->SetTitle( (std::string("Mean of ") + m_axisName).c_str() );
    theRMSProfile->GetYaxis()->SetTitle( (std::string("RMS of ") + m_axisName).c_str() );
 
    // fill it bin by bin
    std::vector<int> indexes;
    for(int ibin = 0; ibin < nProfileBins; ibin++){
        // creating the histogram for this bin..
        std::string bintitle = m_HistogramsVector->GetTitle();
        std::ostringstream binname;
        binname << m_HistogramsVector->GetName() << "vs" << Xvar_name_s << "_" << ibin;
        TH1 *swap = m_HistogramsVector->GetHisto(0);
        double limits = swap->GetXaxis()->GetXmax();
        int nbins = swap->GetNbinsX();
        TH1D *bin = new TH1D(binname.str().c_str(), bintitle.c_str(),
                nbins,-limits,limits);
        for(unsigned int i = 0 ; i < m_HistogramsVector->GetNhistos(); i++){
            indexes = m_HistogramsVector->GetDivisionsIndexes(i);
            if(indexes[binnumber] == ibin){
                swap = GetHisto(i);
                bin->Add(swap);
            }
        }
 
        double entries = 0.;
        double mean = 0.;
        double mean_error = 0.;
        double rms = 0.;
        double rms_error = 0.;
 
        if(bin->GetEntries() > 50){
            GetCoreParameters(bin,mean,mean_error,rms,rms_error,entries);
        }
 
        if(entries > 1){
            rms_error = sqrt( fabs(rms_error*rms_error*entries*entries 
                        - rms*rms/entries));
            mean_error = sqrt( fabs(mean_error*mean_error*entries*entries
                        + mean*mean/entries));
        }
                    
        theMeanProfile->SetBinContent(ibin+1,mean*entries);
        theMeanProfile->SetBinError(ibin+1,mean_error);
        theMeanProfile->SetBinEntries(ibin+1,entries);
        theRMSProfile->SetBinContent(ibin+1,rms*entries);
        theRMSProfile->SetBinError(ibin+1,rms_error);
        theRMSProfile->SetBinEntries(ibin+1,entries);
        
        //std::cout << theMeanProfile->GetBinContent(ibin+1) << "  "
        //<< theMeanProfile->GetBinError(ibin+1) << std::endl;
 
        if(entries > 0 && savebis) bin->Write();
        delete bin;
        bin = 0;
        swap = 0;
 
    }
 
    // put the calcuated profile in he correct place and return it!
    (*m_MeanProfilesVector)[binnumber] = theMeanProfile;
    (*m_RMSProfilesVector)[binnumber] = theRMSProfile;
    if(RMS) return theRMSProfile;
    else return theMeanProfile;
 
}

GetRMSProfile()

TProfile * PixelCalib::PixelResidualHistograms::GetRMSProfile

(

const std::string &

binname

)

Definition at line 147 of file PixelResidualHistograms.cxx.

                                                                        {
 
    for(unsigned int i = 0; i < m_binnames.size(); i++)
        if(m_binnames[i] == binname) return GetProfile(i,true);
    return 0;
 
}

operator=()

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

private

Read()

int PixelCalib::PixelResidualHistograms::Read

(

)

Definition at line 113 of file PixelResidualHistograms.cxx.

                                 {
 
 
    TDirectory *current = gDirectory;
    TDirectory *globaldir = (TDirectory *)current->Get(m_HistogramsVector->GetName());
    globaldir->cd();
    
    globaldir = (TDirectory *)gDirectory->Get(m_HistogramsVector->GetName());
    
    int readhistos = 0;
    readhistos += m_HistogramsVector->FillFromFile(globaldir);
    
    current->cd();
    return readhistos;
}

SetAxisTitle()

void PixelCalib::PixelResidualHistograms::SetAxisTitle

(

const std::string &

title

)

Definition at line 74 of file PixelResidualHistograms.cxx.

                                                                {
 
    m_axisName = title;
    for(unsigned int i = 0 ; i < m_HistogramsVector->GetNhistos() ; i++)
        m_HistogramsVector->GetHisto(i)->GetXaxis()->SetTitle(title.c_str());
 
 
}

Write()

int PixelCalib::PixelResidualHistograms::Write

(

bool

writebins = false

)

Definition at line 85 of file PixelResidualHistograms.cxx.

                                                {
 
    TDirectory *current = gDirectory;
    current->mkdir( m_HistogramsVector->GetName() )->cd();
 
    int writtenhistos = 0;
    m_HistogramsVector->Write();
    writtenhistos +=  m_HistogramsVector->GetNhistos();
 
    TProfile *swap = 0;
    for(unsigned int i = 0; i < m_MeanProfilesVector->size(); i++){
        swap = GetProfile(i,true,writebins);
        if( swap->Write() ) writtenhistos++;
        swap = GetProfile(i,false,writebins);
        if( swap->Write() ) writtenhistos++;
    }
 
    TH1D *swap2 = GetGlobalHisto();
    if( swap2->Write() ) writtenhistos++;
 
    current->cd();  
    swap = 0;
    swap2 = 0;
    return writtenhistos;   
}

Member Data Documentation

m_axisName

std::string PixelCalib::PixelResidualHistograms::m_axisName

private

Definition at line 86 of file PixelResidualHistograms.h.

m_binnage

std::vector< std::vector < float > > PixelCalib::PixelResidualHistograms::m_binnage

private

Definition at line 85 of file PixelResidualHistograms.h.

m_binnames

std::vector< std::string > PixelCalib::PixelResidualHistograms::m_binnames

private

Definition at line 84 of file PixelResidualHistograms.h.

m_GlobalHisto

TH1D* PixelCalib::PixelResidualHistograms::m_GlobalHisto

private

Definition at line 83 of file PixelResidualHistograms.h.

m_HistogramsVector

MultiHisto< TH1D >* PixelCalib::PixelResidualHistograms::m_HistogramsVector

private

Definition at line 80 of file PixelResidualHistograms.h.

m_MeanProfilesVector

std::vector< TProfile*>* PixelCalib::PixelResidualHistograms::m_MeanProfilesVector

private

Definition at line 81 of file PixelResidualHistograms.h.

m_RMSProfilesVector

std::vector< TProfile*>* PixelCalib::PixelResidualHistograms::m_RMSProfilesVector

private

Definition at line 82 of file PixelResidualHistograms.h.

---

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

• PixelResidualHistograms.h
• PixelResidualHistograms.cxx