[u/mrichter/AliRoot.git] / PWGCF / Correlations / Base / AliAnalysisTaskCFTree.cxx

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

// Analysis task to produce trees of lightweight events
// evgeny.kryshen@cern.ch

// aliroot
#include "AliAnalysisTaskCFTree.h"
#include "AliCFParticle.h"
#include "AliAnalysisManager.h"
#include "AliInputEventHandler.h"
#include "AliESDEvent.h"
#include "AliAODEvent.h"
#include "AliMCEvent.h"
#include "AliAODTrack.h"
#include "AliESDtrack.h"
#include "AliExternalTrackParam.h"
#include "AliCentrality.h"
#include "AliAnalysisFilter.h"
#include "AliVMultiplicity.h"
#include "AliAnalysisUtils.h"
// root
#include "TMath.h"
#include "TFile.h"
#include "TList.h"
#include "TH1I.h"
#include "TChain.h"
#include "TTree.h"
#include "TClonesArray.h"
ClassImp(AliAnalysisTaskCFTree)

//-----------------------------------------------------------------------------
AliAnalysisTaskCFTree::AliAnalysisTaskCFTree(const char* name) :
  AliAnalysisTaskSE(name),
  fTrackFilter(0x0),
  fHybridConstrainedMask(0),
  fTPConlyConstrainedMask(0),
  fUtils(0x0),
  fListOfHistos(0x0),
  fEventStatistics(0x0),
  fTree(0x0),
  fTracks(0x0),
  fTracklets(0x0),
  fMuons(0x0),
  fMcParticles(0x0),
  fField(0),
  fCentrality(),
  fVtxZ(0),
  fVtxTPConly(0),
  fVtxContributors(0),
  fPeriod(0),
  fOrbit(),
  fBc(),
  fSelectMask(0),
  fIsPileupSPD(0),
  fIsPileupMV(0),
  fSelectBit(AliVEvent::kAny),
  fZVertexCut(10.),
  fTrackFilterBit(0xffffffff),
  fTrackEtaCut(1.0),
  fPtMin(0.15),
  fSharedClusterCut(0.4),
  fCrossedRowsCut(100),
  fFoundFractionCut(0.8),
  fDphiCut(1.e9),
  fStoreTracks(0),
  fStoreTracklets(0),
  fStoreMuons(0),
  fStoreMcTracks(0),
  fStoreMcTracklets(0),
  fStoreMcMuons(0),
  fStorePidInfo(0)
{
  Info("AliAnalysisTaskCFTree","Calling Constructor");
  DefineInput(0,TChain::Class());
  DefineOutput(1,TList::Class());
  DefineOutput(2,TTree::Class());
}
//-----------------------------------------------------------------------------


//-----------------------------------------------------------------------------
void AliAnalysisTaskCFTree::UserCreateOutputObjects(){
  fListOfHistos = new TList();
  fListOfHistos->SetOwner();
  fEventStatistics = new TH1I("fEventStatistics","",10,0,10);
  fEventStatistics->SetBit(TH1::kCanRebin);

  fListOfHistos->Add(fEventStatistics);

  if (fStoreTracks)    fTracks      = new TClonesArray("AliCFParticle",2000);
  if (fStoreTracklets) fTracklets   = new TClonesArray("AliCFParticle",2000);
  if (fStoreMuons)     fMuons       = new TClonesArray("AliCFParticle",2000);
  if (fStoreMcTracks)  fMcParticles = new TClonesArray("AliCFParticle",2000);
  // create file-resident tree
  TDirectory *owd = gDirectory;
  OpenFile(1);
  fTree = new TTree("events","events");
  owd->cd();
  fTree->Branch("cent",&fCentrality,"fCentrality[6]/F");
  fTree->Branch("vtxz",&fVtxZ);
  fTree->Branch("vtxTPConly",&fVtxTPConly);
  fTree->Branch("vtxContributors",&fVtxContributors);
  fTree->Branch("field",&fField);
  fTree->Branch("run",&fCurrentRunNumber);
  fTree->Branch("period",&fPeriod);
  fTree->Branch("orbit",&fOrbit);
  fTree->Branch("bc",&fBc);
  fTree->Branch("mask",&fSelectMask);
  fTree->Branch("pileupspd",&fIsPileupSPD);
  fTree->Branch("pileupmv",&fIsPileupMV);
  if (fTracks)      fTree->Branch("tracks",&fTracks);
  if (fTracklets)   fTree->Branch("tracklets",&fTracklets);
  if (fMuons)       fTree->Branch("muons",&fMuons);
  if (fMcParticles) fTree->Branch("mcparticles",&fMcParticles);

  fUtils = new AliAnalysisUtils();

  PostData(1,fListOfHistos);
  PostData(2,fTree);
}
//-----------------------------------------------------------------------------


