[u/mrichter/AliRoot.git] / PWG3 / muon / AliAnalysisTaskSingleMuESD.cxx

#include "TChain.h"
#include "TTree.h"
#include "TNtuple.h"
#include "TH1F.h"
#include "TString.h"

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

#include "AliESDEvent.h"
#include "AliESDInputHandler.h"
#include "AliESDVertex.h"
#include "AliESDMuonTrack.h"

#include "AliAnalysisTaskSingleMuESD.h"

// analysis task for single muon analysis of the ESD events
// Authors: Bogdan Vulpescu, Nicole Bastid, LPC Clermont-Ferrand

ClassImp(AliAnalysisTaskSingleMuESD)

//________________________________________________________________________
AliAnalysisTaskSingleMuESD::AliAnalysisTaskSingleMuESD(const char *name) 
  : AliAnalysisTask(name, ""), 
    fESD(0), 
    fNtuple(0), 
    fTrigger(0), 
    fMaskTrig1MuL(1),
    fMaskTrig1MuH(2),
    fMaskTrigUSL(4),
    fMaskTrigLSL(16),
    fMaskTrigUSH(8),
    fMaskTrigLSH(32),
    fTriggerType(kFALSE)
{
  // Constructor

  // Define input and output slots here
  // Input slot #0 works with a TChain
  DefineInput(0, TChain::Class());
  // Output slot #0 writes into a TNtuple container
  DefineOutput(0, TNtuple::Class());
  // Output slot #1 writes into a TH1F container
  DefineOutput(1, TH1F::Class());
}

//________________________________________________________________________
void AliAnalysisTaskSingleMuESD::ConnectInputData(Option_t *) 
{
  // Connect ESD or AOD here
  // Called once

  TTree* tree = dynamic_cast<TTree*> (GetInputData(0));
  if (!tree) {
    Printf("ERROR: Could not read chain from input slot 0");
  } else {
    // Disable all branches and enable only the needed ones
    // The next two lines are different when data produced as AliESDEvent is read
    tree->SetBranchStatus("*", kFALSE);
    tree->SetBranchStatus("MuonTracks.*", kTRUE);
    tree->SetBranchStatus("SPDVertex.*", kTRUE);
    tree->SetBranchStatus("AliESDHeader.*", kTRUE);

    AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());

    if (!esdH) {
      Printf("ERROR: Could not get ESDInputHandler");
    } else
      fESD = esdH->GetEvent();
  }
}

//________________________________________________________________________
void AliAnalysisTaskSingleMuESD::CreateOutputObjects()
{
  // Create output ntuple

  fNtuple = new TNtuple("ntEsd1mu","ntEsd1mu","VtZ:Mult:TMask:Z:Pt:P:Eta:Theta:Phi:Zpos:Hits:Xi2:Eff:TrigMatch:TrigXi2");
  // histogram with trigger classes
  fTrigger = new TH1F("TriggerMask","L/H/USL/USH/LSL/LSH",6,0,6);

}

