TRD/AliTRDCalibTask.cxx

   1
   2 /**************************************************************************
   3  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   4  *                                                                        *
   5  * Author: The ALICE Off-line Project.                                    *
   6  * Contributors are mentioned in the code where appropriate.              *
   7  *                                                                        *
   8  * Permission to use, copy, modify and distribute this software and its   *
   9  * documentation strictly for non-commercial purposes is hereby granted   *
  10  * without fee, provided that the above copyright notice appears in all   *
  11  * copies and that both the copyright notice and this permission notice   *
  12  * appear in the supporting documentation. The authors make no claims     *
  13  * about the suitability of this software for any purpose. It is          *
  14  * provided "as is" without express or implied warranty.                  *
  15  **************************************************************************/
  16
  17 /////////////////////////////////////////////////////////////////////////////////
  18 //
  19 // AliTRDCalibTask
  20 //
  21 // Offline TRD calibration task
  22 //
  23 // Author:
  24 //   R. Bailhache (R.Bailhache@gsi.de)
  25 //
  26 //////////////////////////////////////////////////////////////////////////////////////
  27
  28 #include <iostream>
  29 using namespace std;
  30 #include "Riostream.h"
  31 #include "TChain.h"
  32 #include "TTree.h"
  33 #include "TFile.h"
  34 #include "TProfile2D.h"
  35 #include "TH2I.h"
  36 #include "TH1F.h"
  37 #include "TH2F.h"
  38 #include "TList.h"
  39 #include "TMath.h"
  40 #include "TObject.h"
  41 #include "TObjArray.h"
  42 #include "TString.h"
  43 #include "TCanvas.h"
  44 #include "TLegend.h"
  45 #include "TStyle.h"
  46 #include "TLine.h"
  47 #include "TIterator.h"
  48
  49 #include "AliAnalysisTask.h"
  50 #include "AliAnalysisManager.h"
  51
  52 #include "AliExternalTrackParam.h"
  53 #include "AliESDVertex.h"
  54 #include "AliESDEvent.h"
  55 #include "AliESDfriend.h"
  56 #include "AliCentrality.h"
  57 #include "AliESDInputHandler.h"
  58 #include "AliESDtrack.h"
  59 #include "AliESDfriendTrack.h"
  60 #include "AliTRDtrackV1.h"
  61 #include "AliTRDseedV1.h"
  62 #include "AliTRDcluster.h"
  63 #include "AliTRDgeometry.h"
  64 #include "AliESDtrackCuts.h"
  65 #include "AliESDVertex.h"
  66 #include "AliTRDCalDet.h"
  67
  68 #include "AliTRDCalibraVector.h"
  69 #include "AliTRDCalibraFillHisto.h"
  70 #include "AliTRDCalibraVdriftLinearFit.h"
  71
  72 #include "AliTRDcalibDB.h"
  73 #include "AliCDBId.h"
  74 #include "AliLog.h"
  75
  76
  77 #include "AliTRDCalibTask.h"
  78
  79
  80 ClassImp(AliTRDCalibTask)
  81
  82 //________________________________________________________________________
  83   AliTRDCalibTask::AliTRDCalibTask(const char *name)
  84     : AliAnalysisTaskSE(name), fESD(0),
  85       fESDfriend(0),
  86       fkEsdTrack(0),
  87       fFriendTrack(0),
  88       fCalibObject(0),
  89       fTrdTrack(0),
  90       fCl(0),
  91       fListHist(0),
  92       fTRDCalibraFillHisto(0),
  93       fNEvents(0),
  94       fNbTRDTrack(0),
  95       fNbTRDTrackOffline(0),
  96       fNbTRDTrackStandalone(0),
  97       fNbTPCTRDtrack(0),
  98       fNbGoodTracks(0),
  99       fNbTimeBin(0),
 100       fNbTimeBinOffline(0),
 101       fNbTimeBinStandalone(0),
 102       fNbClusters(0),
 103       fNbClustersOffline(0),
 104       fNbClustersStandalone(0),
 105       fNbTracklets(0),
 106       fNbTrackletsOffline(0),
 107       fNbTrackletsStandalone(0),
 108       fAbsoluteGain(0),
 109       fCH2dSum(0),
 110       fPH2dSum(0),
 111       fCH2dSM(0),
 112       fPH2dSM(0),
 113       fHisto2d(kTRUE),
 114       fVector2d(kFALSE),
 115       fVdriftLinear(kTRUE),
 116       fNbTimeBins(0),
 117       fSelectedTrigger(new TObjArray()),
 118       fRejected(kTRUE),
 119       fEsdTrackCuts(0),
 120       fRequirePrimaryVertex(kFALSE),
 121       fVtxTPC(kFALSE),
 122       fVtxSPD(kFALSE),
 123       fMinNbContributors(0),
 124       fRangePrimaryVertexZ(9999999.0),
 125       fMinNbTracks(9),
 126       fMaxNbTracks(500),
 127       fLow(0),
 128       fHigh(30),
 129       fFillZero(kFALSE),
 130       fNormalizeNbOfCluster(kFALSE),
 131       fRelativeScale(0.0),
 132       fMaxCluster(100.0),
 133       fNbMaxCluster(2),
 134       fOfflineTracks(kFALSE),
 135       fStandaloneTracks(kFALSE),
 136       fVersionGainUsed(-1),
 137       fSubVersionGainUsed(-1),
 138       fVersionGainLocalUsed(-1),
 139       fSubVersionGainLocalUsed(-1),
 140       fVersionVdriftUsed(-1),
 141       fSubVersionVdriftUsed(-1),
 142       fCalDetGain(0x0),
 143       fMaxEvent(0),
 144       fCounter(0),
 145       fDebug(0)
 146 {
 147   //
 148   // Default constructor
 149   //
 150
 151   fNz[0] = 0;
 152   fNz[1] = 0;
 153   fNz[2] = 0;
 154
 155   fNrphi[0] = 0;
 156   fNrphi[1] = 0;
 157   fNrphi[2] = 0;
 158
 159   // Define input and output slots here
 160   // Input slot #0 works with a TChain
 161   DefineInput(0, TChain::Class());
 162
 163   // Output slot #0 writes into a TList container
 164   DefineOutput(1, TList::Class());
 165
 166
 167 }
 168 //____________________________________________________________________________________
 169 AliTRDCalibTask::~AliTRDCalibTask()
 170 {
 171   //
 172   // AliTRDCalibTask destructor
 173   //
 174
 175   // Pointeur
 176   if(fNEvents) delete fNEvents;
 177   if(fNbTRDTrack) delete fNbTRDTrack;
 178   if(fNbTRDTrackOffline) delete fNbTRDTrackOffline;
 179   if(fNbTRDTrackStandalone) delete fNbTRDTrackStandalone;
 180   if(fNbTPCTRDtrack) delete fNbTPCTRDtrack;
 181   if(fNbGoodTracks) delete fNbGoodTracks;
 182   if(fNbTimeBin) delete fNbTimeBin;
 183   if(fNbTimeBinOffline) delete fNbTimeBinOffline;
 184   if(fNbTimeBinStandalone) delete fNbTimeBinStandalone;
 185   if(fNbClusters) delete fNbClusters;
 186   if(fNbClustersOffline) delete fNbClustersOffline;
 187   if(fNbClustersStandalone) delete fNbClustersStandalone;
 188   if(fNbTracklets) delete fNbTracklets;
 189   if(fNbTrackletsOffline) delete fNbTrackletsOffline;
 190   if(fNbTrackletsStandalone) delete fNbTrackletsStandalone;
 191   if(fAbsoluteGain) delete fAbsoluteGain;
 192   if(fCH2dSum) delete fCH2dSum;
 193   if(fPH2dSum) delete fPH2dSum;
 194   if(fCH2dSM) delete fCH2dSM;
 195   if(fPH2dSM) delete fPH2dSM;
 196   if(fCalDetGain) delete fCalDetGain;
 197
 198   if(fSelectedTrigger) {
 199     fSelectedTrigger->Delete();
 200     delete fSelectedTrigger;
 201   }
 202   if(fEsdTrackCuts) {
 203     delete fEsdTrackCuts;
 204   }
 205
 206 }
 207
 208 //________________________________________________________________________
 209 void AliTRDCalibTask::UserCreateOutputObjects()
 210 {
 211   //
 212   // Create the histos
 213   //
 214   //cout << "AliTRDCalibTask::CreateOutputObjects() IN" << endl;
 215
 216   // Number of time bins
 217   if(fNbTimeBins==0) {
 218     AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
 219     fNbTimeBins = cal->GetNumberOfTimeBinsDCS();
 220     if(fNbTimeBins <= 0){
 221       AliWarning(Form("No of TimeBins from DB [%d] use default [30]", fNbTimeBins));
 222       fNbTimeBins = 30;
 223     }
 224   }
 225
 226   // instance calibration
 227   fTRDCalibraFillHisto = AliTRDCalibraFillHisto::Instance();
 228   fTRDCalibraFillHisto->SetHisto2d(fHisto2d); // choose to use histograms
 229   fTRDCalibraFillHisto->SetVector2d(fVector2d); // choose to use vectors
 230   fTRDCalibraFillHisto->SetCH2dOn();  // choose to calibrate the gain
 231   fTRDCalibraFillHisto->SetPH2dOn();  // choose to calibrate the drift velocity
 232   fTRDCalibraFillHisto->SetPRF2dOn(); // choose to look at the PRF
 233   fTRDCalibraFillHisto->SetLinearFitterOn(fVdriftLinear); // Other possibility vdrift VDRIFT
 234   fTRDCalibraFillHisto->SetLinearFitterDebugOn(fVdriftLinear); // Other possibility vdrift
 235   for(Int_t k = 0; k < 3; k++){
 236     if(((fNz[k] != 10) && (fNrphi[k] != 10)) && ((fNz[k] != 100) && (fNrphi[k] != 100))) {
 237       fTRDCalibraFillHisto->SetNz(k,fNz[k]);                                    // Mode calibration
 238       fTRDCalibraFillHisto->SetNrphi(k,fNrphi[k]);                             // Mode calibration
 239     }
 240     else {
 241       if((fNz[k] == 100) && (fNrphi[k] == 100))  {
 242         if(fVector2d) AliInfo("The mode all together is not supported by the vector method");
 243         fTRDCalibraFillHisto->SetAllTogether(k);
 244       }
 245       if((fNz[k] == 10) && (fNrphi[k] == 10))  {
 246         if(fVector2d) AliInfo("The mode per supermodule is not supported by the vector method");
 247         fTRDCalibraFillHisto->SetPerSuperModule(k);
 248       }
 249     }
 250   }
 251   // Variables for how to fill
 252   fTRDCalibraFillHisto->SetFillWithZero(fFillZero);
 253   fTRDCalibraFillHisto->SetNormalizeNbOfCluster(fNormalizeNbOfCluster);
 254   fTRDCalibraFillHisto->SetMaxCluster(fMaxCluster);
 255   fTRDCalibraFillHisto->SetNbMaxCluster(fNbMaxCluster);
 256
 257   // Init with 30 timebins
 258   fTRDCalibraFillHisto->Init2Dhistos(fNbTimeBins); // initialise the histos
 259   fTRDCalibraFillHisto->SetNumberClusters(fLow); // At least 11 clusters
 260   fTRDCalibraFillHisto->SetNumberClustersf(fHigh); // At least 11 clusters
 261   fRelativeScale = fTRDCalibraFillHisto->GetRelativeScale(); // Get the relative scale for the gain
 262
 263   // For testing only
 264   if(fDebug > 2) fTRDCalibraFillHisto->SetDebugLevel(1); //debug stuff
 265
 266   // output list
 267   fListHist = new TList();
 268   fListHist->SetOwner();
 269   if(fHisto2d) {
 270     fListHist->Add(fTRDCalibraFillHisto->GetCH2d());
 271     fListHist->Add(fTRDCalibraFillHisto->GetPH2d());
 272     fListHist->Add(fTRDCalibraFillHisto->GetPRF2d());
 273   }
 274   if(fVdriftLinear) fListHist->Add((TObject *) fTRDCalibraFillHisto->GetVdriftLinearFit());
 275   if(fVector2d) fListHist->Add((TObject *) fTRDCalibraFillHisto->GetCalibraVector()); //calibra vector
 276   fNEvents = new TH1I("NEvents","NEvents", 2, 0, 2);
 277   fListHist->Add(fNEvents);
 278
 279   // absolute gain calibration even without AliESDfriend
 280   Int_t nBinsPt = 25;
 281   Double_t minPt = 0.001;
 282   Double_t maxPt = 10.0;
 283
 284   Double_t *binLimLogPt = new Double_t[nBinsPt+1];
 285   Double_t *binLimPt    = new Double_t[nBinsPt+1];
 286   for(Int_t i=0; i<=nBinsPt; i++) binLimLogPt[i]=(Double_t)TMath::Log10(minPt) + (TMath::Log10(maxPt)-TMath::Log10(minPt))/nBinsPt*(Double_t)i ;
 287   for(Int_t i=0; i<=nBinsPt; i++) binLimPt[i]=(Double_t)TMath::Power(10,binLimLogPt[i]);
 288
 289   fAbsoluteGain = new TH2F("AbsoluteGain","AbsoluteGain", 200, 0.0, 700.0, nBinsPt, binLimPt);
 290   fAbsoluteGain->SetYTitle("Momentum at TRD");
 291   fAbsoluteGain->SetXTitle("charge deposit [a.u]");
 292   fAbsoluteGain->SetZTitle("counts");
 293   fAbsoluteGain->SetStats(0);
 294   fAbsoluteGain->Sumw2();
 295   fListHist->Add(fAbsoluteGain);
 296
 297
 298
 299   /////////////////////////////////////////
 300   // First debug level
 301   ///////////////////////////////////////
 302   if(fDebug > 0) {
 303
 304     // Standart with AliESDfriend
 305     fPH2dSM = new TProfile2D("PH2dSM","Nz10Nrphi10"
 306                             ,fNbTimeBins,-0.05,(Double_t)((fNbTimeBins-0.5)/10.0)
 307                            ,18,0,18);
 308     fPH2dSM->SetYTitle("Det/pad groups");
 309     fPH2dSM->SetXTitle("time [#mus]");
 310     fPH2dSM->SetZTitle("<PH> [a.u.]");
 311     fPH2dSM->SetStats(0);
 312     //
 313     fCH2dSM = new TH2I("CH2dSM","Nz10Nrphi10",50,0,300,18,0,18);
 314     fCH2dSM->SetYTitle("Det/pad groups");
 315     fCH2dSM->SetXTitle("charge deposit [a.u]");
 316     fCH2dSM->SetZTitle("counts");
 317     fCH2dSM->SetStats(0);
 318     fCH2dSM->Sumw2();
 319     //
 320     fPH2dSum = new TProfile2D("PH2dSum","Nz100Nrphi100"
 321                             ,fNbTimeBins,-0.05,(Double_t)((fNbTimeBins-0.5)/10.0)
 322                             ,1,0,1);
 323     fPH2dSum->SetYTitle("Det/pad groups");
 324     fPH2dSum->SetXTitle("time [#mus]");
 325     fPH2dSum->SetZTitle("<PH> [a.u.]");
 326     fPH2dSum->SetStats(0);
 327     //
 328     fCH2dSum = new TH2I("CH2dSum","Nz100Nrphi100",50,0,300,1,0,1);
 329     fCH2dSum->SetYTitle("Det/pad groups");
 330     fCH2dSum->SetXTitle("charge deposit [a.u]");
 331     fCH2dSum->SetZTitle("counts");
 332     fCH2dSum->SetStats(0);
 333     fCH2dSum->Sumw2();
 334     //
 335     fNbGoodTracks = new TH2F("NbGoodTracks","NbGoodTracks",500,0.0,2500.0,200,0.0,100.0);
 336     fNbGoodTracks->SetXTitle("Nb of good tracks");
 337     fNbGoodTracks->SetYTitle("Centrality");
 338     fNbGoodTracks->SetStats(0);
 339
 340
 341     // Add them
 342     fListHist->Add(fPH2dSM);
 343     fListHist->Add(fCH2dSM);
 344     fListHist->Add(fPH2dSum);
 345     fListHist->Add(fCH2dSum);
 346     fListHist->Add(fNbGoodTracks);
 347   }
 348
 349   /////////////////////////////////////////
 350   // Second debug level
 351   ///////////////////////////////////////
 352   if(fDebug > 1) {
 353
 354     fNbTRDTrack = new TH1F("TRDTrack","TRDTrack",50,0,50);
 355     fNbTRDTrack->Sumw2();
 356     fNbTRDTrackOffline = new TH1F("TRDTrackOffline","TRDTrackOffline",50,0,50);
 357     fNbTRDTrackOffline->Sumw2();
 358     fNbTRDTrackStandalone = new TH1F("TRDTrackStandalone","TRDTrackStandalone",50,0,50);
 359     fNbTRDTrackStandalone->Sumw2();
 360     fNbTPCTRDtrack = new TH2F("NbTPCTRDtrack","NbTPCTRDtrack",100,0,100,100,0,100);
 361     fNbTPCTRDtrack->Sumw2();
 362     //
 363     fNbTimeBin = new TH1F("NbTimeBin","NbTimeBin",35,0,35);
 364     fNbTimeBin->Sumw2();
 365     fNbTimeBinOffline = new TH1F("NbTimeBinOffline","NbTimeBinOffline",35,0,35);
 366     fNbTimeBinOffline->Sumw2();
 367     fNbTimeBinStandalone = new TH1F("NbTimeBinStandalone","NbTimeBinStandalone",35,0,35);
 368     fNbTimeBinStandalone->Sumw2();
 369     //
 370     fNbClusters = new TH1F("NbClusters","",35,0,35);
 371     fNbClusters->Sumw2();
 372     fNbClustersOffline = new TH1F("NbClustersOffline","",35,0,35);
 373     fNbClustersOffline->Sumw2();
 374     fNbClustersStandalone = new TH1F("NbClustersStandalone","",35,0,35);
 375     fNbClustersStandalone->Sumw2();
 376     //
 377     fNbTracklets = new TH1F("NbTracklets","NbTracklets",540,0.,540.);
 378     fNbTracklets->Sumw2();
 379     fNbTrackletsOffline = new TH1F("NbTrackletsOffline","NbTrackletsOffline",540,0.,540.);
 380     fNbTrackletsOffline->Sumw2();
 381     fNbTrackletsStandalone = new TH1F("NbTrackletsStandalone","NbTrackletsStandalone",540,0.,540.);
 382     fNbTrackletsStandalone->Sumw2();
 383
 384     fListHist->Add(fNbTRDTrack);
 385     fListHist->Add(fNbTRDTrackOffline);
 386     fListHist->Add(fNbTRDTrackStandalone);
 387     fListHist->Add(fNbTPCTRDtrack);
 388
 389     fListHist->Add(fNbTimeBin);
 390     fListHist->Add(fNbTimeBinOffline);
 391     fListHist->Add(fNbTimeBinStandalone);
 392     fListHist->Add(fNbClusters);
 393     fListHist->Add(fNbClustersOffline);
 394     fListHist->Add(fNbClustersStandalone);
 395     fListHist->Add(fNbTracklets);
 396     fListHist->Add(fNbTrackletsOffline);
 397     fListHist->Add(fNbTrackletsStandalone);
 398
 399   }
 400
 401   delete [] binLimLogPt;
 402   delete [] binLimPt;
 403
 404   //cout << "AliTRDCalibTask::UserCreateOutputObjects() OUT" << endl;
 405
 406 }
 407
 408 //________________________________________________________________________
 409 void AliTRDCalibTask::UserExec(Option_t *)
 410 {
 411   //
 412   // Filling of the histos
 413   //
 414   //cout << "AliTRDCalibTask::Exec() IN" << endl;
 415
 416   // Init Versions and subversions used
 417   if((fVersionGainUsed==-1) || (fSubVersionGainUsed==-1) || (fVersionGainLocalUsed==-1) || (fSubVersionGainLocalUsed==-1) || (fVersionVdriftUsed==-1) || (fSubVersionVdriftUsed==-1)) {
 418     if(!SetVersionSubversion()) {
 419       fVersionGainUsed=0;
 420       fSubVersionGainUsed=0;
 421       fVersionGainLocalUsed=0;
 422       fSubVersionGainLocalUsed=0;
 423       fVersionVdriftUsed=0;
 424       fSubVersionVdriftUsed=0;
 425     }
 426   }
 427   if(fCounter==0) {
 428     fTRDCalibraFillHisto->SetVersionGainUsed(fVersionGainUsed); // Gain Used
 429     fTRDCalibraFillHisto->SetSubVersionGainUsed(fSubVersionGainUsed); // Gain Used
 430     fTRDCalibraFillHisto->SetVersionGainLocalUsed(fVersionGainLocalUsed); // Gain Used
 431     fTRDCalibraFillHisto->SetSubVersionGainLocalUsed(fSubVersionGainLocalUsed); // Gain Used
 432     fTRDCalibraFillHisto->SetVersionVdriftUsed(fVersionVdriftUsed); // Vdrift Used
 433     fTRDCalibraFillHisto->SetSubVersionVdriftUsed(fSubVersionVdriftUsed); // Vdrift Used
 434     fTRDCalibraFillHisto->InitCalDet();
 435   }
 436
 437   //  AliLog::SetGlobalLogLevel(AliLog::kError);
 438   //  cout << "AliTRDCalibTask::Exec() 1" << endl;
 439   fESD = dynamic_cast<AliESDEvent*>(fInputEvent);
 440   if(!fESD){
 441     AliError("ESD Event missing");
 442     PostData(1, fListHist);
 443     return;
 444   }
 445
 446   const char* type = fESD->GetBeamType();
 447
 448
 449   //printf("Counter %d\n",fCounter);
 450
 451   fCounter++;
 452   //cout << "maxEvent = " << fMaxEvent << endl;
 453   //if(fCounter%100==0) cout << "fCounter = " << fCounter << endl;
 454   if((fMaxEvent != 0) && (fMaxEvent < fCounter)) {
 455     PostData(1, fListHist);
 456     return;
 457   }
 458   //if(fCounter%100==0) cout << "fCounter1 = " << fCounter << endl;
 459   //cout << "event = " << fCounter << endl;
 460
 461   //printf("Counter %d\n",fCounter);
 462
 463   ///////////////////
 464   // Check trigger
 465   ///////////////////
 466   Bool_t pass = kTRUE;
 467
 468   if (strstr(type,"p-p")) {
 469
 470     //printf("Will check the triggers\n");
 471
 472     Int_t numberOfTriggerSelected = fSelectedTrigger->GetEntriesFast();
 473     //printf("numberofTriggerSelected %d\n",numberOfTriggerSelected);
 474     if(fRejected) {
 475       pass = kTRUE;
 476       for(Int_t k = 0; k < numberOfTriggerSelected; k++){
 477         const TObjString *const obString=(TObjString*)fSelectedTrigger->At(k);
 478         const TString tString=obString->GetString();
 479         if(fESD->IsTriggerClassFired((const char*)tString)) {
 480           pass = kFALSE;
 481         }
 482       }
 483     }
 484     else {
 485       pass = kFALSE;
 486       for(Int_t k = 0; k < numberOfTriggerSelected; k++){
 487         const TObjString *const obString=(TObjString*)fSelectedTrigger->At(k);
 488         const TString tString=obString->GetString();
 489         if(fESD->IsTriggerClassFired((const char*)tString)) {
 490           pass = kTRUE;
 491         }
 492       }
 493     }
 494     if(!pass) {
 495       PostData(1, fListHist);
 496       return;
 497     }
 498
 499   }
 500
 501   //printf("Class Fired %s\n",(const char*)fESD->GetFiredTriggerClasses());
 502   //printf("Trigger passed\n");
 503
 504   ///////////////////////////////
 505   // Require a primary vertex
 506   //////////////////////////////
 507   if(fRequirePrimaryVertex) {
 508     const AliESDVertex* vtxESD = 0x0;
 509     if      (fVtxTPC) vtxESD = fESD->GetPrimaryVertexTPC() ;
 510     else if (fVtxSPD) vtxESD = fESD->GetPrimaryVertexSPD() ;
 511     else              vtxESD = fESD->GetPrimaryVertexTracks() ;
 512     if(!vtxESD){
 513       PostData(1, fListHist);
 514       return;
 515     }
 516     Int_t nCtrb = vtxESD->GetNContributors();
 517     if(nCtrb < fMinNbContributors) {
 518       PostData(1, fListHist);
 519       return;
 520     }
 521     Double_t zPosition = vtxESD->GetZ();
 522     if(TMath::Abs(zPosition) > fRangePrimaryVertexZ) {
 523       PostData(1, fListHist);
 524       return;
 525     }
 526
 527   }
 528
 529   //printf("Primary vertex passed\n");
 530
 531   //////////////////////////////////////
 532   // Requirement on number of good tracks
 533   //////////////////////////////////////
 534   Int_t nGoodParticles = 0;
 535   Double_t nbTracks = fESD->GetNumberOfTracks();
 536   for(Int_t itrack = 0; itrack < nbTracks; itrack++) {
 537     if(ParticleGood(itrack)) nGoodParticles++;
 538   }
 539   if(fDebug > 0)  {
 540     // Centrality
 541     AliCentrality *esdCentrality = fESD->GetCentrality();
 542     Float_t centrality = esdCentrality->GetCentralityPercentile("V0M");
 543     //Float_t centralityb = esdCentrality->GetCentralityPercentile("CL1");
 544     fNbGoodTracks->Fill(nGoodParticles,centrality);
 545     //printf("centrality %f, centralityb %f\n",centrality,centralityb);
 546   }
 547
 548   if (strstr(type,"Pb-Pb")) {
 549     //printf("Will check the number of good tracks\n");
 550     if((nGoodParticles < fMinNbTracks) || (nGoodParticles > fMaxNbTracks)) {
 551       PostData(1, fListHist);
 552       return;
 553     }
 554   }
 555
 556   fNEvents->Fill(1);
 557
 558   // In total
 559   Int_t nbTrdTracks = 0;
 560   // standalone
 561   Int_t nbTrdTracksStandalone = 0;
 562   // offline
 563   Int_t nbTrdTracksOffline = 0;
 564   // TPC
 565   Int_t nbtrackTPC = 0;
 566
 567
 568
 569   if (nbTracks <= 0.0) {
 570
 571     if(fDebug > 1) {
 572       fNbTRDTrack->Fill(nbTrdTracks);
 573       fNbTRDTrackStandalone->Fill(nbTrdTracksStandalone);
 574       fNbTRDTrackOffline->Fill(nbTrdTracksOffline);
 575     }
 576     PostData(1, fListHist);
 577     return;
 578   }
 579
 580
 581   fESDfriend = dynamic_cast<AliESDfriend*> (fESD->FindListObject("AliESDfriend"));
 582   if(!fESDfriend){
 583     AliError("fESDfriend not available");
 584     PostData(1, fListHist);
 585     return;
 586   }
 587
 588   //printf("has friends\n");
 589
 590   /*
 591   ////////////////////////////////////
 592    // Check the number of TPC tracks
 593    ///////////////////////////////////
 594    //printf("Nb of tracks %f\n",nbTracks);
 595    for(Int_t itrk = 0; itrk < nbTracks; itrk++){
 596      // Get ESD track
 597      fkEsdTrack = fESD->GetTrack(itrk);
 598      ULong_t status = fkEsdTrack->GetStatus();
 599      if(status&(AliESDtrack::kTPCout)) nbtrackTPC++;
 600      if((status&(AliESDtrack::kTRDout)) && (!(status&(AliESDtrack::kTRDin)))) {
 601        nbTrdTracks++;
 602        nbTrdTracksStandalone++;
 603      }
 604      if((status&(AliESDtrack::kTRDin))) {
 605        nbTrdTracks++;
 606        nbTrdTracksOffline++;
 607      }
 608    }
 609
 610    if((nbtrackTPC>0) && (nbTrdTracks > (3.0*nbtrackTPC))) pass = kFALSE;
 611
 612    if(fDebug > 1) {
 613
 614      fNbTRDTrack->Fill(nbTrdTracks);
 615      fNbTRDTrackStandalone->Fill(nbTrdTracksStandalone);
 616      fNbTRDTrackOffline->Fill(nbTrdTracksOffline);
 617      fNbTPCTRDtrack->Fill(nbTrdTracks,nbtrackTPC);
 618
 619    }
 620
 621    if(!pass) {
 622      PostData(1, fListHist);
 623      return;
 624    }
 625   */
 626
 627   /////////////////////////////////////
 628   // Loop on AliESDtrack
 629   ////////////////////////////////////
 630   //printf("Nb of tracks %f\n",nbTracks);
 631   for(int itrk=0; itrk < nbTracks; ++itrk){
 632
 633     // Get ESD track
 634     fkEsdTrack = fESD->GetTrack(itrk);
 635     if(!fkEsdTrack) continue;
 636     ULong_t status = fkEsdTrack->GetStatus();
 637     if(status&(AliESDtrack::kTPCout)) ++nbtrackTPC;
 638
 639     // Quality cuts on the AliESDtrack
 640     if((fEsdTrackCuts) && (!fEsdTrackCuts->IsSelected((AliVParticle *)fkEsdTrack))) {
 641       //printf("Not a good track\n");
 642       continue;
 643     }
 644
 645     // First Absolute gain calibration
 646     Int_t trdNTracklets = (Int_t) fkEsdTrack->GetTRDntracklets();
 647     Int_t trdNTrackletsPID = (Int_t) fkEsdTrack->GetTRDntrackletsPID();
 648     if((trdNTracklets > 0) && (trdNTrackletsPID > 0)) {
 649       for(Int_t iPlane = 0; iPlane < 6; ++iPlane){
 650         //Double_t slide = fkEsdTrack->GetTRDslice(iPlane);
 651         //printf("Number of slide %d\n",fkEsdTrack->GetNumberOfTRDslices());
 652         //Double_t momentum = fkEsdTrack->GetTRDmomentum(iPlane);
 653         //printf("momentum %f, slide %f\n",momentum,slide);
 654         if(fkEsdTrack->GetTRDslice(iPlane) > 0.0)
 655           fAbsoluteGain->Fill(fkEsdTrack->GetTRDslice(iPlane)*8.0/100.0,
 656                               fkEsdTrack->GetTRDmomentum(iPlane));
 657       }
 658     }
 659
 660     // Other cuts
 661     Bool_t good = kTRUE;
 662     Bool_t standalonetrack = kFALSE;
 663     Bool_t offlinetrack = kFALSE;
 664     //ULong_t status = fkEsdTrack->GetStatus();
 665
 666     fFriendTrack = fESDfriend->GetTrack(itrk);
 667     if(!fFriendTrack)  {
 668       //printf("No friend track %d\n",itrk);
 669       continue;
 670     }
 671     //////////////////////////////////////
 672     // Loop on calibration objects
 673     //////////////////////////////////////
 674     Int_t icalib=0;
 675     Int_t nTRDtrackV1=0;
 676     while((fCalibObject = (TObject *)(fFriendTrack->GetCalibObject(icalib++)))){
 677       //printf("Name %s\n",fCalibObject->IsA()->GetName());
 678       if(strcmp(fCalibObject->IsA()->GetName(), "AliTRDtrackV1") != 0) continue;
 679       //printf("Find the calibration object\n");
 680       ++nTRDtrackV1;
 681
 682       if((status&(AliESDtrack::kTRDout)) && (!(status&(AliESDtrack::kTRDin)))) {
 683         standalonetrack = kTRUE;
 684       }
 685       if((status&(AliESDtrack::kTRDin))) {
 686         offlinetrack = kTRUE;
 687       }
 688       if(fOfflineTracks){
 689         if(!offlinetrack){
 690           good = kFALSE;
 691         }
 692       }
 693       else if(fStandaloneTracks){
 694         if(!standalonetrack){
 695           good = kFALSE;
 696         }
 697       }
 698
 699       fTrdTrack = (AliTRDtrackV1 *)fCalibObject;
 700       if(good) {
 701         //cout << "good" << endl;
 702         fTRDCalibraFillHisto->UpdateHistogramsV1(fTrdTrack);
 703         //printf("Fill fTRDCalibraFillHisto\n");
 704       }
 705
 706       //////////////////////////////////
 707       // Debug
 708       ////////////////////////////////
 709
 710       if(fDebug > 0) {
 711
 712         //printf("Enter debug\n");
 713
 714         Int_t nbtracklets = 0;
 715
 716         // Check some stuff
 717         Bool_t standalonetracklet = kFALSE;
 718         const AliTRDseedV1 *tracklet = 0x0;
 719         //////////////////////////////////////
 720         // Loop tracklets
 721         /////////////////////////////////////
 722         Int_t nbclusters=0;
 723         Double_t phtb[AliTRDseedV1::kNtb];
 724         memset(phtb, 0, AliTRDseedV1::kNtb*sizeof(Double_t));
 725         Double_t sum = 0.0;
 726         Float_t normalisation = 6.67;
 727         Int_t detector = 0;
 728         Int_t sector = 0;
 729         for(Int_t itr = 0; itr < 6; ++itr){
 730
 731           if(!(tracklet = fTrdTrack->GetTracklet(itr))) continue;
 732           if(!tracklet->IsOK()) continue;
 733           ++nbtracklets;
 734           standalonetracklet = kFALSE;
 735           if(tracklet->IsStandAlone()) standalonetracklet = kTRUE;
 736
 737           nbclusters = 0;
 738           memset(phtb, 0, AliTRDseedV1::kNtb*sizeof(Double_t));
 739           sum = 0.0;
 740           detector = 0;
 741           sector = 0;
 742           //Int_t crossrow = 0;
 743
 744           // Check no shared clusters
 745           //for(int icc=AliTRDseedV1::kNtb; icc<AliTRDseedV1::kNclusters; icc++){
 746           //  if((fcl = tracklet->GetClusters(icc)))  crossrow = 1;
 747           // }
 748
 749           // Loop on clusters
 750           Int_t time = 0;
 751           Float_t ch = 0;
 752           Float_t qcl = 0;
 753           for(int ic=0; ic<AliTRDseedV1::kNtb; ++ic){
 754
 755             if(!(fCl = tracklet->GetClusters(ic))) continue;
 756             ++nbclusters;
 757             time = fCl->GetPadTime();
 758             ch =  tracklet->GetdQdl(ic);
 759             qcl = TMath::Abs(fCl->GetQ());
 760             detector = fCl->GetDetector();
 761             // Add the charge if shared cluster
 762             if((ic+AliTRDseedV1::kNtb) < AliTRDseedV1::kNclusters) {
 763               if((fCl = tracklet->GetClusters(ic+AliTRDseedV1::kNtb))) {
 764                 qcl += TMath::Abs(fCl->GetQ());
 765                 //printf("Add the cluster charge\n");
 766               }
 767             }
 768             if((time>-1) && (time<fNbTimeBins)) phtb[time]=qcl;
 769             if((fCalDetGain) && (fCalDetGain->GetValue(detector) > 0.0)) sum += ch*fCalDetGain->GetValue(detector)/normalisation;
 770             else sum += ch/normalisation;
 771
 772             if(fDebug > 1) {
 773               fNbTimeBin->Fill(time);
 774               if(tracklet->IsStandAlone()) fNbTimeBinStandalone->Fill(time);
 775               else fNbTimeBinOffline->Fill(time);
 776             }
 777           }
 778           sector = AliTRDgeometry::GetSector(detector);
 779
 780           if(fDebug > 1) {
 781             fNbTracklets->Fill(detector);
 782             if(tracklet->IsStandAlone()) fNbTrackletsStandalone->Fill(detector);
 783             else fNbTrackletsOffline->Fill(detector);
 784
 785             fNbClusters->Fill(nbclusters);
 786             if(tracklet->IsStandAlone())  fNbClustersStandalone->Fill(nbclusters);
 787             else  fNbClustersOffline->Fill(nbclusters);
 788           }
 789
 790           if(fDebug > 0) {
 791             if((nbclusters > fLow) && (nbclusters < fHigh)){
 792               if(fRelativeScale > 0.0) sum = sum/fRelativeScale;
 793               fCH2dSM->Fill(sum,sector+0.5);
 794               fCH2dSum->Fill(sum,0.5);
 795               Bool_t checknoise = kTRUE;
 796               if(fMaxCluster > 0) {
 797                 if(phtb[0] > fMaxCluster) checknoise = kFALSE;
 798                 if(fNbTimeBins > fNbMaxCluster) {
 799                   for(Int_t k = (fNbTimeBins-fNbMaxCluster); k < fNbTimeBins; k++){
 800                     if(phtb[k] > fMaxCluster) checknoise = kFALSE;
 801                   }
 802                 }
 803               }
 804               if(checknoise) {
 805                 for(int ic=0; ic<fNbTimeBins; ic++){
 806                   if(fFillZero) {
 807                     fPH2dSum->Fill((Double_t)(ic/10.0),0.5,(Double_t)phtb[ic]);
 808                     fPH2dSM->Fill((Double_t)(ic/10.0),sector+0.5,(Double_t)phtb[ic]);
 809                   }
 810                   else {
 811                     if(phtb[ic] > 0.0) {
 812                       fPH2dSum->Fill((Double_t)(ic/10.0),0.0,(Double_t)phtb[ic]);
 813                       fPH2dSM->Fill((Double_t)(ic/10.0),sector+0.5,(Double_t)phtb[ic]);
 814                     }
 815                   }
 816                 }
 817               }
 818             }
 819           }
 820         } // loop on tracklets
 821
 822       } // debug
 823
 824     }// while calibration objects
 825     if(nTRDtrackV1 > 0) {
 826       ++nbTrdTracks;
 827       if((status&(AliESDtrack::kTRDout)) && (!(status&(AliESDtrack::kTRDin)))) {
 828         ++nbTrdTracksStandalone;
 829       }
 830       if((status&(AliESDtrack::kTRDin))) {
 831         ++nbTrdTracksOffline;
 832       }
 833     }
 834     //delete fFriendTrack;
 835   } // loop ESD track
 836
 837   if(fDebug > 1) {
 838     fNbTRDTrack->Fill(nbTrdTracks);
 839     fNbTRDTrackStandalone->Fill(nbTrdTracksStandalone);
 840     fNbTRDTrackOffline->Fill(nbTrdTracksOffline);
 841     fNbTPCTRDtrack->Fill(nbTrdTracks,nbtrackTPC);
 842   }
 843
 844   // Post output data
 845   PostData(1, fListHist);
 846   //cout << "AliTRDCalibTask::Exec() OUT" << endl;
 847 }
 848
 849 //________________________________________________________________________
 850 void AliTRDCalibTask::Terminate(Option_t *)
 851 {
 852   //
 853   // Terminate
 854   //
 855
 856   if(fTRDCalibraFillHisto) fTRDCalibraFillHisto->DestroyDebugStreamer();
 857
 858
 859 }
 860 //_______________________________________________________
 861 Bool_t AliTRDCalibTask::Load(const Char_t *filename)
 862 {
 863   //
 864   // Generic container loader
 865   //
 866
 867   if(!TFile::Open(filename)){
 868     //AliWarning(Form("Couldn't open file %s.", filename));
 869     return kFALSE;
 870   }
 871   TList *o = 0x0;
 872   if(!(o = (TList*)gFile->Get(GetName()))){
 873     //AliWarning("Missing histogram container.");
 874     return kFALSE;
 875   }
 876   fListHist = (TList*)o->Clone(GetName());
 877   gFile->Close();
 878   return kTRUE;
 879 }
 880 //_______________________________________________________
 881 Bool_t AliTRDCalibTask::Load(TList *lister)
 882 {
 883   //
 884   // Generic container loader
 885   //
 886
 887   fListHist = (TList*)lister->Clone(GetName());
 888   return kTRUE;
 889 }
 890 //________________________________________________________________________
 891 void AliTRDCalibTask::Plot()
 892 {
 893   //
 894   // Plot the histos stored in the TList
 895   //
 896
 897   if(!fListHist) return;
 898
 899   /////////////////////////////////////
 900   // Take the debug stuff
 901   /////////////////////////////////////
 902
 903   TH1I *nEvents  = (TH1I *) fListHist->FindObject("NEvents");
 904
 905   TH2F *absoluteGain  = (TH2F *) fListHist->FindObject("AbsoluteGain");
 906
 907   TH1F *trdTrack = (TH1F *) fListHist->FindObject("TRDTrack");
 908   TH1F *trdTrackOffline = (TH1F *) fListHist->FindObject("TRDTrackOffline");
 909   TH1F *trdTrackStandalone = (TH1F *) fListHist->FindObject("TRDTrackStandalone");
 910
 911   TH2F *tpctrdTrack = (TH2F *) fListHist->FindObject("NbTPCTRDtrack");
 912
 913   TH1F *nbTimeBin = (TH1F *) fListHist->FindObject("NbTimeBin");
 914   TH1F *nbTimeBinOffline = (TH1F *) fListHist->FindObject("NbTimeBinOffline");
 915   TH1F *nbTimeBinStandalone = (TH1F *) fListHist->FindObject("NbTimeBinStandalone");
 916
 917   TH1F *nbClusters = (TH1F *) fListHist->FindObject("NbClusters");
 918   TH1F *nbClustersOffline = (TH1F *) fListHist->FindObject("NbClustersOffline");
 919   TH1F *nbClustersStandalone = (TH1F *) fListHist->FindObject("NbClustersStandalone");
 920
 921   TH1F *nbTracklets = (TH1F *) fListHist->FindObject("NbTracklets");
 922   TH1F *nbTrackletsOffline = (TH1F *) fListHist->FindObject("NbTrackletsOffline");
 923   TH1F *nbTrackletsStandalone = (TH1F *) fListHist->FindObject("NbTrackletsStandalone");
 924
 925   /////////////////////////////////////
 926   // Take the calibration objects
 927   /////////////////////////////////////
 928
 929   TH2I *ch2d = (TH2I *) fListHist->FindObject("CH2d");
 930   TProfile2D *ph2d = (TProfile2D *) fListHist->FindObject("PH2d");
 931
 932   TH2I *ch2dSum = (TH2I *) fListHist->FindObject("CH2dSum");
 933   TProfile2D *ph2dSum = (TProfile2D *) fListHist->FindObject("PH2dSum");
 934
 935   TH2I *ch2dSM = (TH2I *) fListHist->FindObject("CH2dSM");
 936   TProfile2D *ph2dSM = (TProfile2D *) fListHist->FindObject("PH2dSM");
 937
 938   AliTRDCalibraVdriftLinearFit *linearfit = (AliTRDCalibraVdriftLinearFit *) fListHist->FindObject("AliTRDCalibraVdriftLinearFit");
 939
 940   ////////////////////////////////////////////////
 941   // Add the AliTRDCalibraVdriftLinearFit
 942   ///////////////////////////////////////////////
 943
 944   Int_t first = 0;
 945   TH2S *histolinearfitsum = 0x0;
 946
 947   if(linearfit) {
 948     for(Int_t det = 0; det < 540; det++) {
 949       if(linearfit->GetLinearFitterHisto(det)){
 950         if(TMath::Abs(first)<0.0001){
 951           histolinearfitsum = linearfit->GetLinearFitterHisto(det);
 952           first += 1;
 953         }
 954         else {
 955           if (histolinearfitsum) {
 956             histolinearfitsum->Add(linearfit->GetLinearFitterHisto(det));
 957           }
 958         }
 959       }
 960     }
 961   }
 962
 963   ///////////////////////////
 964   // Style
 965   //////////////////////////
 966
 967   gStyle->SetPalette(1);
 968   gStyle->SetOptStat(1111);
 969   gStyle->SetOptFit(1111);
 970   gStyle->SetPadBorderMode(0);
 971   gStyle->SetCanvasColor(10);
 972   gStyle->SetPadLeftMargin(0.13);
 973   gStyle->SetPadRightMargin(0.13);
 974
 975   /////////////////////////
 976   // Plot
 977   ////////////////////////
 978
 979  if(nEvents) {
 980
 981     TCanvas *debugEvents = new TCanvas("cNEvents","cNEvents",10,10,510,510);
 982     debugEvents->cd(1);
 983     if(nEvents) nEvents->Draw();
 984
 985   }
 986
 987  if(absoluteGain) {
 988
 989     TCanvas *debugAbsoluteGain = new TCanvas("cAbsoluteGain","cAbsoluteGain",10,10,510,510);
 990     debugAbsoluteGain->cd(1);
 991     if(absoluteGain) absoluteGain->Draw();
 992
 993   }
 994
 995   if(trdTrack || tpctrdTrack) {
 996
 997     TCanvas *debugtrdtpcTrack = new TCanvas("TRDtracktpctrdtrack","TRDtracktpctrdtrack",10,10,510,510);
 998     debugtrdtpcTrack->Divide(2,1);
 999     debugtrdtpcTrack->cd(1);
1000     if(trdTrack) trdTrack->Draw();
1001     if(trdTrackOffline) trdTrackOffline->Draw("same");
1002     if(trdTrackStandalone) trdTrackStandalone->Draw("same");
1003     TLegend *leg = new TLegend(0.4,0.6,0.89,0.89);
1004     if(trdTrack) leg->AddEntry(trdTrack,"All","p");
1005     if(trdTrackOffline) leg->AddEntry(trdTrackOffline,"Offline","p");
1006     if(trdTrackStandalone) leg->AddEntry(trdTrackStandalone,"Standalone","p");
1007     leg->Draw("same");
1008     debugtrdtpcTrack->cd(2);
1009     if(tpctrdTrack) tpctrdTrack->Draw();
1010     TLine *line = new TLine(0.0,0.0,100.0,100.0);
1011     line->Draw("same");
1012
1013   }
1014
1015   if(nbTimeBin || nbTracklets || nbClusters) {
1016
1017     TCanvas *debugTracklets = new TCanvas("TRDtimebintrackletcluster","TRDtimebintrackletcluster",10,10,510,510);
1018     debugTracklets->Divide(3,1);
1019     debugTracklets->cd(1);
1020     if(nbTimeBin) nbTimeBin->Draw();
1021     if(nbTimeBinOffline) nbTimeBinOffline->Draw("same");
1022     if(nbTimeBinStandalone) nbTimeBinStandalone->Draw("same");
1023     TLegend *lega = new TLegend(0.4,0.6,0.89,0.89);
1024     if(nbTimeBin) lega->AddEntry(nbTimeBin,"All","p");
1025     if(nbTimeBinOffline) lega->AddEntry(nbTimeBinOffline,"Offline","p");
1026     if(nbTimeBinStandalone) lega->AddEntry(nbTimeBinStandalone,"Standalone","p");
1027     lega->Draw("same");
1028     debugTracklets->cd(2);
1029     if(nbTracklets) nbTracklets->Draw();
1030     if(nbTrackletsOffline) nbTrackletsOffline->Draw("same");
1031     if(nbTrackletsStandalone) nbTrackletsStandalone->Draw("same");
1032     TLegend *legb = new TLegend(0.4,0.6,0.89,0.89);
1033     if(nbTracklets) legb->AddEntry(nbTracklets,"All","p");
1034     if(nbTrackletsOffline) legb->AddEntry(nbTrackletsOffline,"Offline","p");
1035     if(nbTrackletsStandalone) legb->AddEntry(nbTrackletsStandalone,"Standalone","p");
1036     legb->Draw("same");
1037     debugTracklets->cd(3);
1038     if(nbClusters) nbClusters->Draw();
1039     if(nbClustersOffline) nbClustersOffline->Draw("same");
1040     if(nbClustersStandalone) nbClustersStandalone->Draw("same");
1041     TLegend *legc = new TLegend(0.4,0.6,0.89,0.89);
1042     if(nbClusters) legc->AddEntry(nbClusters,"All","p");
1043     if(nbClustersOffline) legc->AddEntry(nbClustersOffline,"Offline","p");
1044     if(nbClustersStandalone) legc->AddEntry(nbClustersStandalone,"Standalone","p");
1045     legc->Draw("same");
1046
1047   }
1048
1049   if(ch2dSum || ph2dSum || histolinearfitsum) {
1050
1051     TCanvas *debugSum = new TCanvas("SumCalibrationObjects","SumCalibrationObjects",10,10,510,510);
1052     debugSum->Divide(3,1);
1053     debugSum->cd(1);
1054     if(ch2dSum) ch2dSum->Draw("lego");
1055     debugSum->cd(2);
1056     if(ph2dSum) ph2dSum->Draw("lego");
1057     debugSum->cd(3);
1058     if(histolinearfitsum) histolinearfitsum->Draw();
1059
1060   }
1061
1062   if(ch2dSM || ph2dSM) {
1063
1064     TCanvas *debugSM = new TCanvas("SMCalibrationObjects","SMCalibrationObjects",10,10,510,510);
1065     debugSM->Divide(2,1);
1066     debugSM->cd(1);
1067     if(ch2dSM) ch2dSM->Draw("lego");
1068     debugSM->cd(2);
1069     if(ph2dSM) ph2dSM->Draw("lego");
1070
1071   }
1072
1073   if(ch2d || ph2d) {
1074
1075     TCanvas *debug = new TCanvas("CalibrationObjects","CalibrationObjects",10,10,510,510);
1076     debug->Divide(2,1);
1077     debug->cd(1);
1078     if(ch2d) ch2d->Draw("lego");
1079     debug->cd(2);
1080     if(ph2d) ph2d->Draw("lego");
1081
1082   }
1083
1084 }
1085 //_______________________________________________________________________________________
1086 void  AliTRDCalibTask::AddTask(const AliTRDCalibTask * calibTask) {
1087
1088   //
1089   // Add stats
1090   //
1091
1092   TList *listcalibTask = calibTask->GetList();
1093   if(!listcalibTask) return;
1094
1095   TH1I *nEvents  = (TH1I *) listcalibTask->FindObject("NEvents");
1096   TH2F *absoluteGain  = (TH2F *) listcalibTask->FindObject("AbsoluteGain");
1097
1098   TH1F *trdTrack = (TH1F *) listcalibTask->FindObject("TRDTrack");
1099   TH1F *trdTrackOffline = (TH1F *) listcalibTask->FindObject("TRDTrackOffline");
1100   TH1F *trdTrackStandalone = (TH1F *) listcalibTask->FindObject("TRDTrackStandalone");
1101
1102   TH2F *tpctrdTrack = (TH2F *) listcalibTask->FindObject("NbTPCTRDtrack");
1103
1104   TH1F *nbTimeBin = (TH1F *) listcalibTask->FindObject("NbTimeBin");
1105   TH1F *nbTimeBinOffline = (TH1F *) listcalibTask->FindObject("NbTimeBinOffline");
1106   TH1F *nbTimeBinStandalone = (TH1F *) listcalibTask->FindObject("NbTimeBinStandalone");
1107
1108   TH1F *nbClusters = (TH1F *) listcalibTask->FindObject("NbClusters");
1109   TH1F *nbClustersOffline = (TH1F *) listcalibTask->FindObject("NbClustersOffline");
1110   TH1F *nbClustersStandalone = (TH1F *) listcalibTask->FindObject("NbClustersStandalone");
1111
1112   TH1F *nbTracklets = (TH1F *) listcalibTask->FindObject("NbTracklets");
1113   TH1F *nbTrackletsOffline = (TH1F *) listcalibTask->FindObject("NbTrackletsOffline");
1114   TH1F *nbTrackletsStandalone = (TH1F *) listcalibTask->FindObject("NbTrackletsStandalone");
1115
1116   TH2I *ch2d = (TH2I *) listcalibTask->FindObject("CH2d");
1117   TProfile2D *ph2d = (TProfile2D *) listcalibTask->FindObject("PH2d");
1118   TProfile2D *prf2d = (TProfile2D *) listcalibTask->FindObject("PRF2d");
1119
1120   TH2I *ch2dSum = (TH2I *) listcalibTask->FindObject("CH2dSum");
1121   TProfile2D *ph2dSum = (TProfile2D *) listcalibTask->FindObject("PH2dSum");
1122
1123   TH2I *ch2dSM = (TH2I *) listcalibTask->FindObject("CH2dSM");
1124   TProfile2D *ph2dSM = (TProfile2D *) listcalibTask->FindObject("PH2dSM");
1125
1126   AliTRDCalibraVdriftLinearFit *linearfit = (AliTRDCalibraVdriftLinearFit *) listcalibTask->FindObject("AliTRDCalibraVdriftLinearFit");
1127   AliTRDCalibraVector *calibraVector = (AliTRDCalibraVector *) listcalibTask->FindObject("AliTRDCalibraVector");
1128
1129   //
1130
1131   TH1I *inEvents  = (TH1I *) fListHist->FindObject("NEvents");
1132   TH2F *iabsoluteGain  = (TH2F *) fListHist->FindObject("AbsoluteGain");
1133
1134   TH1F *itrdTrack = (TH1F *) fListHist->FindObject("TRDTrack");
1135   TH1F *itrdTrackOffline = (TH1F *) fListHist->FindObject("TRDTrackOffline");
1136   TH1F *itrdTrackStandalone = (TH1F *) fListHist->FindObject("TRDTrackStandalone");
1137
1138   TH2F *itpctrdTrack = (TH2F *) fListHist->FindObject("NbTPCTRDtrack");
1139
1140   TH1F *inbTimeBin = (TH1F *) fListHist->FindObject("NbTimeBin");
1141   TH1F *inbTimeBinOffline = (TH1F *) fListHist->FindObject("NbTimeBinOffline");
1142   TH1F *inbTimeBinStandalone = (TH1F *) fListHist->FindObject("NbTimeBinStandalone");
1143
1144   TH1F *inbClusters = (TH1F *) fListHist->FindObject("NbClusters");
1145   TH1F *inbClustersOffline = (TH1F *) fListHist->FindObject("NbClustersOffline");
1146   TH1F *inbClustersStandalone = (TH1F *) fListHist->FindObject("NbClustersStandalone");
1147
1148   TH1F *inbTracklets = (TH1F *) fListHist->FindObject("NbTracklets");
1149   TH1F *inbTrackletsOffline = (TH1F *) fListHist->FindObject("NbTrackletsOffline");
1150   TH1F *inbTrackletsStandalone = (TH1F *) fListHist->FindObject("NbTrackletsStandalone");
1151
1152   TH2I *ich2d = (TH2I *) fListHist->FindObject("CH2d");
1153   TProfile2D *iph2d = (TProfile2D *) fListHist->FindObject("PH2d");
1154   TProfile2D *iprf2d = (TProfile2D *) fListHist->FindObject("PRF2d");
1155
1156   TH2I *ich2dSum = (TH2I *) fListHist->FindObject("CH2dSum");
1157   TProfile2D *iph2dSum = (TProfile2D *) fListHist->FindObject("PH2dSum");
1158
1159   TH2I *ich2dSM = (TH2I *) fListHist->FindObject("CH2dSM");
1160   TProfile2D *iph2dSM = (TProfile2D *) fListHist->FindObject("PH2dSM");
1161
1162   AliTRDCalibraVdriftLinearFit *ilinearfit = (AliTRDCalibraVdriftLinearFit *) fListHist->FindObject("AliTRDCalibraVdriftLinearFit");
1163   AliTRDCalibraVector *icalibraVector = (AliTRDCalibraVector *) fListHist->FindObject("AliTRDCalibraVector");
1164
1165
1166   // Add
1167
1168   if(nEvents) {
1169     if(inEvents) {
1170       inEvents->Add(nEvents);
1171       //printf("Add Events\n");
1172     }
1173     else {
1174       //printf("Create new Events\n");
1175       inEvents = new TH1I(*nEvents);
1176       fListHist->Add(inEvents);
1177     }
1178   }
1179
1180   if(absoluteGain) {
1181     if(iabsoluteGain) iabsoluteGain->Add(absoluteGain);
1182     else {
1183       iabsoluteGain = new TH2F(*absoluteGain);
1184       fListHist->Add(iabsoluteGain);
1185     }
1186   }
1187
1188   if(trdTrack) {
1189     if(itrdTrack) itrdTrack->Add(trdTrack);
1190     else {
1191      itrdTrack = new TH1F(*trdTrack);
1192      fListHist->Add(itrdTrack);
1193     }
1194   }
1195
1196   if(trdTrackOffline) {
1197     if(itrdTrackOffline) itrdTrackOffline->Add(trdTrackOffline);
1198     else {
1199       itrdTrackOffline = new TH1F(*trdTrackOffline);
1200       fListHist->Add(itrdTrackOffline);
1201     }
1202   }
1203
1204   if(trdTrackStandalone) {
1205     if(itrdTrackStandalone) itrdTrackStandalone->Add(trdTrackStandalone);
1206     else {
1207       itrdTrackStandalone = new TH1F(*trdTrackStandalone);
1208       fListHist->Add(itrdTrackStandalone);
1209     }
1210   }
1211
1212   if(tpctrdTrack) {
1213     if(itpctrdTrack) itpctrdTrack->Add(tpctrdTrack);
1214     else {
1215       itpctrdTrack = new TH2F(*tpctrdTrack);
1216       fListHist->Add(itpctrdTrack);
1217     }
1218   }
1219
1220   if(nbTimeBin) {
1221     if(inbTimeBin) inbTimeBin->Add(nbTimeBin);
1222     else {
1223       inbTimeBin = new TH1F(*inbTimeBin);
1224       fListHist->Add(inbTimeBin);
1225     }
1226   }
1227
1228   if(nbTimeBinOffline) {
1229     if(inbTimeBinOffline) inbTimeBinOffline->Add(nbTimeBinOffline);
1230     else {
1231       inbTimeBinOffline = new TH1F(*nbTimeBinOffline);
1232       fListHist->Add(inbTimeBinOffline);
1233     }
1234   }
1235
1236   if(nbTimeBinStandalone) {
1237     if(inbTimeBinStandalone) inbTimeBinStandalone->Add(nbTimeBinStandalone);
1238     else {
1239       inbTimeBinStandalone = new TH1F(*nbTimeBinStandalone);
1240       fListHist->Add(inbTimeBinStandalone);
1241     }
1242   }
1243
1244   if(nbClusters) {
1245     if(inbClusters) inbClusters->Add(nbClusters);
1246     else {
1247       inbClusters = new TH1F(*nbClusters);
1248       fListHist->Add(inbClusters);
1249     }
1250   }
1251
1252   if(nbClustersOffline) {
1253     if(inbClustersOffline) inbClustersOffline->Add(nbClustersOffline);
1254     else {
1255       inbClustersOffline = new TH1F(*nbClustersOffline);
1256       fListHist->Add(inbClustersOffline);
1257     }
1258   }
1259
1260   if(nbClustersStandalone) {
1261     if(inbClustersStandalone) inbClustersStandalone->Add(nbClustersStandalone);
1262     else {
1263       inbClustersStandalone = new TH1F(*nbClustersStandalone);
1264       fListHist->Add(inbClustersStandalone);
1265     }
1266   }
1267
1268   if(nbTracklets) {
1269     if(inbTracklets) inbTracklets->Add(nbTracklets);
1270     else {
1271       inbTracklets = new TH1F(*nbTracklets);
1272       fListHist->Add(inbTracklets);
1273     }
1274   }
1275
1276   if(nbTrackletsOffline) {
1277     if(inbTrackletsOffline) inbTrackletsOffline->Add(nbTrackletsOffline);
1278     else {
1279       inbTrackletsOffline = new TH1F(*nbTrackletsOffline);
1280       fListHist->Add(inbTrackletsOffline);
1281     }
1282   }
1283
1284   if(nbTrackletsStandalone) {
1285     if(inbTrackletsStandalone) inbTrackletsStandalone->Add(nbTrackletsStandalone);
1286     else {
1287       inbTrackletsStandalone = new TH1F(*nbTrackletsStandalone);
1288       fListHist->Add(inbTrackletsStandalone);
1289     }
1290   }
1291
1292   if(ch2d) {
1293     if(ich2d) ich2d->Add(ch2d);
1294     else {
1295       ich2d = new TH2I(*ch2d);
1296       fListHist->Add(ich2d);
1297     }
1298   }
1299
1300   if(ph2d) {
1301     if(iph2d) iph2d->Add(ph2d);
1302     else {
1303       iph2d = new TProfile2D(*ph2d);
1304       fListHist->Add(iph2d);
1305     }
1306   }
1307
1308   if(prf2d) {
1309     if(iprf2d) iprf2d->Add(prf2d);
1310     else {
1311       iprf2d = new TProfile2D(*prf2d);
1312       fListHist->Add(iprf2d);
1313     }
1314   }
1315
1316   if(ch2dSum) {
1317     if(ich2dSum) ich2dSum->Add(ch2dSum);
1318     else {
1319       ich2dSum = new TH2I(*ch2dSum);
1320       fListHist->Add(ich2dSum);
1321     }
1322   }
1323
1324   if(ph2dSum) {
1325     if(iph2dSum) iph2dSum->Add(ph2dSum);
1326     else {
1327       iph2dSum = new TProfile2D(*ph2dSum);
1328       fListHist->Add(iph2dSum);
1329     }
1330   }
1331
1332   if(ch2dSM) {
1333     if(ich2dSM) ich2dSM->Add(ch2dSM);
1334     else {
1335       ich2dSM = new TH2I(*ch2dSM);
1336       fListHist->Add(ich2dSM);
1337     }
1338   }
1339
1340   if(ph2dSM) {
1341     if(iph2dSM) iph2dSM->Add(ph2dSM);
1342     else {
1343       iph2dSM = new TProfile2D(*ph2dSM);
1344       fListHist->Add(iph2dSM);
1345     }
1346   }
1347
1348   if(linearfit) {
1349     if(ilinearfit) ilinearfit->Add(linearfit);
1350     else {
1351       ilinearfit = new AliTRDCalibraVdriftLinearFit(*linearfit);
1352       fListHist->Add(ilinearfit);
1353     }
1354   }
1355
1356   if(calibraVector) {
1357     if(icalibraVector) icalibraVector->Add(calibraVector);
1358     else {
1359       icalibraVector = new AliTRDCalibraVector(*calibraVector);
1360       fListHist->Add(icalibraVector);
1361     }
1362   }
1363
1364 }
1365 //________________________________________________________________________________
1366 Long64_t AliTRDCalibTask::Merge(TCollection *li) {
1367
1368   //
1369   // merge component
1370   //
1371
1372   TIterator* iter = li->MakeIterator();
1373   AliTRDCalibTask* cal = 0;
1374
1375   while ((cal = (AliTRDCalibTask*)iter->Next())) {
1376     if (!cal->InheritsFrom(AliTRDCalibTask::Class())) {
1377       Error("Merge","Attempt to add object of class %s to a %s", cal->ClassName(), this->ClassName());
1378       return -1;
1379     }
1380
1381     // add histograms here...
1382     this->AddTask(cal);
1383
1384   }
1385
1386   return 0;
1387
1388 }
1389 //_____________________________________________________
1390 Bool_t AliTRDCalibTask::SetVersionSubversion(){
1391   //
1392   // Load Chamber Gain factors into the Tender supply
1393   //
1394
1395   printf("SetVersionSubversion\n");
1396
1397   //find previous entry from the UserInfo
1398   TTree *tree=((TChain*)GetInputData(0))->GetTree();
1399   if (!tree) {
1400     AliError("Tree not found in ESDhandler");
1401     return kFALSE;
1402   }
1403
1404   TList *userInfo=(TList*)tree->GetUserInfo();
1405   if (!userInfo) {
1406     AliError("No UserInfo found in tree");
1407     return kFALSE;
1408   }
1409
1410   TList *cdbList=(TList*)userInfo->FindObject("cdbList");
1411   if (!cdbList) {
1412     AliError("No cdbList found in UserInfo");
1413     if (AliLog::GetGlobalLogLevel()>=AliLog::kError) userInfo->Print();
1414     return kFALSE;
1415   }
1416
1417   TIter nextCDB(cdbList);
1418   TObjString *os=0x0;
1419   while ( (os=(TObjString*)nextCDB()) ){
1420     if(os->GetString().Contains("TRD/Calib/ChamberGainFactor")){
1421       // Get Old gain calibration
1422       AliCDBId *id=AliCDBId::MakeFromString(os->GetString());
1423       fVersionGainUsed = id->GetVersion();
1424       fSubVersionGainUsed = id->GetSubVersion();
1425     } else if(os->GetString().Contains("TRD/Calib/ChamberVdrift")){
1426       // Get Old drift velocity calibration
1427       AliCDBId *id=AliCDBId::MakeFromString(os->GetString());
1428       fVersionVdriftUsed = id->GetVersion();
1429       fSubVersionVdriftUsed = id->GetSubVersion();
1430     } else if(os->GetString().Contains("TRD/Calib/LocalGainFactor")){
1431       // Get Old drift velocity calibration
1432       AliCDBId *id=AliCDBId::MakeFromString(os->GetString());
1433       fVersionGainLocalUsed = id->GetVersion();
1434       fSubVersionGainLocalUsed = id->GetSubVersion();
1435     }
1436   }
1437
1438   //printf("VersionGain %d, SubversionGain %d, VersionLocalGain %d, Subversionlocalgain %d, Versionvdrift %d, Subversionvdrift %d\n",fVersionGainUsed,fSubVersionGainUsed,fVersionGainLocalUsed,fSubVersionGainLocalUsed,fVersionVdriftUsed,fSubVersionVdriftUsed);
1439
1440   // Check
1441   if((fVersionGainUsed < 0) || (fVersionGainLocalUsed < 0)  || (fSubVersionGainUsed < 0) || (fSubVersionGainLocalUsed < 0) || (fVersionVdriftUsed < 0) || (fSubVersionVdriftUsed < 0)) {
1442     AliError("No recent calibration found");
1443     return kFALSE;
1444   }
1445   else return kTRUE;
1446
1447 }
1448 //_________________________________________________________________________________________________________________________
1449 Bool_t AliTRDCalibTask::ParticleGood(int i) const {
1450
1451   //
1452   // Definition of good tracks
1453   //
1454
1455
1456   AliESDtrack *track = fESD->GetTrack(i);
1457   if (!track->IsOn(AliESDtrack::kTPCrefit)) return 0;        // TPC refit
1458   if (track->GetTPCNcls() < 90) return 0;                    // number of TPC clusters
1459   if (fabs(track->Eta())>0.8) return 0;                         // fiducial pseudorapidity
1460   Float_t r,z;
1461   track->GetImpactParametersTPC(r,z);
1462   if (fabs(z)>2.0) return 0;                          // impact parameter in z
1463   if (fabs(r)>2.0) return 0;                          // impact parameter in xy
1464   if (r==0) return 0;
1465   return 1;
1466
1467
1468 }
1469
1470
1471