AliFlowEventSimpleMaker.cxx

Go to the documentation of this file.

/**************************************************************************
 * 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.                  *
 **************************************************************************/
// AliFlowEventSimpleMaker:
//
// Class to fill the AliFlowEventSimple
// with AliFlowTrackSimple objects
// Has fill methods for TTree, AliMCEvent, AliESDEvent and AliAODEvent
// author: N. van der Kolk (kolk@nikhef.nl)

#include "Riostream.h"
#include "TTree.h"
#include "TParticle.h"
#include "AliFlowEventSimpleMaker.h"
#include "AliFlowEventSimple.h"
#include "AliFlowTrackSimple.h"
#include "AliMCEvent.h"
#include "AliMCParticle.h"
#include "AliESDEvent.h"
#include "AliESDtrack.h"
#include "AliAODEvent.h"
#include "AliAODTrack.h"
#include "AliCFManager.h"
#include "AliFlowTrackSimpleCuts.h"
#include "assert.h"

using std::endl;
using std::cout;
ClassImp(AliFlowEventSimpleMaker)
//----------------------------------------------------------------------- 
AliFlowEventSimpleMaker::AliFlowEventSimpleMaker() :
  fMCReactionPlaneAngle(0.),
  fCount(0),
  fNoOfLoops(1),
  fEllipticFlowValue(0.),
  fMultiplicityOfEvent(1000000000),
  fMinMult(0),
  fMaxMult(1000000000),
  fEtaMinA(-1.0),
  fEtaMaxA(-0.01),
  fEtaMinB(0.01),
  fEtaMaxB(1.0)
{
  //constructor
}

//-----------------------------------------------------------------------   
AliFlowEventSimpleMaker::~AliFlowEventSimpleMaker()
{
  //destructor
}

//-----------------------------------------------------------------------   
AliFlowEventSimple* AliFlowEventSimpleMaker::FillTracks( AliMCEvent* anInput, const AliCFManager* intCFManager, const AliCFManager* diffCFManager)
{
  //Fills the event from the MC kinematic information
  
  Int_t iNumberOfInputTracks = anInput->GetNumberOfTracks() ;

  if (iNumberOfInputTracks==-1) {
    cout<<"Skipping Event -- No MC information available for this event"<<endl;
    return 0;
  }

  Int_t iN = iNumberOfInputTracks; //maximum number of tracks in AliFlowEventSimple
  Int_t iGoodTracks = 0;           //number of good tracks
  Int_t itrkN = 0;                 //track counter
  Int_t iSelParticlesPOI = 0;     //number of tracks selected for Diff
  Int_t iSelParticlesRP = 0;      //number of tracks selected for Int

  // cut on the multiplicity
  if (intCFManager->CheckEventCuts(AliCFManager::kEvtGenCuts,anInput)) {
    // cout<<"iNumberOfInputTracks = "<<iNumberOfInputTracks<<endl;
    // create an AliFlowEventSimple
    AliFlowEventSimple* pEvent = new AliFlowEventSimple(10);
       
    //loop over tracks
    while (iGoodTracks < iN && itrkN < iNumberOfInputTracks) {
      //get input particle
      AliMCParticle* pParticle = (AliMCParticle*) anInput->GetTrack(itrkN);   
      //make new AliFlowTrackSimple
      AliFlowTrackSimple* pTrack = new AliFlowTrackSimple();
      pTrack->SetPt(pParticle->Pt() );
      pTrack->SetEta(pParticle->Eta() );
      pTrack->SetPhi(pParticle->Phi() );
    
      //check if pParticle passes the cuts
      if (intCFManager->CheckParticleCuts(AliCFManager::kPartGenCuts,pParticle)) {
  pTrack->SetForRPSelection(kTRUE);
  //cout<<"integrated selection. PID = "<<pParticle->Particle()->GetPdgCode()<<endl; 
      }
      if (diffCFManager->CheckParticleCuts(AliCFManager::kPartGenCuts,pParticle)) {
  pTrack->SetForPOISelection(kTRUE);
  //cout<<"differential selection. PID = "<<pParticle->Particle()->GetPdgCode()<<endl; 
      }
      
      //check if any bits are set
      const TBits* bFlowBits = pTrack->GetFlowBits();
      if (bFlowBits->CountBits() ==0) {
  delete pTrack; } //track will not be used anymore
      else {
  pEvent->AddTrack(pTrack) ; 
  iGoodTracks++;

  if (pTrack->InRPSelection())
    { iSelParticlesRP++; }
  if (pTrack->InPOISelection())
    { iSelParticlesPOI++; }
      }
      
      itrkN++; 
    }
    
    pEvent-> SetEventNSelTracksRP(iSelParticlesRP);  
    pEvent->SetMCReactionPlaneAngle(fMCReactionPlaneAngle);
        
    if (iSelParticlesRP >= fMinMult && iSelParticlesRP <= fMaxMult) { 
      if ( (++fCount % 100) == 0) {
  cout<<" MC Reaction Plane Angle = "<<  fMCReactionPlaneAngle << endl;
  //
  cout<<" iGoodTracks = "<<iGoodTracks<<endl;
  cout<<" # of RP selected tracks = "<<iSelParticlesRP<<endl;
  cout<<" # of POI selected tracks = "<<iSelParticlesPOI<<endl;  
  cout << "# " << fCount << " events processed" << endl;
      }
      return pEvent;
    }
    else { 
      cout<<"Not enough tracks in the FlowEventSimple"<<endl;
      return 0;
    }
  }
  else {
    cout<<"Event does not pass multiplicity cuts"<<endl; 
    return 0;
  }
  
}

