[u/mrichter/AliRoot.git] / PWG1 / AliAnaVZEROQA.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.                  *
 **************************************************************************/

//------------------------------
// Analysis task for quality-assurance
// of VZERO ESD
//
// 05/12/2009 cvetan.cheshkov@cern.ch
//------------------------------

#include "TChain.h"
#include "TROOT.h"
#include "TFile.h"
#include "TH1F.h"
#include "TH2F.h"
#include "TCanvas.h"
#include "AliLog.h"
#include "AliESDEvent.h"
#include "AliESDVZERO.h"

#include "AliAnaVZEROQA.h"

ClassImp(AliAnaVZEROQA)

AliAnaVZEROQA::AliAnaVZEROQA():
AliAnalysisTaskSE("AliAnaVZEROQA"),
  fListOfHistos(0),

  fhAdcNoTimeA(0),
  fhAdcWithTimeA(0),
  fhAdcNoTimeC(0),
  fhAdcWithTimeC(0),

  fhAdcPMTNoTime(0),
  fhAdcPMTWithTime(0),
 
  fhTimeA(0),
  fhTimeC(0),

  fhWidthA(0),
  fhWidthC(0),

  fhTimePMT(0),
  fhWidthPMT(0),

  fhAdcWidthA(0),
  fhAdcWidthC(0),

  fhTimeCorr(0),

  fhAdcTimeA(0),
  fhAdcTimeC(0),

  fV0a(0),
  fV0c(0),
  fV0multA(0),
  fV0multC(0),
  fV0ampl(0),

  fhTimePMTCorr(0),
  fhEvents(0),

  fhVtxXYBB(0),
  fhVtxZBB(0),
  fhVtxXYBGA(0),
  fhVtxZBGA(0),
  fhVtxXYBGC(0),
  fhVtxZBGC(0)
{
  // Default constructor
  // Define input and output slots here
  // Input slot #0 works with a TChain
  DefineInput(0, TChain::Class());
  // Output slot #1 TList
  DefineOutput(1, TList::Class());
}

AliAnaVZEROQA::AliAnaVZEROQA(const char* name):
AliAnalysisTaskSE(name),
  fListOfHistos(0),
  fhAdcNoTimeA(0),
  fhAdcWithTimeA(0),
  fhAdcNoTimeC(0),
  fhAdcWithTimeC(0),

  fhAdcPMTNoTime(0),
  fhAdcPMTWithTime(0),
 
  fhTimeA(0),
  fhTimeC(0),

  fhWidthA(0),
  fhWidthC(0),

  fhTimePMT(0),
  fhWidthPMT(0),

  fhAdcWidthA(0),
  fhAdcWidthC(0),

  fhTimeCorr(0),

  fhAdcTimeA(0),
  fhAdcTimeC(0),

  fV0a(0),
  fV0c(0),
  fV0multA(0),
  fV0multC(0),
  fV0ampl(0),

  fhTimePMTCorr(0),
  fhEvents(0),

  fhVtxXYBB(0),
  fhVtxZBB(0),
  fhVtxXYBGA(0),
  fhVtxZBGA(0),
  fhVtxXYBGC(0),
  fhVtxZBGC(0)
{
  // Constructor
  AliInfo("Constructor AliAnaVZEROQA");
  // Define input and output slots here
  // Input slot #0 works with a TChain
  DefineInput(0, TChain::Class());
  // Output slot #1 TList
  DefineOutput(1, TList::Class());
}

TH1F * AliAnaVZEROQA::CreateHisto1D(const char* name, const char* title,Int_t nBins, 
				    Double_t xMin, Double_t xMax,
				    const char* xLabel, const char* yLabel)
{
  // create a histogram
  TH1F* result = new TH1F(name, title, nBins, xMin, xMax);
  result->SetOption("E");
  if (xLabel) result->GetXaxis()->SetTitle(xLabel);
  if (yLabel) result->GetYaxis()->SetTitle(yLabel);
  result->SetMarkerStyle(kFullCircle);
  return result;
}

TH2F * AliAnaVZEROQA::CreateHisto2D(const char* name, const char* title,Int_t nBinsX, 
				    Double_t xMin, Double_t xMax,
				    Int_t nBinsY,
				    Double_t yMin, Double_t yMax,
				    const char* xLabel, const char* yLabel)
{
  // create a histogram
  TH2F* result = new TH2F(name, title, nBinsX, xMin, xMax, nBinsY, yMin, yMax);
  if (xLabel) result->GetXaxis()->SetTitle(xLabel);
  if (yLabel) result->GetYaxis()->SetTitle(yLabel);
  return result;
}

