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

/* $Id$ */

/// An analysis task to check the MUON data in simulated data
/// This class checks out the ESD tree, providing the matching with
/// the trigger,trigger responses for Low and High Pt cuts
/// (in Single, Unlike Sign and Like Sign) and gives Pt, Y, ITS vertex
/// and multiplicity distributions. All results are in histogram form.
/// The output is a root file and eps files in MUON.tar.gz. 

//*-- Frederic Yermia, yermia@to.infn.it
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

#include <TCanvas.h>
#include <TChain.h>
#include <TFile.h>
#include <TH1F.h>
#include <TROOT.h>
#include <TLorentzVector.h>
#include "AliMUONQATask.h" 
#include "AliESD.h" 
#include "AliLog.h"
#include "AliESDVertex.h" 
#include "AliESDMuonTrack.h"
#include <TLorentzVector.h>
//______________________________________________________________________________
AliMUONQATask::AliMUONQATask(const char *name) : 
  AliAnalysisTask(name,""),  
  fChain(0),
  fESD(0), 
  fnTrackTrig(0), 
  ftracktot(0),
  fnevents(0),
  fSLowpt(0),
  fUSLowpt(0),
  fUSHighpt(0),
  fLSLowpt(0),
  fLSHighpt(0),
  fmuonMass(0.105658389),
  fthetaX(0),
  fthetaY(0),
  fpYZ(0),
  fPxRec1(0),
  fPyRec1(0),
  fPzRec1(0),
  fE1(0),
  fZ1(0),
  fhMUONVertex(0),
  fhMUONMult(0),
  fhPt(0),
  fhY(0),
  fheffMatchT(0),
  fhSLowpt(0),
  fhUSLowpt(0),
  fhUSHighpt(0),
  fhLSLowpt(0),
  fhLSHighpt(0),
  fhChi2(0),  
  fhChi2match(0)  
{
  // Constructor.
  // Input slot #0 works with an Ntuple
  DefineInput(0, TChain::Class());
  // Output slot #0 writes into a TH1 container
  DefineOutput(0,  TObjArray::Class()) ; 

}


//______________________________________________________________________________
AliMUONQATask::~AliMUONQATask()
{ 
  // dtor
   fOutputContainer->Clear() ; 
   delete fOutputContainer ; 
  
   delete fhMUONVertex ; 
   delete fhMUONMult ; 
   delete fhPt ; 
   delete fhY ;
   delete fheffMatchT ;
   delete fhSLowpt ;
   delete fhUSLowpt ;
   delete fhUSHighpt;
   delete fhLSLowpt ;
   delete fhLSHighpt;
   delete fhChi2   ;  
   delete fhChi2match ;
}

//______________________________________________________________________________
void AliMUONQATask::ConnectInputData(const Option_t*)
{
  // Initialisation of branch container and histograms 
    
  AliInfo(Form("*** Initialization of %s", GetName())) ; 
  
  // Get input data
  fChain = dynamic_cast<TChain *>(GetInputData(0)) ;
  if (!fChain) {
    AliError(Form("Input 0 for %s not found\n", GetName()));
    return ;
  }
  
  // One should first check if the branch address was taken by some other task
  char ** address = (char **)GetBranchAddress(0, "ESD");
  if (address) {
    fESD = (AliESD*)(*address);
  } else {
    fESD = new AliESD();
    SetBranchAddress(0, "ESD", &fESD);
  }
}

