TPC/AliTPCCalibRaw.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id:  $ */
  17
  18 ////////////////////////////////////////////////////////////////////////////////////////
  19 //                                                                                    //
  20 //     Implementation of the TPC Raw drift velocity and Altro L1 Phase  calibration   //
  21 //                                                                                    //
  22 //               Origin: Jens Wiechula, J.Wiechula@gsi.de                             //
  23 //                                                                                    //
  24 ////////////////////////////////////////////////////////////////////////////////////////
  25 //
  26 //
  27 // *************************************************************************************
  28 // *                                Class Description                                  *
  29 // *************************************************************************************
  30 /*
  31
  32 ----example---
  33 TFile f("CalibAltro.root");
  34 AliTPCCalibRaw *al=(AliTPCCalibRaw*)f.Get(f.GetListOfKeys()->At(0)->GetName())
  35 {
  36 TCanvas *c1=(TCanvas*)gROOT->FindObject("c1");
  37 if (!c1) c1=new TCanvas("c1","c1");
  38 c1->Clear();
  39
  40 TH2F h2f("h2","h2;RCU;fail",216,0,216,al->GetNevents(),0,al->GetNevents());
  41 Bool_t first=kTRUE;
  42 Int_t i,iev;
  43 for (i=0;i<216;++i) {
  44   TVectorF *v=al->GetALTROL1PhaseFailEventsRCU(i);
  45   if (!v) continue;
  46   for (iev=0;iev<al->GetNevents();++iev) {
  47     h2f->SetBinContent(i+1,iev+1,(*v)(iev));
  48   }
  49 //   TH1F h(*v);
  50 //   h.SetLineColor(i/216.*50+50);
  51 //   ((TH1F*)h.Clone(Form("h%d",i)))->Draw(first?"":"same");
  52 //   c1->Modified();
  53 //   c1->Update();
  54   first=kFALSE;
  55 }
  56 h2f->Draw("col");
  57 }
  58
  59 */
  60
  61
  62
  63 //Root includes
  64 #include <TH2C.h>
  65 #include <TH1F.h>
  66 #include <TMap.h>
  67 #include <TObjString.h>
  68
  69 //AliRoot includes
  70 #include "AliTPCCalROC.h"
  71 #include "AliAltroRawStream.h"
  72 #include "AliLog.h"
  73 //class header
  74 #include "AliTPCCalibRaw.h"
  75
  76 ClassImp(AliTPCCalibRaw)
  77
  78 AliTPCCalibRaw::AliTPCCalibRaw() :
  79   AliTPCCalibRawBase(),
  80   fPeakDetMinus(1),
  81   fPeakDetPlus(2),
  82   fNFailL1Phase(0),
  83   fNFailL1PhaseEvent(0),
  84   fFirstTimeStamp(0),
  85   fNSecTime(600), //default 10 minutes
  86   fNBinsTime(60), //default 60*10 minutes = 10 hours
  87   fPadProcessed(kFALSE),
  88   fCurrentChannel(-1),
  89   fCurrentSector(-1),
  90   fLastSector(-2),
  91   fCurrentRow(-1),
  92   fCurrentPad(-1),
  93   fLastTimeBinProc(0),
  94   fPeakTimeBin(0),
  95   fLastSignal(0),
  96   fNOkPlus(0),
  97   fNOkMinus(0),
  98   fArrCurrentPhaseDist(4),
  99   fArrCurrentPhase(kNRCU),
 100   fArrFailEventNumber(100),
 101   fArrALTROL1Phase(1000),
 102   fArrALTROL1PhaseEvent(kNRCU),
 103   fArrALTROL1PhaseFailEvent(kNRCU),
 104   fHnDrift(0x0)
 105 {
 106   //
 107   // Default ctor
 108   //
 109   SetNameTitle("AliTPCCalibRaw","AliTPCCalibRaw");
 110   CreateDVhist();
 111   for (Int_t ircu=0;ircu<kNRCU;++ircu) fArrCurrentPhase.GetMatrixArray()[ircu]=-1;
 112   fFirstTimeBin=850;
 113   fLastTimeBin=1020;
 114 }
 115 //_____________________________________________________________________
 116 AliTPCCalibRaw::AliTPCCalibRaw(const TMap *config) :
 117 AliTPCCalibRawBase(),
 118 fPeakDetMinus(1),
 119 fPeakDetPlus(2),
 120 fNFailL1Phase(0),
 121 fNFailL1PhaseEvent(0),
 122 fFirstTimeStamp(0),
 123 fNSecTime(600), //default 10 minutes
 124 fNBinsTime(60), //default 60*10 minutes = 10 hours
 125 fPadProcessed(kFALSE),
 126 fCurrentChannel(-1),
 127 fCurrentSector(-1),
 128 fLastSector(-2),
 129 fCurrentRow(-1),
 130 fCurrentPad(-1),
 131 fLastTimeBinProc(0),
 132 fPeakTimeBin(0),
 133 fLastSignal(0),
 134 fNOkPlus(0),
 135 fNOkMinus(0),
 136 fArrCurrentPhaseDist(4),
 137 fArrCurrentPhase(kNRCU),
 138 fArrFailEventNumber(100),
 139 fArrALTROL1Phase(1000),
 140 fArrALTROL1PhaseEvent(kNRCU),
 141 fArrALTROL1PhaseFailEvent(kNRCU),
 142 fHnDrift(0x0)
 143 {
 144   //
 145   // Default ctor
 146   //
 147   SetNameTitle("AliTPCCalibRaw","AliTPCCalibRaw");
 148   CreateDVhist();
 149   for (Int_t ircu=0;ircu<kNRCU;++ircu) fArrCurrentPhase.GetMatrixArray()[ircu]=-1;
 150   fFirstTimeBin=850;
 151   fLastTimeBin=1020;
 152   if (config->GetValue("FirstTimeBin")) fFirstTimeBin = ((TObjString*)config->GetValue("FirstTimeBin"))->GetString().Atoi();
 153   if (config->GetValue("LastTimeBin")) fLastTimeBin = ((TObjString*)config->GetValue("LastTimeBin"))->GetString().Atoi();
 154 }
 155
 156 //_____________________________________________________________________
 157 AliTPCCalibRaw::~AliTPCCalibRaw()
 158 {
 159   //
 160   // dtor
 161   //
 162   delete fHnDrift;
 163 }
 164 //_____________________________________________________________________
 165 // AliTPCCalibRaw& AliTPCCalibRaw::operator = (const  AliTPCCalibRaw &source)
 166 // {
 167 //   //
 168 //   // assignment operator
 169 //   //
 170 //   if (&source == this) return *this;
 171 //   new (this) AliTPCCalibRaw(source);
 172 //
 173 //   return *this;
 174 // }
 175
 176 //_____________________________________________________________________
 177 Int_t AliTPCCalibRaw::Update(const Int_t isector, const Int_t iRow, const Int_t iPad,
 178              const Int_t iTimeBin, const Float_t signal)
 179 {
 180   //
 181   // Data filling method
 182   //
 183   if (iRow<0) return 0;
 184   if (iPad<0) return 0;
 185   if (iTimeBin<0) return 0;
 186   if (!fFirstTimeStamp) fFirstTimeStamp=GetTimeStamp();
 187   if ( (iTimeBin>fLastTimeBin) || (iTimeBin<fFirstTimeBin)   ) return 0;
 188   //don't process edge pads
 189   if (IsEdgePad(isector,iRow,iPad)) return 0;
 190 //   Double_t x[kHnBinsDV]={1,isector,0};
 191 //   fHnDrift->Fill(x);
 192   Int_t iChannel  = fROC->GetRowIndexes(isector)[iRow]+iPad; //  global pad position in sector
 193   if (fCurrentChannel==iChannel){
 194     if (fPadProcessed) return 0;
 195   } else {
 196     fPadProcessed=kFALSE;
 197     fNOkPlus=0;
 198     fNOkMinus=0;
 199     fPeakTimeBin=0;
 200     fLastSignal=0;
 201   }
 202 //   Double_t x2[kHnBinsDV]={2,isector,0};
 203 //   fHnDrift->Fill(x2);
 204
 205
 206   if (signal>fLastSignal) ++fNOkPlus;
 207   else if(signal<fLastSignal && fNOkPlus>=fPeakDetPlus){
 208     ++fNOkMinus;
 209     if (!fPeakTimeBin) fPeakTimeBin=fLastTimeBinProc;
 210     if ( fNOkMinus>=fPeakDetMinus ) {
 211       Double_t x[kHnBinsDV]={fPeakTimeBin,isector,(fTimeStamp-fFirstTimeStamp)/fNSecTime};
 212       fHnDrift->Fill(x);
 213     }
 214   } else {
 215     fNOkPlus=0;
 216     fNOkMinus=0;
 217     fPeakTimeBin=0;
 218     fLastSignal=0;
 219   }
 220
 221   fLastTimeBinProc=iTimeBin;
 222   fLastSignal=TMath::Nint(signal);
 223   fCurrentChannel = iChannel;
 224   return 0;
 225 }
 226 //_____________________________________________________________________
 227 void AliTPCCalibRaw::UpdateDDL(){
 228   //
 229   // fill ALTRO L1 information
 230   //
 231
 232   // current phase
 233   Int_t phase=(Int_t)(GetL1PhaseTB()*4.);
 234   //Fill pahse information of current rcu and event
 235   fArrCurrentPhase.GetMatrixArray()[fCurrDDLNum]=phase;
 236   //increase phase counter
 237   ++((fArrCurrentPhaseDist.GetMatrixArray())[phase]);
 238
 239 }
 240 //_____________________________________________________________________
 241 void AliTPCCalibRaw::ResetEvent()
 242 {
 243   //
 244   // Reset event counters
 245   //
 246
 247   fCurrentChannel=-1;
 248   fArrCurrentPhaseDist.Zero();
 249 }
 250 //_____________________________________________________________________
 251 void AliTPCCalibRaw::EndEvent()
 252 {
 253   //
 254   // End event analysis
 255   //
 256
 257
 258   //find phase of the current event
 259   Int_t phaseMaxEntries=-1;
 260   Int_t maxEntries=0;
 261   for (Int_t i=0;i<fArrCurrentPhaseDist.GetNrows();++i){
 262     Int_t entries=(Int_t)fArrCurrentPhaseDist[i];
 263     if (maxEntries<entries) {
 264       maxEntries=entries;
 265       phaseMaxEntries=i;
 266     }
 267   }
 268   // store phase of current event
 269   if (fArrALTROL1Phase.GetNrows()<=GetNevents())
 270     fArrALTROL1Phase.ResizeTo(GetNevents()+1000);
 271   (fArrALTROL1Phase.GetMatrixArray())[GetNevents()]=phaseMaxEntries;
 272
 273   //loop over RCUs and test failures
 274   UInt_t fail=0;
 275   for (Int_t ircu=0;ircu<kNRCU;++ircu){
 276     Int_t phase=(Int_t)fArrCurrentPhase[ircu];
 277     if (phase<0) continue;
 278     if (phase!=phaseMaxEntries){
 279       TVectorF *arr=MakeArrL1PhaseRCU(fCurrDDLNum,kTRUE);
 280       if (arr->GetNrows()<=(Int_t)fNFailL1PhaseEvent) arr->ResizeTo(arr->GetNrows()+100);
 281       (arr->GetMatrixArray())[fNFailL1PhaseEvent]=phase;
 282       ++fNFailL1Phase;
 283       fail=1;
 284       }
 285     //reset current phase information
 286     fArrCurrentPhase[ircu]=-1;
 287   }
 288   if (fail){
 289     if (fArrFailEventNumber.GetNrows()<=(Int_t)fNFailL1PhaseEvent) fArrFailEventNumber.ResizeTo(fArrFailEventNumber.GetNrows()+100);
 290     fArrFailEventNumber.GetMatrixArray()[fNFailL1PhaseEvent]=GetNevents();
 291   }
 292   fNFailL1PhaseEvent+=fail;
 293   IncrementNevents();
 294 }
 295 //_____________________________________________________________________
 296 TH2C *AliTPCCalibRaw::MakeHistL1RCUEvents(Int_t type)
 297 {
 298   // Create a 2D histo RCU:Events indicating the there was a deviation
 299   // from the mean L1 phase of the event
 300   //
 301   //type: 0=Failures, 1=Phases
 302
 303   //number of relavant events, depending on version
 304   Int_t nevents=GetNevents();
 305   //check version
 306   Bool_t newVersion=kFALSE;
 307   for (Int_t ircu=0; ircu<kNRCU; ++ircu){
 308     const TVectorF *v=GetALTROL1PhaseEventsRCU(ircu);
 309     if (!v) continue;
 310     if ((UInt_t)(v->GetNrows())==fNFailL1PhaseEvent){
 311       newVersion=kTRUE;
 312       nevents=fNFailL1PhaseEvent;
 313     }
 314     break;
 315   }
 316   TH2C *h2 = new TH2C("hL1FailRCUEvents","L1 Failures;RCU;Event",kNRCU,0,kNRCU,nevents,0,nevents);
 317   Int_t add=0;
 318   for (Int_t ircu=0;ircu<kNRCU;++ircu) {
 319     const TVectorF *v=GetALTROL1PhaseEventsRCU(ircu);
 320     if (type==0){
 321       add=1;
 322       h2->SetMinimum(0);
 323       h2->SetMaximum(2);
 324     } else if (type==1) {
 325       add=0;
 326       h2->SetMinimum(0);
 327       h2->SetMaximum(4);
 328     }
 329     if (!v) continue;
 330     for (Int_t iev=0;iev<nevents;++iev) {
 331       Float_t val=(*v)(iev);
 332       Float_t phase=fArrALTROL1Phase.GetMatrixArray()[iev];
 333       if (newVersion) {
 334         Int_t event=(Int_t)fArrFailEventNumber.GetMatrixArray()[iev];
 335         phase=fArrALTROL1Phase.GetMatrixArray()[event];
 336       }
 337       if (type==0) val=(val!=phase);
 338       h2->SetBinContent(ircu+1,iev+1,val+add);
 339     }
 340   }
 341   return h2;
 342 }
 343 //_____________________________________________________________________
 344 TH1F *AliTPCCalibRaw::MakeHistL1PhaseDist()
 345 {
 346   //
 347   // L1 phase distribution. Should be flat in ideal case
 348   //
 349   TH1F *h=new TH1F("L1phaseDist","Normalized L1 phase distribution;phase;fraction of events",4,0,4);
 350   h->Sumw2();
 351   for (Int_t iev=0;iev<GetNevents();++iev) h->Fill(fArrALTROL1Phase.GetMatrixArray()[iev]);
 352   if (GetNevents()>0) h->Scale(1./GetNevents());
 353   h->SetMinimum(0);
 354   h->SetMaximum(1);
 355   return h;
 356 }
 357 //_____________________________________________________________________
 358 TVectorF *AliTPCCalibRaw::MakeVectL1PhaseDist()
 359 {
 360   //
 361   // L1 phase distribution. Should be flat in ideal case
 362   //
 363   TVectorF *v=new TVectorF(4);
 364   for (Int_t iev=0;iev<GetNevents();++iev) {
 365     Int_t phase=(Int_t)fArrALTROL1Phase.GetMatrixArray()[iev];
 366     ((v->GetMatrixArray())[phase])+=1./GetNevents();
 367   }
 368   return v;
 369 }
 370 //_____________________________________________________________________
 371 TH2C *AliTPCCalibRaw::MakeHistL1RCUEventsIROC(Int_t type)
 372 {
 373   //
 374   // Create a 2D histo RCU:Events indicating the there was a deviation
 375   // from the mean L1 phase of the event
 376   //
 377   TH2C *h2 = new TH2C("hL1FailRCUEventsIROC","L1 Failures IROCs;RCU;Event",72,0,36,GetNevents(),0,GetNevents());
 378   for (Int_t ircu=0;ircu<72;++ircu) {
 379     const TVectorF *v=0;
 380     if (type==0)      v=GetALTROL1PhaseFailEventsRCU(ircu);
 381     else if (type==1) v=GetALTROL1PhaseEventsRCU(ircu);
 382     if (!v) continue;
 383     for (Int_t iev=0;iev<GetNevents();++iev) {
 384       h2->SetBinContent(ircu+1,iev+1,(*v)(iev));
 385     }
 386   }
 387   return h2;
 388 }
 389 //_____________________________________________________________________
 390 TH2C *AliTPCCalibRaw::MakeHistL1RCUEventsOROC(Int_t type)
 391 {
 392   //
 393   // Create a 2D histo RCU:Events indicating the there was a deviation
 394   // from the mean L1 phase of the event
 395   //
 396   TH2C *h2 = new TH2C("hL1FailRCUEventsOROC","L1 Failures OROCs;RCU;Event",144,0,36,GetNevents(),0,GetNevents());
 397   for (Int_t ircu=72;ircu<kNRCU;++ircu) {
 398     const TVectorF *v=0;
 399     if (type==0)      v=GetALTROL1PhaseFailEventsRCU(ircu);
 400     else if (type==1) v=GetALTROL1PhaseEventsRCU(ircu);
 401     if (!v) continue;
 402     for (Int_t iev=0;iev<GetNevents();++iev) {
 403       h2->SetBinContent(ircu-72+1,iev+1,(*v)(iev));
 404     }
 405   }
 406   return h2;
 407 }
 408 //_____________________________________________________________________
 409 void AliTPCCalibRaw::CreateDVhist()
 410 {
 411   //
 412   // Setup the HnSparse for the drift velocity determination
 413   //
 414   if (fHnDrift) return;
 415   //HnSparse bins
 416   //time bin, roc, time
 417   Int_t    bins[kHnBinsDV] = {fLastTimeBin-fFirstTimeBin, 72, fNBinsTime};
 418   Double_t xmin[kHnBinsDV] = {fFirstTimeBin,0,0};
 419   Double_t xmax[kHnBinsDV] = {fLastTimeBin,72,fNBinsTime};
 420   fHnDrift=new THnSparseI("fHnDrift",Form("Drift velocity using last time bin;time bin[#times 100ns];ROC;Time bin [#times %us]",fNSecTime),kHnBinsDV, bins, xmin, xmax);
 421
 422 }
 423 //_____________________________________________________________________
 424 void AliTPCCalibRaw::Analyse()
 425 {
 426   //
 427   // Analyse Data
 428   //
 429
 430   //resize arrays
 431   fArrALTROL1Phase.ResizeTo(GetNevents());
 432   for (Int_t ircu=0;ircu<kNRCU;++ircu){
 433     TVectorF *arr=MakeArrL1PhaseRCU(ircu);//MakeArrL1PhaseRCU(ircu);
 434     if (!arr) continue;
 435     arr->ResizeTo(fNFailL1PhaseEvent);
 436     fArrFailEventNumber.ResizeTo(fNFailL1PhaseEvent);
 437 //    TVectorF *arrF=MakeArrL1PhaseFailRCU(ircu);
 438 //     arrF->ResizeTo(1);
 439   }
 440
 441   //Analyse drift velocity
 442
 443 }
 444