void AliAnaVZEROQA::UserCreateOutputObjects()
{
  // Create histograms
  AliInfo("AliAnaVZEROQA::UserCreateOutputObjects");
  // Create output container
  fListOfHistos = new TList();

  fhAdcNoTimeA = CreateHisto1D("hAdcNoTimeA","ADC (no Leading Time) V0A",200,0,200,"ADC charge","Entries");
  fhAdcWithTimeA = CreateHisto1D("hAdcWithTimeA","ADC ( with Leading Time) V0A",200,0,200,"ADC charge","Entries");
  fhAdcNoTimeC = CreateHisto1D("hAdcNoTimeC","ADC (no Leading Time) V0C",200,0,200,"ADC charge","Entries");
  fhAdcWithTimeC = CreateHisto1D("hAdcWithTimeC","ADC ( with Leading Time) V0C",200,0,200,"ADC charge","Entries");
  
  fhAdcPMTNoTime = CreateHisto2D("hadcpmtnotime","ADC vs PMT index (no leading time)",64,-0.5,63.5,200,0,200,"PMT index","ADC charge");
  fhAdcPMTWithTime = CreateHisto2D("hadcpmtwithtime","ADC vs PMT index (with leading time)",64,-0.5,63.5,200,0,200,"PMT index","ADC charge");

  fhTimeA = CreateHisto1D("htimepmtA","Time measured by TDC V0A",400,-100,100,"Leading time (ns)","Entries");
  fhTimeC = CreateHisto1D("htimepmtC","Time measured by TDC V0C",400,-100,100,"Leading time (ns)","Entries");

  fhWidthA = CreateHisto1D("hwidthA","Signal width measured by TDC V0A",200,0,100,"Signal width (ns)","Entries");
  fhWidthC = CreateHisto1D("hwidthC","Signal width measured by TDC V0C",200,0,100,"Signal width (ns)","Entries");

  fhTimePMT = CreateHisto2D("htimepmt","Time measured by TDC vs PMT index",64,-0.5,63.5,200,0,100,"PMT Index","Leading time (ns)");
  fhWidthPMT = CreateHisto2D("hwidthpmt","Time width vs PMT index",64,-0.5,63.5,200,0,100,"PMT Index","Signal width (ns)");

  fhAdcWidthA = CreateHisto2D("hadcwidthA","Time width vs ADC V0A",200,0,200,200,0,100,"ADC charge","Width (ns)");
  fhAdcWidthC = CreateHisto2D("hadcwidthC","Time width vs ADC V0C",200,0,200,200,0,100,"ADC charge","Width (ns)");

  fhTimeCorr = CreateHisto2D("htimecorr","Average time C side vs. A side",200,0,100,200,0,100,"Time V0A (ns)","Time V0C (ns");

  fhAdcTimeA = CreateHisto2D("hAdcTimeA","ADC vs Time V0A",1000,-100,100,200,0,200,"Time (ns)","ADC charge");
  fhAdcTimeC = CreateHisto2D("hAdcTimeC","ADC vs Time V0C",1000,-100,100,200,0,200,"Time (ns)","ADC charge");

  fV0a = CreateHisto1D("hV0a","Number of fired PMTs (V0A)",65,-0.5,64.5);
  fV0c = CreateHisto1D("hV0c","Number of fired PMTs (V0C)",65,-0.5,64.5);
  fV0multA = CreateHisto1D("hV0multA","Total reconstructed multiplicity (V0A)",100,0.,1000.);
  fV0multC = CreateHisto1D("hV0multC","Total reconstructed multiplicity (V0C)",100,0.,1000.);
  fV0ampl  = CreateHisto1D("hV0ampl","V0 multiplicity in single channel (all V0 channels)",400,-0.5,99.5);

  fhTimePMTCorr = CreateHisto2D("htimepmtcorr","Time measured by TDC (corrected for slewing, channels aligned) vs PMT index",64,-0.5,63.5,200,0,100,"PMT Index","Leading time (ns)");
  fhEvents = CreateHisto2D("hEvents","V0C vs V0A (empty,bb,bg)",3,-0.5,2.5,3,-0.5,2.5);

  fhVtxXYBB = CreateHisto2D("fhVtxXYBB","XY SPD vertex (bb)",200,-2,2,200,-2,2);
  fhVtxZBB = CreateHisto1D("fhVtxZBB","Z SPD vertex (bb)",400,-50,50);
  fhVtxXYBGA = CreateHisto2D("fhVtxXYBGA","XY SPD vertex (bga)",200,-2,2,200,-2,2);
  fhVtxZBGA = CreateHisto1D("fhVtxZBGA","Z SPD vertex (bga)",400,-50,50);
  fhVtxXYBGC = CreateHisto2D("fhVtxXYBGC","XY SPD vertex (bgc)",200,-2,2,200,-2,2);
  fhVtxZBGC = CreateHisto1D("fhVtxZBGC","Z SPD vertex (bgc)",400,-50,50);

  fListOfHistos->Add(fhAdcNoTimeA);
  fListOfHistos->Add(fhAdcWithTimeA);
  fListOfHistos->Add(fhAdcNoTimeC);
  fListOfHistos->Add(fhAdcWithTimeC);

  fListOfHistos->Add(fhAdcPMTNoTime);
  fListOfHistos->Add(fhAdcPMTWithTime);
 
  fListOfHistos->Add(fhTimeA);
  fListOfHistos->Add(fhTimeC);

  fListOfHistos->Add(fhWidthA);
  fListOfHistos->Add(fhWidthC);

  fListOfHistos->Add(fhTimePMT);
  fListOfHistos->Add(fhWidthPMT);

  fListOfHistos->Add(fhAdcWidthA);
  fListOfHistos->Add(fhAdcWidthC);

  fListOfHistos->Add(fhTimeCorr);

  fListOfHistos->Add(fhAdcTimeA);
  fListOfHistos->Add(fhAdcTimeC);

  fListOfHistos->Add(fV0a);
  fListOfHistos->Add(fV0c);
  fListOfHistos->Add(fV0multA);
  fListOfHistos->Add(fV0multC);
  fListOfHistos->Add(fV0ampl);

  fListOfHistos->Add(fhTimePMTCorr);
  fListOfHistos->Add(fhEvents);

  fListOfHistos->Add(fhVtxXYBB);
  fListOfHistos->Add(fhVtxZBB);
  fListOfHistos->Add(fhVtxXYBGA);
  fListOfHistos->Add(fhVtxZBGA);
  fListOfHistos->Add(fhVtxXYBGC);
  fListOfHistos->Add(fhVtxZBGC);

  PostData(1, fListOfHistos);
}