//-----------------------------------------------------------------------   

AliFlowEventSimple* AliFlowEventSimpleMaker::FillTracks(AliESDEvent* anInput, const AliCFManager* intCFManager, const AliCFManager* diffCFManager)
{
  //Fills the event from the ESD
  
  //flags for particles passing int. and diff. flow cuts
  Bool_t bPassedRPFlowCuts  = kFALSE;
  Bool_t bPassedPOIFlowCuts = kFALSE;
  
  Int_t iNumberOfInputTracks = anInput->GetNumberOfTracks() ;
  
  Int_t iGoodTracks = 0;           //number of good tracks
  Int_t itrkN = 0;                 //track counter
  Int_t iSelParticlesRP = 0;      //number of tracks selected for Int
  Int_t iSelParticlesPOI = 0;     //number of tracks selected for Diff
  
  // cut on the multiplicity
  if (intCFManager->CheckEventCuts(AliCFManager::kEvtRecCuts,anInput)) {
    // cout<<"iNumberOfInputTracks = "<<iNumberOfInputTracks<<endl; 
    // create an AliFlowEventSimple
    AliFlowEventSimple* pEvent = new AliFlowEventSimple(10);

    //loop over tracks
    while (itrkN < iNumberOfInputTracks) {
      AliESDtrack* pParticle = anInput->GetTrack(itrkN);   //get input particle
      
      //check if pParticle passes the cuts
      if (intCFManager->CheckParticleCuts(AliCFManager::kPartRecCuts,pParticle) && 
    intCFManager->CheckParticleCuts(AliCFManager::kPartSelCuts,pParticle)) {
  bPassedRPFlowCuts = kTRUE;
      }
      if (diffCFManager->CheckParticleCuts(AliCFManager::kPartRecCuts,pParticle) && 
    diffCFManager->CheckParticleCuts(AliCFManager::kPartSelCuts,pParticle)) {
  bPassedPOIFlowCuts = kTRUE;
      }
      
      if (bPassedRPFlowCuts || bPassedPOIFlowCuts) {
  //make new AliFLowTrackSimple
  AliFlowTrackSimple* pTrack = new AliFlowTrackSimple();
  pTrack->SetPt(pParticle->Pt() );
  pTrack->SetEta(pParticle->Eta() );
  if (fEllipticFlowValue>0.) 
    { pTrack->SetPhi(pParticle->Phi()-fEllipticFlowValue*TMath::Sin(2*(pParticle->Phi()-fMCReactionPlaneAngle))); cout<<"Added flow to particle"<<endl; }
  else { pTrack->SetPhi(pParticle->Phi() ); } 

  //marking the particles used for int. flow:
  if(bPassedRPFlowCuts) {  
    pTrack->SetForRPSelection(kTRUE);
    iSelParticlesRP++;
    // assign particles to subevents
    if (pTrack->Eta()>=fEtaMinA && pTrack->Eta()<=fEtaMaxA) {
      pTrack->SetForSubevent(0);
    }
    if (pTrack->Eta()>=fEtaMinB && pTrack->Eta()<=fEtaMaxB) {
      pTrack->SetForSubevent(1);
    }

  }
  //marking the particles used for diff. flow:
  if(bPassedPOIFlowCuts) {
    pTrack->SetForPOISelection(kTRUE);
    iSelParticlesPOI++;
  }
  //adding particles which were used either for int. or diff. flow to the list
  pEvent->AddTrack(pTrack);
  iGoodTracks++;
      }//end of if(bPassedIntFlowCuts || bPassedDiffFlowCuts) 
      itrkN++; 
      bPassedRPFlowCuts  = kFALSE;
      bPassedPOIFlowCuts = kFALSE;
    }//end of while (itrkN < iNumberOfInputTracks)
    
    pEvent->SetEventNSelTracksRP(iSelParticlesRP);  
    pEvent->SetMCReactionPlaneAngle(fMCReactionPlaneAngle);
    
    
    if (iSelParticlesRP >= fMinMult && iSelParticlesRP <= fMaxMult) { 
      if ( (++fCount % 100) == 0) {
  if (fMCReactionPlaneAngle != 0) cout<<" MC Reaction Plane Angle = "<<  fMCReactionPlaneAngle << endl;
  else cout<<" MC Reaction Plane Angle = unknown "<< endl;
  cout<<" iGoodTracks = "<<iGoodTracks<<endl;
  cout<<" # of RP selected tracks = "<<iSelParticlesRP<<endl;
  cout<<" # of POI selected tracks = "<<iSelParticlesPOI<<endl;  
  cout << "# " << fCount << " events processed" << endl;
      }
      return pEvent;
    }
    else {
      cout<<"Not enough tracks in the FlowEventSimple"<<endl;
      return 0;
    }
  }
  else {
    cout<<"Event does not pass multiplicity cuts"<<endl; 
    return 0;
  }
  
}