//________________________________________________________________________
void AliMUONQATask::CreateOutputObjects()
{  
  // create histograms 
  fhMUONVertex = new TH1F("hMUONVertex","ITS Vertex"                ,100, -25., 25.);
  fhMUONMult   = new TH1F("hMUONMult"  ,"Multiplicity of ESD tracks",10,  -0.5, 9.5);
  fhPt = new TH1F("hPt","Pt",100, 0.,20.);
  fhY = new TH1F("hY","Rapidity",100,-5.,-1.);
  fheffMatchT =  new TH1F("heff_matchT","Trigger Matching Efficiency",100, 0.,100.);
  fhSLowpt = new TH1F("hSLowpt","Single Low Pt Response (%)",101, 0.,101.);
  fhUSLowpt = new TH1F("hUSLowpt","Unlike Sign Low Pt Response (%)",101, 0.,101.);
  fhUSHighpt = new TH1F("hUSHighpt","Unlike Sign High Pt Response (%)",101, 0.,101.);
  fhLSLowpt = new TH1F("hLSLowpt","Like Sign Low Pt Response (%)",101, 0.,101.);
  fhLSHighpt = new TH1F("hLSHighpt","Like Sign High Pt Response (%)",101, 0.,101.);
  fhChi2 = new TH1F("hChi2","Chi2 by d.o.f.",100, 0.,20.);
  fhChi2match = new TH1F("hChi2match","Chi2 of trig/track matching",100, 0.,20.);
  // create output container
  
  fOutputContainer = new TObjArray(10) ; 
  fOutputContainer->SetName(GetName()) ; 
  fOutputContainer->AddAt(fhMUONVertex,             0) ; 
  fOutputContainer->AddAt(fhMUONMult,               1) ; 
  fOutputContainer->AddAt(fhPt,                     2) ; 
  fOutputContainer->AddAt(fhY,                      3) ; 
  fOutputContainer->AddAt(fheffMatchT,              4) ;
  fOutputContainer->AddAt(fhSLowpt,                 5) ;
  fOutputContainer->AddAt(fhUSLowpt,                6) ;
  fOutputContainer->AddAt(fhUSHighpt,               7) ;
  fOutputContainer->AddAt(fhLSLowpt,                8) ;
  fOutputContainer->AddAt(fhLSHighpt,               9) ;
  fOutputContainer->AddAt(fhChi2,                  10) ;
  fOutputContainer->AddAt( fhChi2match,            11) ;
}

//______________________________________________________________________________
void AliMUONQATask::Exec(Option_t *) 
{
  // Processing of one event
    
  fnevents++ ; 

  Long64_t entry = fChain->GetReadEntry() ;
  
  if (!fESD) {
    AliError("fESD is not connected to the input!") ; 
    return ; 
  }
  
  if ( !((entry-1)%100) ) 
    AliInfo(Form("%s ----> Processing event # %lld",  (dynamic_cast<TChain *>(fChain))->GetFile()->GetName(), entry)) ; 
  
  // ************************  MUON *************************************
    
  const AliESDVertex* vertex = dynamic_cast<const AliESDVertex*>(fESD->GetVertex()) ;

  Double_t zVertex = 0. ;
  if (vertex) 
    zVertex = vertex->GetZv() ;
  
  Int_t nTracks = fESD->GetNumberOfMuonTracks() ;
  
  ULong64_t trigWord = fESD->GetTriggerMask() ;

  if (trigWord & 0x80) {
        fSLowpt++;
  }
  if (trigWord & 0x100){
    fLSLowpt++;
  } 
  if (trigWord & 0x200){
    fLSHighpt++;
  }  
  if (trigWord & 0x400){
    fUSLowpt++;
  }
  if (trigWord & 0x800){
    fUSHighpt++;
  }

  Int_t tracktrig  = 0 ;
  Int_t iTrack1 ; 
  
  for (iTrack1 = 0 ; iTrack1 < nTracks ; iTrack1++) { //1st loop
    AliESDMuonTrack* muonTrack = fESD->GetMuonTrack(iTrack1) ;
    ftracktot++ ;
      fthetaX = muonTrack->GetThetaX();
      fthetaY = muonTrack->GetThetaY();
      fpYZ     =  1./TMath::Abs(muonTrack->GetInverseBendingMomentum());
      fPzRec1  = - fpYZ / TMath::Sqrt(1.0 + TMath::Tan(fthetaY)*TMath::Tan(fthetaY));
      fPxRec1  = fPzRec1 * TMath::Tan(fthetaX);
      fPyRec1  = fPzRec1 * TMath::Tan(fthetaY);
      fZ1 = Int_t(TMath::Sign(1.,muonTrack->GetInverseBendingMomentum()));
      fE1 = TMath::Sqrt(fmuonMass * fmuonMass + fPxRec1 * fPxRec1 + fPyRec1 * fPyRec1 + fPzRec1 * fPzRec1);
      fV1.SetPxPyPzE(fPxRec1, fPyRec1, fPzRec1, fE1);

      // -----------> transverse momentum
      Float_t pt1 = fV1.Pt();
      // ----------->Rapidity
      Float_t y1 = fV1.Rapidity();
  
    if(muonTrack->GetMatchTrigger()) {
      fnTrackTrig++ ;
      tracktrig++ ;
      Float_t  Chi2match = muonTrack->GetChi2MatchTrigger();
      fhChi2match->Fill(Chi2match);
    }

     Float_t   fitfmin  = muonTrack->GetChi2();
     Int_t    ntrackhits = muonTrack->GetNHit();
     Float_t Chi2= fitfmin  / (2.0 * ntrackhits - 5);
    
     fhChi2->Fill(Chi2);
     fhPt->Fill(pt1);
     fhY->Fill(y1);
  }
  
  fhMUONVertex->Fill(zVertex) ;
  fhMUONMult->Fill(Float_t(nTracks)) ;
  
  PostData(0, fOutputContainer);  
}

