[u/mrichter/AliRoot.git] / TPC / AliTPCCalibRaw.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id:  $ */

////////////////////////////////////////////////////////////////////////////////////////
//                                                                                    //
//     Implementation of the TPC Raw drift velocity and Altro L1 Phase  calibration   //
//                                                                                    //
//               Origin: Jens Wiechula, J.Wiechula@gsi.de                             //
//                                                                                    //
////////////////////////////////////////////////////////////////////////////////////////
//
//
// *************************************************************************************
// *                                Class Description                                  *
// *************************************************************************************
/*

----example---
TFile f("CalibAltro.root");
AliTPCCalibRaw *al=(AliTPCCalibRaw*)f.Get(f.GetListOfKeys()->At(0)->GetName())
{
TCanvas *c1=(TCanvas*)gROOT->FindObject("c1");
if (!c1) c1=new TCanvas("c1","c1");
c1->Clear();

TH2F h2f("h2","h2;RCU;fail",216,0,216,al->GetNevents(),0,al->GetNevents());
Bool_t first=kTRUE;
Int_t i,iev;
for (i=0;i<216;++i) {
  TVectorF *v=al->GetALTROL1PhaseFailEventsRCU(i);
  if (!v) continue;
  for (iev=0;iev<al->GetNevents();++iev) {
    h2f->SetBinContent(i+1,iev+1,(*v)(iev));
  }
//   TH1F h(*v);
//   h.SetLineColor(i/216.*50+50);
//   ((TH1F*)h.Clone(Form("h%d",i)))->Draw(first?"":"same");
//   c1->Modified();
//   c1->Update();
  first=kFALSE;
}
h2f->Draw("col");
}

*/


//Root includes
#include <TH2C.h>

//AliRoot includes
#include "AliTPCCalROC.h"
#include "AliAltroRawStream.h"
#include "AliLog.h"

//class header
#include "AliTPCCalibRaw.h"

ClassImp(AliTPCCalibRaw)

AliTPCCalibRaw::AliTPCCalibRaw() :
  AliTPCCalibRawBase(),
  fPeakDetMinus(1),
  fPeakDetPlus(2),
  fNFailL1Phase(0),
  fFirstTimeStamp(0),
  fNSecTime(600), //default 10 minutes
  fNBinsTime(60), //default 60*10 minutes = 10 hours
  fPadProcessed(kFALSE),
  fCurrentChannel(-1),
  fCurrentSector(-1),
  fLastSector(-2),
  fCurrentRow(-1),
  fCurrentPad(-1),
  fLastTimeBinProc(0),
  fPeakTimeBin(0),
  fLastSignal(0),
  fNOkPlus(0),
  fNOkMinus(0),
  fArrCurrentPhaseDist(4),
  fArrALTROL1Phase(1000),
  fArrALTROL1PhaseEvent(216),
  fArrALTROL1PhaseFailEvent(216),
  fHnDrift(0x0)
{
  //
  // Default ctor
  //
  SetNameTitle("AliTPCCalibRaw","AliTPCCalibRaw");
  CreateDVhist();
  fFirstTimeBin=850;
  fLastTimeBin=1000;
}
//_____________________________________________________________________
AliTPCCalibRaw::~AliTPCCalibRaw()
{
  //
  // dtor
  //
  delete fHnDrift;  
}
//_____________________________________________________________________
// AliTPCCalibRaw& AliTPCCalibRaw::operator = (const  AliTPCCalibRaw &source)
// {
//   //
//   // assignment operator
//   //
//   if (&source == this) return *this;
//   new (this) AliTPCCalibRaw(source);
//   
//   return *this;
// }