void AliAnaVZEROQA::UserExec(Option_t */*option*/)
{
  // Fill the QA histograms
  // using ESD data
  AliVEvent* event = InputEvent();
  if (!event) {
    Printf("ERROR: Could not retrieve event");
    return;
  }

  AliESDEvent* esd = dynamic_cast<AliESDEvent*>(event);
  if (!esd) {
    Printf("ERROR: No ESD event");
    return;
  }
  AliESDVZERO* esdV0 = esd->GetVZEROData();
  if (!esdV0) {
    Printf("ERROR: No ESD VZERO");
    return;
  }

  Float_t timeA = 0,timeC = 0;
  Int_t ntimeA = 0, ntimeC = 0;
  for (Int_t i=0; i<64; ++i) {
      if (esdV0->GetTime(i) < 1e-6) {
	if (i >= 32) {
	  fhAdcNoTimeA->Fill(esdV0->GetAdc(i));
	}
	else {
	  fhAdcNoTimeC->Fill(esdV0->GetAdc(i));
	}
	fhAdcPMTNoTime->Fill(i,esdV0->GetAdc(i));
      }
      else {
	if (i >= 32) {
	  fhAdcWithTimeA->Fill(esdV0->GetAdc(i));
	}
	else {
	  fhAdcWithTimeC->Fill(esdV0->GetAdc(i));
	}
	fhAdcPMTWithTime->Fill(i,esdV0->GetAdc(i));
      }

      if (i >= 32) {
	fhTimeA->Fill(esdV0->GetTime(i));
	fhWidthA->Fill(esdV0->GetWidth(i));
	fhAdcWidthA->Fill(esdV0->GetAdc(i),esdV0->GetTime(i));
	fhAdcTimeA->Fill(esdV0->GetTime(i),esdV0->GetAdc(i));
      }
      else {
	fhTimeC->Fill(esdV0->GetTime(i));
	fhWidthC->Fill(esdV0->GetWidth(i));
	fhAdcWidthC->Fill(esdV0->GetAdc(i),esdV0->GetTime(i));
	fhAdcTimeC->Fill(esdV0->GetTime(i),esdV0->GetAdc(i));
       }
      fhTimePMT->Fill(i,esdV0->GetTime(i));
      fhWidthPMT->Fill(i,esdV0->GetWidth(i));

      Float_t correctedTime = CorrectLeadingTime(i,esdV0->GetTime(i),esdV0->GetAdc(i));
      fhTimePMTCorr->Fill(i,correctedTime);

      if (esdV0->GetTime(i) > 1e-6) {
	if (i >= 32) {
	  timeA += correctedTime;
	  ntimeA++;
	}
	else {
	  timeC += correctedTime;
	  ntimeC++;
	}
      }
  }

  if (ntimeA > 0) timeA = timeA/ntimeA;
  if (ntimeC > 0) timeC = timeC/ntimeC;

  fhTimeCorr->Fill(timeA,timeC);

  Int_t flaga = 0, flagc = 0;
  TString stra("emptyA"),strc("emptyC");
  if (timeA > 48 && timeA < 62) { flaga = 1; stra = "BBA"; }
  if (timeA > 26  && timeA < 33) { flaga = 2; stra = "BGA"; }
  if (timeC > 49 && timeC < 60) { flagc = 1; strc = "BBC"; }
  if (timeC > 43 && timeC < 48.5) { flagc = 2; strc = "BGC"; }

  fhEvents->Fill(flaga,flagc);

  const AliESDVertex *vtx = esd->GetPrimaryVertexSPD();

  if (flaga <= 1 && flagc <=1) {
    fhVtxXYBB->Fill(vtx->GetXv(),vtx->GetYv());
    fhVtxZBB->Fill(vtx->GetZv());
  }
  else {
    if (flaga == 2) {
      fhVtxXYBGA->Fill(vtx->GetXv(),vtx->GetYv());
      fhVtxZBGA->Fill(vtx->GetZv());
    }
    if (flagc == 2) {
      fhVtxXYBGC->Fill(vtx->GetXv(),vtx->GetYv());
      fhVtxZBGC->Fill(vtx->GetZv());
    }
  }

  fV0a->Fill(esdV0->GetNbPMV0A());
  fV0c->Fill(esdV0->GetNbPMV0C());
  fV0multA->Fill(esdV0->GetMTotV0A());
  fV0multC->Fill(esdV0->GetMTotV0C());
  for(Int_t i = 0; i < 64; i++) {
    fV0ampl->Fill(esdV0->GetMultiplicity(i));
  }

  // Post output data.
  PostData(1, fListOfHistos);
}

