[u/mrichter/AliRoot.git] / PWG1 / ITS / AliAnalysisTaskSPD.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, 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.                  *
 **************************************************************************/


//-----------------------------------------------------------------------
// Author : A. Mastroserio
//-----------------------------------------------------------------------


#ifndef ALIANALYSISTASKSPD_CXX
#define ALIANALYSISTASKSPD_CXX

#include "AliAnalysisTaskSPD.h"
#include "TClonesArray.h"
#include "TBranch.h"
#include "TH1I.h"
#include "TH2D.h"
#include "TFile.h"
#include "AliSPDUtils.h"
#include "AliESDEvent.h"
#include "TChain.h"
#include "AliLog.h"
#include "AliESDInputHandlerRP.h"
#include "AliAnalysisManager.h"
#include "AliMultiplicity.h"
#include "AliCDBPath.h"
#include "AliCDBManager.h"
#include "AliCDBEntry.h"
#include "AliCDBStorage.h"
#include "AliGeomManager.h"
#include "AliITSRecPoint.h"
#include "AliITSsegmentationSPD.h"
ClassImp(AliAnalysisTaskSPD)
  //__________________________________________________________________________
  AliAnalysisTaskSPD::AliAnalysisTaskSPD() :
    fSegSPD(0x0),
    fOutput(0x0),
    fRunNb(999),
    fOCDBLocation("local://$ALICE_ROOT/OCDB")
{
  //
  //Default ctor
  //
}
//___________________________________________________________________________
AliAnalysisTaskSPD::AliAnalysisTaskSPD(const Char_t* name) :
  AliAnalysisTaskSE(name),
  fSegSPD(0x0),
  fOutput(0x0),
  fRunNb(999),
  fOCDBLocation("local://$ALICE_ROOT/OCDB")
{
  //
  // Constructor. Initialization of Inputs and Outputs
  //
  Info("AliAnalysisTaskSPD","Calling Constructor");

  DefineOutput(1,TList::Class());
  // 
}

//___________________________________________________________________________
AliAnalysisTaskSPD& AliAnalysisTaskSPD::operator=(const AliAnalysisTaskSPD& c) 
{
  //
  // Assignment operator
  //
  if (this!=&c) {
    AliAnalysisTaskSE::operator=(c) ;
    fSegSPD = c.fSegSPD ;
    fOutput = c.fOutput ;
    fRunNb = c.fRunNb;
    fOCDBLocation = c.fOCDBLocation;
  }
  return *this;
}

//___________________________________________________________________________
AliAnalysisTaskSPD::AliAnalysisTaskSPD(const AliAnalysisTaskSPD& c) :
  AliAnalysisTaskSE(c),
  fSegSPD(c.fSegSPD),
  fOutput(c.fOutput),
  fRunNb(c.fRunNb),
  fOCDBLocation(c.fOCDBLocation)
{
  //
  // Copy Constructor
  //

}

