PWGPP/TPC/AliTPCPerformanceSummary.cxx

   1 //------------------------------------------------------------------------------
   2 // Implementation of AliTPCPerformanceSummary class.
   3 // It has only static member functions to extract some TPC Performance
   4 // parameters and produce trend graphs.
   5 // The function MakeReport is to be called for every run. It reads AliPerformanceTPC
   6 // and AliPerformanceDEdx objects from file and produces a
   7 // rootfile with the results stored in a TTree.
   8 // The function MakeReport needs a list of these rootfiles as input
   9 // and writes the output (tree and histograms) to another rootfile.
  10 //
  11 // by M.Knichel 15/10/2010
  12 //------------------------------------------------------------------------------
  13
  14 #include <fstream>
  15
  16 #include "TSystem.h"
  17 #include "TMath.h"
  18 #include "TVectorD.h"
  19 #include "TList.h"
  20 #include "TFile.h"
  21 #include "TGrid.h"
  22 #include "TF1.h"
  23 #include "TH1.h"
  24 #include "TH2.h"
  25 #include "TH3.h"
  26 #include "TProfile.h"
  27 #include "THnSparse.h"
  28 #include "TTree.h"
  29 #include "TChain.h"
  30 #include "TGraph.h"
  31 #include "TPad.h"
  32 #include "TCanvas.h"
  33
  34 #include "AliGRPObject.h"
  35 #include "AliTPCcalibDB.h"
  36 #include "AliTPCcalibDButil.h"
  37 #include "TTreeStream.h"
  38 #include "AliPerformanceTPC.h"
  39 #include "AliPerformanceDEdx.h"
  40 #include "AliPerformanceDCA.h"
  41 #include "AliPerformanceMatch.h"
  42
  43 #include "AliTPCPerformanceSummary.h"
  44
  45 using std::ifstream;
  46
  47 ClassImp(AliTPCPerformanceSummary)
  48
  49 Bool_t AliTPCPerformanceSummary::fgForceTHnSparse = kFALSE;
  50
  51
  52 //_____________________________________________________________________________
  53 void AliTPCPerformanceSummary::WriteToTTreeSRedirector(const AliPerformanceTPC* pTPC, const AliPerformanceDEdx* pTPCgain, const AliPerformanceMatch* pTPCMatch,const AliPerformanceMatch* pTPCPull, const AliPerformanceMatch* pConstrain, TTreeSRedirector* const pcstream, Int_t run)
  54 {
  55    //
  56     // Extracts performance parameters from pTPC and pTPCgain.
  57     // Output is written to pcstream.
  58     // The run number must be provided since it is not stored in
  59     // AliPerformanceTPC or AliPerformanceDEdx.
  60     //
  61     if (run <= 0 ) {
  62         if (pTPCMatch) {run = pTPCMatch->GetRunNumber(); }
  63         if (pTPCgain) {run = pTPCgain->GetRunNumber(); }
  64         if (pTPC) { run = pTPC->GetRunNumber(); }
  65     }
  66     TObjString runType;
  67
  68     //AliTPCcalibDB     *calibDB=0;
  69
  70 //     AliTPCcalibDButil *dbutil =0;
  71     Int_t startTimeGRP=0;
  72     Int_t stopTimeGRP=0;
  73     Int_t time=0;
  74     Int_t duration=0;
  75
  76     //Float_t currentL3 =0;
  77     //Int_t polarityL3 = 0;
  78     //Float_t bz = 0;
  79
  80     //calibDB = AliTPCcalibDB::Instance();
  81
  82 //     dbutil= new AliTPCcalibDButil;
  83
  84     //printf("Processing run %d ...\n",run);
  85     //if (calibDB) {
  86     //AliTPCcalibDB::Instance()->SetRun(run);
  87
  88 //     dbutil->UpdateFromCalibDB();
  89 //     dbutil->SetReferenceRun(run);
  90 //     dbutil->UpdateRefDataFromOCDB();
  91
  92     //if (calibDB->GetGRP(run)){
  93     //startTimeGRP = AliTPCcalibDB::GetGRP(run)->GetTimeStart();
  94     //stopTimeGRP  = AliTPCcalibDB::GetGRP(run)->GetTimeEnd();
  95     //currentL3 = AliTPCcalibDB::GetL3Current(run);
  96     //polarityL3 = AliTPCcalibDB::GetL3Polarity(run);
  97     //bz = AliTPCcalibDB::GetBz(run);
  98
  99     //}
 100     //runType = AliTPCcalibDB::GetRunType(run).Data();
 101     //}
 102   time = (startTimeGRP+stopTimeGRP)/2;
 103   duration = (stopTimeGRP-startTimeGRP);
 104
 105     if (!pcstream) return;
 106     (*pcstream)<<"tpcQA"<<
 107       "run="<<run<<
 108       "time="<<time<<
 109       "startTimeGRP="<<startTimeGRP<<
 110       "stopTimeGRP="<<stopTimeGRP<<
 111       "duration="<<duration<<
 112       "runType.="<<&runType;
 113     if (pTPC) {
 114         pTPC->GetTPCTrackHisto()->GetAxis(9)->SetRangeUser(0.5,1.5);
 115         pTPC->GetTPCTrackHisto()->GetAxis(7)->SetRangeUser(0.25,10);
 116         pTPC->GetTPCTrackHisto()->GetAxis(5)->SetRangeUser(-1,1);
 117         AnalyzeNCL(pTPC, pcstream);
 118         AnalyzeDrift(pTPC, pcstream);
 119         AnalyzeDriftPos(pTPC, pcstream);
 120         AnalyzeDriftNeg(pTPC, pcstream);
 121         AnalyzeDCARPhi(pTPC, pcstream);
 122         AnalyzeDCARPhiPos(pTPC, pcstream);
 123         AnalyzeDCARPhiNeg(pTPC, pcstream);
 124         AnalyzeEvent(pTPC, pcstream);
 125
 126         AnalyzePt(pTPC,pcstream);
 127         AnalyzeChargeOverPt(pTPC,pcstream);
 128         AnalyzeQAPosNegDpT(pTPC,pcstream);
 129         AnalyzeQADCAFitParameter(pTPC,pcstream);
 130         AnalyzeOcc(pTPC,pcstream);
 131
 132         pTPC->GetTPCTrackHisto()->GetAxis(9)->SetRangeUser(-10,10);
 133         pTPC->GetTPCTrackHisto()->GetAxis(7)->SetRangeUser(0,100);
 134         pTPC->GetTPCTrackHisto()->GetAxis(5)->SetRangeUser(-10,10);
 135     }
 136     AnalyzeGain(pTPCgain, pcstream);
 137     AnalyzeMatch(pTPCMatch, pcstream);
 138     AnalyzePull(pTPCPull, pcstream);
 139     AnalyzeConstrain(pConstrain, pcstream);
 140
 141     (*pcstream)<<"tpcQA"<<"\n";
 142 }
 143
 144 //_____________________________________________________________________________
 145 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)
 146 {
 147     //
 148     // Extracts performance parameters from pTPC and pTPCgain.
 149     // Output is written to a TTree saved in outfile.
 150     // The run number must be provided since it is not stored in
 151     // AliPerformanceTPC or AliPerformanceDEdx.
 152     //
 153     // The function creates a TTreeSRedirector and calls the
 154     // function WriteToTTreeSRedirector.
 155     //
 156
 157     if (!outfile) return;
 158     TTreeSRedirector* pcstream = 0;
 159     pcstream = new TTreeSRedirector(outfile);
 160     if (!pcstream) return;
 161     WriteToTTreeSRedirector(pTPC, pTPCgain, pMatch, pPull, pConstrain, pcstream, run);
 162     if (pcstream) { delete pcstream; pcstream = 0; }
 163
 164 }
 165
 166 //_____________________________________________________________________________
 167 Int_t AliTPCPerformanceSummary::MakeReport(const Char_t* infile, const Char_t* outfile, Int_t run)
 168 {
 169     //
 170     // Reads QA information (AliPerformanceTPC and AliPerformanceDEdx) from
 171     // infile (this must be a rootfile) and writes the output to a TTree
 172     // stored in outfile.
 173     // The run number must be provided since it is not stored in
 174     // AliPerformanceTPC or AliPerformanceDEdx.
 175     //
 176     // The input objects must be named "AliPerformanceTPC" and
 177     // "AliPerformanceDEdxTPCInner" and stored in a TList which name must
 178     // be one of the following: "TPC", "TPCQA", "TPC_PerformanceQA"
 179     // or "TPC_PerformanceQA/TPC" (with directory)
 180     //
 181
 182     if (!infile) return -1;
 183     if (!outfile) return -1;
 184     TFile *f =0;
 185     f=TFile::Open(infile,"read");
 186     if (!f) {
 187         printf("File %s not available\n", infile);
 188         return -1;
 189     }
 190     TList* list = 0;
 191     list = dynamic_cast<TList*>(f->Get("TPC"));
 192     if (!list) { list = dynamic_cast<TList*>(f->Get("TPCQA")); }
 193     if (!list) { list = dynamic_cast<TList*>(f->Get("TPC_PerformanceQA/TPCQA")); }
 194     if (!list) { list = dynamic_cast<TList*>(f->Get("TPC_PerformanceQA")); }
 195     if (!list) { list = dynamic_cast<TList*>(f->Get("ITSTPCMatch")); }
 196     if (!list) {
 197             printf("QA %s not available\n", infile);
 198             return -1;
 199     }
 200     AliPerformanceTPC* pTPC = 0;
 201     AliPerformanceDEdx* pTPCgain = 0;
 202     AliPerformanceMatch* pTPCmatch = 0;
 203     AliPerformanceMatch* pTPCPull = 0;
 204     AliPerformanceMatch* pConstrain = 0;
 205
 206     if (list) {  pTPC = dynamic_cast<AliPerformanceTPC*>(list->FindObject("AliPerformanceTPC")); }
 207     if (list) {  pTPCgain = dynamic_cast<AliPerformanceDEdx*>(list->FindObject("AliPerformanceDEdxTPCInner")); }
 208     if (list) {  pTPCmatch = dynamic_cast<AliPerformanceMatch*>(list->FindObject("AliPerformanceMatchTPCITS")); }
 209     if (list) {  pTPCPull = dynamic_cast<AliPerformanceMatch*>(list->FindObject("AliPerformanceMatchITSTPC")); }
 210     if (list) {  pConstrain = dynamic_cast<AliPerformanceMatch*>(list->FindObject("AliPerformanceMatchTPCConstrain")); }
 211
 212     Int_t returncode = 0;
 213     WriteToFile(pTPC, pTPCgain, pTPCmatch , pTPCPull, pConstrain, outfile, run);
 214     if (f) { delete f; f=0; }
 215     return returncode;
 216 }
 217
 218 //_____________________________________________________________________________
 219 Int_t AliTPCPerformanceSummary::ProduceTrends(const Char_t* infilelist, const Char_t* outfile)
 220 {
 221     //
 222     // Produces trend graphs.
 223     //
 224     // Input: infilelist is a textfile with one rootfile per line.
 225     // There should be one rootfile for each run, the rootfile must
 226     // contain the output of the MakeReport function
 227     // Output: the information for all runs is merged into a TTree
 228     // that is saved in outfile along with the trend graphs.
 229     // Trend graphs are stored as TCanvas objects to include axis labels etc.
 230     //
 231
 232     if (!infilelist) return -1;
 233     if (!outfile) return -1;
 234
 235     TChain* chain = new TChain("tpcQA");
 236     if(!chain) return -1;
 237
 238     ifstream in;
 239     in.open(infilelist);
 240
 241     TString currentFile;
 242     while(in.good()) {
 243         in >> currentFile;
 244
 245         if (!currentFile.Contains("root")) continue; // protection
 246         chain->Add(currentFile.Data());
 247     }
 248     in.close();
 249     //TTree *tree = chain;
 250     TTree *tree = chain->CopyTree("1");
 251     if(!tree) return -1;
 252     if (chain) { delete chain; chain=0; }
 253     //TGraph* graph = dynamic_cast<TGraph*>(tree->DrawClone("run:run"));
 254     //TGraph *graph = (TGraph*)gPad->GetPrimitive("Graph");
 255
 256     TFile* out = new TFile(outfile,"RECREATE");
 257     if(!out) return -1;
 258
 259     out->cd();
 260     const Char_t* condition = "meanTPCncl>0";
 261     SaveGraph(tree,"meanTPCnclF","run",condition);
 262     SaveGraph(tree,"rmsTPCnclF","run",condition);
 263     SaveGraph(tree,"meanTPCChi2","run",condition);
 264     SaveGraph(tree,"rmsTPCChi2","run",condition);
 265     SaveGraph(tree,"slopeATPCnclF","run",condition);
 266     SaveGraph(tree,"slopeCTPCnclF","run",condition);
 267     SaveGraph(tree,"slopeATPCnclFErr","run",condition);
 268     SaveGraph(tree,"slopeCTPCnclFErr","run",condition);
 269     SaveGraph(tree,"meanTPCncl","run",condition);
 270     SaveGraph(tree,"rmsTPCncl","run",condition);
 271     SaveGraph(tree,"slopeATPCncl","run",condition);
 272     SaveGraph(tree,"slopeCTPCncl","run",condition);
 273     SaveGraph(tree,"slopeATPCnclErr","run",condition);
 274     SaveGraph(tree,"slopeCTPCnclErr","run",condition);
 275
 276     SaveGraph(tree,"offsetdRA","run",condition);
 277     SaveGraph(tree,"slopedRA","run",condition);
 278     SaveGraph(tree,"offsetdRC","run",condition);
 279     SaveGraph(tree,"slopedRC","run",condition);
 280     SaveGraph(tree,"offsetdRAErr","run",condition);
 281     SaveGraph(tree,"slopedRAErr","run",condition);
 282     SaveGraph(tree,"offsetdRCErr","run",condition);
 283     SaveGraph(tree,"slopedRCErr","run",condition);
 284     SaveGraph(tree,"offsetdRAchi2","run",condition);
 285     SaveGraph(tree,"slopedRAchi2","run",condition);
 286     SaveGraph(tree,"offsetdRCchi2","run",condition);
 287     SaveGraph(tree,"slopedRCchi2","run",condition);
 288
 289     SaveGraph(tree,"offsetdRAPos","run",condition);
 290
 291     SaveGraph(tree,"slopedRAPos","run",condition);
 292     SaveGraph(tree,"offsetdRCPos","run",condition);
 293     SaveGraph(tree,"slopedRCPos","run",condition);
 294     SaveGraph(tree,"offsetdRAErrPos","run",condition);
 295     SaveGraph(tree,"slopedRAErrPos","run",condition);
 296     SaveGraph(tree,"offsetdRCErrPos","run",condition);
 297     SaveGraph(tree,"slopedRCErrPos","run",condition);
 298     SaveGraph(tree,"offsetdRAchi2Pos","run",condition);
 299     SaveGraph(tree,"slopedRAchi2Pos","run",condition);
 300     SaveGraph(tree,"offsetdRCchi2Pos","run",condition);
 301     SaveGraph(tree,"slopedRCchi2Pos","run",condition);
 302
 303     SaveGraph(tree,"offsetdRANeg","run",condition);
 304     SaveGraph(tree,"slopedRANeg","run",condition);
 305     SaveGraph(tree,"offsetdRCNeg","run",condition);
 306     SaveGraph(tree,"slopedRCNeg","run",condition);
 307     SaveGraph(tree,"offsetdRAErrNeg","run",condition);
 308     SaveGraph(tree,"slopedRAErrNeg","run",condition);
 309     SaveGraph(tree,"offsetdRCErrNeg","run",condition);
 310     SaveGraph(tree,"slopedRCErrNeg","run",condition);
 311     SaveGraph(tree,"offsetdRAchi2Neg","run",condition);
 312     SaveGraph(tree,"slopedRAchi2Neg","run",condition);
 313     SaveGraph(tree,"offsetdRCchi2Neg","run",condition);
 314     SaveGraph(tree,"slopedRCchi2Neg","run",condition);
 315
 316     SaveGraph(tree,"offsetdZAPos","run",condition);
 317     SaveGraph(tree,"slopedZAPos","run",condition);
 318     SaveGraph(tree,"offsetdZCPos","run",condition);
 319     SaveGraph(tree,"slopedZCPos","run",condition);
 320     SaveGraph(tree,"offsetdZAErrPos","run",condition);
 321     SaveGraph(tree,"slopedZAErrPos","run",condition);
 322     SaveGraph(tree,"offsetdZCErrPos","run",condition);
 323     SaveGraph(tree,"slopedZCErrPos","run",condition);
 324     SaveGraph(tree,"offsetdZAchi2Pos","run",condition);
 325     SaveGraph(tree,"slopedZAchi2Pos","run",condition);
 326     SaveGraph(tree,"offsetdZCchi2Pos","run",condition);
 327     SaveGraph(tree,"slopedZCchi2Pos","run",condition);
 328
 329     SaveGraph(tree,"offsetdZANeg","run",condition);
 330     SaveGraph(tree,"slopedZANeg","run",condition);
 331     SaveGraph(tree,"offsetdZCNeg","run",condition);
 332     SaveGraph(tree,"slopedZCNeg","run",condition);
 333     SaveGraph(tree,"offsetdZAErrNeg","run",condition);
 334     SaveGraph(tree,"slopedZAErrNeg","run",condition);
 335     SaveGraph(tree,"offsetdZCErrNeg","run",condition);
 336     SaveGraph(tree,"slopedZCErrNeg","run",condition);
 337     SaveGraph(tree,"offsetdZAchi2Neg","run",condition);
 338     SaveGraph(tree,"slopedZAchi2Neg","run",condition);
 339     SaveGraph(tree,"offsetdZCchi2Neg","run",condition);
 340     SaveGraph(tree,"slopedZCchi2Neg","run",condition);
 341
 342     SaveGraph(tree,"offsetdZA","run",condition);
 343     SaveGraph(tree,"slopedZA","run",condition);
 344     SaveGraph(tree,"offsetdZC","run",condition);
 345     SaveGraph(tree,"slopedZC","run",condition);
 346     SaveGraph(tree,"offsetdZAErr","run",condition);
 347     SaveGraph(tree,"slopedZAErr","run",condition);
 348     SaveGraph(tree,"offsetdZCErr","run",condition);
 349     SaveGraph(tree,"slopedZCErr","run",condition);
 350     SaveGraph(tree,"offsetdZAchi2","run",condition);
 351     SaveGraph(tree,"slopedZAchi2","run",condition);
 352     SaveGraph(tree,"offsetdZCchi2","run",condition);
 353     SaveGraph(tree,"slopedZCchi2","run",condition);
 354
 355     SaveGraph(tree,"meanVertX","run",condition);
 356     SaveGraph(tree,"rmsVertX","run",condition);
 357     SaveGraph(tree,"meanVertY","run",condition);
 358     SaveGraph(tree,"rmsVertY","run",condition);
 359     SaveGraph(tree,"meanVertZ","run",condition);
 360     SaveGraph(tree,"rmsVertZ","run",condition);
 361     SaveGraph(tree,"vertStatus","run",condition);
 362     SaveGraph(tree,"meanMult","run",condition);
 363     SaveGraph(tree,"rmsMult","run",condition);
 364     SaveGraph(tree,"meanMultPos","run",condition);
 365     SaveGraph(tree,"rmsMultPos","run",condition);
 366     SaveGraph(tree,"meanMultNeg","run",condition);
 367     SaveGraph(tree,"rmsMultNeg","run",condition);
 368     SaveGraph(tree,"vertAll","run",condition);
 369     SaveGraph(tree,"vertOK","run",condition);
 370
 371
 372     SaveGraph(tree,"meanPtAPos","run",condition);
 373     SaveGraph(tree,"mediumPtAPos","run",condition);
 374     SaveGraph(tree,"highPtAPos","run",condition);
 375     SaveGraph(tree,"meanPtCPos","run",condition);
 376     SaveGraph(tree,"mediumPtCPos","run",condition);
 377     SaveGraph(tree,"highPtCPos","run",condition);
 378     SaveGraph(tree,"meanPtANeg","run",condition);
 379     SaveGraph(tree,"mediumPtANeg","run",condition);
 380     SaveGraph(tree,"highPtANeg","run",condition);
 381     SaveGraph(tree,"meanPtCNeg","run",condition);
 382     SaveGraph(tree,"mediumPtCNeg","run",condition);
 383     SaveGraph(tree,"highPtCNeg","run",condition);
 384
 385     SaveGraph(tree,"qOverPt","run",condition);
 386     SaveGraph(tree,"qOverPtA","run",condition);
 387     SaveGraph(tree,"qOverPtC","run",condition);
 388
 389     SaveGraph(tree,"dcarAP0","run",condition);
 390     SaveGraph(tree,"dcarAP1","run",condition);
 391     SaveGraph(tree,"dcarCP0","run",condition);
 392     SaveGraph(tree,"dcarCP1","run",condition);
 393
 394     condition = "";
 395     SaveGraph(tree,"tpcItsMatchA","run",condition);
 396     SaveGraph(tree,"tpcItsMatchHighPtA","run",condition);
 397     SaveGraph(tree,"tpcItsMatchC","run",condition);
 398     SaveGraph(tree,"tpcItsMatchHighPtC","run",condition);
 399
 400     SaveGraph(tree,"phiPull","run",condition);
 401     SaveGraph(tree,"phiPullHighPt","run",condition);
 402     SaveGraph(tree,"ptPull","run",condition);
 403     SaveGraph(tree,"ptPullHighPt","run",condition);
 404     SaveGraph(tree,"yPull","run",condition);
 405     SaveGraph(tree,"yPullHighPt","run",condition);
 406     SaveGraph(tree,"zPull","run",condition);
 407     SaveGraph(tree,"zPullHighPt","run",condition);
 408     SaveGraph(tree,"lambdaPull","run",condition);
 409     SaveGraph(tree,"lambdaPullHighPt","run",condition);
 410
 411     SaveGraph(tree,"tpcConstrainPhiA","run",condition);
 412     SaveGraph(tree,"tpcConstrainPhiC","run",condition);
 413
 414     SaveGraph(tree,"deltaPt","run",condition);
 415     SaveGraph(tree,"deltaPtchi2","run",condition);
 416     SaveGraph(tree,"deltaPtA","run",condition);
 417     SaveGraph(tree,"deltaPtchi2A","run",condition);
 418     SaveGraph(tree,"deltaPtC","run",condition);
 419     SaveGraph(tree,"deltaPtchi2C","run",condition);
 420     SaveGraph(tree,"deltaPtA_Err","run",condition);
 421     SaveGraph(tree,"deltaPtA_Err","run",condition);
 422     SaveGraph(tree,"deltaPtC_Err","run",condition);
 423
 424     ////////////////////////////////////////////////////////////////////////////////////////////////////////
 425  //save dca fit parameters
 426     SaveGraph(tree,"dcar_posA_0","run",condition);
 427     SaveGraph(tree,"dcar_posA_1","run",condition);
 428     SaveGraph(tree,"dcar_posA_2","run",condition);
 429     SaveGraph(tree,"dcar_posA_chi2","run",condition);
 430     SaveGraph(tree,"dcar_posA_0_Err","run",condition);
 431     SaveGraph(tree,"dcar_posA_1_Err","run",condition);
 432     SaveGraph(tree,"dcar_posA_2_Err","run",condition);
 433
 434     SaveGraph(tree,"dcaz_posA_0","run",condition);
 435     SaveGraph(tree,"dcaz_posA_1","run",condition);
 436     SaveGraph(tree,"dcaz_posA_2","run",condition);
 437     SaveGraph(tree,"dcaz_posA_chi2","run",condition);
 438     SaveGraph(tree,"dcaz_posA_0_Err","run",condition);
 439     SaveGraph(tree,"dcaz_posA_1_Err","run",condition);
 440     SaveGraph(tree,"dcaz_posA_2_Err","run",condition);
 441
 442     SaveGraph(tree,"dcaz_posC_0","run",condition);
 443     SaveGraph(tree,"dcaz_posC_1","run",condition);
 444     SaveGraph(tree,"dcaz_posC_2","run",condition);
 445     SaveGraph(tree,"dcaz_posC_chi2","run",condition);
 446     SaveGraph(tree,"dcaz_posC_0_Err","run",condition);
 447     SaveGraph(tree,"dcaz_posC_1_Err","run",condition);
 448     SaveGraph(tree,"dcaz_posC_2_Err","run",condition);
 449
 450     SaveGraph(tree,"dcar_posC_0","run",condition);
 451     SaveGraph(tree,"dcar_posC_1","run",condition);
 452     SaveGraph(tree,"dcar_posC_2","run",condition);
 453     SaveGraph(tree,"dcar_posC_chi2","run",condition);
 454     SaveGraph(tree,"dcar_posC_0_Err","run",condition);
 455     SaveGraph(tree,"dcar_posC_1_Err","run",condition);
 456     SaveGraph(tree,"dcar_posC_2_Err","run",condition);
 457
 458     SaveGraph(tree,"dcar_negA_0","run",condition);
 459     SaveGraph(tree,"dcar_negA_1","run",condition);
 460     SaveGraph(tree,"dcar_negA_2","run",condition);
 461     SaveGraph(tree,"dcar_negA_chi2","run",condition);
 462     SaveGraph(tree,"dcar_negA_0_Err","run",condition);
 463     SaveGraph(tree,"dcar_negA_1_Err","run",condition);
 464     SaveGraph(tree,"dcar_negA_2_Err","run",condition);
 465
 466     SaveGraph(tree,"dcaz_negA_0","run",condition);
 467     SaveGraph(tree,"dcaz_negA_1","run",condition);
 468     SaveGraph(tree,"dcaz_negA_2","run",condition);
 469     SaveGraph(tree,"dcaz_negA_chi2","run",condition);
 470     SaveGraph(tree,"dcaz_negA_0_Err","run",condition);
 471     SaveGraph(tree,"dcaz_negA_1_Err","run",condition);
 472     SaveGraph(tree,"dcaz_negA_2_Err","run",condition);
 473
 474     SaveGraph(tree,"dcaz_negC_0","run",condition);
 475     SaveGraph(tree,"dcaz_negC_1","run",condition);
 476     SaveGraph(tree,"dcaz_negC_2","run",condition);
 477     SaveGraph(tree,"dcaz_negC_chi2","run",condition);
 478     SaveGraph(tree,"dcaz_negC_0_Err","run",condition);
 479     SaveGraph(tree,"dcaz_negC_1_Err","run",condition);
 480     SaveGraph(tree,"dcaz_negC_2_Err","run",condition);
 481
 482     SaveGraph(tree,"dcar_negC_0","run",condition);
 483     SaveGraph(tree,"dcar_negC_1","run",condition);
 484     SaveGraph(tree,"dcar_negC_2","run",condition);
 485     SaveGraph(tree,"dcar_negC_chi2","run",condition);
 486     SaveGraph(tree,"dcar_negC_0_Err","run",condition);
 487     SaveGraph(tree,"dcar_negC_1_Err","run",condition);
 488     SaveGraph(tree,"dcar_negC_2_Err","run",condition);
 489
 490     SaveGraph(tree,"iroc_A_side","run",condition);
 491     SaveGraph(tree,"iroc_C_side","run",condition);
 492     SaveGraph(tree,"oroc_A_side","run",condition);
 493     SaveGraph(tree,"oroc_C_side","run",condition);
 494
 495     //A/C side IROC
 496     SaveGraph(tree,"TPC_Occ_IROC.","run",condition);
 497     SaveGraph(tree,"TPC_Occ_OROC.","run",condition);
 498     ////////////////////////////////////////////////////////////////////////////////////////////////////////
 499
 500     tree->Write();
 501     out->Close();
 502     if (tree) { delete tree; tree=0; }
 503     if (out) { delete out; out=0; }
 504     return 0;
 505 }
 506
 507 //_____________________________________________________________________________
 508 Int_t AliTPCPerformanceSummary::SaveGraph(TTree* tree, const Char_t* y, const Char_t* x, const Char_t* condition)
 509 {
 510     //
 511     // Creates a Graph and writes the canvas to the current directory
 512     // called by ProduceTrends function.
 513     //
 514
 515     TString s(y);
 516     s += ':';
 517     s += x;
 518     tree->Draw(s.Data(),condition,"goff");
 519     TCanvas* c = new TCanvas(s.Data(),s.Data());
 520     c->cd();
 521     TPad* p = new TPad("pad0","pad0",0,0,1,1);
 522     p->Draw();
 523     p->cd();
 524     if (tree->GetSelectedRows() > 0) {
 525       TGraph* graph = new TGraph(tree->GetSelectedRows(), tree->GetV2(), tree->GetV1());
 526       graph->Draw("AP");
 527       graph->GetXaxis()->SetTitle(x);
 528       graph->GetYaxis()->SetTitle(y);
 529       c->Write(s.Data());
 530       delete graph;
 531     }
 532     //graph->Write(s.Data());
 533     delete c;
 534
 535 return 0;
 536 }
 537
 538 //_____________________________________________________________________________
 539 Int_t AliTPCPerformanceSummary::AnalyzeDCARPhi(const AliPerformanceTPC* pTPC, TTreeSRedirector* const pcstream)
 540 {
 541     //
 542     // Analyse DCA R imperfections
 543     //
 544
 545     if (!pcstream) return 8;
 546     if (!pTPC) return 8;
 547
 548     // variables:
 549     static Double_t offsetdRA=0;
 550     static Double_t slopedRA=0;
 551     static Double_t offsetdRC=0;
 552     static Double_t slopedRC=0;
 553     static Double_t offsetdRAErr=0;
 554     static Double_t slopedRAErr=0;
 555     static Double_t offsetdRCErr=0;
 556     static Double_t slopedRCErr=0;
 557     static Double_t offsetdRAchi2=0;
 558     static Double_t slopedRAchi2=0;
 559     static Double_t offsetdRCchi2=0;
 560     static Double_t slopedRCchi2=0;
 561     static Double_t dcarAP0 = 0;
 562     static Double_t dcarAP1 = 0;
 563     static Double_t dcarCP0 = 0;
 564     static Double_t dcarCP1 = 0;
 565
 566     //AliPerformanceTPC* pTPC =  dynamic_cast<AliPerformanceTPC*>(pTPCObject);
 567
 568     TH1* his1D=0;
 569     TH2* his2D=0;
 570     TH3* his3D=0;
 571
 572     if (pTPC->GetHistos()->FindObject("h_tpc_track_all_recvertex_3_5_7")) {
 573         his3D = dynamic_cast<TH3*>(pTPC->GetHistos()->FindObject("h_tpc_track_all_recvertex_3_5_7"));
 574         if(!his3D) return 8;
 575         his3D->GetYaxis()->SetRangeUser(-1,1);
 576         his3D->GetZaxis()->SetRangeUser(0.25,10);
 577     }
 578
 579     static TF1 *fpol1 = new TF1("fpol1","pol1");
 580     TObjArray arrayFit;
 581     if (his3D && !fgForceTHnSparse) {
 582         his2D = dynamic_cast<TH2*>(his3D->Project3D("xy"));
 583     } else {
 584         his2D = pTPC->GetTPCTrackHisto()->Projection(3,5);
 585     }
 586     if(!his2D) return 8;
 587
 588
 589     his2D->FitSlicesY(0,0,-1,10,"QNR",&arrayFit);
 590     delete his2D;
 591     his1D = (TH1*) arrayFit.At(1);
 592     his1D->Fit(fpol1,"QNRROB=0.8","QNR",-0.8,-0.1);
 593     offsetdRC=fpol1->GetParameter(0);
 594     slopedRC=fpol1->GetParameter(1);
 595     offsetdRCchi2=fpol1->GetChisquare();
 596     slopedRCchi2=fpol1->GetChisquare();
 597     //
 598     his1D->Fit(fpol1,"QNRROB=0.8","QNR",0.1,0.8);
 599     offsetdRA=fpol1->GetParameter(0);
 600     slopedRA=fpol1->GetParameter(1);
 601     offsetdRAErr=fpol1->GetParError(0);
 602     slopedRAErr=fpol1->GetParError(1);
 603     offsetdRAchi2=fpol1->GetChisquare();
 604     slopedRAchi2=fpol1->GetChisquare();
 605     //
 606     printf("DCA R QA report\n");
 607     printf("offsetdRA\t%f\n",offsetdRA);
 608     printf("slopedRA\t%f\n",slopedRA);
 609     printf("offsetdRC\t%f\n",offsetdRC);
 610     printf("slopedRC\t%f\n",slopedRC);
 611
 612     //
 613     //extraction of DCAr versus pt
 614     //
 615     TLinearFitter linearFit;
 616     linearFit.SetFormula("pol1");
 617     TObjArray arrayWidth;
 618     TH1 *width;
 619     Int_t nXbins;
 620     Double_t x,y;
 621     Int_t pn = 1;
 622
 623     if(!his3D)
 624       return 8;
 625     his3D->GetYaxis()->SetRangeUser(-1,1);
 626
 627     //get his2D in A Side
 628     his3D->GetYaxis()->SetRangeUser(0,1);
 629     his3D->GetZaxis()->SetRangeUser(0.35,8);
 630     his2D  = dynamic_cast<TH2*>(his3D->Project3D("xz"));
 631     if (his2D)
 632       his2D->FitSlicesY(0,0,-1,0,"QNR",&arrayWidth);
 633
 634     width =  dynamic_cast<TH1*>(arrayWidth.At(2));
 635     if (width)
 636     {
 637       nXbins = width->GetNbinsX();
 638     for(Int_t i=2; i<nXbins; i++){
 639       x = width->GetBinCenter(i);
 640       if(x!=0)
 641         x = 1.0/(x*x);
 642       y = width->GetBinContent(i);
 643       y = y*y;
 644       linearFit.AddPoint(&x,y,1);
 645     }
 646     if(!linearFit.Eval()){
 647
 648       dcarAP0 = linearFit.GetParameter(0);
 649       if(dcarAP0!=0)
 650         pn = Int_t(TMath::Abs(dcarAP0)/dcarAP0);
 651       dcarAP0 = pn*TMath::Sqrt(TMath::Abs(dcarAP0));
 652
 653       dcarAP1 = linearFit.GetParameter(1);
 654       if(dcarAP1!=0)
 655         pn = Int_t(TMath::Abs(dcarAP1)/dcarAP1);
 656       dcarAP1 = pn*TMath::Sqrt(TMath::Abs(dcarAP1));
 657     }
 658     }
 659
 660     linearFit.ClearPoints();
 661
 662     //get his2D in C Side
 663     his3D->GetYaxis()->SetRangeUser(-1,-0.001);
 664     his2D  = dynamic_cast<TH2*>(his3D->Project3D("xz"));
 665     if (his2D)
 666       his2D->FitSlicesY(0,0,-1,0,"QNR",&arrayWidth);
 667       width =  dynamic_cast<TH1*>(arrayWidth.At(2));
 668     if (width)
 669     {
 670       nXbins = width->GetNbinsX();
 671     for(Int_t i=2; i<nXbins; i++){
 672       x = width->GetBinCenter(i);
 673       if(x!=0)
 674         x = 1.0/(x*x);
 675       y = width->GetBinContent(i);
 676       y = y*y;
 677       linearFit.AddPoint(&x,y);
 678     }
 679     if(!linearFit.Eval()){
 680       dcarCP0 = linearFit.GetParameter(0);
 681       if(dcarCP0!=0)
 682         pn = Int_t(TMath::Abs(dcarCP0)/dcarCP0);
 683       dcarCP0 = pn*TMath::Sqrt(TMath::Abs(dcarCP0));
 684
 685       dcarCP1 = linearFit.GetParameter(1);
 686       if(dcarCP1!=0)
 687         pn = Int_t(TMath::Abs(dcarCP1)/dcarCP1);
 688       dcarCP1 = pn*TMath::Sqrt(TMath::Abs(dcarCP1));
 689     }
 690     }
 691     his3D->GetYaxis()->SetRangeUser(-1,1);
 692     his3D->GetZaxis()->SetRangeUser(0,20);
 693
 694     //
 695     // dump values
 696     //
 697     (*pcstream)<<"tpcQA"<<
 698         "offsetdRA="<< offsetdRA<<
 699         "slopedRA="<< slopedRA<<
 700         "offsetdRC="<< offsetdRC<<
 701         "slopedRC="<<slopedRC<<
 702         //
 703         "offsetdRAErr="<< offsetdRAErr<<
 704         "slopedRAErr="<< slopedRAErr<<
 705         "offsetdRCErr="<< offsetdRCErr<<
 706         "slopedRCErr="<<slopedRCErr<<
 707         //
 708         "offsetdRAchi2="<< offsetdRAchi2<<
 709         "slopedRAchi2="<< slopedRAchi2<<
 710         "offsetdRCchi2="<< offsetdRCchi2<<
 711         "slopedRCchi2="<<slopedRCchi2<<
 712         //
 713         "dcarAP0="<<dcarAP0<<
 714         "dcarAP1="<<dcarAP1<<
 715         "dcarCP0="<<dcarCP0<<
 716         "dcarCP1="<<dcarCP1;
 717
 718     return 0;
 719 }
 720
 721 //_____________________________________________________________________________
 722 Int_t AliTPCPerformanceSummary::AnalyzeDCARPhiPos(const AliPerformanceTPC* pTPC, TTreeSRedirector* const pcstream)
 723 {
 724     //
 725     // Analyse DCA R imperfections for positive particles
 726     //
 727
 728     if (!pcstream) return 16;
 729     if (!pTPC) return 16;
 730
 731     // variables:
 732     static Double_t offsetdRAPos=0;
 733     static Double_t slopedRAPos=0;
 734     static Double_t offsetdRCPos=0;
 735     static Double_t slopedRCPos=0;
 736     static Double_t offsetdRAErrPos=0;
 737     static Double_t slopedRAErrPos=0;
 738     static Double_t offsetdRCErrPos=0;
 739     static Double_t slopedRCErrPos=0;
 740     static Double_t offsetdRAchi2Pos=0;
 741     static Double_t slopedRAchi2Pos=0;
 742     static Double_t offsetdRCchi2Pos=0;
 743     static Double_t slopedRCchi2Pos=0;
 744
 745     //AliPerformanceTPC* pTPC =  dynamic_cast<AliPerformanceTPC*>(pTPCObject);
 746     TH1* his1D=0;
 747     TH2* his2D=0;
 748     TH3* his3D=0;
 749
 750     if (pTPC->GetHistos()->FindObject("h_tpc_track_pos_recvertex_3_5_7")) {
 751         his3D = dynamic_cast<TH3*>(pTPC->GetHistos()->FindObject("h_tpc_track_pos_recvertex_3_5_7"));
 752         if(!his3D) return 16;
 753         his3D->GetYaxis()->SetRangeUser(-1,1);
 754         his3D->GetZaxis()->SetRangeUser(0.25,10);
 755     }
 756
 757     static TF1 *fpol1 = new TF1("fpol1","pol1");
 758     TObjArray arrayFit;
 759     if (his3D && !fgForceTHnSparse) {
 760         his2D = dynamic_cast<TH2*>(his3D->Project3D("xy"));
 761     } else {
 762         pTPC->GetTPCTrackHisto()->GetAxis(8)->SetRangeUser(0,1.5);
 763         his2D = pTPC->GetTPCTrackHisto()->Projection(3,5);
 764         pTPC->GetTPCTrackHisto()->GetAxis(8)->SetRangeUser(-1.5,1.5);
 765     }
 766     if(!his2D) return 16;
 767
 768     his2D->FitSlicesY(0,0,-1,10,"QNR",&arrayFit);
 769     delete his2D;
 770     his1D = (TH1*) arrayFit.At(1);
 771     his1D->Fit(fpol1,"QNRROB=0.8","QNR",-0.8,-0.1);
 772     offsetdRCPos=fpol1->GetParameter(0);
 773     slopedRCPos=fpol1->GetParameter(1);
 774     offsetdRCchi2Pos=fpol1->GetChisquare();
 775     slopedRCchi2Pos=fpol1->GetChisquare();
 776     //
 777     his1D->Fit(fpol1,"QNRROB=0.8","QNR",0.1,0.8);
 778     offsetdRAPos=fpol1->GetParameter(0);
 779     slopedRAPos=fpol1->GetParameter(1);
 780     offsetdRAErrPos=fpol1->GetParError(0);
 781     slopedRAErrPos=fpol1->GetParError(1);
 782     offsetdRAchi2Pos=fpol1->GetChisquare();
 783     slopedRAchi2Pos=fpol1->GetChisquare();
 784     //
 785     printf("DCA R QA Pos report\n");
 786     printf("offsetdRAPos\t%f\n",offsetdRAPos);
 787     printf("slopedRAPos\t%f\n",slopedRAPos);
 788     printf("offsetdRCPos\t%f\n",offsetdRCPos);
 789     printf("slopedRCPos\t%f\n",slopedRCPos);
 790     //
 791     // dump values
 792     //
 793     (*pcstream)<<"tpcQA"<<
 794         "offsetdRAPos="<< offsetdRAPos<<
 795         "slopedRAPos="<< slopedRAPos<<
 796         "offsetdRCPos="<< offsetdRCPos<<
 797         "slopedRCPos="<<slopedRCPos<<
 798         //
 799         "offsetdRAErrPos="<< offsetdRAErrPos<<
 800         "slopedRAErrPos="<< slopedRAErrPos<<
 801         "offsetdRCErrPos="<< offsetdRCErrPos<<
 802         "slopedRCErrPos="<<slopedRCErrPos<<
 803         //
 804         "offsetdRAchi2Pos="<< offsetdRAchi2Pos<<
 805         "slopedRAchi2Pos="<< slopedRAchi2Pos<<
 806         "offsetdRCchi2Pos="<< offsetdRCchi2Pos<<
 807         "slopedRCchi2Pos="<<slopedRCchi2Pos;
 808
 809     return 0;
 810 }
 811
 812 //_____________________________________________________________________________
 813 Int_t AliTPCPerformanceSummary::AnalyzeDCARPhiNeg(const AliPerformanceTPC* pTPC, TTreeSRedirector* const pcstream)
 814 {
 815     //
 816     // Analyse DCA R imperfections for negative particles
 817     //
 818     if (!pcstream) return 32;
 819     if (!pTPC) return 32;
 820
 821     // variables:
 822     static Double_t offsetdRANeg=0;
 823     static Double_t slopedRANeg=0;
 824     static Double_t offsetdRCNeg=0;
 825     static Double_t slopedRCNeg=0;
 826     static Double_t offsetdRAErrNeg=0;
 827     static Double_t slopedRAErrNeg=0;
 828     static Double_t offsetdRCErrNeg=0;
 829     static Double_t slopedRCErrNeg=0;
 830     static Double_t offsetdRAchi2Neg=0;
 831     static Double_t slopedRAchi2Neg=0;
 832     static Double_t offsetdRCchi2Neg=0;
 833     static Double_t slopedRCchi2Neg=0;
 834
 835     //AliPerformanceTPC* pTPC =  dynamic_cast<AliPerformanceTPC*>(pTPCObject);
 836     TH1* his1D=0;
 837     TH2* his2D=0;
 838     TH3* his3D=0;
 839
 840     if (pTPC->GetHistos()->FindObject("h_tpc_track_neg_recvertex_3_5_7")) {
 841         his3D = dynamic_cast<TH3*>(pTPC->GetHistos()->FindObject("h_tpc_track_neg_recvertex_3_5_7"));
 842         if(!his3D) return 32;
 843         his3D->GetYaxis()->SetRangeUser(-1,1);
 844         his3D->GetZaxis()->SetRangeUser(0.25,10);
 845     }
 846
 847     static TF1 *fpol1 = new TF1("fpol1","pol1");
 848     TObjArray arrayFit;
 849     if (his3D && !fgForceTHnSparse) {
 850         his2D = dynamic_cast<TH2*>(his3D->Project3D("xy"));
 851     } else {
 852         pTPC->GetTPCTrackHisto()->GetAxis(8)->SetRangeUser(-1.5,0);
 853         his2D = pTPC->GetTPCTrackHisto()->Projection(3,5);
 854         pTPC->GetTPCTrackHisto()->GetAxis(8)->SetRangeUser(-1.5,1.5);
 855     }
 856     if(!his2D) return 32;
 857
 858     his2D->FitSlicesY(0,0,-1,10,"QNR",&arrayFit);
 859     delete his2D;
 860     his1D = (TH1*) arrayFit.At(1);
 861     his1D->Fit(fpol1,"QNRROB=0.8","QNR",-0.8,-0.1);
 862     offsetdRCNeg=fpol1->GetParameter(0);
 863     slopedRCNeg=fpol1->GetParameter(1);
 864     offsetdRCchi2Neg=fpol1->GetChisquare();
 865     slopedRCchi2Neg=fpol1->GetChisquare();
 866     //
 867     his1D->Fit(fpol1,"QNRROB=0.8","QNR",0.1,0.8);
 868     offsetdRANeg=fpol1->GetParameter(0);
 869     slopedRANeg=fpol1->GetParameter(1);
 870     offsetdRAErrNeg=fpol1->GetParError(0);
 871     slopedRAErrNeg=fpol1->GetParError(1);
 872     offsetdRAchi2Neg=fpol1->GetChisquare();
 873     slopedRAchi2Neg=fpol1->GetChisquare();
 874     //
 875     printf("DCA R QA Neg report\n");
 876     printf("offsetdRANeg\t%f\n",offsetdRANeg);
 877     printf("slopedRANeg\t%f\n",slopedRANeg);
 878     printf("offsetdRCNeg\t%f\n",offsetdRCNeg);
 879     printf("slopedRCNeg\t%f\n",slopedRCNeg);
 880     //
 881     // dump drift QA values
 882     //
 883     (*pcstream)<<"tpcQA"<<
 884         "offsetdRANeg="<< offsetdRANeg<<
 885         "slopedRANeg="<< slopedRANeg<<
 886         "offsetdRCNeg="<< offsetdRCNeg<<
 887         "slopedRCNeg="<<slopedRCNeg<<
 888         //
 889         "offsetdRAErrNeg="<< offsetdRAErrNeg<<
 890         "slopedRAErrNeg="<< slopedRAErrNeg<<
 891         "offsetdRCErrNeg="<< offsetdRCErrNeg<<
 892         "slopedRCErrNeg="<<slopedRCErrNeg<<
 893         //
 894         "offsetdRAchi2Neg="<< offsetdRAchi2Neg<<
 895         "slopedRAchi2Neg="<< slopedRAchi2Neg<<
 896         "offsetdRCchi2Neg="<< offsetdRCchi2Neg<<
 897         "slopedRCchi2Neg="<<slopedRCchi2Neg;
 898
 899     return 0;
 900 }
 901
 902 //_____________________________________________________________________________
 903 Int_t AliTPCPerformanceSummary::AnalyzeNCL(const AliPerformanceTPC* pTPC, TTreeSRedirector* const pcstream)
 904 {
 905     //
 906     // Analyse number of TPC clusters
 907     //
 908
 909     if (!pcstream) return 1;
 910     if (!pTPC) return 1;
 911
 912     // variables:
 913     static Double_t meanTPCnclF=0;
 914     static Double_t rmsTPCnclF=0;
 915     static Double_t meanTPCChi2=0;
 916     static Double_t rmsTPCChi2=0;
 917     static Double_t slopeATPCnclF=0;
 918     static Double_t slopeCTPCnclF=0;
 919     static Double_t slopeATPCnclFErr=0;
 920     static Double_t slopeCTPCnclFErr=0;
 921     static Double_t meanTPCncl=0;
 922     static Double_t rmsTPCncl=0;
 923     static Double_t slopeATPCncl=0;
 924     static Double_t slopeCTPCncl=0;
 925     static Double_t slopeATPCnclErr=0;
 926     static Double_t slopeCTPCnclErr=0;
 927     //
 928     TH1* his1D=0;
 929     TH3* his3D0=0;
 930     TH3* his3D1=0;
 931     TH3* his3D2=0;
 932     TProfile* hprof=0;
 933     static TF1 *fpol1 = new TF1("fpol1","pol1");
 934     //
 935     // all clusters
 936     // only events with rec. vertex
 937     // eta cut - +-1
 938     // pt cut  - 0.250 GeV
 939     pTPC->GetTPCTrackHisto()->GetAxis(5)->SetRangeUser(-1.,1.);
 940     pTPC->GetTPCTrackHisto()->GetAxis(7)->SetRangeUser(0.25,10);
 941
 942     if (pTPC->GetHistos()->FindObject("h_tpc_track_all_recvertex_0_5_7")) {
 943         his3D0 = dynamic_cast<TH3*>(pTPC->GetHistos()->FindObject("h_tpc_track_all_recvertex_0_5_7"));
 944         if(!his3D0) return 1;
 945         his3D0->GetYaxis()->SetRangeUser(-1,1);
 946         his3D0->GetZaxis()->SetRangeUser(0.25,10);
 947     }
 948     if (pTPC->GetHistos()->FindObject("h_tpc_track_all_recvertex_1_5_7")) {
 949         his3D1 = dynamic_cast<TH3*>(pTPC->GetHistos()->FindObject("h_tpc_track_all_recvertex_1_5_7"));
 950         if(!his3D1) return 1;
 951         his3D1->GetYaxis()->SetRangeUser(-1,1);
 952         his3D1->GetZaxis()->SetRangeUser(0.25,10);
 953     }
 954     if (pTPC->GetHistos()->FindObject("h_tpc_track_all_recvertex_2_5_7")) {
 955         his3D2 = dynamic_cast<TH3*>(pTPC->GetHistos()->FindObject("h_tpc_track_all_recvertex_2_5_7"));
 956         if(!his3D2) return 1;
 957         his3D2->GetYaxis()->SetRangeUser(-1,1);
 958         his3D2->GetZaxis()->SetRangeUser(0.25,10);
 959         his3D2->GetXaxis()->SetRangeUser(0.4,1.1);
 960     }
 961
 962
 963     if (his3D0 && !fgForceTHnSparse) {
 964          his1D = his3D0->Project3D("x");
 965     } else {
 966          his1D = pTPC->GetTPCTrackHisto()->Projection(0);
 967     }
 968
 969     meanTPCncl= his1D->GetMean();
 970     rmsTPCncl= his1D->GetRMS();
 971     delete his1D;
 972
 973     if (his3D1 && !fgForceTHnSparse) {
 974          his1D = his3D1->Project3D("x");
 975     } else {
 976          his1D = pTPC->GetTPCTrackHisto()->Projection(1);
 977     }
 978
 979     meanTPCChi2= his1D->GetMean();
 980     rmsTPCChi2= his1D->GetRMS();
 981     delete his1D;
 982
 983    if (his3D0 && !fgForceTHnSparse) {
 984         hprof = (dynamic_cast<TH2*>(his3D0->Project3D("xy")))->ProfileX();
 985     } else {
 986         hprof = pTPC->GetTPCTrackHisto()->Projection(0,5)->ProfileX();
 987     }
 988     if(!hprof) return 1;
 989
 990     hprof->Fit(fpol1,"QNR","QNR",0.1,0.8);
 991     slopeATPCncl= fpol1->GetParameter(1);
 992     slopeATPCnclErr= fpol1->GetParError(1);
 993     hprof->Fit(fpol1,"QNR","QNR",-0.8,-0.1);
 994     slopeCTPCncl= fpol1->GetParameter(1);
 995     slopeCTPCnclErr= fpol1->GetParameter(1);
 996     delete hprof;
 997
 998     //
 999     // findable clusters
1000     //
1001
1002    if (his3D2 && !fgForceTHnSparse) {
1003         his1D = his3D2->Project3D("x");
1004     } else {
1005         pTPC->GetTPCTrackHisto()->GetAxis(2)->SetRangeUser(0.4,1.1);
1006         his1D = pTPC->GetTPCTrackHisto()->Projection(2);
1007     }
1008
1009     meanTPCnclF= his1D->GetMean();
1010     rmsTPCnclF= his1D->GetRMS();
1011     delete his1D;
1012
1013    if (his3D2 && !fgForceTHnSparse) {
1014          his1D = (dynamic_cast<TH2*>(his3D2->Project3D("xy")))->ProfileX();
1015     } else {
1016         pTPC->GetTPCTrackHisto()->GetAxis(2)->SetRangeUser(0.4,1.1);
1017         his1D = pTPC->GetTPCTrackHisto()->Projection(2,5)->ProfileX();
1018     }
1019     if(!his1D) return 1;
1020
1021     his1D->Fit(fpol1,"QNR","QNR",0.1,0.8);
1022     slopeATPCnclF= fpol1->GetParameter(1);
1023     slopeATPCnclFErr= fpol1->GetParError(1);
1024     his1D->Fit(fpol1,"QNR","QNR",-0.8,-0.1);
1025     slopeCTPCnclF= fpol1->GetParameter(1);
1026     slopeCTPCnclFErr= fpol1->GetParameter(1);
1027     delete his1D;
1028
1029     pTPC->GetTPCTrackHisto()->GetAxis(2)->SetRangeUser(0,10);
1030
1031     printf("Cluster QA report\n");
1032     printf("meanTPCnclF=\t%f\n",meanTPCnclF);
1033     printf("rmsTPCnclF=\t%f\n",rmsTPCnclF);
1034     printf("slopeATPCnclF=\t%f\n",slopeATPCnclF);
1035     printf("slopeCTPCnclF=\t%f\n",slopeCTPCnclF);
1036     printf("meanTPCncl=\t%f\n",meanTPCncl);
1037     printf("rmsTPCncl=\t%f\n",rmsTPCncl);
1038     printf("slopeATPCncl=\t%f\n",slopeATPCncl);
1039     printf("slopeCTPCncl=\t%f\n",slopeCTPCncl);
1040     printf("meanTPCChi2=\t%f\n",meanTPCChi2);
1041     printf("rmsTPCChi2=\t%f\n",rmsTPCChi2);
1042     //
1043     // dump results to the tree
1044     //
1045     (*pcstream)<<"tpcQA"<<
1046       "meanTPCnclF="<<meanTPCnclF <<
1047       "rmsTPCnclF="<<rmsTPCnclF <<
1048       "meanTPCChi2="<<meanTPCChi2 <<
1049       "rmsTPCChi2="<<rmsTPCChi2 <<
1050       "slopeATPCnclF="<< slopeATPCnclF<<
1051       "slopeCTPCnclF="<< slopeCTPCnclF<<
1052       "slopeATPCnclFErr="<< slopeATPCnclFErr<<
1053       "slopeCTPCnclFErr="<< slopeCTPCnclFErr<<
1054       "meanTPCncl="<<meanTPCncl <<
1055       "rmsTPCncl="<< rmsTPCncl<<
1056       "slopeATPCncl="<< slopeATPCncl<<
1057       "slopeCTPCncl="<< slopeCTPCncl<<
1058       "slopeATPCnclErr="<< slopeATPCnclErr<<
1059       "slopeCTPCnclErr="<< slopeCTPCnclErr;
1060
1061     return 0;
1062 }
1063
1064 //_____________________________________________________________________________
1065 Int_t AliTPCPerformanceSummary::AnalyzeDrift(const AliPerformanceTPC* pTPC, TTreeSRedirector* const pcstream)
1066 {
1067     //
1068     // Analyse DCA Z imperferctions (drift velocity)
1069     //
1070
1071     if (!pcstream) return 2;
1072     if (!pTPC) return 2;
1073
1074     // variables:
1075     static Double_t offsetdZA=0;
1076     static Double_t slopedZA=0;
1077     static Double_t offsetdZC=0;
1078     static Double_t slopedZC=0;
1079     static Double_t offsetdZAErr=0;
1080     static Double_t slopedZAErr=0;
1081     static Double_t offsetdZCErr=0;
1082     static Double_t slopedZCErr=0;
1083     static Double_t offsetdZAchi2=0;
1084     static Double_t slopedZAchi2=0;
1085     static Double_t offsetdZCchi2=0;
1086     static Double_t slopedZCchi2=0;
1087     TH1* his1D=0;
1088     TH2* his2D=0;
1089     TH3* his3D=0;
1090
1091    if (pTPC->GetHistos()->FindObject("h_tpc_track_all_recvertex_4_5_7")) {
1092         his3D = dynamic_cast<TH3*>(pTPC->GetHistos()->FindObject("h_tpc_track_all_recvertex_4_5_7"));
1093         if(!his3D) return 2;
1094         his3D->GetYaxis()->SetRangeUser(-1,1);
1095         his3D->GetZaxis()->SetRangeUser(0.25,10);
1096    }
1097
1098    if (his3D && !fgForceTHnSparse) {
1099         his2D = dynamic_cast<TH2*>(his3D->Project3D("xy"));
1100     } else {
1101         his2D = pTPC->GetTPCTrackHisto()->Projection(4,5);
1102     }
1103     if(!his2D) return 2;
1104
1105     static TF1 *fpol1 = new TF1("fpol1","pol1");
1106     TObjArray arrayFit;
1107     his2D->FitSlicesY(0,0,-1,10,"QNR",&arrayFit);
1108     delete his2D;
1109     his1D = (TH1*) arrayFit.At(1);
1110     his1D->Fit(fpol1,"QNRROB=0.8","QNR",-0.8,-0.1);
1111     offsetdZC=fpol1->GetParameter(0);
1112     slopedZC=fpol1->GetParameter(1);
1113     offsetdZCErr=fpol1->GetParError(0);
1114     slopedZCErr=fpol1->GetParError(1);
1115     offsetdZCchi2=fpol1->GetChisquare();
1116     slopedZCchi2=fpol1->GetChisquare();
1117     //
1118     his1D->Fit(fpol1,"QNRROB=0.8","QNR",0.1,0.8);
1119     offsetdZA=fpol1->GetParameter(0);
1120     slopedZA=fpol1->GetParameter(1);
1121     offsetdZAErr=fpol1->GetParError(0);
1122     slopedZAErr=fpol1->GetParError(1);
1123     offsetdZAchi2=fpol1->GetChisquare();
1124     slopedZAchi2=fpol1->GetChisquare();
1125     //
1126     printf("Drift velocity QA report\n");
1127     printf("offsetdZA\t%f\n",offsetdZA);
1128     printf("slopedZA\t%f\n",slopedZA);
1129     printf("offsetdZC\t%f\n",offsetdZC);
1130     printf("slopedZC\t%f\n",slopedZC);
1131     //
1132     // dump drift QA values
1133     //
1134     (*pcstream)<<"tpcQA"<<
1135         "offsetdZA="<< offsetdZA<<
1136         "slopedZA="<< slopedZA<<
1137         "offsetdZC="<< offsetdZC<<
1138         "slopedZC="<<slopedZC<<
1139         //
1140         "offsetdZAErr="<< offsetdZAErr<<
1141         "slopedZAErr="<< slopedZAErr<<
1142         "offsetdZCErr="<< offsetdZCErr<<
1143         "slopedZCErr="<<slopedZCErr<<
1144         //
1145         "offsetdZAchi2="<< offsetdZAchi2<<
1146         "slopedZAchi2="<< slopedZAchi2<<
1147         "offsetdZCchi2="<< offsetdZCchi2<<
1148         "slopedZCchi2="<<slopedZCchi2;
1149
1150     return 0;
1151 }
1152
1153 //_____________________________________________________________________________
1154 Int_t AliTPCPerformanceSummary::AnalyzeDriftPos(const AliPerformanceTPC* pTPC, TTreeSRedirector* const pcstream)
1155 {
1156     //
1157     // Analyse DCA Z imperferctions (drift velocity)
1158     // for positive particles
1159     //
1160     if (!pcstream) return 64;
1161     if (!pTPC) return 64;
1162
1163     // variables:
1164     static Double_t offsetdZAPos=0;
1165     static Double_t slopedZAPos=0;
1166     static Double_t offsetdZCPos=0;
1167     static Double_t slopedZCPos=0;
1168     static Double_t offsetdZAErrPos=0;
1169     static Double_t slopedZAErrPos=0;
1170     static Double_t offsetdZCErrPos=0;
1171     static Double_t slopedZCErrPos=0;
1172     static Double_t offsetdZAchi2Pos=0;
1173     static Double_t slopedZAchi2Pos=0;
1174     static Double_t offsetdZCchi2Pos=0;
1175     static Double_t slopedZCchi2Pos=0;
1176     TH1* his1D=0;
1177     TH2* his2D=0;
1178     TH3* his3D=0;
1179
1180    if (pTPC->GetHistos()->FindObject("h_tpc_track_pos_recvertex_4_5_7")) {
1181         his3D = dynamic_cast<TH3*>(pTPC->GetHistos()->FindObject("h_tpc_track_pos_recvertex_4_5_7"));
1182         if(!his3D) return 64;
1183         his3D->GetYaxis()->SetRangeUser(-1,1);
1184         his3D->GetZaxis()->SetRangeUser(0.25,10);
1185     }
1186
1187     if (his3D && !fgForceTHnSparse) {
1188         his2D = dynamic_cast<TH2*>(his3D->Project3D("xy"));
1189     } else {
1190         his2D = pTPC->GetTPCTrackHisto()->Projection(4,5);
1191     }
1192     if(!his2D) return 64;
1193
1194     static TF1 *fpol1 = new TF1("fpol1","pol1");
1195     TObjArray arrayFit;
1196     his2D->FitSlicesY(0,0,-1,10,"QNR",&arrayFit);
1197     delete his2D;
1198
1199     his1D = (TH1*) arrayFit.At(1);
1200     his1D->Fit(fpol1,"QNRROB=0.8","QNR",-0.8,-0.1);
1201     offsetdZCPos=fpol1->GetParameter(0);
1202     slopedZCPos=fpol1->GetParameter(1);
1203     offsetdZCErrPos=fpol1->GetParError(0);
1204     slopedZCErrPos=fpol1->GetParError(1);
1205     offsetdZCchi2Pos=fpol1->GetChisquare();
1206     slopedZCchi2Pos=fpol1->GetChisquare();
1207     //
1208     his1D->Fit(fpol1,"QNRROB=0.8","QNR",0.1,0.8);
1209     offsetdZAPos=fpol1->GetParameter(0);
1210     slopedZAPos=fpol1->GetParameter(1);
1211     offsetdZAErrPos=fpol1->GetParError(0);
1212     slopedZAErrPos=fpol1->GetParError(1);
1213     offsetdZAchi2Pos=fpol1->GetChisquare();
1214     slopedZAchi2Pos=fpol1->GetChisquare();
1215     //
1216     printf("Drift velocity QA report\n");
1217     printf("offsetdZAPos\t%f\n",offsetdZAPos);
1218     printf("slopedZAPos\t%f\n",slopedZAPos);
1219     printf("offsetdZCPos\t%f\n",offsetdZCPos);
1220     printf("slopedZCPos\t%f\n",slopedZCPos);
1221     //
1222     // dump drift QA values
1223     //
1224     (*pcstream)<<"tpcQA"<<
1225         "offsetdZAPos="<< offsetdZAPos<<
1226         "slopedZAPos="<< slopedZAPos<<
1227         "offsetdZCPos="<< offsetdZCPos<<
1228         "slopedZCPos="<<slopedZCPos<<
1229         //
1230         "offsetdZAErrPos="<< offsetdZAErrPos<<
1231         "slopedZAErrPos="<< slopedZAErrPos<<
1232         "offsetdZCErrPos="<< offsetdZCErrPos<<
1233         "slopedZCErrPos="<<slopedZCErrPos<<
1234         //
1235         "offsetdZAchi2Pos="<< offsetdZAchi2Pos<<
1236         "slopedZAchi2Pos="<< slopedZAchi2Pos<<
1237         "offsetdZCchi2Pos="<< offsetdZCchi2Pos<<
1238         "slopedZCchi2Pos="<<slopedZCchi2Pos;
1239
1240     return 0;
1241 }
1242
1243 //_____________________________________________________________________________
1244 Int_t AliTPCPerformanceSummary::AnalyzeDriftNeg(const AliPerformanceTPC* pTPC, TTreeSRedirector* const pcstream)
1245 {
1246     //
1247     // Analyse DCA Z imperferctions (drift velocity)
1248     // for negative particles
1249     //
1250     if (!pcstream) return 128;
1251     if (!pTPC) return 128;
1252
1253     // variables:
1254     static Double_t offsetdZANeg=0;
1255     static Double_t slopedZANeg=0;
1256     static Double_t offsetdZCNeg=0;
1257     static Double_t slopedZCNeg=0;
1258     static Double_t offsetdZAErrNeg=0;
1259     static Double_t slopedZAErrNeg=0;
1260     static Double_t offsetdZCErrNeg=0;
1261     static Double_t slopedZCErrNeg=0;
1262     static Double_t offsetdZAchi2Neg=0;
1263     static Double_t slopedZAchi2Neg=0;
1264     static Double_t offsetdZCchi2Neg=0;
1265     static Double_t slopedZCchi2Neg=0;
1266     TH1* his1D=0;
1267     TH2* his2D=0;
1268     TH3* his3D=0;
1269
1270
1271    if (pTPC->GetHistos()->FindObject("h_tpc_track_neg_recvertex_4_5_7")) {
1272         his3D = dynamic_cast<TH3*>(pTPC->GetHistos()->FindObject("h_tpc_track_neg_recvertex_4_5_7"));
1273         if(!his3D) return 128;
1274         his3D->GetYaxis()->SetRangeUser(-1,1);
1275         his3D->GetZaxis()->SetRangeUser(0.25,10);
1276     }
1277     if (his3D && !fgForceTHnSparse) {
1278         his2D = dynamic_cast<TH2*>(his3D->Project3D("xy"));
1279     } else {
1280         his2D = pTPC->GetTPCTrackHisto()->Projection(4,5);
1281     }
1282     if(!his2D) return 128;
1283
1284     static TF1 *fpol1 = new TF1("fpol1","pol1");
1285     TObjArray arrayFit;
1286     his2D->FitSlicesY(0,0,-1,10,"QNR",&arrayFit);
1287     delete his2D;
1288
1289     his1D = (TH1*) arrayFit.At(1);
1290     his1D->Fit(fpol1,"QNRROB=0.8","QNR",-0.8,-0.1);
1291     offsetdZCNeg=fpol1->GetParameter(0);
1292     slopedZCNeg=fpol1->GetParameter(1);
1293     offsetdZCErrNeg=fpol1->GetParError(0);
1294     slopedZCErrNeg=fpol1->GetParError(1);
1295     offsetdZCchi2Neg=fpol1->GetChisquare();
1296     slopedZCchi2Neg=fpol1->GetChisquare();
1297     //
1298     his1D->Fit(fpol1,"QNRROB=0.8","QNR",0.1,0.8);
1299     offsetdZANeg=fpol1->GetParameter(0);
1300     slopedZANeg=fpol1->GetParameter(1);
1301     offsetdZAErrNeg=fpol1->GetParError(0);
1302     slopedZAErrNeg=fpol1->GetParError(1);
1303     offsetdZAchi2Neg=fpol1->GetChisquare();
1304     slopedZAchi2Neg=fpol1->GetChisquare();
1305     //
1306     printf("Drift velocity QA report\n");
1307     printf("offsetdZANeg\t%f\n",offsetdZANeg);
1308     printf("slopedZANeg\t%f\n",slopedZANeg);
1309     printf("offsetdZCNeg\t%f\n",offsetdZCNeg);
1310     printf("slopedZCNeg\t%f\n",slopedZCNeg);
1311     //
1312     // dump drift QA values
1313     //
1314     (*pcstream)<<"tpcQA"<<
1315         "offsetdZANeg="<< offsetdZANeg<<
1316         "slopedZANeg="<< slopedZANeg<<
1317         "offsetdZCNeg="<< offsetdZCNeg<<
1318         "slopedZCNeg="<<slopedZCNeg<<
1319         //
1320         "offsetdZAErrNeg="<< offsetdZAErrNeg<<
1321         "slopedZAErrNeg="<< slopedZAErrNeg<<
1322         "offsetdZCErrNeg="<< offsetdZCErrNeg<<
1323         "slopedZCErrNeg="<<slopedZCErrNeg<<
1324         //
1325         "offsetdZAchi2Neg="<< offsetdZAchi2Neg<<
1326         "slopedZAchi2Neg="<< slopedZAchi2Neg<<
1327         "offsetdZCchi2Neg="<< offsetdZCchi2Neg<<
1328         "slopedZCchi2Neg="<<slopedZCchi2Neg;
1329
1330     return 0;
1331 }
1332
1333 //_____________________________________________________________________________
1334 Int_t AliTPCPerformanceSummary::AnalyzeGain(const AliPerformanceDEdx* pTPCgain, TTreeSRedirector* const pcstream)
1335 {
1336     //
1337     // Analyse Gain
1338     //
1339
1340     if (!pcstream) return 4;
1341     if (!pTPCgain) return 4;
1342
1343     static TVectorD meanMIPvsSector(36);
1344     static TVectorD sector(36);
1345     static Float_t meanMIP = 0;
1346     static Float_t resolutionMIP = 0;
1347     static Float_t attachSlopeC = 0;
1348     static Float_t attachSlopeA = 0;
1349     static Float_t meanMIPele = 0;
1350     static Float_t resolutionMIPele = 0;
1351     static Float_t electroMIPSeparation = 0;
1352
1353     TH1 * his1D = 0;
1354     //TH1 * hisProj1D=0;
1355     TH2* his2D=0;
1356
1357     meanMIPvsSector.Zero();
1358     //
1359     // select MIP particles
1360     //
1361     pTPCgain->GetDeDxHisto()->GetAxis(7)->SetRangeUser(0.4,0.55);
1362     pTPCgain->GetDeDxHisto()->GetAxis(0)->SetRangeUser(35,60);
1363     pTPCgain->GetDeDxHisto()->GetAxis(6)->SetRangeUser(80,160);
1364     pTPCgain->GetDeDxHisto()->GetAxis(5)->SetRangeUser(-1,1);
1365     //
1366     // MIP position and resolution
1367     //
1368     TF1 gausFit("gausFit","gaus");
1369
1370     if (pTPCgain->GetHistos()->FindObject("h_tpc_dedx_mips_0") && !fgForceTHnSparse) {
1371         his1D = dynamic_cast<TH1*>(pTPCgain->GetHistos()->FindObject("h_tpc_dedx_mips_0")->Clone());
1372     } else {
1373        his1D =  pTPCgain->GetDeDxHisto()->Projection(0);
1374     }
1375     if(!his1D) return 4;
1376     his1D->Fit(&gausFit,"QN","QN");
1377
1378     meanMIP = gausFit.GetParameter(1);
1379     resolutionMIP = 0;
1380     if (meanMIP!=0) resolutionMIP = gausFit.GetParameter(2)/meanMIP;
1381     //removedtotest// delete his1D;
1382
1383     //
1384     // MIP position vs. dip angle (attachment)
1385     //
1386     pTPCgain->GetDeDxHisto()->GetAxis(5)->SetRangeUser(-3,0); // C side
1387     if (pTPCgain->GetHistos()->FindObject("h_tpc_dedx_mips_c_0_5") && !fgForceTHnSparse) {
1388         his2D = dynamic_cast<TH2*>(pTPCgain->GetHistos()->FindObject("h_tpc_dedx_mips_c_0_5")->Clone());
1389     } else {
1390         his2D =  pTPCgain->GetDeDxHisto()->Projection(0,5);
1391     }
1392     if(!his2D) return 4;
1393
1394     TF1 * fpol = new TF1("fpol","pol1");
1395     TObjArray arrayFit;
1396     his2D->FitSlicesY(0,0,-1,10,"QN",&arrayFit);
1397     his1D = (TH1*) arrayFit.At(1);
1398     his1D->Fit(fpol,"QNROB=0.8","QNR",-1,0);
1399     attachSlopeC = fpol->GetParameter(1);
1400     //removedtotest// delete his2D;
1401     //removedtotest// delete his1D;
1402     //
1403     pTPCgain->GetDeDxHisto()->GetAxis(5)->SetRangeUser(0,3); // A side
1404     if (pTPCgain->GetHistos()->FindObject("h_tpc_dedx_mips_a_0_5") && !fgForceTHnSparse) {
1405         his2D = dynamic_cast<TH2*>(pTPCgain->GetHistos()->FindObject("h_tpc_dedx_mips_a_0_5")->Clone());
1406     } else {
1407         his2D =  pTPCgain->GetDeDxHisto()->Projection(0,5);
1408     }
1409     if(!his2D) return 4;
1410
1411     TF1 * fpolA = new TF1("fpolA","pol1");
1412     TObjArray arrayFitA;
1413     //FitSlicesY(TF1* f1 = 0, Int_t firstxbin = 0, Int_t lastxbin = -1, Int_t cut = 0, Option_t* option = "QNR", TObjArray* arr = 0)
1414     his2D->FitSlicesY(0,0,-1,10,"QN",&arrayFit);
1415     his1D = (TH1*) arrayFit.At(1);
1416     his1D->Fit(fpolA,"QNROB=0.8","QN",0,1);
1417     attachSlopeA = fpolA->GetParameter(1);
1418      //removedtotest// delete his2D;
1419      //removedtotest// delete his1D;
1420     //
1421     // MIP position vs. sector
1422     //
1423     pTPCgain->GetDeDxHisto()->GetAxis(5)->SetRangeUser(-3,0); // C side
1424     if (pTPCgain->GetHistos()->FindObject("h_tpc_dedx_mips_c_0_1") && !fgForceTHnSparse) {
1425         his2D = dynamic_cast<TH2*>(pTPCgain->GetHistos()->FindObject("h_tpc_dedx_mips_c_0_1")->Clone());
1426     } else {
1427         his2D =  pTPCgain->GetDeDxHisto()->Projection(0,1);
1428     }
1429     if(!his2D) return 4;
1430
1431     for(Int_t i = 0; i < 18; i++) { // loop over sectors; correct mapping to be checked!
1432         //TH1* his1D=0;
1433         Float_t phiLow = -TMath::Pi() + i*(20./360.)*(2*TMath::Pi());
1434         Float_t phiUp    = -TMath::Pi() + (i+1)*(20./360.)*(2*TMath::Pi());
1435         //pTPCgain->GetDeDxHisto()->GetAxis(1)->SetRangeUser(phiLow,phiUp);
1436         his2D->GetXaxis()->SetRangeUser(phiLow,phiUp);
1437         //his1D = pTPCgain->GetDeDxHisto()->Projection(0);
1438         his1D = his2D->ProjectionY();
1439         TF1 gausFunc("gausFunc","gaus");
1440         his1D->Fit(&gausFunc, "QN");
1441         meanMIPvsSector(i) = gausFunc.GetParameter(1);
1442         sector(i)=i;
1443         //removedtotest// delete his1D;
1444     }
1445      //removedtotest// delete his2D;
1446     //
1447     pTPCgain->GetDeDxHisto()->GetAxis(5)->SetRangeUser(0,3); // A side
1448     if (pTPCgain->GetHistos()->FindObject("h_tpc_dedx_mips_a_0_1") && !fgForceTHnSparse) {
1449         his2D = dynamic_cast<TH2*>(pTPCgain->GetHistos()->FindObject("h_tpc_dedx_mips_a_0_1")->Clone());
1450     } else {
1451         his2D =  pTPCgain->GetDeDxHisto()->Projection(0,1);
1452     }
1453     if(!his2D) return 4;
1454
1455     for(Int_t i = 0; i < 18; i++) { // loop over sectors; correct mapping to be checked!
1456         //TH1* his1D=0;
1457         Float_t phiLow = -TMath::Pi() + i*(20./360.)*(2*TMath::Pi());
1458         Float_t phiUp    = -TMath::Pi() + (i+1)*(20./360.)*(2*TMath::Pi());
1459         //pTPCgain->GetDeDxHisto()->GetAxis(1)->SetRangeUser(phiLow,phiUp);
1460         his2D->GetXaxis()->SetRangeUser(phiLow,phiUp);
1461         //his1D = pTPCgain->GetDeDxHisto()->Projection(0);
1462         his1D = his2D->ProjectionY();
1463         TF1 gausFunc("gausFunc","gaus");
1464         his1D->Fit(&gausFunc, "QN");
1465         meanMIPvsSector(i+18) = gausFunc.GetParameter(1);
1466         sector(i+18)=i+18;
1467         //removedtotest// delete his1D;
1468     }
1469      //removedtotest// delete his2D;
1470
1471      //
1472     //
1473     // select electrons
1474     //
1475     pTPCgain->GetDeDxHisto()->GetAxis(7)->SetRangeUser(0.32,0.38); // momenta
1476     pTPCgain->GetDeDxHisto()->GetAxis(0)->SetRangeUser(70,100); // dedx
1477     pTPCgain->GetDeDxHisto()->GetAxis(6)->SetRangeUser(80,160); // nr clusters
1478     pTPCgain->GetDeDxHisto()->GetAxis(5)->SetRangeUser(-1,1); // eta
1479
1480     TF1 gausFitEle("gausFitEle","gaus");
1481
1482     if (pTPCgain->GetHistos()->FindObject("h_tpc_dedx_mipsele_0") && !fgForceTHnSparse) {
1483       his1D = dynamic_cast<TH1*>(pTPCgain->GetHistos()->FindObject("h_tpc_dedx_mipsele_0")->Clone());
1484     } else {
1485       his1D =  pTPCgain->GetDeDxHisto()->Projection(0);
1486     }
1487     if(!his1D) return 4;
1488     his1D->Fit(&gausFitEle,"QN","QN");
1489
1490     meanMIPele = gausFitEle.GetParameter(1);
1491     resolutionMIPele = 0;
1492     if (meanMIPele!=0) resolutionMIPele = gausFitEle.GetParameter(2)/meanMIPele;
1493
1494     //restore cuts as before
1495     pTPCgain->GetDeDxHisto()->GetAxis(7)->SetRangeUser(0.4,0.55);
1496     pTPCgain->GetDeDxHisto()->GetAxis(0)->SetRangeUser(35,60);
1497     pTPCgain->GetDeDxHisto()->GetAxis(6)->SetRangeUser(80,160);
1498     pTPCgain->GetDeDxHisto()->GetAxis(5)->SetRangeUser(-1,1);
1499
1500     //
1501     // separation between electrons and MIPs
1502     //
1503     electroMIPSeparation = TMath::Abs((meanMIP-meanMIPele));
1504
1505     printf("Gain QA report\n");
1506     printf("MIP mean\t%f\n",meanMIP);
1507     printf("MIP resolution\t%f\n",resolutionMIP);
1508     printf("MIPslopeA\t%f\n",attachSlopeA);
1509     printf("MIPslopeC\t%f\n",attachSlopeC);
1510     printf("Electons energy loss MIP mean\t%f\n",meanMIPele);
1511     printf("Electons MIP resolution\t%f\n",resolutionMIPele);
1512     //
1513
1514     (*pcstream)<<"tpcQA"<<
1515       "MIPattachSlopeC="<<attachSlopeC<<
1516       "MIPattachSlopeA="<<attachSlopeA<<
1517       "resolutionMIP="<<resolutionMIP<<
1518       "meanMIPvsSector.="<<&meanMIPvsSector<<
1519       "sector.="<<&sector<<
1520       "meanMIP="<<meanMIP<<
1521       "meanMIPele="<<meanMIPele<<
1522       "resolutionMIPele="<<resolutionMIPele<<
1523       "electroMIPSeparation="<<electroMIPSeparation;
1524
1525     return 0;
1526 }
1527
1528 //_____________________________________________________________________________
1529 Int_t AliTPCPerformanceSummary::AnalyzeEvent(const AliPerformanceTPC* pTPC, TTreeSRedirector* const pcstream)
1530 {
1531     //
1532     // Analyse Primary Vertex Distribution and Multiplicities
1533     //
1534   if (!pcstream) return 1;
1535     if (!pTPC) return 1;
1536     //
1537     //
1538     //
1539     static Double_t meanVertX=0;
1540     static Double_t rmsVertX=0;
1541     static Double_t meanVertY=0;
1542     static Double_t rmsVertY=0;
1543     static Double_t meanVertZ=0;
1544     static Double_t rmsVertZ=0;
1545     static Double_t vertStatus=0;
1546     static Double_t meanMult=0;
1547     static Double_t rmsMult=0;
1548     static Double_t meanMultPos=0;
1549     static Double_t rmsMultPos=0;
1550     static Double_t meanMultNeg=0;
1551     static Double_t rmsMultNeg=0;
1552     static Double_t vertAll = 0;
1553     static Double_t vertOK = 0;
1554
1555     TH1* his1D=0;
1556     TH1* hc=0;
1557     if (pTPC->GetHistos()->FindObject("h_tpc_event_6") && !fgForceTHnSparse) {
1558         his1D = dynamic_cast<TH1*>(pTPC->GetHistos()->FindObject("h_tpc_event_6")->Clone());
1559     } else {
1560        his1D = pTPC->GetTPCEventHisto()->Projection(6);
1561     }
1562     if(!his1D) return 1;
1563
1564     vertAll = his1D->GetEntries();
1565     vertOK  = his1D->GetBinContent(2);
1566     if (vertAll>=1) {
1567             vertStatus = vertOK / vertAll;
1568     }
1569
1570     delete his1D;
1571
1572     pTPC->GetTPCEventHisto()->GetAxis(6)->SetRange(2,2);
1573
1574     if (pTPC->GetHistos()->FindObject("h_tpc_event_recvertex_0") && !fgForceTHnSparse) {
1575         his1D = dynamic_cast<TH1*>(pTPC->GetHistos()->FindObject("h_tpc_event_recvertex_0")->Clone());
1576     } else {
1577        his1D = pTPC->GetTPCEventHisto()->Projection(0);
1578     }
1579     if(!his1D) return 1;
1580
1581     meanVertX = his1D->GetMean();
1582     rmsVertX    = his1D->GetRMS();
1583     delete his1D;
1584
1585
1586
1587
1588     if (pTPC->GetHistos()->FindObject("h_tpc_event_recvertex_1") && !fgForceTHnSparse) {
1589         his1D = dynamic_cast<TH1*>(pTPC->GetHistos()->FindObject("h_tpc_event_recvertex_1")->Clone());
1590     } else {
1591        his1D = pTPC->GetTPCEventHisto()->Projection(1);
1592     }
1593     if(!his1D) return 1;
1594
1595     meanVertY = his1D->GetMean();
1596     rmsVertY    = his1D->GetRMS();
1597     delete his1D;
1598
1599
1600     if (pTPC->GetHistos()->FindObject("h_tpc_event_recvertex_2") && !fgForceTHnSparse) {
1601         hc = dynamic_cast<TH1*>(pTPC->GetHistos()->FindObject("h_tpc_event_recvertex_2"));
1602         if(!hc) return 1;
1603         //his1D = dynamic_cast<TH1*>(pTPC->GetHistos()->FindObject("h_tpc_event_recvertex_2")->Clone());
1604         his1D = (TH1*)hc->Clone();
1605     } else {
1606        his1D = pTPC->GetTPCEventHisto()->Projection(2);
1607     }
1608     if(!his1D) return 1;
1609
1610     meanVertZ = his1D->GetMean();
1611     rmsVertZ    = his1D->GetRMS();
1612     delete his1D;
1613
1614
1615     if (pTPC->GetHistos()->FindObject("h_tpc_event_recvertex_3") && !fgForceTHnSparse) {
1616         hc = dynamic_cast<TH1*>(pTPC->GetHistos()->FindObject("h_tpc_event_recvertex_3"));
1617         if(!hc) return 1;
1618         //his1D = dynamic_cast<TH1*>(pTPC->GetHistos()->FindObject("h_tpc_event_recvertex_3")->Clone());
1619         his1D = (TH1*)hc->Clone();
1620     } else {
1621        his1D = pTPC->GetTPCEventHisto()->Projection(3);
1622     }
1623     if(!his1D) return 1;
1624
1625     meanMult    = his1D->GetMean();
1626     rmsMult     = his1D->GetRMS();
1627     delete his1D;
1628
1629
1630     if (pTPC->GetHistos()->FindObject("h_tpc_event_recvertex_4") && !fgForceTHnSparse) {
1631         his1D = dynamic_cast<TH1*>(pTPC->GetHistos()->FindObject("h_tpc_event_recvertex_4")->Clone());
1632     } else {
1633        his1D = pTPC->GetTPCEventHisto()->Projection(4);
1634     }
1635     if(!his1D) return 1;
1636
1637     meanMultPos    = his1D->GetMean();
1638     rmsMultPos     = his1D->GetRMS();
1639     delete his1D;
1640
1641     if (pTPC->GetHistos()->FindObject("h_tpc_event_recvertex_5") && !fgForceTHnSparse) {
1642         his1D = dynamic_cast<TH1*>(pTPC->GetHistos()->FindObject("h_tpc_event_recvertex_5")->Clone());
1643     } else {
1644        his1D = pTPC->GetTPCEventHisto()->Projection(5);
1645     }
1646     if(!his1D) return 1;
1647
1648     meanMultNeg    = his1D->GetMean();
1649     rmsMultNeg     = his1D->GetRMS();
1650     delete his1D;
1651
1652     pTPC->GetTPCEventHisto()->GetAxis(6)->SetRange(1,2);
1653     //
1654     (*pcstream)<<"tpcQA"<<
1655         "meanVertX="<<meanVertX<<
1656         "rmsVertX="<<rmsVertX<<
1657         "meanVertY="<<meanVertY<<
1658         "rmsVertY="<<rmsVertY<<
1659         "meanVertZ="<<meanVertZ<<
1660         "rmsVertZ="<<rmsVertZ<<
1661         "vertStatus="<<vertStatus<<
1662         "vertAll="<<vertAll<<
1663         "vertOK="<<vertOK<<
1664         "meanMult="<<meanMult<<
1665         "rmsMult="<<rmsMult<<
1666         "meanMultPos="<<meanMultPos<<
1667         "rmsMultPos="<<rmsMultPos<<
1668         "meanMultNeg="<<meanMultNeg<<
1669         "rmsMultNeg="<<rmsMultNeg;
1670
1671     return 0;
1672 }
1673
1674 //_____________________________________________________________________________
1675 Int_t AliTPCPerformanceSummary::AnalyzePt(const AliPerformanceTPC* pTPC, TTreeSRedirector* const pcstream)
1676 {
1677     //
1678     // Analyse DCA R imperfections for positive particles
1679     //
1680
1681     if (!pcstream) return 256;
1682     if (!pTPC) return 256;
1683
1684     // variables:
1685     static Double_t meanPtAPos = 0;
1686     static Double_t mediumPtAPos = 0;
1687     static Double_t highPtAPos = 0;
1688     static Double_t meanPtCPos = 0;
1689     static Double_t mediumPtCPos = 0;
1690     static Double_t highPtCPos = 0;
1691
1692     static Double_t meanPtANeg = 0;
1693     static Double_t mediumPtANeg = 0;
1694     static Double_t highPtANeg = 0;
1695     static Double_t meanPtCNeg = 0;
1696     static Double_t mediumPtCNeg = 0;
1697     static Double_t highPtCNeg = 0;
1698
1699     TH3* his3D1=0;
1700     TH3* his3D2=0;
1701
1702     if (pTPC->GetHistos()->FindObject("h_tpc_track_pos_recvertex_3_5_7")) {
1703
1704       his3D1 = dynamic_cast<TH3*>(pTPC->GetHistos()->FindObject("h_tpc_track_pos_recvertex_3_5_7"));
1705       if(!his3D1) return 256;
1706
1707       his3D1->GetYaxis()->SetRangeUser(0.1,0.8);
1708
1709       his3D1->GetZaxis()->SetRangeUser(0.25,10);
1710       meanPtAPos = his3D1->GetMean(3);
1711       his3D1->GetZaxis()->SetRangeUser(2,5);
1712       mediumPtAPos = his3D1->GetMean(3);
1713       his3D1->GetZaxis()->SetRangeUser(5,10);
1714       highPtAPos = his3D1->GetMean(3);
1715
1716       his3D1->GetYaxis()->SetRangeUser(-0.8,-0.1);
1717
1718       his3D1->GetZaxis()->SetRangeUser(0.25,10);
1719       meanPtCPos = his3D1->GetMean(3);
1720       his3D1->GetZaxis()->SetRangeUser(2,5);
1721       mediumPtCPos = his3D1->GetMean(3);
1722       his3D1->GetZaxis()->SetRangeUser(5,10);
1723       highPtCPos = his3D1->GetMean(3);
1724
1725       his3D1->GetYaxis()->SetRangeUser(-1,1);
1726       his3D1->GetZaxis()->SetRangeUser(0.25,10);
1727     }
1728
1729
1730     if (pTPC->GetHistos()->FindObject("h_tpc_track_neg_recvertex_3_5_7")) {
1731
1732       his3D2 = dynamic_cast<TH3*>(pTPC->GetHistos()->FindObject("h_tpc_track_neg_recvertex_3_5_7"));
1733       if(!his3D2) return 256;
1734
1735       his3D2->GetYaxis()->SetRangeUser(0.1,0.8);
1736
1737       his3D2->GetZaxis()->SetRangeUser(0.25,10);
1738       meanPtANeg = his3D2->GetMean(3);
1739       his3D2->GetZaxis()->SetRangeUser(2,5);
1740       mediumPtANeg = his3D2->GetMean(3);
1741       his3D2->GetZaxis()->SetRangeUser(5,10);
1742       highPtANeg = his3D2->GetMean(3);
1743
1744       his3D2->GetYaxis()->SetRangeUser(-0.8,-0.1);
1745
1746       his3D2->GetZaxis()->SetRangeUser(0.25,10);
1747       meanPtCNeg = his3D2->GetMean(3);
1748       his3D2->GetZaxis()->SetRangeUser(2,5);
1749       mediumPtCNeg = his3D2->GetMean(3);
1750       his3D2->GetZaxis()->SetRangeUser(5,10);
1751       highPtCNeg = his3D2->GetMean(3);
1752
1753       his3D2->GetYaxis()->SetRangeUser(-1,1);
1754       his3D2->GetZaxis()->SetRangeUser(0.25,10);
1755     }
1756
1757
1758
1759     // dump values
1760     //
1761     (*pcstream)<<"tpcQA"<<
1762       "meanPtAPos="<< meanPtAPos<<
1763       "mediumPtAPos="<< mediumPtAPos<<
1764       "highPtAPos="<< highPtAPos<<
1765       //
1766       "meanPtCPos="<< meanPtCPos<<
1767       "mediumPtCPos="<< mediumPtCPos<<
1768       "highPtCPos="<< highPtCPos<<
1769       //
1770       "meanPtANeg="<< meanPtANeg<<
1771       "mediumPtANeg="<< mediumPtANeg<<
1772       "highPtANeg="<< highPtANeg<<
1773         //
1774       "meanPtCNeg="<< meanPtCNeg<<
1775       "mediumPtCNeg="<< mediumPtCNeg<<
1776       "highPtCNeg="<< highPtCNeg;
1777
1778
1779     return 0;
1780 }
1781
1782 //_____________________________________________________________________________
1783
1784 Int_t AliTPCPerformanceSummary::AnalyzeChargeOverPt(const AliPerformanceTPC* pTPC, TTreeSRedirector* const pcstream){
1785     //
1786     // Analyse DCA R imperfections for positive particles
1787     //
1788
1789     if (!pcstream) return 512;
1790     if (!pTPC) return 512;
1791
1792     // variables:
1793     static Double_t qOverPt = 0;
1794     static Double_t qOverPtA = 0;
1795     static Double_t qOverPtC = 0;
1796
1797     TH2* his2D=0;
1798     TH1* his1D1=0;
1799     TH1* his1D2=0;
1800     TH1* his1D3=0;
1801     TF1 *fp1 = new TF1("fp1","pol2",-1.0,1.0);
1802     TF1 *fp2 = new TF1("fp2","pol2",-1.0,1.0);
1803     TF1 *fp3 = new TF1("fp3","pol2",-1.0,1.0);
1804
1805     if (pTPC->GetHistos()->FindObject("h_tpc_track_all_recvertex_5_8")) {
1806
1807       his2D = dynamic_cast<TH2*>(pTPC->GetHistos()->FindObject("h_tpc_track_all_recvertex_5_8"));
1808       if(!his2D) return 512;
1809
1810       his1D1 = his2D->ProjectionX();
1811       his1D1->Fit(fp1,"R");
1812       if(fp1->GetParameter(2)!=0){
1813         qOverPt = (-1.0)*(fp1->GetParameter(1)/(2.0*fp1->GetParameter(2)));
1814        }
1815       delete fp1;
1816       delete his1D1;
1817
1818        his2D->GetYaxis()->SetRangeUser(0.1,0.8);
1819        his1D2 = his2D->ProjectionX();
1820        his1D2->Fit(fp2,"R");
1821        if(fp2->GetParameter(2)!=0)
1822          qOverPtA = (-1.0)*(fp2->GetParameter(1)/(2.0*fp2->GetParameter(2)));
1823        delete fp2;
1824        delete his1D2;
1825
1826        his2D->GetYaxis()->SetRangeUser(-0.8,-0.1);
1827        his1D3 = his2D->ProjectionX();
1828        his1D3->Fit(fp3,"R");
1829        if(fp3->GetParameter(2)!=0)
1830          qOverPtC = (-1.0)*(fp3->GetParameter(1)/(2.0*fp3->GetParameter(2)));
1831        delete fp3;
1832        delete his1D3;
1833
1834       his2D->GetYaxis()->SetRangeUser(-1.0,1.0);
1835     }
1836
1837
1838     (*pcstream)<<"tpcQA"<<
1839       "qOverPt="<< qOverPt<<
1840       "qOverPtA="<< qOverPtA<<
1841       "qOverPtC="<< qOverPtC;
1842
1843     return 0;
1844 }
1845
1846 Int_t AliTPCPerformanceSummary::AnalyzeMatch(const AliPerformanceMatch* pMatch, TTreeSRedirector* const pcstream)
1847 {
1848   /* if ((pMatch == 0) or (0 == pcstream)) { printf("this will not work anyway..."); }
1849      printf("funtion not implemented");*/
1850
1851   if (!pcstream) return 1024;
1852   if (!pMatch) return 1024;
1853   static Double_t tpcItsMatchA = 0;
1854   static Double_t tpcItsMatchHighPtA = 0;
1855   static Double_t tpcItsMatchC = 0;
1856   static Double_t tpcItsMatchHighPtC = 0;
1857
1858   TH2 *h2D = 0;
1859   TH2 *h2D1 = 0;
1860   if(pMatch->GetHistos()->FindObject("h_tpc_match_trackingeff_all_2_3") &&
1861      pMatch->GetHistos()->FindObject("h_tpc_match_trackingeff_tpc_2_3")){
1862     h2D = dynamic_cast<TH2*>(pMatch->GetHistos()->FindObject("h_tpc_match_trackingeff_all_2_3"));
1863     h2D1 = dynamic_cast<TH2*>(pMatch->GetHistos()->FindObject("h_tpc_match_trackingeff_tpc_2_3"));
1864
1865     if(!h2D) return 4;
1866     if(!h2D1) return 4;
1867
1868     h2D->GetXaxis()->SetRangeUser(0,1.5);
1869     h2D1->GetXaxis()->SetRangeUser(0,1.5);
1870
1871     Double_t entries,entries1;
1872     entries = h2D->GetEffectiveEntries();
1873     entries1 = h2D1->GetEffectiveEntries();
1874     if(entries > 0)
1875       tpcItsMatchA = entries1/entries;
1876
1877     h2D->GetYaxis()->SetRangeUser(4.01,20.);
1878     h2D1->GetYaxis()->SetRangeUser(4.01,20.);
1879     entries = h2D->GetEffectiveEntries();
1880     entries1 = h2D1->GetEffectiveEntries();
1881     if(entries > 0)
1882     tpcItsMatchHighPtA = entries1/entries;
1883
1884
1885     h2D->GetXaxis()->SetRangeUser(-1.5,-0.01);
1886     h2D1->GetXaxis()->SetRangeUser(-1.5,-0.01);
1887     h2D->GetYaxis()->SetRangeUser(0.0,20.);
1888     h2D1->GetYaxis()->SetRangeUser(0.0,20.);
1889
1890     entries = h2D->GetEffectiveEntries();
1891     entries1 = h2D1->GetEffectiveEntries();
1892     if(entries > 0)
1893       tpcItsMatchC = entries1/entries;
1894
1895     h2D->GetYaxis()->SetRangeUser(4.01,20.);
1896     h2D1->GetYaxis()->SetRangeUser(4.01,20.);
1897     entries = h2D->GetEffectiveEntries();
1898     entries1 = h2D1->GetEffectiveEntries();
1899     if(entries > 0)
1900       tpcItsMatchHighPtC = entries1/entries;
1901
1902     h2D->GetXaxis()->SetRangeUser(-1.5,1.5);
1903     h2D1->GetXaxis()->SetRangeUser(-1.5,1.5);
1904     h2D->GetYaxis()->SetRangeUser(0.0,20.);
1905     h2D1->GetYaxis()->SetRangeUser(0.0,20.);
1906     //    delete h2D;
1907     //    delete h2D1;
1908   }
1909
1910   (*pcstream)<<"tpcQA"<<
1911     "tpcItsMatchA="<< tpcItsMatchA<<
1912     "tpcItsMatchHighPtA="<< tpcItsMatchHighPtA<<
1913     "tpcItsMatchC="<< tpcItsMatchC<<
1914     "tpcItsMatchHighPtC="<< tpcItsMatchHighPtC;
1915
1916   return 0;
1917 }
1918
1919 Int_t AliTPCPerformanceSummary::AnalyzePull(const AliPerformanceMatch* pPull, TTreeSRedirector* const pcstream)
1920 {
1921   /* if ((pPull == 0) or (0 == pcstream)) { printf("this will not work anyway..."); }
1922      printf("funtion not implemented");*/
1923
1924   if (!pcstream) return 2048;
1925   if (!pPull) return 2048;
1926   static Double_t phiPull = 0;
1927   static Double_t phiPullHighPt = 0;
1928   static Double_t ptPull = 0;
1929   static Double_t ptPullHighPt = 0;
1930   static Double_t yPull = 0;
1931   static Double_t yPullHighPt = 0;
1932   static Double_t zPull = 0;
1933   static Double_t zPullHighPt = 0;
1934   static Double_t lambdaPull = 0;
1935   static Double_t lambdaPullHighPt = 0;
1936
1937   TH2 *h2D1 = 0;
1938   if(pPull->GetHistos()->FindObject("h_tpc_match_pull_2_7")){
1939     h2D1 = dynamic_cast<TH2*>(pPull->GetHistos()->FindObject("h_tpc_match_pull_2_7"));
1940     if(!h2D1) return 4;
1941     phiPull = h2D1->GetMean(2);
1942     h2D1->SetAxisRange(0.0,1.0/5.0,"X");
1943     phiPullHighPt = h2D1->GetMean(2);
1944     h2D1->SetAxisRange(0.0,10.0,"X");
1945     //    delete h2D1;
1946   }
1947
1948   TH2 *h2D2 = 0;
1949   if(pPull->GetHistos()->FindObject("h_tpc_match_pull_4_7")){
1950     h2D2 = dynamic_cast<TH2*>(pPull->GetHistos()->FindObject("h_tpc_match_pull_4_7"));
1951     if(!h2D2) return 4;
1952     ptPull = h2D2->GetMean(2);
1953
1954     h2D2->SetAxisRange(0.0,1.0/5.0,"X");
1955     ptPullHighPt = h2D2->GetMean(2);
1956     h2D2->SetAxisRange(0.0,10.0,"X");
1957     //    delete h2D2;
1958   }
1959
1960   TH2 *h2D3 = 0;
1961   if(pPull->GetHistos()->FindObject("h_tpc_match_pull_0_7")){
1962     h2D3 = dynamic_cast<TH2*>(pPull->GetHistos()->FindObject("h_tpc_match_pull_0_7"));
1963     if(!h2D3) return 4;
1964     yPull = h2D3->GetMean(2);
1965
1966     h2D3->SetAxisRange(0.0,1.0/5.0,"X");
1967     yPullHighPt = h2D3->GetMean(2);
1968     h2D3->SetAxisRange(0.0,10.0,"X");
1969     //    delete h2D3;
1970   }
1971
1972   TH2 *h2D4 = 0;
1973   if(pPull->GetHistos()->FindObject("h_tpc_match_pull_1_7")){
1974     h2D4 = dynamic_cast<TH2*>(pPull->GetHistos()->FindObject("h_tpc_match_pull_1_7"));
1975     if(!h2D4) return 4;
1976     zPull = h2D4->GetMean(2);
1977
1978     h2D4->SetAxisRange(0.0,1.0/5.0,"X");
1979     zPullHighPt = h2D4->GetMean(2);
1980     h2D4->SetAxisRange(0.0,10.0,"X");
1981     //    delete h2D4;
1982  }
1983
1984   TH2 *h2D5 = 0;
1985   if(pPull->GetHistos()->FindObject("h_tpc_match_pull_3_7")){
1986     h2D5 = dynamic_cast<TH2*>(pPull->GetHistos()->FindObject("h_tpc_match_pull_3_7"));
1987     if(!h2D5) return 4;
1988     lambdaPull = h2D5->GetMean(2);
1989
1990     h2D5->SetAxisRange(0.0,1.0/5.0,"X");
1991     lambdaPullHighPt = h2D5->GetMean(2);
1992     h2D5->SetAxisRange(0.0,10.0,"X");
1993     //    delete h2D5;
1994 }
1995
1996   (*pcstream)<<"tpcQA"<<
1997     "phiPull="<< phiPull<<
1998     "phiPullHighPt="<< phiPullHighPt<<
1999     "ptPull="<< ptPull<<
2000     "ptPullHighPt="<< ptPullHighPt<<
2001     "yPull="<< yPull<<
2002     "yPullHighPt="<< yPullHighPt<<
2003     "zPull="<< zPull<<
2004     "zPullHighPt="<< zPullHighPt<<
2005     "lambdaPull="<< lambdaPull<<
2006     "lambdaPullHighPt="<< lambdaPullHighPt;
2007
2008   return 0;
2009 }
2010 Int_t AliTPCPerformanceSummary::AnalyzeConstrain(const AliPerformanceMatch* pConstrain, TTreeSRedirector* pcstream)
2011 {
2012   if (!pcstream) return 5126;
2013   if (!pConstrain) return 5126;
2014
2015     TH3* his3D=0;
2016     static Double_t tpcConstrainPhiA = 0;
2017     static Double_t tpcConstrainPhiC = 0;
2018
2019     if (pConstrain->GetHistos()->FindObject("h_tpc_constrain_tpc_0_2_3")) {
2020
2021       his3D = dynamic_cast<TH3*>(pConstrain->GetHistos()->FindObject("h_tpc_constrain_tpc_0_2_3"));//phi pull:pt:eta
2022       if(!his3D) return 5126;
2023
2024       his3D->GetZaxis()->SetRangeUser(0.0,1.0);
2025       tpcConstrainPhiA = his3D->GetMean(1);
2026       his3D->GetZaxis()->SetRangeUser(-1.0,-0.001);
2027       tpcConstrainPhiC = his3D->GetMean(1);
2028     }
2029
2030   (*pcstream)<<"tpcQA"<<
2031     "tpcConstrainPhiA="<<tpcConstrainPhiA <<
2032     "tpcConstrainPhiC="<< tpcConstrainPhiC;
2033
2034   return 0;
2035 }
2036
2037 //_____________________________________________________________________________
2038  Int_t AliTPCPerformanceSummary::AnalyzeQAPosNegDpT(const AliPerformanceTPC* pTPC, TTreeSRedirector* const pcstream)
2039 {
2040   //function which plot 1/Pt for negative and
2041   //positive particles
2042
2043   if (!pcstream) return 512;
2044   if (!pTPC) return 512;
2045
2046   TH3D* pos3=0;
2047   TH3D* neg3=0;
2048   TH1D* pos=0;
2049   TH1D* neg=0;
2050   TH1D* posC=0;
2051   TH1D* negC=0;
2052   TH1D* posA=0;
2053   TH1D* negA=0;
2054   static Double_t deltaPtC = 0;
2055   static Double_t deltaPtchi2C = 0;
2056   static Double_t slopeC = 0;
2057   static Double_t deltaPtA = 0;
2058   static Double_t deltaPtchi2A = 0;
2059   static Double_t slopeA = 0;
2060   static Double_t deltaPt = 0;
2061   static Double_t deltaPtchi2 = 0;
2062   static Double_t slope = 0;
2063   static Double_t deltaPt_Err = 0;
2064   static Double_t deltaPtA_Err = 0;
2065   static Double_t deltaPtC_Err = 0;
2066
2067
2068 //C side
2069
2070   if(pTPC->GetHistos()->FindObject("h_tpc_track_pos_recvertex_0_5_7"))
2071     {
2072     pos3 = dynamic_cast<TH3D*>(pTPC->GetHistos()->FindObject("h_tpc_track_pos_recvertex_0_5_7"));
2073     if(!pos3) return 512;
2074
2075     pos = pos3->ProjectionZ("pos",71,-1,6,25);
2076     posC = pos3->ProjectionZ("posC",71,-1,6,15);
2077     posA = pos3->ProjectionZ("posA",71,-1,16,25);
2078     }
2079
2080     if(pTPC->GetHistos()->FindObject("h_tpc_track_neg_recvertex_0_5_7")){
2081     neg3 = dynamic_cast<TH3D*>(pTPC->GetHistos()->FindObject("h_tpc_track_neg_recvertex_0_5_7"));
2082     if(!neg3) return 512;
2083
2084     neg = neg3->ProjectionZ("neg",71,-1,6,25);
2085     negC = neg3->ProjectionZ("negC",71,-1,6,15);
2086     negA = neg3->ProjectionZ("negA",71,-1,16,25);
2087 }
2088
2089 if(!pos) return 512;
2090 if(!neg) return 512;
2091 if(!posA) return 512;
2092 if(!negA) return 512;
2093 if(!posC) return 512;
2094 if(!negC) return 512;
2095
2096 pos->Sumw2();
2097 neg->Sumw2();
2098 posA->Sumw2();
2099 negA->Sumw2();
2100 posC->Sumw2();
2101 negC->Sumw2();
2102
2103 pos->Scale(1.,"width");
2104 neg->Scale(1.,"width");
2105 posA->Scale(1.,"width");
2106 negA->Scale(1.,"width");
2107 posC->Scale(1.,"width");
2108 negC->Scale(1.,"width");
2109
2110 //both sides
2111
2112 TF1 fpt("fpt","[1]*exp(-1/((1/x))*[0])",0.1,10);
2113 TF1 fpt2("fpt2","[1]*exp(-1/((1/x))*[0])",0.1,10);
2114 fpt.SetParameters(1,0.5);
2115 fpt2.SetParameters(1,0.5);
2116 pos->Fit(&fpt,"","",1,4); pos->Fit(&fpt,"","",1,4); pos->Fit(&fpt,"","",1,4);
2117 neg->Fit(&fpt2,"","",1,4); neg->Fit(&fpt2,"","",1,4); neg->Fit(&fpt2,"","",1,4);
2118
2119 slope = (fpt.GetParameter(0)+fpt2.GetParameter(0))/2.;
2120
2121 TH1D* ratio = new TH1D(*pos);
2122 ratio->Divide(neg);
2123
2124 ratio->Draw();
2125 TF1 fptRatio("fptratio","[2]*exp(-1/((1/x)+[1])*[0])/exp(-1/((1/x)-[1])*[0])",0.1,10);
2126 fptRatio.SetParameters(0.5,0.006,1);
2127 fptRatio.FixParameter(0,slope);
2128 fptRatio.Draw();
2129 ratio->Fit(&fptRatio,"","",1,4); ratio->Fit(&fptRatio,"","",1,4);
2130 ratio->Fit(&fptRatio,"","",1,4);
2131
2132 deltaPt = fptRatio.GetParameter(1);
2133 deltaPtchi2 = fptRatio.GetChisquare();
2134
2135 //get the errors
2136 deltaPt_Err = fptRatio.GetParError(1);
2137
2138
2139 //A side
2140
2141 TF1 fptA("fptA","[1]*exp(-1/((1/x))*[0])",0.1,10);
2142 TF1 fpt2A("fpt2A","[1]*exp(-1/((1/x))*[0])",0.1,10);
2143 fptA.SetParameters(1,0.5);
2144 fpt2A.SetParameters(1,0.5);
2145 posA->Fit(&fptA,"","",1,4); posA->Fit(&fptA,"","",1,4); posA->Fit(&fptA,"","",1,4);
2146 negA->Fit(&fpt2A,"","",1,4); negA->Fit(&fpt2A,"","",1,4); negA->Fit(&fpt2A,"","",1,4);
2147
2148 slopeA = (fptA.GetParameter(0)+fpt2A.GetParameter(0))/2.;
2149
2150 TH1D* ratioA = new TH1D(*posA);
2151 ratioA->Divide(negA);
2152
2153 ratioA->Draw();
2154 TF1 fptRatioA("fptratioA","[2]*exp(-1/((1/x)+[1])*[0])/exp(-1/((1/x)-[1])*[0])",0.1,10);
2155 fptRatioA.SetParameters(0.5,0.006,1);
2156 fptRatioA.FixParameter(0,slopeA);
2157 fptRatioA.Draw();
2158 ratioA->Fit(&fptRatioA,"","",1,4); ratio->Fit(&fptRatioA,"","",1,4);
2159 ratioA->Fit(&fptRatioA,"","",1,4);
2160
2161 deltaPtA = fptRatioA.GetParameter(1);
2162 deltaPtchi2A = fptRatioA.GetChisquare();
2163
2164 //get the errors
2165 deltaPtA_Err = fptRatioA.GetParError(1);
2166
2167  delete ratioA;
2168  delete pos;
2169  delete neg;
2170
2171
2172 //C side
2173 TF1 fptC("fptC","[1]*exp(-1/((1/x))*[0])",0.1,10);
2174 TF1 fpt2C("fpt2C","[1]*exp(-1/((1/x))*[0])",0.1,10);
2175 fptC.SetParameters(1,0.5);
2176 fpt2C.SetParameters(1,0.5);
2177 posC->Fit(&fptC,"","",1,4); posC->Fit(&fptC,"","",1,4); posC->Fit(&fptC,"","",1,4);
2178 negC->Fit(&fpt2C,"","",1,4); negC->Fit(&fpt2C,"","",1,4); negC->Fit(&fpt2C,"","",1,4);
2179
2180 slopeC = (fptC.GetParameter(0)+fpt2C.GetParameter(0))/2.;
2181
2182 TH1D* ratioC = new TH1D(*posC);
2183 ratioC->Divide(negC);
2184
2185 ratioC->Draw();
2186 TF1 fptRatioC("fptratioC","[2]*exp(-1/((1/x)+[1])*[0])/exp(-1/((1/x)-[1])*[0])",0.1,10);
2187 fptRatioC.SetParameters(0.5,0.006,1);
2188 fptRatioC.FixParameter(0,slopeC);
2189 fptRatioC.Draw();
2190 ratioC->Fit(&fptRatioC,"","",1,4); ratio->Fit(&fptRatioC,"","",1,4);
2191 ratioC->Fit(&fptRatioC,"","",1,4);
2192
2193 deltaPtC = fptRatioC.GetParameter(1);
2194 deltaPtchi2C = fptRatioC.GetChisquare();
2195
2196 //get the errors
2197 deltaPtC_Err = fptRatioC.GetParError(1);
2198
2199
2200  delete posC;
2201  delete negC;
2202  delete ratioC;
2203
2204     (*pcstream)<<"tpcQA"<<
2205       "deltaPt="<< deltaPt<<
2206       "deltaPtchi2="<< deltaPtchi2<<
2207       "deltaPtA="<< deltaPtA<<
2208       "deltaPtchi2A="<< deltaPtchi2A<<
2209       "deltaPtC="<< deltaPtC<<
2210       "deltaPtchi2C="<< deltaPtchi2C<<
2211       "deltaPt_Err="<< deltaPt_Err<<
2212       "deltaPtA_Err="<< deltaPtA_Err<<
2213       "deltaPtC_Err="<< deltaPtC_Err;
2214
2215     return 0;
2216 }
2217
2218 //_____________________________________________________________________________
2219  Int_t AliTPCPerformanceSummary::AnalyzeQADCAFitParameter(const AliPerformanceTPC* pTPC, TTreeSRedirector* const pcstream)
2220 {
2221
2222   //
2223   //function which retrieve DCA fit parameters
2224   //
2225
2226   if (!pcstream) return 16;
2227   if (!pTPC) return 16;
2228
2229   TH3* dcar_pos3=0;
2230   TH3* dcaz_pos3=0;
2231   TH3* dcar_neg3=0;
2232   TH3* dcaz_neg3=0;
2233
2234   static Double_t dcar_posA_0=0;
2235   static Double_t dcar_posA_1=0;
2236   static Double_t dcar_posA_2=0;
2237   static Double_t dcar_posA_chi2=0;
2238   static Double_t dcar_posA_0_Err=0;
2239   static Double_t dcar_posA_1_Err=0;
2240   static Double_t dcar_posA_2_Err=0;
2241
2242   static Double_t dcar_posC_0=0;
2243   static Double_t dcar_posC_1=0;
2244   static Double_t dcar_posC_2=0;
2245   static Double_t dcar_posC_chi2=0;
2246   static Double_t dcar_posC_0_Err=0;
2247   static Double_t dcar_posC_1_Err=0;
2248   static Double_t dcar_posC_2_Err=0;
2249
2250   static Double_t dcaz_posA_0=0;
2251   static Double_t dcaz_posA_1=0;
2252   static Double_t dcaz_posA_2=0;
2253   static Double_t dcaz_posA_chi2=0;
2254   static Double_t dcaz_posA_0_Err=0;
2255   static Double_t dcaz_posA_1_Err=0;
2256   static Double_t dcaz_posA_2_Err=0;
2257
2258   static Double_t dcaz_posC_0=0;
2259   static Double_t dcaz_posC_1=0;
2260   static Double_t dcaz_posC_2=0;
2261   static Double_t dcaz_posC_chi2=0;
2262   static Double_t dcaz_posC_0_Err=0;
2263   static Double_t dcaz_posC_1_Err=0;
2264   static Double_t dcaz_posC_2_Err=0;
2265
2266   static Double_t dcar_negA_0=0;
2267   static Double_t dcar_negA_1=0;
2268   static Double_t dcar_negA_2=0;
2269   static Double_t dcar_negA_chi2=0;
2270   static Double_t dcar_negA_0_Err=0;
2271   static Double_t dcar_negA_1_Err=0;
2272   static Double_t dcar_negA_2_Err=0;
2273
2274   static Double_t dcar_negC_0=0;
2275   static Double_t dcar_negC_1=0;
2276   static Double_t dcar_negC_2=0;
2277   static Double_t dcar_negC_chi2=0;
2278   static Double_t dcar_negC_0_Err=0;
2279   static Double_t dcar_negC_1_Err=0;
2280   static Double_t dcar_negC_2_Err=0;
2281
2282   static Double_t dcaz_negA_0=0;
2283   static Double_t dcaz_negA_1=0;
2284   static Double_t dcaz_negA_2=0;
2285   static Double_t dcaz_negA_chi2=0;
2286   static Double_t dcaz_negA_0_Err=0;
2287   static Double_t dcaz_negA_1_Err=0;
2288   static Double_t dcaz_negA_2_Err=0;
2289
2290   static Double_t dcaz_negC_0=0;
2291   static Double_t dcaz_negC_1=0;
2292   static Double_t dcaz_negC_2=0;
2293   static Double_t dcaz_negC_chi2=0;
2294   static Double_t dcaz_negC_0_Err=0;
2295   static Double_t dcaz_negC_1_Err=0;
2296   static Double_t dcaz_negC_2_Err=0;
2297
2298   if (pTPC->GetHistos()->FindObject("h_tpc_track_pos_recvertex_3_5_6")) {
2299     dcar_pos3 = dynamic_cast<TH3*>(pTPC->GetHistos()->FindObject("h_tpc_track_pos_recvertex_3_5_6"));
2300   }
2301
2302   if (pTPC->GetHistos()->FindObject("h_tpc_track_pos_recvertex_3_5_6")) {
2303     dcaz_pos3 = dynamic_cast<TH3*>(pTPC->GetHistos()->FindObject("h_tpc_track_pos_recvertex_4_5_6"));
2304   }
2305
2306   if (pTPC->GetHistos()->FindObject("h_tpc_track_pos_recvertex_3_5_6")) {
2307     dcar_neg3 = dynamic_cast<TH3*>(pTPC->GetHistos()->FindObject("h_tpc_track_neg_recvertex_3_5_6"));
2308   }
2309
2310   if (pTPC->GetHistos()->FindObject("h_tpc_track_pos_recvertex_3_5_6")) {
2311     dcaz_neg3 = dynamic_cast<TH3*>(pTPC->GetHistos()->FindObject("h_tpc_track_neg_recvertex_4_5_6"));
2312   }
2313
2314   TF1 fit("fit","[0]+[1]*cos(x)+[2]*sin(x)",0,7);
2315
2316   dcar_pos3->GetYaxis()->SetRangeUser(0,0.99);
2317   TH1* dcar_posA = (dynamic_cast<TH2*>(dcar_pos3->Project3D("xz_1")))->ProfileX();
2318   dcar_posA->Fit(&fit,"NQ");
2319   dcar_posA_0 = fit.GetParameter(0);
2320   dcar_posA_1 = fit.GetParameter(1);
2321   dcar_posA_2 = fit.GetParameter(2);
2322   dcar_posA_chi2 = fit.GetChisquare();
2323   dcar_posA_0_Err = fit.GetParError(0);
2324   dcar_posA_1_Err = fit.GetParError(1);
2325   dcar_posA_2_Err = fit.GetParError(2);
2326
2327   dcar_pos3->GetYaxis()->SetRangeUser(-1.0,-0.01);
2328   TH1* dcar_posC = (dynamic_cast<TH2*>(dcar_pos3->Project3D("xz_2")))->ProfileX();
2329   dcar_posC->Fit(&fit,"NQ");
2330   dcar_posC_0 = fit.GetParameter(0);
2331   dcar_posC_1 = fit.GetParameter(1);
2332   dcar_posC_2 = fit.GetParameter(2);
2333   dcar_posC_chi2 = fit.GetChisquare();
2334   dcar_posC_0_Err = fit.GetParError(0);
2335   dcar_posC_1_Err = fit.GetParError(1);
2336   dcar_posC_2_Err = fit.GetParError(2);
2337
2338   dcaz_pos3->GetYaxis()->SetRangeUser(0,0.99);
2339   TH1* dcaz_posA = (dynamic_cast<TH2*>(dcaz_pos3->Project3D("xz_3")))->ProfileX();
2340   dcaz_posA->Fit(&fit,"NQ");
2341   dcaz_posA_0 = fit.GetParameter(0);
2342   dcaz_posA_1 = fit.GetParameter(1);
2343   dcaz_posA_2 = fit.GetParameter(2);
2344   dcaz_posA_chi2 = fit.GetChisquare();
2345   dcaz_posA_0_Err = fit.GetParError(0);
2346   dcaz_posA_1_Err = fit.GetParError(1);
2347   dcaz_posA_2_Err = fit.GetParError(2);
2348
2349   dcaz_pos3->GetYaxis()->SetRangeUser(-1.0,-0.01);
2350   TH1* dcaz_posC = (dynamic_cast<TH2*>(dcaz_pos3->Project3D("xz_4")))->ProfileX();
2351   dcaz_posC->Fit(&fit,"NQ");
2352   dcaz_posC_0 = fit.GetParameter(0);
2353   dcaz_posC_1 = fit.GetParameter(1);
2354   dcaz_posC_2 = fit.GetParameter(2);
2355   dcaz_posC_chi2 = fit.GetChisquare();
2356   dcaz_posC_0_Err = fit.GetParError(0);
2357   dcaz_posC_1_Err = fit.GetParError(1);
2358   dcaz_posC_2_Err = fit.GetParError(2);
2359
2360
2361
2362    dcar_neg3->GetYaxis()->SetRangeUser(0,0.99);
2363   TH1* dcar_negA = (dynamic_cast<TH2*>(dcar_neg3->Project3D("xz_1")))->ProfileX();
2364   dcar_negA->Fit(&fit,"NQ");
2365   dcar_negA_0 = fit.GetParameter(0);
2366   dcar_negA_1 = fit.GetParameter(1);
2367   dcar_negA_2 = fit.GetParameter(2);
2368   dcar_negA_chi2 = fit.GetChisquare();
2369   dcar_negA_0_Err = fit.GetParError(0);
2370   dcar_negA_1_Err = fit.GetParError(1);
2371   dcar_negA_2_Err = fit.GetParError(2);
2372
2373   dcar_neg3->GetYaxis()->SetRangeUser(-1.0,-0.01);
2374   TH1* dcar_negC = (dynamic_cast<TH2*>(dcar_neg3->Project3D("xz_2")))->ProfileX();
2375   dcar_negC->Fit(&fit,"NQ");
2376   dcar_negC_0 = fit.GetParameter(0);
2377   dcar_negC_1 = fit.GetParameter(1);
2378   dcar_negC_2 = fit.GetParameter(2);
2379   dcar_negC_chi2 = fit.GetChisquare();
2380   dcar_negC_0_Err = fit.GetParError(0);
2381   dcar_negC_1_Err = fit.GetParError(1);
2382   dcar_negC_2_Err = fit.GetParError(2);
2383
2384   dcaz_neg3->GetYaxis()->SetRangeUser(0,0.99);
2385   TH1* dcaz_negA = (dynamic_cast<TH2*>(dcaz_neg3->Project3D("xz_3")))->ProfileX();
2386   dcaz_negA->Fit(&fit,"NQ");
2387   dcaz_negA_0 = fit.GetParameter(0);
2388   dcaz_negA_1 = fit.GetParameter(1);
2389   dcaz_negA_2 = fit.GetParameter(2);
2390   dcaz_negA_chi2 = fit.GetChisquare();
2391   dcaz_negA_0_Err = fit.GetParError(0);
2392   dcaz_negA_1_Err = fit.GetParError(1);
2393   dcaz_negA_2_Err = fit.GetParError(2);
2394
2395   dcaz_neg3->GetYaxis()->SetRangeUser(-1.0,-0.01);
2396   TH1* dcaz_negC = (dynamic_cast<TH2*>(dcaz_neg3->Project3D("xz_4")))->ProfileX();
2397   dcaz_negC->Fit(&fit,"NQ");
2398   dcaz_negC_0 = fit.GetParameter(0);
2399   dcaz_negC_1 = fit.GetParameter(1);
2400   dcaz_negC_2 = fit.GetParameter(2);
2401   dcaz_negC_chi2 = fit.GetChisquare();
2402   dcaz_negC_0_Err = fit.GetParError(0);
2403   dcaz_negC_1_Err = fit.GetParError(1);
2404   dcaz_negC_2_Err = fit.GetParError(2);
2405
2406
2407 // store results (shift in dca) in ttree
2408
2409     (*pcstream)<<"tpcQA"<<
2410       "dcar_posA_0="<< dcar_posA_0<<
2411       "dcar_posA_1="<< dcar_posA_1<<
2412       "dcar_posA_2="<< dcar_posA_2<<
2413       "dcar_posA_chi2="<< dcar_posA_chi2<<
2414       "dcar_posA_0_Err="<< dcar_posA_0_Err<<
2415       "dcar_posA_1_Err="<< dcar_posA_1_Err<<
2416       "dcar_posA_2_Err="<< dcar_posA_2_Err;
2417
2418       (*pcstream)<<"tpcQA"<<
2419       "dcaz_posA_0="<< dcaz_posA_0<<
2420       "dcaz_posA_1="<< dcaz_posA_1<<
2421       "dcaz_posA_2="<< dcaz_posA_2<<
2422       "dcaz_posA_chi2="<< dcaz_posA_chi2<<
2423       "dcaz_posA_0_Err="<< dcaz_posA_0_Err<<
2424       "dcaz_posA_1_Err="<< dcaz_posA_1_Err<<
2425       "dcaz_posA_2_Err="<< dcaz_posA_2_Err;
2426
2427       (*pcstream)<<"tpcQA"<<
2428       "dcaz_posC_0="<< dcaz_posC_0<<
2429       "dcaz_posC_1="<< dcaz_posC_1<<
2430       "dcaz_posC_2="<< dcaz_posC_2<<
2431       "dcaz_posC_chi2="<< dcaz_posC_chi2<<
2432       "dcaz_posC_0_Err="<< dcaz_posC_0_Err<<
2433       "dcaz_posC_1_Err="<< dcaz_posC_1_Err<<
2434       "dcaz_posC_2_Err="<< dcaz_posC_2_Err;
2435
2436       (*pcstream)<<"tpcQA"<<
2437       "dcar_posC_0="<< dcar_posC_0<<
2438       "dcar_posC_1="<< dcar_posC_1<<
2439       "dcar_posC_2="<< dcar_posC_2<<
2440       "dcar_posC_chi2="<< dcar_posC_chi2<<
2441       "dcar_posC_0_Err="<< dcar_posC_0_Err<<
2442       "dcar_posC_1_Err="<< dcar_posC_1_Err<<
2443       "dcar_posC_2_Err="<< dcar_posC_2_Err;
2444
2445
2446      (*pcstream)<<"tpcQA"<<
2447       "dcar_negA_0="<< dcar_negA_0<<
2448       "dcar_negA_1="<< dcar_negA_1<<
2449       "dcar_negA_2="<< dcar_negA_2<<
2450       "dcar_negA_chi2="<< dcar_negA_chi2<<
2451       "dcar_negA_0_Err="<< dcar_negA_0_Err<<
2452       "dcar_negA_1_Err="<< dcar_negA_1_Err<<
2453       "dcar_negA_2_Err="<< dcar_negA_2_Err;
2454
2455       (*pcstream)<<"tpcQA"<<
2456       "dcaz_negA_0="<< dcaz_negA_0<<
2457       "dcaz_negA_1="<< dcaz_negA_1<<
2458       "dcaz_negA_2="<< dcaz_negA_2<<
2459       "dcaz_negA_chi2="<< dcaz_negA_chi2<<
2460       "dcaz_negA_0_Err="<< dcaz_negA_0_Err<<
2461       "dcaz_negA_1_Err="<< dcaz_negA_1_Err<<
2462       "dcaz_negA_2_Err="<< dcaz_negA_2_Err;
2463
2464       (*pcstream)<<"tpcQA"<<
2465       "dcaz_negC_0="<< dcaz_negC_0<<
2466       "dcaz_negC_1="<< dcaz_negC_1<<
2467       "dcaz_negC_2="<< dcaz_negC_2<<
2468       "dcaz_negC_chi2="<< dcaz_negC_chi2<<
2469       "dcaz_negC_0_Err="<< dcaz_negC_0_Err<<
2470       "dcaz_negC_1_Err="<< dcaz_negC_1_Err<<
2471       "dcaz_negC_2_Err="<< dcaz_negC_2_Err;
2472
2473       (*pcstream)<<"tpcQA"<<
2474       "dcar_negC_0="<< dcar_negC_0<<
2475       "dcar_negC_1="<< dcar_negC_1<<
2476       "dcar_negC_2="<< dcar_negC_2<<
2477       "dcar_negC_chi2="<< dcar_negC_chi2<<
2478       "dcar_negC_0_Err="<< dcar_negC_0_Err<<
2479       "dcar_negC_1_Err="<< dcar_negC_1_Err<<
2480       "dcar_negC_2_Err="<< dcar_negC_2_Err;
2481
2482       return 0;
2483 }
2484
2485 //_____________________________________________________________________________
2486 Int_t AliTPCPerformanceSummary::AnalyzeOcc(const AliPerformanceTPC* pTPC, TTreeSRedirector* const pcstream)
2487 {
2488   //
2489   //function which make trending of occupany per side and IROC-OROC
2490   //
2491
2492   if (!pcstream) return 16;
2493   if (!pTPC) return 16;
2494
2495   TH3* h3D_1=0;
2496   TH2* his2D=0;
2497   TH1* his1D=0;
2498
2499   static Double_t norm=0;
2500   static Double_t mean_occ_chamber=0;
2501   static Double_t rms_mean_occ_chamber=0;
2502   static Float_t occ_chamber=0;
2503   static Double_t rmsNr   = 3.0;
2504   static Int_t n_chamber_lowOcc = 0;
2505   static Double_t minOcc= 0;
2506
2507   //nr of chamber within the thresholds
2508   static Int_t iroc_A_side =0;
2509   static Int_t oroc_A_side=0;
2510   static Int_t iroc_C_side =0;
2511   static Int_t oroc_C_side =0;
2512
2513   //occupancy for each chamber, normalized to the total occupancy
2514   static TVectorF meanOccArray_iroc(36);
2515   static TVectorF meanOccArray_oroc(36);
2516
2517  if (pTPC->GetHistos()->FindObject("h_tpc_clust_0_1_2")) {
2518     h3D_1 = dynamic_cast<TH3*>(pTPC->GetHistos()->FindObject("h_tpc_clust_0_1_2"));
2519   }
2520
2521   //////////////////////////////////////////
2522   // normalization
2523   h3D_1->GetZaxis()->SetRangeUser(0,0.99); //A side
2524   h3D_1->GetXaxis()->SetRangeUser(0,160); //IROC + OROC
2525   his2D  = dynamic_cast<TH2*>(h3D_1->Project3D("xy_A_norm"));
2526   if(!his2D) return 4;
2527   his1D = his2D->ProjectionX();
2528   norm = his1D->Integral();
2529   printf("normalization:  \t%f\n",norm);
2530   if (norm < 0.001) norm=0.00001;
2531   delete his2D;
2532
2533   //////////////////////////////////////////
2534   // A_side IROC
2535   h3D_1->GetZaxis()->SetRangeUser(0,0.99); //A_side
2536   h3D_1->GetXaxis()->SetRangeUser(0,63); //IROC
2537
2538   his2D = dynamic_cast<TH2*>(h3D_1->Project3D("xy_A_side_IROC"));
2539   if(!his2D) return 4;
2540
2541   printf("-------------- A_IROC occupancy \t\n");
2542
2543   for(Int_t i = 0; i < 18; i++) { //fill IROC A_side
2544     Float_t phiLow = i*(20./360.)*(2*TMath::Pi());
2545     Float_t phiUp  = (i+1)*(20./360.)*(2*TMath::Pi());
2546     his2D->GetXaxis()->SetRangeUser(phiLow,phiUp);
2547     his1D = his2D->ProjectionX();
2548     occ_chamber = (his1D->Integral()) / norm;
2549     printf("%d occ_chamber \t%f \t phiLow phiUp  \t%f  %f \n",i, occ_chamber, phiLow, phiUp);
2550     meanOccArray_iroc[i]= occ_chamber;//fill array with occupancy for each chamber
2551     mean_occ_chamber += occ_chamber;//compute the average occupancy
2552     rms_mean_occ_chamber  += occ_chamber*occ_chamber;
2553     delete his1D;
2554   }
2555   delete his2D;
2556
2557   mean_occ_chamber /= 18; //nr of sectors
2558   rms_mean_occ_chamber  /= 18; //nr of sectors
2559
2560   rms_mean_occ_chamber   =  TMath::Sqrt( TMath::Abs(rms_mean_occ_chamber - (mean_occ_chamber*mean_occ_chamber)) );
2561   minOcc    = mean_occ_chamber - rmsNr*rms_mean_occ_chamber;
2562
2563   printf("mean_occ_chamber +- rms_mean_occ_chamber \t%f\t%f \n", mean_occ_chamber, rms_mean_occ_chamber);
2564   printf("min Occ allowed (threshold) \t%f \n", minOcc);
2565
2566   for (Int_t i = 0; i<18; i++) {
2567     if (meanOccArray_iroc[i] < minOcc) {n_chamber_lowOcc++;}
2568   }
2569   iroc_A_side = (18 - n_chamber_lowOcc); //nr of iroc above the thr
2570   printf("Nr of iroc_A_side \t%i \n \n ",iroc_A_side);
2571
2572   mean_occ_chamber=0;
2573   rms_mean_occ_chamber=0;
2574   occ_chamber=0.;
2575   n_chamber_lowOcc=0;
2576   minOcc=0.;
2577   ////////////////////////////////////////////
2578   // A_side OROC
2579   h3D_1->GetZaxis()->SetRangeUser(0,0.99); //A_side
2580   h3D_1->GetXaxis()->SetRangeUser(64,160); //OROC
2581
2582   his2D = dynamic_cast<TH2*>(h3D_1->Project3D("xy_A_side_OROC"));
2583   if(!his2D) return 4;
2584
2585   printf("-------------- A_OROC occupancy \t\n");
2586
2587   for(Int_t i = 0; i < 18; i++) {
2588     Float_t phiLow = i*(20./360.)*(2*TMath::Pi());
2589     Float_t phiUp  = (i+1)*(20./360.)*(2*TMath::Pi());
2590     his2D->GetXaxis()->SetRangeUser(phiLow,phiUp);
2591     his1D = his2D->ProjectionX();
2592     occ_chamber = (his1D->Integral()) / norm;
2593     printf("%d occ_chamber \t%f \t phiLow phiUp  \t%f  %f \n",i, occ_chamber, phiLow, phiUp);
2594     meanOccArray_oroc[i]= occ_chamber;//fill array with occupancy for each chamber
2595     mean_occ_chamber += occ_chamber;//compute the average occupancy
2596     rms_mean_occ_chamber  += occ_chamber*occ_chamber;
2597     delete his1D;
2598   }
2599   delete his2D;
2600
2601   mean_occ_chamber /= 18; //nr of sectors
2602   rms_mean_occ_chamber  /= 18; //nr of sectors
2603
2604   rms_mean_occ_chamber   =  TMath::Sqrt( TMath::Abs(rms_mean_occ_chamber - (mean_occ_chamber*mean_occ_chamber)) );
2605   minOcc    = mean_occ_chamber - rmsNr*rms_mean_occ_chamber;
2606
2607   printf("mean_occ_chamber +- rms_mean_occ_chamber \t%f\t%f \n", mean_occ_chamber, rms_mean_occ_chamber);
2608   printf("min Occ allowed (threshold) \t%f \n", minOcc);
2609
2610   for (Int_t i = 0; i<18; i++) {
2611     if (meanOccArray_oroc[i] < minOcc) {n_chamber_lowOcc++;}
2612   }
2613   oroc_A_side = (18 - n_chamber_lowOcc); //variable stored in the trending
2614   printf("Nr of oroc_A_side \t%i \n \n ",oroc_A_side);
2615
2616   mean_occ_chamber=0;
2617   rms_mean_occ_chamber=0;
2618   occ_chamber=0.;
2619   n_chamber_lowOcc=0;
2620   minOcc=0.;
2621
2622   ////////////////////////////////////////////////////////////////////////////////
2623   // C side
2624   //////////////////////////////////////////
2625
2626   // normalization
2627   h3D_1->GetZaxis()->SetRangeUser(-1,-0.001); //C side
2628   h3D_1->GetXaxis()->SetRangeUser(0,160); //IROC + OROC
2629   his2D  = dynamic_cast<TH2*>(h3D_1->Project3D("xy_C_norm"));
2630   if(!his2D) return 4;
2631   his1D = his2D->ProjectionX();
2632   norm = his1D->Integral();
2633   printf("normalization:  \t%f\n",norm);
2634   if (norm < 0.001) norm=0.00001;
2635   delete his2D;
2636
2637   //////////////////////////////////////////
2638   // C_side IROC
2639   h3D_1->GetZaxis()->SetRangeUser(-1,-0.001); //C_side
2640   h3D_1->GetXaxis()->SetRangeUser(0,63); //IROC
2641
2642   his2D = dynamic_cast<TH2*>(h3D_1->Project3D("xy_C_side_IROC"));
2643   if(!his2D) return 4;
2644
2645   printf("-------------- C_IROC occupancy \t\n");
2646
2647   for(Int_t i = 0; i < 18; i++) {
2648     Float_t phiLow = i*(20./360.)*(2*TMath::Pi());
2649     Float_t phiUp  = (i+1)*(20./360.)*(2*TMath::Pi());
2650     his2D->GetXaxis()->SetRangeUser(phiLow,phiUp);
2651     his1D = his2D->ProjectionX();
2652     occ_chamber = (his1D->Integral()) / norm;
2653     printf("%d occ_chamber \t%f \t phiLow phiUp  \t%f  %f \n",i, occ_chamber, phiLow, phiUp);
2654     meanOccArray_iroc[18+i]= occ_chamber;//fill array with occupancy for each chamber, C side, therefore index 18+i
2655     mean_occ_chamber += occ_chamber;//compute the average occupancy
2656     rms_mean_occ_chamber  += occ_chamber*occ_chamber;
2657     delete his1D;
2658   }
2659   delete his2D;
2660
2661   mean_occ_chamber /= 18; //nr of sectors
2662   rms_mean_occ_chamber  /= 18; //nr of sectors
2663
2664   rms_mean_occ_chamber   =  TMath::Sqrt( TMath::Abs(rms_mean_occ_chamber - (mean_occ_chamber*mean_occ_chamber)) );
2665   minOcc    = mean_occ_chamber - rmsNr*rms_mean_occ_chamber;
2666
2667   printf("mean_occ_chamber +- rms_mean_occ_chamber \t%f\t%f \n", mean_occ_chamber, rms_mean_occ_chamber);
2668   printf("min Occ allowed (threshold) \t%f \n", minOcc);
2669
2670   for (Int_t i = 18; i<36; i++) {
2671     if (meanOccArray_iroc[i] < minOcc) {n_chamber_lowOcc++;}
2672   }
2673   iroc_C_side = (18 - n_chamber_lowOcc); //variable stored in the trending
2674   printf("Nr of iroc_C_side \t%i \n \n ",iroc_C_side);
2675
2676   mean_occ_chamber=0;
2677   rms_mean_occ_chamber=0;
2678   occ_chamber=0.;
2679   n_chamber_lowOcc=0;
2680   minOcc=0.;
2681
2682   ////////////////////////////////////////////
2683   // C_side OROC
2684   h3D_1->GetZaxis()->SetRangeUser(-1,-0.001); //C_side
2685   h3D_1->GetXaxis()->SetRangeUser(64,160); //OROC
2686
2687   his2D = dynamic_cast<TH2*>(h3D_1->Project3D("xy_C_side_OROC"));
2688   if(!his2D) return 4;
2689
2690   printf("-------------- C_OROC occupancy \t\n");
2691
2692   for(Int_t i = 0; i < 18; i++) {
2693     Float_t phiLow = i*(20./360.)*(2*TMath::Pi());
2694     Float_t phiUp  = (i+1)*(20./360.)*(2*TMath::Pi());
2695     his2D->GetXaxis()->SetRangeUser(phiLow,phiUp);
2696     his1D = his2D->ProjectionX();
2697     occ_chamber = (his1D->Integral()) / norm;
2698     printf("%d occ_chamber \t%f \t phiLow phiUp  \t%f  %f \n",i, occ_chamber, phiLow, phiUp);
2699     meanOccArray_oroc[18+i]= occ_chamber;//fill array with occupancy for each chamber
2700     mean_occ_chamber += occ_chamber;//compute the average occupancy
2701     rms_mean_occ_chamber  += occ_chamber*occ_chamber;
2702     delete his1D;
2703   }
2704   delete his2D;
2705
2706   mean_occ_chamber /= 18; //nr of sectors
2707   rms_mean_occ_chamber  /= 18; //nr of sectors
2708
2709   rms_mean_occ_chamber   =  TMath::Sqrt( TMath::Abs(rms_mean_occ_chamber - (mean_occ_chamber*mean_occ_chamber)) );
2710   minOcc    = mean_occ_chamber - rmsNr*rms_mean_occ_chamber;
2711
2712   printf("mean_occ_chamber +- rms_mean_occ_chamber \t%f\t%f \n", mean_occ_chamber, rms_mean_occ_chamber);
2713   printf("min Occ allowed (threshold) \t%f \n", minOcc);
2714
2715   for (Int_t i = 18; i<36; i++) {
2716     if (meanOccArray_oroc[i] < minOcc) {n_chamber_lowOcc++;}
2717   }
2718   oroc_C_side = (18 - n_chamber_lowOcc); //variable stored in the trending
2719   printf("Nr of oroc_C_side \t%i \n \n ",oroc_C_side);
2720
2721   mean_occ_chamber=0;
2722   rms_mean_occ_chamber=0;
2723   occ_chamber=0.;
2724   n_chamber_lowOcc=0;
2725   minOcc=0.;
2726
2727   (*pcstream)<<"tpcQA"<<
2728    "iroc_A_side="<< iroc_A_side<<
2729    "oroc_A_side="<< oroc_A_side<<
2730    "iroc_C_side="<< iroc_C_side<<
2731    "oroc_C_side="<< oroc_C_side<<
2732    //A/C side IROC
2733    "TPC_Occ_IROC.="<< &meanOccArray_iroc<<
2734    //A/C side OROC
2735    "TPC_Occ_OROC.="<< &meanOccArray_oroc;
2736
2737  return 0;
2738   }
2739