[u/mrichter/AliRoot.git] / PWG2 / FLOW / AliFlowEventSimpleMaker.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.                  *
 **************************************************************************/
/* $Id */

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

// 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)


ClassImp(AliFlowEventSimpleMaker)
//----------------------------------------------------------------------- 
AliFlowEventSimpleMaker::AliFlowEventSimpleMaker():
  fEvent(0),
  fTrack(0),
  fParticle(0)
{

  //constructor

}


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


//-----------------------------------------------------------------------   
AliFlowEventSimple* AliFlowEventSimpleMaker::FillTracks(TTree* fInput)
{
  //fills the event from a TTree of kinematic.root files
  Bool_t  fDoubleLoop = kFALSE; 

  Int_t fNumberOfInputTracks = fInput->GetEntries() ;
  //cerr<<"fNumberOfInputTracks = "<<fNumberOfInputTracks<<endl;
  fParticle = new TParticle();
  fInput->SetBranchAddress("Particles",&fParticle);  
  //  fEvent = new AliFlowEventSimple(fNumberOfInputTracks);
  fEvent = new AliFlowEventSimple(10);
  //cerr<<fEvent<<" fEvent "<<endl;
  
  Int_t fN = fNumberOfInputTracks;
  //  Int_t fN = 576; //multiplicity for chi=1.5
  //  Int_t fN = 256; //multiplicity for chi=1
  //  Int_t fN = 164; //multiplicity for chi=0.8
  Int_t fGoodTracks = 0;
  Int_t ftrkN = 0;
  Int_t fSelParticlesDiff = 0;
  Int_t fSelParticlesInt = 0;
  
  if (fDoubleLoop)
    {                   //double loop
      while (fGoodTracks < fN*2 && ftrkN < fNumberOfInputTracks) 
	{
	  fInput->GetEntry(ftrkN);   //get input particle
	  //cut on tracks
	  if(TMath::Abs(fParticle->Eta()) < 0.9) 
	    {
	      //	      Int_t fLoop = floor(2.*fParticle->Pt())+2;
	      //	      for(Int_t d=0;d<fLoop;d++) 
	      for(Int_t d=0;d<2;d++) 
		{
		  if(
		     TMath::Abs(fParticle->GetPdgCode()) == 211
		     //	      TMath::Abs(fParticle->GetPdgCode()) == 211 ||
		     //	      TMath::Abs(fParticle->GetPdgCode()) == 321 ||
		     //	      TMath::Abs(fParticle->GetPdgCode()) == 2212
		     )
		    {
		      fTrack = new AliFlowTrackSimple();
		      fTrack->SetPt(fParticle->Pt() );
		      fTrack->SetEta(fParticle->Eta() );
		      fTrack->SetPhi(fParticle->Phi() );
		      fTrack->SetForIntegratedFlow(kTRUE);
		      fTrack->SetForDifferentialFlow(kTRUE);

		      if (fTrack->UseForIntegratedFlow())
			{ fSelParticlesInt++; }
		      if (fTrack->UseForDifferentialFlow())
			{ fSelParticlesDiff++; }
		      fGoodTracks++;
		      fEvent->TrackCollection()->Add(fTrack);
		    }
			/*
		  else if(
			  TMath::Abs(fParticle->GetPdgCode()) == 2212
			  )
		    {
		      fTrack = new AliFlowTrackSimple();
		      fTrack->SetPt(fParticle->Pt() );
		      fTrack->SetEta(fParticle->Eta() );
		      fTrack->SetPhi(fParticle->Phi() );
		      fTrack->SetForIntegratedFlow(kFALSE);
		      fTrack->SetForDifferentialFlow(kTRUE);

		      if (fTrack->UseForIntegratedFlow())
			{ fSelParticlesInt++; }
		      if (fTrack->UseForDifferentialFlow())
			{ fSelParticlesDiff++; }
		      fGoodTracks++;
		      fEvent->TrackCollection()->Add(fTrack);     
		    }
			*/
		}
	    }
	  ftrkN++; 
	}
    }

  else {                                  //normal loop
    while (fGoodTracks < fN && ftrkN < fNumberOfInputTracks) {
      fInput->GetEntry(ftrkN);   //get input particle
      //cut on tracks
      if (TMath::Abs(fParticle->Eta()) < 0.2)
	{
	  if(
	     TMath::Abs(fParticle->GetPdgCode()) == 211
	     //	      TMath::Abs(fParticle->GetPdgCode()) == 211 ||
	     //	      TMath::Abs(fParticle->GetPdgCode()) == 321 ||
	     //	      TMath::Abs(fParticle->GetPdgCode()) == 2212
	     )
	    {
	      fTrack = new AliFlowTrackSimple() ;
	      fTrack->SetPt(fParticle->Pt() );
	      fTrack->SetEta(fParticle->Eta() );
	      fTrack->SetPhi(fParticle->Phi() );
	      fTrack->SetForIntegratedFlow(kTRUE);
	      fTrack->SetForDifferentialFlow(kTRUE);

	      if (fTrack->UseForIntegratedFlow())
		{ fSelParticlesInt++; }
	      if (fTrack->UseForDifferentialFlow())
		{ fSelParticlesDiff++; }
	      fGoodTracks++;
	      fEvent->TrackCollection()->Add(fTrack) ;  	     
	    }
	  /*	  else if(
		  TMath::Abs(fParticle->GetPdgCode()) == 211
		  )
	    {
	      fTrack = new AliFlowTrackSimple();
	      fTrack->SetPt(fParticle->Pt() );
	      fTrack->SetEta(fParticle->Eta() );
	      fTrack->SetPhi(fParticle->Phi() );
	      fTrack->SetForIntegratedFlow(kFALSE);
	      fTrack->SetForDifferentialFlow(kTRUE);

	      if (fTrack->UseForIntegratedFlow())
		{ fSelParticlesInt++; }
	      if (fTrack->UseForDifferentialFlow())
		{ fSelParticlesDiff++; }
	      fGoodTracks++;
	      fEvent->TrackCollection()->Add(fTrack);  	     
	    }
	  */
	}
      
      ftrkN++; 
    }
  }

  fEvent-> SetEventNSelTracksIntFlow(fSelParticlesInt);  
  fEvent->SetNumberOfTracks(fGoodTracks);
  cout<<" fGoodTracks = "<<fGoodTracks<<endl;
  cout << "  fSelectedTracksInt = " << fSelParticlesInt << endl;  
  return fEvent;
  
}