//_____________________________________________________________________
Int_t AliTPCCalibRaw::Update(const Int_t isector, const Int_t iRow, const Int_t iPad,
             const Int_t iTimeBin, const Float_t signal)
{
  //
  // Data filling method
  //
  if (iRow<0) return 0;
  if (iPad<0) return 0;
  if (iTimeBin<0) return 0;
  if (!fFirstTimeStamp) fFirstTimeStamp=GetTimeStamp();
  if (fCurrDDLNum!=fPrevDDLNum){
    TVectorF *arr=MakeArrL1PhaseRCU(fCurrDDLNum,kTRUE);
    if (arr->GetNrows()<=fNevents) arr->ResizeTo(arr->GetNrows()+1000);
    // phase as a position of a quarter time bin
    Int_t phase=(Int_t)(GetL1PhaseTB()*4.);
//     printf("DDL: %03d, phase: %d (%f))\n",fCurrDDLNum,phase,GetL1PhaseTB());
    //Fill pahse information of current rcu and event
    (arr->GetMatrixArray())[fNevents]=phase;
    //increase phase counter 
    ++((fArrCurrentPhaseDist.GetMatrixArray())[phase]);
//     printf("RCUId: %03d (%03d), DDL: %03d, sector: %02d\n",fCurrRCUId, fPrevRCUId, fCurrDDLNum, isector);
  }

  if ( (iTimeBin>fLastTimeBin) || (iTimeBin<fFirstTimeBin)   ) return 0;
  //don't process edge pads
  if (IsEdgePad(isector,iRow,iPad)) return 0;
//   Double_t x[kHnBinsDV]={1,isector,0};
//   fHnDrift->Fill(x);
  Int_t iChannel  = fROC->GetRowIndexes(isector)[iRow]+iPad; //  global pad position in sector
  if (fCurrentChannel==iChannel){
    if (fPadProcessed) return 0;
  } else {
    fPadProcessed=kFALSE;
    fNOkPlus=0;
    fNOkMinus=0;
    fPeakTimeBin=0;
    fLastSignal=0;
  }
//   Double_t x2[kHnBinsDV]={2,isector,0};
//   fHnDrift->Fill(x2);
  

  if (signal>fLastSignal) ++fNOkPlus;
  else if(signal<fLastSignal && fNOkPlus>=fPeakDetPlus){
    ++fNOkMinus;
    if (!fPeakTimeBin) fPeakTimeBin=fLastTimeBinProc;
    if ( fNOkMinus>=fPeakDetMinus ) {
      Double_t x[kHnBinsDV]={fPeakTimeBin,isector,(fTimeStamp-fFirstTimeStamp)/fNSecTime};
      fHnDrift->Fill(x);
    } 
  } else {
    fNOkPlus=0;
    fNOkMinus=0;
    fPeakTimeBin=0;
    fLastSignal=0;
  }

  fLastTimeBinProc=iTimeBin;
  fLastSignal=TMath::Nint(signal);
  fCurrentChannel = iChannel;
  return 0;
}
//_____________________________________________________________________
void AliTPCCalibRaw::ResetEvent()
{
  //
  // Reset event counters
  //

  fCurrentChannel=-1;
  fArrCurrentPhaseDist.Zero();
}
//_____________________________________________________________________
void AliTPCCalibRaw::EndEvent()
{
  //
  // End event analysis
  //

  
  //find phase of the current event
  Int_t phaseMaxEntries=-1;
  Int_t maxEntries=0;
  for (Int_t i=0;i<fArrCurrentPhaseDist.GetNrows();++i){
    Int_t entries=(Int_t)fArrCurrentPhaseDist[i];
    if (maxEntries<entries) {
      maxEntries=entries;
      phaseMaxEntries=i;
    }
  }
  // store phase of current event
  if (fArrALTROL1Phase.GetNrows()<=GetNevents())
    fArrALTROL1Phase.ResizeTo(GetNevents()+1000);
  (fArrALTROL1Phase.GetMatrixArray())[GetNevents()]=phaseMaxEntries;
  
  //loop over RCUs and test failures
  for (Int_t ircu=0;ircu<216;++ircu){
    const TVectorF *arr=GetALTROL1PhaseEventsRCU(ircu);//MakeArrL1PhaseRCU(ircu);
    if (!arr) continue;
    TVectorF *arrF=MakeArrL1PhaseFailRCU(ircu,kTRUE);
    if (arrF->GetNrows()<=fNevents) arrF->ResizeTo(arrF->GetNrows()+1000);
    if ((arr->GetMatrixArray())[fNevents]!=phaseMaxEntries){
      (arrF->GetMatrixArray())[fNevents]=1;
      ++fNFailL1Phase;
      }
  }
  IncrementNevents();
}
//_____________________________________________________________________
TH2C *AliTPCCalibRaw::MakeHistL1RCUEvents(Int_t type)
{
  // Create a 2D histo RCU:Events indicating the there was a deviation
  // from the mean L1 phase of the event
  //
  //type: 0=Failures, 1=Phases
  TH2C *h2 = new TH2C("hL1FailRCUEvents","L1 Failures;RCU;Event",216,0,216,GetNevents(),0,GetNevents());
  for (Int_t ircu=0;ircu<216;++ircu) {
    const TVectorF *v=0;
    if (type==0)      v=GetALTROL1PhaseFailEventsRCU(ircu);
    else if (type==1) v=GetALTROL1PhaseEventsRCU(ircu);
    if (!v) continue;
    for (Int_t iev=0;iev<GetNevents();++iev) {
      h2->SetBinContent(ircu+1,iev+1,(*v)(iev)+1);
    }
  }
  return h2;
}
//_____________________________________________________________________
TH2C *AliTPCCalibRaw::MakeHistL1RCUEventsIROC(Int_t type)
{
  //
  // Create a 2D histo RCU:Events indicating the there was a deviation
  // from the mean L1 phase of the event
  //
  TH2C *h2 = new TH2C("hL1FailRCUEventsIROC","L1 Failures IROCs;RCU;Event",72,0,36,GetNevents(),0,GetNevents());
  for (Int_t ircu=0;ircu<72;++ircu) {
    const TVectorF *v=0;
    if (type==0)      v=GetALTROL1PhaseFailEventsRCU(ircu);
    else if (type==1) v=GetALTROL1PhaseEventsRCU(ircu);
    if (!v) continue;
    for (Int_t iev=0;iev<GetNevents();++iev) {
      h2->SetBinContent(ircu+1,iev+1,(*v)(iev)+1);
    }
  }
  return h2;
}
//_____________________________________________________________________
TH2C *AliTPCCalibRaw::MakeHistL1RCUEventsOROC(Int_t type)
{
  //
  // Create a 2D histo RCU:Events indicating the there was a deviation
  // from the mean L1 phase of the event
  //
  TH2C *h2 = new TH2C("hL1FailRCUEventsOROC","L1 Failures OROCs;RCU;Event",144,0,36,GetNevents(),0,GetNevents());
  for (Int_t ircu=72;ircu<216;++ircu) {
    const TVectorF *v=0;
    if (type==0)      v=GetALTROL1PhaseFailEventsRCU(ircu);
    else if (type==1) v=GetALTROL1PhaseEventsRCU(ircu);
    if (!v) continue;
    for (Int_t iev=0;iev<GetNevents();++iev) {
      h2->SetBinContent(ircu-72+1,iev+1,(*v)(iev)+1);
    }
  }
  return h2;
}
//_____________________________________________________________________
void AliTPCCalibRaw::CreateDVhist()
{
  //
  // Setup the HnSparse for the drift velocity determination
  //
  if (fHnDrift) return;
  //HnSparse bins
  //time bin, roc, time
  Int_t    bins[kHnBinsDV] = {1000, 72, fNBinsTime};
  Double_t xmin[kHnBinsDV] = {0,0,0};
  Double_t xmax[kHnBinsDV] = {1000,72,fNBinsTime};
  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);
    
}
//_____________________________________________________________________
void AliTPCCalibRaw::Analyse()
{
  //
  // Analyse Data
  //

  //resize arrays
  fArrALTROL1Phase.ResizeTo(GetNevents());
  for (Int_t ircu=0;ircu<216;++ircu){
    TVectorF *arr=MakeArrL1PhaseRCU(ircu);//MakeArrL1PhaseRCU(ircu);
    if (!arr) continue;
    TVectorF *arrF=MakeArrL1PhaseFailRCU(ircu);
    arr->ResizeTo(GetNevents());
    arrF->ResizeTo(GetNevents());
  }

  //Analyse drift velocity
  
}
Commit	Line	Data
ddeb9c4f	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