ROOT logo
//-*- Mode: C++ -*-
// $Id$
#ifndef ALIHLTINDEXGRID_H
#define ALIHLTINDEXGRID_H
//* This file is property of and copyright by the ALICE HLT Project        * 
//* ALICE Experiment at CERN, All rights reserved.                         *
//* See cxx source for full Copyright notice                               *

/// @file   AliHLTIndexGrid.h
/// @author Matthias Richter
/// @date   2011-08-14
/// @brief  Index grid for 3 dimensional coordinates
///

#include "AliHLTDataTypes.h"
#include <iostream>
#include <iomanip>
#include <memory>
#include <cerrno>
#include <cmath>

template <typename T, typename V>
class AliHLTIndexGrid {
 public:
  AliHLTIndexGrid(T maxX, T stepX,
		  T maxY, T stepY,
		  T maxZ, T stepZ,
		  int initialDataSize=-1)
    : fMaxX(maxX)
    , fStepX(stepX)
    , fMaxY(maxY)
    , fStepY(stepY)
    , fMaxZ(maxZ)
    , fStepZ(stepZ)
    , fDimX(0)
    , fDimY(0)
    , fDimZ(0)
    , fCells(NULL)
    , fCellDimension(0)
    , fData(NULL)
    , fDataDimension(initialDataSize)
    , fCount(0)
    , fIterator()
    , fIteratorEnd()
  {
    // constructor
    if (fMaxX>0. && fMaxY>0. && fMaxZ>0 &&
	fStepX>0. && fStepY>0. && fStepZ>0) {
      fDimX=(int)ceil(fMaxX/fStepX);
      fDimY=(int)ceil(fMaxY/fStepY);
      fDimZ=(int)ceil(fMaxZ/fStepZ);

      fCellDimension=fDimX*fDimY*fDimZ;
      fCells=new AliHLTIndexGridCell[fCellDimension];
      if (fDataDimension<0) fDataDimension=fgkDefaultDataSize;
      fData=new V[fDataDimension];
      Clear();
    }
  }

  virtual ~AliHLTIndexGrid() {
    // destructor
    if (fData) delete [] fData;
    if (fCells) delete [] fCells;
  }

  // for now array of spacepoint ids
  typedef V ValueType;

  int GetDimensionX() const {return fDimX;}
  int GetDimensionY() const {return fDimY;}
  int GetDimensionZ() const {return fDimZ;}
  int GetXIndex(T x) const {
    if (x>fMaxX) return fDimX-1;
    if (x<0) return 0;
    return (int)(x/fStepX);
  }
  int GetYIndex(T y) const {
    if (y>fMaxY) return fDimY-1;
    if (y<0) return 0;
    return (int)(y/fStepY);
  }
  int GetZIndex(T z) const {
    if (z>fMaxZ) return fDimZ-1;
    if (z<0) return 0;
    return (int)(z/fStepZ);
  }
  int Index(int xindex, int yindex, int zindex) {
    return xindex*fDimY*fDimZ + yindex*fDimZ + zindex;
  }
  T GetLowerBoundX(int cell) const {
    if (fDimX==0 || fDimY==0 ||fDimZ==0) return (T)0;
    int index=cell/(fDimY*fDimZ);
    return index*fStepX;
  }
  T GetCenterX(int cell) const {
    if (fDimX==0 || fDimY==0 ||fDimZ==0) return (T)0;
    return GetLowerBoundX(cell)+fStepX/2;
  }
  T GetLowerBoundY(int cell) const {
    if (fDimX==0 || fDimY==0 ||fDimZ==0) return (T)0;
    int index=cell%(fDimY*fDimZ); index/=fDimZ;
    return index*fStepY;
  }
  T GetCenterY(int cell) const {
    if (fDimX==0 || fDimY==0 ||fDimZ==0) return (T)0;
    return GetLowerBoundY(cell)+fStepY/2;
  }
  T GetLowerBoundZ(int cell) const {
    if (fDimX==0 || fDimY==0 ||fDimZ==0) return (T)0;
    int index=cell%(fDimY*fDimZ); index%=fDimZ;
    return index*fStepZ;
  }
  T GetCenterZ(int cell) const {
    if (fDimX==0 || fDimY==0 ||fDimZ==0) return (T)0;
    return GetLowerBoundZ(cell)+fStepZ/2;
  }
  int GetCellIndex(T x, T y, T z) const {
    return GetXIndex(x)*fDimY*fDimZ + (y<0?0:GetYIndex(y))*fDimZ + (z<0?0:GetZIndex(z));
  }
  int GetNumberOfSpacePoints(int index=0, int endIndex=-1) const {
    if (!fCells) return 0;
    if (endIndex<0) endIndex=fCellDimension;
    int count=0;
    for (int cell=index; cell<endIndex && cell<fCellDimension && count<fCount; cell++) if (fCells[cell].fCount>0) count+=fCells[cell].fCount;
    return count;
  }

