ROOT logo
#include "AliAnalysisTask.h"
#include "AliAnalysisManager.h"
#include "AliAnalysisDataContainer.h"
#include "AliITSRecPoint.h"
#include "AliESDEvent.h"
#include "AliESDRun.h"
#include "AliDAQ.h"
#include "AliTrackPointArray.h"
#include "AliITSgeomTGeo.h"
#include "AliITSTPArrayFit.h"
#include "AliESDfriend.h"
#include "AliCDBManager.h"
#include "AliCDBEntry.h"
#include "AliITSCalibrationSDD.h"
#include "AliITSresponseSDD.h"
#include "AliGeomManager.h"
#include "AliMultiplicity.h"
#include <TSystem.h>
#include <TTree.h>
#include <TH1F.h>
#include <TH2F.h>
#include <TProfile.h>
#include <TChain.h>
#include <TGeoGlobalMagField.h>
#include "AliESDInputHandlerRP.h"
#include "AliITSSumTP.h"
#include "AliMagF.h"

/**************************************************************************
 * Copyright(c) 1998-2010, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

//*************************************************************************
// Implementation of class AliAnalysiTaskITSAlignQA
// AliAnalysisTaskSE to extract from ESD + ESDfriends 
// the track-to-point residuals and dE/dx vs, time for SDD modules
//
// Author: F. Prino, prino@to.infn.it
//*************************************************************************


#include "AliAnalysisTaskITSAlignQA.h"

ClassImp(AliAnalysisTaskITSAlignQA)
//______________________________________________________________________________
AliAnalysisTaskITSAlignQA::AliAnalysisTaskITSAlignQA() : AliAnalysisTaskSE("SDD Calibration"), 
  fOutput(0),
  fHistNEvents(0),
  fHistPtAccept(0),
  fDoSPDResiduals(kTRUE),
  fDoSDDResiduals(kTRUE),
  fDoSSDResiduals(kTRUE),
  fDoSDDdEdxCalib(kTRUE),
  fDoSDDVDriftCalib(kTRUE),
  fDoSDDDriftTime(kTRUE),
  fDoFillTPTree(kFALSE),
  fUseITSsaTracks(kFALSE),
  fLoadGeometry(kFALSE),
  fUseVertex(kFALSE),
  fUseVertexForZOnly(kFALSE),
  fUseTPCMomentum(kFALSE),
  fMinVtxContributors(5),
  fRemovePileupWithSPD(kTRUE),
  fMinITSpts(3),
  fMinTPCpts(70),
  fMinPt(0.5),
  fNPtBins(8),
  fMinMult(0),
  fMaxMult(1e9),
  fCutDCAXY(100.),
  fCutDCAZ(100.),
  fFitter(0),
  fITSSumTP(),
  fTPTree(),
  fRunNb(0),
  fOCDBLocation("local://$ALICE_ROOT/OCDB")
{
  //
  fFitter = new AliITSTPArrayFit(5);
  Double_t xbins[9]={0.3,0.5,0.75,1.,1.5,2.,3.,5.,10.};
  SetPtBinLimits(8,xbins);
  DefineOutput(1, TList::Class());
}


//___________________________________________________________________________
AliAnalysisTaskITSAlignQA::~AliAnalysisTaskITSAlignQA(){
  //
  if (fOutput && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) {
    delete fOutput;
    delete fITSSumTP;
  }
  delete fFitter;
  delete fTPTree;
  //
}
//___________________________________________________________________________
void AliAnalysisTaskITSAlignQA::UserCreateOutputObjects() {
  //

  if(fLoadGeometry) LoadGeometryFromOCDB();

  fOutput = new TList();
  fOutput->SetOwner();
  fOutput->SetName("OutputHistos");

  fHistNEvents = new TH1F("hNEvents", "Number of processed events",kNEvStatBins,-0.5,kNEvStatBins-0.5);
  //fHistNEvents->Sumw2();
  fHistNEvents->SetMinimum(0);
  fHistNEvents->GetXaxis()->SetBinLabel(kEvAll+1,"All Events");
  fHistNEvents->GetXaxis()->SetBinLabel(kEvCnt+1,"After Centrality cut");
  fHistNEvents->GetXaxis()->SetBinLabel(kEvVtx+1,"After Vertex cut");
  fHistNEvents->GetXaxis()->SetBinLabel(kEvPlp+1,"After Pileup cut");
  fHistNEvents->GetXaxis()->SetBinLabel(kNTracks+1,"Tracks Accepted");
  fOutput->Add(fHistNEvents);

  fHistPtAccept = new TH1F("hPtAccept","Pt distrib of accepted tracks",50,0.,5.);
  //fHistPtAccept->Sumw2();
  fHistPtAccept->SetMinimum(0);
  fOutput->Add(fHistPtAccept);

  if(fDoSPDResiduals) CreateSPDHistos();
  if(fDoSDDResiduals || fDoSDDdEdxCalib || fDoSDDVDriftCalib || fDoSDDDriftTime) CreateSDDHistos();
  if(fDoSSDResiduals) CreateSSDHistos();
  //
  if (fDoFillTPTree) {
    TFile* troutf = OpenFile(2);
    if (!troutf) {
      AliFatal("Failed to open output file for AliITSSumTP tree");
      exit(1);
    }
    fITSSumTP = new AliITSSumTP();
    fTPTree = new TTree("ITSSumTP","ITS TP Summary");
    fTPTree->Branch("AliITSSumTP","AliITSSumTP",&fITSSumTP);
    PostData(2,fTPTree);
  }
  //
  PostData(1,fOutput);
}

//___________________________________________________________________________
void AliAnalysisTaskITSAlignQA::CreateSPDHistos(){
  // Histos for SPD
  

  for(Int_t iMod=0; iMod<kNSPDmods; iMod++){
    fHistSPDResidX[iMod] = new TH2F(Form("hSPDResidX%d",iMod),
				    Form("hSPDResidX%d",iMod),
				    fNPtBins,fPtBinLimits,
				    250,-0.05,0.05);
    //fHistSPDResidX[iMod]->Sumw2();
    fOutput->Add(fHistSPDResidX[iMod]);

    fHistSPDResidZ[iMod] = new TH2F(Form("hSPDResidZ%d",iMod),
				    Form("hSPDResidZ%d",iMod),
				    fNPtBins,fPtBinLimits,
				    250,-0.1,0.1);
    //fHistSPDResidZ[iMod]->Sumw2();
    fOutput->Add(fHistSPDResidZ[iMod]);
  }
  return;
}

//___________________________________________________________________________
void AliAnalysisTaskITSAlignQA::CreateSDDHistos(){
  // Histos for SDD

  for(Int_t iMod=0; iMod<kNSDDmods; iMod++){
    if (fDoSDDResiduals) {
      fHistSDDResidX[iMod] = new TH2F(Form("hSDDResidX%d",iMod+kNSPDmods),
				      Form("hSDDResidX%d",iMod+kNSPDmods),
				      fNPtBins,fPtBinLimits,
				      300,-0.15,0.15);
      //fHistSDDResidX[iMod]->Sumw2();
      fOutput->Add(fHistSDDResidX[iMod]);
      
      fHistSDDResidZ[iMod] = new TH2F(Form("hSDDResidZ%d",iMod+kNSPDmods),
				      Form("hSDDResidZ%d",iMod+kNSPDmods),
				      fNPtBins,fPtBinLimits,
				      200,-0.1,0.1);
      //fHistSDDResidZ[iMod]->Sumw2();
      fOutput->Add(fHistSDDResidZ[iMod]);
      
      fHistSDDResidXvsX[iMod] = new TH2F(Form("hSDDResidXvsX%d",iMod+kNSPDmods),
					 Form("hSDDResidXvsX%d",iMod+kNSPDmods),
					 40,-3.5,3.5,300,-0.15,0.15);   
      //fHistSDDResidXvsX[iMod]->Sumw2();
      fOutput->Add(fHistSDDResidXvsX[iMod]);
      
      fHistSDDResidXvsZ[iMod] = new TH2F(Form("hSDDResidXvsZ%d",iMod+kNSPDmods),
					 Form("hSDDResidXvsZ%d",iMod+kNSPDmods),
					 10,-3.8,3.8,300,-0.15,0.15);   
      //fHistSDDResidXvsZ[iMod]->Sumw2();
      fOutput->Add(fHistSDDResidXvsZ[iMod]);
      
      fHistSDDResidZvsX[iMod] = new TH2F(Form("hSDDResidZvsX%d",iMod+kNSPDmods),
				      Form("hSDDResidZvsX%d",iMod+kNSPDmods),
				      40,-3.5,3.5,200,-0.1,0.1);   
      //fHistSDDResidZvsX[iMod]->Sumw2();
      fOutput->Add(fHistSDDResidZvsX[iMod]);
      
      fHistSDDResidZvsZ[iMod] = new TH2F(Form("hSDDResidZvsZ%d",iMod+kNSPDmods),
					 Form("hSDDResidZvsZ%d",iMod+kNSPDmods),
					 10,-3.8,3.8,200,-0.1,0.1);   
      //fHistSDDResidZvsZ[iMod]->Sumw2();
      fOutput->Add(fHistSDDResidZvsZ[iMod]);
      //
    }
    //
    if (fDoSDDVDriftCalib) {
      for (int ix=0;ix<2;ix++) { // profile histos per side
	//
	char* hnm = Form("hpSDDResXvsXD%d_%d",iMod+kNSPDmods,ix);
	int nbX = 50, nbZ = 20, nbXOffs = 2, nbZOffs = 2;
	double xRange = 3.5085e4, zRange = 7.5264e4, xOffs = nbXOffs*xRange/nbX, zOffs = nbZOffs*zRange/nbZ;
	fHProfSDDResidXvsXD[iMod][ix] = new TProfile(hnm, hnm, nbX+2*nbXOffs, -xOffs, xRange + xOffs);
	//fHProfSDDResidXvsXD[iMod][ix]->Sumw2();
	fOutput->Add(fHProfSDDResidXvsXD[iMod][ix]);
	//
	hnm = Form("hpSDDDrTimevsXD%d_%d",iMod+kNSPDmods,ix);
	fHProfSDDDrTimevsXD[iMod][ix] = new TProfile(hnm, hnm, nbX+2*nbXOffs, -xOffs, xRange + xOffs);
	//fHProfSDDDrTimevsXD[iMod][ix]->Sumw2();
	fOutput->Add(fHProfSDDDrTimevsXD[iMod][ix]);
	//
	hnm = Form("hpSDDResXvsZ%d_%d",iMod+kNSPDmods,ix);
	fHProfSDDResidXvsZ[iMod][ix] = new TProfile(hnm, hnm, nbZ+2*nbZOffs, -(0.5*zRange+zOffs),(0.5*zRange+zOffs));
	//fHProfSDDResidXvsZ[iMod][ix]->Sumw2();
	fOutput->Add(fHProfSDDResidXvsZ[iMod][ix]);
	//
	hnm = Form("hpSDDDrTimevsZ%d_%d",iMod+kNSPDmods,ix);
	fHProfSDDDrTimevsZ[iMod][ix] = new TProfile(hnm, hnm, nbZ+2*nbZOffs, -(0.5*zRange+zOffs),(0.5*zRange+zOffs));
	//fHProfSDDDrTimevsZ[iMod][ix]->Sumw2();
	fOutput->Add(fHProfSDDDrTimevsZ[iMod][ix]);
	//
      }
    }
    
    if(fDoSDDdEdxCalib){
      fHistSDDdEdxvsDrTime[iMod] = new TH2F(Form("hSDDdEdxvsDrTime%d",iMod+kNSPDmods),
					    Form("hSDDdEdxvsDrTime%d",iMod+kNSPDmods),
					    16,0.,6400.,100,0.,300.);
      //fHistSDDdEdxvsDrTime[iMod]->Sumw2();
      fOutput->Add(fHistSDDdEdxvsDrTime[iMod]);
    }
    //
    if (fDoSDDDriftTime) {
      fHistSDDDrTimeAll[iMod]=new TH1F(Form("hSDDDrTimeAll%d",iMod+kNSPDmods),
				       Form("hSDDDrTimeAll%d",iMod+kNSPDmods),
				       3200,0.,6400.);
      //fHistSDDDrTimeAll[iMod]->Sumw2();
      fHistSDDDrTimeAll[iMod]->SetMinimum(0.);
      fOutput->Add(fHistSDDDrTimeAll[iMod]);
      
      fHistSDDDrTimeExtra[iMod]=new TH1F(Form("hSDDDrTimeExtra%d",iMod+kNSPDmods),
					 Form("hSDDDrTimeExtra%d",iMod+kNSPDmods),
					 3200,0.,6400.);
      //fHistSDDDrTimeExtra[iMod]->Sumw2();
      fHistSDDDrTimeExtra[iMod]->SetMinimum(0.);
      fOutput->Add(fHistSDDDrTimeExtra[iMod]);
      
      fHistSDDDrTimeAttac[iMod]=new TH1F(Form("hSDDDrTimeAttac%d",iMod+kNSPDmods),
					 Form("hSDDDrTimeAttac%d",iMod+kNSPDmods),
					 3200,0.,6400.);
      //fHistSDDDrTimeAttac[iMod]->Sumw2();
      fHistSDDDrTimeAttac[iMod]->SetMinimum(0.);
      fOutput->Add(fHistSDDDrTimeAttac[iMod]);
    }
  }
  return;
  //
}

//___________________________________________________________________________
void AliAnalysisTaskITSAlignQA::CreateSSDHistos(){
  // Histos for SSD
  for(Int_t iMod=0; iMod<kNSSDmods; iMod++){
    fHistSSDResidX[iMod] = new TH2F(Form("hSSDResidX%d",iMod+kNSPDmods+kNSDDmods),
				    Form("hSSDResidX%d",iMod+kNSPDmods+kNSDDmods),
				    fNPtBins,fPtBinLimits,
				    250,-0.1,0.1);
    //fHistSSDResidX[iMod]->Sumw2();
    fOutput->Add(fHistSSDResidX[iMod]);

    fHistSSDResidZ[iMod] = new TH2F(Form("hSSDResidZ%d",iMod+kNSPDmods+kNSDDmods),
				    Form("hSSDResidZ%d",iMod+kNSPDmods+kNSDDmods),
				    fNPtBins,fPtBinLimits,
				    250,-1.,1.);
    //fHistSSDResidZ[iMod]->Sumw2();
    fOutput->Add(fHistSSDResidZ[iMod]);
  }
  return;
}
//______________________________________________________________________________
void AliAnalysisTaskITSAlignQA::UserExec(Option_t *)
{
  //
  static AliTrackPointArray* arrayITS = 0;
  AliTrackPointArray* arrayITSNoVtx = 0;
  //
  AliESDEvent *esd = (AliESDEvent*) (InputEvent());
  if (fITSSumTP) fITSSumTP->Reset();

  if(!esd) {
    printf("AliAnalysisTaskITSAlignQA::Exec(): bad ESD\n");
    return;
  } 

  if(!ESDfriend()) {
    printf("AliAnalysisTaskITSAlignQA::Exec(): bad ESDfriend\n");
    return;
  }
  //
  static Bool_t firstCheck = kTRUE;
  if (firstCheck) {
    //    
    if (TMath::Abs(esd->GetCurrentL3())<300) { // no field
      SetMinPt(0.005);
      AliInfo("No magnetic field: eliminating pt cut");
    }
    const AliESDRun *esdrn = esd->GetESDRun();
    if (!esdrn) return;
    Int_t activeDetectors = esdrn->GetDetectorsInReco();
    if ( !(activeDetectors & AliDAQ::kTPC) ) {
      AliInfo("No TPC, suppress TPC points request");
      SetUseITSstandaloneTracks(kTRUE);
      SetUseTPCMomentum(kFALSE);
    }
    firstCheck = kFALSE;
  }
  //
  fHistNEvents->Fill(kEvAll);
  //
  if (!AcceptCentrality(esd)) return;
  fHistNEvents->Fill(kEvCnt);

  const AliESDVertex* vtx=0,*vtxSPD=0;
  vtx    = esd->GetPrimaryVertex();
  vtxSPD = esd->GetPrimaryVertexSPD();
  //
  if (fUseVertex) {  // check the vertex if it is requested as an extra point
    if (!AcceptVertex(vtx,vtxSPD)) return;
  }

  fHistNEvents->Fill(kEvVtx);
  if (fRemovePileupWithSPD){
    // skip events tagged by SPD as pileup
    if(esd->IsPileupFromSPD()) return;
  }
  fHistNEvents->Fill(kEvPlp);

  //
  fFitter->SetBz(esd->GetMagneticField());

  const AliTrackPointArray *array = 0;
  Int_t ntracks = esd->GetNumberOfTracks();

  for (Int_t itrack=0; itrack < ntracks; itrack++) {
    //
    if (arrayITS) {delete arrayITS; arrayITS = 0;}  // reset points from previous tracks 
    arrayITSNoVtx = 0;
    //
    AliESDtrack * track = esd->GetTrack(itrack);
    if(!track) continue;
    if(!AcceptTrack(track, vtx)) continue;
    array = track->GetTrackPointArray();
    if(!array) continue;
    arrayITS = PrepareTrack(array, vtx);
    if (fITSSumTP) {
      arrayITSNoVtx = PrepareTrack(array, 0);
      arrayITSNoVtx->SetUniqueID(itrack);
      fITSSumTP->AddTrack(arrayITSNoVtx);
    }
    //
    fHistNEvents->Fill(kNTracks);
    //
    Int_t npts  = arrayITS->GetNPoints();
    Int_t npts1 = fUseVertexForZOnly ? npts-1 : npts;
    //
    if(fDoSPDResiduals){ 
      FitAndFillSPD(1,arrayITS,npts1,track);
      FitAndFillSPD(2,arrayITS,npts1,track);
    }
    if(fDoSDDResiduals || fDoSDDdEdxCalib || fDoSDDVDriftCalib || fDoSDDDriftTime) {
      FitAndFillSDDrphi(arrayITS,npts,track);
      if (fDoSDDResiduals) {
	FitAndFillSDDz(3,arrayITS,npts1,track);
	FitAndFillSDDz(4,arrayITS,npts1,track);
      }
    }
    if(fDoSSDResiduals){ 
      FitAndFillSSD(5,arrayITS,npts1,track);
      FitAndFillSSD(6,arrayITS,npts1,track);
    }
  }
  //
  if (fITSSumTP) { // store vertex and mometum info
    double xyz[3]={0,0,0};
    fITSSumTP->SetVertex(vtx);
    TObjArray& tps = fITSSumTP->GetTracks();
    int ntp = tps.GetEntriesFast();
    fITSSumTP->BookNTracks(ntp);
    for (int it=ntp;it--;) {
      AliTrackPointArray* tp = (AliTrackPointArray*)tps[it];
      if (!tp) continue;
      AliESDtrack* esdTr = esd->GetTrack(tp->GetUniqueID());
      double crv =  esdTr->GetC(esd->GetMagneticField());
      double crve = TMath::Sqrt(esdTr->GetSigma1Pt2()) * esd->GetMagneticField()*kB2C;
      fITSSumTP->SetCrvGlo(it,crv);
      fITSSumTP->SetCrvGloErr(it,crve);
      const AliExternalTrackParam* inTPC =  esdTr->GetTPCInnerParam(); // TPC track at vtx
      if (inTPC) {
	 crv =  inTPC->GetC(esd->GetMagneticField());
	 crve = TMath::Sqrt(inTPC->GetSigma1Pt2()) * TMath::Abs(esd->GetMagneticField()*kB2C);
	 fITSSumTP->SetCrvTPC(it,crv);
	 fITSSumTP->SetCrvTPCErr(it,crve);
      }
      inTPC = esdTr->GetInnerParam();  // TPC track at the inner wall
      if (inTPC) {
	inTPC->GetXYZ(xyz);
	fITSSumTP->SetTPCInnerXYZ(it,xyz);
      }
    }
    fITSSumTP->SetUniqueID(fCurrentRunNumber);
    if (ntp) fTPTree->Fill();
    CopyUserInfo();
  }

  //
  PostData(1,fOutput);
  
}

//___________________________________________________________________________
Bool_t AliAnalysisTaskITSAlignQA::AcceptTrack(const AliESDtrack * track, const AliESDVertex* vtx)
{
  // track selection cuts
  Bool_t accept=kTRUE;
  if(fUseITSsaTracks){ 
    if(track->GetNcls(1)>0) accept=kFALSE;
  }else{
    if(track->GetNcls(1)<fMinTPCpts) accept=kFALSE;
  }
  if(track->GetNcls(0) < fMinITSpts) accept=kFALSE;
  Int_t trstatus=track->GetStatus();
  if(!(trstatus&AliESDtrack::kITSrefit)) accept=kFALSE;
  Float_t pt = 0;
  if (fUseTPCMomentum && track->IsOn(AliESDtrack::kTPCrefit)) pt = track->GetTPCInnerParam()->Pt();
  else pt = track->Pt();
  //
  if(pt<fMinPt) accept=kFALSE;
  //
  // if vertex constraint is used, apply soft DCA cut
  if (vtx) {
    Double_t dz[2],cov[3];
    AliExternalTrackParam trc = *track;
    if (!trc.PropagateToDCA(vtx, fFitter->GetBz(), 3.0, dz, cov)) accept=kFALSE;
    else {
      if (dz[0]*dz[0]/(1e-4+cov[0])>fCutDCAXY) accept=kFALSE;
      if (dz[1]*dz[1]/(4e-4+cov[2])>fCutDCAZ)  accept=kFALSE;
    }
  }
  //
  if(accept) fHistPtAccept->Fill(pt);
  return accept;
}

//___________________________________________________________________________
Bool_t AliAnalysisTaskITSAlignQA::AcceptVertex(const AliESDVertex * vtx, const AliESDVertex * vtxSPD) {
  // vertex selection cuts
  if (!vtx || vtx->GetStatus()<1) return kFALSE;
  if (!vtxSPD || vtxSPD->GetStatus()<1) return kFALSE;
  if (vtx->GetNContributors()<fMinVtxContributors) return kFALSE;
  if (TMath::Abs(vtx->GetZ()-vtxSPD->GetZ())>0.3) return kFALSE;
  return kTRUE;
}

//___________________________________________________________________________
void AliAnalysisTaskITSAlignQA::FitAndFillSPD(Int_t iLayer, const AliTrackPointArray *array, Int_t npts,AliESDtrack * track){
  // fit track and fills histos for SPD
  fFitter->AttachPoints(array,0, npts-1); 
  Int_t iPtSPD[4],modIdSPD[4];
  Int_t nPtSPD=0;
  Double_t resGlo[3],resLoc[3];
  for(Int_t ipt=0; ipt<npts; ipt++) {
    AliTrackPoint point;
    Int_t modId;
    array->GetPoint(point,ipt);
    Int_t volId = point.GetVolumeID();
    if (volId == kVtxSensVID) continue; // this is a vertex constraint
    Int_t layerId = AliGeomManager::VolUIDToLayer(volId,modId);
    if(layerId==iLayer){
      modId+=AliITSgeomTGeo::GetModuleIndex(layerId,1,1);
      iPtSPD[nPtSPD] = ipt;
      modIdSPD[nPtSPD] = modId;
      ++nPtSPD;
      fFitter->SetCovIScale(ipt,1e-4); 
    }
  }
  if(nPtSPD>0){
    double pt = (fUseTPCMomentum && track->IsOn(AliESDtrack::kTPCrefit)) ? track->GetTPCInnerParam()->Pt() : track->Pt();
    fFitter->Fit(track->Charge(),pt,0.);
    Double_t chi2=fFitter->GetChi2NDF();
    if ( chi2<0 || chi2>1e4 ) return; // fit failed, abandon this track
    for (Int_t ip=0; ip<nPtSPD;ip++) {
      fFitter->GetResiduals(resGlo,iPtSPD[ip]);
      TGeoHMatrix *mcurr = AliITSgeomTGeo::GetMatrix(modIdSPD[ip]);
      mcurr->MasterToLocalVect(resGlo,resLoc);
      Int_t index=modIdSPD[ip];
      fHistSPDResidX[index]->Fill(pt,resLoc[0]);
      fHistSPDResidZ[index]->Fill(pt,resLoc[2]);
    }
  }    
}
//___________________________________________________________________________
void AliAnalysisTaskITSAlignQA::FitAndFillSDDrphi(const AliTrackPointArray *array, Int_t npts, AliESDtrack * track){
  // fit track and fills histos for SDD along rphi (drift coord.)
  Double_t dedx[4];
  track->GetITSdEdxSamples(dedx);

  fFitter->AttachPoints(array,0, npts-1); 
  Int_t iPtSDD[4],modIdSDD[4],modSide[4];
  Double_t xLocSDD[4],zLocSDD[4],drTime[4];
  Int_t nPtSDD=0;
  Int_t nPtSSDSPD=0;
  Double_t resGlo[3],resLoc[3];
  Float_t  posGloF[3];
  Double_t posGlo[3],posLoc[3];

  for(Int_t ipt=0; ipt<npts; ipt++) {
    AliTrackPoint point;
    Int_t modId;
    array->GetPoint(point,ipt);
    Int_t volId = point.GetVolumeID();
    if (volId == kVtxSensVID) continue; // this is a vertex constraint
    Int_t layerId = AliGeomManager::VolUIDToLayer(volId,modId);
    if(layerId==3 || layerId==4){
      drTime[nPtSDD] = point.GetDriftTime();
      modId+=AliITSgeomTGeo::GetModuleIndex(layerId,1,1);
      Int_t index=modId-kNSPDmods;
      if (fDoSDDDriftTime) {
	fHistSDDDrTimeAll[index]->Fill(drTime[nPtSDD]);
	if(point.IsExtra()) fHistSDDDrTimeExtra[index]->Fill(drTime[nPtSDD]);
	else fHistSDDDrTimeAttac[index]->Fill(drTime[nPtSDD]);
      }
      if (fDoSDDdEdxCalib) {
	Float_t dedxLay=dedx[layerId-3];
	if(dedxLay>1.) fHistSDDdEdxvsDrTime[index]->Fill(drTime[nPtSDD],dedxLay);
      }
      iPtSDD[nPtSDD] = ipt;
      modIdSDD[nPtSDD] = modId;
      modSide[nPtSDD] = point.GetClusterType()&BIT(16) ? 0:1; 
      point.GetXYZ(posGloF);
      for(Int_t icoor=0;icoor<3;icoor++) posGlo[icoor]=posGloF[icoor];
      AliITSgeomTGeo::GlobalToLocal(modId,posGlo,posLoc);
      xLocSDD[nPtSDD]=posLoc[0];
      zLocSDD[nPtSDD]=posLoc[2];
      ++nPtSDD;
      fFitter->SetCovIScale(ipt,1e-4); // scaling for inverted errors of SDD
    }else{
      ++nPtSSDSPD;
    }
  }
  if(nPtSDD>0 && nPtSSDSPD>=2){
    double pt = (fUseTPCMomentum && track->IsOn(AliESDtrack::kTPCrefit)) ? track->GetTPCInnerParam()->Pt() : track->Pt();
    fFitter->Fit(track->Charge(),pt,0.);
    Double_t chi2=fFitter->GetChi2NDF();
    if ( chi2<0 || chi2>1e4 ) return; // fit failed, abandon this track
    for (Int_t ip=0; ip<nPtSDD;ip++) {
      fFitter->GetResiduals(resGlo,iPtSDD[ip]);
      TGeoHMatrix *mcurr = AliITSgeomTGeo::GetMatrix(modIdSDD[ip]);
      mcurr->MasterToLocalVect(resGlo,resLoc);
      Int_t index=modIdSDD[ip]-kNSPDmods;
      if (fDoSDDResiduals) {
	fHistSDDResidX[index]->Fill(pt,resLoc[0]);
	fHistSDDResidXvsX[index]->Fill(xLocSDD[ip],resLoc[0]);
	fHistSDDResidXvsZ[index]->Fill(zLocSDD[ip],resLoc[0]);
      }
      //
      if (fDoSDDVDriftCalib) {
	double cf = modSide[ip] ? 1.e4:-1.e4;
	double xMeas = cf*xLocSDD[ip];            // measured coordinate in microns
	double xRes  = cf*resLoc[0];             // X residual in microns
	double xDriftTrue  = 3.5085e4 - (xMeas + xRes);   // "true" drift distance
	//
	fHProfSDDResidXvsXD[index][modSide[ip]]->Fill(xDriftTrue, xRes);
	fHProfSDDResidXvsZ[index][modSide[ip]]->Fill(zLocSDD[ip]*1e4, xRes);
	fHProfSDDDrTimevsXD[index][modSide[ip]]->Fill(xDriftTrue, drTime[ip]);
	fHProfSDDDrTimevsZ[index][modSide[ip]]->Fill(zLocSDD[ip]*1e4, drTime[ip]);      
      }
    }
  }
}
//___________________________________________________________________________
void AliAnalysisTaskITSAlignQA::FitAndFillSDDz(Int_t iLayer, const AliTrackPointArray *array, Int_t npts, AliESDtrack * track){
  // fit track and fills histos for SDD along z

  fFitter->AttachPoints(array,0, npts-1); 
  Int_t iPtSDD[4],modIdSDD[4];
  Double_t xLocSDD[4],zLocSDD[4];
  Int_t nPtSDD=0;
  Double_t resGlo[3],resLoc[3];
  Float_t  posGloF[3];
  Double_t posGlo[3],posLoc[3];
  for(Int_t ipt=0; ipt<npts; ipt++) {
    AliTrackPoint point;
    Int_t modId;
    array->GetPoint(point,ipt);
    Int_t volId = point.GetVolumeID();
    if (volId == kVtxSensVID) continue; // this is a vertex constraint
    Int_t layerId = AliGeomManager::VolUIDToLayer(volId,modId);
    if(layerId==iLayer){
      modId+=AliITSgeomTGeo::GetModuleIndex(layerId,1,1);
      iPtSDD[nPtSDD] = ipt;
      modIdSDD[nPtSDD] = modId;
      point.GetXYZ(posGloF);
      for(Int_t icoor=0;icoor<3;icoor++) posGlo[icoor]=posGloF[icoor];
      AliITSgeomTGeo::GlobalToLocal(modId,posGlo,posLoc);
      xLocSDD[nPtSDD]=posLoc[0];
      zLocSDD[nPtSDD]=posLoc[2];
      ++nPtSDD;
      fFitter->SetCovIScale(ipt,1e-4); // scaling for inverted errors of SDD
    }
  }
  if(nPtSDD>0){
    double pt = (fUseTPCMomentum && track->IsOn(AliESDtrack::kTPCrefit)) ? track->GetTPCInnerParam()->Pt() : track->Pt();
    fFitter->Fit(track->Charge(),pt,0.);
    Double_t chi2=fFitter->GetChi2NDF();
    if ( chi2<0 || chi2>1e4 ) return; // fit failed, abandon this track
    for (Int_t ip=0; ip<nPtSDD;ip++) {
      fFitter->GetResiduals(resGlo,iPtSDD[ip]);
      TGeoHMatrix *mcurr = AliITSgeomTGeo::GetMatrix(modIdSDD[ip]);
      mcurr->MasterToLocalVect(resGlo,resLoc);
      Int_t index=modIdSDD[ip]-kNSPDmods;
      fHistSDDResidZ[index]->Fill(pt,resLoc[2]);
      fHistSDDResidZvsX[index]->Fill(xLocSDD[ip],resLoc[2]);
      fHistSDDResidZvsZ[index]->Fill(zLocSDD[ip],resLoc[2]);
    }
  }
}
//___________________________________________________________________________
void AliAnalysisTaskITSAlignQA::FitAndFillSSD(Int_t iLayer, const AliTrackPointArray *array, Int_t npts,AliESDtrack * track){
  // fit track and fills histos for SSD
  fFitter->AttachPoints(array,0, npts-1); 
  Int_t iPtSSD[4],modIdSSD[4];
  Int_t nPtSSD=0;
  Double_t resGlo[3],resLoc[3];
  for(Int_t ipt=0; ipt<npts; ipt++) {
    AliTrackPoint point;
    Int_t modId;
    array->GetPoint(point,ipt);
    Int_t volId = point.GetVolumeID();
    if (volId == kVtxSensVID) continue; // this is a vertex constraint
    Int_t layerId = AliGeomManager::VolUIDToLayer(volId,modId);
    if(layerId==iLayer){
      modId+=AliITSgeomTGeo::GetModuleIndex(layerId,1,1);
      iPtSSD[nPtSSD] = ipt;
      modIdSSD[nPtSSD] = modId;
      ++nPtSSD;
      fFitter->SetCovIScale(ipt,1e-4); 
    }  
  }
  if(nPtSSD>0){
    double pt = (fUseTPCMomentum && track->IsOn(AliESDtrack::kTPCrefit)) ? track->GetTPCInnerParam()->Pt() : track->Pt();
    fFitter->Fit(track->Charge(),pt,0.);
    Double_t chi2=fFitter->GetChi2NDF();
    if ( chi2<0 || chi2>1e4 ) return; // fit failed, abandon this track
    for (Int_t ip=0; ip<nPtSSD;ip++) {
      fFitter->GetResiduals(resGlo,iPtSSD[ip]);
      TGeoHMatrix *mcurr = AliITSgeomTGeo::GetMatrix(modIdSSD[ip]);
      mcurr->MasterToLocalVect(resGlo,resLoc);
      Int_t index=modIdSSD[ip]-kNSPDmods-kNSDDmods;
      fHistSSDResidX[index]->Fill(pt,resLoc[0]);
      fHistSSDResidZ[index]->Fill(pt,resLoc[2]);
    }
  }
}
//______________________________________________________________________________
void AliAnalysisTaskITSAlignQA::Terminate(Option_t */*option*/)
{
  // Terminate analysis
  fOutput = dynamic_cast<TList*> (GetOutputData(1));
  if (!fOutput) {     
    printf("ERROR: fOutput not available\n");
    return;
  }

  fHistNEvents = dynamic_cast<TH1F*>(fOutput->FindObject("hNEvents"));
  if(fHistNEvents){
    AliInfo(Form("Number of analyzed events = %d, %d tracks accepted",
		 (Int_t)fHistNEvents->GetBinContent(kEvAcc+1),(Int_t)fHistNEvents->GetBinContent(kNTracks+1)));
  }else{
    printf("Warning: pointer to fHistNEvents is NULL\n");
  }
  //
  if (fDoFillTPTree) CreateUserInfo();
  //
  return;
}


