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 <TMap.h>
  66 #include <TObjString.h>
  67
  68 //AliRoot includes
  69 #include "AliTPCCalROC.h"
  70 #include "AliAltroRawStream.h"
  71 #include "AliLog.h"
  72 //class header
  73 #include "AliTPCCalibRaw.h"
  74
  75 ClassImp(AliTPCCalibRaw)
  76
  77 AliTPCCalibRaw::AliTPCCalibRaw() :
  78   AliTPCCalibRawBase(),
  79   fPeakDetMinus(1),
  80   fPeakDetPlus(2),
  81   fNFailL1Phase(0),
  82   fFirstTimeStamp(0),
  83   fNSecTime(600), //default 10 minutes
  84   fNBinsTime(60), //default 60*10 minutes = 10 hours
  85   fPadProcessed(kFALSE),
  86   fCurrentChannel(-1),
  87   fCurrentSector(-1),
  88   fLastSector(-2),
  89   fCurrentRow(-1),
  90   fCurrentPad(-1),
  91   fLastTimeBinProc(0),
  92   fPeakTimeBin(0),
  93   fLastSignal(0),
  94   fNOkPlus(0),
  95   fNOkMinus(0),
  96   fArrCurrentPhaseDist(4),
  97   fArrALTROL1Phase(1000),
  98   fArrALTROL1PhaseEvent(216),
  99   fArrALTROL1PhaseFailEvent(216),
 100   fHnDrift(0x0)
 101 {
 102   //
 103   // Default ctor
 104   //
 105   SetNameTitle("AliTPCCalibRaw","AliTPCCalibRaw");
 106   CreateDVhist();
 107   fFirstTimeBin=850;
 108   fLastTimeBin=1020;
 109 }
 110 //_____________________________________________________________________
 111 AliTPCCalibRaw::AliTPCCalibRaw(const TMap *config) :
 112 AliTPCCalibRawBase(),
 113 fPeakDetMinus(1),
 114 fPeakDetPlus(2),
 115 fNFailL1Phase(0),
 116 fFirstTimeStamp(0),
 117 fNSecTime(600), //default 10 minutes
 118 fNBinsTime(60), //default 60*10 minutes = 10 hours
 119 fPadProcessed(kFALSE),
 120 fCurrentChannel(-1),
 121 fCurrentSector(-1),
 122 fLastSector(-2),
 123 fCurrentRow(-1),
 124 fCurrentPad(-1),
 125 fLastTimeBinProc(0),
 126 fPeakTimeBin(0),
 127 fLastSignal(0),
 128 fNOkPlus(0),
 129 fNOkMinus(0),
 130 fArrCurrentPhaseDist(4),
 131 fArrALTROL1Phase(1000),
 132 fArrALTROL1PhaseEvent(216),
 133 fArrALTROL1PhaseFailEvent(216),
 134 fHnDrift(0x0)
 135 {
 136   //
 137   // Default ctor
 138   //
 139   SetNameTitle("AliTPCCalibRaw","AliTPCCalibRaw");
 140   CreateDVhist();
 141   fFirstTimeBin=850;
 142   fLastTimeBin=1020;
 143   if (config->GetValue("FirstTimeBin")) fFirstTimeBin = ((TObjString*)config->GetValue("FirstTimeBin"))->GetString().Atoi();
 144   if (config->GetValue("LastTimeBin")) fLastTimeBin = ((TObjString*)config->GetValue("LastTimeBin"))->GetString().Atoi();
 145 }
 146
 147 //_____________________________________________________________________
 148 AliTPCCalibRaw::~AliTPCCalibRaw()
 149 {
 150   //
 151   // dtor
 152   //
 153   delete fHnDrift;
 154 }
 155 //_____________________________________________________________________
 156 // AliTPCCalibRaw& AliTPCCalibRaw::operator = (const  AliTPCCalibRaw &source)
 157 // {
 158 //   //
 159 //   // assignment operator
 160 //   //
 161 //   if (&source == this) return *this;
 162 //   new (this) AliTPCCalibRaw(source);
 163 //
 164 //   return *this;
 165 // }
 166
 167 //_____________________________________________________________________
 168 Int_t AliTPCCalibRaw::Update(const Int_t isector, const Int_t iRow, const Int_t iPad,
 169              const Int_t iTimeBin, const Float_t signal)
 170 {
 171   //
 172   // Data filling method
 173   //
 174   if (iRow<0) return 0;
 175   if (iPad<0) return 0;
 176   if (iTimeBin<0) return 0;
 177   if (!fFirstTimeStamp) fFirstTimeStamp=GetTimeStamp();
 178   if ( (iTimeBin>fLastTimeBin) || (iTimeBin<fFirstTimeBin)   ) return 0;
 179   //don't process edge pads
 180   if (IsEdgePad(isector,iRow,iPad)) return 0;
 181 //   Double_t x[kHnBinsDV]={1,isector,0};
 182 //   fHnDrift->Fill(x);
 183   Int_t iChannel  = fROC->GetRowIndexes(isector)[iRow]+iPad; //  global pad position in sector
 184   if (fCurrentChannel==iChannel){
 185     if (fPadProcessed) return 0;
 186   } else {
 187     fPadProcessed=kFALSE;
 188     fNOkPlus=0;
 189     fNOkMinus=0;
 190     fPeakTimeBin=0;
 191     fLastSignal=0;
 192   }
 193 //   Double_t x2[kHnBinsDV]={2,isector,0};
 194 //   fHnDrift->Fill(x2);
 195
 196
 197   if (signal>fLastSignal) ++fNOkPlus;
 198   else if(signal<fLastSignal && fNOkPlus>=fPeakDetPlus){
 199     ++fNOkMinus;
 200     if (!fPeakTimeBin) fPeakTimeBin=fLastTimeBinProc;
 201     if ( fNOkMinus>=fPeakDetMinus ) {
 202       Double_t x[kHnBinsDV]={fPeakTimeBin,isector,(fTimeStamp-fFirstTimeStamp)/fNSecTime};
 203       fHnDrift->Fill(x);
 204     }
 205   } else {
 206     fNOkPlus=0;
 207     fNOkMinus=0;
 208     fPeakTimeBin=0;
 209     fLastSignal=0;
 210   }
 211
 212   fLastTimeBinProc=iTimeBin;
 213   fLastSignal=TMath::Nint(signal);
 214   fCurrentChannel = iChannel;
 215   return 0;
 216 }
 217 //_____________________________________________________________________
 218 void AliTPCCalibRaw::UpdateDDL(){
 219   //
 220   // fill ALTRO L1 information
 221   //
 222 //   if (fCurrDDLNum!=fPrevDDLNum){
 223     TVectorF *arr=MakeArrL1PhaseRCU(fCurrDDLNum,kTRUE);
 224     if (arr->GetNrows()<=fNevents) arr->ResizeTo(arr->GetNrows()+1000);
 225     // phase as a position of a quarter time bin
 226     Int_t phase=(Int_t)(GetL1PhaseTB()*4.);
 227 //     printf("DDL: %03d, phase: %d (%f))\n",fCurrDDLNum,phase,GetL1PhaseTB());
 228     //Fill pahse information of current rcu and event
 229     (arr->GetMatrixArray())[fNevents]=phase;
 230     //increase phase counter
 231     ++((fArrCurrentPhaseDist.GetMatrixArray())[phase]);
 232 //     printf("RCUId: %03d (%03d), DDL: %03d, sector: %02d\n",fCurrRCUId, fPrevRCUId, fCurrDDLNum, isector);
 233 //   }
 234
 235 }
 236 //_____________________________________________________________________
 237 void AliTPCCalibRaw::ResetEvent()
 238 {
 239   //
 240   // Reset event counters
 241   //
 242
 243   fCurrentChannel=-1;
 244   fArrCurrentPhaseDist.Zero();
 245 }
 246 //_____________________________________________________________________
 247 void AliTPCCalibRaw::EndEvent()
 248 {
 249   //
 250   // End event analysis
 251   //
 252
 253
 254   //find phase of the current event
 255   Int_t phaseMaxEntries=-1;
 256   Int_t maxEntries=0;
 257   for (Int_t i=0;i<fArrCurrentPhaseDist.GetNrows();++i){
 258     Int_t entries=(Int_t)fArrCurrentPhaseDist[i];
 259     if (maxEntries<entries) {
 260       maxEntries=entries;
 261       phaseMaxEntries=i;
 262     }
 263   }
 264   // store phase of current event
 265   if (fArrALTROL1Phase.GetNrows()<=GetNevents())
 266     fArrALTROL1Phase.ResizeTo(GetNevents()+1000);
 267   (fArrALTROL1Phase.GetMatrixArray())[GetNevents()]=phaseMaxEntries;
 268
 269   //loop over RCUs and test failures
 270   for (Int_t ircu=0;ircu<216;++ircu){
 271     const TVectorF *arr=GetALTROL1PhaseEventsRCU(ircu);//MakeArrL1PhaseRCU(ircu);
 272     if (!arr) continue;
 273     TVectorF *arrF=MakeArrL1PhaseFailRCU(ircu,kTRUE);
 274     if (arrF->GetNrows()<=fNevents) arrF->ResizeTo(arrF->GetNrows()+1000);
 275     if ((arr->GetMatrixArray())[fNevents]!=phaseMaxEntries){
 276       (arrF->GetMatrixArray())[fNevents]=1;
 277       ++fNFailL1Phase;
 278       }
 279   }
 280   IncrementNevents();
 281 }
 282 //_____________________________________________________________________
 283 TH2C *AliTPCCalibRaw::MakeHistL1RCUEvents(Int_t type)
 284 {
 285   // Create a 2D histo RCU:Events indicating the there was a deviation
 286   // from the mean L1 phase of the event
 287   //
 288   //type: 0=Failures, 1=Phases
 289   TH2C *h2 = new TH2C("hL1FailRCUEvents","L1 Failures;RCU;Event",216,0,216,GetNevents(),0,GetNevents());
 290   Int_t add=0;
 291   for (Int_t ircu=0;ircu<216;++ircu) {
 292     const TVectorF *v=0;
 293     if (type==0){
 294       v=GetALTROL1PhaseFailEventsRCU(ircu);
 295       add=1;
 296       h2->SetMinimum(0);
 297       h2->SetMaximum(2);
 298     } else if (type==1) {
 299       v=GetALTROL1PhaseEventsRCU(ircu);
 300       add=0;
 301       h2->SetMinimum(0);
 302       h2->SetMaximum(4);
 303     }
 304     if (!v) continue;
 305     for (Int_t iev=0;iev<GetNevents();++iev) {
 306       h2->SetBinContent(ircu+1,iev+1,(*v)(iev)+add);
 307     }
 308   }
 309   return h2;
 310 }
 311 //_____________________________________________________________________
 312 TH2C *AliTPCCalibRaw::MakeHistL1RCUEventsIROC(Int_t type)
 313 {
 314   //
 315   // Create a 2D histo RCU:Events indicating the there was a deviation
 316   // from the mean L1 phase of the event
 317   //
 318   TH2C *h2 = new TH2C("hL1FailRCUEventsIROC","L1 Failures IROCs;RCU;Event",72,0,36,GetNevents(),0,GetNevents());
 319   for (Int_t ircu=0;ircu<72;++ircu) {
 320     const TVectorF *v=0;
 321     if (type==0)      v=GetALTROL1PhaseFailEventsRCU(ircu);
 322     else if (type==1) v=GetALTROL1PhaseEventsRCU(ircu);
 323     if (!v) continue;
 324     for (Int_t iev=0;iev<GetNevents();++iev) {
 325       h2->SetBinContent(ircu+1,iev+1,(*v)(iev));
 326     }
 327   }
 328   return h2;
 329 }
 330 //_____________________________________________________________________
 331 TH2C *AliTPCCalibRaw::MakeHistL1RCUEventsOROC(Int_t type)
 332 {
 333   //
 334   // Create a 2D histo RCU:Events indicating the there was a deviation
 335   // from the mean L1 phase of the event
 336   //
 337   TH2C *h2 = new TH2C("hL1FailRCUEventsOROC","L1 Failures OROCs;RCU;Event",144,0,36,GetNevents(),0,GetNevents());
 338   for (Int_t ircu=72;ircu<216;++ircu) {
 339     const TVectorF *v=0;
 340     if (type==0)      v=GetALTROL1PhaseFailEventsRCU(ircu);
 341     else if (type==1) v=GetALTROL1PhaseEventsRCU(ircu);
 342     if (!v) continue;
 343     for (Int_t iev=0;iev<GetNevents();++iev) {
 344       h2->SetBinContent(ircu-72+1,iev+1,(*v)(iev));
 345     }
 346   }
 347   return h2;
 348 }
 349 //_____________________________________________________________________
 350 void AliTPCCalibRaw::CreateDVhist()
 351 {
 352   //
 353   // Setup the HnSparse for the drift velocity determination
 354   //
 355   if (fHnDrift) return;
 356   //HnSparse bins
 357   //time bin, roc, time
 358   Int_t    bins[kHnBinsDV] = {fLastTimeBin-fFirstTimeBin, 72, fNBinsTime};
 359   Double_t xmin[kHnBinsDV] = {fFirstTimeBin,0,0};
 360   Double_t xmax[kHnBinsDV] = {fLastTimeBin,72,fNBinsTime};
 361   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);
 362
 363 }
 364 //_____________________________________________________________________
 365 void AliTPCCalibRaw::Analyse()
 366 {
 367   //
 368   // Analyse Data
 369   //
 370
 371   //resize arrays
 372   fArrALTROL1Phase.ResizeTo(GetNevents());
 373   for (Int_t ircu=0;ircu<216;++ircu){
 374     TVectorF *arr=MakeArrL1PhaseRCU(ircu);//MakeArrL1PhaseRCU(ircu);
 375     if (!arr) continue;
 376     TVectorF *arrF=MakeArrL1PhaseFailRCU(ircu);
 377     arr->ResizeTo(GetNevents());
 378     arrF->ResizeTo(GetNevents());
 379   }
 380
 381   //Analyse drift velocity
 382
 383 }
 384