[u/mrichter/AliRoot.git] / ANALYSIS / AliAnalysis.cxx

#include "AliAnalysis.h"
//________________________________
///////////////////////////////////////////////////////////
//
// class AliAnalysis
//
// Base class for analysis.
// Each inheriting calss must define 3 methods:
//   - Init() : that is called before event processing
//   - ProcessEvent(AliESD*,AliStack*)
//   - 
// Piotr.Skowronski@cern.ch
//
///////////////////////////////////////////////////////////

#include "AliEventCut.h"
#include "AliAODPairCut.h"

ClassImp(AliAnalysis)

AliAnalysis::AliAnalysis():
 fEventCut(0x0),
 fCutOnSim(kTRUE),
 fCutOnRec(kTRUE),
 fPairCut(new AliAODPairEmptyCut()),//empty cut - accepts all particles
 fkPass(&AliAnalysis::PassPartAndTrack), //by default perform cut on both track and particle pair 
 fkPass1(&AliAnalysis::PassPartAndTrack1), //used onluy by ProcessTracksAndParticles
 fkPass2(&AliAnalysis::PassPartAndTrack2),
 fkPassPairProp(&AliAnalysis::PassPairPropPartAndTrack)
{
 //ctor
}
/*********************************************************/

AliAnalysis::AliAnalysis(const char* name,const char* title):
 TTask(name,title),
 fEventCut(0x0),
 fCutOnSim(kTRUE),
 fCutOnRec(kTRUE),
 fPairCut(new AliAODPairEmptyCut()),//empty cut - accepts all particles
 fkPass(&AliAnalysis::PassPartAndTrack), //by default perform cut on both track and particle pair 
 fkPass1(&AliAnalysis::PassPartAndTrack1), //used onluy by ProcessTracksAndParticles
 fkPass2(&AliAnalysis::PassPartAndTrack2),
 fkPassPairProp(&AliAnalysis::PassPairPropPartAndTrack)
{
 //ctor
}
/*********************************************************/
AliAnalysis::AliAnalysis(const AliAnalysis& ana):
 TTask(ana),
 fEventCut(ana.fEventCut),
 fCutOnSim(ana.fCutOnSim),
 fCutOnRec(ana.fCutOnRec),
 fPairCut(ana.fPairCut),
 fkPass(ana.fkPass),
 fkPass1(ana.fkPass1),
 fkPass2(ana.fkPass2),
 fkPassPairProp(ana.fkPassPairProp)
{
 //ctor
}
/*********************************************************/

AliAnalysis::~AliAnalysis()
{
 //dtor
 delete fEventCut;
}
/*********************************************************/

void AliAnalysis::SetEventCut(AliEventCut* evcut)
{
//Sets event -  makes a private copy
  delete fEventCut;
  if (evcut) fEventCut = (AliEventCut*)evcut->Clone();
  else fEventCut = 0x0;
}
/*********************************************************/

Bool_t AliAnalysis::Rejected(AliAOD* recevent, AliAOD* simevent)
{
  //checks the event cut
  if (fEventCut == 0x0) return kFALSE;
  
  if (fCutOnRec)
    if (fEventCut->Rejected(recevent)) return kTRUE;
    
  if (fCutOnSim)
    if (fEventCut->Rejected(simevent)) return kTRUE;
  
  return kFALSE;
}
/*************************************************************************************/ 

void AliAnalysis::SetPairCut(AliAODPairCut* cut)
{
//Sets new Pair Cut. Old one is deleted
//Note that it is created new object instead of simple pointer set
//I do not want to have pointer
//to object created somewhere else
//because in that case I could not believe that
//it would always exist (sb could delete it)
//so we have always own copy

 if(!cut)
   {
     Error("AliHBTFunction::SetPairCut","argument is NULL");
     return;
   }
 delete fPairCut;
 fPairCut = (AliAODPairCut*)cut->Clone();

}
/******************************************************************/

