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