[u/mrichter/AliRoot.git] / PWGUD / DIFFRACTIVE / QA / AliAnalysisTaskCPQA.cxx

// QA task for central production study
// author: Martin Poghosyan

#include <TList.h>
#include <TTree.h>
#include <TH1F.h>
#include <TH2F.h>
#include <TH3F.h>


#include "AliVEvent.h"
#include "AliESDEvent.h"
#include "AliESDtrack.h"
#include "AliHeader.h"
#include "AliESDInputHandler.h"
#include "AliAnalysisManager.h"
#include "AliMultiplicity.h"
#include "AliTriggerAnalysis.h"
#include "AliESDVertex.h"
#include "AliESDtrackCuts.h"

#include "AliAnalysisTaskCPQA.h"


ClassImp(AliAnalysisTaskCPQA)

//________________________________________________________________________
  AliAnalysisTaskCPQA::AliAnalysisTaskCPQA(const char *name)
  : AliAnalysisTaskSE(name),
  fUseMC(kFALSE),
  fESD(0),
  fOutputList(0),
  fhEvent(0),
  fTriggerAnalysis(0)
{
  for(Int_t i = 0; i<4; i++)
    {
      fhV0A[i]=0;
      fhV0C[i]=0;
      fhV0online[i]=0;
      fhV0offline[i]=0;
      fhSPDFiredChip[i]=0;
      fhSPDFastOrChip[i]=0;
      fhReferenceMultiplicity[i]=0;
      fhVtxTrack[i]=0;
    }

//  fEtaMaxM = 2;
//  fEtaMaxD = 0.9;
//fVtxZmax = 10;

  DefineOutput(1, TList::Class());
}

AliAnalysisTaskCPQA::~AliAnalysisTaskCPQA() 
{
   if (fOutputList && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) {
    printf("Deleteing output\n");

    if(fOutputList){
      delete fOutputList;
      fOutputList = 0;
    }

        if(fTriggerAnalysis)
          delete fTriggerAnalysis;

   }
}


//________________________________________________________________________
void AliAnalysisTaskCPQA::UserCreateOutputObjects()
{
  fTriggerAnalysis = new AliTriggerAnalysis();
  if (fUseMC) fTriggerAnalysis->SetAnalyzeMC(1);

  // Create histograms
  // Called once

  fOutputList = new TList();
  fOutputList->SetOwner();


  fhEvent = new TH1F("hEvent","hEvent",100, -0.5, 99.5); 
  fOutputList->Add(fhEvent);

  for(Int_t i = 0; i<4; i++)
    {
      fhV0A[i] = Hist2D(Form("hV0A_%d",i), 5, -1.5, 3.5, 5, -1.5, 3.5,"V0A_{online}","V0A_{offline}"); fOutputList->Add(fhV0A[i]);
      fhV0C[i] = Hist2D(Form("hV0C_%d",i), 5, -1.5, 3.5, 5, -1.5, 3.5,"V0C_{online}","V0C_{offline}"); fOutputList->Add(fhV0C[i]);
      fhV0online[i]  = Hist2D(Form("hV0online_%d",i) , 5, -1.5, 3.5, 5, -1.5, 3.5,"V0C_{online}","V0A_{online}"); fOutputList->Add(fhV0online[i]);
      fhV0offline[i] = Hist2D(Form("hV0offline_%d",i), 5, -1.5, 3.5, 5, -1.5, 3.5,"V0C_{offline}","V0A_{offline}"); fOutputList->Add(fhV0offline[i]);
      fhSPDFiredChip[i] = Hist1D(Form("fhSPDFiredChip_%d",i), 1200, -0.5, 1199.5); fOutputList->Add(fhSPDFiredChip[i]);
      fhSPDFastOrChip[i] = Hist1D(Form("fhSPDFastOrChip_%d",i), 1200, -0.5, 1199.5); fOutputList->Add(fhSPDFastOrChip[i]);
      fhReferenceMultiplicity[i] = Hist1D(Form("fhReferenceMultiplicity_%d",i), 50, -10.5, 39.5);  fOutputList->Add(fhReferenceMultiplicity[i]);
      fhVtxTrack[i] = Hist3D(Form("fhVtxTrack_%d",i), 100, -1, 1, 100, -1, 1, 1000, -30, 30, "x_{vtx}", "y_{vtx}", "z_{vtx}"); fOutputList->Add(fhVtxTrack[i]);
   }

  PostData(1, fOutputList);
 

}