//-----------------------------------------------------------------------   
AliFlowEventSimple* AliFlowEventSimpleMaker::FillTracks(AliMCEvent* fInput)
{
  //Fills the event from the MC kinematic information
  
  Int_t fNumberOfInputTracks = fInput->GetNumberOfTracks() ;
  cerr<<"fInput->GetNumberOfTracks() = "<<fNumberOfInputTracks<<endl;
 
  fEvent = new AliFlowEventSimple(10);
    
  //Int_t fN = 256; //multiplicity for chi=1
  Int_t fN = fNumberOfInputTracks;
  Int_t fGoodTracks = 0;
  Int_t ftrkN = 0;
  Int_t fSelParticlesDiff = 0;
  Int_t fSelParticlesInt = 0;

   
  //normal loop
  while (fGoodTracks < fN && ftrkN < fNumberOfInputTracks) {
    AliMCParticle* myParticle = fInput->GetTrack(ftrkN);   //get input particle
    //cut on tracks
    if (TMath::Abs(myParticle->Eta()) < 0.2)
      {
	if(
	   TMath::Abs(myParticle->Particle()->GetPdgCode()) == 211
	   //	      TMath::Abs(myParticle->Particle()->GetPdgCode()) == 211 ||
	   //	      TMath::Abs(myParticle->Particle()->GetPdgCode()) == 321 ||
	   //	      TMath::Abs(myParticle->Particle()->GetPdgCode()) == 2212
	   )
	  {
	    fTrack = new AliFlowTrackSimple() ;
	    fTrack->SetPt(myParticle->Pt() );
	    fTrack->SetEta(myParticle->Eta() );
	    fTrack->SetPhi(myParticle->Phi() );
	    fTrack->SetForIntegratedFlow(kTRUE);
	    fTrack->SetForDifferentialFlow(kTRUE);

	    if (fTrack->UseForIntegratedFlow())
	      { fSelParticlesInt++; }
	    if (fTrack->UseForDifferentialFlow())
	      { fSelParticlesDiff++; }
	    fGoodTracks++;
	    fEvent->TrackCollection()->Add(fTrack) ;  	     
	  }
	  /*	  else if(
		  TMath::Abs(myParticle->Particle()->GetPdgCode()) == 211
		  )
	    {
	      fTrack = new AliFlowTrackSimple();
	      fTrack->SetPt(myParticle->Pt() );
	      fTrack->SetEta(myParticle->Eta() );
	      fTrack->SetPhi(myParticle->Phi() );
	      fTrack->SetForIntegratedFlow(kFALSE);
	      fTrack->SetForDifferentialFlow(kTRUE);

	      if (fTrack->UseForIntegratedFlow())
		{ fSelParticlesInt++; }
	      if (fTrack->UseForDifferentialFlow())
		{ fSelParticlesDiff++; }
	      fGoodTracks++;
	      fEvent->TrackCollection()->Add(fTrack);  	     
	    }
	  */
      }
      
    ftrkN++; 
  }
  
  fEvent-> SetEventNSelTracksIntFlow(fSelParticlesInt);  
  fEvent->SetNumberOfTracks(fGoodTracks);
  cout<<" fGoodTracks = "<<fGoodTracks<<endl;
  cout << "  fSelectedTracksInt = " << fSelParticlesInt << endl;  
  return fEvent;
  

}


