[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 <TH2F.h>

#include "AliQAChecker.h"
#include "AliGlobalQADataMaker.h"
#include "AliGeomManager.h"
#include "AliESDEvent.h"
#include "AliESDv0.h"
#include "AliRawReader.h"
#include "AliESDVZERO.h"
#include "AliMultiplicity.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
  //------------------------------------------------------
  static Bool_t first = kTRUE ; 
  if ( ! first ) 
    return ; 
  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);
  
  first = kFALSE ; 
}

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

  const Bool_t expert   = kTRUE ; 
  const Bool_t image    = kTRUE ; 
 {// Cluster related QA
    const Char_t *name[]={
      "hGlobalFractionAssignedClustersITS",
      "hGlobalFractionAssignedClustersTPC",
      "hGlobalFractionAssignedClustersTRD",
      "hGlobalClustersPerITSModule"
    };
    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",
      "Number of clusters per an ITS module"
    };
    Add2ESDsList(new TH1F(name[0],title[0],100,0.,2.),kClr0, !expert, image);
    Add2ESDsList(new TH1F(name[1],title[1],100,0.,2.),kClr1, !expert, image);
    Add2ESDsList(new TH1F(name[2],title[2],100,0.,2.),kClr2, !expert, image);
    Add2ESDsList(new TH1F(name[3],title[3],2201,-0.5,2200.5),kClr3, !expert, image);
  }

  {// Track related QA
    const Char_t *name[]={
      "hGlobalTrackAzimuthe",                               // kTrk0
      "hGlobalTrackEta",                                    // kTrk1
      "hGlobalTPCTrackpT",                                  // kTrk2
      "hGlobalTPCITSMatchedpT",                             // kTrk3
      "hGlobalTPCTOFMatchedpT",                             // kTrk4
      "hGlobalTPCITSMatchingProbability",                   // kTrk5
      "hGlobalTPCTOFMatchingProbability",                   // kTrk6
      "hGlobalTPCsideAposDCA",                              // kTrk7
      "hGlobalTPCsideAnegDCA",                              // kTrk8
      "hGlobalTPCsideCposDCA",                              // kTrk9
      "hGlobalTPCsideCnegDCA"                               // kTrk10
  };
    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
      "TPC side A: DCA for the positive tracks (mm)",         // kTrk7
      "TPC side A: DCA for the negative tracks (mm)",         // kTrk8
      "TPC side C: DCA for the positive tracks (mm)",         // kTrk9
      "TPC side C: DCA for the negative tracks (mm)"          // kTrk10
    };
  Add2ESDsList(new TH1F(name[0],title[0],100, 0.,TMath::TwoPi()),kTrk0, !expert, image);
  Add2ESDsList(new TH1F(name[1],title[1],100,-2.00,2.00),kTrk1, !expert, image);
  Add2ESDsList(new TH1F(name[2],title[2],50,  0.20,5.00),kTrk2, !expert, image);
  Add2ESDsList(new TH1F(name[3],title[3],50,  0.20,5.00),kTrk3, !expert, image);
  Add2ESDsList(new TH1F(name[4],title[4],50,  0.20,5.00),kTrk4, !expert, image);
  Add2ESDsList(new TH1F(name[5],title[5],50,  0.20,5.00),kTrk5, !expert, image);
  Add2ESDsList(new TH1F(name[6],title[6],50,  0.20,5.00),kTrk6, !expert, image);
  Add2ESDsList(new TH1F(name[7],title[7],50, -25.0,25.0),kTrk7, !expert, image);
  Add2ESDsList(new TH1F(name[8],title[8],50, -25.0,25.0),kTrk8, !expert, image);
  Add2ESDsList(new TH1F(name[9],title[9],50, -25.0,25.0),kTrk9, !expert, image);
  Add2ESDsList(new TH1F(name[10],title[10],50, -25.0,25.0),kTrk10, !expert, image);
  }

  {// 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, !expert, image);
    Add2ESDsList(new TH1F(name[1],title[1],50,  0.4477,0.5477),kK0off, !expert, image);
    Add2ESDsList(new TH1F(name[2],title[2],50,  1.0657,1.1657),kL0on, !expert, image);
    Add2ESDsList(new TH1F(name[3],title[3],50,  1.0657,1.1657),kL0off, !expert, image);
  }

  {// PID related QA
  const Char_t *name[]={
    "hGlobalITSdEdx",
    "hGlobalTPCdEdx",
    "hGlobalTOFTrackingvsMeasured",
    "hGlobalTPCdEdxvsMomentum"
   };
    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)",
      "TPC: dEdx (A.U.) vs momentum (GeV)"
     };
    Add2ESDsList(new TH1F(name[0],title[0],50,0.00,200.),kPid0, !expert, image);
    Add2ESDsList(new TH1F(name[1],title[1],50,0.00,100.),kPid1, !expert, image);
    Add2ESDsList(new TH1F(name[2],title[2],50,-3500.,3500.),kPid2, !expert, image);
    Add2ESDsList(new TH2F(name[3],title[3],1500,0.05,15.,700,0.,700.),kPid3,!expert,image);
   }
  {// Multiplicity related QA
    const Char_t *name[]={
      "hGlobalV0AvsITS",
      "hGlobalV0CvsITS"
    };
    const Char_t *title[]={
      "Multiplicity: V0A vs ITS",
      "Multiplicity: V0C vs ITS"
    };
    TH2F *h0=new TH2F(name[0],title[0],41,-0.5,40.5, 33,-0.5,32.5);
    Add2ESDsList(h0,kMlt0, !expert, image);
    TH2F *h1=new TH2F(name[1],title[1],41,-0.5,40.5, 33,-0.5,32.5);
    Add2ESDsList(h1,kMlt1, !expert, image);
  }

}

