[u/mrichter/AliRoot.git] / HBTAN / AliHBTParticleCut.cxx

#include "AliHBTParticleCut.h"

#include <Riostream.h>

ClassImp(AliHBTParticleCut)
const Int_t AliHBTParticleCut::fkgMaxCuts = 50;
/******************************************************************/

AliHBTParticleCut::AliHBTParticleCut()
 {
   fCuts = new AliHbtBaseCut* [fkgMaxCuts];//last property in the property
                                         //property enum => defines number of properties
   fNCuts = 0;
   fPID  = 0;
 }
/******************************************************************/

AliHBTParticleCut::AliHBTParticleCut(const AliHBTParticleCut& in)
{
  fCuts = new AliHbtBaseCut* [fkgMaxCuts];//last property in the property
                                         //property enum => defines number of properties
  fNCuts = in.fNCuts;
  fPID  = in.fPID;
  for (Int_t i = 0;i<fNCuts;i++)
   {
     fCuts[i] = (AliHbtBaseCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
   }
}
/******************************************************************/

AliHBTParticleCut::~AliHBTParticleCut()
{
  for (Int_t i = 0;i<fNCuts;i++)
   {
     delete fCuts[i];
   }
  delete []fCuts;
} 
/******************************************************************/

Bool_t AliHBTParticleCut::Pass(AliHBTParticle* p)
{
//method checks all the cuts that are set (in the list)
//If any of the baseCuts rejects particle False(rejection) is returned
 if(!p) 
  {
    Warning("Pass()","No Pasaran! We never accept NULL pointers");
    return kTRUE;
  }
 if( (p->GetPdgCode() != fPID) && ( fPID != 0)) return kTRUE;
 
 for (Int_t i = 0;i<fNCuts;i++)
   {
    if ( (fCuts[i]->Pass(p)) ) return kTRUE; //if one of the cuts rejects, then reject
   }
  return kFALSE;
}
/******************************************************************/

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

/******************************************************************/
AliHbtBaseCut* AliHBTParticleCut::FindCut(AliHBTCutProperty 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 AliHBTParticleCut::SetMomentumRange(Double_t min, Double_t max)
{
  AliHBTMomentumCut* cut= (AliHBTMomentumCut*)FindCut(kHbtP);
  if(cut) cut->SetRange(min,max);
  else fCuts[fNCuts++] = new AliHBTMomentumCut(min,max);
}
/******************************************************************/


void AliHBTParticleCut::SetPtRange(Double_t min, Double_t max)
{
  AliHBTPtCut* cut= (AliHBTPtCut*)FindCut(kHbtPt);
  if(cut) cut->SetRange(min,max);
  else fCuts[fNCuts++] = new AliHBTPtCut(min,max);

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

void AliHBTParticleCut::SetEnergyRange(Double_t min, Double_t max)
{
  AliHBTEnergyCut* cut= (AliHBTEnergyCut*)FindCut(kHbtE);
  if(cut) cut->SetRange(min,max);
  else fCuts[fNCuts++] = new AliHBTEnergyCut(min,max);
 
}
/******************************************************************/

void AliHBTParticleCut::SetRapidityRange(Double_t min, Double_t max)
{
  AliHbtBaseCut* cut = FindCut(kHbtRapidity);
  if(cut) cut->SetRange(min,max);
  else fCuts[fNCuts++] = new AliHBTRapidityCut(min,max);

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

void AliHBTParticleCut::SetPseudoRapidityRange(Double_t min, Double_t max)
{
  AliHbtBaseCut* cut = FindCut(kHbtPseudoRapidity);
  if(cut) cut->SetRange(min,max);
  else fCuts[fNCuts++] = new AliHBTPseudoRapidityCut(min,max);
 
}
/******************************************************************/

void AliHBTParticleCut::SetPxRange(Double_t min, Double_t max)
{
  AliHbtBaseCut* cut = FindCut(kHbtPx);
  if(cut) cut->SetRange(min,max);
  else fCuts[fNCuts++] = new AliHBTPxCut(min,max);
}
/******************************************************************/

void AliHBTParticleCut::SetPyRange(Double_t min, Double_t max)
{  
  AliHbtBaseCut* cut = FindCut(kHbtPy);
  if(cut) cut->SetRange(min,max);
  else fCuts[fNCuts++] = new AliHBTPyCut(min,max);
}
/******************************************************************/

void AliHBTParticleCut::SetPzRange(Double_t min, Double_t max)
{
  AliHbtBaseCut* cut = FindCut(kHbtPz);
  if(cut) cut->SetRange(min,max);
  else fCuts[fNCuts++] = new AliHBTPzCut(min,max);
}
/******************************************************************/

void AliHBTParticleCut::SetPhiRange(Double_t min, Double_t max)
{
  AliHbtBaseCut* cut = FindCut(kHbtPhi);
  if(cut) cut->SetRange(min,max);
  else fCuts[fNCuts++] = new AliHBTPhiCut(min,max);
}
/******************************************************************/

void AliHBTParticleCut::SetThetaRange(Double_t min, Double_t max)
{
  AliHbtBaseCut* cut = FindCut(kHbtTheta);
  if(cut) cut->SetRange(min,max);
  else fCuts[fNCuts++] = new AliHBTThetaCut(min,max);
}
/******************************************************************/

void AliHBTParticleCut::SetVxRange(Double_t min, Double_t max)
{
  AliHbtBaseCut* cut = FindCut(kHbtVx);
  if(cut) cut->SetRange(min,max);
  else fCuts[fNCuts++] = new AliHBTVxCut(min,max);
}
/******************************************************************/

void AliHBTParticleCut::SetVyRange(Double_t min, Double_t max)
{
  AliHbtBaseCut* cut = FindCut(kHbtVy);
  if(cut) cut->SetRange(min,max);
  else fCuts[fNCuts++] = new AliHBTVyCut(min,max);
}
/******************************************************************/

void AliHBTParticleCut::SetVzRange(Double_t min, Double_t max)
{
  AliHbtBaseCut* cut = FindCut(kHbtVz);
  if(cut) cut->SetRange(min,max);
  else fCuts[fNCuts++] = new AliHBTVzCut(min,max);
}

/******************************************************************/
void AliHBTParticleCut::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()) 
    {
      Int_t i;
      for (i = 0;i<fNCuts;i++) delete fCuts[i];
      b.ReadVersion(&R__s, &R__c);
      TObject::Streamer(b);
      b >> fPID;
      b >> fNCuts;
      for (i = 0;i<fNCuts;i++) 
       {
         b >> fCuts[i];
       }
       b.CheckByteCount(R__s, R__c,AliHBTParticleCut::IsA());
    } 
   else 
    {
     R__c = b.WriteVersion(AliHBTParticleCut::IsA(), kTRUE);
     TObject::Streamer(b);
     b << fPID;
     b << fNCuts;
     for (Int_t i = 0;i<fNCuts;i++)
      {
       b << fCuts[i];
      }
     b.SetByteCount(R__c, kTRUE);
   }
}

void AliHBTParticleCut::Print(void)
{
  cout<<"Printing AliHBTParticleCut, this = "<<this<<endl;
  cout<<"fPID  "<<fPID<<endl;
  cout<<"fNCuts  "<<fNCuts <<endl;
  for (Int_t i = 0;i<fNCuts;i++)
      {
       cout<<"  fCuts["<<i<<"]  "<<fCuts[i]<<endl<<"   ";
       fCuts[i]->Print();
      }
}

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

ClassImp(AliHBTEmptyParticleCut)
void AliHBTEmptyParticleCut::Streamer(TBuffer &b)
 {
  AliHBTParticleCut::Streamer(b);
 }
/******************************************************************/
/******************************************************************/
/******************************************************************/

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

ClassImp(AliHbtBaseCut)
void AliHbtBaseCut::Print(void)
{
  cout<<"fMin="<<fMin <<", fMax=" <<fMax<<"    ";
  PrintProperty();
}
void AliHbtBaseCut::PrintProperty(void)
{
 switch (fProperty)
  {
   case  kHbtP: 
     cout<<"kHbtP"; break;
   case  kHbtPt: 
     cout<<"kHbtPt"; break;
   case  kHbtE: 
     cout<<"kHbtE"; break;
   case  kHbtRapidity: 
     cout<<"kHbtRapidity"; break;
   case  kHbtPseudoRapidity: 
     cout<<"kHbtPseudoRapidity"; break;
   case  kHbtPx: 
     cout<<"kHbtPx"; break;
   case  kHbtPy: 
     cout<<"kHbtPy"; break;
   case  kHbtPz: 
     cout<<"kHbtPz"; break;   
   case  kHbtPhi: 
     cout<<"kHbtPhi"; break;
   case  kHbtTheta: 
     cout<<"kHbtTheta"; break;
   case  kHbtVx: 
     cout<<"kHbtVx"; break;
   case  kHbtVy: 
     cout<<"kHbtVy"; break;
   case  kHbtVz: 
     cout<<"kHbtVz"; break;
   case  kHbtNone: 
     cout<<"kHbtNone"; break;
   default: 
     cout<<"Property Not Found";
  }
 cout<<endl;
}
ClassImp( AliHBTMomentumCut )

ClassImp( AliHBTPtCut )
ClassImp( AliHBTEnergyCut )
ClassImp( AliHBTRapidityCut )
ClassImp( AliHBTPseudoRapidityCut )
ClassImp( AliHBTPxCut )
ClassImp( AliHBTPyCut )
ClassImp( AliHBTPzCut )
ClassImp( AliHBTPhiCut )
ClassImp( AliHBTThetaCut )
ClassImp( AliHBTVxCut )
ClassImp( AliHBTVyCut )
ClassImp( AliHBTVzCut )

ClassImp( AliHBTPIDCut )

ClassImp( AliHBTLogicalOperCut )

AliHBTLogicalOperCut::AliHBTLogicalOperCut():
 AliHbtBaseCut(-10e10,10e10,kHbtNone),
 fFirst(new AliHBTDummyBaseCut),
 fSecond(new AliHBTDummyBaseCut)
{

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

AliHBTLogicalOperCut::AliHBTLogicalOperCut(AliHbtBaseCut* first, AliHbtBaseCut* second):
 AliHbtBaseCut(-10e10,10e10,kHbtNone),
 fFirst((first)?(AliHbtBaseCut*)first->Clone():0x0),
 fSecond((second)?(AliHbtBaseCut*)second->Clone():0x0)
{
  if ( (fFirst && fSecond) == kFALSE) 
   {
     Fatal("AliHBTLogicalOperCut","One of parameters is NULL!");
   }
}
/******************************************************************/

AliHBTLogicalOperCut::~AliHBTLogicalOperCut()
{
//destructor
  delete fFirst;
  delete fSecond;
}
/******************************************************************/

Bool_t AliHBTLogicalOperCut::AliHBTDummyBaseCut::Pass(AliHBTParticle*p)
{
  Warning("Pass","You are using dummy base cut! Probobly some logical cut is not set up properly");
  return kFALSE;//accept
}
/******************************************************************/

void AliHBTLogicalOperCut::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()) 
   {
     delete fFirst;
     delete fSecond;
     fFirst  = 0x0;
     fSecond = 0x0;

     b.ReadVersion(&R__s, &R__c);
     TObject::Streamer(b);
     b >> fFirst;
     b >> fSecond;
     b.CheckByteCount(R__s, R__c,AliHBTLogicalOperCut::IsA());
   } 
  else 
   {
     R__c = b.WriteVersion(AliHBTLogicalOperCut::IsA(), kTRUE);
     TObject::Streamer(b);
     b << fFirst;
     b << fSecond;
     b.SetByteCount(R__c, kTRUE);
  }
}

/******************************************************************/
ClassImp(AliHBTOrCut)

Bool_t AliHBTOrCut::Pass(AliHBTParticle * p)
{
  //returns true when rejected 
  //AND operation is a little bit misleading but is correct
  //User wants to build logical cuts with natural (positive) logic
  //while HBTAN use inernally reverse (returns true when rejected)
  if (fFirst->Pass(p) && fSecond->Pass(p)) return kTRUE;//rejected (both rejected, returned kTRUE)
  return kFALSE;//accepted, at least one accepted (returned kFALSE)
}
/******************************************************************/

ClassImp(AliHBTAndCut)

Bool_t AliHBTAndCut::Pass(AliHBTParticle * p)
{
  //returns true when rejected 
  //OR operation is a little bit misleading but is correct
  //User wants to build logical cuts with natural (positive) logic
  //while HBTAN use inernally reverse (returns true when rejected)
  if (fFirst->Pass(p) || fSecond->Pass(p)) return kTRUE;//rejected (any of two rejected(returned kTRUE) )
  return kFALSE;//accepted (both accepted (returned kFALSE))
}
/******************************************************************/
Commit	Line	Data
1b446896	1	#include "AliHBTParticleCut.h"
1b446896	2
d0c23b58	3	#include <Riostream.h>
1b446896	4
	5	ClassImp(AliHBTParticleCut)
	6	const Int_t AliHBTParticleCut::fkgMaxCuts = 50;
	7	/******************************************************************/
	8
	9	AliHBTParticleCut::AliHBTParticleCut()
	10	{
	11	fCuts = new AliHbtBaseCut* [fkgMaxCuts];//last property in the property
	12	//property enum => defines number of properties
	13	fNCuts = 0;
	14	fPID = 0;
	15	}
	16	/******************************************************************/
	17
	18	AliHBTParticleCut::AliHBTParticleCut(const AliHBTParticleCut& in)
	19	{
	20	fCuts = new AliHbtBaseCut* [fkgMaxCuts];//last property in the property
	21	//property enum => defines number of properties
	22	fNCuts = in.fNCuts;
	23	fPID = in.fPID;
	24	for (Int_t i = 0;i<fNCuts;i++)
	25	{
	26	fCuts[i] = (AliHbtBaseCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
	27	}
	28	}
	29	/******************************************************************/
	30
	31	AliHBTParticleCut::~AliHBTParticleCut()
	32	{
	33	for (Int_t i = 0;i<fNCuts;i++)
	34	{
	35	delete fCuts[i];
	36	}
	37	delete []fCuts;
	38	}
	39	/******************************************************************/
	40
	41	Bool_t AliHBTParticleCut::Pass(AliHBTParticle* p)
	42	{
	43	//method checks all the cuts that are set (in the list)
	44	//If any of the baseCuts rejects particle False(rejection) is returned
	45	if(!p)
	46	{
	47	Warning("Pass()","No Pasaran! We never accept NULL pointers");
	48	return kTRUE;
	49	}
	50	if( (p->GetPdgCode() != fPID) && ( fPID != 0)) return kTRUE;
	51
	52	for (Int_t i = 0;i<fNCuts;i++)
	53	{
	54	if ( (fCuts[i]->Pass(p)) ) return kTRUE; //if one of the cuts rejects, then reject
	55	}
	56	return kFALSE;
	57	}
	58	/******************************************************************/
	59
	60	void AliHBTParticleCut::AddBasePartCut(AliHbtBaseCut* basecut)
	61	{
	62	//adds the base pair cut (cut on one value)
	63
	64	if (!basecut) return;
	65	if( fNCuts == (fkgMaxCuts-1) )
	66	{
	67	Warning("AddBasePartCut","Not enough place for another cut");
68	return;
69	}
70	fCuts[fNCuts++]=basecut;
71
72	}
73
74	/******************************************************************/
75	AliHbtBaseCut* AliHBTParticleCut::FindCut(AliHBTCutProperty property)
76	{
77
78	for (Int_t i = 0;i<fNCuts;i++)
79	{
80	if (fCuts[i]->GetProperty() == property)
81	return fCuts[i]; //we found the cut we were searching for
82	}
83
84	return 0x0; //we did not found this cut
85
86	}
87	/******************************************************************/
88
89	void AliHBTParticleCut::SetMomentumRange(Double_t min, Double_t max)
90	{
91	AliHBTMomentumCut* cut= (AliHBTMomentumCut*)FindCut(kHbtP);
92	if(cut) cut->SetRange(min,max);
93	else fCuts[fNCuts++] = new AliHBTMomentumCut(min,max);
94	}
95	/******************************************************************/
96
97
98	void AliHBTParticleCut::SetPtRange(Double_t min, Double_t max)
99	{
100	AliHBTPtCut* cut= (AliHBTPtCut*)FindCut(kHbtPt);
101	if(cut) cut->SetRange(min,max);
102	else fCuts[fNCuts++] = new AliHBTPtCut(min,max);
103
104	}
105	/******************************************************************/
106
107	void AliHBTParticleCut::SetEnergyRange(Double_t min, Double_t max)
108	{
109	AliHBTEnergyCut* cut= (AliHBTEnergyCut*)FindCut(kHbtE);
110	if(cut) cut->SetRange(min,max);
111	else fCuts[fNCuts++] = new AliHBTEnergyCut(min,max);
112
113	}
114	/******************************************************************/
115
116	void AliHBTParticleCut::SetRapidityRange(Double_t min, Double_t max)
117	{
118	AliHbtBaseCut* cut = FindCut(kHbtRapidity);
119	if(cut) cut->SetRange(min,max);
120	else fCuts[fNCuts++] = new AliHBTRapidityCut(min,max);
121
122	}
123	/******************************************************************/
124
125	void AliHBTParticleCut::SetPseudoRapidityRange(Double_t min, Double_t max)
126	{
127	AliHbtBaseCut* cut = FindCut(kHbtPseudoRapidity);
128	if(cut) cut->SetRange(min,max);
129	else fCuts[fNCuts++] = new AliHBTPseudoRapidityCut(min,max);
130
131	}
132	/******************************************************************/
133
134	void AliHBTParticleCut::SetPxRange(Double_t min, Double_t max)
135	{
136	AliHbtBaseCut* cut = FindCut(kHbtPx);
137	if(cut) cut->SetRange(min,max);
138	else fCuts[fNCuts++] = new AliHBTPxCut(min,max);
139	}
140	/******************************************************************/
141
142	void AliHBTParticleCut::SetPyRange(Double_t min, Double_t max)
143	{
144	AliHbtBaseCut* cut = FindCut(kHbtPy);
145	if(cut) cut->SetRange(min,max);
146	else fCuts[fNCuts++] = new AliHBTPyCut(min,max);
147	}
148	/******************************************************************/
149
150	void AliHBTParticleCut::SetPzRange(Double_t min, Double_t max)
151	{
152	AliHbtBaseCut* cut = FindCut(kHbtPz);
153	if(cut) cut->SetRange(min,max);
154	else fCuts[fNCuts++] = new AliHBTPzCut(min,max);
155	}
156	/******************************************************************/
157
158	void AliHBTParticleCut::SetPhiRange(Double_t min, Double_t max)
159	{
160	AliHbtBaseCut* cut = FindCut(kHbtPhi);
161	if(cut) cut->SetRange(min,max);
162	else fCuts[fNCuts++] = new AliHBTPhiCut(min,max);
163	}
164	/******************************************************************/
165
166	void AliHBTParticleCut::SetThetaRange(Double_t min, Double_t max)
167	{
168	AliHbtBaseCut* cut = FindCut(kHbtTheta);
169	if(cut) cut->SetRange(min,max);
170	else fCuts[fNCuts++] = new AliHBTThetaCut(min,max);
171	}
172	/******************************************************************/
173
174	void AliHBTParticleCut::SetVxRange(Double_t min, Double_t max)
175	{
176	AliHbtBaseCut* cut = FindCut(kHbtVx);
177	if(cut) cut->SetRange(min,max);
178	else fCuts[fNCuts++] = new AliHBTVxCut(min,max);
179	}
180	/******************************************************************/
181
182	void AliHBTParticleCut::SetVyRange(Double_t min, Double_t max)
183	{
184	AliHbtBaseCut* cut = FindCut(kHbtVy);
185	if(cut) cut->SetRange(min,max);
186	else fCuts[fNCuts++] = new AliHBTVyCut(min,max);
187	}
188	/******************************************************************/
189
190	void AliHBTParticleCut::SetVzRange(Double_t min, Double_t max)
191	{
192	AliHbtBaseCut* cut = FindCut(kHbtVz);
193	if(cut) cut->SetRange(min,max);
194	else fCuts[fNCuts++] = new AliHBTVzCut(min,max);
195	}
196
197	/******************************************************************/
198	void AliHBTParticleCut::Streamer(TBuffer &b)
199	{
200	// Stream all objects in the array to or from the I/O buffer.
201
202	UInt_t R__s, R__c;
203	if (b.IsReading())
204	{
e9b3bfa8	205	Int_t i;
	206	for (i = 0;i<fNCuts;i++) delete fCuts[i];
	207	b.ReadVersion(&R__s, &R__c);
1b446896	208	TObject::Streamer(b);
	209	b >> fPID;
	210	b >> fNCuts;
e9b3bfa8	211	for (i = 0;i<fNCuts;i++)
1b446896	212	{
e9b3bfa8	213	b >> fCuts[i];
1b446896	214	}
	215	b.CheckByteCount(R__s, R__c,AliHBTParticleCut::IsA());
	216	}
	217	else
	218	{
	219	R__c = b.WriteVersion(AliHBTParticleCut::IsA(), kTRUE);
	220	TObject::Streamer(b);
	221	b << fPID;
	222	b << fNCuts;
	223	for (Int_t i = 0;i<fNCuts;i++)
	224	{
	225	b << fCuts[i];
	226	}
	227	b.SetByteCount(R__c, kTRUE);
	228	}
	229	}
	230
	231	void AliHBTParticleCut::Print(void)
	232	{
	233	cout<<"Printing AliHBTParticleCut, this = "<<this<<endl;
	234	cout<<"fPID "<<fPID<<endl;
	235	cout<<"fNCuts "<<fNCuts <<endl;
	236	for (Int_t i = 0;i<fNCuts;i++)
	237	{
	238	cout<<" fCuts["<<i<<"] "<<fCuts[i]<<endl<<" ";
	239	fCuts[i]->Print();
	240	}
	241	}
	242
	243	/******************************************************************/
	244	/******************************************************************/
	245
	246	ClassImp(AliHBTEmptyParticleCut)
	247	void AliHBTEmptyParticleCut::Streamer(TBuffer &b)
	248	{
	249	AliHBTParticleCut::Streamer(b);
	250	}
	251	/******************************************************************/
	252	/******************************************************************/
	253	/******************************************************************/
	254
	255	/******************************************************************/
	256	/******************************************************************/
	257	/******************************************************************/
	258
	259	ClassImp(AliHbtBaseCut)
	260	void AliHbtBaseCut::Print(void)
	261	{
	262	cout<<"fMin="<<fMin <<", fMax=" <<fMax<<" ";
	263	PrintProperty();
	264	}
	265	void AliHbtBaseCut::PrintProperty(void)
	266	{
	267	switch (fProperty)
	268	{
	269	case kHbtP:
	270	cout<<"kHbtP"; break;
	271	case kHbtPt:
	272	cout<<"kHbtPt"; break;
	273	case kHbtE:
	274	cout<<"kHbtE"; break;
	275	case kHbtRapidity:
	276	cout<<"kHbtRapidity"; break;
	277	case kHbtPseudoRapidity:
278	cout<<"kHbtPseudoRapidity"; break;
279	case kHbtPx:
280	cout<<"kHbtPx"; break;
281	case kHbtPy:
282	cout<<"kHbtPy"; break;
283	case kHbtPz:
284	cout<<"kHbtPz"; break;
285	case kHbtPhi:
286	cout<<"kHbtPhi"; break;
287	case kHbtTheta:
288	cout<<"kHbtTheta"; break;
289	case kHbtVx:
290	cout<<"kHbtVx"; break;
291	case kHbtVy:
292	cout<<"kHbtVy"; break;
293	case kHbtVz:
294	cout<<"kHbtVz"; break;
295	case kHbtNone:
296	cout<<"kHbtNone"; break;
297	default:
298	cout<<"Property Not Found";
299	}
300	cout<<endl;
301	}
302	ClassImp( AliHBTMomentumCut )
303
304	ClassImp( AliHBTPtCut )
305	ClassImp( AliHBTEnergyCut )
306	ClassImp( AliHBTRapidityCut )
307	ClassImp( AliHBTPseudoRapidityCut )
308	ClassImp( AliHBTPxCut )
309	ClassImp( AliHBTPyCut )
310	ClassImp( AliHBTPzCut )
311	ClassImp( AliHBTPhiCut )
312	ClassImp( AliHBTThetaCut )
313	ClassImp( AliHBTVxCut )
314	ClassImp( AliHBTVyCut )
315	ClassImp( AliHBTVzCut )
316
4617f71a	317	ClassImp( AliHBTPIDCut )
1b446896	318
4617f71a	319	ClassImp( AliHBTLogicalOperCut )
	320
	321	AliHBTLogicalOperCut::AliHBTLogicalOperCut():
	322	AliHbtBaseCut(-10e10,10e10,kHbtNone),
	323	fFirst(new AliHBTDummyBaseCut),
	324	fSecond(new AliHBTDummyBaseCut)
	325	{
	326
	327	}
	328	/******************************************************************/
	329
	330	AliHBTLogicalOperCut::AliHBTLogicalOperCut(AliHbtBaseCut* first, AliHbtBaseCut* second):
	331	AliHbtBaseCut(-10e10,10e10,kHbtNone),
	332	fFirst((first)?(AliHbtBaseCut*)first->Clone():0x0),
	333	fSecond((second)?(AliHbtBaseCut*)second->Clone():0x0)
	334	{
	335	if ( (fFirst && fSecond) == kFALSE)
	336	{
	337	Fatal("AliHBTLogicalOperCut","One of parameters is NULL!");
	338	}
	339	}
	340	/******************************************************************/
	341
	342	AliHBTLogicalOperCut::~AliHBTLogicalOperCut()
	343	{
	344	//destructor
	345	delete fFirst;
	346	delete fSecond;
	347	}
	348	/******************************************************************/
	349
	350	Bool_t AliHBTLogicalOperCut::AliHBTDummyBaseCut::Pass(AliHBTParticle*p)
	351	{
	352	Warning("Pass","You are using dummy base cut! Probobly some logical cut is not set up properly");
	353	return kFALSE;//accept
	354	}
	355	/******************************************************************/
	356
	357	void AliHBTLogicalOperCut::Streamer(TBuffer &b)
	358	{
	359	// Stream all objects in the array to or from the I/O buffer.
	360	UInt_t R__s, R__c;
	361	if (b.IsReading())
	362	{
	363	delete fFirst;
	364	delete fSecond;
	365	fFirst = 0x0;
	366	fSecond = 0x0;
	367
	368	b.ReadVersion(&R__s, &R__c);
	369	TObject::Streamer(b);
	370	b >> fFirst;
	371	b >> fSecond;
	372	b.CheckByteCount(R__s, R__c,AliHBTLogicalOperCut::IsA());
	373	}
	374	else
	375	{
	376	R__c = b.WriteVersion(AliHBTLogicalOperCut::IsA(), kTRUE);
	377	TObject::Streamer(b);
	378	b << fFirst;
	379	b << fSecond;
	380	b.SetByteCount(R__c, kTRUE);
	381	}
	382	}
383
384	/******************************************************************/
385	ClassImp(AliHBTOrCut)
386
387	Bool_t AliHBTOrCut::Pass(AliHBTParticle * p)
388	{
389	//returns true when rejected
390	//AND operation is a little bit misleading but is correct
391	//User wants to build logical cuts with natural (positive) logic
392	//while HBTAN use inernally reverse (returns true when rejected)
393	if (fFirst->Pass(p) && fSecond->Pass(p)) return kTRUE;//rejected (both rejected, returned kTRUE)
394	return kFALSE;//accepted, at least one accepted (returned kFALSE)
395	}
396	/******************************************************************/
397
398	ClassImp(AliHBTAndCut)
399
400	Bool_t AliHBTAndCut::Pass(AliHBTParticle * p)
401	{
402	//returns true when rejected
403	//OR operation is a little bit misleading but is correct
404	//User wants to build logical cuts with natural (positive) logic
405	//while HBTAN use inernally reverse (returns true when rejected)
406	if (fFirst->Pass(p) \|\| fSecond->Pass(p)) return kTRUE;//rejected (any of two rejected(returned kTRUE) )
407	return kFALSE;//accepted (both accepted (returned kFALSE))
408	}
409	/******************************************************************/