#include "AliHBTPair.h"
#include "AliHBTPairCut.h"
#include "AliHBTFunction.h"
+#include "AliHBTMonitorFunction.h"
#include <TBenchmark.h>
#include <TList.h>
fParticleFunctions = new AliHBTOnePairFctn* [fgkFctnArraySize];
fParticleAndTrackFunctions = new AliHBTTwoPairFctn* [fgkFctnArraySize];
+ fParticleMonitorFunctions = new AliHBTMonOneParticleFctn* [fgkFctnArraySize];
+ fTrackMonitorFunctions = new AliHBTMonOneParticleFctn* [fgkFctnArraySize];
+ fParticleAndTrackMonitorFunctions = new AliHBTMonTwoParticleFctn* [fgkFctnArraySize];
+
fNTrackFunctions = 0;
fNParticleFunctions = 0;
fNParticleAndTrackFunctions = 0;
+ fNParticleMonitorFunctions = 0;
+ fNTrackMonitorFunctions = 0;
+ fNParticleAndTrackMonitorFunctions = 0;
+
fPairCut = new AliHBTEmptyPairCut();//empty cut - accepts all particles
fBufferSize = 2;
delete [] fParticleFunctions;
delete [] fParticleAndTrackFunctions;
+ delete [] fParticleMonitorFunctions;
+ delete [] fTrackMonitorFunctions;
+ delete [] fParticleAndTrackMonitorFunctions;
+
delete fPairCut; // always have an copy of an object - we create we dstroy
}
const char *oP = strstr(option,"Particles");
Bool_t nonid = IsNonIdentAnalysis();
+ // nonid=0;
+ cout<<"nonid = "<<nonid<<endl;
if(oT && oP)
{
if ( (j%100) == 0) cout<<"Mixing particle "<<j<<" from event "<<i<<" with particles from event "<<i<<endl;
part1= partEvent->GetParticle(j);
- track1= trackEvent->GetParticle(j);
-
+ track1= trackEvent->GetParticle(j);
+
+ UInt_t zz;
+ for(zz = 0; zz<fNParticleMonitorFunctions; zz++)
+ fParticleMonitorFunctions[zz]->ProcessSameEventParticles(part1);
+ for(zz = 0; zz<fNTrackMonitorFunctions; zz++)
+ fTrackMonitorFunctions[zz]->ProcessSameEventParticles(track1);
+ for(zz = 0; zz<fNParticleAndTrackMonitorFunctions; zz++)
+ fParticleAndTrackMonitorFunctions[zz]->ProcessSameEventParticles(track1,part1);
+
+ if ( (fNParticleFunctions == 0) && (fNTrackFunctions ==0) && (fNParticleAndTrackFunctions == 0))
+ continue;
+
for (Int_t k =j+1; k < partEvent->GetNumberOfParticles() ; k++)
{
part2= partEvent->GetParticle(k);
partpair->SetParticles(part1,part2);
- track2= trackEvent->GetParticle(k);
+ track2= trackEvent->GetParticle(k);
trackpair->SetParticles(track1,track2);
if(fPairCut->Pass(partpair) || (fPairCut->Pass(trackpair))) //check pair cut
if( ( fPairCut->Pass(partpair->GetSwapedPair()) ) || ( fPairCut->Pass(trackpair->GetSwapedPair()) ) )
continue; //swaped pairs do not meet criteria of pair cut as well, take next particle
else
- { //swaped pair meets all the criteria
+ { //swaped pair meets all the criteria
tmppartpair = partpair->GetSwapedPair();
tmptrackpair = trackpair->GetSwapedPair();
-
}
}
else
/***************************************/
for (Int_t i = 0;i<Nev-1;i++) //In each event (but last) ....
{
-
+
+ if ((fNParticleFunctions == 0) && (fNTrackFunctions ==0) && (fNParticleAndTrackFunctions == 0))
+ continue;
+
partEvent= fReader->GetParticleEvent(i);
if (!partEvent) continue;
trackEvent = fReader->GetTrackEvent(i);
// N=0;
-
+
for (Int_t j = 0; j< partEvent->GetNumberOfParticles(); j++) // ... Loop over all particles ...
{
trackEvent2 = fReader->GetTrackEvent(k);
if ( (j%100) == 0) cout<<"Mixing particle "<<j<<" from event "<<i<<" with particles from event "<<k<<endl;
-
+
for(Int_t l = 0; l<partEvent2->GetNumberOfParticles();l++) // ... on all particles
{
if( (fPairCut->Pass(partpair)) || (fPairCut->Pass(trackpair)) ) //check pair cut
{ //do not meets crietria of the
if( ( fPairCut->Pass(partpair->GetSwapedPair()) ) || ( fPairCut->Pass(trackpair->GetSwapedPair()) ) )
- continue;
- else
- {
- tmppartpair = partpair->GetSwapedPair();
- tmptrackpair = trackpair->GetSwapedPair();
- }
+ continue;
+ else
+ {
+ tmppartpair = partpair->GetSwapedPair();
+ tmptrackpair = trackpair->GetSwapedPair();
+ }
}
else
{//meets criteria of the pair cut
{
if ( (j%100) == 0) cout<<"Mixing particle "<<j<<" from event "<<i<<" with particles from event "<<i<<endl;
- track1= trackEvent->GetParticle(j);
-
+ track1= trackEvent->GetParticle(j);
+
+ UInt_t zz;
+ for(zz = 0; zz<fNTrackMonitorFunctions; zz++)
+ fTrackMonitorFunctions[zz]->ProcessSameEventParticles(track1);
+
+ if ( fNTrackFunctions ==0 )
+ continue;
+
for (Int_t k =j+1; k < trackEvent->GetNumberOfParticles() ; k++)
{
- track2= trackEvent->GetParticle(k);
- trackpair->SetParticles(track1,track2);
- if(fPairCut->Pass(trackpair)) //check pair cut
- { //do not meets crietria of the
- if( fPairCut->Pass(trackpair->GetSwapedPair()) ) continue;
- else tmptrackpair = trackpair->GetSwapedPair();
+ track2= trackEvent->GetParticle(k);
+ trackpair->SetParticles(track1,track2);
+ if(fPairCut->Pass(trackpair)) //check pair cut
+ { //do not meets crietria of the
+ if( fPairCut->Pass(trackpair->GetSwapedPair()) ) continue;
+ else tmptrackpair = trackpair->GetSwapedPair();
}
else
{
/***************************************/
for (Int_t i = 0;i<Nev-1;i++) //In each event (but last) ....
{
+ if ( fNTrackFunctions ==0 )
+ continue;
+
trackEvent = fReader->GetTrackEvent(i);
if (!trackEvent) continue;
// N=0;
if (!trackEvent2) continue;
if ( (j%100) == 0) cout<<"Mixing particle "<<j<<" from event "<<i<<" with particles from event "<<k<<endl;
-
+
for(Int_t l = 0; l<trackEvent2->GetNumberOfParticles();l++) // ... on all particles
{
if(fPairCut->Pass(trackpair)) //check pair cut
{ //do not meets crietria of the
if( fPairCut->Pass(trackpair->GetSwapedPair()) ) continue;
- else tmptrackpair = trackpair->GetSwapedPair();
+ else tmptrackpair = trackpair->GetSwapedPair();
}
else
{
if ( (j%100) == 0) cout<<"Mixing particle "<<j<<" from event "<<i<<" with particles from event "<<i<<endl;
part1= partEvent->GetParticle(j);
-
+
+ UInt_t zz;
+ for(zz = 0; zz<fNParticleMonitorFunctions; zz++)
+ fParticleMonitorFunctions[zz]->ProcessSameEventParticles(part1);
+
+ if ( fNParticleFunctions ==0 )
+ continue;
+
for (Int_t k =j+1; k < partEvent->GetNumberOfParticles() ; k++)
{
part2= partEvent->GetParticle(k);
{
tmppartpair = partpair;
}
-
+
UInt_t ii;
-
for(ii = 0;ii<fNParticleFunctions;ii++)
fParticleFunctions[ii]->ProcessSameEventParticles(tmppartpair);
}
/***************************************/
for (Int_t i = 0;i<Nev-1;i++) //In each event (but last)....
{
+ if ( fNParticleFunctions ==0 )
+ continue;
+
partEvent= fReader->GetParticleEvent(i);
if (!partEvent) continue;
if (!partEvent2) continue;
if ( (j%100) == 0) cout<<"Mixing particle "<<j<<" from event "<<i<<" with particles from event "<<k<<endl;
-
+
for(Int_t l = 0; l<partEvent2->GetNumberOfParticles();l++) // ... on all particles
{
if(fPairCut->Pass(partpair)) //check pair cut
{ //do not meets crietria of the
if( fPairCut->Pass(partpair->GetSwapedPair()) ) continue;
- else tmppartpair = partpair->GetSwapedPair();
+ else tmppartpair = partpair->GetSwapedPair();
}
else
{
for(ii = 0;ii<fNParticleAndTrackFunctions;ii++)
fParticleAndTrackFunctions[ii]->Write();
+
+ for(ii = 0;ii<fNParticleMonitorFunctions;ii++)
+ fParticleMonitorFunctions[ii]->Write();
+
+ for(ii = 0;ii<fNTrackMonitorFunctions;ii++)
+ fTrackMonitorFunctions[ii]->Write();
+
+ for(ii = 0;ii<fNParticleAndTrackMonitorFunctions;ii++)
+ fParticleAndTrackMonitorFunctions[ii]->Write();
}
/*************************************************************************************/
}
fParticleFunctions[fNParticleFunctions] = f;
fNParticleFunctions++;
-
-
}
+/*************************************************************************************/
+
void AliHBTAnalysis::AddParticleAndTrackFunction(AliHBTTwoPairFctn* f)
{
if (f == 0x0) return;
fParticleAndTrackFunctions[fNParticleAndTrackFunctions] = f;
fNParticleAndTrackFunctions++;
}
+/*************************************************************************************/
+
+void AliHBTAnalysis::AddParticleMonitorFunction(AliHBTMonOneParticleFctn* f)
+{
+ if (f == 0x0) return;
+
+ if (fNParticleMonitorFunctions == fgkFctnArraySize)
+ {
+ Error("AliHBTAnalysis::AddParticleMonitorFunction","Can not add this function, not enough place in the array.");
+ }
+ fParticleMonitorFunctions[fNParticleMonitorFunctions] = f;
+ fNParticleMonitorFunctions++;
+}
+/*************************************************************************************/
+void AliHBTAnalysis::AddTrackMonitorFunction(AliHBTMonOneParticleFctn* f)
+{
+ if (f == 0x0) return;
+ if (fNTrackMonitorFunctions == fgkFctnArraySize)
+ {
+ Error("AliHBTAnalysis::AddTrackMonitorFunction","Can not add this function, not enough place in the array.");
+ }
+ fTrackMonitorFunctions[fNTrackMonitorFunctions] = f;
+ fNTrackMonitorFunctions++;
+}
/*************************************************************************************/
+void AliHBTAnalysis::AddParticleAndTrackMonitorFunction(AliHBTMonTwoParticleFctn* f)
+{
+ if (f == 0x0) return;
+ if (fNParticleAndTrackMonitorFunctions == fgkFctnArraySize)
+ {
+ Error("AliHBTAnalysis::AddParticleAndTrackMonitorFunction","Can not add this function, not enough place in the array.");
+ }
+ fParticleAndTrackMonitorFunctions[fNParticleAndTrackMonitorFunctions] = f;
+ fNParticleAndTrackMonitorFunctions++;
+}
+
+/*************************************************************************************/
/*************************************************************************************/
Bool_t AliHBTAnalysis::RunCoherencyCheck()
/********************************/
/* Filtering out */
/********************************/
- if (ninbuffer > fBufferSize)
- {
+ 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
trackEvent2 = (AliHBTEvent*)tbuffer.Remove(tbuffer.Last());
ninbuffer--;
part1= partEvent1->GetParticle(j);
track1= trackEvent1->GetParticle(j);
+ UInt_t zz;
+ for(zz = 0; zz<fNParticleMonitorFunctions; zz++)
+ fParticleMonitorFunctions[zz]->ProcessSameEventParticles(part1);
+ for(zz = 0; zz<fNTrackMonitorFunctions; zz++)
+ fTrackMonitorFunctions[zz]->ProcessSameEventParticles(track1);
+ for(zz = 0; zz<fNParticleAndTrackMonitorFunctions; zz++)
+ fParticleAndTrackMonitorFunctions[zz]->ProcessSameEventParticles(track1,part1);
/***************************************/
/****** filling numerators ********/
fParticleAndTrackFunctions[ii]->ProcessSameEventParticles(trackpair,partpair);
}
}
+
+
/***************************************/
/***** Filling denominators *********/
/***************************************/
/********************************/
/* Filtering out */
/********************************/
- if (ninbuffer > fBufferSize)
- {
+ 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
trackEvent2 = (AliHBTEvent*)tbuffer.Remove(tbuffer.Last());
ninbuffer--;
}
track1= trackEvent1->GetParticle(j);
+ UInt_t zz;
+ for(zz = 0; zz<fNTrackMonitorFunctions; zz++)
+ fTrackMonitorFunctions[zz]->ProcessSameEventParticles(track1);
/***************************************/
/****** filling numerators ********/
/********************************/
/* Filtering out */
/********************************/
- if (ninbuffer > fBufferSize)
- {
+ 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--;
}
part1= partEvent1->GetParticle(j);
+ UInt_t zz;
+ for(zz = 0; zz<fNParticleMonitorFunctions; zz++)
+ fParticleMonitorFunctions[zz]->ProcessSameEventParticles(part1);
/***************************************/
/****** filling numerators ********/
{//meets criteria of the pair cut
UInt_t ii;
for(ii = 0;ii<fNParticleFunctions;ii++)
- fParticleFunctions[ii]->ProcessSameEventParticles(partpair);
-
+ {
+ // if ((k%100) == 0) cout<<".";
+ fParticleFunctions[ii]->ProcessSameEventParticles(partpair);
+ }
}
}
/***************************************/
{//meets criteria of the pair cut
UInt_t ii;
for(ii = 0;ii<fNParticleFunctions;ii++)
- fParticleFunctions[ii]->ProcessDiffEventParticles(partpair);
-
+ {
+ // if ((k%100) == 0) cout<<"*";
+ fParticleFunctions[ii]->ProcessDiffEventParticles(partpair);
+ }
}
}// for particles event2
}//while event2
//in the future is possible to perform more sophisticated check
//if cuts have excluding requirements
- if (fPairCut->IsEmpty()) return kFALSE;
- if (fPairCut->GetFirstPartCut()->IsEmpty()) return kFALSE;
- if (fPairCut->GetSecondPartCut()->IsEmpty()) return kFALSE;
+ if (fPairCut->IsEmpty())
+ return kFALSE;
+
+ if (fPairCut->GetFirstPartCut()->IsEmpty())
+ return kFALSE;
+
+ if (fPairCut->GetSecondPartCut()->IsEmpty())
+ return kFALSE;
Int_t id1 = fPairCut->GetFirstPartCut()->GetPID();
Int_t id2 = fPairCut->GetSecondPartCut()->GetPID();
-
- if ( (id1==0) || (id2==0) || (id1==id2) ) return kFALSE;
+ if ( (id1==0) || (id2==0) || (id1==id2) )
+ return kFALSE;
+
return kTRUE;
}
#pragma link C++ class AliHBTEvent+;
#pragma link C++ class AliHBTRun+;
#pragma link C++ class AliHBTFunction+;
+#pragma link C++ class AliHBTMonitorFunction+;
#pragma link C++ class AliHBTOnePairFctn+;
-#pragma link C++ class AliHBTTwoPairFctn+;
#pragma link C++ class AliHBTOnePairFctn1D+;
#pragma link C++ class AliHBTOnePairFctn2D+;
#pragma link C++ class AliHBTOnePairFctn3D+;
-
+#pragma link C++ class AliHBTTwoPairFctn+;
#pragma link C++ class AliHBTTwoPairFctn1D+;
#pragma link C++ class AliHBTTwoPairFctn2D+;
#pragma link C++ class AliHBTTwoPairFctn3D+;
+#pragma link C++ class AliHBTMonOneParticleFctn+;
+#pragma link C++ class AliHBTMonOneParticleFctn1D+;
+#pragma link C++ class AliHBTMonOneParticleFctn2D+;
+#pragma link C++ class AliHBTMonOneParticleFctn3D+;
+#pragma link C++ class AliHBTMonTwoParticleFctn+;
+#pragma link C++ class AliHBTMonTwoParticleFctn1D+;
+#pragma link C++ class AliHBTMonTwoParticleFctn2D+;
+#pragma link C++ class AliHBTMonTwoParticleFctn3D+;
+
#pragma link C++ class AliHBTPair+;
#pragma link C++ class AliHBTParticleCut-;
#pragma link C++ class AliHBTEmptyParticleCut-;
#pragma link C++ class AliHBTInvMassCorrelFctn+;
-#pragma link C++ class AliHBTQOutResolVSQInvFctn+;
-#pragma link C++ class AliHBTQSideResolVSQInvFctn+;
-#pragma link C++ class AliHBTQLongResolVSQInvFctn+;
-#pragma link C++ class AliHBTQInvResolVSKtFctn+;
-#pragma link C++ class AliHBTQOutResolVSKtFctn+;
-#pragma link C++ class AliHBTQSideResolVSKtFctn+;
-#pragma link C++ class AliHBTQLongResolVSKtFctn+;
-#pragma link C++ class AliHBTQOutResolVSQOutFctn+;
-#pragma link C++ class AliHBTQSideResolVSQSideFctn+;
-#pragma link C++ class AliHBTQLongResolVSQLongFctn+;
+#pragma link C++ class AliHBTQInvResolVsQInvFctn+;
+#pragma link C++ class AliHBTQOutResolVsQInvFctn+;
+#pragma link C++ class AliHBTQSideResolVsQInvFctn+;
+#pragma link C++ class AliHBTQLongResolVsQInvFctn+;
+
+#pragma link C++ class AliHBTQInvResolVsKtFctn+;
+#pragma link C++ class AliHBTQOutResolVsKtFctn+;
+#pragma link C++ class AliHBTQSideResolVsKtFctn+;
+#pragma link C++ class AliHBTQLongResolVsKtFctn+;
+
+#pragma link C++ class AliHBTQOutResolVsQOutFctn+;
+#pragma link C++ class AliHBTQSideResolVsQSideFctn+;
+#pragma link C++ class AliHBTQLongResolVsQLongFctn+;
+
+#pragma link C++ class AliHBTPairThetaResolVsQInvFctn+;
+#pragma link C++ class AliHBTPairPhiResolVsQInvFctn+;
+#pragma link C++ class AliHBTPairThetaResolVsKtFctn+;
+#pragma link C++ class AliHBTPairPhiResolVsKtFctn+;
+
+#pragma link C++ class AliHBTQInvDistributionVsKtFctn+;
+#pragma link C++ class AliHBTQOutDistributionVsKtFctn+;
+#pragma link C++ class AliHBTQSideDistributionVsKtFctn+;
+#pragma link C++ class AliHBTQLongDistributionVsKtFctn+;
+
+#pragma link C++ class AliHBTMonPxDistributionFctn+;
+#pragma link C++ class AliHBTMonPyDistributionFctn+;
+#pragma link C++ class AliHBTMonPzDistributionFctn+;
+#pragma link C++ class AliHBTMonPDistributionFctn+;
+#pragma link C++ class AliHBTMonPtDistributionFctn+;
+#pragma link C++ class AliHBTMonPhiDistributionFctn+;
+#pragma link C++ class AliHBTMonThetaDistributionFctn+;
+
+#pragma link C++ class AliHBTMonPxDistributionVsPtFctn+;
+#pragma link C++ class AliHBTMonPyDistributionVsPtFctn+;
+#pragma link C++ class AliHBTMonPzDistributionVsPtFctn+;
+#pragma link C++ class AliHBTMonPDistributionVsPtFctn+;
+#pragma link C++ class AliHBTMonPhiDistributionVsPtFctn+;
+#pragma link C++ class AliHBTMonThetaDistributionVsPtFctn+;
+
+#pragma link C++ class AliHBTMonPxResolutionFctn+;
+#pragma link C++ class AliHBTMonPyResolutionFctn+;
+#pragma link C++ class AliHBTMonPzResolutionFctn+;
+#pragma link C++ class AliHBTMonPResolutionFctn+;
+#pragma link C++ class AliHBTMonPtResolutionFctn+;
+#pragma link C++ class AliHBTMonPhiResolutionFctn+;
+#pragma link C++ class AliHBTMonThetaResolutionFctn+;
+
+#pragma link C++ class AliHBTMonPxResolutionVsPtFctn+;
+#pragma link C++ class AliHBTMonPyResolutionVsPtFctn+;
+#pragma link C++ class AliHBTMonPzResolutionVsPtFctn+;
+#pragma link C++ class AliHBTMonPResolutionVsPtFctn+;
+#pragma link C++ class AliHBTMonPtResolutionVsPtFctn+;
+#pragma link C++ class AliHBTMonPhiResolutionVsPtFctn+;
+#pragma link C++ class AliHBTMonThetaResolutionVsPtFctn+;
-#pragma link C++ class AliHBTLLWeights+;
-#pragma link C++ class AliHBTLLWeightQInvFctn+;
#pragma link C++ class AliHBTTwoTrackEffFctn+;
#pragma link C++ class AliHBTTwoTrackEffFctn3D+;
+#pragma link C++ class AliHBTLLWeights+;
+#pragma link C++ class AliHBTLLWeightQInvFctn+;
+#pragma link C++ class AliHBTLLWeightTheorQInvFctn+;
+
+
+
#endif