//___________________________________________________________________________
AliAnalysisTaskSPD::~AliAnalysisTaskSPD() {
  //
  //destructor
  //
  Info("~AliAnalysisTaskSPD","Calling Destructor");
  if (fSegSPD) delete fSegSPD ;
   if (fOutput) {
    delete fOutput;
    fOutput = 0;
  }
}
//___________________________________________________________________________
void AliAnalysisTaskSPD::UserCreateOutputObjects() {

  Info("CreateOutputObjects","CreateOutputObjects of task %s", GetName());
  if(fRunNb!=999){
    LoadGeometryFromOCDB();
  }
  fSegSPD = new AliITSsegmentationSPD();

  //slot #1
  OpenFile(1);
  fOutput = new TList();
  //
  // Booking rec points related histograms
  //0
  TH2D *hLocalMapL1 = new TH2D("hLocalMapL1"," Local coordinates  - Layer 1",660,-16.5,16.5,410,-0.5,40.5); // safe limits for local coordinates in a module : z = -4,4, x = -1,1;
  hLocalMapL1->SetXTitle("direction Z [cm]");
  hLocalMapL1->SetYTitle("direction X [cm]");
  fOutput->AddLast(hLocalMapL1);
  //1
  TH2D *hLocalMapL2 = new TH2D("hLocalMapL2"," Local coordinates  - Layer 2",660,-16.5,16.5,810,-0.5,80.5);
  hLocalMapL2->SetXTitle("direction Z [cm]");
  hLocalMapL2->SetYTitle("direction X [cm]");
  fOutput->AddLast(hLocalMapL2);
  //2
  TH1F *hClusterModYield = new TH1F("hClusterModYield","Cluster yield in modules",241,-0.5,240.5);
  hClusterModYield->SetXTitle("module number");
  fOutput->AddLast(hClusterModYield);
  // 3
  TH1F *hClusterYield = new TH1F("hClusterYield","Cluster yield per chip",1200,-0.5,1199.5) ;
  hClusterYield->SetXTitle("chip key");
  fOutput->AddLast(hClusterYield); 
  //4
  TH1F *hClusterYieldOnline = new TH1F("hClusterYieldOnline","Cluster yield per chip (online coord eq*60+hs*10+chip)",1200,-0.5,1199.5) ;
  hClusterYieldOnline->SetXTitle("chip");
  fOutput->AddLast(hClusterYieldOnline);
  //5
  TH1F *hFiredChip = new TH1F("hFiredChip","Fired chip (at least one cluster)",1200,-0.5,1199.5);
  hFiredChip->SetXTitle("chip key");
  fOutput->AddLast(hFiredChip);
  //6
  TH1F *hFOFiredChip = new TH1F("hFOFiredChip","FO Fired chip ",1200,-0.5,1199.5);
  hFOFiredChip->SetXTitle("chip key");
  fOutput->AddLast(hFOFiredChip);
  //7
  TH1F *hFOgood = new TH1F("hFOgood"," FO-good (at least one cluster) ",1200,-0.5,1199.5);
  hFOgood->SetXTitle("chip key");
  fOutput->AddLast(hFOgood);
  //8
  TH2F *hFOgoodPerBC = new TH2F("hFOgoodPerBCmod4"," FO-good signals in BCmod4 ",1200,-0.5,1199.5,4,-0.5,3.5);
  hFOgoodPerBC->SetXTitle("chip key");
  fOutput->AddLast(hFOgoodPerBC);
  //9
  TH2F *hFiredChipsPerBC = new TH2F("hFiredChipsPerBCmod4"," fired chips in BCmod4 ",1200,-0.5,1199.5,4,-0.5,3.5);
  hFiredChipsPerBC->SetXTitle("chip key");
  fOutput->AddLast(hFiredChipsPerBC);
  //10
  TH1F *hFOnoisy = new TH1F("hFOnoisy","FO-noisy (no cluster)",1200,-0.5,1199.5);
  hFOnoisy->SetXTitle("chip key");
  fOutput->AddLast(hFOnoisy);

  //
  // Booking ESD related histograms
  //

  // 11
  TH1I *hTracklets = new TH1I("hNtracklets","Tracklet distribution",80,0,80);
  hTracklets->SetXTitle("# Tracklets");
  fOutput->AddLast(hTracklets);
  //12
  TH2F *hSPDphivsSPDeta= new TH2F("hSPDphivsSPDeta", "Tracklets - #varphi vs #eta",120,-3.,3,360,0.,2*TMath::Pi());
  hSPDphivsSPDeta->GetXaxis()->SetTitle("Pseudorapidity #eta");
  hSPDphivsSPDeta->GetYaxis()->SetTitle("#varphi [rad]");
  fOutput->AddLast(hSPDphivsSPDeta);
  //13
  TH1F *hSPDphiZpos= new TH1F("hSPDphiZpos", "Tracklets - #varphi (Z>0)",360,0.,2*TMath::Pi());
  hSPDphiZpos->SetXTitle("#varphi [rad]");
  fOutput->AddLast(hSPDphiZpos);
  //14
  TH1F *hSPDphiZneg= new TH1F("hSPDphiZneg", "Tracklets - #varphi (Z<0)",360,0.,2*TMath::Pi());
  hSPDphiZneg->SetXTitle("#varphi [rad]");
  fOutput->AddLast(hSPDphiZneg);
  //15
  TH1F *hVertexZ = new TH1F("hVertexZ","Vertex Z distribution",300,-15,15);
  hVertexZ->SetXTitle("Z Vertex [cm]");
  fOutput->AddLast(hVertexZ); 
  //16
  TH1I *hEventsProcessed = new TH1I("hEventsProcessed","Number of processed events",1,0,1) ;
  fOutput->AddLast(hEventsProcessed);
}
//_________________________________________________
void AliAnalysisTaskSPD::UserExec(Option_t *)
{
  //
  // Main loop function
  //
  AliESDInputHandlerRP *hand = dynamic_cast<AliESDInputHandlerRP*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
  if(!hand) {
    printf("No AliESDInputHandlerRP \n");  
    return;
  }

  AliESDEvent *ESD = hand->GetEvent();
  if(!ESD) {
    printf("No AliESDEvent \n");
    return;
  }

  Bool_t recP = kTRUE;
  TTree * treeRP = hand->GetTreeR("ITS");
  if(!treeRP) {
    //AliWarning("No ITS RecPoints tree ");
    recP=kFALSE;
  }

  
  // ESD related histograms
 
   const AliESDVertex *vertex = ESD->GetPrimaryVertexSPD();
   const AliMultiplicity *mult = ESD->GetMultiplicity();
 
   // Event selection
   if(!vertex) return;
   if(!vertex->GetStatus()) return;
   if(vertex->GetNContributors() < 1) return;

  ((TH1I*)fOutput->At(16))->Fill(0);
   
  ((TH1I*)fOutput->At(11))->Fill(mult->GetNumberOfTracklets());
  UInt_t bc = (UInt_t)ESD->GetBunchCrossNumber();
  for(Int_t iChipKey=0; iChipKey < 1200; iChipKey++){
    if(mult->TestFiredChipMap(iChipKey)) {
     ((TH1F*)fOutput->At(5))->Fill(iChipKey);
     if(bc>0)((TH2F*)fOutput->At(9))->Fill(iChipKey,bc%4);   
     }
    if(mult->TestFastOrFiredChips(iChipKey)) ((TH1F*)fOutput->At(6))->Fill(iChipKey);
    if(mult->TestFastOrFiredChips(iChipKey) && mult->TestFiredChipMap(iChipKey)) {
      ((TH1F*)fOutput->At(7))->Fill(iChipKey);
      if(bc>0) ((TH2F*)fOutput->At(8))->Fill(iChipKey,bc%4);
     
    }
    if(mult->TestFastOrFiredChips(iChipKey) && !mult->TestFiredChipMap(iChipKey)) ((TH1F*)fOutput->At(10))->Fill(iChipKey);
  }
  
  
  Double_t vtxPos[3] = {999, 999, 999};
  if(vertex){
    vertex->GetXYZ(vtxPos);
 
    ((TH1F*)fOutput->At(15))->Fill(vtxPos[2]);
 
    for(Int_t iTracklet =0; iTracklet < mult->GetNumberOfTracklets(); iTracklet++){

      Float_t phiTr= mult->GetPhi(iTracklet);
      Float_t etaTr =mult->GetEta(iTracklet);

      ((TH2F*)fOutput->At(12))->Fill(etaTr,phiTr);

      // Z pos or Z neg
      Float_t z = vtxPos[2] + 3.9 / TMath::Tan(2 * TMath::ATan(TMath::Exp(- etaTr)));
      if(z>0) ((TH1F*)fOutput->At(13))->Fill(phiTr);
      else ((TH1F*)fOutput->At(14))->Fill(phiTr);
    }
  } 
  
  
  if(recP){
  // RecPoints info

  TClonesArray statITSrec("AliITSRecPoint");
  TClonesArray *ITSCluster = &statITSrec;
  TBranch* branch=treeRP->GetBranch("ITSRecPoints");
  if(!branch) {
    printf("NO treeRP branch available. Exiting...\n");
    return;
  }

  branch->SetAddress(&ITSCluster);

  for(Int_t iMod=0;iMod<240;iMod++){
    branch->GetEvent(iMod);
    Int_t nrecp = statITSrec.GetEntries();
    if(nrecp>0) ((TH1F*)fOutput->At(2))->Fill(iMod,nrecp);
  
    for(Int_t irec=0;irec<nrecp;irec++) {
      AliITSRecPoint *recp = (AliITSRecPoint*)statITSrec.At(irec);
      Int_t lay=recp->GetLayer();
      if(lay>1) continue;

      // ----  Filling maps (local coordinates rearranged) -----
      Float_t local[3]={-1,-1};
      local[1]=recp->GetDetLocalX();
      local[0]=recp->GetDetLocalZ();
      Int_t eq = AliSPDUtils::GetOnlineEqIdFromOffline(iMod);
      Int_t hs = AliSPDUtils::GetOnlineHSFromOffline(iMod);
      Int_t row, col;
      fSegSPD->LocalToDet(0.5,local[0],row,col);
      Int_t chip = AliSPDUtils::GetOnlineChipFromOffline(iMod,col);
     
      Double_t locx, locz, equip;
      Double_t corrlocz =0;
      if(lay==0) corrlocz=local[0];
      else corrlocz = -local[0];
      // rearranging local geometry
      if(eq<10) equip=eq;
      else equip=eq-10;
      if(eq<10){
	if(chip<5) locz =corrlocz +8 +4;
	else locz = corrlocz+4;
      } else {
	if(chip<5) locz = corrlocz-8-4;
	else locz = corrlocz-4;
      }
      // filling maps
      if(lay==0){
	locx = (local[1]+1) + hs*2 +equip*4;
	((TH2D*)fOutput->At(0))->Fill(locz,locx);
	
      } else {
	locx = (local[1]+1) + (hs-2)*2 +equip*8;
	((TH2D*)fOutput->At(1))->Fill(locz,locx);
      }
      // ---- End Filling maps (local coordinates rearranged) -----
    
      ((TH1F*)fOutput->At(3))->Fill(AliSPDUtils::GetOfflineChipKeyFromOnline(eq,hs,chip));
      ((TH1F*)fOutput->At(4))->Fill(eq*60+hs*10+chip);
   
    }
  }
 }// end if rec points are available
 
  
  /* PostData(0) is taken care of by AliAnalysisTaskSE */
  PostData(1,fOutput) ;

}


