ROOT logo
//------------------------------------------------------------------------------
// Implementation of AliTPCPerformanceSummary class. 
// It has only static member functions to extract some TPC Performance
// parameters and produce trend graphs.
// The function MakeReport is to be called for every run. It reads AliPerformanceTPC
// and AliPerformanceDEdx objects from file and produces a
// rootfile with the results stored in a TTree.
// The function MakeReport needs a list of these rootfiles as input
// and writes the output (tree and histograms) to another rootfile.
//
// by M.Knichel 15/10/2010
//------------------------------------------------------------------------------

#include <fstream>

#include "TSystem.h"
#include "TMath.h"
#include "TVectorD.h"
#include "TList.h"
#include "TFile.h"
#include "TGrid.h"
#include "TF1.h"
#include "TH1.h"
#include "TH2.h"
#include "TH3.h"
#include "TProfile.h"
#include "THnSparse.h"
#include "TTree.h"
#include "TChain.h"
#include "TGraph.h"
#include "TPad.h"
#include "TCanvas.h"

#include "AliGRPObject.h"
#include "AliTPCcalibDB.h"
#include "AliTPCcalibDButil.h"
#include "TTreeStream.h"
#include "AliPerformanceTPC.h"
#include "AliPerformanceDEdx.h"
#include "AliPerformanceDCA.h"
#include "AliPerformanceMatch.h"

#include "AliTPCPerformanceSummary.h"

using std::ifstream;

ClassImp(AliTPCPerformanceSummary)

Bool_t AliTPCPerformanceSummary::fgForceTHnSparse = kFALSE;


//_____________________________________________________________________________
void AliTPCPerformanceSummary::WriteToTTreeSRedirector(const AliPerformanceTPC* pTPC, const AliPerformanceDEdx* pTPCgain, const AliPerformanceMatch* pTPCMatch,const AliPerformanceMatch* pTPCPull, const AliPerformanceMatch* pConstrain, TTreeSRedirector* const pcstream, Int_t run)
{
   // 
    // Extracts performance parameters from pTPC and pTPCgain.
    // Output is written to pcstream.
    // The run number must be provided since it is not stored in 
    // AliPerformanceTPC or AliPerformanceDEdx.
    //
    if (run <= 0 ) {
        if (pTPCMatch) {run = pTPCMatch->GetRunNumber(); }
        if (pTPCgain) {run = pTPCgain->GetRunNumber(); }
        if (pTPC) { run = pTPC->GetRunNumber(); }
    }
    TObjString runType;

    //AliTPCcalibDB     *calibDB=0;

//     AliTPCcalibDButil *dbutil =0;
    Int_t startTimeGRP=0;
    Int_t stopTimeGRP=0;   
    Int_t time=0;
    Int_t duration=0;

    //Float_t currentL3 =0;
    //Int_t polarityL3 = 0;
    //Float_t bz = 0;

    //calibDB = AliTPCcalibDB::Instance();

//     dbutil= new AliTPCcalibDButil;   
        
    //printf("Processing run %d ...\n",run);
    //if (calibDB) { 
    //AliTPCcalibDB::Instance()->SetRun(run); 

//     dbutil->UpdateFromCalibDB();
//     dbutil->SetReferenceRun(run);
//     dbutil->UpdateRefDataFromOCDB();     
     
    //if (calibDB->GetGRP(run)){
    //startTimeGRP = AliTPCcalibDB::GetGRP(run)->GetTimeStart();
    //stopTimeGRP  = AliTPCcalibDB::GetGRP(run)->GetTimeEnd();
    //currentL3 = AliTPCcalibDB::GetL3Current(run);
    //polarityL3 = AliTPCcalibDB::GetL3Polarity(run);
    //bz = AliTPCcalibDB::GetBz(run);
    
    //}    
    //runType = AliTPCcalibDB::GetRunType(run).Data();  
    //}  
  time = (startTimeGRP+stopTimeGRP)/2;
  duration = (stopTimeGRP-startTimeGRP);
    
    if (!pcstream) return;
    (*pcstream)<<"tpcQA"<<      
      "run="<<run<<
      "time="<<time<<
      "startTimeGRP="<<startTimeGRP<<
      "stopTimeGRP="<<stopTimeGRP<<
      "duration="<<duration<<
      "runType.="<<&runType;
    if (pTPC) {
        pTPC->GetTPCTrackHisto()->GetAxis(9)->SetRangeUser(0.5,1.5);
        pTPC->GetTPCTrackHisto()->GetAxis(7)->SetRangeUser(0.25,10);
        pTPC->GetTPCTrackHisto()->GetAxis(5)->SetRangeUser(-1,1);    
        AnalyzeNCL(pTPC, pcstream);    
        AnalyzeDrift(pTPC, pcstream);
        AnalyzeDriftPos(pTPC, pcstream);
        AnalyzeDriftNeg(pTPC, pcstream);    
        AnalyzeDCARPhi(pTPC, pcstream);
        AnalyzeDCARPhiPos(pTPC, pcstream);
        AnalyzeDCARPhiNeg(pTPC, pcstream);
        AnalyzeEvent(pTPC, pcstream);         

	AnalyzePt(pTPC,pcstream);
	AnalyzeChargeOverPt(pTPC,pcstream); 
	AnalyzeQAPosNegDpT(pTPC,pcstream);
	AnalyzeQADCAFitParameter(pTPC,pcstream);
	AnalyzeOcc(pTPC,pcstream);

        pTPC->GetTPCTrackHisto()->GetAxis(9)->SetRangeUser(-10,10);
        pTPC->GetTPCTrackHisto()->GetAxis(7)->SetRangeUser(0,100);
        pTPC->GetTPCTrackHisto()->GetAxis(5)->SetRangeUser(-10,10); 
    }
    AnalyzeGain(pTPCgain, pcstream);
    AnalyzeMatch(pTPCMatch, pcstream);
    AnalyzePull(pTPCPull, pcstream);
    AnalyzeConstrain(pConstrain, pcstream);
   
    (*pcstream)<<"tpcQA"<<"\n";
}

//_____________________________________________________________________________
void AliTPCPerformanceSummary::WriteToFile(const AliPerformanceTPC* pTPC, const AliPerformanceDEdx* pTPCgain, const AliPerformanceMatch* pMatch,  const AliPerformanceMatch* pPull, const AliPerformanceMatch* pConstrain, const Char_t* outfile, Int_t run)
{
    //
    // Extracts performance parameters from pTPC and pTPCgain.
    // Output is written to a TTree saved in outfile.
    // The run number must be provided since it is not stored in 
    // AliPerformanceTPC or AliPerformanceDEdx.
    //
    // The function creates a TTreeSRedirector and calls the 
    // function WriteToTTreeSRedirector.
    //
    
    if (!outfile) return;
    TTreeSRedirector* pcstream = 0;
    pcstream = new TTreeSRedirector(outfile);
    if (!pcstream) return;
    WriteToTTreeSRedirector(pTPC, pTPCgain, pMatch, pPull, pConstrain, pcstream, run);
    if (pcstream) { delete pcstream; pcstream = 0; }    
    
}

//_____________________________________________________________________________
Int_t AliTPCPerformanceSummary::MakeReport(const Char_t* infile, const Char_t* outfile, Int_t run)
{
    //
    // Reads QA information (AliPerformanceTPC and AliPerformanceDEdx) from
    // infile (this must be a rootfile) and writes the output to a TTree
    // stored in outfile.
    // The run number must be provided since it is not stored in 
    // AliPerformanceTPC or AliPerformanceDEdx.
    // 
    // The input objects must be named "AliPerformanceTPC" and 
    // "AliPerformanceDEdxTPCInner" and stored in a TList which name must
    // be one of the following: "TPC", "TPCQA", "TPC_PerformanceQA"
    // or "TPC_PerformanceQA/TPC" (with directory)
    //
    
    if (!infile) return -1;
    if (!outfile) return -1;
    TFile *f =0;
    f=TFile::Open(infile,"read");
    if (!f) {
        printf("File %s not available\n", infile);
        return -1;
    } 
    TList* list = 0;
    list = dynamic_cast<TList*>(f->Get("TPC")); 
    if (!list) { list = dynamic_cast<TList*>(f->Get("TPCQA")); }
    if (!list) { list = dynamic_cast<TList*>(f->Get("TPC_PerformanceQA/TPCQA")); }
    if (!list) { list = dynamic_cast<TList*>(f->Get("TPC_PerformanceQA")); }
    if (!list) { list = dynamic_cast<TList*>(f->Get("ITSTPCMatch")); }
    if (!list) {
            printf("QA %s not available\n", infile);
            return -1;
    } 
    AliPerformanceTPC* pTPC = 0;
    AliPerformanceDEdx* pTPCgain = 0; 
    AliPerformanceMatch* pTPCmatch = 0; 
    AliPerformanceMatch* pTPCPull = 0; 
    AliPerformanceMatch* pConstrain = 0;
    
    if (list) {  pTPC = dynamic_cast<AliPerformanceTPC*>(list->FindObject("AliPerformanceTPC")); }
    if (list) {  pTPCgain = dynamic_cast<AliPerformanceDEdx*>(list->FindObject("AliPerformanceDEdxTPCInner")); }
    if (list) {  pTPCmatch = dynamic_cast<AliPerformanceMatch*>(list->FindObject("AliPerformanceMatchTPCITS")); }
    if (list) {  pTPCPull = dynamic_cast<AliPerformanceMatch*>(list->FindObject("AliPerformanceMatchITSTPC")); }
    if (list) {  pConstrain = dynamic_cast<AliPerformanceMatch*>(list->FindObject("AliPerformanceMatchTPCConstrain")); }
    
    Int_t returncode = 0;
    WriteToFile(pTPC, pTPCgain, pTPCmatch , pTPCPull, pConstrain, outfile, run);
    if (f) { delete f; f=0; }
    return returncode;
}

//_____________________________________________________________________________
Int_t AliTPCPerformanceSummary::ProduceTrends(const Char_t* infilelist, const Char_t* outfile)
{
    //
    // Produces trend graphs.
    //
    // Input: infilelist is a textfile with one rootfile per line.
    // There should be one rootfile for each run, the rootfile must
    // contain the output of the MakeReport function
    // Output: the information for all runs is merged into a TTree
    // that is saved in outfile along with the trend graphs.
    // Trend graphs are stored as TCanvas objects to include axis labels etc.
    //
    
    if (!infilelist) return -1;
    if (!outfile) return -1;
     
    TChain* chain = new TChain("tpcQA");
    if(!chain) return -1;

    ifstream in;
    in.open(infilelist);

    TString currentFile;    
    while(in.good()) {
        in >> currentFile;

        if (!currentFile.Contains("root")) continue; // protection            
        chain->Add(currentFile.Data());
    }
    in.close();
    //TTree *tree = chain;
    TTree *tree = chain->CopyTree("1");
    if(!tree) return -1;
    if (chain) { delete chain; chain=0; }
    //TGraph* graph = dynamic_cast<TGraph*>(tree->DrawClone("run:run"));
    //TGraph *graph = (TGraph*)gPad->GetPrimitive("Graph");
    
    TFile* out = new TFile(outfile,"RECREATE");
    if(!out) return -1;

    out->cd();
    const Char_t* condition = "meanTPCncl>0";
    SaveGraph(tree,"meanTPCnclF","run",condition);
    SaveGraph(tree,"rmsTPCnclF","run",condition);
    SaveGraph(tree,"meanTPCChi2","run",condition);
    SaveGraph(tree,"rmsTPCChi2","run",condition);
    SaveGraph(tree,"slopeATPCnclF","run",condition);
    SaveGraph(tree,"slopeCTPCnclF","run",condition);
    SaveGraph(tree,"slopeATPCnclFErr","run",condition);
    SaveGraph(tree,"slopeCTPCnclFErr","run",condition);
    SaveGraph(tree,"meanTPCncl","run",condition);
    SaveGraph(tree,"rmsTPCncl","run",condition);
    SaveGraph(tree,"slopeATPCncl","run",condition);
    SaveGraph(tree,"slopeCTPCncl","run",condition);
    SaveGraph(tree,"slopeATPCnclErr","run",condition);
    SaveGraph(tree,"slopeCTPCnclErr","run",condition);
    
    SaveGraph(tree,"offsetdRA","run",condition);
    SaveGraph(tree,"slopedRA","run",condition);
    SaveGraph(tree,"offsetdRC","run",condition);
    SaveGraph(tree,"slopedRC","run",condition);
    SaveGraph(tree,"offsetdRAErr","run",condition);
    SaveGraph(tree,"slopedRAErr","run",condition);    
    SaveGraph(tree,"offsetdRCErr","run",condition);
    SaveGraph(tree,"slopedRCErr","run",condition);
    SaveGraph(tree,"offsetdRAchi2","run",condition);
    SaveGraph(tree,"slopedRAchi2","run",condition);
    SaveGraph(tree,"offsetdRCchi2","run",condition);    
    SaveGraph(tree,"slopedRCchi2","run",condition);    
    
    SaveGraph(tree,"offsetdRAPos","run",condition);
      
    SaveGraph(tree,"slopedRAPos","run",condition);
    SaveGraph(tree,"offsetdRCPos","run",condition);
    SaveGraph(tree,"slopedRCPos","run",condition);
    SaveGraph(tree,"offsetdRAErrPos","run",condition);
    SaveGraph(tree,"slopedRAErrPos","run",condition);
    SaveGraph(tree,"offsetdRCErrPos","run",condition); 
    SaveGraph(tree,"slopedRCErrPos","run",condition);
    SaveGraph(tree,"offsetdRAchi2Pos","run",condition);
    SaveGraph(tree,"slopedRAchi2Pos","run",condition);
    SaveGraph(tree,"offsetdRCchi2Pos","run",condition);
    SaveGraph(tree,"slopedRCchi2Pos","run",condition);
        
    SaveGraph(tree,"offsetdRANeg","run",condition);
    SaveGraph(tree,"slopedRANeg","run",condition);
    SaveGraph(tree,"offsetdRCNeg","run",condition);
    SaveGraph(tree,"slopedRCNeg","run",condition);
    SaveGraph(tree,"offsetdRAErrNeg","run",condition);
    SaveGraph(tree,"slopedRAErrNeg","run",condition);
    SaveGraph(tree,"offsetdRCErrNeg","run",condition);
    SaveGraph(tree,"slopedRCErrNeg","run",condition);
    SaveGraph(tree,"offsetdRAchi2Neg","run",condition);
    SaveGraph(tree,"slopedRAchi2Neg","run",condition);
    SaveGraph(tree,"offsetdRCchi2Neg","run",condition);
    SaveGraph(tree,"slopedRCchi2Neg","run",condition);
        
    SaveGraph(tree,"offsetdZAPos","run",condition);
    SaveGraph(tree,"slopedZAPos","run",condition);
    SaveGraph(tree,"offsetdZCPos","run",condition);
    SaveGraph(tree,"slopedZCPos","run",condition);
    SaveGraph(tree,"offsetdZAErrPos","run",condition);
    SaveGraph(tree,"slopedZAErrPos","run",condition);
    SaveGraph(tree,"offsetdZCErrPos","run",condition);
    SaveGraph(tree,"slopedZCErrPos","run",condition);
    SaveGraph(tree,"offsetdZAchi2Pos","run",condition);
    SaveGraph(tree,"slopedZAchi2Pos","run",condition);
    SaveGraph(tree,"offsetdZCchi2Pos","run",condition);
    SaveGraph(tree,"slopedZCchi2Pos","run",condition);
    
    SaveGraph(tree,"offsetdZANeg","run",condition);
    SaveGraph(tree,"slopedZANeg","run",condition);
    SaveGraph(tree,"offsetdZCNeg","run",condition);
    SaveGraph(tree,"slopedZCNeg","run",condition);
    SaveGraph(tree,"offsetdZAErrNeg","run",condition);
    SaveGraph(tree,"slopedZAErrNeg","run",condition);
    SaveGraph(tree,"offsetdZCErrNeg","run",condition);
    SaveGraph(tree,"slopedZCErrNeg","run",condition);
    SaveGraph(tree,"offsetdZAchi2Neg","run",condition);
    SaveGraph(tree,"slopedZAchi2Neg","run",condition);
    SaveGraph(tree,"offsetdZCchi2Neg","run",condition);
    SaveGraph(tree,"slopedZCchi2Neg","run",condition);    
    
    SaveGraph(tree,"offsetdZA","run",condition);
    SaveGraph(tree,"slopedZA","run",condition);
    SaveGraph(tree,"offsetdZC","run",condition);
    SaveGraph(tree,"slopedZC","run",condition);
    SaveGraph(tree,"offsetdZAErr","run",condition);
    SaveGraph(tree,"slopedZAErr","run",condition);
    SaveGraph(tree,"offsetdZCErr","run",condition);
    SaveGraph(tree,"slopedZCErr","run",condition);
    SaveGraph(tree,"offsetdZAchi2","run",condition);
    SaveGraph(tree,"slopedZAchi2","run",condition);
    SaveGraph(tree,"offsetdZCchi2","run",condition);
    SaveGraph(tree,"slopedZCchi2","run",condition);        

    SaveGraph(tree,"meanVertX","run",condition);
    SaveGraph(tree,"rmsVertX","run",condition);
    SaveGraph(tree,"meanVertY","run",condition);
    SaveGraph(tree,"rmsVertY","run",condition);
    SaveGraph(tree,"meanVertZ","run",condition);
    SaveGraph(tree,"rmsVertZ","run",condition);
    SaveGraph(tree,"vertStatus","run",condition);
    SaveGraph(tree,"meanMult","run",condition);
    SaveGraph(tree,"rmsMult","run",condition);
    SaveGraph(tree,"meanMultPos","run",condition);
    SaveGraph(tree,"rmsMultPos","run",condition);
    SaveGraph(tree,"meanMultNeg","run",condition);
    SaveGraph(tree,"rmsMultNeg","run",condition);
    SaveGraph(tree,"vertAll","run",condition);
    SaveGraph(tree,"vertOK","run",condition);


    SaveGraph(tree,"meanPtAPos","run",condition);
    SaveGraph(tree,"mediumPtAPos","run",condition);
    SaveGraph(tree,"highPtAPos","run",condition);
    SaveGraph(tree,"meanPtCPos","run",condition);
    SaveGraph(tree,"mediumPtCPos","run",condition);
    SaveGraph(tree,"highPtCPos","run",condition);
    SaveGraph(tree,"meanPtANeg","run",condition);
    SaveGraph(tree,"mediumPtANeg","run",condition);
    SaveGraph(tree,"highPtANeg","run",condition);
    SaveGraph(tree,"meanPtCNeg","run",condition);
    SaveGraph(tree,"mediumPtCNeg","run",condition);
    SaveGraph(tree,"highPtCNeg","run",condition);
 
    SaveGraph(tree,"qOverPt","run",condition);
    SaveGraph(tree,"qOverPtA","run",condition);
    SaveGraph(tree,"qOverPtC","run",condition);

    SaveGraph(tree,"dcarAP0","run",condition);
    SaveGraph(tree,"dcarAP1","run",condition);
    SaveGraph(tree,"dcarCP0","run",condition);
    SaveGraph(tree,"dcarCP1","run",condition);

    condition = "";
    SaveGraph(tree,"tpcItsMatchA","run",condition);
    SaveGraph(tree,"tpcItsMatchHighPtA","run",condition);
    SaveGraph(tree,"tpcItsMatchC","run",condition);
    SaveGraph(tree,"tpcItsMatchHighPtC","run",condition);
    
    SaveGraph(tree,"phiPull","run",condition);
    SaveGraph(tree,"phiPullHighPt","run",condition);
    SaveGraph(tree,"ptPull","run",condition);
    SaveGraph(tree,"ptPullHighPt","run",condition);
    SaveGraph(tree,"yPull","run",condition);
    SaveGraph(tree,"yPullHighPt","run",condition);
    SaveGraph(tree,"zPull","run",condition);
    SaveGraph(tree,"zPullHighPt","run",condition);
    SaveGraph(tree,"lambdaPull","run",condition);
    SaveGraph(tree,"lambdaPullHighPt","run",condition);
    
    SaveGraph(tree,"tpcConstrainPhiA","run",condition);
    SaveGraph(tree,"tpcConstrainPhiC","run",condition);
     
    SaveGraph(tree,"deltaPt","run",condition);
    SaveGraph(tree,"deltaPtchi2","run",condition);
    SaveGraph(tree,"deltaPtA","run",condition);
    SaveGraph(tree,"deltaPtchi2A","run",condition);
    SaveGraph(tree,"deltaPtC","run",condition);
    SaveGraph(tree,"deltaPtchi2C","run",condition);
    SaveGraph(tree,"deltaPtA_Err","run",condition);
    SaveGraph(tree,"deltaPtA_Err","run",condition);
    SaveGraph(tree,"deltaPtC_Err","run",condition);
    
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
 //save dca fit parameters
    SaveGraph(tree,"dcar_posA_0","run",condition);
    SaveGraph(tree,"dcar_posA_1","run",condition);
    SaveGraph(tree,"dcar_posA_2","run",condition);
    SaveGraph(tree,"dcar_posA_chi2","run",condition);
    SaveGraph(tree,"dcar_posA_0_Err","run",condition);
    SaveGraph(tree,"dcar_posA_1_Err","run",condition);
    SaveGraph(tree,"dcar_posA_2_Err","run",condition);

    SaveGraph(tree,"dcaz_posA_0","run",condition);
    SaveGraph(tree,"dcaz_posA_1","run",condition);
    SaveGraph(tree,"dcaz_posA_2","run",condition);
    SaveGraph(tree,"dcaz_posA_chi2","run",condition);
    SaveGraph(tree,"dcaz_posA_0_Err","run",condition);
    SaveGraph(tree,"dcaz_posA_1_Err","run",condition);
    SaveGraph(tree,"dcaz_posA_2_Err","run",condition);

    SaveGraph(tree,"dcaz_posC_0","run",condition);
    SaveGraph(tree,"dcaz_posC_1","run",condition);
    SaveGraph(tree,"dcaz_posC_2","run",condition);
    SaveGraph(tree,"dcaz_posC_chi2","run",condition);
    SaveGraph(tree,"dcaz_posC_0_Err","run",condition);
    SaveGraph(tree,"dcaz_posC_1_Err","run",condition);
    SaveGraph(tree,"dcaz_posC_2_Err","run",condition);

    SaveGraph(tree,"dcar_posC_0","run",condition);
    SaveGraph(tree,"dcar_posC_1","run",condition);
    SaveGraph(tree,"dcar_posC_2","run",condition);
    SaveGraph(tree,"dcar_posC_chi2","run",condition);
    SaveGraph(tree,"dcar_posC_0_Err","run",condition);
    SaveGraph(tree,"dcar_posC_1_Err","run",condition);
    SaveGraph(tree,"dcar_posC_2_Err","run",condition);

    SaveGraph(tree,"dcar_negA_0","run",condition);
    SaveGraph(tree,"dcar_negA_1","run",condition);
    SaveGraph(tree,"dcar_negA_2","run",condition);
    SaveGraph(tree,"dcar_negA_chi2","run",condition);
    SaveGraph(tree,"dcar_negA_0_Err","run",condition);
    SaveGraph(tree,"dcar_negA_1_Err","run",condition);
    SaveGraph(tree,"dcar_negA_2_Err","run",condition);

    SaveGraph(tree,"dcaz_negA_0","run",condition);
    SaveGraph(tree,"dcaz_negA_1","run",condition);
    SaveGraph(tree,"dcaz_negA_2","run",condition);
    SaveGraph(tree,"dcaz_negA_chi2","run",condition);
    SaveGraph(tree,"dcaz_negA_0_Err","run",condition);
    SaveGraph(tree,"dcaz_negA_1_Err","run",condition);
    SaveGraph(tree,"dcaz_negA_2_Err","run",condition);
    
    SaveGraph(tree,"dcaz_negC_0","run",condition);
    SaveGraph(tree,"dcaz_negC_1","run",condition);
    SaveGraph(tree,"dcaz_negC_2","run",condition);
    SaveGraph(tree,"dcaz_negC_chi2","run",condition);
    SaveGraph(tree,"dcaz_negC_0_Err","run",condition);
    SaveGraph(tree,"dcaz_negC_1_Err","run",condition);
    SaveGraph(tree,"dcaz_negC_2_Err","run",condition);
    
    SaveGraph(tree,"dcar_negC_0","run",condition);
    SaveGraph(tree,"dcar_negC_1","run",condition);
    SaveGraph(tree,"dcar_negC_2","run",condition);
    SaveGraph(tree,"dcar_negC_chi2","run",condition);
    SaveGraph(tree,"dcar_negC_0_Err","run",condition);
    SaveGraph(tree,"dcar_negC_1_Err","run",condition);
    SaveGraph(tree,"dcar_negC_2_Err","run",condition);

    SaveGraph(tree,"iroc_A_side","run",condition);    
    SaveGraph(tree,"iroc_C_side","run",condition);    
    SaveGraph(tree,"oroc_A_side","run",condition);    
    SaveGraph(tree,"oroc_C_side","run",condition);    

    //A/C side IROC                                                                                                                                                           
    SaveGraph(tree,"TPC_Occ_IROC.","run",condition);
    SaveGraph(tree,"TPC_Occ_OROC.","run",condition);
    ////////////////////////////////////////////////////////////////////////////////////////////////////////

    tree->Write();
    out->Close();   
    if (tree) { delete tree; tree=0; }
    if (out) { delete out; out=0; }
    return 0;
}

//_____________________________________________________________________________
Int_t AliTPCPerformanceSummary::SaveGraph(TTree* tree, const Char_t* y, const Char_t* x, const Char_t* condition)
{    
    //
    // Creates a Graph and writes the canvas to the current directory
    // called by ProduceTrends function.
    //
    
    TString s(y);
    s += ':';
    s += x;
    tree->Draw(s.Data(),condition,"goff");
    TCanvas* c = new TCanvas(s.Data(),s.Data());
    c->cd();
    TPad* p = new TPad("pad0","pad0",0,0,1,1);
    p->Draw();
    p->cd();
    if (tree->GetSelectedRows() > 0) {
      TGraph* graph = new TGraph(tree->GetSelectedRows(), tree->GetV2(), tree->GetV1());
      graph->Draw("AP");
      graph->GetXaxis()->SetTitle(x);
      graph->GetYaxis()->SetTitle(y);
      c->Write(s.Data());
      delete graph;
    }
    //graph->Write(s.Data());
    delete c;
    
return 0;
}

//_____________________________________________________________________________
Int_t AliTPCPerformanceSummary::AnalyzeDCARPhi(const AliPerformanceTPC* pTPC, TTreeSRedirector* const pcstream)
{
    //
    // Analyse DCA R imperfections
    //
    
    if (!pcstream) return 8;
    if (!pTPC) return 8;
        
    // variables:
    static Double_t offsetdRA=0;
    static Double_t slopedRA=0;
    static Double_t offsetdRC=0;
    static Double_t slopedRC=0;
    static Double_t offsetdRAErr=0;
    static Double_t slopedRAErr=0;
    static Double_t offsetdRCErr=0;
    static Double_t slopedRCErr=0;
    static Double_t offsetdRAchi2=0;
    static Double_t slopedRAchi2=0;
    static Double_t offsetdRCchi2=0;
    static Double_t slopedRCchi2=0;
    static Double_t dcarAP0 = 0;
    static Double_t dcarAP1 = 0;
    static Double_t dcarCP0 = 0;
    static Double_t dcarCP1 = 0;

    //AliPerformanceTPC* pTPC =  dynamic_cast<AliPerformanceTPC*>(pTPCObject);    
    
    TH1* his1D=0;
    TH2* his2D=0;
    TH3* his3D=0;
    
    if (pTPC->GetHistos()->FindObject("h_tpc_track_all_recvertex_3_5_7")) {    
        his3D = dynamic_cast<TH3*>(pTPC->GetHistos()->FindObject("h_tpc_track_all_recvertex_3_5_7"));
        if(!his3D) return 8;
        his3D->GetYaxis()->SetRangeUser(-1,1);
        his3D->GetZaxis()->SetRangeUser(0.25,10);
    }
    
    static TF1 *fpol1 = new TF1("fpol1","pol1");
    TObjArray arrayFit;
    if (his3D && !fgForceTHnSparse) { 
        his2D = dynamic_cast<TH2*>(his3D->Project3D("xy")); 
    } else {    
        his2D = pTPC->GetTPCTrackHisto()->Projection(3,5);
    }            
    if(!his2D) return 8;

    
    his2D->FitSlicesY(0,0,-1,10,"QNR",&arrayFit);
    delete his2D;
    his1D = (TH1*) arrayFit.At(1);
    his1D->Fit(fpol1,"QNRROB=0.8","QNR",-0.8,-0.1);
    offsetdRC=fpol1->GetParameter(0);
    slopedRC=fpol1->GetParameter(1);
    offsetdRCchi2=fpol1->GetChisquare();
    slopedRCchi2=fpol1->GetChisquare();
    //
    his1D->Fit(fpol1,"QNRROB=0.8","QNR",0.1,0.8);
    offsetdRA=fpol1->GetParameter(0);
    slopedRA=fpol1->GetParameter(1);
    offsetdRAErr=fpol1->GetParError(0);
    slopedRAErr=fpol1->GetParError(1);
    offsetdRAchi2=fpol1->GetChisquare();
    slopedRAchi2=fpol1->GetChisquare();
    //
    printf("DCA R QA report\n");
    printf("offsetdRA\t%f\n",offsetdRA);
    printf("slopedRA\t%f\n",slopedRA);
    printf("offsetdRC\t%f\n",offsetdRC);
    printf("slopedRC\t%f\n",slopedRC);

    //
    //extraction of DCAr versus pt
    //
    TLinearFitter linearFit;
    linearFit.SetFormula("pol1");
    TObjArray arrayWidth;  
    TH1 *width;
    Int_t nXbins;
    Double_t x,y;
    Int_t pn = 1;

    if(!his3D)
      return 8;
    his3D->GetYaxis()->SetRangeUser(-1,1);

    //get his2D in A Side
    his3D->GetYaxis()->SetRangeUser(0,1);
    his3D->GetZaxis()->SetRangeUser(0.35,8);
    his2D  = dynamic_cast<TH2*>(his3D->Project3D("xz"));
    if (his2D)
      his2D->FitSlicesY(0,0,-1,0,"QNR",&arrayWidth);

    width =  dynamic_cast<TH1*>(arrayWidth.At(2));
    if (width) 
    {
      nXbins = width->GetNbinsX();
    for(Int_t i=2; i<nXbins; i++){
      x = width->GetBinCenter(i);
      if(x!=0)
	x = 1.0/(x*x);
      y = width->GetBinContent(i);
      y = y*y;
      linearFit.AddPoint(&x,y,1);
    }
    if(!linearFit.Eval()){
      
      dcarAP0 = linearFit.GetParameter(0);
      if(dcarAP0!=0)
	pn = Int_t(TMath::Abs(dcarAP0)/dcarAP0);
      dcarAP0 = pn*TMath::Sqrt(TMath::Abs(dcarAP0));

      dcarAP1 = linearFit.GetParameter(1);
      if(dcarAP1!=0)
	pn = Int_t(TMath::Abs(dcarAP1)/dcarAP1);
      dcarAP1 = pn*TMath::Sqrt(TMath::Abs(dcarAP1));
    }
    }

    linearFit.ClearPoints();
    
    //get his2D in C Side
    his3D->GetYaxis()->SetRangeUser(-1,-0.001);
    his2D  = dynamic_cast<TH2*>(his3D->Project3D("xz"));
    if (his2D)
      his2D->FitSlicesY(0,0,-1,0,"QNR",&arrayWidth);
      width =  dynamic_cast<TH1*>(arrayWidth.At(2));
    if (width) 
    {
      nXbins = width->GetNbinsX();
    for(Int_t i=2; i<nXbins; i++){
      x = width->GetBinCenter(i);
      if(x!=0)
	x = 1.0/(x*x);
      y = width->GetBinContent(i);
      y = y*y;
      linearFit.AddPoint(&x,y);
    }
    if(!linearFit.Eval()){
      dcarCP0 = linearFit.GetParameter(0);
      if(dcarCP0!=0)
	pn = Int_t(TMath::Abs(dcarCP0)/dcarCP0);
      dcarCP0 = pn*TMath::Sqrt(TMath::Abs(dcarCP0));

      dcarCP1 = linearFit.GetParameter(1);
      if(dcarCP1!=0)
	pn = Int_t(TMath::Abs(dcarCP1)/dcarCP1);
      dcarCP1 = pn*TMath::Sqrt(TMath::Abs(dcarCP1));
    }
    }
    his3D->GetYaxis()->SetRangeUser(-1,1);
    his3D->GetZaxis()->SetRangeUser(0,20);

    //
    // dump values
    //
    (*pcstream)<<"tpcQA"<<
        "offsetdRA="<< offsetdRA<<
        "slopedRA="<< slopedRA<<
        "offsetdRC="<< offsetdRC<<
        "slopedRC="<<slopedRC<<
        //
        "offsetdRAErr="<< offsetdRAErr<<
        "slopedRAErr="<< slopedRAErr<<
        "offsetdRCErr="<< offsetdRCErr<<
        "slopedRCErr="<<slopedRCErr<<
        //
        "offsetdRAchi2="<< offsetdRAchi2<<
        "slopedRAchi2="<< slopedRAchi2<<
        "offsetdRCchi2="<< offsetdRCchi2<<
        "slopedRCchi2="<<slopedRCchi2<<
        //
        "dcarAP0="<<dcarAP0<<
        "dcarAP1="<<dcarAP1<<
        "dcarCP0="<<dcarCP0<<
        "dcarCP1="<<dcarCP1;
        
    return 0;
}

