[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>
#include <TMap.h>
#include <TObjString.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=1020;
}
//_____________________________________________________________________
AliTPCCalibRaw::AliTPCCalibRaw(const TMap *config) :
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=1020;
  if (config->GetValue("FirstTimeBin")) fFirstTimeBin = ((TObjString*)config->GetValue("FirstTimeBin"))->GetString().Atoi();
  if (config->GetValue("LastTimeBin")) fLastTimeBin = ((TObjString*)config->GetValue("LastTimeBin"))->GetString().Atoi();
}

//_____________________________________________________________________
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 ( (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::UpdateDDL(){
  //
  // fill ALTRO L1 information
  //
//   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);
//   }
  
}
//_____________________________________________________________________
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());
  Int_t add=0;
  for (Int_t ircu=0;ircu<216;++ircu) {
    const TVectorF *v=0;
    if (type==0){
      v=GetALTROL1PhaseFailEventsRCU(ircu);
      add=1;
      h2->SetMinimum(0);
      h2->SetMaximum(2);
    } else if (type==1) {
      v=GetALTROL1PhaseEventsRCU(ircu);
      add=0;
      h2->SetMinimum(0);
      h2->SetMaximum(4);
    }
    if (!v) continue;
    for (Int_t iev=0;iev<GetNevents();++iev) {
      h2->SetBinContent(ircu+1,iev+1,(*v)(iev)+add);
    }
  }
  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));
    }
  }
  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));
    }
  }
  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] = {fLastTimeBin-fFirstTimeBin, 72, fNBinsTime};
  Double_t xmin[kHnBinsDV] = {fFirstTimeBin,0,0};
  Double_t xmax[kHnBinsDV] = {fLastTimeBin,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>
f113dfeb	65	#include <TMap.h>
f113dfeb	66	#include <TObjString.h>
ddeb9c4f	67
	68	//AliRoot includes
	69	#include "AliTPCCalROC.h"
	70	#include "AliAltroRawStream.h"
	71	#include "AliLog.h"
ddeb9c4f	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;
f113dfeb	108	fLastTimeBin=1020;
ddeb9c4f	109	}
f113dfeb	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
ddeb9c4f	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();
ddeb9c4f	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;
5312f439	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.);
d73f0401	227	// printf("DDL: %03d, phase: %d (%f))\n",fCurrDDLNum,phase,GetL1PhaseTB());
5312f439	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
ddeb9c4f	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());
5312f439	290	Int_t add=0;
ddeb9c4f	291	for (Int_t ircu=0;ircu<216;++ircu) {
ddeb9c4f	292	const TVectorF *v=0;
5312f439	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	}
ddeb9c4f	304	if (!v) continue;
ddeb9c4f	305	for (Int_t iev=0;iev<GetNevents();++iev) {
5312f439	306	h2->SetBinContent(ircu+1,iev+1,(*v)(iev)+add);
ddeb9c4f	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) {
5312f439	325	h2->SetBinContent(ircu+1,iev+1,(*v)(iev));
ddeb9c4f	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) {
5312f439	344	h2->SetBinContent(ircu-72+1,iev+1,(*v)(iev));
ddeb9c4f	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
f113dfeb	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};
ddeb9c4f	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