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