[u/mrichter/AliRoot.git] / PWG1 / T0 / AliT0AnalysisTaskQA.cxx

#include "TChain.h"
#include "TTree.h"
#include "TH1F.h"
#include "TF1.h"
#include "TH2F.h"
#include "TCanvas.h"
#include "TObjArray.h"

#include "AliAnalysisTask.h"
#include "AliAnalysisManager.h"

#include "AliESDEvent.h"
#include "AliESDInputHandler.h"

#include "AliT0AnalysisTaskQA.h"

//#include "AliCDBMetaData.h"
//#include "AliCDBId.h"
//#include "AliCDBEntry.h"
//#include "AliCDBManager.h"
//#include "AliCDBStorage.h"

// Task should calculate channels offset 
// Authors: Alla 

ClassImp(AliT0AnalysisTaskQA)
//________________________________________________________________________
AliT0AnalysisTaskQA::AliT0AnalysisTaskQA() 
  : AliAnalysisTaskSE(),  fESD(0x0), fTzeroObject(0x0),
  fTzeroORA(0x0), fTzeroORC(0x0), fResolution(0x0), fTzeroORAplusORC(0x0),
    fRunNumber(0),fTimeVSAmplitude(0x0),fCFDVSPmtId(0x0),fSPDVertexVST0Vertex(0x0),
  fOrAvsNtracks(0), fOrCvsNtracks(0), fT0vsNtracks(0),
  fEffAC(0), fEffA(0), fEffC(0), ftracksEffSPD(0)
  
{
  // Constructor

  // Define input and output slots here
  // Input slot #0 works with a TChain

// ########### NEVER define slots in the IO constructor
//  DefineInput(0,  TChain::Class());
//  DefineOutput(1, TObjArray::Class());
}


//________________________________________________________________________
AliT0AnalysisTaskQA::AliT0AnalysisTaskQA(const char *name) 
  : AliAnalysisTaskSE(name),  fESD(0x0), fTzeroObject(0x0),
  fTzeroORA(0x0), fTzeroORC(0x0), fResolution(0x0), fTzeroORAplusORC(0x0),
    fRunNumber(0),fTimeVSAmplitude(0x0),fCFDVSPmtId(0x0),fSPDVertexVST0Vertex(0x0),
    fOrAvsNtracks(0), fOrCvsNtracks(0), fT0vsNtracks(0),
   fEffAC(0), fEffA(0), fEffC(0), ftracksEffSPD(0)

{
  // Constructor
  // Define input and output slots here
  // Input slot #0 works with a TChain
  DefineInput(0, TChain::Class());
  DefineOutput(1, TObjArray::Class());
  // Output slot #0 id reserved by the base class for AOD
  // Output slot #1 writes into a TH1 container
}

//________________________________________________________________________
AliT0AnalysisTaskQA::~AliT0AnalysisTaskQA() 
{
  // Destructor
  // printf("AliT0CalibOffsetChannels~AliT0CalibOffsetChannels() ");
  delete fTzeroObject; // This deletes everything ...
}