//___________________________________________________________________________
void AliAnalysisTaskITSAlignQA::LoadGeometryFromOCDB(){
  //method to get the gGeomanager
  // it is called at the CreatedOutputObject stage
  // to comply with the CAF environment
  AliInfo("Loading geometry");

  AliCDBManager *man = AliCDBManager::Instance();
  man->SetDefaultStorage(fOCDBLocation.Data());
  man->SetRun(fRunNb);
  AliCDBEntry* obj = man->Get(AliCDBPath("GRP", "Geometry", "Data"));
  if(obj){
    AliGeomManager::SetGeometry((TGeoManager*)obj->GetObject());
    AliGeomManager::GetNalignable("ITS");
    AliGeomManager::ApplyAlignObjsFromCDB("ITS");
  }
  else AliFatal("Geometry object not found in OCDB");
}


//______________________________________________________________________________________
AliTrackPointArray* AliAnalysisTaskITSAlignQA::PrepareTrack(const AliTrackPointArray* inp, const AliESDVertex* vtx)
{
  // Extract from the global TrackPointArray the ITS part and optionally add vertex as the last measured point
  //
  int npts = inp->GetNPoints();
  int modID=0,nptITS = 0;
  int itsRefs[24];
  const UShort_t *vids = inp->GetVolumeID();
  for(int ipt=0; ipt<npts; ipt++) { // count ITS points
    if (vids[ipt]<=0) continue;
    int layerId = AliGeomManager::VolUIDToLayer(vids[ipt],modID);
    if(layerId<1 || layerId>6) continue;
    itsRefs[nptITS++] = ipt;
  }
  //
  AliTrackPointArray *trackCopy = new AliTrackPointArray(nptITS + (vtx ? 1:0)); // reserve extra space if vertex provided
  AliTrackPoint point;
  for(int ipt=0; ipt<nptITS; ipt++) {
    inp->GetPoint(point,itsRefs[ipt]);
    trackCopy->AddPoint(ipt,&point);
  }
  //
  if (vtx) {
    PrepareVertexConstraint(vtx,point);
    trackCopy->AddPoint(nptITS,&point); // add vertex constraint as a last point
  }
  return trackCopy;
}