//-----------------------------------------------------------------------------
void AliAnalysisTaskCFTree::UserExec(Option_t *){
  fEventStatistics->Fill("before cuts",1);
  
  if (!fInputEvent) return;
  fEventStatistics->Fill("after event check",1);
  
  // TODO
  //  TString classes = fInputEvent->GetFiredTriggerClasses();
  //  fClassesFired = 0;
  //  fClassesFired |= (classes.Contains("CINT7-S-") << 0);
  //  fClassesFired |= (classes.Contains("CINT7-B-") << 0);
  //  fClassesFired |= (classes.Contains("CSHM8-S-") << 1);
  //  fClassesFired |= (classes.Contains("CSHM8-B-") << 1);
  //  fClassesFired |= (classes.Contains("CMSL7-S-") << 2);
  //  fClassesFired |= (classes.Contains("CMSL7-B-") << 2);
  //  fClassesFired |= (classes.Contains("CMSH7-S-") << 3);
  //  fClassesFired |= (classes.Contains("CMSH7-B-") << 3);
  //  fClassesFired |= (classes.Contains("CMUL7-S-") << 4);
  //  fClassesFired |= (classes.Contains("CMUL7-B-") << 4);
  //  fClassesFired |= (classes.Contains("CMLL7-S-") << 5);
  //  fClassesFired |= (classes.Contains("CMLL7-B-") << 5);
  //  fClassesFired |= (classes.Contains("CINT8-S-") << 6);
  //  fClassesFired |= (classes.Contains("CSPI7-S-") << 7);
  //  fClassesFired |= (classes.Contains("CSPI8-S-") << 8);
  //  fClassesFired |= (classes.Contains("CMSL8-S-") << 9);
  //  fClassesFired |= (classes.Contains("CMSH8-S-") <<10);
  //  fClassesFired |= (classes.Contains("CMUL8-S-") <<11);
  //  fClassesFired |= (classes.Contains("CMLL8-S-") <<12);
  //  fClassesFired |= (classes.Contains("C0MUL-SA") <<13);
  //  fClassesFired |= (classes.Contains("C0MUL-SC") <<14);
  //  if (!fClassesFired) return;
  //  fEventStatistics->Fill("after trigger check",1);
  
  fSelectMask = fInputHandler->IsEventSelected();
  if (!(fSelectMask & fSelectBit)) return;
  
  fEventStatistics->Fill("after physics selection",1);
  
  fPeriod        = fInputEvent->GetPeriodNumber();
  fOrbit         = fInputEvent->GetOrbitNumber();
  fBc            = fInputEvent->GetBunchCrossNumber();
  fField         = fInputEvent->GetMagneticField();
  fCentrality[0] = fInputEvent->GetCentrality()->GetCentralityPercentile("V0M");
  fCentrality[1] = fInputEvent->GetCentrality()->GetCentralityPercentile("V0A");
  fCentrality[2] = fInputEvent->GetCentrality()->GetCentralityPercentile("V0C");
  fCentrality[3] = fInputEvent->GetCentrality()->GetCentralityPercentile("CL1");
  fCentrality[4] = fInputEvent->GetCentrality()->GetCentralityPercentile("ZNA");
  fCentrality[5] = fInputEvent->GetCentrality()->GetCentralityPercentile("ZNC");
  fIsPileupSPD   = fUtils->IsPileUpSPD(fInputEvent);
  fIsPileupMV    = fUtils->IsPileUpMV(fInputEvent);
//  fNofITSClusters[i] = esd->GetMultiplicity()->GetNumberOfITSClusters(i);
  
  const AliVVertex* vertex  = fInputEvent->GetPrimaryVertex();
  fVtxZ  = vertex->GetZ();
  fVtxTPConly = TString(vertex->GetName()).CompareTo("PrimaryVertex") && TString(vertex->GetName()).CompareTo("SPDVertex");
  fVtxContributors = vertex->GetNContributors();
  if (TMath::Abs(fVtxZ) >= fZVertexCut)  return;
  fEventStatistics->Fill("after vertex cut",1);
  
  if (fTracks) {
    fTracks->Clear();
    for (Int_t ipart=0;ipart<fInputEvent->GetNumberOfTracks();ipart++){
      AliVTrack* track = (AliVTrack*) fInputEvent->GetTrack(ipart);
      if (!track) continue;
      UInt_t mask = GetFilterMap(track);
      if (!(mask & fTrackFilterBit)) continue;

      if (track->InheritsFrom("AliAODTrack")) AddTrack(track,mask,0);
      else if (track->InheritsFrom("AliESDtrack")) {
        if (mask)                           AddTrack(track,mask,1);
        if (mask & fHybridConstrainedMask)  AddTrack(track,mask,2);
        if (mask & fTPConlyConstrainedMask) AddTrack(track,mask,3);
      }
    }
  }
  
  if (fTracklets){
    fTracklets->Clear();
    AliVMultiplicity* mult = fInputEvent->GetMultiplicity();
    Int_t nTracklets = mult->GetNumberOfTracklets();
    for (Int_t i=0;i<nTracklets;i++){
      Float_t phi   = mult->GetPhi(i);
      Float_t eta   = -TMath::Log(TMath::Tan(mult->GetTheta(i)/2));
      Float_t dphi  = mult->GetDeltaPhi(i);
      if (TMath::Abs(dphi)>fDphiCut) continue;
      AliCFParticle* tracklet = new ((*fTracklets)[fTracklets->GetEntriesFast()]) AliCFParticle(dphi,eta,phi,0,0,fStoreMcTracklets?4:0);
      if (!fStoreMcTracklets || !fMCEvent) continue;
      Int_t label1 = mult->GetLabel(i,0);
      Int_t label2 = mult->GetLabel(i,1);
      if (label1!=label2) continue;
      AliVParticle* particle = fMCEvent->GetTrack(label1);
      if (!particle) continue;
      Short_t charge = particle->Charge();
      Float_t ptMC   = particle->Pt();
      Float_t etaMC  = particle->Eta();
      Float_t phiMC  = particle->Phi();
      Float_t pdg    = particle->PdgCode();
      tracklet->SetCharge(charge);
      tracklet->SetAt(ptMC,0);
      tracklet->SetAt(etaMC,1);
      tracklet->SetAt(phiMC,2);
      tracklet->SetAt(pdg,3);
    }
  }
  
  AliAODEvent* aod = dynamic_cast<AliAODEvent*> (fInputEvent);
  if (fMuons && aod){ // aod only
    fMuons->Clear();
    for (Int_t iTrack = 0; iTrack < aod->GetNumberOfTracks(); iTrack++) {
      AliAODTrack* track = dynamic_cast<AliAODTrack*>(aod->GetTrack(iTrack));
      if(!track) AliFatal("Not a standard AOD");
      if (!track->IsMuonTrack()) continue;
      Float_t pt     = track->Pt();
      Float_t eta    = track->Eta();
      Float_t phi    = track->Phi();
      Short_t charge = track->Charge();
      Float_t dca    = track->DCA();
      Float_t chi2   = track->Chi2perNDF();
      Float_t rabs   = track->GetRAtAbsorberEnd();
      Int_t   mask   = track->GetMatchTrigger();
      if (rabs < 17.6 || rabs > 89.5) continue;
      if (eta < -4 || eta > -2.5) continue;
      AliCFParticle* part = new ((*fMuons)[fMuons->GetEntriesFast()]) AliCFParticle(pt,eta,phi,charge,mask,fStoreMcMuons?11:3);
      part->SetAt(dca,0);
      part->SetAt(chi2,1);
      part->SetAt(rabs,2);
      if (!fStoreMcMuons || !fMCEvent) continue;
      Int_t label = TMath::Abs(track->GetLabel()); 
      AliVParticle* mcpart = fMCEvent->GetTrack(label);
      if (!mcpart) continue;
      Int_t mcpdg = mcpart->PdgCode();
      Float_t mcpt  = mcpart->Pt();
      Float_t mceta = mcpart->Eta();
      Float_t mcphi = mcpart->Phi();
      part->SetAt(mcpt,3);
      part->SetAt(mceta,4);
      part->SetAt(mcphi,5);
      part->SetAt(mcpdg,6);
      part->SetAt(0,10);
      Bool_t isPrimary = fMCEvent->IsPhysicalPrimary(label);
      if (isPrimary) continue;
      label = mcpart->GetMother();
      while (!isPrimary && label>=0) {
        mcpart = (AliVParticle*) fMCEvent->GetTrack(label);
        label = mcpart->GetMother();
        isPrimary = fMCEvent->IsPhysicalPrimary(label);
      }
      if (!mcpart) continue;
      Float_t mcprimarypt  = mcpart->Pt();
      Float_t mcprimaryeta = mcpart->Eta();
      Float_t mcprimaryphi = mcpart->Phi();
      Int_t   mcprimarypdg = mcpart->PdgCode();
      part->SetAt(mcprimarypt,7);
      part->SetAt(mcprimaryeta,8);
      part->SetAt(mcprimaryphi,9);
      part->SetAt(mcprimarypdg,10);
    }
  }

  if (fMcParticles && fMCEvent) {
    fMcParticles->Clear();
    TString gen;
    for (Int_t ipart=0;ipart<fMCEvent->GetNumberOfTracks();ipart++){
      AliVParticle* part = fMCEvent->GetTrack(ipart);
      Bool_t isCocktail = fMCEvent->GetCocktailGenerator(ipart,gen);
      if (isCocktail && !gen.Contains("Pythia") && !gen.Contains("Hijing") && !gen.Contains("AMPT") && !gen.Contains("DPMJET")) continue;
      Float_t pt     = part->Pt();
      Float_t eta    = part->Eta();
      Float_t phi    = part->Phi();
      Char_t  charge = part->Charge();
      Int_t   mask   = part->PdgCode();
      // TODO
      //  Bool_t isPrimary = fMCEvent->IsPhysicalPrimary(ipart);
      // if (pt < fMcPtMin) continue;
      // if (TMath::Abs(eta) > fMcTrackEtaCut) continue;
      new ((*fMcParticles)[fMcParticles->GetEntriesFast()]) AliCFParticle(pt,eta,phi,charge,mask);
    }
  }

  fTree->Fill();
  PostData(1,fListOfHistos);
  PostData(2,fTree);
}
//-----------------------------------------------------------------------------