//________________________________________________________________________
void AliAnalysisTaskSingleMuESD::Exec(Option_t *) 
{
  // Main loop
  // Called for each event
  // Fill the ntuple with variables and the trigger histogram

  Float_t  ntvar[15], pt, p, eta, thetad, phid, charge, chi2, zcoor, chi2MatchTrig;
  ULong64_t mask = 0;
  Int_t masksave = 0, hits, matchTrig;
  Double_t rEff[2];
  Double_t fZVertex = 0;
  Double_t fYVertex = 0;
  Double_t fXVertex = 0;
  Double_t fErXVertex = 0;
  Double_t fErYVertex = 0;
  
  if (!fESD) {
    Printf("ERROR: fESD not available");
    return;
  }

  // Trigger checks
  // mask values: L/H/USL/USH/LSL/LSH
  // Bit position    Histogram bin     Trigger class
  // 1 (less)        1 ("L")           MULow          single low pt
  // 2               2 ("H")           MUHigh         single high pt
  // 3               3 ("USL")         MULU           unlike-sign low pt
  // 4               4 ("USH")         MUHU           unlike-sign high pt
  // 5               5 ("LSL")         MULL           like-sign low pt
  // 6 (most)        6 ("LSH")         MUHL           like-sign high pt
  if (fTriggerType) {
    mask = fESD->GetTriggerMask();
    if (mask & fMaskTrig1MuL) {
      fTrigger->Fill(0.5);
      masksave |= 0x01;
    }
    if (mask & fMaskTrig1MuH) {
      fTrigger->Fill(1.5);
      masksave |= 0x02;
    }
    if (mask & fMaskTrigUSL)  {
      fTrigger->Fill(2.5);
      masksave |= 0x04;
    }
    if (mask & fMaskTrigUSH)  {
      fTrigger->Fill(3.5);
      masksave |= 0x08;
    }
    if (mask & fMaskTrigLSL)  {
      fTrigger->Fill(4.5);
      masksave |= 0x10;
    }
    if (mask & fMaskTrigLSH)  {
      fTrigger->Fill(5.5);
      masksave |= 0x20;
    }
  } else {
    TString firedTC = fESD->GetFiredTriggerClasses();
    if (firedTC.Contains("MULow")) {
      fTrigger->Fill(0.5);
      masksave |= 0x01;
    }
    if (firedTC.Contains("MUHigh")) {
      fTrigger->Fill(1.5);
      masksave |= 0x02;
    }
    if (firedTC.Contains("MULU")) {
      fTrigger->Fill(2.5);
      masksave |= 0x04;
    }
    if (firedTC.Contains("MUHU")) {
      fTrigger->Fill(3.5);
      masksave |= 0x08;
    }
    if (firedTC.Contains("MULL")) {
      fTrigger->Fill(4.5);
      masksave |= 0x10;
    }
    if (firedTC.Contains("MUHL")) {
      fTrigger->Fill(5.5);
      masksave |= 0x20;
    }
  }

  // get the SPD reconstructed vertex (vertexer) 
  AliESDVertex* vertex = (AliESDVertex*) fESD->GetVertex();
  if (vertex->GetNContributors()) {
    fZVertex = vertex->GetZv();
    fYVertex = vertex->GetYv();
    fXVertex = vertex->GetXv();
    fErXVertex = vertex->GetXRes();
    fErYVertex = vertex->GetYRes();
  }

  Int_t nTracks = (Int_t)fESD->GetNumberOfMuonTracks() ;
  for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {

    AliESDMuonTrack* muonTrack = new AliESDMuonTrack(*(fESD->GetMuonTrack(iTrack)));
    if (!muonTrack) {
      Printf("ERROR: Could not receive track %d", iTrack);
      continue;
    }

    pt = muonTrack->Pt();
    p = muonTrack->P();
    eta = muonTrack->Eta();
    thetad =  muonTrack->Theta()*180./TMath::Pi();	
    phid = muonTrack->Phi()*180./TMath::Pi();
    charge = muonTrack->Charge();
    hits = muonTrack->GetNHit();	
    chi2 = muonTrack->GetChi2() / (2.0 * hits - 5);
    zcoor = muonTrack->GetZ();
    matchTrig = muonTrack->GetMatchTrigger();
    chi2MatchTrig = muonTrack->GetChi2MatchTrigger();
    
    rEff[0] = rEff[1] = 0.0;
    GetEffFitted(eta,pt,rEff);
        
    ntvar[0] = fZVertex;
    ntvar[1] = nTracks;
    ntvar[2] = masksave;
    ntvar[3] = charge;
    ntvar[4] = pt;
    ntvar[5] = p;
    ntvar[6] = eta;	
    ntvar[7] = thetad;
    ntvar[8] = phid;
    ntvar[9] = zcoor;
    ntvar[10] = hits;	
    ntvar[11] = chi2;
    ntvar[12] = rEff[0];
    ntvar[13] = matchTrig;
    ntvar[14] = chi2MatchTrig;	

    fNtuple->Fill(ntvar);


  } //track loop 

  // Post output data.
  PostData(0, fNtuple);
  PostData(1, fTrigger);

}      

//________________________________________________________________________
void AliAnalysisTaskSingleMuESD::Terminate(Option_t *) 
{
  // the end
}

//________________________________________________________________________
void AliAnalysisTaskSingleMuESD::GetEffFitted(Double_t eta, Double_t pt, Double_t rEff[2])
{
  // tracking efficiency

  Int_t nbinEta =15;
  Float_t etaMin = -4.;
  Float_t etaBin = 0.1;
  Int_t numBin = -1;
  rEff[0]=1.;rEff[1]=0.;
  
  // nbinEta = number of eta bins startig at etaMin = -4 and binning of 0.1 (etaBin)
  Float_t p0[15] = {-0.9338,-0.9441,-0.9397,-0.9586,-0.9713,-0.9752,-0.9711,-0.9751,-0.9746,-0.9729,-0.9754,-0.9722,-0.9722,-0.971,-0.9709};
  Float_t p1[15] = {-0.6383,-1.4729,-1.0109,-1.4316,-1.5926,-1.367,-1.1895,-1.2834,-1.3289,-1.5916,-1.4258,-1.0983,-1.0812,-0.7179, -0.4613};      
  
  Float_t etaInf, etaSup;
  for (Int_t i = 1; i < nbinEta+1; i++){
    etaInf = etaMin + (i-1)*etaBin;
    etaSup = etaMin + i*etaBin;
    if(eta > etaInf && eta <= etaSup) numBin = i-1;
  } 
  
  if(numBin>=0 && pt >=1.) rEff[0] = p0[numBin] * TMath::TanH(p1[numBin]*pt);
  rEff[1] = 0;

}