//------------------------------------------------------------------
void AliT0AnalysisTaskQA::UserCreateOutputObjects()
{
  // Create histograms
 fTimeVSAmplitude = new TH2F*[NPMT0];

 for (Int_t i=0; i<NPMT0; i++) {
    fTimeVSAmplitude[i]= new TH2F (Form("fTimeVSAmplitude%d",i+1),"fTimeVsAmplitude",500, 0, 50,1500,1000,7000);
  }

  fTzeroORAplusORC = new TH1F("fTzeroORAplusORC","ORA+ORC /2",100,-2000,2000);   //or A plus or C 
  fResolution      = new TH1F("fResolution","fResolution",100,-2000,2000);// or A minus or C spectrum
  fTzeroORA        = new TH1F("fTzeroORA","fTzeroORA",100,-2000,2000);// or A spectrum
  fTzeroORC        = new TH1F("fTzeroORC","fTzeroORC",100,-2000,2000);// or C spectrum
  fCFDVSPmtId      = new TH2F("fCFDVSPmtId","fCFDVSPmtId",24,0,24,1500,1000,7000);  // 
  fSPDVertexVST0Vertex = new TH2F("fSPDVertexVST0Vertex","fSPDVertexVST0Vertex",30,-30,30,30,-30,30);
  fOrAvsNtracks    = new TH2F("fAvstracks", "Avstracks",200, 0, 1000, 500, -1000, 1000);
  fOrCvsNtracks    = new TH2F("fCvstracks", "Cvstracks",200, 0, 1000, 500, -1000, 1000);
  fT0vsNtracks     = new TH2F("fT0ACvstrackles", "T0ACvstracks",200, 0, 1000, 500, -1000, 1000); 
   fEffAC = new TH1F("EffAC","T0Eff ", 200, 0, 1000);
   fEffA = new TH1F("EffA","T0AEff ", 200, 0, 1000);
   fEffC = new TH1F("EffC","T0CEff ", 200, 0, 1000);
   ftracksEffSPD= new TH1F("ftracksEffSPD","SPDeff", 200, 0, 1000);

  fTzeroObject     = new TObjArray();
  fTzeroObject->SetOwner(kTRUE);
  
  for (Int_t i=0; i<24; i++)
    fTzeroObject->AddAtAndExpand(fTimeVSAmplitude[i],i);

  fTzeroObject->AddAtAndExpand(fCFDVSPmtId,24);
  fTzeroObject->AddAtAndExpand(fSPDVertexVST0Vertex,25);
  fTzeroObject->AddAtAndExpand(fTzeroORAplusORC, 26);
  fTzeroObject->AddAtAndExpand(fResolution, 27);
  fTzeroObject->AddAtAndExpand(fTzeroORA, 28);
  fTzeroObject->AddAtAndExpand(fTzeroORC, 29);
  fTzeroObject->AddAtAndExpand(fT0vsNtracks, 30);
  fTzeroObject->AddAtAndExpand(fOrAvsNtracks,31);
  fTzeroObject->AddAtAndExpand(fOrCvsNtracks, 32);
  fTzeroObject->AddAtAndExpand(fEffC, 33);
  fTzeroObject->AddAtAndExpand(fEffA, 34);
  fTzeroObject->AddAtAndExpand(fEffAC, 35);
  fTzeroObject->AddAtAndExpand(ftracksEffSPD, 36);

  PostData(1, fTzeroObject);
  // Called once
}

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

  // Post output data.
  fESD = dynamic_cast<AliESDEvent*>(InputEvent());
  if (!fESD) {
    printf("ERROR: fESD not available\n");
    return;
  }

  fRunNumber =  fESD->GetRunNumber() ; 

  const Double32_t* time = fESD->GetT0time();
  const Double32_t* amplitude = fESD->GetT0amplitude();

 
  for (Int_t i=0; i<24; i++) {
    if(time[i]<9999 &&abs(time[i])>1e-8 && amplitude[i]<9999&&abs(amplitude[i])>1e-8 )
      {
	//	cout<<"time "<<time[i]<<" amplitude "<<amplitude[i]<<endl;
	fTimeVSAmplitude[i]->Fill(amplitude[i],time[i]);
	fCFDVSPmtId->Fill(i,time[i]);
      }
  }

  const Double32_t* mean = fESD->GetT0TOF();
  Double32_t orA = mean[1];
  Double32_t orC = mean[2];
  Int_t ntracks = fESD->GetNumberOfTracks(); 

  if(orA<99999){
    fTzeroORA->Fill(orA);
    fOrAvsNtracks->Fill(ntracks, orA);
    fEffA->Fill(ntracks);
  }
  if(orC<99999) {
    fTzeroORC->Fill(orC);
    fOrCvsNtracks->Fill(ntracks, orC);
    fEffC->Fill(ntracks);
   }
  if(orA<99999 && orC<99999) {
    fResolution->Fill((orA-orC)/2.);
    fTzeroORAplusORC->Fill(mean[0]);
    fEffAC->Fill(ntracks);
    fT0vsNtracks->Fill(ntracks, mean[0]);
  }
  
  Double32_t t0vertex = fESD->GetT0zVertex();
  Double32_t esdzvertex;
  const AliESDVertex * esdvertex = fESD->GetPrimaryVertex();
  Int_t nofcontrib=-1;
  nofcontrib=esdvertex->GetNContributors();
  if(nofcontrib>0)    ftracksEffSPD->Fill(ntracks);
   if(esdvertex && t0vertex<999)
    {
      if(nofcontrib>0)
	{
	  esdzvertex=esdvertex->GetZv();
	  fSPDVertexVST0Vertex->Fill(t0vertex,esdzvertex);
	}
    }
  PostData(1, fTzeroObject);
}      
 //________________________________________________________________________
void AliT0AnalysisTaskQA::Terminate(Option_t *) 
{
  
   // Called once at the end of the query
}
Commit	Line	Data
07682040	1	#include "TChain.h"
	2	#include "TTree.h"
	3	#include "TH1F.h"
	4	#include "TF1.h"
	5	#include "TH2F.h"
	6	#include "TCanvas.h"
	7	#include "TObjArray.h"
	8
	9	#include "AliAnalysisTask.h"
	10	#include "AliAnalysisManager.h"
	11
	12	#include "AliESDEvent.h"
	13	#include "AliESDInputHandler.h"
	14
	15	#include "AliT0AnalysisTaskQA.h"
	16
	17	//#include "AliCDBMetaData.h"
	18	//#include "AliCDBId.h"
	19	//#include "AliCDBEntry.h"
	20	//#include "AliCDBManager.h"
	21	//#include "AliCDBStorage.h"
	22
	23	// Task should calculate channels offset
	24	// Authors: Alla
	25
	26	ClassImp(AliT0AnalysisTaskQA)
	27	//________________________________________________________________________
	28	AliT0AnalysisTaskQA::AliT0AnalysisTaskQA()
	29	: AliAnalysisTaskSE(), fESD(0x0), fTzeroObject(0x0),
	30	fTzeroORA(0x0), fTzeroORC(0x0), fResolution(0x0), fTzeroORAplusORC(0x0),
	31	fRunNumber(0),fTimeVSAmplitude(0x0),fCFDVSPmtId(0x0),fSPDVertexVST0Vertex(0x0),