  // increment counter of the cell where the spacepoint is
  int CountSpacePoint(T x, T y, T z) {
    // increment counter of the cell where the spacepoint is
    int cell=GetCellIndex(x, y, z);
    if (cell<0 || !fCells || cell>=fCellDimension) return -EFAULT;
    if (fCells[cell].fCount<0) fCells[cell].fCount=1;
    else fCells[cell].fCount++;
    return 0;
  }


  // add spacepoint, all spacepoints must have been counted before
  int AddSpacePoint(ValueType t, T x, T y, T z) {
    // add spacepoint, all spacepoints must have been counted before
    int cell=GetCellIndex(x, y, z);
    if (cell<0 || !fCells || cell>=fCellDimension) return -EFAULT;
    if (fCells[cell].fFilled==fCells[cell].fCount) return -ENOSPC;
    if (fCells[cell].fStartIndex<0 && IndexCells()<0) return -EACCES;
    int offset=fCells[cell].fStartIndex+fCells[cell].fFilled;
    fData[offset]=t;
    fCells[cell].fFilled++;
    fCount++;
    return 0;
  }

  void Clear(const char* /*option*/="") {
    // clear internal data
    if (fCells) memset(fCells, 0xff, fCellDimension*sizeof(AliHLTIndexGridCell));
    if (fData) memset(fData, 0, fDataDimension*sizeof(V));
    fCount=0;
  }

  void Print(const char* /*option*/="") {
  // print info
  bool bPrintEmpty=false;
  ios::fmtflags coutflags=cout.flags(); // backup cout status flags
  cout << "AliHLTIndexGrid: " << (fCells?fCellDimension:0) << " cells" << endl;
  cout << "   x: " << fDimX << " [0," << fMaxX << "]" << endl;
  cout << "   y: " << fDimY << " [0," << fMaxY << "]" << endl;
  cout << "   z: " << fDimZ << " [0," << fMaxZ << "]" << endl;
  cout << "   " << GetNumberOfSpacePoints(0, fCellDimension) << " point(s)" << endl;
  if (fCells) {
    for (int i=0; i<fCellDimension; i++) {
      if (!bPrintEmpty && fCells[i].fCount<=0) continue;
      cout << "     " << setfill(' ') << setw(7) << fixed << setprecision(0) << i << " (" 
	  << " " << setw(3) << GetLowerBoundX(i)
	  << " " << setw(3) << GetLowerBoundY(i)
	  << " " << setw(4) << GetLowerBoundZ(i)
	  << "): ";
      cout << setw(3) << fCells[i].fCount << " entries, " << setw(3) << fCells[i].fFilled << " filled";
      cout << "  start index " << setw(5) << fCells[i].fStartIndex;
      cout << endl;
      if (fCells[i].fCount>0) {
	cout << "          ";
	for (iterator id=begin(GetLowerBoundX(i), GetLowerBoundY(i), GetLowerBoundZ(i));
	     id!=end(); id++) {
	  cout << " 0x" << hex << setw(8) << setfill('0') << id.Data();
	}
	cout  << endl;
      }
    }
  }
  cout.flags(coutflags); // restore the original flags
}


  class iterator {
  public:
  iterator()
    : fData(NULL) {}
  iterator(ValueType* pData)
    : fData(pData) {}
  iterator(const iterator& i)
    : fData(i.fData) {}
    iterator& operator=(const iterator& i)
      { if (this!=&i) {fData=i.fData;} return *this;}
    ~iterator() {fData=NULL;}

    bool operator==(const iterator& i) const  {return (fData!=NULL) && (fData==i.fData);}
    bool operator!=(const iterator& i) const  {return (fData!=NULL) && (fData!=i.fData);}
    // prefix operators
    iterator& operator++() {fData++; return *this;}
    iterator& operator--() {fData--; return *this;}
    // postfix operators
    iterator operator++(int) {iterator i(*this); fData++; return i;}
    iterator operator--(int) {iterator i(*this); fData--; return i;}

    iterator& operator+=(int step) {fData+=step; return *this;}

    const ValueType& Data() const {return *fData;}
    ValueType& Data() {return *fData;}

    ValueType operator*() {return *fData;}

  protected:
  private:
    ValueType* fData; //! data
  };

  // prepare iterator and end marker
  iterator& begin(T x=(T)-1, T y=(T)-1, T z=(T)-1) {
    fIterator.~iterator();
    fIteratorEnd.~iterator();

    int startIndex=0;
    if (x<0) {
      // get all data
      if (fData) {
	new (&fIterator) iterator(fData);
	fIteratorEnd=fIterator;
	fIteratorEnd+=fCount;
      }
      return fIterator;
    }

    // only search for the start index if specific x selected
    int cell=GetCellIndex(x, y, z);
    if (cell<0 || !fCells || cell>=fCellDimension) return fIterator;
    // get the index of the cell
    startIndex=fCells[cell].fStartIndex;
    if (!fData || startIndex>=fDataDimension) return fIterator;

    // get the range end position
    int endCell=cell+1;
    if (x<0) endCell=fCellDimension;
    else if (y<0) endCell=GetCellIndex(x+fStepX, (T)-1, (T)-1); // all entries for fixed x
    else if (z<0) endCell=GetCellIndex(x, y+fStepY, (T)-1); // all entries for fixed x and y
    if (endCell<=cell) {
      // cell index returned is never outside the array
      // so this is a special case where we get to the bounds of the array
      endCell=fCellDimension;
    }

    // find the first cell with content in the range 
    for (; startIndex<0 && cell<endCell;) {
      startIndex=fCells[++cell].fStartIndex;
    }
    if (startIndex<0) return fIterator;

    new (&fIterator) iterator(fData+startIndex);
    fIteratorEnd=fIterator;
    fIteratorEnd+=GetNumberOfSpacePoints(cell, endCell);
    return fIterator;
  }

  // get loop end marker
  iterator& end() {
    return fIteratorEnd;
  }

  iterator& find(ValueType v) {
    for (iterator i=begin(); i!=end(); i++) {
      if (i.Data()==v) {
	fIterator=i;
	return fIterator;
      }
    }
    return end();
  }

  // find cell of entry
  int FindCell(ValueType v) const {
    if (!fCells) return -1;
    for (int cell=0; cell<fCellDimension; cell++)
      for (int count=0; count<fCells[cell].fCount; count++)
	if (fData[fCells[cell].fStartIndex+count]==v)
	  return cell;
    return -1;
  }

  struct AliHLTIndexGridCell {
    int fCount;
    int fFilled;
    int fStartIndex;
  };

 protected:
 private:
  // standard constructor prohibited
  AliHLTIndexGrid();
  // copy constructor prohibited
  AliHLTIndexGrid(const AliHLTIndexGrid&);
  // assignment operator prohibited
  AliHLTIndexGrid& operator=(const AliHLTIndexGrid&);

  int IndexCells() {
    // set the start index for data of every cell based on the counts
    if (!fCells || fCellDimension<=0) return -ENOBUFS;
    int offset=0;
    int cell=0;
    for (; cell<fCellDimension; cell++) {
      if (fCells[cell].fCount<0) continue;
      fCells[cell].fStartIndex=offset;
      offset+=fCells[cell].fCount;
      fCells[cell].fFilled=0;
    }

    if (offset>fDataDimension) {
      // grow the data array
      auto_ptr<V> newArray(new V[offset]);
      if (newArray.get()) {
	memcpy(newArray.get(), fData, fDataDimension);
	memset(newArray.get()+fDataDimension, 0, (offset-fDataDimension)*sizeof(V));
	delete fData;
	fData=newArray.release();
	fDataDimension=offset;
      } else {
	for (cell=0; cell<fCellDimension; cell++) {
	  fCells[cell].fStartIndex=-1;
	}
      }
    }
    return 0;
  }


