[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);}

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