1be7ae64	32	fOrAvsNtracks(0), fOrCvsNtracks(0), fT0vsNtracks(0),
	33	fEffAC(0), fEffA(0), fEffC(0), ftracksEffSPD(0)
	34
07682040	35	{
	36	// Constructor
	37
	38	// Define input and output slots here
	39	// Input slot #0 works with a TChain
	40
	41	// ########### NEVER define slots in the IO constructor
	42	// DefineInput(0, TChain::Class());
	43	// DefineOutput(1, TObjArray::Class());
	44	}
	45
	46
	47	//________________________________________________________________________
	48	AliT0AnalysisTaskQA::AliT0AnalysisTaskQA(const char *name)
	49	: AliAnalysisTaskSE(name), fESD(0x0), fTzeroObject(0x0),
	50	fTzeroORA(0x0), fTzeroORC(0x0), fResolution(0x0), fTzeroORAplusORC(0x0),
	51	fRunNumber(0),fTimeVSAmplitude(0x0),fCFDVSPmtId(0x0),fSPDVertexVST0Vertex(0x0),
1be7ae64	52	fOrAvsNtracks(0), fOrCvsNtracks(0), fT0vsNtracks(0),
	53	fEffAC(0), fEffA(0), fEffC(0), ftracksEffSPD(0)
	54