//-----------------------------------------------------------------------   
AliFlowEventSimple* AliFlowEventSimpleMaker::FillTracks(AliESDEvent* fInput)
{
  //Fills the event from the ESD
  
  Int_t fNumberOfInputTracks = fInput->GetNumberOfTracks() ;
  cerr<<"fInput->GetNumberOfTracks() = "<<fNumberOfInputTracks<<endl;
  
  fEvent = new AliFlowEventSimple(10);
    
  //Int_t fN = 256; //multiplicity for chi=1
  Int_t fN = fNumberOfInputTracks;
  Int_t fGoodTracks = 0;
  Int_t ftrkN = 0;
  Int_t fSelParticlesDiff = 0;
  Int_t fSelParticlesInt = 0;


  //normal loop
  while (fGoodTracks < fN && ftrkN < fNumberOfInputTracks) {
    AliESDtrack* myParticle = fInput->GetTrack(ftrkN);   //get input particle
    //cut on tracks
    if (TMath::Abs(myParticle->Eta()) < 0.2)
      {
	fTrack = new AliFlowTrackSimple() ;
	fTrack->SetPt(myParticle->Pt() );
	fTrack->SetEta(myParticle->Eta() );
	fTrack->SetPhi(myParticle->Phi() );
	fTrack->SetForIntegratedFlow(kTRUE);
	fTrack->SetForDifferentialFlow(kTRUE);

	if (fTrack->UseForIntegratedFlow())
	  { fSelParticlesInt++; }
	if (fTrack->UseForDifferentialFlow())
	  { fSelParticlesDiff++; }
	fGoodTracks++;
	fEvent->TrackCollection()->Add(fTrack) ;  	     
      }
      
    ftrkN++; 
  }
  
  fEvent-> SetEventNSelTracksIntFlow(fSelParticlesInt);  
  fEvent->SetNumberOfTracks(fGoodTracks);
  cout<<" fGoodTracks = "<<fGoodTracks<<endl;
  cout << "  fSelectedTracksInt = " << fSelParticlesInt << endl;  
  return fEvent;


}