  T fMaxX;
  T fStepX;
  T fMaxY;
  T fStepY;
  T fMaxZ;
  T fStepZ;

  int fDimX;
  int fDimY;
  int fDimZ;

  AliHLTIndexGridCell* fCells; //! cell array
  int fCellDimension; //! size of cell array
  ValueType* fData; //! spacepoint data
  int fDataDimension; //! size of spacepoint data
  int fCount;

  iterator fIterator; //! iterator
  iterator fIteratorEnd; //! end marker iterator

  static const int fgkDefaultDataSize=10000; //! the default data size

  ClassDef(AliHLTIndexGrid, 0)
};

#endif
 AliHLTIndexGrid.h:1
 AliHLTIndexGrid.h:2
 AliHLTIndexGrid.h:3
 AliHLTIndexGrid.h:4
 AliHLTIndexGrid.h:5
 AliHLTIndexGrid.h:6
 AliHLTIndexGrid.h:7
 AliHLTIndexGrid.h:8
 AliHLTIndexGrid.h:9
 AliHLTIndexGrid.h:10
 AliHLTIndexGrid.h:11
 AliHLTIndexGrid.h:12
 AliHLTIndexGrid.h:13
 AliHLTIndexGrid.h:14
 AliHLTIndexGrid.h:15
 AliHLTIndexGrid.h:16
 AliHLTIndexGrid.h:17
 AliHLTIndexGrid.h:18
 AliHLTIndexGrid.h:19
 AliHLTIndexGrid.h:20
 AliHLTIndexGrid.h:21
 AliHLTIndexGrid.h:22
 AliHLTIndexGrid.h:23
 AliHLTIndexGrid.h:24
 AliHLTIndexGrid.h:25
 AliHLTIndexGrid.h:26
 AliHLTIndexGrid.h:27
 AliHLTIndexGrid.h:28
 AliHLTIndexGrid.h:29
 AliHLTIndexGrid.h:30
 AliHLTIndexGrid.h:31
 AliHLTIndexGrid.h:32
 AliHLTIndexGrid.h:33
 AliHLTIndexGrid.h:34
 AliHLTIndexGrid.h:35
 AliHLTIndexGrid.h:36
 AliHLTIndexGrid.h:37
 AliHLTIndexGrid.h:38
 AliHLTIndexGrid.h:39
 AliHLTIndexGrid.h:40
 AliHLTIndexGrid.h:41
 AliHLTIndexGrid.h:42
 AliHLTIndexGrid.h:43
 AliHLTIndexGrid.h:44
 AliHLTIndexGrid.h:45
 AliHLTIndexGrid.h:46
 AliHLTIndexGrid.h:47
 AliHLTIndexGrid.h:48
 AliHLTIndexGrid.h:49
 AliHLTIndexGrid.h:50
 AliHLTIndexGrid.h:51
 AliHLTIndexGrid.h:52
 AliHLTIndexGrid.h:53
 AliHLTIndexGrid.h:54
 AliHLTIndexGrid.h:55
 AliHLTIndexGrid.h:56
 AliHLTIndexGrid.h:57
 AliHLTIndexGrid.h:58
 AliHLTIndexGrid.h:59
 AliHLTIndexGrid.h:60
 AliHLTIndexGrid.h:61
 AliHLTIndexGrid.h:62
 AliHLTIndexGrid.h:63
 AliHLTIndexGrid.h:64
 AliHLTIndexGrid.h:65
 AliHLTIndexGrid.h:66
 AliHLTIndexGrid.h:67
 AliHLTIndexGrid.h:68
 AliHLTIndexGrid.h:69
 AliHLTIndexGrid.h:70
 AliHLTIndexGrid.h:71
 AliHLTIndexGrid.h:72
 AliHLTIndexGrid.h:73
 AliHLTIndexGrid.h:74
 AliHLTIndexGrid.h:75
 AliHLTIndexGrid.h:76
 AliHLTIndexGrid.h:77
 AliHLTIndexGrid.h:78
 AliHLTIndexGrid.h:79
 AliHLTIndexGrid.h:80
 AliHLTIndexGrid.h:81
 AliHLTIndexGrid.h:82
 AliHLTIndexGrid.h:83
 AliHLTIndexGrid.h:84
 AliHLTIndexGrid.h:85
 AliHLTIndexGrid.h:86
 AliHLTIndexGrid.h:87
 AliHLTIndexGrid.h:88
 AliHLTIndexGrid.h:89
 AliHLTIndexGrid.h:90
 AliHLTIndexGrid.h:91
 AliHLTIndexGrid.h:92
 AliHLTIndexGrid.h:93
 AliHLTIndexGrid.h:94
 AliHLTIndexGrid.h:95
 AliHLTIndexGrid.h:96
 AliHLTIndexGrid.h:97
 AliHLTIndexGrid.h:98
 AliHLTIndexGrid.h:99
 AliHLTIndexGrid.h:100
 AliHLTIndexGrid.h:101
 AliHLTIndexGrid.h:102
 AliHLTIndexGrid.h:103
 AliHLTIndexGrid.h:104
 AliHLTIndexGrid.h:105
 AliHLTIndexGrid.h:106
 AliHLTIndexGrid.h:107
 AliHLTIndexGrid.h:108
 AliHLTIndexGrid.h:109
 AliHLTIndexGrid.h:110
 AliHLTIndexGrid.h:111
 AliHLTIndexGrid.h:112
 AliHLTIndexGrid.h:113
 AliHLTIndexGrid.h:114
 AliHLTIndexGrid.h:115
 AliHLTIndexGrid.h:116
 AliHLTIndexGrid.h:117
 AliHLTIndexGrid.h:118
 AliHLTIndexGrid.h:119
 AliHLTIndexGrid.h:120
 AliHLTIndexGrid.h:121
 AliHLTIndexGrid.h:122
 AliHLTIndexGrid.h:123
 AliHLTIndexGrid.h:124
 AliHLTIndexGrid.h:125
 AliHLTIndexGrid.h:126
 AliHLTIndexGrid.h:127
 AliHLTIndexGrid.h:128
 AliHLTIndexGrid.h:129
 AliHLTIndexGrid.h:130
 AliHLTIndexGrid.h:131
 AliHLTIndexGrid.h:132
 AliHLTIndexGrid.h:133
 AliHLTIndexGrid.h:134
 AliHLTIndexGrid.h:135
 AliHLTIndexGrid.h:136
 AliHLTIndexGrid.h:137
 AliHLTIndexGrid.h:138
 AliHLTIndexGrid.h:139
 AliHLTIndexGrid.h:140
 AliHLTIndexGrid.h:141
 AliHLTIndexGrid.h:142
 AliHLTIndexGrid.h:143
 AliHLTIndexGrid.h:144
 AliHLTIndexGrid.h:145
 AliHLTIndexGrid.h:146
 AliHLTIndexGrid.h:147
 AliHLTIndexGrid.h:148
 AliHLTIndexGrid.h:149
 AliHLTIndexGrid.h:150
 AliHLTIndexGrid.h:151
 AliHLTIndexGrid.h:152
 AliHLTIndexGrid.h:153
 AliHLTIndexGrid.h:154
 AliHLTIndexGrid.h:155
 AliHLTIndexGrid.h:156
 AliHLTIndexGrid.h:157
 AliHLTIndexGrid.h:158
 AliHLTIndexGrid.h:159
 AliHLTIndexGrid.h:160
 AliHLTIndexGrid.h:161
 AliHLTIndexGrid.h:162
 AliHLTIndexGrid.h:163
 AliHLTIndexGrid.h:164
 AliHLTIndexGrid.h:165
 AliHLTIndexGrid.h:166
 AliHLTIndexGrid.h:167
 AliHLTIndexGrid.h:168
 AliHLTIndexGrid.h:169
 AliHLTIndexGrid.h:170
 AliHLTIndexGrid.h:171
 AliHLTIndexGrid.h:172
 AliHLTIndexGrid.h:173
 AliHLTIndexGrid.h:174
 AliHLTIndexGrid.h:175
 AliHLTIndexGrid.h:176
 AliHLTIndexGrid.h:177
 AliHLTIndexGrid.h:178
 AliHLTIndexGrid.h:179
 AliHLTIndexGrid.h:180
 AliHLTIndexGrid.h:181
 AliHLTIndexGrid.h:182
 AliHLTIndexGrid.h:183
 AliHLTIndexGrid.h:184
 AliHLTIndexGrid.h:185
 AliHLTIndexGrid.h:186
 AliHLTIndexGrid.h:187
 AliHLTIndexGrid.h:188
 AliHLTIndexGrid.h:189
 AliHLTIndexGrid.h:190
 AliHLTIndexGrid.h:191
 AliHLTIndexGrid.h:192
 AliHLTIndexGrid.h:193
 AliHLTIndexGrid.h:194
 AliHLTIndexGrid.h:195
 AliHLTIndexGrid.h:196
 AliHLTIndexGrid.h:197
 AliHLTIndexGrid.h:198
 AliHLTIndexGrid.h:199
 AliHLTIndexGrid.h:200
 AliHLTIndexGrid.h:201
 AliHLTIndexGrid.h:202
 AliHLTIndexGrid.h:203
 AliHLTIndexGrid.h:204
 AliHLTIndexGrid.h:205
 AliHLTIndexGrid.h:206
 AliHLTIndexGrid.h:207
 AliHLTIndexGrid.h:208
 AliHLTIndexGrid.h:209
 AliHLTIndexGrid.h:210
 AliHLTIndexGrid.h:211
 AliHLTIndexGrid.h:212
 AliHLTIndexGrid.h:213
 AliHLTIndexGrid.h:214
 AliHLTIndexGrid.h:215
 AliHLTIndexGrid.h:216
 AliHLTIndexGrid.h:217
 AliHLTIndexGrid.h:218
 AliHLTIndexGrid.h:219
 AliHLTIndexGrid.h:220
 AliHLTIndexGrid.h:221
 AliHLTIndexGrid.h:222
 AliHLTIndexGrid.h:223
 AliHLTIndexGrid.h:224
 AliHLTIndexGrid.h:225
 AliHLTIndexGrid.h:226
 AliHLTIndexGrid.h:227
 AliHLTIndexGrid.h:228
 AliHLTIndexGrid.h:229
 AliHLTIndexGrid.h:230
 AliHLTIndexGrid.h:231
 AliHLTIndexGrid.h:232
 AliHLTIndexGrid.h:233
 AliHLTIndexGrid.h:234
 AliHLTIndexGrid.h:235
 AliHLTIndexGrid.h:236
 AliHLTIndexGrid.h:237
 AliHLTIndexGrid.h:238
 AliHLTIndexGrid.h:239
 AliHLTIndexGrid.h:240
 AliHLTIndexGrid.h:241
 AliHLTIndexGrid.h:242
 AliHLTIndexGrid.h:243
 AliHLTIndexGrid.h:244
 AliHLTIndexGrid.h:245
 AliHLTIndexGrid.h:246
 AliHLTIndexGrid.h:247
 AliHLTIndexGrid.h:248
 AliHLTIndexGrid.h:249
 AliHLTIndexGrid.h:250
 AliHLTIndexGrid.h:251
 AliHLTIndexGrid.h:252
 AliHLTIndexGrid.h:253
 AliHLTIndexGrid.h:254
 AliHLTIndexGrid.h:255
 AliHLTIndexGrid.h:256
 AliHLTIndexGrid.h:257
 AliHLTIndexGrid.h:258
 AliHLTIndexGrid.h:259
 AliHLTIndexGrid.h:260
 AliHLTIndexGrid.h:261
 AliHLTIndexGrid.h:262
 AliHLTIndexGrid.h:263
 AliHLTIndexGrid.h:264
 AliHLTIndexGrid.h:265
 AliHLTIndexGrid.h:266
 AliHLTIndexGrid.h:267
 AliHLTIndexGrid.h:268
 AliHLTIndexGrid.h:269
 AliHLTIndexGrid.h:270
 AliHLTIndexGrid.h:271
 AliHLTIndexGrid.h:272
 AliHLTIndexGrid.h:273
 AliHLTIndexGrid.h:274
 AliHLTIndexGrid.h:275
 AliHLTIndexGrid.h:276
 AliHLTIndexGrid.h:277
 AliHLTIndexGrid.h:278
 AliHLTIndexGrid.h:279
 AliHLTIndexGrid.h:280
 AliHLTIndexGrid.h:281
 AliHLTIndexGrid.h:282
 AliHLTIndexGrid.h:283
 AliHLTIndexGrid.h:284
 AliHLTIndexGrid.h:285
 AliHLTIndexGrid.h:286
 AliHLTIndexGrid.h:287
 AliHLTIndexGrid.h:288
 AliHLTIndexGrid.h:289
 AliHLTIndexGrid.h:290
 AliHLTIndexGrid.h:291
 AliHLTIndexGrid.h:292
 AliHLTIndexGrid.h:293
 AliHLTIndexGrid.h:294
 AliHLTIndexGrid.h:295
 AliHLTIndexGrid.h:296
 AliHLTIndexGrid.h:297
 AliHLTIndexGrid.h:298
 AliHLTIndexGrid.h:299
 AliHLTIndexGrid.h:300
 AliHLTIndexGrid.h:301
 AliHLTIndexGrid.h:302
 AliHLTIndexGrid.h:303
 AliHLTIndexGrid.h:304
 AliHLTIndexGrid.h:305
 AliHLTIndexGrid.h:306
 AliHLTIndexGrid.h:307
 AliHLTIndexGrid.h:308
 AliHLTIndexGrid.h:309
 AliHLTIndexGrid.h:310
 AliHLTIndexGrid.h:311
 AliHLTIndexGrid.h:312
 AliHLTIndexGrid.h:313
 AliHLTIndexGrid.h:314
 AliHLTIndexGrid.h:315
 AliHLTIndexGrid.h:316
 AliHLTIndexGrid.h:317
 AliHLTIndexGrid.h:318
 AliHLTIndexGrid.h:319
 AliHLTIndexGrid.h:320
 AliHLTIndexGrid.h:321
 AliHLTIndexGrid.h:322
 AliHLTIndexGrid.h:323
 AliHLTIndexGrid.h:324
 AliHLTIndexGrid.h:325
 AliHLTIndexGrid.h:326
 AliHLTIndexGrid.h:327
 AliHLTIndexGrid.h:328
 AliHLTIndexGrid.h:329
 AliHLTIndexGrid.h:330
 AliHLTIndexGrid.h:331
 AliHLTIndexGrid.h:332
 AliHLTIndexGrid.h:333
 AliHLTIndexGrid.h:334
 AliHLTIndexGrid.h:335
 AliHLTIndexGrid.h:336
 AliHLTIndexGrid.h:337
 AliHLTIndexGrid.h:338
 AliHLTIndexGrid.h:339
 AliHLTIndexGrid.h:340
 AliHLTIndexGrid.h:341
 AliHLTIndexGrid.h:342
 AliHLTIndexGrid.h:343
 AliHLTIndexGrid.h:344
 AliHLTIndexGrid.h:345
 AliHLTIndexGrid.h:346
 AliHLTIndexGrid.h:347
 AliHLTIndexGrid.h:348
 AliHLTIndexGrid.h:349
 AliHLTIndexGrid.h:350
 AliHLTIndexGrid.h:351
 AliHLTIndexGrid.h:352
 AliHLTIndexGrid.h:353
 AliHLTIndexGrid.h:354
 AliHLTIndexGrid.h:355
 AliHLTIndexGrid.h:356
 AliHLTIndexGrid.h:357
 AliHLTIndexGrid.h:358
 AliHLTIndexGrid.h:359
 AliHLTIndexGrid.h:360
 AliHLTIndexGrid.h:361
 AliHLTIndexGrid.h:362
 AliHLTIndexGrid.h:363
 AliHLTIndexGrid.h:364
 AliHLTIndexGrid.h:365
 AliHLTIndexGrid.h:366
 AliHLTIndexGrid.h:367
 AliHLTIndexGrid.h:368
 AliHLTIndexGrid.h:369
 AliHLTIndexGrid.h:370