void AliAnaVZEROQA::Terminate(Option_t *)
{
  // Store the output histograms
  // from the list
  fListOfHistos = dynamic_cast<TList*>(GetOutputData(1));
  if (!fListOfHistos) {
    Printf("ERROR: fListOfHistos not available");
    return;
  }
	
  Info("AliAnaVZEROQA", "Successfully finished");
}

Float_t AliAnaVZEROQA::CorrectLeadingTime(Int_t i, Float_t time, Float_t adc) const
{
  // Correct for slewing and align the channels

  if (time < 1e-6) return 0;

  // Time offsets between channels
  Float_t timeShift[64] = {30.2914 , 30.0019 , 30.7429 , 30.1997 , 30.1511 , 29.6437 , 30.0609 , 29.5452 , 30.1437 , 30.745 , 30.7537 , 30.446 , 30.2771 , 30.838 , 30.3748 , 30.0635 , 30.1786 , 30.282 , 31.0992 , 30.7491 , 30.624 , 30.9268 , 30.6585 , 30.4895 , 31.5815 , 31.3871 , 31.2032 , 31.5778 , 31.0838 , 31.2259 , 31.2122 , 31.5989 , 28.3792 , 28.8325 , 27.8719 , 28.3475 , 26.9925 , 27.9300 , 28.4223 , 28.4996 , 28.2934 , 28.1281 , 27.209 , 28.5327 , 28.1181 , 28.0888 , 29.5111 , 28.6601 , 29.7705 , 29.6531 , 30.3373 , 30.2345 , 30.5935 , 29.8164 , 30.2235 , 29.6505 , 30.1225 , 31.2045 , 30.8399 , 30.6789 , 30.2784 , 31.7028 , 31.4239 , 30.1814};
  time -= timeShift[i];

  // Slewing correction
  if (adc < 1e-6) return time;

  time += 30.;
  if (adc > 300.) adc = 300.;
  if (adc > 70.) {
    return (time -
	    2.93028e+01 +
	    adc*1.25188e-02 -
	    adc*adc*2.68348e-05);
  }
  else {
    return (time -
	    3.52314e+01 +
	    adc*5.99289e-01 -
	    adc*adc*2.74668e-02 +
	    adc*adc*adc*6.61224e-04 -
	    adc*adc*adc*adc*7.77105e-06 +
	    adc*adc*adc*adc*adc*3.51229e-08);
  }
}
Commit	Line	Data
ecb38463	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	//------------------------------
	17	// Analysis task for quality-assurance
	18	// of VZERO ESD
	19	//
	20	// 05/12/2009 cvetan.cheshkov@cern.ch
	21	//------------------------------
	22
	23	#include "TChain.h"
	24	#include "TROOT.h"
	25	#include "TFile.h"
	26	#include "TH1F.h"
	27	#include "TH2F.h"
ecb38463	28	#include "TCanvas.h"
	29	#include "AliLog.h"
	30	#include "AliESDEvent.h"
	31	#include "AliESDVZERO.h"
	32
	33	#include "AliAnaVZEROQA.h"
	34
	35	ClassImp(AliAnaVZEROQA)
	36
	37	AliAnaVZEROQA::AliAnaVZEROQA():
	38	AliAnalysisTaskSE("AliAnaVZEROQA"),
	39	fListOfHistos(0),
	40
	41	fhAdcNoTimeA(0),
	42	fhAdcWithTimeA(0),
	43	fhAdcNoTimeC(0),
	44	fhAdcWithTimeC(0),
	45
	46	fhAdcPMTNoTime(0),
	47	fhAdcPMTWithTime(0),
	48
	49	fhTimeA(0),
	50	fhTimeC(0),
	51
	52	fhWidthA(0),
	53	fhWidthC(0),
	54
	55	fhTimePMT(0),
	56	fhWidthPMT(0),
	57
	58	fhAdcWidthA(0),
	59	fhAdcWidthC(0),
	60
	61	fhTimeCorr(0),
	62
	63	fhAdcTimeA(0),
	64	fhAdcTimeC(0),
	65
	66	fV0a(0),
	67	fV0c(0),
	68	fV0multA(0),
	69	fV0multC(0),