//______________________________________________________________________________
void AliMUONQATask::Terminate(Option_t *)
{
  // Processing when the event loop is ended
    Int_t fSLowPt = fSLowpt;
   if(fnevents){
     fSLowPt = 100 * fSLowpt / fnevents ;
     fhSLowpt->Fill(fSLowPt); }
    Int_t fUSLowPt = fUSLowpt;
   if(fnevents){
     fUSLowPt = 100 * fUSLowpt / fnevents ;
     fhUSLowpt->Fill(fUSLowPt); }
    Int_t fUSHighPt = fUSHighpt;
    if(fnevents){
      fUSHighPt = 100 * fUSHighpt / fnevents ;
      fhUSHighpt->Fill(fUSHighPt); }
    Int_t fLSLowPt = fLSLowpt;
    if(fnevents){
      fLSLowPt = 100 * fLSLowpt / fnevents ;
      fhLSLowpt->Fill(fLSLowPt); }
    Int_t fLSHighPt = fLSHighpt;
    if(fnevents){
      fLSHighPt = 100 * fLSHighpt / fnevents ;
      fhLSHighpt->Fill(fLSHighPt); }
  
    Int_t effMatch = -1 ; 
    if (ftracktot){ 
      effMatch = 100 * fnTrackTrig / ftracktot ;
      fheffMatchT->Fill(effMatch);}

  AliInfo(Form("Terminate %s:", GetName())) ;
  fOutputContainer = (TObjArray*)GetOutputData(0);
  fhMUONVertex = (TH1F*)fOutputContainer->At(0);
  fhMUONMult   = (TH1F*)fOutputContainer->At(1); 
  fhPt  = (TH1F*)fOutputContainer->At(2); 
  fhY  = (TH1F*)fOutputContainer->At(3); 
  fheffMatchT=(TH1F*)fOutputContainer->At(4); 
  fhSLowpt=(TH1F*)fOutputContainer->At(5); 
  fhUSLowpt=(TH1F*)fOutputContainer->At(6); 
  fhUSHighpt=(TH1F*)fOutputContainer->At(7);
  fhLSLowpt=(TH1F*)fOutputContainer->At(8); 
  fhLSHighpt=(TH1F*)fOutputContainer->At(9);
 //______________________________________________________________________
  printf("===================================================\n") ;
  printf("================  %s ESD SUMMARY    ==============\n", GetName()) ;
  printf("                                                   \n") ;
  printf("         Total number of processed events  %d      \n", fnevents) ;
  printf("\n")  ;
  printf("\n")  ;
  printf("Table 1:                                         \n") ;
   printf("===================================================\n") ;
 printf(" Global Trigger output       Low pt  High pt \n") ;
  printf(" number of Single      :\t");
  printf("%i\t", fSLowpt) ;
  printf("\n");
  printf(" number of UnlikeSign pair  :\t"); 
  printf("%i\t%i\t", fUSLowpt, fUSHighpt) ;
  printf("\n");
  printf(" number of LikeSign pair    :\t");  
  printf("%i\t%i\t", fLSLowpt, fLSHighpt) ;
  printf("\n");
  printf("===================================================\n") ;
  printf("\n") ;
  printf("matching efficiency with the trigger for single tracks = %2d %% \n", effMatch);
  printf("\n") ;
  printf("===================================================\n") ;
  
TCanvas * cMUON1 = new TCanvas("cMUON1", "MUON ESD Vert & Mult", 400, 10, 600, 700) ;
  cMUON1->Divide(1,2) ;
  cMUON1->cd(1) ;
 fhMUONVertex->SetXTitle("Vz (cm)");
  fhMUONVertex->Draw() ;
  cMUON1->cd(2) ;
  fhMUONMult->SetXTitle(" Track Multiplicity");
  fhMUONMult->Draw() ;
  cMUON1->Print("MUON1.eps") ; 

  TCanvas * cMUON2 = new TCanvas("cMUON2", "MUON ESD Pt & Y", 400, 10, 600, 700) ;
  cMUON2->Divide(1,2) ;
  cMUON2->cd(1) ;
  fhPt->SetXTitle("Pt (GeV)");
  fhPt->Draw() ;
  cMUON2->cd(2) ;
  fhY->SetXTitle("Y");
  fhY->Draw() ;
  cMUON2->Print("MUON2.eps") ;
  
  TCanvas * cMUON3 = new TCanvas("cMUON3", "Track Chi2 by dof and Chi2 of trigger/track matching ", 400, 10, 600, 700) ;
  cMUON3->Divide(1,2) ;
  cMUON3->cd(1) ;
  fhChi2->SetXTitle("Chi2 by d.o.f.");
  fhChi2->Draw();
  cMUON3->cd(2) ;
  fhChi2match->SetXTitle("Chi2 of trig/track matching");
  fhChi2match->Draw();
  cMUON3->Print("MUON3.eps") ;
  
  TCanvas * cMUON4 = new TCanvas("cMUON4", "Trigger Matching and Trigger Response (%)", 400, 10, 600, 700) ;
  cMUON4->Divide(2,3) ;
  cMUON4->cd(1) ;
  fheffMatchT->SetXTitle("%");
  fheffMatchT->Draw() ;
  cMUON4->cd(2) ;
  fhSLowpt->SetXTitle("%");
  fhSLowpt->Draw() ;
  cMUON4->cd(3) ;
  fhUSLowpt->SetXTitle("%");
  fhUSLowpt->Draw() ;
  cMUON4->cd(4) ;
  fhUSHighpt->SetXTitle("%");
  fhUSHighpt->Draw() ;
  cMUON4->cd(5) ;
  fhLSLowpt->SetXTitle("%");
  fhLSLowpt->Draw() ;
  cMUON4->cd(6) ;
  fhLSHighpt->SetXTitle("%");
  fhLSHighpt->Draw() ;
  cMUON4->Print("MUON4.eps") ;
 
  char line[1024] ; 
  sprintf(line, ".!tar -zcvf %s.tar.gz *.eps", GetName()) ; 
  gROOT->ProcessLine(line);
  sprintf(line, ".!rm -fR *.eps"); 
  gROOT->ProcessLine(line);
 
  AliInfo(Form("!!! All the eps files are in %s.tar.gz !!! \n", GetName())) ;
}
Commit	Line	Data
1dfe075f	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	**************************************************************************/
0b28fd57	15
	16	/* $Id$ */
	17
