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


/* $Id$ */

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