[u/mrichter/AliRoot.git] / STEER / AliGlobalQADataMaker.cxx

/*
 The class for calculating the global (not detector specific) quality assurance.
 It reuses the following TLists from its base class 
    AliQADataMaker::fRecPointsQAList (for keeping the track residuals)
    AliQADataMaker::fESDsQAList      (for keeping global ESD QA data)
*/

#include <TPDGCode.h>
#include <TH1F.h>

#include "AliQAChecker.h"
#include "AliGlobalQADataMaker.h"
#include "AliGeomManager.h"
#include "AliESDEvent.h"
#include "AliESDv0.h"
#include "AliRawReader.h"

ClassImp(AliGlobalQADataMaker)
 
//____________________________________________________________________________ 
void AliGlobalQADataMaker::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
{
  //Detector specific actions at end of cycle
  // do the QA checking
  AliQAChecker::Instance()->Run(AliQAv1::kGLOBAL, task, list) ;  
}

//____________________________________________________________________________ 
void AliGlobalQADataMaker::InitRaws()
{
  // create Raws histograms in Raws subdir
}

//____________________________________________________________________________ 
void AliGlobalQADataMaker::InitRecPoints() {
  //------------------------------------------------------
  // This function books the histograms of *track*residuals*
  // as a part of global QA
  //------------------------------------------------------
  const Char_t *name[]={
    "hGlobalSPD1ResidualsY","SPD1ResidualsZ",
    "hGlobalSPD2ResidualsY","SPD2ResidualsZ",
    "hGlobalSDD1ResidualsY","SDD1ResidualsZ",
    "hGlobalSDD2ResidualsY","SDD2ResidualsZ",
    "hGlobalSSD1ResidualsY","SSD1ResidualsZ",
    "hGlobalSSD2ResidualsY","SSD2ResidualsZ",
    
    "hGlobalTPC1ResidualsY","TPC1ResidualsZ",
    "hGlobalTPC2ResidualsY","TPC2ResidualsZ",
    
    "hGlobalTRD1ResidualsY","TRD1ResidualsZ",
    "hGlobalTRD2ResidualsY","TRD2ResidualsZ",
    "hGlobalTRD3ResidualsY","TRD3ResidualsZ",
    "hGlobalTRD4ResidualsY","TRD4ResidualsZ",
    "hGlobalTRD5ResidualsY","TRD5ResidualsZ",
    "hGlobalTRD6ResidualsY","TRD6ResidualsZ",
    
    "hGlobalTOFResidualsY","TOFResidualsZ",
    
    "hGlobalPHOS1ResidualsY","PHOS1ResidualsZ",
    "hGlobalPHOS2ResidualsY","PHOS2ResidualsZ",
    
    "hGlobalHMPIDResidualsY","HMPIDResidualsZ",
    
    "hGlobalMUONResidualsY","MUONResidualsZ",
    
    "hGlobalEMCALResidualsY","EMCALResidualsZ"
  };
  const Char_t *title[]={
    "SPD1 residuals Y","SPD1 residuals Z",
    "SPD2 residuals Y","SPD2 residuals Z",
    "SDD1 residuals Y","SDD1 residuals Z",
    "SDD2 residuals Y","SDD2 residuals Z",
    "SSD1 residuals Y","SSD1 residuals Z",
    "SSD2 residuals Y","SSD2 residuals Z",
    
    "TPC1 residuals Y","TPC1 residuals Z",
    "TPC2 residuals Y","TPC2 residuals Z",
    
    "TRD1 residuals Y","TRD1 residuals Z",
    "TRD2 residuals Y","TRD2 residuals Z",
    "TRD3 residuals Y","TRD3 residuals Z",
    "TRD4 residuals Y","TRD4 residuals Z",
    "TRD5 residuals Y","TRD5 residuals Z",
    "TRD6 residuals Y","TRD6 residuals Z",
    
    "TOF residuals Y","TOF residuals Z",
    
    "PHOS1 residuals Y","PHOS1 residuals Z",
    "PHOS2 residuals Y","PHOS2 residuals Z",
    
    "HMPID residuals Y","HMPID residuals Z",
    
    "MUON residuals Y","MUON residuals Z",
    
    "EMCAL residuals Y","EMCAL residuals Z"
  };
  
  for (Int_t m=1; m<AliGeomManager::kLastLayer; m++) {
    Int_t i=2*m-2;
    TH1F *h=new TH1F(name[i],title[i],100,-5.,5.);
    Add2RecPointsList(h,i);    
    h=new TH1F(name[i+1],title[i+1],100,-5.,5.);
    Add2RecPointsList(h,i+1);    
  }

  Add2RecPointsList(
  new TH1F("hGlobalSSD1AbsoluteResidualsYNegZ",
           "SSD1 Absolute Residuals Y Neg Z",100,-2.,2.),40);
  Add2RecPointsList(
  new TH1F("hGlobalSSD1AbsoluteResidualsZNegZ",
           "SSD1 Absolute Residuals Z Neg Z",100,-2.,2.),41);
  Add2RecPointsList(
  new TH1F("hGlobalSSD1AbsoluteResidualsYPosZ",
           "SSD1 Absolute Residuals Y Pos Z",100,-2.,2.),42);
  Add2RecPointsList(
  new TH1F("hGlobalSSD1AbsoluteResidualsZPosZ",
           "SSD1 Absolute Residuals Z Pos Z",100,-2.,2.),43);


  Add2RecPointsList(
  new TH1F("hGlobalSSD2AbsoluteResidualsYNegZ",
           "SSD2 Absolute Residuals Y Neg Z",100,-3.,3.),44);
  Add2RecPointsList(
  new TH1F("hGlobalSSD2AbsoluteResidualsZNegZ",
           "SSD2 Absolute Residuals Z Neg Z",100,-3.,3.),45);
  Add2RecPointsList(
  new TH1F("hGlobalSSD2AbsoluteResidualsYPosZ",
           "SSD2 Absolute Residuals Y Pos Z",100,-3.,3.),46);
  Add2RecPointsList(
  new TH1F("hGlobalSSD2AbsoluteResidualsZPosZ",
           "SSD2Absolute Residuals Z Pos Z",100,-3.,3.),47);
  
}