TH1F* AliAnalysisTaskCPQA::Hist1D(const char* name, Int_t nBins, Double_t xMin, Double_t xMax,  const char* xLabel, Int_t color, Int_t lst, const char* yLabel)
{
// create a 1D histogram

  TH1F* res = new TH1F(name, name, nBins, xMin, xMax);
  if (xLabel) res->GetXaxis()->SetTitle(xLabel);
  if (yLabel) res->GetYaxis()->SetTitle(yLabel);
  res->SetLineColor(color);
  res->SetMarkerColor(color);
  res->SetLineStyle(lst);
  return res;
}


TH2F *AliAnalysisTaskCPQA::Hist2D(const char* name, Int_t nBinsx, Double_t xMin, Double_t xMax, Int_t nBinsy, Double_t yMin, Double_t yMax, const char* xLabel, const char* yLabel, Int_t color)
{
// create a 2D histogram

  TH2F *res = new TH2F(name, name, nBinsx, xMin, xMax, nBinsy, yMin, yMax);
  if (xLabel) res->GetXaxis()->SetTitle(xLabel);
  if (yLabel) res->GetYaxis()->SetTitle(yLabel);
  //  res->SetMarkerStyle(kFullCircle);
  //  res->SetOption("E");
  res->SetLineColor(color);
  //  fOutputList->Add(res);
  return res;
}

  TH3F *AliAnalysisTaskCPQA::Hist3D(const char* name, Int_t nBinsx, Double_t xMin, Double_t xMax, Int_t nBinsy, Double_t yMin, Double_t yMax,  Int_t nBinsz, Double_t zMin, Double_t zMax, const char* xLabel, const char* yLabel, const char *zLabel)
{
// create a 3D histogram

  TH3F *res = new TH3F(name, name, nBinsx, xMin, xMax, nBinsy, yMin, yMax, nBinsz, zMin, zMax);
  if (xLabel) res->GetXaxis()->SetTitle(xLabel);
  if (yLabel) res->GetYaxis()->SetTitle(yLabel);
  if (zLabel) res->GetZaxis()->SetTitle(zLabel);
  //  res->SetMarkerStyle(kFullCircle);
  //  res->SetOption("E");
  //  res->SetLineColor(color);
  //  fOutputList->Add(res);
  return res;
}


//________________________________________________________________________
void AliAnalysisTaskCPQA::UserExec(Option_t *)
{
  // Main loop
  // Called for each event

  //    return;
  AliVEvent *event = InputEvent();
  if (!event) {
     Error("UserExec", "Could not retrieve event");
     return;
  }

  fESD = dynamic_cast<AliESDEvent*> (InputEvent());
  if (fESD) {
    LoopESD();
      if (fUseMC)
         LoopESDMC();
  }


  PostData(1, fOutputList);
}      

//________________________________________________________________________
void AliAnalysisTaskCPQA::Terminate(Option_t*)
{
 
}


void AliAnalysisTaskCPQA::LoopESDMC()
{
  // Main loop
  // Called for each event
  /*

  Int_t indexD1 = 1;
  Int_t indexD2 = 2;


  AliMCEvent *mcEvent = (AliMCEvent*) MCEvent();
  if (!mcEvent) {
    Error("LoopESDMC", "Could not retrieve MC event");
    return;
  }


  AliHeader* header = mcEvent->Header();
  if (!header)
    {
          AliDebug(AliLog::kError, "Header not available");
          return;
    }

  AliGenEventHeader* genHeader = header->GenEventHeader();
  if(!genHeader)
    {
      AliDebug(AliLog::kError, "GenHeader not available");
      return;
    }

*/  
 

}


