EVE/EveDet/AliEveTPCSectorData.cxx

   1 // $Id$
   2 // Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
   3
   4 /**************************************************************************
   5  * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
   6  * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for          *
   7  * full copyright notice.                                                 *
   8  **************************************************************************/
   9
  10 #include "AliEveTPCSectorData.h"
  11 #include <AliTPCParamSR.h>
  12
  13 #include <set>
  14 #include <string.h>
  15
  16 //==============================================================================
  17 //==============================================================================
  18 // AliEveTPCSectorData
  19 //==============================================================================
  20
  21 //______________________________________________________________________________
  22 //
  23 // Stores data from a fiven TPC sector.
  24 //
  25 // Row addresses grow linearly by radius, there is no separation on
  26 // inner/outer segments. The SegmentInfo objects can be used to get
  27 // information about low-level segments.
  28 //
  29 // A lot of TPC-sector geometry information is stored as static data.
  30 //
  31 // For accessing data, see for example AliEveTPCSector2DGL::CreateTexture()
  32 // and LoadPadrow().
  33 //
  34
  35 ClassImp(AliEveTPCSectorData)
  36
  37 AliTPCParam* AliEveTPCSectorData::fgParam    = 0;
  38 Float_t      AliEveTPCSectorData::fgZLength  = 0;
  39 Int_t        AliEveTPCSectorData::fgNAllRows = 0;
  40 Int_t        AliEveTPCSectorData::fgNAllPads = 0;
  41 Int_t*       AliEveTPCSectorData::fgRowBegs  = 0;
  42
  43 AliEveTPCSectorData::SegmentInfo AliEveTPCSectorData::fgInnSeg;
  44 AliEveTPCSectorData::SegmentInfo AliEveTPCSectorData::fgOut1Seg;
  45 AliEveTPCSectorData::SegmentInfo AliEveTPCSectorData::fgOut2Seg;
  46
  47 AliEveTPCSectorData::SegmentInfo* AliEveTPCSectorData::fgSegInfoPtrs[3] = {0};
  48
  49 /******************************************************************************/
  50
  51 void AliEveTPCSectorData::InitStatics()
  52 {
  53   // Initialize static variables.
  54
  55   if (fgParam != 0) return;
  56
  57   fgParam    = new AliTPCParamSR;
  58   fgZLength  = fgParam->GetZLength(0) + 0.275;
  59   fgNAllRows = fgParam->GetNRowLow()  + fgParam->GetNRowUp();
  60   fgNAllPads = 0;
  61   fgRowBegs  = new Int_t[fgNAllRows + 1];
  62
  63   {
  64     Int_t row = 0;
  65     for (Int_t i=0; i<fgParam->GetNRowLow(); ++i, ++row)
  66     {
  67       fgRowBegs[row] = fgNAllPads;
  68       fgNAllPads += fgParam->GetNPadsLow(i);
  69     }
  70     for (Int_t i=0; i<fgParam->GetNRowUp(); ++i, ++row)
  71     {
  72       fgRowBegs[row] = fgNAllPads;
  73       fgNAllPads += fgParam->GetNPadsUp(i);
  74     }
  75     fgRowBegs[fgNAllRows] = fgNAllPads;
  76   }
  77
  78   // Fill SegmentInfos, used by rendering classes.
  79
  80   // General paramameters
  81   fgInnSeg.fPadWidth   = fgParam->GetInnerPadPitchWidth();
  82   fgInnSeg.fPadHeight  = fgParam->GetInnerPadPitchLength();
  83   fgInnSeg.fRLow       = fgParam->GetPadRowRadiiLow(0);
  84   fgInnSeg.fNRows      = fgParam->GetNRowLow();
  85   fgInnSeg.fFirstRow   = 0;
  86   fgInnSeg.fLastRow    = fgInnSeg.fNRows - 1;
  87   fgInnSeg.fNMaxPads   = fgParam->GetNPadsLow(fgInnSeg.fNRows - 1);
  88   fgSegInfoPtrs[0]     = &fgInnSeg;
  89
  90   fgOut1Seg.fPadWidth  = fgParam->GetOuterPadPitchWidth();
  91   fgOut1Seg.fPadHeight = fgParam->GetOuter1PadPitchLength();
  92   fgOut1Seg.fRLow      = fgParam->GetPadRowRadiiUp(0);
  93   fgOut1Seg.fNRows     = fgParam->GetNRowUp1();
  94   fgOut1Seg.fFirstRow  = fgInnSeg.fNRows;
  95   fgOut1Seg.fLastRow   = fgOut1Seg.fFirstRow + fgOut1Seg.fNRows - 1;
  96   fgOut1Seg.fNMaxPads  = fgParam->GetNPadsUp(fgOut1Seg.fNRows - 1);
  97   fgSegInfoPtrs[1]     = &fgOut1Seg;
  98
  99   fgOut2Seg.fPadWidth  = fgParam->GetOuterPadPitchWidth();
 100   fgOut2Seg.fPadHeight = fgParam->GetOuter2PadPitchLength();
 101   fgOut2Seg.fRLow      = fgParam->GetPadRowRadiiUp(fgOut1Seg.fNRows);
 102   fgOut2Seg.fNRows     = fgParam->GetNRowUp() - fgOut1Seg.fNRows;
 103   fgOut2Seg.fFirstRow  = fgOut1Seg.fLastRow + 1;
 104   fgOut2Seg.fLastRow   = fgOut2Seg.fFirstRow + fgOut2Seg.fNRows - 1;
 105   fgOut2Seg.fNMaxPads  = fgParam->GetNPadsUp(fgParam->GetNRowUp() - 1);
 106   fgSegInfoPtrs[2]     = &fgOut2Seg;
 107
 108   // Set stepsize arrays
 109
 110   { // Inner
 111     Int_t k=0, npads = fgParam->GetNPadsLow(0);
 112     for (Int_t row = 0; row < fgInnSeg.fNRows; ++row)
 113     {
 114       if (fgParam->GetNPadsLow(row) > npads)
 115       {
 116         npads = fgParam->GetNPadsLow(row);
 117         fgInnSeg.fYStep[k] = row*fgInnSeg.fPadHeight + fgInnSeg.fRLow;
 118         k++;
 119       }
 120     }
 121     fgInnSeg.fNYSteps = k;
 122   }
 123
 124   {  // Outer 1 seg
 125     Int_t k=0, npads = fgParam->GetNPadsUp(0);
 126     for (Int_t row = 0; row < fgOut1Seg.fNRows; ++row)
 127     {
 128       if (fgParam->GetNPadsUp(row) > npads)
 129       {
 130         npads = fgParam->GetNPadsUp(row);
 131         fgOut1Seg.fYStep[k] = row*fgOut1Seg.fPadHeight + fgOut1Seg.fRLow ;
 132         k++;
 133       }
 134     }
 135     fgOut1Seg.fNYSteps = k;
 136   }
 137
 138   {  // Outer 2 seg
 139     Int_t k=0, npads = fgParam->GetNPadsUp(fgOut1Seg.fNRows);
 140     for (Int_t row = fgOut1Seg.fNRows; row < fgParam->GetNRowUp(); ++row)
 141     {
 142       if (fgParam->GetNPadsUp(row) > npads)
 143       {
 144         npads = fgParam->GetNPadsUp(row);
 145         fgOut2Seg.fYStep[k] = (row - fgOut1Seg.fNRows)*fgOut2Seg.fPadHeight + fgOut2Seg.fRLow ;
 146         k++;
 147       }
 148     }
 149     fgOut2Seg.fNYSteps = k;
 150   }
 151 }
 152
 153 Int_t AliEveTPCSectorData::GetNPadsInRow(Int_t row)
 154 {
 155   // Return number of pads in given row.
 156
 157   if (row < 0 || row >= fgNAllRows) return 0;
 158   return fgRowBegs[row + 1] - fgRowBegs[row];
 159 }
 160
 161 const AliEveTPCSectorData::SegmentInfo& AliEveTPCSectorData::GetSeg(Int_t seg)
 162 {
 163   // Return reference to segment geometry information.
 164   // 0 ~ inner, 1 ~ middle, 2 ~ outer.
 165
 166   static const SegmentInfo null;
 167
 168   if (seg < 0 || seg > 2)
 169     return null;
 170   else
 171     return *fgSegInfoPtrs[seg];
 172 }
 173
 174 /******************************************************************************/
 175 // True member functions start here.
 176 /******************************************************************************/
 177
 178 void AliEveTPCSectorData::NewBlock()
 179 {
 180   // Create new data-block. Position is set to the beginning.
 181
 182   fBlocks.push_back(new Short_t[fkBlockSize]);
 183   fBlockPos = 0;
 184 }
 185
 186 /******************************************************************************/
 187
 188 AliEveTPCSectorData::AliEveTPCSectorData(Int_t sector, Int_t bsize) :
 189   fSectorID(sector),  fNPadsFilled(0), fPads(),
 190   fkBlockSize(bsize), fBlockPos(0),    fBlocks(),
 191   fCurrentRow(0), fCurrentPad(0), fCurrentPos(0), fCurrentStep(0)
 192 {
 193   // Constructor.
 194
 195   memset(fPadBuffer,0,2048*sizeof(Short_t));
 196
 197   if (fgParam == 0) InitStatics();
 198
 199   fPads.assign(fgNAllPads, PadData());
 200   fBlocks.reserve(16);
 201   fBlockPos = fkBlockSize; // Enforce creation of a new block.
 202 }
 203
 204
 205 AliEveTPCSectorData::~AliEveTPCSectorData()
 206 {
 207   // Destructor.
 208
 209   for (std::vector<Short_t*>::iterator b=fBlocks.begin(); b!=fBlocks.end(); ++b)
 210     delete [] *b;
 211 }
 212
 213 void AliEveTPCSectorData::DropData()
 214 {
 215   // Drop data, deallocate data-blocks.
 216
 217   fPads.assign(fgNAllPads, PadData());
 218   for (std::vector<Short_t*>::iterator b=fBlocks.begin(); b!=fBlocks.end(); ++b)
 219     delete [] *b;
 220   fBlocks.clear();
 221   fBlockPos = fkBlockSize; // Enforce creation of a new block.
 222 }
 223
 224 /******************************************************************************/
 225
 226 void AliEveTPCSectorData::Print(Option_t* /*opt*/) const
 227 {
 228   // Print summary information.
 229
 230   printf("AliEveTPCSectorData sector=%d, NPadsFilled=%d, NBlocks=%d, BlockPos=%d\n",
 231          fSectorID, fNPadsFilled, (Int_t) fBlocks.size(), fBlockPos);
 232 }
 233
 234 /******************************************************************************/
 235
 236 void AliEveTPCSectorData::BeginPad(Int_t row, Int_t pad, Bool_t reverseTime)
 237 {
 238   // Begin filling of pad-data as specified with arguments.
 239
 240   fCurrentRow = row;
 241   fCurrentPad = pad;
 242   if (reverseTime) {
 243     fCurrentPos  = 2046;
 244     fCurrentStep = -2;
 245   } else {
 246     fCurrentPos  = 0;
 247     fCurrentStep = 2;
 248   }
 249   //printf("begpad for row=%d pad=%d\n  buf=%p pos=%d step=%d\n",
 250   //     fCurrentRow, fCurrentPad,
 251   //     fPadBuffer, fCurrentPos, fCurrentStep);
 252 }
 253
 254 void AliEveTPCSectorData::EndPad(Bool_t autoPedestal, Short_t threshold)
 255 {
 256   // End filling of pad-data. At this point data is compressed and moved
 257   // into the cuurent position in memory block.
 258
 259   Short_t *beg, *end;
 260   if (fCurrentStep > 0) {
 261     beg = fPadBuffer;
 262     end = fPadBuffer + fCurrentPos;
 263   } else {
 264     beg = fPadBuffer + fCurrentPos + 2;
 265     end = fPadBuffer + 2048;
 266   }
 267
 268   //printf("endpad for row=%d pad=%d\n  buf=%p beg=%p end=%p pos=%d step=%d\n",
 269   //     fCurrentRow, fCurrentPad,
 270   //     fPadBuffer, beg, end, fCurrentPos, fCurrentStep);
 271   if (beg >= end)
 272     return;
 273
 274   if (autoPedestal) {
 275     Short_t array[1024];
 276     Short_t* val;
 277     val = beg + 1;
 278     while (val <= end) {
 279       array[(val-beg)/2] = *val;
 280       val += 2;
 281     }
 282     Short_t pedestal = TMath::Nint(TMath::Median((end-beg)/2, array));
 283     val = beg + 1;
 284     while (val <= end) {
 285       *val -= pedestal;
 286       val += 2;
 287     }
 288     Short_t* wpos = beg;
 289     Short_t* rpos = beg;
 290     while (rpos < end) {
 291       if (rpos[1] >= threshold) {
 292         wpos[0] = rpos[0];
 293         wpos[1] = rpos[1];
 294         wpos += 2;
 295       }
 296       rpos += 2;
 297     }
 298     end = wpos;
 299   }
 300
 301   Short_t* wpos = beg;
 302   Short_t* rpos = beg;
 303
 304   // Compress pad buffer
 305   while (rpos < end) {
 306     Short_t* spos = rpos;
 307     Short_t  t    = spos[0];
 308     while (true) {
 309       rpos += 2;
 310       if (rpos >= end || *rpos > t + 1 || t == 0)
 311         break;
 312       ++t;
 313     }
 314     Short_t n = t - spos[0] + 1;
 315     if (n == 1) {
 316       wpos[0] = -spos[0];
 317       wpos[1] =  spos[1];
 318       wpos += 2;
 319     } else {
 320       wpos[0] = spos[0];
 321       wpos[2] = spos[1];
 322       wpos[1] = n;
 323       wpos += 3; spos += 3;
 324       while (--n) {
 325         *wpos = *spos;
 326         ++wpos; spos += 2;
 327       }
 328     }
 329   }
 330
 331   // Copy buffer to storage, set PadData
 332   if (wpos > beg) {
 333     Short_t len = wpos - beg;
 334     if (len > fkBlockSize - fBlockPos)
 335       NewBlock();
 336     Short_t *dest = fBlocks.back() + fBlockPos;
 337     memcpy(dest, beg, len*sizeof(Short_t));
 338     fBlockPos += len;
 339
 340     PadData& pad = fPads[PadIndex(fCurrentRow, fCurrentPad)];
 341     pad.SetDataLength(dest, len);
 342   }
 343
 344   ++fNPadsFilled;
 345 }
 346
 347 /******************************************************************************/
 348
 349 const AliEveTPCSectorData::PadData& AliEveTPCSectorData::GetPadData(Int_t padAddr) const
 350 {
 351   // Get pad-data reference by absolute index.
 352
 353   static const PadData kNull;
 354
 355   if (padAddr < 0 || padAddr >= fgNAllPads) return kNull;
 356   return fPads[padAddr];
 357 }
 358
 359 const AliEveTPCSectorData::PadData& AliEveTPCSectorData::GetPadData(Int_t row, Int_t pad) const
 360 {
 361   // Get pad-data reference by row and pad number.
 362
 363   static const PadData kNull;
 364
 365   Int_t np = GetNPadsInRow(row);
 366   if (np == 0 || pad < 0 || pad >= np) return kNull;
 367   return GetPadData(fgRowBegs[row] + pad);
 368 }
 369
 370 AliEveTPCSectorData::PadIterator AliEveTPCSectorData::MakePadIterator(Int_t padAddr, Short_t thr)
 371 {
 372   // Get pad-data iterator by absolute index.
 373
 374   return PadIterator(GetPadData(padAddr), thr);
 375 }
 376
 377 AliEveTPCSectorData::PadIterator AliEveTPCSectorData::MakePadIterator(Int_t row, Int_t pad, Short_t thr)
 378 {
 379   // Get pad-data iterator by row and pad number.
 380
 381   return PadIterator(GetPadData(row, pad), thr);
 382 }
 383
 384 AliEveTPCSectorData::RowIterator AliEveTPCSectorData::MakeRowIterator(Int_t row, Short_t thr)
 385 {
 386   // Get row iterator.
 387
 388   Short_t npads = GetNPadsInRow(row);
 389   if (npads > 0)
 390     return RowIterator(&fPads[fgRowBegs[row]], npads, thr);
 391   else
 392     return RowIterator(0, 0);
 393 }
 394
 395 /******************************************************************************/
 396 // AliEveTPCSectorData::PadData
 397 /******************************************************************************/
 398
 399 void AliEveTPCSectorData::PadData::Print(Option_t* /*opt*/)
 400 {
 401   // Print summary information.
 402
 403   printf("addr=%p, len=%hd>\n", (void*)fData, fLength);
 404   for (Int_t i=0; i<fLength; ++i)
 405     printf("  %3d %hd\n", i, fData[i]);
 406 }
 407
 408 /******************************************************************************/
 409 // AliEveTPCSectorData::PadIterator
 410 /******************************************************************************/
 411
 412 Bool_t AliEveTPCSectorData::PadIterator::Next()
 413 {
 414   // Move iterator to next signal above the iteration threshold.
 415   // Returns false when the end of data is reached.
 416
 417   if (fPos >= fEnd) return kFALSE;
 418   if (fNChunk > 0) {
 419     ++fTime;
 420     --fNChunk;
 421     fSignal = *fPos; ++fPos;
 422   } else {
 423     fTime = fPos[0];
 424     if (fTime <= 0) {
 425       fTime   = -fTime;
 426       fSignal = fPos[1];
 427       fPos += 2;
 428     } else {
 429       fNChunk = fPos[1] - 1;
 430       fSignal = fPos[2];
 431       fPos += 3;
 432     }
 433   }
 434   return (fSignal > fThreshold) ? kTRUE : Next();
 435 }
 436
 437 void AliEveTPCSectorData::PadIterator::Reset()
 438 {
 439   // Return to the beginning of the pad-data. Must call Next() to get to
 440   // the first stored signal.
 441
 442   fPos    = fBeg;
 443   fTime   = -1;
 444   fSignal = -1;
 445   fNChunk = 0;
 446 }
 447
 448 void AliEveTPCSectorData::PadIterator::Reset(const PadData& pd)
 449 {
 450   // Reinitialize to new pad-data. Must call Next() to get to the
 451   // first stored signal.
 452
 453   fBeg = pd.Data();
 454   fEnd = pd.Data() + pd.Length();
 455   fPos = pd.Data();
 456   Reset();
 457 }
 458
 459 void AliEveTPCSectorData::PadIterator::Test()
 460 {
 461   while (Next())
 462     printf("  %3d %d\n", fTime, fSignal);
 463 }
 464
 465 /******************************************************************************/
 466 // AliEveTPCSectorData::RowIterator
 467 /******************************************************************************/
 468
 469 Bool_t AliEveTPCSectorData::RowIterator::NextPad()
 470 {
 471   // Move iterator to next pad.
 472
 473   ++fPad;
 474   if(fPad >= fNPads) return kFALSE;
 475   Reset(fPadArray[fPad]);
 476   return kTRUE;
 477 }
 478
 479 void AliEveTPCSectorData::RowIterator::ResetRow()
 480 {
 481   // Return to the beginning of the row. Must call NextPad() to get to
 482   // the zeroth pad.
 483
 484   fPad = -1;
 485 }
 486
 487 void AliEveTPCSectorData::RowIterator::ResetRow(const PadData* first, Short_t npads)
 488 {
 489   // Reinitialize to another pad-data array. Must call NextPad() to
 490   // get to the zeroth pad.
 491
 492   fPadArray =  first;
 493   fNPads    =  npads;
 494   fPad      = -1;
 495 }
 496
 497 /******************************************************************************/
 498 // AliEveTPCSectorData::SegmentInfo
 499 /******************************************************************************/
 500
 501 //______________________________________________________________________________
 502 //
 503 // Stores geometry data about a segment needed for fast data-access
 504 // and rendering
 505
 506 ClassImp(AliEveTPCSectorData::SegmentInfo)
 507
 508 AliEveTPCSectorData::SegmentInfo::SegmentInfo() :
 509   TObject(),
 510
 511   fPadWidth(0), fPadHeight(0),
 512   fRLow(0), fNRows(0), fFirstRow(0), fLastRow(0),
 513   fNMaxPads(0),
 514   fNYSteps(0)
 515 {
 516   // Constructor.
 517
 518   memset(fYStep, 0, sizeof(fYStep));
 519 }