//_____________________________________________________________________________
Int_t AliTPCPerformanceSummary::AnalyzeDCARPhiPos(const AliPerformanceTPC* pTPC, TTreeSRedirector* const pcstream)
{
    //
    // Analyse DCA R imperfections for positive particles
    //
    
    if (!pcstream) return 16;
    if (!pTPC) return 16;

    // variables:
    static Double_t offsetdRAPos=0;
    static Double_t slopedRAPos=0;
    static Double_t offsetdRCPos=0;
    static Double_t slopedRCPos=0;
    static Double_t offsetdRAErrPos=0;
    static Double_t slopedRAErrPos=0;
    static Double_t offsetdRCErrPos=0;
    static Double_t slopedRCErrPos=0;
    static Double_t offsetdRAchi2Pos=0;
    static Double_t slopedRAchi2Pos=0;
    static Double_t offsetdRCchi2Pos=0;
    static Double_t slopedRCchi2Pos=0;

    //AliPerformanceTPC* pTPC =  dynamic_cast<AliPerformanceTPC*>(pTPCObject);    
    TH1* his1D=0;
    TH2* his2D=0;
    TH3* his3D=0;
    
    if (pTPC->GetHistos()->FindObject("h_tpc_track_pos_recvertex_3_5_7")) {    
        his3D = dynamic_cast<TH3*>(pTPC->GetHistos()->FindObject("h_tpc_track_pos_recvertex_3_5_7"));
        if(!his3D) return 16;
        his3D->GetYaxis()->SetRangeUser(-1,1);
        his3D->GetZaxis()->SetRangeUser(0.25,10);
    }
    
    static TF1 *fpol1 = new TF1("fpol1","pol1");
    TObjArray arrayFit;
    if (his3D && !fgForceTHnSparse) { 
        his2D = dynamic_cast<TH2*>(his3D->Project3D("xy")); 
    } else {    
        pTPC->GetTPCTrackHisto()->GetAxis(8)->SetRangeUser(0,1.5);        
        his2D = pTPC->GetTPCTrackHisto()->Projection(3,5);
        pTPC->GetTPCTrackHisto()->GetAxis(8)->SetRangeUser(-1.5,1.5);
    }            
    if(!his2D) return 16;
    
    his2D->FitSlicesY(0,0,-1,10,"QNR",&arrayFit);
    delete his2D;    
    his1D = (TH1*) arrayFit.At(1);
    his1D->Fit(fpol1,"QNRROB=0.8","QNR",-0.8,-0.1);
    offsetdRCPos=fpol1->GetParameter(0);
    slopedRCPos=fpol1->GetParameter(1);
    offsetdRCchi2Pos=fpol1->GetChisquare();
    slopedRCchi2Pos=fpol1->GetChisquare();
    //
    his1D->Fit(fpol1,"QNRROB=0.8","QNR",0.1,0.8);
    offsetdRAPos=fpol1->GetParameter(0);
    slopedRAPos=fpol1->GetParameter(1);
    offsetdRAErrPos=fpol1->GetParError(0);
    slopedRAErrPos=fpol1->GetParError(1);
    offsetdRAchi2Pos=fpol1->GetChisquare();
    slopedRAchi2Pos=fpol1->GetChisquare();
    //
    printf("DCA R QA Pos report\n");
    printf("offsetdRAPos\t%f\n",offsetdRAPos);
    printf("slopedRAPos\t%f\n",slopedRAPos);
    printf("offsetdRCPos\t%f\n",offsetdRCPos);
    printf("slopedRCPos\t%f\n",slopedRCPos);
    //
    // dump values
    //
    (*pcstream)<<"tpcQA"<<
        "offsetdRAPos="<< offsetdRAPos<<
        "slopedRAPos="<< slopedRAPos<<
        "offsetdRCPos="<< offsetdRCPos<<
        "slopedRCPos="<<slopedRCPos<<
        //
        "offsetdRAErrPos="<< offsetdRAErrPos<<
        "slopedRAErrPos="<< slopedRAErrPos<<
        "offsetdRCErrPos="<< offsetdRCErrPos<<
        "slopedRCErrPos="<<slopedRCErrPos<<
        //
        "offsetdRAchi2Pos="<< offsetdRAchi2Pos<<
        "slopedRAchi2Pos="<< slopedRAchi2Pos<<
        "offsetdRCchi2Pos="<< offsetdRCchi2Pos<<
        "slopedRCchi2Pos="<<slopedRCchi2Pos;
        
    return 0;
}

//_____________________________________________________________________________
Int_t AliTPCPerformanceSummary::AnalyzeDCARPhiNeg(const AliPerformanceTPC* pTPC, TTreeSRedirector* const pcstream)
{
    //
    // Analyse DCA R imperfections for negative particles
    //
    if (!pcstream) return 32;
    if (!pTPC) return 32;

    // variables:
    static Double_t offsetdRANeg=0;
    static Double_t slopedRANeg=0;
    static Double_t offsetdRCNeg=0;
    static Double_t slopedRCNeg=0;
    static Double_t offsetdRAErrNeg=0;
    static Double_t slopedRAErrNeg=0;
    static Double_t offsetdRCErrNeg=0;
    static Double_t slopedRCErrNeg=0;
    static Double_t offsetdRAchi2Neg=0;
    static Double_t slopedRAchi2Neg=0;
    static Double_t offsetdRCchi2Neg=0;
    static Double_t slopedRCchi2Neg=0;

    //AliPerformanceTPC* pTPC =  dynamic_cast<AliPerformanceTPC*>(pTPCObject);    
    TH1* his1D=0;
    TH2* his2D=0;
    TH3* his3D=0;
    
    if (pTPC->GetHistos()->FindObject("h_tpc_track_neg_recvertex_3_5_7")) {    
        his3D = dynamic_cast<TH3*>(pTPC->GetHistos()->FindObject("h_tpc_track_neg_recvertex_3_5_7"));
	if(!his3D) return 32;
        his3D->GetYaxis()->SetRangeUser(-1,1);
        his3D->GetZaxis()->SetRangeUser(0.25,10);
    }
    
    static TF1 *fpol1 = new TF1("fpol1","pol1");
    TObjArray arrayFit;
    if (his3D && !fgForceTHnSparse) {
        his2D = dynamic_cast<TH2*>(his3D->Project3D("xy")); 
    } else {    
        pTPC->GetTPCTrackHisto()->GetAxis(8)->SetRangeUser(-1.5,0);        
        his2D = pTPC->GetTPCTrackHisto()->Projection(3,5);
        pTPC->GetTPCTrackHisto()->GetAxis(8)->SetRangeUser(-1.5,1.5);
    }            
    if(!his2D) return 32;

    his2D->FitSlicesY(0,0,-1,10,"QNR",&arrayFit);
    delete his2D;    
    his1D = (TH1*) arrayFit.At(1);
    his1D->Fit(fpol1,"QNRROB=0.8","QNR",-0.8,-0.1);
    offsetdRCNeg=fpol1->GetParameter(0);
    slopedRCNeg=fpol1->GetParameter(1);
    offsetdRCchi2Neg=fpol1->GetChisquare();
    slopedRCchi2Neg=fpol1->GetChisquare();
    //
    his1D->Fit(fpol1,"QNRROB=0.8","QNR",0.1,0.8);
    offsetdRANeg=fpol1->GetParameter(0);
    slopedRANeg=fpol1->GetParameter(1);
    offsetdRAErrNeg=fpol1->GetParError(0);
    slopedRAErrNeg=fpol1->GetParError(1);
    offsetdRAchi2Neg=fpol1->GetChisquare();
    slopedRAchi2Neg=fpol1->GetChisquare();
    //
    printf("DCA R QA Neg report\n");
    printf("offsetdRANeg\t%f\n",offsetdRANeg);
    printf("slopedRANeg\t%f\n",slopedRANeg);
    printf("offsetdRCNeg\t%f\n",offsetdRCNeg);
    printf("slopedRCNeg\t%f\n",slopedRCNeg);
    //
    // dump drift QA values
    //
    (*pcstream)<<"tpcQA"<<
        "offsetdRANeg="<< offsetdRANeg<<
        "slopedRANeg="<< slopedRANeg<<
        "offsetdRCNeg="<< offsetdRCNeg<<
        "slopedRCNeg="<<slopedRCNeg<<
        //
        "offsetdRAErrNeg="<< offsetdRAErrNeg<<
        "slopedRAErrNeg="<< slopedRAErrNeg<<
        "offsetdRCErrNeg="<< offsetdRCErrNeg<<
        "slopedRCErrNeg="<<slopedRCErrNeg<<
        //
        "offsetdRAchi2Neg="<< offsetdRAchi2Neg<<
        "slopedRAchi2Neg="<< slopedRAchi2Neg<<
        "offsetdRCchi2Neg="<< offsetdRCchi2Neg<<
        "slopedRCchi2Neg="<<slopedRCchi2Neg;
        
    return 0;
}

//_____________________________________________________________________________
Int_t AliTPCPerformanceSummary::AnalyzeNCL(const AliPerformanceTPC* pTPC, TTreeSRedirector* const pcstream)
{
    //
    // Analyse number of TPC clusters 
    //
    
    if (!pcstream) return 1;
    if (!pTPC) return 1;
 
    // variables:
    static Double_t meanTPCnclF=0;
    static Double_t rmsTPCnclF=0;
    static Double_t meanTPCChi2=0;
    static Double_t rmsTPCChi2=0;  
    static Double_t slopeATPCnclF=0;
    static Double_t slopeCTPCnclF=0;
    static Double_t slopeATPCnclFErr=0;
    static Double_t slopeCTPCnclFErr=0;
    static Double_t meanTPCncl=0;
    static Double_t rmsTPCncl=0;
    static Double_t slopeATPCncl=0;
    static Double_t slopeCTPCncl=0;
    static Double_t slopeATPCnclErr=0;
    static Double_t slopeCTPCnclErr=0;  
    //
    TH1* his1D=0;
    TH3* his3D0=0;
    TH3* his3D1=0;
    TH3* his3D2=0;
    TProfile* hprof=0;
    static TF1 *fpol1 = new TF1("fpol1","pol1");
    //
    // all clusters
    // only events with rec. vertex
    // eta cut - +-1
    // pt cut  - 0.250 GeV
    pTPC->GetTPCTrackHisto()->GetAxis(5)->SetRangeUser(-1.,1.);
    pTPC->GetTPCTrackHisto()->GetAxis(7)->SetRangeUser(0.25,10);
    
    if (pTPC->GetHistos()->FindObject("h_tpc_track_all_recvertex_0_5_7")) {    
        his3D0 = dynamic_cast<TH3*>(pTPC->GetHistos()->FindObject("h_tpc_track_all_recvertex_0_5_7"));
        if(!his3D0) return 1;
        his3D0->GetYaxis()->SetRangeUser(-1,1);
        his3D0->GetZaxis()->SetRangeUser(0.25,10);
    }
    if (pTPC->GetHistos()->FindObject("h_tpc_track_all_recvertex_1_5_7")) {    
        his3D1 = dynamic_cast<TH3*>(pTPC->GetHistos()->FindObject("h_tpc_track_all_recvertex_1_5_7"));
        if(!his3D1) return 1;
        his3D1->GetYaxis()->SetRangeUser(-1,1);
        his3D1->GetZaxis()->SetRangeUser(0.25,10);
    }
    if (pTPC->GetHistos()->FindObject("h_tpc_track_all_recvertex_2_5_7")) {    
        his3D2 = dynamic_cast<TH3*>(pTPC->GetHistos()->FindObject("h_tpc_track_all_recvertex_2_5_7"));
        if(!his3D2) return 1;
        his3D2->GetYaxis()->SetRangeUser(-1,1);
        his3D2->GetZaxis()->SetRangeUser(0.25,10);
        his3D2->GetXaxis()->SetRangeUser(0.4,1.1);        
    }    
    

    if (his3D0 && !fgForceTHnSparse) { 
         his1D = his3D0->Project3D("x"); 
    } else {
         his1D = pTPC->GetTPCTrackHisto()->Projection(0);
    }
 
    meanTPCncl= his1D->GetMean();
    rmsTPCncl= his1D->GetRMS();
    delete his1D;
    
    if (his3D1 && !fgForceTHnSparse) {
         his1D = his3D1->Project3D("x"); 
    } else {
         his1D = pTPC->GetTPCTrackHisto()->Projection(1);
    }
          
    meanTPCChi2= his1D->GetMean();
    rmsTPCChi2= his1D->GetRMS();
    delete his1D;  
    
   if (his3D0 && !fgForceTHnSparse) {
        hprof = (dynamic_cast<TH2*>(his3D0->Project3D("xy")))->ProfileX(); 
    } else {
        hprof = pTPC->GetTPCTrackHisto()->Projection(0,5)->ProfileX();
    }
    if(!hprof) return 1;
    
    hprof->Fit(fpol1,"QNR","QNR",0.1,0.8);
    slopeATPCncl= fpol1->GetParameter(1);
    slopeATPCnclErr= fpol1->GetParError(1);
    hprof->Fit(fpol1,"QNR","QNR",-0.8,-0.1);
    slopeCTPCncl= fpol1->GetParameter(1);
    slopeCTPCnclErr= fpol1->GetParameter(1);
    delete hprof;
    
    //
    // findable clusters
    //
    
   if (his3D2 && !fgForceTHnSparse) {
        his1D = his3D2->Project3D("x"); 
    } else {    
        pTPC->GetTPCTrackHisto()->GetAxis(2)->SetRangeUser(0.4,1.1);
        his1D = pTPC->GetTPCTrackHisto()->Projection(2);
    }    
        
    meanTPCnclF= his1D->GetMean();
    rmsTPCnclF= his1D->GetRMS();
    delete his1D;
    
   if (his3D2 && !fgForceTHnSparse) { 
         his1D = (dynamic_cast<TH2*>(his3D2->Project3D("xy")))->ProfileX(); 
    } else {    
        pTPC->GetTPCTrackHisto()->GetAxis(2)->SetRangeUser(0.4,1.1);
        his1D = pTPC->GetTPCTrackHisto()->Projection(2,5)->ProfileX();
    }      
    if(!his1D) return 1;
    
    his1D->Fit(fpol1,"QNR","QNR",0.1,0.8);
    slopeATPCnclF= fpol1->GetParameter(1);
    slopeATPCnclFErr= fpol1->GetParError(1);
    his1D->Fit(fpol1,"QNR","QNR",-0.8,-0.1);
    slopeCTPCnclF= fpol1->GetParameter(1);
    slopeCTPCnclFErr= fpol1->GetParameter(1);
    delete his1D;
        
    pTPC->GetTPCTrackHisto()->GetAxis(2)->SetRangeUser(0,10);
    
    printf("Cluster QA report\n");
    printf("meanTPCnclF=\t%f\n",meanTPCnclF);
    printf("rmsTPCnclF=\t%f\n",rmsTPCnclF);
    printf("slopeATPCnclF=\t%f\n",slopeATPCnclF);
    printf("slopeCTPCnclF=\t%f\n",slopeCTPCnclF);
    printf("meanTPCncl=\t%f\n",meanTPCncl);
    printf("rmsTPCncl=\t%f\n",rmsTPCncl);
    printf("slopeATPCncl=\t%f\n",slopeATPCncl);
    printf("slopeCTPCncl=\t%f\n",slopeCTPCncl);
    printf("meanTPCChi2=\t%f\n",meanTPCChi2);
    printf("rmsTPCChi2=\t%f\n",rmsTPCChi2);
    //
    // dump results to the tree
    //
    (*pcstream)<<"tpcQA"<<
      "meanTPCnclF="<<meanTPCnclF <<   
      "rmsTPCnclF="<<rmsTPCnclF <<
      "meanTPCChi2="<<meanTPCChi2 <<
      "rmsTPCChi2="<<rmsTPCChi2 <<
      "slopeATPCnclF="<< slopeATPCnclF<<
      "slopeCTPCnclF="<< slopeCTPCnclF<<
      "slopeATPCnclFErr="<< slopeATPCnclFErr<<
      "slopeCTPCnclFErr="<< slopeCTPCnclFErr<<
      "meanTPCncl="<<meanTPCncl <<
      "rmsTPCncl="<< rmsTPCncl<<
      "slopeATPCncl="<< slopeATPCncl<<
      "slopeCTPCncl="<< slopeCTPCncl<<
      "slopeATPCnclErr="<< slopeATPCnclErr<<
      "slopeCTPCnclErr="<< slopeCTPCnclErr;
    
    return 0;
}

//_____________________________________________________________________________
Int_t AliTPCPerformanceSummary::AnalyzeDrift(const AliPerformanceTPC* pTPC, TTreeSRedirector* const pcstream)
{
    //
    // Analyse DCA Z imperferctions (drift velocity)
    //
    
    if (!pcstream) return 2;
    if (!pTPC) return 2;

    // variables:
    static Double_t offsetdZA=0;
    static Double_t slopedZA=0;
    static Double_t offsetdZC=0;
    static Double_t slopedZC=0;
    static Double_t offsetdZAErr=0;
    static Double_t slopedZAErr=0;
    static Double_t offsetdZCErr=0;
    static Double_t slopedZCErr=0;
    static Double_t offsetdZAchi2=0;
    static Double_t slopedZAchi2=0;
    static Double_t offsetdZCchi2=0;
    static Double_t slopedZCchi2=0;
    TH1* his1D=0;
    TH2* his2D=0;
    TH3* his3D=0;
    
   if (pTPC->GetHistos()->FindObject("h_tpc_track_all_recvertex_4_5_7")) {    
        his3D = dynamic_cast<TH3*>(pTPC->GetHistos()->FindObject("h_tpc_track_all_recvertex_4_5_7"));
        if(!his3D) return 2;
        his3D->GetYaxis()->SetRangeUser(-1,1);
        his3D->GetZaxis()->SetRangeUser(0.25,10);
   }

   if (his3D && !fgForceTHnSparse) { 
        his2D = dynamic_cast<TH2*>(his3D->Project3D("xy")); 
    } else {    
        his2D = pTPC->GetTPCTrackHisto()->Projection(4,5);
    }        
    if(!his2D) return 2;
    
    static TF1 *fpol1 = new TF1("fpol1","pol1");
    TObjArray arrayFit;
    his2D->FitSlicesY(0,0,-1,10,"QNR",&arrayFit);
    delete his2D;
    his1D = (TH1*) arrayFit.At(1);
    his1D->Fit(fpol1,"QNRROB=0.8","QNR",-0.8,-0.1);
    offsetdZC=fpol1->GetParameter(0);
    slopedZC=fpol1->GetParameter(1);
    offsetdZCErr=fpol1->GetParError(0);
    slopedZCErr=fpol1->GetParError(1);        
    offsetdZCchi2=fpol1->GetChisquare();
    slopedZCchi2=fpol1->GetChisquare();
    //
    his1D->Fit(fpol1,"QNRROB=0.8","QNR",0.1,0.8);
    offsetdZA=fpol1->GetParameter(0);
    slopedZA=fpol1->GetParameter(1);
    offsetdZAErr=fpol1->GetParError(0);
    slopedZAErr=fpol1->GetParError(1);
    offsetdZAchi2=fpol1->GetChisquare();
    slopedZAchi2=fpol1->GetChisquare();
    //
    printf("Drift velocity QA report\n");
    printf("offsetdZA\t%f\n",offsetdZA);
    printf("slopedZA\t%f\n",slopedZA);
    printf("offsetdZC\t%f\n",offsetdZC);
    printf("slopedZC\t%f\n",slopedZC);
    //
    // dump drift QA values
    //
    (*pcstream)<<"tpcQA"<<
        "offsetdZA="<< offsetdZA<<
        "slopedZA="<< slopedZA<<
        "offsetdZC="<< offsetdZC<<
        "slopedZC="<<slopedZC<<
        //
        "offsetdZAErr="<< offsetdZAErr<<
        "slopedZAErr="<< slopedZAErr<<
        "offsetdZCErr="<< offsetdZCErr<<
        "slopedZCErr="<<slopedZCErr<<
        //
        "offsetdZAchi2="<< offsetdZAchi2<<
        "slopedZAchi2="<< slopedZAchi2<<
        "offsetdZCchi2="<< offsetdZCchi2<<
        "slopedZCchi2="<<slopedZCchi2;
    
    return 0;
}

//_____________________________________________________________________________
Int_t AliTPCPerformanceSummary::AnalyzeDriftPos(const AliPerformanceTPC* pTPC, TTreeSRedirector* const pcstream)
{
    //
    // Analyse DCA Z imperferctions (drift velocity)
    // for positive particles
    //
    if (!pcstream) return 64;
    if (!pTPC) return 64;
        
    // variables:
    static Double_t offsetdZAPos=0;
    static Double_t slopedZAPos=0;
    static Double_t offsetdZCPos=0;
    static Double_t slopedZCPos=0;
    static Double_t offsetdZAErrPos=0;
    static Double_t slopedZAErrPos=0;
    static Double_t offsetdZCErrPos=0;
    static Double_t slopedZCErrPos=0;
    static Double_t offsetdZAchi2Pos=0;
    static Double_t slopedZAchi2Pos=0;
    static Double_t offsetdZCchi2Pos=0;
    static Double_t slopedZCchi2Pos=0;
    TH1* his1D=0;
    TH2* his2D=0;
    TH3* his3D=0;
    
   if (pTPC->GetHistos()->FindObject("h_tpc_track_pos_recvertex_4_5_7")) {    
        his3D = dynamic_cast<TH3*>(pTPC->GetHistos()->FindObject("h_tpc_track_pos_recvertex_4_5_7"));
        if(!his3D) return 64;
        his3D->GetYaxis()->SetRangeUser(-1,1);
        his3D->GetZaxis()->SetRangeUser(0.25,10);
    } 

    if (his3D && !fgForceTHnSparse) { 
        his2D = dynamic_cast<TH2*>(his3D->Project3D("xy")); 
    } else {    
        his2D = pTPC->GetTPCTrackHisto()->Projection(4,5);
    }            
    if(!his2D) return 64;
    
    static TF1 *fpol1 = new TF1("fpol1","pol1");
    TObjArray arrayFit;
    his2D->FitSlicesY(0,0,-1,10,"QNR",&arrayFit);
    delete his2D;
    
    his1D = (TH1*) arrayFit.At(1);
    his1D->Fit(fpol1,"QNRROB=0.8","QNR",-0.8,-0.1);
    offsetdZCPos=fpol1->GetParameter(0);
    slopedZCPos=fpol1->GetParameter(1);
    offsetdZCErrPos=fpol1->GetParError(0);
    slopedZCErrPos=fpol1->GetParError(1);        
    offsetdZCchi2Pos=fpol1->GetChisquare();
    slopedZCchi2Pos=fpol1->GetChisquare();
    //
    his1D->Fit(fpol1,"QNRROB=0.8","QNR",0.1,0.8);
    offsetdZAPos=fpol1->GetParameter(0);
    slopedZAPos=fpol1->GetParameter(1);
    offsetdZAErrPos=fpol1->GetParError(0);
    slopedZAErrPos=fpol1->GetParError(1);
    offsetdZAchi2Pos=fpol1->GetChisquare();
    slopedZAchi2Pos=fpol1->GetChisquare();
    //
    printf("Drift velocity QA report\n");
    printf("offsetdZAPos\t%f\n",offsetdZAPos);
    printf("slopedZAPos\t%f\n",slopedZAPos);
    printf("offsetdZCPos\t%f\n",offsetdZCPos);
    printf("slopedZCPos\t%f\n",slopedZCPos);
    //
    // dump drift QA values
    //
    (*pcstream)<<"tpcQA"<<
        "offsetdZAPos="<< offsetdZAPos<<
        "slopedZAPos="<< slopedZAPos<<
        "offsetdZCPos="<< offsetdZCPos<<
        "slopedZCPos="<<slopedZCPos<<
        //
        "offsetdZAErrPos="<< offsetdZAErrPos<<
        "slopedZAErrPos="<< slopedZAErrPos<<
        "offsetdZCErrPos="<< offsetdZCErrPos<<
        "slopedZCErrPos="<<slopedZCErrPos<<
        //
        "offsetdZAchi2Pos="<< offsetdZAchi2Pos<<
        "slopedZAchi2Pos="<< slopedZAchi2Pos<<
        "offsetdZCchi2Pos="<< offsetdZCchi2Pos<<
        "slopedZCchi2Pos="<<slopedZCchi2Pos;
        
    return 0;
}

//_____________________________________________________________________________
Int_t AliTPCPerformanceSummary::AnalyzeDriftNeg(const AliPerformanceTPC* pTPC, TTreeSRedirector* const pcstream)
{
    //
    // Analyse DCA Z imperferctions (drift velocity)
    // for negative particles
    //
    if (!pcstream) return 128;
    if (!pTPC) return 128;
            
    // variables:
    static Double_t offsetdZANeg=0;
    static Double_t slopedZANeg=0;
    static Double_t offsetdZCNeg=0;
    static Double_t slopedZCNeg=0;
    static Double_t offsetdZAErrNeg=0;
    static Double_t slopedZAErrNeg=0;
    static Double_t offsetdZCErrNeg=0;
    static Double_t slopedZCErrNeg=0;
    static Double_t offsetdZAchi2Neg=0;
    static Double_t slopedZAchi2Neg=0;
    static Double_t offsetdZCchi2Neg=0;
    static Double_t slopedZCchi2Neg=0;
    TH1* his1D=0;
    TH2* his2D=0;
    TH3* his3D=0;
    
    
   if (pTPC->GetHistos()->FindObject("h_tpc_track_neg_recvertex_4_5_7")) {    
        his3D = dynamic_cast<TH3*>(pTPC->GetHistos()->FindObject("h_tpc_track_neg_recvertex_4_5_7"));
        if(!his3D) return 128;
        his3D->GetYaxis()->SetRangeUser(-1,1);
        his3D->GetZaxis()->SetRangeUser(0.25,10);
    }
    if (his3D && !fgForceTHnSparse) { 
        his2D = dynamic_cast<TH2*>(his3D->Project3D("xy")); 
    } else {    
        his2D = pTPC->GetTPCTrackHisto()->Projection(4,5);
    }                
    if(!his2D) return 128;
    
    static TF1 *fpol1 = new TF1("fpol1","pol1");
    TObjArray arrayFit;
    his2D->FitSlicesY(0,0,-1,10,"QNR",&arrayFit);
    delete his2D;
    
    his1D = (TH1*) arrayFit.At(1);
    his1D->Fit(fpol1,"QNRROB=0.8","QNR",-0.8,-0.1);
    offsetdZCNeg=fpol1->GetParameter(0);
    slopedZCNeg=fpol1->GetParameter(1);
    offsetdZCErrNeg=fpol1->GetParError(0);
    slopedZCErrNeg=fpol1->GetParError(1);        
    offsetdZCchi2Neg=fpol1->GetChisquare();
    slopedZCchi2Neg=fpol1->GetChisquare();
    //
    his1D->Fit(fpol1,"QNRROB=0.8","QNR",0.1,0.8);
    offsetdZANeg=fpol1->GetParameter(0);
    slopedZANeg=fpol1->GetParameter(1);
    offsetdZAErrNeg=fpol1->GetParError(0);
    slopedZAErrNeg=fpol1->GetParError(1);
    offsetdZAchi2Neg=fpol1->GetChisquare();
    slopedZAchi2Neg=fpol1->GetChisquare();
    //
    printf("Drift velocity QA report\n");
    printf("offsetdZANeg\t%f\n",offsetdZANeg);
    printf("slopedZANeg\t%f\n",slopedZANeg);
    printf("offsetdZCNeg\t%f\n",offsetdZCNeg);
    printf("slopedZCNeg\t%f\n",slopedZCNeg);
    //
    // dump drift QA values
    //
    (*pcstream)<<"tpcQA"<<
        "offsetdZANeg="<< offsetdZANeg<<
        "slopedZANeg="<< slopedZANeg<<
        "offsetdZCNeg="<< offsetdZCNeg<<
        "slopedZCNeg="<<slopedZCNeg<<
        //
        "offsetdZAErrNeg="<< offsetdZAErrNeg<<
        "slopedZAErrNeg="<< slopedZAErrNeg<<
        "offsetdZCErrNeg="<< offsetdZCErrNeg<<
        "slopedZCErrNeg="<<slopedZCErrNeg<<
        //
        "offsetdZAchi2Neg="<< offsetdZAchi2Neg<<
        "slopedZAchi2Neg="<< slopedZAchi2Neg<<
        "offsetdZCchi2Neg="<< offsetdZCchi2Neg<<
        "slopedZCchi2Neg="<<slopedZCchi2Neg;
    
    return 0;
}

//_____________________________________________________________________________
Int_t AliTPCPerformanceSummary::AnalyzeGain(const AliPerformanceDEdx* pTPCgain, TTreeSRedirector* const pcstream)
{
    //
    // Analyse Gain
    //
    
    if (!pcstream) return 4;
    if (!pTPCgain) return 4;

    static TVectorD meanMIPvsSector(36);
    static TVectorD sector(36);
    static Float_t meanMIP = 0;
    static Float_t resolutionMIP = 0;
    static Float_t attachSlopeC = 0;
    static Float_t attachSlopeA = 0;
    static Float_t meanMIPele = 0;
    static Float_t resolutionMIPele = 0;
    static Float_t electroMIPSeparation = 0;
    
    TH1 * his1D = 0;
    //TH1 * hisProj1D=0;
    TH2* his2D=0;
     
    meanMIPvsSector.Zero();
    //
    // select MIP particles
    //
    pTPCgain->GetDeDxHisto()->GetAxis(7)->SetRangeUser(0.4,0.55);
    pTPCgain->GetDeDxHisto()->GetAxis(0)->SetRangeUser(35,60);
    pTPCgain->GetDeDxHisto()->GetAxis(6)->SetRangeUser(80,160);
    pTPCgain->GetDeDxHisto()->GetAxis(5)->SetRangeUser(-1,1);
    //
    // MIP position and resolution
    //    
    TF1 gausFit("gausFit","gaus");
   
    if (pTPCgain->GetHistos()->FindObject("h_tpc_dedx_mips_0") && !fgForceTHnSparse) {    
        his1D = dynamic_cast<TH1*>(pTPCgain->GetHistos()->FindObject("h_tpc_dedx_mips_0")->Clone());
    } else {
       his1D =  pTPCgain->GetDeDxHisto()->Projection(0);
    }
    if(!his1D) return 4;
    his1D->Fit(&gausFit,"QN","QN");

    meanMIP = gausFit.GetParameter(1);
    resolutionMIP = 0;
    if (meanMIP!=0) resolutionMIP = gausFit.GetParameter(2)/meanMIP;
    //removedtotest// delete his1D;
    
    //
    // MIP position vs. dip angle (attachment)
    //    
    pTPCgain->GetDeDxHisto()->GetAxis(5)->SetRangeUser(-3,0); // C side
    if (pTPCgain->GetHistos()->FindObject("h_tpc_dedx_mips_c_0_5") && !fgForceTHnSparse) {    
        his2D = dynamic_cast<TH2*>(pTPCgain->GetHistos()->FindObject("h_tpc_dedx_mips_c_0_5")->Clone());
    } else {
        his2D =  pTPCgain->GetDeDxHisto()->Projection(0,5);
    }        
    if(!his2D) return 4;

    TF1 * fpol = new TF1("fpol","pol1");
    TObjArray arrayFit;
    his2D->FitSlicesY(0,0,-1,10,"QN",&arrayFit);    
    his1D = (TH1*) arrayFit.At(1);
    his1D->Fit(fpol,"QNROB=0.8","QNR",-1,0);
    attachSlopeC = fpol->GetParameter(1);
    //removedtotest// delete his2D;
    //removedtotest// delete his1D;
    //
    pTPCgain->GetDeDxHisto()->GetAxis(5)->SetRangeUser(0,3); // A side
    if (pTPCgain->GetHistos()->FindObject("h_tpc_dedx_mips_a_0_5") && !fgForceTHnSparse) {    
        his2D = dynamic_cast<TH2*>(pTPCgain->GetHistos()->FindObject("h_tpc_dedx_mips_a_0_5")->Clone());
    } else {
        his2D =  pTPCgain->GetDeDxHisto()->Projection(0,5);
    }         
    if(!his2D) return 4;

    TF1 * fpolA = new TF1("fpolA","pol1");
    TObjArray arrayFitA;
    //FitSlicesY(TF1* f1 = 0, Int_t firstxbin = 0, Int_t lastxbin = -1, Int_t cut = 0, Option_t* option = "QNR", TObjArray* arr = 0)   
    his2D->FitSlicesY(0,0,-1,10,"QN",&arrayFit); 
    his1D = (TH1*) arrayFit.At(1);
    his1D->Fit(fpolA,"QNROB=0.8","QN",0,1);
    attachSlopeA = fpolA->GetParameter(1);
     //removedtotest// delete his2D;
     //removedtotest// delete his1D;
    //
    // MIP position vs. sector
    //
    pTPCgain->GetDeDxHisto()->GetAxis(5)->SetRangeUser(-3,0); // C side
    if (pTPCgain->GetHistos()->FindObject("h_tpc_dedx_mips_c_0_1") && !fgForceTHnSparse) {    
        his2D = dynamic_cast<TH2*>(pTPCgain->GetHistos()->FindObject("h_tpc_dedx_mips_c_0_1")->Clone());
    } else {
        his2D =  pTPCgain->GetDeDxHisto()->Projection(0,1);
    }
    if(!his2D) return 4;

    for(Int_t i = 0; i < 18; i++) { // loop over sectors; correct mapping to be checked!
        //TH1* his1D=0;
        Float_t phiLow = -TMath::Pi() + i*(20./360.)*(2*TMath::Pi());
        Float_t phiUp    = -TMath::Pi() + (i+1)*(20./360.)*(2*TMath::Pi());
        //pTPCgain->GetDeDxHisto()->GetAxis(1)->SetRangeUser(phiLow,phiUp);
        his2D->GetXaxis()->SetRangeUser(phiLow,phiUp);
        //his1D = pTPCgain->GetDeDxHisto()->Projection(0); 
        his1D = his2D->ProjectionY(); 
        TF1 gausFunc("gausFunc","gaus");
        his1D->Fit(&gausFunc, "QN");
        meanMIPvsSector(i) = gausFunc.GetParameter(1);
        sector(i)=i;
        //removedtotest// delete his1D;
    }
     //removedtotest// delete his2D;
    //
    pTPCgain->GetDeDxHisto()->GetAxis(5)->SetRangeUser(0,3); // A side
    if (pTPCgain->GetHistos()->FindObject("h_tpc_dedx_mips_a_0_1") && !fgForceTHnSparse) {    
        his2D = dynamic_cast<TH2*>(pTPCgain->GetHistos()->FindObject("h_tpc_dedx_mips_a_0_1")->Clone());
    } else {
        his2D =  pTPCgain->GetDeDxHisto()->Projection(0,1);
    }    
    if(!his2D) return 4; 

    for(Int_t i = 0; i < 18; i++) { // loop over sectors; correct mapping to be checked!
        //TH1* his1D=0;
        Float_t phiLow = -TMath::Pi() + i*(20./360.)*(2*TMath::Pi());
        Float_t phiUp    = -TMath::Pi() + (i+1)*(20./360.)*(2*TMath::Pi());
        //pTPCgain->GetDeDxHisto()->GetAxis(1)->SetRangeUser(phiLow,phiUp);
        his2D->GetXaxis()->SetRangeUser(phiLow,phiUp);
        //his1D = pTPCgain->GetDeDxHisto()->Projection(0);
        his1D = his2D->ProjectionY();
        TF1 gausFunc("gausFunc","gaus");
        his1D->Fit(&gausFunc, "QN");
        meanMIPvsSector(i+18) = gausFunc.GetParameter(1);
        sector(i+18)=i+18;
        //removedtotest// delete his1D;
    }
     //removedtotest// delete his2D;

     //                                                         
    //  
    // select electrons                                                                                                               
    //                                                                                                                                                                           
    pTPCgain->GetDeDxHisto()->GetAxis(7)->SetRangeUser(0.32,0.38); // momenta
    pTPCgain->GetDeDxHisto()->GetAxis(0)->SetRangeUser(70,100); // dedx
    pTPCgain->GetDeDxHisto()->GetAxis(6)->SetRangeUser(80,160); // nr clusters
    pTPCgain->GetDeDxHisto()->GetAxis(5)->SetRangeUser(-1,1); // eta

    TF1 gausFitEle("gausFitEle","gaus");

    if (pTPCgain->GetHistos()->FindObject("h_tpc_dedx_mipsele_0") && !fgForceTHnSparse) {
      his1D = dynamic_cast<TH1*>(pTPCgain->GetHistos()->FindObject("h_tpc_dedx_mipsele_0")->Clone());
    } else {
      his1D =  pTPCgain->GetDeDxHisto()->Projection(0);
    }
    if(!his1D) return 4;
    his1D->Fit(&gausFitEle,"QN","QN");

    meanMIPele = gausFitEle.GetParameter(1);
    resolutionMIPele = 0;
    if (meanMIPele!=0) resolutionMIPele = gausFitEle.GetParameter(2)/meanMIPele;
    
    //restore cuts as before
    pTPCgain->GetDeDxHisto()->GetAxis(7)->SetRangeUser(0.4,0.55);
    pTPCgain->GetDeDxHisto()->GetAxis(0)->SetRangeUser(35,60);
    pTPCgain->GetDeDxHisto()->GetAxis(6)->SetRangeUser(80,160);
    pTPCgain->GetDeDxHisto()->GetAxis(5)->SetRangeUser(-1,1);

    //                                                                                                                                                                        
    // separation between electrons and MIPs                                                                                                                                  
    // 
    electroMIPSeparation = TMath::Abs((meanMIP-meanMIPele));

    printf("Gain QA report\n");
    printf("MIP mean\t%f\n",meanMIP);
    printf("MIP resolution\t%f\n",resolutionMIP);
    printf("MIPslopeA\t%f\n",attachSlopeA);
    printf("MIPslopeC\t%f\n",attachSlopeC);
    printf("Electons energy loss MIP mean\t%f\n",meanMIPele);
    printf("Electons MIP resolution\t%f\n",resolutionMIPele);
    // 
    
    (*pcstream)<<"tpcQA"<<
      "MIPattachSlopeC="<<attachSlopeC<<
      "MIPattachSlopeA="<<attachSlopeA<<
      "resolutionMIP="<<resolutionMIP<<
      "meanMIPvsSector.="<<&meanMIPvsSector<<
      "sector.="<<&sector<<
      "meanMIP="<<meanMIP<<
      "meanMIPele="<<meanMIPele<<
      "resolutionMIPele="<<resolutionMIPele<<
      "electroMIPSeparation="<<electroMIPSeparation;
    
    return 0;
}

