EdbCell2 Class Reference

#include <EdbCell2.h>

Inheritance diagram for EdbCell2:

Collaboration diagram for EdbCell2:

Public Member Functions
bool	AddObject (float v[2], TObject *obj)
bool	AddObject (float x, float y, TObject *obj)
bool	AddObject (int ix, int iy, TObject *obj)
bool	AddObject (int j, TObject *obj)
int	AddObjectOverlap (float x, float y, float dx, float dy, TObject *obj)
int	CellLim ()
void	Copy (const EdbCell2 &cell)
void	Delete ()
	EdbCell2 ()
	[eNcell] pointers to cells More...
	EdbCell2 (const EdbCell2 &cell)
TObject *	GetObject (float x, float y, int ientr) const
TObject *	GetObject (int ix, int iy, int ientr) const
TObject *	GetObject (int j, int ientr) const
int	InitCell (EdbCell2 &c)
int	InitCell (int maxpercell, int n[2], float min[2], float max[2])
int	InitCell (int nx, float minx, float maxx, int ny, float miny, float maxy, int maxpercell)
void	InitEPC ()
void	PrintStat ()
void	Reset ()
int	SelectObjects (float min[2], float max[2], TObjArray &arr)
int	SelectObjects (int min[2], int max[2], TObjArray &arr)
int	SelectObjects (TObjArray &arr)
int	SelectObjectsC (float v[2], float r, TObjArray &arr)
int	SelectObjectsC (float v[2], int ir[2], TObjArray &arr)
int	SelectObjectsC (int iv[2], int ir[2], TObjArray &arr)
int	SelectObjectsCJ (int j, int ir, TObjArray &arr)
void	Set0 ()
	~EdbCell2 ()
Public Member Functions inherited from EdbH2
void	AddBin (int jcell, int n)
int	Bin (float x, float y) const
int	Bin (int iv[2]) const
int	Bin (int ix, int iy) const
int	Bin (int j) const
void	CleanCells ()
void	Copy (const EdbH2 &h)
void	Delete ()
int	DiscardHighCells (int nmax)
TH2F *	DrawH2 (const char *name="plot2d", const char *title="EdbH2plot2D")
TH1I *	DrawSpectrum (const char *name="plot1d", const char *title="EdbH2 DrawSpectrum")
	EdbH2 ()
	EdbH2 (const EdbH2 &h)
	EdbH2 (int nx, float minx, float maxx, int ny, float miny, float maxy)
int	Fill (float x, float y)
int	Fill (float x, float y, int n)
int	Fill (int j, int n=1)
int	InitH2 (const EdbH2 &h)
int	InitH2 (int n[2], float min[2], float max[2])
int	InitH2 (int nx, float minx, float maxx, int ny, float miny, float maxy)
Long_t	Integral ()
Long_t	Integral (int iv[2], int ir[2])
int	IX (float x) const
int	IX (int jcell) const
int	IY (float y) const
int	IY (int jcell) const
int	Jcell (float v[2]) const
int	Jcell (float x, float y) const
int	Jcell (int ix, int iy) const
int	MaxBin ()
Float_t	Mean ()
int	Ncell () const
int	NX () const
int	NY () const
void	PrintStat ()
EdbH1 *	ProjectionX ()
EdbH1 *	ProjectionY ()
void	Set0 ()
void	SetBin (int ix, int iy, int n)
void	SetBin (int j, int n)
float	X (int ix) const
float	Xbin () const
float	Xj (int j) const
float	Xmax () const
float	XmaxA (float level=0)
float	Xmin () const
float	XminA (float level=0)
float	Y (int iy) const
float	Ybin () const
float	Yj (int j) const
float	Ymax () const
float	YmaxA (float level=0)
float	Ymin () const
float	YminA (float level=0)
	~EdbH2 ()

Private Attributes
Int_t	eCapacity
Int_t	eCellLim
TObject ***	epC
TObject **	epO

Additional Inherited Members
Protected Attributes inherited from EdbH2
Float_t	eBin [2]
Float_t	eMax [2]
Float_t	eMin [2]
Int_t	eN [2]
Int_t *	eNC
Int_t	eNcell

Constructor & Destructor Documentation

EdbCell2() [1/2]

EdbCell2::EdbCell2

(

)

[eNcell] pointers to cells

{
  Set0();
}

EdbCell2() [2/2]

EdbCell2::EdbCell2 ( const EdbCell2 &  cell )

inline

{ Set0(); Copy(cell); }

~EdbCell2()

EdbCell2::~EdbCell2

(

)

{ 
  Delete();
}

Member Function Documentation

AddObject() [1/4]

bool EdbCell2::AddObject ( float  v[2], TObject *  obj  )

inline

{ return AddObject(v[0],v[1],obj); }

AddObject() [2/4]

bool EdbCell2::AddObject	(	float	x,
		float	y,
		TObject *	obj
	)

{ 
  int j = Jcell(x,y);
  return AddObject(j, obj);
}

AddObject() [3/4]

bool EdbCell2::AddObject	(	int	ix,
		int	iy,
		TObject *	obj
	)

{ 
  int j = Jcell(ix,iy);
  return AddObject(j, obj);
}

AddObject() [4/4]

bool EdbCell2::AddObject	(	int	j,
		TObject *	obj
	)

{ 
  if(!obj)                    return 0;
  if(j>=eNcell)               return 0;
  if(j<0)                     return 0;
  if( eNC[j] >= eCellLim )    return 0;
  epC[j][eNC[j]] = obj;
  eNC[j]++;
  return 1;
}

AddObjectOverlap()

int EdbCell2::AddObjectOverlap	(	float	x,
		float	y,
		float	dx,
		float	dy,
		TObject *	obj
	)

{
  // works correctly if overlap less then the cell size
  int cnt=0;
  std::vector<int> J;
  J.push_back( Jcell(x,y) );
  J.push_back( Jcell(x+dx,y) );
  J.push_back( Jcell(x-dx,y) );
  J.push_back( Jcell(x,y+dy) );
  J.push_back( Jcell(x,y-dy) );
  std::sort(J.begin(), J.end());
  std::vector<int>::iterator ip = std::unique( J.begin(), J.end() );
  J.resize( std::distance(J.begin(), ip) );
  for (ip=J.begin(); ip!=J.end(); ++ip)
  {
    AddObject(*ip,obj); 
    cnt++;
  }
  return cnt;
}

CellLim()

int EdbCell2::CellLim ( )

inline

{ return eCellLim; }

Copy()

void EdbCell2::Copy

(

const EdbCell2 &

cell

)

{
  EdbH2::Copy(cell);
  eCellLim  = cell.eCellLim;
  eCapacity = cell.eCapacity;
  for(int i=0; i<eNcell; i++) 
    for(int j=0; i<eCellLim; i++)  AddObject(i, GetObject(i,j));
}

Delete()

void EdbCell2::Delete

(

)

{
  if(epC)    { delete [] epC;    epC = 0;  }
  if(epO)    { delete [] epO;    epO = 0;  }
}

GetObject() [1/3]

TObject* EdbCell2::GetObject ( float  x, float  y, int  ientr  ) const

inline

{ return GetObject( Jcell(x,y), ientr); }

GetObject() [2/3]

TObject* EdbCell2::GetObject ( int  ix, int  iy, int  ientr  ) const

inline

{ return GetObject( Jcell(ix,iy), ientr); }

GetObject() [3/3]

TObject* EdbCell2::GetObject ( int  j, int  ientr  ) const

inline

                                             { 
    if(j>=0&&j<eNcell&&ientr>=0&&ientr<eCellLim) return epC[j][ientr];
    else return 0;
  }

InitCell() [1/3]

int EdbCell2::InitCell ( EdbCell2 &  c )

inline

{ return InitCell(c.NX(),c.Xmin(),c.Xmax(),c.NY(),c.Ymin(),c.Ymax(), c.CellLim() ); }

InitCell() [2/3]

int EdbCell2::InitCell	(	int	maxpercell,
		int	n[2],
		float	min[2],
		float	max[2]
	)

{
  Log(3,"EdbCell2::InitCell","%d %f %f %d %f %f", n[0],min[0],max[0],n[1],min[1],max[1] );
  Delete();
  InitH2(n, min, max);
  Log(3,"EdbCell2::InitCell","reserve space for maxpercell(%d) * eNcell(%d) = %d objects", 
      maxpercell, eNcell, maxpercell*eNcell);
  eCellLim = maxpercell;
  eCapacity = eNcell*eCellLim;
  epO     = new TObject*[eCapacity];          //- pointers to objects
  epC     = new TObject**[eNcell];            //- pointers to cells
  InitEPC();
  return eNcell;
}