//________________________________________________________________________
void AliAnalysisTaskSingleMuESD::SetTriggerType(const Char_t *trig)
{
  // set the trigger masks according to the trigger type used in the
  // simulations
  
  TString triggerType(trig);

  if (!triggerType.CompareTo("MUON")) {
    fMaskTrig1MuL =  1;  // MULow
    fMaskTrig1MuH =  2;  // MUHigh
    fMaskTrigUSL  =  4;  // MULU
    fMaskTrigLSL  = 16;  // MULL
    fMaskTrigUSH  =  8;  // MUHU
    fMaskTrigLSH  = 32;  // MUHL
  } else if (!triggerType.CompareTo("p-p")) {
    fMaskTrig1MuL =    128;  // MULow
    fMaskTrig1MuH =    256;  // MUHigh
    fMaskTrigUSL  =  65536;  // MULU
    fMaskTrigLSL  = 131072;  // MULL
    fMaskTrigUSH  = 262144;  // MUHU
    fMaskTrigLSH  = 524288;  // MUHL
  } else {
    // MUON trigger, values by default in the constructor
  }
  
  fTriggerType = kTRUE;

}
Commit	Line	Data
509204ee	1	#include "TChain.h"
	2	#include "TTree.h"
	3	#include "TNtuple.h"
	4	#include "TH1F.h"
	5	#include "TString.h"
	6
	7	#include "AliAnalysisTask.h"
	8	#include "AliAnalysisManager.h"
	9
	10	#include "AliESDEvent.h"
	11	#include "AliESDInputHandler.h"
	12	#include "AliESDVertex.h"
	13	#include "AliESDMuonTrack.h"
	14
	15	#include "AliAnalysisTaskSingleMuESD.h"
	16
	17	// analysis task for single muon analysis of the ESD events
	18	// Authors: Bogdan Vulpescu, Nicole Bastid, LPC Clermont-Ferrand
	19
	20	ClassImp(AliAnalysisTaskSingleMuESD)
	21
	22	//________________________________________________________________________
	23	AliAnalysisTaskSingleMuESD::AliAnalysisTaskSingleMuESD(const char *name)
	24	: AliAnalysisTask(name, ""),
	25	fESD(0),
	26	fNtuple(0),
	27	fTrigger(0),
	28	fMaskTrig1MuL(1),
	29	fMaskTrig1MuH(2),
	30	fMaskTrigUSL(4),
	31	fMaskTrigLSL(16),
	32	fMaskTrigUSH(8),
	33	fMaskTrigLSH(32),
	34	fTriggerType(kFALSE)
	35	{
	36	// Constructor
	37
	38	// Define input and output slots here
	39	// Input slot #0 works with a TChain
	40	DefineInput(0, TChain::Class());
	41	// Output slot #0 writes into a TNtuple container
	42	DefineOutput(0, TNtuple::Class());
	43	// Output slot #1 writes into a TH1F container
	44	DefineOutput(1, TH1F::Class());
	45	}
	46
	47	//________________________________________________________________________
	48	void AliAnalysisTaskSingleMuESD::ConnectInputData(Option_t *)
	49	{
	50	// Connect ESD or AOD here
	51	// Called once
	52
	53	TTree* tree = dynamic_cast<TTree*> (GetInputData(0));
	54	if (!tree) {
	55	Printf("ERROR: Could not read chain from input slot 0");
	56	} else {
	57	// Disable all branches and enable only the needed ones
	58	// The next two lines are different when data produced as AliESDEvent is read
	59	tree->SetBranchStatus("*", kFALSE);
	60	tree->SetBranchStatus("MuonTracks.*", kTRUE);
	61	tree->SetBranchStatus("SPDVertex.*", kTRUE);
	62	tree->SetBranchStatus("AliESDHeader.*", kTRUE);
	63
	64	AliESDInputHandler esdH = dynamic_cast<AliESDInputHandler> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
65
66	if (!esdH) {
67	Printf("ERROR: Could not get ESDInputHandler");
68	} else
69	fESD = esdH->GetEvent();
70	}
71	}
72
73	//________________________________________________________________________
74	void AliAnalysisTaskSingleMuESD::CreateOutputObjects()
75	{
76	// Create output ntuple
77
78	fNtuple = new TNtuple("ntEsd1mu","ntEsd1mu","VtZ:Mult:TMask:Z:Pt:P:Eta:Theta:Phi:Zpos:Hits:Xi2:Eff:TrigMatch:TrigXi2");
79	// histogram with trigger classes
80	fTrigger = new TH1F("TriggerMask","L/H/USL/USH/LSL/LSH",6,0,6);
81
82	}
83
84	//________________________________________________________________________
85	void AliAnalysisTaskSingleMuESD::Exec(Option_t *)
86	{
87	// Main loop
88	// Called for each event
89	// Fill the ntuple with variables and the trigger histogram
90
91	Float_t ntvar[15], pt, p, eta, thetad, phid, charge, chi2, zcoor, chi2MatchTrig;
92	ULong64_t mask = 0;
93	Int_t masksave = 0, hits, matchTrig;
94	Double_t rEff[2];
95	Double_t fZVertex = 0;
96	Double_t fYVertex = 0;
97	Double_t fXVertex = 0;
98	Double_t fErXVertex = 0;
99	Double_t fErYVertex = 0;
100
101	if (!fESD) {
102	Printf("ERROR: fESD not available");
103	return;
104	}
105
106	// Trigger checks
107	// mask values: L/H/USL/USH/LSL/LSH
108	// Bit position Histogram bin Trigger class
109	// 1 (less) 1 ("L") MULow single low pt
110	// 2 2 ("H") MUHigh single high pt
111	// 3 3 ("USL") MULU unlike-sign low pt
112	// 4 4 ("USH") MUHU unlike-sign high pt
113	// 5 5 ("LSL") MULL like-sign low pt
114	// 6 (most) 6 ("LSH") MUHL like-sign high pt
115	if (fTriggerType) {
116	mask = fESD->GetTriggerMask();
117	if (mask & fMaskTrig1MuL) {
118	fTrigger->Fill(0.5);
119	masksave \|= 0x01;
120	}
121	if (mask & fMaskTrig1MuH) {
122	fTrigger->Fill(1.5);
123	masksave \|= 0x02;
124	}
125	if (mask & fMaskTrigUSL) {
126	fTrigger->Fill(2.5);
127	masksave \|= 0x04;
128	}
129	if (mask & fMaskTrigUSH) {
130	fTrigger->Fill(3.5);
131	masksave \|= 0x08;
132	}
133	if (mask & fMaskTrigLSL) {
134	fTrigger->Fill(4.5);
135	masksave \|= 0x10;
136	}
137	if (mask & fMaskTrigLSH) {
138	fTrigger->Fill(5.5);
139	masksave \|= 0x20;
140	}
141	} else {
142	TString firedTC = fESD->GetFiredTriggerClasses();
143	if (firedTC.Contains("MULow")) {
144	fTrigger->Fill(0.5);
145	masksave \|= 0x01;
146	}
147	if (firedTC.Contains("MUHigh")) {
148	fTrigger->Fill(1.5);
149	masksave \|= 0x02;
150	}
151	if (firedTC.Contains("MULU")) {
152	fTrigger->Fill(2.5);
153	masksave \|= 0x04;
154	}
155	if (firedTC.Contains("MUHU")) {
156	fTrigger->Fill(3.5);
157	masksave \|= 0x08;
158	}
159	if (firedTC.Contains("MULL")) {
160	fTrigger->Fill(4.5);
161	masksave \|= 0x10;
162	}
163	if (firedTC.Contains("MUHL")) {
164	fTrigger->Fill(5.5);
165	masksave \|= 0x20;
166	}
167	}
168
169	// get the SPD reconstructed vertex (vertexer)
170	AliESDVertex* vertex = (AliESDVertex*) fESD->GetVertex();
171	if (vertex->GetNContributors()) {
172	fZVertex = vertex->GetZv();
173	fYVertex = vertex->GetYv();
174	fXVertex = vertex->GetXv();
175	fErXVertex = vertex->GetXRes();
176	fErYVertex = vertex->GetYRes();
177	}
178
179	Int_t nTracks = (Int_t)fESD->GetNumberOfMuonTracks() ;
180	for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {
181
182	AliESDMuonTrack* muonTrack = new AliESDMuonTrack(*(fESD->GetMuonTrack(iTrack)));
183	if (!muonTrack) {
184	Printf("ERROR: Could not receive track %d", iTrack);
185	continue;
186	}
187
188	pt = muonTrack->Pt();
189	p = muonTrack->P();
190	eta = muonTrack->Eta();
191	thetad = muonTrack->Theta()*180./TMath::Pi();
192	phid = muonTrack->Phi()*180./TMath::Pi();
193	charge = muonTrack->Charge();
194	hits = muonTrack->GetNHit();
195	chi2 = muonTrack->GetChi2() / (2.0 * hits - 5);
196	zcoor = muonTrack->GetZ();
197	matchTrig = muonTrack->GetMatchTrigger();
198	chi2MatchTrig = muonTrack->GetChi2MatchTrigger();
199
200	rEff[0] = rEff[1] = 0.0;
201	GetEffFitted(eta,pt,rEff);
202
203	ntvar[0] = fZVertex;
204	ntvar[1] = nTracks;
205	ntvar[2] = masksave;
206	ntvar[3] = charge;
207	ntvar[4] = pt;
208	ntvar[5] = p;
209	ntvar[6] = eta;
210	ntvar[7] = thetad;
211	ntvar[8] = phid;
212	ntvar[9] = zcoor;
213	ntvar[10] = hits;
214	ntvar[11] = chi2;
215	ntvar[12] = rEff[0];
216	ntvar[13] = matchTrig;
217	ntvar[14] = chi2MatchTrig;
218
219	fNtuple->Fill(ntvar);
220
221
222	} //track loop
223
224	// Post output data.
225	PostData(0, fNtuple);
226	PostData(1, fTrigger);
227
228	}
229
230	//________________________________________________________________________
231	void AliAnalysisTaskSingleMuESD::Terminate(Option_t *)
232	{
233	// the end
234	}
235
236	//________________________________________________________________________
237	void AliAnalysisTaskSingleMuESD::GetEffFitted(Double_t eta, Double_t pt, Double_t rEff[2])
238	{
239	// tracking efficiency
240
241	Int_t nbinEta =15;
242	Float_t etaMin = -4.;
243	Float_t etaBin = 0.1;
244	Int_t numBin = -1;
245	rEff[0]=1.;rEff[1]=0.;
246
247	// nbinEta = number of eta bins startig at etaMin = -4 and binning of 0.1 (etaBin)
248	Float_t p0[15] = {-0.9338,-0.9441,-0.9397,-0.9586,-0.9713,-0.9752,-0.9711,-0.9751,-0.9746,-0.9729,-0.9754,-0.9722,-0.9722,-0.971,-0.9709};
249	Float_t p1[15] = {-0.6383,-1.4729,-1.0109,-1.4316,-1.5926,-1.367,-1.1895,-1.2834,-1.3289,-1.5916,-1.4258,-1.0983,-1.0812,-0.7179, -0.4613};
250
251	Float_t etaInf, etaSup;
252	for (Int_t i = 1; i < nbinEta+1; i++){
253	etaInf = etaMin + (i-1)*etaBin;
254	etaSup = etaMin + i*etaBin;
255	if(eta > etaInf && eta <= etaSup) numBin = i-1;
256	}
257
258	if(numBin>=0 && pt >=1.) rEff[0] = p0[numBin] * TMath::TanH(p1[numBin]*pt);
259	rEff[1] = 0;
260
261	}
262
263	//________________________________________________________________________
264	void AliAnalysisTaskSingleMuESD::SetTriggerType(const Char_t *trig)
265	{
266	// set the trigger masks according to the trigger type used in the
267	// simulations
268
269	TString triggerType(trig);
270
271	if (!triggerType.CompareTo("MUON")) {
272	fMaskTrig1MuL = 1; // MULow
273	fMaskTrig1MuH = 2; // MUHigh
274	fMaskTrigUSL = 4; // MULU
275	fMaskTrigLSL = 16; // MULL
276	fMaskTrigUSH = 8; // MUHU
277	fMaskTrigLSH = 32; // MUHL
278	} else if (!triggerType.CompareTo("p-p")) {
279	fMaskTrig1MuL = 128; // MULow
280	fMaskTrig1MuH = 256; // MUHigh
281	fMaskTrigUSL = 65536; // MULU
282	fMaskTrigLSL = 131072; // MULL
283	fMaskTrigUSH = 262144; // MUHU
284	fMaskTrigLSH = 524288; // MUHL
285	} else {
286	// MUON trigger, values by default in the constructor
287	}
288
289	fTriggerType = kTRUE;
290
291	}
292