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