//-----------------------------------------------------------------------   
AliFlowEventSimple* AliFlowEventSimpleMaker::FillTracks(AliAODEvent* anInput,  const AliCFManager* intCFManager, const AliCFManager* diffCFManager)
{
  //Fills the event from the AOD
  
  Int_t iNumberOfInputTracks = anInput->GetNumberOfTracks() ;
  
  Int_t iN = iNumberOfInputTracks; //maximum number of tracks in AliFlowEventSimple
  Int_t iGoodTracks = 0;           //number of good tracks
  Int_t itrkN = 0;                 //track counter
  Int_t iSelParticlesPOI = 0;     //number of tracks selected for Diff
  Int_t iSelParticlesRP = 0;      //number of tracks selected for Int

  // cut on the multiplicity
  if (intCFManager->CheckEventCuts(AliCFManager::kEvtRecCuts,anInput)) {
    // cout<<"iNumberOfInputTracks = "<<iNumberOfInputTracks<<endl; 
    // create an AliFlowEventSimple
    AliFlowEventSimple* pEvent = new AliFlowEventSimple(10);

    //loop over tracks
    while (iGoodTracks < iN && itrkN < iNumberOfInputTracks) {
      AliAODTrack* pParticle = dynamic_cast<AliAODTrack*>(anInput->GetTrack(itrkN));
      assert((pParticle)&&"Not a standard AOD");   //get input particle
      //make new AliFlowTrackSimple
      AliFlowTrackSimple* pTrack = new AliFlowTrackSimple();
      pTrack->SetPt(pParticle->Pt() );
      pTrack->SetEta(pParticle->Eta() );
      pTrack->SetPhi(pParticle->Phi() );
      
      //check if pParticle passes the cuts
      if (intCFManager->CheckParticleCuts(AliCFManager::kPartRecCuts,pParticle) &&
    intCFManager->CheckParticleCuts(AliCFManager::kPartSelCuts,pParticle)) {          
  pTrack->SetForRPSelection(kTRUE); }
      if (diffCFManager->CheckParticleCuts(AliCFManager::kPartRecCuts,pParticle) &&
    diffCFManager->CheckParticleCuts(AliCFManager::kPartSelCuts,pParticle)) {
  pTrack->SetForPOISelection(kTRUE);} 
      
      
      //check if any bits are set
      const TBits* bFlowBits = pTrack->GetFlowBits();
      if (bFlowBits->CountBits() ==0) {
  delete pTrack; } //track will not be used anymore
      else {
  pEvent->AddTrack(pTrack) ; 
  iGoodTracks++;
  
  if (pTrack->InRPSelection())
    { iSelParticlesRP++; }
  if (pTrack->InPOISelection())
    { iSelParticlesPOI++; }
  
      }
      
      itrkN++; 
    }
    
    pEvent-> SetEventNSelTracksRP(iSelParticlesRP);  
    pEvent->SetMCReactionPlaneAngle(fMCReactionPlaneAngle);
    
    if (iSelParticlesRP >= fMinMult && iSelParticlesRP <= fMaxMult) { 
      if ( (++fCount % 100) == 0) {
  if (fMCReactionPlaneAngle != 0) cout<<" MC Reaction Plane Angle = "<<  fMCReactionPlaneAngle << endl;
  else cout<<" MC Reaction Plane Angle = unknown "<< endl;
  cout<<" iGoodTracks = "<<iGoodTracks<<endl;
  cout<<" # of RP selected tracks = "<<iSelParticlesRP<<endl;
  cout<<" # of POI selected tracks = "<<iSelParticlesPOI<<endl;  
  cout << "# " << fCount << " events processed" << endl;
      }
      return pEvent;
    }
    else {
      cout<<"Not enough tracks in the FlowEventSimple"<<endl;
      return 0;
    }
  }
  else {
    cout<<"Event does not pass multiplicity cuts"<<endl; 
    return 0;
  }
  
}