//____________________________________________________________________________
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
  //-----------------------------------------------------------

  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
    }

    for (Int_t j=0; j<6; ++j) {
      Int_t idet, sts;
      Float_t xloc,zloc;
      if (!track->GetITSModuleIndexInfo(j,idet,sts,xloc,zloc)) continue;
      if (j>=2) idet+=240;
      if (j>=4) idet+=260;
      if ((sts==1)||(sts==2)||(sts==4)) GetESDsData(kClr3)->Fill(idet);  
    }

    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);
	}
      }
    }
    const AliExternalTrackParam *tpcTrack=track->GetTPCInnerParam();
    const AliExternalTrackParam *innTrack=track->GetInnerParam();
    if (tpcTrack)
    if (innTrack) {
       const AliESDVertex *vtx=esd->GetPrimaryVertex();
       Double_t xv=vtx->GetXv();
       Double_t yv=vtx->GetYv();
       Double_t zv=vtx->GetZv();
       Float_t dz[2];
       tpcTrack->GetDZ(xv,yv,zv,esd->GetMagneticField(),dz);
       dz[0]*=10.; // in mm
       if (innTrack->GetZ()  > 0)
       if (innTrack->GetTgl()> 0) { // TPC side A
	  if (tpcTrack->GetSign() > 0) GetESDsData(kTrk7)->Fill(dz[0]);
          else                         GetESDsData(kTrk8)->Fill(dz[0]);
       }
       if (innTrack->GetZ()  < 0)
       if (innTrack->GetTgl()< 0) { // TPC side C
	  if (tpcTrack->GetSign() > 0) GetESDsData(kTrk9)->Fill(dz[0]);
          else                         GetESDsData(kTrk10)->Fill(dz[0]);
       }
    }

    // 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);
      }
    }
    const AliExternalTrackParam *par=track->GetInnerParam();
    if (par) {
      Double_t pp=par->GetP();
      Double_t dedx=track->GetTPCsignal();
      TH2F *h = dynamic_cast<TH2F*>(GetESDsData(kPid3));
      h->Fill(pp,dedx);
    }
 
  }

  // Multiplicity related QA
  AliESDVZERO     *mltV0 =esd->GetVZEROData();
  const AliMultiplicity *mltITS=esd->GetMultiplicity();
  if (mltV0)
    if (mltITS) {
       Short_t nv0a=mltV0->GetNbPMV0A();
       Short_t nv0c=mltV0->GetNbPMV0C();
       Int_t   nits=mltITS->GetNumberOfTracklets();
       TH2F *h0=dynamic_cast<TH2F*>(GetESDsData(kMlt0));
       h0->Fill(nits,nv0a);
       TH2F *h1=dynamic_cast<TH2F*>(GetESDsData(kMlt1));
       h1->Fill(nits,nv0c);
    }


  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>
