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

  const Bool_t expert   = kTRUE ; 
  const Bool_t image    = kTRUE ; 
 {// 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, !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);
  }

  {// 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"
  };
    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, !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);
  }

}

//____________________________________________________________________________
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);
	}
      }
    }
    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);
      }
    }
  }

  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
f728e025	143	const Bool_t expert = kTRUE ;
	144	const Bool_t image = kTRUE ;
	145	{// Cluster related QA
dd1b15c4	146	const Char_t *name[]={
	147	"hGlobalFractionAssignedClustersITS",
	148	"hGlobalFractionAssignedClustersTPC",
	149	"hGlobalFractionAssignedClustersTRD"
	150	};
	151	const Char_t *title[]={
	152	"Fraction of the assigned clusters in ITS",
	153	"Fraction of the assigned clusters in TPC",
	154	"Fraction of the assigned clusters in TRD"
	155	};
f728e025	156	Add2ESDsList(new TH1F(name[0],title[0],100,0.,2.),kClr0, !expert, image);
	157	Add2ESDsList(new TH1F(name[1],title[1],100,0.,2.),kClr1, !expert, image);
	158	Add2ESDsList(new TH1F(name[2],title[2],100,0.,2.),kClr2, !expert, image);
542c6c71	159	}
	160
	161	{// Track related QA
dd1b15c4	162	const Char_t *name[]={
	163	"hGlobalTrackAzimuthe", // kTrk0
	164	"hGlobalTrackEta", // kTrk1
	165	"hGlobalTPCTrackpT", // kTrk2
	166	"hGlobalTPCITSMatchedpT", // kTrk3
	167	"hGlobalTPCTOFMatchedpT", // kTrk4
	168	"hGlobalTPCITSMatchingProbability", // kTrk5
8336b059	169	"hGlobalTPCTOFMatchingProbability", // kTrk6
	170	"hGlobalTPCsideAposDCA", // kTrk7
	171	"hGlobalTPCsideAnegDCA", // kTrk8
	172	"hGlobalTPCsideCposDCA", // kTrk9
	173	"hGlobalTPCsideCnegDCA" // kTrk10
542c6c71	174	};
dd1b15c4	175	const Char_t *title[]={
	176	"Track azimuthal distribution (rad)", // kTrk0
	177	"Track pseudo-rapidity distribution", // kTrk1
	178	"TPC: track momentum distribution (GeV)", // kTrk2
	179	"TPC-ITS matched: track momentum distribution (GeV)", // kTrk3
	180	"TPC-TOF matched: track momentum distribution (GeV)", // kTrk4
	181	"TPC-ITS track-matching probability", // kTrk5
8336b059	182	"TPC-TOF track-matching probability", // kTrk6
	183	"TPC side A: DCA for the positive tracks (mm)", // kTrk7
	184	"TPC side A: DCA for the negative tracks (mm)", // kTrk8
	185	"TPC side C: DCA for the positive tracks (mm)", // kTrk9
	186	"TPC side C: DCA for the negative tracks (mm)" // kTrk10
dd1b15c4	187	};
f728e025	188	Add2ESDsList(new TH1F(name[0],title[0],100, 0.,TMath::TwoPi()),kTrk0, !expert, image);
	189	Add2ESDsList(new TH1F(name[1],title[1],100,-2.00,2.00),kTrk1, !expert, image);
	190	Add2ESDsList(new TH1F(name[2],title[2],50, 0.20,5.00),kTrk2, !expert, image);
	191	Add2ESDsList(new TH1F(name[3],title[3],50, 0.20,5.00),kTrk3, !expert, image);
	192	Add2ESDsList(new TH1F(name[4],title[4],50, 0.20,5.00),kTrk4, !expert, image);
	193	Add2ESDsList(new TH1F(name[5],title[5],50, 0.20,5.00),kTrk5, !expert, image);
	194	Add2ESDsList(new TH1F(name[6],title[6],50, 0.20,5.00),kTrk6, !expert, image);
	195	Add2ESDsList(new TH1F(name[7],title[7],50, -25.0,25.0),kTrk7, !expert, image);
	196	Add2ESDsList(new TH1F(name[8],title[8],50, -25.0,25.0),kTrk8, !expert, image);
	197	Add2ESDsList(new TH1F(name[9],title[9],50, -25.0,25.0),kTrk9, !expert, image);
	198	Add2ESDsList(new TH1F(name[10],title[10],50, -25.0,25.0),kTrk10, !expert, image);
542c6c71	199	}
	200
	201	{// V0 related QA
dd1b15c4	202	const Char_t *name[]={
	203	"hGlobalPromptK0sMass",
	204	"hGlobalOfflineK0sMass",
	205	"hGlobalPromptLambda0Lambda0BarMass",
	206	"hGlobalOfflineLambda0Lambda0BarMass"
	207	};
	208	const Char_t *title[]={
	209	"On-the-fly K0s mass (GeV)",
	210	"Offline K0s mass (GeV)",
	211	"On-the-fly Lambda0 + Lambda0Bar mass (GeV)",
	212	"Offline Lambda0 + Lambda0Bar mass (GeV)"
	213	};
f728e025	214	Add2ESDsList(new TH1F(name[0],title[0],50, 0.4477,0.5477),kK0on, !expert, image);
	215	Add2ESDsList(new TH1F(name[1],title[1],50, 0.4477,0.5477),kK0off, !expert, image);
	216	Add2ESDsList(new TH1F(name[2],title[2],50, 1.0657,1.1657),kL0on, !expert, image);
	217	Add2ESDsList(new TH1F(name[3],title[3],50, 1.0657,1.1657),kL0off, !expert, image);
542c6c71	218	}
	219
	220	{// PID related QA
a6e0ebfe	221	const Char_t *name[]={
c9622234	222	"hGlobalITSdEdx",
	223	"hGlobalTPCdEdx",
	224	"hGlobalTOFTrackingvsMeasured"
542c6c71	225	};
dd1b15c4	226	const Char_t *title[]={
	227	"ITS: dEdx (ADC) for particles with momentum 0.4 - 0.5 (GeV)",
	228	"TPC: dEdx (ADC) for particles with momentum 0.4 - 0.5 (GeV)",
	229	"TOF: tracking - measured (ps)"
	230	};
f728e025	231	Add2ESDsList(new TH1F(name[0],title[0],50,0.00,200.),kPid0, !expert, image);
	232	Add2ESDsList(new TH1F(name[1],title[1],50,0.00,100.),kPid1, !expert, image);
	233	Add2ESDsList(new TH1F(name[2],title[2],50,-3500.,3500.),kPid2, !expert, image);
542c6c71	234	}
542c6c71	235
d7259b2e	236	}
d7259b2e	237
fb774831	238	//____________________________________________________________________________
	239	void AliGlobalQADataMaker::MakeRaws(AliRawReader* rawReader)
	240	{
	241	//Fill prepared histograms with Raw digit properties
	242	rawReader->Reset() ;
	243
	244	}
	245
	246	//____________________________________________________________________________