892effee	70	fV0ampl(0),
	71
	72	fhTimePMTCorr(0),
	73	fhEvents(0),
	74
	75	fhVtxXYBB(0),
	76	fhVtxZBB(0),
	77	fhVtxXYBGA(0),
	78	fhVtxZBGA(0),
	79	fhVtxXYBGC(0),
	80	fhVtxZBGC(0)
ecb38463	81	{
	82	// Default constructor
	83	// Define input and output slots here
	84	// Input slot #0 works with a TChain
	85	DefineInput(0, TChain::Class());
	86	// Output slot #1 TList
	87	DefineOutput(1, TList::Class());
	88	}
	89
	90	AliAnaVZEROQA::AliAnaVZEROQA(const char* name):
	91	AliAnalysisTaskSE(name),
	92	fListOfHistos(0),
	93	fhAdcNoTimeA(0),
	94	fhAdcWithTimeA(0),
	95	fhAdcNoTimeC(0),
	96	fhAdcWithTimeC(0),
	97
	98	fhAdcPMTNoTime(0),
	99	fhAdcPMTWithTime(0),
	100
	101	fhTimeA(0),
	102	fhTimeC(0),
	103
	104	fhWidthA(0),
	105	fhWidthC(0),
	106
	107	fhTimePMT(0),
	108	fhWidthPMT(0),
	109
	110	fhAdcWidthA(0),
	111	fhAdcWidthC(0),
	112
	113	fhTimeCorr(0),
	114
	115	fhAdcTimeA(0),
	116	fhAdcTimeC(0),
	117
	118	fV0a(0),
	119	fV0c(0),
	120	fV0multA(0),
	121	fV0multC(0),
892effee	122	fV0ampl(0),
	123
	124	fhTimePMTCorr(0),
	125	fhEvents(0),
	126
	127	fhVtxXYBB(0),
	128	fhVtxZBB(0),
	129	fhVtxXYBGA(0),
	130	fhVtxZBGA(0),
	131	fhVtxXYBGC(0),
	132	fhVtxZBGC(0)