2937b8ff	10	#include <TH2F.h>
c0af1be2	11
fb774831	12	#include "AliQAChecker.h"
c0af1be2	13	#include "AliGlobalQADataMaker.h"
c0af1be2	14	#include "AliGeomManager.h"
d7259b2e	15	#include "AliESDEvent.h"
542c6c71	16	#include "AliESDv0.h"
fb774831	17	#include "AliRawReader.h"
2937b8ff	18	#include "AliESDVZERO.h"
2937b8ff	19	#include "AliMultiplicity.h"
c0af1be2	20
	21	ClassImp(AliGlobalQADataMaker)
	22
fb774831	23	//____________________________________________________________________________
4e25ac79	24	void AliGlobalQADataMaker::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
fb774831	25	{
	26	//Detector specific actions at end of cycle
	27	// do the QA checking
4e25ac79	28	AliQAChecker::Instance()->Run(AliQAv1::kGLOBAL, task, list) ;
fb774831	29	}
	30
	31	//____________________________________________________________________________
	32	void AliGlobalQADataMaker::InitRaws()
	33	{
	34	// create Raws histograms in Raws subdir
	35	}
	36
	37	//____________________________________________________________________________
c0af1be2	38	void AliGlobalQADataMaker::InitRecPoints() {
c0af1be2	39	//------------------------------------------------------
d7259b2e	40	// This function books the histograms of trackresiduals*
c0af1be2	41	// as a part of global QA
c0af1be2	42	//------------------------------------------------------
ebb9ea7c	43	static Bool_t first = kTRUE ;
	44	if ( ! first )
	45	return ;
a6e0ebfe	46	const Char_t *name[]={
dd1b15c4	47	"hGlobalSPD1ResidualsY","SPD1ResidualsZ",
	48	"hGlobalSPD2ResidualsY","SPD2ResidualsZ",
	49	"hGlobalSDD1ResidualsY","SDD1ResidualsZ",
	50	"hGlobalSDD2ResidualsY","SDD2ResidualsZ",
	51	"hGlobalSSD1ResidualsY","SSD1ResidualsZ",
	52	"hGlobalSSD2ResidualsY","SSD2ResidualsZ",
	53
	54	"hGlobalTPC1ResidualsY","TPC1ResidualsZ",
	55	"hGlobalTPC2ResidualsY","TPC2ResidualsZ",
	56
	57	"hGlobalTRD1ResidualsY","TRD1ResidualsZ",
	58	"hGlobalTRD2ResidualsY","TRD2ResidualsZ",
	59	"hGlobalTRD3ResidualsY","TRD3ResidualsZ",
	60	"hGlobalTRD4ResidualsY","TRD4ResidualsZ",
	61	"hGlobalTRD5ResidualsY","TRD5ResidualsZ",
	62	"hGlobalTRD6ResidualsY","TRD6ResidualsZ",
	63
	64	"hGlobalTOFResidualsY","TOFResidualsZ",
	65
	66	"hGlobalPHOS1ResidualsY","PHOS1ResidualsZ",
	67	"hGlobalPHOS2ResidualsY","PHOS2ResidualsZ",
	68
	69	"hGlobalHMPIDResidualsY","HMPIDResidualsZ",
	70
	71	"hGlobalMUONResidualsY","MUONResidualsZ",
	72
	73	"hGlobalEMCALResidualsY","EMCALResidualsZ"
	74	};
	75	const Char_t *title[]={
c0af1be2	76	"SPD1 residuals Y","SPD1 residuals Z",
	77	"SPD2 residuals Y","SPD2 residuals Z",
	78	"SDD1 residuals Y","SDD1 residuals Z",
	79	"SDD2 residuals Y","SDD2 residuals Z",
	80	"SSD1 residuals Y","SSD1 residuals Z",
	81	"SSD2 residuals Y","SSD2 residuals Z",
dd1b15c4	82
c0af1be2	83	"TPC1 residuals Y","TPC1 residuals Z",
c0af1be2	84	"TPC2 residuals Y","TPC2 residuals Z",
dd1b15c4	85
c0af1be2	86	"TRD1 residuals Y","TRD1 residuals Z",
	87	"TRD2 residuals Y","TRD2 residuals Z",
	88	"TRD3 residuals Y","TRD3 residuals Z",
	89	"TRD4 residuals Y","TRD4 residuals Z",
	90	"TRD5 residuals Y","TRD5 residuals Z",
	91	"TRD6 residuals Y","TRD6 residuals Z",
dd1b15c4	92
c0af1be2	93	"TOF residuals Y","TOF residuals Z",
dd1b15c4	94
c0af1be2	95	"PHOS1 residuals Y","PHOS1 residuals Z",
c0af1be2	96	"PHOS2 residuals Y","PHOS2 residuals Z",
dd1b15c4	97
c0af1be2	98	"HMPID residuals Y","HMPID residuals Z",
dd1b15c4	99
c0af1be2	100	"MUON residuals Y","MUON residuals Z",
dd1b15c4	101
c0af1be2	102	"EMCAL residuals Y","EMCAL residuals Z"
c0af1be2	103	};
dd1b15c4	104
c0af1be2	105	for (Int_t m=1; m<AliGeomManager::kLastLayer; m++) {
c0af1be2	106	Int_t i=2*m-2;
dd1b15c4	107	TH1F *h=new TH1F(name[i],title[i],100,-5.,5.);
c0af1be2	108	Add2RecPointsList(h,i);
dd1b15c4	109	h=new TH1F(name[i+1],title[i+1],100,-5.,5.);
c0af1be2	110	Add2RecPointsList(h,i+1);
c0af1be2	111	}
a935c6c0	112
49ab451d	113	Add2RecPointsList(
dd1b15c4	114	new TH1F("hGlobalSSD1AbsoluteResidualsYNegZ",
dd1b15c4	115	"SSD1 Absolute Residuals Y Neg Z",100,-2.,2.),40);
a935c6c0	116	Add2RecPointsList(
dd1b15c4	117	new TH1F("hGlobalSSD1AbsoluteResidualsZNegZ",
dd1b15c4	118	"SSD1 Absolute Residuals Z Neg Z",100,-2.,2.),41);
49ab451d	119	Add2RecPointsList(
dd1b15c4	120	new TH1F("hGlobalSSD1AbsoluteResidualsYPosZ",
dd1b15c4	121	"SSD1 Absolute Residuals Y Pos Z",100,-2.,2.),42);
a935c6c0	122	Add2RecPointsList(
dd1b15c4	123	new TH1F("hGlobalSSD1AbsoluteResidualsZPosZ",
dd1b15c4	124	"SSD1 Absolute Residuals Z Pos Z",100,-2.,2.),43);
49ab451d	125
	126
	127	Add2RecPointsList(
dd1b15c4	128	new TH1F("hGlobalSSD2AbsoluteResidualsYNegZ",
dd1b15c4	129	"SSD2 Absolute Residuals Y Neg Z",100,-3.,3.),44);
a935c6c0	130	Add2RecPointsList(
dd1b15c4	131	new TH1F("hGlobalSSD2AbsoluteResidualsZNegZ",
dd1b15c4	132	"SSD2 Absolute Residuals Z Neg Z",100,-3.,3.),45);
49ab451d	133	Add2RecPointsList(
dd1b15c4	134	new TH1F("hGlobalSSD2AbsoluteResidualsYPosZ",
dd1b15c4	135	"SSD2 Absolute Residuals Y Pos Z",100,-3.,3.),46);
a935c6c0	136	Add2RecPointsList(
dd1b15c4	137	new TH1F("hGlobalSSD2AbsoluteResidualsZPosZ",
dd1b15c4	138	"SSD2Absolute Residuals Z Pos Z",100,-3.,3.),47);
a935c6c0	139
ebb9ea7c	140	first = kFALSE ;
c0af1be2	141	}
d7259b2e	142
fb774831	143	//____________________________________________________________________________
d7259b2e	144	void AliGlobalQADataMaker::InitESDs() {
	145	//------------------------------------------------------
	146	// This function books the ESD QA histograms
	147	// as a part of global QA
	148	//------------------------------------------------------
542c6c71	149
f728e025	150	const Bool_t expert = kTRUE ;
	151	const Bool_t image = kTRUE ;
	152	{// Cluster related QA
dd1b15c4	153	const Char_t *name[]={
	154	"hGlobalFractionAssignedClustersITS",
	155	"hGlobalFractionAssignedClustersTPC",
2937b8ff	156	"hGlobalFractionAssignedClustersTRD",
2937b8ff	157	"hGlobalClustersPerITSModule"
dd1b15c4	158	};
	159	const Char_t *title[]={
	160	"Fraction of the assigned clusters in ITS",
	161	"Fraction of the assigned clusters in TPC",
2937b8ff	162	"Fraction of the assigned clusters in TRD",
2937b8ff	163	"Number of clusters per an ITS module"
dd1b15c4	164	};
f728e025	165	Add2ESDsList(new TH1F(name[0],title[0],100,0.,2.),kClr0, !expert, image);
	166	Add2ESDsList(new TH1F(name[1],title[1],100,0.,2.),kClr1, !expert, image);
	167	Add2ESDsList(new TH1F(name[2],title[2],100,0.,2.),kClr2, !expert, image);
0428b94a	168	Add2ESDsList(new TH1F(name[3],title[3],2201,-0.5,2200.5),kClr3, !expert, image);
542c6c71	169	}
	170
	171	{// Track related QA
dd1b15c4	172	const Char_t *name[]={
	173	"hGlobalTrackAzimuthe", // kTrk0
	174	"hGlobalTrackEta", // kTrk1
	175	"hGlobalTPCTrackpT", // kTrk2
	176	"hGlobalTPCITSMatchedpT", // kTrk3
	177	"hGlobalTPCTOFMatchedpT", // kTrk4
	178	"hGlobalTPCITSMatchingProbability", // kTrk5
8336b059	179	"hGlobalTPCTOFMatchingProbability", // kTrk6
	180	"hGlobalTPCsideAposDCA", // kTrk7
	181	"hGlobalTPCsideAnegDCA", // kTrk8
	182	"hGlobalTPCsideCposDCA", // kTrk9
	183	"hGlobalTPCsideCnegDCA" // kTrk10
542c6c71	184	};
dd1b15c4	185	const Char_t *title[]={
	186	"Track azimuthal distribution (rad)", // kTrk0
	187	"Track pseudo-rapidity distribution", // kTrk1
	188	"TPC: track momentum distribution (GeV)", // kTrk2
	189	"TPC-ITS matched: track momentum distribution (GeV)", // kTrk3
	190	"TPC-TOF matched: track momentum distribution (GeV)", // kTrk4
	191	"TPC-ITS track-matching probability", // kTrk5
8336b059	192	"TPC-TOF track-matching probability", // kTrk6
	193	"TPC side A: DCA for the positive tracks (mm)", // kTrk7
	194	"TPC side A: DCA for the negative tracks (mm)", // kTrk8
	195	"TPC side C: DCA for the positive tracks (mm)", // kTrk9
	196	"TPC side C: DCA for the negative tracks (mm)" // kTrk10
dd1b15c4	197	};
f728e025	198	Add2ESDsList(new TH1F(name[0],title[0],100, 0.,TMath::TwoPi()),kTrk0, !expert, image);
	199	Add2ESDsList(new TH1F(name[1],title[1],100,-2.00,2.00),kTrk1, !expert, image);
	200	Add2ESDsList(new TH1F(name[2],title[2],50, 0.20,5.00),kTrk2, !expert, image);
	201	Add2ESDsList(new TH1F(name[3],title[3],50, 0.20,5.00),kTrk3, !expert, image);
	202	Add2ESDsList(new TH1F(name[4],title[4],50, 0.20,5.00),kTrk4, !expert, image);
	203	Add2ESDsList(new TH1F(name[5],title[5],50, 0.20,5.00),kTrk5, !expert, image);
	204	Add2ESDsList(new TH1F(name[6],title[6],50, 0.20,5.00),kTrk6, !expert, image);
	205	Add2ESDsList(new TH1F(name[7],title[7],50, -25.0,25.0),kTrk7, !expert, image);
	206	Add2ESDsList(new TH1F(name[8],title[8],50, -25.0,25.0),kTrk8, !expert, image);
	207	Add2ESDsList(new TH1F(name[9],title[9],50, -25.0,25.0),kTrk9, !expert, image);
	208	Add2ESDsList(new TH1F(name[10],title[10],50, -25.0,25.0),kTrk10, !expert, image);
542c6c71	209	}
	210
	211	{// V0 related QA
dd1b15c4	212	const Char_t *name[]={
	213	"hGlobalPromptK0sMass",
	214	"hGlobalOfflineK0sMass",
	215	"hGlobalPromptLambda0Lambda0BarMass",
	216	"hGlobalOfflineLambda0Lambda0BarMass"
	217	};
	218	const Char_t *title[]={
	219	"On-the-fly K0s mass (GeV)",
	220	"Offline K0s mass (GeV)",
	221	"On-the-fly Lambda0 + Lambda0Bar mass (GeV)",
	222	"Offline Lambda0 + Lambda0Bar mass (GeV)"
	223	};
f728e025	224	Add2ESDsList(new TH1F(name[0],title[0],50, 0.4477,0.5477),kK0on, !expert, image);
	225	Add2ESDsList(new TH1F(name[1],title[1],50, 0.4477,0.5477),kK0off, !expert, image);
	226	Add2ESDsList(new TH1F(name[2],title[2],50, 1.0657,1.1657),kL0on, !expert, image);
	227	Add2ESDsList(new TH1F(name[3],title[3],50, 1.0657,1.1657),kL0off, !expert, image);
542c6c71	228	}
	229
	230	{// PID related QA
a6e0ebfe	231	const Char_t *name[]={
c9622234	232	"hGlobalITSdEdx",
c9622234	233	"hGlobalTPCdEdx",
2937b8ff	234	"hGlobalTOFTrackingvsMeasured",
	235	"hGlobalTPCdEdxvsMomentum"
	236	};
dd1b15c4	237	const Char_t *title[]={
	238	"ITS: dEdx (ADC) for particles with momentum 0.4 - 0.5 (GeV)",
	239	"TPC: dEdx (ADC) for particles with momentum 0.4 - 0.5 (GeV)",
2937b8ff	240	"TOF: tracking - measured (ps)",
	241	"TPC: dEdx (A.U.) vs momentum (GeV)"
	242	};
f728e025	243	Add2ESDsList(new TH1F(name[0],title[0],50,0.00,200.),kPid0, !expert, image);
	244	Add2ESDsList(new TH1F(name[1],title[1],50,0.00,100.),kPid1, !expert, image);
	245	Add2ESDsList(new TH1F(name[2],title[2],50,-3500.,3500.),kPid2, !expert, image);
2937b8ff	246	Add2ESDsList(new TH2F(name[3],title[3],1500,0.05,15.,700,0.,700.),kPid3,!expert,image);
	247	}
	248	{// Multiplicity related QA
	249	const Char_t *name[]={
	250	"hGlobalV0AvsITS",
	251	"hGlobalV0CvsITS"
	252	};
	253	const Char_t *title[]={
	254	"Multiplicity: V0A vs ITS",
	255	"Multiplicity: V0C vs ITS"
	256	};
0428b94a	257	TH2F *h0=new TH2F(name[0],title[0],41,-0.5,40.5, 33,-0.5,32.5);
2937b8ff	258	Add2ESDsList(h0,kMlt0, !expert, image);
0428b94a	259	TH2F *h1=new TH2F(name[1],title[1],41,-0.5,40.5, 33,-0.5,32.5);
2937b8ff	260	Add2ESDsList(h1,kMlt1, !expert, image);
542c6c71	261	}
542c6c71	262
d7259b2e	263	}
d7259b2e	264
fb774831	265	//____________________________________________________________________________
	266	void AliGlobalQADataMaker::MakeRaws(AliRawReader* rawReader)
	267	{
	268	//Fill prepared histograms with Raw digit properties
	269	rawReader->Reset() ;
	270
	271	}
	272
	273	//____________________________________________________________________________