//____________________________________________________________________________ 
void AliGlobalQADataMaker::InitESDs() {
  //------------------------------------------------------
  // This function books the ESD QA histograms
  // as a part of global QA
  //------------------------------------------------------

  {// Cluster related QA
    const Char_t *name[]={
      "hGlobalFractionAssignedClustersITS",
      "hGlobalFractionAssignedClustersTPC",
      "hGlobalFractionAssignedClustersTRD"
    };
    const Char_t *title[]={
      "Fraction of the assigned clusters in ITS",
      "Fraction of the assigned clusters in TPC",
      "Fraction of the assigned clusters in TRD"
    };
    Add2ESDsList(new TH1F(name[0],title[0],100,0.,2.),kClr0);
    Add2ESDsList(new TH1F(name[1],title[1],100,0.,2.),kClr1);
    Add2ESDsList(new TH1F(name[2],title[2],100,0.,2.),kClr2);
  }

  {// Track related QA
    const Char_t *name[]={
      "hGlobalTrackAzimuthe",                               // kTrk0
      "hGlobalTrackEta",                                    // kTrk1
      "hGlobalTPCTrackpT",                                  // kTrk2
      "hGlobalTPCITSMatchedpT",                             // kTrk3
      "hGlobalTPCTOFMatchedpT",                             // kTrk4
      "hGlobalTPCITSMatchingProbability",                   // kTrk5
      "hGlobalTPCTOFMatchingProbability"                    // kTrk6
  };
    const Char_t *title[]={
      "Track azimuthal distribution (rad)",                   // kTrk0
      "Track pseudo-rapidity distribution",                   // kTrk1
      "TPC: track momentum distribution (GeV)",               // kTrk2
      "TPC-ITS matched: track momentum distribution (GeV)",   // kTrk3
      "TPC-TOF matched: track momentum distribution (GeV)",   // kTrk4
      "TPC-ITS track-matching probability",                   // kTrk5
      "TPC-TOF track-matching probability"                    // kTrk6
    };
  Add2ESDsList(new TH1F(name[0],title[0],100, 0.,TMath::TwoPi()),kTrk0);
  Add2ESDsList(new TH1F(name[1],title[1],100,-2.00,2.00),kTrk1);
  Add2ESDsList(new TH1F(name[2],title[2],50,  0.20,5.00),kTrk2);
  Add2ESDsList(new TH1F(name[3],title[3],50,  0.20,5.00),kTrk3);
  Add2ESDsList(new TH1F(name[4],title[4],50,  0.20,5.00),kTrk4);
  Add2ESDsList(new TH1F(name[5],title[5],50,  0.20,5.00),kTrk5);
  Add2ESDsList(new TH1F(name[6],title[6],50,  0.20,5.00),kTrk6);
  }

  {// V0 related QA
    const Char_t *name[]={
      "hGlobalPromptK0sMass",
      "hGlobalOfflineK0sMass",
      "hGlobalPromptLambda0Lambda0BarMass",
      "hGlobalOfflineLambda0Lambda0BarMass"
    };
    const Char_t *title[]={
      "On-the-fly K0s mass (GeV)",
      "Offline K0s mass (GeV)",
      "On-the-fly Lambda0 + Lambda0Bar mass (GeV)",
      "Offline Lambda0 + Lambda0Bar mass (GeV)"
    };
    Add2ESDsList(new TH1F(name[0],title[0],50,  0.4477,0.5477),kK0on);
    Add2ESDsList(new TH1F(name[1],title[1],50,  0.4477,0.5477),kK0off);
    Add2ESDsList(new TH1F(name[2],title[2],50,  1.0657,1.1657),kL0on);
    Add2ESDsList(new TH1F(name[3],title[3],50,  1.0657,1.1657),kL0off);
  }

  {// PID related QA
  const Char_t *name[]={
    "hGlobalITSdEdx",
    "hGlobalTPCdEdx",
    "hGlobalTOFTrackingvsMeasured"
  };
    const Char_t *title[]={
      "ITS: dEdx (ADC) for particles with momentum 0.4 - 0.5 (GeV)",
      "TPC: dEdx (ADC) for particles with momentum 0.4 - 0.5 (GeV)",
      "TOF: tracking - measured (ps)"
    };
    Add2ESDsList(new TH1F(name[0],title[0],50,0.00,200.),kPid0);
    Add2ESDsList(new TH1F(name[1],title[1],50,0.00,100.),kPid1);
    Add2ESDsList(new TH1F(name[2],title[2],50,-3500.,3500.),kPid2);
  }

}

