[u/mrichter/AliRoot.git] / ITS / AliITSplotSPDClusters.C

#if !defined(__CINT__) || defined(__MAKECINT__)

// Standard includes
#include <iostream.h>
// Root includes
#include <TFile.h>
#include <TObjArray.h>
#include <TClonesArray.h>
#include <TTree.h>
#include <TBranch.h>
#include <TH1D.h>
// AliRoot includes
#include "STEER/AliRun.h"
#include "ITS/AliITS.h"
#include "ITS/AliITSRawCluster.h"

#endif

void AliITSplotSPDClusters(const char* filename="galice_80.root"){
    //------------------------------------------------------------------
    // This macro will read the TreeC produced during reconstruction and
    // plot the number and type of clusters found in the SPD.
    // root [0] .L AliITSplotSPDClusters.C  //this loads the macro in memory
    // root [1] AliITSplotSPDClusters();    //by default process first event
    // or
    // root [1] AliITSplotSPDClusters("galice2.root"); // process all events
    //                                                    from the file
    //                                                    galice2.root.
    // or
    // root [0] .x AliITSplotSPDClusters.C("galice2.root") // will all of the
    //                                                        events from the
    //                                                        galice2.root
    //------------------------------------------------------------------

    // delete the current gAlice object, the one from input file will be used
    if(gAlice){
	delete gAlice;
	gAlice = 0;
    }else{ // Dynamically link some shared libs
        if(gClassTable->GetID("AliRun") < 0) {
            gROOT->LoadMacro("loadlibs.C");
            loadlibs();
        } // end if
    } // end if gAlice

    // Connect the Root Galice file containing Geometry, Kine and Hits
    TFile *file = (TFile*)gROOT->GetListOfFiles()->FindObject(filename);
    if(!file) file = new TFile(filename);
    // Get AliRun object from file or create it if not on file
    if(!gAlice) {
        gAlice = (AliRun*)file->Get("gAlice");
        if(gAlice) cout << "AliRun object found on file" << endl;
        if(!gAlice) gAlice = new AliRun("gAlice","SPD Clulster analysis");
    } // end if !gAlice
    Int_t nevents = gAlice->GetEventsPerRun();

    // Get pointers to the ITS Alice detectors.
    AliITS *ITS = (AliITS*) gAlice->GetDetector("ITS");
    if(ITS==0){
        cout << "ITS not found. Exiting." << endl;
        return;
    } // end if ITS==0
    AliITSresponseSPDdubna *resp0 = ITS->DetType(0)->GetResponseModel();
    Float_t diffCoeff= resp0->DistanceOverVoltage();//Get Value of Diffusion Coefficient parameter d/v.
    diffCoeff *= resp0->Temperature();
    diffCoeff = TMath::Sqrt(diffCoeff*8.6173376e-5);// K_Boltzman/e_Coulumb
    char    aDiffCoeff[100];            //Character array for sprintf

    sprintf(aDiffCoeff,"Number of SPD Clusters in x, layer 1, DiffCoeff=%f #sqrt{cm}",
	    diffCoeff);
    TH1D *hclx1 = new TH1D("hclx1",aDiffCoeff,15,0.5,15.5);
    sprintf(aDiffCoeff,"Number of SPD Clusters in z, layer 1, DiffCoeff=%f #sqrt{cm}",
	    diffCoeff);
    TH1D *hclz1 = new TH1D("hclz1",aDiffCoeff,5,0.5,5.5);
    sprintf(aDiffCoeff,"Number of SPD Clusters in x, layer 2, DiffCoeff=%f #sqrt{cm}",
	    diffCoeff);
    TH1D *hclx2 = new TH1D("hclx2",aDiffCoeff,15,0.5,15.5);
    sprintf(aDiffCoeff,"Number of SPD Clusters in z, layer 2, DiffCoeff=%f #sqrt{cm}",
	    diffCoeff);
    TH1D *hclz2 = new TH1D("hclz2",aDiffCoeff,5,0.5,5.5);
    // Create Arrays with clusters from:  Data, Ba/Sa Model, old version of
    // Dubna
    Float_t dataX1[9] = {0.493, 0.493, 0.0273, 0.00617, 0.00112, 0.000257,
			 0.000257,  0.000257, 0.000257};
                        //clusters from the data in the x-dimension with
                        //standard paramaters
    Float_t baSaX1[11] = {0.942, 0.0180, 0.0112, 0.00389, 0.00203, 0.000257,
			  0.001, 0.000257, 0.000257, 0.000257, 0.001};
                        //same for Ba/Sa model
    Float_t dubnaX1[7] =  {0.889, 0.0789, 0.0151, 0.00389, 0.001, 0.001,
			   0.001};
                        //same for old version of Dubna model
    Float_t dataX2[9] = {0.482, 0.482, 0.0325, 0.00791, 0.00157, 0.000275,
                         0.000275, 0.000275, 0.000275};
                        //clusters from the data in the x-dimension with
                        //optimized paramaters
    Float_t baSaX2[11] = {0.946, 0.0175, 0.0245, 0.00482, 0.001, 0.001,
			  0.000275,  0.001, 0.000275, 0.000275, 0.001};
                        //same for Ba/Sa model
    Float_t dubnaX2[8] = {0.638, 0.325, 0.0275, 0.01, 0.00431, 0.000275,
			  0.001, 0.001};
                        //same for old version of Dubna model
    Float_t dataZ1[4] = {0.889, 0.0624, 0.000257, 0.000257};
                        //clusters from the data in the z-dimension with
                        //standard paramaters
    Float_t baSaZ1[3] = {1., 0.0160, 0.000257}; //same for Ba/Sa model
    Float_t dubnaZ1[3] = {0.889, 0.0180, 0.000257};
                        //same for old version of Dubna model
    Float_t dataZ2[4] = {0.889, 0.0624, 0.000257, 0.000257};
                        //clusters from the data in the z-dimension with
                        //optimized paramaters
    Float_t baSaZ2[4] = {1., 0.0160, 0.00215, 0.000257}; //same for Ba/Sa model
    Float_t dubnaZ2[3] = {0.889, 0.0412, 0.000257};
                        //same for old version of Dubna model
    
    TH1F *hdataX1  = new TH1F("hdataX1","Number of SPD Clusters in x, layer 1",
			      9, 0.5, 9.5);
    hdataX1->SetMarkerColor(2);
    hdataX1->SetMarkerStyle(20);
    hdataX1->SetMarkerSize(0.7);
    TH1F *hbaSaX1  = new TH1F("hbaSaX1", "Ba/Sa", 11, 0.5, 11.5);
    TH1F *hdubnaX1 = new TH1F("hdubnaX1", "Old Dubna", 7, 0.5, 7.5);
    TH1F *hdataX2  = new TH1F("hdataX2","Number of SPD Clusters in x, layer 2",
			      9, 0.5, 9.5);
    hdataX2->SetMarkerColor(2);
    hdataX2->SetMarkerStyle(20);
    hdataX2->SetMarkerSize(0.7);
    TH1F *hbaSaX2  = new TH1F("hbaSaX2", "Ba/Sa", 11, 0.5, 11.5);
    TH1F *hdubnaX2 = new TH1F("hdubnaX2", "Old Dubna", 8, 0.5, 8.5);
    TH1F *hdataZ1  = new TH1F("hdataZ1","Number of SPD Clusters in z, layer 1",
			      4, 0.5, 4.5);
    hdataZ1->SetMarkerColor(2);
    hdataZ1->SetMarkerStyle(20);
    hdataZ1->SetMarkerSize(0.7);
    TH1F *hbaSaZ1  = new TH1F("hbaSaZ1", "Ba/Sa", 3, 0.5, 3.5);
    TH1F *hdubnaZ1 = new TH1F("hdubnaZ1", "Old Dubna", 3, 0.5, 3.5);
    TH1F *hdataZ2  = new TH1F("hdataZ2","Number of SPD Clusters in z, layer 2",
			      4, 0.5, 4.5);
    hdataZ2->SetMarkerColor(2);
    hdataZ2->SetMarkerStyle(20);
    hdataZ2->SetMarkerSize(0.7);
    TH1F *hbaSaZ2  = new TH1F("hbaSaZ2", "Ba/Sa", 4, 0.5, 4.5);
    TH1F *hdubnaZ2 = new TH1F("hdubnaZ2", "Old Dubna", 3, 0.5, 3.5);

    Int_t j = 0; //j will be a counter for the loops to fill the histograms
                 //with the values for clusters for the Data, the Ba/Sa model
                 //and the old Dubna model
    for(j=0; j<9; j++){
	hdataX1->SetBinContent((j+1), (Double_t)dataX1[j]);
	hdataX1->SetBinError((j+1), 0.00001);
    }
    for(j=0; j<11; j++) hbaSaX1->Fill((Float_t)j +0.5, baSaX1[j]);
    for(j=0; j<7; j++)  hdubnaX1->Fill((Float_t)j +0.5, dubnaX1[j]);
    for(j=0; j<9; j++){
	hdataX2->SetBinContent((j+1), (Double_t)dataX2[j]);
	hdataX2->SetBinError((j+1), 0.00001);
    }
    for(j=0; j<11; j++) hbaSaX2->Fill((Float_t)j +0.5, baSaX2[j]);
    for(j=0; j<8; j++)  hdubnaX2->Fill((Float_t)j +0.5, dubnaX2[j]);
    for(j=0; j<4; j++){
	hdataZ1->SetBinContent((j+1), (Double_t)dataZ1[j]);
	hdataZ1->SetBinError((j+1), 0.00001);
    }
    for(j=0; j<3; j++)  hbaSaZ1->Fill((Float_t)j +0.5, baSaZ1[j]);
    for(j=0; j<3; j++)  hdubnaZ1->Fill((Float_t)j +0.5, dubnaZ1[j]);
    for(j=0; j<4; j++){
	hdataZ2->SetBinContent((j+1), (Double_t)dataZ2[j]);
	hdataZ2->SetBinError((j+1), 0.00001);
    }
    for(j=0; j<4; j++)  hbaSaZ2->Fill((Float_t)j +0.5, baSaZ2[j]);
    for(j=0; j<3; j++)  hdubnaZ2->Fill((Float_t)j +0.5, dubnaZ2[j]);

    TTree *tc = 0;
    TBranch *spdBranch = 0;
    TClonesArray *spdClustcA = new TClonesArray("AliITSRawClusterSPD",1000);
    AliITSRawClusterSPD *spdClust = 0;
    char tn[20];
    Int_t evnt,i,n,nc;
    Float_t nclx = 0,nclz = 0;
    for(evnt=0;evnt<nevents;evnt++){
	sprintf(tn,"TreeC%d",evnt);
	tc = (TTree*) file->Get(tn);
	spdBranch = tc->GetBranch("ITSClustersSPD");
	spdBranch->SetAddress(&spdClustcA);
  	n = (Int_t) tc->GetEntries();
	for(i=0;i<n;i++){
  	    tc->GetEvent(i);
	    nc = spdClustcA->GetEntries();
	    if(nc>240) nc = 240;
	    for(j=0;j<nc;j++){
		spdClust = (AliITSRawClusterSPD*) spdClustcA->At(j);
		nclx = spdClust->NclX();
		nclz = spdClust->NclZ();
		if(spdClust->Module()<80){
		    hclx1->Fill(nclx-0.5);
		    hclz1->Fill(nclz-0.5);
		}else if(spdClust->Module()<240){
		    hclx2->Fill(nclx-0.5);
		    hclz2->Fill(nclz-0.5);
		} //endif
	    } // end for j
	} // end for i
	spdClustcA->Clear();
	delete spdBranch; spdBranch = 0;
	delete tc; tc = 0;
    } // end for evnt

    //Begin Process of normalizing histograms
    Double_t integral = (Double_t) hclx1->Integral();
    if(integral>0.0) hclx1->Scale(1./integral);
    integral = hclz1->Integral();
    if(integral>0.0) hclz1->Scale(1./integral);
    integral = hclx2->Integral();
    if(integral>0.0) hclx2->Scale(1./integral);
    integral = hclz2->Integral();
    if(integral>0.0) hclz2->Scale(1./integral);

    hclx1->SetMinimum(0.000257);
    hclx1->SetMaximum(1.01);
    hclz1->SetMinimum(0.000274);
    hclz1->SetMaximum(1.01);
    hclx2->SetMinimum(0.000257);
    hclx2->SetMaximum(1.01);
    hclz2->SetMinimum(0.000257);
    hclz2->SetMaximum(1.01);

    sprintf(aDiffCoeff,"SPD Clusters with Diffusion Coefficent=%f",diffCoeff);
    TCanvas *cSPDclusters = new TCanvas("cSPDclusters",aDiffCoeff,
				       400,10,600,776);
    cSPDclusters->Divide(2, 2);

    cSPDclusters->cd(1);
    cSPDclusters->SetLogy(1);
    hclx1->Draw("hist");
    hdataX1->Draw("same e1p");
    hbaSaX1->SetLineColor(4);
    hbaSaX1->SetLineStyle(2);    
    hbaSaX1->Draw("same");
    hdubnaX1->SetLineColor(3);
    hdubnaX1->SetLineStyle(4);
    hdubnaX1->Draw("same");
    TLegend *l1 = new TLegend(0.55,0.65,0.76,0.82);
    l1->AddEntry(hclx1,"New simulation","l");
    l1->AddEntry(hdataX1,"Test Beam Results","p");
    l1->AddEntry(hbaSaX1,"Bari/Selero simulation","l");
    l1->AddEntry(hdubnaX1,"Dubna simulation","l");
    l1->Draw();

    cSPDclusters->cd(2);
    cSPDclusters->SetLogy(1);
    hclz1->Draw("hist");
    hdataZ1->Draw("same e1p");
    hbaSaZ2->SetLineColor(4);
    hbaSaZ1->SetLineStyle(2);
    hbaSaZ1->Draw("same");
    hdubnaZ1->SetLineColor(3);
    hdubnaZ1->SetLineStyle(4);
    hdubnaZ1->Draw("same");
    TLegend *l2 = new TLegend(0.55,0.65,0.76,0.82);
    l2->AddEntry(hclz1,"New simulation","l");
    l2->AddEntry(hdataZ1,"Test Beam Results","p");
    l2->AddEntry(hbaSaZ1,"Bari/Selero simulation","l");
    l2->AddEntry(hdubnaZ1,"Dubna simulation","l");
    l2->Draw();

    cSPDclusters->cd(3);
    cSPDclusters->SetLogy(1);
    hclx2->Draw("hist");
    TLegend *l3 = new TLegend(0.55,0.65,0.76,0.82);
    l3->AddEntry(hclx2,"New simulation","l");
    l3->Draw();
/*
    hdataX2->Draw("e1p");
    hbaSaX2->SetLineColor(4);
    hbaSaX2->SetLineStyle(2);
    hbaSaX2->Draw("same");
    hdubnaX2->SetLineColor(3);
    hdubnaX2->SetLineStyle(4);
    hdubnaX2->Draw("same");
*/
    cSPDclusters->cd(4);
    cSPDclusters->SetLogy(1);
    hclz2->Draw("hist");
    TLegend *l4 = new TLegend(0.55,0.65,0.76,0.82);
    l4->AddEntry(hclz2,"New simulation","l");
    l4->Draw();
/*
    hdataZ2->Draw("e1p");
    hbaSaZ2->SetLineColor(4);
    hbaSaZ2->SetLineStyle(2);
    hbaSaZ2->Draw("same");
    hdubnaZ2->SetLineColor(3);
    hdubnaZ2->SetLineStyle(4);
    hdubnaZ2->Draw("same");
*/
    cSPDclusters->Update();

    if(gROOT->IsBatch()){
	cSPDclusters->Print("SPDClusters.eps");
    } // end if gROOT->IsBatch()

}
Commit	Line	Data
ad456e33	1	#if !defined(__CINT__) \|\| defined(__MAKECINT__)
	2
	3	// Standard includes
	4	#include <iostream.h>
	5	// Root includes
	6	#include <TFile.h>
	7	#include <TObjArray.h>
	8	#include <TClonesArray.h>
	9	#include <TTree.h>
	10	#include <TBranch.h>
	11	#include <TH1D.h>
	12	// AliRoot includes
	13	#include "STEER/AliRun.h"
	14	#include "ITS/AliITS.h"
	15	#include "ITS/AliITSRawCluster.h"
	16
	17	#endif
	18
	19	void AliITSplotSPDClusters(const char* filename="galice_80.root"){
	20	//------------------------------------------------------------------
	21	// This macro will read the TreeC produced during reconstruction and
	22	// plot the number and type of clusters found in the SPD.
	23	// root [0] .L AliITSplotSPDClusters.C //this loads the macro in memory
	24	// root [1] AliITSplotSPDClusters(); //by default process first event
	25	// or
	26	// root [1] AliITSplotSPDClusters("galice2.root"); // process all events
	27	// from the file
	28	// galice2.root.
	29	// or
	30	// root [0] .x AliITSplotSPDClusters.C("galice2.root") // will all of the
	31	// events from the
	32	// galice2.root
	33	//------------------------------------------------------------------
	34
	35	// delete the current gAlice object, the one from input file will be used
	36	if(gAlice){
	37	delete gAlice;
	38	gAlice = 0;
	39	}else{ // Dynamically link some shared libs
	40	if(gClassTable->GetID("AliRun") < 0) {
	41	gROOT->LoadMacro("loadlibs.C");
	42	loadlibs();
	43	} // end if
	44	} // end if gAlice
	45
	46	// Connect the Root Galice file containing Geometry, Kine and Hits
	47	TFile file = (TFile)gROOT->GetListOfFiles()->FindObject(filename);
	48	if(!file) file = new TFile(filename);
	49	// Get AliRun object from file or create it if not on file
	50	if(!gAlice) {
	51	gAlice = (AliRun*)file->Get("gAlice");
	52	if(gAlice) cout << "AliRun object found on file" << endl;
	53	if(!gAlice) gAlice = new AliRun("gAlice","SPD Clulster analysis");
	54	} // end if !gAlice
	55	Int_t nevents = gAlice->GetEventsPerRun();
	56
	57	// Get pointers to the ITS Alice detectors.
	58	AliITS ITS = (AliITS) gAlice->GetDetector("ITS");
	59	if(ITS==0){
	60	cout << "ITS not found. Exiting." << endl;
	61	return;
	62	} // end if ITS==0
	63	AliITSresponseSPDdubna *resp0 = ITS->DetType(0)->GetResponseModel();
	64	Float_t diffCoeff= resp0->DistanceOverVoltage();//Get Value of Diffusion Coefficient parameter d/v.
404d4045	65	diffCoeff *= resp0->Temperature();
	66	diffCoeff = TMath::Sqrt(diffCoeff*8.6173376e-5);// K_Boltzman/e_Coulumb
	67	char aDiffCoeff[100]; //Character array for sprintf
ad456e33	68
404d4045	69	sprintf(aDiffCoeff,"Number of SPD Clusters in x, layer 1, DiffCoeff=%f #sqrt{cm}",
	70	diffCoeff);
	71	TH1D *hclx1 = new TH1D("hclx1",aDiffCoeff,15,0.5,15.5);
	72	sprintf(aDiffCoeff,"Number of SPD Clusters in z, layer 1, DiffCoeff=%f #sqrt{cm}",
	73	diffCoeff);
	74	TH1D *hclz1 = new TH1D("hclz1",aDiffCoeff,5,0.5,5.5);
	75	sprintf(aDiffCoeff,"Number of SPD Clusters in x, layer 2, DiffCoeff=%f #sqrt{cm}",
	76	diffCoeff);
	77	TH1D *hclx2 = new TH1D("hclx2",aDiffCoeff,15,0.5,15.5);
	78	sprintf(aDiffCoeff,"Number of SPD Clusters in z, layer 2, DiffCoeff=%f #sqrt{cm}",
	79	diffCoeff);
	80	TH1D *hclz2 = new TH1D("hclz2",aDiffCoeff,5,0.5,5.5);
ad456e33	81	// Create Arrays with clusters from: Data, Ba/Sa Model, old version of
	82	// Dubna
	83	Float_t dataX1[9] = {0.493, 0.493, 0.0273, 0.00617, 0.00112, 0.000257,
	84	0.000257, 0.000257, 0.000257};
	85	//clusters from the data in the x-dimension with
	86	//standard paramaters
	87	Float_t baSaX1[11] = {0.942, 0.0180, 0.0112, 0.00389, 0.00203, 0.000257,
	88	0.001, 0.000257, 0.000257, 0.000257, 0.001};
	89	//same for Ba/Sa model
	90	Float_t dubnaX1[7] = {0.889, 0.0789, 0.0151, 0.00389, 0.001, 0.001,
	91	0.001};
	92	//same for old version of Dubna model
	93	Float_t dataX2[9] = {0.482, 0.482, 0.0325, 0.00791, 0.00157, 0.000275,
	94	0.000275, 0.000275, 0.000275};
	95	//clusters from the data in the x-dimension with
	96	//optimized paramaters
	97	Float_t baSaX2[11] = {0.946, 0.0175, 0.0245, 0.00482, 0.001, 0.001,
	98	0.000275, 0.001, 0.000275, 0.000275, 0.001};
	99	//same for Ba/Sa model
	100	Float_t dubnaX2[8] = {0.638, 0.325, 0.0275, 0.01, 0.00431, 0.000275,
	101	0.001, 0.001};
	102	//same for old version of Dubna model
	103	Float_t dataZ1[4] = {0.889, 0.0624, 0.000257, 0.000257};
	104	//clusters from the data in the z-dimension with
	105	//standard paramaters
	106	Float_t baSaZ1[3] = {1., 0.0160, 0.000257}; //same for Ba/Sa model
	107	Float_t dubnaZ1[3] = {0.889, 0.0180, 0.000257};
	108	//same for old version of Dubna model
	109	Float_t dataZ2[4] = {0.889, 0.0624, 0.000257, 0.000257};
	110	//clusters from the data in the z-dimension with
	111	//optimized paramaters
	112	Float_t baSaZ2[4] = {1., 0.0160, 0.00215, 0.000257}; //same for Ba/Sa model
	113	Float_t dubnaZ2[3] = {0.889, 0.0412, 0.000257};
	114	//same for old version of Dubna model
	115
	116	TH1F *hdataX1 = new TH1F("hdataX1","Number of SPD Clusters in x, layer 1",
	117	9, 0.5, 9.5);
	118	hdataX1->SetMarkerColor(2);
	119	hdataX1->SetMarkerStyle(20);
	120	hdataX1->SetMarkerSize(0.7);
	121	TH1F *hbaSaX1 = new TH1F("hbaSaX1", "Ba/Sa", 11, 0.5, 11.5);
	122	TH1F *hdubnaX1 = new TH1F("hdubnaX1", "Old Dubna", 7, 0.5, 7.5);
	123	TH1F *hdataX2 = new TH1F("hdataX2","Number of SPD Clusters in x, layer 2",
	124	9, 0.5, 9.5);
	125	hdataX2->SetMarkerColor(2);
	126	hdataX2->SetMarkerStyle(20);
	127	hdataX2->SetMarkerSize(0.7);
	128	TH1F *hbaSaX2 = new TH1F("hbaSaX2", "Ba/Sa", 11, 0.5, 11.5);
	129	TH1F *hdubnaX2 = new TH1F("hdubnaX2", "Old Dubna", 8, 0.5, 8.5);
	130	TH1F *hdataZ1 = new TH1F("hdataZ1","Number of SPD Clusters in z, layer 1",
	131	4, 0.5, 4.5);
	132	hdataZ1->SetMarkerColor(2);
	133	hdataZ1->SetMarkerStyle(20);
	134	hdataZ1->SetMarkerSize(0.7);
	135	TH1F *hbaSaZ1 = new TH1F("hbaSaZ1", "Ba/Sa", 3, 0.5, 3.5);
	136	TH1F *hdubnaZ1 = new TH1F("hdubnaZ1", "Old Dubna", 3, 0.5, 3.5);
	137	TH1F *hdataZ2 = new TH1F("hdataZ2","Number of SPD Clusters in z, layer 2",
	138	4, 0.5, 4.5);
	139	hdataZ2->SetMarkerColor(2);
	140	hdataZ2->SetMarkerStyle(20);
	141	hdataZ2->SetMarkerSize(0.7);
	142	TH1F *hbaSaZ2 = new TH1F("hbaSaZ2", "Ba/Sa", 4, 0.5, 4.5);
	143	TH1F *hdubnaZ2 = new TH1F("hdubnaZ2", "Old Dubna", 3, 0.5, 3.5);
	144
145	Int_t j = 0; //j will be a counter for the loops to fill the histograms
146	//with the values for clusters for the Data, the Ba/Sa model
147	//and the old Dubna model
148	for(j=0; j<9; j++){
149	hdataX1->SetBinContent((j+1), (Double_t)dataX1[j]);
150	hdataX1->SetBinError((j+1), 0.00001);
151	}
152	for(j=0; j<11; j++) hbaSaX1->Fill((Float_t)j +0.5, baSaX1[j]);
153	for(j=0; j<7; j++) hdubnaX1->Fill((Float_t)j +0.5, dubnaX1[j]);
154	for(j=0; j<9; j++){
155	hdataX2->SetBinContent((j+1), (Double_t)dataX2[j]);
156	hdataX2->SetBinError((j+1), 0.00001);
157	}
158	for(j=0; j<11; j++) hbaSaX2->Fill((Float_t)j +0.5, baSaX2[j]);
159	for(j=0; j<8; j++) hdubnaX2->Fill((Float_t)j +0.5, dubnaX2[j]);
160	for(j=0; j<4; j++){
161	hdataZ1->SetBinContent((j+1), (Double_t)dataZ1[j]);
162	hdataZ1->SetBinError((j+1), 0.00001);
163	}
164	for(j=0; j<3; j++) hbaSaZ1->Fill((Float_t)j +0.5, baSaZ1[j]);
165	for(j=0; j<3; j++) hdubnaZ1->Fill((Float_t)j +0.5, dubnaZ1[j]);
166	for(j=0; j<4; j++){
167	hdataZ2->SetBinContent((j+1), (Double_t)dataZ2[j]);
168	hdataZ2->SetBinError((j+1), 0.00001);
169	}
170	for(j=0; j<4; j++) hbaSaZ2->Fill((Float_t)j +0.5, baSaZ2[j]);
171	for(j=0; j<3; j++) hdubnaZ2->Fill((Float_t)j +0.5, dubnaZ2[j]);
172
173	TTree *tc = 0;
174	TBranch *spdBranch = 0;
175	TClonesArray *spdClustcA = new TClonesArray("AliITSRawClusterSPD",1000);
176	AliITSRawClusterSPD *spdClust = 0;
177	char tn[20];
178	Int_t evnt,i,n,nc;
179	Float_t nclx = 0,nclz = 0;
180	for(evnt=0;evnt<nevents;evnt++){
181	sprintf(tn,"TreeC%d",evnt);
182	tc = (TTree*) file->Get(tn);
183	spdBranch = tc->GetBranch("ITSClustersSPD");
184	spdBranch->SetAddress(&spdClustcA);
185	n = (Int_t) tc->GetEntries();
186	for(i=0;i<n;i++){
187	tc->GetEvent(i);
188	nc = spdClustcA->GetEntries();
189	if(nc>240) nc = 240;
190	for(j=0;j<nc;j++){
191	spdClust = (AliITSRawClusterSPD*) spdClustcA->At(j);
192	nclx = spdClust->NclX();
193	nclz = spdClust->NclZ();
194	if(spdClust->Module()<80){
195	hclx1->Fill(nclx-0.5);
196	hclz1->Fill(nclz-0.5);
197	}else if(spdClust->Module()<240){
198	hclx2->Fill(nclx-0.5);
199	hclz2->Fill(nclz-0.5);
200	} //endif
201	} // end for j
202	} // end for i
203	spdClustcA->Clear();
204	delete spdBranch; spdBranch = 0;
205	delete tc; tc = 0;
206	} // end for evnt
207
208	//Begin Process of normalizing histograms
209	Double_t integral = (Double_t) hclx1->Integral();
210	if(integral>0.0) hclx1->Scale(1./integral);
211	integral = hclz1->Integral();
212	if(integral>0.0) hclz1->Scale(1./integral);
213	integral = hclx2->Integral();
214	if(integral>0.0) hclx2->Scale(1./integral);
215	integral = hclz2->Integral();
216	if(integral>0.0) hclz2->Scale(1./integral);
217
404d4045	218	hclx1->SetMinimum(0.000257);
	219	hclx1->SetMaximum(1.01);
	220	hclz1->SetMinimum(0.000274);
	221	hclz1->SetMaximum(1.01);
	222	hclx2->SetMinimum(0.000257);
	223	hclx2->SetMaximum(1.01);
	224	hclz2->SetMinimum(0.000257);
	225	hclz2->SetMaximum(1.01);
ad456e33	226
ad456e33	227	sprintf(aDiffCoeff,"SPD Clusters with Diffusion Coefficent=%f",diffCoeff);
ad456e33	228	TCanvas *cSPDclusters = new TCanvas("cSPDclusters",aDiffCoeff,
404d4045	229	400,10,600,776);
ad456e33	230	cSPDclusters->Divide(2, 2);
	231
	232	cSPDclusters->cd(1);
404d4045	233	cSPDclusters->SetLogy(1);
	234	hclx1->Draw("hist");
	235	hdataX1->Draw("same e1p");
ad456e33	236	hbaSaX1->SetLineColor(4);
	237	hbaSaX1->SetLineStyle(2);
	238	hbaSaX1->Draw("same");
	239	hdubnaX1->SetLineColor(3);
	240	hdubnaX1->SetLineStyle(4);
	241	hdubnaX1->Draw("same");
404d4045	242	TLegend *l1 = new TLegend(0.55,0.65,0.76,0.82);
	243	l1->AddEntry(hclx1,"New simulation","l");
	244	l1->AddEntry(hdataX1,"Test Beam Results","p");
	245	l1->AddEntry(hbaSaX1,"Bari/Selero simulation","l");
	246	l1->AddEntry(hdubnaX1,"Dubna simulation","l");
	247	l1->Draw();
ad456e33	248
ad456e33	249	cSPDclusters->cd(2);
404d4045	250	cSPDclusters->SetLogy(1);
	251	hclz1->Draw("hist");
	252	hdataZ1->Draw("same e1p");
ad456e33	253	hbaSaZ2->SetLineColor(4);
	254	hbaSaZ1->SetLineStyle(2);
	255	hbaSaZ1->Draw("same");
	256	hdubnaZ1->SetLineColor(3);
	257	hdubnaZ1->SetLineStyle(4);
	258	hdubnaZ1->Draw("same");
404d4045	259	TLegend *l2 = new TLegend(0.55,0.65,0.76,0.82);
	260	l2->AddEntry(hclz1,"New simulation","l");
	261	l2->AddEntry(hdataZ1,"Test Beam Results","p");
	262	l2->AddEntry(hbaSaZ1,"Bari/Selero simulation","l");
	263	l2->AddEntry(hdubnaZ1,"Dubna simulation","l");
	264	l2->Draw();
ad456e33	265
ad456e33	266	cSPDclusters->cd(3);
404d4045	267	cSPDclusters->SetLogy(1);
	268	hclx2->Draw("hist");
	269	TLegend *l3 = new TLegend(0.55,0.65,0.76,0.82);
	270	l3->AddEntry(hclx2,"New simulation","l");
	271	l3->Draw();
	272	/*
ad456e33	273	hdataX2->Draw("e1p");
ad456e33	274	hbaSaX2->SetLineColor(4);
	275	hbaSaX2->SetLineStyle(2);
	276	hbaSaX2->Draw("same");
	277	hdubnaX2->SetLineColor(3);
	278	hdubnaX2->SetLineStyle(4);
	279	hdubnaX2->Draw("same");
404d4045	280	*/
ad456e33	281	cSPDclusters->cd(4);
404d4045	282	cSPDclusters->SetLogy(1);
	283	hclz2->Draw("hist");
	284	TLegend *l4 = new TLegend(0.55,0.65,0.76,0.82);
	285	l4->AddEntry(hclz2,"New simulation","l");
	286	l4->Draw();
	287	/*
ad456e33	288	hdataZ2->Draw("e1p");
ad456e33	289	hbaSaZ2->SetLineColor(4);
	290	hbaSaZ2->SetLineStyle(2);
	291	hbaSaZ2->Draw("same");
	292	hdubnaZ2->SetLineColor(3);
	293	hdubnaZ2->SetLineStyle(4);
	294	hdubnaZ2->Draw("same");
404d4045	295	*/
404d4045	296	cSPDclusters->Update();
ad456e33	297
	298	if(gROOT->IsBatch()){
	299	cSPDclusters->Print("SPDClusters.eps");
	300	} // end if gROOT->IsBatch()
	301
	302	}