//_____________________________________________________________________________
Int_t AliTPCPerformanceSummary::AnalyzeEvent(const AliPerformanceTPC* pTPC, TTreeSRedirector* const pcstream)
{
    //
    // Analyse Primary Vertex Distribution and Multiplicities
    //
  if (!pcstream) return 1;
    if (!pTPC) return 1;
    //
    // 
    //
    static Double_t meanVertX=0;
    static Double_t rmsVertX=0;
    static Double_t meanVertY=0;
    static Double_t rmsVertY=0;
    static Double_t meanVertZ=0;
    static Double_t rmsVertZ=0;
    static Double_t vertStatus=0;
    static Double_t meanMult=0;
    static Double_t rmsMult=0;
    static Double_t meanMultPos=0;
    static Double_t rmsMultPos=0;
    static Double_t meanMultNeg=0;
    static Double_t rmsMultNeg=0;
    static Double_t vertAll = 0;
    static Double_t vertOK = 0;
    
    TH1* his1D=0;
    TH1* hc=0;
    if (pTPC->GetHistos()->FindObject("h_tpc_event_6") && !fgForceTHnSparse) {    
        his1D = dynamic_cast<TH1*>(pTPC->GetHistos()->FindObject("h_tpc_event_6")->Clone());
    } else {
       his1D = pTPC->GetTPCEventHisto()->Projection(6);
    }
    if(!his1D) return 1;

    vertAll = his1D->GetEntries();
    vertOK  = his1D->GetBinContent(2);
    if (vertAll>=1) {
            vertStatus = vertOK / vertAll;
    }
    
    delete his1D;
    
    pTPC->GetTPCEventHisto()->GetAxis(6)->SetRange(2,2);
   
    if (pTPC->GetHistos()->FindObject("h_tpc_event_recvertex_0") && !fgForceTHnSparse) {    
        his1D = dynamic_cast<TH1*>(pTPC->GetHistos()->FindObject("h_tpc_event_recvertex_0")->Clone());
    } else {
       his1D = pTPC->GetTPCEventHisto()->Projection(0);
    }
    if(!his1D) return 1;

    meanVertX = his1D->GetMean();    
    rmsVertX    = his1D->GetRMS();
    delete his1D;
    
    
    
    
    if (pTPC->GetHistos()->FindObject("h_tpc_event_recvertex_1") && !fgForceTHnSparse) {    
        his1D = dynamic_cast<TH1*>(pTPC->GetHistos()->FindObject("h_tpc_event_recvertex_1")->Clone());
    } else {
       his1D = pTPC->GetTPCEventHisto()->Projection(1);
    }
    if(!his1D) return 1;

    meanVertY = his1D->GetMean();
    rmsVertY    = his1D->GetRMS();
    delete his1D;
    
    
    if (pTPC->GetHistos()->FindObject("h_tpc_event_recvertex_2") && !fgForceTHnSparse) {    
        hc = dynamic_cast<TH1*>(pTPC->GetHistos()->FindObject("h_tpc_event_recvertex_2"));
	if(!hc) return 1;
        //his1D = dynamic_cast<TH1*>(pTPC->GetHistos()->FindObject("h_tpc_event_recvertex_2")->Clone());
        his1D = (TH1*)hc->Clone();
    } else {
       his1D = pTPC->GetTPCEventHisto()->Projection(2);
    }    
    if(!his1D) return 1;

    meanVertZ = his1D->GetMean();
    rmsVertZ    = his1D->GetRMS();
    delete his1D;
    
    
    if (pTPC->GetHistos()->FindObject("h_tpc_event_recvertex_3") && !fgForceTHnSparse) {    
        hc = dynamic_cast<TH1*>(pTPC->GetHistos()->FindObject("h_tpc_event_recvertex_3"));
	if(!hc) return 1;
        //his1D = dynamic_cast<TH1*>(pTPC->GetHistos()->FindObject("h_tpc_event_recvertex_3")->Clone());
        his1D = (TH1*)hc->Clone();
    } else {
       his1D = pTPC->GetTPCEventHisto()->Projection(3);
    }
    if(!his1D) return 1;

    meanMult    = his1D->GetMean();
    rmsMult     = his1D->GetRMS();
    delete his1D;
    
    
    if (pTPC->GetHistos()->FindObject("h_tpc_event_recvertex_4") && !fgForceTHnSparse) {    
        his1D = dynamic_cast<TH1*>(pTPC->GetHistos()->FindObject("h_tpc_event_recvertex_4")->Clone());
    } else {
       his1D = pTPC->GetTPCEventHisto()->Projection(4);
    }
    if(!his1D) return 1;

    meanMultPos    = his1D->GetMean();
    rmsMultPos     = his1D->GetRMS();
    delete his1D;
    
    if (pTPC->GetHistos()->FindObject("h_tpc_event_recvertex_5") && !fgForceTHnSparse) {    
        his1D = dynamic_cast<TH1*>(pTPC->GetHistos()->FindObject("h_tpc_event_recvertex_5")->Clone());
    } else {
       his1D = pTPC->GetTPCEventHisto()->Projection(5);
    }
    if(!his1D) return 1;

    meanMultNeg    = his1D->GetMean();
    rmsMultNeg     = his1D->GetRMS();
    delete his1D;
    
    pTPC->GetTPCEventHisto()->GetAxis(6)->SetRange(1,2);
    //
    (*pcstream)<<"tpcQA"<<
        "meanVertX="<<meanVertX<<
        "rmsVertX="<<rmsVertX<<
        "meanVertY="<<meanVertY<<
        "rmsVertY="<<rmsVertY<<
        "meanVertZ="<<meanVertZ<<
        "rmsVertZ="<<rmsVertZ<<
        "vertStatus="<<vertStatus<<
        "vertAll="<<vertAll<<
        "vertOK="<<vertOK<<
        "meanMult="<<meanMult<<
        "rmsMult="<<rmsMult<<
        "meanMultPos="<<meanMultPos<<
        "rmsMultPos="<<rmsMultPos<<
        "meanMultNeg="<<meanMultNeg<<
        "rmsMultNeg="<<rmsMultNeg;     
     
    return 0;
}

//_____________________________________________________________________________
Int_t AliTPCPerformanceSummary::AnalyzePt(const AliPerformanceTPC* pTPC, TTreeSRedirector* const pcstream)
{
    //
    // Analyse DCA R imperfections for positive particles
    //
    
    if (!pcstream) return 256;
    if (!pTPC) return 256;

    // variables:
    static Double_t meanPtAPos = 0;
    static Double_t mediumPtAPos = 0;
    static Double_t highPtAPos = 0;
    static Double_t meanPtCPos = 0;
    static Double_t mediumPtCPos = 0;
    static Double_t highPtCPos = 0;

    static Double_t meanPtANeg = 0;
    static Double_t mediumPtANeg = 0;
    static Double_t highPtANeg = 0;
    static Double_t meanPtCNeg = 0;
    static Double_t mediumPtCNeg = 0;
    static Double_t highPtCNeg = 0;

    TH3* his3D1=0;
    TH3* his3D2=0;
    
    if (pTPC->GetHistos()->FindObject("h_tpc_track_pos_recvertex_3_5_7")) {    

      his3D1 = dynamic_cast<TH3*>(pTPC->GetHistos()->FindObject("h_tpc_track_pos_recvertex_3_5_7"));
      if(!his3D1) return 256;
	
      his3D1->GetYaxis()->SetRangeUser(0.1,0.8);
      
      his3D1->GetZaxis()->SetRangeUser(0.25,10);
      meanPtAPos = his3D1->GetMean(3);
      his3D1->GetZaxis()->SetRangeUser(2,5);
      mediumPtAPos = his3D1->GetMean(3);
      his3D1->GetZaxis()->SetRangeUser(5,10);
      highPtAPos = his3D1->GetMean(3);
      
      his3D1->GetYaxis()->SetRangeUser(-0.8,-0.1);

      his3D1->GetZaxis()->SetRangeUser(0.25,10);
      meanPtCPos = his3D1->GetMean(3);
      his3D1->GetZaxis()->SetRangeUser(2,5);
      mediumPtCPos = his3D1->GetMean(3);
      his3D1->GetZaxis()->SetRangeUser(5,10);
      highPtCPos = his3D1->GetMean(3);

      his3D1->GetYaxis()->SetRangeUser(-1,1);
      his3D1->GetZaxis()->SetRangeUser(0.25,10);
    }


    if (pTPC->GetHistos()->FindObject("h_tpc_track_neg_recvertex_3_5_7")) {    

      his3D2 = dynamic_cast<TH3*>(pTPC->GetHistos()->FindObject("h_tpc_track_neg_recvertex_3_5_7"));
      if(!his3D2) return 256;
	
      his3D2->GetYaxis()->SetRangeUser(0.1,0.8);

      his3D2->GetZaxis()->SetRangeUser(0.25,10);
      meanPtANeg = his3D2->GetMean(3);
      his3D2->GetZaxis()->SetRangeUser(2,5);
      mediumPtANeg = his3D2->GetMean(3);
      his3D2->GetZaxis()->SetRangeUser(5,10);
      highPtANeg = his3D2->GetMean(3);
      
      his3D2->GetYaxis()->SetRangeUser(-0.8,-0.1);

      his3D2->GetZaxis()->SetRangeUser(0.25,10);
      meanPtCNeg = his3D2->GetMean(3);
      his3D2->GetZaxis()->SetRangeUser(2,5);
      mediumPtCNeg = his3D2->GetMean(3);
      his3D2->GetZaxis()->SetRangeUser(5,10);
      highPtCNeg = his3D2->GetMean(3);
      
      his3D2->GetYaxis()->SetRangeUser(-1,1);
      his3D2->GetZaxis()->SetRangeUser(0.25,10);
    }



    // dump values
    //
    (*pcstream)<<"tpcQA"<<
      "meanPtAPos="<< meanPtAPos<<
      "mediumPtAPos="<< mediumPtAPos<<
      "highPtAPos="<< highPtAPos<<
      //
      "meanPtCPos="<< meanPtCPos<<
      "mediumPtCPos="<< mediumPtCPos<<
      "highPtCPos="<< highPtCPos<<
      //
      "meanPtANeg="<< meanPtANeg<<
      "mediumPtANeg="<< mediumPtANeg<<
      "highPtANeg="<< highPtANeg<<
        //
      "meanPtCNeg="<< meanPtCNeg<<
      "mediumPtCNeg="<< mediumPtCNeg<<
      "highPtCNeg="<< highPtCNeg;

        
    return 0;
}

//_____________________________________________________________________________

Int_t AliTPCPerformanceSummary::AnalyzeChargeOverPt(const AliPerformanceTPC* pTPC, TTreeSRedirector* const pcstream){
    //
    // Analyse DCA R imperfections for positive particles
    //
    
    if (!pcstream) return 512;
    if (!pTPC) return 512;

    // variables:
    static Double_t qOverPt = 0;
    static Double_t qOverPtA = 0;
    static Double_t qOverPtC = 0;

    TH2* his2D=0;
    TH1* his1D1=0;
    TH1* his1D2=0;
    TH1* his1D3=0;
    TF1 *fp1 = new TF1("fp1","pol2",-1.0,1.0);
    TF1 *fp2 = new TF1("fp2","pol2",-1.0,1.0);
    TF1 *fp3 = new TF1("fp3","pol2",-1.0,1.0);
    
    if (pTPC->GetHistos()->FindObject("h_tpc_track_all_recvertex_5_8")) {

      his2D = dynamic_cast<TH2*>(pTPC->GetHistos()->FindObject("h_tpc_track_all_recvertex_5_8"));
      if(!his2D) return 512;

      his1D1 = his2D->ProjectionX();
      his1D1->Fit(fp1,"R");
      if(fp1->GetParameter(2)!=0){
	qOverPt = (-1.0)*(fp1->GetParameter(1)/(2.0*fp1->GetParameter(2)));
       }
      delete fp1;
      delete his1D1;

       his2D->GetYaxis()->SetRangeUser(0.1,0.8);
       his1D2 = his2D->ProjectionX();
       his1D2->Fit(fp2,"R");
       if(fp2->GetParameter(2)!=0)
	 qOverPtA = (-1.0)*(fp2->GetParameter(1)/(2.0*fp2->GetParameter(2)));
       delete fp2;
       delete his1D2;
     
       his2D->GetYaxis()->SetRangeUser(-0.8,-0.1);       
       his1D3 = his2D->ProjectionX();
       his1D3->Fit(fp3,"R");
       if(fp3->GetParameter(2)!=0)
	 qOverPtC = (-1.0)*(fp3->GetParameter(1)/(2.0*fp3->GetParameter(2)));
       delete fp3;
       delete his1D3;
       
      his2D->GetYaxis()->SetRangeUser(-1.0,1.0);
    }
    
    
    (*pcstream)<<"tpcQA"<<
      "qOverPt="<< qOverPt<<
      "qOverPtA="<< qOverPtA<<
      "qOverPtC="<< qOverPtC;
    
    return 0;
}

Int_t AliTPCPerformanceSummary::AnalyzeMatch(const AliPerformanceMatch* pMatch, TTreeSRedirector* const pcstream)
{
  /* if ((pMatch == 0) or (0 == pcstream)) { printf("this will not work anyway..."); }
     printf("funtion not implemented");*/

  if (!pcstream) return 1024;
  if (!pMatch) return 1024;
  static Double_t tpcItsMatchA = 0;
  static Double_t tpcItsMatchHighPtA = 0; 
  static Double_t tpcItsMatchC = 0;
  static Double_t tpcItsMatchHighPtC = 0; 

  TH2 *h2D = 0;
  TH2 *h2D1 = 0;
  if(pMatch->GetHistos()->FindObject("h_tpc_match_trackingeff_all_2_3") &&
     pMatch->GetHistos()->FindObject("h_tpc_match_trackingeff_tpc_2_3")){
    h2D = dynamic_cast<TH2*>(pMatch->GetHistos()->FindObject("h_tpc_match_trackingeff_all_2_3"));
    h2D1 = dynamic_cast<TH2*>(pMatch->GetHistos()->FindObject("h_tpc_match_trackingeff_tpc_2_3"));
   
    if(!h2D) return 4;
    if(!h2D1) return 4;

    h2D->GetXaxis()->SetRangeUser(0,1.5);
    h2D1->GetXaxis()->SetRangeUser(0,1.5);

    Double_t entries,entries1;
    entries = h2D->GetEffectiveEntries();
    entries1 = h2D1->GetEffectiveEntries();
    if(entries > 0)
      tpcItsMatchA = entries1/entries;

    h2D->GetYaxis()->SetRangeUser(4.01,20.);
    h2D1->GetYaxis()->SetRangeUser(4.01,20.);
    entries = h2D->GetEffectiveEntries();
    entries1 = h2D1->GetEffectiveEntries();
    if(entries > 0)
    tpcItsMatchHighPtA = entries1/entries;


    h2D->GetXaxis()->SetRangeUser(-1.5,-0.01);
    h2D1->GetXaxis()->SetRangeUser(-1.5,-0.01);
    h2D->GetYaxis()->SetRangeUser(0.0,20.);
    h2D1->GetYaxis()->SetRangeUser(0.0,20.);

    entries = h2D->GetEffectiveEntries();
    entries1 = h2D1->GetEffectiveEntries();
    if(entries > 0)
      tpcItsMatchC = entries1/entries;

    h2D->GetYaxis()->SetRangeUser(4.01,20.);
    h2D1->GetYaxis()->SetRangeUser(4.01,20.);
    entries = h2D->GetEffectiveEntries();
    entries1 = h2D1->GetEffectiveEntries();
    if(entries > 0)
      tpcItsMatchHighPtC = entries1/entries;

    h2D->GetXaxis()->SetRangeUser(-1.5,1.5);
    h2D1->GetXaxis()->SetRangeUser(-1.5,1.5);
    h2D->GetYaxis()->SetRangeUser(0.0,20.);
    h2D1->GetYaxis()->SetRangeUser(0.0,20.);
    //    delete h2D;
    //    delete h2D1;
  }

  (*pcstream)<<"tpcQA"<<
    "tpcItsMatchA="<< tpcItsMatchA<<
    "tpcItsMatchHighPtA="<< tpcItsMatchHighPtA<<
    "tpcItsMatchC="<< tpcItsMatchC<<
    "tpcItsMatchHighPtC="<< tpcItsMatchHighPtC;

  return 0;
}

Int_t AliTPCPerformanceSummary::AnalyzePull(const AliPerformanceMatch* pPull, TTreeSRedirector* const pcstream)
{
  /* if ((pPull == 0) or (0 == pcstream)) { printf("this will not work anyway..."); }
     printf("funtion not implemented");*/

  if (!pcstream) return 2048;
  if (!pPull) return 2048;
  static Double_t phiPull = 0;
  static Double_t phiPullHighPt = 0; 
  static Double_t ptPull = 0;
  static Double_t ptPullHighPt = 0; 
  static Double_t yPull = 0;
  static Double_t yPullHighPt = 0; 
  static Double_t zPull = 0;
  static Double_t zPullHighPt = 0; 
  static Double_t lambdaPull = 0;
  static Double_t lambdaPullHighPt = 0; 

  TH2 *h2D1 = 0;
  if(pPull->GetHistos()->FindObject("h_tpc_match_pull_2_7")){
    h2D1 = dynamic_cast<TH2*>(pPull->GetHistos()->FindObject("h_tpc_match_pull_2_7"));
    if(!h2D1) return 4;
    phiPull = h2D1->GetMean(2);
    h2D1->SetAxisRange(0.0,1.0/5.0,"X");
    phiPullHighPt = h2D1->GetMean(2);
    h2D1->SetAxisRange(0.0,10.0,"X");
    //    delete h2D1;
  }

  TH2 *h2D2 = 0;
  if(pPull->GetHistos()->FindObject("h_tpc_match_pull_4_7")){
    h2D2 = dynamic_cast<TH2*>(pPull->GetHistos()->FindObject("h_tpc_match_pull_4_7"));
    if(!h2D2) return 4;
    ptPull = h2D2->GetMean(2);

    h2D2->SetAxisRange(0.0,1.0/5.0,"X");
    ptPullHighPt = h2D2->GetMean(2);
    h2D2->SetAxisRange(0.0,10.0,"X");
    //    delete h2D2;
  }

  TH2 *h2D3 = 0;
  if(pPull->GetHistos()->FindObject("h_tpc_match_pull_0_7")){
    h2D3 = dynamic_cast<TH2*>(pPull->GetHistos()->FindObject("h_tpc_match_pull_0_7"));
    if(!h2D3) return 4;
    yPull = h2D3->GetMean(2);

    h2D3->SetAxisRange(0.0,1.0/5.0,"X");
    yPullHighPt = h2D3->GetMean(2);
    h2D3->SetAxisRange(0.0,10.0,"X");
    //    delete h2D3;
  }

  TH2 *h2D4 = 0;
  if(pPull->GetHistos()->FindObject("h_tpc_match_pull_1_7")){
    h2D4 = dynamic_cast<TH2*>(pPull->GetHistos()->FindObject("h_tpc_match_pull_1_7"));
    if(!h2D4) return 4;
    zPull = h2D4->GetMean(2);

    h2D4->SetAxisRange(0.0,1.0/5.0,"X");
    zPullHighPt = h2D4->GetMean(2);
    h2D4->SetAxisRange(0.0,10.0,"X");
    //    delete h2D4;
 }

  TH2 *h2D5 = 0;
  if(pPull->GetHistos()->FindObject("h_tpc_match_pull_3_7")){
    h2D5 = dynamic_cast<TH2*>(pPull->GetHistos()->FindObject("h_tpc_match_pull_3_7"));
    if(!h2D5) return 4;
    lambdaPull = h2D5->GetMean(2);

    h2D5->SetAxisRange(0.0,1.0/5.0,"X");
    lambdaPullHighPt = h2D5->GetMean(2);
    h2D5->SetAxisRange(0.0,10.0,"X");
    //    delete h2D5;
}

  (*pcstream)<<"tpcQA"<<
    "phiPull="<< phiPull<<
    "phiPullHighPt="<< phiPullHighPt<<
    "ptPull="<< ptPull<<
    "ptPullHighPt="<< ptPullHighPt<<
    "yPull="<< yPull<<
    "yPullHighPt="<< yPullHighPt<<
    "zPull="<< zPull<<
    "zPullHighPt="<< zPullHighPt<<
    "lambdaPull="<< lambdaPull<<
    "lambdaPullHighPt="<< lambdaPullHighPt;
    
  return 0;
}
Int_t AliTPCPerformanceSummary::AnalyzeConstrain(const AliPerformanceMatch* pConstrain, TTreeSRedirector* pcstream)
{
  if (!pcstream) return 5126;
  if (!pConstrain) return 5126;

    TH3* his3D=0;
    static Double_t tpcConstrainPhiA = 0;
    static Double_t tpcConstrainPhiC = 0;
    
    if (pConstrain->GetHistos()->FindObject("h_tpc_constrain_tpc_0_2_3")) {    
      
      his3D = dynamic_cast<TH3*>(pConstrain->GetHistos()->FindObject("h_tpc_constrain_tpc_0_2_3"));//phi pull:pt:eta
      if(!his3D) return 5126;
      
      his3D->GetZaxis()->SetRangeUser(0.0,1.0);
      tpcConstrainPhiA = his3D->GetMean(1);
      his3D->GetZaxis()->SetRangeUser(-1.0,-0.001);
      tpcConstrainPhiC = his3D->GetMean(1);
    }

  (*pcstream)<<"tpcQA"<<
    "tpcConstrainPhiA="<<tpcConstrainPhiA <<
    "tpcConstrainPhiC="<< tpcConstrainPhiC;
  
  return 0;
}

//_____________________________________________________________________________
 Int_t AliTPCPerformanceSummary::AnalyzeQAPosNegDpT(const AliPerformanceTPC* pTPC, TTreeSRedirector* const pcstream)
{
  //function which plot 1/Pt for negative and 
  //positive particles
  
  if (!pcstream) return 512;
  if (!pTPC) return 512;
  
  TH3D* pos3=0;
  TH3D* neg3=0;
  TH1D* pos=0;
  TH1D* neg=0;
  TH1D* posC=0;
  TH1D* negC=0;
  TH1D* posA=0;
  TH1D* negA=0;
  static Double_t deltaPtC = 0;
  static Double_t deltaPtchi2C = 0;
  static Double_t slopeC = 0;
  static Double_t deltaPtA = 0;
  static Double_t deltaPtchi2A = 0;
  static Double_t slopeA = 0;
  static Double_t deltaPt = 0;
  static Double_t deltaPtchi2 = 0;
  static Double_t slope = 0;
  static Double_t deltaPt_Err = 0; 
  static Double_t deltaPtA_Err = 0;
  static Double_t deltaPtC_Err = 0;


//C side

  if(pTPC->GetHistos()->FindObject("h_tpc_track_pos_recvertex_0_5_7"))
    {
    pos3 = dynamic_cast<TH3D*>(pTPC->GetHistos()->FindObject("h_tpc_track_pos_recvertex_0_5_7")); 
    if(!pos3) return 512;
  
    pos = pos3->ProjectionZ("pos",71,-1,6,25);
    posC = pos3->ProjectionZ("posC",71,-1,6,15);
    posA = pos3->ProjectionZ("posA",71,-1,16,25);
    }

    if(pTPC->GetHistos()->FindObject("h_tpc_track_neg_recvertex_0_5_7")){
    neg3 = dynamic_cast<TH3D*>(pTPC->GetHistos()->FindObject("h_tpc_track_neg_recvertex_0_5_7")); 
    if(!neg3) return 512;
    
    neg = neg3->ProjectionZ("neg",71,-1,6,25);
    negC = neg3->ProjectionZ("negC",71,-1,6,15);
    negA = neg3->ProjectionZ("negA",71,-1,16,25);
}

if(!pos) return 512; 
if(!neg) return 512; 
if(!posA) return 512; 
if(!negA) return 512; 
if(!posC) return 512; 
if(!negC) return 512; 

pos->Sumw2();
neg->Sumw2();
posA->Sumw2();
negA->Sumw2();
posC->Sumw2();
negC->Sumw2();

pos->Scale(1.,"width");
neg->Scale(1.,"width");
posA->Scale(1.,"width");
negA->Scale(1.,"width");
posC->Scale(1.,"width");
negC->Scale(1.,"width");

//both sides

TF1 fpt("fpt","[1]*exp(-1/((1/x))*[0])",0.1,10);
TF1 fpt2("fpt2","[1]*exp(-1/((1/x))*[0])",0.1,10);
fpt.SetParameters(1,0.5);
fpt2.SetParameters(1,0.5);
pos->Fit(&fpt,"","",1,4); pos->Fit(&fpt,"","",1,4); pos->Fit(&fpt,"","",1,4);
neg->Fit(&fpt2,"","",1,4); neg->Fit(&fpt2,"","",1,4); neg->Fit(&fpt2,"","",1,4);

slope = (fpt.GetParameter(0)+fpt2.GetParameter(0))/2.;

TH1D* ratio = new TH1D(*pos); 
ratio->Divide(neg);

ratio->Draw();
TF1 fptRatio("fptratio","[2]*exp(-1/((1/x)+[1])*[0])/exp(-1/((1/x)-[1])*[0])",0.1,10);
fptRatio.SetParameters(0.5,0.006,1);
fptRatio.FixParameter(0,slope);
fptRatio.Draw();
ratio->Fit(&fptRatio,"","",1,4); ratio->Fit(&fptRatio,"","",1,4); 
ratio->Fit(&fptRatio,"","",1,4);

deltaPt = fptRatio.GetParameter(1);
deltaPtchi2 = fptRatio.GetChisquare();

//get the errors
deltaPt_Err = fptRatio.GetParError(1);


//A side

TF1 fptA("fptA","[1]*exp(-1/((1/x))*[0])",0.1,10);
TF1 fpt2A("fpt2A","[1]*exp(-1/((1/x))*[0])",0.1,10);
fptA.SetParameters(1,0.5);
fpt2A.SetParameters(1,0.5);
posA->Fit(&fptA,"","",1,4); posA->Fit(&fptA,"","",1,4); posA->Fit(&fptA,"","",1,4);
negA->Fit(&fpt2A,"","",1,4); negA->Fit(&fpt2A,"","",1,4); negA->Fit(&fpt2A,"","",1,4);

slopeA = (fptA.GetParameter(0)+fpt2A.GetParameter(0))/2.;

TH1D* ratioA = new TH1D(*posA); 
ratioA->Divide(negA);

ratioA->Draw();
TF1 fptRatioA("fptratioA","[2]*exp(-1/((1/x)+[1])*[0])/exp(-1/((1/x)-[1])*[0])",0.1,10);
fptRatioA.SetParameters(0.5,0.006,1);
fptRatioA.FixParameter(0,slopeA);
fptRatioA.Draw();
ratioA->Fit(&fptRatioA,"","",1,4); ratio->Fit(&fptRatioA,"","",1,4); 
ratioA->Fit(&fptRatioA,"","",1,4);

deltaPtA = fptRatioA.GetParameter(1);
deltaPtchi2A = fptRatioA.GetChisquare();

//get the errors
deltaPtA_Err = fptRatioA.GetParError(1);

 delete ratioA;
 delete pos;
 delete neg;


//C side
TF1 fptC("fptC","[1]*exp(-1/((1/x))*[0])",0.1,10);
TF1 fpt2C("fpt2C","[1]*exp(-1/((1/x))*[0])",0.1,10);
fptC.SetParameters(1,0.5);
fpt2C.SetParameters(1,0.5);
posC->Fit(&fptC,"","",1,4); posC->Fit(&fptC,"","",1,4); posC->Fit(&fptC,"","",1,4);
negC->Fit(&fpt2C,"","",1,4); negC->Fit(&fpt2C,"","",1,4); negC->Fit(&fpt2C,"","",1,4);

slopeC = (fptC.GetParameter(0)+fpt2C.GetParameter(0))/2.;

TH1D* ratioC = new TH1D(*posC); 
ratioC->Divide(negC);

ratioC->Draw();
TF1 fptRatioC("fptratioC","[2]*exp(-1/((1/x)+[1])*[0])/exp(-1/((1/x)-[1])*[0])",0.1,10);
fptRatioC.SetParameters(0.5,0.006,1);
fptRatioC.FixParameter(0,slopeC);
fptRatioC.Draw();
ratioC->Fit(&fptRatioC,"","",1,4); ratio->Fit(&fptRatioC,"","",1,4); 
ratioC->Fit(&fptRatioC,"","",1,4);

deltaPtC = fptRatioC.GetParameter(1);
deltaPtchi2C = fptRatioC.GetChisquare();

//get the errors
deltaPtC_Err = fptRatioC.GetParError(1);


 delete posC;
 delete negC;
 delete ratioC;
    
    (*pcstream)<<"tpcQA"<<      
      "deltaPt="<< deltaPt<<
      "deltaPtchi2="<< deltaPtchi2<<
      "deltaPtA="<< deltaPtA<<
      "deltaPtchi2A="<< deltaPtchi2A<<
      "deltaPtC="<< deltaPtC<<
      "deltaPtchi2C="<< deltaPtchi2C<<
      "deltaPt_Err="<< deltaPt_Err<<
      "deltaPtA_Err="<< deltaPtA_Err<<
      "deltaPtC_Err="<< deltaPtC_Err;    
      
    return 0;
}

