HBTAN/AliHBTParticleCut.cxx

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