void AliAnalysis::SetCutsOnSim()
{
 // -- aplies only to Process("TracksAndParticles")
 // (ProcessTracksAndParticles and ProcessTracksAndParticlesNonIdentAnal)
 // Only particles properties are checkes against cuts
  
  fCutOnRec = kFALSE;
  fCutOnSim = kTRUE;
  
  fkPass = &AliAnalysis::PassPart;
  fkPass1 = &AliAnalysis::PassPart1;
  fkPass2 = &AliAnalysis::PassPart2;
  fkPassPairProp = &AliAnalysis::PassPairPropPart;
  
}
/*************************************************************************************/ 

void AliAnalysis::SetCutsOnRec()
{
 // -- aplies only to Process("TracksAndParticles")
 // (ProcessTracksAndParticles and ProcessTracksAndParticlesNonIdentAnal)
 // Only tracks properties are checkes against cuts
  
  fCutOnRec = kTRUE;
  fCutOnSim = kFALSE;
 
  fkPass = &AliAnalysis::PassTrack;
  fkPass1 = &AliAnalysis::PassTrack1;
  fkPass2 = &AliAnalysis::PassTrack2;
  fkPassPairProp = &AliAnalysis::PassPairPropTrack;
 
}
/*************************************************************************************/ 

void AliAnalysis::SetCutsOnRecAndSim()
{
 // -- aplies only to Process("TracksAndParticles")
 // (ProcessTracksAndParticles and ProcessTracksAndParticlesNonIdentAnal)
 // Both, tracks and particles, properties are checked against cuts

  fCutOnRec = kTRUE;
  fCutOnSim = kTRUE;

  fkPass = &AliAnalysis::PassPartAndTrack;
  fkPass1 = &AliAnalysis::PassPartAndTrack1;
  fkPass2 = &AliAnalysis::PassPartAndTrack2;
  fkPassPairProp = &AliAnalysis::PassPairPropPartAndTrack;
}
Commit	Line	Data
	1	#include "AliAnalysis.h"
	2	//________________________________
	3	///////////////////////////////////////////////////////////
	4	//
	5	// class AliAnalysis
	6	//
	7	// Base class for analysis.
	8	// Each inheriting calss must define 3 methods:
	9	// - Init() : that is called before event processing
	10	// - ProcessEvent(AliESD,AliStack)
	11	// -
	12	// Piotr.Skowronski@cern.ch
	13	//
	14	///////////////////////////////////////////////////////////
	15
	16	#include "AliEventCut.h"
	17	#include "AliAODPairCut.h"
	18
	19	ClassImp(AliAnalysis)
	20
	21	AliAnalysis::AliAnalysis():
	22	fEventCut(0x0),
	23	fCutOnSim(kTRUE),
	24	fCutOnRec(kTRUE),
	25	fPairCut(new AliAODPairEmptyCut()),//empty cut - accepts all particles
	26	fkPass(&AliAnalysis::PassPartAndTrack), //by default perform cut on both track and particle pair
	27	fkPass1(&AliAnalysis::PassPartAndTrack1), //used onluy by ProcessTracksAndParticles
	28	fkPass2(&AliAnalysis::PassPartAndTrack2),
	29	fkPassPairProp(&AliAnalysis::PassPairPropPartAndTrack)
	30	{
	31	//ctor
	32	}
	33	/*********************************************************/
	34
	35	AliAnalysis::AliAnalysis(const char* name,const char* title):
	36	TTask(name,title),
	37	fEventCut(0x0),
	38	fCutOnSim(kTRUE),
	39	fCutOnRec(kTRUE),
	40	fPairCut(new AliAODPairEmptyCut()),//empty cut - accepts all particles
	41	fkPass(&AliAnalysis::PassPartAndTrack), //by default perform cut on both track and particle pair
	42	fkPass1(&AliAnalysis::PassPartAndTrack1), //used onluy by ProcessTracksAndParticles
	43	fkPass2(&AliAnalysis::PassPartAndTrack2),
	44	fkPassPairProp(&AliAnalysis::PassPairPropPartAndTrack)
	45	{
	46	//ctor
	47	}
	48	/*********************************************************/
	49	AliAnalysis::AliAnalysis(const AliAnalysis& ana):
	50	TTask(ana),
	51	fEventCut(ana.fEventCut),
	52	fCutOnSim(ana.fCutOnSim),
	53	fCutOnRec(ana.fCutOnRec),
	54	fPairCut(ana.fPairCut),
	55	fkPass(ana.fkPass),
	56	fkPass1(ana.fkPass1),
	57	fkPass2(ana.fkPass2),
	58	fkPassPairProp(ana.fkPassPairProp)
	59	{
	60	//ctor
	61	}
	62	/*********************************************************/
	63
	64	AliAnalysis::~AliAnalysis()
	65	{
	66	//dtor
	67	delete fEventCut;
	68	}
	69	/*********************************************************/
	70
	71	void AliAnalysis::SetEventCut(AliEventCut* evcut)
	72	{
	73	//Sets event - makes a private copy
	74	delete fEventCut;
	75	if (evcut) fEventCut = (AliEventCut*)evcut->Clone();
	76	else fEventCut = 0x0;
	77	}
	78	/*********************************************************/
	79
	80	Bool_t AliAnalysis::Rejected(AliAOD* recevent, AliAOD* simevent)
	81	{
	82	//checks the event cut
	83	if (fEventCut == 0x0) return kFALSE;
	84
	85	if (fCutOnRec)
	86	if (fEventCut->Rejected(recevent)) return kTRUE;
	87
	88	if (fCutOnSim)
	89	if (fEventCut->Rejected(simevent)) return kTRUE;
	90
	91	return kFALSE;
	92	}
	93	/*************************************************************************************/
	94
	95	void AliAnalysis::SetPairCut(AliAODPairCut* cut)
	96	{
	97	//Sets new Pair Cut. Old one is deleted
	98	//Note that it is created new object instead of simple pointer set
	99	//I do not want to have pointer
	100	//to object created somewhere else
	101	//because in that case I could not believe that
	102	//it would always exist (sb could delete it)
	103	//so we have always own copy
	104
	105	if(!cut)
	106	{
	107	Error("AliHBTFunction::SetPairCut","argument is NULL");
	108	return;
	109	}
	110	delete fPairCut;
	111	fPairCut = (AliAODPairCut*)cut->Clone();
	112
	113	}
	114	/******************************************************************/
	115
	116	void AliAnalysis::SetCutsOnSim()
	117	{
	118	// -- aplies only to Process("TracksAndParticles")
	119	// (ProcessTracksAndParticles and ProcessTracksAndParticlesNonIdentAnal)
	120	// Only particles properties are checkes against cuts
	121
	122	fCutOnRec = kFALSE;
	123	fCutOnSim = kTRUE;
	124
	125	fkPass = &AliAnalysis::PassPart;
	126	fkPass1 = &AliAnalysis::PassPart1;
	127	fkPass2 = &AliAnalysis::PassPart2;
	128	fkPassPairProp = &AliAnalysis::PassPairPropPart;
	129
	130	}
	131	/*************************************************************************************/
	132
	133	void AliAnalysis::SetCutsOnRec()
	134	{
	135	// -- aplies only to Process("TracksAndParticles")
	136	// (ProcessTracksAndParticles and ProcessTracksAndParticlesNonIdentAnal)
	137	// Only tracks properties are checkes against cuts
	138
	139	fCutOnRec = kTRUE;
	140	fCutOnSim = kFALSE;
	141
	142	fkPass = &AliAnalysis::PassTrack;
	143	fkPass1 = &AliAnalysis::PassTrack1;
	144	fkPass2 = &AliAnalysis::PassTrack2;
	145	fkPassPairProp = &AliAnalysis::PassPairPropTrack;
	146
	147	}
	148	/*************************************************************************************/
	149
	150	void AliAnalysis::SetCutsOnRecAndSim()
	151	{
	152	// -- aplies only to Process("TracksAndParticles")
	153	// (ProcessTracksAndParticles and ProcessTracksAndParticlesNonIdentAnal)
	154	// Both, tracks and particles, properties are checked against cuts
	155
	156	fCutOnRec = kTRUE;
	157	fCutOnSim = kTRUE;
	158
	159	fkPass = &AliAnalysis::PassPartAndTrack;
	160	fkPass1 = &AliAnalysis::PassPartAndTrack1;
	161	fkPass2 = &AliAnalysis::PassPartAndTrack2;
	162	fkPassPairProp = &AliAnalysis::PassPairPropPartAndTrack;
	163	}