//-----------------------------------------------------------------------   
AliFlowEventSimple* AliFlowEventSimpleMaker::FillTracks(AliAODEvent* fInput)
{
  //Fills the event from the AOD
  
  Int_t fNumberOfInputTracks = fInput->GetNumberOfTracks() ;
  cerr<<"fInput->GetNumberOfTracks() = "<<fNumberOfInputTracks<<endl;
  
  fEvent = new AliFlowEventSimple(10);
    
  //Int_t fN = 256; //multiplicity for chi=1
  Int_t fN = fNumberOfInputTracks;
  Int_t fGoodTracks = 0;
  Int_t ftrkN = 0;
  Int_t fSelParticlesDiff = 0;
  Int_t fSelParticlesInt = 0;

  
  //normal loop
  while (fGoodTracks < fN && ftrkN < fNumberOfInputTracks) {
    AliAODTrack* myParticle = fInput->GetTrack(ftrkN);   //get input particle
    //cut on tracks
    if (TMath::Abs(myParticle->Eta()) < 0.2)
      {
	fTrack = new AliFlowTrackSimple() ;
	fTrack->SetPt(myParticle->Pt() );
	fTrack->SetEta(myParticle->Eta() );
	fTrack->SetPhi(myParticle->Phi() );
	fTrack->SetForIntegratedFlow(kTRUE);
	fTrack->SetForDifferentialFlow(kTRUE);

	if (fTrack->UseForIntegratedFlow())
	  { fSelParticlesInt++; }
	if (fTrack->UseForDifferentialFlow())
	  { fSelParticlesDiff++; }
	fGoodTracks++;
	fEvent->TrackCollection()->Add(fTrack) ;  	     
      }
      
    ftrkN++; 
  }
  
  fEvent-> SetEventNSelTracksIntFlow(fSelParticlesInt);  
  fEvent->SetNumberOfTracks(fGoodTracks);
  cout<<" fGoodTracks = "<<fGoodTracks<<endl;
  cout << "  fSelectedTracksInt = " << fSelParticlesInt << endl;  
  return fEvent;
  
}
//-----------------------------------------------------------------------   
AliFlowEventSimple*  AliFlowEventSimpleMaker::FillTracks(AliESDEvent* fInput, AliMCEvent* fInputMc, Int_t fOption)
{
  //fills the event with tracks from the ESD and kinematics from the MC info via the track label

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

  Int_t fNumberOfInputTracks = fInput->GetNumberOfTracks() ;
  cerr<<"fInput->GetNumberOfTracks() = "<<fNumberOfInputTracks<<endl;
  
  fEvent = new AliFlowEventSimple(10);
    
  //Int_t fN = 256; //multiplicity for chi=1
  Int_t fN = fNumberOfInputTracks;
  Int_t fGoodTracks = 0;
  Int_t ftrkN = 0;
  Int_t fSelParticlesDiff = 0;
  Int_t fSelParticlesInt = 0;

  //normal loop
  while (fGoodTracks < fN && ftrkN < fNumberOfInputTracks) {
    AliESDtrack* myParticle = fInput->GetTrack(ftrkN);   //get input particle
    //get Label
    Int_t fLabel = myParticle->GetLabel();
    //match to mc particle
    AliMCParticle* fMcParticle = fInputMc->GetTrack(TMath::Abs(fLabel));
    
    //check
    if (TMath::Abs(myParticle->GetLabel())!=fMcParticle->Label()) cout<<"myParticle->GetLabel()!=fMcParticle->Label() "<<myParticle->GetLabel()<<"  "<<fMcParticle->Label()<<endl;
    
    //cut on tracks
    if (TMath::Abs(myParticle->Eta()) < 0.2)
      {
	if(
	   TMath::Abs(fMcParticle->Particle()->GetPdgCode()) == 211 //pions
	   //	      TMath::Abs(fMcParticle->Particle()->GetPdgCode()) == 211 ||
	   //	      TMath::Abs(fMcParticle->Particle()->GetPdgCode()) == 321 ||
	   //	      TMath::Abs(fMcParticle->Particle()->GetPdgCode()) == 2212
	   )
	  {
	    if(fOption == 0) { //take the PID from the MC & the kinematics from the ESD
	      fTrack = new AliFlowTrackSimple() ;
	      fTrack->SetPt(myParticle->Pt() );
	      fTrack->SetEta(myParticle->Eta() );
	      fTrack->SetPhi(myParticle->Phi() );
	      fTrack->SetForIntegratedFlow(kTRUE);
	      fTrack->SetForDifferentialFlow(kTRUE);
	    }
	    else if (fOption == 1) { //take the PID and kinematics from the MC
	      fTrack = new AliFlowTrackSimple() ;
	      fTrack->SetPt(fMcParticle->Pt() );
	      fTrack->SetEta(fMcParticle->Eta() );
	      fTrack->SetPhi(fMcParticle->Phi() );
	      fTrack->SetForIntegratedFlow(kTRUE);
	      fTrack->SetForDifferentialFlow(kTRUE);
	    }
	    else { cout<<"Not a valid option"<<endl; }
	    if (fTrack->UseForIntegratedFlow())
	      { fSelParticlesInt++; }
	    if (fTrack->UseForDifferentialFlow())
	      { fSelParticlesDiff++; }
	    fGoodTracks++;
	    fEvent->TrackCollection()->Add(fTrack) ;  	     
	  }
      }
    ftrkN++; 
  }
  
  fEvent-> SetEventNSelTracksIntFlow(fSelParticlesInt);  
  fEvent->SetNumberOfTracks(fGoodTracks);
  cout<<" fGoodTracks = "<<fGoodTracks<<endl;
  cout << "  fSelectedTracksInt = " << fSelParticlesInt << endl;  
  return fEvent;


}