//-----------------------------------------------------------------------------
UInt_t AliAnalysisTaskCFTree::GetFilterMap(AliVTrack* track){
  UInt_t mask = 0;
  if (track->InheritsFrom("AliAODTrack")) {
    AliAODTrack* part = (AliAODTrack*) track;
    mask = part->GetFilterMap();
    Double_t nCrossedRaws      = part->GetTPCNCrossedRows();
    Double_t nFindableClusters = part->GetTPCNclsF();
    Double_t nSharedClusters   = part->GetTPCnclsS();
    Double_t nClusters         = part->GetTPCncls();
    Bool_t itsRefit            = part->GetStatus() & AliVTrack::kITSrefit;
    if (nCrossedRaws/nFindableClusters > fFoundFractionCut) mask |= (1 << 26);
    if (nCrossedRaws>fCrossedRowsCut)                       mask |= (1 << 27);
    if (itsRefit)                                           mask |= (1 << 28);
    if (nSharedClusters/nClusters<=fSharedClusterCut)       mask |= (1 << 29);
    if (part->GetLabel()<0)                                 mask |= (1 << 31);
  } else if (track->InheritsFrom("AliESDtrack")){
    AliESDtrack* part = (AliESDtrack*) track;
    if (!fTrackFilter) AliFatal("Track filter undefined");
    mask |= fTrackFilter->IsSelected(part);
  }
  
  return mask;
}
//-----------------------------------------------------------------------------