//-----------------------------------------------------------------------   
AliFlowEventSimple*  AliFlowEventSimpleMaker::FillTracks(AliESDEvent* anInput, const AliMCEvent* anInputMc, const AliCFManager* intCFManager, const AliCFManager* diffCFManager, Int_t anOption)
{
  //fills the event with tracks from the ESD and kinematics from the MC info via the track label

  
  if (!(anOption ==0 || anOption ==1)) {
    cout<<"WRONG OPTION IN AliFlowEventSimpleMaker::FillTracks(AliESDEvent* anInput, AliMCEvent* anInputMc, Int_t anOption)"<<endl;
    exit(1);
  }

  Int_t iNumberOfInputTracks = anInput->GetNumberOfTracks() ;

  Int_t iNumberOfInputTracksMC = anInputMc->GetNumberOfTracks() ;
  if (iNumberOfInputTracksMC==-1) {
    cout<<"Skipping Event -- No MC information available for this event"<<endl;
    return 0;
  }

  Int_t iN = iNumberOfInputTracks; //maximum number of tracks in AliFlowEventSimple
  Int_t iGoodTracks = 0;           //number of good tracks
  Int_t itrkN = 0;                 //track counter
  Int_t iSelParticlesPOI = 0;     //number of tracks selected for Diff
  Int_t iSelParticlesRP = 0;      //number of tracks selected for Int

  // cut on the multiplicity
  if (intCFManager->CheckEventCuts(AliCFManager::kEvtRecCuts,anInput)) {
    // cout<<"iNumberOfInputTracks = "<<iNumberOfInputTracks<<endl; 
    // create an AliFlowEventSimple
    AliFlowEventSimple* pEvent = new AliFlowEventSimple(10);

    //loop over ESD tracks
    while (iGoodTracks < iN && itrkN < iNumberOfInputTracks) {
      AliESDtrack* pParticle = anInput->GetTrack(itrkN);   //get input particle
      //get Label
      Int_t iLabel = pParticle->GetLabel();
      //match to mc particle
      AliMCParticle* pMcParticle = (AliMCParticle*) anInputMc->GetTrack(TMath::Abs(iLabel));
      
      //check
      if (TMath::Abs(pParticle->GetLabel())!=pMcParticle->Label()) cout<<"pParticle->GetLabel()!=pMcParticle->Label() "<<pParticle->GetLabel()<<"  "<<pMcParticle->Label()<<endl;
      
      //make new AliFlowTrackSimple
      AliFlowTrackSimple* pTrack = new AliFlowTrackSimple();
      if(anOption == 0) { //take the PID from the MC & the kinematics from the ESD
  pTrack->SetPt(pParticle->Pt() );
  pTrack->SetEta(pParticle->Eta() );
  pTrack->SetPhi(pParticle->Phi() );
      }
      else if (anOption == 1) { //take the PID and kinematics from the MC
  pTrack->SetPt(pMcParticle->Pt() );
  pTrack->SetEta(pMcParticle->Eta() );
  pTrack->SetPhi(pMcParticle->Phi() );
      }
      else { cout<<"Not a valid option"<<endl; }
      
      //check if pParticle passes the cuts
      if(anOption == 0) { 
  //cout<<"take the PID from the MC & the kinematics from the ESD"<<endl;
  if (intCFManager->CheckParticleCuts(AliCFManager::kPartGenCuts,pMcParticle,"mcGenCuts1") && 
      intCFManager->CheckParticleCuts(AliCFManager::kPartRecCuts,pParticle)) {  
    pTrack->SetForRPSelection(kTRUE); }
  if (diffCFManager->CheckParticleCuts(AliCFManager::kPartGenCuts,pMcParticle,"mcGenCuts2") &&
      diffCFManager->CheckParticleCuts(AliCFManager::kPartRecCuts,pParticle)) {  
    pTrack->SetForPOISelection(kTRUE);}
      }
      else if (anOption == 1) { 
  //cout<<"take the PID and kinematics from the MC"<<endl;
  if (intCFManager->CheckParticleCuts(AliCFManager::kPartGenCuts,pMcParticle)) {  
    pTrack->SetForRPSelection(kTRUE); }
  if (diffCFManager->CheckParticleCuts(AliCFManager::kPartGenCuts,pMcParticle)) {  
    pTrack->SetForPOISelection(kTRUE);}
      }
      else { cout<<"Not a valid option"<<endl; }
      
      //check if any bits are set
      const TBits* bFlowBits = pTrack->GetFlowBits();
      if (bFlowBits->CountBits() ==0) {
  delete pTrack; } //track will not be used anymore
      else {
  pEvent->AddTrack(pTrack) ; 
  iGoodTracks++;  
  
  if (pTrack->InRPSelection())
    { iSelParticlesRP++; }
  if (pTrack->InPOISelection())
    { iSelParticlesPOI++; }
  
      }
      
      itrkN++; 
    }
    
    pEvent->SetEventNSelTracksRP(iSelParticlesRP);  
    pEvent->SetMCReactionPlaneAngle(fMCReactionPlaneAngle);
        
    if (iSelParticlesRP >= fMinMult && iSelParticlesRP <= fMaxMult) { 
      if ( (++fCount % 100) == 0) {
  if (fMCReactionPlaneAngle != 0) cout<<" MC Reaction Plane Angle = "<<  fMCReactionPlaneAngle << endl;
  else cout<<" MC Reaction Plane Angle = unknown "<< endl;
  cout << " Number of MC input tracks = " << iNumberOfInputTracksMC << endl;
  cout<<" iGoodTracks = "<<iGoodTracks<<endl;
  cout<<" # of RP selected tracks = "<<iSelParticlesRP<<endl;
  cout<<" # of POI selected tracks = "<<iSelParticlesPOI<<endl;  
  cout << "# " << fCount << " events processed" << endl;
      }
      return pEvent;
    }
    else {
      cout<<"Not enough tracks in the FlowEventSimple"<<endl;
      return 0;
    }
  }
  else {
    cout<<"Event does not pass multiplicity cuts"<<endl; 
    return 0;
  }
    
}