//____________________________________________________________________________
void AliGlobalQADataMaker::MakeRaws(AliRawReader* rawReader)
{
  //Fill prepared histograms with Raw digit properties
  rawReader->Reset() ;

}

//____________________________________________________________________________ 
void AliGlobalQADataMaker::MakeESDs(AliESDEvent * event) {
  //-----------------------------------------------------------
  // This function fills the ESD QA histograms
  // as a part of global QA
  //-----------------------------------------------------------
  // Check id histograms already created for this Event Specie
  if ( ! GetESDsData(kClr0) )
    InitESDs() ;


  const AliESDEvent *esd=event;

  Int_t ntrk=esd->GetNumberOfTracks() ; 
  for (Int_t i=0; i<ntrk; i++) {
    const AliESDtrack *track=esd->GetTrack(i);

    // Cluster related QA
    if (track->IsOn(AliESDtrack::kITSrefit)) {
      Int_t n=track->GetITSclusters(0);
      GetESDsData(kClr0)->Fill(Float_t(n)/6.); //6 is the number of ITS layers
    }

    if (track->IsOn(AliESDtrack::kTPCrefit)) {
      Int_t n =track->GetTPCNcls();
      Int_t nf=track->GetTPCNclsF();      // number of crossed TPC pad rows
      if (nf>0) {
        Double_t val = n*1.0/nf; 
        GetESDsData(kClr1)->Fill(val); 
      }
    }

    if (track->IsOn(AliESDtrack::kTRDrefit)) {
      Int_t n=track->GetTRDclusters(0);
      GetESDsData(kClr2)->Fill(Float_t(n)/(6*24));//(6*24) is the number of TRD time bins
    }

    Double_t p=track->GetP();

    // Track related QA
    if (track->IsOn(AliESDtrack::kTPCrefit)) {
      Float_t dz[2]; 
      track->GetDZ(0.,0.,0.,esd->GetMagneticField(),dz); 
      if ((TMath::Abs(dz[0])<3.) && (TMath::Abs(dz[1])<3.)) { // beam pipe
        Double_t phi=track->Phi();
	GetESDsData(kTrk0)->Fill(phi);
	Double_t y=track->Eta();
	GetESDsData(kTrk1)->Fill(y);

        if (TMath::Abs(y)<0.9) {
	   GetESDsData(kTrk2)->Fill(p);
	   if (track->IsOn(AliESDtrack::kITSrefit)) GetESDsData(kTrk3)->Fill(p);
	  //if (track->IsOn(AliESDtrack::kTOFout)) GetESDsData(kTrk4)->Fill(p);
	   if (track->GetTOFsignal()>0) GetESDsData(kTrk4)->Fill(p);
	}
      }
    }

    // PID related QA
    if ((p>0.4) && (p<0.5)) {
      if (track->IsOn(AliESDtrack::kITSpid)) {
	Double_t dedx=track->GetITSsignal();
        GetESDsData(kPid0)->Fill(dedx);
      }
      if (track->IsOn(AliESDtrack::kTPCpid)) {
	Double_t dedx=track->GetTPCsignal();
        GetESDsData(kPid1)->Fill(dedx);
      }
    }
    if (p>1.0) {
      if (track->IsOn(AliESDtrack::kTOFpid)) {
        Double_t times[10];
        track->GetIntegratedTimes(times);
        Double_t tof=track->GetTOFsignal();
        GetESDsData(kPid2)->Fill(times[2]-tof);
      }
    }
  }

  TH1 *tpc=GetESDsData(kTrk2); tpc->Sumw2();
  TH1 *its=GetESDsData(kTrk3); its->Sumw2();
  TH1 *tof=GetESDsData(kTrk4); tof->Sumw2();
  GetESDsData(kTrk5)->Divide(its,tpc,1,1.,"b");
  GetESDsData(kTrk6)->Divide(tof,tpc,1,1.,"b");

  // V0 related QA
  Int_t nV0=esd->GetNumberOfV0s();
  for (Int_t i=0; i<nV0; i++) {
    Double_t mass;
    AliESDv0 v0(*esd->GetV0(i));

    v0.ChangeMassHypothesis(kK0Short);
    mass=v0.GetEffMass();
    if (v0.GetOnFlyStatus())
       GetESDsData(kK0on)->Fill(mass);
    else
       GetESDsData(kK0off)->Fill(mass);

    v0.ChangeMassHypothesis(kLambda0);
    mass=v0.GetEffMass();
    if (v0.GetOnFlyStatus())
       GetESDsData(kL0on)->Fill(mass);
    else
       GetESDsData(kL0off)->Fill(mass);

    v0.ChangeMassHypothesis(kLambda0Bar);
    mass=v0.GetEffMass();
    if (v0.GetOnFlyStatus())
       GetESDsData(kL0on)->Fill(mass);
    else
       GetESDsData(kL0off)->Fill(mass);
  }

}
Commit	Line	Data
c0af1be2	1	/*
	2	The class for calculating the global (not detector specific) quality assurance.
	3	It reuses the following TLists from its base class
	4	AliQADataMaker::fRecPointsQAList (for keeping the track residuals)
	5	AliQADataMaker::fESDsQAList (for keeping global ESD QA data)
	6	*/
	7