//-----------------------------------------------------------------------------
AliCFParticle* AliAnalysisTaskCFTree::AddTrack(AliVTrack* track, UInt_t mask, UInt_t flag){

  // skip neutral mc trackicles
  Char_t charge = track->Charge();
  if (charge==0) return NULL;
  
  // set pt,eta,phi
  Float_t pt=0,eta=0,phi=0;
  if (flag==0 || flag==1){ // AOD or Global ESD tracks
    pt  = track->Pt();
    eta = track->Eta();
    phi = track->Phi();
    if  (flag==1) mask &= (~fHybridConstrainedMask) & (~fTPConlyConstrainedMask);
  } 
  else if (flag==2) { // Hybrid constrained tracks (ESD)
    AliESDtrack* part = (AliESDtrack*) track;
    const AliExternalTrackParam* param = part->GetConstrainedParam();
    pt  = param->Pt();
    eta = param->Eta();
    phi = param->Phi();
    mask &= fHybridConstrainedMask;
  } 
  else if (flag==3) { // TPC only constrained tracks (ESD)
    AliESDtrack* part = (AliESDtrack*) track;
    AliESDtrack tpcTrack;
    if (!part->FillTPCOnlyTrack(tpcTrack)) return NULL;
    AliExternalTrackParam param;
    const AliESDVertex* vtxSPD = ((AliESDEvent*) fInputEvent)->GetPrimaryVertexSPD();
    if (!tpcTrack.RelateToVertexTPC(vtxSPD,fField,1.e30,&param)) return NULL;
    pt  = param.Pt();
    eta = param.Eta();
    phi = param.Phi();
    mask &= fTPConlyConstrainedMask;
  }

  // kinematic cuts
  if (pt < fPtMin || TMath::Abs(eta) > fTrackEtaCut) return NULL;

  AliCFParticle* cftrack = new ((*fTracks)[fTracks->GetEntriesFast()]) AliCFParticle(pt,eta,phi,charge,mask,fStorePidInfo ? 3: 0);

  if (!fStorePidInfo) return cftrack;
  Float_t ncl  = track->GetTPCsignalN();
  Float_t dedx = track->GetTPCsignalTunedOnData(); if (dedx<=0) dedx = track->GetTPCsignal();
  Float_t beta = -99;
  if (track->GetStatus()&AliESDtrack::kTOFpid){
    Double_t tof[5];
    track->GetIntegratedTimes(tof);
    beta = tof[0]/track->GetTOFsignal();
  }
  cftrack->SetAt(ncl,0);
  cftrack->SetAt(dedx,1);
  cftrack->SetAt(beta,2);
  return cftrack;
}
Commit	Line	Data
5fe7e785	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	// Analysis task to produce trees of lightweight events
	17	// evgeny.kryshen@cern.ch
	18
	19	// aliroot
	20	#include "AliAnalysisTaskCFTree.h"
	21	#include "AliCFParticle.h"
	22	#include "AliAnalysisManager.h"
	23	#include "AliInputEventHandler.h"
	24	#include "AliESDEvent.h"
	25	#include "AliAODEvent.h"
	26	#include "AliMCEvent.h"
5fe7e785	27	#include "AliAODTrack.h"
5fe7e785	28	#include "AliESDtrack.h"
5fe7e785	29	#include "AliExternalTrackParam.h"
	30	#include "AliCentrality.h"
	31	#include "AliAnalysisFilter.h"
d8c679e5	32	#include "AliVMultiplicity.h"
d8c679e5	33	#include "AliAnalysisUtils.h"
5fe7e785	34	// root
	35	#include "TMath.h"
	36	#include "TFile.h"
	37	#include "TList.h"
	38	#include "TH1I.h"
	39	#include "TChain.h"
	40	#include "TTree.h"
	41	#include "TClonesArray.h"
	42	ClassImp(AliAnalysisTaskCFTree)
	43
	44	//-----------------------------------------------------------------------------
	45	AliAnalysisTaskCFTree::AliAnalysisTaskCFTree(const char* name) :
d8c679e5	46	AliAnalysisTaskSE(name),
5fe7e785	47	fTrackFilter(0x0),
	48	fHybridConstrainedMask(0),
	49	fTPConlyConstrainedMask(0),
d8c679e5	50	fUtils(0x0),
5fe7e785	51	fListOfHistos(0x0),
	52	fEventStatistics(0x0),
	53	fTree(0x0),
