[u/mrichter/AliRoot.git] / PWGJE / EMCALJetTasks / AliAnalysisTaskScale.cxx

// $Id$
//
// Scale task.
//
// Author: R.Reed, M.Connors

#include "AliAnalysisTaskScale.h"

#include <TClonesArray.h>
#include <TF1.h>
#include <TH2F.h>
#include <TLorentzVector.h>
#include <TMath.h>

#include "AliEMCALGeometry.h"
#include "AliLog.h"
#include "AliVCluster.h"
#include "AliVTrack.h"

ClassImp(AliAnalysisTaskScale)

//________________________________________________________________________
AliAnalysisTaskScale::AliAnalysisTaskScale() : 
  AliAnalysisTaskEmcal("AliAnalysisTaskScale", kTRUE), 
  fScaleFunction(0),
  fHistPtTPCvsCent(0), 
  fHistPtEMCALvsCent(0), 
  fHistEtvsCent(0),  
  fHistScalevsCent(0),  
  fHistDeltaScalevsCent(0), 
  fHistScaleEmcalvsCent(0),      
  fHistScale2EmcalvsCent(0),     
  fHistChScalevsCent(0),          
  fHistChScale2EmcalvsCent(0),   
  fHistPtTPCvsNtrack(0), 
  fHistPtEMCALvsNtrack(0), 
  fHistEtvsNtrack(0),  
  fHistScalevsNtrack(0),  
  fHistDeltaScalevsNtrack(0),
  fHistScaleEmcalvsNtrack(0),      
  fHistScale2EmcalvsNtrack(0),     
  fHistChScalevsNtrack(0),          
  fHistChScale2EmcalvsNtrack(0),   
  fHistTrackPtvsCent(0), 
  fHistClusterPtvsCent(0),
  fHistTrackEtaPhi(0), 
  fHistClusterEtaPhi(0),
  fHistScalevsScale2Emcal(0),      
  fHistScalevsScaleEmcal(0),       
  fHistScaleEmcalvsScale2Emcal(0)
{
  // Default constructor.

  SetMakeGeneralHistograms(kTRUE);
}

//________________________________________________________________________
AliAnalysisTaskScale::AliAnalysisTaskScale(const char *name) :
  AliAnalysisTaskEmcal(name, kTRUE), 
  fScaleFunction(0),
  fHistPtTPCvsCent(0), 
  fHistPtEMCALvsCent(0), 
  fHistEtvsCent(0),  
  fHistScalevsCent(0),  
  fHistDeltaScalevsCent(0), 
  fHistScaleEmcalvsCent(0),      
  fHistScale2EmcalvsCent(0),     
  fHistChScalevsCent(0),          
  fHistChScale2EmcalvsCent(0),   
  fHistPtTPCvsNtrack(0), 
  fHistPtEMCALvsNtrack(0), 
  fHistEtvsNtrack(0),  
  fHistScalevsNtrack(0),  
  fHistDeltaScalevsNtrack(0),
  fHistScaleEmcalvsNtrack(0),      
  fHistScale2EmcalvsNtrack(0),     
  fHistChScalevsNtrack(0),          
  fHistChScale2EmcalvsNtrack(0),   
  fHistTrackPtvsCent(0), 
  fHistClusterPtvsCent(0),
  fHistTrackEtaPhi(0), 
  fHistClusterEtaPhi(0),
  fHistScalevsScale2Emcal(0),      
  fHistScalevsScaleEmcal(0),       
  fHistScaleEmcalvsScale2Emcal(0)
{
  // Constructor.

  SetMakeGeneralHistograms(kTRUE);
}