542c6c71	274	void AliGlobalQADataMaker::MakeESDs(AliESDEvent * event) {
d7259b2e	275	//-----------------------------------------------------------
	276	// This function fills the ESD QA histograms
	277	// as a part of global QA
	278	//-----------------------------------------------------------
c9622234	279
542c6c71	280	const AliESDEvent *esd=event;
542c6c71	281
d7259b2e	282	Int_t ntrk=esd->GetNumberOfTracks() ;
d7259b2e	283	for (Int_t i=0; i<ntrk; i++) {
542c6c71	284	const AliESDtrack *track=esd->GetTrack(i);
d7259b2e	285
542c6c71	286	// Cluster related QA
d7259b2e	287	if (track->IsOn(AliESDtrack::kITSrefit)) {
d7259b2e	288	Int_t n=track->GetITSclusters(0);
542c6c71	289	GetESDsData(kClr0)->Fill(Float_t(n)/6.); //6 is the number of ITS layers
d7259b2e	290	}
d7259b2e	291
ff355e43	292	for (Int_t j=0; j<6; ++j) {
2937b8ff	293	Int_t idet, sts;
2937b8ff	294	Float_t xloc,zloc;
ff355e43	295	if (!track->GetITSModuleIndexInfo(j,idet,sts,xloc,zloc)) continue;
	296	if (j>=2) idet+=240;
	297	if (j>=4) idet+=260;
2937b8ff	298	if ((sts==1)\|\|(sts==2)\|\|(sts==4)) GetESDsData(kClr3)->Fill(idet);
	299	}
	300
d7259b2e	301	if (track->IsOn(AliESDtrack::kTPCrefit)) {
	302	Int_t n =track->GetTPCNcls();
	303	Int_t nf=track->GetTPCNclsF(); // number of crossed TPC pad rows
1aaf4118	304	if (nf>0) {
	305	Double_t val = n*1.0/nf;
	306	GetESDsData(kClr1)->Fill(val);
	307	}
d7259b2e	308	}
	309
	310	if (track->IsOn(AliESDtrack::kTRDrefit)) {
	311	Int_t n=track->GetTRDclusters(0);
e3bd5382	312	GetESDsData(kClr2)->Fill(Float_t(n)/(624));//(624) is the number of TRD time bins
542c6c71	313	}
	314
	315	Double_t p=track->GetP();
	316
	317	// Track related QA
	318	if (track->IsOn(AliESDtrack::kTPCrefit)) {
	319	Float_t dz[2];
	320	track->GetDZ(0.,0.,0.,esd->GetMagneticField(),dz);
	321	if ((TMath::Abs(dz[0])<3.) && (TMath::Abs(dz[1])<3.)) { // beam pipe
	322	Double_t phi=track->Phi();
	323	GetESDsData(kTrk0)->Fill(phi);
44f14df0	324	Double_t y=track->Eta();
542c6c71	325	GetESDsData(kTrk1)->Fill(y);
542c6c71	326
cecff4fc	327	if (TMath::Abs(y)<0.9) {
	328	GetESDsData(kTrk2)->Fill(p);
	329	if (track->IsOn(AliESDtrack::kITSrefit)) GetESDsData(kTrk3)->Fill(p);
4d9ba05c	330	//if (track->IsOn(AliESDtrack::kTOFout)) GetESDsData(kTrk4)->Fill(p);
4d9ba05c	331	if (track->GetTOFsignal()>0) GetESDsData(kTrk4)->Fill(p);
cecff4fc	332	}
542c6c71	333	}
542c6c71	334	}
8336b059	335	const AliExternalTrackParam *tpcTrack=track->GetTPCInnerParam();
	336	const AliExternalTrackParam *innTrack=track->GetInnerParam();
	337	if (tpcTrack)
	338	if (innTrack) {
	339	const AliESDVertex *vtx=esd->GetPrimaryVertex();
	340	Double_t xv=vtx->GetXv();
	341	Double_t yv=vtx->GetYv();
	342	Double_t zv=vtx->GetZv();
	343	Float_t dz[2];
	344	tpcTrack->GetDZ(xv,yv,zv,esd->GetMagneticField(),dz);
	345	dz[0]*=10.; // in mm
	346	if (innTrack->GetZ() > 0)
	347	if (innTrack->GetTgl()> 0) { // TPC side A
	348	if (tpcTrack->GetSign() > 0) GetESDsData(kTrk7)->Fill(dz[0]);
	349	else GetESDsData(kTrk8)->Fill(dz[0]);
	350	}
	351	if (innTrack->GetZ() < 0)
	352	if (innTrack->GetTgl()< 0) { // TPC side C
	353	if (tpcTrack->GetSign() > 0) GetESDsData(kTrk9)->Fill(dz[0]);
	354	else GetESDsData(kTrk10)->Fill(dz[0]);
	355	}
	356	}
542c6c71	357
	358	// PID related QA
	359	if ((p>0.4) && (p<0.5)) {
	360	if (track->IsOn(AliESDtrack::kITSpid)) {
	361	Double_t dedx=track->GetITSsignal();
	362	GetESDsData(kPid0)->Fill(dedx);
	363	}
	364	if (track->IsOn(AliESDtrack::kTPCpid)) {
	365	Double_t dedx=track->GetTPCsignal();
	366	GetESDsData(kPid1)->Fill(dedx);
	367	}
d7259b2e	368	}
542c6c71	369	if (p>1.0) {
	370	if (track->IsOn(AliESDtrack::kTOFpid)) {
	371	Double_t times[10];
	372	track->GetIntegratedTimes(times);
	373	Double_t tof=track->GetTOFsignal();
	374	GetESDsData(kPid2)->Fill(times[2]-tof);
	375	}
	376	}
2937b8ff	377	const AliExternalTrackParam *par=track->GetInnerParam();
	378	if (par) {
	379	Double_t pp=par->GetP();
	380	Double_t dedx=track->GetTPCsignal();
	381	TH2F h = dynamic_cast<TH2F>(GetESDsData(kPid3));
	382	h->Fill(pp,dedx);
	383	}
	384
542c6c71	385	}
d7259b2e	386
2937b8ff	387	// Multiplicity related QA
	388	AliESDVZERO *mltV0 =esd->GetVZEROData();
	389	const AliMultiplicity *mltITS=esd->GetMultiplicity();
	390	if (mltV0)
	391	if (mltITS) {
	392	Short_t nv0a=mltV0->GetNbPMV0A();
	393	Short_t nv0c=mltV0->GetNbPMV0C();
	394	Int_t nits=mltITS->GetNumberOfTracklets();
	395	TH2F h0=dynamic_cast<TH2F>(GetESDsData(kMlt0));
	396	h0->Fill(nits,nv0a);
	397	TH2F h1=dynamic_cast<TH2F>(GetESDsData(kMlt1));
	398	h1->Fill(nits,nv0c);
	399	}
	400
	401
cecff4fc	402	TH1 *tpc=GetESDsData(kTrk2); tpc->Sumw2();
	403	TH1 *its=GetESDsData(kTrk3); its->Sumw2();
	404	TH1 *tof=GetESDsData(kTrk4); tof->Sumw2();
542c6c71	405	GetESDsData(kTrk5)->Divide(its,tpc,1,1.,"b");
	406	GetESDsData(kTrk6)->Divide(tof,tpc,1,1.,"b");
	407
	408	// V0 related QA
	409	Int_t nV0=esd->GetNumberOfV0s();
	410	for (Int_t i=0; i<nV0; i++) {
	411	Double_t mass;
	412	AliESDv0 v0(*esd->GetV0(i));
	413
	414	v0.ChangeMassHypothesis(kK0Short);
	415	mass=v0.GetEffMass();
b72280b3	416	if (v0.GetOnFlyStatus())
	417	GetESDsData(kK0on)->Fill(mass);
	418	else
	419	GetESDsData(kK0off)->Fill(mass);
542c6c71	420
	421	v0.ChangeMassHypothesis(kLambda0);
	422	mass=v0.GetEffMass();
b72280b3	423	if (v0.GetOnFlyStatus())
	424	GetESDsData(kL0on)->Fill(mass);
	425	else
	426	GetESDsData(kL0off)->Fill(mass);
542c6c71	427
	428	v0.ChangeMassHypothesis(kLambda0Bar);
	429	mass=v0.GetEffMass();
b72280b3	430	if (v0.GetOnFlyStatus())
	431	GetESDsData(kL0on)->Fill(mass);
	432	else
	433	GetESDsData(kL0off)->Fill(mass);
d7259b2e	434	}
542c6c71	435
f92b626a	436	}