//local methods
//-----------------------------------------------------------------------   
AliFlowEventSimple* AliFlowEventSimpleMaker::FillTracks(TTree* anInput, const AliFlowTrackSimpleCuts* rpCuts, const AliFlowTrackSimpleCuts* poiCuts)
{
  //fills the event from a TTree of kinematic.root files
  
  // number of times to use the same particle (trick to introduce nonflow)
  
  //flags for particles passing int. and diff. flow cuts
  Bool_t bPassedRPFlowCuts  = kFALSE;
  Bool_t bPassedPOIFlowCuts = kFALSE;
  
  //track cut values
  Double_t dPtMaxRP  = rpCuts->GetPtMax();
  Double_t dPtMinRP  = rpCuts->GetPtMin();
  Double_t dEtaMaxRP = rpCuts->GetEtaMax();
  Double_t dEtaMinRP = rpCuts->GetEtaMin();
  Double_t dPhiMaxRP = rpCuts->GetPhiMax();
  Double_t dPhiMinRP = rpCuts->GetPhiMin();
  Int_t iPIDRP       = rpCuts->GetPID();
  
  Double_t dPtMaxPOI  = poiCuts->GetPtMax();
  Double_t dPtMinPOI  = poiCuts->GetPtMin();
  Double_t dEtaMaxPOI = poiCuts->GetEtaMax();
  Double_t dEtaMinPOI = poiCuts->GetEtaMin();
  Double_t dPhiMaxPOI = poiCuts->GetPhiMax();
  Double_t dPhiMinPOI = poiCuts->GetPhiMin();
  Int_t iPIDPOI       = poiCuts->GetPID();
  
  Int_t iNumberOfInputTracks = anInput->GetEntries() ;

  TParticle* pParticle = new TParticle();
  anInput->SetBranchAddress("Particles",&pParticle);  
  //  AliFlowEventSimple* pEvent = new AliFlowEventSimple(iNumberOfInputTracks);
  AliFlowEventSimple* pEvent = new AliFlowEventSimple(10);
  
  //  Int_t fMultiplicityOfEvent = 576; //multiplicity for chi=1.5
  //  Int_t fMultiplicityOfEvent = 256; //multiplicity for chi=1
  //  Int_t fMultiplicityOfEvent = 164; //multiplicity for chi=0.8

  Int_t iGoodTracks = 0;
  Int_t itrkN = 0;
  Int_t iSelParticlesRP = 0;
  Int_t iSelParticlesPOI = 0;
  
  while (itrkN < iNumberOfInputTracks) {
    anInput->GetEntry(itrkN);   //get input particle
    if (pParticle->IsPrimary()) {
      //checking the cuts for int. and diff. flow
      if (pParticle->Pt() > dPtMinRP && pParticle->Pt() < dPtMaxRP &&
    pParticle->Eta() > dEtaMinRP && pParticle->Eta() < dEtaMaxRP &&
    pParticle->Phi() > dPhiMinRP && pParticle->Phi() < dPhiMaxRP &&
    TMath::Abs(pParticle->GetPdgCode()) == iPIDRP) { 
  bPassedRPFlowCuts = kTRUE;
      } 
    
      if (pParticle->Pt() > dPtMinPOI && pParticle->Pt() < dPtMaxPOI &&
    pParticle->Eta() > dEtaMinPOI && pParticle->Eta() < dEtaMaxPOI &&
    pParticle->Phi() > dPhiMinPOI && pParticle->Phi() < dPhiMaxPOI &&
    TMath::Abs(pParticle->GetPdgCode()) == iPIDPOI){ 
  bPassedPOIFlowCuts = kTRUE; 
      }
    }
    if (bPassedRPFlowCuts || bPassedPOIFlowCuts) {
      for(Int_t d=0;d<fNoOfLoops;d++) {
  AliFlowTrackSimple* pTrack = new AliFlowTrackSimple();
  pTrack->SetPt(pParticle->Pt());
  pTrack->SetEta(pParticle->Eta());
  pTrack->SetPhi(pParticle->Phi()-fEllipticFlowValue*TMath::Sin(2*(pParticle->Phi()-fMCReactionPlaneAngle)));
  
  //marking the particles used for int. flow:
  if(bPassedRPFlowCuts && iSelParticlesRP < fMultiplicityOfEvent) {  
    pTrack->SetForRPSelection(kTRUE);
    iSelParticlesRP++;
  }
  //marking the particles used for diff. flow:
  if(bPassedPOIFlowCuts && iGoodTracks%fNoOfLoops==0) {
    pTrack->SetForPOISelection(kTRUE);
    iSelParticlesPOI++;
  }
  //adding a particles which were used either for int. or diff. flow to the list
  pEvent->AddTrack(pTrack);
  iGoodTracks++;
      }//end of for(Int_t d=0;d<iLoops;d++)
    }//end of if(bPassedIntFlowCuts || bPassedDiffFlowCuts) 
    itrkN++;  
    bPassedRPFlowCuts  = kFALSE;
    bPassedPOIFlowCuts = kFALSE;
  }//end of while (itrkN < iNumberOfInputTracks)
  
  pEvent->SetEventNSelTracksRP(iSelParticlesRP);  
  pEvent->SetMCReactionPlaneAngle(fMCReactionPlaneAngle);

  if ( (++fCount % 100) == 0) {
    if (fMCReactionPlaneAngle != 0) cout<<" MC Reaction Plane Angle = "<<  fMCReactionPlaneAngle << endl;
    else cout<<" MC Reaction Plane Angle = unknown "<< endl;
    cout<<" iGoodTracks = "<< iGoodTracks << endl;
    cout<<" # of RP selected tracks = "<<iSelParticlesRP<<endl;
    cout<<" # of POI selected tracks = "<<iSelParticlesPOI<<endl;  
    cout << "# " << fCount << " events processed" << endl;
  }

  delete pParticle;
  return pEvent;
}