//________________________________________________________________________
void AliAnalysisTaskCPQA::LoopESD()
{
   Int_t TrType = 0;
   Bool_t fkIsPhysSel = kFALSE;

  fhEvent->Fill(0);

  if(!fUseMC)
    {
      TrType = -1;
      if(fESD->IsTriggerClassFired("CINT1-B-NOPF-ALLNOTRD"))        TrType=0;
      else if(fESD->IsTriggerClassFired("CINT1-AC-NOPF-ALLNOTRD"))  TrType=1;
      else if(fESD->IsTriggerClassFired("CINT1-E-NOPF-ALLNOTRD"))   TrType=3;

      else if(fESD->IsTriggerClassFired("CINT1-B-NOPF-FASTNOTRD"))  TrType=0;
      else if(fESD->IsTriggerClassFired("CINT1-AC-NOPF-FASTNOTRD")) TrType=1;
      else if(fESD->IsTriggerClassFired("CINT1-E-NOPF-FASTNOTRD"))  TrType=3;

      else if(fESD->IsTriggerClassFired("CINT1B-ABCE-NOPF-ALL"))  TrType=0;
      else if(fESD->IsTriggerClassFired("CINT1A-ABCE-NOPF-ALL"))  TrType=1;
      else if(fESD->IsTriggerClassFired("CINT1C-ABCE-NOPF-ALL"))  TrType=2;
      else if(fESD->IsTriggerClassFired("CINT1-E-NOPF-ALL"))      TrType=3;

      UInt_t mask =  ((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected();
      fkIsPhysSel=(mask & AliVEvent::kMB) ? 1 : 0; // check if minimum bias trigger class fired
 

      if(!fkIsPhysSel) return;
      printf("TrType = %d\n",TrType);
      if(TrType==-1) return;
    }

  fhEvent->Fill(1);


  Int_t V0Aonline  = fTriggerAnalysis->V0Trigger(fESD, AliTriggerAnalysis::kASide, kTRUE) ;
  Int_t V0Conline  = fTriggerAnalysis->V0Trigger(fESD, AliTriggerAnalysis::kCSide, kTRUE) ;
  Int_t V0Aoffline = fTriggerAnalysis->V0Trigger(fESD, AliTriggerAnalysis::kASide, kFALSE) ;
  Int_t V0Coffline = fTriggerAnalysis->V0Trigger(fESD, AliTriggerAnalysis::kCSide, kFALSE) ;


  fhV0A[TrType]->Fill(V0Aonline, V0Aoffline);
  fhV0C[TrType]->Fill(V0Conline, V0Coffline);
  fhV0online[TrType]->Fill(V0Conline, V0Aonline);
  fhV0offline[TrType]->Fill(V0Coffline, V0Aoffline);


  if(V0Aoffline!=0 || V0Coffline!=0) 
    {
      return;
    }
 
  fhEvent->Fill(2);

  const AliMultiplicity *mult = fESD->GetMultiplicity();
  for (Int_t i=0; i<1200; i++)
    {
      if(mult->TestFiredChipMap(i)) fhSPDFiredChip[TrType]->Fill(i);
      if(mult->TestFastOrFiredChips(i)) fhSPDFastOrChip[TrType]->Fill(i);
    }


  fhReferenceMultiplicity[TrType]->Fill(AliESDtrackCuts::GetReferenceMultiplicity(fESD,AliESDtrackCuts::kTrackletsITSTPC,1.2));


  const AliESDVertex *primaryTrackVtx = fESD->GetPrimaryVertexTracks();
  if (!primaryTrackVtx->GetStatus() && !primaryTrackVtx->GetStatus() )
    {
      return;
    }

  fhEvent->Fill(3);

  fhVtxTrack[TrType]->Fill(primaryTrackVtx->GetX(), primaryTrackVtx->GetY(), primaryTrackVtx->GetZ());


  return;
}
Commit	Line	Data
cc9e563c	1	// QA task for central production study
	2	// author: Martin Poghosyan
	3
	4	#include <TList.h>
	5	#include <TTree.h>
	6	#include <TH1F.h>
	7	#include <TH2F.h>
	8	#include <TH3F.h>
	9
	10
	11	#include "AliVEvent.h"
	12	#include "AliESDEvent.h"
	13	#include "AliESDtrack.h"
	14	#include "AliHeader.h"
	15	#include "AliESDInputHandler.h"
	16	#include "AliAnalysisManager.h"
	17	#include "AliMultiplicity.h"
	18	#include "AliTriggerAnalysis.h"
	19	#include "AliESDVertex.h"
	20	#include "AliESDtrackCuts.h"
	21
	22	#include "AliAnalysisTaskCPQA.h"
	23
	24
	25	ClassImp(AliAnalysisTaskCPQA)
	26
	27	//________________________________________________________________________
	28	AliAnalysisTaskCPQA::AliAnalysisTaskCPQA(const char *name)
	29	: AliAnalysisTaskSE(name),
	30	fUseMC(kFALSE),
	31	fESD(0),
	32	fOutputList(0),
	33	fhEvent(0),
	34	fTriggerAnalysis(0)
cc9e563c	35	{
	36	for(Int_t i = 0; i<4; i++)
	37	{
	38	fhV0A[i]=0;
	39	fhV0C[i]=0;
	40	fhV0online[i]=0;
	41	fhV0offline[i]=0;
	42	fhSPDFiredChip[i]=0;
	43	fhSPDFastOrChip[i]=0;
	44	fhReferenceMultiplicity[i]=0;
	45	fhVtxTrack[i]=0;
	46	}
	47
666e0b53	48	// fEtaMaxM = 2;
	49	// fEtaMaxD = 0.9;
	50	//fVtxZmax = 10;
cc9e563c	51
	52	DefineOutput(1, TList::Class());
	53	}
	54
	55	AliAnalysisTaskCPQA::~AliAnalysisTaskCPQA()
	56	{
	57	if (fOutputList && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) {
	58	printf("Deleteing output\n");
	59
	60	if(fOutputList){
	61	delete fOutputList;
	62	fOutputList = 0;
	63	}
	64
	65	if(fTriggerAnalysis)
	66	delete fTriggerAnalysis;
	67
	68	}
	69	}
	70
	71
	72
	73
	74	//________________________________________________________________________
	75	void AliAnalysisTaskCPQA::UserCreateOutputObjects()
	76	{
	77	fTriggerAnalysis = new AliTriggerAnalysis();
	78	if (fUseMC) fTriggerAnalysis->SetAnalyzeMC(1);
	79
	80	// Create histograms
	81	// Called once
	82
	83	fOutputList = new TList();
	84	fOutputList->SetOwner();
	85
	86
	87	fhEvent = new TH1F("hEvent","hEvent",100, -0.5, 99.5);
	88	fOutputList->Add(fhEvent);
	89
	90	for(Int_t i = 0; i<4; i++)
	91	{
	92	fhV0A[i] = Hist2D(Form("hV0A_%d",i), 5, -1.5, 3.5, 5, -1.5, 3.5,"V0A_{online}","V0A_{offline}"); fOutputList->Add(fhV0A[i]);
	93	fhV0C[i] = Hist2D(Form("hV0C_%d",i), 5, -1.5, 3.5, 5, -1.5, 3.5,"V0C_{online}","V0C_{offline}"); fOutputList->Add(fhV0C[i]);
	94	fhV0online[i] = Hist2D(Form("hV0online_%d",i) , 5, -1.5, 3.5, 5, -1.5, 3.5,"V0C_{online}","V0A_{online}"); fOutputList->Add(fhV0online[i]);
	95	fhV0offline[i] = Hist2D(Form("hV0offline_%d",i), 5, -1.5, 3.5, 5, -1.5, 3.5,"V0C_{offline}","V0A_{offline}"); fOutputList->Add(fhV0offline[i]);
	96	fhSPDFiredChip[i] = Hist1D(Form("fhSPDFiredChip_%d",i), 1200, -0.5, 1199.5); fOutputList->Add(fhSPDFiredChip[i]);
	97	fhSPDFastOrChip[i] = Hist1D(Form("fhSPDFastOrChip_%d",i), 1200, -0.5, 1199.5); fOutputList->Add(fhSPDFastOrChip[i]);
	98	fhReferenceMultiplicity[i] = Hist1D(Form("fhReferenceMultiplicity_%d",i), 50, -10.5, 39.5); fOutputList->Add(fhReferenceMultiplicity[i]);
	99	fhVtxTrack[i] = Hist3D(Form("fhVtxTrack_%d",i), 100, -1, 1, 100, -1, 1, 1000, -30, 30, "x_{vtx}", "y_{vtx}", "z_{vtx}"); fOutputList->Add(fhVtxTrack[i]);
	100	}
	101
	102	PostData(1, fOutputList);
	103
	104
	105	}
	106
	107
	108
	109	TH1F* AliAnalysisTaskCPQA::Hist1D(const char* name, Int_t nBins, Double_t xMin, Double_t xMax, const char* xLabel, Int_t color, Int_t lst, const char* yLabel)
	110	{
	111	// create a 1D histogram
	112
	113	TH1F* res = new TH1F(name, name, nBins, xMin, xMax);
	114	if (xLabel) res->GetXaxis()->SetTitle(xLabel);
115	if (yLabel) res->GetYaxis()->SetTitle(yLabel);
116	res->SetLineColor(color);
117	res->SetMarkerColor(color);
118	res->SetLineStyle(lst);
119	return res;
120	}
121
122
123	TH2F AliAnalysisTaskCPQA::Hist2D(const char name, Int_t nBinsx, Double_t xMin, Double_t xMax, Int_t nBinsy, Double_t yMin, Double_t yMax, const char* xLabel, const char* yLabel, Int_t color)
124	{
125	// create a 2D histogram
126
127	TH2F *res = new TH2F(name, name, nBinsx, xMin, xMax, nBinsy, yMin, yMax);
128	if (xLabel) res->GetXaxis()->SetTitle(xLabel);
129	if (yLabel) res->GetYaxis()->SetTitle(yLabel);
130	// res->SetMarkerStyle(kFullCircle);
131	// res->SetOption("E");
132	res->SetLineColor(color);
133	// fOutputList->Add(res);
134	return res;
135	}
136
137	TH3F AliAnalysisTaskCPQA::Hist3D(const char name, Int_t nBinsx, Double_t xMin, Double_t xMax, Int_t nBinsy, Double_t yMin, Double_t yMax, Int_t nBinsz, Double_t zMin, Double_t zMax, const char* xLabel, const char* yLabel, const char *zLabel)
138	{
139	// create a 3D histogram
140
141	TH3F *res = new TH3F(name, name, nBinsx, xMin, xMax, nBinsy, yMin, yMax, nBinsz, zMin, zMax);
142	if (xLabel) res->GetXaxis()->SetTitle(xLabel);
143	if (yLabel) res->GetYaxis()->SetTitle(yLabel);
144	if (zLabel) res->GetZaxis()->SetTitle(zLabel);
145	// res->SetMarkerStyle(kFullCircle);
146	// res->SetOption("E");
147	// res->SetLineColor(color);
148	// fOutputList->Add(res);
149	return res;
150	}
151
152
153
154	//________________________________________________________________________
155	void AliAnalysisTaskCPQA::UserExec(Option_t *)
156	{
157	// Main loop
158	// Called for each event
159
160	// return;
161	AliVEvent *event = InputEvent();
162	if (!event) {
163	Error("UserExec", "Could not retrieve event");
164	return;
165	}
166
167	fESD = dynamic_cast<AliESDEvent*> (InputEvent());
168	if (fESD) {
169	LoopESD();
170	if (fUseMC)
171	LoopESDMC();
172	}
173
174
175
176	PostData(1, fOutputList);
177	}
178
179	//________________________________________________________________________
180	void AliAnalysisTaskCPQA::Terminate(Option_t*)
181	{
182
183	}
184
185
186	void AliAnalysisTaskCPQA::LoopESDMC()
187	{
188	// Main loop
189	// Called for each event
190	/*
191
192	Int_t indexD1 = 1;
193	Int_t indexD2 = 2;
194
195
196	AliMCEvent mcEvent = (AliMCEvent) MCEvent();
197	if (!mcEvent) {
198	Error("LoopESDMC", "Could not retrieve MC event");
199	return;
200	}
201
202
203	AliHeader* header = mcEvent->Header();
204	if (!header)
205	{
206	AliDebug(AliLog::kError, "Header not available");
207	return;
208	}
209
210	AliGenEventHeader* genHeader = header->GenEventHeader();
211	if(!genHeader)
212	{
213	AliDebug(AliLog::kError, "GenHeader not available");
214	return;
215	}
216
217	*/
218
219
220	}
221
222
223
224
225	//________________________________________________________________________
226	void AliAnalysisTaskCPQA::LoopESD()
227	{
228	Int_t TrType = 0;
229	Bool_t fkIsPhysSel = kFALSE;
230
231	fhEvent->Fill(0);
232
233	if(!fUseMC)
234	{
235	TrType = -1;
236	if(fESD->IsTriggerClassFired("CINT1-B-NOPF-ALLNOTRD")) TrType=0;
237	else if(fESD->IsTriggerClassFired("CINT1-AC-NOPF-ALLNOTRD")) TrType=1;
238	else if(fESD->IsTriggerClassFired("CINT1-E-NOPF-ALLNOTRD")) TrType=3;
239
240	else if(fESD->IsTriggerClassFired("CINT1-B-NOPF-FASTNOTRD")) TrType=0;
241	else if(fESD->IsTriggerClassFired("CINT1-AC-NOPF-FASTNOTRD")) TrType=1;
242	else if(fESD->IsTriggerClassFired("CINT1-E-NOPF-FASTNOTRD")) TrType=3;
243
244	else if(fESD->IsTriggerClassFired("CINT1B-ABCE-NOPF-ALL")) TrType=0;
245	else if(fESD->IsTriggerClassFired("CINT1A-ABCE-NOPF-ALL")) TrType=1;
246	else if(fESD->IsTriggerClassFired("CINT1C-ABCE-NOPF-ALL")) TrType=2;
247	else if(fESD->IsTriggerClassFired("CINT1-E-NOPF-ALL")) TrType=3;
248
249	UInt_t mask = ((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected();
250	fkIsPhysSel=(mask & AliVEvent::kMB) ? 1 : 0; // check if minimum bias trigger class fired
251
252
253	if(!fkIsPhysSel) return;
254	printf("TrType = %d\n",TrType);
255	if(TrType==-1) return;
256	}
257
258	fhEvent->Fill(1);
259
260
261	Int_t V0Aonline = fTriggerAnalysis->V0Trigger(fESD, AliTriggerAnalysis::kASide, kTRUE) ;
262	Int_t V0Conline = fTriggerAnalysis->V0Trigger(fESD, AliTriggerAnalysis::kCSide, kTRUE) ;
263	Int_t V0Aoffline = fTriggerAnalysis->V0Trigger(fESD, AliTriggerAnalysis::kASide, kFALSE) ;
264	Int_t V0Coffline = fTriggerAnalysis->V0Trigger(fESD, AliTriggerAnalysis::kCSide, kFALSE) ;
265
266
267	fhV0A[TrType]->Fill(V0Aonline, V0Aoffline);
268	fhV0C[TrType]->Fill(V0Conline, V0Coffline);
269	fhV0online[TrType]->Fill(V0Conline, V0Aonline);
270	fhV0offline[TrType]->Fill(V0Coffline, V0Aoffline);
271
272
273	if(V0Aoffline!=0 \|\| V0Coffline!=0)
274	{
275	return;
276	}
277
278	fhEvent->Fill(2);
279
280	const AliMultiplicity *mult = fESD->GetMultiplicity();
281	for (Int_t i=0; i<1200; i++)
282	{
283	if(mult->TestFiredChipMap(i)) fhSPDFiredChip[TrType]->Fill(i);
284	if(mult->TestFastOrFiredChips(i)) fhSPDFastOrChip[TrType]->Fill(i);
285	}
286
287
288	fhReferenceMultiplicity[TrType]->Fill(AliESDtrackCuts::GetReferenceMultiplicity(fESD,AliESDtrackCuts::kTrackletsITSTPC,1.2));
289
290
291	const AliESDVertex *primaryTrackVtx = fESD->GetPrimaryVertexTracks();
292	if (!primaryTrackVtx->GetStatus() && !primaryTrackVtx->GetStatus() )
293	{
294	return;
295	}
296
297	fhEvent->Fill(3);
298
299	fhVtxTrack[TrType]->Fill(primaryTrackVtx->GetX(), primaryTrackVtx->GetY(), primaryTrackVtx->GetZ());
300
301
302
303	return;
304	}
305