d8c679e5	54	fTracks(0x0),
4c66fa46	55	fTracklets(0x0),
4c66fa46	56	fMuons(0x0),
d8c679e5	57	fMcParticles(0x0),
5fe7e785	58	fField(0),
d8c679e5	59	fCentrality(),
	60	fVtxZ(0),
	61	fVtxTPConly(0),
	62	fVtxContributors(0),
5fe7e785	63	fPeriod(0),
	64	fOrbit(),
	65	fBc(),
	66	fSelectMask(0),
d8c679e5	67	fIsPileupSPD(0),
	68	fIsPileupMV(0),
	69	fSelectBit(AliVEvent::kAny),
5fe7e785	70	fZVertexCut(10.),
5fe7e785	71	fTrackFilterBit(0xffffffff),
	72	fTrackEtaCut(1.0),
	73	fPtMin(0.15),
	74	fSharedClusterCut(0.4),
	75	fCrossedRowsCut(100),
4c66fa46	76	fFoundFractionCut(0.8),
c0ff46c8	77	fDphiCut(1.e9),
8e77b3fd	78	fStoreTracks(0),
4c66fa46	79	fStoreTracklets(0),
d8c679e5	80	fStoreMuons(0),
	81	fStoreMcTracks(0),
	82	fStoreMcTracklets(0),
	83	fStoreMcMuons(0),
	84	fStorePidInfo(0)
5fe7e785	85	{
	86	Info("AliAnalysisTaskCFTree","Calling Constructor");
	87	DefineInput(0,TChain::Class());
d8c679e5	88	DefineOutput(1,TList::Class());
d8c679e5	89	DefineOutput(2,TTree::Class());
5fe7e785	90	}
	91	//-----------------------------------------------------------------------------
	92
	93
	94	//-----------------------------------------------------------------------------
d8c679e5	95	void AliAnalysisTaskCFTree::UserCreateOutputObjects(){
5fe7e785	96	fListOfHistos = new TList();
	97	fListOfHistos->SetOwner();
	98	fEventStatistics = new TH1I("fEventStatistics","",10,0,10);
	99	fEventStatistics->SetBit(TH1::kCanRebin);
	100
	101	fListOfHistos->Add(fEventStatistics);
	102
d8c679e5	103	if (fStoreTracks) fTracks = new TClonesArray("AliCFParticle",2000);
	104	if (fStoreTracklets) fTracklets = new TClonesArray("AliCFParticle",2000);
	105	if (fStoreMuons) fMuons = new TClonesArray("AliCFParticle",2000);
	106	if (fStoreMcTracks) fMcParticles = new TClonesArray("AliCFParticle",2000);
5fe7e785	107	// create file-resident tree
	108	TDirectory *owd = gDirectory;
	109	OpenFile(1);
	110	fTree = new TTree("events","events");
	111	owd->cd();
d8c679e5	112	fTree->Branch("cent",&fCentrality,"fCentrality[6]/F");
	113	fTree->Branch("vtxz",&fVtxZ);
	114	fTree->Branch("vtxTPConly",&fVtxTPConly);
	115	fTree->Branch("vtxContributors",&fVtxContributors);
5fe7e785	116	fTree->Branch("field",&fField);
d8c679e5	117	fTree->Branch("run",&fCurrentRunNumber);
5fe7e785	118	fTree->Branch("period",&fPeriod);
	119	fTree->Branch("orbit",&fOrbit);
	120	fTree->Branch("bc",&fBc);
	121	fTree->Branch("mask",&fSelectMask);
d8c679e5	122	fTree->Branch("pileupspd",&fIsPileupSPD);
	123	fTree->Branch("pileupmv",&fIsPileupMV);
	124	if (fTracks) fTree->Branch("tracks",&fTracks);
	125	if (fTracklets) fTree->Branch("tracklets",&fTracklets);
	126	if (fMuons) fTree->Branch("muons",&fMuons);
	127	if (fMcParticles) fTree->Branch("mcparticles",&fMcParticles);
	128
	129	fUtils = new AliAnalysisUtils();
	130
	131	PostData(1,fListOfHistos);
	132	PostData(2,fTree);
5fe7e785	133	}
	134	//-----------------------------------------------------------------------------
	135
	136
	137	//-----------------------------------------------------------------------------