//_______________________________________________________________________________________
void AliAnalysisTaskITSAlignQA::PrepareVertexConstraint(const AliESDVertex* vtx, AliTrackPoint &point)
{
  // convert vertex to measured point with dummy VID
  if (!vtx) return;
  //
  double cmat[6];
  float cmatF[6];
  point.SetVolumeID(kVtxSensVID);
  //
  vtx->GetCovMatrix(cmat);
  cmatF[0] = cmat[0]; // xx
  cmatF[1] = cmat[1]; // xy
  cmatF[2] = cmat[3]; // xz
  cmatF[3] = cmat[2]; // yy
  cmatF[4] = cmat[4]; // yz
  cmatF[5] = cmat[5]; // zz
  point.SetXYZ(vtx->GetX(),vtx->GetY(),vtx->GetZ(), cmatF);
}


//_______________________________________________________________________________________
Bool_t AliAnalysisTaskITSAlignQA::AcceptCentrality(const AliESDEvent *esd) const
{
  // check if events is in the required multiplicity range
  //
  const AliMultiplicity *alimult = esd->GetMultiplicity();
  Int_t nclsSPDouter=0;
  if(alimult) nclsSPDouter = alimult->GetNumberOfITSClusters(1);
  if(nclsSPDouter<fMinMult || nclsSPDouter>fMaxMult) return kFALSE;
  //
  return kTRUE;
}