57139bf5	18	/// An analysis task to check the MUON data in simulated data
	19	/// This class checks out the ESD tree, providing the matching with
	20	/// the trigger,trigger responses for Low and High Pt cuts
	21	/// (in Single, Unlike Sign and Like Sign) and gives Pt, Y, ITS vertex
	22	/// and multiplicity distributions. All results are in histogram form.
	23	/// The output is a root file and eps files in MUON.tar.gz.
	24
	25	//*-- Frederic Yermia, yermia@to.infn.it
1dfe075f	26	//////////////////////////////////////////////////////////////////////////////
	27	//////////////////////////////////////////////////////////////////////////////
	28
0b28fd57	29	#include <TCanvas.h>
1dfe075f	30	#include <TChain.h>
57139bf5	31	#include <TFile.h>
1dfe075f	32	#include <TH1F.h>
0b28fd57	33	#include <TROOT.h>
57139bf5	34	#include <TLorentzVector.h>
1dfe075f	35	#include "AliMUONQATask.h"
	36	#include "AliESD.h"
	37	#include "AliLog.h"
	38	#include "AliESDVertex.h"
	39	#include "AliESDMuonTrack.h"
57139bf5	40	#include <TLorentzVector.h>
1dfe075f	41	//______________________________________________________________________________
	42	AliMUONQATask::AliMUONQATask(const char *name) :
	43	AliAnalysisTask(name,""),
	44	fChain(0),
	45	fESD(0),
	46	fnTrackTrig(0),
	47	ftracktot(0),
	48	fnevents(0),