542c6c71	8	#include <TPDGCode.h>
c0af1be2	9	#include <TH1F.h>
c0af1be2	10
fb774831	11	#include "AliQAChecker.h"
c0af1be2	12	#include "AliGlobalQADataMaker.h"
c0af1be2	13	#include "AliGeomManager.h"
d7259b2e	14	#include "AliESDEvent.h"
542c6c71	15	#include "AliESDv0.h"
fb774831	16	#include "AliRawReader.h"
c0af1be2	17
	18	ClassImp(AliGlobalQADataMaker)
	19
fb774831	20	//____________________________________________________________________________
4e25ac79	21	void AliGlobalQADataMaker::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
fb774831	22	{
	23	//Detector specific actions at end of cycle
	24	// do the QA checking
4e25ac79	25	AliQAChecker::Instance()->Run(AliQAv1::kGLOBAL, task, list) ;
fb774831	26	}
	27
	28	//____________________________________________________________________________
	29	void AliGlobalQADataMaker::InitRaws()
	30	{
	31	// create Raws histograms in Raws subdir
	32	}
	33
	34	//____________________________________________________________________________
c0af1be2	35	void AliGlobalQADataMaker::InitRecPoints() {
c0af1be2	36	//------------------------------------------------------
d7259b2e	37	// This function books the histograms of trackresiduals*
c0af1be2	38	// as a part of global QA
c0af1be2	39	//------------------------------------------------------
a6e0ebfe	40	const Char_t *name[]={
dd1b15c4	41	"hGlobalSPD1ResidualsY","SPD1ResidualsZ",
	42	"hGlobalSPD2ResidualsY","SPD2ResidualsZ",
	43	"hGlobalSDD1ResidualsY","SDD1ResidualsZ",
	44	"hGlobalSDD2ResidualsY","SDD2ResidualsZ",
	45	"hGlobalSSD1ResidualsY","SSD1ResidualsZ",
	46	"hGlobalSSD2ResidualsY","SSD2ResidualsZ",
	47
	48	"hGlobalTPC1ResidualsY","TPC1ResidualsZ",
	49	"hGlobalTPC2ResidualsY","TPC2ResidualsZ",
	50
	51	"hGlobalTRD1ResidualsY","TRD1ResidualsZ",
	52	"hGlobalTRD2ResidualsY","TRD2ResidualsZ",
	53	"hGlobalTRD3ResidualsY","TRD3ResidualsZ",
	54	"hGlobalTRD4ResidualsY","TRD4ResidualsZ",
	55	"hGlobalTRD5ResidualsY","TRD5ResidualsZ",
	56	"hGlobalTRD6ResidualsY","TRD6ResidualsZ",
	57
	58	"hGlobalTOFResidualsY","TOFResidualsZ",
	59
	60	"hGlobalPHOS1ResidualsY","PHOS1ResidualsZ",
	61	"hGlobalPHOS2ResidualsY","PHOS2ResidualsZ",
	62
	63	"hGlobalHMPIDResidualsY","HMPIDResidualsZ",
	64
	65	"hGlobalMUONResidualsY","MUONResidualsZ",
	66
	67	"hGlobalEMCALResidualsY","EMCALResidualsZ"
	68	};
	69	const Char_t *title[]={
c0af1be2	70	"SPD1 residuals Y","SPD1 residuals Z",
	71	"SPD2 residuals Y","SPD2 residuals Z",
	72	"SDD1 residuals Y","SDD1 residuals Z",
	73	"SDD2 residuals Y","SDD2 residuals Z",
	74	"SSD1 residuals Y","SSD1 residuals Z",
	75	"SSD2 residuals Y","SSD2 residuals Z",
dd1b15c4	76
c0af1be2	77	"TPC1 residuals Y","TPC1 residuals Z",
c0af1be2	78	"TPC2 residuals Y","TPC2 residuals Z",
dd1b15c4	79
c0af1be2	80	"TRD1 residuals Y","TRD1 residuals Z",
	81	"TRD2 residuals Y","TRD2 residuals Z",
	82	"TRD3 residuals Y","TRD3 residuals Z",
	83	"TRD4 residuals Y","TRD4 residuals Z",
	84	"TRD5 residuals Y","TRD5 residuals Z",
	85	"TRD6 residuals Y","TRD6 residuals Z",
dd1b15c4	86
c0af1be2	87	"TOF residuals Y","TOF residuals Z",
dd1b15c4	88
c0af1be2	89	"PHOS1 residuals Y","PHOS1 residuals Z",
c0af1be2	90	"PHOS2 residuals Y","PHOS2 residuals Z",
dd1b15c4	91
c0af1be2	92	"HMPID residuals Y","HMPID residuals Z",
dd1b15c4	93
c0af1be2	94	"MUON residuals Y","MUON residuals Z",
dd1b15c4	95
c0af1be2	96	"EMCAL residuals Y","EMCAL residuals Z"
c0af1be2	97	};
dd1b15c4	98
c0af1be2	99	for (Int_t m=1; m<AliGeomManager::kLastLayer; m++) {
c0af1be2	100	Int_t i=2*m-2;
dd1b15c4	101	TH1F *h=new TH1F(name[i],title[i],100,-5.,5.);
c0af1be2	102	Add2RecPointsList(h,i);
dd1b15c4	103	h=new TH1F(name[i+1],title[i+1],100,-5.,5.);
c0af1be2	104	Add2RecPointsList(h,i+1);
c0af1be2	105	}
a935c6c0	106
49ab451d	107	Add2RecPointsList(
dd1b15c4	108	new TH1F("hGlobalSSD1AbsoluteResidualsYNegZ",
dd1b15c4	109	"SSD1 Absolute Residuals Y Neg Z",100,-2.,2.),40);
a935c6c0	110	Add2RecPointsList(
dd1b15c4	111	new TH1F("hGlobalSSD1AbsoluteResidualsZNegZ",
dd1b15c4	112	"SSD1 Absolute Residuals Z Neg Z",100,-2.,2.),41);
49ab451d	113	Add2RecPointsList(
dd1b15c4	114	new TH1F("hGlobalSSD1AbsoluteResidualsYPosZ",
dd1b15c4	115	"SSD1 Absolute Residuals Y Pos Z",100,-2.,2.),42);
a935c6c0	116	Add2RecPointsList(
dd1b15c4	117	new TH1F("hGlobalSSD1AbsoluteResidualsZPosZ",
dd1b15c4	118	"SSD1 Absolute Residuals Z Pos Z",100,-2.,2.),43);
49ab451d	119
	120
	121	Add2RecPointsList(
dd1b15c4	122	new TH1F("hGlobalSSD2AbsoluteResidualsYNegZ",
dd1b15c4	123	"SSD2 Absolute Residuals Y Neg Z",100,-3.,3.),44);
a935c6c0	124	Add2RecPointsList(
dd1b15c4	125	new TH1F("hGlobalSSD2AbsoluteResidualsZNegZ",
dd1b15c4	126	"SSD2 Absolute Residuals Z Neg Z",100,-3.,3.),45);
49ab451d	127	Add2RecPointsList(
dd1b15c4	128	new TH1F("hGlobalSSD2AbsoluteResidualsYPosZ",
dd1b15c4	129	"SSD2 Absolute Residuals Y Pos Z",100,-3.,3.),46);
a935c6c0	130	Add2RecPointsList(
dd1b15c4	131	new TH1F("hGlobalSSD2AbsoluteResidualsZPosZ",
dd1b15c4	132	"SSD2Absolute Residuals Z Pos Z",100,-3.,3.),47);
a935c6c0	133
c0af1be2	134	}
d7259b2e	135
fb774831	136	//____________________________________________________________________________
d7259b2e	137	void AliGlobalQADataMaker::InitESDs() {
	138	//------------------------------------------------------
	139	// This function books the ESD QA histograms
	140	// as a part of global QA
	141	//------------------------------------------------------
542c6c71	142
542c6c71	143	{// Cluster related QA
dd1b15c4	144	const Char_t *name[]={
	145	"hGlobalFractionAssignedClustersITS",
	146	"hGlobalFractionAssignedClustersTPC",
	147	"hGlobalFractionAssignedClustersTRD"
	148	};
	149	const Char_t *title[]={
	150	"Fraction of the assigned clusters in ITS",
	151	"Fraction of the assigned clusters in TPC",
	152	"Fraction of the assigned clusters in TRD"
	153	};
	154	Add2ESDsList(new TH1F(name[0],title[0],100,0.,2.),kClr0);
	155	Add2ESDsList(new TH1F(name[1],title[1],100,0.,2.),kClr1);
	156	Add2ESDsList(new TH1F(name[2],title[2],100,0.,2.),kClr2);
542c6c71	157	}
	158
	159	{// Track related QA
dd1b15c4	160	const Char_t *name[]={
	161	"hGlobalTrackAzimuthe", // kTrk0
	162	"hGlobalTrackEta", // kTrk1
	163	"hGlobalTPCTrackpT", // kTrk2
	164	"hGlobalTPCITSMatchedpT", // kTrk3
	165	"hGlobalTPCTOFMatchedpT", // kTrk4
	166	"hGlobalTPCITSMatchingProbability", // kTrk5
	167	"hGlobalTPCTOFMatchingProbability" // kTrk6
542c6c71	168	};
dd1b15c4	169	const Char_t *title[]={
	170	"Track azimuthal distribution (rad)", // kTrk0
	171	"Track pseudo-rapidity distribution", // kTrk1
	172	"TPC: track momentum distribution (GeV)", // kTrk2
	173	"TPC-ITS matched: track momentum distribution (GeV)", // kTrk3
	174	"TPC-TOF matched: track momentum distribution (GeV)", // kTrk4
	175	"TPC-ITS track-matching probability", // kTrk5
	176	"TPC-TOF track-matching probability" // kTrk6
	177	};
	178	Add2ESDsList(new TH1F(name[0],title[0],100, 0.,TMath::TwoPi()),kTrk0);
	179	Add2ESDsList(new TH1F(name[1],title[1],100,-2.00,2.00),kTrk1);
	180	Add2ESDsList(new TH1F(name[2],title[2],50, 0.20,5.00),kTrk2);
	181	Add2ESDsList(new TH1F(name[3],title[3],50, 0.20,5.00),kTrk3);
	182	Add2ESDsList(new TH1F(name[4],title[4],50, 0.20,5.00),kTrk4);
	183	Add2ESDsList(new TH1F(name[5],title[5],50, 0.20,5.00),kTrk5);
	184	Add2ESDsList(new TH1F(name[6],title[6],50, 0.20,5.00),kTrk6);
542c6c71	185	}
	186
	187	{// V0 related QA
dd1b15c4	188	const Char_t *name[]={
	189	"hGlobalPromptK0sMass",
	190	"hGlobalOfflineK0sMass",
	191	"hGlobalPromptLambda0Lambda0BarMass",
	192	"hGlobalOfflineLambda0Lambda0BarMass"
	193	};
	194	const Char_t *title[]={
	195	"On-the-fly K0s mass (GeV)",
	196	"Offline K0s mass (GeV)",
	197	"On-the-fly Lambda0 + Lambda0Bar mass (GeV)",
	198	"Offline Lambda0 + Lambda0Bar mass (GeV)"
	199	};
	200	Add2ESDsList(new TH1F(name[0],title[0],50, 0.4477,0.5477),kK0on);
	201	Add2ESDsList(new TH1F(name[1],title[1],50, 0.4477,0.5477),kK0off);
	202	Add2ESDsList(new TH1F(name[2],title[2],50, 1.0657,1.1657),kL0on);
	203	Add2ESDsList(new TH1F(name[3],title[3],50, 1.0657,1.1657),kL0off);
542c6c71	204	}
	205
	206	{// PID related QA
a6e0ebfe	207	const Char_t *name[]={
c9622234	208	"hGlobalITSdEdx",
	209	"hGlobalTPCdEdx",
	210	"hGlobalTOFTrackingvsMeasured"
542c6c71	211	};
dd1b15c4	212	const Char_t *title[]={
	213	"ITS: dEdx (ADC) for particles with momentum 0.4 - 0.5 (GeV)",
	214	"TPC: dEdx (ADC) for particles with momentum 0.4 - 0.5 (GeV)",
	215	"TOF: tracking - measured (ps)"
	216	};
	217	Add2ESDsList(new TH1F(name[0],title[0],50,0.00,200.),kPid0);
	218	Add2ESDsList(new TH1F(name[1],title[1],50,0.00,100.),kPid1);
	219	Add2ESDsList(new TH1F(name[2],title[2],50,-3500.,3500.),kPid2);
542c6c71	220	}
542c6c71	221
d7259b2e	222	}
d7259b2e	223
fb774831	224	//____________________________________________________________________________
	225	void AliGlobalQADataMaker::MakeRaws(AliRawReader* rawReader)
	226	{
	227	//Fill prepared histograms with Raw digit properties
	228	rawReader->Reset() ;
	229
	230	}
	231
	232	//____________________________________________________________________________