ecb38463	133	{
	134	// Constructor
	135	AliInfo("Constructor AliAnaVZEROQA");
	136	// Define input and output slots here
	137	// Input slot #0 works with a TChain
	138	DefineInput(0, TChain::Class());
	139	// Output slot #1 TList
	140	DefineOutput(1, TList::Class());
	141	}
	142
	143	TH1F * AliAnaVZEROQA::CreateHisto1D(const char* name, const char* title,Int_t nBins,
	144	Double_t xMin, Double_t xMax,
	145	const char* xLabel, const char* yLabel)
	146	{
	147	// create a histogram
	148	TH1F* result = new TH1F(name, title, nBins, xMin, xMax);
	149	result->SetOption("E");
	150	if (xLabel) result->GetXaxis()->SetTitle(xLabel);
	151	if (yLabel) result->GetYaxis()->SetTitle(yLabel);
	152	result->SetMarkerStyle(kFullCircle);
	153	return result;
	154	}
	155
	156	TH2F * AliAnaVZEROQA::CreateHisto2D(const char* name, const char* title,Int_t nBinsX,
	157	Double_t xMin, Double_t xMax,
	158	Int_t nBinsY,
	159	Double_t yMin, Double_t yMax,
	160	const char* xLabel, const char* yLabel)
	161	{
	162	// create a histogram
	163	TH2F* result = new TH2F(name, title, nBinsX, xMin, xMax, nBinsY, yMin, yMax);
	164	if (xLabel) result->GetXaxis()->SetTitle(xLabel);
	165	if (yLabel) result->GetYaxis()->SetTitle(yLabel);
	166	return result;
	167	}
	168
	169	void AliAnaVZEROQA::UserCreateOutputObjects()
	170	{
	171	// Create histograms
	172	AliInfo("AliAnaVZEROQA::UserCreateOutputObjects");
	173	// Create output container
	174	fListOfHistos = new TList();
	175
	176	fhAdcNoTimeA = CreateHisto1D("hAdcNoTimeA","ADC (no Leading Time) V0A",200,0,200,"ADC charge","Entries");
	177	fhAdcWithTimeA = CreateHisto1D("hAdcWithTimeA","ADC ( with Leading Time) V0A",200,0,200,"ADC charge","Entries");
	178	fhAdcNoTimeC = CreateHisto1D("hAdcNoTimeC","ADC (no Leading Time) V0C",200,0,200,"ADC charge","Entries");
	179	fhAdcWithTimeC = CreateHisto1D("hAdcWithTimeC","ADC ( with Leading Time) V0C",200,0,200,"ADC charge","Entries");
	180
	181	fhAdcPMTNoTime = CreateHisto2D("hadcpmtnotime","ADC vs PMT index (no leading time)",64,-0.5,63.5,200,0,200,"PMT index","ADC charge");
	182	fhAdcPMTWithTime = CreateHisto2D("hadcpmtwithtime","ADC vs PMT index (with leading time)",64,-0.5,63.5,200,0,200,"PMT index","ADC charge");
	183
	184	fhTimeA = CreateHisto1D("htimepmtA","Time measured by TDC V0A",400,-100,100,"Leading time (ns)","Entries");
	185	fhTimeC = CreateHisto1D("htimepmtC","Time measured by TDC V0C",400,-100,100,"Leading time (ns)","Entries");
	186
	187	fhWidthA = CreateHisto1D("hwidthA","Signal width measured by TDC V0A",200,0,100,"Signal width (ns)","Entries");
	188	fhWidthC = CreateHisto1D("hwidthC","Signal width measured by TDC V0C",200,0,100,"Signal width (ns)","Entries");
	189
	190	fhTimePMT = CreateHisto2D("htimepmt","Time measured by TDC vs PMT index",64,-0.5,63.5,200,0,100,"PMT Index","Leading time (ns)");
	191	fhWidthPMT = CreateHisto2D("hwidthpmt","Time width vs PMT index",64,-0.5,63.5,200,0,100,"PMT Index","Signal width (ns)");
	192
	193	fhAdcWidthA = CreateHisto2D("hadcwidthA","Time width vs ADC V0A",200,0,200,200,0,100,"ADC charge","Width (ns)");
	194	fhAdcWidthC = CreateHisto2D("hadcwidthC","Time width vs ADC V0C",200,0,200,200,0,100,"ADC charge","Width (ns)");
	195
	196	fhTimeCorr = CreateHisto2D("htimecorr","Average time C side vs. A side",200,0,100,200,0,100,"Time V0A (ns)","Time V0C (ns");
197
198	fhAdcTimeA = CreateHisto2D("hAdcTimeA","ADC vs Time V0A",1000,-100,100,200,0,200,"Time (ns)","ADC charge");
199	fhAdcTimeC = CreateHisto2D("hAdcTimeC","ADC vs Time V0C",1000,-100,100,200,0,200,"Time (ns)","ADC charge");
200
201	fV0a = CreateHisto1D("hV0a","Number of fired PMTs (V0A)",65,-0.5,64.5);
202	fV0c = CreateHisto1D("hV0c","Number of fired PMTs (V0C)",65,-0.5,64.5);
203	fV0multA = CreateHisto1D("hV0multA","Total reconstructed multiplicity (V0A)",100,0.,1000.);
204	fV0multC = CreateHisto1D("hV0multC","Total reconstructed multiplicity (V0C)",100,0.,1000.);
205	fV0ampl = CreateHisto1D("hV0ampl","V0 multiplicity in single channel (all V0 channels)",400,-0.5,99.5);
206
892effee	207	fhTimePMTCorr = CreateHisto2D("htimepmtcorr","Time measured by TDC (corrected for slewing, channels aligned) vs PMT index",64,-0.5,63.5,200,0,100,"PMT Index","Leading time (ns)");
	208	fhEvents = CreateHisto2D("hEvents","V0C vs V0A (empty,bb,bg)",3,-0.5,2.5,3,-0.5,2.5);
	209
	210	fhVtxXYBB = CreateHisto2D("fhVtxXYBB","XY SPD vertex (bb)",200,-2,2,200,-2,2);
	211	fhVtxZBB = CreateHisto1D("fhVtxZBB","Z SPD vertex (bb)",400,-50,50);
	212	fhVtxXYBGA = CreateHisto2D("fhVtxXYBGA","XY SPD vertex (bga)",200,-2,2,200,-2,2);
	213	fhVtxZBGA = CreateHisto1D("fhVtxZBGA","Z SPD vertex (bga)",400,-50,50);
	214	fhVtxXYBGC = CreateHisto2D("fhVtxXYBGC","XY SPD vertex (bgc)",200,-2,2,200,-2,2);
	215	fhVtxZBGC = CreateHisto1D("fhVtxZBGC","Z SPD vertex (bgc)",400,-50,50);
	216
ecb38463	217	fListOfHistos->Add(fhAdcNoTimeA);
	218	fListOfHistos->Add(fhAdcWithTimeA);
	219	fListOfHistos->Add(fhAdcNoTimeC);
	220	fListOfHistos->Add(fhAdcWithTimeC);
	221
	222	fListOfHistos->Add(fhAdcPMTNoTime);
	223	fListOfHistos->Add(fhAdcPMTWithTime);
	224
	225	fListOfHistos->Add(fhTimeA);
	226	fListOfHistos->Add(fhTimeC);
	227
	228	fListOfHistos->Add(fhWidthA);
	229	fListOfHistos->Add(fhWidthC);
	230
	231	fListOfHistos->Add(fhTimePMT);
	232	fListOfHistos->Add(fhWidthPMT);
	233
	234	fListOfHistos->Add(fhAdcWidthA);
	235	fListOfHistos->Add(fhAdcWidthC);
	236
	237	fListOfHistos->Add(fhTimeCorr);
	238
	239	fListOfHistos->Add(fhAdcTimeA);
	240	fListOfHistos->Add(fhAdcTimeC);
	241
	242	fListOfHistos->Add(fV0a);
	243	fListOfHistos->Add(fV0c);
	244	fListOfHistos->Add(fV0multA);
	245	fListOfHistos->Add(fV0multC);
	246	fListOfHistos->Add(fV0ampl);
892effee	247
	248	fListOfHistos->Add(fhTimePMTCorr);
	249	fListOfHistos->Add(fhEvents);
	250
	251	fListOfHistos->Add(fhVtxXYBB);
	252	fListOfHistos->Add(fhVtxZBB);
	253	fListOfHistos->Add(fhVtxXYBGA);
	254	fListOfHistos->Add(fhVtxZBGA);
	255	fListOfHistos->Add(fhVtxXYBGC);
	256	fListOfHistos->Add(fhVtxZBGC);
3b5284bd	257
3b5284bd	258	PostData(1, fListOfHistos);
ecb38463	259	}
	260
	261	void AliAnaVZEROQA::UserExec(Option_t /option*/)
	262	{
f0a651f0	263	// Fill the QA histograms
f0a651f0	264	// using ESD data
ecb38463	265	AliVEvent* event = InputEvent();
	266	if (!event) {
	267	Printf("ERROR: Could not retrieve event");
	268	return;
	269	}
	270
	271	AliESDEvent* esd = dynamic_cast<AliESDEvent*>(event);
713a03ae	272	if (!esd) {
	273	Printf("ERROR: No ESD event");
	274	return;
	275	}
ecb38463	276	AliESDVZERO* esdV0 = esd->GetVZEROData();
713a03ae	277	if (!esdV0) {
	278	Printf("ERROR: No ESD VZERO");
	279	return;
	280	}
ecb38463	281
	282	Float_t timeA = 0,timeC = 0;
	283	Int_t ntimeA = 0, ntimeC = 0;
	284	for (Int_t i=0; i<64; ++i) {
	285	if (esdV0->GetTime(i) < 1e-6) {
	286	if (i >= 32) {
	287	fhAdcNoTimeA->Fill(esdV0->GetAdc(i));
	288	}
	289	else {
	290	fhAdcNoTimeC->Fill(esdV0->GetAdc(i));
	291	}
	292	fhAdcPMTNoTime->Fill(i,esdV0->GetAdc(i));
	293	}
	294	else {
	295	if (i >= 32) {
	296	fhAdcWithTimeA->Fill(esdV0->GetAdc(i));
	297	}
	298	else {
	299	fhAdcWithTimeC->Fill(esdV0->GetAdc(i));
	300	}
	301	fhAdcPMTWithTime->Fill(i,esdV0->GetAdc(i));
	302	}
	303
	304	if (i >= 32) {
	305	fhTimeA->Fill(esdV0->GetTime(i));
	306	fhWidthA->Fill(esdV0->GetWidth(i));
	307	fhAdcWidthA->Fill(esdV0->GetAdc(i),esdV0->GetTime(i));
	308	fhAdcTimeA->Fill(esdV0->GetTime(i),esdV0->GetAdc(i));
	309	}
	310	else {
	311	fhTimeC->Fill(esdV0->GetTime(i));
	312	fhWidthC->Fill(esdV0->GetWidth(i));
	313	fhAdcWidthC->Fill(esdV0->GetAdc(i),esdV0->GetTime(i));
	314	fhAdcTimeC->Fill(esdV0->GetTime(i),esdV0->GetAdc(i));
	315	}
	316	fhTimePMT->Fill(i,esdV0->GetTime(i));
	317	fhWidthPMT->Fill(i,esdV0->GetWidth(i));
	318
892effee	319	Float_t correctedTime = CorrectLeadingTime(i,esdV0->GetTime(i),esdV0->GetAdc(i));
	320	fhTimePMTCorr->Fill(i,correctedTime);
	321
ecb38463	322	if (esdV0->GetTime(i) > 1e-6) {
ecb38463	323	if (i >= 32) {
892effee	324	timeA += correctedTime;
ecb38463	325	ntimeA++;
	326	}
	327	else {
892effee	328	timeC += correctedTime;
ecb38463	329	ntimeC++;
	330	}
	331	}
	332	}
	333
	334	if (ntimeA > 0) timeA = timeA/ntimeA;
	335	if (ntimeC > 0) timeC = timeC/ntimeC;
	336
	337	fhTimeCorr->Fill(timeA,timeC);
	338
892effee	339	Int_t flaga = 0, flagc = 0;
	340	TString stra("emptyA"),strc("emptyC");
	341	if (timeA > 48 && timeA < 62) { flaga = 1; stra = "BBA"; }
	342	if (timeA > 26 && timeA < 33) { flaga = 2; stra = "BGA"; }
	343	if (timeC > 49 && timeC < 60) { flagc = 1; strc = "BBC"; }
	344	if (timeC > 43 && timeC < 48.5) { flagc = 2; strc = "BGC"; }
	345
	346	fhEvents->Fill(flaga,flagc);
	347
	348	const AliESDVertex *vtx = esd->GetPrimaryVertexSPD();
	349
	350	if (flaga <= 1 && flagc <=1) {
	351	fhVtxXYBB->Fill(vtx->GetXv(),vtx->GetYv());
	352	fhVtxZBB->Fill(vtx->GetZv());
	353	}
	354	else {
	355	if (flaga == 2) {
	356	fhVtxXYBGA->Fill(vtx->GetXv(),vtx->GetYv());
	357	fhVtxZBGA->Fill(vtx->GetZv());
	358	}
	359	if (flagc == 2) {
	360	fhVtxXYBGC->Fill(vtx->GetXv(),vtx->GetYv());
	361	fhVtxZBGC->Fill(vtx->GetZv());
	362	}
	363	}
	364
ecb38463	365	fV0a->Fill(esdV0->GetNbPMV0A());
	366	fV0c->Fill(esdV0->GetNbPMV0C());
	367	fV0multA->Fill(esdV0->GetMTotV0A());
	368	fV0multC->Fill(esdV0->GetMTotV0C());
	369	for(Int_t i = 0; i < 64; i++) {
	370	fV0ampl->Fill(esdV0->GetMultiplicity(i));
	371	}
	372
	373	// Post output data.
	374	PostData(1, fListOfHistos);
	375	}
	376
	377	void AliAnaVZEROQA::Terminate(Option_t *)
	378	{
f0a651f0	379	// Store the output histograms
f0a651f0	380	// from the list
ecb38463	381	fListOfHistos = dynamic_cast<TList*>(GetOutputData(1));
	382	if (!fListOfHistos) {
	383	Printf("ERROR: fListOfHistos not available");
	384	return;
	385	}
	386
ecb38463	387	Info("AliAnaVZEROQA", "Successfully finished");
	388	}
	389