57139bf5	49	fSLowpt(0),
1dfe075f	50	fUSLowpt(0),
1dfe075f	51	fUSHighpt(0),
1dfe075f	52	fLSLowpt(0),
1dfe075f	53	fLSHighpt(0),
57139bf5	54	fmuonMass(0.105658389),
	55	fthetaX(0),
	56	fthetaY(0),
	57	fpYZ(0),
	58	fPxRec1(0),
	59	fPyRec1(0),
	60	fPzRec1(0),
	61	fE1(0),
	62	fZ1(0),
1dfe075f	63	fhMUONVertex(0),
57139bf5	64	fhMUONMult(0),
	65	fhPt(0),
	66	fhY(0),
	67	fheffMatchT(0),
	68	fhSLowpt(0),
	69	fhUSLowpt(0),
	70	fhUSHighpt(0),
	71	fhLSLowpt(0),
	72	fhLSHighpt(0),
	73	fhChi2(0),
	74	fhChi2match(0)
1dfe075f	75	{
	76	// Constructor.
	77	// Input slot #0 works with an Ntuple
	78	DefineInput(0, TChain::Class());
	79	// Output slot #0 writes into a TH1 container
	80	DefineOutput(0, TObjArray::Class()) ;
57139bf5	81
1dfe075f	82	}
1dfe075f	83
57139bf5	84
1dfe075f	85	//______________________________________________________________________________
	86	AliMUONQATask::~AliMUONQATask()
	87	{
	88	// dtor
57139bf5	89	fOutputContainer->Clear() ;
57139bf5	90	delete fOutputContainer ;
1dfe075f	91
57139bf5	92	delete fhMUONVertex ;
	93	delete fhMUONMult ;
	94	delete fhPt ;
	95	delete fhY ;
	96	delete fheffMatchT ;
	97	delete fhSLowpt ;
	98	delete fhUSLowpt ;
	99	delete fhUSHighpt;
	100	delete fhLSLowpt ;
	101	delete fhLSHighpt;
	102	delete fhChi2 ;
	103	delete fhChi2match ;
1dfe075f	104	}
	105
	106	//______________________________________________________________________________
