[u/mrichter/AliRoot.git] / STEER / 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 "AliCDBPath.h"
#include "AliCDBEntry.h"
#include "AliCDBManager.h"
#include "AliDetectorRecoParam.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
  ClonePerTrigClass(AliQAv1::kRAWS); // this should be the last line
}

//____________________________________________________________________________
void AliGlobalQADataMaker::InitRecoParams() 
{
  // Get the recoparam form the OCDB 
  if (!fRecoParam) {
    TString name("GRP") ; 
    AliDebug(AliQAv1::GetQADebugLevel(), Form("Loading reconstruction parameter objects for detector %s", name.Data()));
    AliCDBPath path(name.Data(),"Calib","RecoParam");
    AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
    if(!entry) {
      fRecoParam = NULL ; 
      AliDebug(AliQAv1::GetQADebugLevel(), Form("Couldn't find RecoParam entry in OCDB for detector %s",name.Data()));
    }
    else {
      TObject * recoParamObj = entry->GetObject() ; 
      if ( strcmp(recoParamObj->ClassName(), "TObjArray") == 0 ) {
          // The detector has only one set of reco parameters
        AliDebug(AliQAv1::GetQADebugLevel(), Form("Array of reconstruction parameters found for detector %s",name.Data()));
        TObjArray *recoParamArray = static_cast<TObjArray*>(recoParamObj) ;
        for (Int_t iRP=0; iRP<recoParamArray->GetEntriesFast(); iRP++) {
          fRecoParam = static_cast<AliDetectorRecoParam*>(recoParamArray->At(iRP)) ;
          if (!fRecoParam) 
            break ; 
          else if (fRecoParam->IsDefault()) 
            break ; 
        }
      }
      else if (recoParamObj->InheritsFrom("AliDetectorRecoParam")) {
          // The detector has only one set of reco parameters
          // Registering it in AliRecoParam
        AliDebug(AliQAv1::GetQADebugLevel(), Form("Single set of reconstruction parameters found for detector %s",name.Data()));
        fRecoParam = static_cast<AliDetectorRecoParam*>(recoParamObj) ;
        static_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
      } else { 
        AliError(Form("No valid RecoParam object found in the OCDB for detector %s",name.Data()));
      }
    }
  }
}

//____________________________________________________________________________ 
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;
  //
  ClonePerTrigClass(AliQAv1::kRECPOINTS); // this should be the last line 
}

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

  {// Event related QA
    const Char_t *name[]={
      "hGlobalPrimaryVertex"
    };
    const Char_t *title[]={
      "Z-distribution of the primary vertex"
    };
    Add2ESDsList(new TH1F(name[0],title[0],100,-20.,20.),kEvt0,!expert,image);
  }
 
  {// 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);
  }
  //
  ClonePerTrigClass(AliQAv1::kESDS); // this should be the last line
}

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