//________________________________________________________________________
void AliAnalysisTaskScale::UserCreateOutputObjects()
{
  // Create my user objects.

  AliAnalysisTaskEmcal::UserCreateOutputObjects();

  fHistPtTPCvsCent             = new TH2F("PtTPCvsCent","rho vs cent",            101, -1, 100,   500,   0, 1000);
  fHistPtEMCALvsCent           = new TH2F("PtEMCALvsCent","rho vs cent",          101, -1, 100,   500,   0, 1000);
  fHistEtvsCent                = new TH2F("EtvsCent","rho vs cent",               101, -1, 100,   500,   0, 1000);
  fHistScalevsCent             = new TH2F("ScalevsCent","rho vs cent",            101, -1, 100,   500,   0, 5);
  fHistDeltaScalevsCent        = new TH2F("DeltaScalevsCent","rho vs cent",       101, -1, 100,   500,  -2.5, 2.5);
  fHistScaleEmcalvsCent        = new TH2F("ScaleEmcalvsCent","",                  101, -1, 100,   500,   0, 5);
  fHistScale2EmcalvsCent       = new TH2F("Scale2EmcalvsCent","",                 101, -1, 100,   500,   0, 5);
  fHistChScalevsCent           = new TH2F("ChScalevsCent","",                     101, -1, 100,   500,   0, 5);
  fHistChScale2EmcalvsCent     = new TH2F("ChScale2EmcalvsCent","",               101, -1, 100,   500,   0, 5);
  fHistPtTPCvsNtrack           = new TH2F("PtTPCvsNtrack","rho vs cent",          500,  0, 2500,  500,   0, 1000);
  fHistPtEMCALvsNtrack         = new TH2F("PtEMCALvsNtrack","rho vs cent",        500,  0, 2500,  500,   0, 1000);
  fHistEtvsNtrack              = new TH2F("EtvsNtrack","rho vs cent",             500,  0, 2500,  500,   0, 1000);
  fHistScalevsNtrack           = new TH2F("ScalevsNtrack","rho vs cent",          500,  0, 2500,  500,   0, 5);
  fHistDeltaScalevsNtrack      = new TH2F("DeltaScalevsNtrack","rho vs cent",     500,  0, 2500,  500,  -2.5, 2.5);
  fHistScaleEmcalvsNtrack      = new TH2F("ScaleEmcalvsNtrack","",                500,  0, 2500,  500,   0, 5);
  fHistScale2EmcalvsNtrack     = new TH2F("Scale2EmcalvsNtrack","",               500,  0, 2500,  500,   0, 5);
  fHistChScalevsNtrack         = new TH2F("ChScalevsNtrack","",                   500,  0, 2500,  500,   0, 5);
  fHistChScale2EmcalvsNtrack   = new TH2F("ChScale2EmcalvsNtrack","",             500,  0, 2500,  500,   0, 5);
  fHistTrackPtvsCent           = new TH2F("TrackPtvsCent","Track pt vs cent",     101, -1, 100,   500,   0, 100);
  fHistClusterPtvsCent         = new TH2F("ClusterPtvsCent","Cluster pt vs cent", 101, -1, 100,   500,   0, 100);
  fHistTrackEtaPhi             = new TH2F("TrackEtaPhi","Track eta phi",          100, -1.0, 1.0, 101,   0, 2.02*TMath::Pi());
  fHistClusterEtaPhi           = new TH2F("ClusterEtaPhi","Cluster eta phi",      100, -1.0, 1.0, 101,   0, 2.02*TMath::Pi());
  fHistScalevsScale2Emcal      = new TH2F("ScalevsScale2Emcal","",                500,  0, 5,     500,   0, 5);
  fHistScalevsScaleEmcal       = new TH2F("ScalevsScaleEmcal","",                 500,  0, 5,     500,   0, 5);
  fHistScaleEmcalvsScale2Emcal = new TH2F("ScaleEmcalvsScale2Emcal","",           500,  0, 5,     500,   0, 5);

  fOutput->Add(fHistPtTPCvsCent);
  fOutput->Add(fHistPtEMCALvsCent);
  fOutput->Add(fHistEtvsCent);
  fOutput->Add(fHistScalevsCent);
  fOutput->Add(fHistDeltaScalevsCent);
  fOutput->Add(fHistScaleEmcalvsCent);      
  fOutput->Add(fHistScale2EmcalvsCent);     
  fOutput->Add(fHistChScalevsCent);    
  fOutput->Add(fHistChScale2EmcalvsCent);   
  fOutput->Add(fHistPtTPCvsNtrack);
  fOutput->Add(fHistPtEMCALvsNtrack);
  fOutput->Add(fHistEtvsNtrack);
  fOutput->Add(fHistScalevsNtrack);
  fOutput->Add(fHistDeltaScalevsNtrack);
  fOutput->Add(fHistScaleEmcalvsNtrack);      
  fOutput->Add(fHistScale2EmcalvsNtrack);     
  fOutput->Add(fHistChScalevsNtrack);    
  fOutput->Add(fHistChScale2EmcalvsNtrack);   
  fOutput->Add(fHistTrackPtvsCent);
  fOutput->Add(fHistClusterPtvsCent);
  fOutput->Add(fHistTrackEtaPhi);
  fOutput->Add(fHistClusterEtaPhi);
  fOutput->Add(fHistScalevsScale2Emcal);      
  fOutput->Add(fHistScalevsScaleEmcal);       
  fOutput->Add(fHistScaleEmcalvsScale2Emcal);

  PostData(1, fOutput);
}

//________________________________________________________________________
Double_t AliAnalysisTaskScale::GetScaleFactor(Double_t cent)
{
  // Get scale function.

  Double_t scale = -1;
  if (fScaleFunction)
    scale = fScaleFunction->Eval(cent);
  return scale;
}

//________________________________________________________________________
Bool_t AliAnalysisTaskScale::FillHistograms() 
{
  // Execute on each event.
  const Double_t EmcalMinEta = fGeom->GetArm1EtaMin();
  const Double_t EmcalMaxEta = fGeom->GetArm1EtaMax();
  const Double_t EmcalMinPhi = fGeom->GetArm1PhiMin() * TMath::DegToRad();
  const Double_t EmcalMaxPhi = fGeom->GetArm1PhiMax() * TMath::DegToRad();
  const Double_t EmcalWidth = (EmcalMaxPhi-EmcalMinPhi)/2.0;

  Double_t TpcMinPhi   = fTrackMinPhi;
  Double_t TpcMaxPhi   = fTrackMaxPhi;
  if (TpcMaxPhi > TMath::Pi()*2)
    TpcMaxPhi = TMath::Pi()*2;
  
  if (TpcMinPhi < 0)
    TpcMinPhi = 0;

  const Double_t TpcArea     = (TpcMaxPhi - TpcMinPhi) * (EmcalMinEta - EmcalMaxEta);
  const Double_t EmcalArea   = (EmcalMaxPhi - EmcalMinPhi) * (EmcalMinEta - EmcalMaxEta);

  Double_t ptTPC   = 0;
  Double_t ptEMCAL = 0;
  Double_t ptEMCAL2 = 0;

  const Int_t Ntracks = fTracks->GetEntries();
  for (Int_t iTracks = 0; iTracks < Ntracks; ++iTracks) {
    AliVTrack *track = static_cast<AliVTrack*>(fTracks->At(iTracks));

    if (!track)
      continue;

    if (!AcceptTrack(track))
      continue;

    if (TMath::Abs(track->Eta()) > 0.7)   // only accept tracks in the EMCal eta range
      continue;

    fHistTrackPtvsCent->Fill(fCent,track->Pt());
    fHistTrackEtaPhi->Fill(track->Eta(),track->Phi());
    ptTPC += track->Pt();
    if ((track->Phi() > (EmcalMaxPhi+EmcalWidth)) || (track->Phi() < (EmcalMinPhi-EmcalWidth)))
      continue;
    ptEMCAL2 += track->Pt();
    if ((track->Phi() > EmcalMaxPhi) || (track->Phi() < EmcalMinPhi))
      continue;
    ptEMCAL += track->Pt();
  }

  if (ptTPC == 0) 
    return kFALSE;
  
  Double_t Et = 0;
  const Int_t Nclus = fCaloClusters->GetEntries();
  for (Int_t iClus = 0; iClus < Nclus; ++iClus) {
    AliVCluster *c = static_cast<AliVCluster*>(fCaloClusters->At(iClus));
    if (!c)
      continue;

    if (!AcceptCluster(c))
      continue;

    TLorentzVector nPart;
    c->GetMomentum(nPart, fVertex);

    fHistClusterPtvsCent->Fill(fCent, nPart.Pt());
    fHistClusterEtaPhi->Fill(nPart.Eta(), nPart.Phi());

    Et += nPart.Pt();
  }

 
  const Double_t scalecalc         = ((Et + ptEMCAL) / EmcalArea) * (TpcArea / ptTPC);
  const Double_t scale             = GetScaleFactor(fCent);
  Double_t scalecalcemcal          = -1;
  if (ptEMCAL > 0)
    scalecalcemcal                 = (Et+ptEMCAL)/ptEMCAL;
  Double_t scalecalcemcal2         = -1;
  Double_t Chscalecalcemcal2       = -1;
  if (ptEMCAL2 > 0){
    scalecalcemcal2                = 2*(Et+ptEMCAL)/ptEMCAL2;
    Chscalecalcemcal2              = 2*ptEMCAL/ptEMCAL2;}
  const Double_t Chscalecalcemcal  = ((ptEMCAL) / EmcalArea) * (TpcArea / ptTPC);

  fHistScaleEmcalvsCent->Fill(fCent,scalecalcemcal);      
  fHistScale2EmcalvsCent->Fill(fCent,scalecalcemcal2);     
  fHistChScalevsCent->Fill(fCent,Chscalecalcemcal);    
  fHistChScale2EmcalvsCent->Fill(fCent,Chscalecalcemcal2);   
  fHistScaleEmcalvsNtrack->Fill(Ntracks,scalecalcemcal);      
  fHistScale2EmcalvsNtrack->Fill(Ntracks,scalecalcemcal2);     
  fHistChScalevsNtrack->Fill(Ntracks,Chscalecalcemcal);    
  fHistChScale2EmcalvsNtrack->Fill(Ntracks,Chscalecalcemcal2);   
  fHistPtTPCvsCent->Fill(fCent, ptTPC);
  fHistPtEMCALvsCent->Fill(fCent, ptEMCAL);
  fHistEtvsCent->Fill(fCent, Et);
  fHistScalevsCent->Fill(fCent, scalecalc);
  fHistDeltaScalevsCent->Fill(fCent, scalecalc - scale);
  fHistPtTPCvsNtrack->Fill(Ntracks, ptTPC);
  fHistPtEMCALvsNtrack->Fill(Ntracks, ptEMCAL);
  fHistEtvsNtrack->Fill(Ntracks, Et);
  fHistScalevsNtrack->Fill(Ntracks, scalecalc);
  fHistDeltaScalevsNtrack->Fill(Ntracks, scalecalc - scale);
  fHistScalevsScale2Emcal->Fill(scalecalc,scalecalcemcal2);      
  fHistScalevsScaleEmcal->Fill(scalecalc,scalecalcemcal); 
  fHistScaleEmcalvsScale2Emcal->Fill(scalecalcemcal,scalecalcemcal2);

  return kTRUE;
}
Commit	Line	Data
0b777a09	1	// $Id$
4a6b693d	2	//
	3	// Scale task.
	4	//
68263112	5	// Author: R.Reed, M.Connors
0b777a09	6
c25dc25a	7	#include "AliAnalysisTaskScale.h"
c25dc25a	8
0b777a09	9	#include <TClonesArray.h>
c25dc25a	10	#include <TF1.h>
8154249f	11	#include <TH2F.h>
0b777a09	12	#include <TLorentzVector.h>
73e2fd59	13	#include <TMath.h>
b1dfb3f4	14
40e2fd10	15	#include "AliEMCALGeometry.h"
40e2fd10	16	#include "AliLog.h"
c25dc25a	17	#include "AliVCluster.h"
c25dc25a	18	#include "AliVTrack.h"
0b777a09	19
	20	ClassImp(AliAnalysisTaskScale)
	21
c25dc25a	22	//________________________________________________________________________
c25dc25a	23	AliAnalysisTaskScale::AliAnalysisTaskScale() :
e44e8726	24	AliAnalysisTaskEmcal("AliAnalysisTaskScale", kTRUE),
c25dc25a	25	fScaleFunction(0),
c25dc25a	26	fHistPtTPCvsCent(0),
	27	fHistPtEMCALvsCent(0),
	28	fHistEtvsCent(0),
	29	fHistScalevsCent(0),
	30	fHistDeltaScalevsCent(0),
a828ea11	31	fHistScaleEmcalvsCent(0),
	32	fHistScale2EmcalvsCent(0),
	33	fHistChScalevsCent(0),
	34	fHistChScale2EmcalvsCent(0),
c25dc25a	35	fHistPtTPCvsNtrack(0),
	36	fHistPtEMCALvsNtrack(0),
	37	fHistEtvsNtrack(0),
	38	fHistScalevsNtrack(0),
	39	fHistDeltaScalevsNtrack(0),
a828ea11	40	fHistScaleEmcalvsNtrack(0),
	41	fHistScale2EmcalvsNtrack(0),
	42	fHistChScalevsNtrack(0),
	43	fHistChScale2EmcalvsNtrack(0),
c25dc25a	44	fHistTrackPtvsCent(0),
	45	fHistClusterPtvsCent(0),
	46	fHistTrackEtaPhi(0),
a828ea11	47	fHistClusterEtaPhi(0),
	48	fHistScalevsScale2Emcal(0),
	49	fHistScalevsScaleEmcal(0),
	50	fHistScaleEmcalvsScale2Emcal(0)
c25dc25a	51	{
c25dc25a	52	// Default constructor.
73e2fd59	53
73e2fd59	54	SetMakeGeneralHistograms(kTRUE);
c25dc25a	55	}
c25dc25a	56
0b777a09	57	//________________________________________________________________________
b1dfb3f4	58	AliAnalysisTaskScale::AliAnalysisTaskScale(const char *name) :
e44e8726	59	AliAnalysisTaskEmcal(name, kTRUE),
b1dfb3f4	60	fScaleFunction(0),
b1dfb3f4	61	fHistPtTPCvsCent(0),
	62	fHistPtEMCALvsCent(0),
	63	fHistEtvsCent(0),
	64	fHistScalevsCent(0),
	65	fHistDeltaScalevsCent(0),
a828ea11	66	fHistScaleEmcalvsCent(0),
	67	fHistScale2EmcalvsCent(0),
	68	fHistChScalevsCent(0),
	69	fHistChScale2EmcalvsCent(0),
b1dfb3f4	70	fHistPtTPCvsNtrack(0),
	71	fHistPtEMCALvsNtrack(0),
	72	fHistEtvsNtrack(0),
	73	fHistScalevsNtrack(0),
a5e84976	74	fHistDeltaScalevsNtrack(0),
a828ea11	75	fHistScaleEmcalvsNtrack(0),
	76	fHistScale2EmcalvsNtrack(0),
	77	fHistChScalevsNtrack(0),
	78	fHistChScale2EmcalvsNtrack(0),
a5e84976	79	fHistTrackPtvsCent(0),
	80	fHistClusterPtvsCent(0),
	81	fHistTrackEtaPhi(0),
a828ea11	82	fHistClusterEtaPhi(0),
	83	fHistScalevsScale2Emcal(0),
	84	fHistScalevsScaleEmcal(0),
	85	fHistScaleEmcalvsScale2Emcal(0)
0b777a09	86	{
4a6b693d	87	// Constructor.
0b777a09	88
73e2fd59	89	SetMakeGeneralHistograms(kTRUE);
0b777a09	90	}
	91
	92	//________________________________________________________________________
	93	void AliAnalysisTaskScale::UserCreateOutputObjects()
	94	{
4a6b693d	95	// Create my user objects.
4a6b693d	96
73e2fd59	97	AliAnalysisTaskEmcal::UserCreateOutputObjects();
0b777a09	98
a828ea11	99	fHistPtTPCvsCent = new TH2F("PtTPCvsCent","rho vs cent", 101, -1, 100, 500, 0, 1000);
	100	fHistPtEMCALvsCent = new TH2F("PtEMCALvsCent","rho vs cent", 101, -1, 100, 500, 0, 1000);
	101	fHistEtvsCent = new TH2F("EtvsCent","rho vs cent", 101, -1, 100, 500, 0, 1000);
	102	fHistScalevsCent = new TH2F("ScalevsCent","rho vs cent", 101, -1, 100, 500, 0, 5);
	103	fHistDeltaScalevsCent = new TH2F("DeltaScalevsCent","rho vs cent", 101, -1, 100, 500, -2.5, 2.5);
	104	fHistScaleEmcalvsCent = new TH2F("ScaleEmcalvsCent","", 101, -1, 100, 500, 0, 5);
	105	fHistScale2EmcalvsCent = new TH2F("Scale2EmcalvsCent","", 101, -1, 100, 500, 0, 5);
	106	fHistChScalevsCent = new TH2F("ChScalevsCent","", 101, -1, 100, 500, 0, 5);
	107	fHistChScale2EmcalvsCent = new TH2F("ChScale2EmcalvsCent","", 101, -1, 100, 500, 0, 5);
	108	fHistPtTPCvsNtrack = new TH2F("PtTPCvsNtrack","rho vs cent", 500, 0, 2500, 500, 0, 1000);
	109	fHistPtEMCALvsNtrack = new TH2F("PtEMCALvsNtrack","rho vs cent", 500, 0, 2500, 500, 0, 1000);
	110	fHistEtvsNtrack = new TH2F("EtvsNtrack","rho vs cent", 500, 0, 2500, 500, 0, 1000);
	111	fHistScalevsNtrack = new TH2F("ScalevsNtrack","rho vs cent", 500, 0, 2500, 500, 0, 5);
	112	fHistDeltaScalevsNtrack = new TH2F("DeltaScalevsNtrack","rho vs cent", 500, 0, 2500, 500, -2.5, 2.5);
	113	fHistScaleEmcalvsNtrack = new TH2F("ScaleEmcalvsNtrack","", 500, 0, 2500, 500, 0, 5);
	114	fHistScale2EmcalvsNtrack = new TH2F("Scale2EmcalvsNtrack","", 500, 0, 2500, 500, 0, 5);
	115	fHistChScalevsNtrack = new TH2F("ChScalevsNtrack","", 500, 0, 2500, 500, 0, 5);
	116	fHistChScale2EmcalvsNtrack = new TH2F("ChScale2EmcalvsNtrack","", 500, 0, 2500, 500, 0, 5);
	117	fHistTrackPtvsCent = new TH2F("TrackPtvsCent","Track pt vs cent", 101, -1, 100, 500, 0, 100);
	118	fHistClusterPtvsCent = new TH2F("ClusterPtvsCent","Cluster pt vs cent", 101, -1, 100, 500, 0, 100);
	119	fHistTrackEtaPhi = new TH2F("TrackEtaPhi","Track eta phi", 100, -1.0, 1.0, 101, 0, 2.02*TMath::Pi());
	120	fHistClusterEtaPhi = new TH2F("ClusterEtaPhi","Cluster eta phi", 100, -1.0, 1.0, 101, 0, 2.02*TMath::Pi());
	121	fHistScalevsScale2Emcal = new TH2F("ScalevsScale2Emcal","", 500, 0, 5, 500, 0, 5);
	122	fHistScalevsScaleEmcal = new TH2F("ScalevsScaleEmcal","", 500, 0, 5, 500, 0, 5);
	123	fHistScaleEmcalvsScale2Emcal = new TH2F("ScaleEmcalvsScale2Emcal","", 500, 0, 5, 500, 0, 5);
	124
e44e8726	125	fOutput->Add(fHistPtTPCvsCent);
	126	fOutput->Add(fHistPtEMCALvsCent);
	127	fOutput->Add(fHistEtvsCent);
	128	fOutput->Add(fHistScalevsCent);
	129	fOutput->Add(fHistDeltaScalevsCent);
a828ea11	130	fOutput->Add(fHistScaleEmcalvsCent);
	131	fOutput->Add(fHistScale2EmcalvsCent);
	132	fOutput->Add(fHistChScalevsCent);
	133	fOutput->Add(fHistChScale2EmcalvsCent);
e44e8726	134	fOutput->Add(fHistPtTPCvsNtrack);
	135	fOutput->Add(fHistPtEMCALvsNtrack);
	136	fOutput->Add(fHistEtvsNtrack);
	137	fOutput->Add(fHistScalevsNtrack);
	138	fOutput->Add(fHistDeltaScalevsNtrack);
a828ea11	139	fOutput->Add(fHistScaleEmcalvsNtrack);
	140	fOutput->Add(fHistScale2EmcalvsNtrack);
	141	fOutput->Add(fHistChScalevsNtrack);
	142	fOutput->Add(fHistChScale2EmcalvsNtrack);
e44e8726	143	fOutput->Add(fHistTrackPtvsCent);
	144	fOutput->Add(fHistClusterPtvsCent);
	145	fOutput->Add(fHistTrackEtaPhi);
	146	fOutput->Add(fHistClusterEtaPhi);
a828ea11	147	fOutput->Add(fHistScalevsScale2Emcal);
	148	fOutput->Add(fHistScalevsScaleEmcal);
	149	fOutput->Add(fHistScaleEmcalvsScale2Emcal);
e44e8726	150
e44e8726	151	PostData(1, fOutput);
0b777a09	152	}
0b777a09	153
b1dfb3f4	154	//________________________________________________________________________
	155	Double_t AliAnalysisTaskScale::GetScaleFactor(Double_t cent)
	156	{
c25dc25a	157	// Get scale function.
c25dc25a	158
b1dfb3f4	159	Double_t scale = -1;
	160	if (fScaleFunction)
	161	scale = fScaleFunction->Eval(cent);
	162	return scale;
	163	}
	164
e44e8726	165	//________________________________________________________________________
	166	Bool_t AliAnalysisTaskScale::FillHistograms()
	167	{
	168	// Execute on each event.
40e2fd10	169	const Double_t EmcalMinEta = fGeom->GetArm1EtaMin();
	170	const Double_t EmcalMaxEta = fGeom->GetArm1EtaMax();
	171	const Double_t EmcalMinPhi = fGeom->GetArm1PhiMin() * TMath::DegToRad();
	172	const Double_t EmcalMaxPhi = fGeom->GetArm1PhiMax() * TMath::DegToRad();
a828ea11	173	const Double_t EmcalWidth = (EmcalMaxPhi-EmcalMinPhi)/2.0;
0b777a09	174
a828ea11	175	Double_t TpcMinPhi = fTrackMinPhi;
	176	Double_t TpcMaxPhi = fTrackMaxPhi;
	177	if (TpcMaxPhi > TMath::Pi()*2)
	178	TpcMaxPhi = TMath::Pi()*2;
	179
	180	if (TpcMinPhi < 0)
	181	TpcMinPhi = 0;
40e2fd10	182
	183	const Double_t TpcArea = (TpcMaxPhi - TpcMinPhi) * (EmcalMinEta - EmcalMaxEta);
	184	const Double_t EmcalArea = (EmcalMaxPhi - EmcalMinPhi) * (EmcalMinEta - EmcalMaxEta);
b1dfb3f4	185
85211d8e	186	Double_t ptTPC = 0;
85211d8e	187	Double_t ptEMCAL = 0;
a828ea11	188	Double_t ptEMCAL2 = 0;
b1dfb3f4	189
e44e8726	190	const Int_t Ntracks = fTracks->GetEntries();
0b777a09	191	for (Int_t iTracks = 0; iTracks < Ntracks; ++iTracks) {
e44e8726	192	AliVTrack track = static_cast<AliVTrack>(fTracks->At(iTracks));
b1dfb3f4	193
0b777a09	194	if (!track)
0b777a09	195	continue;
b1dfb3f4	196
e44e8726	197	if (!AcceptTrack(track))
	198	continue;
	199
b1dfb3f4	200	if (TMath::Abs(track->Eta()) > 0.7) // only accept tracks in the EMCal eta range
0b777a09	201	continue;
b1dfb3f4	202
e44e8726	203	fHistTrackPtvsCent->Fill(fCent,track->Pt());
a5e84976	204	fHistTrackEtaPhi->Fill(track->Eta(),track->Phi());
b1dfb3f4	205	ptTPC += track->Pt();
a828ea11	206	if ((track->Phi() > (EmcalMaxPhi+EmcalWidth)) \|\| (track->Phi() < (EmcalMinPhi-EmcalWidth)))
	207	continue;
	208	ptEMCAL2 += track->Pt();
b1dfb3f4	209	if ((track->Phi() > EmcalMaxPhi) \|\| (track->Phi() < EmcalMinPhi))
0b777a09	210	continue;
b1dfb3f4	211	ptEMCAL += track->Pt();
85211d8e	212	}
e44e8726	213
	214	if (ptTPC == 0)
	215	return kFALSE;
0b777a09	216
85211d8e	217	Double_t Et = 0;
e44e8726	218	const Int_t Nclus = fCaloClusters->GetEntries();
4a6b693d	219	for (Int_t iClus = 0; iClus < Nclus; ++iClus) {
e44e8726	220	AliVCluster c = static_cast<AliVCluster>(fCaloClusters->At(iClus));
d03084cd	221	if (!c)
d03084cd	222	continue;
e44e8726	223
e44e8726	224	if (!AcceptCluster(c))
0b777a09	225	continue;
a5e84976	226
e44e8726	227	TLorentzVector nPart;
e44e8726	228	c->GetMomentum(nPart, fVertex);
a5e84976	229
e44e8726	230	fHistClusterPtvsCent->Fill(fCent, nPart.Pt());
e44e8726	231	fHistClusterEtaPhi->Fill(nPart.Eta(), nPart.Phi());
a5e84976	232
85211d8e	233	Et += nPart.Pt();
0b777a09	234	}
bb1b4cb8	235
a828ea11	236
	237	const Double_t scalecalc = ((Et + ptEMCAL) / EmcalArea) * (TpcArea / ptTPC);
	238	const Double_t scale = GetScaleFactor(fCent);
	239	Double_t scalecalcemcal = -1;
	240	if (ptEMCAL > 0)
	241	scalecalcemcal = (Et+ptEMCAL)/ptEMCAL;
	242	Double_t scalecalcemcal2 = -1;
	243	Double_t Chscalecalcemcal2 = -1;
	244	if (ptEMCAL2 > 0){
	245	scalecalcemcal2 = 2*(Et+ptEMCAL)/ptEMCAL2;
	246	Chscalecalcemcal2 = 2*ptEMCAL/ptEMCAL2;}
	247	const Double_t Chscalecalcemcal = ((ptEMCAL) / EmcalArea) * (TpcArea / ptTPC);
	248
	249	fHistScaleEmcalvsCent->Fill(fCent,scalecalcemcal);
	250	fHistScale2EmcalvsCent->Fill(fCent,scalecalcemcal2);
	251	fHistChScalevsCent->Fill(fCent,Chscalecalcemcal);
	252	fHistChScale2EmcalvsCent->Fill(fCent,Chscalecalcemcal2);
	253	fHistScaleEmcalvsNtrack->Fill(Ntracks,scalecalcemcal);
	254	fHistScale2EmcalvsNtrack->Fill(Ntracks,scalecalcemcal2);
	255	fHistChScalevsNtrack->Fill(Ntracks,Chscalecalcemcal);
	256	fHistChScale2EmcalvsNtrack->Fill(Ntracks,Chscalecalcemcal2);
e44e8726	257	fHistPtTPCvsCent->Fill(fCent, ptTPC);
	258	fHistPtEMCALvsCent->Fill(fCent, ptEMCAL);
	259	fHistEtvsCent->Fill(fCent, Et);
	260	fHistScalevsCent->Fill(fCent, scalecalc);
	261	fHistDeltaScalevsCent->Fill(fCent, scalecalc - scale);
b1dfb3f4	262	fHistPtTPCvsNtrack->Fill(Ntracks, ptTPC);
	263	fHistPtEMCALvsNtrack->Fill(Ntracks, ptEMCAL);
	264	fHistEtvsNtrack->Fill(Ntracks, Et);
	265	fHistScalevsNtrack->Fill(Ntracks, scalecalc);
	266	fHistDeltaScalevsNtrack->Fill(Ntracks, scalecalc - scale);
a828ea11	267	fHistScalevsScale2Emcal->Fill(scalecalc,scalecalcemcal2);
	268	fHistScalevsScaleEmcal->Fill(scalecalc,scalecalcemcal);
	269	fHistScaleEmcalvsScale2Emcal->Fill(scalecalcemcal,scalecalcemcal2);
0b777a09	270
e44e8726	271	return kTRUE;
4a6b693d	272	}