d8c679e5	138	void AliAnalysisTaskCFTree::UserExec(Option_t *){
5fe7e785	139	fEventStatistics->Fill("before cuts",1);
5fe7e785	140
d8c679e5	141	if (!fInputEvent) return;
5fe7e785	142	fEventStatistics->Fill("after event check",1);
5fe7e785	143
d8c679e5	144	// TODO
	145	// TString classes = fInputEvent->GetFiredTriggerClasses();
	146	// fClassesFired = 0;
	147	// fClassesFired \|= (classes.Contains("CINT7-S-") << 0);
	148	// fClassesFired \|= (classes.Contains("CINT7-B-") << 0);
	149	// fClassesFired \|= (classes.Contains("CSHM8-S-") << 1);
	150	// fClassesFired \|= (classes.Contains("CSHM8-B-") << 1);
	151	// fClassesFired \|= (classes.Contains("CMSL7-S-") << 2);
	152	// fClassesFired \|= (classes.Contains("CMSL7-B-") << 2);
	153	// fClassesFired \|= (classes.Contains("CMSH7-S-") << 3);
	154	// fClassesFired \|= (classes.Contains("CMSH7-B-") << 3);
	155	// fClassesFired \|= (classes.Contains("CMUL7-S-") << 4);
	156	// fClassesFired \|= (classes.Contains("CMUL7-B-") << 4);
	157	// fClassesFired \|= (classes.Contains("CMLL7-S-") << 5);
	158	// fClassesFired \|= (classes.Contains("CMLL7-B-") << 5);
	159	// fClassesFired \|= (classes.Contains("CINT8-S-") << 6);
	160	// fClassesFired \|= (classes.Contains("CSPI7-S-") << 7);
	161	// fClassesFired \|= (classes.Contains("CSPI8-S-") << 8);
	162	// fClassesFired \|= (classes.Contains("CMSL8-S-") << 9);
	163	// fClassesFired \|= (classes.Contains("CMSH8-S-") <<10);
	164	// fClassesFired \|= (classes.Contains("CMUL8-S-") <<11);
	165	// fClassesFired \|= (classes.Contains("CMLL8-S-") <<12);
	166	// fClassesFired \|= (classes.Contains("C0MUL-SA") <<13);
	167	// fClassesFired \|= (classes.Contains("C0MUL-SC") <<14);
	168	// if (!fClassesFired) return;
	169	// fEventStatistics->Fill("after trigger check",1);
5fe7e785	170
	171	fSelectMask = fInputHandler->IsEventSelected();
	172	if (!(fSelectMask & fSelectBit)) return;
5fe7e785	173
d8c679e5	174	fEventStatistics->Fill("after physics selection",1);
	175
	176	fPeriod = fInputEvent->GetPeriodNumber();
	177	fOrbit = fInputEvent->GetOrbitNumber();
	178	fBc = fInputEvent->GetBunchCrossNumber();
	179	fField = fInputEvent->GetMagneticField();
	180	fCentrality[0] = fInputEvent->GetCentrality()->GetCentralityPercentile("V0M");
	181	fCentrality[1] = fInputEvent->GetCentrality()->GetCentralityPercentile("V0A");
	182	fCentrality[2] = fInputEvent->GetCentrality()->GetCentralityPercentile("V0C");
	183	fCentrality[3] = fInputEvent->GetCentrality()->GetCentralityPercentile("CL1");
	184	fCentrality[4] = fInputEvent->GetCentrality()->GetCentralityPercentile("ZNA");
	185	fCentrality[5] = fInputEvent->GetCentrality()->GetCentralityPercentile("ZNC");
	186	fIsPileupSPD = fUtils->IsPileUpSPD(fInputEvent);
	187	fIsPileupMV = fUtils->IsPileUpMV(fInputEvent);
	188	// fNofITSClusters[i] = esd->GetMultiplicity()->GetNumberOfITSClusters(i);
	189
	190	const AliVVertex* vertex = fInputEvent->GetPrimaryVertex();
	191	fVtxZ = vertex->GetZ();
	192	fVtxTPConly = TString(vertex->GetName()).CompareTo("PrimaryVertex") && TString(vertex->GetName()).CompareTo("SPDVertex");
	193	fVtxContributors = vertex->GetNContributors();
	194	if (TMath::Abs(fVtxZ) >= fZVertexCut) return;
	195	fEventStatistics->Fill("after vertex cut",1);
	196
	197	if (fTracks) {
	198	fTracks->Clear();
	199	for (Int_t ipart=0;ipart<fInputEvent->GetNumberOfTracks();ipart++){
	200	AliVTrack* track = (AliVTrack*) fInputEvent->GetTrack(ipart);
	201	if (!track) continue;
	202	UInt_t mask = GetFilterMap(track);
	203	if (!(mask & fTrackFilterBit)) continue;
5fe7e785	204
d8c679e5	205	if (track->InheritsFrom("AliAODTrack")) AddTrack(track,mask,0);
	206	else if (track->InheritsFrom("AliESDtrack")) {
	207	if (mask) AddTrack(track,mask,1);
	208	if (mask & fHybridConstrainedMask) AddTrack(track,mask,2);
	209	if (mask & fTPConlyConstrainedMask) AddTrack(track,mask,3);
4c66fa46	210	}
4c66fa46	211	}
5fe7e785	212	}
4c66fa46	213
d8c679e5	214	if (fTracklets){
	215	fTracklets->Clear();
	216	AliVMultiplicity* mult = fInputEvent->GetMultiplicity();
	217	Int_t nTracklets = mult->GetNumberOfTracklets();
	218	for (Int_t i=0;i<nTracklets;i++){
	219	Float_t phi = mult->GetPhi(i);
	220	Float_t eta = -TMath::Log(TMath::Tan(mult->GetTheta(i)/2));
	221	Float_t dphi = mult->GetDeltaPhi(i);
	222	if (TMath::Abs(dphi)>fDphiCut) continue;
	223	AliCFParticle* tracklet = new ((*fTracklets)[fTracklets->GetEntriesFast()]) AliCFParticle(dphi,eta,phi,0,0,fStoreMcTracklets?4:0);
	224	if (!fStoreMcTracklets \|\| !fMCEvent) continue;
	225	Int_t label1 = mult->GetLabel(i,0);
	226	Int_t label2 = mult->GetLabel(i,1);
	227	if (label1!=label2) continue;
	228	AliVParticle* particle = fMCEvent->GetTrack(label1);
	229	if (!particle) continue;
	230	Short_t charge = particle->Charge();
	231	Float_t ptMC = particle->Pt();
	232	Float_t etaMC = particle->Eta();
	233	Float_t phiMC = particle->Phi();
	234	Float_t pdg = particle->PdgCode();
	235	tracklet->SetCharge(charge);
	236	tracklet->SetAt(ptMC,0);
	237	tracklet->SetAt(etaMC,1);
	238	tracklet->SetAt(phiMC,2);
	239	tracklet->SetAt(pdg,3);
2bb5fec4	240	}
d8c679e5	241	}
	242
	243	AliAODEvent* aod = dynamic_cast<AliAODEvent*> (fInputEvent);
	244	if (fMuons && aod){ // aod only
	245	fMuons->Clear();
4640c275	246	for (Int_t iTrack = 0; iTrack < aod->GetNumberOfTracks(); iTrack++) {
	247	AliAODTrack* track = dynamic_cast<AliAODTrack*>(aod->GetTrack(iTrack));
	248	if(!track) AliFatal("Not a standard AOD");
d8c679e5	249	if (!track->IsMuonTrack()) continue;
	250	Float_t pt = track->Pt();
	251	Float_t eta = track->Eta();
	252	Float_t phi = track->Phi();
	253	Short_t charge = track->Charge();
	254	Float_t dca = track->DCA();
	255	Float_t chi2 = track->Chi2perNDF();
	256	Float_t rabs = track->GetRAtAbsorberEnd();
	257	Int_t mask = track->GetMatchTrigger();
	258	if (rabs < 17.6 \|\| rabs > 89.5) continue;
	259	if (eta < -4 \|\| eta > -2.5) continue;
	260	AliCFParticle* part = new ((*fMuons)[fMuons->GetEntriesFast()]) AliCFParticle(pt,eta,phi,charge,mask,fStoreMcMuons?11:3);
	261	part->SetAt(dca,0);
	262	part->SetAt(chi2,1);
	263	part->SetAt(rabs,2);
	264	if (!fStoreMcMuons \|\| !fMCEvent) continue;
	265	Int_t label = TMath::Abs(track->GetLabel());
	266	AliVParticle* mcpart = fMCEvent->GetTrack(label);
	267	if (!mcpart) continue;
	268	Int_t mcpdg = mcpart->PdgCode();
	269	Float_t mcpt = mcpart->Pt();
	270	Float_t mceta = mcpart->Eta();
	271	Float_t mcphi = mcpart->Phi();
	272	part->SetAt(mcpt,3);
	273	part->SetAt(mceta,4);
	274	part->SetAt(mcphi,5);
	275	part->SetAt(mcpdg,6);
	276	part->SetAt(0,10);
	277	Bool_t isPrimary = fMCEvent->IsPhysicalPrimary(label);
	278	if (isPrimary) continue;
	279	label = mcpart->GetMother();
	280	while (!isPrimary && label>=0) {
	281	mcpart = (AliVParticle*) fMCEvent->GetTrack(label);
	282	label = mcpart->GetMother();
	283	isPrimary = fMCEvent->IsPhysicalPrimary(label);
8e77b3fd	284	}
d8c679e5	285	if (!mcpart) continue;
	286	Float_t mcprimarypt = mcpart->Pt();
	287	Float_t mcprimaryeta = mcpart->Eta();
	288	Float_t mcprimaryphi = mcpart->Phi();
	289	Int_t mcprimarypdg = mcpart->PdgCode();
	290	part->SetAt(mcprimarypt,7);
	291	part->SetAt(mcprimaryeta,8);
	292	part->SetAt(mcprimaryphi,9);
	293	part->SetAt(mcprimarypdg,10);
5fe7e785	294	}
d8c679e5	295	}
8e77b3fd	296
d8c679e5	297	if (fMcParticles && fMCEvent) {
	298	fMcParticles->Clear();
	299	TString gen;
	300	for (Int_t ipart=0;ipart<fMCEvent->GetNumberOfTracks();ipart++){
	301	AliVParticle* part = fMCEvent->GetTrack(ipart);
	302	Bool_t isCocktail = fMCEvent->GetCocktailGenerator(ipart,gen);
	303	if (isCocktail && !gen.Contains("Pythia") && !gen.Contains("Hijing") && !gen.Contains("AMPT") && !gen.Contains("DPMJET")) continue;
	304	Float_t pt = part->Pt();
	305	Float_t eta = part->Eta();
	306	Float_t phi = part->Phi();
	307	Char_t charge = part->Charge();
	308	Int_t mask = part->PdgCode();
	309	// TODO
	310	// Bool_t isPrimary = fMCEvent->IsPhysicalPrimary(ipart);
	311	// if (pt < fMcPtMin) continue;
	312	// if (TMath::Abs(eta) > fMcTrackEtaCut) continue;
	313	new ((*fMcParticles)[fMcParticles->GetEntriesFast()]) AliCFParticle(pt,eta,phi,charge,mask);
5fe7e785	314	}
5fe7e785	315	}
d8c679e5	316
5fe7e785	317	fTree->Fill();
d8c679e5	318	PostData(1,fListOfHistos);
d8c679e5	319	PostData(2,fTree);
5fe7e785	320	}
	321	//-----------------------------------------------------------------------------
	322
	323
	324	//-----------------------------------------------------------------------------
