HBTAN/AliHBTPairCut.cxx

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