[u/mrichter/AliRoot.git] / PWGGA / EMCALJetTasks / UserTasks / AliAnalysisTaskEmcalJetHMEC.cxx

// $Id$

#include "AliAnalysisTaskEmcalJetHMEC.h"

#include "TChain.h"
#include "TTree.h"
#include "TList.h"
#include "TH1F.h"
#include "TH2F.h"
#include "THnSparse.h"
#include "TCanvas.h"
#include <TClonesArray.h>
#include <TParticle.h>
#include "AliVTrack.h"
#include "TParameter.h"

#include "AliAODEvent.h"
#include "AliAnalysisTask.h"
#include "AliAnalysisManager.h"

#include "AliESDEvent.h"
#include "AliESDInputHandler.h"
#include "AliESDCaloCluster.h"
#include "AliESDVertex.h"
#include "AliCentrality.h"
#include "AliAODJet.h"
#include "AliEmcalJet.h"
#include "AliESDtrackCuts.h"

#include "TVector3.h"
#include "AliPicoTrack.h"
#include "AliEventPoolManager.h"

ClassImp(AliAnalysisTaskEmcalJetHMEC)

//________________________________________________________________________
AliAnalysisTaskEmcalJetHMEC::AliAnalysisTaskEmcalJetHMEC() : 
  AliAnalysisTaskSE(),
  fTracksName("tracks"),
  fJetsName("jets"),
  fPhimin(-10), 
  fPhimax(10),
  fEtamin(-0.9), 
  fEtamax(0.9),
  fAreacut(0.0),
  fESD(0), 
  fPoolMgr(0x0), 
  fOutputList(0),
  fHistTrackPt(0),
  fHistCentrality(0), 
  fHistJetEtaPhi(0), 
  fHistTrackEtaPhi(0), 
  fHistJetHEtaPhi(0) 
{
  // Default Constructor

  for(Int_t icent = 0; icent<6; ++icent){
    fHistJetPt[icent]=0;
    fHistJetPtBias[icent]=0;
    fHistJetPtTT[icent]=0;
    for(Int_t iptjet = 0; iptjet<5; ++iptjet){
      for(Int_t ieta = 0; ieta<3; ++ieta){	
	fHistJetH[icent][iptjet][ieta]=0;
	fHistJetHBias[icent][iptjet][ieta]=0;
	fHistJetHTT[icent][iptjet][ieta]=0;

      }
    }
  }

}
//________________________________________________________________________
AliAnalysisTaskEmcalJetHMEC::AliAnalysisTaskEmcalJetHMEC(const char *name) : 
  AliAnalysisTaskSE(name),
  fTracksName("tracks"),
  fJetsName("jets"),
  fPhimin(-10), 
  fPhimax(10),
  fEtamin(-0.9), 
  fEtamax(0.9),
  fAreacut(0.0),
  fDoEventMixing(0),
  fMixingTracks(50000),
  fESD(0), 
  fPoolMgr(0x0), 
  fOutputList(0), 
  fHistTrackPt(0),
  fHistCentrality(0), 
  fHistJetEtaPhi(0), 
  fHistTrackEtaPhi(0), 
  fHistJetHEtaPhi(0),
  fNevents(0),
  fTindex(0),
  fTrigBufferIndex(0),
  fCountAgain(0), 
  fhnMixedEvents(0x0)
{
  // Constructor
  for(Int_t icent = 0; icent<6; ++icent){
    fHistJetPt[icent]=0;
    fHistJetPtBias[icent]=0;
    fHistJetPtTT[icent]=0;
    for(Int_t iptjet = 0; iptjet<5; ++iptjet){
      for(Int_t ieta = 0; ieta<3; ++ieta){	
	fHistJetH[icent][iptjet][ieta]=0;
	fHistJetHBias[icent][iptjet][ieta]=0;
	fHistJetHTT[icent][iptjet][ieta]=0;
      }
    }
  }

    for(Int_t i=0; i<10; i++) {
       for(Int_t j=0; j<6; j++) {
	    fTrigBuffer[i][j]=0;
		}				
    }	


  DefineInput(0, TChain::Class());
  DefineOutput(1, TList::Class());

}

//________________________________________________________________________
void AliAnalysisTaskEmcalJetHMEC::UserCreateOutputObjects()
{
  // Called once

 
  AliVEventHandler* handler = AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler();
  if (!handler) {
    AliError("Input handler not available!");
    return;
  }

  OpenFile(1);
  fOutputList = new TList();
  fOutputList->SetOwner();


  // Create histograms
  fHistTrackPt = new TH1F("fHistTrackPt", "P_{T} distribution", 1000, 0.0, 100.0);


  fHistCentrality = new TH1F("fHistCentrality","centrality",100,0,100);

  fHistJetEtaPhi = new TH2F("fHistJetEtaPhi","Jet eta-phi",900,-1.8,1.8,640,-3.2,3.2);
  fHistTrackEtaPhi = new TH2F("fHistTrackEtaPhi","Track eta-phi",900,-1.8,1.8,640,-3.2,3.2);
  fHistJetHEtaPhi = new TH2F("fHistJetHEtaPhi","Jet-Hadron deta-dphi",900,-1.8,1.8,640,-1.6,4.8);

  char name[200];

 
  for(Int_t icent = 0; icent<6; ++icent){
    sprintf(name,"fHistJetPt_%i",icent);   
    fHistJetPt[icent] = new TH1F(name,name,200,0,200);
    fOutputList->Add(fHistJetPt[icent]);

    sprintf(name,"fHistJetPtBias_%i",icent);   
    fHistJetPtBias[icent] = new TH1F(name,name,200,0,200);
    fOutputList->Add(fHistJetPtBias[icent]);

    sprintf(name,"fHistJetPtTT_%i",icent);   
    fHistJetPtTT[icent] = new TH1F(name,name,200,0,200);
    fOutputList->Add(fHistJetPtTT[icent]);

    for(Int_t iptjet = 0; iptjet<5; ++iptjet){
      for(Int_t ieta = 0; ieta<3; ++ieta){	
	sprintf(name,"fHistJetH_%i_%i_%i",icent,iptjet,ieta);   
	fHistJetH[icent][iptjet][ieta]=new TH2F(name,name,64,-0.5*TMath::Pi(),1.5*TMath::Pi(),300,0,30);
	fOutputList->Add(fHistJetH[icent][iptjet][ieta]);

	sprintf(name,"fHistJetHBias_%i_%i_%i",icent,iptjet,ieta);   
	fHistJetHBias[icent][iptjet][ieta]=new TH2F(name,name,64,-0.5*TMath::Pi(),1.5*TMath::Pi(),300,0,30);
	fOutputList->Add(fHistJetHBias[icent][iptjet][ieta]);

	sprintf(name,"fHistJetHTT_%i_%i_%i",icent,iptjet,ieta);   
	fHistJetHTT[icent][iptjet][ieta]=new TH2F(name,name,64,-0.5*TMath::Pi(),1.5*TMath::Pi(),300,0,30);
	fOutputList->Add(fHistJetHTT[icent][iptjet][ieta]);

      }
    }
  }

  if(fDoEventMixing){    
     UInt_t cifras = 0; // bit coded, see GetDimParams() below 
     cifras = 1<<0 | 1<<1 | 1<<2 | 1<<3 | 1<<4 | 1<<5 | 1<<7; 
     fhnMixedEvents = NewTHnSparseF("fhnMixedEvents", cifras);
     }


  fOutputList->Add(fHistTrackPt);
  fOutputList->Add(fHistCentrality);
  fOutputList->Add(fHistJetEtaPhi);
  fOutputList->Add(fHistTrackEtaPhi);
  fOutputList->Add(fHistJetHEtaPhi);
   fOutputList->Add(fhnMixedEvents);


  PostData(1, fOutputList);


  //Event Mixing
  Int_t trackDepth = fMixingTracks; 
  Int_t poolsize   = 1000;  // Maximum number of events, ignored in the present implemented of AliEventPoolManager
 
  Int_t nZvtxBins  = 7+1+7;
  // bins for second buffer are shifted by 100 cm
  Double_t vertexBins[] = { -7, -5, -3, -1, 1, 3, 5, 7, 93, 95, 97, 99, 101, 103, 105, 107 };
  Double_t* zvtxbin = vertexBins;

  Int_t nCentralityBins  = 100;
  Double_t centralityBins[nCentralityBins];
  for(Int_t ic=0; ic<nCentralityBins; ic++){
    centralityBins[ic]=1.0*ic;
  }
  //Double_t* centbin = centralityBins;

  //cout << "filling centrality bins" <<endl;
  //Int_t nCentralityBins  = fHistCentrality->GetNbinsX();
  //Double_t* centralityBins = (Double_t*)fHistCentrality->GetXaxis()->GetXbins()->GetArray();

  fPoolMgr = new AliEventPoolManager(poolsize, trackDepth, nCentralityBins, centralityBins, nZvtxBins, zvtxbin);

  
}

//________________________________________________________________________

Double_t AliAnalysisTaskEmcalJetHMEC:: RelativePhi(Double_t mphi,Double_t vphi) {


  if (vphi < -1*TMath::Pi()) vphi += (2*TMath::Pi());
  else if (vphi > TMath::Pi()) vphi -= (2*TMath::Pi());
  if (mphi < -1*TMath::Pi()) mphi += (2*TMath::Pi());
  else if (mphi > TMath::Pi()) mphi -= (2*TMath::Pi());
  Double_t dphi = vphi-mphi;
  if (dphi < -1*TMath::Pi()) dphi += (2*TMath::Pi());
  else if (dphi > TMath::Pi()) dphi -= (2*TMath::Pi());

  return dphi;//dphi in [-Pi, Pi]                                                                                                    
}


//________________________________________________________________________
Int_t AliAnalysisTaskEmcalJetHMEC::GetCentBin(Double_t cent) const 
{
  // Get centrality bin.

  Int_t centbin = -1;
  if (cent>=0 && cent<10)
    centbin = 0;
  else if (cent>=10 && cent<20)
    centbin = 1;
  else if (cent>=20 && cent<30)
    centbin = 2;
  else if (cent>=30 && cent<40)
    centbin = 3;
  else if (cent>=40 && cent<50)
    centbin = 4;
  else if (cent>=50 && cent<90)
    centbin = 5;
  return centbin;
}


//________________________________________________________________________
Int_t AliAnalysisTaskEmcalJetHMEC::GetEtaBin(Double_t eta) const 
{
  // Get eta bin for histos.

  Int_t etabin = -1;
  if (TMath::Abs(eta)<=0.4)
    etabin = 0;
  else if (TMath::Abs(eta)>0.4 && TMath::Abs(eta)<0.8)
    etabin = 1;
  else if (TMath::Abs(eta)>=0.8)
    etabin = 2;
  return etabin;
}
//________________________________________________________________________
Int_t AliAnalysisTaskEmcalJetHMEC::GetpTjetBin(Double_t pt) const 
{
  // Get jet pt  bin for histos.

  Int_t ptbin = -1;
  if (pt>=10 && pt<15)
    ptbin = 0;
  else if (pt>=15 && pt<20)
    ptbin = 1;
  else if (pt>=20 && pt<25)
    ptbin = 2;
  else if (pt>=25 && pt<30)
    ptbin = 3;
  else if (pt>=30)
    ptbin = 4;


  return ptbin;
}


//________________________________________________________________________
void AliAnalysisTaskEmcalJetHMEC::UserExec(Option_t *) 
{


  // Main loop called for each event
 // esd or aod mode
  Bool_t esdMode = kTRUE;
  if (dynamic_cast<AliAODEvent*>(InputEvent()))
    esdMode = kFALSE;


  if (esdMode) {
    // optimization in case autobranch loading is off
    AliAnalysisManager *am = AliAnalysisManager::GetAnalysisManager();
    if (fTracksName == "Tracks")
      am->LoadBranch("Tracks");
  }
 

  //get centrality
  TList *list = InputEvent()->GetList();
  AliCentrality *centrality = InputEvent()->GetCentrality() ;
  Double_t fcent=-1; 
  if(centrality)
    fcent = centrality->GetCentralityPercentile("V0M");
  else
    fcent=99;//probably pp data

  if (fcent<0) {
    AliError(Form("Centrality negative: %f", fcent));
    return;
  }


  fHistCentrality->Fill(fcent);
  Int_t centbin = GetCentBin(fcent);

  TClonesArray *jets = 0;
  TClonesArray *tracks = 0;

  tracks = dynamic_cast<TClonesArray*>(list->FindObject(fTracksName));
  if (!tracks) {
    AliError(Form("Pointer to tracks %s == 0", fTracksName.Data() ));
    return;
  }
  const Int_t Ntracks=tracks->GetEntries();

  jets= dynamic_cast<TClonesArray*>(list->FindObject(fJetsName));
  const Int_t Njets = jets->GetEntries();
 
  //Leticia's loop to find hardest track

  Int_t iTT=-1;
  Double_t ptmax=-10;

  for (Int_t iTracks = 0; iTracks < Ntracks; iTracks++) 
    {
      AliVTrack* track = static_cast<AliVTrack*>(tracks->At(iTracks));
      if (!track) {
	printf("ERROR: Could not receive track %d\n", iTracks);
	continue;
      }
      
      if(TMath::Abs(track->Eta())>0.9) continue;
      if(track->Pt()<0.15)continue;
      //iCount++;
      if(track->Pt()>ptmax){
	ptmax=track->Pt();
	iTT=iTracks;
      }
    }

  
  Int_t ijethi=-1;

  Double_t highestjetpt=0.0;

  Int_t passedTTcut=0;

  for (Int_t ijet = 0; ijet < Njets; ijet++)
    {
 
      AliEmcalJet *jet = static_cast<AliEmcalJet*>(jets->At(ijet));
      
      if (!jet)
	continue;
      
      //pt,eta,phi,centrality
      float jetphi = jet->Phi();
      if (jetphi>TMath::Pi())
	jetphi = jetphi-2*TMath::Pi();
      
      if ((jet->Phi()<fPhimin)||(jet->Phi()>fPhimax))
	continue;
      if ((jet->Eta()<fEtamin)||(jet->Eta()>fEtamax))
	continue;
      //fHistAreavsRawPt[centbin]->Fill(jet->Pt(),jet->Area());
      if (jet->Area()<fAreacut)
	continue;
      //prevents 0 area jets from sneaking by when area cut == 0
      if (jet->Area()==0)
	continue;

      Double_t jetPt = jet->Pt();

      if(highestjetpt<jetPt){
	ijethi=ijet;
	highestjetpt=jetPt;
      }

    }


  //Only look at the highest pT jet in the event

  if(ijethi>-1){
    AliEmcalJet *jet = static_cast<AliEmcalJet*>(jets->At(ijethi)); 
    
    Double_t jetphi = jet->Phi();
    Double_t jetPt = jet->Pt();
    Double_t jeteta=jet->Eta();

      fHistJetPt[centbin]->Fill(jet->Pt());

      if ((jet->MaxTrackPt()>6) || (jet->MaxClusterPt()>6))
	fHistJetPtBias[centbin]->Fill(jet->Pt());


      fHistJetEtaPhi->Fill(jet->Eta(),jetphi);

      //fHistDeltaPtvsArea->Fill(jetPt,jet->Area());

      if(iTT>0){
	AliVTrack* TT = static_cast<AliVTrack*>(tracks->At(iTT));
	if(TMath::Abs(jetphi-TT->Phi()-TMath::Pi())<0.6) passedTTcut=1;
	else passedTTcut=0;
      }

      if(passedTTcut)
	fHistJetPtTT[centbin]->Fill(jet->Pt());
   

  if (highestjetpt>10) {
   
    for (Int_t iTracks = 0; iTracks < Ntracks; iTracks++) 
      {
	AliVTrack* track = static_cast<AliVTrack*>(tracks->At(iTracks));
	if (!track) {
	  printf("ERROR: Could not receive track %d\n", iTracks);
	  continue;
	}
	
	  if(TMath::Abs(track->Eta())>0.9) continue;

	  fHistTrackPt->Fill(track->Pt());
	  	  
	  if (track->Pt()<0.15)
	    continue;
	  
	  Double_t trackphi = track->Phi();
	  if (trackphi > TMath::Pi())
	    trackphi = trackphi-2*TMath::Pi();

	  Double_t tracketa=track->Eta();
      
	  Double_t deta=tracketa-jeteta;
	  Int_t ieta=GetEtaBin(deta);

	  //Jet pt, track pt, dPhi,deta,fcent
	  Double_t dphijh = RelativePhi(jetphi,trackphi);
	  if (dphijh < -0.5*TMath::Pi())
	    dphijh= dphijh+ 2*TMath::Pi();

	  Int_t iptjet=-1;
	  iptjet=GetpTjetBin(jetPt);

	  fHistJetH[centbin][iptjet][ieta]->Fill(dphijh,track->Pt());
	  fHistJetHEtaPhi->Fill(deta,dphijh);
	  fHistTrackEtaPhi->Fill(tracketa,trackphi);
	  if ((jet->MaxTrackPt()>6) || (jet->MaxClusterPt()>6))
	    fHistJetHBias[centbin][iptjet][ieta]->Fill(dphijh,track->Pt());
	  
	  if(passedTTcut)
	  fHistJetHTT[centbin][iptjet][ieta]->Fill(dphijh,track->Pt());


	} //track loop
  }//jet pt cut

  
  // create a list of reduced objects. This speeds up processing and reduces memory consumption for the event pool
  TObjArray* tracksClone = CloneAndReduceTrackList(tracks);
  //delete tracks;

  Double_t fvertex[3]={0,0,0};
  InputEvent()->GetPrimaryVertex()->GetXYZ(fvertex);
  Double_t zVtx=fvertex[3];
  
  if(fDoEventMixing>0){
    
    // event mixing
    
    // 1. First get an event pool corresponding in mult (cent) and
    //    zvertex to the current event. Once initialized, the pool
    //    should contain nMix (reduced) events. This routine does not
    //    pre-scan the chain. The first several events of every chain
    //    will be skipped until the needed pools are filled to the
    //    specified depth. If the pool categories are not too rare, this
    //    should not be a problem. If they are rare, you could lose
    //    statistics.

    // 2. Collect the whole pool's content of tracks into one TObjArray
    //    (bgTracks), which is effectively a single background super-event.

    // 3. The reduced and bgTracks arrays must both be passed into
    //    FillCorrelations(). Also nMix should be passed in, so a weight
    //    of 1./nMix can be applied.


    AliEventPool* pool = fPoolMgr->GetEventPool(fcent, zVtx);

    pool->PrintInfo();

    
    if (!pool)
      AliFatal(Form("No pool found for centrality = %f, zVtx = %f", fcent, zVtx));


    if (pool->IsReady() || pool->NTracksInPool() > fMixingTracks / 10 || pool->GetCurrentNEvents() >= 5) 
    {
      
      Int_t nMix = pool->GetCurrentNEvents();
      
    
      // Fill mixed-event histos here  
      for (Int_t jMix=0; jMix<nMix; jMix++) 
      {
	TObjArray* bgTracks = pool->GetEvent(jMix);
	const Int_t Nbgtrks = bgTracks->GetEntries();
	for(Int_t ibg=0; ibg<Nbgtrks; ibg++){
	  AliPicoTrack *part = static_cast<AliPicoTrack*>(bgTracks->At(ibg));         
	  if(!part) continue;

	  Double_t DPhi = jetphi - part->Phi();
	  Double_t DEta = jeteta - part->Eta();
	  Double_t DR=TMath::Sqrt(DPhi*DPhi+DEta*DEta);
	  if(DPhi<-0.5*TMath::Pi()) DPhi+=2.*TMath::Pi();
	  if(DPhi>3./2.*TMath::Pi()) DPhi-=2.*TMath::Pi();
	  Double_t triggerEntries[7] = {fcent,jetPt,part->Pt(),DR,DEta,DPhi,0.0};                      
	  fhnMixedEvents->Fill(triggerEntries,1./nMix);
	}
 
      }
    }
    pool->UpdatePool(tracksClone);
  
  }


  }

  PostData(1, fOutputList);
}      

//________________________________________________________________________
void AliAnalysisTaskEmcalJetHMEC::Terminate(Option_t *) 
{
  //just terminate

}

THnSparse* AliAnalysisTaskEmcalJetHMEC::NewTHnSparseF(const char* name, UInt_t entries)
{
   // generate new THnSparseF, axes are defined in GetDimParams()

   Int_t count = 0;
   UInt_t tmp = entries;
   while(tmp!=0){
      count++;
      tmp = tmp &~ -tmp;  // clear lowest bit
   }

   TString hnTitle(name);
   const Int_t dim = count;
   Int_t nbins[dim];
   Double_t xmin[dim];
   Double_t xmax[dim];

   Int_t i=0;
   Int_t c=0;
   while(c<dim && i<32){
      if(entries&(1<<i)){
      
         TString label("");
         GetDimParams(i, label, nbins[c], xmin[c], xmax[c]);
         hnTitle += Form(";%s",label.Data());
         c++;
      }
      
      i++;
   }
   hnTitle += ";";

   return new THnSparseF(name, hnTitle.Data(), dim, nbins, xmin, xmax);
}

void AliAnalysisTaskEmcalJetHMEC::GetDimParams(Int_t iEntry, TString &label, Int_t &nbins, Double_t &xmin, Double_t &xmax)
{
   // stores label and binning of axis for THnSparse

   const Double_t pi = TMath::Pi();
   
   switch(iEntry){
      
   case 0:
      label = "V0 centrality (%)";
     
         nbins = 10;
         xmin = 0.;
         xmax = 100.;
         break;
      
      
   case 1:
      label = "corrected jet pt";
         nbins = 20;
         xmin = 0.;
         xmax = 200.;
          break;
      
      
   case 2:
      label = "track pT";
     
         nbins = 100;
         xmin = 0.;
         xmax = 10;
         break;
      
      
    case 3:
      label = "deltaR";
      nbins = 15;
      xmin = 0.;
      xmax = 1.5;
      break;


   case 4:
      label = "deltaEta";
      nbins = 8;
      xmin = -1.6;
      xmax = 1.6;
      break;


  case 5:
      label = "deltaPhi";
      nbins = 64;
      xmin = -0.5*pi;
      xmax = 1.5*pi;
      break;   
   
      
    case 6:
      label = "leading track";
      nbins = 13;
      xmin = 0;
      xmax = 50;
      break;
           
     case 7:
    
      label = "trigger track";
      nbins =10;
      xmin = 0;
      xmax = 50;
      break;


   }

}


//_________________________________________________
// From CF event mixing code PhiCorrelations
TObjArray* AliAnalysisTaskEmcalJetHMEC::CloneAndReduceTrackList(TObjArray* tracks)
{
  // clones a track list by using AliDPhiBasicParticle which uses much less memory (used for event mixing)
  
  TObjArray* tracksClone = new TObjArray;
  tracksClone->SetOwner(kTRUE);
  
  for (Int_t i=0; i<tracks->GetEntriesFast(); i++)
  {
    AliVParticle* particle = (AliVParticle*) tracks->At(i);
    tracksClone->Add(new AliPicoTrack(particle->Pt(), particle->Eta(), particle->Phi(), particle->Charge(), 0, 0, 0, 0));
  }
  
  return tracksClone;
}
Commit	Line	Data
7f71d351	1	// $Id$
5b38fc6d	2
	3	#include "AliAnalysisTaskEmcalJetHMEC.h"
	4
1101e468	5	#include "TChain.h"
	6	#include "TTree.h"
	7	#include "TList.h"
	8	#include "TH1F.h"
	9	#include "TH2F.h"
	10	#include "THnSparse.h"
	11	#include "TCanvas.h"
	12	#include <TClonesArray.h>
	13	#include <TParticle.h>
	14	#include "AliVTrack.h"
	15	#include "TParameter.h"
	16
	17	#include "AliAODEvent.h"
	18	#include "AliAnalysisTask.h"
	19	#include "AliAnalysisManager.h"
	20
	21	#include "AliESDEvent.h"
	22	#include "AliESDInputHandler.h"
	23	#include "AliESDCaloCluster.h"
	24	#include "AliESDVertex.h"
	25	#include "AliCentrality.h"
	26	#include "AliAODJet.h"
	27	#include "AliEmcalJet.h"
	28	#include "AliESDtrackCuts.h"
1101e468	29
5b38fc6d	30	#include "TVector3.h"
5b38fc6d	31	#include "AliPicoTrack.h"
55f64c2f	32	#include "AliEventPoolManager.h"
5b38fc6d	33
1101e468	34	ClassImp(AliAnalysisTaskEmcalJetHMEC)
	35
	36	//________________________________________________________________________
	37	AliAnalysisTaskEmcalJetHMEC::AliAnalysisTaskEmcalJetHMEC() :
	38	AliAnalysisTaskSE(),
	39	fTracksName("tracks"),
	40	fJetsName("jets"),
	41	fPhimin(-10),
	42	fPhimax(10),
	43	fEtamin(-0.9),
	44	fEtamax(0.9),
	45	fAreacut(0.0),
	46	fESD(0),
55f64c2f	47	fPoolMgr(0x0),
55f64c2f	48	fOutputList(0),
1101e468	49	fHistTrackPt(0),
	50	fHistCentrality(0),
	51	fHistJetEtaPhi(0),
	52	fHistTrackEtaPhi(0),
5b38fc6d	53	fHistJetHEtaPhi(0)
1101e468	54	{
	55	// Default Constructor
	56
	57	for(Int_t icent = 0; icent<6; ++icent){
	58	fHistJetPt[icent]=0;
81941f29	59	fHistJetPtBias[icent]=0;
81941f29	60	fHistJetPtTT[icent]=0;
55f64c2f	61	for(Int_t iptjet = 0; iptjet<5; ++iptjet){
1101e468	62	for(Int_t ieta = 0; ieta<3; ++ieta){
	63	fHistJetH[icent][iptjet][ieta]=0;
	64	fHistJetHBias[icent][iptjet][ieta]=0;
81941f29	65	fHistJetHTT[icent][iptjet][ieta]=0;
81941f29	66
1101e468	67	}
	68	}
	69	}
	70
	71	}
	72	//________________________________________________________________________
	73	AliAnalysisTaskEmcalJetHMEC::AliAnalysisTaskEmcalJetHMEC(const char *name) :
	74	AliAnalysisTaskSE(name),
	75	fTracksName("tracks"),
	76	fJetsName("jets"),
	77	fPhimin(-10),
	78	fPhimax(10),
	79	fEtamin(-0.9),
	80	fEtamax(0.9),
	81	fAreacut(0.0),
55f64c2f	82	fDoEventMixing(0),
55f64c2f	83	fMixingTracks(50000),
1101e468	84	fESD(0),
55f64c2f	85	fPoolMgr(0x0),
1101e468	86	fOutputList(0),
	87	fHistTrackPt(0),
	88	fHistCentrality(0),
	89	fHistJetEtaPhi(0),
	90	fHistTrackEtaPhi(0),
55f64c2f	91	fHistJetHEtaPhi(0),
	92	fNevents(0),
	93	fTindex(0),
	94	fTrigBufferIndex(0),
	95	fCountAgain(0),
	96	fhnMixedEvents(0x0)
1101e468	97	{
	98	// Constructor
	99	for(Int_t icent = 0; icent<6; ++icent){
	100	fHistJetPt[icent]=0;
	101	fHistJetPtBias[icent]=0;
81941f29	102	fHistJetPtTT[icent]=0;
81941f29	103	for(Int_t iptjet = 0; iptjet<5; ++iptjet){
1101e468	104	for(Int_t ieta = 0; ieta<3; ++ieta){
	105	fHistJetH[icent][iptjet][ieta]=0;
	106	fHistJetHBias[icent][iptjet][ieta]=0;
81941f29	107	fHistJetHTT[icent][iptjet][ieta]=0;
1101e468	108	}
	109	}
	110	}
	111
55f64c2f	112	for(Int_t i=0; i<10; i++) {
	113	for(Int_t j=0; j<6; j++) {
	114	fTrigBuffer[i][j]=0;
	115	}
	116	}
	117
	118
1101e468	119	DefineInput(0, TChain::Class());
	120	DefineOutput(1, TList::Class());
	121
	122	}
	123
	124	//________________________________________________________________________
	125	void AliAnalysisTaskEmcalJetHMEC::UserCreateOutputObjects()
	126	{
	127	// Called once
	128
	129
	130	AliVEventHandler* handler = AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler();
	131	if (!handler) {
	132	AliError("Input handler not available!");
	133	return;
	134	}
	135
	136	OpenFile(1);
	137	fOutputList = new TList();
	138	fOutputList->SetOwner();
	139
1101e468	140
55f64c2f	141
55f64c2f	142	// Create histograms
1101e468	143	fHistTrackPt = new TH1F("fHistTrackPt", "P_{T} distribution", 1000, 0.0, 100.0);
	144
	145
	146
	147	fHistCentrality = new TH1F("fHistCentrality","centrality",100,0,100);
	148
	149	fHistJetEtaPhi = new TH2F("fHistJetEtaPhi","Jet eta-phi",900,-1.8,1.8,640,-3.2,3.2);
	150	fHistTrackEtaPhi = new TH2F("fHistTrackEtaPhi","Track eta-phi",900,-1.8,1.8,640,-3.2,3.2);
	151	fHistJetHEtaPhi = new TH2F("fHistJetHEtaPhi","Jet-Hadron deta-dphi",900,-1.8,1.8,640,-1.6,4.8);
	152
	153	char name[200];
	154
	155
	156	for(Int_t icent = 0; icent<6; ++icent){
	157	sprintf(name,"fHistJetPt_%i",icent);
	158	fHistJetPt[icent] = new TH1F(name,name,200,0,200);
	159	fOutputList->Add(fHistJetPt[icent]);
	160
	161	sprintf(name,"fHistJetPtBias_%i",icent);
	162	fHistJetPtBias[icent] = new TH1F(name,name,200,0,200);
	163	fOutputList->Add(fHistJetPtBias[icent]);
	164
81941f29	165	sprintf(name,"fHistJetPtTT_%i",icent);
	166	fHistJetPtTT[icent] = new TH1F(name,name,200,0,200);
	167	fOutputList->Add(fHistJetPtTT[icent]);
	168
	169	for(Int_t iptjet = 0; iptjet<5; ++iptjet){
1101e468	170	for(Int_t ieta = 0; ieta<3; ++ieta){
	171	sprintf(name,"fHistJetH_%i_%i_%i",icent,iptjet,ieta);
	172	fHistJetH[icent][iptjet][ieta]=new TH2F(name,name,64,-0.5TMath::Pi(),1.5TMath::Pi(),300,0,30);
	173	fOutputList->Add(fHistJetH[icent][iptjet][ieta]);
	174
	175	sprintf(name,"fHistJetHBias_%i_%i_%i",icent,iptjet,ieta);
	176	fHistJetHBias[icent][iptjet][ieta]=new TH2F(name,name,64,-0.5TMath::Pi(),1.5TMath::Pi(),300,0,30);
	177	fOutputList->Add(fHistJetHBias[icent][iptjet][ieta]);
	178
81941f29	179	sprintf(name,"fHistJetHTT_%i_%i_%i",icent,iptjet,ieta);
	180	fHistJetHTT[icent][iptjet][ieta]=new TH2F(name,name,64,-0.5TMath::Pi(),1.5TMath::Pi(),300,0,30);
	181	fOutputList->Add(fHistJetHTT[icent][iptjet][ieta]);
	182
1101e468	183	}
	184	}
	185	}
	186
55f64c2f	187	if(fDoEventMixing){
	188	UInt_t cifras = 0; // bit coded, see GetDimParams() below
	189	cifras = 1<<0 \| 1<<1 \| 1<<2 \| 1<<3 \| 1<<4 \| 1<<5 \| 1<<7;
	190	fhnMixedEvents = NewTHnSparseF("fhnMixedEvents", cifras);
	191	}
	192
1101e468	193
	194
	195	fOutputList->Add(fHistTrackPt);
	196	fOutputList->Add(fHistCentrality);
	197	fOutputList->Add(fHistJetEtaPhi);
	198	fOutputList->Add(fHistTrackEtaPhi);
	199	fOutputList->Add(fHistJetHEtaPhi);
55f64c2f	200	fOutputList->Add(fhnMixedEvents);
1101e468	201
	202
	203	PostData(1, fOutputList);
	204
55f64c2f	205
	206	//Event Mixing
	207	Int_t trackDepth = fMixingTracks;
	208	Int_t poolsize = 1000; // Maximum number of events, ignored in the present implemented of AliEventPoolManager
	209
	210	Int_t nZvtxBins = 7+1+7;
	211	// bins for second buffer are shifted by 100 cm
	212	Double_t vertexBins[] = { -7, -5, -3, -1, 1, 3, 5, 7, 93, 95, 97, 99, 101, 103, 105, 107 };
	213	Double_t* zvtxbin = vertexBins;
	214
	215	Int_t nCentralityBins = 100;
	216	Double_t centralityBins[nCentralityBins];
	217	for(Int_t ic=0; ic<nCentralityBins; ic++){
	218	centralityBins[ic]=1.0*ic;
	219	}
	220	//Double_t* centbin = centralityBins;
	221
	222	//cout << "filling centrality bins" <<endl;
	223	//Int_t nCentralityBins = fHistCentrality->GetNbinsX();
	224	//Double_t* centralityBins = (Double_t*)fHistCentrality->GetXaxis()->GetXbins()->GetArray();
	225
	226	fPoolMgr = new AliEventPoolManager(poolsize, trackDepth, nCentralityBins, centralityBins, nZvtxBins, zvtxbin);
	227
	228
	229
1101e468	230	}
	231
	232	//________________________________________________________________________
	233
	234	Double_t AliAnalysisTaskEmcalJetHMEC:: RelativePhi(Double_t mphi,Double_t vphi) {
	235
	236
	237	if (vphi < -1TMath::Pi()) vphi += (2TMath::Pi());
	238	else if (vphi > TMath::Pi()) vphi -= (2*TMath::Pi());
	239	if (mphi < -1TMath::Pi()) mphi += (2TMath::Pi());
	240	else if (mphi > TMath::Pi()) mphi -= (2*TMath::Pi());
	241	Double_t dphi = vphi-mphi;
	242	if (dphi < -1TMath::Pi()) dphi += (2TMath::Pi());
	243	else if (dphi > TMath::Pi()) dphi -= (2*TMath::Pi());
	244
	245	return dphi;//dphi in [-Pi, Pi]
	246	}
	247
	248
	249	//________________________________________________________________________
	250	Int_t AliAnalysisTaskEmcalJetHMEC::GetCentBin(Double_t cent) const
	251	{
	252	// Get centrality bin.
	253
	254	Int_t centbin = -1;
	255	if (cent>=0 && cent<10)
	256	centbin = 0;
	257	else if (cent>=10 && cent<20)
	258	centbin = 1;
	259	else if (cent>=20 && cent<30)
	260	centbin = 2;
	261	else if (cent>=30 && cent<40)
	262	centbin = 3;
	263	else if (cent>=40 && cent<50)
	264	centbin = 4;
	265	else if (cent>=50 && cent<90)
	266	centbin = 5;
	267	return centbin;
	268	}
	269
	270
	271	//________________________________________________________________________
	272	Int_t AliAnalysisTaskEmcalJetHMEC::GetEtaBin(Double_t eta) const
	273	{
	274	// Get eta bin for histos.
	275
	276	Int_t etabin = -1;
	277	if (TMath::Abs(eta)<=0.4)
	278	etabin = 0;
	279	else if (TMath::Abs(eta)>0.4 && TMath::Abs(eta)<0.8)
	280	etabin = 1;
	281	else if (TMath::Abs(eta)>=0.8)
	282	etabin = 2;
	283	return etabin;
	284	}
	285	//________________________________________________________________________