d8c679e5	325	UInt_t AliAnalysisTaskCFTree::GetFilterMap(AliVTrack* track){
5fe7e785	326	UInt_t mask = 0;
d8c679e5	327	if (track->InheritsFrom("AliAODTrack")) {
d8c679e5	328	AliAODTrack* part = (AliAODTrack*) track;
5fe7e785	329	mask = part->GetFilterMap();
	330	Double_t nCrossedRaws = part->GetTPCNCrossedRows();
	331	Double_t nFindableClusters = part->GetTPCNclsF();
	332	Double_t nSharedClusters = part->GetTPCnclsS();
	333	Double_t nClusters = part->GetTPCncls();
	334	Bool_t itsRefit = part->GetStatus() & AliVTrack::kITSrefit;
	335	if (nCrossedRaws/nFindableClusters > fFoundFractionCut) mask \|= (1 << 26);
	336	if (nCrossedRaws>fCrossedRowsCut) mask \|= (1 << 27);
	337	if (itsRefit) mask \|= (1 << 28);
	338	if (nSharedClusters/nClusters<=fSharedClusterCut) mask \|= (1 << 29);
	339	if (part->GetLabel()<0) mask \|= (1 << 31);
d8c679e5	340	} else if (track->InheritsFrom("AliESDtrack")){
d8c679e5	341	AliESDtrack* part = (AliESDtrack*) track;
5fe7e785	342	if (!fTrackFilter) AliFatal("Track filter undefined");
	343	mask \|= fTrackFilter->IsSelected(part);
	344	}
	345
	346	return mask;
	347	}
	348	//-----------------------------------------------------------------------------
	349
	350
	351	//-----------------------------------------------------------------------------
d8c679e5	352	AliCFParticle* AliAnalysisTaskCFTree::AddTrack(AliVTrack* track, UInt_t mask, UInt_t flag){
5fe7e785	353
d8c679e5	354	// skip neutral mc trackicles
d8c679e5	355	Char_t charge = track->Charge();
5fe7e785	356	if (charge==0) return NULL;
	357
	358	// set pt,eta,phi
	359	Float_t pt=0,eta=0,phi=0;
d8c679e5	360	if (flag==0 \|\| flag==1){ // AOD or Global ESD tracks
	361	pt = track->Pt();
	362	eta = track->Eta();
	363	phi = track->Phi();
5fe7e785	364	if (flag==1) mask &= (~fHybridConstrainedMask) & (~fTPConlyConstrainedMask);
	365	}
	366	else if (flag==2) { // Hybrid constrained tracks (ESD)
d8c679e5	367	AliESDtrack* part = (AliESDtrack*) track;
d8c679e5	368	const AliExternalTrackParam* param = part->GetConstrainedParam();
5fe7e785	369	pt = param->Pt();
	370	eta = param->Eta();
	371	phi = param->Phi();
	372	mask &= fHybridConstrainedMask;
	373	}
	374	else if (flag==3) { // TPC only constrained tracks (ESD)
d8c679e5	375	AliESDtrack* part = (AliESDtrack*) track;
5fe7e785	376	AliESDtrack tpcTrack;
d8c679e5	377	if (!part->FillTPCOnlyTrack(tpcTrack)) return NULL;
5fe7e785	378	AliExternalTrackParam param;
d8c679e5	379	const AliESDVertex* vtxSPD = ((AliESDEvent*) fInputEvent)->GetPrimaryVertexSPD();
5fe7e785	380	if (!tpcTrack.RelateToVertexTPC(vtxSPD,fField,1.e30,&param)) return NULL;
	381	pt = param.Pt();
	382	eta = param.Eta();
	383	phi = param.Phi();
	384	mask &= fTPConlyConstrainedMask;
	385	}
	386
	387	// kinematic cuts
	388	if (pt < fPtMin \|\| TMath::Abs(eta) > fTrackEtaCut) return NULL;
	389
d8c679e5	390	AliCFParticle* cftrack = new ((*fTracks)[fTracks->GetEntriesFast()]) AliCFParticle(pt,eta,phi,charge,mask,fStorePidInfo ? 3: 0);
e428489e	391
d8c679e5	392	if (!fStorePidInfo) return cftrack;
e428489e	393	Float_t ncl = track->GetTPCsignalN();
	394	Float_t dedx = track->GetTPCsignalTunedOnData(); if (dedx<=0) dedx = track->GetTPCsignal();
	395	Float_t beta = -99;
	396	if (track->GetStatus()&AliESDtrack::kTOFpid){
	397	Double_t tof[5];
	398	track->GetIntegratedTimes(tof);
	399	beta = tof[0]/track->GetTOFsignal();
	400	}
d8c679e5	401	cftrack->SetAt(ncl,0);
	402	cftrack->SetAt(dedx,1);
	403	cftrack->SetAt(beta,2);
	404	return cftrack;
5fe7e785	405	}