//____________________________________________________________________________ 
void AliGlobalQADataMaker::MakeESDs(AliESDEvent * event) {
  //-----------------------------------------------------------
  // This function fills the ESD QA histograms
  // as a part of global QA
  //-----------------------------------------------------------

  const AliESDEvent *esd=event;

  // Event related QA
  const AliESDVertex *vtx=esd->GetPrimaryVertex();
  if (!vtx->GetStatus()) return;

  Double_t xv=vtx->GetXv();
  Double_t yv=vtx->GetYv();
  Double_t zv=vtx->GetZv();
  FillESDsData(kEvt0,zv);


  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);
      FillESDsData(kClr0,Float_t(n)/6.); //6 is the number of ITS layers
    }

    for (Int_t j=0; j<6; ++j) {
      Int_t idet=0, sts=0;
      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)) FillESDsData(kClr3,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; 
        FillESDsData(kClr1,val); 
      }
    }

    if (track->IsOn(AliESDtrack::kTRDrefit)) {
      Int_t n=track->GetTRDclusters(0);
      FillESDsData(kClr2,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(xv,yv,zv,esd->GetMagneticField(),dz); 
      if ((TMath::Abs(dz[0])<3.) && (TMath::Abs(dz[1])<3.)) { // beam pipe
        Double_t phi=track->Phi();
	FillESDsData(kTrk0,phi);
	Double_t y=track->Eta();
	FillESDsData(kTrk1,y);

        if (TMath::Abs(y)<0.9) {
	  FillESDsData(kTrk2,p);
	  if (track->IsOn(AliESDtrack::kITSrefit)) FillESDsData(kTrk3,p);
	  //if (track->IsOn(AliESDtrack::kTOFout)) FillESDsData(kTrk4,p);
	  if (track->GetTOFsignal()>0) FillESDsData(kTrk4,p);
	}
      }
    }
    const AliExternalTrackParam *tpcTrack=track->GetTPCInnerParam();
    const AliExternalTrackParam *innTrack=track->GetInnerParam();
    if (tpcTrack)
    if (innTrack) {
       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) FillESDsData(kTrk7,dz[0]);
	 else                         FillESDsData(kTrk8,dz[0]);
       }
       if (innTrack->GetZ()  < 0)
       if (innTrack->GetTgl()< 0) { // TPC side C
	 if (tpcTrack->GetSign() > 0) FillESDsData(kTrk9,dz[0]);
	 else                         FillESDsData(kTrk10,dz[0]);
       }
    }

    // PID related QA
    if ((p>0.4) && (p<0.5)) {
      if (track->IsOn(AliESDtrack::kITSpid)) {
	Double_t dedx=track->GetITSsignal();
        FillESDsData(kPid0,dedx);
      }
      if (track->IsOn(AliESDtrack::kTPCpid)) {
	Double_t dedx=track->GetTPCsignal();
        FillESDsData(kPid1,dedx);
      }
    }
    if (p>1.0) {
      if (track->IsOn(AliESDtrack::kITSrefit))
      if (track->IsOn(AliESDtrack::kTPCrefit))
      if (track->IsOn(AliESDtrack::kTOFout)) {
         Float_t dz[2];
         track->GetDZ(xv,yv,zv,esd->GetMagneticField(),dz);
         if (dz[1]<3.) {
            Double_t times[10];
            track->GetIntegratedTimes(times);
            Double_t tof=track->GetTOFsignal()/*-847055 -1771207*/;
            FillESDsData(kPid2,times[2]-tof);
	 }
      }
    }
    const AliExternalTrackParam *par=track->GetInnerParam();
    if (par) {
      Double_t pp=par->GetP();
      Double_t dedx=track->GetTPCsignal();
      FillESDsData(kPid3,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();
       FillESDsData(kMlt0,nits,nv0a);
       FillESDsData(kMlt1,nits,nv0c);
    }

  // RS
  for (int itr = -1; itr<GetNEventTrigClasses(); itr++) {
    TH1 *tpc = GetMatchingESDsHisto(kTrk2,itr);
    TH1 *its = GetMatchingESDsHisto(kTrk3,itr);
    TH1 *tof = GetMatchingESDsHisto(kTrk4,itr);
    TH1* h5 =  GetMatchingESDsHisto(kTrk5,itr);
    TH1* h6 =  GetMatchingESDsHisto(kTrk6,itr);
    if (h5 && h6 && tpc && its && tof) {
      tpc->Sumw2();
      its->Sumw2();
      tof->Sumw2();
      h5->Divide(its,tpc,1,1.,"b");
      h6->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));

    Int_t nidx=TMath::Abs(v0.GetNindex());
    AliESDtrack *ntrack1=esd->GetTrack(nidx);
    if (!ntrack1->IsOn(AliESDtrack::kTPCrefit)) continue;

    Int_t pidx=TMath::Abs(v0.GetPindex());
    AliESDtrack *ptrack1=esd->GetTrack(pidx);
    if (!ptrack1->IsOn(AliESDtrack::kTPCrefit)) continue;

    v0.ChangeMassHypothesis(kK0Short);
    mass=v0.GetEffMass();
    if (v0.GetOnFlyStatus())
      FillESDsData(kK0on,mass);
    else
      FillESDsData(kK0off,mass);

    v0.ChangeMassHypothesis(kLambda0);
    mass=v0.GetEffMass();
    if (v0.GetOnFlyStatus())
      FillESDsData(kL0on,mass);
    else
      FillESDsData(kL0off,mass);

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