// ALICE Off-Line framework:
//
// Piotr.Skowronski@cern.ch
-// more info: http://alisoft.cern.ch/people/skowron/analyzer/index.html
+// more info: http://aliweb.cern.ch/people/skowron/analyzer/index.html
//
////////////////////////////////////////////////////////////////////////////
//_________________________________________________________
+#include <Riostream.h>
+#include <AliESD.h>
+
+#include <TSystem.h>
+#include <TFile.h>
#include "AliAOD.h"
#include "AliAODParticle.h"
#include "AliAODPairCut.h"
+#include "AliEventCut.h"
#include "AliEventBuffer.h"
#include "AliHBTPair.h"
#include "AliHBTFunction.h"
#include "AliHBTMonitorFunction.h"
+#include "AliLog.h"
-#include <TSystem.h>
ClassImp(AliHBTAnalysis)
fParticleMonitorFunctions ( new AliHBTMonOneParticleFctn* [fgkFctnArraySize]),
fTrackMonitorFunctions ( new AliHBTMonOneParticleFctn* [fgkFctnArraySize]),
fParticleAndTrackMonitorFunctions ( new AliHBTMonTwoParticleFctn* [fgkFctnArraySize]),
- fPairCut(new AliAODEmptyPairCut()),//empty cut - accepts all particles
+ fBkgEventCut(0x0),
+ fPartBuffer(0x0),
+ fTrackBuffer(0x0),
fBufferSize(2),
fDisplayMixingInfo(fgkDefaultMixingInfo),
fIsOwner(kFALSE),
- fPartBuffer(0x0),
- fTrackBuffer(0x0),
fProcessOption(kSimulatedAndReconstructed),
fNoCorrfctns(kFALSE),
- fkPass(&AliHBTAnalysis::PassPartAndTrack), //by default perform cut on both track and particle pair
- fkPass1(&AliHBTAnalysis::PassPartAndTrack1), //used onluy by ProcessTracksAndParticles
- fkPass2(&AliHBTAnalysis::PassPartAndTrack2),
- fkPassPairProp(&AliHBTAnalysis::PassPairPropPartAndTrack)
+ fOutputFileName(0x0),
+ fVertexX(0.0),
+ fVertexY(0.0),
+ fVertexZ(0.0)
{
//default constructor
fParticleMonitorFunctions(0x0),
fTrackMonitorFunctions(0x0),
fParticleAndTrackMonitorFunctions(0x0),
- fPairCut(0x0),
+ fBkgEventCut(0x0),
+ fPartBuffer(0x0),
+ fTrackBuffer(0x0),
fBufferSize(fgkDefaultBufferSize),
fDisplayMixingInfo(fgkDefaultMixingInfo),
fIsOwner(kFALSE),
- fPartBuffer(0x0),
- fTrackBuffer(0x0),
fProcessOption(kSimulatedAndReconstructed),
fNoCorrfctns(kFALSE),
- fkPass(&AliHBTAnalysis::PassPartAndTrack), //by default perform cut on both track and particle pair
- fkPass1(&AliHBTAnalysis::PassPartAndTrack1),
- fkPass2(&AliHBTAnalysis::PassPartAndTrack2),
- fkPassPairProp(&AliHBTAnalysis::PassPairPropPartAndTrack)
+ fOutputFileName(0x0),
+ fVertexX(0.0),
+ fVertexY(0.0),
+ fVertexZ(0.0)
{
//copy constructor
Fatal("AliHBTAnalysis(const AliHBTAnalysis&)","Sensless");
if (fIsOwner)
{
- if (AliVAODParticle::GetDebug()>5)Info("~AliHBTAnalysis","Is Owner: Attempting to delete functions");
+ AliDebug(5,"Is Owner: Attempting to delete functions");
DeleteFunctions();
if (AliVAODParticle::GetDebug()>5)Info("~AliHBTAnalysis","Delete functions done");
}
delete [] fTrackMonitorFunctions;
delete [] fParticleAndTrackMonitorFunctions;
- delete fPairCut; // always have an copy of an object - we create we dstroy
+ delete fBkgEventCut;
+ delete fOutputFileName;
}
/*************************************************************************************/
+
Int_t AliHBTAnalysis::ProcessEvent(AliAOD* aodrec, AliAOD* aodsim)
{
//Processes one event
if (fProcEvent == 0x0)
{
- Error("ProcessEvent","Analysis option not specified");
+ Error("ProcessEvent","Analysis <<%s>> option not specified.",GetName());
return 1;
}
- if ( Pass(aodrec,aodsim) ) return 0;
+ if ( Rejected(aodrec,aodsim) )
+ {
+// Double_t x = 0, y = 0, z = 0;
+// aodrec->GetPrimaryVertex(x,y,z);
+// Info("ProcessEvent","Event has vertex at %f %f %f",x,y,z);
+ Info("ProcessEvent","Nch is %d",aodsim->GetNumberOfCharged());
+ Info("ProcessEvent","%s: Event cut rejected this event",GetName());
+ return 0;
+ }
+
+ //Move event to the apparent vertex -> must be after the event cut
+ //It is important for any cut that use any spacial coordiantes,
+ //f.g. anti-merging cut in order to preserve the same bahavior of variables (f.g. distance between tracks)
+ Double_t dvx = 0, dvy = 0, dvz = 0;
+ if (aodrec)
+ {
+ Double_t pvx,pvy,pvz;
+ aodrec->GetPrimaryVertex(pvx,pvy,pvz);
+
+ dvx = fVertexX - pvx;
+ dvy = fVertexY - pvy;
+ dvz = fVertexZ - pvz;
+ aodrec->Move(dvx,dvy,dvz);
+ }
- return (this->*fProcEvent)(aodrec,aodsim);
+ Int_t result = (this->*fProcEvent)(aodrec,aodsim);
+
+ if (aodrec) aodrec->Move(-dvx,-dvy,-dvz);//move event back to the same spacial coordinates
+
+ return result;
}
/*************************************************************************************/
void AliHBTAnalysis::DeleteFunctions()
{
//Deletes all functions added to analysis
+
UInt_t ii;
for(ii = 0;ii<fNParticleFunctions;ii++)
{
case kReconstructed:
if (nonid) fProcEvent = &AliHBTAnalysis::ProcessRecNonId;
else fProcEvent = &AliHBTAnalysis::ProcessRec;
+ SetCutsOnRec();
break;
case kSimulated:
if (nonid) fProcEvent = &AliHBTAnalysis::ProcessSimNonId;
else fProcEvent = &AliHBTAnalysis::ProcessSim;
+ SetCutsOnSim();
break;
case kSimulatedAndReconstructed:
AliAOD * trackEvent = aodrec, *partEvent = aodsim;
AliAOD* trackEvent1 = new AliAOD();
AliAOD* partEvent1 = new AliAOD();
- partEvent1->SetOwner(kTRUE);
- trackEvent1->SetOwner(kTRUE);
AliAOD * trackEvent2,*partEvent2;
if ( !partEvent || !trackEvent )
{
- Error("ProcessRecAndSim","Can not get event");
+ Error("ProcessRecAndSim","<<%s>> Can not get event",GetName());
return 1;
}
/****** filling numerators ********/
/***************************************/
if ( (j%fDisplayMixingInfo) == 0)
- Info("ProcessTracksAndParticles",
+ Info("ProcessRecAndSim",
"Mixing particle %d with particles from the same event",j);
part1= partEvent->GetParticle(j);
track1= trackEvent->GetParticle(j);
-
+
Bool_t firstcut = (this->*fkPass1)(part1,track1);
if (fBufferSize != 0)
if ( (firstcut == kFALSE) || ( (this->*fkPass2)(part1,track1) == kFALSE ) )
//accepted by any cut
// we have to copy because reader keeps only one event
- partEvent1->AddParticle(new AliAODParticle(*part1));
- trackEvent1->AddParticle(new AliAODParticle(*track1));
+ partEvent1->AddParticle(part1);
+ trackEvent1->AddParticle(track1);
}
if (firstcut) continue;
m++;
if ( (j%fDisplayMixingInfo) == 0)
- Info("ProcessTracksAndParticles",
+ Info("ProcessRecAndSim",
"Mixing particle %d from current event with particles from event %d",j,-m);
for(Int_t l = 0; l<partEvent2->GetNumberOfParticles();l++) // ... on all particles
AliAOD* partEvent = aodsim;
AliAOD* partEvent1 = new AliAOD();
- partEvent1->SetOwner(kTRUE);
AliAOD* partEvent2;
register UInt_t ii;
-
-
if ( !partEvent )
{
- Error("ProcessRecAndSim","Can not get event");
+ Error("ProcessSim","Can not get event");
return 1;
}
for (Int_t j = 0; j<partEvent->GetNumberOfParticles() ; j++)
{
- /***************************************/
- /****** Looping same events ********/
- /****** filling numerators ********/
- /***************************************/
- if ( (j%fDisplayMixingInfo) == 0)
- Info("ProcessTracksAndParticles",
- "Mixing particle %d with particles from the same event",j);
+ /***************************************/
+ /****** Looping same events ********/
+ /****** filling numerators ********/
+ /***************************************/
+ if ( (j%fDisplayMixingInfo) == 0)
+ Info("ProcessSim",
+ "Mixing particle %d with particles from the same event",j);
- part1= partEvent->GetParticle(j);
+ part1= partEvent->GetParticle(j);
- Bool_t firstcut = fPairCut->GetFirstPartCut()->Pass(part1);
+ Bool_t firstcut = fPairCut->GetFirstPartCut()->Rejected(part1);
- if (fBufferSize != 0)
- if ( (firstcut == kFALSE) || ( fPairCut->GetSecondPartCut()->Pass(part1) == kFALSE ) )
- {
- //accepted by any cut
- // we have to copy because reader keeps only one event
+ if (fBufferSize != 0)
+ if ( (firstcut == kFALSE) || ( fPairCut->GetSecondPartCut()->Rejected(part1) == kFALSE ) )
+ {
+ //accepted by any cut
+ // we have to copy because reader keeps only one event
- partEvent1->AddParticle(new AliAODParticle(*part1));
- }
+ partEvent1->AddParticle(part1);
+ }
- if (firstcut) continue;
+ if (firstcut) continue;
- for(ii = 0; ii<fNParticleMonitorFunctions; ii++)
- fParticleMonitorFunctions[ii]->Process(part1);
+ for(ii = 0; ii<fNParticleMonitorFunctions; ii++)
+ fParticleMonitorFunctions[ii]->Process(part1);
- if ( fNParticleFunctions == 0 ) continue;
+ if ( fNParticleFunctions == 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);
+ for (Int_t k =j+1; k < partEvent->GetNumberOfParticles() ; k++)
+ {
+ part2= partEvent->GetParticle(k);
+ if (part1->GetUID() == part2->GetUID()) continue;
+ partpair->SetParticles(part1,part2);
+
+ if(fPairCut->Rejected(partpair)) //check pair cut
+ { //do not meets crietria of the
+ if( fPairCut->Rejected((AliHBTPair*)partpair->GetSwappedPair()) ) continue;
+ else tmppartpair = (AliHBTPair*)partpair->GetSwappedPair();
+ }
+ else
+ {
+ tmppartpair = partpair;
+ }
- if(fPairCut->Pass(partpair)) //check pair cut
- { //do not meets crietria of the
- if( fPairCut->Pass((AliHBTPair*)partpair->GetSwappedPair()) ) continue;
- else tmppartpair = (AliHBTPair*)partpair->GetSwappedPair();
- }
- else
- {
- tmppartpair = partpair;
- }
+ for(ii = 0;ii<fNParticleFunctions;ii++)
+ fParticleFunctions[ii]->ProcessSameEventParticles(tmppartpair);
- for(ii = 0;ii<fNParticleFunctions;ii++)
- fParticleFunctions[ii]->ProcessSameEventParticles(tmppartpair);
+ //end of 2nd loop over particles from the same event
+ }//for (Int_t k =j+1; k < partEvent->GetNumberOfParticles() ; k++)
- //end of 2nd loop over particles from the same event
- }//for (Int_t k =j+1; k < partEvent->GetNumberOfParticles() ; k++)
+ /***************************************/
+ /***** Filling denominators *********/
+ /***************************************/
+ if (fBufferSize == 0) continue;
- /***************************************/
- /***** Filling denominators *********/
- /***************************************/
- if (fBufferSize == 0) continue;
+ fPartBuffer->ResetIter();
+ Int_t m = 0;
+ while (( partEvent2 = fPartBuffer->Next() ))
+ {
+ m++;
+ if ( (j%fDisplayMixingInfo) == 0)
+ Info("ProcessSim",
+ "Mixing particle %d from current event with particles from event %d",j,-m);
+ for(Int_t l = 0; l<partEvent2->GetNumberOfParticles();l++) // ... on all particles
+ {
- fPartBuffer->ResetIter();
- Int_t m = 0;
- while (( partEvent2 = fPartBuffer->Next() ))
- {
- m++;
- if ( (j%fDisplayMixingInfo) == 0)
- Info("ProcessParticles",
- "Mixing particle %d from current event with particles from event %d",j,-m);
- for(Int_t l = 0; l<partEvent2->GetNumberOfParticles();l++) // ... on all particles
- {
-
- part2= partEvent2->GetParticle(l);
- partpair->SetParticles(part1,part2);
-
- if( fPairCut->Pass(partpair) ) //check pair cut
- { //do not meets crietria of the
- if( fPairCut->Pass((AliHBTPair*)partpair->GetSwappedPair()) )
- continue;
- else
- {
- tmppartpair = (AliHBTPair*)partpair->GetSwappedPair();
- }
- }
- else
- {//meets criteria of the pair cut
- tmppartpair = partpair;
- }
-
- for(ii = 0;ii<fNParticleFunctions;ii++)
- fParticleFunctions[ii]->ProcessDiffEventParticles(tmppartpair);
-
- }//for(Int_t l = 0; l<N2;l++) // ... on all particles
- }
- }
+ part2= partEvent2->GetParticle(l);
+ partpair->SetParticles(part1,part2);
+
+ if( fPairCut->Rejected(partpair) ) //check pair cut
+ { //do not meets crietria of the
+ if( fPairCut->Rejected((AliHBTPair*)partpair->GetSwappedPair()) )
+ continue;
+ else
+ {
+ tmppartpair = (AliHBTPair*)partpair->GetSwappedPair();
+ }
+ }
+ else
+ {//meets criteria of the pair cut
+ tmppartpair = partpair;
+ }
+
+ for(ii = 0;ii<fNParticleFunctions;ii++)
+ fParticleFunctions[ii]->ProcessDiffEventParticles(tmppartpair);
+
+ }//for(Int_t l = 0; l<N2;l++) // ... on all particles
+ }
+ }
+
+
delete fPartBuffer->Push(partEvent1);
//end of loop over events
return 0;
AliAOD* trackEvent = aodrec;
AliAOD* trackEvent1 = new AliAOD();
- trackEvent1->SetOwner(kTRUE);
AliAOD* trackEvent2;
AliHBTPair * tmptrackpair;
register UInt_t ii;
-
if ( !trackEvent )
{
/****** filling numerators ********/
/***************************************/
if ( (j%fDisplayMixingInfo) == 0)
- Info("ProcessTracksAndParticles",
+ Info("ProcessRec",
"Mixing Particle %d with Particles from the same event",j);
track1= trackEvent->GetParticle(j);
- Bool_t firstcut = fPairCut->GetFirstPartCut()->Pass(track1);
+ Bool_t firstcut = fPairCut->GetFirstPartCut()->Rejected(track1);
if (fBufferSize != 0)
- if ( (firstcut == kFALSE) || ( fPairCut->GetSecondPartCut()->Pass(track1) == kFALSE ) )
+ if ( (firstcut == kFALSE) || ( fPairCut->GetSecondPartCut()->Rejected(track1) == kFALSE ) )
{
//accepted by any cut
// we have to copy because reader keeps only one event
- trackEvent1->AddParticle(new AliAODParticle(*track1));
+ trackEvent1->AddParticle(track1);
}
if (firstcut) continue;
for(ii = 0; ii<fNParticleMonitorFunctions; ii++)
fParticleMonitorFunctions[ii]->Process(track1);
- if ( fNParticleFunctions == 0 ) continue;
+ if ( fNTrackFunctions == 0 ) continue;
for (Int_t k =j+1; k < trackEvent->GetNumberOfParticles() ; k++)
{
if (track1->GetUID() == track2->GetUID()) continue;
trackpair->SetParticles(track1,track2);
- if(fPairCut->Pass(trackpair)) //check pair cut
+ if(fPairCut->Rejected(trackpair)) //check pair cut
{ //do not meets crietria of the
- if( fPairCut->Pass((AliHBTPair*)trackpair->GetSwappedPair()) ) continue;
+ if( fPairCut->Rejected((AliHBTPair*)trackpair->GetSwappedPair()) ) continue;
else tmptrackpair = (AliHBTPair*)trackpair->GetSwappedPair();
}
else
}
for(ii = 0;ii<fNTrackFunctions;ii++)
- fParticleFunctions[ii]->ProcessSameEventParticles(tmptrackpair);
+ fTrackFunctions[ii]->ProcessSameEventParticles(tmptrackpair);
//end of 2nd loop over Particles from the same event
}//for (Int_t k =j+1; k < trackEvent->GetNumberOfParticles() ; k++)
if (fBufferSize == 0) continue;
fTrackBuffer->ResetIter();
- Int_t m = 0;
- while (( trackEvent2 = fTrackBuffer->Next() ))
+ Int_t m = 0;
+ while (( trackEvent2 = fTrackBuffer->Next() ))
+ {
+ m++;
+ if ( (j%fDisplayMixingInfo) == 0)
+ Info("ProcessRec",
+ "Mixing Particle %d from current event with Particles from event %d",j,-m);
+ for(Int_t l = 0; l<trackEvent2->GetNumberOfParticles();l++) // ... on all Particles
{
- m++;
- if ( (j%fDisplayMixingInfo) == 0)
- Info("ProcessParticles",
- "Mixing Particle %d from current event with Particles from event %d",j,-m);
- for(Int_t l = 0; l<trackEvent2->GetNumberOfParticles();l++) // ... on all Particles
- {
-
- track2= trackEvent2->GetParticle(l);
- trackpair->SetParticles(track1,track2);
-
- if( fPairCut->Pass(trackpair) ) //check pair cut
- { //do not meets crietria of the
- if( fPairCut->Pass((AliHBTPair*)trackpair->GetSwappedPair()) )
- continue;
- else
- {
- tmptrackpair = (AliHBTPair*)trackpair->GetSwappedPair();
- }
- }
- else
- {//meets criteria of the pair cut
- tmptrackpair = trackpair;
+
+ track2= trackEvent2->GetParticle(l);
+ trackpair->SetParticles(track1,track2);
+
+ if( fPairCut->Rejected(trackpair) ) //check pair cut
+ { //do not meets crietria of the
+ if( fPairCut->Rejected((AliHBTPair*)trackpair->GetSwappedPair()) )
+ continue;
+ else
+ {
+ tmptrackpair = (AliHBTPair*)trackpair->GetSwappedPair();
}
-
- for(ii = 0;ii<fNTrackFunctions;ii++)
- fTrackFunctions[ii]->ProcessDiffEventParticles(tmptrackpair);
-
- }//for(Int_t l = 0; l<N2;l++) // ... on all Particles
- }
- }
+ }
+ else
+ {//meets criteria of the pair cut
+ tmptrackpair = trackpair;
+ }
+
+ for(ii = 0;ii<fNTrackFunctions;ii++)
+ fTrackFunctions[ii]->ProcessDiffEventParticles(tmptrackpair);
+
+ }//for(Int_t l = 0; l<N2;l++) // ... on all Particles
+ }
+ }
delete fTrackBuffer->Push(trackEvent1);
//end of loop over events
return 0;
static AliAOD aodsim1;
AliAOD * trackEvent1=&aodrec1,*partEvent1=&aodsim1;//Particle that passes first particle cut, this event
+ trackEvent1->Reset();
+ partEvent1->Reset();
AliAOD * trackEvent2=0x0,*partEvent2=0x0;//Particle that passes second particle cut, this event
AliAOD * trackEvent3=0x0,*partEvent3=0x0;//Particle that passes second particle cut, events from buffer
register UInt_t ii;
-
- trackEvent1 = new AliAOD();
- partEvent1 = new AliAOD();
- trackEvent1->SetOwner(kFALSE);
- partEvent1->SetOwner(kFALSE);;
-
/********************************/
/* Filtering out */
/********************************/
{
partEvent2 = new AliAOD();
trackEvent2 = new AliAOD();
- partEvent2->SetOwner(kTRUE);
- trackEvent2->SetOwner(kTRUE);
}
FilterOut(partEvent1, partEvent2, rawpartEvent, trackEvent1, trackEvent2, rawtrackEvent);
}
}
- if ( fBufferSize == 0) continue;//do not mix diff histograms
- /***************************************/
- /***** Filling denominators *********/
- /***************************************/
- fPartBuffer->ResetIter();
- fTrackBuffer->ResetIter();
+ if ( fBufferSize == 0) continue;//do not mix diff histograms
+ /***************************************/
+ /***** Filling denominators *********/
+ /***************************************/
+ fPartBuffer->ResetIter();
+ fTrackBuffer->ResetIter();
- Int_t nmonitor = 0;
+ Int_t nmonitor = 0;
- while ( (partEvent3 = fPartBuffer->Next() ) != 0x0)
- {
- trackEvent3 = fTrackBuffer->Next();
+ while ( (partEvent3 = fPartBuffer->Next() ) != 0x0)
+ {
+ trackEvent3 = fTrackBuffer->Next();
- if ( (j%fDisplayMixingInfo) == 0)
- Info("ProcessTracksAndParticlesNonIdentAnal",
- "Mixing particle %d from current event with particles from event%d",j,-(++nmonitor));
+ if ( (j%fDisplayMixingInfo) == 0)
+ Info("ProcessTracksAndParticlesNonIdentAnal",
+ "Mixing particle %d from current event with particles from event%d",j,-(++nmonitor));
- for (Int_t k = 0; k < partEvent3->GetNumberOfParticles() ; k++)
- {
- part2= partEvent3->GetParticle(k);
- partpair->SetParticles(part1,part2);
+ for (Int_t k = 0; k < partEvent3->GetNumberOfParticles() ; k++)
+ {
+ part2= partEvent3->GetParticle(k);
+ partpair->SetParticles(part1,part2);
- track2= trackEvent3->GetParticle(k);
- trackpair->SetParticles(track1,track2);
+ track2= trackEvent3->GetParticle(k);
+ trackpair->SetParticles(track1,track2);
- if( (this->*fkPassPairProp)(partpair,trackpair) ) //check pair cut
- { //do not meets crietria of the pair cut
- continue;
- }
- else
- {//meets criteria of the pair cut
- UInt_t ii;
- for(ii = 0;ii<fNParticleFunctions;ii++)
- fParticleFunctions[ii]->ProcessDiffEventParticles(partpair);
+ if( (this->*fkPassPairProp)(partpair,trackpair) ) //check pair cut
+ { //do not meets crietria of the pair cut
+ continue;
+ }
+ else
+ {//meets criteria of the pair cut
+ UInt_t ii;
+ for(ii = 0;ii<fNParticleFunctions;ii++)
+ fParticleFunctions[ii]->ProcessDiffEventParticles(partpair);
- for(ii = 0;ii<fNTrackFunctions;ii++)
- fTrackFunctions[ii]->ProcessDiffEventParticles(trackpair);
+ for(ii = 0;ii<fNTrackFunctions;ii++)
+ fTrackFunctions[ii]->ProcessDiffEventParticles(trackpair);
- for(ii = 0;ii<fNParticleAndTrackFunctions;ii++)
- fParticleAndTrackFunctions[ii]->ProcessDiffEventParticles(trackpair,partpair);
- }
- }// for particles event2
- }//while event2
+ for(ii = 0;ii<fNParticleAndTrackFunctions;ii++)
+ fParticleAndTrackFunctions[ii]->ProcessDiffEventParticles(trackpair,partpair);
+ }
+ }// for particles event2
+ }//while event2
}//for over particles in event1
delete fPartBuffer->Push(partEvent2);
static AliAOD aodsim1;
AliAOD* partEvent1=&aodsim1;//Particle that passes first particle cut, this event
+ partEvent1->Reset();
AliAOD* partEvent2=0x0;//Particle that passes second particle cut, this event
AliAOD* partEvent3=0x0;//Particle that passes second particle cut, events from buffer
register UInt_t ii;
-
- partEvent1 = new AliAOD();
- partEvent1->SetOwner(kFALSE);;
-
-
/********************************/
/* Filtering out */
/********************************/
if (partEvent2==0x0)//in case fBufferSize == 0 and pointers are created do not eneter
{
partEvent2 = new AliAOD();
- partEvent2->SetOwner(kTRUE);
}
FilterOut(partEvent1, partEvent2, rawpartEvent);
AliVAODParticle * track1, * track2;
static AliAOD aodrec1;
-
AliAOD * trackEvent1=&aodrec1;//Particle that passes first particle cut, this event
+ trackEvent1->Reset();
AliAOD * trackEvent2=0x0;//Particle that passes second particle cut, this event
AliAOD * trackEvent3=0x0;//Particle that passes second particle cut, events from buffer
-
AliAOD* rawtrackEvent = aodrec;//this we get from Reader
static AliHBTPair tpair;
register UInt_t ii;
- trackEvent1 = new AliAOD();
- trackEvent1->SetOwner(kFALSE);
-
/********************************/
/* Filtering out */
/********************************/
if ( trackEvent2==0x0 )//in case fBufferSize == 0 and pointers are created do not eneter
{
trackEvent2 = new AliAOD();
- trackEvent2->SetOwner(kTRUE);
}
FilterOut(trackEvent1, trackEvent2, rawtrackEvent);
{
//Calls Write for all defined functions in analysis
//== writes all results
+ TFile* oututfile = 0x0;
+ if (fOutputFileName)
+ {
+ oututfile = TFile::Open(*fOutputFileName,"update");
+ }
UInt_t ii;
for(ii = 0;ii<fNParticleFunctions;ii++)
{
}
fParticleAndTrackMonitorFunctions[ii]->Write();
}
+ delete oututfile;
+}
+/*************************************************************************************/
+
+void AliHBTAnalysis::SetOutputFileName(const char* fname)
+{
+ //Sets fiele name where to dump results,
+ //if not specified reults are written to gDirectory
+ if (fname == 0x0)
+ {
+ delete fOutputFileName;
+ fOutputFileName = 0x0;
+ return;
+ }
+ if ( strcmp(fname,"") == 0 )
+ {
+ delete fOutputFileName;
+ fOutputFileName = 0x0;
+ return;
+ }
+ if (fOutputFileName == 0x0) fOutputFileName = new TString(fname);
+ else *fOutputFileName = fname;
}
/*************************************************************************************/
if (in2)
{
- outpart2->AddParticle(new AliAODParticle(*part));
- outtrack2->AddParticle(new AliAODParticle(*track));
+ outpart2->AddParticle(part);
+ outtrack2->AddParticle(track);
continue;
}
}
in1 = in2 = kTRUE;
part = in->GetParticle(i);
- if ( cut1->Pass(part) ) in1 = kFALSE; //if part is rejected by cut1, in1 is false
- if ( cut2->Pass(part) ) in2 = kFALSE; //if part is rejected by cut2, in2 is false
+ if ( cut1->Rejected(part) ) in1 = kFALSE; //if part is rejected by cut1, in1 is false
+ if ( cut2->Rejected(part) ) in2 = kFALSE; //if part is rejected by cut2, in2 is false
if (gDebug)//to be removed in real analysis
if ( in1 && in2 ) //both cuts accepted, should never happen, just in case
}
/*************************************************************************************/
-void AliHBTAnalysis::SetCutsOnParticles()
-{
- // -- aplies only to Process("TracksAndParticles")
- // (ProcessTracksAndParticles and ProcessTracksAndParticlesNonIdentAnal)
- // Only particles properties are checkes against cuts
- fkPass = &AliHBTAnalysis::PassPart;
- fkPass1 = &AliHBTAnalysis::PassPart1;
- fkPass2 = &AliHBTAnalysis::PassPart2;
- fkPassPairProp = &AliHBTAnalysis::PassPairPropPart;
+void AliHBTAnalysis::SetApparentVertex(Double_t x, Double_t y, Double_t z)
+{
+ //Sets apparent vertex
+ // All events have to be moved to the same vertex position in order to
+ // to be able to comare any space positions (f.g. anti-merging)
+ // This method defines this position
-}
-/*************************************************************************************/
-
-void AliHBTAnalysis::SetCutsOnTracks()
-{
- // -- aplies only to Process("TracksAndParticles")
- // (ProcessTracksAndParticles and ProcessTracksAndParticlesNonIdentAnal)
- // Only tracks properties are checkes against cuts
- Info("SetCutsOnTracks","Only reconstructed particles will be checked");
- fkPass = &AliHBTAnalysis::PassTrack;
- fkPass1 = &AliHBTAnalysis::PassTrack1;
- fkPass2 = &AliHBTAnalysis::PassTrack2;
- fkPassPairProp = &AliHBTAnalysis::PassPairPropTrack;
-
-}
-/*************************************************************************************/
-
-void AliHBTAnalysis::SetCutsOnTracksAndParticles()
-{
- // -- aplies only to Process("TracksAndParticles")
- // (ProcessTracksAndParticles and ProcessTracksAndParticlesNonIdentAnal)
- // Both, tracks and particles, properties are checked against cuts
- fkPass = &AliHBTAnalysis::PassPartAndTrack;
- fkPass1 = &AliHBTAnalysis::PassPartAndTrack1;
- fkPass2 = &AliHBTAnalysis::PassPartAndTrack2;
- fkPassPairProp = &AliHBTAnalysis::PassPairPropPartAndTrack;
+ fVertexX = x;
+ fVertexY = y;
+ fVertexZ = z;
}
/*************************************************************************************/
}
}
-/*************************************************************************************/
-
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff