HLT/TRD/AliHLTTRDTracklet.cxx

   1 // $Id$
   2
   3 /**************************************************************************
   4  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   5  *                                                                        *
   6  * Authors:                                                               *
   7  *          for The ALICE HLT Project.                                    *
   8  *                                                                        *
   9  * Permission to use, copy, modify and distribute this software and its   *
  10  * documentation strictly for non-commercial purposes is hereby granted   *
  11  * without fee, provided that the above copyright notice appears in all   *
  12  * copies and that both the copyright notice and this permission notice   *
  13  * appear in the supporting documentation. The authors make no claims     *
  14  * about the suitability of this software for any purpose. It is          *
  15  * provided "as is" without express or implied warranty.                  *
  16  **************************************************************************/
  17
  18 //  @file   AliHLTTRDTracklet.cxx
  19 //  @author Theodor Rascanu
  20 //  @date
  21 //  @brief  A datacontainer for tracklets for the HLT.
  22 //
  23
  24 #include "AliHLTTRDTracklet.h"
  25
  26 /**
  27  * Default Constructor
  28  */
  29 //============================================================================
  30 AliHLTTRDTracklet::AliHLTTRDTracklet():
  31   fN(0),
  32   fdX(-1),
  33   fS2Y(-1),
  34   fPt(-1),
  35   fX0(-1),
  36   fChi2(-1),
  37   // fExB(-1),
  38   // fVD(-1),
  39   // fT0(-1),
  40   // fS2PRF(-1),
  41   // fDiffL(-1),
  42   // fDiffT(-1),
  43   // fX(-1),
  44   // fY(-1),
  45   // fZ(-1),
  46   // fS2Z(-1),
  47   fDet(-1),
  48   fBits(0),
  49   fCount(0),
  50 #if defined(__HP_aCC) || defined(__DECCXX) || defined(__SUNPRO_CC)
  51   fSize(sizeof(AliHLTTRDTracklet)-sizeof(fClusters[0])),
  52 #else
  53   fSize(sizeof(AliHLTTRDTracklet))
  54 #endif
  55 {
  56   InitArrays();
  57 }
  58
  59 /**
  60  * Main Constructor
  61  */
  62 //============================================================================
  63 AliHLTTRDTracklet::AliHLTTRDTracklet(const AliTRDseedV1* const inTracklet):
  64   fN(inTracklet->fN),
  65   fdX(inTracklet->fdX),
  66   fS2Y(inTracklet->fS2Y),
  67   fPt(inTracklet->fPt),
  68   fX0(inTracklet->fX0),
  69   fChi2(inTracklet->fChi2),
  70   // fExB(inTracklet->fExB),
  71   // fVD(inTracklet->fVD),
  72   // fT0(inTracklet->fT0),
  73   // fS2PRF(inTracklet->fS2PRF),
  74   // fDiffL(inTracklet->fDiffL),
  75   // fDiffT(inTracklet->fDiffT),
  76   // fX(inTracklet->fX),
  77   // fY(inTracklet->fY),
  78   // fZ(inTracklet->fZ),
  79   // fS2Z(inTracklet->fS2Z),
  80   fDet(inTracklet->fDet),
  81   fBits(0),
  82   fCount(0),
  83 #if defined(__HP_aCC) || defined(__DECCXX) || defined(__SUNPRO_CC)
  84   fSize(sizeof(AliHLTTRDTracklet)-sizeof(fClusters[0])),
  85 #else
  86   fSize(sizeof(AliHLTTRDTracklet))
  87 #endif
  88 {
  89   CopyDataMembers(inTracklet);
  90 }
  91
  92 /**
  93  * Copy simple (non-pointer) data members from TRDTracklet to HLTTRDTracklet
  94  */
  95 //============================================================================
  96 void AliHLTTRDTracklet::CopyDataMembers(const AliTRDseedV1* const inTracklet)
  97 {
  98   for (Int_t i=0; i < 2; i++){
  99     fYref[i]   = inTracklet->fYref[i];
 100     fZref[i]   = inTracklet->fZref[i];
 101     fYfit[i]   = inTracklet->fYfit[i];
 102     fZfit[i]   = inTracklet->fZfit[i];
 103   }
 104   fC[0] = inTracklet->GetC();
 105 #ifndef HAVE_NOT_ALITRD_SEEDV1_r39693
 106   fC[1] = inTracklet->GetC(1);
 107 #endif //HAVE_NOT_ALITRD_SEEDV1_r39693
 108   for (Int_t i=0; i < 3; i++){
 109     fPad[i] = inTracklet->fPad[i];
 110     // fCov[i] = inTracklet->fCov[i];
 111   }
 112
 113   // for (Int_t i=0; i < 7; i++){
 114   //   fRefCov[i] = inTracklet->fRefCov[i];
 115   // }
 116
 117   // for (Int_t i=0; i < AliTRDseedV1::kNslices; i++){
 118   //   fdEdx[i] = inTracklet->fdEdx[i];
 119   // }
 120
 121   for (Int_t i=0; i < AliPID::kSPECIES; i++){
 122     fProb[i] = inTracklet->fProb[i];
 123   }
 124
 125   fBits = UInt_t(inTracklet->TestBits(-1)) >> 14;
 126
 127   for (Int_t iTimeBin = 0; iTimeBin < AliTRDseedV1::kNclusters; iTimeBin++){
 128     AliTRDcluster* trdCluster = inTracklet->GetClusters(iTimeBin);
 129     if (trdCluster){
 130       fPos[fCount] = iTimeBin;
 131       new (&fClusters[fCount]) AliHLTTRDExtCluster(trdCluster);
 132       fCount++;
 133       fSize += sizeof(fClusters[0]);
 134     }
 135   }
 136   //if((void*)&fClusters[fCount]!=(void*)GetEndPointer()){printf("ERRR");return;}
 137 }
 138
 139 /**
 140  * Copy data to the output TRDseedV1
 141  */
 142 //============================================================================
 143 void AliHLTTRDTracklet::ExportTRDTracklet(AliTRDseedV1* const outTracklet) const
 144 {
 145   //outTracklet->Reset(); we always use a fresh trdtracklet as input, so this is useless
 146   outTracklet->SetBit(AliTRDseedV1::kOwner);
 147
 148   outTracklet->fN      = fN;
 149   outTracklet->fdX     = fdX;
 150   outTracklet->fX0     = fX0;
 151   outTracklet->fS2Y    = fS2Y;
 152   outTracklet->fPt     = fPt;
 153   outTracklet->SetC(fC[0]);
 154 #ifndef HAVE_NOT_ALITRD_SEEDV1_r39693
 155   outTracklet->SetC(fC[1], 1);
 156 #endif //HAVE_NOT_ALITRD_SEEDV1_r39693
 157   outTracklet->fChi2   = fChi2;
 158   // outTracklet->fExB    = fExB;
 159   // outTracklet->fVD     = fVD;
 160   // outTracklet->fT0     = fT0;
 161   // outTracklet->fS2PRF  = fS2PRF;
 162   // outTracklet->fDiffL  = fDiffL;
 163   // outTracklet->fDiffT  = fDiffT;
 164   // outTracklet->fX      = fX;
 165   // outTracklet->fY      = fY;
 166   // outTracklet->fZ      = fZ;
 167   // outTracklet->fS2Z    = fS2Z;
 168   outTracklet->fDet    = fDet;
 169
 170   for (Int_t i=0; i < 2; i++){
 171     outTracklet->fYref[i]   = fYref[i];
 172     outTracklet->fZref[i]   = fZref[i];
 173     outTracklet->fYfit[i]   = fYfit[i];
 174     outTracklet->fZfit[i]   = fZfit[i];
 175   }
 176
 177   for (Int_t i=0; i < 3; i++){
 178     outTracklet->fPad[i] = fPad[i];
 179     // outTracklet->fCov[i] = fCov[i];
 180   }
 181
 182   // for (Int_t i=0; i < 7; i++){
 183   //   outTracklet->fRefCov[i] = fRefCov[i];
 184   // }
 185
 186   // for (Int_t i=0; i < AliTRDseedV1::kNslices; i++){
 187   //   outTracklet->fdEdx[i] = fdEdx[i];
 188   // }
 189
 190   for (Int_t i=0; i < AliPID::kSPECIES; i++){
 191     outTracklet->fProb[i] = fProb[i];
 192   }
 193
 194   outTracklet->SetBit(UInt_t(fBits)<<14);
 195
 196   for(Int_t iCluster=0; iCluster < fCount; iCluster++){
 197     AliTRDcluster *trdCluster = new AliTRDcluster();
 198     fClusters[iCluster].ExportTRDCluster(trdCluster);
 199     trdCluster->SetDetector(fDet);
 200     outTracklet->fClusters[fPos[iCluster]] = trdCluster;
 201     outTracklet->fIndexes[fPos[iCluster]] = iCluster;
 202   }
 203 }
 204
 205
 206 /**
 207  * Init arrays
 208  */
 209 //============================================================================
 210 void AliHLTTRDTracklet::InitArrays()
 211 {
 212   for (Int_t i=0; i < 2; i++){
 213     fYref[i] = -1;
 214     fZref[i] = -1;
 215     fYfit[i] = -1;
 216     fZfit[i] = -1;
 217   }
 218   fC[0] = 0.; fC[1] = 0.;
 219   for (Int_t i=0; i < AliPID::kSPECIES; i++)
 220     fProb[i]=0;
 221   for (Int_t i=0; i<AliTRDseedV1::kNclusters; i++)
 222     fPos[i]=0;
 223
 224 }
 225
 226 /**
 227  * Prints main info about tracklet
 228  */
 229 //============================================================================
 230 void AliHLTTRDTracklet::Print(Bool_t printClusters) const
 231 {
 232   //printf("--hltTracklet-- addr 0x%p(%i); fSize %i\n", this, (int)this, fSize);
 233   printf("      fDet %i; fPt %f; fdX %f fN %i\n", fDet, fPt, fdX, fN);
 234
 235   if(!printClusters) return;
 236   for (UInt_t iCluster = 0; iCluster < fCount; iCluster++){
 237     printf(" [%i] ",iCluster);
 238     fClusters[iCluster].Print();
 239   }
 240 }
 241
 242 /**
 243  * Save tracklet at block position
 244  */
 245 //============================================================================
 246 AliHLTUInt32_t AliHLTTRDTracklet::SaveAt(AliHLTUInt8_t *const block, const AliTRDseedV1* const inTracklet)
 247 {
 248   AliHLTUInt32_t size=0;
 249
 250   memcpy(block,inTracklet,sizeof(AliTRDseedV1));
 251   size+=sizeof(AliTRDseedV1);
 252
 253   for(int i=0; i<AliTRDseedV1::kNclusters; i++){
 254     AliTRDcluster* inClust = inTracklet->GetClusters(i);
 255     if(inClust) size+=AliHLTTRDCluster::SaveAt(block+size, inClust);
 256   }
 257
 258   return size;
 259 }
 260
 261 /**
 262  * Read tracklet from block
 263  */
 264 //============================================================================
 265 AliHLTUInt32_t AliHLTTRDTracklet::LoadFrom(AliTRDseedV1 *const outTracklet, const AliHLTUInt8_t *const block)
 266 {
 267   AliHLTUInt32_t size=0;
 268
 269   memcpy(((AliHLTUInt8_t*)outTracklet)+sizeof(void*),block+sizeof(void*),sizeof(AliTRDseedV1)-sizeof(void*));
 270   size+=sizeof(AliTRDseedV1);
 271
 272   for(int i=0; i<AliTRDseedV1::kNclusters; i++){
 273     if(outTracklet->GetClusters(i)){
 274       AliTRDcluster *const outClust = new AliTRDcluster;
 275       outTracklet->fClusters[i]=outClust;
 276       size+=AliHLTTRDCluster::LoadFrom(outClust, block+size);
 277     }
 278   }
 279
 280   outTracklet->SetBit(AliTRDseedV1::kOwner);
 281
 282   return size;
 283 }