f0a651f0	390	Float_t AliAnaVZEROQA::CorrectLeadingTime(Int_t i, Float_t time, Float_t adc) const
892effee	391	{
	392	// Correct for slewing and align the channels
	393
f0a651f0	394	if (time < 1e-6) return 0;
892effee	395
	396	// Time offsets between channels
	397	Float_t timeShift[64] = {30.2914 , 30.0019 , 30.7429 , 30.1997 , 30.1511 , 29.6437 , 30.0609 , 29.5452 , 30.1437 , 30.745 , 30.7537 , 30.446 , 30.2771 , 30.838 , 30.3748 , 30.0635 , 30.1786 , 30.282 , 31.0992 , 30.7491 , 30.624 , 30.9268 , 30.6585 , 30.4895 , 31.5815 , 31.3871 , 31.2032 , 31.5778 , 31.0838 , 31.2259 , 31.2122 , 31.5989 , 28.3792 , 28.8325 , 27.8719 , 28.3475 , 26.9925 , 27.9300 , 28.4223 , 28.4996 , 28.2934 , 28.1281 , 27.209 , 28.5327 , 28.1181 , 28.0888 , 29.5111 , 28.6601 , 29.7705 , 29.6531 , 30.3373 , 30.2345 , 30.5935 , 29.8164 , 30.2235 , 29.6505 , 30.1225 , 31.2045 , 30.8399 , 30.6789 , 30.2784 , 31.7028 , 31.4239 , 30.1814};
	398	time -= timeShift[i];
	399
	400	// Slewing correction
f0a651f0	401	if (adc < 1e-6) return time;
892effee	402
	403	time += 30.;
	404	if (adc > 300.) adc = 300.;
	405	if (adc > 70.) {
	406	return (time -
	407	2.93028e+01 +
	408	adc*1.25188e-02 -
	409	adcadc2.68348e-05);
	410	}
	411	else {
	412	return (time -
	413	3.52314e+01 +
	414	adc*5.99289e-01 -
	415	adcadc2.74668e-02 +
	416	adcadcadc*6.61224e-04 -
	417	adcadcadcadc7.77105e-06 +
	418	adcadcadcadcadc*3.51229e-08);
	419	}
	420	}
ecb38463	421
	422
	423
	424
	425
	426
	427
	428
	429
	430
	431
	432
	433
	434
	435
	436
	437
	438
	439
	440
	441
	442
	443
	444
	445
	446
	447
	448
	449
	450
	451
	452
	453
	454
	455
	456
	457
	458
	459
	460
	461
	462
	463
	464
	465
	466
	467
	468
	469
	470
	471
	472
	473
	474
	475
	476
	477
	478
	479
	480
	481