[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(12) ; 
  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(" *** %s Report:", 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("         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("     matching efficiency with the trigger for single tracks = %2d %% \n", effMatch);
  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 -zcf %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
84eb42a1	148	fOutputContainer = new TObjArray(12) ;
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
84eb42a1	282	AliInfo(Form(" *** %s Report:", GetName())) ;
84eb42a1	283
c52c2132	284	fOutputContainer = (TObjArray*)GetOutputData(0);
	285	fhMUONVertex = (TH1F*)fOutputContainer->At(0);
	286	fhMUONMult = (TH1F*)fOutputContainer->At(1);
57139bf5	287	fhPt = (TH1F*)fOutputContainer->At(2);
	288	fhY = (TH1F*)fOutputContainer->At(3);
	289	fheffMatchT=(TH1F*)fOutputContainer->At(4);
	290	fhSLowpt=(TH1F*)fOutputContainer->At(5);
	291	fhUSLowpt=(TH1F*)fOutputContainer->At(6);
	292	fhUSHighpt=(TH1F*)fOutputContainer->At(7);
	293	fhLSLowpt=(TH1F*)fOutputContainer->At(8);
	294	fhLSHighpt=(TH1F*)fOutputContainer->At(9);
84eb42a1	295
1dfe075f	296	printf(" Total number of processed events %d \n", fnevents) ;
84eb42a1	297	printf(" \n") ;
	298	printf(" \n") ;
	299	printf(" Table 1: \n") ;
	300	printf(" ===================================================\n") ;
	301	printf(" Global Trigger output Low pt High pt \n") ;
	302	printf(" number of Single :\t");
	303	printf(" %i\t", fSLowpt) ;
1dfe075f	304	printf("\n");
84eb42a1	305	printf(" number of UnlikeSign pair :\t");
84eb42a1	306	printf(" %i\t%i\t", fUSLowpt, fUSHighpt) ;
1dfe075f	307	printf("\n");
84eb42a1	308	printf(" number of LikeSign pair :\t");
84eb42a1	309	printf(" %i\t%i\t", fLSLowpt, fLSHighpt) ;
1dfe075f	310	printf("\n");
84eb42a1	311	printf(" matching efficiency with the trigger for single tracks = %2d %% \n", effMatch);
57139bf5	312	printf("\n") ;
1dfe075f	313
57139bf5	314	TCanvas * cMUON1 = new TCanvas("cMUON1", "MUON ESD Vert & Mult", 400, 10, 600, 700) ;
	315	cMUON1->Divide(1,2) ;
	316	cMUON1->cd(1) ;
	317	fhMUONVertex->SetXTitle("Vz (cm)");
1dfe075f	318	fhMUONVertex->Draw() ;
57139bf5	319	cMUON1->cd(2) ;
	320	fhMUONMult->SetXTitle(" Track Multiplicity");
	321	fhMUONMult->Draw() ;
	322	cMUON1->Print("MUON1.eps") ;
1dfe075f	323
57139bf5	324	TCanvas * cMUON2 = new TCanvas("cMUON2", "MUON ESD Pt & Y", 400, 10, 600, 700) ;
	325	cMUON2->Divide(1,2) ;
	326	cMUON2->cd(1) ;
	327	fhPt->SetXTitle("Pt (GeV)");
	328	fhPt->Draw() ;
	329	cMUON2->cd(2) ;
	330	fhY->SetXTitle("Y");
	331	fhY->Draw() ;
	332	cMUON2->Print("MUON2.eps") ;
	333
	334	TCanvas * cMUON3 = new TCanvas("cMUON3", "Track Chi2 by dof and Chi2 of trigger/track matching ", 400, 10, 600, 700) ;
	335	cMUON3->Divide(1,2) ;
	336	cMUON3->cd(1) ;
	337	fhChi2->SetXTitle("Chi2 by d.o.f.");
	338	fhChi2->Draw();
	339	cMUON3->cd(2) ;
	340	fhChi2match->SetXTitle("Chi2 of trig/track matching");
	341	fhChi2match->Draw();
	342	cMUON3->Print("MUON3.eps") ;
	343
	344	TCanvas * cMUON4 = new TCanvas("cMUON4", "Trigger Matching and Trigger Response (%)", 400, 10, 600, 700) ;
	345	cMUON4->Divide(2,3) ;
	346	cMUON4->cd(1) ;
	347	fheffMatchT->SetXTitle("%");
	348	fheffMatchT->Draw() ;
	349	cMUON4->cd(2) ;
	350	fhSLowpt->SetXTitle("%");
	351	fhSLowpt->Draw() ;
	352	cMUON4->cd(3) ;
	353	fhUSLowpt->SetXTitle("%");
	354	fhUSLowpt->Draw() ;
	355	cMUON4->cd(4) ;
	356	fhUSHighpt->SetXTitle("%");
	357	fhUSHighpt->Draw() ;
	358	cMUON4->cd(5) ;
	359	fhLSLowpt->SetXTitle("%");
	360	fhLSLowpt->Draw() ;
	361	cMUON4->cd(6) ;
	362	fhLSHighpt->SetXTitle("%");
	363	fhLSHighpt->Draw() ;
	364	cMUON4->Print("MUON4.eps") ;
	365
1dfe075f	366	char line[1024] ;
84eb42a1	367	sprintf(line, ".!tar -zcf %s.tar.gz *.eps", GetName()) ;
1dfe075f	368	gROOT->ProcessLine(line);
	369	sprintf(line, ".!rm -fR *.eps");
	370	gROOT->ProcessLine(line);
	371
	372	AliInfo(Form("!!! All the eps files are in %s.tar.gz !!! \n", GetName())) ;
	373	}