HBTAN/AliHBTPairCut.cxx

   1 /* $Id$ */
   2
   3 //-------------------------------------------------------------------
   4 // Class AliHBTPairCut:
   5 // implements cut on the pair of particles
   6 // more info: http://alisoft.cern.ch/people/skowron/analyzer/index.html
   7 // Author: Piotr.Skowronski@cern.ch
   8 //-------------------------------------------------------------------
   9
  10 #include "AliHBTPairCut.h"
  11 #include "AliHBTPair.h"
  12 #include "AliHBTParticleCut.h"
  13
  14 ClassImp(AliHBTPairCut)
  15 const Int_t AliHBTPairCut::fgkMaxCuts = 50;
  16 /**********************************************************/
  17
  18 AliHBTPairCut::AliHBTPairCut():
  19   fNCuts(0)
  20 {
  21   //constructor
  22   fFirstPartCut = new AliHBTEmptyParticleCut(); //empty cuts
  23   fSecondPartCut= new AliHBTEmptyParticleCut(); //empty cuts
  24
  25   fCuts = new AliHbtBasePairCut*[fgkMaxCuts];
  26 }
  27 /**********************************************************/
  28
  29 AliHBTPairCut::AliHBTPairCut(const AliHBTPairCut& in)
  30 {
  31   //copy constructor
  32   fCuts = new AliHbtBasePairCut*[fgkMaxCuts];
  33   fNCuts = in.fNCuts;
  34
  35   fFirstPartCut = (AliHBTParticleCut*)in.fFirstPartCut->Clone();
  36   fSecondPartCut = (AliHBTParticleCut*)in.fSecondPartCut->Clone();
  37
  38   for (Int_t i = 0;i<fNCuts;i++)
  39     {
  40       fCuts[i] = (AliHbtBasePairCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
  41     }
  42 }
  43 /**********************************************************/
  44
  45 AliHBTPairCut&  AliHBTPairCut::operator=(const AliHBTPairCut& in)
  46 {
  47   //assignment operator
  48   fCuts = new AliHbtBasePairCut*[fgkMaxCuts];
  49   fNCuts = in.fNCuts;
  50
  51   fFirstPartCut = (AliHBTParticleCut*)in.fFirstPartCut->Clone();
  52   fSecondPartCut = (AliHBTParticleCut*)in.fSecondPartCut->Clone();
  53
  54   for (Int_t i = 0;i<fNCuts;i++)
  55     {
  56       fCuts[i] = (AliHbtBasePairCut*)in.fCuts[i]->Clone();//create new object (clone) and rember pointer to it
  57     }
  58   return * this;
  59 }
  60 /**********************************************************/
  61
  62 AliHBTPairCut::~AliHBTPairCut()
  63 {
  64   //destructor
  65   if (fFirstPartCut != fSecondPartCut)
  66     {
  67       delete fSecondPartCut;
  68     }
  69   delete fFirstPartCut;
  70   for (Int_t i = 0;i<fNCuts;i++)
  71     {
  72       delete fCuts[i];
  73     }
  74   delete []fCuts;
  75 }
  76 /**********************************************************/
  77
  78 /**********************************************************/
  79
  80 void AliHBTPairCut::AddBasePairCut(AliHbtBasePairCut* basecut)
  81 {
  82   //adds the base pair cut (cut on one value)
  83
  84   if (!basecut) return;
  85   if( fNCuts == (fgkMaxCuts-1) )
  86     {
  87       Warning("AddBasePairCut","Not enough place for another cut");
  88       return;
  89     }
  90   fCuts[fNCuts++]=basecut;
  91 }
  92 /**********************************************************/
  93
  94 Bool_t AliHBTPairCut::Pass(AliHBTPair* pair) const
  95 {
  96   //methods which checks if given pair meets all criteria of the cut
  97   //if it meets returns FALSE
  98   //if NOT   returns    TRUE
  99   if(!pair)
 100     {
 101       Warning("Pass","No Pasaran! We never accept NULL pointers");
 102       return kTRUE;
 103     }
 104
 105   //check particle's cuts
 106   if( ( fFirstPartCut->Pass( pair->Particle1()) ) ||
 107       ( fSecondPartCut->Pass(pair->Particle2()) )   )
 108     {
 109       return kTRUE;
 110     }
 111   return PassPairProp(pair);
 112 }
 113 /**********************************************************/
 114
 115 Bool_t AliHBTPairCut::PassPairProp(AliHBTPair* pair) const
 116 {
 117   //methods which checks if given pair meets all criteria of the cut
 118   //if it meets returns FALSE
 119   //if NOT   returns    TRUE
 120   //examine all base pair cuts
 121   for (Int_t i = 0;i<fNCuts;i++)
 122     {
 123       if ( (fCuts[i]->Pass(pair)) ) return kTRUE; //if one of the cuts reject, then reject
 124     }
 125   return kFALSE;
 126 }
 127 /**********************************************************/
 128
 129 void AliHBTPairCut::SetFirstPartCut(AliHBTParticleCut* cut)
 130 {
 131   // set cut for the first particle
 132   if(!cut)
 133     {
 134       Error("SetFirstPartCut","argument is NULL");
 135       return;
 136     }
 137   delete fFirstPartCut;
 138   fFirstPartCut = (AliHBTParticleCut*)cut->Clone();
 139
 140 }
 141 /**********************************************************/
 142
 143 void AliHBTPairCut::SetSecondPartCut(AliHBTParticleCut* cut)
 144 {
 145   // set cut for the second particle
 146   if(!cut)
 147     {
 148       Error("SetSecondPartCut","argument is NULL");
 149       return;
 150     }
 151   delete fSecondPartCut;
 152   fSecondPartCut = (AliHBTParticleCut*)cut->Clone();
 153 }
 154 /**********************************************************/
 155
 156 void AliHBTPairCut::SetPartCut(AliHBTParticleCut* cut)
 157 {
 158   //sets the the same cut on both particles
 159   if(!cut)
 160     {
 161       Error("SetFirstPartCut","argument is NULL");
 162       return;
 163     }
 164   delete fFirstPartCut;
 165   fFirstPartCut = (AliHBTParticleCut*)cut->Clone();
 166
 167   delete fSecondPartCut; //even if null should not be harmful
 168   fSecondPartCut = fFirstPartCut;
 169 }
 170 /**********************************************************/
 171
 172 void AliHBTPairCut::SetQInvRange(Double_t min, Double_t max)
 173 {
 174   // set range of accepted invariant masses
 175   AliHBTQInvCut* cut= (AliHBTQInvCut*)FindCut(kHbtPairCutPropQInv);
 176   if(cut) cut->SetRange(min,max);
 177   else fCuts[fNCuts++] = new AliHBTQInvCut(min,max);
 178 }
 179 /**********************************************************/
 180 void AliHBTPairCut::SetQOutCMSLRange(Double_t min, Double_t max)
 181 {
 182   // set range of accepted QOut in CMS
 183   AliHBTQOutCMSLCCut* cut= (AliHBTQOutCMSLCCut*)FindCut(kHbtPairCutPropQOutCMSLC);
 184   if(cut) cut->SetRange(min,max);
 185   else fCuts[fNCuts++] = new AliHBTQOutCMSLCCut(min,max);
 186 }
 187
 188 /**********************************************************/
 189 void AliHBTPairCut::SetQSideCMSLRange(Double_t min, Double_t max)
 190 {
 191   // set range of accepted QSide in CMS
 192   AliHBTQSideCMSLCCut* cut= (AliHBTQSideCMSLCCut*)FindCut(kHbtPairCutPropQSideCMSLC);
 193   if(cut) cut->SetRange(min,max);
 194   else fCuts[fNCuts++] = new AliHBTQSideCMSLCCut(min,max);
 195 }
 196
 197 /**********************************************************/
 198 void AliHBTPairCut::SetQLongCMSLRange(Double_t min, Double_t max)
 199 {
 200   // set range of accepted QLong in CMS
 201   AliHBTQLongCMSLCCut* cut= (AliHBTQLongCMSLCCut*)FindCut(kHbtPairCutPropQLongCMSLC);
 202   if(cut) cut->SetRange(min,max);
 203   else fCuts[fNCuts++] = new AliHBTQLongCMSLCCut(min,max);
 204 }
 205
 206 /**********************************************************/
 207
 208 void AliHBTPairCut::SetKtRange(Double_t min, Double_t max)
 209 {
 210   // set range of accepted Kt (?)
 211   AliHBTKtCut* cut= (AliHBTKtCut*)FindCut(kHbtPairCutPropKt);
 212   if(cut) cut->SetRange(min,max);
 213   else fCuts[fNCuts++] = new AliHBTKtCut(min,max);
 214 }
 215 /**********************************************************/
 216
 217 void AliHBTPairCut::SetKStarRange(Double_t min, Double_t max)
 218 {
 219   // set range of accepted KStar (?)
 220   AliHBTKStarCut* cut= (AliHBTKStarCut*)FindCut(kHbtPairCutPropKStar);
 221   if(cut) cut->SetRange(min,max);
 222   else fCuts[fNCuts++] = new AliHBTKStarCut(min,max);
 223 }
 224 /**********************************************************/
 225
 226 AliHbtBasePairCut* AliHBTPairCut::FindCut(AliHBTPairCutProperty property)
 227 {
 228   // Find the cut corresponding to "property"
 229   for (Int_t i = 0;i<fNCuts;i++)
 230     {
 231       if (fCuts[i]->GetProperty() == property)
 232         return fCuts[i]; //we found the cut we were searching for
 233     }
 234
 235   return 0x0; //we did not found this cut
 236
 237 }
 238 /**********************************************************/
 239
 240 void AliHBTPairCut::Streamer(TBuffer &b)
 241 {
 242   // Stream all objects in the array to or from the I/O buffer.
 243
 244   UInt_t R__s, R__c;
 245   if (b.IsReading())
 246     {
 247       Version_t v = b.ReadVersion(&R__s, &R__c);
 248       if (v > -1)
 249        {
 250           delete fFirstPartCut;
 251           delete fSecondPartCut;
 252           fFirstPartCut = 0x0;
 253           fSecondPartCut = 0x0;
 254           TObject::Streamer(b);
 255           b >> fFirstPartCut;
 256           b >> fSecondPartCut;
 257           b >> fNCuts;
 258           for (Int_t i = 0;i<fNCuts;i++)
 259            {
 260              b >> fCuts[i];
 261            }
 262         }
 263       b.CheckByteCount(R__s, R__c,AliHBTPairCut::IsA());
 264     }
 265   else
 266     {
 267       R__c = b.WriteVersion(AliHBTPairCut::IsA(), kTRUE);
 268       TObject::Streamer(b);
 269       b << fFirstPartCut;
 270       b << fSecondPartCut;
 271       b << fNCuts;
 272       for (Int_t i = 0;i<fNCuts;i++)
 273         {
 274           b << fCuts[i];
 275         }
 276       b.SetByteCount(R__c, kTRUE);
 277     }
 278 }
 279
 280 ClassImp(AliHBTEmptyPairCut)
 281
 282 void AliHBTEmptyPairCut::Streamer(TBuffer &b)
 283 {
 284 //streamer for empty pair cut
 285   AliHBTPairCut::Streamer(b);
 286 }
 287
 288 ClassImp(AliHbtBasePairCut)
 289 ClassImp(AliHBTQInvCut)
 290 ClassImp(AliHBTKtCut)
 291 ClassImp(AliHBTQSideCMSLCCut)
 292 ClassImp(AliHBTQOutCMSLCCut)
 293 ClassImp(AliHBTQLongCMSLCCut)