//___________________________________________________________________________
void AliAnalysisTaskSPD::Terminate(Option_t*)
{
  // The Terminate() function is the last function to be called during
  // a query. It always runs on the client, it can be used to present
  // the results graphically or save the results to file.

  AliAnalysisTaskSE::Terminate();
}


//___________________________________________________________________________
void AliAnalysisTaskSPD::LoadGeometryFromOCDB(){
  //method to get the gGeomanager
  // it is called at the CreatedOutputObject stage
  // to comply with the CAF environment
  AliCDBManager *man = AliCDBManager::Instance();
  man->SetDefaultStorage(fOCDBLocation.Data());
  man->SetRun(fRunNb);  
  AliCDBEntry* obj = man->Get(AliCDBPath("GRP", "Geometry", "Data"));
  AliGeomManager::SetGeometry((TGeoManager*)obj->GetObject());
  AliGeomManager::GetNalignable("ITS");
  AliGeomManager::ApplyAlignObjsFromCDB("ITS"); 
}


#endif
Commit	Line	Data
4587ea58	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16
	17	//-----------------------------------------------------------------------
	18	// Author : A. Mastroserio
	19	//-----------------------------------------------------------------------
	20
	21
	22	#ifndef ALIANALYSISTASKSPD_CXX
	23	#define ALIANALYSISTASKSPD_CXX
	24
	25	#include "AliAnalysisTaskSPD.h"
	26	#include "TClonesArray.h"
	27	#include "TBranch.h"
	28	#include "TH1I.h"
	29	#include "TH2D.h"
	30	#include "TFile.h"
	31	#include "AliSPDUtils.h"
	32	#include "AliESDEvent.h"
	33	#include "TChain.h"
	34	#include "AliLog.h"
	35	#include "AliESDInputHandlerRP.h"
	36	#include "AliAnalysisManager.h"
	37	#include "AliMultiplicity.h"
	38	#include "AliCDBPath.h"
	39	#include "AliCDBManager.h"
	40	#include "AliCDBEntry.h"
	41	#include "AliCDBStorage.h"
	42	#include "AliGeomManager.h"
	43	#include "AliITSRecPoint.h"
	44	#include "AliITSsegmentationSPD.h"
	45	ClassImp(AliAnalysisTaskSPD)
	46	//__________________________________________________________________________
	47	AliAnalysisTaskSPD::AliAnalysisTaskSPD() :
	48	fSegSPD(0x0),
	49	fOutput(0x0),
	50	fRunNb(999),
	51	fOCDBLocation("local://$ALICE_ROOT/OCDB")
	52	{
	53	//
	54	//Default ctor
	55	//
	56	}
	57	//___________________________________________________________________________
	58	AliAnalysisTaskSPD::AliAnalysisTaskSPD(const Char_t* name) :
	59	AliAnalysisTaskSE(name),
	60	fSegSPD(0x0),
	61	fOutput(0x0),
	62	fRunNb(999),
	63	fOCDBLocation("local://$ALICE_ROOT/OCDB")
	64	{
65	//
66	// Constructor. Initialization of Inputs and Outputs
67	//
68	Info("AliAnalysisTaskSPD","Calling Constructor");
69
70	DefineOutput(1,TList::Class());
71	//
72	}
73
74	//___________________________________________________________________________
75	AliAnalysisTaskSPD& AliAnalysisTaskSPD::operator=(const AliAnalysisTaskSPD& c)
76	{
77	//
78	// Assignment operator
79	//
80	if (this!=&c) {
81	AliAnalysisTaskSE::operator=(c) ;
82	fSegSPD = c.fSegSPD ;
83	fOutput = c.fOutput ;
84	fRunNb = c.fRunNb;
85	fOCDBLocation = c.fOCDBLocation;
4587ea58	86	}
	87	return *this;
	88	}
	89
	90	//___________________________________________________________________________
	91	AliAnalysisTaskSPD::AliAnalysisTaskSPD(const AliAnalysisTaskSPD& c) :
	92	AliAnalysisTaskSE(c),
	93	fSegSPD(c.fSegSPD),
	94	fOutput(c.fOutput),
	95	fRunNb(c.fRunNb),
	96	fOCDBLocation(c.fOCDBLocation)
	97	{
	98	//
	99	// Copy Constructor
	100	//
	101
	102	}
	103
	104	//___________________________________________________________________________
	105	AliAnalysisTaskSPD::~AliAnalysisTaskSPD() {
	106	//
	107	//destructor
	108	//
	109	Info("~AliAnalysisTaskSPD","Calling Destructor");
	110	if (fSegSPD) delete fSegSPD ;
	111	if (fOutput) {
	112	delete fOutput;
	113	fOutput = 0;
	114	}
	115	}
	116	//___________________________________________________________________________
	117	void AliAnalysisTaskSPD::UserCreateOutputObjects() {
	118
	119	Info("CreateOutputObjects","CreateOutputObjects of task %s", GetName());
	120	if(fRunNb!=999){
	121	LoadGeometryFromOCDB();
	122	}
	123	fSegSPD = new AliITSsegmentationSPD();
	124
	125	//slot #1
	126	OpenFile(1);
	127	fOutput = new TList();
	128	//
	129	// Booking rec points related histograms
	130	//0
3c9441f1	131	TH2D *hLocalMapL1 = new TH2D("hLocalMapL1"," Local coordinates - Layer 1",660,-16.5,16.5,410,-0.5,40.5); // safe limits for local coordinates in a module : z = -4,4, x = -1,1;
4587ea58	132	hLocalMapL1->SetXTitle("direction Z [cm]");
	133	hLocalMapL1->SetYTitle("direction X [cm]");
	134	fOutput->AddLast(hLocalMapL1);
	135	//1
3c9441f1	136	TH2D *hLocalMapL2 = new TH2D("hLocalMapL2"," Local coordinates - Layer 2",660,-16.5,16.5,810,-0.5,80.5);
4587ea58	137	hLocalMapL2->SetXTitle("direction Z [cm]");
	138	hLocalMapL2->SetYTitle("direction X [cm]");
	139	fOutput->AddLast(hLocalMapL2);
	140	//2
	141	TH1F *hClusterModYield = new TH1F("hClusterModYield","Cluster yield in modules",241,-0.5,240.5);
	142	hClusterModYield->SetXTitle("module number");
	143	fOutput->AddLast(hClusterModYield);
	144	// 3
	145	TH1F *hClusterYield = new TH1F("hClusterYield","Cluster yield per chip",1200,-0.5,1199.5) ;
	146	hClusterYield->SetXTitle("chip key");
	147	fOutput->AddLast(hClusterYield);
	148	//4
	149	TH1F hClusterYieldOnline = new TH1F("hClusterYieldOnline","Cluster yield per chip (online coord eq60+hs*10+chip)",1200,-0.5,1199.5) ;
	150	hClusterYieldOnline->SetXTitle("chip");
	151	fOutput->AddLast(hClusterYieldOnline);
	152	//5
	153	TH1F *hFiredChip = new TH1F("hFiredChip","Fired chip (at least one cluster)",1200,-0.5,1199.5);
	154	hFiredChip->SetXTitle("chip key");
	155	fOutput->AddLast(hFiredChip);
	156	//6
	157	TH1F *hFOFiredChip = new TH1F("hFOFiredChip","FO Fired chip ",1200,-0.5,1199.5);
	158	hFOFiredChip->SetXTitle("chip key");
	159	fOutput->AddLast(hFOFiredChip);
	160	//7
	161	TH1F *hFOgood = new TH1F("hFOgood"," FO-good (at least one cluster) ",1200,-0.5,1199.5);
ce972512	162	hFOgood->SetXTitle("chip key");
4587ea58	163	fOutput->AddLast(hFOgood);
ce972512	164	//8
	165	TH2F *hFOgoodPerBC = new TH2F("hFOgoodPerBCmod4"," FO-good signals in BCmod4 ",1200,-0.5,1199.5,4,-0.5,3.5);
	166	hFOgoodPerBC->SetXTitle("chip key");
	167	fOutput->AddLast(hFOgoodPerBC);
	168	//9
	169	TH2F *hFiredChipsPerBC = new TH2F("hFiredChipsPerBCmod4"," fired chips in BCmod4 ",1200,-0.5,1199.5,4,-0.5,3.5);
	170	hFiredChipsPerBC->SetXTitle("chip key");
	171	fOutput->AddLast(hFiredChipsPerBC);
	172	//10
4587ea58	173	TH1F *hFOnoisy = new TH1F("hFOnoisy","FO-noisy (no cluster)",1200,-0.5,1199.5);
ce972512	174	hFOnoisy->SetXTitle("chip key");
4587ea58	175	fOutput->AddLast(hFOnoisy);
	176
	177	//
	178	// Booking ESD related histograms
	179	//
	180
ce972512	181	// 11
4587ea58	182	TH1I *hTracklets = new TH1I("hNtracklets","Tracklet distribution",80,0,80);
ce972512	183	hTracklets->SetXTitle("# Tracklets");
4587ea58	184	fOutput->AddLast(hTracklets);
ce972512	185	//12
4587ea58	186	TH2F hSPDphivsSPDeta= new TH2F("hSPDphivsSPDeta", "Tracklets - #varphi vs #eta",120,-3.,3,360,0.,2TMath::Pi());
	187	hSPDphivsSPDeta->GetXaxis()->SetTitle("Pseudorapidity #eta");
	188	hSPDphivsSPDeta->GetYaxis()->SetTitle("#varphi [rad]");
	189	fOutput->AddLast(hSPDphivsSPDeta);
ce972512	190	//13
4587ea58	191	TH1F hSPDphiZpos= new TH1F("hSPDphiZpos", "Tracklets - #varphi (Z>0)",360,0.,2TMath::Pi());
	192	hSPDphiZpos->SetXTitle("#varphi [rad]");
	193	fOutput->AddLast(hSPDphiZpos);
ce972512	194	//14
4587ea58	195	TH1F hSPDphiZneg= new TH1F("hSPDphiZneg", "Tracklets - #varphi (Z<0)",360,0.,2TMath::Pi());
	196	hSPDphiZneg->SetXTitle("#varphi [rad]");
	197	fOutput->AddLast(hSPDphiZneg);
ce972512	198	//15
4587ea58	199	TH1F *hVertexZ = new TH1F("hVertexZ","Vertex Z distribution",300,-15,15);
	200	hVertexZ->SetXTitle("Z Vertex [cm]");
	201	fOutput->AddLast(hVertexZ);
ce972512	202	//16
4587ea58	203	TH1I *hEventsProcessed = new TH1I("hEventsProcessed","Number of processed events",1,0,1) ;
	204	fOutput->AddLast(hEventsProcessed);
	205	}
	206	//_________________________________________________
	207	void AliAnalysisTaskSPD::UserExec(Option_t *)
	208	{
	209	//
	210	// Main loop function
	211	//
4587ea58	212	AliESDInputHandlerRP hand = dynamic_cast<AliESDInputHandlerRP> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
	213	if(!hand) {
	214	printf("No AliESDInputHandlerRP \n");
	215	return;
	216	}
	217
	218	AliESDEvent *ESD = hand->GetEvent();
	219	if(!ESD) {
	220	printf("No AliESDEvent \n");
	221	return;
	222	}
3c9441f1	223
3c9441f1	224	Bool_t recP = kTRUE;
4587ea58	225	TTree * treeRP = hand->GetTreeR("ITS");
4587ea58	226	if(!treeRP) {
3c9441f1	227	//AliWarning("No ITS RecPoints tree ");
3c9441f1	228	recP=kFALSE;
4587ea58	229	}
4587ea58	230
3c9441f1	231
	232
	233	// ESD related histograms
	234
	235	const AliESDVertex *vertex = ESD->GetPrimaryVertexSPD();
	236	const AliMultiplicity *mult = ESD->GetMultiplicity();
	237
	238	// Event selection
	239	if(!vertex) return;
	240	if(!vertex->GetStatus()) return;
	241	if(vertex->GetNContributors() < 1) return;
	242
ce972512	243	((TH1I*)fOutput->At(16))->Fill(0);
3c9441f1	244
	245	((TH1I*)fOutput->At(11))->Fill(mult->GetNumberOfTracklets());
	246	UInt_t bc = (UInt_t)ESD->GetBunchCrossNumber();
	247	for(Int_t iChipKey=0; iChipKey < 1200; iChipKey++){
	248	if(mult->TestFiredChipMap(iChipKey)) {
	249	((TH1F*)fOutput->At(5))->Fill(iChipKey);
	250	if(bc>0)((TH2F*)fOutput->At(9))->Fill(iChipKey,bc%4);
	251	}
	252	if(mult->TestFastOrFiredChips(iChipKey)) ((TH1F*)fOutput->At(6))->Fill(iChipKey);
	253	if(mult->TestFastOrFiredChips(iChipKey) && mult->TestFiredChipMap(iChipKey)) {
	254	((TH1F*)fOutput->At(7))->Fill(iChipKey);
	255	if(bc>0) ((TH2F*)fOutput->At(8))->Fill(iChipKey,bc%4);
	256
	257	}
	258	if(mult->TestFastOrFiredChips(iChipKey) && !mult->TestFiredChipMap(iChipKey)) ((TH1F*)fOutput->At(10))->Fill(iChipKey);
	259	}
	260
	261
	262	Double_t vtxPos[3] = {999, 999, 999};
	263	if(vertex){
	264	vertex->GetXYZ(vtxPos);
	265
	266	((TH1F*)fOutput->At(15))->Fill(vtxPos[2]);
	267
	268	for(Int_t iTracklet =0; iTracklet < mult->GetNumberOfTracklets(); iTracklet++){
4587ea58	269
3c9441f1	270	Float_t phiTr= mult->GetPhi(iTracklet);
	271	Float_t etaTr =mult->GetEta(iTracklet);
	272
	273	((TH2F*)fOutput->At(12))->Fill(etaTr,phiTr);
	274
	275	// Z pos or Z neg
	276	Float_t z = vtxPos[2] + 3.9 / TMath::Tan(2 * TMath::ATan(TMath::Exp(- etaTr)));
	277	if(z>0) ((TH1F*)fOutput->At(13))->Fill(phiTr);
	278	else ((TH1F*)fOutput->At(14))->Fill(phiTr);
	279	}
	280	}
	281
	282
	283	if(recP){
4587ea58	284	// RecPoints info
	285
	286	TClonesArray statITSrec("AliITSRecPoint");
	287	TClonesArray *ITSCluster = &statITSrec;
	288	TBranch* branch=treeRP->GetBranch("ITSRecPoints");
	289	if(!branch) {
	290	printf("NO treeRP branch available. Exiting...\n");
	291	return;
	292	}
	293
	294	branch->SetAddress(&ITSCluster);
	295
4587ea58	296	for(Int_t iMod=0;iMod<240;iMod++){
	297	branch->GetEvent(iMod);
	298	Int_t nrecp = statITSrec.GetEntries();
	299	if(nrecp>0) ((TH1F*)fOutput->At(2))->Fill(iMod,nrecp);
	300
	301	for(Int_t irec=0;irec<nrecp;irec++) {
	302	AliITSRecPoint recp = (AliITSRecPoint)statITSrec.At(irec);
	303	Int_t lay=recp->GetLayer();
	304	if(lay>1) continue;
	305
	306	// ---- Filling maps (local coordinates rearranged) -----
	307	Float_t local[3]={-1,-1};
	308	local[1]=recp->GetDetLocalX();
	309	local[0]=recp->GetDetLocalZ();
	310	Int_t eq = AliSPDUtils::GetOnlineEqIdFromOffline(iMod);
	311	Int_t hs = AliSPDUtils::GetOnlineHSFromOffline(iMod);
	312	Int_t row, col;
	313	fSegSPD->LocalToDet(0.5,local[0],row,col);
	314	Int_t chip = AliSPDUtils::GetOnlineChipFromOffline(iMod,col);
	315
	316	Double_t locx, locz, equip;
	317	Double_t corrlocz =0;
	318	if(lay==0) corrlocz=local[0];
	319	else corrlocz = -local[0];
	320	// rearranging local geometry
	321	if(eq<10) equip=eq;
	322	else equip=eq-10;
	323	if(eq<10){
	324	if(chip<5) locz =corrlocz +8 +4;
	325	else locz = corrlocz+4;
	326	} else {
	327	if(chip<5) locz = corrlocz-8-4;
	328	else locz = corrlocz-4;
	329	}
	330	// filling maps
	331	if(lay==0){
	332	locx = (local[1]+1) + hs2 +equip4;
	333	((TH2D*)fOutput->At(0))->Fill(locz,locx);
	334
	335	} else {
	336	locx = (local[1]+1) + (hs-2)2 +equip8;
	337	((TH2D*)fOutput->At(1))->Fill(locz,locx);
	338	}
	339	// ---- End Filling maps (local coordinates rearranged) -----
	340
4587ea58	341	((TH1F*)fOutput->At(3))->Fill(AliSPDUtils::GetOfflineChipKeyFromOnline(eq,hs,chip));
	342	((TH1F)fOutput->At(4))->Fill(eq60+hs*10+chip);
	343
	344	}
	345	}
3c9441f1	346	}// end if rec points are available
4587ea58	347
4587ea58	348
4587ea58	349
4587ea58	350
	351	/* PostData(0) is taken care of by AliAnalysisTaskSE */
	352	PostData(1,fOutput) ;
	353
	354	}
	355
	356
	357	//___________________________________________________________________________
	358	void AliAnalysisTaskSPD::Terminate(Option_t*)
	359	{
	360	// The Terminate() function is the last function to be called during
	361	// a query. It always runs on the client, it can be used to present
	362	// the results graphically or save the results to file.
	363
4587ea58	364	AliAnalysisTaskSE::Terminate();
	365	}
	366
	367
	368
	369	//___________________________________________________________________________
	370	void AliAnalysisTaskSPD::LoadGeometryFromOCDB(){
	371	//method to get the gGeomanager
	372	// it is called at the CreatedOutputObject stage
	373	// to comply with the CAF environment
	374	AliCDBManager *man = AliCDBManager::Instance();
	375	man->SetDefaultStorage(fOCDBLocation.Data());
	376	man->SetRun(fRunNb);
	377	AliCDBEntry* obj = man->Get(AliCDBPath("GRP", "Geometry", "Data"));
	378	AliGeomManager::SetGeometry((TGeoManager*)obj->GetObject());
	379	AliGeomManager::GetNalignable("ITS");
	380	AliGeomManager::ApplyAlignObjsFromCDB("ITS");
	381	}
	382
	383
	384	#endif