//_______________________________________________________________________________________
void AliAnalysisTaskITSAlignQA::CreateUserInfo()
{
  // if needed, set user info of the output tree
  if (!fTPTree) {
    AliError("TrackPoints summary tree does not exist"); 
    return;
  }
  TList* uInfo = fTPTree->GetUserInfo();
  TMap  *cdbMapCopy  = (TMap*)uInfo->FindObject("cdbMap");
  TList *cdbListCopy = (TList*)uInfo->FindObject("cdbList"); 
  TList *bzList      = (TList*)uInfo->FindObject("BzkGauss"); 
  if (cdbMapCopy && cdbListCopy && bzList) return; //already done
  //
  const TMap *cdbMap = AliCDBManager::Instance()->GetStorageMap();	 
  const TList *cdbList = AliCDBManager::Instance()->GetRetrievedIds();	 
  //
  cdbMapCopy = new TMap(cdbMap->GetEntries());	 
  cdbMapCopy->SetOwner(1);	 
  cdbMapCopy->SetName("cdbMap");	 
  TIter iter(cdbMap->GetTable());	 
  //
  TPair* pair = 0;	 
  while((pair = dynamic_cast<TPair*> (iter.Next()))){	 
    TObjString* keyStr = dynamic_cast<TObjString*> (pair->Key());	 
    TObjString* valStr = dynamic_cast<TObjString*> (pair->Value());
    if (keyStr && valStr) {
      cdbMapCopy->Add(new TObjString(keyStr->GetName()), new TObjString(valStr->GetName()));	 
      AliInfo(Form("Add %s : %s to cdbMap of ITSTPUserInfo",keyStr->GetName(),valStr->GetName()));
    }
  }	 
  //
  cdbListCopy = new TList();	 
  cdbListCopy->SetOwner(1);	 
  cdbListCopy->SetName("cdbList");	 
  // 
  TIter iter2(cdbList);	  	 
  AliCDBId* id=0;
  while((id = dynamic_cast<AliCDBId*> (iter2.Next()))){	 
    cdbListCopy->Add(new TObjString(id->ToString().Data()));	 
    AliInfo(Form("Add %s to cdbList of ITSTPUserInfo",id->ToString().Data()));
  }	 
  // 
  uInfo->Add(cdbMapCopy);	 
  uInfo->Add(cdbListCopy);  
  //
  AliMagF *fld = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
  Double_t bz = fld ? fld->SolenoidField() : 0;
  TString bzString; bzString+=bz;
  TObjString *bzObjString = new TObjString(bzString);
  bzList = new TList();	 
  bzList->SetOwner(1);	 
  bzList->SetName("BzkGauss");	 
  bzList->Add(bzObjString);
  uInfo->Add(bzList);
  //
}

