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