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

#include "AliAODPairCut.h"
/* $Id$ */

/////////////////////////////////////////////////////////////////////////
//
// Class AliAODPairCut:
// implements cut on the pair of particles
// more info: http://aliweb.cern.ch/people/skowron/analyzer/index.html
// Author: Piotr.Skowronski@cern.ch
//-------------------------------------------------------------------

#include "AliAODPair.h"
#include "AliAODParticleCut.h"
//#include "AliTrackPoints.h"
//#include "AliClusterMap.h"

ClassImp(AliAODPairCut)
const Int_t AliAODPairCut::fgkMaxCuts = 50;
/**********************************************************/

AliAODPairCut::AliAODPairCut():
  fFirstPartCut(new AliAODParticleEmptyCut()), //empty cuts
  fSecondPartCut(new AliAODParticleEmptyCut()), //empty cuts
  fCuts(new AliAODPairBaseCut*[fgkMaxCuts]),
  fNCuts(0)
{
  //constructor
    
  for (Int_t i = 0;i<fNCuts;i++)
   {
     fCuts[i] = 0x0;
   }
}
/**********************************************************/

AliAODPairCut::AliAODPairCut(const AliAODPairCut& in):
  TNamed(in),
  fFirstPartCut((AliAODParticleCut*)in.fFirstPartCut->Clone()),
  fSecondPartCut((AliAODParticleCut*)in.fSecondPartCut->Clone()),
  fCuts(new AliAODPairBaseCut*[fgkMaxCuts]),
  fNCuts(in.fNCuts)
{
  //copy constructor

 
  for (Int_t i = 0;i<fNCuts;i++)
    {
      fCuts[i] = (AliAODPairBaseCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
    }
}
/**********************************************************/

AliAODPairCut&  AliAODPairCut::operator=(const AliAODPairCut& in)
{
  //assignment operator
  fCuts = new AliAODPairBaseCut*[fgkMaxCuts];
  fNCuts = in.fNCuts;

  fFirstPartCut = (AliAODParticleCut*)in.fFirstPartCut->Clone();
  fSecondPartCut = (AliAODParticleCut*)in.fSecondPartCut->Clone();
 
  for (Int_t i = 0;i<fNCuts;i++)
    {
      fCuts[i] = (AliAODPairBaseCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
    }
  return * this;
}
/**********************************************************/

AliAODPairCut::~AliAODPairCut()
{
  //destructor
  if (fFirstPartCut != fSecondPartCut)
    {
      delete fSecondPartCut;
    }
  delete fFirstPartCut;
  for (Int_t i = 0;i<fNCuts;i++)
    {
      delete fCuts[i];
    }
  delete []fCuts;
} 
/**********************************************************/

/**********************************************************/

void AliAODPairCut::AddBasePairCut(AliAODPairBaseCut* basecut)
{
  //adds the base pair cut (cut on one value)
  
  if (!basecut) return;
  if( fNCuts == (fgkMaxCuts-1) )
    {
      Warning("AddBasePairCut","Not enough place for another cut");
      return;
    }
  fCuts[fNCuts++]=basecut;
}
/**********************************************************/

Bool_t AliAODPairCut::Rejected(AliAODPair* pair) const
{
  //methods which checks if given pair meets all criteria of the cut
  //if it meets returns FALSE
  //if NOT   returns    TRUE
  if(!pair) 
    {
      Warning("Pass","No Pasaran! We never accept NULL pointers");
      return kTRUE;
    }
  
  //check particle's cuts
  if( ( fFirstPartCut->Rejected( pair->Particle1()) ) || 
      ( fSecondPartCut->Rejected(pair->Particle2()) )   )
    {  
      return kTRUE;
    }
  return PassPairProp(pair);
}
/**********************************************************/

Bool_t AliAODPairCut::PassPairProp(AliAODPair* pair) const
{
  //methods which checks if given pair meets all criteria of the cut
  //if it meets returns FALSE
  //if NOT   returns    TRUE
  //examine all base pair cuts
  for (Int_t i = 0;i<fNCuts;i++)
    {
      if ( (fCuts[i]->Rejected(pair)) ) return kTRUE; //if one of the cuts reject, then reject
    }
  return kFALSE;
}
/**********************************************************/

void AliAODPairCut::Print()
{
 //Prints the cut
  for (Int_t i = 0;i<fNCuts;i++)
    {
      fCuts[i]->Dump();
    }
}
/**********************************************************/

void AliAODPairCut::SetFirstPartCut(AliAODParticleCut* cut)
{
  // set cut for the first particle
  if(!cut) 
    {
      Error("SetFirstPartCut","argument is NULL");
      return;
    }
  delete fFirstPartCut;
  fFirstPartCut = (AliAODParticleCut*)cut->Clone();
  
}
/**********************************************************/

void AliAODPairCut::SetSecondPartCut(AliAODParticleCut* cut)
{
  // set cut for the second particle
  if(!cut) 
    {
      Error("SetSecondPartCut","argument is NULL");
      return;
    }
  delete fSecondPartCut;
  fSecondPartCut = (AliAODParticleCut*)cut->Clone();
}
/**********************************************************/

void AliAODPairCut::SetPartCut(AliAODParticleCut* cut)
{
  //sets the the same cut on both particles
  if(!cut) 
    {
      Error("SetFirstPartCut","argument is NULL");
      return;
    }
  if (fFirstPartCut == fSecondPartCut) fSecondPartCut = 0x0;
  
  delete fFirstPartCut;
  fFirstPartCut = (AliAODParticleCut*)cut->Clone();
  
  delete fSecondPartCut; //even if null should not be harmful
  fSecondPartCut = fFirstPartCut;
}
/**********************************************************/

void AliAODPairCut::SetQInvRange(Double_t min, Double_t max)
{
  // set range of accepted invariant masses
  AliAODQInvCut* cut= (AliAODQInvCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropQInv);
  if(cut) cut->SetRange(min,max);
  else fCuts[fNCuts++] = new AliAODQInvCut(min,max);
}
/**********************************************************/

void AliAODPairCut::SetQOutLCMSRange(Double_t min, Double_t max)
{
  // set range of accepted QOut in CMS
  AliAODQOutLCMSCut* cut= (AliAODQOutLCMSCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropQOutLCMS);
  if(cut) cut->SetRange(min,max);
  else fCuts[fNCuts++] = new AliAODQOutLCMSCut(min,max);
}
/**********************************************************/

void AliAODPairCut::SetQSideLCMSRange(Double_t min, Double_t max)
{
  // set range of accepted QSide in CMS
  AliAODQSideLCMSCut* cut= (AliAODQSideLCMSCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropQSideLCMS);
  if(cut) cut->SetRange(min,max);
  else fCuts[fNCuts++] = new AliAODQSideLCMSCut(min,max);
}

/**********************************************************/

void AliAODPairCut::SetQLongLCMSRange(Double_t min, Double_t max)
{
  // set range of accepted QLong in CMS
  AliAODQLongLCMSCut* cut= (AliAODQLongLCMSCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropQLongLCMS);
  if(cut) cut->SetRange(min,max);
  else fCuts[fNCuts++] = new AliAODQLongLCMSCut(min,max);
}
/**********************************************************/

void AliAODPairCut::SetDeltaERange(Double_t min, Double_t max)
{
  // set range of accepted DeltaE
  AliAODKtCut* cut= (AliAODKtCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropDeltaE);
  if(cut) cut->SetRange(min,max);
  else fCuts[fNCuts++] = new AliAODDeltaECut(min,max);
}
/**********************************************************/

void AliAODPairCut::SetDeltaPRange(Double_t min, Double_t max)
{
  // set range of accepted DeltaP
  AliAODKtCut* cut= (AliAODKtCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropDeltaP);
  if(cut) cut->SetRange(min,max);
  else fCuts[fNCuts++] = new AliAODDeltaPCut(min,max);
}
/**********************************************************/

void AliAODPairCut::SetKtRange(Double_t min, Double_t max)
{
  // set range of accepted Kt (avarage transverse pair momentum)
  AliAODKtCut* cut= (AliAODKtCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropKt);
  if(cut) cut->SetRange(min,max);
  else fCuts[fNCuts++] = new AliAODKtCut(min,max);
}
/**********************************************************/

void AliAODPairCut::SetKStarRange(Double_t min, Double_t max)
{
  // set range of accepted KStar (invariant pair momentum difference (fourvector))
  AliAODKStarCut* cut= (AliAODKStarCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropKStar);
  if(cut) cut->SetRange(min,max);
  else fCuts[fNCuts++] = new AliAODKStarCut(min,max);
}
/**********************************************************/

void AliAODPairCut::SetKStarOutRange(Double_t min, Double_t max)
{
  // set range of accepted KStar (invariant pair momentum difference (fourvector))
  AliAODKStarOutCut* cut= (AliAODKStarOutCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropKStarOut);
  if(cut) cut->SetRange(min,max);
  else fCuts[fNCuts++] = new AliAODKStarOutCut(min,max);
}
/**********************************************************/

void AliAODPairCut::SetKStarSideRange(Double_t min, Double_t max)
{
  // set range of accepted KStar (invariant pair momentum difference (fourvector))
  AliAODKStarSideCut* cut= (AliAODKStarSideCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropKStarSide);
  if(cut) cut->SetRange(min,max);
  else fCuts[fNCuts++] = new AliAODKStarSideCut(min,max);
}
/**********************************************************/

void AliAODPairCut::SetKStarLongRange(Double_t min, Double_t max)
{
  // set range of accepted KStar (invariant pair momentum difference (fourvector))
  AliAODKStarLongCut* cut= (AliAODKStarLongCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropKStarLong);
  if(cut) cut->SetRange(min,max);
  else fCuts[fNCuts++] = new AliAODKStarLongCut(min,max);
}
/**********************************************************/

void AliAODPairCut::SetAvSeparationRange(Double_t min, Double_t max)
{
  //sets avarage separation cut ->Anti-Merging cut
  AliAODPairBaseCut* cut= FindCut(AliAODPairBaseCut::kHbtPairCutPropAvSepar);
  if(cut) cut->SetRange(min,max);
  else fCuts[fNCuts++] = new AliAODAvSeparationCut(min,max);
}
/**********************************************************/

void AliAODPairCut::SetITSSeparation(Int_t layer, Double_t drphi, Double_t dz)
{
  //Anti-Merging Cut for first pixel layer
  AliAODITSSeparationCut* cut= dynamic_cast<AliAODITSSeparationCut*>(FindCut(AliAODPairBaseCut::kHbtPairCutPropPixelSepar));
  if(cut) 
   {
     if (layer == cut->GetLayer())
      {
        cut->SetRange(drphi,dz);//In this cut fMin is drphi, and fMax dz
        return;
      }
   }
  fCuts[fNCuts++] = new AliAODITSSeparationCut(layer,drphi,dz);
//  Info("SetITSSeparation","Added %d at address %#x",fNCuts-1,fCuts[fNCuts-1]);
}
/**********************************************************/

void AliAODPairCut::SetClusterOverlapRange(Double_t min,Double_t max)
{
  //sets cluster overlap factor cut ->Anti-Splitting cut
  //cluster overlap factor ranges between 
  // -0.5 (in all padrows both tracks have cluters) 
  // and 1 (in all padrows one track has cluter and second has not)
  // When Overlap Factor is 1 this pair of tracks in highly probable to be
  // splitted track: one particle that is recontructed twise
  // STAR uses range from -0.5 to 0.6 
  
  AliAODPairBaseCut* cut= FindCut(AliAODPairBaseCut::kHbtPairCutPropClOverlap);
  if(cut) cut->SetRange(min,max);
  else fCuts[fNCuts++] = new AliAODCluterOverlapCut(min,max);
}
/**********************************************************/

AliAODPairBaseCut* AliAODPairCut::FindCut(AliAODPairBaseCut::EAODPairCutProperty property)
{
  // Find the cut corresponding to "property"
  for (Int_t i = 0;i<fNCuts;i++)
    {
      if (fCuts[i]->GetProperty() == property) 
	return fCuts[i]; //we found the cut we were searching for
    }
  
  return 0x0; //we did not found this cut
  
}
/**********************************************************/

void AliAODPairCut::Streamer(TBuffer &b)
{
  // Stream all objects in the array to or from the I/O buffer.
  
  UInt_t R__s, R__c;
  if (b.IsReading()) 
    {
      Version_t v = b.ReadVersion(&R__s, &R__c);
      if (v > -1)
       {
          delete fFirstPartCut;
          delete fSecondPartCut;
          fFirstPartCut = 0x0;
          fSecondPartCut = 0x0;
          TObject::Streamer(b);
          b >> fFirstPartCut;
          b >> fSecondPartCut;
          b >> fNCuts;
          for (Int_t i = 0;i<fNCuts;i++)
           {
             b >> fCuts[i];
           }
        }
      b.CheckByteCount(R__s, R__c,AliAODPairCut::IsA());
    } 
  else 
    {
      R__c = b.WriteVersion(AliAODPairCut::IsA(), kTRUE);
      TObject::Streamer(b);
      
//      printf("Streamer Cut 1 %#x Cut 2 %#x\n",fFirstPartCut,fSecondPartCut);
//      this->Dump();
//      fFirstPartCut->Dump();
      
      b << fFirstPartCut;
      b << fSecondPartCut;
      b << fNCuts;
      for (Int_t i = 0;i<fNCuts;i++)
        {
          b << fCuts[i];
        }
      b.SetByteCount(R__c, kTRUE);
    }
}
/******************************************************************/

ClassImp(AliAODPairEmptyCut)
  
void AliAODPairEmptyCut::Streamer(TBuffer &b)
{
//streamer for empty pair cut
  AliAODPairCut::Streamer(b);
}
/******************************************************************/
Commit	Line	Data
073745bc	1	#include "AliAODPairCut.h"
78d7c6d3	2	/* $Id$ */
0206ddfb	3
78d7c6d3	4	/////////////////////////////////////////////////////////////////////////
	5	//
	6	// Class AliAODPairCut:
78d7c6d3	7	// implements cut on the pair of particles
c7ffd78f	8	// more info: http://aliweb.cern.ch/people/skowron/analyzer/index.html
78d7c6d3	9	// Author: Piotr.Skowronski@cern.ch
78d7c6d3	10	//-------------------------------------------------------------------
0206ddfb	11
78d7c6d3	12	#include "AliAODPair.h"
78d7c6d3	13	#include "AliAODParticleCut.h"
0206ddfb	14	//#include "AliTrackPoints.h"
0206ddfb	15	//#include "AliClusterMap.h"
78d7c6d3	16
	17	ClassImp(AliAODPairCut)
	18	const Int_t AliAODPairCut::fgkMaxCuts = 50;
	19	/**********************************************************/
	20
	21	AliAODPairCut::AliAODPairCut():
af250cbf	22	fFirstPartCut(new AliAODParticleEmptyCut()), //empty cuts
	23	fSecondPartCut(new AliAODParticleEmptyCut()), //empty cuts
	24	fCuts(new AliAODPairBaseCut*[fgkMaxCuts]),
78d7c6d3	25	fNCuts(0)
	26	{
	27	//constructor
78d7c6d3	28
78d7c6d3	29	for (Int_t i = 0;i<fNCuts;i++)
	30	{
	31	fCuts[i] = 0x0;
	32	}
	33	}
	34	/**********************************************************/
	35
	36	AliAODPairCut::AliAODPairCut(const AliAODPairCut& in):
af250cbf	37	TNamed(in),
	38	fFirstPartCut((AliAODParticleCut*)in.fFirstPartCut->Clone()),
	39	fSecondPartCut((AliAODParticleCut*)in.fSecondPartCut->Clone()),
	40	fCuts(new AliAODPairBaseCut*[fgkMaxCuts]),
	41	fNCuts(in.fNCuts)
78d7c6d3	42	{
78d7c6d3	43	//copy constructor
78d7c6d3	44
78d7c6d3	45
	46	for (Int_t i = 0;i<fNCuts;i++)
	47	{
b4fb427e	48	fCuts[i] = (AliAODPairBaseCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
78d7c6d3	49	}
	50	}
	51	/**********************************************************/
	52
	53	AliAODPairCut& AliAODPairCut::operator=(const AliAODPairCut& in)
	54	{
	55	//assignment operator
b4fb427e	56	fCuts = new AliAODPairBaseCut*[fgkMaxCuts];
78d7c6d3	57	fNCuts = in.fNCuts;
	58
	59	fFirstPartCut = (AliAODParticleCut*)in.fFirstPartCut->Clone();
	60	fSecondPartCut = (AliAODParticleCut*)in.fSecondPartCut->Clone();
	61
	62	for (Int_t i = 0;i<fNCuts;i++)
	63	{
b4fb427e	64	fCuts[i] = (AliAODPairBaseCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
78d7c6d3	65	}
	66	return * this;
	67	}
	68	/**********************************************************/
	69
	70	AliAODPairCut::~AliAODPairCut()
	71	{
	72	//destructor
	73	if (fFirstPartCut != fSecondPartCut)
	74	{
	75	delete fSecondPartCut;
	76	}
	77	delete fFirstPartCut;
	78	for (Int_t i = 0;i<fNCuts;i++)
	79	{
	80	delete fCuts[i];
	81	}
	82	delete []fCuts;
	83	}
	84	/**********************************************************/
	85
	86	/**********************************************************/
	87
b4fb427e	88	void AliAODPairCut::AddBasePairCut(AliAODPairBaseCut* basecut)
78d7c6d3	89	{
	90	//adds the base pair cut (cut on one value)
	91
	92	if (!basecut) return;
	93	if( fNCuts == (fgkMaxCuts-1) )
	94	{
	95	Warning("AddBasePairCut","Not enough place for another cut");
	96	return;
	97	}
	98	fCuts[fNCuts++]=basecut;
	99	}
	100	/**********************************************************/
	101
cea0a066	102	Bool_t AliAODPairCut::Rejected(AliAODPair* pair) const
78d7c6d3	103	{
	104	//methods which checks if given pair meets all criteria of the cut
	105	//if it meets returns FALSE
	106	//if NOT returns TRUE
	107	if(!pair)
	108	{
	109	Warning("Pass","No Pasaran! We never accept NULL pointers");
	110	return kTRUE;
	111	}
	112
	113	//check particle's cuts
cea0a066	114	if( ( fFirstPartCut->Rejected( pair->Particle1()) ) \|\|
cea0a066	115	( fSecondPartCut->Rejected(pair->Particle2()) ) )
78d7c6d3	116	{
	117	return kTRUE;
	118	}
	119	return PassPairProp(pair);
	120	}
	121	/**********************************************************/
	122
	123	Bool_t AliAODPairCut::PassPairProp(AliAODPair* pair) const
	124	{
	125	//methods which checks if given pair meets all criteria of the cut
	126	//if it meets returns FALSE
	127	//if NOT returns TRUE
	128	//examine all base pair cuts
	129	for (Int_t i = 0;i<fNCuts;i++)
	130	{
cea0a066	131	if ( (fCuts[i]->Rejected(pair)) ) return kTRUE; //if one of the cuts reject, then reject
78d7c6d3	132	}
	133	return kFALSE;
	134	}
	135	/**********************************************************/
	136
	137	void AliAODPairCut::Print()
	138	{
	139	//Prints the cut
	140	for (Int_t i = 0;i<fNCuts;i++)
	141	{
	142	fCuts[i]->Dump();
	143	}
	144	}
	145	/**********************************************************/
	146
	147	void AliAODPairCut::SetFirstPartCut(AliAODParticleCut* cut)
	148	{
	149	// set cut for the first particle
	150	if(!cut)
	151	{
	152	Error("SetFirstPartCut","argument is NULL");
	153	return;
	154	}
	155	delete fFirstPartCut;
	156	fFirstPartCut = (AliAODParticleCut*)cut->Clone();
	157
	158	}
	159	/**********************************************************/
	160
	161	void AliAODPairCut::SetSecondPartCut(AliAODParticleCut* cut)
	162	{
	163	// set cut for the second particle
	164	if(!cut)
	165	{
	166	Error("SetSecondPartCut","argument is NULL");
	167	return;
	168	}
	169	delete fSecondPartCut;
	170	fSecondPartCut = (AliAODParticleCut*)cut->Clone();
	171	}
	172	/**********************************************************/
	173
	174	void AliAODPairCut::SetPartCut(AliAODParticleCut* cut)
	175	{
	176	//sets the the same cut on both particles
	177	if(!cut)
	178	{
	179	Error("SetFirstPartCut","argument is NULL");
	180	return;
	181	}
	182	if (fFirstPartCut == fSecondPartCut) fSecondPartCut = 0x0;
	183
	184	delete fFirstPartCut;
	185	fFirstPartCut = (AliAODParticleCut*)cut->Clone();
	186
	187	delete fSecondPartCut; //even if null should not be harmful
	188	fSecondPartCut = fFirstPartCut;
	189	}
	190	/**********************************************************/
	191
	192	void AliAODPairCut::SetQInvRange(Double_t min, Double_t max)
	193	{
	194	// set range of accepted invariant masses
073745bc	195	AliAODQInvCut* cut= (AliAODQInvCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropQInv);
78d7c6d3	196	if(cut) cut->SetRange(min,max);
	197	else fCuts[fNCuts++] = new AliAODQInvCut(min,max);
	198	}
	199	/**********************************************************/
5c9d56e2	200
e6375609	201	void AliAODPairCut::SetQOutLCMSRange(Double_t min, Double_t max)
78d7c6d3	202	{
78d7c6d3	203	// set range of accepted QOut in CMS
073745bc	204	AliAODQOutLCMSCut* cut= (AliAODQOutLCMSCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropQOutLCMS);
78d7c6d3	205	if(cut) cut->SetRange(min,max);
	206	else fCuts[fNCuts++] = new AliAODQOutLCMSCut(min,max);
	207	}
78d7c6d3	208	/**********************************************************/
5c9d56e2	209
e6375609	210	void AliAODPairCut::SetQSideLCMSRange(Double_t min, Double_t max)
78d7c6d3	211	{
78d7c6d3	212	// set range of accepted QSide in CMS
073745bc	213	AliAODQSideLCMSCut* cut= (AliAODQSideLCMSCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropQSideLCMS);
78d7c6d3	214	if(cut) cut->SetRange(min,max);
	215	else fCuts[fNCuts++] = new AliAODQSideLCMSCut(min,max);
	216	}
	217
	218	/**********************************************************/
5c9d56e2	219
e6375609	220	void AliAODPairCut::SetQLongLCMSRange(Double_t min, Double_t max)
78d7c6d3	221	{
78d7c6d3	222	// set range of accepted QLong in CMS
073745bc	223	AliAODQLongLCMSCut* cut= (AliAODQLongLCMSCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropQLongLCMS);
78d7c6d3	224	if(cut) cut->SetRange(min,max);
	225	else fCuts[fNCuts++] = new AliAODQLongLCMSCut(min,max);
	226	}
5c9d56e2	227	/**********************************************************/
78d7c6d3	228
5c9d56e2	229	void AliAODPairCut::SetDeltaERange(Double_t min, Double_t max)
	230	{
	231	// set range of accepted DeltaE
	232	AliAODKtCut* cut= (AliAODKtCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropDeltaE);
	233	if(cut) cut->SetRange(min,max);
	234	else fCuts[fNCuts++] = new AliAODDeltaECut(min,max);
	235	}
	236	/**********************************************************/
	237
	238	void AliAODPairCut::SetDeltaPRange(Double_t min, Double_t max)
	239	{
	240	// set range of accepted DeltaP
	241	AliAODKtCut* cut= (AliAODKtCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropDeltaP);
	242	if(cut) cut->SetRange(min,max);
	243	else fCuts[fNCuts++] = new AliAODDeltaPCut(min,max);
	244	}
78d7c6d3	245	/**********************************************************/
	246
	247	void AliAODPairCut::SetKtRange(Double_t min, Double_t max)
	248	{
5c9d56e2	249	// set range of accepted Kt (avarage transverse pair momentum)
073745bc	250	AliAODKtCut* cut= (AliAODKtCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropKt);
78d7c6d3	251	if(cut) cut->SetRange(min,max);
	252	else fCuts[fNCuts++] = new AliAODKtCut(min,max);
	253	}
	254	/**********************************************************/
	255
	256	void AliAODPairCut::SetKStarRange(Double_t min, Double_t max)
	257	{
5c9d56e2	258	// set range of accepted KStar (invariant pair momentum difference (fourvector))
073745bc	259	AliAODKStarCut* cut= (AliAODKStarCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropKStar);
78d7c6d3	260	if(cut) cut->SetRange(min,max);
	261	else fCuts[fNCuts++] = new AliAODKStarCut(min,max);
	262	}
	263	/**********************************************************/
	264
fe3f2f54	265	void AliAODPairCut::SetKStarOutRange(Double_t min, Double_t max)
	266	{
	267	// set range of accepted KStar (invariant pair momentum difference (fourvector))
	268	AliAODKStarOutCut* cut= (AliAODKStarOutCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropKStarOut);
	269	if(cut) cut->SetRange(min,max);
	270	else fCuts[fNCuts++] = new AliAODKStarOutCut(min,max);
	271	}
	272	/**********************************************************/
	273
	274	void AliAODPairCut::SetKStarSideRange(Double_t min, Double_t max)
	275	{
	276	// set range of accepted KStar (invariant pair momentum difference (fourvector))
	277	AliAODKStarSideCut* cut= (AliAODKStarSideCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropKStarSide);
	278	if(cut) cut->SetRange(min,max);
	279	else fCuts[fNCuts++] = new AliAODKStarSideCut(min,max);
	280	}
	281	/**********************************************************/
	282
	283	void AliAODPairCut::SetKStarLongRange(Double_t min, Double_t max)
	284	{
	285	// set range of accepted KStar (invariant pair momentum difference (fourvector))
	286	AliAODKStarLongCut* cut= (AliAODKStarLongCut*)FindCut(AliAODPairBaseCut::kHbtPairCutPropKStarLong);
	287	if(cut) cut->SetRange(min,max);
	288	else fCuts[fNCuts++] = new AliAODKStarLongCut(min,max);
	289	}
	290	/**********************************************************/
	291
78d7c6d3	292	void AliAODPairCut::SetAvSeparationRange(Double_t min, Double_t max)
	293	{
	294	//sets avarage separation cut ->Anti-Merging cut
073745bc	295	AliAODPairBaseCut* cut= FindCut(AliAODPairBaseCut::kHbtPairCutPropAvSepar);
78d7c6d3	296	if(cut) cut->SetRange(min,max);
	297	else fCuts[fNCuts++] = new AliAODAvSeparationCut(min,max);
	298	}
	299	/**********************************************************/
	300
	301	void AliAODPairCut::SetITSSeparation(Int_t layer, Double_t drphi, Double_t dz)
	302	{
	303	//Anti-Merging Cut for first pixel layer
073745bc	304	AliAODITSSeparationCut* cut= dynamic_cast<AliAODITSSeparationCut*>(FindCut(AliAODPairBaseCut::kHbtPairCutPropPixelSepar));
78d7c6d3	305	if(cut)
	306	{
	307	if (layer == cut->GetLayer())
	308	{
	309	cut->SetRange(drphi,dz);//In this cut fMin is drphi, and fMax dz
	310	return;
	311	}
	312	}
	313	fCuts[fNCuts++] = new AliAODITSSeparationCut(layer,drphi,dz);
	314	// Info("SetITSSeparation","Added %d at address %#x",fNCuts-1,fCuts[fNCuts-1]);
	315	}
	316	/**********************************************************/
	317
	318	void AliAODPairCut::SetClusterOverlapRange(Double_t min,Double_t max)
	319	{
	320	//sets cluster overlap factor cut ->Anti-Splitting cut
	321	//cluster overlap factor ranges between
	322	// -0.5 (in all padrows both tracks have cluters)
	323	// and 1 (in all padrows one track has cluter and second has not)
	324	// When Overlap Factor is 1 this pair of tracks in highly probable to be
	325	// splitted track: one particle that is recontructed twise
	326	// STAR uses range from -0.5 to 0.6
	327
073745bc	328	AliAODPairBaseCut* cut= FindCut(AliAODPairBaseCut::kHbtPairCutPropClOverlap);
78d7c6d3	329	if(cut) cut->SetRange(min,max);
	330	else fCuts[fNCuts++] = new AliAODCluterOverlapCut(min,max);
	331	}
	332	/**********************************************************/
	333
073745bc	334	AliAODPairBaseCut* AliAODPairCut::FindCut(AliAODPairBaseCut::EAODPairCutProperty property)
78d7c6d3	335	{
	336	// Find the cut corresponding to "property"
	337	for (Int_t i = 0;i<fNCuts;i++)
	338	{
	339	if (fCuts[i]->GetProperty() == property)
	340	return fCuts[i]; //we found the cut we were searching for
	341	}
	342
	343	return 0x0; //we did not found this cut
	344
	345	}
	346	/**********************************************************/
	347
	348	void AliAODPairCut::Streamer(TBuffer &b)
	349	{
	350	// Stream all objects in the array to or from the I/O buffer.
	351
	352	UInt_t R__s, R__c;
	353	if (b.IsReading())
	354	{
	355	Version_t v = b.ReadVersion(&R__s, &R__c);
	356	if (v > -1)
	357	{
	358	delete fFirstPartCut;
	359	delete fSecondPartCut;
	360	fFirstPartCut = 0x0;
	361	fSecondPartCut = 0x0;
	362	TObject::Streamer(b);
	363	b >> fFirstPartCut;
	364	b >> fSecondPartCut;
	365	b >> fNCuts;
	366	for (Int_t i = 0;i<fNCuts;i++)
	367	{
	368	b >> fCuts[i];
	369	}
	370	}
	371	b.CheckByteCount(R__s, R__c,AliAODPairCut::IsA());
	372	}
	373	else
	374	{
	375	R__c = b.WriteVersion(AliAODPairCut::IsA(), kTRUE);
	376	TObject::Streamer(b);
	377
	378	// printf("Streamer Cut 1 %#x Cut 2 %#x\n",fFirstPartCut,fSecondPartCut);
	379	// this->Dump();
	380	// fFirstPartCut->Dump();
	381
	382	b << fFirstPartCut;
	383	b << fSecondPartCut;
	384	b << fNCuts;
	385	for (Int_t i = 0;i<fNCuts;i++)
	386	{
	387	b << fCuts[i];
	388	}
	389	b.SetByteCount(R__c, kTRUE);
	390	}
	391	}
	392	/******************************************************************/
	393
b4fb427e	394	ClassImp(AliAODPairEmptyCut)
78d7c6d3	395
b4fb427e	396	void AliAODPairEmptyCut::Streamer(TBuffer &b)
78d7c6d3	397	{
	398	//streamer for empty pair cut
	399	AliAODPairCut::Streamer(b);
	400	}
	401	/******************************************************************/
	402