81941f29	286	Int_t AliAnalysisTaskEmcalJetHMEC::GetpTjetBin(Double_t pt) const
1101e468	287	{
81941f29	288	// Get jet pt bin for histos.
	289
	290	Int_t ptbin = -1;
	291	if (pt>=10 && pt<15)
	292	ptbin = 0;
	293	else if (pt>=15 && pt<20)
	294	ptbin = 1;
	295	else if (pt>=20 && pt<25)
	296	ptbin = 2;
	297	else if (pt>=25 && pt<30)
	298	ptbin = 3;
	299	else if (pt>=30)
	300	ptbin = 4;
	301
	302
	303	return ptbin;
1101e468	304	}
	305
	306
	307	//________________________________________________________________________
	308	void AliAnalysisTaskEmcalJetHMEC::UserExec(Option_t *)
	309	{
	310
	311
	312	// Main loop called for each event
	313	// esd or aod mode
	314	Bool_t esdMode = kTRUE;
	315	if (dynamic_cast<AliAODEvent*>(InputEvent()))
	316	esdMode = kFALSE;
	317
	318
	319	if (esdMode) {
	320	// optimization in case autobranch loading is off
	321	AliAnalysisManager *am = AliAnalysisManager::GetAnalysisManager();
	322	if (fTracksName == "Tracks")
	323	am->LoadBranch("Tracks");
	324	}
	325
	326
	327	//get centrality
	328	TList *list = InputEvent()->GetList();
	329	AliCentrality *centrality = InputEvent()->GetCentrality() ;
	330	Double_t fcent=-1;
	331	if(centrality)
	332	fcent = centrality->GetCentralityPercentile("V0M");
	333	else
	334	fcent=99;//probably pp data
	335
	336	if (fcent<0) {
	337	AliError(Form("Centrality negative: %f", fcent));
	338	return;
	339	}
	340
	341
	342	fHistCentrality->Fill(fcent);
	343	Int_t centbin = GetCentBin(fcent);
	344
	345	TClonesArray *jets = 0;
	346	TClonesArray *tracks = 0;
	347
	348	tracks = dynamic_cast<TClonesArray*>(list->FindObject(fTracksName));
	349	if (!tracks) {
	350	AliError(Form("Pointer to tracks %s == 0", fTracksName.Data() ));
	351	return;
	352	}
	353	const Int_t Ntracks=tracks->GetEntries();
	354
	355	jets= dynamic_cast<TClonesArray*>(list->FindObject(fJetsName));
	356	const Int_t Njets = jets->GetEntries();
	357
81941f29	358	//Leticia's loop to find hardest track
	359
	360	Int_t iTT=-1;
	361	Double_t ptmax=-10;
	362
	363	for (Int_t iTracks = 0; iTracks < Ntracks; iTracks++)
	364	{
	365	AliVTrack* track = static_cast<AliVTrack*>(tracks->At(iTracks));
	366	if (!track) {
	367	printf("ERROR: Could not receive track %d\n", iTracks);
	368	continue;
	369	}
	370
	371	if(TMath::Abs(track->Eta())>0.9) continue;
	372	if(track->Pt()<0.15)continue;
	373	//iCount++;
	374	if(track->Pt()>ptmax){
	375	ptmax=track->Pt();
	376	iTT=iTracks;
	377	}
	378	}
1101e468	379
1101e468	380
81941f29	381	Int_t ijethi=-1;
	382
	383	Double_t highestjetpt=0.0;
	384
	385	Int_t passedTTcut=0;
1101e468	386
	387	for (Int_t ijet = 0; ijet < Njets; ijet++)
	388	{
81941f29	389
1101e468	390	AliEmcalJet jet = static_cast<AliEmcalJet>(jets->At(ijet));
	391
	392	if (!jet)
	393	continue;
	394
	395	//pt,eta,phi,centrality
	396	float jetphi = jet->Phi();
	397	if (jetphi>TMath::Pi())
	398	jetphi = jetphi-2*TMath::Pi();
	399
	400	if ((jet->Phi()<fPhimin)\|\|(jet->Phi()>fPhimax))
	401	continue;
	402	if ((jet->Eta()<fEtamin)\|\|(jet->Eta()>fEtamax))
	403	continue;
	404	//fHistAreavsRawPt[centbin]->Fill(jet->Pt(),jet->Area());
	405	if (jet->Area()<fAreacut)
	406	continue;
	407	//prevents 0 area jets from sneaking by when area cut == 0
	408	if (jet->Area()==0)
	409	continue;
	410
1101e468	411	Double_t jetPt = jet->Pt();
1101e468	412
59d5ae99	413	if(highestjetpt<jetPt){
	414	ijethi=ijet;
	415	highestjetpt=jetPt;
	416	}
	417
	418	}
	419
	420
	421
	422	//Only look at the highest pT jet in the event
	423
	424	if(ijethi>-1){
	425	AliEmcalJet jet = static_cast<AliEmcalJet>(jets->At(ijethi));
	426
55f64c2f	427	Double_t jetphi = jet->Phi();
59d5ae99	428	Double_t jetPt = jet->Pt();
55f64c2f	429	Double_t jeteta=jet->Eta();
1101e468	430
	431	fHistJetPt[centbin]->Fill(jet->Pt());
	432
81941f29	433	if ((jet->MaxTrackPt()>6) \|\| (jet->MaxClusterPt()>6))
	434	fHistJetPtBias[centbin]->Fill(jet->Pt());
	435
	436
1101e468	437	fHistJetEtaPhi->Fill(jet->Eta(),jetphi);
	438
	439	//fHistDeltaPtvsArea->Fill(jetPt,jet->Area());
	440
81941f29	441	if(iTT>0){
	442	AliVTrack* TT = static_cast<AliVTrack*>(tracks->At(iTT));
	443	if(TMath::Abs(jetphi-TT->Phi()-TMath::Pi())<0.6) passedTTcut=1;
	444	else passedTTcut=0;
	445	}
1101e468	446
81941f29	447	if(passedTTcut)
81941f29	448	fHistJetPtTT[centbin]->Fill(jet->Pt());
59d5ae99	449
81941f29	450
81941f29	451	if (highestjetpt>10) {
81941f29	452
81941f29	453	for (Int_t iTracks = 0; iTracks < Ntracks; iTracks++)
	454	{
	455	AliVTrack* track = static_cast<AliVTrack*>(tracks->At(iTracks));
	456	if (!track) {
	457	printf("ERROR: Could not receive track %d\n", iTracks);
	458	continue;
	459	}
	460
1101e468	461	if(TMath::Abs(track->Eta())>0.9) continue;
	462
	463	fHistTrackPt->Fill(track->Pt());
	464
81941f29	465	if (track->Pt()<0.15)
1101e468	466	continue;
	467
	468	Double_t trackphi = track->Phi();
	469	if (trackphi > TMath::Pi())
	470	trackphi = trackphi-2*TMath::Pi();
	471
	472	Double_t tracketa=track->Eta();
55f64c2f	473
1101e468	474	Double_t deta=tracketa-jeteta;
	475	Int_t ieta=GetEtaBin(deta);
	476
	477	//Jet pt, track pt, dPhi,deta,fcent
	478	Double_t dphijh = RelativePhi(jetphi,trackphi);
	479	if (dphijh < -0.5*TMath::Pi())
	480	dphijh= dphijh+ 2*TMath::Pi();
	481
	482	Int_t iptjet=-1;
	483	iptjet=GetpTjetBin(jetPt);
	484
	485	fHistJetH[centbin][iptjet][ieta]->Fill(dphijh,track->Pt());
	486	fHistJetHEtaPhi->Fill(deta,dphijh);
	487	fHistTrackEtaPhi->Fill(tracketa,trackphi);
81941f29	488	if ((jet->MaxTrackPt()>6) \|\| (jet->MaxClusterPt()>6))
1101e468	489	fHistJetHBias[centbin][iptjet][ieta]->Fill(dphijh,track->Pt());
81941f29	490
81941f29	491	if(passedTTcut)
59d5ae99	492	fHistJetHTT[centbin][iptjet][ieta]->Fill(dphijh,track->Pt());
1101e468	493
1101e468	494
1101e468	495	} //track loop
59d5ae99	496	}//jet pt cut
55f64c2f	497
	498
	499	// create a list of reduced objects. This speeds up processing and reduces memory consumption for the event pool
	500	TObjArray* tracksClone = CloneAndReduceTrackList(tracks);
	501	//delete tracks;
	502
	503	Double_t fvertex[3]={0,0,0};
	504	InputEvent()->GetPrimaryVertex()->GetXYZ(fvertex);
	505	Double_t zVtx=fvertex[3];
	506
	507	if(fDoEventMixing>0){
	508
	509	// event mixing
	510
	511	// 1. First get an event pool corresponding in mult (cent) and
	512	// zvertex to the current event. Once initialized, the pool
	513	// should contain nMix (reduced) events. This routine does not
	514	// pre-scan the chain. The first several events of every chain
	515	// will be skipped until the needed pools are filled to the
	516	// specified depth. If the pool categories are not too rare, this
	517	// should not be a problem. If they are rare, you could lose
	518	// statistics.
	519
	520	// 2. Collect the whole pool's content of tracks into one TObjArray
	521	// (bgTracks), which is effectively a single background super-event.
	522
	523	// 3. The reduced and bgTracks arrays must both be passed into
	524	// FillCorrelations(). Also nMix should be passed in, so a weight
	525	// of 1./nMix can be applied.
	526
	527
	528
	529
	530
	531	AliEventPool* pool = fPoolMgr->GetEventPool(fcent, zVtx);
	532
	533	pool->PrintInfo();
	534
	535
	536	if (!pool)
	537	AliFatal(Form("No pool found for centrality = %f, zVtx = %f", fcent, zVtx));
	538
	539
	540	if (pool->IsReady() \|\| pool->NTracksInPool() > fMixingTracks / 10 \|\| pool->GetCurrentNEvents() >= 5)
	541	{
	542
	543	Int_t nMix = pool->GetCurrentNEvents();
55f64c2f	544
	545
	546	// Fill mixed-event histos here
	547	for (Int_t jMix=0; jMix<nMix; jMix++)
	548	{
	549	TObjArray* bgTracks = pool->GetEvent(jMix);
	550	const Int_t Nbgtrks = bgTracks->GetEntries();
	551	for(Int_t ibg=0; ibg<Nbgtrks; ibg++){
5b38fc6d	552	AliPicoTrack part = static_cast<AliPicoTrack>(bgTracks->At(ibg));
55f64c2f	553	if(!part) continue;
	554
	555	Double_t DPhi = jetphi - part->Phi();
	556	Double_t DEta = jeteta - part->Eta();
	557	Double_t DR=TMath::Sqrt(DPhiDPhi+DEtaDEta);
	558	if(DPhi<-0.5TMath::Pi()) DPhi+=2.TMath::Pi();
	559	if(DPhi>3./2.TMath::Pi()) DPhi-=2.TMath::Pi();
	560	Double_t triggerEntries[7] = {fcent,jetPt,part->Pt(),DR,DEta,DPhi,0.0};
	561	fhnMixedEvents->Fill(triggerEntries,1./nMix);
	562	}
	563
	564	}
	565	}
	566	pool->UpdatePool(tracksClone);
	567
	568	}
	569
	570
	571
59d5ae99	572	}
59d5ae99	573
1101e468	574	PostData(1, fOutputList);
	575	}
	576
	577	//________________________________________________________________________
	578	void AliAnalysisTaskEmcalJetHMEC::Terminate(Option_t *)
	579	{
	580	//just terminate
	581
	582	}
	583
