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

#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 "AliAnalysisTaskEmcalJetHMEC.h"
#include "TVector3.h"

#include "AliEventPoolManager.h"
ClassImp(AliAnalysisTaskEmcalJetHMEC)
ClassImp( AliDPhiBasicParticleMEC )

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