07682040	55	{
	56	// Constructor
	57	// Define input and output slots here
	58	// Input slot #0 works with a TChain
	59	DefineInput(0, TChain::Class());
	60	DefineOutput(1, TObjArray::Class());
	61	// Output slot #0 id reserved by the base class for AOD
	62	// Output slot #1 writes into a TH1 container
	63	}
	64
	65	//________________________________________________________________________
	66	AliT0AnalysisTaskQA::~AliT0AnalysisTaskQA()
	67	{
	68	// Destructor
	69	// printf("AliT0CalibOffsetChannels~AliT0CalibOffsetChannels() ");
	70	delete fTzeroObject; // This deletes everything ...
	71	}
	72
	73	//------------------------------------------------------------------
	74	void AliT0AnalysisTaskQA::UserCreateOutputObjects()
	75	{
	76	// Create histograms
	77	fTimeVSAmplitude = new TH2F*[NPMT0];
	78
	79	for (Int_t i=0; i<NPMT0; i++) {
1be7ae64	80	fTimeVSAmplitude[i]= new TH2F (Form("fTimeVSAmplitude%d",i+1),"fTimeVsAmplitude",500, 0, 50,1500,1000,7000);
07682040	81	}
	82
	83	fTzeroORAplusORC = new TH1F("fTzeroORAplusORC","ORA+ORC /2",100,-2000,2000); //or A plus or C
	84	fResolution = new TH1F("fResolution","fResolution",100,-2000,2000);// or A minus or C spectrum
	85	fTzeroORA = new TH1F("fTzeroORA","fTzeroORA",100,-2000,2000);// or A spectrum
	86	fTzeroORC = new TH1F("fTzeroORC","fTzeroORC",100,-2000,2000);// or C spectrum
750c312d	87	fCFDVSPmtId = new TH2F("fCFDVSPmtId","fCFDVSPmtId",24,0,24,1500,1000,7000); //
07682040	88	fSPDVertexVST0Vertex = new TH2F("fSPDVertexVST0Vertex","fSPDVertexVST0Vertex",30,-30,30,30,-30,30);
	89	fOrAvsNtracks = new TH2F("fAvstracks", "Avstracks",200, 0, 1000, 500, -1000, 1000);
	90	fOrCvsNtracks = new TH2F("fCvstracks", "Cvstracks",200, 0, 1000, 500, -1000, 1000);
	91	fT0vsNtracks = new TH2F("fT0ACvstrackles", "T0ACvstracks",200, 0, 1000, 500, -1000, 1000);
750c312d	92	fEffAC = new TH1F("EffAC","T0Eff ", 200, 0, 1000);
	93	fEffA = new TH1F("EffA","T0AEff ", 200, 0, 1000);
	94	fEffC = new TH1F("EffC","T0CEff ", 200, 0, 1000);
	95	ftracksEffSPD= new TH1F("ftracksEffSPD","SPDeff", 200, 0, 1000);
07682040	96
	97	fTzeroObject = new TObjArray();
	98	fTzeroObject->SetOwner(kTRUE);
	99
	100	for (Int_t i=0; i<24; i++)
	101	fTzeroObject->AddAtAndExpand(fTimeVSAmplitude[i],i);
	102
	103	fTzeroObject->AddAtAndExpand(fCFDVSPmtId,24);
	104	fTzeroObject->AddAtAndExpand(fSPDVertexVST0Vertex,25);
	105	fTzeroObject->AddAtAndExpand(fTzeroORAplusORC, 26);
	106	fTzeroObject->AddAtAndExpand(fResolution, 27);
	107	fTzeroObject->AddAtAndExpand(fTzeroORA, 28);
	108	fTzeroObject->AddAtAndExpand(fTzeroORC, 29);
	109	fTzeroObject->AddAtAndExpand(fT0vsNtracks, 30);
	110	fTzeroObject->AddAtAndExpand(fOrAvsNtracks,31);
	111	fTzeroObject->AddAtAndExpand(fOrCvsNtracks, 32);
750c312d	112	fTzeroObject->AddAtAndExpand(fEffC, 33);
	113	fTzeroObject->AddAtAndExpand(fEffA, 34);
	114	fTzeroObject->AddAtAndExpand(fEffAC, 35);
	115	fTzeroObject->AddAtAndExpand(ftracksEffSPD, 36);
07682040	116
	117	PostData(1, fTzeroObject);
	118	// Called once
	119	}
	120
	121	//________________________________________________________________________
	122	void AliT0AnalysisTaskQA::UserExec(Option_t *)
	123	{
	124	// Main loop
	125	// Called for each event
	126
	127	// Post output data.
	128	fESD = dynamic_cast<AliESDEvent*>(InputEvent());
	129	if (!fESD) {
	130	printf("ERROR: fESD not available\n");
	131	return;
	132	}
	133
	134	fRunNumber = fESD->GetRunNumber() ;
	135
	136	const Double32_t* time = fESD->GetT0time();
	137	const Double32_t* amplitude = fESD->GetT0amplitude();
	138
	139
	140	for (Int_t i=0; i<24; i++) {
	141	if(time[i]<9999 &&abs(time[i])>1e-8 && amplitude[i]<9999&&abs(amplitude[i])>1e-8 )
	142	{
	143	// cout<<"time "<<time[i]<<" amplitude "<<amplitude[i]<<endl;
	144	fTimeVSAmplitude[i]->Fill(amplitude[i],time[i]);
	145	fCFDVSPmtId->Fill(i,time[i]);
	146	}
	147	}
	148
	149	const Double32_t* mean = fESD->GetT0TOF();
	150	Double32_t orA = mean[1];
	151	Double32_t orC = mean[2];
	152	Int_t ntracks = fESD->GetNumberOfTracks();
	153
750c312d	154	if(orA<99999){
07682040	155	fTzeroORA->Fill(orA);
07682040	156	fOrAvsNtracks->Fill(ntracks, orA);
750c312d	157	fEffA->Fill(ntracks);
07682040	158	}
750c312d	159	if(orC<99999) {
07682040	160	fTzeroORC->Fill(orC);
07682040	161	fOrCvsNtracks->Fill(ntracks, orC);
750c312d	162	fEffC->Fill(ntracks);
	163	}
	164	if(orA<99999 && orC<99999) {
07682040	165	fResolution->Fill((orA-orC)/2.);
07682040	166	fTzeroORAplusORC->Fill(mean[0]);
750c312d	167	fEffAC->Fill(ntracks);
07682040	168	fT0vsNtracks->Fill(ntracks, mean[0]);
	169	}
	170
	171	Double32_t t0vertex = fESD->GetT0zVertex();
07682040	172	Double32_t esdzvertex;
	173	const AliESDVertex * esdvertex = fESD->GetPrimaryVertex();
	174	Int_t nofcontrib=-1;
750c312d	175	nofcontrib=esdvertex->GetNContributors();
	176	if(nofcontrib>0) ftracksEffSPD->Fill(ntracks);
	177	if(esdvertex && t0vertex<999)
07682040	178	{
750c312d	179	if(nofcontrib>0)
07682040	180	{
07682040	181	esdzvertex=esdvertex->GetZv();
07682040	182	fSPDVertexVST0Vertex->Fill(t0vertex,esdzvertex);
	183	}
	184	}
07682040	185	PostData(1, fTzeroObject);
	186	}
	187	//________________________________________________________________________
	188	void AliT0AnalysisTaskQA::Terminate(Option_t *)
	189	{
	190
	191	// Called once at the end of the query
	192	}