542c6c71	233	void AliGlobalQADataMaker::MakeESDs(AliESDEvent * event) {
d7259b2e	234	//-----------------------------------------------------------
	235	// This function fills the ESD QA histograms
	236	// as a part of global QA
	237	//-----------------------------------------------------------
eca4fa66	238	// Check id histograms already created for this Event Specie
	239	if ( ! GetESDsData(kClr0) )
	240	InitESDs() ;
	241
c9622234	242
542c6c71	243	const AliESDEvent *esd=event;
542c6c71	244
d7259b2e	245	Int_t ntrk=esd->GetNumberOfTracks() ;
d7259b2e	246	for (Int_t i=0; i<ntrk; i++) {
542c6c71	247	const AliESDtrack *track=esd->GetTrack(i);
d7259b2e	248
542c6c71	249	// Cluster related QA
d7259b2e	250	if (track->IsOn(AliESDtrack::kITSrefit)) {
d7259b2e	251	Int_t n=track->GetITSclusters(0);
542c6c71	252	GetESDsData(kClr0)->Fill(Float_t(n)/6.); //6 is the number of ITS layers
d7259b2e	253	}
	254
	255	if (track->IsOn(AliESDtrack::kTPCrefit)) {
	256	Int_t n =track->GetTPCNcls();
	257	Int_t nf=track->GetTPCNclsF(); // number of crossed TPC pad rows
1aaf4118	258	if (nf>0) {
	259	Double_t val = n*1.0/nf;
	260	GetESDsData(kClr1)->Fill(val);
	261	}
d7259b2e	262	}
	263
	264	if (track->IsOn(AliESDtrack::kTRDrefit)) {
	265	Int_t n=track->GetTRDclusters(0);
e3bd5382	266	GetESDsData(kClr2)->Fill(Float_t(n)/(624));//(624) is the number of TRD time bins
542c6c71	267	}
	268
	269	Double_t p=track->GetP();
	270
	271	// Track related QA
	272	if (track->IsOn(AliESDtrack::kTPCrefit)) {
	273	Float_t dz[2];
	274	track->GetDZ(0.,0.,0.,esd->GetMagneticField(),dz);
	275	if ((TMath::Abs(dz[0])<3.) && (TMath::Abs(dz[1])<3.)) { // beam pipe
	276	Double_t phi=track->Phi();
	277	GetESDsData(kTrk0)->Fill(phi);
44f14df0	278	Double_t y=track->Eta();
542c6c71	279	GetESDsData(kTrk1)->Fill(y);
542c6c71	280
cecff4fc	281	if (TMath::Abs(y)<0.9) {
	282	GetESDsData(kTrk2)->Fill(p);
	283	if (track->IsOn(AliESDtrack::kITSrefit)) GetESDsData(kTrk3)->Fill(p);
4d9ba05c	284	//if (track->IsOn(AliESDtrack::kTOFout)) GetESDsData(kTrk4)->Fill(p);
4d9ba05c	285	if (track->GetTOFsignal()>0) GetESDsData(kTrk4)->Fill(p);
cecff4fc	286	}
542c6c71	287	}
	288	}
	289
	290	// PID related QA
	291	if ((p>0.4) && (p<0.5)) {
	292	if (track->IsOn(AliESDtrack::kITSpid)) {
	293	Double_t dedx=track->GetITSsignal();
	294	GetESDsData(kPid0)->Fill(dedx);
	295	}
	296	if (track->IsOn(AliESDtrack::kTPCpid)) {
	297	Double_t dedx=track->GetTPCsignal();
	298	GetESDsData(kPid1)->Fill(dedx);
	299	}
d7259b2e	300	}
542c6c71	301	if (p>1.0) {
	302	if (track->IsOn(AliESDtrack::kTOFpid)) {
	303	Double_t times[10];
	304	track->GetIntegratedTimes(times);
	305	Double_t tof=track->GetTOFsignal();
	306	GetESDsData(kPid2)->Fill(times[2]-tof);
	307	}
	308	}
	309	}
d7259b2e	310
cecff4fc	311	TH1 *tpc=GetESDsData(kTrk2); tpc->Sumw2();
	312	TH1 *its=GetESDsData(kTrk3); its->Sumw2();
	313	TH1 *tof=GetESDsData(kTrk4); tof->Sumw2();
542c6c71	314	GetESDsData(kTrk5)->Divide(its,tpc,1,1.,"b");
	315	GetESDsData(kTrk6)->Divide(tof,tpc,1,1.,"b");
	316
	317	// V0 related QA
	318	Int_t nV0=esd->GetNumberOfV0s();
	319	for (Int_t i=0; i<nV0; i++) {
	320	Double_t mass;
	321	AliESDv0 v0(*esd->GetV0(i));
	322
	323	v0.ChangeMassHypothesis(kK0Short);
	324	mass=v0.GetEffMass();
b72280b3	325	if (v0.GetOnFlyStatus())
	326	GetESDsData(kK0on)->Fill(mass);
	327	else
	328	GetESDsData(kK0off)->Fill(mass);
542c6c71	329
	330	v0.ChangeMassHypothesis(kLambda0);
	331	mass=v0.GetEffMass();
b72280b3	332	if (v0.GetOnFlyStatus())
	333	GetESDsData(kL0on)->Fill(mass);
	334	else
	335	GetESDsData(kL0off)->Fill(mass);
542c6c71	336
	337	v0.ChangeMassHypothesis(kLambda0Bar);
	338	mass=v0.GetEffMass();
b72280b3	339	if (v0.GetOnFlyStatus())
	340	GetESDsData(kL0on)->Fill(mass);
	341	else
	342	GetESDsData(kL0off)->Fill(mass);
d7259b2e	343	}
542c6c71	344
f92b626a	345	}