542c6c71	247	void AliGlobalQADataMaker::MakeESDs(AliESDEvent * event) {
d7259b2e	248	//-----------------------------------------------------------
	249	// This function fills the ESD QA histograms
	250	// as a part of global QA
	251	//-----------------------------------------------------------
eca4fa66	252	// Check id histograms already created for this Event Specie
	253	if ( ! GetESDsData(kClr0) )
	254	InitESDs() ;
	255
c9622234	256
542c6c71	257	const AliESDEvent *esd=event;
542c6c71	258
d7259b2e	259	Int_t ntrk=esd->GetNumberOfTracks() ;
d7259b2e	260	for (Int_t i=0; i<ntrk; i++) {
542c6c71	261	const AliESDtrack *track=esd->GetTrack(i);
d7259b2e	262
542c6c71	263	// Cluster related QA
d7259b2e	264	if (track->IsOn(AliESDtrack::kITSrefit)) {
d7259b2e	265	Int_t n=track->GetITSclusters(0);
542c6c71	266	GetESDsData(kClr0)->Fill(Float_t(n)/6.); //6 is the number of ITS layers
d7259b2e	267	}
	268
	269	if (track->IsOn(AliESDtrack::kTPCrefit)) {
	270	Int_t n =track->GetTPCNcls();
	271	Int_t nf=track->GetTPCNclsF(); // number of crossed TPC pad rows
1aaf4118	272	if (nf>0) {
	273	Double_t val = n*1.0/nf;
	274	GetESDsData(kClr1)->Fill(val);
	275	}
d7259b2e	276	}
	277
	278	if (track->IsOn(AliESDtrack::kTRDrefit)) {
	279	Int_t n=track->GetTRDclusters(0);
e3bd5382	280	GetESDsData(kClr2)->Fill(Float_t(n)/(624));//(624) is the number of TRD time bins
542c6c71	281	}
	282
	283	Double_t p=track->GetP();
	284
	285	// Track related QA
	286	if (track->IsOn(AliESDtrack::kTPCrefit)) {
	287	Float_t dz[2];
	288	track->GetDZ(0.,0.,0.,esd->GetMagneticField(),dz);
	289	if ((TMath::Abs(dz[0])<3.) && (TMath::Abs(dz[1])<3.)) { // beam pipe
	290	Double_t phi=track->Phi();
	291	GetESDsData(kTrk0)->Fill(phi);
44f14df0	292	Double_t y=track->Eta();
542c6c71	293	GetESDsData(kTrk1)->Fill(y);
542c6c71	294
cecff4fc	295	if (TMath::Abs(y)<0.9) {
	296	GetESDsData(kTrk2)->Fill(p);
	297	if (track->IsOn(AliESDtrack::kITSrefit)) GetESDsData(kTrk3)->Fill(p);
4d9ba05c	298	//if (track->IsOn(AliESDtrack::kTOFout)) GetESDsData(kTrk4)->Fill(p);
4d9ba05c	299	if (track->GetTOFsignal()>0) GetESDsData(kTrk4)->Fill(p);
cecff4fc	300	}
542c6c71	301	}
542c6c71	302	}
8336b059	303	const AliExternalTrackParam *tpcTrack=track->GetTPCInnerParam();
	304	const AliExternalTrackParam *innTrack=track->GetInnerParam();
	305	if (tpcTrack)
	306	if (innTrack) {
	307	const AliESDVertex *vtx=esd->GetPrimaryVertex();
	308	Double_t xv=vtx->GetXv();
	309	Double_t yv=vtx->GetYv();
	310	Double_t zv=vtx->GetZv();
	311	Float_t dz[2];
	312	tpcTrack->GetDZ(xv,yv,zv,esd->GetMagneticField(),dz);
	313	dz[0]*=10.; // in mm
	314	if (innTrack->GetZ() > 0)
	315	if (innTrack->GetTgl()> 0) { // TPC side A
	316	if (tpcTrack->GetSign() > 0) GetESDsData(kTrk7)->Fill(dz[0]);
	317	else GetESDsData(kTrk8)->Fill(dz[0]);
	318	}
	319	if (innTrack->GetZ() < 0)
	320	if (innTrack->GetTgl()< 0) { // TPC side C
	321	if (tpcTrack->GetSign() > 0) GetESDsData(kTrk9)->Fill(dz[0]);
	322	else GetESDsData(kTrk10)->Fill(dz[0]);
	323	}
	324	}
542c6c71	325
	326	// PID related QA
	327	if ((p>0.4) && (p<0.5)) {
	328	if (track->IsOn(AliESDtrack::kITSpid)) {
	329	Double_t dedx=track->GetITSsignal();
	330	GetESDsData(kPid0)->Fill(dedx);
	331	}
	332	if (track->IsOn(AliESDtrack::kTPCpid)) {
	333	Double_t dedx=track->GetTPCsignal();
	334	GetESDsData(kPid1)->Fill(dedx);
	335	}
d7259b2e	336	}
542c6c71	337	if (p>1.0) {
	338	if (track->IsOn(AliESDtrack::kTOFpid)) {
	339	Double_t times[10];
	340	track->GetIntegratedTimes(times);
	341	Double_t tof=track->GetTOFsignal();
	342	GetESDsData(kPid2)->Fill(times[2]-tof);
	343	}
	344	}
	345	}
d7259b2e	346
cecff4fc	347	TH1 *tpc=GetESDsData(kTrk2); tpc->Sumw2();
	348	TH1 *its=GetESDsData(kTrk3); its->Sumw2();
	349	TH1 *tof=GetESDsData(kTrk4); tof->Sumw2();
542c6c71	350	GetESDsData(kTrk5)->Divide(its,tpc,1,1.,"b");
	351	GetESDsData(kTrk6)->Divide(tof,tpc,1,1.,"b");
	352
	353	// V0 related QA
	354	Int_t nV0=esd->GetNumberOfV0s();
	355	for (Int_t i=0; i<nV0; i++) {
	356	Double_t mass;
	357	AliESDv0 v0(*esd->GetV0(i));
	358
	359	v0.ChangeMassHypothesis(kK0Short);
	360	mass=v0.GetEffMass();
b72280b3	361	if (v0.GetOnFlyStatus())
	362	GetESDsData(kK0on)->Fill(mass);
	363	else
	364	GetESDsData(kK0off)->Fill(mass);
542c6c71	365
	366	v0.ChangeMassHypothesis(kLambda0);
	367	mass=v0.GetEffMass();
b72280b3	368	if (v0.GetOnFlyStatus())
	369	GetESDsData(kL0on)->Fill(mass);
	370	else
	371	GetESDsData(kL0off)->Fill(mass);
542c6c71	372
	373	v0.ChangeMassHypothesis(kLambda0Bar);
	374	mass=v0.GetEffMass();
b72280b3	375	if (v0.GetOnFlyStatus())
	376	GetESDsData(kL0on)->Fill(mass);
	377	else
	378	GetESDsData(kL0off)->Fill(mass);
d7259b2e	379	}
542c6c71	380
f92b626a	381	}