#include <TBenchmark.h>
#include <TList.h>
+//_________________________________________________________
+///////////////////////////////////////////////////////////
+//
+//Central Object Of HBTAnalyser:
+//This class performs main looping within HBT Analysis
+//User must plug a reader of Type AliHBTReader
+//User plugs in coorelation and monitor functions
+//as well as monitor functions
+//
+//HBT Analysis Tool, which is integral part of AliRoot,
+//ALICE Off-Line framework:
+//
+//Piotr.Skowronski@cern.ch
+//more info: http://alisoft.cern.ch/people/skowron/analyzer/index.html
+//
+//_________________________________________________________
+
ClassImp(AliHBTAnalysis)
const UInt_t AliHBTAnalysis::fgkFctnArraySize = 100;
const Int_t AliHBTAnalysis::fgkDefaultBufferSize = 5;
AliHBTAnalysis::AliHBTAnalysis():
- fReader(0x0),
- fNTrackFunctions(0),
- fNParticleFunctions(0),
- fNParticleAndTrackFunctions(0),
- fNTrackMonitorFunctions(0),
- fNParticleMonitorFunctions(0),
- fNParticleAndTrackMonitorFunctions(0),
- fBufferSize(2),
- fDisplayMixingInfo(fgkDefaultMixingInfo),
- fIsOwner(kFALSE)
+ fReader(0x0),
+ fNTrackFunctions(0),
+ fNParticleFunctions(0),
+ fNParticleAndTrackFunctions(0),
+ fNTrackMonitorFunctions(0),
+ fNParticleMonitorFunctions(0),
+ fNParticleAndTrackMonitorFunctions(0),
+ fBufferSize(2),
+ fDisplayMixingInfo(fgkDefaultMixingInfo),
+ fIsOwner(kFALSE)
{
+//default constructor
fTrackFunctions = new AliHBTOnePairFctn* [fgkFctnArraySize];
fParticleFunctions = new AliHBTOnePairFctn* [fgkFctnArraySize];
fParticleAndTrackFunctions = new AliHBTTwoPairFctn* [fgkFctnArraySize];
/*************************************************************************************/
AliHBTAnalysis::AliHBTAnalysis(const AliHBTAnalysis& in):
- fReader(0x0),
- fNTrackFunctions(0),
- fNParticleFunctions(0),
- fNParticleAndTrackFunctions(0),
- fNTrackMonitorFunctions(0),
- fNParticleMonitorFunctions(0),
- fNParticleAndTrackMonitorFunctions(0),
- fTrackFunctions(0x0),
- fParticleFunctions(0x0),
- fParticleAndTrackFunctions(0x0),
- fParticleMonitorFunctions(0x0),
- fTrackMonitorFunctions(0x0),
- fParticleAndTrackMonitorFunctions(0x0),
- fPairCut(0x0),
- fBufferSize(fgkDefaultBufferSize),
- fDisplayMixingInfo(fgkDefaultMixingInfo),
- fIsOwner(kFALSE)
+ fReader(0x0),
+ fNTrackFunctions(0),
+ fNParticleFunctions(0),
+ fNParticleAndTrackFunctions(0),
+ fNTrackMonitorFunctions(0),
+ fNParticleMonitorFunctions(0),
+ fNParticleAndTrackMonitorFunctions(0),
+ fTrackFunctions(0x0),
+ fParticleFunctions(0x0),
+ fParticleAndTrackFunctions(0x0),
+ fParticleMonitorFunctions(0x0),
+ fTrackMonitorFunctions(0x0),
+ fParticleAndTrackMonitorFunctions(0x0),
+ fPairCut(0x0),
+ fBufferSize(fgkDefaultBufferSize),
+ fDisplayMixingInfo(fgkDefaultMixingInfo),
+ fIsOwner(kFALSE)
{
+//copy constructor
Fatal("AliHBTAnalysis(const AliHBTAnalysis&)","Sensless");
}
/*************************************************************************************/
const AliHBTAnalysis& AliHBTAnalysis::operator=(const AliHBTAnalysis& right)
{
+//operator =
Fatal("AliHBTAnalysis(const AliHBTAnalysis&)","Sensless");
return *this;
}
//note that we do not delete functions itself
// they should be deleted by whom where created
//we only store pointers, and we use "new" only for pointers array
- if (fIsOwner) DeleteFunctions();
+ if (fIsOwner)
+ DeleteFunctions();
delete [] fTrackFunctions;
delete [] fParticleFunctions;
delete [] fParticleAndTrackFunctions;
}
/*************************************************************************************/
+
void AliHBTAnalysis::DeleteFunctions()
{
+ //Deletes all functions added to analysis
UInt_t ii;
for(ii = 0;ii<fNParticleFunctions;ii++)
delete fParticleFunctions[ii];
+ fNParticleFunctions = 0;
for(ii = 0;ii<fNTrackFunctions;ii++)
delete fTrackFunctions[ii];
-
+ fNTrackFunctions = 0;
+
for(ii = 0;ii<fNParticleAndTrackFunctions;ii++)
delete fParticleAndTrackFunctions[ii];
+ fNParticleAndTrackFunctions = 0;
for(ii = 0; ii<fNParticleMonitorFunctions; ii++)
delete fParticleMonitorFunctions[ii];
+ fNParticleMonitorFunctions = 0;
for(ii = 0; ii<fNTrackMonitorFunctions; ii++)
delete fTrackMonitorFunctions[ii];
+ fNTrackMonitorFunctions = 0;
for(ii = 0; ii<fNParticleAndTrackMonitorFunctions; ii++)
delete fParticleAndTrackMonitorFunctions[ii];
+ fNParticleAndTrackMonitorFunctions = 0;
}
+/*************************************************************************************/
+
+void AliHBTAnalysis::Init()
+{
+//Initializeation method
+//calls Init for all functions
+ UInt_t ii;
+ for(ii = 0;ii<fNParticleFunctions;ii++)
+ fParticleFunctions[ii]->Init();
+
+ for(ii = 0;ii<fNTrackFunctions;ii++)
+ fTrackFunctions[ii]->Init();
+
+ for(ii = 0;ii<fNParticleAndTrackFunctions;ii++)
+ fParticleAndTrackFunctions[ii]->Init();
+
+ for(ii = 0; ii<fNParticleMonitorFunctions; ii++)
+ fParticleMonitorFunctions[ii]->Init();
+
+ for(ii = 0; ii<fNTrackMonitorFunctions; ii++)
+ fTrackMonitorFunctions[ii]->Init();
+
+ for(ii = 0; ii<fNParticleAndTrackMonitorFunctions; ii++)
+ fParticleAndTrackMonitorFunctions[ii]->Init();
+}
+/*************************************************************************************/
+
+void AliHBTAnalysis::ResetFunctions()
+{
+//In case fOwner is true, deletes all functions
+//in other case, just set number of analysis to 0
+ if (fIsOwner) DeleteFunctions();
+ else
+ {
+ fNParticleFunctions = 0;
+ fNTrackFunctions = 0;
+ fNParticleAndTrackFunctions = 0;
+ fNParticleMonitorFunctions = 0;
+ fNTrackMonitorFunctions = 0;
+ fNParticleAndTrackMonitorFunctions = 0;
+ }
+}
+/*************************************************************************************/
+
void AliHBTAnalysis::Process(Option_t* option)
{
//default option = "TracksAndParticles"
return;
}
-
const char *oT = strstr(option,"Tracks");
const char *oP = strstr(option,"Particles");
"Coherency check not passed. Maybe change the option?\n");
return;
}
+ Init();
if (nonid) ProcessTracksAndParticlesNonIdentAnal();
else ProcessTracksAndParticles();
return;
Error("Process","There is no data to analyze.");
return;
}
+ Init();
if (nonid) ProcessTracksNonIdentAnal();
else ProcessTracks();
return;
Error("Process","There is no data to analyze.");
return;
}
+ Init();
if (nonid) ProcessParticlesNonIdentAnal();
else ProcessParticles();
return;
}
}
-
/*************************************************************************************/
void AliHBTAnalysis::ProcessTracksAndParticles()
{
-
//In order to minimize calling AliRun::GetEvent (we need at one time particles from different events),
//the loops are splited
// Int_t N1, N2, N=0; //number of particles in current event(we prcess two events in one time)
- Int_t Nev = fReader->GetNumberOfTrackEvents();
+ Int_t nev = fReader->GetNumberOfTrackEvents();
/***************************************/
/****** Looping same events ********/
register UInt_t ii;
- for (Int_t i = 0;i<Nev;i++)
+ for (Int_t i = 0;i<nev;i++)
{
partEvent= fReader->GetParticleEvent(i);
trackEvent = fReader->GetTrackEvent(i);
if (fPairCut->GetFirstPartCut()->Pass(part1)) continue;
for(ii = 0; ii<fNParticleMonitorFunctions; ii++)
- fParticleMonitorFunctions[ii]->ProcessSameEventParticles(part1);
+ fParticleMonitorFunctions[ii]->Process(part1);
for(ii = 0; ii<fNTrackMonitorFunctions; ii++)
- fTrackMonitorFunctions[ii]->ProcessSameEventParticles(track1);
+ fTrackMonitorFunctions[ii]->Process(track1);
for(ii = 0; ii<fNParticleAndTrackMonitorFunctions; ii++)
- fParticleAndTrackMonitorFunctions[ii]->ProcessSameEventParticles(track1,part1);
+ fParticleAndTrackMonitorFunctions[ii]->Process(track1,part1);
if ( (fNParticleFunctions == 0) && (fNTrackFunctions ==0) && (fNParticleAndTrackFunctions == 0))
continue;
for (Int_t k =j+1; k < partEvent->GetNumberOfParticles() ; k++)
{
part2= partEvent->GetParticle(k);
+ if (part1->GetUID() == part2->GetUID()) continue;
partpair->SetParticles(part1,part2);
track2= trackEvent->GetParticle(k);
}
}
+
/***** Filling denominators *********/
/***************************************/
if (fBufferSize != 0)
- for (Int_t i = 0;i<Nev-1;i++) //In each event (but last) ....
+ for (Int_t i = 0;i<nev-1;i++) //In each event (but last) ....
{
if ((fNParticleFunctions == 0) && (fNTrackFunctions ==0) && (fNParticleAndTrackFunctions == 0))
if (fPairCut->GetFirstPartCut()->Pass(part1)) continue;
- Int_t NNN;
+ Int_t maxeventnumber;
- if ( ((i+fBufferSize) >= Nev) ||( fBufferSize < 0) ) //if buffer size is negative
+ if ( ((i+fBufferSize) >= nev) ||( fBufferSize < 0) ) //if buffer size is negative
//or current event+buffersize is greater
//than max nuber of events
{
- NNN = Nev; //set the max event number
+ maxeventnumber = nev; //set the max event number
}
else
{
- NNN = i+fBufferSize; //set the current event number + fBufferSize
+ maxeventnumber = i+fBufferSize; //set the current event number + fBufferSize
}
- for (Int_t k = i+1; k<NNN;k++) // ... Loop over next event
+ for (Int_t k = i+1; k<maxeventnumber;k++) // ... Loop over next event
{
partEvent2= fReader->GetParticleEvent(k);
for(ii = 0;ii<fNParticleAndTrackFunctions;ii++)
fParticleAndTrackFunctions[ii]->ProcessDiffEventParticles(tmptrackpair,tmppartpair);
}//for(Int_t l = 0; l<N2;l++) // ... on all particles
- }//for (Int_t k = i+1; k<NNN;k++) // ... Loop over next event
+ }//for (Int_t k = i+1; k<maxeventnumber;k++) // ... Loop over next event
}
}
/***************************************/
void AliHBTAnalysis::ProcessTracks()
{
- //In order to minimize calling AliRun::GetEvent (we need at one time particles from different events),
+//In order to minimize calling AliRun::GetEvent (we need at one time particles from different events),
//the loops are splited
AliHBTParticle * track1, * track2;
AliHBTEvent * trackEvent;
AliHBTEvent * trackEvent2;
UInt_t ii;
- Int_t Nev = fReader->GetNumberOfTrackEvents();
+ Int_t nev = fReader->GetNumberOfTrackEvents();
AliHBTPair * trackpair = new AliHBTPair();
AliHBTPair * tmptrackpair; //temporary pointer
/****** Looping same events ********/
/****** filling numerators ********/
/***************************************/
- for (Int_t i = 0;i<Nev;i++)
+ for (Int_t i = 0;i<nev;i++)
{
trackEvent = fReader->GetTrackEvent(i);
if (!trackEvent) continue;
if (fPairCut->GetFirstPartCut()->Pass(track1)) continue;
for(ii = 0; ii<fNTrackMonitorFunctions; ii++)
- fTrackMonitorFunctions[ii]->ProcessSameEventParticles(track1);
+ fTrackMonitorFunctions[ii]->Process(track1);
if ( fNTrackFunctions ==0 )
continue;
for (Int_t k =j+1; k < trackEvent->GetNumberOfParticles() ; k++)
{
- track2= trackEvent->GetParticle(k);
+ track2= trackEvent->GetParticle(k);
+ if (track1->GetUID() == track2->GetUID()) continue;
+
trackpair->SetParticles(track1,track2);
if(fPairCut->Pass(trackpair)) //check pair cut
{ //do not meets crietria of the
/***** Filling diff histogram *********/
/***************************************/
if (fBufferSize != 0)
- for (Int_t i = 0;i<Nev-1;i++) //In each event (but last) ....
+ for (Int_t i = 0;i<nev-1;i++) //In each event (but last) ....
{
if ( fNTrackFunctions ==0 )
continue;
track1= trackEvent->GetParticle(j);
if (fPairCut->GetFirstPartCut()->Pass(track1)) continue;
- Int_t NNN;
+ Int_t maxeventnumber;
- if ( ((i+fBufferSize) >= Nev) ||( fBufferSize < 0) ) //if buffer size is negative
+ if ( ((i+fBufferSize) >= nev) ||( fBufferSize < 0) ) //if buffer size is negative
//or current event+buffersize is greater
//than max nuber of events
{
- NNN = Nev; //set the max event number
+ maxeventnumber = nev; //set the max event number
}
else
{
- NNN = i+fBufferSize; //set the current event number + fBufferSize
+ maxeventnumber = i+fBufferSize; //set the current event number + fBufferSize
}
- for (Int_t k = i+1; k<NNN;k++) // ... Loop over next event
+ for (Int_t k = i+1; k<maxeventnumber;k++) // ... Loop over next event
{
trackEvent2 = fReader->GetTrackEvent(k);
if (!trackEvent2) continue;
if ( (j%fDisplayMixingInfo) == 0)
- Info("ProcessTracksAndParticles",
+ Info("ProcessTracks",
"Mixing particle %d from event %d with particles from event %d",j,i,k);
for(Int_t l = 0; l<trackEvent2->GetNumberOfParticles();l++) // ... on all particles
fTrackFunctions[ii]->ProcessDiffEventParticles(tmptrackpair);
}//for(Int_t l = 0; l<N2;l++) // ... on all particles
- }//for (Int_t k = i+1; k<NNN;k++) // ... Loop over next event
+ }//for (Int_t k = i+1; k<maxeventnumber;k++) // ... Loop over next event
}
}
/***************************************/
AliHBTPair * partpair = new AliHBTPair();
AliHBTPair * tmppartpair; //temporary pointer to the pair
- Int_t Nev = fReader->GetNumberOfPartEvents();
+ Int_t nev = fReader->GetNumberOfPartEvents();
/***************************************/
/****** Looping same events ********/
/****** filling numerators ********/
/***************************************/
- for (Int_t i = 0;i<Nev;i++)
+ for (Int_t i = 0;i<nev;i++)
{
partEvent= fReader->GetParticleEvent(i);
if (!partEvent) continue;
UInt_t zz;
for(zz = 0; zz<fNParticleMonitorFunctions; zz++)
- fParticleMonitorFunctions[zz]->ProcessSameEventParticles(part1);
+ fParticleMonitorFunctions[zz]->Process(part1);
if ( fNParticleFunctions ==0 )
continue;
for (Int_t k =j+1; k < partEvent->GetNumberOfParticles() ; k++)
{
part2= partEvent->GetParticle(k);
+ if (part1->GetUID() == part2->GetUID()) continue; //this is the same particle but different incarnation (PID)
partpair->SetParticles(part1,part2);
if( fPairCut->Pass(partpair) ) //check pair cut
/***** Filling diff histogram *********/
/***************************************/
if (fBufferSize != 0) //less then 0 mix everything, == 0 do not mix denominator
- for (Int_t i = 0;i<Nev-1;i++) //In each event (but last)....
+ for (Int_t i = 0;i<nev-1;i++) //In each event (but last)....
{
if ( fNParticleFunctions ==0 )
continue;
{
part1= partEvent->GetParticle(j);
if (fPairCut->GetFirstPartCut()->Pass(part1)) continue;
- Int_t NNN;
+ Int_t maxeventnumber;
- if ( ((i+fBufferSize) >= Nev) ||( fBufferSize < 0) ) //if buffer size is negative
+ if ( ((i+fBufferSize) >= nev) ||( fBufferSize < 0) ) //if buffer size is negative
//or current event+buffersize is greater
//than max nuber of events
{
- NNN = Nev; //set the max event number
+ maxeventnumber = nev; //set the max event number
}
else
{
- NNN = i+fBufferSize; //set the current event number + fBufferSize
+ maxeventnumber = i+fBufferSize; //set the current event number + fBufferSize
}
- for (Int_t k = i+1; k<NNN;k++) // ... Loop over next event
+ for (Int_t k = i+1; k<maxeventnumber;k++) // ... Loop over next event
{
partEvent2= fReader->GetParticleEvent(k);
fParticleFunctions[ii]->ProcessDiffEventParticles(tmppartpair);
}//for(Int_t l = 0; l<N2;l++) // ... on all particles
- }//for (Int_t k = i+1; k<NNN;k++) // ... Loop over next event
+ }//for (Int_t k = i+1; k<maxeventnumber;k++) // ... Loop over next event
}
}
/***************************************/
AliHBTEvent * rawtrackEvent, *rawpartEvent;
- Int_t Nev = fReader->GetNumberOfTrackEvents();
+ Int_t nev = fReader->GetNumberOfTrackEvents();
AliHBTPair * trackpair = new AliHBTPair();
AliHBTPair * partpair = new AliHBTPair();
Info("ProcessTracksAndParticlesNonIdentAnal","***** NON IDENT MODE ****************");
Info("ProcessTracksAndParticlesNonIdentAnal","**************************************");
- for (Int_t i = 0;i<Nev;i++)
+ for (Int_t i = 0;i<nev;i++)
{
rawpartEvent = fReader->GetParticleEvent(i);
rawtrackEvent = fReader->GetTrackEvent(i);
track1= trackEvent1->GetParticle(j);
for(ii = 0; ii<fNParticleMonitorFunctions; ii++)
- fParticleMonitorFunctions[ii]->ProcessSameEventParticles(part1);
+ fParticleMonitorFunctions[ii]->Process(part1);
for(ii = 0; ii<fNTrackMonitorFunctions; ii++)
- fTrackMonitorFunctions[ii]->ProcessSameEventParticles(track1);
+ fTrackMonitorFunctions[ii]->Process(track1);
for(ii = 0; ii<fNParticleAndTrackMonitorFunctions; ii++)
- fParticleAndTrackMonitorFunctions[ii]->ProcessSameEventParticles(track1,part1);
+ fParticleAndTrackMonitorFunctions[ii]->Process(track1,part1);
/***************************************/
/****** filling numerators ********/
for (Int_t k = 0; k < partEvent2->GetNumberOfParticles() ; k++)
{
part2= partEvent2->GetParticle(k);
+ if (part1->GetUID() == part2->GetUID()) continue;//this is the same particle but with different PID
partpair->SetParticles(part1,part2);
track2= trackEvent2->GetParticle(k);
}//while event2
}//for over particles in event1
+ if ( fBufferSize == 0) continue;//do not mix diff histograms-> do not add to buffer list
pbuffer.AddFirst(partEvent2);
tbuffer.AddFirst(trackEvent2);
partEvent2 = 0x0;
}//end of loop over events (1)
pbuffer.SetOwner(); //to clean stored events by the way of buffer destruction
tbuffer.SetOwner();
- delete partEvent2;
- delete trackEvent2;
+ delete partEvent1;
+ delete trackEvent1;
+ delete partpair;
+ delete trackpair;
+ if ( fBufferSize == 0)
+ {//in that case we did not add these events to list
+ delete partEvent2;
+ delete trackEvent2;
+ }
}
/*************************************************************************************/
void AliHBTAnalysis::ProcessTracksNonIdentAnal()
{
+//Process Tracks only with non identical mode
AliHBTParticle * track1, * track2;
AliHBTEvent * trackEvent1=0x0;
AliHBTEvent * trackEvent2=0x0;
AliHBTEvent * trackEvent3=0x0;
+
AliHBTEvent * rawtrackEvent;
- Int_t Nev = fReader->GetNumberOfTrackEvents();
+ Int_t nev = fReader->GetNumberOfTrackEvents();
AliHBTPair * trackpair = new AliHBTPair();
Info("ProcessTracksNonIdentAnal","***** NON IDENT MODE ****************");
Info("ProcessTracksNonIdentAnal","**************************************");
- for (Int_t i = 0;i<Nev;i++)
+ for (Int_t i = 0;i<nev;i++)
{
rawtrackEvent = fReader->GetTrackEvent(i);
if (rawtrackEvent == 0x0) continue;//in case of any error
track1= trackEvent1->GetParticle(j);
for(ii = 0; ii<fNTrackMonitorFunctions; ii++)
- fTrackMonitorFunctions[ii]->ProcessSameEventParticles(track1);
+ fTrackMonitorFunctions[ii]->Process(track1);
/***************************************/
/****** filling numerators ********/
for (Int_t k = 0; k < trackEvent2->GetNumberOfParticles() ; k++)
{
track2= trackEvent2->GetParticle(k);
+ if (track1->GetUID() == track2->GetUID()) continue;//this is the same particle but with different PID
trackpair->SetParticles(track1,track2);
}//while event2
}//for over particles in event1
+ if ( fBufferSize == 0) continue;//do not mix diff histograms
tbuffer.AddFirst(trackEvent2);
+ trackEvent2 = 0x0;
ninbuffer++;
}//end of loop over events (1)
-
+
+ delete trackpair;
+ delete trackEvent1;
+ if (fBufferSize == 0) delete trackEvent2;
tbuffer.SetOwner();
}
/*************************************************************************************/
void AliHBTAnalysis::ProcessParticlesNonIdentAnal()
{
+//process paricles only with non identical mode
AliHBTParticle * part1 = 0x0, * part2 = 0x0;
AliHBTEvent * partEvent1 = 0x0;
AliHBTEvent * rawpartEvent = 0x0;
- Int_t Nev = fReader->GetNumberOfPartEvents();
+ Int_t nev = fReader->GetNumberOfPartEvents();
AliHBTPair * partpair = new AliHBTPair();
Info("ProcessParticlesNonIdentAnal","***** NON IDENT MODE ****************");
Info("ProcessParticlesNonIdentAnal","**************************************");
- for (Int_t i = 0;i<Nev;i++)
+ for (Int_t i = 0;i<nev;i++)
{
rawpartEvent = fReader->GetParticleEvent(i);
if ( rawpartEvent == 0x0 ) continue;//in case of any error
/********************************/
/* Filtering out */
/********************************/
- if ((ninbuffer > fBufferSize) && (fBufferSize > 0))
- {//if we have in buffer desired number of events, use the last. If fBufferSize<0 mix all events for background
- partEvent2 = (AliHBTEvent*)pbuffer.Remove(pbuffer.Last()); //remove from the end to be reset, filled and put on the beginning
- ninbuffer--;
- }
- else
- {
- partEvent2 = new AliHBTEvent();
- partEvent2->SetOwner(kFALSE);
- }
+ if ( (fBufferSize != 0) || ( partEvent2==0x0) )//in case fBufferSize == 0 and pointers are created do not eneter
+ if ((ninbuffer > fBufferSize) && (fBufferSize > 0))
+ {//if we have in buffer desired number of events, use the last. If fBufferSize<0 mix all events for background
+ partEvent2 = (AliHBTEvent*)pbuffer.Remove(pbuffer.Last()); //remove from the end to be reset, filled and put on the beginning
+ ninbuffer--;
+ }
+ else
+ {
+ partEvent2 = new AliHBTEvent();
+ partEvent2->SetOwner(kFALSE);
+ }
FilterOut(partEvent1, partEvent2, rawpartEvent);
for (Int_t j = 0; j<partEvent1->GetNumberOfParticles() ; j++)
UInt_t zz;
for(zz = 0; zz<fNParticleMonitorFunctions; zz++)
- fParticleMonitorFunctions[zz]->ProcessSameEventParticles(part1);
+ fParticleMonitorFunctions[zz]->Process(part1);
/***************************************/
/****** filling numerators ********/
for (Int_t k = 0; k < partEvent2->GetNumberOfParticles() ; k++)
{
part2= partEvent2->GetParticle(k);
+ if (part1->GetUID() == part2->GetUID()) continue;//this is the same particle but with different PID
partpair->SetParticles(part1,part2);
if(fPairCut->PassPairProp(partpair) ) //check pair cut
}
}
}
+ if ( fBufferSize == 0) continue;//do not mix diff histograms
/***************************************/
/***** Filling denominators *********/
/***************************************/
}// for particles event2
}//while event2
}//for over particles in event1
-
+ if ( fBufferSize == 0) continue;//do not mix diff histograms
pbuffer.AddFirst(partEvent2);
+ partEvent2 = 0x0;
ninbuffer++;
}//end of loop over events (1)
-
+ delete partpair;
+ delete partEvent1;
+ if ( fBufferSize == 0) delete partEvent2;
pbuffer.SetOwner();//to delete stered events.
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff