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   //cout << "AliTRDCalibTask::UserCreateOutputObjects() OUT" << endl;
 421 }
 422
 423
 424 //________________________________________________________________________
 425 void AliTRDCalibTask::UserExec(Option_t *)
 426 {
 427   //
 428   // Filling of the histos
 429   //
 430   //cout << "AliTRDCalibTask::Exec() IN" << endl;
 431
 432   // Init Versions and subversions used
 433   if((fVersionGainUsed==-1) || (fSubVersionGainUsed==-1) || (fVersionGainLocalUsed==-1) || (fSubVersionGainLocalUsed==-1) || (fVersionVdriftUsed==-1) || (fSubVersionVdriftUsed==-1)) {
 434     if(!SetVersionSubversion()) {
 435       fVersionGainUsed=0;
 436       fSubVersionGainUsed=0;
 437       fVersionGainLocalUsed=0;
 438       fSubVersionGainLocalUsed=0;
 439       fVersionVdriftUsed=0;
 440       fSubVersionVdriftUsed=0;
 441     }
 442   }
 443   if(fCounter==0) {
 444     fTRDCalibraFillHisto->SetVersionGainUsed(fVersionGainUsed); // Gain Used
 445     fTRDCalibraFillHisto->SetSubVersionGainUsed(fSubVersionGainUsed); // Gain Used
 446     fTRDCalibraFillHisto->SetVersionGainLocalUsed(fVersionGainLocalUsed); // Gain Used
 447     fTRDCalibraFillHisto->SetSubVersionGainLocalUsed(fSubVersionGainLocalUsed); // Gain Used
 448     fTRDCalibraFillHisto->SetVersionVdriftUsed(fVersionVdriftUsed); // Vdrift Used
 449     fTRDCalibraFillHisto->SetSubVersionVdriftUsed(fSubVersionVdriftUsed); // Vdrift Used
 450     fTRDCalibraFillHisto->InitCalDet();
 451   }
 452
 453   //  AliLog::SetGlobalLogLevel(AliLog::kError);
 454   //  cout << "AliTRDCalibTask::Exec() 1" << endl;
 455   fESD = dynamic_cast<AliESDEvent*>(fInputEvent);
 456   if(!fESD){
 457     AliError("ESD Event missing");
 458     PostData(1, fListHist);
 459     return;
 460   }
 461
 462   //printf("Counter %d\n",fCounter);
 463
 464   fCounter++;
 465   //cout << "maxEvent = " << fMaxEvent << endl;
 466   //if(fCounter%100==0) cout << "fCounter = " << fCounter << endl;
 467   if((fMaxEvent != 0) && (fMaxEvent < fCounter)) return;
 468   //if(fCounter%100==0) cout << "fCounter1 = " << fCounter << endl;
 469   //cout << "event = " << fCounter << endl;
 470
 471   //printf("Counter %d\n",fCounter);
 472
 473   ///////////////////
 474   // Check trigger
 475   ///////////////////
 476   Bool_t pass = kTRUE;
 477   Int_t numberOfTriggerSelected = fSelectedTrigger->GetEntriesFast();
 478   //printf("numberofTriggerSelected %d\n",numberOfTriggerSelected);
 479   if(fRejected) {
 480     pass = kTRUE;
 481     for(Int_t k = 0; k < numberOfTriggerSelected; k++){
 482       const TObjString *const obString=(TObjString*)fSelectedTrigger->At(k);
 483       const TString tString=obString->GetString();
 484       if(fESD->IsTriggerClassFired((const char*)tString)) {
 485         pass = kFALSE;
 486       }
 487     }
 488   }
 489   else {
 490     pass = kFALSE;
 491     for(Int_t k = 0; k < numberOfTriggerSelected; k++){
 492       const TObjString *const obString=(TObjString*)fSelectedTrigger->At(k);
 493       const TString tString=obString->GetString();
 494       if(fESD->IsTriggerClassFired((const char*)tString)) {
 495         pass = kTRUE;
 496       }
 497     }
 498   }
 499   if(!pass) {
 500     PostData(1, fListHist);
 501     return;
 502   }
 503   //printf("Class Fired %s\n",(const char*)fESD->GetFiredTriggerClasses());
 504   //printf("Trigger passed\n");
 505
 506   ///////////////////////////////
 507   // Require a primary vertex
 508   //////////////////////////////
 509   if(fRequirePrimaryVertex) {
 510     const AliESDVertex* vtxESD = 0x0;
 511     if      (fVtxTPC) vtxESD = fESD->GetPrimaryVertexTPC() ;
 512     else if (fVtxSPD) vtxESD = fESD->GetPrimaryVertexSPD() ;
 513     else              vtxESD = fESD->GetPrimaryVertexTracks() ;
 514     if(!vtxESD){
 515       PostData(1, fListHist);
 516       return;
 517     }
 518     Int_t nCtrb = vtxESD->GetNContributors();
 519     if(nCtrb < fMinNbContributors) {
 520       PostData(1, fListHist);
 521       return;
 522     }
 523     Double_t zPosition = vtxESD->GetZ();
 524     if(TMath::Abs(zPosition) > fRangePrimaryVertexZ) {
 525       PostData(1, fListHist);
 526       return;
 527     }
 528
 529   }
 530
 531   //printf("Primary vertex passed\n");
 532
 533   fNEvents->Fill(1);
 534
 535   // In total
 536   Int_t nbTrdTracks = 0;
 537   // standalone
 538   Int_t nbTrdTracksStandalone = 0;
 539   // offline
 540   Int_t nbTrdTracksOffline = 0;
 541   // TPC
 542   Int_t nbtrackTPC = 0;
 543
 544   Double_t nbTracks = fESD->GetNumberOfTracks();
 545   //printf("Number of tracks %f\n",nbTracks);
 546
 547   if (nbTracks <= 0.0) {
 548
 549     if(fDebug > 1) {
 550       fNbTRDTrack->Fill(nbTrdTracks);
 551       fNbTRDTrackStandalone->Fill(nbTrdTracksStandalone);
 552       fNbTRDTrackOffline->Fill(nbTrdTracksOffline);
 553     }
 554     PostData(1, fListHist);
 555     return;
 556   }
 557
 558
 559   fESDfriend = dynamic_cast<AliESDfriend*> (fESD->FindListObject("AliESDfriend"));
 560   if(!fESDfriend){
 561     AliError("fESDfriend not available");
 562     PostData(1, fListHist);
 563     return;
 564   }
 565
 566   //printf("has friends\n");
 567
 568   /*
 569   ////////////////////////////////////
 570    // Check the number of TPC tracks
 571    ///////////////////////////////////
 572    //printf("Nb of tracks %f\n",nbTracks);
 573    for(Int_t itrk = 0; itrk < nbTracks; itrk++){
 574      // Get ESD track
 575      fkEsdTrack = fESD->GetTrack(itrk);
 576      ULong_t status = fkEsdTrack->GetStatus();
 577      if(status&(AliESDtrack::kTPCout)) nbtrackTPC++;
 578      if((status&(AliESDtrack::kTRDout)) && (!(status&(AliESDtrack::kTRDin)))) {
 579        nbTrdTracks++;
 580        nbTrdTracksStandalone++;
 581      }
 582      if((status&(AliESDtrack::kTRDin))) {
 583        nbTrdTracks++;
 584        nbTrdTracksOffline++;
 585      }
 586    }
 587
 588    if((nbtrackTPC>0) && (nbTrdTracks > (3.0*nbtrackTPC))) pass = kFALSE;
 589
 590    if(fDebug > 1) {
 591
 592      fNbTRDTrack->Fill(nbTrdTracks);
 593      fNbTRDTrackStandalone->Fill(nbTrdTracksStandalone);
 594      fNbTRDTrackOffline->Fill(nbTrdTracksOffline);
 595      fNbTPCTRDtrack->Fill(nbTrdTracks,nbtrackTPC);
 596
 597    }
 598
 599    if(!pass) {
 600      PostData(1, fListHist);
 601      return;
 602    }
 603   */
 604
 605   /////////////////////////////////////
 606   // Loop on AliESDtrack
 607   ////////////////////////////////////
 608   //printf("Nb of tracks %f\n",nbTracks);
 609   for(int itrk=0; itrk < nbTracks; ++itrk){
 610
 611     // Get ESD track
 612     fkEsdTrack = fESD->GetTrack(itrk);
 613     if(!fkEsdTrack) continue;
 614     ULong_t status = fkEsdTrack->GetStatus();
 615     if(status&(AliESDtrack::kTPCout)) ++nbtrackTPC;
 616
 617     // Quality cuts on the AliESDtrack
 618     if((fEsdTrackCuts) && (!fEsdTrackCuts->IsSelected((AliVParticle *)fkEsdTrack))) {
 619       //printf("Not a good track\n");
 620       continue;
 621     }
 622
 623     // First Absolute gain calibration
 624     Int_t trdNTracklets = (Int_t) fkEsdTrack->GetTRDntracklets();
 625     Int_t trdNTrackletsPID = (Int_t) fkEsdTrack->GetTRDntrackletsPID();
 626     if((trdNTracklets > 0) && (trdNTrackletsPID > 0)) {
 627       for(Int_t iPlane = 0; iPlane < 6; ++iPlane){
 628         //Double_t slide = fkEsdTrack->GetTRDslice(iPlane);
 629         //printf("Number of slide %d\n",fkEsdTrack->GetNumberOfTRDslices());
 630         //Double_t momentum = fkEsdTrack->GetTRDmomentum(iPlane);
 631         //printf("momentum %f, slide %f\n",momentum,slide);
 632         if(fkEsdTrack->GetTRDslice(iPlane) > 0.0)
 633           fAbsoluteGain->Fill(fkEsdTrack->GetTRDslice(iPlane)*8.0/100.0,
 634                               fkEsdTrack->GetTRDmomentum(iPlane));
 635       }
 636     }
 637
 638     // Other cuts
 639     Bool_t good = kTRUE;
 640     Bool_t standalonetrack = kFALSE;
 641     Bool_t offlinetrack = kFALSE;
 642     //ULong_t status = fkEsdTrack->GetStatus();
 643
 644     fFriendTrack = fESDfriend->GetTrack(itrk);
 645     if(!fFriendTrack)  {
 646       //printf("No friend track %d\n",itrk);
 647       continue;
 648     }
 649     //////////////////////////////////////
 650     // Loop on calibration objects
 651     //////////////////////////////////////
 652     Int_t icalib=0;
 653     Int_t nTRDtrackV1=0;
 654     while((fCalibObject = (TObject *)(fFriendTrack->GetCalibObject(icalib++)))){
 655       //printf("Name %s\n",fCalibObject->IsA()->GetName());
 656       if(strcmp(fCalibObject->IsA()->GetName(), "AliTRDtrackV1") != 0) continue;
 657       //printf("Find the calibration object\n");
 658       ++nTRDtrackV1;
 659
 660       if((status&(AliESDtrack::kTRDout)) && (!(status&(AliESDtrack::kTRDin)))) {
 661         standalonetrack = kTRUE;
 662       }
 663       if((status&(AliESDtrack::kTRDin))) {
 664         offlinetrack = kTRUE;
 665       }
 666       if(fOfflineTracks){
 667         if(!offlinetrack){
 668           good = kFALSE;
 669         }
 670       }
 671       else if(fStandaloneTracks){
 672         if(!standalonetrack){
 673           good = kFALSE;
 674         }
 675       }
 676
 677       fTrdTrack = (AliTRDtrackV1 *)fCalibObject;
 678       if(good) {
 679         //cout << "good" << endl;
 680         fTRDCalibraFillHisto->UpdateHistogramsV1(fTrdTrack);
 681         //printf("Fill fTRDCalibraFillHisto\n");
 682       }
 683
 684       //////////////////////////////////
 685       // Debug
 686       ////////////////////////////////
 687
 688       if(fDebug > 0) {
 689
 690         //printf("Enter debug\n");
 691
 692         Int_t nbtracklets = 0;
 693
 694         // Check some stuff
 695         Bool_t standalonetracklet = kFALSE;
 696         const AliTRDseedV1 *tracklet = 0x0;
 697         //////////////////////////////////////
 698         // Loop tracklets
 699         /////////////////////////////////////
 700         Int_t nbclusters=0;
 701         Double_t phtb[AliTRDseedV1::kNtb];
 702         memset(phtb, 0, AliTRDseedV1::kNtb*sizeof(Double_t));
 703         Double_t sum = 0.0;
 704         Float_t normalisation = 6.67;
 705         Int_t detector = 0;
 706         Int_t sector = 0;
 707         for(Int_t itr = 0; itr < 6; ++itr){
 708
 709           if(!(tracklet = fTrdTrack->GetTracklet(itr))) continue;
 710           if(!tracklet->IsOK()) continue;
 711           ++nbtracklets;
 712           standalonetracklet = kFALSE;
 713           if(tracklet->IsStandAlone()) standalonetracklet = kTRUE;
 714
 715           nbclusters = 0;
 716           memset(phtb, 0, AliTRDseedV1::kNtb*sizeof(Double_t));
 717           sum = 0.0;
 718           detector = 0;
 719           sector = 0;
 720           //Int_t crossrow = 0;
 721
 722           // Check no shared clusters
 723           //for(int icc=AliTRDseedV1::kNtb; icc<AliTRDseedV1::kNclusters; icc++){
 724           //  if((fcl = tracklet->GetClusters(icc)))  crossrow = 1;
 725           // }
 726
 727           // Loop on clusters
 728           Int_t time = 0;
 729           Float_t ch = 0;
 730           Float_t qcl = 0;
 731           for(int ic=0; ic<AliTRDseedV1::kNtb; ++ic){
 732
 733             if(!(fCl = tracklet->GetClusters(ic))) continue;
 734             ++nbclusters;
 735             time = fCl->GetPadTime();
 736             ch =  tracklet->GetdQdl(ic);
 737             qcl = TMath::Abs(fCl->GetQ());
 738             detector = fCl->GetDetector();
 739             // Add the charge if shared cluster
 740             if((ic+AliTRDseedV1::kNtb) < AliTRDseedV1::kNclusters) {
 741               if((fCl = tracklet->GetClusters(ic+AliTRDseedV1::kNtb))) {
 742                 qcl += TMath::Abs(fCl->GetQ());
 743                 //printf("Add the cluster charge\n");
 744               }
 745             }
 746             if((time>-1) && (time<fNbTimeBins)) phtb[time]=qcl;
 747             if((fCalDetGain) && (fCalDetGain->GetValue(detector) > 0.0)) sum += ch*fCalDetGain->GetValue(detector)/normalisation;
 748             else sum += ch/normalisation;
 749
 750             if(fDebug > 1) {
 751               fNbTimeBin->Fill(time);
 752               if(tracklet->IsStandAlone()) fNbTimeBinStandalone->Fill(time);
 753               else fNbTimeBinOffline->Fill(time);
 754             }
 755           }
 756           sector = AliTRDgeometry::GetSector(detector);
 757
 758           if(fDebug > 1) {
 759             fNbTracklets->Fill(detector);
 760             if(tracklet->IsStandAlone()) fNbTrackletsStandalone->Fill(detector);
 761             else fNbTrackletsOffline->Fill(detector);
 762
 763             fNbClusters->Fill(nbclusters);
 764             if(tracklet->IsStandAlone())  fNbClustersStandalone->Fill(nbclusters);
 765             else  fNbClustersOffline->Fill(nbclusters);
 766           }
 767
 768           if(fDebug > 0) {
 769             if((nbclusters > fLow) && (nbclusters < fHigh)){
 770               if(fRelativeScale > 0.0) sum = sum/fRelativeScale;
 771               fCH2dSM->Fill(sum,sector+0.5);
 772               fCH2dSum->Fill(sum,0.5);
 773               Bool_t checknoise = kTRUE;
 774               if(fMaxCluster > 0) {
 775                 if(phtb[0] > fMaxCluster) checknoise = kFALSE;
 776                 if(fNbTimeBins > fNbMaxCluster) {
 777                   for(Int_t k = (fNbTimeBins-fNbMaxCluster); k < fNbTimeBins; k++){
 778                     if(phtb[k] > fMaxCluster) checknoise = kFALSE;
 779                   }
 780                 }
 781               }
 782               if(checknoise) {
 783                 for(int ic=0; ic<fNbTimeBins; ic++){
 784                   if(fFillZero) {
 785                     fPH2dSum->Fill((Double_t)(ic/10.0),0.5,(Double_t)phtb[ic]);
 786                     fPH2dSM->Fill((Double_t)(ic/10.0),sector+0.5,(Double_t)phtb[ic]);
 787                   }
 788                   else {
 789                     if(phtb[ic] > 0.0) {
 790                       fPH2dSum->Fill((Double_t)(ic/10.0),0.0,(Double_t)phtb[ic]);
 791                       fPH2dSM->Fill((Double_t)(ic/10.0),sector+0.5,(Double_t)phtb[ic]);
 792                     }
 793                   }
 794                 }
 795               }
 796             }
 797           }
 798         } // loop on tracklets
 799
 800       } // debug
 801
 802     }// while calibration objects
 803     if(nTRDtrackV1 > 0) {
 804       ++nbTrdTracks;
 805       if((status&(AliESDtrack::kTRDout)) && (!(status&(AliESDtrack::kTRDin)))) {
 806         ++nbTrdTracksStandalone;
 807       }
 808       if((status&(AliESDtrack::kTRDin))) {
 809         ++nbTrdTracksOffline;
 810       }
 811     }
 812     //delete fFriendTrack;
 813   } // loop ESD track
 814
 815   if(fDebug > 1) {
 816     fNbTRDTrack->Fill(nbTrdTracks);
 817     fNbTRDTrackStandalone->Fill(nbTrdTracksStandalone);
 818     fNbTRDTrackOffline->Fill(nbTrdTracksOffline);
 819     fNbTPCTRDtrack->Fill(nbTrdTracks,nbtrackTPC);
 820   }
 821
 822   // Post output data
 823   PostData(1, fListHist);
 824   //cout << "AliTRDCalibTask::Exec() OUT" << endl;
 825 }
 826
 827 //________________________________________________________________________
 828 void AliTRDCalibTask::Terminate(Option_t *)
 829 {
 830   //
 831   // Terminate
 832   //
 833
 834   if(fTRDCalibraFillHisto) fTRDCalibraFillHisto->DestroyDebugStreamer();
 835
 836
 837 }
 838 //_______________________________________________________
 839 Bool_t AliTRDCalibTask::Load(const Char_t *filename)
 840 {
 841   //
 842   // Generic container loader
 843   //
 844
 845   if(!TFile::Open(filename)){
 846     //AliWarning(Form("Couldn't open file %s.", filename));
 847     return kFALSE;
 848   }
 849   TList *o = 0x0;
 850   if(!(o = (TList*)gFile->Get(GetName()))){
 851     //AliWarning("Missing histogram container.");
 852     return kFALSE;
 853   }
 854   fListHist = (TList*)o->Clone(GetName());
 855   gFile->Close();
 856   return kTRUE;
 857 }
 858 //_______________________________________________________
 859 Bool_t AliTRDCalibTask::Load(TList *lister)
 860 {
 861   //
 862   // Generic container loader
 863   //
 864
 865   fListHist = (TList*)lister->Clone(GetName());
 866   return kTRUE;
 867 }
 868 //________________________________________________________________________
 869 void AliTRDCalibTask::Plot()
 870 {
 871   //
 872   // Plot the histos stored in the TList
 873   //
 874
 875   if(!fListHist) return;
 876
 877   /////////////////////////////////////
 878   // Take the debug stuff
 879   /////////////////////////////////////
 880
 881   TH1I *nEvents  = (TH1I *) fListHist->FindObject("NEvents");
 882
 883   TH2F *absoluteGain  = (TH2F *) fListHist->FindObject("AbsoluteGain");
 884
 885   TH1F *trdTrack = (TH1F *) fListHist->FindObject("TRDTrack");
 886   TH1F *trdTrackOffline = (TH1F *) fListHist->FindObject("TRDTrackOffline");
 887   TH1F *trdTrackStandalone = (TH1F *) fListHist->FindObject("TRDTrackStandalone");
 888
 889   TH2F *tpctrdTrack = (TH2F *) fListHist->FindObject("NbTPCTRDtrack");
 890
 891   TH1F *nbTimeBin = (TH1F *) fListHist->FindObject("NbTimeBin");
 892   TH1F *nbTimeBinOffline = (TH1F *) fListHist->FindObject("NbTimeBinOffline");
 893   TH1F *nbTimeBinStandalone = (TH1F *) fListHist->FindObject("NbTimeBinStandalone");
 894
 895   TH1F *nbClusters = (TH1F *) fListHist->FindObject("NbClusters");
 896   TH1F *nbClustersOffline = (TH1F *) fListHist->FindObject("NbClustersOffline");
 897   TH1F *nbClustersStandalone = (TH1F *) fListHist->FindObject("NbClustersStandalone");
 898
 899   TH1F *nbTracklets = (TH1F *) fListHist->FindObject("NbTracklets");
 900   TH1F *nbTrackletsOffline = (TH1F *) fListHist->FindObject("NbTrackletsOffline");
 901   TH1F *nbTrackletsStandalone = (TH1F *) fListHist->FindObject("NbTrackletsStandalone");
 902
 903   /////////////////////////////////////
 904   // Take the calibration objects
 905   /////////////////////////////////////
 906
 907   TH2I *ch2d = (TH2I *) fListHist->FindObject("CH2d");
 908   TProfile2D *ph2d = (TProfile2D *) fListHist->FindObject("PH2d");
 909
 910   TH2I *ch2dSum = (TH2I *) fListHist->FindObject("CH2dSum");
 911   TProfile2D *ph2dSum = (TProfile2D *) fListHist->FindObject("PH2dSum");
 912
 913   TH2I *ch2dSM = (TH2I *) fListHist->FindObject("CH2dSM");
 914   TProfile2D *ph2dSM = (TProfile2D *) fListHist->FindObject("PH2dSM");
 915
 916   AliTRDCalibraVdriftLinearFit *linearfit = (AliTRDCalibraVdriftLinearFit *) fListHist->FindObject("AliTRDCalibraVdriftLinearFit");
 917
 918   ////////////////////////////////////////////////
 919   // Add the AliTRDCalibraVdriftLinearFit
 920   ///////////////////////////////////////////////
 921
 922   Int_t first = 0;
 923   TH2S *histolinearfitsum = 0x0;
 924
 925   if(linearfit) {
 926     for(Int_t det = 0; det < 540; det++) {
 927       if(linearfit->GetLinearFitterHisto(det)){
 928         if(TMath::Abs(first)<0.0001){
 929           histolinearfitsum = linearfit->GetLinearFitterHisto(det);
 930           first += 1;
 931         }
 932         else {
 933           histolinearfitsum ->Add(linearfit->GetLinearFitterHisto(det));
 934         }
 935       }
 936     }
 937   }
 938
 939   ///////////////////////////
 940   // Style
 941   //////////////////////////
 942
 943   gStyle->SetPalette(1);
 944   gStyle->SetOptStat(1111);
 945   gStyle->SetOptFit(1111);
 946   gStyle->SetPadBorderMode(0);
 947   gStyle->SetCanvasColor(10);
 948   gStyle->SetPadLeftMargin(0.13);
 949   gStyle->SetPadRightMargin(0.13);
 950
 951   /////////////////////////
 952   // Plot
 953   ////////////////////////
 954
 955  if(nEvents) {
 956
 957     TCanvas *debugEvents = new TCanvas("cNEvents","cNEvents",10,10,510,510);
 958     debugEvents->cd(1);
 959     if(nEvents) nEvents->Draw();
 960
 961   }
 962
 963  if(absoluteGain) {
 964
 965     TCanvas *debugAbsoluteGain = new TCanvas("cAbsoluteGain","cAbsoluteGain",10,10,510,510);
 966     debugAbsoluteGain->cd(1);
 967     if(absoluteGain) absoluteGain->Draw();
 968
 969   }
 970
 971   if(trdTrack || tpctrdTrack) {
 972
 973     TCanvas *debugtrdtpcTrack = new TCanvas("TRDtracktpctrdtrack","TRDtracktpctrdtrack",10,10,510,510);
 974     debugtrdtpcTrack->Divide(2,1);
 975     debugtrdtpcTrack->cd(1);
 976     if(trdTrack) trdTrack->Draw();
 977     if(trdTrackOffline) trdTrackOffline->Draw("same");
 978     if(trdTrackStandalone) trdTrackStandalone->Draw("same");
 979     TLegend *leg = new TLegend(0.4,0.6,0.89,0.89);
 980     if(trdTrack) leg->AddEntry(trdTrack,"All","p");
 981     if(trdTrackOffline) leg->AddEntry(trdTrackOffline,"Offline","p");
 982     if(trdTrackStandalone) leg->AddEntry(trdTrackStandalone,"Standalone","p");
 983     leg->Draw("same");
 984     debugtrdtpcTrack->cd(2);
 985     if(tpctrdTrack) tpctrdTrack->Draw();
 986     TLine *line = new TLine(0.0,0.0,100.0,100.0);
 987     line->Draw("same");
 988
 989   }
 990
 991   if(nbTimeBin || nbTracklets || nbClusters) {
 992
 993     TCanvas *debugTracklets = new TCanvas("TRDtimebintrackletcluster","TRDtimebintrackletcluster",10,10,510,510);
 994     debugTracklets->Divide(3,1);
 995     debugTracklets->cd(1);
 996     if(nbTimeBin) nbTimeBin->Draw();
 997     if(nbTimeBinOffline) nbTimeBinOffline->Draw("same");
 998     if(nbTimeBinStandalone) nbTimeBinStandalone->Draw("same");
 999     TLegend *lega = new TLegend(0.4,0.6,0.89,0.89);
1000     if(nbTimeBin) lega->AddEntry(nbTimeBin,"All","p");
1001     if(nbTimeBinOffline) lega->AddEntry(nbTimeBinOffline,"Offline","p");
1002     if(nbTimeBinStandalone) lega->AddEntry(nbTimeBinStandalone,"Standalone","p");
1003     lega->Draw("same");
1004     debugTracklets->cd(2);
1005     if(nbTracklets) nbTracklets->Draw();
1006     if(nbTrackletsOffline) nbTrackletsOffline->Draw("same");
1007     if(nbTrackletsStandalone) nbTrackletsStandalone->Draw("same");
1008     TLegend *legb = new TLegend(0.4,0.6,0.89,0.89);
1009     if(nbTracklets) legb->AddEntry(nbTracklets,"All","p");
1010     if(nbTrackletsOffline) legb->AddEntry(nbTrackletsOffline,"Offline","p");
1011     if(nbTrackletsStandalone) legb->AddEntry(nbTrackletsStandalone,"Standalone","p");
1012     legb->Draw("same");
1013     debugTracklets->cd(3);
1014     if(nbClusters) nbClusters->Draw();
1015     if(nbClustersOffline) nbClustersOffline->Draw("same");
1016     if(nbClustersStandalone) nbClustersStandalone->Draw("same");
1017     TLegend *legc = new TLegend(0.4,0.6,0.89,0.89);
1018     if(nbClusters) legc->AddEntry(nbClusters,"All","p");
1019     if(nbClustersOffline) legc->AddEntry(nbClustersOffline,"Offline","p");
1020     if(nbClustersStandalone) legc->AddEntry(nbClustersStandalone,"Standalone","p");
1021     legc->Draw("same");
1022
1023   }
1024
1025   if(ch2dSum || ph2dSum || histolinearfitsum) {
1026
1027     TCanvas *debugSum = new TCanvas("SumCalibrationObjects","SumCalibrationObjects",10,10,510,510);
1028     debugSum->Divide(3,1);
1029     debugSum->cd(1);
1030     if(ch2dSum) ch2dSum->Draw("lego");
1031     debugSum->cd(2);
1032     if(ph2dSum) ph2dSum->Draw("lego");
1033     debugSum->cd(3);
1034     if(histolinearfitsum) histolinearfitsum->Draw();
1035
1036   }
1037
1038   if(ch2dSM || ph2dSM) {
1039
1040     TCanvas *debugSM = new TCanvas("SMCalibrationObjects","SMCalibrationObjects",10,10,510,510);
1041     debugSM->Divide(2,1);
1042     debugSM->cd(1);
1043     if(ch2dSM) ch2dSM->Draw("lego");
1044     debugSM->cd(2);
1045     if(ph2dSM) ph2dSM->Draw("lego");
1046
1047   }
1048
1049   if(ch2d || ph2d) {
1050
1051     TCanvas *debug = new TCanvas("CalibrationObjects","CalibrationObjects",10,10,510,510);
1052     debug->Divide(2,1);
1053     debug->cd(1);
1054     if(ch2d) ch2d->Draw("lego");
1055     debug->cd(2);
1056     if(ph2d) ph2d->Draw("lego");
1057
1058   }
1059
1060 }
1061 //_______________________________________________________________________________________
1062 void  AliTRDCalibTask::AddTask(const AliTRDCalibTask * calibTask) {
1063
1064   //
1065   // Add stats
1066   //
1067
1068   TList *listcalibTask = calibTask->GetList();
1069   if(!listcalibTask) return;
1070
1071   TH1I *nEvents  = (TH1I *) listcalibTask->FindObject("NEvents");
1072   TH2F *absoluteGain  = (TH2F *) listcalibTask->FindObject("AbsoluteGain");
1073
1074   TH1F *trdTrack = (TH1F *) listcalibTask->FindObject("TRDTrack");
1075   TH1F *trdTrackOffline = (TH1F *) listcalibTask->FindObject("TRDTrackOffline");
1076   TH1F *trdTrackStandalone = (TH1F *) listcalibTask->FindObject("TRDTrackStandalone");
1077
1078   TH2F *tpctrdTrack = (TH2F *) listcalibTask->FindObject("NbTPCTRDtrack");
1079
1080   TH1F *nbTimeBin = (TH1F *) listcalibTask->FindObject("NbTimeBin");
1081   TH1F *nbTimeBinOffline = (TH1F *) listcalibTask->FindObject("NbTimeBinOffline");
1082   TH1F *nbTimeBinStandalone = (TH1F *) listcalibTask->FindObject("NbTimeBinStandalone");
1083
1084   TH1F *nbClusters = (TH1F *) listcalibTask->FindObject("NbClusters");
1085   TH1F *nbClustersOffline = (TH1F *) listcalibTask->FindObject("NbClustersOffline");
1086   TH1F *nbClustersStandalone = (TH1F *) listcalibTask->FindObject("NbClustersStandalone");
1087
1088   TH1F *nbTracklets = (TH1F *) listcalibTask->FindObject("NbTracklets");
1089   TH1F *nbTrackletsOffline = (TH1F *) listcalibTask->FindObject("NbTrackletsOffline");
1090   TH1F *nbTrackletsStandalone = (TH1F *) listcalibTask->FindObject("NbTrackletsStandalone");
1091
1092   TH2I *ch2d = (TH2I *) listcalibTask->FindObject("CH2d");
1093   TProfile2D *ph2d = (TProfile2D *) listcalibTask->FindObject("PH2d");
1094   TProfile2D *prf2d = (TProfile2D *) listcalibTask->FindObject("PRF2d");
1095
1096   TH2I *ch2dSum = (TH2I *) listcalibTask->FindObject("CH2dSum");
1097   TProfile2D *ph2dSum = (TProfile2D *) listcalibTask->FindObject("PH2dSum");
1098
1099   TH2I *ch2dSM = (TH2I *) listcalibTask->FindObject("CH2dSM");
1100   TProfile2D *ph2dSM = (TProfile2D *) listcalibTask->FindObject("PH2dSM");
1101
1102   AliTRDCalibraVdriftLinearFit *linearfit = (AliTRDCalibraVdriftLinearFit *) listcalibTask->FindObject("AliTRDCalibraVdriftLinearFit");
1103   AliTRDCalibraVector *calibraVector = (AliTRDCalibraVector *) listcalibTask->FindObject("AliTRDCalibraVector");
1104
1105   //
1106
1107   TH1I *inEvents  = (TH1I *) fListHist->FindObject("NEvents");
1108   TH2F *iabsoluteGain  = (TH2F *) fListHist->FindObject("AbsoluteGain");
1109
1110   TH1F *itrdTrack = (TH1F *) fListHist->FindObject("TRDTrack");
1111   TH1F *itrdTrackOffline = (TH1F *) fListHist->FindObject("TRDTrackOffline");
1112   TH1F *itrdTrackStandalone = (TH1F *) fListHist->FindObject("TRDTrackStandalone");
1113
1114   TH2F *itpctrdTrack = (TH2F *) fListHist->FindObject("NbTPCTRDtrack");
1115
1116   TH1F *inbTimeBin = (TH1F *) fListHist->FindObject("NbTimeBin");
1117   TH1F *inbTimeBinOffline = (TH1F *) fListHist->FindObject("NbTimeBinOffline");
1118   TH1F *inbTimeBinStandalone = (TH1F *) fListHist->FindObject("NbTimeBinStandalone");
1119
1120   TH1F *inbClusters = (TH1F *) fListHist->FindObject("NbClusters");
1121   TH1F *inbClustersOffline = (TH1F *) fListHist->FindObject("NbClustersOffline");
1122   TH1F *inbClustersStandalone = (TH1F *) fListHist->FindObject("NbClustersStandalone");
1123
1124   TH1F *inbTracklets = (TH1F *) fListHist->FindObject("NbTracklets");
1125   TH1F *inbTrackletsOffline = (TH1F *) fListHist->FindObject("NbTrackletsOffline");
1126   TH1F *inbTrackletsStandalone = (TH1F *) fListHist->FindObject("NbTrackletsStandalone");
1127
1128   TH2I *ich2d = (TH2I *) fListHist->FindObject("CH2d");
1129   TProfile2D *iph2d = (TProfile2D *) fListHist->FindObject("PH2d");
1130   TProfile2D *iprf2d = (TProfile2D *) fListHist->FindObject("PRF2d");
1131
1132   TH2I *ich2dSum = (TH2I *) fListHist->FindObject("CH2dSum");
1133   TProfile2D *iph2dSum = (TProfile2D *) fListHist->FindObject("PH2dSum");
1134
1135   TH2I *ich2dSM = (TH2I *) fListHist->FindObject("CH2dSM");
1136   TProfile2D *iph2dSM = (TProfile2D *) fListHist->FindObject("PH2dSM");
1137
1138   AliTRDCalibraVdriftLinearFit *ilinearfit = (AliTRDCalibraVdriftLinearFit *) fListHist->FindObject("AliTRDCalibraVdriftLinearFit");
1139   AliTRDCalibraVector *icalibraVector = (AliTRDCalibraVector *) fListHist->FindObject("AliTRDCalibraVector");
1140
1141
1142   // Add
1143
1144   if(nEvents) {
1145     if(inEvents) {
1146       inEvents->Add(nEvents);
1147       //printf("Add Events\n");
1148     }
1149     else {
1150       //printf("Create new Events\n");
1151       inEvents = new TH1I(*nEvents);
1152       fListHist->Add(inEvents);
1153     }
1154   }
1155
1156   if(absoluteGain) {
1157     if(iabsoluteGain) iabsoluteGain->Add(absoluteGain);
1158     else {
1159       iabsoluteGain = new TH2F(*absoluteGain);
1160       fListHist->Add(iabsoluteGain);
1161     }
1162   }
1163
1164   if(trdTrack) {
1165     if(itrdTrack) itrdTrack->Add(trdTrack);
1166     else {
1167      itrdTrack = new TH1F(*trdTrack);
1168      fListHist->Add(itrdTrack);
1169     }
1170   }
1171
1172   if(trdTrackOffline) {
1173     if(itrdTrackOffline) itrdTrackOffline->Add(trdTrackOffline);
1174     else {
1175       itrdTrackOffline = new TH1F(*trdTrackOffline);
1176       fListHist->Add(itrdTrackOffline);
1177     }
1178   }
1179
1180   if(trdTrackStandalone) {
1181     if(itrdTrackStandalone) itrdTrackStandalone->Add(trdTrackStandalone);
1182     else {
1183       itrdTrackStandalone = new TH1F(*trdTrackStandalone);
1184       fListHist->Add(itrdTrackStandalone);
1185     }
1186   }
1187
1188   if(tpctrdTrack) {
1189     if(itpctrdTrack) itpctrdTrack->Add(tpctrdTrack);
1190     else {
1191       itpctrdTrack = new TH2F(*tpctrdTrack);
1192       fListHist->Add(itpctrdTrack);
1193     }
1194   }
1195
1196   if(nbTimeBin) {
1197     if(inbTimeBin) inbTimeBin->Add(nbTimeBin);
1198     else {
1199       inbTimeBin = new TH1F(*inbTimeBin);
1200       fListHist->Add(inbTimeBin);
1201     }
1202   }
1203
1204   if(nbTimeBinOffline) {
1205     if(inbTimeBinOffline) inbTimeBinOffline->Add(nbTimeBinOffline);
1206     else {
1207       inbTimeBinOffline = new TH1F(*nbTimeBinOffline);
1208       fListHist->Add(inbTimeBinOffline);
1209     }
1210   }
1211
1212   if(nbTimeBinStandalone) {
1213     if(inbTimeBinStandalone) inbTimeBinStandalone->Add(nbTimeBinStandalone);
1214     else {
1215       inbTimeBinStandalone = new TH1F(*nbTimeBinStandalone);
1216       fListHist->Add(inbTimeBinStandalone);
1217     }
1218   }
1219
1220   if(nbClusters) {
1221     if(inbClusters) inbClusters->Add(nbClusters);
1222     else {
1223       inbClusters = new TH1F(*nbClusters);
1224       fListHist->Add(inbClusters);
1225     }
1226   }
1227
1228   if(nbClustersOffline) {
1229     if(inbClustersOffline) inbClustersOffline->Add(nbClustersOffline);
1230     else {
1231       inbClustersOffline = new TH1F(*nbClustersOffline);
1232       fListHist->Add(inbClustersOffline);
1233     }
1234   }
1235
1236   if(nbClustersStandalone) {
1237     if(inbClustersStandalone) inbClustersStandalone->Add(nbClustersStandalone);
1238     else {
1239       inbClustersStandalone = new TH1F(*nbClustersStandalone);
1240       fListHist->Add(inbClustersStandalone);
1241     }
1242   }
1243
1244   if(nbTracklets) {
1245     if(inbTracklets) inbTracklets->Add(nbTracklets);
1246     else {
1247       inbTracklets = new TH1F(*nbTracklets);
1248       fListHist->Add(inbTracklets);
1249     }
1250   }
1251
1252   if(nbTrackletsOffline) {
1253     if(inbTrackletsOffline) inbTrackletsOffline->Add(nbTrackletsOffline);
1254     else {
1255       inbTrackletsOffline = new TH1F(*nbTrackletsOffline);
1256       fListHist->Add(inbTrackletsOffline);
1257     }
1258   }
1259
1260   if(nbTrackletsStandalone) {
1261     if(inbTrackletsStandalone) inbTrackletsStandalone->Add(nbTrackletsStandalone);
1262     else {
1263       inbTrackletsStandalone = new TH1F(*nbTrackletsStandalone);
1264       fListHist->Add(inbTrackletsStandalone);
1265     }
1266   }
1267
1268   if(ch2d) {
1269     if(ich2d) ich2d->Add(ch2d);
1270     else {
1271       ich2d = new TH2I(*ch2d);
1272       fListHist->Add(ich2d);
1273     }
1274   }
1275
1276   if(ph2d) {
1277     if(iph2d) iph2d->Add(ph2d);
1278     else {
1279       iph2d = new TProfile2D(*ph2d);
1280       fListHist->Add(iph2d);
1281     }
1282   }
1283
1284   if(prf2d) {
1285     if(iprf2d) iprf2d->Add(prf2d);
1286     else {
1287       iprf2d = new TProfile2D(*prf2d);
1288       fListHist->Add(iprf2d);
1289     }
1290   }
1291
1292   if(ch2dSum) {
1293     if(ich2dSum) ich2dSum->Add(ch2dSum);
1294     else {
1295       ich2dSum = new TH2I(*ch2dSum);
1296       fListHist->Add(ich2dSum);
1297     }
1298   }
1299
1300   if(ph2dSum) {
1301     if(iph2dSum) iph2dSum->Add(ph2dSum);
1302     else {
1303       iph2dSum = new TProfile2D(*ph2dSum);
1304       fListHist->Add(iph2dSum);
1305     }
1306   }
1307
1308   if(ch2dSM) {
1309     if(ich2dSM) ich2dSM->Add(ch2dSM);
1310     else {
1311       ich2dSM = new TH2I(*ch2dSM);
1312       fListHist->Add(ich2dSM);
1313     }
1314   }
1315
1316   if(ph2dSM) {
1317     if(iph2dSM) iph2dSM->Add(ph2dSM);
1318     else {
1319       iph2dSM = new TProfile2D(*ph2dSM);
1320       fListHist->Add(iph2dSM);
1321     }
1322   }
1323
1324   if(linearfit) {
1325     if(ilinearfit) ilinearfit->Add(linearfit);
1326     else {
1327       ilinearfit = new AliTRDCalibraVdriftLinearFit(*linearfit);
1328       fListHist->Add(ilinearfit);
1329     }
1330   }
1331
1332   if(calibraVector) {
1333     if(icalibraVector) icalibraVector->Add(calibraVector);
1334     else {
1335       icalibraVector = new AliTRDCalibraVector(*calibraVector);
1336       fListHist->Add(icalibraVector);
1337     }
1338   }
1339
1340 }
1341 //________________________________________________________________________________
1342 Long64_t AliTRDCalibTask::Merge(TCollection *li) {
1343
1344   //
1345   // merge component
1346   //
1347
1348   TIterator* iter = li->MakeIterator();
1349   AliTRDCalibTask* cal = 0;
1350
1351   while ((cal = (AliTRDCalibTask*)iter->Next())) {
1352     if (!cal->InheritsFrom(AliTRDCalibTask::Class())) {
1353       Error("Merge","Attempt to add object of class %s to a %s", cal->ClassName(), this->ClassName());
1354       return -1;
1355     }
1356
1357     // add histograms here...
1358     this->AddTask(cal);
1359
1360   }
1361
1362   return 0;
1363
1364 }
1365 //_____________________________________________________
1366 Bool_t AliTRDCalibTask::SetVersionSubversion(){
1367   //
1368   // Load Chamber Gain factors into the Tender supply
1369   //
1370
1371   printf("SetVersionSubversion\n");
1372
1373   //find previous entry from the UserInfo
1374   TTree *tree=((TChain*)GetInputData(0))->GetTree();
1375   if (!tree) {
1376     AliError("Tree not found in ESDhandler");
1377     return kFALSE;
1378   }
1379
1380   TList *userInfo=(TList*)tree->GetUserInfo();
1381   if (!userInfo) {
1382     AliError("No UserInfo found in tree");
1383     return kFALSE;
1384   }
1385
1386   TList *cdbList=(TList*)userInfo->FindObject("cdbList");
1387   if (!cdbList) {
1388     AliError("No cdbList found in UserInfo");
1389     if (AliLog::GetGlobalLogLevel()>=AliLog::kError) userInfo->Print();
1390     return kFALSE;
1391   }
1392
1393   TIter nextCDB(cdbList);
1394   TObjString *os=0x0;
1395   while ( (os=(TObjString*)nextCDB()) ){
1396     if(os->GetString().Contains("TRD/Calib/ChamberGainFactor")){
1397       // Get Old gain calibration
1398       AliCDBId *id=AliCDBId::MakeFromString(os->GetString());
1399       fVersionGainUsed = id->GetVersion();
1400       fSubVersionGainUsed = id->GetSubVersion();
1401     } else if(os->GetString().Contains("TRD/Calib/ChamberVdrift")){
1402       // Get Old drift velocity calibration
1403       AliCDBId *id=AliCDBId::MakeFromString(os->GetString());
1404       fVersionVdriftUsed = id->GetVersion();
1405       fSubVersionVdriftUsed = id->GetSubVersion();
1406     } else if(os->GetString().Contains("TRD/Calib/LocalGainFactor")){
1407       // Get Old drift velocity calibration
1408       AliCDBId *id=AliCDBId::MakeFromString(os->GetString());
1409       fVersionGainLocalUsed = id->GetVersion();
1410       fSubVersionGainLocalUsed = id->GetSubVersion();
1411     }
1412   }
1413
1414   //printf("VersionGain %d, SubversionGain %d, VersionLocalGain %d, Subversionlocalgain %d, Versionvdrift %d, Subversionvdrift %d\n",fVersionGainUsed,fSubVersionGainUsed,fVersionGainLocalUsed,fSubVersionGainLocalUsed,fVersionVdriftUsed,fSubVersionVdriftUsed);
1415
1416   // Check
1417   if((fVersionGainUsed < 0) || (fVersionGainLocalUsed < 0)  || (fSubVersionGainUsed < 0) || (fSubVersionGainLocalUsed < 0) || (fVersionVdriftUsed < 0) || (fSubVersionVdriftUsed < 0)) {
1418     AliError("No recent calibration found");
1419     return kFALSE;
1420   }
1421   else return kTRUE;
1422
1423 }
1424
1425