//-----------------------------------------------------------------------   
AliFlowEventSimple* AliFlowEventSimpleMaker::FillTracks(AliMCEvent* anInput)
{
  //Fills the event from the MC kinematic information
  
  Int_t iNumberOfInputTracks = anInput->GetNumberOfTracks() ;
 
  AliFlowEventSimple* pEvent = new AliFlowEventSimple(10);
    
  //Int_t iN = 256; //multiplicity for chi=1
  Int_t iN = iNumberOfInputTracks;
  Int_t iGoodTracks = 0;
  Int_t itrkN = 0;
  Int_t iSelParticlesPOI = 0;
  Int_t iSelParticlesRP = 0;

  //normal loop
  while (iGoodTracks < iN && itrkN < iNumberOfInputTracks) {
    AliMCParticle* pParticle = (AliMCParticle*) anInput->GetTrack(itrkN);   //get input particle
    //cut on tracks
    if (TMath::Abs(pParticle->Eta()) < 0.9)
      {
  if(
     TMath::Abs(pParticle->Particle()->GetPdgCode()) == 211
     //       TMath::Abs(pParticle->Particle()->GetPdgCode()) == 211 ||
     //       TMath::Abs(pParticle->Particle()->GetPdgCode()) == 321 ||
     //       TMath::Abs(pParticle->Particle()->GetPdgCode()) == 2212
     )
    {
      AliFlowTrackSimple* pTrack = new AliFlowTrackSimple();
      pTrack->SetPt(pParticle->Pt() );
      pTrack->SetEta(pParticle->Eta() );
      pTrack->SetPhi(pParticle->Phi() );
      pTrack->SetForRPSelection(kTRUE);
      pTrack->SetForPOISelection(kTRUE);

      if (pTrack->InRPSelection())
        { iSelParticlesRP++; }
      if (pTrack->InPOISelection())
        { iSelParticlesPOI++; }
      iGoodTracks++;
      pEvent->AddTrack(pTrack) ;         
    }
  /*    else if(
      TMath::Abs(pParticle->Particle()->GetPdgCode()) == 211
      )
      {
        AliFlowTrackSimple* pTrack = new AliFlowTrackSimple();
        pTrack->SetPt(pParticle->Pt() );
        pTrack->SetEta(pParticle->Eta() );
        pTrack->SetPhi(pParticle->Phi() );
        pTrack->SetForRPSelection(kFALSE);
        pTrack->SetForPOISelection(kTRUE);

        if (pTrack->InRPSelection())
    { iSelParticlesRP++; }
        if (pTrack->InPOISelection())
    { iSelParticlesPOI++; }
        iGoodTracks++;
        pEvent->AddTrack(pTrack);        
      }
    */
      }
      
    itrkN++; 
  }
  
  pEvent-> SetEventNSelTracksRP(iSelParticlesRP);  
  pEvent->SetMCReactionPlaneAngle(fMCReactionPlaneAngle);

  if ( (++fCount % 100) == 0) {
    if (fMCReactionPlaneAngle != 0) cout<<" MC Reaction Plane Angle = "<<  fMCReactionPlaneAngle << endl;
    else cout<<" MC Reaction Plane Angle = unknown "<< endl;
    cout<<" iGoodTracks = "<<iGoodTracks<<endl;
    cout<<" # of RP selected tracks = "<<iSelParticlesRP<<endl;
    cout<<" # of POI selected tracks = "<<iSelParticlesPOI<<endl;  
    cout << "# " << fCount << " events processed" << endl;
  }

  return pEvent;

}