/*
$Log$
*/
Commit	Line	Data
f1d945a1	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	/* $Id */
	16
	17	#include "Riostream.h"
	18	#include "AliFlowEventSimpleMaker.h"
	19	#include "AliFlowEventSimple.h"
	20	#include "AliFlowTrackSimple.h"
	21	#include "TTree.h"
	22	#include "TParticle.h"
	23	#include "AliMCEvent.h"
	24	#include "AliMCParticle.h"
	25	#include "AliESDEvent.h"
	26	#include "AliESDtrack.h"
	27	#include "AliAODEvent.h"
	28	#include "AliAODTrack.h"
	29
	30	// AliFlowEventSimpleMaker:
	31	// Class to fill the AliFlowEventSimple
	32	// with AliFlowTrackSimple objects
	33	// Has fill methods for TTree, AliMCEvent, AliESDEvent and AliAODEvent
	34	// author: N. van der Kolk (kolk@nikhef.nl)
	35
	36
	37
	38	ClassImp(AliFlowEventSimpleMaker)
	39	//-----------------------------------------------------------------------
	40	AliFlowEventSimpleMaker::AliFlowEventSimpleMaker():
	41	fEvent(0),
	42	fTrack(0),
	43	fParticle(0)
	44	{
	45
	46	//constructor
	47
	48	}
	49
	50
	51	//-----------------------------------------------------------------------
	52	AliFlowEventSimpleMaker::~AliFlowEventSimpleMaker()
	53	{
	54	//desstructor
	55	}
	56
	57
	58	//-----------------------------------------------------------------------
	59	AliFlowEventSimple* AliFlowEventSimpleMaker::FillTracks(TTree* fInput)
	60	{
	61	//fills the event from a TTree of kinematic.root files
	62	Bool_t fDoubleLoop = kFALSE;
	63
	64	Int_t fNumberOfInputTracks = fInput->GetEntries() ;
65	//cerr<<"fNumberOfInputTracks = "<<fNumberOfInputTracks<<endl;
66	fParticle = new TParticle();
67	fInput->SetBranchAddress("Particles",&fParticle);
68	// fEvent = new AliFlowEventSimple(fNumberOfInputTracks);
69	fEvent = new AliFlowEventSimple(10);
70	//cerr<<fEvent<<" fEvent "<<endl;
71
72	Int_t fN = fNumberOfInputTracks;
73	// Int_t fN = 576; //multiplicity for chi=1.5
74	// Int_t fN = 256; //multiplicity for chi=1
75	// Int_t fN = 164; //multiplicity for chi=0.8
76	Int_t fGoodTracks = 0;
77	Int_t ftrkN = 0;
78	Int_t fSelParticlesDiff = 0;
79	Int_t fSelParticlesInt = 0;
80
81	if (fDoubleLoop)
82	{ //double loop
83	while (fGoodTracks < fN*2 && ftrkN < fNumberOfInputTracks)
84	{
85	fInput->GetEntry(ftrkN); //get input particle
86	//cut on tracks
87	if(TMath::Abs(fParticle->Eta()) < 0.9)
88	{
89	// Int_t fLoop = floor(2.*fParticle->Pt())+2;
90	// for(Int_t d=0;d<fLoop;d++)
91	for(Int_t d=0;d<2;d++)
92	{
93	if(
94	TMath::Abs(fParticle->GetPdgCode()) == 211
95	// TMath::Abs(fParticle->GetPdgCode()) == 211 \|\|
96	// TMath::Abs(fParticle->GetPdgCode()) == 321 \|\|
97	// TMath::Abs(fParticle->GetPdgCode()) == 2212
98	)
99	{
100	fTrack = new AliFlowTrackSimple();
101	fTrack->SetPt(fParticle->Pt() );
102	fTrack->SetEta(fParticle->Eta() );
103	fTrack->SetPhi(fParticle->Phi() );
104	fTrack->SetForIntegratedFlow(kTRUE);
105	fTrack->SetForDifferentialFlow(kTRUE);
106
107	if (fTrack->UseForIntegratedFlow())
108	{ fSelParticlesInt++; }
109	if (fTrack->UseForDifferentialFlow())
110	{ fSelParticlesDiff++; }
111	fGoodTracks++;
112	fEvent->TrackCollection()->Add(fTrack);
113	}
114	/*
115	else if(
116	TMath::Abs(fParticle->GetPdgCode()) == 2212
117	)
118	{
119	fTrack = new AliFlowTrackSimple();
120	fTrack->SetPt(fParticle->Pt() );
121	fTrack->SetEta(fParticle->Eta() );
122	fTrack->SetPhi(fParticle->Phi() );
123	fTrack->SetForIntegratedFlow(kFALSE);
124	fTrack->SetForDifferentialFlow(kTRUE);
125
126	if (fTrack->UseForIntegratedFlow())
127	{ fSelParticlesInt++; }
128	if (fTrack->UseForDifferentialFlow())
129	{ fSelParticlesDiff++; }
130	fGoodTracks++;
131	fEvent->TrackCollection()->Add(fTrack);
132	}
133	*/
134	}
135	}
136	ftrkN++;
137	}
138	}
139
140	else { //normal loop
141	while (fGoodTracks < fN && ftrkN < fNumberOfInputTracks) {
142	fInput->GetEntry(ftrkN); //get input particle
143	//cut on tracks
144	if (TMath::Abs(fParticle->Eta()) < 0.2)
145	{
146	if(
147	TMath::Abs(fParticle->GetPdgCode()) == 211
148	// TMath::Abs(fParticle->GetPdgCode()) == 211 \|\|
149	// TMath::Abs(fParticle->GetPdgCode()) == 321 \|\|
150	// TMath::Abs(fParticle->GetPdgCode()) == 2212
151	)
152	{
153	fTrack = new AliFlowTrackSimple() ;
154	fTrack->SetPt(fParticle->Pt() );
155	fTrack->SetEta(fParticle->Eta() );
156	fTrack->SetPhi(fParticle->Phi() );
157	fTrack->SetForIntegratedFlow(kTRUE);
158	fTrack->SetForDifferentialFlow(kTRUE);
159
160	if (fTrack->UseForIntegratedFlow())
161	{ fSelParticlesInt++; }
162	if (fTrack->UseForDifferentialFlow())
163	{ fSelParticlesDiff++; }
164	fGoodTracks++;
165	fEvent->TrackCollection()->Add(fTrack) ;
166	}
167	/* else if(
168	TMath::Abs(fParticle->GetPdgCode()) == 211
169	)
170	{
171	fTrack = new AliFlowTrackSimple();
172	fTrack->SetPt(fParticle->Pt() );
173	fTrack->SetEta(fParticle->Eta() );
174	fTrack->SetPhi(fParticle->Phi() );
175	fTrack->SetForIntegratedFlow(kFALSE);
176	fTrack->SetForDifferentialFlow(kTRUE);
177
178	if (fTrack->UseForIntegratedFlow())
179	{ fSelParticlesInt++; }
180	if (fTrack->UseForDifferentialFlow())
181	{ fSelParticlesDiff++; }
182	fGoodTracks++;
183	fEvent->TrackCollection()->Add(fTrack);
184	}
185	*/
186	}
187
188	ftrkN++;
189	}
190	}
191
192	fEvent-> SetEventNSelTracksIntFlow(fSelParticlesInt);
193	fEvent->SetNumberOfTracks(fGoodTracks);
194	cout<<" fGoodTracks = "<<fGoodTracks<<endl;
195	cout << " fSelectedTracksInt = " << fSelParticlesInt << endl;
196	return fEvent;
197
198	}
199
200	//-----------------------------------------------------------------------
201	AliFlowEventSimple* AliFlowEventSimpleMaker::FillTracks(AliMCEvent* fInput)
202	{
203	//Fills the event from the MC kinematic information
0b7f49e9	204
f1d945a1	205	Int_t fNumberOfInputTracks = fInput->GetNumberOfTracks() ;
	206	cerr<<"fInput->GetNumberOfTracks() = "<<fNumberOfInputTracks<<endl;
	207
	208	fEvent = new AliFlowEventSimple(10);
	209
	210	//Int_t fN = 256; //multiplicity for chi=1
	211	Int_t fN = fNumberOfInputTracks;
	212	Int_t fGoodTracks = 0;
	213	Int_t ftrkN = 0;
	214	Int_t fSelParticlesDiff = 0;
	215	Int_t fSelParticlesInt = 0;
	216
0b7f49e9	217
	218	//normal loop
	219	while (fGoodTracks < fN && ftrkN < fNumberOfInputTracks) {
8232a5ec	220	AliMCParticle* myParticle = fInput->GetTrack(ftrkN); //get input particle
0b7f49e9	221	//cut on tracks
8232a5ec	222	if (TMath::Abs(myParticle->Eta()) < 0.2)
0b7f49e9	223	{
0b7f49e9	224	if(
8232a5ec	225	TMath::Abs(myParticle->Particle()->GetPdgCode()) == 211
	226	// TMath::Abs(myParticle->Particle()->GetPdgCode()) == 211 \|\|
	227	// TMath::Abs(myParticle->Particle()->GetPdgCode()) == 321 \|\|
	228	// TMath::Abs(myParticle->Particle()->GetPdgCode()) == 2212
0b7f49e9	229	)
	230	{
	231	fTrack = new AliFlowTrackSimple() ;
8232a5ec	232	fTrack->SetPt(myParticle->Pt() );
	233	fTrack->SetEta(myParticle->Eta() );
	234	fTrack->SetPhi(myParticle->Phi() );
0b7f49e9	235	fTrack->SetForIntegratedFlow(kTRUE);
	236	fTrack->SetForDifferentialFlow(kTRUE);
	237
	238	if (fTrack->UseForIntegratedFlow())
	239	{ fSelParticlesInt++; }
	240	if (fTrack->UseForDifferentialFlow())
	241	{ fSelParticlesDiff++; }
	242	fGoodTracks++;
	243	fEvent->TrackCollection()->Add(fTrack) ;
	244	}
f1d945a1	245	/* else if(
8232a5ec	246	TMath::Abs(myParticle->Particle()->GetPdgCode()) == 211
f1d945a1	247	)
	248	{
	249	fTrack = new AliFlowTrackSimple();
8232a5ec	250	fTrack->SetPt(myParticle->Pt() );
	251	fTrack->SetEta(myParticle->Eta() );
	252	fTrack->SetPhi(myParticle->Phi() );
f1d945a1	253	fTrack->SetForIntegratedFlow(kFALSE);
	254	fTrack->SetForDifferentialFlow(kTRUE);
	255
	256	if (fTrack->UseForIntegratedFlow())
	257	{ fSelParticlesInt++; }
	258	if (fTrack->UseForDifferentialFlow())
	259	{ fSelParticlesDiff++; }
	260	fGoodTracks++;
	261	fEvent->TrackCollection()->Add(fTrack);
	262	}
	263	*/
0b7f49e9	264	}
f1d945a1	265
0b7f49e9	266	ftrkN++;
f1d945a1	267	}
0b7f49e9	268
f1d945a1	269	fEvent-> SetEventNSelTracksIntFlow(fSelParticlesInt);
	270	fEvent->SetNumberOfTracks(fGoodTracks);
	271	cout<<" fGoodTracks = "<<fGoodTracks<<endl;
	272	cout << " fSelectedTracksInt = " << fSelParticlesInt << endl;
	273	return fEvent;
	274
	275
	276	}
	277
	278
	279	//-----------------------------------------------------------------------
	280	AliFlowEventSimple* AliFlowEventSimpleMaker::FillTracks(AliESDEvent* fInput)
	281	{
	282	//Fills the event from the ESD
0b7f49e9	283
f1d945a1	284	Int_t fNumberOfInputTracks = fInput->GetNumberOfTracks() ;
	285	cerr<<"fInput->GetNumberOfTracks() = "<<fNumberOfInputTracks<<endl;
	286
	287	fEvent = new AliFlowEventSimple(10);
	288
	289	//Int_t fN = 256; //multiplicity for chi=1
	290	Int_t fN = fNumberOfInputTracks;
	291	Int_t fGoodTracks = 0;
	292	Int_t ftrkN = 0;
	293	Int_t fSelParticlesDiff = 0;
	294	Int_t fSelParticlesInt = 0;
	295
	296
0b7f49e9	297	//normal loop
0b7f49e9	298	while (fGoodTracks < fN && ftrkN < fNumberOfInputTracks) {
8232a5ec	299	AliESDtrack* myParticle = fInput->GetTrack(ftrkN); //get input particle
0b7f49e9	300	//cut on tracks
8232a5ec	301	if (TMath::Abs(myParticle->Eta()) < 0.2)
0b7f49e9	302	{
0b7f49e9	303	fTrack = new AliFlowTrackSimple() ;
8232a5ec	304	fTrack->SetPt(myParticle->Pt() );
	305	fTrack->SetEta(myParticle->Eta() );
	306	fTrack->SetPhi(myParticle->Phi() );
0b7f49e9	307	fTrack->SetForIntegratedFlow(kTRUE);
	308	fTrack->SetForDifferentialFlow(kTRUE);
	309
	310	if (fTrack->UseForIntegratedFlow())
	311	{ fSelParticlesInt++; }
	312	if (fTrack->UseForDifferentialFlow())
	313	{ fSelParticlesDiff++; }
	314	fGoodTracks++;
	315	fEvent->TrackCollection()->Add(fTrack) ;
	316	}
f1d945a1	317
0b7f49e9	318	ftrkN++;
f1d945a1	319	}
0b7f49e9	320
f1d945a1	321	fEvent-> SetEventNSelTracksIntFlow(fSelParticlesInt);
	322	fEvent->SetNumberOfTracks(fGoodTracks);
	323	cout<<" fGoodTracks = "<<fGoodTracks<<endl;
	324	cout << " fSelectedTracksInt = " << fSelParticlesInt << endl;
	325	return fEvent;
0b7f49e9	326
f1d945a1	327
	328	}
	329
	330
	331
	332	//-----------------------------------------------------------------------
	333	AliFlowEventSimple* AliFlowEventSimpleMaker::FillTracks(AliAODEvent* fInput)
	334	{
	335	//Fills the event from the AOD
0b7f49e9	336
f1d945a1	337	Int_t fNumberOfInputTracks = fInput->GetNumberOfTracks() ;
	338	cerr<<"fInput->GetNumberOfTracks() = "<<fNumberOfInputTracks<<endl;
	339
	340	fEvent = new AliFlowEventSimple(10);
	341
	342	//Int_t fN = 256; //multiplicity for chi=1
	343	Int_t fN = fNumberOfInputTracks;
	344	Int_t fGoodTracks = 0;
	345	Int_t ftrkN = 0;
	346	Int_t fSelParticlesDiff = 0;
	347	Int_t fSelParticlesInt = 0;
	348
	349
0b7f49e9	350	//normal loop
0b7f49e9	351	while (fGoodTracks < fN && ftrkN < fNumberOfInputTracks) {
8232a5ec	352	AliAODTrack* myParticle = fInput->GetTrack(ftrkN); //get input particle
0b7f49e9	353	//cut on tracks
8232a5ec	354	if (TMath::Abs(myParticle->Eta()) < 0.2)
0b7f49e9	355	{
0b7f49e9	356	fTrack = new AliFlowTrackSimple() ;
8232a5ec	357	fTrack->SetPt(myParticle->Pt() );
	358	fTrack->SetEta(myParticle->Eta() );
	359	fTrack->SetPhi(myParticle->Phi() );
0b7f49e9	360	fTrack->SetForIntegratedFlow(kTRUE);
	361	fTrack->SetForDifferentialFlow(kTRUE);
	362
	363	if (fTrack->UseForIntegratedFlow())
	364	{ fSelParticlesInt++; }
	365	if (fTrack->UseForDifferentialFlow())
	366	{ fSelParticlesDiff++; }
	367	fGoodTracks++;
	368	fEvent->TrackCollection()->Add(fTrack) ;
	369	}
f1d945a1	370
0b7f49e9	371	ftrkN++;
	372	}
	373
	374	fEvent-> SetEventNSelTracksIntFlow(fSelParticlesInt);
	375	fEvent->SetNumberOfTracks(fGoodTracks);
	376	cout<<" fGoodTracks = "<<fGoodTracks<<endl;
	377	cout << " fSelectedTracksInt = " << fSelParticlesInt << endl;
	378	return fEvent;
	379
	380	}
	381	//-----------------------------------------------------------------------
	382	AliFlowEventSimple* AliFlowEventSimpleMaker::FillTracks(AliESDEvent* fInput, AliMCEvent* fInputMc, Int_t fOption)
	383	{
	384	//fills the event with tracks from the ESD and kinematics from the MC info via the track label
	385
	386	if (!(fOption ==0 \|\| fOption ==1)) {
	387	cout<<"WRONG OPTION IN AliFlowEventSimpleMaker::FillTracks(AliESDEvent* fInput, AliMCEvent* fInputMc, Int_t fOption)"<<endl;
	388	exit(1);
f1d945a1	389	}
f1d945a1	390
0b7f49e9	391	Int_t fNumberOfInputTracks = fInput->GetNumberOfTracks() ;
	392	cerr<<"fInput->GetNumberOfTracks() = "<<fNumberOfInputTracks<<endl;
	393
	394	fEvent = new AliFlowEventSimple(10);
	395
	396	//Int_t fN = 256; //multiplicity for chi=1
	397	Int_t fN = fNumberOfInputTracks;
	398	Int_t fGoodTracks = 0;
	399	Int_t ftrkN = 0;
	400	Int_t fSelParticlesDiff = 0;
	401	Int_t fSelParticlesInt = 0;
f1d945a1	402
0b7f49e9	403	//normal loop
0b7f49e9	404	while (fGoodTracks < fN && ftrkN < fNumberOfInputTracks) {
8232a5ec	405	AliESDtrack* myParticle = fInput->GetTrack(ftrkN); //get input particle
0b7f49e9	406	//get Label
8232a5ec	407	Int_t fLabel = myParticle->GetLabel();
0b7f49e9	408	//match to mc particle
	409	AliMCParticle* fMcParticle = fInputMc->GetTrack(TMath::Abs(fLabel));
	410
	411	//check
8232a5ec	412	if (TMath::Abs(myParticle->GetLabel())!=fMcParticle->Label()) cout<<"myParticle->GetLabel()!=fMcParticle->Label() "<<myParticle->GetLabel()<<" "<<fMcParticle->Label()<<endl;
0b7f49e9	413
0b7f49e9	414	//cut on tracks
8232a5ec	415	if (TMath::Abs(myParticle->Eta()) < 0.2)
0b7f49e9	416	{
	417	if(
	418	TMath::Abs(fMcParticle->Particle()->GetPdgCode()) == 211 //pions
	419	// TMath::Abs(fMcParticle->Particle()->GetPdgCode()) == 211 \|\|
	420	// TMath::Abs(fMcParticle->Particle()->GetPdgCode()) == 321 \|\|
	421	// TMath::Abs(fMcParticle->Particle()->GetPdgCode()) == 2212
	422	)
	423	{
	424	if(fOption == 0) { //take the PID from the MC & the kinematics from the ESD
	425	fTrack = new AliFlowTrackSimple() ;
8232a5ec	426	fTrack->SetPt(myParticle->Pt() );
	427	fTrack->SetEta(myParticle->Eta() );
	428	fTrack->SetPhi(myParticle->Phi() );
0b7f49e9	429	fTrack->SetForIntegratedFlow(kTRUE);
	430	fTrack->SetForDifferentialFlow(kTRUE);
	431	}
	432	else if (fOption == 1) { //take the PID and kinematics from the MC
	433	fTrack = new AliFlowTrackSimple() ;
	434	fTrack->SetPt(fMcParticle->Pt() );
	435	fTrack->SetEta(fMcParticle->Eta() );
	436	fTrack->SetPhi(fMcParticle->Phi() );
	437	fTrack->SetForIntegratedFlow(kTRUE);
	438	fTrack->SetForDifferentialFlow(kTRUE);
	439	}
	440	else { cout<<"Not a valid option"<<endl; }
	441	if (fTrack->UseForIntegratedFlow())
	442	{ fSelParticlesInt++; }
	443	if (fTrack->UseForDifferentialFlow())
	444	{ fSelParticlesDiff++; }
	445	fGoodTracks++;
	446	fEvent->TrackCollection()->Add(fTrack) ;
	447	}
	448	}
	449	ftrkN++;
	450	}
	451
f1d945a1	452	fEvent-> SetEventNSelTracksIntFlow(fSelParticlesInt);
	453	fEvent->SetNumberOfTracks(fGoodTracks);
	454	cout<<" fGoodTracks = "<<fGoodTracks<<endl;
	455	cout << " fSelectedTracksInt = " << fSelParticlesInt << endl;
	456	return fEvent;
	457
0b7f49e9	458
f1d945a1	459	}
f1d945a1	460
0b7f49e9	461
0b7f49e9	462
f1d945a1	463	/*
	464	$Log$
	465	*/
	466