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