//_______________________________________________________________________________________
void AliAnalysisTaskITSAlignQA::CopyUserInfo()
{
  // if available, copy the UserInfo from the ESDtree to the output tree
  static Bool_t done = kFALSE;
  if (done) return;
  if (!fTPTree) {
    AliError("TrackPoints summary tree does not exist"); 
    return;
  }
  AliESDInputHandler *handler = (AliESDInputHandler*)AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler();
  TTree* esdTree = 0;
  if (!handler || !(esdTree=handler->GetTree())) return;
  if (esdTree->InheritsFrom(TChain::Class())) esdTree = esdTree->GetTree();
  TList* uInfoSrc = esdTree->GetUserInfo();
  const TMap  *cdbMapSrc  = (TMap*)uInfoSrc->FindObject("cdbMap");
  const TList *cdbListSrc = (TList*)uInfoSrc->FindObject("cdbList"); 
  if (!cdbMapSrc || !cdbListSrc) return;
  //
  AliInfo("Create ITSTPUserInfo from esdTree");
  TList* uInfoDst = fTPTree->GetUserInfo();
  //
  TMap *cdbMapCopy = new TMap(cdbMapSrc->GetEntries());	 
  cdbMapCopy->SetOwner(1);	 
  cdbMapCopy->SetName("cdbMap");	 
  TIter iter(cdbMapSrc->GetTable());	 
  TPair* pair = 0;	 
  while((pair = dynamic_cast<TPair*> (iter.Next()))){	 
    TObjString* keyStr = dynamic_cast<TObjString*> (pair->Key());	 
    TObjString* valStr = dynamic_cast<TObjString*> (pair->Value());
    if (keyStr && valStr) {
      cdbMapCopy->Add(new TObjString(keyStr->GetName()), new TObjString(valStr->GetName()));	 
      AliInfo(Form("Add %s : %s to cdbMap of ITSTPUserInfo",keyStr->GetName(),valStr->GetName()));
    }
  }	 
  //  
  TList *cdbListCopy = new TList();	 
  cdbListCopy->SetOwner(1);	 
  cdbListCopy->SetName("cdbList");	 
  // 
  TIter iter2(cdbListSrc);	  	 
  TObjString* id=0;
  while((id = dynamic_cast<TObjString*> (iter2.Next()))){	 
    cdbListCopy->Add(new TObjString(*id));	 
    AliInfo(Form("Add %s to cdbList of ITSTPUserInfo",id->GetName()));
  }	 
  // 
  uInfoDst->Add(cdbMapCopy);	 
  uInfoDst->Add(cdbListCopy);  
  //
  AliMagF *fld = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
  Double_t bz = fld ? fld->SolenoidField() : 0;
  TString bzString; bzString+=bz;
  TObjString *bzObjString = new TObjString(bzString);
  TList *bzList = new TList();	 
  bzList->SetOwner(1);	 
  bzList->SetName("BzkGauss");	 
  bzList->Add(bzObjString);
  uInfoDst->Add(bzList);
  //
  done = kTRUE;
}
 AliAnalysisTaskITSAlignQA.cxx:1
 AliAnalysisTaskITSAlignQA.cxx:2
 AliAnalysisTaskITSAlignQA.cxx:3
 AliAnalysisTaskITSAlignQA.cxx:4
 AliAnalysisTaskITSAlignQA.cxx:5
 AliAnalysisTaskITSAlignQA.cxx:6
 AliAnalysisTaskITSAlignQA.cxx:7
 AliAnalysisTaskITSAlignQA.cxx:8
 AliAnalysisTaskITSAlignQA.cxx:9
 AliAnalysisTaskITSAlignQA.cxx:10
 AliAnalysisTaskITSAlignQA.cxx:11
 AliAnalysisTaskITSAlignQA.cxx:12
 AliAnalysisTaskITSAlignQA.cxx:13
 AliAnalysisTaskITSAlignQA.cxx:14
 AliAnalysisTaskITSAlignQA.cxx:15
 AliAnalysisTaskITSAlignQA.cxx:16
 AliAnalysisTaskITSAlignQA.cxx:17
 AliAnalysisTaskITSAlignQA.cxx:18
 AliAnalysisTaskITSAlignQA.cxx:19
 AliAnalysisTaskITSAlignQA.cxx:20
 AliAnalysisTaskITSAlignQA.cxx:21
 AliAnalysisTaskITSAlignQA.cxx:22
 AliAnalysisTaskITSAlignQA.cxx:23
 AliAnalysisTaskITSAlignQA.cxx:24
 AliAnalysisTaskITSAlignQA.cxx:25
 AliAnalysisTaskITSAlignQA.cxx:26
 AliAnalysisTaskITSAlignQA.cxx:27
 AliAnalysisTaskITSAlignQA.cxx:28
 AliAnalysisTaskITSAlignQA.cxx:29
 AliAnalysisTaskITSAlignQA.cxx:30
 AliAnalysisTaskITSAlignQA.cxx:31
 AliAnalysisTaskITSAlignQA.cxx:32
 AliAnalysisTaskITSAlignQA.cxx:33
 AliAnalysisTaskITSAlignQA.cxx:34
 AliAnalysisTaskITSAlignQA.cxx:35
 AliAnalysisTaskITSAlignQA.cxx:36
 AliAnalysisTaskITSAlignQA.cxx:37
 AliAnalysisTaskITSAlignQA.cxx:38
 AliAnalysisTaskITSAlignQA.cxx:39
 AliAnalysisTaskITSAlignQA.cxx:40
 AliAnalysisTaskITSAlignQA.cxx:41
 AliAnalysisTaskITSAlignQA.cxx:42
 AliAnalysisTaskITSAlignQA.cxx:43
 AliAnalysisTaskITSAlignQA.cxx:44
 AliAnalysisTaskITSAlignQA.cxx:45
 AliAnalysisTaskITSAlignQA.cxx:46
 AliAnalysisTaskITSAlignQA.cxx:47
 AliAnalysisTaskITSAlignQA.cxx:48
 AliAnalysisTaskITSAlignQA.cxx:49
 AliAnalysisTaskITSAlignQA.cxx:50
 AliAnalysisTaskITSAlignQA.cxx:51
 AliAnalysisTaskITSAlignQA.cxx:52
 AliAnalysisTaskITSAlignQA.cxx:53
 AliAnalysisTaskITSAlignQA.cxx:54
 AliAnalysisTaskITSAlignQA.cxx:55
 AliAnalysisTaskITSAlignQA.cxx:56
 AliAnalysisTaskITSAlignQA.cxx:57
 AliAnalysisTaskITSAlignQA.cxx:58
 AliAnalysisTaskITSAlignQA.cxx:59
 AliAnalysisTaskITSAlignQA.cxx:60
 AliAnalysisTaskITSAlignQA.cxx:61
 AliAnalysisTaskITSAlignQA.cxx:62
 AliAnalysisTaskITSAlignQA.cxx:63
 AliAnalysisTaskITSAlignQA.cxx:64
 AliAnalysisTaskITSAlignQA.cxx:65
 AliAnalysisTaskITSAlignQA.cxx:66
 AliAnalysisTaskITSAlignQA.cxx:67
 AliAnalysisTaskITSAlignQA.cxx:68
 AliAnalysisTaskITSAlignQA.cxx:69
 AliAnalysisTaskITSAlignQA.cxx:70
 AliAnalysisTaskITSAlignQA.cxx:71
 AliAnalysisTaskITSAlignQA.cxx:72
 AliAnalysisTaskITSAlignQA.cxx:73
 AliAnalysisTaskITSAlignQA.cxx:74
 AliAnalysisTaskITSAlignQA.cxx:75
 AliAnalysisTaskITSAlignQA.cxx:76
 AliAnalysisTaskITSAlignQA.cxx:77
 AliAnalysisTaskITSAlignQA.cxx:78
 AliAnalysisTaskITSAlignQA.cxx:79
 AliAnalysisTaskITSAlignQA.cxx:80
 AliAnalysisTaskITSAlignQA.cxx:81
 AliAnalysisTaskITSAlignQA.cxx:82
 AliAnalysisTaskITSAlignQA.cxx:83
 AliAnalysisTaskITSAlignQA.cxx:84
 AliAnalysisTaskITSAlignQA.cxx:85
 AliAnalysisTaskITSAlignQA.cxx:86
 AliAnalysisTaskITSAlignQA.cxx:87
 AliAnalysisTaskITSAlignQA.cxx:88
 AliAnalysisTaskITSAlignQA.cxx:89
 AliAnalysisTaskITSAlignQA.cxx:90
 AliAnalysisTaskITSAlignQA.cxx:91
 AliAnalysisTaskITSAlignQA.cxx:92
 AliAnalysisTaskITSAlignQA.cxx:93
 AliAnalysisTaskITSAlignQA.cxx:94
 AliAnalysisTaskITSAlignQA.cxx:95
 AliAnalysisTaskITSAlignQA.cxx:96
 AliAnalysisTaskITSAlignQA.cxx:97
 AliAnalysisTaskITSAlignQA.cxx:98
 AliAnalysisTaskITSAlignQA.cxx:99
 AliAnalysisTaskITSAlignQA.cxx:100
 AliAnalysisTaskITSAlignQA.cxx:101
 AliAnalysisTaskITSAlignQA.cxx:102
 AliAnalysisTaskITSAlignQA.cxx:103
 AliAnalysisTaskITSAlignQA.cxx:104
 AliAnalysisTaskITSAlignQA.cxx:105
 AliAnalysisTaskITSAlignQA.cxx:106
 AliAnalysisTaskITSAlignQA.cxx:107
 AliAnalysisTaskITSAlignQA.cxx:108
 AliAnalysisTaskITSAlignQA.cxx:109
 AliAnalysisTaskITSAlignQA.cxx:110
 AliAnalysisTaskITSAlignQA.cxx:111
 AliAnalysisTaskITSAlignQA.cxx:112
 AliAnalysisTaskITSAlignQA.cxx:113
 AliAnalysisTaskITSAlignQA.cxx:114
 AliAnalysisTaskITSAlignQA.cxx:115
 AliAnalysisTaskITSAlignQA.cxx:116
 AliAnalysisTaskITSAlignQA.cxx:117
 AliAnalysisTaskITSAlignQA.cxx:118
 AliAnalysisTaskITSAlignQA.cxx:119
 AliAnalysisTaskITSAlignQA.cxx:120
 AliAnalysisTaskITSAlignQA.cxx:121
 AliAnalysisTaskITSAlignQA.cxx:122
 AliAnalysisTaskITSAlignQA.cxx:123
 AliAnalysisTaskITSAlignQA.cxx:124
 AliAnalysisTaskITSAlignQA.cxx:125
 AliAnalysisTaskITSAlignQA.cxx:126
 AliAnalysisTaskITSAlignQA.cxx:127
 AliAnalysisTaskITSAlignQA.cxx:128
 AliAnalysisTaskITSAlignQA.cxx:129
 AliAnalysisTaskITSAlignQA.cxx:130
 AliAnalysisTaskITSAlignQA.cxx:131
 AliAnalysisTaskITSAlignQA.cxx:132
 AliAnalysisTaskITSAlignQA.cxx:133
 AliAnalysisTaskITSAlignQA.cxx:134
 AliAnalysisTaskITSAlignQA.cxx:135
 AliAnalysisTaskITSAlignQA.cxx:136
 AliAnalysisTaskITSAlignQA.cxx:137
 AliAnalysisTaskITSAlignQA.cxx:138
 AliAnalysisTaskITSAlignQA.cxx:139
 AliAnalysisTaskITSAlignQA.cxx:140
 AliAnalysisTaskITSAlignQA.cxx:141
 AliAnalysisTaskITSAlignQA.cxx:142
 AliAnalysisTaskITSAlignQA.cxx:143
 AliAnalysisTaskITSAlignQA.cxx:144
 AliAnalysisTaskITSAlignQA.cxx:145
 AliAnalysisTaskITSAlignQA.cxx:146
 AliAnalysisTaskITSAlignQA.cxx:147
 AliAnalysisTaskITSAlignQA.cxx:148
 AliAnalysisTaskITSAlignQA.cxx:149
 AliAnalysisTaskITSAlignQA.cxx:150
 AliAnalysisTaskITSAlignQA.cxx:151
 AliAnalysisTaskITSAlignQA.cxx:152
 AliAnalysisTaskITSAlignQA.cxx:153
 AliAnalysisTaskITSAlignQA.cxx:154
 AliAnalysisTaskITSAlignQA.cxx:155
 AliAnalysisTaskITSAlignQA.cxx:156
 AliAnalysisTaskITSAlignQA.cxx:157
 AliAnalysisTaskITSAlignQA.cxx:158
 AliAnalysisTaskITSAlignQA.cxx:159
 AliAnalysisTaskITSAlignQA.cxx:160
 AliAnalysisTaskITSAlignQA.cxx:161
 AliAnalysisTaskITSAlignQA.cxx:162
 AliAnalysisTaskITSAlignQA.cxx:163
 AliAnalysisTaskITSAlignQA.cxx:164
 AliAnalysisTaskITSAlignQA.cxx:165
 AliAnalysisTaskITSAlignQA.cxx:166
 AliAnalysisTaskITSAlignQA.cxx:167
 AliAnalysisTaskITSAlignQA.cxx:168
 AliAnalysisTaskITSAlignQA.cxx:169
 AliAnalysisTaskITSAlignQA.cxx:170
 AliAnalysisTaskITSAlignQA.cxx:171
 AliAnalysisTaskITSAlignQA.cxx:172
 AliAnalysisTaskITSAlignQA.cxx:173
 AliAnalysisTaskITSAlignQA.cxx:174
 AliAnalysisTaskITSAlignQA.cxx:175
 AliAnalysisTaskITSAlignQA.cxx:176
 AliAnalysisTaskITSAlignQA.cxx:177
 AliAnalysisTaskITSAlignQA.cxx:178
 AliAnalysisTaskITSAlignQA.cxx:179
 AliAnalysisTaskITSAlignQA.cxx:180
 AliAnalysisTaskITSAlignQA.cxx:181
 AliAnalysisTaskITSAlignQA.cxx:182
 AliAnalysisTaskITSAlignQA.cxx:183
 AliAnalysisTaskITSAlignQA.cxx:184
 AliAnalysisTaskITSAlignQA.cxx:185
 AliAnalysisTaskITSAlignQA.cxx:186
 AliAnalysisTaskITSAlignQA.cxx:187
 AliAnalysisTaskITSAlignQA.cxx:188
 AliAnalysisTaskITSAlignQA.cxx:189
 AliAnalysisTaskITSAlignQA.cxx:190
 AliAnalysisTaskITSAlignQA.cxx:191
 AliAnalysisTaskITSAlignQA.cxx:192
 AliAnalysisTaskITSAlignQA.cxx:193
 AliAnalysisTaskITSAlignQA.cxx:194
 AliAnalysisTaskITSAlignQA.cxx:195
 AliAnalysisTaskITSAlignQA.cxx:196
 AliAnalysisTaskITSAlignQA.cxx:197
 AliAnalysisTaskITSAlignQA.cxx:198
 AliAnalysisTaskITSAlignQA.cxx:199
 AliAnalysisTaskITSAlignQA.cxx:200
 AliAnalysisTaskITSAlignQA.cxx:201
 AliAnalysisTaskITSAlignQA.cxx:202
 AliAnalysisTaskITSAlignQA.cxx:203
 AliAnalysisTaskITSAlignQA.cxx:204
 AliAnalysisTaskITSAlignQA.cxx:205
 AliAnalysisTaskITSAlignQA.cxx:206
 AliAnalysisTaskITSAlignQA.cxx:207
 AliAnalysisTaskITSAlignQA.cxx:208
 AliAnalysisTaskITSAlignQA.cxx:209
 AliAnalysisTaskITSAlignQA.cxx:210
 AliAnalysisTaskITSAlignQA.cxx:211
 AliAnalysisTaskITSAlignQA.cxx:212
 AliAnalysisTaskITSAlignQA.cxx:213
 AliAnalysisTaskITSAlignQA.cxx:214
 AliAnalysisTaskITSAlignQA.cxx:215
 AliAnalysisTaskITSAlignQA.cxx:216
 AliAnalysisTaskITSAlignQA.cxx:217
 AliAnalysisTaskITSAlignQA.cxx:218
 AliAnalysisTaskITSAlignQA.cxx:219
 AliAnalysisTaskITSAlignQA.cxx:220
 AliAnalysisTaskITSAlignQA.cxx:221
 AliAnalysisTaskITSAlignQA.cxx:222
 AliAnalysisTaskITSAlignQA.cxx:223
 AliAnalysisTaskITSAlignQA.cxx:224
 AliAnalysisTaskITSAlignQA.cxx:225
 AliAnalysisTaskITSAlignQA.cxx:226
 AliAnalysisTaskITSAlignQA.cxx:227
 AliAnalysisTaskITSAlignQA.cxx:228
 AliAnalysisTaskITSAlignQA.cxx:229
 AliAnalysisTaskITSAlignQA.cxx:230
 AliAnalysisTaskITSAlignQA.cxx:231
 AliAnalysisTaskITSAlignQA.cxx:232
 AliAnalysisTaskITSAlignQA.cxx:233
 AliAnalysisTaskITSAlignQA.cxx:234
 AliAnalysisTaskITSAlignQA.cxx:235
 AliAnalysisTaskITSAlignQA.cxx:236
 AliAnalysisTaskITSAlignQA.cxx:237
 AliAnalysisTaskITSAlignQA.cxx:238
 AliAnalysisTaskITSAlignQA.cxx:239
 AliAnalysisTaskITSAlignQA.cxx:240
 AliAnalysisTaskITSAlignQA.cxx:241
 AliAnalysisTaskITSAlignQA.cxx:242
 AliAnalysisTaskITSAlignQA.cxx:243
 AliAnalysisTaskITSAlignQA.cxx:244
 AliAnalysisTaskITSAlignQA.cxx:245
 AliAnalysisTaskITSAlignQA.cxx:246
 AliAnalysisTaskITSAlignQA.cxx:247
 AliAnalysisTaskITSAlignQA.cxx:248
 AliAnalysisTaskITSAlignQA.cxx:249
 AliAnalysisTaskITSAlignQA.cxx:250
 AliAnalysisTaskITSAlignQA.cxx:251
 AliAnalysisTaskITSAlignQA.cxx:252
 AliAnalysisTaskITSAlignQA.cxx:253
 AliAnalysisTaskITSAlignQA.cxx:254
 AliAnalysisTaskITSAlignQA.cxx:255
 AliAnalysisTaskITSAlignQA.cxx:256
 AliAnalysisTaskITSAlignQA.cxx:257
 AliAnalysisTaskITSAlignQA.cxx:258
 AliAnalysisTaskITSAlignQA.cxx:259
 AliAnalysisTaskITSAlignQA.cxx:260
 AliAnalysisTaskITSAlignQA.cxx:261
 AliAnalysisTaskITSAlignQA.cxx:262
 AliAnalysisTaskITSAlignQA.cxx:263
 AliAnalysisTaskITSAlignQA.cxx:264
 AliAnalysisTaskITSAlignQA.cxx:265
 AliAnalysisTaskITSAlignQA.cxx:266
 AliAnalysisTaskITSAlignQA.cxx:267
 AliAnalysisTaskITSAlignQA.cxx:268
 AliAnalysisTaskITSAlignQA.cxx:269
 AliAnalysisTaskITSAlignQA.cxx:270
 AliAnalysisTaskITSAlignQA.cxx:271
 AliAnalysisTaskITSAlignQA.cxx:272
 AliAnalysisTaskITSAlignQA.cxx:273
 AliAnalysisTaskITSAlignQA.cxx:274
 AliAnalysisTaskITSAlignQA.cxx:275
 AliAnalysisTaskITSAlignQA.cxx:276
 AliAnalysisTaskITSAlignQA.cxx:277
 AliAnalysisTaskITSAlignQA.cxx:278
 AliAnalysisTaskITSAlignQA.cxx:279
 AliAnalysisTaskITSAlignQA.cxx:280
 AliAnalysisTaskITSAlignQA.cxx:281
 AliAnalysisTaskITSAlignQA.cxx:282
 AliAnalysisTaskITSAlignQA.cxx:283
 AliAnalysisTaskITSAlignQA.cxx:284
 AliAnalysisTaskITSAlignQA.cxx:285
 AliAnalysisTaskITSAlignQA.cxx:286
 AliAnalysisTaskITSAlignQA.cxx:287
 AliAnalysisTaskITSAlignQA.cxx:288
 AliAnalysisTaskITSAlignQA.cxx:289
 AliAnalysisTaskITSAlignQA.cxx:290
 AliAnalysisTaskITSAlignQA.cxx:291
 AliAnalysisTaskITSAlignQA.cxx:292
 AliAnalysisTaskITSAlignQA.cxx:293
 AliAnalysisTaskITSAlignQA.cxx:294
 AliAnalysisTaskITSAlignQA.cxx:295
 AliAnalysisTaskITSAlignQA.cxx:296
 AliAnalysisTaskITSAlignQA.cxx:297
 AliAnalysisTaskITSAlignQA.cxx:298
 AliAnalysisTaskITSAlignQA.cxx:299
 AliAnalysisTaskITSAlignQA.cxx:300
 AliAnalysisTaskITSAlignQA.cxx:301
 AliAnalysisTaskITSAlignQA.cxx:302
 AliAnalysisTaskITSAlignQA.cxx:303
 AliAnalysisTaskITSAlignQA.cxx:304
 AliAnalysisTaskITSAlignQA.cxx:305
 AliAnalysisTaskITSAlignQA.cxx:306
 AliAnalysisTaskITSAlignQA.cxx:307
 AliAnalysisTaskITSAlignQA.cxx:308
 AliAnalysisTaskITSAlignQA.cxx:309
 AliAnalysisTaskITSAlignQA.cxx:310
 AliAnalysisTaskITSAlignQA.cxx:311
 AliAnalysisTaskITSAlignQA.cxx:312
 AliAnalysisTaskITSAlignQA.cxx:313
 AliAnalysisTaskITSAlignQA.cxx:314
 AliAnalysisTaskITSAlignQA.cxx:315
 AliAnalysisTaskITSAlignQA.cxx:316
 AliAnalysisTaskITSAlignQA.cxx:317
 AliAnalysisTaskITSAlignQA.cxx:318
 AliAnalysisTaskITSAlignQA.cxx:319
 AliAnalysisTaskITSAlignQA.cxx:320
 AliAnalysisTaskITSAlignQA.cxx:321
 AliAnalysisTaskITSAlignQA.cxx:322
 AliAnalysisTaskITSAlignQA.cxx:323
 AliAnalysisTaskITSAlignQA.cxx:324
 AliAnalysisTaskITSAlignQA.cxx:325
 AliAnalysisTaskITSAlignQA.cxx:326
 AliAnalysisTaskITSAlignQA.cxx:327
 AliAnalysisTaskITSAlignQA.cxx:328
 AliAnalysisTaskITSAlignQA.cxx:329
 AliAnalysisTaskITSAlignQA.cxx:330
 AliAnalysisTaskITSAlignQA.cxx:331
 AliAnalysisTaskITSAlignQA.cxx:332
 AliAnalysisTaskITSAlignQA.cxx:333
 AliAnalysisTaskITSAlignQA.cxx:334
 AliAnalysisTaskITSAlignQA.cxx:335
 AliAnalysisTaskITSAlignQA.cxx:336
 AliAnalysisTaskITSAlignQA.cxx:337
 AliAnalysisTaskITSAlignQA.cxx:338
 AliAnalysisTaskITSAlignQA.cxx:339
 AliAnalysisTaskITSAlignQA.cxx:340
 AliAnalysisTaskITSAlignQA.cxx:341
 AliAnalysisTaskITSAlignQA.cxx:342
 AliAnalysisTaskITSAlignQA.cxx:343
 AliAnalysisTaskITSAlignQA.cxx:344
 AliAnalysisTaskITSAlignQA.cxx:345
 AliAnalysisTaskITSAlignQA.cxx:346
 AliAnalysisTaskITSAlignQA.cxx:347
 AliAnalysisTaskITSAlignQA.cxx:348
 AliAnalysisTaskITSAlignQA.cxx:349
 AliAnalysisTaskITSAlignQA.cxx:350
 AliAnalysisTaskITSAlignQA.cxx:351
 AliAnalysisTaskITSAlignQA.cxx:352
 AliAnalysisTaskITSAlignQA.cxx:353
 AliAnalysisTaskITSAlignQA.cxx:354
 AliAnalysisTaskITSAlignQA.cxx:355
 AliAnalysisTaskITSAlignQA.cxx:356
 AliAnalysisTaskITSAlignQA.cxx:357
 AliAnalysisTaskITSAlignQA.cxx:358
 AliAnalysisTaskITSAlignQA.cxx:359
 AliAnalysisTaskITSAlignQA.cxx:360
 AliAnalysisTaskITSAlignQA.cxx:361
 AliAnalysisTaskITSAlignQA.cxx:362
 AliAnalysisTaskITSAlignQA.cxx:363
 AliAnalysisTaskITSAlignQA.cxx:364
 AliAnalysisTaskITSAlignQA.cxx:365
 AliAnalysisTaskITSAlignQA.cxx:366
 AliAnalysisTaskITSAlignQA.cxx:367
 AliAnalysisTaskITSAlignQA.cxx:368
 AliAnalysisTaskITSAlignQA.cxx:369
 AliAnalysisTaskITSAlignQA.cxx:370
 AliAnalysisTaskITSAlignQA.cxx:371
 AliAnalysisTaskITSAlignQA.cxx:372
 AliAnalysisTaskITSAlignQA.cxx:373
 AliAnalysisTaskITSAlignQA.cxx:374
 AliAnalysisTaskITSAlignQA.cxx:375
 AliAnalysisTaskITSAlignQA.cxx:376
 AliAnalysisTaskITSAlignQA.cxx:377
 AliAnalysisTaskITSAlignQA.cxx:378
 AliAnalysisTaskITSAlignQA.cxx:379
 AliAnalysisTaskITSAlignQA.cxx:380
 AliAnalysisTaskITSAlignQA.cxx:381
 AliAnalysisTaskITSAlignQA.cxx:382
 AliAnalysisTaskITSAlignQA.cxx:383
 AliAnalysisTaskITSAlignQA.cxx:384
 AliAnalysisTaskITSAlignQA.cxx:385
 AliAnalysisTaskITSAlignQA.cxx:386
 AliAnalysisTaskITSAlignQA.cxx:387
 AliAnalysisTaskITSAlignQA.cxx:388
 AliAnalysisTaskITSAlignQA.cxx:389
 AliAnalysisTaskITSAlignQA.cxx:390
 AliAnalysisTaskITSAlignQA.cxx:391
 AliAnalysisTaskITSAlignQA.cxx:392
 AliAnalysisTaskITSAlignQA.cxx:393
 AliAnalysisTaskITSAlignQA.cxx:394
 AliAnalysisTaskITSAlignQA.cxx:395
 AliAnalysisTaskITSAlignQA.cxx:396
 AliAnalysisTaskITSAlignQA.cxx:397
 AliAnalysisTaskITSAlignQA.cxx:398
 AliAnalysisTaskITSAlignQA.cxx:399
 AliAnalysisTaskITSAlignQA.cxx:400
 AliAnalysisTaskITSAlignQA.cxx:401
 AliAnalysisTaskITSAlignQA.cxx:402
 AliAnalysisTaskITSAlignQA.cxx:403
 AliAnalysisTaskITSAlignQA.cxx:404
 AliAnalysisTaskITSAlignQA.cxx:405
 AliAnalysisTaskITSAlignQA.cxx:406
 AliAnalysisTaskITSAlignQA.cxx:407
 AliAnalysisTaskITSAlignQA.cxx:408
 AliAnalysisTaskITSAlignQA.cxx:409
 AliAnalysisTaskITSAlignQA.cxx:410
 AliAnalysisTaskITSAlignQA.cxx:411
 AliAnalysisTaskITSAlignQA.cxx:412
 AliAnalysisTaskITSAlignQA.cxx:413
 AliAnalysisTaskITSAlignQA.cxx:414
 AliAnalysisTaskITSAlignQA.cxx:415
 AliAnalysisTaskITSAlignQA.cxx:416
 AliAnalysisTaskITSAlignQA.cxx:417
 AliAnalysisTaskITSAlignQA.cxx:418
 AliAnalysisTaskITSAlignQA.cxx:419
 AliAnalysisTaskITSAlignQA.cxx:420
 AliAnalysisTaskITSAlignQA.cxx:421
 AliAnalysisTaskITSAlignQA.cxx:422
 AliAnalysisTaskITSAlignQA.cxx:423
 AliAnalysisTaskITSAlignQA.cxx:424
 AliAnalysisTaskITSAlignQA.cxx:425
 AliAnalysisTaskITSAlignQA.cxx:426
 AliAnalysisTaskITSAlignQA.cxx:427
 AliAnalysisTaskITSAlignQA.cxx:428
 AliAnalysisTaskITSAlignQA.cxx:429
 AliAnalysisTaskITSAlignQA.cxx:430
 AliAnalysisTaskITSAlignQA.cxx:431
 AliAnalysisTaskITSAlignQA.cxx:432
 AliAnalysisTaskITSAlignQA.cxx:433
 AliAnalysisTaskITSAlignQA.cxx:434
 AliAnalysisTaskITSAlignQA.cxx:435
 AliAnalysisTaskITSAlignQA.cxx:436
 AliAnalysisTaskITSAlignQA.cxx:437
 AliAnalysisTaskITSAlignQA.cxx:438
 AliAnalysisTaskITSAlignQA.cxx:439
 AliAnalysisTaskITSAlignQA.cxx:440
 AliAnalysisTaskITSAlignQA.cxx:441
 AliAnalysisTaskITSAlignQA.cxx:442
 AliAnalysisTaskITSAlignQA.cxx:443
 AliAnalysisTaskITSAlignQA.cxx:444
 AliAnalysisTaskITSAlignQA.cxx:445
 AliAnalysisTaskITSAlignQA.cxx:446
 AliAnalysisTaskITSAlignQA.cxx:447
 AliAnalysisTaskITSAlignQA.cxx:448
 AliAnalysisTaskITSAlignQA.cxx:449
 AliAnalysisTaskITSAlignQA.cxx:450
 AliAnalysisTaskITSAlignQA.cxx:451
 AliAnalysisTaskITSAlignQA.cxx:452
 AliAnalysisTaskITSAlignQA.cxx:453
 AliAnalysisTaskITSAlignQA.cxx:454
 AliAnalysisTaskITSAlignQA.cxx:455
 AliAnalysisTaskITSAlignQA.cxx:456
 AliAnalysisTaskITSAlignQA.cxx:457
 AliAnalysisTaskITSAlignQA.cxx:458
 AliAnalysisTaskITSAlignQA.cxx:459
 AliAnalysisTaskITSAlignQA.cxx:460
 AliAnalysisTaskITSAlignQA.cxx:461
 AliAnalysisTaskITSAlignQA.cxx:462
 AliAnalysisTaskITSAlignQA.cxx:463
 AliAnalysisTaskITSAlignQA.cxx:464
 AliAnalysisTaskITSAlignQA.cxx:465
 AliAnalysisTaskITSAlignQA.cxx:466
 AliAnalysisTaskITSAlignQA.cxx:467
 AliAnalysisTaskITSAlignQA.cxx:468
 AliAnalysisTaskITSAlignQA.cxx:469
 AliAnalysisTaskITSAlignQA.cxx:470
 AliAnalysisTaskITSAlignQA.cxx:471
 AliAnalysisTaskITSAlignQA.cxx:472
 AliAnalysisTaskITSAlignQA.cxx:473
 AliAnalysisTaskITSAlignQA.cxx:474
 AliAnalysisTaskITSAlignQA.cxx:475
 AliAnalysisTaskITSAlignQA.cxx:476
 AliAnalysisTaskITSAlignQA.cxx:477
 AliAnalysisTaskITSAlignQA.cxx:478
 AliAnalysisTaskITSAlignQA.cxx:479
 AliAnalysisTaskITSAlignQA.cxx:480
 AliAnalysisTaskITSAlignQA.cxx:481
 AliAnalysisTaskITSAlignQA.cxx:482
 AliAnalysisTaskITSAlignQA.cxx:483
 AliAnalysisTaskITSAlignQA.cxx:484
 AliAnalysisTaskITSAlignQA.cxx:485
 AliAnalysisTaskITSAlignQA.cxx:486
 AliAnalysisTaskITSAlignQA.cxx:487
 AliAnalysisTaskITSAlignQA.cxx:488
 AliAnalysisTaskITSAlignQA.cxx:489
 AliAnalysisTaskITSAlignQA.cxx:490
 AliAnalysisTaskITSAlignQA.cxx:491
 AliAnalysisTaskITSAlignQA.cxx:492
 AliAnalysisTaskITSAlignQA.cxx:493
 AliAnalysisTaskITSAlignQA.cxx:494
 AliAnalysisTaskITSAlignQA.cxx:495
 AliAnalysisTaskITSAlignQA.cxx:496
 AliAnalysisTaskITSAlignQA.cxx:497
 AliAnalysisTaskITSAlignQA.cxx:498
 AliAnalysisTaskITSAlignQA.cxx:499
 AliAnalysisTaskITSAlignQA.cxx:500
 AliAnalysisTaskITSAlignQA.cxx:501
 AliAnalysisTaskITSAlignQA.cxx:502
 AliAnalysisTaskITSAlignQA.cxx:503
 AliAnalysisTaskITSAlignQA.cxx:504
 AliAnalysisTaskITSAlignQA.cxx:505
 AliAnalysisTaskITSAlignQA.cxx:506
 AliAnalysisTaskITSAlignQA.cxx:507
 AliAnalysisTaskITSAlignQA.cxx:508
 AliAnalysisTaskITSAlignQA.cxx:509
 AliAnalysisTaskITSAlignQA.cxx:510
 AliAnalysisTaskITSAlignQA.cxx:511
 AliAnalysisTaskITSAlignQA.cxx:512
 AliAnalysisTaskITSAlignQA.cxx:513
 AliAnalysisTaskITSAlignQA.cxx:514
 AliAnalysisTaskITSAlignQA.cxx:515
 AliAnalysisTaskITSAlignQA.cxx:516
 AliAnalysisTaskITSAlignQA.cxx:517
 AliAnalysisTaskITSAlignQA.cxx:518
 AliAnalysisTaskITSAlignQA.cxx:519
 AliAnalysisTaskITSAlignQA.cxx:520
 AliAnalysisTaskITSAlignQA.cxx:521
 AliAnalysisTaskITSAlignQA.cxx:522
 AliAnalysisTaskITSAlignQA.cxx:523
 AliAnalysisTaskITSAlignQA.cxx:524
 AliAnalysisTaskITSAlignQA.cxx:525
 AliAnalysisTaskITSAlignQA.cxx:526
 AliAnalysisTaskITSAlignQA.cxx:527
 AliAnalysisTaskITSAlignQA.cxx:528
 AliAnalysisTaskITSAlignQA.cxx:529
 AliAnalysisTaskITSAlignQA.cxx:530
 AliAnalysisTaskITSAlignQA.cxx:531
 AliAnalysisTaskITSAlignQA.cxx:532
 AliAnalysisTaskITSAlignQA.cxx:533
 AliAnalysisTaskITSAlignQA.cxx:534
 AliAnalysisTaskITSAlignQA.cxx:535
 AliAnalysisTaskITSAlignQA.cxx:536
 AliAnalysisTaskITSAlignQA.cxx:537
 AliAnalysisTaskITSAlignQA.cxx:538
 AliAnalysisTaskITSAlignQA.cxx:539
 AliAnalysisTaskITSAlignQA.cxx:540
 AliAnalysisTaskITSAlignQA.cxx:541
 AliAnalysisTaskITSAlignQA.cxx:542
 AliAnalysisTaskITSAlignQA.cxx:543
 AliAnalysisTaskITSAlignQA.cxx:544
 AliAnalysisTaskITSAlignQA.cxx:545
 AliAnalysisTaskITSAlignQA.cxx:546
 AliAnalysisTaskITSAlignQA.cxx:547
 AliAnalysisTaskITSAlignQA.cxx:548
 AliAnalysisTaskITSAlignQA.cxx:549
 AliAnalysisTaskITSAlignQA.cxx:550
 AliAnalysisTaskITSAlignQA.cxx:551
 AliAnalysisTaskITSAlignQA.cxx:552
 AliAnalysisTaskITSAlignQA.cxx:553
 AliAnalysisTaskITSAlignQA.cxx:554
 AliAnalysisTaskITSAlignQA.cxx:555
 AliAnalysisTaskITSAlignQA.cxx:556
 AliAnalysisTaskITSAlignQA.cxx:557
 AliAnalysisTaskITSAlignQA.cxx:558
 AliAnalysisTaskITSAlignQA.cxx:559
 AliAnalysisTaskITSAlignQA.cxx:560
 AliAnalysisTaskITSAlignQA.cxx:561
 AliAnalysisTaskITSAlignQA.cxx:562
 AliAnalysisTaskITSAlignQA.cxx:563
 AliAnalysisTaskITSAlignQA.cxx:564
 AliAnalysisTaskITSAlignQA.cxx:565
 AliAnalysisTaskITSAlignQA.cxx:566
 AliAnalysisTaskITSAlignQA.cxx:567
 AliAnalysisTaskITSAlignQA.cxx:568
 AliAnalysisTaskITSAlignQA.cxx:569
 AliAnalysisTaskITSAlignQA.cxx:570
 AliAnalysisTaskITSAlignQA.cxx:571
 AliAnalysisTaskITSAlignQA.cxx:572
 AliAnalysisTaskITSAlignQA.cxx:573
 AliAnalysisTaskITSAlignQA.cxx:574
 AliAnalysisTaskITSAlignQA.cxx:575
 AliAnalysisTaskITSAlignQA.cxx:576
 AliAnalysisTaskITSAlignQA.cxx:577
 AliAnalysisTaskITSAlignQA.cxx:578
 AliAnalysisTaskITSAlignQA.cxx:579
 AliAnalysisTaskITSAlignQA.cxx:580
 AliAnalysisTaskITSAlignQA.cxx:581
 AliAnalysisTaskITSAlignQA.cxx:582
 AliAnalysisTaskITSAlignQA.cxx:583
 AliAnalysisTaskITSAlignQA.cxx:584
 AliAnalysisTaskITSAlignQA.cxx:585
 AliAnalysisTaskITSAlignQA.cxx:586
 AliAnalysisTaskITSAlignQA.cxx:587
 AliAnalysisTaskITSAlignQA.cxx:588
 AliAnalysisTaskITSAlignQA.cxx:589
 AliAnalysisTaskITSAlignQA.cxx:590
 AliAnalysisTaskITSAlignQA.cxx:591
 AliAnalysisTaskITSAlignQA.cxx:592
 AliAnalysisTaskITSAlignQA.cxx:593
 AliAnalysisTaskITSAlignQA.cxx:594
 AliAnalysisTaskITSAlignQA.cxx:595
 AliAnalysisTaskITSAlignQA.cxx:596
 AliAnalysisTaskITSAlignQA.cxx:597
 AliAnalysisTaskITSAlignQA.cxx:598
 AliAnalysisTaskITSAlignQA.cxx:599
 AliAnalysisTaskITSAlignQA.cxx:600
 AliAnalysisTaskITSAlignQA.cxx:601
 AliAnalysisTaskITSAlignQA.cxx:602
 AliAnalysisTaskITSAlignQA.cxx:603
 AliAnalysisTaskITSAlignQA.cxx:604
 AliAnalysisTaskITSAlignQA.cxx:605
 AliAnalysisTaskITSAlignQA.cxx:606
 AliAnalysisTaskITSAlignQA.cxx:607
 AliAnalysisTaskITSAlignQA.cxx:608
 AliAnalysisTaskITSAlignQA.cxx:609
 AliAnalysisTaskITSAlignQA.cxx:610
 AliAnalysisTaskITSAlignQA.cxx:611
 AliAnalysisTaskITSAlignQA.cxx:612
 AliAnalysisTaskITSAlignQA.cxx:613
 AliAnalysisTaskITSAlignQA.cxx:614
 AliAnalysisTaskITSAlignQA.cxx:615
 AliAnalysisTaskITSAlignQA.cxx:616
 AliAnalysisTaskITSAlignQA.cxx:617
 AliAnalysisTaskITSAlignQA.cxx:618
 AliAnalysisTaskITSAlignQA.cxx:619
 AliAnalysisTaskITSAlignQA.cxx:620
 AliAnalysisTaskITSAlignQA.cxx:621
 AliAnalysisTaskITSAlignQA.cxx:622
 AliAnalysisTaskITSAlignQA.cxx:623
 AliAnalysisTaskITSAlignQA.cxx:624
 AliAnalysisTaskITSAlignQA.cxx:625
 AliAnalysisTaskITSAlignQA.cxx:626
 AliAnalysisTaskITSAlignQA.cxx:627
 AliAnalysisTaskITSAlignQA.cxx:628
 AliAnalysisTaskITSAlignQA.cxx:629
 AliAnalysisTaskITSAlignQA.cxx:630
 AliAnalysisTaskITSAlignQA.cxx:631
 AliAnalysisTaskITSAlignQA.cxx:632
 AliAnalysisTaskITSAlignQA.cxx:633
 AliAnalysisTaskITSAlignQA.cxx:634
 AliAnalysisTaskITSAlignQA.cxx:635
 AliAnalysisTaskITSAlignQA.cxx:636
 AliAnalysisTaskITSAlignQA.cxx:637
 AliAnalysisTaskITSAlignQA.cxx:638
 AliAnalysisTaskITSAlignQA.cxx:639
 AliAnalysisTaskITSAlignQA.cxx:640
 AliAnalysisTaskITSAlignQA.cxx:641
 AliAnalysisTaskITSAlignQA.cxx:642
 AliAnalysisTaskITSAlignQA.cxx:643
 AliAnalysisTaskITSAlignQA.cxx:644
 AliAnalysisTaskITSAlignQA.cxx:645
 AliAnalysisTaskITSAlignQA.cxx:646
 AliAnalysisTaskITSAlignQA.cxx:647
 AliAnalysisTaskITSAlignQA.cxx:648
 AliAnalysisTaskITSAlignQA.cxx:649
 AliAnalysisTaskITSAlignQA.cxx:650
 AliAnalysisTaskITSAlignQA.cxx:651
 AliAnalysisTaskITSAlignQA.cxx:652
 AliAnalysisTaskITSAlignQA.cxx:653
 AliAnalysisTaskITSAlignQA.cxx:654
 AliAnalysisTaskITSAlignQA.cxx:655
 AliAnalysisTaskITSAlignQA.cxx:656
 AliAnalysisTaskITSAlignQA.cxx:657
 AliAnalysisTaskITSAlignQA.cxx:658
 AliAnalysisTaskITSAlignQA.cxx:659
 AliAnalysisTaskITSAlignQA.cxx:660
 AliAnalysisTaskITSAlignQA.cxx:661
 AliAnalysisTaskITSAlignQA.cxx:662
 AliAnalysisTaskITSAlignQA.cxx:663
 AliAnalysisTaskITSAlignQA.cxx:664
 AliAnalysisTaskITSAlignQA.cxx:665
 AliAnalysisTaskITSAlignQA.cxx:666
 AliAnalysisTaskITSAlignQA.cxx:667
 AliAnalysisTaskITSAlignQA.cxx:668
 AliAnalysisTaskITSAlignQA.cxx:669
 AliAnalysisTaskITSAlignQA.cxx:670
 AliAnalysisTaskITSAlignQA.cxx:671
 AliAnalysisTaskITSAlignQA.cxx:672
 AliAnalysisTaskITSAlignQA.cxx:673
 AliAnalysisTaskITSAlignQA.cxx:674
 AliAnalysisTaskITSAlignQA.cxx:675
 AliAnalysisTaskITSAlignQA.cxx:676
 AliAnalysisTaskITSAlignQA.cxx:677
 AliAnalysisTaskITSAlignQA.cxx:678
 AliAnalysisTaskITSAlignQA.cxx:679
 AliAnalysisTaskITSAlignQA.cxx:680
 AliAnalysisTaskITSAlignQA.cxx:681
 AliAnalysisTaskITSAlignQA.cxx:682
 AliAnalysisTaskITSAlignQA.cxx:683
 AliAnalysisTaskITSAlignQA.cxx:684
 AliAnalysisTaskITSAlignQA.cxx:685
 AliAnalysisTaskITSAlignQA.cxx:686
 AliAnalysisTaskITSAlignQA.cxx:687
 AliAnalysisTaskITSAlignQA.cxx:688
 AliAnalysisTaskITSAlignQA.cxx:689
 AliAnalysisTaskITSAlignQA.cxx:690
 AliAnalysisTaskITSAlignQA.cxx:691
 AliAnalysisTaskITSAlignQA.cxx:692
 AliAnalysisTaskITSAlignQA.cxx:693
 AliAnalysisTaskITSAlignQA.cxx:694
 AliAnalysisTaskITSAlignQA.cxx:695
 AliAnalysisTaskITSAlignQA.cxx:696
 AliAnalysisTaskITSAlignQA.cxx:697
 AliAnalysisTaskITSAlignQA.cxx:698
 AliAnalysisTaskITSAlignQA.cxx:699
 AliAnalysisTaskITSAlignQA.cxx:700
 AliAnalysisTaskITSAlignQA.cxx:701
 AliAnalysisTaskITSAlignQA.cxx:702
 AliAnalysisTaskITSAlignQA.cxx:703
 AliAnalysisTaskITSAlignQA.cxx:704
 AliAnalysisTaskITSAlignQA.cxx:705
 AliAnalysisTaskITSAlignQA.cxx:706
 AliAnalysisTaskITSAlignQA.cxx:707
 AliAnalysisTaskITSAlignQA.cxx:708
 AliAnalysisTaskITSAlignQA.cxx:709
 AliAnalysisTaskITSAlignQA.cxx:710
 AliAnalysisTaskITSAlignQA.cxx:711
 AliAnalysisTaskITSAlignQA.cxx:712
 AliAnalysisTaskITSAlignQA.cxx:713
 AliAnalysisTaskITSAlignQA.cxx:714
 AliAnalysisTaskITSAlignQA.cxx:715
 AliAnalysisTaskITSAlignQA.cxx:716
 AliAnalysisTaskITSAlignQA.cxx:717
 AliAnalysisTaskITSAlignQA.cxx:718
 AliAnalysisTaskITSAlignQA.cxx:719
 AliAnalysisTaskITSAlignQA.cxx:720
 AliAnalysisTaskITSAlignQA.cxx:721
 AliAnalysisTaskITSAlignQA.cxx:722
 AliAnalysisTaskITSAlignQA.cxx:723
 AliAnalysisTaskITSAlignQA.cxx:724
 AliAnalysisTaskITSAlignQA.cxx:725
 AliAnalysisTaskITSAlignQA.cxx:726
 AliAnalysisTaskITSAlignQA.cxx:727
 AliAnalysisTaskITSAlignQA.cxx:728
 AliAnalysisTaskITSAlignQA.cxx:729
 AliAnalysisTaskITSAlignQA.cxx:730
 AliAnalysisTaskITSAlignQA.cxx:731
 AliAnalysisTaskITSAlignQA.cxx:732
 AliAnalysisTaskITSAlignQA.cxx:733
 AliAnalysisTaskITSAlignQA.cxx:734
 AliAnalysisTaskITSAlignQA.cxx:735
 AliAnalysisTaskITSAlignQA.cxx:736
 AliAnalysisTaskITSAlignQA.cxx:737
 AliAnalysisTaskITSAlignQA.cxx:738
 AliAnalysisTaskITSAlignQA.cxx:739
 AliAnalysisTaskITSAlignQA.cxx:740
 AliAnalysisTaskITSAlignQA.cxx:741
 AliAnalysisTaskITSAlignQA.cxx:742
 AliAnalysisTaskITSAlignQA.cxx:743
 AliAnalysisTaskITSAlignQA.cxx:744
 AliAnalysisTaskITSAlignQA.cxx:745
 AliAnalysisTaskITSAlignQA.cxx:746
 AliAnalysisTaskITSAlignQA.cxx:747
 AliAnalysisTaskITSAlignQA.cxx:748
 AliAnalysisTaskITSAlignQA.cxx:749
 AliAnalysisTaskITSAlignQA.cxx:750
 AliAnalysisTaskITSAlignQA.cxx:751
 AliAnalysisTaskITSAlignQA.cxx:752
 AliAnalysisTaskITSAlignQA.cxx:753
 AliAnalysisTaskITSAlignQA.cxx:754
 AliAnalysisTaskITSAlignQA.cxx:755
 AliAnalysisTaskITSAlignQA.cxx:756
 AliAnalysisTaskITSAlignQA.cxx:757
 AliAnalysisTaskITSAlignQA.cxx:758
 AliAnalysisTaskITSAlignQA.cxx:759
 AliAnalysisTaskITSAlignQA.cxx:760
 AliAnalysisTaskITSAlignQA.cxx:761
 AliAnalysisTaskITSAlignQA.cxx:762
 AliAnalysisTaskITSAlignQA.cxx:763
 AliAnalysisTaskITSAlignQA.cxx:764
 AliAnalysisTaskITSAlignQA.cxx:765
 AliAnalysisTaskITSAlignQA.cxx:766
 AliAnalysisTaskITSAlignQA.cxx:767
 AliAnalysisTaskITSAlignQA.cxx:768
 AliAnalysisTaskITSAlignQA.cxx:769
 AliAnalysisTaskITSAlignQA.cxx:770
 AliAnalysisTaskITSAlignQA.cxx:771
 AliAnalysisTaskITSAlignQA.cxx:772
 AliAnalysisTaskITSAlignQA.cxx:773
 AliAnalysisTaskITSAlignQA.cxx:774
 AliAnalysisTaskITSAlignQA.cxx:775
 AliAnalysisTaskITSAlignQA.cxx:776
 AliAnalysisTaskITSAlignQA.cxx:777
 AliAnalysisTaskITSAlignQA.cxx:778
 AliAnalysisTaskITSAlignQA.cxx:779
 AliAnalysisTaskITSAlignQA.cxx:780
 AliAnalysisTaskITSAlignQA.cxx:781
 AliAnalysisTaskITSAlignQA.cxx:782
 AliAnalysisTaskITSAlignQA.cxx:783
 AliAnalysisTaskITSAlignQA.cxx:784
 AliAnalysisTaskITSAlignQA.cxx:785
 AliAnalysisTaskITSAlignQA.cxx:786
 AliAnalysisTaskITSAlignQA.cxx:787
 AliAnalysisTaskITSAlignQA.cxx:788
 AliAnalysisTaskITSAlignQA.cxx:789
 AliAnalysisTaskITSAlignQA.cxx:790
 AliAnalysisTaskITSAlignQA.cxx:791
 AliAnalysisTaskITSAlignQA.cxx:792
 AliAnalysisTaskITSAlignQA.cxx:793
 AliAnalysisTaskITSAlignQA.cxx:794
 AliAnalysisTaskITSAlignQA.cxx:795
 AliAnalysisTaskITSAlignQA.cxx:796
 AliAnalysisTaskITSAlignQA.cxx:797
 AliAnalysisTaskITSAlignQA.cxx:798
 AliAnalysisTaskITSAlignQA.cxx:799
 AliAnalysisTaskITSAlignQA.cxx:800
 AliAnalysisTaskITSAlignQA.cxx:801
 AliAnalysisTaskITSAlignQA.cxx:802
 AliAnalysisTaskITSAlignQA.cxx:803
 AliAnalysisTaskITSAlignQA.cxx:804
 AliAnalysisTaskITSAlignQA.cxx:805
 AliAnalysisTaskITSAlignQA.cxx:806
 AliAnalysisTaskITSAlignQA.cxx:807
 AliAnalysisTaskITSAlignQA.cxx:808
 AliAnalysisTaskITSAlignQA.cxx:809
 AliAnalysisTaskITSAlignQA.cxx:810
 AliAnalysisTaskITSAlignQA.cxx:811
 AliAnalysisTaskITSAlignQA.cxx:812
 AliAnalysisTaskITSAlignQA.cxx:813
 AliAnalysisTaskITSAlignQA.cxx:814
 AliAnalysisTaskITSAlignQA.cxx:815
 AliAnalysisTaskITSAlignQA.cxx:816
 AliAnalysisTaskITSAlignQA.cxx:817
 AliAnalysisTaskITSAlignQA.cxx:818
 AliAnalysisTaskITSAlignQA.cxx:819
 AliAnalysisTaskITSAlignQA.cxx:820
 AliAnalysisTaskITSAlignQA.cxx:821
 AliAnalysisTaskITSAlignQA.cxx:822
 AliAnalysisTaskITSAlignQA.cxx:823
 AliAnalysisTaskITSAlignQA.cxx:824
 AliAnalysisTaskITSAlignQA.cxx:825
 AliAnalysisTaskITSAlignQA.cxx:826
 AliAnalysisTaskITSAlignQA.cxx:827
 AliAnalysisTaskITSAlignQA.cxx:828
 AliAnalysisTaskITSAlignQA.cxx:829
 AliAnalysisTaskITSAlignQA.cxx:830
 AliAnalysisTaskITSAlignQA.cxx:831
 AliAnalysisTaskITSAlignQA.cxx:832
 AliAnalysisTaskITSAlignQA.cxx:833
 AliAnalysisTaskITSAlignQA.cxx:834
 AliAnalysisTaskITSAlignQA.cxx:835
 AliAnalysisTaskITSAlignQA.cxx:836
 AliAnalysisTaskITSAlignQA.cxx:837
 AliAnalysisTaskITSAlignQA.cxx:838
 AliAnalysisTaskITSAlignQA.cxx:839
 AliAnalysisTaskITSAlignQA.cxx:840
 AliAnalysisTaskITSAlignQA.cxx:841
 AliAnalysisTaskITSAlignQA.cxx:842
 AliAnalysisTaskITSAlignQA.cxx:843
 AliAnalysisTaskITSAlignQA.cxx:844
 AliAnalysisTaskITSAlignQA.cxx:845
 AliAnalysisTaskITSAlignQA.cxx:846
 AliAnalysisTaskITSAlignQA.cxx:847
 AliAnalysisTaskITSAlignQA.cxx:848
 AliAnalysisTaskITSAlignQA.cxx:849
 AliAnalysisTaskITSAlignQA.cxx:850
 AliAnalysisTaskITSAlignQA.cxx:851
 AliAnalysisTaskITSAlignQA.cxx:852
 AliAnalysisTaskITSAlignQA.cxx:853
 AliAnalysisTaskITSAlignQA.cxx:854
 AliAnalysisTaskITSAlignQA.cxx:855
 AliAnalysisTaskITSAlignQA.cxx:856
 AliAnalysisTaskITSAlignQA.cxx:857
 AliAnalysisTaskITSAlignQA.cxx:858
 AliAnalysisTaskITSAlignQA.cxx:859
 AliAnalysisTaskITSAlignQA.cxx:860
 AliAnalysisTaskITSAlignQA.cxx:861
 AliAnalysisTaskITSAlignQA.cxx:862
 AliAnalysisTaskITSAlignQA.cxx:863
 AliAnalysisTaskITSAlignQA.cxx:864
 AliAnalysisTaskITSAlignQA.cxx:865
 AliAnalysisTaskITSAlignQA.cxx:866
 AliAnalysisTaskITSAlignQA.cxx:867
 AliAnalysisTaskITSAlignQA.cxx:868
 AliAnalysisTaskITSAlignQA.cxx:869
 AliAnalysisTaskITSAlignQA.cxx:870
 AliAnalysisTaskITSAlignQA.cxx:871
 AliAnalysisTaskITSAlignQA.cxx:872
 AliAnalysisTaskITSAlignQA.cxx:873
 AliAnalysisTaskITSAlignQA.cxx:874
 AliAnalysisTaskITSAlignQA.cxx:875
 AliAnalysisTaskITSAlignQA.cxx:876
 AliAnalysisTaskITSAlignQA.cxx:877
 AliAnalysisTaskITSAlignQA.cxx:878
 AliAnalysisTaskITSAlignQA.cxx:879
 AliAnalysisTaskITSAlignQA.cxx:880
 AliAnalysisTaskITSAlignQA.cxx:881
 AliAnalysisTaskITSAlignQA.cxx:882
 AliAnalysisTaskITSAlignQA.cxx:883
 AliAnalysisTaskITSAlignQA.cxx:884
 AliAnalysisTaskITSAlignQA.cxx:885
 AliAnalysisTaskITSAlignQA.cxx:886
 AliAnalysisTaskITSAlignQA.cxx:887
 AliAnalysisTaskITSAlignQA.cxx:888
 AliAnalysisTaskITSAlignQA.cxx:889
 AliAnalysisTaskITSAlignQA.cxx:890
 AliAnalysisTaskITSAlignQA.cxx:891
 AliAnalysisTaskITSAlignQA.cxx:892
 AliAnalysisTaskITSAlignQA.cxx:893
 AliAnalysisTaskITSAlignQA.cxx:894
 AliAnalysisTaskITSAlignQA.cxx:895
 AliAnalysisTaskITSAlignQA.cxx:896
 AliAnalysisTaskITSAlignQA.cxx:897
 AliAnalysisTaskITSAlignQA.cxx:898
 AliAnalysisTaskITSAlignQA.cxx:899
 AliAnalysisTaskITSAlignQA.cxx:900
 AliAnalysisTaskITSAlignQA.cxx:901
 AliAnalysisTaskITSAlignQA.cxx:902
 AliAnalysisTaskITSAlignQA.cxx:903
 AliAnalysisTaskITSAlignQA.cxx:904
 AliAnalysisTaskITSAlignQA.cxx:905
 AliAnalysisTaskITSAlignQA.cxx:906
 AliAnalysisTaskITSAlignQA.cxx:907
 AliAnalysisTaskITSAlignQA.cxx:908
 AliAnalysisTaskITSAlignQA.cxx:909
 AliAnalysisTaskITSAlignQA.cxx:910
 AliAnalysisTaskITSAlignQA.cxx:911
 AliAnalysisTaskITSAlignQA.cxx:912
 AliAnalysisTaskITSAlignQA.cxx:913
 AliAnalysisTaskITSAlignQA.cxx:914
 AliAnalysisTaskITSAlignQA.cxx:915