55f64c2f	584	THnSparse* AliAnalysisTaskEmcalJetHMEC::NewTHnSparseF(const char* name, UInt_t entries)
	585	{
	586	// generate new THnSparseF, axes are defined in GetDimParams()
	587
	588	Int_t count = 0;
	589	UInt_t tmp = entries;
	590	while(tmp!=0){
	591	count++;
	592	tmp = tmp &~ -tmp; // clear lowest bit
	593	}
	594
	595	TString hnTitle(name);
	596	const Int_t dim = count;
	597	Int_t nbins[dim];
	598	Double_t xmin[dim];
	599	Double_t xmax[dim];
	600
	601	Int_t i=0;
	602	Int_t c=0;
	603	while(c<dim && i<32){
	604	if(entries&(1<<i)){
	605
	606	TString label("");
	607	GetDimParams(i, label, nbins[c], xmin[c], xmax[c]);
	608	hnTitle += Form(";%s",label.Data());
	609	c++;
	610	}
	611
	612	i++;
	613	}
	614	hnTitle += ";";
	615
	616	return new THnSparseF(name, hnTitle.Data(), dim, nbins, xmin, xmax);
	617	}
	618
	619	void AliAnalysisTaskEmcalJetHMEC::GetDimParams(Int_t iEntry, TString &label, Int_t &nbins, Double_t &xmin, Double_t &xmax)
	620	{
	621	// stores label and binning of axis for THnSparse
	622
	623	const Double_t pi = TMath::Pi();
	624
	625	switch(iEntry){
	626
	627	case 0:
	628	label = "V0 centrality (%)";
	629
	630	nbins = 10;
	631	xmin = 0.;
	632	xmax = 100.;
	633	break;
	634
	635
	636	case 1:
	637	label = "corrected jet pt";
	638	nbins = 20;
	639	xmin = 0.;
	640	xmax = 200.;
	641	break;
	642
	643
	644	case 2:
	645	label = "track pT";
	646
	647	nbins = 100;
648	xmin = 0.;
649	xmax = 10;
650	break;
651
652
653	case 3:
654	label = "deltaR";
655	nbins = 15;
656	xmin = 0.;
657	xmax = 1.5;
658	break;
659
660
661
662	case 4:
663	label = "deltaEta";
664	nbins = 8;
665	xmin = -1.6;
666	xmax = 1.6;
667	break;
668
669
670	case 5:
671	label = "deltaPhi";
5b38fc6d	672	nbins = 64;
55f64c2f	673	xmin = -0.5*pi;
	674	xmax = 1.5*pi;
	675	break;
	676
	677
	678
	679	case 6:
	680	label = "leading track";
	681	nbins = 13;
	682	xmin = 0;
	683	xmax = 50;
	684	break;
	685
	686	case 7:
	687
	688	label = "trigger track";
	689	nbins =10;
	690	xmin = 0;
	691	xmax = 50;
	692	break;
	693
	694
	695
	696
	697	}
	698
	699	}
	700
	701
	702	//_________________________________________________
	703	// From CF event mixing code PhiCorrelations
	704	TObjArray* AliAnalysisTaskEmcalJetHMEC::CloneAndReduceTrackList(TObjArray* tracks)
	705	{
	706	// clones a track list by using AliDPhiBasicParticle which uses much less memory (used for event mixing)
	707
	708	TObjArray* tracksClone = new TObjArray;
	709	tracksClone->SetOwner(kTRUE);
	710
	711	for (Int_t i=0; i<tracks->GetEntriesFast(); i++)
	712	{
	713	AliVParticle* particle = (AliVParticle*) tracks->At(i);
5b38fc6d	714	tracksClone->Add(new AliPicoTrack(particle->Pt(), particle->Eta(), particle->Phi(), particle->Charge(), 0, 0, 0, 0));
55f64c2f	715	}
	716
	717	return tracksClone;
	718	}
	719
	720
1101e468	721