InitCell() [3/3]

int EdbCell2::InitCell	(	int	nx,
		float	minx,
		float	maxx,
		int	ny,
		float	miny,
		float	maxy,
		int	maxpercell
	)

{
  int n[2] = {nx,ny};
  float min[2] = {minx,miny};
  float max[2] = {maxx,maxy};
  return InitCell(maxpercell, n, min, max);
}

InitEPC()

void EdbCell2::InitEPC

(

)

{
  TObject **po = epO;
  epC[0]=po;
  for(int i=1; i<eNcell; i++) {po+=eCellLim; epC[i]=po;}
}

PrintStat()

void EdbCell2::PrintStat

(

)

{
  printf("EdbCell2 limit = %4d\n",eCellLim);
  ((EdbH2*)this)->PrintStat();
}

Reset()

void EdbCell2::Reset ( )

inline

{CleanCells(); Delete();}

SelectObjects() [1/3]

int EdbCell2::SelectObjects	(	float	min[2],
		float	max[2],
		TObjArray &	arr
	)

{
  int mi[2] = { IX(min[0]), IY(min[1]) };
  int ma[2] = { IX(max[0]), IY(max[1]) };
  return SelectObjects(mi,ma, arr);
}

SelectObjects() [2/3]

int EdbCell2::SelectObjects	(	int	min[2],
		int	max[2],
		TObjArray &	arr
	)

{
  int nobj  = 0;
  int jcell = 0;
  for(int ix = Max(0,min[0]); ix<=Min(eN[0]-1,max[0]); ix++)
    for(int iy = Max(0,min[1]); iy<=Min(eN[1]-1,max[1]); iy++) 
      {
    jcell = Jcell(ix,iy);
    if(eNC[jcell]<1)      continue;
    for(int k=0; k<eNC[jcell]; k++)   { arr.Add( epC[jcell][k] );  nobj++; }
      }
  return nobj;
}

SelectObjects() [3/3]

int EdbCell2::SelectObjects

(

TObjArray &

arr

)

{
  // select all objects
  int nobj  = 0;
  for(int jcell=0; jcell<eNcell; jcell++) {
    if(eNC[jcell]<1)      continue;
    for(int k=0; k<eNC[jcell]; k++)   { arr.Add( epC[jcell][k] );  nobj++; }
  }
  return nobj;
}

SelectObjectsC() [1/3]

int EdbCell2::SelectObjectsC ( float  v[2], float  r, TObjArray &  arr  )

inline

                                                          {
      int ir[2] = { (int)(r/Xbin()) + 1, (int)(r/Ybin()) + 1 };
      return SelectObjectsC(v, ir, arr);
     };

SelectObjectsC() [2/3]

int EdbCell2::SelectObjectsC ( float  v[2], int  ir[2], TObjArray &  arr  )

inline

                                                            {
    int iv[2] = { IX(v[0]), IY(v[1]) }; 
    return SelectObjectsC(iv, ir, arr);
  }

SelectObjectsC() [3/3]

int EdbCell2::SelectObjectsC	(	int	iv[2],
		int	ir[2],
		TObjArray &	arr
	)

{
  int min[2] = {vcent[0]-vdiff[0],vcent[1]-vdiff[1]};
  int max[2] = {vcent[0]+vdiff[0],vcent[1]+vdiff[1]};
  return SelectObjects(min,max, arr);
}

SelectObjectsCJ()

int EdbCell2::SelectObjectsCJ ( int  j, int  ir, TObjArray &  arr  )

inline

                                                     {
    int iv[2] = { IX(j), IY(j) };
    int irr[2] = { ir, ir };
    return SelectObjectsC(iv, irr, arr);
  }

Set0()

void EdbCell2::Set0

(

)

{
  eCellLim=0;
  eCapacity=0;
  epO=0;
  epC=0;
}

Member Data Documentation

eCapacity

Int_t EdbCell2::eCapacity

private

eCellLim

Int_t EdbCell2::eCellLim

private

epC

TObject*** EdbCell2::epC

private

epO

TObject** EdbCell2::epO

private

---

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

• src/libEmath/EdbCell2.h
• src/libEmath/EdbCell2.cpp