//_____________________________________________________________________________
 Int_t AliTPCPerformanceSummary::AnalyzeQADCAFitParameter(const AliPerformanceTPC* pTPC, TTreeSRedirector* const pcstream)
{
  
  //
  //function which retrieve DCA fit parameters
  //
  
  if (!pcstream) return 16;
  if (!pTPC) return 16;
  
  TH3* dcar_pos3=0;
  TH3* dcaz_pos3=0;
  TH3* dcar_neg3=0;
  TH3* dcaz_neg3=0;

  static Double_t dcar_posA_0=0; 
  static Double_t dcar_posA_1=0; 
  static Double_t dcar_posA_2=0; 
  static Double_t dcar_posA_chi2=0; 
  static Double_t dcar_posA_0_Err=0; 
  static Double_t dcar_posA_1_Err=0; 
  static Double_t dcar_posA_2_Err=0; 
  
  static Double_t dcar_posC_0=0; 
  static Double_t dcar_posC_1=0; 
  static Double_t dcar_posC_2=0; 
  static Double_t dcar_posC_chi2=0; 
  static Double_t dcar_posC_0_Err=0; 
  static Double_t dcar_posC_1_Err=0; 
  static Double_t dcar_posC_2_Err=0; 

  static Double_t dcaz_posA_0=0; 
  static Double_t dcaz_posA_1=0; 
  static Double_t dcaz_posA_2=0; 
  static Double_t dcaz_posA_chi2=0; 
  static Double_t dcaz_posA_0_Err=0; 
  static Double_t dcaz_posA_1_Err=0; 
  static Double_t dcaz_posA_2_Err=0; 
  
  static Double_t dcaz_posC_0=0; 
  static Double_t dcaz_posC_1=0; 
  static Double_t dcaz_posC_2=0; 
  static Double_t dcaz_posC_chi2=0; 
  static Double_t dcaz_posC_0_Err=0; 
  static Double_t dcaz_posC_1_Err=0; 
  static Double_t dcaz_posC_2_Err=0; 
  
  static Double_t dcar_negA_0=0; 
  static Double_t dcar_negA_1=0; 
  static Double_t dcar_negA_2=0; 
  static Double_t dcar_negA_chi2=0; 
  static Double_t dcar_negA_0_Err=0; 
  static Double_t dcar_negA_1_Err=0; 
  static Double_t dcar_negA_2_Err=0; 
  
  static Double_t dcar_negC_0=0; 
  static Double_t dcar_negC_1=0; 
  static Double_t dcar_negC_2=0; 
  static Double_t dcar_negC_chi2=0; 
  static Double_t dcar_negC_0_Err=0; 
  static Double_t dcar_negC_1_Err=0; 
  static Double_t dcar_negC_2_Err=0; 

  static Double_t dcaz_negA_0=0; 
  static Double_t dcaz_negA_1=0; 
  static Double_t dcaz_negA_2=0; 
  static Double_t dcaz_negA_chi2=0; 
  static Double_t dcaz_negA_0_Err=0; 
  static Double_t dcaz_negA_1_Err=0; 
  static Double_t dcaz_negA_2_Err=0; 
 
  static Double_t dcaz_negC_0=0; 
  static Double_t dcaz_negC_1=0; 
  static Double_t dcaz_negC_2=0; 
  static Double_t dcaz_negC_chi2=0; 
  static Double_t dcaz_negC_0_Err=0; 
  static Double_t dcaz_negC_1_Err=0; 
  static Double_t dcaz_negC_2_Err=0;
 
  if (pTPC->GetHistos()->FindObject("h_tpc_track_pos_recvertex_3_5_6")) {  
    dcar_pos3 = dynamic_cast<TH3*>(pTPC->GetHistos()->FindObject("h_tpc_track_pos_recvertex_3_5_6"));
  }
  
  if (pTPC->GetHistos()->FindObject("h_tpc_track_pos_recvertex_3_5_6")) {  
    dcaz_pos3 = dynamic_cast<TH3*>(pTPC->GetHistos()->FindObject("h_tpc_track_pos_recvertex_4_5_6"));
  }
  
  if (pTPC->GetHistos()->FindObject("h_tpc_track_pos_recvertex_3_5_6")) {  
    dcar_neg3 = dynamic_cast<TH3*>(pTPC->GetHistos()->FindObject("h_tpc_track_neg_recvertex_3_5_6")); 
  }
  
  if (pTPC->GetHistos()->FindObject("h_tpc_track_pos_recvertex_3_5_6")) {  
    dcaz_neg3 = dynamic_cast<TH3*>(pTPC->GetHistos()->FindObject("h_tpc_track_neg_recvertex_4_5_6"));
  }

  TF1 fit("fit","[0]+[1]*cos(x)+[2]*sin(x)",0,7); 

  dcar_pos3->GetYaxis()->SetRangeUser(0,0.99);    
  TH1* dcar_posA = (dynamic_cast<TH2*>(dcar_pos3->Project3D("xz_1")))->ProfileX(); 
  dcar_posA->Fit(&fit,"NQ");
  dcar_posA_0 = fit.GetParameter(0);
  dcar_posA_1 = fit.GetParameter(1);
  dcar_posA_2 = fit.GetParameter(2);
  dcar_posA_chi2 = fit.GetChisquare();  
  dcar_posA_0_Err = fit.GetParError(0);
  dcar_posA_1_Err = fit.GetParError(1);
  dcar_posA_2_Err = fit.GetParError(2);
  
  dcar_pos3->GetYaxis()->SetRangeUser(-1.0,-0.01);    
  TH1* dcar_posC = (dynamic_cast<TH2*>(dcar_pos3->Project3D("xz_2")))->ProfileX(); 
  dcar_posC->Fit(&fit,"NQ");
  dcar_posC_0 = fit.GetParameter(0);
  dcar_posC_1 = fit.GetParameter(1);
  dcar_posC_2 = fit.GetParameter(2);
  dcar_posC_chi2 = fit.GetChisquare();    
  dcar_posC_0_Err = fit.GetParError(0);
  dcar_posC_1_Err = fit.GetParError(1);
  dcar_posC_2_Err = fit.GetParError(2);

  dcaz_pos3->GetYaxis()->SetRangeUser(0,0.99);    
  TH1* dcaz_posA = (dynamic_cast<TH2*>(dcaz_pos3->Project3D("xz_3")))->ProfileX(); 
  dcaz_posA->Fit(&fit,"NQ");
  dcaz_posA_0 = fit.GetParameter(0);
  dcaz_posA_1 = fit.GetParameter(1);
  dcaz_posA_2 = fit.GetParameter(2);
  dcaz_posA_chi2 = fit.GetChisquare();      
  dcaz_posA_0_Err = fit.GetParError(0);
  dcaz_posA_1_Err = fit.GetParError(1);
  dcaz_posA_2_Err = fit.GetParError(2);  
  
  dcaz_pos3->GetYaxis()->SetRangeUser(-1.0,-0.01);    
  TH1* dcaz_posC = (dynamic_cast<TH2*>(dcaz_pos3->Project3D("xz_4")))->ProfileX(); 
  dcaz_posC->Fit(&fit,"NQ");
  dcaz_posC_0 = fit.GetParameter(0);
  dcaz_posC_1 = fit.GetParameter(1);
  dcaz_posC_2 = fit.GetParameter(2);
  dcaz_posC_chi2 = fit.GetChisquare();    
  dcaz_posC_0_Err = fit.GetParError(0);
  dcaz_posC_1_Err = fit.GetParError(1);
  dcaz_posC_2_Err = fit.GetParError(2);  
    

  
   dcar_neg3->GetYaxis()->SetRangeUser(0,0.99);    
  TH1* dcar_negA = (dynamic_cast<TH2*>(dcar_neg3->Project3D("xz_1")))->ProfileX(); 
  dcar_negA->Fit(&fit,"NQ");
  dcar_negA_0 = fit.GetParameter(0);
  dcar_negA_1 = fit.GetParameter(1);
  dcar_negA_2 = fit.GetParameter(2);
  dcar_negA_chi2 = fit.GetChisquare();  
  dcar_negA_0_Err = fit.GetParError(0);
  dcar_negA_1_Err = fit.GetParError(1);
  dcar_negA_2_Err = fit.GetParError(2);
  
  dcar_neg3->GetYaxis()->SetRangeUser(-1.0,-0.01);    
  TH1* dcar_negC = (dynamic_cast<TH2*>(dcar_neg3->Project3D("xz_2")))->ProfileX(); 
  dcar_negC->Fit(&fit,"NQ");
  dcar_negC_0 = fit.GetParameter(0);
  dcar_negC_1 = fit.GetParameter(1);
  dcar_negC_2 = fit.GetParameter(2);
  dcar_negC_chi2 = fit.GetChisquare();    
  dcar_negC_0_Err = fit.GetParError(0);
  dcar_negC_1_Err = fit.GetParError(1);
  dcar_negC_2_Err = fit.GetParError(2);

  dcaz_neg3->GetYaxis()->SetRangeUser(0,0.99);    
  TH1* dcaz_negA = (dynamic_cast<TH2*>(dcaz_neg3->Project3D("xz_3")))->ProfileX(); 
  dcaz_negA->Fit(&fit,"NQ");
  dcaz_negA_0 = fit.GetParameter(0);
  dcaz_negA_1 = fit.GetParameter(1);
  dcaz_negA_2 = fit.GetParameter(2);
  dcaz_negA_chi2 = fit.GetChisquare();      
  dcaz_negA_0_Err = fit.GetParError(0);
  dcaz_negA_1_Err = fit.GetParError(1);
  dcaz_negA_2_Err = fit.GetParError(2);  
  
  dcaz_neg3->GetYaxis()->SetRangeUser(-1.0,-0.01);    
  TH1* dcaz_negC = (dynamic_cast<TH2*>(dcaz_neg3->Project3D("xz_4")))->ProfileX(); 
  dcaz_negC->Fit(&fit,"NQ");
  dcaz_negC_0 = fit.GetParameter(0);
  dcaz_negC_1 = fit.GetParameter(1);
  dcaz_negC_2 = fit.GetParameter(2);
  dcaz_negC_chi2 = fit.GetChisquare();    
  dcaz_negC_0_Err = fit.GetParError(0);
  dcaz_negC_1_Err = fit.GetParError(1);
  dcaz_negC_2_Err = fit.GetParError(2);  
    

// store results (shift in dca) in ttree
    
    (*pcstream)<<"tpcQA"<<      
      "dcar_posA_0="<< dcar_posA_0<<
      "dcar_posA_1="<< dcar_posA_1<<
      "dcar_posA_2="<< dcar_posA_2<<
      "dcar_posA_chi2="<< dcar_posA_chi2<<
      "dcar_posA_0_Err="<< dcar_posA_0_Err<<
      "dcar_posA_1_Err="<< dcar_posA_1_Err<<
      "dcar_posA_2_Err="<< dcar_posA_2_Err;    
      
      (*pcstream)<<"tpcQA"<<            
      "dcaz_posA_0="<< dcaz_posA_0<<
      "dcaz_posA_1="<< dcaz_posA_1<<
      "dcaz_posA_2="<< dcaz_posA_2<<
      "dcaz_posA_chi2="<< dcaz_posA_chi2<<
      "dcaz_posA_0_Err="<< dcaz_posA_0_Err<<
      "dcaz_posA_1_Err="<< dcaz_posA_1_Err<<
      "dcaz_posA_2_Err="<< dcaz_posA_2_Err;          
      
      (*pcstream)<<"tpcQA"<<            
      "dcaz_posC_0="<< dcaz_posC_0<<
      "dcaz_posC_1="<< dcaz_posC_1<<
      "dcaz_posC_2="<< dcaz_posC_2<<
      "dcaz_posC_chi2="<< dcaz_posC_chi2<<
      "dcaz_posC_0_Err="<< dcaz_posC_0_Err<<
      "dcaz_posC_1_Err="<< dcaz_posC_1_Err<<
      "dcaz_posC_2_Err="<< dcaz_posC_2_Err;           

      (*pcstream)<<"tpcQA"<<            
      "dcar_posC_0="<< dcar_posC_0<<
      "dcar_posC_1="<< dcar_posC_1<<
      "dcar_posC_2="<< dcar_posC_2<<
      "dcar_posC_chi2="<< dcar_posC_chi2<<
      "dcar_posC_0_Err="<< dcar_posC_0_Err<<
      "dcar_posC_1_Err="<< dcar_posC_1_Err<<
      "dcar_posC_2_Err="<< dcar_posC_2_Err;           
            
      
     (*pcstream)<<"tpcQA"<<      
      "dcar_negA_0="<< dcar_negA_0<<
      "dcar_negA_1="<< dcar_negA_1<<
      "dcar_negA_2="<< dcar_negA_2<<
      "dcar_negA_chi2="<< dcar_negA_chi2<<
      "dcar_negA_0_Err="<< dcar_negA_0_Err<<
      "dcar_negA_1_Err="<< dcar_negA_1_Err<<
      "dcar_negA_2_Err="<< dcar_negA_2_Err;    
      
      (*pcstream)<<"tpcQA"<<            
      "dcaz_negA_0="<< dcaz_negA_0<<
      "dcaz_negA_1="<< dcaz_negA_1<<
      "dcaz_negA_2="<< dcaz_negA_2<<
      "dcaz_negA_chi2="<< dcaz_negA_chi2<<
      "dcaz_negA_0_Err="<< dcaz_negA_0_Err<<
      "dcaz_negA_1_Err="<< dcaz_negA_1_Err<<
      "dcaz_negA_2_Err="<< dcaz_negA_2_Err;          
      
      (*pcstream)<<"tpcQA"<<            
      "dcaz_negC_0="<< dcaz_negC_0<<
      "dcaz_negC_1="<< dcaz_negC_1<<
      "dcaz_negC_2="<< dcaz_negC_2<<
      "dcaz_negC_chi2="<< dcaz_negC_chi2<<
      "dcaz_negC_0_Err="<< dcaz_negC_0_Err<<
      "dcaz_negC_1_Err="<< dcaz_negC_1_Err<<
      "dcaz_negC_2_Err="<< dcaz_negC_2_Err;           

      (*pcstream)<<"tpcQA"<<            
      "dcar_negC_0="<< dcar_negC_0<<
      "dcar_negC_1="<< dcar_negC_1<<
      "dcar_negC_2="<< dcar_negC_2<<
      "dcar_negC_chi2="<< dcar_negC_chi2<<
      "dcar_negC_0_Err="<< dcar_negC_0_Err<<
      "dcar_negC_1_Err="<< dcar_negC_1_Err<<
      "dcar_negC_2_Err="<< dcar_negC_2_Err;                 
      
      return 0;
}