//-----------------------------------------------------------------------   
AliFlowEventSimple* AliFlowEventSimpleMaker::FillTracks(AliESDEvent* anInput)
{
  //Fills the event from the ESD
  
  Int_t iNumberOfInputTracks = anInput->GetNumberOfTracks() ;
  
  AliFlowEventSimple* pEvent = new AliFlowEventSimple(10);
    
  //Int_t iN = 256; //multiplicity for chi=1
  Int_t iN = iNumberOfInputTracks;
  Int_t iGoodTracks = 0;
  Int_t itrkN = 0;
  Int_t iSelParticlesPOI = 0;
  Int_t iSelParticlesRP = 0;

 
  
  //normal loop
  while (iGoodTracks < iN && itrkN < iNumberOfInputTracks) {
    AliESDtrack* pParticle = anInput->GetTrack(itrkN);   //get input particle
    //cut on tracks
    if (TMath::Abs(pParticle->Eta()) < 0.9)
    
   
    
    {
  AliFlowTrackSimple* pTrack = new AliFlowTrackSimple();
  pTrack->SetPt(pParticle->Pt() );
  pTrack->SetEta(pParticle->Eta() );
  pTrack->SetPhi(pParticle->Phi() );
  pTrack->SetForRPSelection(kTRUE);
  pTrack->SetForPOISelection(kTRUE);

  if (pTrack->InRPSelection())
    { iSelParticlesRP++; }
  if (pTrack->InPOISelection())
    { iSelParticlesPOI++; }
  iGoodTracks++;
  pEvent->AddTrack(pTrack) ;         
      }
      
    itrkN++; 
  }
  
  pEvent-> SetEventNSelTracksRP(iSelParticlesRP);  
  pEvent->SetMCReactionPlaneAngle(fMCReactionPlaneAngle);

  if ( (++fCount % 100) == 0) {
    if (fMCReactionPlaneAngle != 0) cout<<" MC Reaction Plane Angle = "<<  fMCReactionPlaneAngle << endl;
    else cout<<" MC Reaction Plane Angle = unknown "<< endl;
    cout<<" iGoodTracks = "<<iGoodTracks<<endl;
    cout<<" # of RP selected tracks = "<<iSelParticlesRP<<endl;
    cout<<" # of POI selected tracks = "<<iSelParticlesPOI<<endl;  
    cout << "# " << fCount << " events processed" << endl;
  }

  return pEvent;
}

//-----------------------------------------------------------------------   

AliFlowEventSimple* AliFlowEventSimpleMaker::FillTracks(AliAODEvent* anInput)
{
  //Fills the event from the AOD
  
  Int_t iNumberOfInputTracks = anInput->GetNumberOfTracks() ;
  
  AliFlowEventSimple* pEvent = new AliFlowEventSimple(10);
    
  //Int_t iN = 256; //multiplicity for chi=1
  Int_t iN = iNumberOfInputTracks;
  Int_t iGoodTracks = 0;
  Int_t itrkN = 0;
  Int_t iSelParticlesPOI = 0;
  Int_t iSelParticlesRP = 0;
  
  //normal loop
  while (iGoodTracks < iN && itrkN < iNumberOfInputTracks) {
    AliAODTrack* pParticle = dynamic_cast<AliAODTrack*>(anInput->GetTrack(itrkN));
    assert((pParticle)&&"Not a standard AOD");   //get input particle
    //cut on tracks
    if (TMath::Abs(pParticle->Eta()) < 0.9)
      {
  AliFlowTrackSimple* pTrack = new AliFlowTrackSimple();
  pTrack->SetPt(pParticle->Pt() );
  pTrack->SetEta(pParticle->Eta() );
  pTrack->SetPhi(pParticle->Phi() );
  pTrack->SetForRPSelection(kTRUE);
  pTrack->SetForPOISelection(kTRUE);

  if (pTrack->InRPSelection())
    { iSelParticlesRP++; }
  if (pTrack->InPOISelection())
    { iSelParticlesPOI++; }
  iGoodTracks++;
  pEvent->AddTrack(pTrack) ;         
      }
      
    itrkN++; 
  }
  
  pEvent-> SetEventNSelTracksRP(iSelParticlesRP);  
  pEvent->SetMCReactionPlaneAngle(fMCReactionPlaneAngle);

  if ( (++fCount % 100) == 0) {
    if (fMCReactionPlaneAngle != 0) cout<<" MC Reaction Plane Angle = "<<  fMCReactionPlaneAngle << endl;
    else cout<<" MC Reaction Plane Angle = unknown "<< endl;
    cout<<" iGoodTracks = "<<iGoodTracks<<endl;
    cout<<" # of RP selected tracks = "<<iSelParticlesRP<<endl;
    cout<<" # of POI selected tracks = "<<iSelParticlesPOI<<endl;  
    cout << "# " << fCount << " events processed" << endl;
  }

  return pEvent;
}

