ANALYSIS/AliAODPairBaseCut.cxx

   1 #include "AliAODPairBaseCut.h"
   2
   3 #include "AliTrackPoints.h"
   4 #include "AliClusterMap.h"
   5
   6
   7 ClassImp(AliAODPairBaseCut)
   8 ClassImp(AliAODQInvCut)
   9 ClassImp(AliAODKtCut)
  10 ClassImp(AliAODQSideLCMSCut)
  11 ClassImp(AliAODQOutLCMSCut)
  12 ClassImp(AliAODQLongLCMSCut)
  13 ClassImp(AliAODDeltaECut)
  14 ClassImp(AliAODDeltaPCut)
  15 ClassImp(AliAODDeltaPvectorCut)
  16 ClassImp(AliAODDeltaPhiCut)
  17 ClassImp(AliAODDeltaThetaCut)
  18
  19 /******************************************************************/
  20 ClassImp(AliAODAvSeparationCut)
  21
  22 Double_t AliAODAvSeparationCut::GetValue(AliAODPair* pair) const
  23 {
  24   //chacks if avarage distance of two tracks is in given range
  25   AliTrackPoints* tpts1 = pair->Particle1()->GetTPCTrackPoints();
  26   if ( tpts1 == 0x0)
  27    {//it could be simulated pair
  28 //     Warning("GetValue","Track 1 does not have Track Points. Pair NOT Passed.");
  29      return -1.0;
  30    }
  31
  32   AliTrackPoints* tpts2 = pair->Particle2()->GetTPCTrackPoints();
  33   if ( tpts2 == 0x0)
  34    {
  35 //     Warning("GetValue","Track 2 does not have Track Points. Pair NOT Passed.");
  36      return -1.0;
  37    }
  38
  39   return tpts1->AvarageDistance(*tpts2);
  40 }
  41 /******************************************************************/
  42 ClassImp(AliAODSeparationCut)
  43
  44 Double_t AliAODSeparationCut::GetValue(AliAODPair* pair) const
  45 {
  46   //chacks if avarage distance of two tracks is in given range
  47   AliTrackPoints* tpts1 = pair->Particle1()->GetTPCTrackPoints();
  48   if ( tpts1 == 0x0)
  49    {//it could be simulated pair
  50 //     Warning("GetValue","Track 1 does not have Track Points. Pair NOT Passed.");
  51      return -1.0;
  52    }
  53
  54   AliTrackPoints* tpts2 = pair->Particle2()->GetTPCTrackPoints();
  55   if ( tpts2 == 0x0)
  56    {
  57 //     Warning("GetValue","Track 2 does not have Track Points. Pair NOT Passed.");
  58      return -1.0;
  59    }
  60   Float_t x1=0,y1=0,z1=0;
  61   Float_t x2=0,y2=0,z2=0;
  62
  63   tpts1->PositionAt(fPoint,x1,y1,z1);
  64   tpts2->PositionAt(fPoint,x2,y2,z2);
  65   Double_t dx1 = x1 - x2;
  66   Double_t dy1 = y1 - y2;
  67   Double_t dz1 = z1 - z2;
  68   Double_t d = TMath::Sqrt(dx1*dx1 + dy1*dy1 + dz1*dz1);
  69   return d;
  70 }
  71 /******************************************************************/
  72
  73 ClassImp(AliAODITSSeparationCut)
  74
  75 Bool_t AliAODITSSeparationCut::Rejected(AliAODPair* pair) const
  76 {
  77  //Checks if two tracks do not cross first pixels too close to each other
  78  //If two tracks use the same cluster in pixels they are given
  79  //the same position what skews theta angles (both are the same)
  80  //These guys create artificial correlation in non-id analyses
  81  //which is positive for identical polar angles (Qlong=0)
  82  //and negative for a little bit different theta angle (Qlong=epsilon)
  83  //Such tracks "attracks" each other.
  84
  85   AliTrackPoints* tpts1 = pair->Particle1()->GetITSTrackPoints();
  86   if ( tpts1 == 0x0)
  87    {//it could be simulated pair
  88      Warning("Pass","Track 1 does not have ITS Track Points. Pair NOT Passed.");
  89      return kTRUE;//reject
  90    }
  91
  92   AliTrackPoints* tpts2 = pair->Particle2()->GetITSTrackPoints();
  93   if ( tpts2 == 0x0)
  94    {
  95      Warning("Pass","Track 2 does not have ITS Track Points. Pair NOT Passed.");
  96      return kTRUE;//reject
  97    }
  98   Float_t  x1=0.0,y1=0.0,z1=0.0,x2=0.0,y2=0.0,z2=0.0;
  99   tpts1->PositionAt(fLayer,x1,y1,z1);
 100   tpts2->PositionAt(fLayer,x2,y2,z2);
 101
 102 //  Info("Pass","rphi %f z %f",fMin,fMax);
 103 //  Info("Pass","P1: %f %f %f", x1,y1,z1);
 104 //  Info("Pass","P2: %f %f %f", x2,y2,z2);
 105
 106   Double_t dz = TMath::Abs(z1-z2);
 107
 108   //fMax encodes treshold valaue of distance in Z
 109   if (dz > fMax) return kFALSE;//pair accepted
 110
 111   Double_t drphi = TMath::Hypot(x1-x2,y1-y2);
 112
 113   //fMin encodes treshold valaue of distance in r-phi
 114   if (drphi > fMin) return kFALSE;
 115
 116   return kTRUE;//they are too close, rejected
 117 }
 118 /******************************************************************/
 119
 120 ClassImp(AliAODCluterOverlapCut)
 121
 122 Double_t  AliAODCluterOverlapCut::GetValue(AliAODPair* pair) const
 123 {
 124   //Returns Cluter Overlap Factor
 125   //It ranges between -0.5 (in all padrows both tracks have cluters)
 126   // and 1 (in all padrows one track has cluter and second has not)
 127   // When Overlap Factor is 1 this pair of tracks in highly probable to be
 128   // splitted track: one particle that is recontructed twise
 129
 130   AliClusterMap* cm1 = pair->Particle1()->GetClusterMap();
 131   if ( cm1 == 0x0)
 132    {
 133      Warning("GetValue","Track 1 does not have Cluster Map. Returning -0.5.");
 134      return -.5;
 135    }
 136
 137   AliClusterMap* cm2 = pair->Particle2()->GetClusterMap();
 138   if ( cm2 == 0x0)
 139    {
 140      Warning("GetValue","Track 2 does not have Cluster Map. Returning -0.5.");
 141      return -.5;
 142    }
 143   return cm1->GetOverlapFactor(*cm2);
 144 }
 145 /******************************************************************/
 146 ClassImp(AliAODOutSideSameSignCut)
 147
 148 Bool_t AliAODOutSideSameSignCut::Rejected(AliAODPair *p) const
 149 {
 150   //returns kTRUE if pair DO NOT meet cut criteria
 151
 152   if ( p->GetQOutLCMS()*p->GetQSideLCMS() > 0 )
 153    {
 154      return kFALSE;//accpeted
 155    }
 156
 157   return kTRUE ;//rejected
 158 }
 159 /******************************************************************/
 160 ClassImp(AliAODOutSideDiffSignCut)
 161
 162 Bool_t AliAODOutSideDiffSignCut::Rejected(AliAODPair *p) const
 163 {
 164   //returns kTRUE if pair DO NOT meet cut criteria
 165
 166   if ( p->GetQOutLCMS()*p->GetQSideLCMS() > 0 )
 167    {
 168      return kTRUE;//rejected
 169    }
 170
 171   return kFALSE;//accepted
 172 }
 173 /******************************************************************/
 174 ClassImp( AliAODLogicalOperPairCut )
 175
 176 AliAODLogicalOperPairCut::AliAODLogicalOperPairCut():
 177  AliAODPairBaseCut(-10e10,10e10,kHbtPairCutPropNone),
 178  fFirst(new AliAODDummyBasePairCut),
 179  fSecond(new AliAODDummyBasePairCut)
 180 {
 181  //ctor
 182 }
 183 /******************************************************************/
 184
 185 AliAODLogicalOperPairCut::AliAODLogicalOperPairCut(AliAODPairBaseCut* first, AliAODPairBaseCut* second):
 186  AliAODPairBaseCut(-10e10,10e10,kHbtPairCutPropNone),
 187  fFirst((first)?(AliAODPairBaseCut*)first->Clone():0x0),
 188  fSecond((second)?(AliAODPairBaseCut*)second->Clone():0x0)
 189 {
 190   //ctor
 191   //note that base cuts are copied, not just pointers assigned
 192   if ( (fFirst && fSecond) == kFALSE)
 193    {
 194      Fatal("AliAODLogicalOperPairCut","One of parameters is NULL!");
 195    }
 196 }
 197 /******************************************************************/
 198
 199 AliAODLogicalOperPairCut::~AliAODLogicalOperPairCut()
 200 {
 201   //destructor
 202   delete fFirst;
 203   delete fSecond;
 204 }
 205 /******************************************************************/
 206
 207 Bool_t AliAODLogicalOperPairCut::AliAODDummyBasePairCut::Rejected(AliAODPair* /*pair*/)  const
 208 {
 209   //checks if particles passes properties defined by this cut
 210   Warning("Pass","You are using dummy base cut! Probobly some logical cut is not set up properly");
 211   return kFALSE;//accept
 212 }
 213 /******************************************************************/
 214
 215 void AliAODLogicalOperPairCut::Streamer(TBuffer &b)
 216 {
 217   // Stream all objects in the array to or from the I/O buffer.
 218   UInt_t R__s, R__c;
 219   if (b.IsReading())
 220    {
 221      delete fFirst;
 222      delete fSecond;
 223      fFirst  = 0x0;
 224      fSecond = 0x0;
 225
 226      b.ReadVersion(&R__s, &R__c);
 227      TObject::Streamer(b);
 228      b >> fFirst;
 229      b >> fSecond;
 230      b.CheckByteCount(R__s, R__c,AliAODLogicalOperPairCut::IsA());
 231    }
 232   else
 233    {
 234      R__c = b.WriteVersion(AliAODLogicalOperPairCut::IsA(), kTRUE);
 235      TObject::Streamer(b);
 236      b << fFirst;
 237      b << fSecond;
 238      b.SetByteCount(R__c, kTRUE);
 239   }
 240 }
 241
 242 /******************************************************************/
 243 ClassImp(AliAODOrPairCut)
 244
 245 Bool_t AliAODOrPairCut::Rejected(AliAODPair * p) const
 246 {
 247   //returns true when rejected
 248   //AND operation is a little bit misleading but is correct
 249   //User wants to build logical cuts with natural (positive) logic
 250   //while ALIAN use inernally reverse (returns true when rejected)
 251   if (fFirst->Rejected(p) && fSecond->Rejected(p) ) return kTRUE;//rejected (both rejected, returned kTRUE)
 252   return kFALSE;//accepted, at least one accepted (returned kFALSE)
 253 }
 254 /******************************************************************/
 255
 256 ClassImp(AliAODAndPairCut)
 257
 258 Bool_t AliAODAndPairCut::Rejected(AliAODPair * p)  const
 259 {
 260   //returns true when rejected
 261   //OR operation is a little bit misleading but is correct
 262   //User wants to build logical cuts with natural (positive) logic
 263   //while ALIAN use inernally reverse (returns true when rejected)
 264   if (fFirst->Rejected(p))
 265    {//first rejected - we reject
 266      return kTRUE;
 267    }
 268   else
 269    {//first accepted
 270     if (fSecond->Rejected(p))
 271      {//second rejected - we reject
 272        return kTRUE;
 273      }
 274    }
 275 //  if (fFirst->Rejected(p) || fSecond->Rejected(p)) return kTRUE;//rejected (any of two rejected(returned kTRUE) )
 276
 277   return kFALSE;//accepted (both accepted (returned kFALSE))
 278 }
 279 /******************************************************************/