TIndexCellIterV Class Reference

#include <TIndexCell.h>

Inheritance diagram for TIndexCellIterV:

Collaboration diagram for TIndexCellIterV:

Public Member Functions
const TIndexCell *	GetCell () const
int	LevelDown ()
TIndexCell const *	Next ()
TIndexCell const *	NextAll ()
void	Reset ()
void	Test ()
	TIndexCellIterV (const TIndexCell *cell, int level, long vcent[], long vdiff[], Bool_t dir=kIterForward)
	~TIndexCellIterV ()

Private Member Functions
	TIndexCellIterV ()

Private Attributes
const TIndexCell *	fCell
Bool_t	fDirection
Int_t	fLevel
Int_t	fLevel0
Int_t	fPass
Long_t *	fVcent
Long_t *	fVdiff
Int_t *	fVind
Long_t *	fVval

Constructor & Destructor Documentation

TIndexCellIterV() [1/2]

TIndexCellIterV::TIndexCellIterV ( )

inlineprivate

: fCell(0) { }

TIndexCellIterV() [2/2]

TIndexCellIterV::TIndexCellIterV	(	const TIndexCell *	cell,
		int	level,
		long	vcent[],
		long	vdiff[],
		Bool_t	dir = kIterForward
	)

{
   // Create cell iterator. By default the iteration direction
   // is kIterForward. To go backward use kIterBackward.
 
   fPass = 0;
   fCell     = cell;
   fDirection = dir;
   if( level > fCell->Nlevels() ) level=0;
   if( level < 1 ) level=0;
   fLevel = fLevel0 = level;
 
   if(fLevel0 >= 0) {
     fVind  = new Int_t[  fLevel0 ];
     fVval  = new Long_t[ fLevel0 ];
     Reset();
   }
 
   fVcent = new Long_t[level];
   fVdiff = new Long_t[level];
 
   for(int i=0; i<level; i++) {
     fVcent[i] = vcent[i];
     fVdiff[i] = vdiff[i];
   }
}

~TIndexCellIterV()

TIndexCellIterV::~TIndexCellIterV ( )

inline

{ }

Member Function Documentation

GetCell()

const TIndexCell* TIndexCellIterV::GetCell ( ) const

inline

{ return fCell; }

LevelDown()

int TIndexCellIterV::LevelDown

(

)

{
  if(fLevel<2) return 0;
  fLevel--;
  fVind[fLevel] = 0;
  int nent = fCell->At(fLevel-1,fVind)->GetEntriesFast();
  //printf("LevelDown: level = %d, nent= %d  fVind= %d\n",fLevel, nent,fVind[fLevel-1]);
  if( fVind[fLevel-1] < nent-1 ) {
    fVind[fLevel-1]++;
    fLevel=fLevel0;
    fVind[fLevel0-1]=-1;
    return 1;
  } else return LevelDown();
  return 0;
}

Next()

TIndexCell const * TIndexCellIterV::Next

(

)

{
  // Return next object in the defined volume. 
  // Returns 0 when no more objects in the cell.
 
  // TODO: inefficient cycle ! put here find...
 
  TIndexCell const *b=0;
 
  while( (b=NextAll()) ) {
    fCell->GetValues( fLevel0, fVind, fVval );
    //printf("flevel0: %d  fVind[0]: %d, fVval[1]: %ld \n",fLevel0,  fVind[0], fVval[1]);
    for(int lev=0; lev<fLevel0; lev++) {
      if( TMath::Abs( fVval[lev]-fVcent[lev] ) > fVdiff[lev] ) break;
      if( lev == fLevel0-1 ) return b;
    }
  }
  return 0;
}

NextAll()

TIndexCell const * TIndexCellIterV::NextAll

(

)

{
   // Return next object in cell. Returns 0 when no more objects in cell.
 
  if( fLevel0 <0 )   return 0;
 
 START:
 
  if( fLevel != fLevel0 )   return 0;
 
  int nent = fCell->At(fLevel-1,fVind)->GetEntriesFast();
  //printf("Next: nent= %d  fPass= %d\n",nent,fPass);
 
  if( fVind[fLevel-1] < nent-1 ) {
    fVind[fLevel-1]++;
    fPass++;
    return  fCell->At(fLevel,fVind);
  } else {
    if( LevelDown() ) goto START;
  }
  return 0;
}

Reset()

void TIndexCellIterV::Reset

(

)

{
   // Reset array iterator.
  if (fDirection == kIterForward) {
    fLevel = fLevel0;
    for(int i=0; i<fLevel0; i++ ) fVind[i]=0;
    fVind[fLevel0-1]=-1;
  }
  else    {}
}

Test()

void TIndexCellIterV::Test

(

)

{
  int count=0;
  while( NextAll() ) count++;
  printf("count = %d\n",count);
}

Member Data Documentation

fCell

const TIndexCell* TIndexCellIterV::fCell

private

fDirection

Bool_t TIndexCellIterV::fDirection

private

fLevel

Int_t TIndexCellIterV::fLevel

private

fLevel0

Int_t TIndexCellIterV::fLevel0

private

fPass

Int_t TIndexCellIterV::fPass

private

fVcent

Long_t* TIndexCellIterV::fVcent

private

fVdiff

Long_t* TIndexCellIterV::fVdiff

private

fVind

Int_t* TIndexCellIterV::fVind

private

fVval

Long_t* TIndexCellIterV::fVval

private

---

The documentation for this class was generated from the following files:

• src/libEmath/TIndexCell.h
• src/libEmath/TIndexCell.cpp