//-----------------------------------------------------------------------   
AliFlowEventSimple*  AliFlowEventSimpleMaker::FillTracks(AliESDEvent* anInput, const AliMCEvent* anInputMc, Int_t anOption)
{
  //fills the event with tracks from the ESD and kinematics from the MC info via the track label

  if (!(anOption ==0 || anOption ==1)) {
    cout<<"WRONG OPTION IN AliFlowEventSimpleMaker::FillTracks(AliESDEvent* anInput, AliMCEvent* anInputMc, Int_t anOption)"<<endl;
    exit(1);
  }

  Int_t iNumberOfInputTracks = anInput->GetNumberOfTracks() ;
  
  AliFlowEventSimple* pEvent = new AliFlowEventSimple(10);
    
  //Int_t iN = 256; //multiplicity for chi=1
  Int_t iN = iNumberOfInputTracks;
  Int_t iGoodTracks = 0;
  Int_t itrkN = 0;
  Int_t iSelParticlesPOI = 0;
  Int_t iSelParticlesRP = 0;

  //normal loop
  while (iGoodTracks < iN && itrkN < iNumberOfInputTracks) {
    AliESDtrack* pParticle = anInput->GetTrack(itrkN);   //get input particle
    //get Label
    Int_t iLabel = pParticle->GetLabel();
    //match to mc particle
    AliMCParticle* pMcParticle = (AliMCParticle*) anInputMc->GetTrack(TMath::Abs(iLabel));
    
    //check
    if (TMath::Abs(pParticle->GetLabel())!=pMcParticle->Label()) cout<<"pParticle->GetLabel()!=pMcParticle->Label() "<<pParticle->GetLabel()<<"  "<<pMcParticle->Label()<<endl;
    
    //cut on tracks
    if (TMath::Abs(pParticle->Eta()) < 0.2)
      {
  if(
     TMath::Abs(pMcParticle->Particle()->GetPdgCode()) == 211 //pions
     //       TMath::Abs(pMcParticle->Particle()->GetPdgCode()) == 211 ||
     //       TMath::Abs(pMcParticle->Particle()->GetPdgCode()) == 321 ||
     //       TMath::Abs(pMcParticle->Particle()->GetPdgCode()) == 2212
     )
    {
      AliFlowTrackSimple* pTrack = new AliFlowTrackSimple();
      if(anOption == 0) { //take the PID from the MC & the kinematics from the ESD
        pTrack->SetPt(pParticle->Pt() );
        pTrack->SetEta(pParticle->Eta() );
        pTrack->SetPhi(pParticle->Phi() );
        pTrack->SetForRPSelection(kTRUE);
        pTrack->SetForPOISelection(kTRUE);
      }
      else if (anOption == 1) { //take the PID and kinematics from the MC
        pTrack->SetPt(pMcParticle->Pt() );
        pTrack->SetEta(pMcParticle->Eta() );
        pTrack->SetPhi(pMcParticle->Phi() );
        pTrack->SetForRPSelection(kTRUE);
        pTrack->SetForPOISelection(kTRUE);
      }
      else { cout<<"Not a valid option"<<endl; }
      if (pTrack->InRPSelection())
        { iSelParticlesRP++; }
      if (pTrack->InPOISelection())
        { iSelParticlesPOI++; }
      iGoodTracks++;
      pEvent->AddTrack(pTrack) ;         
    }
      }
    itrkN++; 
  }
  
  pEvent-> SetEventNSelTracksRP(iSelParticlesRP);  
  pEvent->SetMCReactionPlaneAngle(fMCReactionPlaneAngle);

  if ( (++fCount % 100) == 0) {
    if (fMCReactionPlaneAngle != 0) cout<<" MC Reaction Plane Angle = "<<  fMCReactionPlaneAngle << endl;
    else cout<<" MC Reaction Plane Angle = unknown "<< endl;
    cout<<" iGoodTracks = "<<iGoodTracks<<endl;
    cout<<" # of RP selected tracks = "<<iSelParticlesRP<<endl;
    cout<<" # of POI selected tracks = "<<iSelParticlesPOI<<endl;  
    cout << "# " << fCount << " events processed" << endl;
  }

  return pEvent;
}