c52c2132	107	void AliMUONQATask::ConnectInputData(const Option_t*)
1dfe075f	108	{
	109	// Initialisation of branch container and histograms
	110
	111	AliInfo(Form("*** Initialization of %s", GetName())) ;
	112
	113	// Get input data
	114	fChain = dynamic_cast<TChain *>(GetInputData(0)) ;
	115	if (!fChain) {
	116	AliError(Form("Input 0 for %s not found\n", GetName()));
	117	return ;
	118	}
	119
c52c2132	120	// One should first check if the branch address was taken by some other task
	121	char address = (char )GetBranchAddress(0, "ESD");
	122	if (address) {
	123	fESD = (AliESD)(address);
	124	} else {
	125	fESD = new AliESD();
	126	SetBranchAddress(0, "ESD", &fESD);
1dfe075f	127	}
c52c2132	128	}
	129
	130	//________________________________________________________________________
	131	void AliMUONQATask::CreateOutputObjects()
	132	{
1dfe075f	133	// create histograms
	134	fhMUONVertex = new TH1F("hMUONVertex","ITS Vertex" ,100, -25., 25.);
	135	fhMUONMult = new TH1F("hMUONMult" ,"Multiplicity of ESD tracks",10, -0.5, 9.5);
57139bf5	136	fhPt = new TH1F("hPt","Pt",100, 0.,20.);
	137	fhY = new TH1F("hY","Rapidity",100,-5.,-1.);
	138	fheffMatchT = new TH1F("heff_matchT","Trigger Matching Efficiency",100, 0.,100.);
	139	fhSLowpt = new TH1F("hSLowpt","Single Low Pt Response (%)",101, 0.,101.);
	140	fhUSLowpt = new TH1F("hUSLowpt","Unlike Sign Low Pt Response (%)",101, 0.,101.);
	141	fhUSHighpt = new TH1F("hUSHighpt","Unlike Sign High Pt Response (%)",101, 0.,101.);
	142	fhLSLowpt = new TH1F("hLSLowpt","Like Sign Low Pt Response (%)",101, 0.,101.);
	143	fhLSHighpt = new TH1F("hLSHighpt","Like Sign High Pt Response (%)",101, 0.,101.);
	144	fhChi2 = new TH1F("hChi2","Chi2 by d.o.f.",100, 0.,20.);
	145	fhChi2match = new TH1F("hChi2match","Chi2 of trig/track matching",100, 0.,20.);
1dfe075f	146	// create output container
1dfe075f	147
57139bf5	148	fOutputContainer = new TObjArray(10) ;
1dfe075f	149	fOutputContainer->SetName(GetName()) ;
1dfe075f	150	fOutputContainer->AddAt(fhMUONVertex, 0) ;
1dfe075f	151	fOutputContainer->AddAt(fhMUONMult, 1) ;
57139bf5	152	fOutputContainer->AddAt(fhPt, 2) ;
	153	fOutputContainer->AddAt(fhY, 3) ;
	154	fOutputContainer->AddAt(fheffMatchT, 4) ;
	155	fOutputContainer->AddAt(fhSLowpt, 5) ;
	156	fOutputContainer->AddAt(fhUSLowpt, 6) ;
	157	fOutputContainer->AddAt(fhUSHighpt, 7) ;
	158	fOutputContainer->AddAt(fhLSLowpt, 8) ;
	159	fOutputContainer->AddAt(fhLSHighpt, 9) ;
	160	fOutputContainer->AddAt(fhChi2, 10) ;
	161	fOutputContainer->AddAt( fhChi2match, 11) ;
1dfe075f	162	}
	163
	164	//______________________________________________________________________________
	165	void AliMUONQATask::Exec(Option_t *)
	166	{
	167	// Processing of one event
	168
	169	fnevents++ ;
	170
	171	Long64_t entry = fChain->GetReadEntry() ;
	172
	173	if (!fESD) {
	174	AliError("fESD is not connected to the input!") ;
	175	return ;
	176	}
	177
	178	if ( !((entry-1)%100) )
	179	AliInfo(Form("%s ----> Processing event # %lld", (dynamic_cast<TChain *>(fChain))->GetFile()->GetName(), entry)) ;
	180
	181	// ********************** MUON ***********************************
	182
	183	const AliESDVertex* vertex = dynamic_cast<const AliESDVertex*>(fESD->GetVertex()) ;
	184
	185	Double_t zVertex = 0. ;
	186	if (vertex)
	187	zVertex = vertex->GetZv() ;
	188
	189	Int_t nTracks = fESD->GetNumberOfMuonTracks() ;
	190
	191	ULong64_t trigWord = fESD->GetTriggerMask() ;
	192
57139bf5	193	if (trigWord & 0x80) {
	194	fSLowpt++;
	195	}
	196	if (trigWord & 0x100){
1dfe075f	197	fLSLowpt++;
57139bf5	198	}
57139bf5	199	if (trigWord & 0x200){
1dfe075f	200	fLSHighpt++;
57139bf5	201	}
	202	if (trigWord & 0x400){
	203	fUSLowpt++;
	204	}
	205	if (trigWord & 0x800){
	206	fUSHighpt++;
	207	}
1dfe075f	208
	209	Int_t tracktrig = 0 ;
	210	Int_t iTrack1 ;
	211
	212	for (iTrack1 = 0 ; iTrack1 < nTracks ; iTrack1++) { //1st loop
	213	AliESDMuonTrack* muonTrack = fESD->GetMuonTrack(iTrack1) ;
	214	ftracktot++ ;
57139bf5	215	fthetaX = muonTrack->GetThetaX();
	216	fthetaY = muonTrack->GetThetaY();
	217	fpYZ = 1./TMath::Abs(muonTrack->GetInverseBendingMomentum());
	218	fPzRec1 = - fpYZ / TMath::Sqrt(1.0 + TMath::Tan(fthetaY)*TMath::Tan(fthetaY));
	219	fPxRec1 = fPzRec1 * TMath::Tan(fthetaX);
	220	fPyRec1 = fPzRec1 * TMath::Tan(fthetaY);
	221	fZ1 = Int_t(TMath::Sign(1.,muonTrack->GetInverseBendingMomentum()));
	222	fE1 = TMath::Sqrt(fmuonMass * fmuonMass + fPxRec1 * fPxRec1 + fPyRec1 * fPyRec1 + fPzRec1 * fPzRec1);
	223	fV1.SetPxPyPzE(fPxRec1, fPyRec1, fPzRec1, fE1);
	224
	225	// -----------> transverse momentum
	226	Float_t pt1 = fV1.Pt();
	227	// ----------->Rapidity
	228	Float_t y1 = fV1.Rapidity();
	229
1dfe075f	230	if(muonTrack->GetMatchTrigger()) {
	231	fnTrackTrig++ ;
	232	tracktrig++ ;
57139bf5	233	Float_t Chi2match = muonTrack->GetChi2MatchTrigger();
57139bf5	234	fhChi2match->Fill(Chi2match);
1dfe075f	235	}
1dfe075f	236
57139bf5	237	Float_t fitfmin = muonTrack->GetChi2();
	238	Int_t ntrackhits = muonTrack->GetNHit();
	239	Float_t Chi2= fitfmin / (2.0 * ntrackhits - 5);
	240
	241	fhChi2->Fill(Chi2);
	242	fhPt->Fill(pt1);
	243	fhY->Fill(y1);
	244	}
	245
1dfe075f	246	fhMUONVertex->Fill(zVertex) ;
1dfe075f	247	fhMUONMult->Fill(Float_t(nTracks)) ;
57139bf5	248
1dfe075f	249	PostData(0, fOutputContainer);
	250	}
	251
	252	//______________________________________________________________________________
	253	void AliMUONQATask::Terminate(Option_t *)
	254	{
	255	// Processing when the event loop is ended
57139bf5	256	Int_t fSLowPt = fSLowpt;
	257	if(fnevents){
	258	fSLowPt = 100 * fSLowpt / fnevents ;
	259	fhSLowpt->Fill(fSLowPt); }
	260	Int_t fUSLowPt = fUSLowpt;
	261	if(fnevents){
	262	fUSLowPt = 100 * fUSLowpt / fnevents ;
	263	fhUSLowpt->Fill(fUSLowPt); }
	264	Int_t fUSHighPt = fUSHighpt;
	265	if(fnevents){
	266	fUSHighPt = 100 * fUSHighpt / fnevents ;
	267	fhUSHighpt->Fill(fUSHighPt); }
	268	Int_t fLSLowPt = fLSLowpt;
	269	if(fnevents){
	270	fLSLowPt = 100 * fLSLowpt / fnevents ;
	271	fhLSLowpt->Fill(fLSLowPt); }
	272	Int_t fLSHighPt = fLSHighpt;
	273	if(fnevents){
	274	fLSHighPt = 100 * fLSHighpt / fnevents ;
	275	fhLSHighpt->Fill(fLSHighPt); }
	276
	277	Int_t effMatch = -1 ;
	278	if (ftracktot){
	279	effMatch = 100 * fnTrackTrig / ftracktot ;
	280	fheffMatchT->Fill(effMatch);}
1dfe075f	281
1dfe075f	282	AliInfo(Form("Terminate %s:", GetName())) ;
c52c2132	283	fOutputContainer = (TObjArray*)GetOutputData(0);
	284	fhMUONVertex = (TH1F*)fOutputContainer->At(0);
	285	fhMUONMult = (TH1F*)fOutputContainer->At(1);
57139bf5	286	fhPt = (TH1F*)fOutputContainer->At(2);
	287	fhY = (TH1F*)fOutputContainer->At(3);
	288	fheffMatchT=(TH1F*)fOutputContainer->At(4);
	289	fhSLowpt=(TH1F*)fOutputContainer->At(5);
	290	fhUSLowpt=(TH1F*)fOutputContainer->At(6);
	291	fhUSHighpt=(TH1F*)fOutputContainer->At(7);
	292	fhLSLowpt=(TH1F*)fOutputContainer->At(8);
	293	fhLSHighpt=(TH1F*)fOutputContainer->At(9);
	294	//______________________________________________________________________
1dfe075f	295	printf("===================================================\n") ;
	296	printf("================ %s ESD SUMMARY ==============\n", GetName()) ;
	297	printf(" \n") ;
	298	printf(" Total number of processed events %d \n", fnevents) ;
	299	printf("\n") ;
	300	printf("\n") ;
57139bf5	301	printf("Table 1: \n") ;
	302	printf("===================================================\n") ;
	303	printf(" Global Trigger output Low pt High pt \n") ;
	304	printf(" number of Single :\t");
	305	printf("%i\t", fSLowpt) ;
1dfe075f	306	printf("\n");
1dfe075f	307	printf(" number of UnlikeSign pair :\t");
57139bf5	308	printf("%i\t%i\t", fUSLowpt, fUSHighpt) ;
1dfe075f	309	printf("\n");
1dfe075f	310	printf(" number of LikeSign pair :\t");
57139bf5	311	printf("%i\t%i\t", fLSLowpt, fLSHighpt) ;
1dfe075f	312	printf("\n");
	313	printf("===================================================\n") ;
	314	printf("\n") ;
57139bf5	315	printf("matching efficiency with the trigger for single tracks = %2d %% \n", effMatch);
	316	printf("\n") ;
	317	printf("===================================================\n") ;
1dfe075f	318
57139bf5	319	TCanvas * cMUON1 = new TCanvas("cMUON1", "MUON ESD Vert & Mult", 400, 10, 600, 700) ;
	320	cMUON1->Divide(1,2) ;
	321	cMUON1->cd(1) ;
	322	fhMUONVertex->SetXTitle("Vz (cm)");
1dfe075f	323	fhMUONVertex->Draw() ;
57139bf5	324	cMUON1->cd(2) ;
	325	fhMUONMult->SetXTitle(" Track Multiplicity");
	326	fhMUONMult->Draw() ;
	327	cMUON1->Print("MUON1.eps") ;
1dfe075f	328
57139bf5	329	TCanvas * cMUON2 = new TCanvas("cMUON2", "MUON ESD Pt & Y", 400, 10, 600, 700) ;
	330	cMUON2->Divide(1,2) ;
	331	cMUON2->cd(1) ;
	332	fhPt->SetXTitle("Pt (GeV)");
	333	fhPt->Draw() ;
	334	cMUON2->cd(2) ;
	335	fhY->SetXTitle("Y");
	336	fhY->Draw() ;
	337	cMUON2->Print("MUON2.eps") ;
	338
	339	TCanvas * cMUON3 = new TCanvas("cMUON3", "Track Chi2 by dof and Chi2 of trigger/track matching ", 400, 10, 600, 700) ;
	340	cMUON3->Divide(1,2) ;
	341	cMUON3->cd(1) ;
	342	fhChi2->SetXTitle("Chi2 by d.o.f.");
	343	fhChi2->Draw();
	344	cMUON3->cd(2) ;
	345	fhChi2match->SetXTitle("Chi2 of trig/track matching");
	346	fhChi2match->Draw();
	347	cMUON3->Print("MUON3.eps") ;
	348
	349	TCanvas * cMUON4 = new TCanvas("cMUON4", "Trigger Matching and Trigger Response (%)", 400, 10, 600, 700) ;
	350	cMUON4->Divide(2,3) ;
	351	cMUON4->cd(1) ;
	352	fheffMatchT->SetXTitle("%");
	353	fheffMatchT->Draw() ;
	354	cMUON4->cd(2) ;
	355	fhSLowpt->SetXTitle("%");
	356	fhSLowpt->Draw() ;
	357	cMUON4->cd(3) ;
	358	fhUSLowpt->SetXTitle("%");
	359	fhUSLowpt->Draw() ;
	360	cMUON4->cd(4) ;
	361	fhUSHighpt->SetXTitle("%");
	362	fhUSHighpt->Draw() ;
	363	cMUON4->cd(5) ;
	364	fhLSLowpt->SetXTitle("%");
	365	fhLSLowpt->Draw() ;
	366	cMUON4->cd(6) ;
	367	fhLSHighpt->SetXTitle("%");
	368	fhLSHighpt->Draw() ;
	369	cMUON4->Print("MUON4.eps") ;
	370
1dfe075f	371	char line[1024] ;
	372	sprintf(line, ".!tar -zcvf %s.tar.gz *.eps", GetName()) ;
	373	gROOT->ProcessLine(line);
	374	sprintf(line, ".!rm -fR *.eps");
	375	gROOT->ProcessLine(line);
	376
	377	AliInfo(Form("!!! All the eps files are in %s.tar.gz !!! \n", GetName())) ;
	378	}