//_____________________________________________________________________________                                                                                                  
Int_t AliTPCPerformanceSummary::AnalyzeOcc(const AliPerformanceTPC* pTPC, TTreeSRedirector* const pcstream)
{
  //                                                                                                                                                                      
  //function which make trending of occupany per side and IROC-OROC                                     
  //                                                                                                                                                                            

  if (!pcstream) return 16;
  if (!pTPC) return 16;

  TH3* h3D_1=0;
  TH2* his2D=0;
  TH1* his1D=0;

  static Double_t norm=0; 
  static Double_t mean_occ_chamber=0;                                                                                                                                         
  static Double_t rms_mean_occ_chamber=0;   
  static Float_t occ_chamber=0;
  static Double_t rmsNr   = 3.0;
  static Int_t n_chamber_lowOcc = 0;  
  static Double_t minOcc= 0;  
  
  //nr of chamber within the thresholds
  static Int_t iroc_A_side =0;
  static Int_t oroc_A_side=0;
  static Int_t iroc_C_side =0;
  static Int_t oroc_C_side =0;
  
  //occupancy for each chamber, normalized to the total occupancy  
  static TVectorF meanOccArray_iroc(36);
  static TVectorF meanOccArray_oroc(36);

 if (pTPC->GetHistos()->FindObject("h_tpc_clust_0_1_2")) {  
    h3D_1 = dynamic_cast<TH3*>(pTPC->GetHistos()->FindObject("h_tpc_clust_0_1_2"));
  }
  
  //////////////////////////////////////////
  // normalization
  h3D_1->GetZaxis()->SetRangeUser(0,0.99); //A side
  h3D_1->GetXaxis()->SetRangeUser(0,160); //IROC + OROC
  his2D  = dynamic_cast<TH2*>(h3D_1->Project3D("xy_A_norm"));
  if(!his2D) return 4;
  his1D = his2D->ProjectionX();
  norm = his1D->Integral();
  printf("normalization:  \t%f\n",norm);
  if (norm < 0.001) norm=0.00001;
  delete his2D;
  
  //////////////////////////////////////////
  // A_side IROC
  h3D_1->GetZaxis()->SetRangeUser(0,0.99); //A_side
  h3D_1->GetXaxis()->SetRangeUser(0,63); //IROC    

  his2D = dynamic_cast<TH2*>(h3D_1->Project3D("xy_A_side_IROC"));
  if(!his2D) return 4;

  printf("-------------- A_IROC occupancy \t\n");

  for(Int_t i = 0; i < 18; i++) { //fill IROC A_side         
    Float_t phiLow = i*(20./360.)*(2*TMath::Pi());
    Float_t phiUp  = (i+1)*(20./360.)*(2*TMath::Pi());
    his2D->GetXaxis()->SetRangeUser(phiLow,phiUp); 
    his1D = his2D->ProjectionX();
    occ_chamber = (his1D->Integral()) / norm;    
    printf("%d occ_chamber \t%f \t phiLow phiUp  \t%f  %f \n",i, occ_chamber, phiLow, phiUp);
    meanOccArray_iroc[i]= occ_chamber;//fill array with occupancy for each chamber
    mean_occ_chamber += occ_chamber;//compute the average occupancy        
    rms_mean_occ_chamber  += occ_chamber*occ_chamber;
    delete his1D;
  }
  delete his2D;

  mean_occ_chamber /= 18; //nr of sectors                                                                                                                              
  rms_mean_occ_chamber  /= 18; //nr of sectors                                            
  
  rms_mean_occ_chamber   =  TMath::Sqrt( TMath::Abs(rms_mean_occ_chamber - (mean_occ_chamber*mean_occ_chamber)) );                                         
  minOcc    = mean_occ_chamber - rmsNr*rms_mean_occ_chamber;  

  printf("mean_occ_chamber +- rms_mean_occ_chamber \t%f\t%f \n", mean_occ_chamber, rms_mean_occ_chamber);
  printf("min Occ allowed (threshold) \t%f \n", minOcc);

  for (Int_t i = 0; i<18; i++) {
    if (meanOccArray_iroc[i] < minOcc) {n_chamber_lowOcc++;}
  }
  iroc_A_side = (18 - n_chamber_lowOcc); //nr of iroc above the thr
  printf("Nr of iroc_A_side \t%i \n \n ",iroc_A_side);

  mean_occ_chamber=0;
  rms_mean_occ_chamber=0;
  occ_chamber=0.;
  n_chamber_lowOcc=0;
  minOcc=0.;
  ////////////////////////////////////////////
  // A_side OROC
  h3D_1->GetZaxis()->SetRangeUser(0,0.99); //A_side
  h3D_1->GetXaxis()->SetRangeUser(64,160); //OROC    

  his2D = dynamic_cast<TH2*>(h3D_1->Project3D("xy_A_side_OROC"));
  if(!his2D) return 4;

  printf("-------------- A_OROC occupancy \t\n");

  for(Int_t i = 0; i < 18; i++) {          
    Float_t phiLow = i*(20./360.)*(2*TMath::Pi());
    Float_t phiUp  = (i+1)*(20./360.)*(2*TMath::Pi());
    his2D->GetXaxis()->SetRangeUser(phiLow,phiUp); 
    his1D = his2D->ProjectionX();
    occ_chamber = (his1D->Integral()) / norm;    
    printf("%d occ_chamber \t%f \t phiLow phiUp  \t%f  %f \n",i, occ_chamber, phiLow, phiUp);
    meanOccArray_oroc[i]= occ_chamber;//fill array with occupancy for each chamber
    mean_occ_chamber += occ_chamber;//compute the average occupancy        
    rms_mean_occ_chamber  += occ_chamber*occ_chamber;
    delete his1D;
  }
  delete his2D;

  mean_occ_chamber /= 18; //nr of sectors                                                                                                                              
  rms_mean_occ_chamber  /= 18; //nr of sectors                                            
  
  rms_mean_occ_chamber   =  TMath::Sqrt( TMath::Abs(rms_mean_occ_chamber - (mean_occ_chamber*mean_occ_chamber)) );                                         
  minOcc    = mean_occ_chamber - rmsNr*rms_mean_occ_chamber;  

  printf("mean_occ_chamber +- rms_mean_occ_chamber \t%f\t%f \n", mean_occ_chamber, rms_mean_occ_chamber);
  printf("min Occ allowed (threshold) \t%f \n", minOcc);

  for (Int_t i = 0; i<18; i++) {
    if (meanOccArray_oroc[i] < minOcc) {n_chamber_lowOcc++;}
  }
  oroc_A_side = (18 - n_chamber_lowOcc); //variable stored in the trending
  printf("Nr of oroc_A_side \t%i \n \n ",oroc_A_side);

  mean_occ_chamber=0;
  rms_mean_occ_chamber=0;
  occ_chamber=0.;
  n_chamber_lowOcc=0;
  minOcc=0.;

  ////////////////////////////////////////////////////////////////////////////////
  // C side
  //////////////////////////////////////////
  
  // normalization
  h3D_1->GetZaxis()->SetRangeUser(-1,-0.001); //C side
  h3D_1->GetXaxis()->SetRangeUser(0,160); //IROC + OROC
  his2D  = dynamic_cast<TH2*>(h3D_1->Project3D("xy_C_norm"));
  if(!his2D) return 4;
  his1D = his2D->ProjectionX();
  norm = his1D->Integral();
  printf("normalization:  \t%f\n",norm);
  if (norm < 0.001) norm=0.00001;
  delete his2D;
  
  //////////////////////////////////////////
  // C_side IROC
  h3D_1->GetZaxis()->SetRangeUser(-1,-0.001); //C_side
  h3D_1->GetXaxis()->SetRangeUser(0,63); //IROC    

  his2D = dynamic_cast<TH2*>(h3D_1->Project3D("xy_C_side_IROC"));
  if(!his2D) return 4;

  printf("-------------- C_IROC occupancy \t\n");

  for(Int_t i = 0; i < 18; i++) {          
    Float_t phiLow = i*(20./360.)*(2*TMath::Pi());
    Float_t phiUp  = (i+1)*(20./360.)*(2*TMath::Pi());
    his2D->GetXaxis()->SetRangeUser(phiLow,phiUp); 
    his1D = his2D->ProjectionX();
    occ_chamber = (his1D->Integral()) / norm;    
    printf("%d occ_chamber \t%f \t phiLow phiUp  \t%f  %f \n",i, occ_chamber, phiLow, phiUp);
    meanOccArray_iroc[18+i]= occ_chamber;//fill array with occupancy for each chamber, C side, therefore index 18+i
    mean_occ_chamber += occ_chamber;//compute the average occupancy        
    rms_mean_occ_chamber  += occ_chamber*occ_chamber;
    delete his1D;
  }
  delete his2D;

  mean_occ_chamber /= 18; //nr of sectors                                                                                                                              
  rms_mean_occ_chamber  /= 18; //nr of sectors                                            
  
  rms_mean_occ_chamber   =  TMath::Sqrt( TMath::Abs(rms_mean_occ_chamber - (mean_occ_chamber*mean_occ_chamber)) );                                         
  minOcc    = mean_occ_chamber - rmsNr*rms_mean_occ_chamber;  

  printf("mean_occ_chamber +- rms_mean_occ_chamber \t%f\t%f \n", mean_occ_chamber, rms_mean_occ_chamber);
  printf("min Occ allowed (threshold) \t%f \n", minOcc);

  for (Int_t i = 18; i<36; i++) {
    if (meanOccArray_iroc[i] < minOcc) {n_chamber_lowOcc++;}
  }
  iroc_C_side = (18 - n_chamber_lowOcc); //variable stored in the trending
  printf("Nr of iroc_C_side \t%i \n \n ",iroc_C_side);

  mean_occ_chamber=0;
  rms_mean_occ_chamber=0;
  occ_chamber=0.;
  n_chamber_lowOcc=0;
  minOcc=0.;

  ////////////////////////////////////////////
  // C_side OROC
  h3D_1->GetZaxis()->SetRangeUser(-1,-0.001); //C_side
  h3D_1->GetXaxis()->SetRangeUser(64,160); //OROC    

  his2D = dynamic_cast<TH2*>(h3D_1->Project3D("xy_C_side_OROC"));
  if(!his2D) return 4;

  printf("-------------- C_OROC occupancy \t\n");

  for(Int_t i = 0; i < 18; i++) {          
    Float_t phiLow = i*(20./360.)*(2*TMath::Pi());
    Float_t phiUp  = (i+1)*(20./360.)*(2*TMath::Pi());
    his2D->GetXaxis()->SetRangeUser(phiLow,phiUp); 
    his1D = his2D->ProjectionX();
    occ_chamber = (his1D->Integral()) / norm;    
    printf("%d occ_chamber \t%f \t phiLow phiUp  \t%f  %f \n",i, occ_chamber, phiLow, phiUp);
    meanOccArray_oroc[18+i]= occ_chamber;//fill array with occupancy for each chamber
    mean_occ_chamber += occ_chamber;//compute the average occupancy        
    rms_mean_occ_chamber  += occ_chamber*occ_chamber;
    delete his1D;
  }
  delete his2D;

  mean_occ_chamber /= 18; //nr of sectors                                                                                                                              
  rms_mean_occ_chamber  /= 18; //nr of sectors                                            
  
  rms_mean_occ_chamber   =  TMath::Sqrt( TMath::Abs(rms_mean_occ_chamber - (mean_occ_chamber*mean_occ_chamber)) );                                         
  minOcc    = mean_occ_chamber - rmsNr*rms_mean_occ_chamber;  

  printf("mean_occ_chamber +- rms_mean_occ_chamber \t%f\t%f \n", mean_occ_chamber, rms_mean_occ_chamber);
  printf("min Occ allowed (threshold) \t%f \n", minOcc);

  for (Int_t i = 18; i<36; i++) {
    if (meanOccArray_oroc[i] < minOcc) {n_chamber_lowOcc++;}
  }
  oroc_C_side = (18 - n_chamber_lowOcc); //variable stored in the trending
  printf("Nr of oroc_C_side \t%i \n \n ",oroc_C_side);

  mean_occ_chamber=0;
  rms_mean_occ_chamber=0;
  occ_chamber=0.;
  n_chamber_lowOcc=0;
  minOcc=0.;

  (*pcstream)<<"tpcQA"<<      
   "iroc_A_side="<< iroc_A_side<<
   "oroc_A_side="<< oroc_A_side<<
   "iroc_C_side="<< iroc_C_side<<
   "oroc_C_side="<< oroc_C_side<<
   //A/C side IROC 
   "TPC_Occ_IROC.="<< &meanOccArray_iroc<< 
   //A/C side OROC
   "TPC_Occ_OROC.="<< &meanOccArray_oroc;   

 return 0;
  }

 AliTPCPerformanceSummary.cxx:1
 AliTPCPerformanceSummary.cxx:2
 AliTPCPerformanceSummary.cxx:3
 AliTPCPerformanceSummary.cxx:4
 AliTPCPerformanceSummary.cxx:5
 AliTPCPerformanceSummary.cxx:6
 AliTPCPerformanceSummary.cxx:7
 AliTPCPerformanceSummary.cxx:8
 AliTPCPerformanceSummary.cxx:9
 AliTPCPerformanceSummary.cxx:10
 AliTPCPerformanceSummary.cxx:11
 AliTPCPerformanceSummary.cxx:12
 AliTPCPerformanceSummary.cxx:13
 AliTPCPerformanceSummary.cxx:14
 AliTPCPerformanceSummary.cxx:15
 AliTPCPerformanceSummary.cxx:16
 AliTPCPerformanceSummary.cxx:17
 AliTPCPerformanceSummary.cxx:18
 AliTPCPerformanceSummary.cxx:19
 AliTPCPerformanceSummary.cxx:20
 AliTPCPerformanceSummary.cxx:21
 AliTPCPerformanceSummary.cxx:22
 AliTPCPerformanceSummary.cxx:23
 AliTPCPerformanceSummary.cxx:24
 AliTPCPerformanceSummary.cxx:25
 AliTPCPerformanceSummary.cxx:26
 AliTPCPerformanceSummary.cxx:27
 AliTPCPerformanceSummary.cxx:28
 AliTPCPerformanceSummary.cxx:29
 AliTPCPerformanceSummary.cxx:30
 AliTPCPerformanceSummary.cxx:31
 AliTPCPerformanceSummary.cxx:32
 AliTPCPerformanceSummary.cxx:33
 AliTPCPerformanceSummary.cxx:34
 AliTPCPerformanceSummary.cxx:35
 AliTPCPerformanceSummary.cxx:36
 AliTPCPerformanceSummary.cxx:37
 AliTPCPerformanceSummary.cxx:38
 AliTPCPerformanceSummary.cxx:39
 AliTPCPerformanceSummary.cxx:40
 AliTPCPerformanceSummary.cxx:41
 AliTPCPerformanceSummary.cxx:42
 AliTPCPerformanceSummary.cxx:43
 AliTPCPerformanceSummary.cxx:44
 AliTPCPerformanceSummary.cxx:45
 AliTPCPerformanceSummary.cxx:46
 AliTPCPerformanceSummary.cxx:47
 AliTPCPerformanceSummary.cxx:48
 AliTPCPerformanceSummary.cxx:49
 AliTPCPerformanceSummary.cxx:50
 AliTPCPerformanceSummary.cxx:51
 AliTPCPerformanceSummary.cxx:52
 AliTPCPerformanceSummary.cxx:53
 AliTPCPerformanceSummary.cxx:54
 AliTPCPerformanceSummary.cxx:55
 AliTPCPerformanceSummary.cxx:56
 AliTPCPerformanceSummary.cxx:57
 AliTPCPerformanceSummary.cxx:58
 AliTPCPerformanceSummary.cxx:59
 AliTPCPerformanceSummary.cxx:60
 AliTPCPerformanceSummary.cxx:61
 AliTPCPerformanceSummary.cxx:62
 AliTPCPerformanceSummary.cxx:63
 AliTPCPerformanceSummary.cxx:64
 AliTPCPerformanceSummary.cxx:65
 AliTPCPerformanceSummary.cxx:66
 AliTPCPerformanceSummary.cxx:67
 AliTPCPerformanceSummary.cxx:68
 AliTPCPerformanceSummary.cxx:69
 AliTPCPerformanceSummary.cxx:70
 AliTPCPerformanceSummary.cxx:71
 AliTPCPerformanceSummary.cxx:72
 AliTPCPerformanceSummary.cxx:73
 AliTPCPerformanceSummary.cxx:74
 AliTPCPerformanceSummary.cxx:75
 AliTPCPerformanceSummary.cxx:76
 AliTPCPerformanceSummary.cxx:77
 AliTPCPerformanceSummary.cxx:78
 AliTPCPerformanceSummary.cxx:79
 AliTPCPerformanceSummary.cxx:80
 AliTPCPerformanceSummary.cxx:81
 AliTPCPerformanceSummary.cxx:82
 AliTPCPerformanceSummary.cxx:83
 AliTPCPerformanceSummary.cxx:84
 AliTPCPerformanceSummary.cxx:85
 AliTPCPerformanceSummary.cxx:86
 AliTPCPerformanceSummary.cxx:87
 AliTPCPerformanceSummary.cxx:88
 AliTPCPerformanceSummary.cxx:89
 AliTPCPerformanceSummary.cxx:90
 AliTPCPerformanceSummary.cxx:91
 AliTPCPerformanceSummary.cxx:92
 AliTPCPerformanceSummary.cxx:93
 AliTPCPerformanceSummary.cxx:94
 AliTPCPerformanceSummary.cxx:95
 AliTPCPerformanceSummary.cxx:96
 AliTPCPerformanceSummary.cxx:97
 AliTPCPerformanceSummary.cxx:98
 AliTPCPerformanceSummary.cxx:99
 AliTPCPerformanceSummary.cxx:100
 AliTPCPerformanceSummary.cxx:101
 AliTPCPerformanceSummary.cxx:102
 AliTPCPerformanceSummary.cxx:103
 AliTPCPerformanceSummary.cxx:104
 AliTPCPerformanceSummary.cxx:105
 AliTPCPerformanceSummary.cxx:106
 AliTPCPerformanceSummary.cxx:107
 AliTPCPerformanceSummary.cxx:108
 AliTPCPerformanceSummary.cxx:109
 AliTPCPerformanceSummary.cxx:110
 AliTPCPerformanceSummary.cxx:111
 AliTPCPerformanceSummary.cxx:112
 AliTPCPerformanceSummary.cxx:113
 AliTPCPerformanceSummary.cxx:114
 AliTPCPerformanceSummary.cxx:115
 AliTPCPerformanceSummary.cxx:116
 AliTPCPerformanceSummary.cxx:117
 AliTPCPerformanceSummary.cxx:118
 AliTPCPerformanceSummary.cxx:119
 AliTPCPerformanceSummary.cxx:120
 AliTPCPerformanceSummary.cxx:121
 AliTPCPerformanceSummary.cxx:122
 AliTPCPerformanceSummary.cxx:123
 AliTPCPerformanceSummary.cxx:124
 AliTPCPerformanceSummary.cxx:125
 AliTPCPerformanceSummary.cxx:126
 AliTPCPerformanceSummary.cxx:127
 AliTPCPerformanceSummary.cxx:128
 AliTPCPerformanceSummary.cxx:129
 AliTPCPerformanceSummary.cxx:130
 AliTPCPerformanceSummary.cxx:131
 AliTPCPerformanceSummary.cxx:132
 AliTPCPerformanceSummary.cxx:133
 AliTPCPerformanceSummary.cxx:134
 AliTPCPerformanceSummary.cxx:135
 AliTPCPerformanceSummary.cxx:136
 AliTPCPerformanceSummary.cxx:137
 AliTPCPerformanceSummary.cxx:138
 AliTPCPerformanceSummary.cxx:139
 AliTPCPerformanceSummary.cxx:140
 AliTPCPerformanceSummary.cxx:141
 AliTPCPerformanceSummary.cxx:142
 AliTPCPerformanceSummary.cxx:143
 AliTPCPerformanceSummary.cxx:144
 AliTPCPerformanceSummary.cxx:145
 AliTPCPerformanceSummary.cxx:146
 AliTPCPerformanceSummary.cxx:147
 AliTPCPerformanceSummary.cxx:148
 AliTPCPerformanceSummary.cxx:149
 AliTPCPerformanceSummary.cxx:150
 AliTPCPerformanceSummary.cxx:151
 AliTPCPerformanceSummary.cxx:152
 AliTPCPerformanceSummary.cxx:153
 AliTPCPerformanceSummary.cxx:154
 AliTPCPerformanceSummary.cxx:155
 AliTPCPerformanceSummary.cxx:156
 AliTPCPerformanceSummary.cxx:157
 AliTPCPerformanceSummary.cxx:158
 AliTPCPerformanceSummary.cxx:159
 AliTPCPerformanceSummary.cxx:160
 AliTPCPerformanceSummary.cxx:161
 AliTPCPerformanceSummary.cxx:162
 AliTPCPerformanceSummary.cxx:163
 AliTPCPerformanceSummary.cxx:164
 AliTPCPerformanceSummary.cxx:165
 AliTPCPerformanceSummary.cxx:166
 AliTPCPerformanceSummary.cxx:167
 AliTPCPerformanceSummary.cxx:168
 AliTPCPerformanceSummary.cxx:169
 AliTPCPerformanceSummary.cxx:170
 AliTPCPerformanceSummary.cxx:171
 AliTPCPerformanceSummary.cxx:172
 AliTPCPerformanceSummary.cxx:173
 AliTPCPerformanceSummary.cxx:174
 AliTPCPerformanceSummary.cxx:175
 AliTPCPerformanceSummary.cxx:176
 AliTPCPerformanceSummary.cxx:177
 AliTPCPerformanceSummary.cxx:178
 AliTPCPerformanceSummary.cxx:179
 AliTPCPerformanceSummary.cxx:180
 AliTPCPerformanceSummary.cxx:181
 AliTPCPerformanceSummary.cxx:182
 AliTPCPerformanceSummary.cxx:183
 AliTPCPerformanceSummary.cxx:184
 AliTPCPerformanceSummary.cxx:185
 AliTPCPerformanceSummary.cxx:186
 AliTPCPerformanceSummary.cxx:187
 AliTPCPerformanceSummary.cxx:188
 AliTPCPerformanceSummary.cxx:189
 AliTPCPerformanceSummary.cxx:190
 AliTPCPerformanceSummary.cxx:191
 AliTPCPerformanceSummary.cxx:192
 AliTPCPerformanceSummary.cxx:193
 AliTPCPerformanceSummary.cxx:194
 AliTPCPerformanceSummary.cxx:195
 AliTPCPerformanceSummary.cxx:196
 AliTPCPerformanceSummary.cxx:197
 AliTPCPerformanceSummary.cxx:198
 AliTPCPerformanceSummary.cxx:199
 AliTPCPerformanceSummary.cxx:200
 AliTPCPerformanceSummary.cxx:201
 AliTPCPerformanceSummary.cxx:202
 AliTPCPerformanceSummary.cxx:203
 AliTPCPerformanceSummary.cxx:204
 AliTPCPerformanceSummary.cxx:205
 AliTPCPerformanceSummary.cxx:206
 AliTPCPerformanceSummary.cxx:207
 AliTPCPerformanceSummary.cxx:208
 AliTPCPerformanceSummary.cxx:209
 AliTPCPerformanceSummary.cxx:210
 AliTPCPerformanceSummary.cxx:211
 AliTPCPerformanceSummary.cxx:212
 AliTPCPerformanceSummary.cxx:213
 AliTPCPerformanceSummary.cxx:214
 AliTPCPerformanceSummary.cxx:215
 AliTPCPerformanceSummary.cxx:216
 AliTPCPerformanceSummary.cxx:217
 AliTPCPerformanceSummary.cxx:218
 AliTPCPerformanceSummary.cxx:219
 AliTPCPerformanceSummary.cxx:220
 AliTPCPerformanceSummary.cxx:221
 AliTPCPerformanceSummary.cxx:222
 AliTPCPerformanceSummary.cxx:223
 AliTPCPerformanceSummary.cxx:224
 AliTPCPerformanceSummary.cxx:225
 AliTPCPerformanceSummary.cxx:226
 AliTPCPerformanceSummary.cxx:227
 AliTPCPerformanceSummary.cxx:228
 AliTPCPerformanceSummary.cxx:229
 AliTPCPerformanceSummary.cxx:230
 AliTPCPerformanceSummary.cxx:231
 AliTPCPerformanceSummary.cxx:232
 AliTPCPerformanceSummary.cxx:233
 AliTPCPerformanceSummary.cxx:234
 AliTPCPerformanceSummary.cxx:235
 AliTPCPerformanceSummary.cxx:236
 AliTPCPerformanceSummary.cxx:237
 AliTPCPerformanceSummary.cxx:238
 AliTPCPerformanceSummary.cxx:239
 AliTPCPerformanceSummary.cxx:240
 AliTPCPerformanceSummary.cxx:241
 AliTPCPerformanceSummary.cxx:242
 AliTPCPerformanceSummary.cxx:243
 AliTPCPerformanceSummary.cxx:244
 AliTPCPerformanceSummary.cxx:245
 AliTPCPerformanceSummary.cxx:246
 AliTPCPerformanceSummary.cxx:247
 AliTPCPerformanceSummary.cxx:248
 AliTPCPerformanceSummary.cxx:249
 AliTPCPerformanceSummary.cxx:250
 AliTPCPerformanceSummary.cxx:251
 AliTPCPerformanceSummary.cxx:252
 AliTPCPerformanceSummary.cxx:253
 AliTPCPerformanceSummary.cxx:254
 AliTPCPerformanceSummary.cxx:255
 AliTPCPerformanceSummary.cxx:256
 AliTPCPerformanceSummary.cxx:257
 AliTPCPerformanceSummary.cxx:258
 AliTPCPerformanceSummary.cxx:259
 AliTPCPerformanceSummary.cxx:260
 AliTPCPerformanceSummary.cxx:261
 AliTPCPerformanceSummary.cxx:262
 AliTPCPerformanceSummary.cxx:263
 AliTPCPerformanceSummary.cxx:264
 AliTPCPerformanceSummary.cxx:265
 AliTPCPerformanceSummary.cxx:266
 AliTPCPerformanceSummary.cxx:267
 AliTPCPerformanceSummary.cxx:268
 AliTPCPerformanceSummary.cxx:269
 AliTPCPerformanceSummary.cxx:270
 AliTPCPerformanceSummary.cxx:271
 AliTPCPerformanceSummary.cxx:272
 AliTPCPerformanceSummary.cxx:273
 AliTPCPerformanceSummary.cxx:274
 AliTPCPerformanceSummary.cxx:275
 AliTPCPerformanceSummary.cxx:276
 AliTPCPerformanceSummary.cxx:277
 AliTPCPerformanceSummary.cxx:278
 AliTPCPerformanceSummary.cxx:279
 AliTPCPerformanceSummary.cxx:280
 AliTPCPerformanceSummary.cxx:281
 AliTPCPerformanceSummary.cxx:282
 AliTPCPerformanceSummary.cxx:283
 AliTPCPerformanceSummary.cxx:284
 AliTPCPerformanceSummary.cxx:285
 AliTPCPerformanceSummary.cxx:286
 AliTPCPerformanceSummary.cxx:287
 AliTPCPerformanceSummary.cxx:288
 AliTPCPerformanceSummary.cxx:289
 AliTPCPerformanceSummary.cxx:290
 AliTPCPerformanceSummary.cxx:291
 AliTPCPerformanceSummary.cxx:292
 AliTPCPerformanceSummary.cxx:293
 AliTPCPerformanceSummary.cxx:294
 AliTPCPerformanceSummary.cxx:295
 AliTPCPerformanceSummary.cxx:296
 AliTPCPerformanceSummary.cxx:297
 AliTPCPerformanceSummary.cxx:298
 AliTPCPerformanceSummary.cxx:299
 AliTPCPerformanceSummary.cxx:300
 AliTPCPerformanceSummary.cxx:301
 AliTPCPerformanceSummary.cxx:302
 AliTPCPerformanceSummary.cxx:303
 AliTPCPerformanceSummary.cxx:304
 AliTPCPerformanceSummary.cxx:305
 AliTPCPerformanceSummary.cxx:306
 AliTPCPerformanceSummary.cxx:307
 AliTPCPerformanceSummary.cxx:308
 AliTPCPerformanceSummary.cxx:309
 AliTPCPerformanceSummary.cxx:310
 AliTPCPerformanceSummary.cxx:311
 AliTPCPerformanceSummary.cxx:312
 AliTPCPerformanceSummary.cxx:313
 AliTPCPerformanceSummary.cxx:314
 AliTPCPerformanceSummary.cxx:315
 AliTPCPerformanceSummary.cxx:316
 AliTPCPerformanceSummary.cxx:317
 AliTPCPerformanceSummary.cxx:318
 AliTPCPerformanceSummary.cxx:319
 AliTPCPerformanceSummary.cxx:320
 AliTPCPerformanceSummary.cxx:321
 AliTPCPerformanceSummary.cxx:322
 AliTPCPerformanceSummary.cxx:323
 AliTPCPerformanceSummary.cxx:324
 AliTPCPerformanceSummary.cxx:325
 AliTPCPerformanceSummary.cxx:326
 AliTPCPerformanceSummary.cxx:327
 AliTPCPerformanceSummary.cxx:328
 AliTPCPerformanceSummary.cxx:329
 AliTPCPerformanceSummary.cxx:330
 AliTPCPerformanceSummary.cxx:331
 AliTPCPerformanceSummary.cxx:332
 AliTPCPerformanceSummary.cxx:333
 AliTPCPerformanceSummary.cxx:334
 AliTPCPerformanceSummary.cxx:335
 AliTPCPerformanceSummary.cxx:336
 AliTPCPerformanceSummary.cxx:337
 AliTPCPerformanceSummary.cxx:338
 AliTPCPerformanceSummary.cxx:339
 AliTPCPerformanceSummary.cxx:340
 AliTPCPerformanceSummary.cxx:341
 AliTPCPerformanceSummary.cxx:342
 AliTPCPerformanceSummary.cxx:343
 AliTPCPerformanceSummary.cxx:344
 AliTPCPerformanceSummary.cxx:345
 AliTPCPerformanceSummary.cxx:346
 AliTPCPerformanceSummary.cxx:347
 AliTPCPerformanceSummary.cxx:348
 AliTPCPerformanceSummary.cxx:349
 AliTPCPerformanceSummary.cxx:350
 AliTPCPerformanceSummary.cxx:351
 AliTPCPerformanceSummary.cxx:352
 AliTPCPerformanceSummary.cxx:353
 AliTPCPerformanceSummary.cxx:354
 AliTPCPerformanceSummary.cxx:355
 AliTPCPerformanceSummary.cxx:356
 AliTPCPerformanceSummary.cxx:357
 AliTPCPerformanceSummary.cxx:358
 AliTPCPerformanceSummary.cxx:359
 AliTPCPerformanceSummary.cxx:360
 AliTPCPerformanceSummary.cxx:361
 AliTPCPerformanceSummary.cxx:362
 AliTPCPerformanceSummary.cxx:363
 AliTPCPerformanceSummary.cxx:364
 AliTPCPerformanceSummary.cxx:365
 AliTPCPerformanceSummary.cxx:366
 AliTPCPerformanceSummary.cxx:367
 AliTPCPerformanceSummary.cxx:368
 AliTPCPerformanceSummary.cxx:369
 AliTPCPerformanceSummary.cxx:370
 AliTPCPerformanceSummary.cxx:371
 AliTPCPerformanceSummary.cxx:372
 AliTPCPerformanceSummary.cxx:373
 AliTPCPerformanceSummary.cxx:374
 AliTPCPerformanceSummary.cxx:375
 AliTPCPerformanceSummary.cxx:376
 AliTPCPerformanceSummary.cxx:377
 AliTPCPerformanceSummary.cxx:378
 AliTPCPerformanceSummary.cxx:379
 AliTPCPerformanceSummary.cxx:380
 AliTPCPerformanceSummary.cxx:381
 AliTPCPerformanceSummary.cxx:382
 AliTPCPerformanceSummary.cxx:383
 AliTPCPerformanceSummary.cxx:384
 AliTPCPerformanceSummary.cxx:385
 AliTPCPerformanceSummary.cxx:386
 AliTPCPerformanceSummary.cxx:387
 AliTPCPerformanceSummary.cxx:388
 AliTPCPerformanceSummary.cxx:389
 AliTPCPerformanceSummary.cxx:390
 AliTPCPerformanceSummary.cxx:391
 AliTPCPerformanceSummary.cxx:392
 AliTPCPerformanceSummary.cxx:393
 AliTPCPerformanceSummary.cxx:394
 AliTPCPerformanceSummary.cxx:395
 AliTPCPerformanceSummary.cxx:396
 AliTPCPerformanceSummary.cxx:397
 AliTPCPerformanceSummary.cxx:398
 AliTPCPerformanceSummary.cxx:399
 AliTPCPerformanceSummary.cxx:400
 AliTPCPerformanceSummary.cxx:401
 AliTPCPerformanceSummary.cxx:402
 AliTPCPerformanceSummary.cxx:403
 AliTPCPerformanceSummary.cxx:404
 AliTPCPerformanceSummary.cxx:405
 AliTPCPerformanceSummary.cxx:406
 AliTPCPerformanceSummary.cxx:407
 AliTPCPerformanceSummary.cxx:408
 AliTPCPerformanceSummary.cxx:409
 AliTPCPerformanceSummary.cxx:410
 AliTPCPerformanceSummary.cxx:411
 AliTPCPerformanceSummary.cxx:412
 AliTPCPerformanceSummary.cxx:413
 AliTPCPerformanceSummary.cxx:414
 AliTPCPerformanceSummary.cxx:415
 AliTPCPerformanceSummary.cxx:416
 AliTPCPerformanceSummary.cxx:417
 AliTPCPerformanceSummary.cxx:418
 AliTPCPerformanceSummary.cxx:419
 AliTPCPerformanceSummary.cxx:420
 AliTPCPerformanceSummary.cxx:421
 AliTPCPerformanceSummary.cxx:422
 AliTPCPerformanceSummary.cxx:423
 AliTPCPerformanceSummary.cxx:424
 AliTPCPerformanceSummary.cxx:425
 AliTPCPerformanceSummary.cxx:426
 AliTPCPerformanceSummary.cxx:427
 AliTPCPerformanceSummary.cxx:428
 AliTPCPerformanceSummary.cxx:429
 AliTPCPerformanceSummary.cxx:430
 AliTPCPerformanceSummary.cxx:431
 AliTPCPerformanceSummary.cxx:432
 AliTPCPerformanceSummary.cxx:433
 AliTPCPerformanceSummary.cxx:434
 AliTPCPerformanceSummary.cxx:435
 AliTPCPerformanceSummary.cxx:436
 AliTPCPerformanceSummary.cxx:437
 AliTPCPerformanceSummary.cxx:438
 AliTPCPerformanceSummary.cxx:439
 AliTPCPerformanceSummary.cxx:440
 AliTPCPerformanceSummary.cxx:441
 AliTPCPerformanceSummary.cxx:442
 AliTPCPerformanceSummary.cxx:443
 AliTPCPerformanceSummary.cxx:444
 AliTPCPerformanceSummary.cxx:445
 AliTPCPerformanceSummary.cxx:446
 AliTPCPerformanceSummary.cxx:447
 AliTPCPerformanceSummary.cxx:448
 AliTPCPerformanceSummary.cxx:449
 AliTPCPerformanceSummary.cxx:450
 AliTPCPerformanceSummary.cxx:451
 AliTPCPerformanceSummary.cxx:452
 AliTPCPerformanceSummary.cxx:453
 AliTPCPerformanceSummary.cxx:454
 AliTPCPerformanceSummary.cxx:455
 AliTPCPerformanceSummary.cxx:456
 AliTPCPerformanceSummary.cxx:457
 AliTPCPerformanceSummary.cxx:458
 AliTPCPerformanceSummary.cxx:459
 AliTPCPerformanceSummary.cxx:460
 AliTPCPerformanceSummary.cxx:461
 AliTPCPerformanceSummary.cxx:462
 AliTPCPerformanceSummary.cxx:463
 AliTPCPerformanceSummary.cxx:464
 AliTPCPerformanceSummary.cxx:465
 AliTPCPerformanceSummary.cxx:466
 AliTPCPerformanceSummary.cxx:467
 AliTPCPerformanceSummary.cxx:468
 AliTPCPerformanceSummary.cxx:469
 AliTPCPerformanceSummary.cxx:470
 AliTPCPerformanceSummary.cxx:471
 AliTPCPerformanceSummary.cxx:472
 AliTPCPerformanceSummary.cxx:473
 AliTPCPerformanceSummary.cxx:474
 AliTPCPerformanceSummary.cxx:475
 AliTPCPerformanceSummary.cxx:476
 AliTPCPerformanceSummary.cxx:477
 AliTPCPerformanceSummary.cxx:478
 AliTPCPerformanceSummary.cxx:479
 AliTPCPerformanceSummary.cxx:480
 AliTPCPerformanceSummary.cxx:481
 AliTPCPerformanceSummary.cxx:482
 AliTPCPerformanceSummary.cxx:483
 AliTPCPerformanceSummary.cxx:484
 AliTPCPerformanceSummary.cxx:485
 AliTPCPerformanceSummary.cxx:486
 AliTPCPerformanceSummary.cxx:487
 AliTPCPerformanceSummary.cxx:488
 AliTPCPerformanceSummary.cxx:489
 AliTPCPerformanceSummary.cxx:490
 AliTPCPerformanceSummary.cxx:491
 AliTPCPerformanceSummary.cxx:492
 AliTPCPerformanceSummary.cxx:493
 AliTPCPerformanceSummary.cxx:494
 AliTPCPerformanceSummary.cxx:495
 AliTPCPerformanceSummary.cxx:496
 AliTPCPerformanceSummary.cxx:497
 AliTPCPerformanceSummary.cxx:498
 AliTPCPerformanceSummary.cxx:499
 AliTPCPerformanceSummary.cxx:500
 AliTPCPerformanceSummary.cxx:501
 AliTPCPerformanceSummary.cxx:502
 AliTPCPerformanceSummary.cxx:503
 AliTPCPerformanceSummary.cxx:504
 AliTPCPerformanceSummary.cxx:505
 AliTPCPerformanceSummary.cxx:506
 AliTPCPerformanceSummary.cxx:507
 AliTPCPerformanceSummary.cxx:508
 AliTPCPerformanceSummary.cxx:509
 AliTPCPerformanceSummary.cxx:510
 AliTPCPerformanceSummary.cxx:511
 AliTPCPerformanceSummary.cxx:512
 AliTPCPerformanceSummary.cxx:513
 AliTPCPerformanceSummary.cxx:514
 AliTPCPerformanceSummary.cxx:515
 AliTPCPerformanceSummary.cxx:516
 AliTPCPerformanceSummary.cxx:517
 AliTPCPerformanceSummary.cxx:518
 AliTPCPerformanceSummary.cxx:519
 AliTPCPerformanceSummary.cxx:520
 AliTPCPerformanceSummary.cxx:521
 AliTPCPerformanceSummary.cxx:522
 AliTPCPerformanceSummary.cxx:523
 AliTPCPerformanceSummary.cxx:524
 AliTPCPerformanceSummary.cxx:525
 AliTPCPerformanceSummary.cxx:526
 AliTPCPerformanceSummary.cxx:527
 AliTPCPerformanceSummary.cxx:528
 AliTPCPerformanceSummary.cxx:529
 AliTPCPerformanceSummary.cxx:530
 AliTPCPerformanceSummary.cxx:531
 AliTPCPerformanceSummary.cxx:532
 AliTPCPerformanceSummary.cxx:533
 AliTPCPerformanceSummary.cxx:534
 AliTPCPerformanceSummary.cxx:535
 AliTPCPerformanceSummary.cxx:536
 AliTPCPerformanceSummary.cxx:537
 AliTPCPerformanceSummary.cxx:538
 AliTPCPerformanceSummary.cxx:539
 AliTPCPerformanceSummary.cxx:540
 AliTPCPerformanceSummary.cxx:541
 AliTPCPerformanceSummary.cxx:542
 AliTPCPerformanceSummary.cxx:543
 AliTPCPerformanceSummary.cxx:544
 AliTPCPerformanceSummary.cxx:545
 AliTPCPerformanceSummary.cxx:546
 AliTPCPerformanceSummary.cxx:547
 AliTPCPerformanceSummary.cxx:548
 AliTPCPerformanceSummary.cxx:549
 AliTPCPerformanceSummary.cxx:550
 AliTPCPerformanceSummary.cxx:551
 AliTPCPerformanceSummary.cxx:552
 AliTPCPerformanceSummary.cxx:553
 AliTPCPerformanceSummary.cxx:554
 AliTPCPerformanceSummary.cxx:555
 AliTPCPerformanceSummary.cxx:556
 AliTPCPerformanceSummary.cxx:557
 AliTPCPerformanceSummary.cxx:558
 AliTPCPerformanceSummary.cxx:559
 AliTPCPerformanceSummary.cxx:560
 AliTPCPerformanceSummary.cxx:561
 AliTPCPerformanceSummary.cxx:562
 AliTPCPerformanceSummary.cxx:563
 AliTPCPerformanceSummary.cxx:564
 AliTPCPerformanceSummary.cxx:565
 AliTPCPerformanceSummary.cxx:566
 AliTPCPerformanceSummary.cxx:567
 AliTPCPerformanceSummary.cxx:568
 AliTPCPerformanceSummary.cxx:569
 AliTPCPerformanceSummary.cxx:570
 AliTPCPerformanceSummary.cxx:571
 AliTPCPerformanceSummary.cxx:572
 AliTPCPerformanceSummary.cxx:573
 AliTPCPerformanceSummary.cxx:574
 AliTPCPerformanceSummary.cxx:575
 AliTPCPerformanceSummary.cxx:576
 AliTPCPerformanceSummary.cxx:577
 AliTPCPerformanceSummary.cxx:578
 AliTPCPerformanceSummary.cxx:579
 AliTPCPerformanceSummary.cxx:580
 AliTPCPerformanceSummary.cxx:581
 AliTPCPerformanceSummary.cxx:582
 AliTPCPerformanceSummary.cxx:583
 AliTPCPerformanceSummary.cxx:584
 AliTPCPerformanceSummary.cxx:585
 AliTPCPerformanceSummary.cxx:586
 AliTPCPerformanceSummary.cxx:587
 AliTPCPerformanceSummary.cxx:588
 AliTPCPerformanceSummary.cxx:589
 AliTPCPerformanceSummary.cxx:590
 AliTPCPerformanceSummary.cxx:591
 AliTPCPerformanceSummary.cxx:592
 AliTPCPerformanceSummary.cxx:593
 AliTPCPerformanceSummary.cxx:594
 AliTPCPerformanceSummary.cxx:595
 AliTPCPerformanceSummary.cxx:596
 AliTPCPerformanceSummary.cxx:597
 AliTPCPerformanceSummary.cxx:598
 AliTPCPerformanceSummary.cxx:599
 AliTPCPerformanceSummary.cxx:600
 AliTPCPerformanceSummary.cxx:601
 AliTPCPerformanceSummary.cxx:602
 AliTPCPerformanceSummary.cxx:603
 AliTPCPerformanceSummary.cxx:604
 AliTPCPerformanceSummary.cxx:605
 AliTPCPerformanceSummary.cxx:606
 AliTPCPerformanceSummary.cxx:607
 AliTPCPerformanceSummary.cxx:608
 AliTPCPerformanceSummary.cxx:609
 AliTPCPerformanceSummary.cxx:610
 AliTPCPerformanceSummary.cxx:611
 AliTPCPerformanceSummary.cxx:612
 AliTPCPerformanceSummary.cxx:613
 AliTPCPerformanceSummary.cxx:614
 AliTPCPerformanceSummary.cxx:615
 AliTPCPerformanceSummary.cxx:616
 AliTPCPerformanceSummary.cxx:617
 AliTPCPerformanceSummary.cxx:618
 AliTPCPerformanceSummary.cxx:619
 AliTPCPerformanceSummary.cxx:620
 AliTPCPerformanceSummary.cxx:621
 AliTPCPerformanceSummary.cxx:622
 AliTPCPerformanceSummary.cxx:623
 AliTPCPerformanceSummary.cxx:624
 AliTPCPerformanceSummary.cxx:625
 AliTPCPerformanceSummary.cxx:626
 AliTPCPerformanceSummary.cxx:627
 AliTPCPerformanceSummary.cxx:628
 AliTPCPerformanceSummary.cxx:629
 AliTPCPerformanceSummary.cxx:630
 AliTPCPerformanceSummary.cxx:631
 AliTPCPerformanceSummary.cxx:632
 AliTPCPerformanceSummary.cxx:633
 AliTPCPerformanceSummary.cxx:634
 AliTPCPerformanceSummary.cxx:635
 AliTPCPerformanceSummary.cxx:636
 AliTPCPerformanceSummary.cxx:637
 AliTPCPerformanceSummary.cxx:638
 AliTPCPerformanceSummary.cxx:639
 AliTPCPerformanceSummary.cxx:640
 AliTPCPerformanceSummary.cxx:641
 AliTPCPerformanceSummary.cxx:642
 AliTPCPerformanceSummary.cxx:643
 AliTPCPerformanceSummary.cxx:644
 AliTPCPerformanceSummary.cxx:645
 AliTPCPerformanceSummary.cxx:646
 AliTPCPerformanceSummary.cxx:647
 AliTPCPerformanceSummary.cxx:648
 AliTPCPerformanceSummary.cxx:649
 AliTPCPerformanceSummary.cxx:650
 AliTPCPerformanceSummary.cxx:651
 AliTPCPerformanceSummary.cxx:652
 AliTPCPerformanceSummary.cxx:653
 AliTPCPerformanceSummary.cxx:654
 AliTPCPerformanceSummary.cxx:655
 AliTPCPerformanceSummary.cxx:656
 AliTPCPerformanceSummary.cxx:657
 AliTPCPerformanceSummary.cxx:658
 AliTPCPerformanceSummary.cxx:659
 AliTPCPerformanceSummary.cxx:660
 AliTPCPerformanceSummary.cxx:661
 AliTPCPerformanceSummary.cxx:662
 AliTPCPerformanceSummary.cxx:663
 AliTPCPerformanceSummary.cxx:664
 AliTPCPerformanceSummary.cxx:665
 AliTPCPerformanceSummary.cxx:666
 AliTPCPerformanceSummary.cxx:667
 AliTPCPerformanceSummary.cxx:668
 AliTPCPerformanceSummary.cxx:669
 AliTPCPerformanceSummary.cxx:670
 AliTPCPerformanceSummary.cxx:671
 AliTPCPerformanceSummary.cxx:672
 AliTPCPerformanceSummary.cxx:673
 AliTPCPerformanceSummary.cxx:674
 AliTPCPerformanceSummary.cxx:675
 AliTPCPerformanceSummary.cxx:676
 AliTPCPerformanceSummary.cxx:677
 AliTPCPerformanceSummary.cxx:678
 AliTPCPerformanceSummary.cxx:679
 AliTPCPerformanceSummary.cxx:680
 AliTPCPerformanceSummary.cxx:681
 AliTPCPerformanceSummary.cxx:682
 AliTPCPerformanceSummary.cxx:683
 AliTPCPerformanceSummary.cxx:684
 AliTPCPerformanceSummary.cxx:685
 AliTPCPerformanceSummary.cxx:686
 AliTPCPerformanceSummary.cxx:687
 AliTPCPerformanceSummary.cxx:688
 AliTPCPerformanceSummary.cxx:689
 AliTPCPerformanceSummary.cxx:690
 AliTPCPerformanceSummary.cxx:691
 AliTPCPerformanceSummary.cxx:692
 AliTPCPerformanceSummary.cxx:693
 AliTPCPerformanceSummary.cxx:694
 AliTPCPerformanceSummary.cxx:695
 AliTPCPerformanceSummary.cxx:696
 AliTPCPerformanceSummary.cxx:697
 AliTPCPerformanceSummary.cxx:698
 AliTPCPerformanceSummary.cxx:699
 AliTPCPerformanceSummary.cxx:700
 AliTPCPerformanceSummary.cxx:701
 AliTPCPerformanceSummary.cxx:702
 AliTPCPerformanceSummary.cxx:703
 AliTPCPerformanceSummary.cxx:704
 AliTPCPerformanceSummary.cxx:705
 AliTPCPerformanceSummary.cxx:706
 AliTPCPerformanceSummary.cxx:707
 AliTPCPerformanceSummary.cxx:708
 AliTPCPerformanceSummary.cxx:709
 AliTPCPerformanceSummary.cxx:710
 AliTPCPerformanceSummary.cxx:711
 AliTPCPerformanceSummary.cxx:712
 AliTPCPerformanceSummary.cxx:713
 AliTPCPerformanceSummary.cxx:714
 AliTPCPerformanceSummary.cxx:715
 AliTPCPerformanceSummary.cxx:716
 AliTPCPerformanceSummary.cxx:717
 AliTPCPerformanceSummary.cxx:718
 AliTPCPerformanceSummary.cxx:719
 AliTPCPerformanceSummary.cxx:720
 AliTPCPerformanceSummary.cxx:721
 AliTPCPerformanceSummary.cxx:722
 AliTPCPerformanceSummary.cxx:723
 AliTPCPerformanceSummary.cxx:724
 AliTPCPerformanceSummary.cxx:725
 AliTPCPerformanceSummary.cxx:726
 AliTPCPerformanceSummary.cxx:727
 AliTPCPerformanceSummary.cxx:728
 AliTPCPerformanceSummary.cxx:729
 AliTPCPerformanceSummary.cxx:730
 AliTPCPerformanceSummary.cxx:731
 AliTPCPerformanceSummary.cxx:732
 AliTPCPerformanceSummary.cxx:733
 AliTPCPerformanceSummary.cxx:734
 AliTPCPerformanceSummary.cxx:735
 AliTPCPerformanceSummary.cxx:736
 AliTPCPerformanceSummary.cxx:737
 AliTPCPerformanceSummary.cxx:738
 AliTPCPerformanceSummary.cxx:739
 AliTPCPerformanceSummary.cxx:740
 AliTPCPerformanceSummary.cxx:741
 AliTPCPerformanceSummary.cxx:742
 AliTPCPerformanceSummary.cxx:743
 AliTPCPerformanceSummary.cxx:744
 AliTPCPerformanceSummary.cxx:745
 AliTPCPerformanceSummary.cxx:746
 AliTPCPerformanceSummary.cxx:747
 AliTPCPerformanceSummary.cxx:748
 AliTPCPerformanceSummary.cxx:749
 AliTPCPerformanceSummary.cxx:750
 AliTPCPerformanceSummary.cxx:751
 AliTPCPerformanceSummary.cxx:752
 AliTPCPerformanceSummary.cxx:753
 AliTPCPerformanceSummary.cxx:754
 AliTPCPerformanceSummary.cxx:755
 AliTPCPerformanceSummary.cxx:756
 AliTPCPerformanceSummary.cxx:757
 AliTPCPerformanceSummary.cxx:758
 AliTPCPerformanceSummary.cxx:759
 AliTPCPerformanceSummary.cxx:760
 AliTPCPerformanceSummary.cxx:761
 AliTPCPerformanceSummary.cxx:762
 AliTPCPerformanceSummary.cxx:763
 AliTPCPerformanceSummary.cxx:764
 AliTPCPerformanceSummary.cxx:765
 AliTPCPerformanceSummary.cxx:766
 AliTPCPerformanceSummary.cxx:767
 AliTPCPerformanceSummary.cxx:768
 AliTPCPerformanceSummary.cxx:769
 AliTPCPerformanceSummary.cxx:770
 AliTPCPerformanceSummary.cxx:771
 AliTPCPerformanceSummary.cxx:772
 AliTPCPerformanceSummary.cxx:773
 AliTPCPerformanceSummary.cxx:774
 AliTPCPerformanceSummary.cxx:775
 AliTPCPerformanceSummary.cxx:776
 AliTPCPerformanceSummary.cxx:777
 AliTPCPerformanceSummary.cxx:778
 AliTPCPerformanceSummary.cxx:779
 AliTPCPerformanceSummary.cxx:780
 AliTPCPerformanceSummary.cxx:781
 AliTPCPerformanceSummary.cxx:782
 AliTPCPerformanceSummary.cxx:783
 AliTPCPerformanceSummary.cxx:784
 AliTPCPerformanceSummary.cxx:785
 AliTPCPerformanceSummary.cxx:786
 AliTPCPerformanceSummary.cxx:787
 AliTPCPerformanceSummary.cxx:788
 AliTPCPerformanceSummary.cxx:789
 AliTPCPerformanceSummary.cxx:790
 AliTPCPerformanceSummary.cxx:791
 AliTPCPerformanceSummary.cxx:792
 AliTPCPerformanceSummary.cxx:793
 AliTPCPerformanceSummary.cxx:794
 AliTPCPerformanceSummary.cxx:795
 AliTPCPerformanceSummary.cxx:796
 AliTPCPerformanceSummary.cxx:797
 AliTPCPerformanceSummary.cxx:798
 AliTPCPerformanceSummary.cxx:799
 AliTPCPerformanceSummary.cxx:800
 AliTPCPerformanceSummary.cxx:801
 AliTPCPerformanceSummary.cxx:802
 AliTPCPerformanceSummary.cxx:803
 AliTPCPerformanceSummary.cxx:804
 AliTPCPerformanceSummary.cxx:805
 AliTPCPerformanceSummary.cxx:806
 AliTPCPerformanceSummary.cxx:807
 AliTPCPerformanceSummary.cxx:808
 AliTPCPerformanceSummary.cxx:809
 AliTPCPerformanceSummary.cxx:810
 AliTPCPerformanceSummary.cxx:811
 AliTPCPerformanceSummary.cxx:812
 AliTPCPerformanceSummary.cxx:813
 AliTPCPerformanceSummary.cxx:814
 AliTPCPerformanceSummary.cxx:815
 AliTPCPerformanceSummary.cxx:816
 AliTPCPerformanceSummary.cxx:817
 AliTPCPerformanceSummary.cxx:818
 AliTPCPerformanceSummary.cxx:819
 AliTPCPerformanceSummary.cxx:820
 AliTPCPerformanceSummary.cxx:821
 AliTPCPerformanceSummary.cxx:822
 AliTPCPerformanceSummary.cxx:823
 AliTPCPerformanceSummary.cxx:824
 AliTPCPerformanceSummary.cxx:825
 AliTPCPerformanceSummary.cxx:826
 AliTPCPerformanceSummary.cxx:827
 AliTPCPerformanceSummary.cxx:828
 AliTPCPerformanceSummary.cxx:829
 AliTPCPerformanceSummary.cxx:830
 AliTPCPerformanceSummary.cxx:831
 AliTPCPerformanceSummary.cxx:832
 AliTPCPerformanceSummary.cxx:833
 AliTPCPerformanceSummary.cxx:834
 AliTPCPerformanceSummary.cxx:835
 AliTPCPerformanceSummary.cxx:836
 AliTPCPerformanceSummary.cxx:837
 AliTPCPerformanceSummary.cxx:838
 AliTPCPerformanceSummary.cxx:839
 AliTPCPerformanceSummary.cxx:840
 AliTPCPerformanceSummary.cxx:841
 AliTPCPerformanceSummary.cxx:842
 AliTPCPerformanceSummary.cxx:843
 AliTPCPerformanceSummary.cxx:844
 AliTPCPerformanceSummary.cxx:845
 AliTPCPerformanceSummary.cxx:846
 AliTPCPerformanceSummary.cxx:847
 AliTPCPerformanceSummary.cxx:848
 AliTPCPerformanceSummary.cxx:849
 AliTPCPerformanceSummary.cxx:850
 AliTPCPerformanceSummary.cxx:851
 AliTPCPerformanceSummary.cxx:852
 AliTPCPerformanceSummary.cxx:853
 AliTPCPerformanceSummary.cxx:854
 AliTPCPerformanceSummary.cxx:855
 AliTPCPerformanceSummary.cxx:856
 AliTPCPerformanceSummary.cxx:857
 AliTPCPerformanceSummary.cxx:858
 AliTPCPerformanceSummary.cxx:859
 AliTPCPerformanceSummary.cxx:860
 AliTPCPerformanceSummary.cxx:861
 AliTPCPerformanceSummary.cxx:862
 AliTPCPerformanceSummary.cxx:863
 AliTPCPerformanceSummary.cxx:864
 AliTPCPerformanceSummary.cxx:865
 AliTPCPerformanceSummary.cxx:866
 AliTPCPerformanceSummary.cxx:867
 AliTPCPerformanceSummary.cxx:868
 AliTPCPerformanceSummary.cxx:869
 AliTPCPerformanceSummary.cxx:870
 AliTPCPerformanceSummary.cxx:871
 AliTPCPerformanceSummary.cxx:872
 AliTPCPerformanceSummary.cxx:873
 AliTPCPerformanceSummary.cxx:874
 AliTPCPerformanceSummary.cxx:875
 AliTPCPerformanceSummary.cxx:876
 AliTPCPerformanceSummary.cxx:877
 AliTPCPerformanceSummary.cxx:878
 AliTPCPerformanceSummary.cxx:879
 AliTPCPerformanceSummary.cxx:880
 AliTPCPerformanceSummary.cxx:881
 AliTPCPerformanceSummary.cxx:882
 AliTPCPerformanceSummary.cxx:883
 AliTPCPerformanceSummary.cxx:884
 AliTPCPerformanceSummary.cxx:885
 AliTPCPerformanceSummary.cxx:886
 AliTPCPerformanceSummary.cxx:887
 AliTPCPerformanceSummary.cxx:888
 AliTPCPerformanceSummary.cxx:889
 AliTPCPerformanceSummary.cxx:890
 AliTPCPerformanceSummary.cxx:891
 AliTPCPerformanceSummary.cxx:892
 AliTPCPerformanceSummary.cxx:893
 AliTPCPerformanceSummary.cxx:894
 AliTPCPerformanceSummary.cxx:895
 AliTPCPerformanceSummary.cxx:896
 AliTPCPerformanceSummary.cxx:897
 AliTPCPerformanceSummary.cxx:898
 AliTPCPerformanceSummary.cxx:899
 AliTPCPerformanceSummary.cxx:900
 AliTPCPerformanceSummary.cxx:901
 AliTPCPerformanceSummary.cxx:902
 AliTPCPerformanceSummary.cxx:903
 AliTPCPerformanceSummary.cxx:904
 AliTPCPerformanceSummary.cxx:905
 AliTPCPerformanceSummary.cxx:906
 AliTPCPerformanceSummary.cxx:907
 AliTPCPerformanceSummary.cxx:908
 AliTPCPerformanceSummary.cxx:909
 AliTPCPerformanceSummary.cxx:910
 AliTPCPerformanceSummary.cxx:911
 AliTPCPerformanceSummary.cxx:912
 AliTPCPerformanceSummary.cxx:913
 AliTPCPerformanceSummary.cxx:914
 AliTPCPerformanceSummary.cxx:915
 AliTPCPerformanceSummary.cxx:916
 AliTPCPerformanceSummary.cxx:917
 AliTPCPerformanceSummary.cxx:918
 AliTPCPerformanceSummary.cxx:919
 AliTPCPerformanceSummary.cxx:920
 AliTPCPerformanceSummary.cxx:921
 AliTPCPerformanceSummary.cxx:922
 AliTPCPerformanceSummary.cxx:923
 AliTPCPerformanceSummary.cxx:924
 AliTPCPerformanceSummary.cxx:925
 AliTPCPerformanceSummary.cxx:926
 AliTPCPerformanceSummary.cxx:927
 AliTPCPerformanceSummary.cxx:928
 AliTPCPerformanceSummary.cxx:929
 AliTPCPerformanceSummary.cxx:930
 AliTPCPerformanceSummary.cxx:931
 AliTPCPerformanceSummary.cxx:932
 AliTPCPerformanceSummary.cxx:933
 AliTPCPerformanceSummary.cxx:934
 AliTPCPerformanceSummary.cxx:935
 AliTPCPerformanceSummary.cxx:936
 AliTPCPerformanceSummary.cxx:937
 AliTPCPerformanceSummary.cxx:938
 AliTPCPerformanceSummary.cxx:939
 AliTPCPerformanceSummary.cxx:940
 AliTPCPerformanceSummary.cxx:941
 AliTPCPerformanceSummary.cxx:942
 AliTPCPerformanceSummary.cxx:943
 AliTPCPerformanceSummary.cxx:944
 AliTPCPerformanceSummary.cxx:945
 AliTPCPerformanceSummary.cxx:946
 AliTPCPerformanceSummary.cxx:947
 AliTPCPerformanceSummary.cxx:948
 AliTPCPerformanceSummary.cxx:949
 AliTPCPerformanceSummary.cxx:950
 AliTPCPerformanceSummary.cxx:951
 AliTPCPerformanceSummary.cxx:952
 AliTPCPerformanceSummary.cxx:953
 AliTPCPerformanceSummary.cxx:954
 AliTPCPerformanceSummary.cxx:955
 AliTPCPerformanceSummary.cxx:956
 AliTPCPerformanceSummary.cxx:957
 AliTPCPerformanceSummary.cxx:958
 AliTPCPerformanceSummary.cxx:959
 AliTPCPerformanceSummary.cxx:960
 AliTPCPerformanceSummary.cxx:961
 AliTPCPerformanceSummary.cxx:962
 AliTPCPerformanceSummary.cxx:963
 AliTPCPerformanceSummary.cxx:964
 AliTPCPerformanceSummary.cxx:965
 AliTPCPerformanceSummary.cxx:966
 AliTPCPerformanceSummary.cxx:967
 AliTPCPerformanceSummary.cxx:968
 AliTPCPerformanceSummary.cxx:969
 AliTPCPerformanceSummary.cxx:970
 AliTPCPerformanceSummary.cxx:971
 AliTPCPerformanceSummary.cxx:972
 AliTPCPerformanceSummary.cxx:973
 AliTPCPerformanceSummary.cxx:974
 AliTPCPerformanceSummary.cxx:975
 AliTPCPerformanceSummary.cxx:976
 AliTPCPerformanceSummary.cxx:977
 AliTPCPerformanceSummary.cxx:978
 AliTPCPerformanceSummary.cxx:979
 AliTPCPerformanceSummary.cxx:980
 AliTPCPerformanceSummary.cxx:981
 AliTPCPerformanceSummary.cxx:982
 AliTPCPerformanceSummary.cxx:983
 AliTPCPerformanceSummary.cxx:984
 AliTPCPerformanceSummary.cxx:985
 AliTPCPerformanceSummary.cxx:986
 AliTPCPerformanceSummary.cxx:987
 AliTPCPerformanceSummary.cxx:988
 AliTPCPerformanceSummary.cxx:989
 AliTPCPerformanceSummary.cxx:990
 AliTPCPerformanceSummary.cxx:991
 AliTPCPerformanceSummary.cxx:992
 AliTPCPerformanceSummary.cxx:993
 AliTPCPerformanceSummary.cxx:994
 AliTPCPerformanceSummary.cxx:995
 AliTPCPerformanceSummary.cxx:996
 AliTPCPerformanceSummary.cxx:997
 AliTPCPerformanceSummary.cxx:998
 AliTPCPerformanceSummary.cxx:999
 AliTPCPerformanceSummary.cxx:1000
 AliTPCPerformanceSummary.cxx:1001
 AliTPCPerformanceSummary.cxx:1002
 AliTPCPerformanceSummary.cxx:1003
 AliTPCPerformanceSummary.cxx:1004
 AliTPCPerformanceSummary.cxx:1005
 AliTPCPerformanceSummary.cxx:1006
 AliTPCPerformanceSummary.cxx:1007
 AliTPCPerformanceSummary.cxx:1008
 AliTPCPerformanceSummary.cxx:1009
 AliTPCPerformanceSummary.cxx:1010
 AliTPCPerformanceSummary.cxx:1011
 AliTPCPerformanceSummary.cxx:1012
 AliTPCPerformanceSummary.cxx:1013
 AliTPCPerformanceSummary.cxx:1014
 AliTPCPerformanceSummary.cxx:1015
 AliTPCPerformanceSummary.cxx:1016
 AliTPCPerformanceSummary.cxx:1017
 AliTPCPerformanceSummary.cxx:1018
 AliTPCPerformanceSummary.cxx:1019
 AliTPCPerformanceSummary.cxx:1020
 AliTPCPerformanceSummary.cxx:1021
 AliTPCPerformanceSummary.cxx:1022
 AliTPCPerformanceSummary.cxx:1023
 AliTPCPerformanceSummary.cxx:1024
 AliTPCPerformanceSummary.cxx:1025
 AliTPCPerformanceSummary.cxx:1026
 AliTPCPerformanceSummary.cxx:1027
 AliTPCPerformanceSummary.cxx:1028
 AliTPCPerformanceSummary.cxx:1029
 AliTPCPerformanceSummary.cxx:1030
 AliTPCPerformanceSummary.cxx:1031
 AliTPCPerformanceSummary.cxx:1032
 AliTPCPerformanceSummary.cxx:1033
 AliTPCPerformanceSummary.cxx:1034
 AliTPCPerformanceSummary.cxx:1035
 AliTPCPerformanceSummary.cxx:1036
 AliTPCPerformanceSummary.cxx:1037
 AliTPCPerformanceSummary.cxx:1038
 AliTPCPerformanceSummary.cxx:1039
 AliTPCPerformanceSummary.cxx:1040
 AliTPCPerformanceSummary.cxx:1041
 AliTPCPerformanceSummary.cxx:1042
 AliTPCPerformanceSummary.cxx:1043
 AliTPCPerformanceSummary.cxx:1044
 AliTPCPerformanceSummary.cxx:1045
 AliTPCPerformanceSummary.cxx:1046
 AliTPCPerformanceSummary.cxx:1047
 AliTPCPerformanceSummary.cxx:1048
 AliTPCPerformanceSummary.cxx:1049
 AliTPCPerformanceSummary.cxx:1050
 AliTPCPerformanceSummary.cxx:1051
 AliTPCPerformanceSummary.cxx:1052
 AliTPCPerformanceSummary.cxx:1053
 AliTPCPerformanceSummary.cxx:1054
 AliTPCPerformanceSummary.cxx:1055
 AliTPCPerformanceSummary.cxx:1056
 AliTPCPerformanceSummary.cxx:1057
 AliTPCPerformanceSummary.cxx:1058
 AliTPCPerformanceSummary.cxx:1059
 AliTPCPerformanceSummary.cxx:1060
 AliTPCPerformanceSummary.cxx:1061
 AliTPCPerformanceSummary.cxx:1062
 AliTPCPerformanceSummary.cxx:1063
 AliTPCPerformanceSummary.cxx:1064
 AliTPCPerformanceSummary.cxx:1065
 AliTPCPerformanceSummary.cxx:1066
 AliTPCPerformanceSummary.cxx:1067
 AliTPCPerformanceSummary.cxx:1068
 AliTPCPerformanceSummary.cxx:1069
 AliTPCPerformanceSummary.cxx:1070
 AliTPCPerformanceSummary.cxx:1071
 AliTPCPerformanceSummary.cxx:1072
 AliTPCPerformanceSummary.cxx:1073
 AliTPCPerformanceSummary.cxx:1074
 AliTPCPerformanceSummary.cxx:1075
 AliTPCPerformanceSummary.cxx:1076
 AliTPCPerformanceSummary.cxx:1077
 AliTPCPerformanceSummary.cxx:1078
 AliTPCPerformanceSummary.cxx:1079
 AliTPCPerformanceSummary.cxx:1080
 AliTPCPerformanceSummary.cxx:1081
 AliTPCPerformanceSummary.cxx:1082
 AliTPCPerformanceSummary.cxx:1083
 AliTPCPerformanceSummary.cxx:1084
 AliTPCPerformanceSummary.cxx:1085
 AliTPCPerformanceSummary.cxx:1086
 AliTPCPerformanceSummary.cxx:1087
 AliTPCPerformanceSummary.cxx:1088
 AliTPCPerformanceSummary.cxx:1089
 AliTPCPerformanceSummary.cxx:1090
 AliTPCPerformanceSummary.cxx:1091
 AliTPCPerformanceSummary.cxx:1092
 AliTPCPerformanceSummary.cxx:1093
 AliTPCPerformanceSummary.cxx:1094
 AliTPCPerformanceSummary.cxx:1095
 AliTPCPerformanceSummary.cxx:1096
 AliTPCPerformanceSummary.cxx:1097
 AliTPCPerformanceSummary.cxx:1098
 AliTPCPerformanceSummary.cxx:1099
 AliTPCPerformanceSummary.cxx:1100
 AliTPCPerformanceSummary.cxx:1101
 AliTPCPerformanceSummary.cxx:1102
 AliTPCPerformanceSummary.cxx:1103
 AliTPCPerformanceSummary.cxx:1104
 AliTPCPerformanceSummary.cxx:1105
 AliTPCPerformanceSummary.cxx:1106
 AliTPCPerformanceSummary.cxx:1107
 AliTPCPerformanceSummary.cxx:1108
 AliTPCPerformanceSummary.cxx:1109
 AliTPCPerformanceSummary.cxx:1110
 AliTPCPerformanceSummary.cxx:1111
 AliTPCPerformanceSummary.cxx:1112
 AliTPCPerformanceSummary.cxx:1113
 AliTPCPerformanceSummary.cxx:1114
 AliTPCPerformanceSummary.cxx:1115
 AliTPCPerformanceSummary.cxx:1116
 AliTPCPerformanceSummary.cxx:1117
 AliTPCPerformanceSummary.cxx:1118
 AliTPCPerformanceSummary.cxx:1119
 AliTPCPerformanceSummary.cxx:1120
 AliTPCPerformanceSummary.cxx:1121
 AliTPCPerformanceSummary.cxx:1122
 AliTPCPerformanceSummary.cxx:1123
 AliTPCPerformanceSummary.cxx:1124
 AliTPCPerformanceSummary.cxx:1125
 AliTPCPerformanceSummary.cxx:1126
 AliTPCPerformanceSummary.cxx:1127
 AliTPCPerformanceSummary.cxx:1128
 AliTPCPerformanceSummary.cxx:1129
 AliTPCPerformanceSummary.cxx:1130
 AliTPCPerformanceSummary.cxx:1131
 AliTPCPerformanceSummary.cxx:1132
 AliTPCPerformanceSummary.cxx:1133
 AliTPCPerformanceSummary.cxx:1134
 AliTPCPerformanceSummary.cxx:1135
 AliTPCPerformanceSummary.cxx:1136
 AliTPCPerformanceSummary.cxx:1137
 AliTPCPerformanceSummary.cxx:1138
 AliTPCPerformanceSummary.cxx:1139
 AliTPCPerformanceSummary.cxx:1140
 AliTPCPerformanceSummary.cxx:1141
 AliTPCPerformanceSummary.cxx:1142
 AliTPCPerformanceSummary.cxx:1143
 AliTPCPerformanceSummary.cxx:1144
 AliTPCPerformanceSummary.cxx:1145
 AliTPCPerformanceSummary.cxx:1146
 AliTPCPerformanceSummary.cxx:1147
 AliTPCPerformanceSummary.cxx:1148
 AliTPCPerformanceSummary.cxx:1149
 AliTPCPerformanceSummary.cxx:1150
 AliTPCPerformanceSummary.cxx:1151
 AliTPCPerformanceSummary.cxx:1152
 AliTPCPerformanceSummary.cxx:1153
 AliTPCPerformanceSummary.cxx:1154
 AliTPCPerformanceSummary.cxx:1155
 AliTPCPerformanceSummary.cxx:1156
 AliTPCPerformanceSummary.cxx:1157
 AliTPCPerformanceSummary.cxx:1158
 AliTPCPerformanceSummary.cxx:1159
 AliTPCPerformanceSummary.cxx:1160
 AliTPCPerformanceSummary.cxx:1161
 AliTPCPerformanceSummary.cxx:1162
 AliTPCPerformanceSummary.cxx:1163
 AliTPCPerformanceSummary.cxx:1164
 AliTPCPerformanceSummary.cxx:1165
 AliTPCPerformanceSummary.cxx:1166
 AliTPCPerformanceSummary.cxx:1167
 AliTPCPerformanceSummary.cxx:1168
 AliTPCPerformanceSummary.cxx:1169
 AliTPCPerformanceSummary.cxx:1170
 AliTPCPerformanceSummary.cxx:1171
 AliTPCPerformanceSummary.cxx:1172
 AliTPCPerformanceSummary.cxx:1173
 AliTPCPerformanceSummary.cxx:1174
 AliTPCPerformanceSummary.cxx:1175
 AliTPCPerformanceSummary.cxx:1176
 AliTPCPerformanceSummary.cxx:1177
 AliTPCPerformanceSummary.cxx:1178
 AliTPCPerformanceSummary.cxx:1179
 AliTPCPerformanceSummary.cxx:1180
 AliTPCPerformanceSummary.cxx:1181
 AliTPCPerformanceSummary.cxx:1182
 AliTPCPerformanceSummary.cxx:1183
 AliTPCPerformanceSummary.cxx:1184
 AliTPCPerformanceSummary.cxx:1185
 AliTPCPerformanceSummary.cxx:1186
 AliTPCPerformanceSummary.cxx:1187
 AliTPCPerformanceSummary.cxx:1188
 AliTPCPerformanceSummary.cxx:1189
 AliTPCPerformanceSummary.cxx:1190
 AliTPCPerformanceSummary.cxx:1191
 AliTPCPerformanceSummary.cxx:1192
 AliTPCPerformanceSummary.cxx:1193
 AliTPCPerformanceSummary.cxx:1194
 AliTPCPerformanceSummary.cxx:1195
 AliTPCPerformanceSummary.cxx:1196
 AliTPCPerformanceSummary.cxx:1197
 AliTPCPerformanceSummary.cxx:1198
 AliTPCPerformanceSummary.cxx:1199
 AliTPCPerformanceSummary.cxx:1200
 AliTPCPerformanceSummary.cxx:1201
 AliTPCPerformanceSummary.cxx:1202
 AliTPCPerformanceSummary.cxx:1203
 AliTPCPerformanceSummary.cxx:1204
 AliTPCPerformanceSummary.cxx:1205
 AliTPCPerformanceSummary.cxx:1206
 AliTPCPerformanceSummary.cxx:1207
 AliTPCPerformanceSummary.cxx:1208
 AliTPCPerformanceSummary.cxx:1209
 AliTPCPerformanceSummary.cxx:1210
 AliTPCPerformanceSummary.cxx:1211
 AliTPCPerformanceSummary.cxx:1212
 AliTPCPerformanceSummary.cxx:1213
 AliTPCPerformanceSummary.cxx:1214
 AliTPCPerformanceSummary.cxx:1215
 AliTPCPerformanceSummary.cxx:1216
 AliTPCPerformanceSummary.cxx:1217
 AliTPCPerformanceSummary.cxx:1218
 AliTPCPerformanceSummary.cxx:1219
 AliTPCPerformanceSummary.cxx:1220
 AliTPCPerformanceSummary.cxx:1221
 AliTPCPerformanceSummary.cxx:1222
 AliTPCPerformanceSummary.cxx:1223
 AliTPCPerformanceSummary.cxx:1224
 AliTPCPerformanceSummary.cxx:1225
 AliTPCPerformanceSummary.cxx:1226
 AliTPCPerformanceSummary.cxx:1227
 AliTPCPerformanceSummary.cxx:1228
 AliTPCPerformanceSummary.cxx:1229
 AliTPCPerformanceSummary.cxx:1230
 AliTPCPerformanceSummary.cxx:1231
 AliTPCPerformanceSummary.cxx:1232
 AliTPCPerformanceSummary.cxx:1233
 AliTPCPerformanceSummary.cxx:1234
 AliTPCPerformanceSummary.cxx:1235
 AliTPCPerformanceSummary.cxx:1236
 AliTPCPerformanceSummary.cxx:1237
 AliTPCPerformanceSummary.cxx:1238
 AliTPCPerformanceSummary.cxx:1239
 AliTPCPerformanceSummary.cxx:1240
 AliTPCPerformanceSummary.cxx:1241
 AliTPCPerformanceSummary.cxx:1242
 AliTPCPerformanceSummary.cxx:1243
 AliTPCPerformanceSummary.cxx:1244
 AliTPCPerformanceSummary.cxx:1245
 AliTPCPerformanceSummary.cxx:1246
 AliTPCPerformanceSummary.cxx:1247
 AliTPCPerformanceSummary.cxx:1248
 AliTPCPerformanceSummary.cxx:1249
 AliTPCPerformanceSummary.cxx:1250
 AliTPCPerformanceSummary.cxx:1251
 AliTPCPerformanceSummary.cxx:1252
 AliTPCPerformanceSummary.cxx:1253
 AliTPCPerformanceSummary.cxx:1254
 AliTPCPerformanceSummary.cxx:1255
 AliTPCPerformanceSummary.cxx:1256
 AliTPCPerformanceSummary.cxx:1257
 AliTPCPerformanceSummary.cxx:1258
 AliTPCPerformanceSummary.cxx:1259
 AliTPCPerformanceSummary.cxx:1260
 AliTPCPerformanceSummary.cxx:1261
 AliTPCPerformanceSummary.cxx:1262
 AliTPCPerformanceSummary.cxx:1263
 AliTPCPerformanceSummary.cxx:1264
 AliTPCPerformanceSummary.cxx:1265
 AliTPCPerformanceSummary.cxx:1266
 AliTPCPerformanceSummary.cxx:1267
 AliTPCPerformanceSummary.cxx:1268
 AliTPCPerformanceSummary.cxx:1269
 AliTPCPerformanceSummary.cxx:1270
 AliTPCPerformanceSummary.cxx:1271
 AliTPCPerformanceSummary.cxx:1272
 AliTPCPerformanceSummary.cxx:1273
 AliTPCPerformanceSummary.cxx:1274
 AliTPCPerformanceSummary.cxx:1275
 AliTPCPerformanceSummary.cxx:1276
 AliTPCPerformanceSummary.cxx:1277
 AliTPCPerformanceSummary.cxx:1278
 AliTPCPerformanceSummary.cxx:1279
 AliTPCPerformanceSummary.cxx:1280
 AliTPCPerformanceSummary.cxx:1281
 AliTPCPerformanceSummary.cxx:1282
 AliTPCPerformanceSummary.cxx:1283
 AliTPCPerformanceSummary.cxx:1284
 AliTPCPerformanceSummary.cxx:1285
 AliTPCPerformanceSummary.cxx:1286
 AliTPCPerformanceSummary.cxx:1287
 AliTPCPerformanceSummary.cxx:1288
 AliTPCPerformanceSummary.cxx:1289
 AliTPCPerformanceSummary.cxx:1290
 AliTPCPerformanceSummary.cxx:1291
 AliTPCPerformanceSummary.cxx:1292
 AliTPCPerformanceSummary.cxx:1293
 AliTPCPerformanceSummary.cxx:1294
 AliTPCPerformanceSummary.cxx:1295
 AliTPCPerformanceSummary.cxx:1296
 AliTPCPerformanceSummary.cxx:1297
 AliTPCPerformanceSummary.cxx:1298
 AliTPCPerformanceSummary.cxx:1299
 AliTPCPerformanceSummary.cxx:1300
 AliTPCPerformanceSummary.cxx:1301
 AliTPCPerformanceSummary.cxx:1302
 AliTPCPerformanceSummary.cxx:1303
 AliTPCPerformanceSummary.cxx:1304
 AliTPCPerformanceSummary.cxx:1305
 AliTPCPerformanceSummary.cxx:1306
 AliTPCPerformanceSummary.cxx:1307
 AliTPCPerformanceSummary.cxx:1308
 AliTPCPerformanceSummary.cxx:1309
 AliTPCPerformanceSummary.cxx:1310
 AliTPCPerformanceSummary.cxx:1311
 AliTPCPerformanceSummary.cxx:1312
 AliTPCPerformanceSummary.cxx:1313
 AliTPCPerformanceSummary.cxx:1314
 AliTPCPerformanceSummary.cxx:1315
 AliTPCPerformanceSummary.cxx:1316
 AliTPCPerformanceSummary.cxx:1317
 AliTPCPerformanceSummary.cxx:1318
 AliTPCPerformanceSummary.cxx:1319
 AliTPCPerformanceSummary.cxx:1320
 AliTPCPerformanceSummary.cxx:1321
 AliTPCPerformanceSummary.cxx:1322
 AliTPCPerformanceSummary.cxx:1323
 AliTPCPerformanceSummary.cxx:1324
 AliTPCPerformanceSummary.cxx:1325
 AliTPCPerformanceSummary.cxx:1326
 AliTPCPerformanceSummary.cxx:1327
 AliTPCPerformanceSummary.cxx:1328
 AliTPCPerformanceSummary.cxx:1329
 AliTPCPerformanceSummary.cxx:1330
 AliTPCPerformanceSummary.cxx:1331
 AliTPCPerformanceSummary.cxx:1332
 AliTPCPerformanceSummary.cxx:1333
 AliTPCPerformanceSummary.cxx:1334
 AliTPCPerformanceSummary.cxx:1335
 AliTPCPerformanceSummary.cxx:1336
 AliTPCPerformanceSummary.cxx:1337
 AliTPCPerformanceSummary.cxx:1338
 AliTPCPerformanceSummary.cxx:1339
 AliTPCPerformanceSummary.cxx:1340
 AliTPCPerformanceSummary.cxx:1341
 AliTPCPerformanceSummary.cxx:1342
 AliTPCPerformanceSummary.cxx:1343
 AliTPCPerformanceSummary.cxx:1344
 AliTPCPerformanceSummary.cxx:1345
 AliTPCPerformanceSummary.cxx:1346
 AliTPCPerformanceSummary.cxx:1347
 AliTPCPerformanceSummary.cxx:1348
 AliTPCPerformanceSummary.cxx:1349
 AliTPCPerformanceSummary.cxx:1350
 AliTPCPerformanceSummary.cxx:1351
 AliTPCPerformanceSummary.cxx:1352
 AliTPCPerformanceSummary.cxx:1353
 AliTPCPerformanceSummary.cxx:1354
 AliTPCPerformanceSummary.cxx:1355
 AliTPCPerformanceSummary.cxx:1356
 AliTPCPerformanceSummary.cxx:1357
 AliTPCPerformanceSummary.cxx:1358
 AliTPCPerformanceSummary.cxx:1359
 AliTPCPerformanceSummary.cxx:1360
 AliTPCPerformanceSummary.cxx:1361
 AliTPCPerformanceSummary.cxx:1362
 AliTPCPerformanceSummary.cxx:1363
 AliTPCPerformanceSummary.cxx:1364
 AliTPCPerformanceSummary.cxx:1365
 AliTPCPerformanceSummary.cxx:1366
 AliTPCPerformanceSummary.cxx:1367
 AliTPCPerformanceSummary.cxx:1368
 AliTPCPerformanceSummary.cxx:1369
 AliTPCPerformanceSummary.cxx:1370
 AliTPCPerformanceSummary.cxx:1371
 AliTPCPerformanceSummary.cxx:1372
 AliTPCPerformanceSummary.cxx:1373
 AliTPCPerformanceSummary.cxx:1374
 AliTPCPerformanceSummary.cxx:1375
 AliTPCPerformanceSummary.cxx:1376
 AliTPCPerformanceSummary.cxx:1377
 AliTPCPerformanceSummary.cxx:1378
 AliTPCPerformanceSummary.cxx:1379
 AliTPCPerformanceSummary.cxx:1380
 AliTPCPerformanceSummary.cxx:1381
 AliTPCPerformanceSummary.cxx:1382
 AliTPCPerformanceSummary.cxx:1383
 AliTPCPerformanceSummary.cxx:1384
 AliTPCPerformanceSummary.cxx:1385
 AliTPCPerformanceSummary.cxx:1386
 AliTPCPerformanceSummary.cxx:1387
 AliTPCPerformanceSummary.cxx:1388
 AliTPCPerformanceSummary.cxx:1389
 AliTPCPerformanceSummary.cxx:1390
 AliTPCPerformanceSummary.cxx:1391
 AliTPCPerformanceSummary.cxx:1392
 AliTPCPerformanceSummary.cxx:1393
 AliTPCPerformanceSummary.cxx:1394
 AliTPCPerformanceSummary.cxx:1395
 AliTPCPerformanceSummary.cxx:1396
 AliTPCPerformanceSummary.cxx:1397
 AliTPCPerformanceSummary.cxx:1398
 AliTPCPerformanceSummary.cxx:1399
 AliTPCPerformanceSummary.cxx:1400
 AliTPCPerformanceSummary.cxx:1401
 AliTPCPerformanceSummary.cxx:1402
 AliTPCPerformanceSummary.cxx:1403
 AliTPCPerformanceSummary.cxx:1404
 AliTPCPerformanceSummary.cxx:1405
 AliTPCPerformanceSummary.cxx:1406
 AliTPCPerformanceSummary.cxx:1407
 AliTPCPerformanceSummary.cxx:1408
 AliTPCPerformanceSummary.cxx:1409
 AliTPCPerformanceSummary.cxx:1410
 AliTPCPerformanceSummary.cxx:1411
 AliTPCPerformanceSummary.cxx:1412
 AliTPCPerformanceSummary.cxx:1413
 AliTPCPerformanceSummary.cxx:1414
 AliTPCPerformanceSummary.cxx:1415
 AliTPCPerformanceSummary.cxx:1416
 AliTPCPerformanceSummary.cxx:1417
 AliTPCPerformanceSummary.cxx:1418
 AliTPCPerformanceSummary.cxx:1419
 AliTPCPerformanceSummary.cxx:1420
 AliTPCPerformanceSummary.cxx:1421
 AliTPCPerformanceSummary.cxx:1422
 AliTPCPerformanceSummary.cxx:1423
 AliTPCPerformanceSummary.cxx:1424
 AliTPCPerformanceSummary.cxx:1425
 AliTPCPerformanceSummary.cxx:1426
 AliTPCPerformanceSummary.cxx:1427
 AliTPCPerformanceSummary.cxx:1428
 AliTPCPerformanceSummary.cxx:1429
 AliTPCPerformanceSummary.cxx:1430
 AliTPCPerformanceSummary.cxx:1431
 AliTPCPerformanceSummary.cxx:1432
 AliTPCPerformanceSummary.cxx:1433
 AliTPCPerformanceSummary.cxx:1434
 AliTPCPerformanceSummary.cxx:1435
 AliTPCPerformanceSummary.cxx:1436
 AliTPCPerformanceSummary.cxx:1437
 AliTPCPerformanceSummary.cxx:1438
 AliTPCPerformanceSummary.cxx:1439
 AliTPCPerformanceSummary.cxx:1440
 AliTPCPerformanceSummary.cxx:1441
 AliTPCPerformanceSummary.cxx:1442
 AliTPCPerformanceSummary.cxx:1443
 AliTPCPerformanceSummary.cxx:1444
 AliTPCPerformanceSummary.cxx:1445
 AliTPCPerformanceSummary.cxx:1446
 AliTPCPerformanceSummary.cxx:1447
 AliTPCPerformanceSummary.cxx:1448
 AliTPCPerformanceSummary.cxx:1449
 AliTPCPerformanceSummary.cxx:1450
 AliTPCPerformanceSummary.cxx:1451
 AliTPCPerformanceSummary.cxx:1452
 AliTPCPerformanceSummary.cxx:1453
 AliTPCPerformanceSummary.cxx:1454
 AliTPCPerformanceSummary.cxx:1455
 AliTPCPerformanceSummary.cxx:1456
 AliTPCPerformanceSummary.cxx:1457
 AliTPCPerformanceSummary.cxx:1458
 AliTPCPerformanceSummary.cxx:1459
 AliTPCPerformanceSummary.cxx:1460
 AliTPCPerformanceSummary.cxx:1461
 AliTPCPerformanceSummary.cxx:1462
 AliTPCPerformanceSummary.cxx:1463
 AliTPCPerformanceSummary.cxx:1464
 AliTPCPerformanceSummary.cxx:1465
 AliTPCPerformanceSummary.cxx:1466
 AliTPCPerformanceSummary.cxx:1467
 AliTPCPerformanceSummary.cxx:1468
 AliTPCPerformanceSummary.cxx:1469
 AliTPCPerformanceSummary.cxx:1470
 AliTPCPerformanceSummary.cxx:1471
 AliTPCPerformanceSummary.cxx:1472
 AliTPCPerformanceSummary.cxx:1473
 AliTPCPerformanceSummary.cxx:1474
 AliTPCPerformanceSummary.cxx:1475
 AliTPCPerformanceSummary.cxx:1476
 AliTPCPerformanceSummary.cxx:1477
 AliTPCPerformanceSummary.cxx:1478
 AliTPCPerformanceSummary.cxx:1479
 AliTPCPerformanceSummary.cxx:1480
 AliTPCPerformanceSummary.cxx:1481
 AliTPCPerformanceSummary.cxx:1482
 AliTPCPerformanceSummary.cxx:1483
 AliTPCPerformanceSummary.cxx:1484
 AliTPCPerformanceSummary.cxx:1485
 AliTPCPerformanceSummary.cxx:1486
 AliTPCPerformanceSummary.cxx:1487
 AliTPCPerformanceSummary.cxx:1488
 AliTPCPerformanceSummary.cxx:1489
 AliTPCPerformanceSummary.cxx:1490
 AliTPCPerformanceSummary.cxx:1491
 AliTPCPerformanceSummary.cxx:1492
 AliTPCPerformanceSummary.cxx:1493
 AliTPCPerformanceSummary.cxx:1494
 AliTPCPerformanceSummary.cxx:1495
 AliTPCPerformanceSummary.cxx:1496
 AliTPCPerformanceSummary.cxx:1497
 AliTPCPerformanceSummary.cxx:1498
 AliTPCPerformanceSummary.cxx:1499
 AliTPCPerformanceSummary.cxx:1500
 AliTPCPerformanceSummary.cxx:1501
 AliTPCPerformanceSummary.cxx:1502
 AliTPCPerformanceSummary.cxx:1503
 AliTPCPerformanceSummary.cxx:1504
 AliTPCPerformanceSummary.cxx:1505
 AliTPCPerformanceSummary.cxx:1506
 AliTPCPerformanceSummary.cxx:1507
 AliTPCPerformanceSummary.cxx:1508
 AliTPCPerformanceSummary.cxx:1509
 AliTPCPerformanceSummary.cxx:1510
 AliTPCPerformanceSummary.cxx:1511
 AliTPCPerformanceSummary.cxx:1512
 AliTPCPerformanceSummary.cxx:1513
 AliTPCPerformanceSummary.cxx:1514
 AliTPCPerformanceSummary.cxx:1515
 AliTPCPerformanceSummary.cxx:1516
 AliTPCPerformanceSummary.cxx:1517
 AliTPCPerformanceSummary.cxx:1518
 AliTPCPerformanceSummary.cxx:1519
 AliTPCPerformanceSummary.cxx:1520
 AliTPCPerformanceSummary.cxx:1521
 AliTPCPerformanceSummary.cxx:1522
 AliTPCPerformanceSummary.cxx:1523
 AliTPCPerformanceSummary.cxx:1524
 AliTPCPerformanceSummary.cxx:1525
 AliTPCPerformanceSummary.cxx:1526
 AliTPCPerformanceSummary.cxx:1527
 AliTPCPerformanceSummary.cxx:1528
 AliTPCPerformanceSummary.cxx:1529
 AliTPCPerformanceSummary.cxx:1530
 AliTPCPerformanceSummary.cxx:1531
 AliTPCPerformanceSummary.cxx:1532
 AliTPCPerformanceSummary.cxx:1533
 AliTPCPerformanceSummary.cxx:1534
 AliTPCPerformanceSummary.cxx:1535
 AliTPCPerformanceSummary.cxx:1536
 AliTPCPerformanceSummary.cxx:1537
 AliTPCPerformanceSummary.cxx:1538
 AliTPCPerformanceSummary.cxx:1539
 AliTPCPerformanceSummary.cxx:1540
 AliTPCPerformanceSummary.cxx:1541
 AliTPCPerformanceSummary.cxx:1542
 AliTPCPerformanceSummary.cxx:1543
 AliTPCPerformanceSummary.cxx:1544
 AliTPCPerformanceSummary.cxx:1545
 AliTPCPerformanceSummary.cxx:1546
 AliTPCPerformanceSummary.cxx:1547
 AliTPCPerformanceSummary.cxx:1548
 AliTPCPerformanceSummary.cxx:1549
 AliTPCPerformanceSummary.cxx:1550
 AliTPCPerformanceSummary.cxx:1551
 AliTPCPerformanceSummary.cxx:1552
 AliTPCPerformanceSummary.cxx:1553
 AliTPCPerformanceSummary.cxx:1554
 AliTPCPerformanceSummary.cxx:1555
 AliTPCPerformanceSummary.cxx:1556
 AliTPCPerformanceSummary.cxx:1557
 AliTPCPerformanceSummary.cxx:1558
 AliTPCPerformanceSummary.cxx:1559
 AliTPCPerformanceSummary.cxx:1560
 AliTPCPerformanceSummary.cxx:1561
 AliTPCPerformanceSummary.cxx:1562
 AliTPCPerformanceSummary.cxx:1563
 AliTPCPerformanceSummary.cxx:1564
 AliTPCPerformanceSummary.cxx:1565
 AliTPCPerformanceSummary.cxx:1566
 AliTPCPerformanceSummary.cxx:1567
 AliTPCPerformanceSummary.cxx:1568
 AliTPCPerformanceSummary.cxx:1569
 AliTPCPerformanceSummary.cxx:1570
 AliTPCPerformanceSummary.cxx:1571
 AliTPCPerformanceSummary.cxx:1572
 AliTPCPerformanceSummary.cxx:1573
 AliTPCPerformanceSummary.cxx:1574
 AliTPCPerformanceSummary.cxx:1575
 AliTPCPerformanceSummary.cxx:1576
 AliTPCPerformanceSummary.cxx:1577
 AliTPCPerformanceSummary.cxx:1578
 AliTPCPerformanceSummary.cxx:1579
 AliTPCPerformanceSummary.cxx:1580
 AliTPCPerformanceSummary.cxx:1581
 AliTPCPerformanceSummary.cxx:1582
 AliTPCPerformanceSummary.cxx:1583
 AliTPCPerformanceSummary.cxx:1584
 AliTPCPerformanceSummary.cxx:1585
 AliTPCPerformanceSummary.cxx:1586
 AliTPCPerformanceSummary.cxx:1587
 AliTPCPerformanceSummary.cxx:1588
 AliTPCPerformanceSummary.cxx:1589
 AliTPCPerformanceSummary.cxx:1590
 AliTPCPerformanceSummary.cxx:1591
 AliTPCPerformanceSummary.cxx:1592
 AliTPCPerformanceSummary.cxx:1593
 AliTPCPerformanceSummary.cxx:1594
 AliTPCPerformanceSummary.cxx:1595
 AliTPCPerformanceSummary.cxx:1596
 AliTPCPerformanceSummary.cxx:1597
 AliTPCPerformanceSummary.cxx:1598
 AliTPCPerformanceSummary.cxx:1599
 AliTPCPerformanceSummary.cxx:1600
 AliTPCPerformanceSummary.cxx:1601
 AliTPCPerformanceSummary.cxx:1602
 AliTPCPerformanceSummary.cxx:1603
 AliTPCPerformanceSummary.cxx:1604
 AliTPCPerformanceSummary.cxx:1605
 AliTPCPerformanceSummary.cxx:1606
 AliTPCPerformanceSummary.cxx:1607
 AliTPCPerformanceSummary.cxx:1608
 AliTPCPerformanceSummary.cxx:1609
 AliTPCPerformanceSummary.cxx:1610
 AliTPCPerformanceSummary.cxx:1611
 AliTPCPerformanceSummary.cxx:1612
 AliTPCPerformanceSummary.cxx:1613
 AliTPCPerformanceSummary.cxx:1614
 AliTPCPerformanceSummary.cxx:1615
 AliTPCPerformanceSummary.cxx:1616
 AliTPCPerformanceSummary.cxx:1617
 AliTPCPerformanceSummary.cxx:1618
 AliTPCPerformanceSummary.cxx:1619
 AliTPCPerformanceSummary.cxx:1620
 AliTPCPerformanceSummary.cxx:1621
 AliTPCPerformanceSummary.cxx:1622
 AliTPCPerformanceSummary.cxx:1623
 AliTPCPerformanceSummary.cxx:1624
 AliTPCPerformanceSummary.cxx:1625
 AliTPCPerformanceSummary.cxx:1626
 AliTPCPerformanceSummary.cxx:1627
 AliTPCPerformanceSummary.cxx:1628
 AliTPCPerformanceSummary.cxx:1629
 AliTPCPerformanceSummary.cxx:1630
 AliTPCPerformanceSummary.cxx:1631
 AliTPCPerformanceSummary.cxx:1632
 AliTPCPerformanceSummary.cxx:1633
 AliTPCPerformanceSummary.cxx:1634
 AliTPCPerformanceSummary.cxx:1635
 AliTPCPerformanceSummary.cxx:1636
 AliTPCPerformanceSummary.cxx:1637
 AliTPCPerformanceSummary.cxx:1638
 AliTPCPerformanceSummary.cxx:1639
 AliTPCPerformanceSummary.cxx:1640
 AliTPCPerformanceSummary.cxx:1641
 AliTPCPerformanceSummary.cxx:1642
 AliTPCPerformanceSummary.cxx:1643
 AliTPCPerformanceSummary.cxx:1644
 AliTPCPerformanceSummary.cxx:1645
 AliTPCPerformanceSummary.cxx:1646
 AliTPCPerformanceSummary.cxx:1647
 AliTPCPerformanceSummary.cxx:1648
 AliTPCPerformanceSummary.cxx:1649
 AliTPCPerformanceSummary.cxx:1650
 AliTPCPerformanceSummary.cxx:1651
 AliTPCPerformanceSummary.cxx:1652
 AliTPCPerformanceSummary.cxx:1653
 AliTPCPerformanceSummary.cxx:1654
 AliTPCPerformanceSummary.cxx:1655
 AliTPCPerformanceSummary.cxx:1656
 AliTPCPerformanceSummary.cxx:1657
 AliTPCPerformanceSummary.cxx:1658
 AliTPCPerformanceSummary.cxx:1659
 AliTPCPerformanceSummary.cxx:1660
 AliTPCPerformanceSummary.cxx:1661
 AliTPCPerformanceSummary.cxx:1662
 AliTPCPerformanceSummary.cxx:1663
 AliTPCPerformanceSummary.cxx:1664
 AliTPCPerformanceSummary.cxx:1665
 AliTPCPerformanceSummary.cxx:1666
 AliTPCPerformanceSummary.cxx:1667
 AliTPCPerformanceSummary.cxx:1668
 AliTPCPerformanceSummary.cxx:1669
 AliTPCPerformanceSummary.cxx:1670
 AliTPCPerformanceSummary.cxx:1671
 AliTPCPerformanceSummary.cxx:1672
 AliTPCPerformanceSummary.cxx:1673
 AliTPCPerformanceSummary.cxx:1674
 AliTPCPerformanceSummary.cxx:1675
 AliTPCPerformanceSummary.cxx:1676
 AliTPCPerformanceSummary.cxx:1677
 AliTPCPerformanceSummary.cxx:1678
 AliTPCPerformanceSummary.cxx:1679
 AliTPCPerformanceSummary.cxx:1680
 AliTPCPerformanceSummary.cxx:1681
 AliTPCPerformanceSummary.cxx:1682
 AliTPCPerformanceSummary.cxx:1683
 AliTPCPerformanceSummary.cxx:1684
 AliTPCPerformanceSummary.cxx:1685
 AliTPCPerformanceSummary.cxx:1686
 AliTPCPerformanceSummary.cxx:1687
 AliTPCPerformanceSummary.cxx:1688
 AliTPCPerformanceSummary.cxx:1689
 AliTPCPerformanceSummary.cxx:1690
 AliTPCPerformanceSummary.cxx:1691
 AliTPCPerformanceSummary.cxx:1692
 AliTPCPerformanceSummary.cxx:1693
 AliTPCPerformanceSummary.cxx:1694
 AliTPCPerformanceSummary.cxx:1695
 AliTPCPerformanceSummary.cxx:1696
 AliTPCPerformanceSummary.cxx:1697
 AliTPCPerformanceSummary.cxx:1698
 AliTPCPerformanceSummary.cxx:1699
 AliTPCPerformanceSummary.cxx:1700
 AliTPCPerformanceSummary.cxx:1701
 AliTPCPerformanceSummary.cxx:1702
 AliTPCPerformanceSummary.cxx:1703
 AliTPCPerformanceSummary.cxx:1704
 AliTPCPerformanceSummary.cxx:1705
 AliTPCPerformanceSummary.cxx:1706
 AliTPCPerformanceSummary.cxx:1707
 AliTPCPerformanceSummary.cxx:1708
 AliTPCPerformanceSummary.cxx:1709
 AliTPCPerformanceSummary.cxx:1710
 AliTPCPerformanceSummary.cxx:1711
 AliTPCPerformanceSummary.cxx:1712
 AliTPCPerformanceSummary.cxx:1713
 AliTPCPerformanceSummary.cxx:1714
 AliTPCPerformanceSummary.cxx:1715
 AliTPCPerformanceSummary.cxx:1716
 AliTPCPerformanceSummary.cxx:1717
 AliTPCPerformanceSummary.cxx:1718
 AliTPCPerformanceSummary.cxx:1719
 AliTPCPerformanceSummary.cxx:1720
 AliTPCPerformanceSummary.cxx:1721
 AliTPCPerformanceSummary.cxx:1722
 AliTPCPerformanceSummary.cxx:1723
 AliTPCPerformanceSummary.cxx:1724
 AliTPCPerformanceSummary.cxx:1725
 AliTPCPerformanceSummary.cxx:1726
 AliTPCPerformanceSummary.cxx:1727
 AliTPCPerformanceSummary.cxx:1728
 AliTPCPerformanceSummary.cxx:1729
 AliTPCPerformanceSummary.cxx:1730
 AliTPCPerformanceSummary.cxx:1731
 AliTPCPerformanceSummary.cxx:1732
 AliTPCPerformanceSummary.cxx:1733
 AliTPCPerformanceSummary.cxx:1734
 AliTPCPerformanceSummary.cxx:1735
 AliTPCPerformanceSummary.cxx:1736
 AliTPCPerformanceSummary.cxx:1737
 AliTPCPerformanceSummary.cxx:1738
 AliTPCPerformanceSummary.cxx:1739
 AliTPCPerformanceSummary.cxx:1740
 AliTPCPerformanceSummary.cxx:1741
 AliTPCPerformanceSummary.cxx:1742
 AliTPCPerformanceSummary.cxx:1743
 AliTPCPerformanceSummary.cxx:1744
 AliTPCPerformanceSummary.cxx:1745
 AliTPCPerformanceSummary.cxx:1746
 AliTPCPerformanceSummary.cxx:1747
 AliTPCPerformanceSummary.cxx:1748
 AliTPCPerformanceSummary.cxx:1749
 AliTPCPerformanceSummary.cxx:1750
 AliTPCPerformanceSummary.cxx:1751
 AliTPCPerformanceSummary.cxx:1752
 AliTPCPerformanceSummary.cxx:1753
 AliTPCPerformanceSummary.cxx:1754
 AliTPCPerformanceSummary.cxx:1755
 AliTPCPerformanceSummary.cxx:1756
 AliTPCPerformanceSummary.cxx:1757
 AliTPCPerformanceSummary.cxx:1758
 AliTPCPerformanceSummary.cxx:1759
 AliTPCPerformanceSummary.cxx:1760
 AliTPCPerformanceSummary.cxx:1761
 AliTPCPerformanceSummary.cxx:1762
 AliTPCPerformanceSummary.cxx:1763
 AliTPCPerformanceSummary.cxx:1764
 AliTPCPerformanceSummary.cxx:1765
 AliTPCPerformanceSummary.cxx:1766
 AliTPCPerformanceSummary.cxx:1767
 AliTPCPerformanceSummary.cxx:1768
 AliTPCPerformanceSummary.cxx:1769
 AliTPCPerformanceSummary.cxx:1770
 AliTPCPerformanceSummary.cxx:1771
 AliTPCPerformanceSummary.cxx:1772
 AliTPCPerformanceSummary.cxx:1773
 AliTPCPerformanceSummary.cxx:1774
 AliTPCPerformanceSummary.cxx:1775
 AliTPCPerformanceSummary.cxx:1776
 AliTPCPerformanceSummary.cxx:1777
 AliTPCPerformanceSummary.cxx:1778
 AliTPCPerformanceSummary.cxx:1779
 AliTPCPerformanceSummary.cxx:1780
 AliTPCPerformanceSummary.cxx:1781
 AliTPCPerformanceSummary.cxx:1782
 AliTPCPerformanceSummary.cxx:1783
 AliTPCPerformanceSummary.cxx:1784
 AliTPCPerformanceSummary.cxx:1785
 AliTPCPerformanceSummary.cxx:1786
 AliTPCPerformanceSummary.cxx:1787
 AliTPCPerformanceSummary.cxx:1788
 AliTPCPerformanceSummary.cxx:1789
 AliTPCPerformanceSummary.cxx:1790
 AliTPCPerformanceSummary.cxx:1791
 AliTPCPerformanceSummary.cxx:1792
 AliTPCPerformanceSummary.cxx:1793
 AliTPCPerformanceSummary.cxx:1794
 AliTPCPerformanceSummary.cxx:1795
 AliTPCPerformanceSummary.cxx:1796
 AliTPCPerformanceSummary.cxx:1797
 AliTPCPerformanceSummary.cxx:1798
 AliTPCPerformanceSummary.cxx:1799
 AliTPCPerformanceSummary.cxx:1800
 AliTPCPerformanceSummary.cxx:1801
 AliTPCPerformanceSummary.cxx:1802
 AliTPCPerformanceSummary.cxx:1803
 AliTPCPerformanceSummary.cxx:1804
 AliTPCPerformanceSummary.cxx:1805
 AliTPCPerformanceSummary.cxx:1806
 AliTPCPerformanceSummary.cxx:1807
 AliTPCPerformanceSummary.cxx:1808
 AliTPCPerformanceSummary.cxx:1809
 AliTPCPerformanceSummary.cxx:1810
 AliTPCPerformanceSummary.cxx:1811
 AliTPCPerformanceSummary.cxx:1812
 AliTPCPerformanceSummary.cxx:1813
 AliTPCPerformanceSummary.cxx:1814
 AliTPCPerformanceSummary.cxx:1815
 AliTPCPerformanceSummary.cxx:1816
 AliTPCPerformanceSummary.cxx:1817
 AliTPCPerformanceSummary.cxx:1818
 AliTPCPerformanceSummary.cxx:1819
 AliTPCPerformanceSummary.cxx:1820
 AliTPCPerformanceSummary.cxx:1821
 AliTPCPerformanceSummary.cxx:1822
 AliTPCPerformanceSummary.cxx:1823
 AliTPCPerformanceSummary.cxx:1824
 AliTPCPerformanceSummary.cxx:1825
 AliTPCPerformanceSummary.cxx:1826
 AliTPCPerformanceSummary.cxx:1827
 AliTPCPerformanceSummary.cxx:1828
 AliTPCPerformanceSummary.cxx:1829
 AliTPCPerformanceSummary.cxx:1830
 AliTPCPerformanceSummary.cxx:1831
 AliTPCPerformanceSummary.cxx:1832
 AliTPCPerformanceSummary.cxx:1833
 AliTPCPerformanceSummary.cxx:1834
 AliTPCPerformanceSummary.cxx:1835
 AliTPCPerformanceSummary.cxx:1836
 AliTPCPerformanceSummary.cxx:1837
 AliTPCPerformanceSummary.cxx:1838
 AliTPCPerformanceSummary.cxx:1839
 AliTPCPerformanceSummary.cxx:1840
 AliTPCPerformanceSummary.cxx:1841
 AliTPCPerformanceSummary.cxx:1842
 AliTPCPerformanceSummary.cxx:1843
 AliTPCPerformanceSummary.cxx:1844
 AliTPCPerformanceSummary.cxx:1845
 AliTPCPerformanceSummary.cxx:1846
 AliTPCPerformanceSummary.cxx:1847
 AliTPCPerformanceSummary.cxx:1848
 AliTPCPerformanceSummary.cxx:1849
 AliTPCPerformanceSummary.cxx:1850
 AliTPCPerformanceSummary.cxx:1851
 AliTPCPerformanceSummary.cxx:1852
 AliTPCPerformanceSummary.cxx:1853
 AliTPCPerformanceSummary.cxx:1854
 AliTPCPerformanceSummary.cxx:1855
 AliTPCPerformanceSummary.cxx:1856
 AliTPCPerformanceSummary.cxx:1857
 AliTPCPerformanceSummary.cxx:1858
 AliTPCPerformanceSummary.cxx:1859
 AliTPCPerformanceSummary.cxx:1860
 AliTPCPerformanceSummary.cxx:1861
 AliTPCPerformanceSummary.cxx:1862
 AliTPCPerformanceSummary.cxx:1863
 AliTPCPerformanceSummary.cxx:1864
 AliTPCPerformanceSummary.cxx:1865
 AliTPCPerformanceSummary.cxx:1866
 AliTPCPerformanceSummary.cxx:1867
 AliTPCPerformanceSummary.cxx:1868
 AliTPCPerformanceSummary.cxx:1869
 AliTPCPerformanceSummary.cxx:1870
 AliTPCPerformanceSummary.cxx:1871
 AliTPCPerformanceSummary.cxx:1872
 AliTPCPerformanceSummary.cxx:1873
 AliTPCPerformanceSummary.cxx:1874
 AliTPCPerformanceSummary.cxx:1875
 AliTPCPerformanceSummary.cxx:1876
 AliTPCPerformanceSummary.cxx:1877
 AliTPCPerformanceSummary.cxx:1878
 AliTPCPerformanceSummary.cxx:1879
 AliTPCPerformanceSummary.cxx:1880
 AliTPCPerformanceSummary.cxx:1881
 AliTPCPerformanceSummary.cxx:1882
 AliTPCPerformanceSummary.cxx:1883
 AliTPCPerformanceSummary.cxx:1884
 AliTPCPerformanceSummary.cxx:1885
 AliTPCPerformanceSummary.cxx:1886
 AliTPCPerformanceSummary.cxx:1887
 AliTPCPerformanceSummary.cxx:1888
 AliTPCPerformanceSummary.cxx:1889
 AliTPCPerformanceSummary.cxx:1890
 AliTPCPerformanceSummary.cxx:1891
 AliTPCPerformanceSummary.cxx:1892
 AliTPCPerformanceSummary.cxx:1893
 AliTPCPerformanceSummary.cxx:1894
 AliTPCPerformanceSummary.cxx:1895
 AliTPCPerformanceSummary.cxx:1896
 AliTPCPerformanceSummary.cxx:1897
 AliTPCPerformanceSummary.cxx:1898
 AliTPCPerformanceSummary.cxx:1899
 AliTPCPerformanceSummary.cxx:1900
 AliTPCPerformanceSummary.cxx:1901
 AliTPCPerformanceSummary.cxx:1902
 AliTPCPerformanceSummary.cxx:1903
 AliTPCPerformanceSummary.cxx:1904
 AliTPCPerformanceSummary.cxx:1905
 AliTPCPerformanceSummary.cxx:1906
 AliTPCPerformanceSummary.cxx:1907
 AliTPCPerformanceSummary.cxx:1908
 AliTPCPerformanceSummary.cxx:1909
 AliTPCPerformanceSummary.cxx:1910
 AliTPCPerformanceSummary.cxx:1911
 AliTPCPerformanceSummary.cxx:1912
 AliTPCPerformanceSummary.cxx:1913
 AliTPCPerformanceSummary.cxx:1914
 AliTPCPerformanceSummary.cxx:1915
 AliTPCPerformanceSummary.cxx:1916
 AliTPCPerformanceSummary.cxx:1917
 AliTPCPerformanceSummary.cxx:1918
 AliTPCPerformanceSummary.cxx:1919
 AliTPCPerformanceSummary.cxx:1920
 AliTPCPerformanceSummary.cxx:1921
 AliTPCPerformanceSummary.cxx:1922
 AliTPCPerformanceSummary.cxx:1923
 AliTPCPerformanceSummary.cxx:1924
 AliTPCPerformanceSummary.cxx:1925
 AliTPCPerformanceSummary.cxx:1926
 AliTPCPerformanceSummary.cxx:1927
 AliTPCPerformanceSummary.cxx:1928
 AliTPCPerformanceSummary.cxx:1929
 AliTPCPerformanceSummary.cxx:1930
 AliTPCPerformanceSummary.cxx:1931
 AliTPCPerformanceSummary.cxx:1932
 AliTPCPerformanceSummary.cxx:1933
 AliTPCPerformanceSummary.cxx:1934
 AliTPCPerformanceSummary.cxx:1935
 AliTPCPerformanceSummary.cxx:1936
 AliTPCPerformanceSummary.cxx:1937
 AliTPCPerformanceSummary.cxx:1938
 AliTPCPerformanceSummary.cxx:1939
 AliTPCPerformanceSummary.cxx:1940
 AliTPCPerformanceSummary.cxx:1941
 AliTPCPerformanceSummary.cxx:1942
 AliTPCPerformanceSummary.cxx:1943
 AliTPCPerformanceSummary.cxx:1944
 AliTPCPerformanceSummary.cxx:1945
 AliTPCPerformanceSummary.cxx:1946
 AliTPCPerformanceSummary.cxx:1947
 AliTPCPerformanceSummary.cxx:1948
 AliTPCPerformanceSummary.cxx:1949
 AliTPCPerformanceSummary.cxx:1950
 AliTPCPerformanceSummary.cxx:1951
 AliTPCPerformanceSummary.cxx:1952
 AliTPCPerformanceSummary.cxx:1953
 AliTPCPerformanceSummary.cxx:1954
 AliTPCPerformanceSummary.cxx:1955
 AliTPCPerformanceSummary.cxx:1956
 AliTPCPerformanceSummary.cxx:1957
 AliTPCPerformanceSummary.cxx:1958
 AliTPCPerformanceSummary.cxx:1959
 AliTPCPerformanceSummary.cxx:1960
 AliTPCPerformanceSummary.cxx:1961
 AliTPCPerformanceSummary.cxx:1962
 AliTPCPerformanceSummary.cxx:1963
 AliTPCPerformanceSummary.cxx:1964
 AliTPCPerformanceSummary.cxx:1965
 AliTPCPerformanceSummary.cxx:1966
 AliTPCPerformanceSummary.cxx:1967
 AliTPCPerformanceSummary.cxx:1968
 AliTPCPerformanceSummary.cxx:1969
 AliTPCPerformanceSummary.cxx:1970
 AliTPCPerformanceSummary.cxx:1971
 AliTPCPerformanceSummary.cxx:1972
 AliTPCPerformanceSummary.cxx:1973
 AliTPCPerformanceSummary.cxx:1974
 AliTPCPerformanceSummary.cxx:1975
 AliTPCPerformanceSummary.cxx:1976
 AliTPCPerformanceSummary.cxx:1977
 AliTPCPerformanceSummary.cxx:1978
 AliTPCPerformanceSummary.cxx:1979
 AliTPCPerformanceSummary.cxx:1980
 AliTPCPerformanceSummary.cxx:1981
 AliTPCPerformanceSummary.cxx:1982
 AliTPCPerformanceSummary.cxx:1983
 AliTPCPerformanceSummary.cxx:1984
 AliTPCPerformanceSummary.cxx:1985
 AliTPCPerformanceSummary.cxx:1986
 AliTPCPerformanceSummary.cxx:1987
 AliTPCPerformanceSummary.cxx:1988
 AliTPCPerformanceSummary.cxx:1989
 AliTPCPerformanceSummary.cxx:1990
 AliTPCPerformanceSummary.cxx:1991
 AliTPCPerformanceSummary.cxx:1992
 AliTPCPerformanceSummary.cxx:1993
 AliTPCPerformanceSummary.cxx:1994
 AliTPCPerformanceSummary.cxx:1995
 AliTPCPerformanceSummary.cxx:1996
 AliTPCPerformanceSummary.cxx:1997
 AliTPCPerformanceSummary.cxx:1998
 AliTPCPerformanceSummary.cxx:1999
 AliTPCPerformanceSummary.cxx:2000
 AliTPCPerformanceSummary.cxx:2001
 AliTPCPerformanceSummary.cxx:2002
 AliTPCPerformanceSummary.cxx:2003
 AliTPCPerformanceSummary.cxx:2004
 AliTPCPerformanceSummary.cxx:2005
 AliTPCPerformanceSummary.cxx:2006
 AliTPCPerformanceSummary.cxx:2007
 AliTPCPerformanceSummary.cxx:2008
 AliTPCPerformanceSummary.cxx:2009
 AliTPCPerformanceSummary.cxx:2010
 AliTPCPerformanceSummary.cxx:2011
 AliTPCPerformanceSummary.cxx:2012
 AliTPCPerformanceSummary.cxx:2013
 AliTPCPerformanceSummary.cxx:2014
 AliTPCPerformanceSummary.cxx:2015
 AliTPCPerformanceSummary.cxx:2016
 AliTPCPerformanceSummary.cxx:2017
 AliTPCPerformanceSummary.cxx:2018
 AliTPCPerformanceSummary.cxx:2019
 AliTPCPerformanceSummary.cxx:2020
 AliTPCPerformanceSummary.cxx:2021
 AliTPCPerformanceSummary.cxx:2022
 AliTPCPerformanceSummary.cxx:2023
 AliTPCPerformanceSummary.cxx:2024
 AliTPCPerformanceSummary.cxx:2025
 AliTPCPerformanceSummary.cxx:2026
 AliTPCPerformanceSummary.cxx:2027
 AliTPCPerformanceSummary.cxx:2028
 AliTPCPerformanceSummary.cxx:2029
 AliTPCPerformanceSummary.cxx:2030
 AliTPCPerformanceSummary.cxx:2031
 AliTPCPerformanceSummary.cxx:2032
 AliTPCPerformanceSummary.cxx:2033
 AliTPCPerformanceSummary.cxx:2034
 AliTPCPerformanceSummary.cxx:2035
 AliTPCPerformanceSummary.cxx:2036
 AliTPCPerformanceSummary.cxx:2037
 AliTPCPerformanceSummary.cxx:2038
 AliTPCPerformanceSummary.cxx:2039
 AliTPCPerformanceSummary.cxx:2040
 AliTPCPerformanceSummary.cxx:2041
 AliTPCPerformanceSummary.cxx:2042
 AliTPCPerformanceSummary.cxx:2043
 AliTPCPerformanceSummary.cxx:2044
 AliTPCPerformanceSummary.cxx:2045
 AliTPCPerformanceSummary.cxx:2046
 AliTPCPerformanceSummary.cxx:2047
 AliTPCPerformanceSummary.cxx:2048
 AliTPCPerformanceSummary.cxx:2049
 AliTPCPerformanceSummary.cxx:2050
 AliTPCPerformanceSummary.cxx:2051
 AliTPCPerformanceSummary.cxx:2052
 AliTPCPerformanceSummary.cxx:2053
 AliTPCPerformanceSummary.cxx:2054
 AliTPCPerformanceSummary.cxx:2055
 AliTPCPerformanceSummary.cxx:2056
 AliTPCPerformanceSummary.cxx:2057
 AliTPCPerformanceSummary.cxx:2058
 AliTPCPerformanceSummary.cxx:2059
 AliTPCPerformanceSummary.cxx:2060
 AliTPCPerformanceSummary.cxx:2061
 AliTPCPerformanceSummary.cxx:2062
 AliTPCPerformanceSummary.cxx:2063
 AliTPCPerformanceSummary.cxx:2064
 AliTPCPerformanceSummary.cxx:2065
 AliTPCPerformanceSummary.cxx:2066
 AliTPCPerformanceSummary.cxx:2067
 AliTPCPerformanceSummary.cxx:2068
 AliTPCPerformanceSummary.cxx:2069
 AliTPCPerformanceSummary.cxx:2070
 AliTPCPerformanceSummary.cxx:2071
 AliTPCPerformanceSummary.cxx:2072
 AliTPCPerformanceSummary.cxx:2073
 AliTPCPerformanceSummary.cxx:2074
 AliTPCPerformanceSummary.cxx:2075
 AliTPCPerformanceSummary.cxx:2076
 AliTPCPerformanceSummary.cxx:2077
 AliTPCPerformanceSummary.cxx:2078
 AliTPCPerformanceSummary.cxx:2079
 AliTPCPerformanceSummary.cxx:2080
 AliTPCPerformanceSummary.cxx:2081
 AliTPCPerformanceSummary.cxx:2082
 AliTPCPerformanceSummary.cxx:2083
 AliTPCPerformanceSummary.cxx:2084
 AliTPCPerformanceSummary.cxx:2085
 AliTPCPerformanceSummary.cxx:2086
 AliTPCPerformanceSummary.cxx:2087
 AliTPCPerformanceSummary.cxx:2088
 AliTPCPerformanceSummary.cxx:2089
 AliTPCPerformanceSummary.cxx:2090
 AliTPCPerformanceSummary.cxx:2091
 AliTPCPerformanceSummary.cxx:2092
 AliTPCPerformanceSummary.cxx:2093
 AliTPCPerformanceSummary.cxx:2094
 AliTPCPerformanceSummary.cxx:2095
 AliTPCPerformanceSummary.cxx:2096
 AliTPCPerformanceSummary.cxx:2097
 AliTPCPerformanceSummary.cxx:2098
 AliTPCPerformanceSummary.cxx:2099
 AliTPCPerformanceSummary.cxx:2100
 AliTPCPerformanceSummary.cxx:2101
 AliTPCPerformanceSummary.cxx:2102
 AliTPCPerformanceSummary.cxx:2103
 AliTPCPerformanceSummary.cxx:2104
 AliTPCPerformanceSummary.cxx:2105
 AliTPCPerformanceSummary.cxx:2106
 AliTPCPerformanceSummary.cxx:2107
 AliTPCPerformanceSummary.cxx:2108
 AliTPCPerformanceSummary.cxx:2109
 AliTPCPerformanceSummary.cxx:2110
 AliTPCPerformanceSummary.cxx:2111
 AliTPCPerformanceSummary.cxx:2112
 AliTPCPerformanceSummary.cxx:2113
 AliTPCPerformanceSummary.cxx:2114
 AliTPCPerformanceSummary.cxx:2115
 AliTPCPerformanceSummary.cxx:2116
 AliTPCPerformanceSummary.cxx:2117
 AliTPCPerformanceSummary.cxx:2118
 AliTPCPerformanceSummary.cxx:2119
 AliTPCPerformanceSummary.cxx:2120
 AliTPCPerformanceSummary.cxx:2121
 AliTPCPerformanceSummary.cxx:2122
 AliTPCPerformanceSummary.cxx:2123
 AliTPCPerformanceSummary.cxx:2124
 AliTPCPerformanceSummary.cxx:2125
 AliTPCPerformanceSummary.cxx:2126
 AliTPCPerformanceSummary.cxx:2127
 AliTPCPerformanceSummary.cxx:2128
 AliTPCPerformanceSummary.cxx:2129
 AliTPCPerformanceSummary.cxx:2130
 AliTPCPerformanceSummary.cxx:2131
 AliTPCPerformanceSummary.cxx:2132
 AliTPCPerformanceSummary.cxx:2133
 AliTPCPerformanceSummary.cxx:2134
 AliTPCPerformanceSummary.cxx:2135
 AliTPCPerformanceSummary.cxx:2136
 AliTPCPerformanceSummary.cxx:2137
 AliTPCPerformanceSummary.cxx:2138
 AliTPCPerformanceSummary.cxx:2139
 AliTPCPerformanceSummary.cxx:2140
 AliTPCPerformanceSummary.cxx:2141
 AliTPCPerformanceSummary.cxx:2142
 AliTPCPerformanceSummary.cxx:2143
 AliTPCPerformanceSummary.cxx:2144
 AliTPCPerformanceSummary.cxx:2145
 AliTPCPerformanceSummary.cxx:2146
 AliTPCPerformanceSummary.cxx:2147
 AliTPCPerformanceSummary.cxx:2148
 AliTPCPerformanceSummary.cxx:2149
 AliTPCPerformanceSummary.cxx:2150
 AliTPCPerformanceSummary.cxx:2151
 AliTPCPerformanceSummary.cxx:2152
 AliTPCPerformanceSummary.cxx:2153
 AliTPCPerformanceSummary.cxx:2154
 AliTPCPerformanceSummary.cxx:2155
 AliTPCPerformanceSummary.cxx:2156
 AliTPCPerformanceSummary.cxx:2157
 AliTPCPerformanceSummary.cxx:2158
 AliTPCPerformanceSummary.cxx:2159
 AliTPCPerformanceSummary.cxx:2160
 AliTPCPerformanceSummary.cxx:2161
 AliTPCPerformanceSummary.cxx:2162
 AliTPCPerformanceSummary.cxx:2163
 AliTPCPerformanceSummary.cxx:2164
 AliTPCPerformanceSummary.cxx:2165
 AliTPCPerformanceSummary.cxx:2166
 AliTPCPerformanceSummary.cxx:2167
 AliTPCPerformanceSummary.cxx:2168
 AliTPCPerformanceSummary.cxx:2169
 AliTPCPerformanceSummary.cxx:2170
 AliTPCPerformanceSummary.cxx:2171
 AliTPCPerformanceSummary.cxx:2172
 AliTPCPerformanceSummary.cxx:2173
 AliTPCPerformanceSummary.cxx:2174
 AliTPCPerformanceSummary.cxx:2175
 AliTPCPerformanceSummary.cxx:2176
 AliTPCPerformanceSummary.cxx:2177
 AliTPCPerformanceSummary.cxx:2178
 AliTPCPerformanceSummary.cxx:2179
 AliTPCPerformanceSummary.cxx:2180
 AliTPCPerformanceSummary.cxx:2181
 AliTPCPerformanceSummary.cxx:2182
 AliTPCPerformanceSummary.cxx:2183
 AliTPCPerformanceSummary.cxx:2184
 AliTPCPerformanceSummary.cxx:2185
 AliTPCPerformanceSummary.cxx:2186
 AliTPCPerformanceSummary.cxx:2187
 AliTPCPerformanceSummary.cxx:2188
 AliTPCPerformanceSummary.cxx:2189
 AliTPCPerformanceSummary.cxx:2190
 AliTPCPerformanceSummary.cxx:2191
 AliTPCPerformanceSummary.cxx:2192
 AliTPCPerformanceSummary.cxx:2193
 AliTPCPerformanceSummary.cxx:2194
 AliTPCPerformanceSummary.cxx:2195
 AliTPCPerformanceSummary.cxx:2196
 AliTPCPerformanceSummary.cxx:2197
 AliTPCPerformanceSummary.cxx:2198
 AliTPCPerformanceSummary.cxx:2199
 AliTPCPerformanceSummary.cxx:2200
 AliTPCPerformanceSummary.cxx:2201
 AliTPCPerformanceSummary.cxx:2202
 AliTPCPerformanceSummary.cxx:2203
 AliTPCPerformanceSummary.cxx:2204
 AliTPCPerformanceSummary.cxx:2205
 AliTPCPerformanceSummary.cxx:2206
 AliTPCPerformanceSummary.cxx:2207
 AliTPCPerformanceSummary.cxx:2208
 AliTPCPerformanceSummary.cxx:2209
 AliTPCPerformanceSummary.cxx:2210
 AliTPCPerformanceSummary.cxx:2211
 AliTPCPerformanceSummary.cxx:2212
 AliTPCPerformanceSummary.cxx:2213
 AliTPCPerformanceSummary.cxx:2214
 AliTPCPerformanceSummary.cxx:2215
 AliTPCPerformanceSummary.cxx:2216
 AliTPCPerformanceSummary.cxx:2217
 AliTPCPerformanceSummary.cxx:2218
 AliTPCPerformanceSummary.cxx:2219
 AliTPCPerformanceSummary.cxx:2220
 AliTPCPerformanceSummary.cxx:2221
 AliTPCPerformanceSummary.cxx:2222
 AliTPCPerformanceSummary.cxx:2223
 AliTPCPerformanceSummary.cxx:2224
 AliTPCPerformanceSummary.cxx:2225
 AliTPCPerformanceSummary.cxx:2226
 AliTPCPerformanceSummary.cxx:2227
 AliTPCPerformanceSummary.cxx:2228
 AliTPCPerformanceSummary.cxx:2229
 AliTPCPerformanceSummary.cxx:2230
 AliTPCPerformanceSummary.cxx:2231
 AliTPCPerformanceSummary.cxx:2232
 AliTPCPerformanceSummary.cxx:2233
 AliTPCPerformanceSummary.cxx:2234
 AliTPCPerformanceSummary.cxx:2235
 AliTPCPerformanceSummary.cxx:2236
 AliTPCPerformanceSummary.cxx:2237
 AliTPCPerformanceSummary.cxx:2238
 AliTPCPerformanceSummary.cxx:2239
 AliTPCPerformanceSummary.cxx:2240
 AliTPCPerformanceSummary.cxx:2241
 AliTPCPerformanceSummary.cxx:2242
 AliTPCPerformanceSummary.cxx:2243
 AliTPCPerformanceSummary.cxx:2244
 AliTPCPerformanceSummary.cxx:2245
 AliTPCPerformanceSummary.cxx:2246
 AliTPCPerformanceSummary.cxx:2247
 AliTPCPerformanceSummary.cxx:2248
 AliTPCPerformanceSummary.cxx:2249
 AliTPCPerformanceSummary.cxx:2250
 AliTPCPerformanceSummary.cxx:2251
 AliTPCPerformanceSummary.cxx:2252
 AliTPCPerformanceSummary.cxx:2253
 AliTPCPerformanceSummary.cxx:2254
 AliTPCPerformanceSummary.cxx:2255
 AliTPCPerformanceSummary.cxx:2256
 AliTPCPerformanceSummary.cxx:2257
 AliTPCPerformanceSummary.cxx:2258
 AliTPCPerformanceSummary.cxx:2259
 AliTPCPerformanceSummary.cxx:2260
 AliTPCPerformanceSummary.cxx:2261
 AliTPCPerformanceSummary.cxx:2262
 AliTPCPerformanceSummary.cxx:2263
 AliTPCPerformanceSummary.cxx:2264
 AliTPCPerformanceSummary.cxx:2265
 AliTPCPerformanceSummary.cxx:2266
 AliTPCPerformanceSummary.cxx:2267
 AliTPCPerformanceSummary.cxx:2268
 AliTPCPerformanceSummary.cxx:2269
 AliTPCPerformanceSummary.cxx:2270
 AliTPCPerformanceSummary.cxx:2271
 AliTPCPerformanceSummary.cxx:2272
 AliTPCPerformanceSummary.cxx:2273
 AliTPCPerformanceSummary.cxx:2274
 AliTPCPerformanceSummary.cxx:2275
 AliTPCPerformanceSummary.cxx:2276
 AliTPCPerformanceSummary.cxx:2277
 AliTPCPerformanceSummary.cxx:2278
 AliTPCPerformanceSummary.cxx:2279
 AliTPCPerformanceSummary.cxx:2280
 AliTPCPerformanceSummary.cxx:2281
 AliTPCPerformanceSummary.cxx:2282
 AliTPCPerformanceSummary.cxx:2283
 AliTPCPerformanceSummary.cxx:2284
 AliTPCPerformanceSummary.cxx:2285
 AliTPCPerformanceSummary.cxx:2286
 AliTPCPerformanceSummary.cxx:2287
 AliTPCPerformanceSummary.cxx:2288
 AliTPCPerformanceSummary.cxx:2289
 AliTPCPerformanceSummary.cxx:2290
 AliTPCPerformanceSummary.cxx:2291
 AliTPCPerformanceSummary.cxx:2292
 AliTPCPerformanceSummary.cxx:2293
 AliTPCPerformanceSummary.cxx:2294
 AliTPCPerformanceSummary.cxx:2295
 AliTPCPerformanceSummary.cxx:2296
 AliTPCPerformanceSummary.cxx:2297
 AliTPCPerformanceSummary.cxx:2298
 AliTPCPerformanceSummary.cxx:2299
 AliTPCPerformanceSummary.cxx:2300
 AliTPCPerformanceSummary.cxx:2301
 AliTPCPerformanceSummary.cxx:2302
 AliTPCPerformanceSummary.cxx:2303
 AliTPCPerformanceSummary.cxx:2304
 AliTPCPerformanceSummary.cxx:2305
 AliTPCPerformanceSummary.cxx:2306
 AliTPCPerformanceSummary.cxx:2307
 AliTPCPerformanceSummary.cxx:2308
 AliTPCPerformanceSummary.cxx:2309
 AliTPCPerformanceSummary.cxx:2310
 AliTPCPerformanceSummary.cxx:2311
 AliTPCPerformanceSummary.cxx:2312
 AliTPCPerformanceSummary.cxx:2313
 AliTPCPerformanceSummary.cxx:2314
 AliTPCPerformanceSummary.cxx:2315
 AliTPCPerformanceSummary.cxx:2316
 AliTPCPerformanceSummary.cxx:2317
 AliTPCPerformanceSummary.cxx:2318
 AliTPCPerformanceSummary.cxx:2319
 AliTPCPerformanceSummary.cxx:2320
 AliTPCPerformanceSummary.cxx:2321
 AliTPCPerformanceSummary.cxx:2322
 AliTPCPerformanceSummary.cxx:2323
 AliTPCPerformanceSummary.cxx:2324
 AliTPCPerformanceSummary.cxx:2325
 AliTPCPerformanceSummary.cxx:2326
 AliTPCPerformanceSummary.cxx:2327
 AliTPCPerformanceSummary.cxx:2328
 AliTPCPerformanceSummary.cxx:2329
 AliTPCPerformanceSummary.cxx:2330
 AliTPCPerformanceSummary.cxx:2331
 AliTPCPerformanceSummary.cxx:2332
 AliTPCPerformanceSummary.cxx:2333
 AliTPCPerformanceSummary.cxx:2334
 AliTPCPerformanceSummary.cxx:2335
 AliTPCPerformanceSummary.cxx:2336
 AliTPCPerformanceSummary.cxx:2337
 AliTPCPerformanceSummary.cxx:2338
 AliTPCPerformanceSummary.cxx:2339
 AliTPCPerformanceSummary.cxx:2340
 AliTPCPerformanceSummary.cxx:2341
 AliTPCPerformanceSummary.cxx:2342
 AliTPCPerformanceSummary.cxx:2343
 AliTPCPerformanceSummary.cxx:2344
 AliTPCPerformanceSummary.cxx:2345
 AliTPCPerformanceSummary.cxx:2346
 AliTPCPerformanceSummary.cxx:2347
 AliTPCPerformanceSummary.cxx:2348
 AliTPCPerformanceSummary.cxx:2349
 AliTPCPerformanceSummary.cxx:2350
 AliTPCPerformanceSummary.cxx:2351
 AliTPCPerformanceSummary.cxx:2352
 AliTPCPerformanceSummary.cxx:2353
 AliTPCPerformanceSummary.cxx:2354
 AliTPCPerformanceSummary.cxx:2355
 AliTPCPerformanceSummary.cxx:2356
 AliTPCPerformanceSummary.cxx:2357
 AliTPCPerformanceSummary.cxx:2358
 AliTPCPerformanceSummary.cxx:2359
 AliTPCPerformanceSummary.cxx:2360
 AliTPCPerformanceSummary.cxx:2361
 AliTPCPerformanceSummary.cxx:2362
 AliTPCPerformanceSummary.cxx:2363
 AliTPCPerformanceSummary.cxx:2364
 AliTPCPerformanceSummary.cxx:2365
 AliTPCPerformanceSummary.cxx:2366
 AliTPCPerformanceSummary.cxx:2367
 AliTPCPerformanceSummary.cxx:2368
 AliTPCPerformanceSummary.cxx:2369
 AliTPCPerformanceSummary.cxx:2370
 AliTPCPerformanceSummary.cxx:2371
 AliTPCPerformanceSummary.cxx:2372
 AliTPCPerformanceSummary.cxx:2373
 AliTPCPerformanceSummary.cxx:2374
 AliTPCPerformanceSummary.cxx:2375
 AliTPCPerformanceSummary.cxx:2376
 AliTPCPerformanceSummary.cxx:2377
 AliTPCPerformanceSummary.cxx:2378
 AliTPCPerformanceSummary.cxx:2379
 AliTPCPerformanceSummary.cxx:2380
 AliTPCPerformanceSummary.cxx:2381
 AliTPCPerformanceSummary.cxx:2382
 AliTPCPerformanceSummary.cxx:2383
 AliTPCPerformanceSummary.cxx:2384
 AliTPCPerformanceSummary.cxx:2385
 AliTPCPerformanceSummary.cxx:2386
 AliTPCPerformanceSummary.cxx:2387
 AliTPCPerformanceSummary.cxx:2388
 AliTPCPerformanceSummary.cxx:2389
 AliTPCPerformanceSummary.cxx:2390
 AliTPCPerformanceSummary.cxx:2391
 AliTPCPerformanceSummary.cxx:2392
 AliTPCPerformanceSummary.cxx:2393
 AliTPCPerformanceSummary.cxx:2394
 AliTPCPerformanceSummary.cxx:2395
 AliTPCPerformanceSummary.cxx:2396
 AliTPCPerformanceSummary.cxx:2397
 AliTPCPerformanceSummary.cxx:2398
 AliTPCPerformanceSummary.cxx:2399
 AliTPCPerformanceSummary.cxx:2400
 AliTPCPerformanceSummary.cxx:2401
 AliTPCPerformanceSummary.cxx:2402
 AliTPCPerformanceSummary.cxx:2403
 AliTPCPerformanceSummary.cxx:2404
 AliTPCPerformanceSummary.cxx:2405
 AliTPCPerformanceSummary.cxx:2406
 AliTPCPerformanceSummary.cxx:2407
 AliTPCPerformanceSummary.cxx:2408
 AliTPCPerformanceSummary.cxx:2409
 AliTPCPerformanceSummary.cxx:2410
 AliTPCPerformanceSummary.cxx:2411
 AliTPCPerformanceSummary.cxx:2412
 AliTPCPerformanceSummary.cxx:2413
 AliTPCPerformanceSummary.cxx:2414
 AliTPCPerformanceSummary.cxx:2415
 AliTPCPerformanceSummary.cxx:2416
 AliTPCPerformanceSummary.cxx:2417
 AliTPCPerformanceSummary.cxx:2418
 AliTPCPerformanceSummary.cxx:2419
 AliTPCPerformanceSummary.cxx:2420
 AliTPCPerformanceSummary.cxx:2421
 AliTPCPerformanceSummary.cxx:2422
 AliTPCPerformanceSummary.cxx:2423
 AliTPCPerformanceSummary.cxx:2424
 AliTPCPerformanceSummary.cxx:2425
 AliTPCPerformanceSummary.cxx:2426
 AliTPCPerformanceSummary.cxx:2427
 AliTPCPerformanceSummary.cxx:2428
 AliTPCPerformanceSummary.cxx:2429
 AliTPCPerformanceSummary.cxx:2430
 AliTPCPerformanceSummary.cxx:2431
 AliTPCPerformanceSummary.cxx:2432
 AliTPCPerformanceSummary.cxx:2433
 AliTPCPerformanceSummary.cxx:2434
 AliTPCPerformanceSummary.cxx:2435
 AliTPCPerformanceSummary.cxx:2436
 AliTPCPerformanceSummary.cxx:2437
 AliTPCPerformanceSummary.cxx:2438
 AliTPCPerformanceSummary.cxx:2439
 AliTPCPerformanceSummary.cxx:2440
 AliTPCPerformanceSummary.cxx:2441
 AliTPCPerformanceSummary.cxx:2442
 AliTPCPerformanceSummary.cxx:2443
 AliTPCPerformanceSummary.cxx:2444
 AliTPCPerformanceSummary.cxx:2445
 AliTPCPerformanceSummary.cxx:2446
 AliTPCPerformanceSummary.cxx:2447
 AliTPCPerformanceSummary.cxx:2448
 AliTPCPerformanceSummary.cxx:2449
 AliTPCPerformanceSummary.cxx:2450
 AliTPCPerformanceSummary.cxx:2451
 AliTPCPerformanceSummary.cxx:2452
 AliTPCPerformanceSummary.cxx:2453
 AliTPCPerformanceSummary.cxx:2454
 AliTPCPerformanceSummary.cxx:2455
 AliTPCPerformanceSummary.cxx:2456
 AliTPCPerformanceSummary.cxx:2457
 AliTPCPerformanceSummary.cxx:2458
 AliTPCPerformanceSummary.cxx:2459
 AliTPCPerformanceSummary.cxx:2460
 AliTPCPerformanceSummary.cxx:2461
 AliTPCPerformanceSummary.cxx:2462
 AliTPCPerformanceSummary.cxx:2463
 AliTPCPerformanceSummary.cxx:2464
 AliTPCPerformanceSummary.cxx:2465
 AliTPCPerformanceSummary.cxx:2466
 AliTPCPerformanceSummary.cxx:2467
 AliTPCPerformanceSummary.cxx:2468
 AliTPCPerformanceSummary.cxx:2469
 AliTPCPerformanceSummary.cxx:2470
 AliTPCPerformanceSummary.cxx:2471
 AliTPCPerformanceSummary.cxx:2472
 AliTPCPerformanceSummary.cxx:2473
 AliTPCPerformanceSummary.cxx:2474
 AliTPCPerformanceSummary.cxx:2475
 AliTPCPerformanceSummary.cxx:2476
 AliTPCPerformanceSummary.cxx:2477
 AliTPCPerformanceSummary.cxx:2478
 AliTPCPerformanceSummary.cxx:2479
 AliTPCPerformanceSummary.cxx:2480
 AliTPCPerformanceSummary.cxx:2481
 AliTPCPerformanceSummary.cxx:2482
 AliTPCPerformanceSummary.cxx:2483
 AliTPCPerformanceSummary.cxx:2484
 AliTPCPerformanceSummary.cxx:2485
 AliTPCPerformanceSummary.cxx:2486
 AliTPCPerformanceSummary.cxx:2487
 AliTPCPerformanceSummary.cxx:2488
 AliTPCPerformanceSummary.cxx:2489
 AliTPCPerformanceSummary.cxx:2490
 AliTPCPerformanceSummary.cxx:2491
 AliTPCPerformanceSummary.cxx:2492
 AliTPCPerformanceSummary.cxx:2493
 AliTPCPerformanceSummary.cxx:2494
 AliTPCPerformanceSummary.cxx:2495
 AliTPCPerformanceSummary.cxx:2496
 AliTPCPerformanceSummary.cxx:2497
 AliTPCPerformanceSummary.cxx:2498
 AliTPCPerformanceSummary.cxx:2499
 AliTPCPerformanceSummary.cxx:2500
 AliTPCPerformanceSummary.cxx:2501
 AliTPCPerformanceSummary.cxx:2502
 AliTPCPerformanceSummary.cxx:2503
 AliTPCPerformanceSummary.cxx:2504
 AliTPCPerformanceSummary.cxx:2505
 AliTPCPerformanceSummary.cxx:2506
 AliTPCPerformanceSummary.cxx:2507
 AliTPCPerformanceSummary.cxx:2508
 AliTPCPerformanceSummary.cxx:2509
 AliTPCPerformanceSummary.cxx:2510
 AliTPCPerformanceSummary.cxx:2511
 AliTPCPerformanceSummary.cxx:2512
 AliTPCPerformanceSummary.cxx:2513
 AliTPCPerformanceSummary.cxx:2514
 AliTPCPerformanceSummary.cxx:2515
 AliTPCPerformanceSummary.cxx:2516
 AliTPCPerformanceSummary.cxx:2517
 AliTPCPerformanceSummary.cxx:2518
 AliTPCPerformanceSummary.cxx:2519
 AliTPCPerformanceSummary.cxx:2520
 AliTPCPerformanceSummary.cxx:2521
 AliTPCPerformanceSummary.cxx:2522
 AliTPCPerformanceSummary.cxx:2523
 AliTPCPerformanceSummary.cxx:2524
 AliTPCPerformanceSummary.cxx:2525
 AliTPCPerformanceSummary.cxx:2526
 AliTPCPerformanceSummary.cxx:2527
 AliTPCPerformanceSummary.cxx:2528
 AliTPCPerformanceSummary.cxx:2529
 AliTPCPerformanceSummary.cxx:2530
 AliTPCPerformanceSummary.cxx:2531
 AliTPCPerformanceSummary.cxx:2532
 AliTPCPerformanceSummary.cxx:2533
 AliTPCPerformanceSummary.cxx:2534
 AliTPCPerformanceSummary.cxx:2535
 AliTPCPerformanceSummary.cxx:2536
 AliTPCPerformanceSummary.cxx:2537
 AliTPCPerformanceSummary.cxx:2538
 AliTPCPerformanceSummary.cxx:2539
 AliTPCPerformanceSummary.cxx:2540
 AliTPCPerformanceSummary.cxx:2541
 AliTPCPerformanceSummary.cxx:2542
 AliTPCPerformanceSummary.cxx:2543
 AliTPCPerformanceSummary.cxx:2544
 AliTPCPerformanceSummary.cxx:2545
 AliTPCPerformanceSummary.cxx:2546
 AliTPCPerformanceSummary.cxx:2547
 AliTPCPerformanceSummary.cxx:2548
 AliTPCPerformanceSummary.cxx:2549
 AliTPCPerformanceSummary.cxx:2550
 AliTPCPerformanceSummary.cxx:2551
 AliTPCPerformanceSummary.cxx:2552
 AliTPCPerformanceSummary.cxx:2553
 AliTPCPerformanceSummary.cxx:2554
 AliTPCPerformanceSummary.cxx:2555
 AliTPCPerformanceSummary.cxx:2556
 AliTPCPerformanceSummary.cxx:2557
 AliTPCPerformanceSummary.cxx:2558
 AliTPCPerformanceSummary.cxx:2559
 AliTPCPerformanceSummary.cxx:2560
 AliTPCPerformanceSummary.cxx:2561
 AliTPCPerformanceSummary.cxx:2562
 AliTPCPerformanceSummary.cxx:2563
 AliTPCPerformanceSummary.cxx:2564
 AliTPCPerformanceSummary.cxx:2565
 AliTPCPerformanceSummary.cxx:2566
 AliTPCPerformanceSummary.cxx:2567
 AliTPCPerformanceSummary.cxx:2568
 AliTPCPerformanceSummary.cxx:2569
 AliTPCPerformanceSummary.cxx:2570
 AliTPCPerformanceSummary.cxx:2571
 AliTPCPerformanceSummary.cxx:2572
 AliTPCPerformanceSummary.cxx:2573
 AliTPCPerformanceSummary.cxx:2574
 AliTPCPerformanceSummary.cxx:2575
 AliTPCPerformanceSummary.cxx:2576
 AliTPCPerformanceSummary.cxx:2577
 AliTPCPerformanceSummary.cxx:2578
 AliTPCPerformanceSummary.cxx:2579
 AliTPCPerformanceSummary.cxx:2580
 AliTPCPerformanceSummary.cxx:2581
 AliTPCPerformanceSummary.cxx:2582
 AliTPCPerformanceSummary.cxx:2583
 AliTPCPerformanceSummary.cxx:2584
 AliTPCPerformanceSummary.cxx:2585
 AliTPCPerformanceSummary.cxx:2586
 AliTPCPerformanceSummary.cxx:2587
 AliTPCPerformanceSummary.cxx:2588
 AliTPCPerformanceSummary.cxx:2589
 AliTPCPerformanceSummary.cxx:2590
 AliTPCPerformanceSummary.cxx:2591
 AliTPCPerformanceSummary.cxx:2592
 AliTPCPerformanceSummary.cxx:2593
 AliTPCPerformanceSummary.cxx:2594
 AliTPCPerformanceSummary.cxx:2595
 AliTPCPerformanceSummary.cxx:2596
 AliTPCPerformanceSummary.cxx:2597
 AliTPCPerformanceSummary.cxx:2598
 AliTPCPerformanceSummary.cxx:2599
 AliTPCPerformanceSummary.cxx:2600
 AliTPCPerformanceSummary.cxx:2601
 AliTPCPerformanceSummary.cxx:2602
 AliTPCPerformanceSummary.cxx:2603
 AliTPCPerformanceSummary.cxx:2604
 AliTPCPerformanceSummary.cxx:2605
 AliTPCPerformanceSummary.cxx:2606
 AliTPCPerformanceSummary.cxx:2607
 AliTPCPerformanceSummary.cxx:2608
 AliTPCPerformanceSummary.cxx:2609
 AliTPCPerformanceSummary.cxx:2610
 AliTPCPerformanceSummary.cxx:2611
 AliTPCPerformanceSummary.cxx:2612
 AliTPCPerformanceSummary.cxx:2613
 AliTPCPerformanceSummary.cxx:2614
 AliTPCPerformanceSummary.cxx:2615
 AliTPCPerformanceSummary.cxx:2616
 AliTPCPerformanceSummary.cxx:2617
 AliTPCPerformanceSummary.cxx:2618
 AliTPCPerformanceSummary.cxx:2619
 AliTPCPerformanceSummary.cxx:2620
 AliTPCPerformanceSummary.cxx:2621
 AliTPCPerformanceSummary.cxx:2622
 AliTPCPerformanceSummary.cxx:2623
 AliTPCPerformanceSummary.cxx:2624
 AliTPCPerformanceSummary.cxx:2625
 AliTPCPerformanceSummary.cxx:2626
 AliTPCPerformanceSummary.cxx:2627
 AliTPCPerformanceSummary.cxx:2628
 AliTPCPerformanceSummary.cxx:2629
 AliTPCPerformanceSummary.cxx:2630
 AliTPCPerformanceSummary.cxx:2631
 AliTPCPerformanceSummary.cxx:2632
 AliTPCPerformanceSummary.cxx:2633
 AliTPCPerformanceSummary.cxx:2634
 AliTPCPerformanceSummary.cxx:2635
 AliTPCPerformanceSummary.cxx:2636
 AliTPCPerformanceSummary.cxx:2637
 AliTPCPerformanceSummary.cxx:2638
 AliTPCPerformanceSummary.cxx:2639
 AliTPCPerformanceSummary.cxx:2640
 AliTPCPerformanceSummary.cxx:2641
 AliTPCPerformanceSummary.cxx:2642
 AliTPCPerformanceSummary.cxx:2643
 AliTPCPerformanceSummary.cxx:2644
 AliTPCPerformanceSummary.cxx:2645
 AliTPCPerformanceSummary.cxx:2646
 AliTPCPerformanceSummary.cxx:2647
 AliTPCPerformanceSummary.cxx:2648
 AliTPCPerformanceSummary.cxx:2649
 AliTPCPerformanceSummary.cxx:2650
 AliTPCPerformanceSummary.cxx:2651
 AliTPCPerformanceSummary.cxx:2652
 AliTPCPerformanceSummary.cxx:2653
 AliTPCPerformanceSummary.cxx:2654
 AliTPCPerformanceSummary.cxx:2655
 AliTPCPerformanceSummary.cxx:2656
 AliTPCPerformanceSummary.cxx:2657
 AliTPCPerformanceSummary.cxx:2658
 AliTPCPerformanceSummary.cxx:2659
 AliTPCPerformanceSummary.cxx:2660
 AliTPCPerformanceSummary.cxx:2661
 AliTPCPerformanceSummary.cxx:2662
 AliTPCPerformanceSummary.cxx:2663
 AliTPCPerformanceSummary.cxx:2664
 AliTPCPerformanceSummary.cxx:2665
 AliTPCPerformanceSummary.cxx:2666
 AliTPCPerformanceSummary.cxx:2667
 AliTPCPerformanceSummary.cxx:2668
 AliTPCPerformanceSummary.cxx:2669
 AliTPCPerformanceSummary.cxx:2670
 AliTPCPerformanceSummary.cxx:2671
 AliTPCPerformanceSummary.cxx:2672
 AliTPCPerformanceSummary.cxx:2673
 AliTPCPerformanceSummary.cxx:2674
 AliTPCPerformanceSummary.cxx:2675
 AliTPCPerformanceSummary.cxx:2676
 AliTPCPerformanceSummary.cxx:2677
 AliTPCPerformanceSummary.cxx:2678
 AliTPCPerformanceSummary.cxx:2679
 AliTPCPerformanceSummary.cxx:2680
 AliTPCPerformanceSummary.cxx:2681
 AliTPCPerformanceSummary.cxx:2682
 AliTPCPerformanceSummary.cxx:2683
 AliTPCPerformanceSummary.cxx:2684
 AliTPCPerformanceSummary.cxx:2685
 AliTPCPerformanceSummary.cxx:2686
 AliTPCPerformanceSummary.cxx:2687
 AliTPCPerformanceSummary.cxx:2688
 AliTPCPerformanceSummary.cxx:2689
 AliTPCPerformanceSummary.cxx:2690
 AliTPCPerformanceSummary.cxx:2691
 AliTPCPerformanceSummary.cxx:2692
 AliTPCPerformanceSummary.cxx:2693
 AliTPCPerformanceSummary.cxx:2694
 AliTPCPerformanceSummary.cxx:2695
 AliTPCPerformanceSummary.cxx:2696
 AliTPCPerformanceSummary.cxx:2697
 AliTPCPerformanceSummary.cxx:2698
 AliTPCPerformanceSummary.cxx:2699
 AliTPCPerformanceSummary.cxx:2700
 AliTPCPerformanceSummary.cxx:2701
 AliTPCPerformanceSummary.cxx:2702
 AliTPCPerformanceSummary.cxx:2703
 AliTPCPerformanceSummary.cxx:2704
 AliTPCPerformanceSummary.cxx:2705
 AliTPCPerformanceSummary.cxx:2706
 AliTPCPerformanceSummary.cxx:2707
 AliTPCPerformanceSummary.cxx:2708
 AliTPCPerformanceSummary.cxx:2709
 AliTPCPerformanceSummary.cxx:2710
 AliTPCPerformanceSummary.cxx:2711
 AliTPCPerformanceSummary.cxx:2712
 AliTPCPerformanceSummary.cxx:2713
 AliTPCPerformanceSummary.cxx:2714
 AliTPCPerformanceSummary.cxx:2715
 AliTPCPerformanceSummary.cxx:2716
 AliTPCPerformanceSummary.cxx:2717
 AliTPCPerformanceSummary.cxx:2718
 AliTPCPerformanceSummary.cxx:2719
 AliTPCPerformanceSummary.cxx:2720
 AliTPCPerformanceSummary.cxx:2721
 AliTPCPerformanceSummary.cxx:2722
 AliTPCPerformanceSummary.cxx:2723
 AliTPCPerformanceSummary.cxx:2724
 AliTPCPerformanceSummary.cxx:2725
 AliTPCPerformanceSummary.cxx:2726
 AliTPCPerformanceSummary.cxx:2727
 AliTPCPerformanceSummary.cxx:2728
 AliTPCPerformanceSummary.cxx:2729
 AliTPCPerformanceSummary.cxx:2730
 AliTPCPerformanceSummary.cxx:2731
 AliTPCPerformanceSummary.cxx:2732
 AliTPCPerformanceSummary.cxx:2733
 AliTPCPerformanceSummary.cxx:2734
 AliTPCPerformanceSummary.cxx:2735
 AliTPCPerformanceSummary.cxx:2736
 AliTPCPerformanceSummary.cxx:2737
 AliTPCPerformanceSummary.cxx:2738
 AliTPCPerformanceSummary.cxx:2739