EdbH2 Class Reference

fast 2-dim histogram class (used as a basis for EdbCell2) More...

#include <EdbCell2.h>

Inheritance diagram for EdbH2:

Collaboration diagram for EdbH2:

Public Member Functions
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 DrawSpectrun")
	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	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 ()

Protected Attributes
Float_t	eBin [2]
	bin size More...
Float_t	eMax [2]
	max More...
Float_t	eMin [2]
	min More...
Int_t	eN [2]
	divisions More...
Int_t *	eNC
	[eNcell] number of objects/cell More...
Int_t	eNcell
	eNx*eNy More...

Detailed Description

fast 2-dim histogram class (used as a basis for EdbCell2)

//////////////////////////////////////////////////////////////////////// // EdbCell2 // // class to group 2-dim objects for the fast access // // ////////////////////////////////////////////////////////////////////////

Constructor & Destructor Documentation

EdbH2() [1/3]

EdbH2::EdbH2

(

)

{
  Set0();
}

EdbH2() [2/3]

EdbH2::EdbH2 ( int  nx, float  minx, float  maxx, int  ny, float  miny, float  maxy  )

inline

{ Set0(); InitH2(nx, minx, maxx, ny, miny, maxy); }

EdbH2() [3/3]

EdbH2::EdbH2

(

const EdbH2 &

h

)

{
  Set0();
  Copy(h);
}

~EdbH2()

EdbH2::~EdbH2

(

)

{ 
  Delete();
}

Member Function Documentation

AddBin()

void EdbH2::AddBin ( int  jcell, int  n  )

inline

{ if(jcell>=0&&jcell<eNcell) eNC[jcell]+=n; }

Bin() [1/4]

int EdbH2::Bin ( float  x, float  y  ) const

inline

{return (Jcell(x,y)>-1)? eNC[Jcell(x,y)] : 0; }

Bin() [2/4]

int EdbH2::Bin ( int  iv[2] ) const

inline

{return Bin(iv[0],iv[1]);}

Bin() [3/4]

int EdbH2::Bin ( int  ix, int  iy  ) const

inline

{return (Jcell(ix,iy)>-1)? eNC[Jcell(ix,iy)] : 0; }

Bin() [4/4]

int EdbH2::Bin ( int  j ) const

inline

{if(j>-1||j<eNcell) return eNC[j]; else return 0; }

CleanCells()

void EdbH2::CleanCells

(

)

{
  if(eNC) memset(eNC,'\0',eNcell*sizeof(Int_t));
}

Copy()

void EdbH2::Copy

(

const EdbH2 &

h

)

{
  Delete();
  for(int i=0; i<2; i++)     { 
    eN[i]=h.eN[i];
    eMin[i]=h.eMin[i];
    eMax[i]=h.eMax[i];
    eBin[i]=h.eBin[i];
  }
  eNcell=h.eNcell;
  if(h.eNC) {
    eNC = new Int_t[eNcell];
    memcpy( eNC, h.eNC, sizeof(Int_t)*eNcell );
  }
}

Delete()

void EdbH2::Delete

(

)

{
  if(eNC)    { delete [] eNC;    eNC = 0;  }
  eNcell=0;
  eN[0] = eN[1] = 0;
  eMin[0] = eMin[1] = 0;
  eMax[0] = eMax[1] = 0;
}

DiscardHighCells()

int EdbH2::DiscardHighCells

(

int

nmax

)

{
  int ic=0;
  for(int i=0; i<eNcell; i++)  
    if(eNC[i]>nmax) { eNC[i]=0; ic++; }
  return ic;
}

DrawH2()

TH2F * EdbH2::DrawH2	(	const char *	name = "plot2d",
		const char *	title = "EdbH2plot2D"
	)

{
  TObject *obj=0;
  if((obj=gDirectory->FindObject(name))) delete obj;
  TH2F *h = new TH2F(name, title, eN[0],eMin[0],eMax[0],eN[1],eMin[1],eMax[1]);
  for(int i=0; i<eN[0]; i++)
    for(int j=0; j<eN[1]; j++)
      h->Fill( X(i), Y(j), Bin(i,j) );
  return h;
}

DrawSpectrum()

TH1I * EdbH2::DrawSpectrum	(	const char *	name = "plot1d",
		const char *	title = "EdbH2 DrawSpectrun"
	)

{
  int imax = MaxBin();
  TH1I *h = new TH1I(name, title, imax,0,imax);
  for(int i=0; i<eNcell; i++)    h->Fill( eNC[i] );
  return h;
}

Fill() [1/2]

int EdbH2::Fill ( float  x, float  y  )

inline

{ return Fill(x,y,1); }

Fill() [2/2]

int EdbH2::Fill	(	float	x,
		float	y,
		int	n
	)

{ 
  if(x>eMin[0]&&x<eMax[0]&&y>eMin[1]&&y<eMax[1]) {
    int j = Jcell(x,y);
    if(j<0)              return 0;
    eNC[j] += n;
    return n;
  }
  return 0;
}

InitH2() [1/3]

int EdbH2::InitH2

(

const EdbH2 &

h

)

{
  int n[2]={h.NX(),h.NY()};
  float min[2]={h.Xmin(),h.Ymin()};
  float max[2]={h.Xmax(),h.Ymax()};
  return InitH2(n,min,max);
}

InitH2() [2/3]

int EdbH2::InitH2	(	int	n[2],
		float	min[2],
		float	max[2]
	)

{ 
  Delete();
  for(int i=0; i<2; i++) {
    if(n[i]<1) return 0;
    eN[i]=n[i];
    eMin[i] = min[i];
    eMax[i] = max[i];
    eBin[i] = (eMax[i]-eMin[i])/eN[i];
    //    if(eBin[i]<0.00000001) return 0;
  }
  eNcell = eN[0]*eN[1];
  eNC = new Int_t[eNcell];
  CleanCells();
  return eNcell;
}

InitH2() [3/3]

int EdbH2::InitH2	(	int	nx,
		float	minx,
		float	maxx,
		int	ny,
		float	miny,
		float	maxy
	)

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

Integral() [1/2]

Long_t EdbH2::Integral

(

)

{
  Long_t ntot=0;
  for(int i=0; i<eNcell; i++) ntot+=eNC[i];
  return ntot;
}

Integral() [2/2]

Long_t EdbH2::Integral	(	int	iv[2],
		int	ir[2]
	)

{
  Long_t ntot=0, nbin=0;
  for(int ix=iv[0]-ir[0]; ix<=iv[0]+ir[0]; ix++) 
    for(int iy=iv[1]-ir[1]; iy<=iv[1]+ir[1]; iy++) 
      {ntot+=Bin(ix,iy); nbin++;}
  return ntot;
}

IX() [1/2]

int EdbH2::IX ( float  x ) const

inline

{return (int)((x-eMin[0])/eBin[0]); }

IX() [2/2]

int EdbH2::IX ( int  jcell ) const

inline

{return jcell%eN[0]; }

IY() [1/2]

int EdbH2::IY ( float  y ) const

inline

{return (int)((y-eMin[1])/eBin[1]); }

IY() [2/2]

int EdbH2::IY ( int  jcell ) const

inline

{return jcell/eN[0]; }

Jcell() [1/3]

int EdbH2::Jcell ( float  v[2] ) const

inline

{return Jcell(IX(v[0]),IY(v[1])); }

Jcell() [2/3]

int EdbH2::Jcell ( float  x, float  y  ) const

inline

{return Jcell( IX(x), IY(y)); }

Jcell() [3/3]

int EdbH2::Jcell ( int  ix, int  iy  ) const

inline

{if(ix>=0&&ix<eN[0]&&iy>=0&&iy<eN[1]) return iy*eN[0]+ix; else return -1;}

MaxBin()

int EdbH2::MaxBin

(

)

{
  int peak=0;
  for(int i=0; i<eNcell; i++)  if(eNC[i]>peak)  peak =eNC[i];
  return peak;
}

Mean()

Float_t EdbH2::Mean ( )

inline

{ return 1.*Integral()/eNcell; }

Ncell()

int EdbH2::Ncell ( ) const

inline

{return eN[0]*eN[1];}

NX()

int EdbH2::NX ( ) const

inline

{return eN[0];}

NY()

int EdbH2::NY ( ) const

inline

{return eN[1];}

PrintStat()

void EdbH2::PrintStat

(

)

{
  printf("X:%5d cells in range (%10.2f %10.2f) with bin %10.2f \n", eN[0],eMin[0],eMax[0],eBin[0]);
  printf("Y:%5d cells in range (%10.2f %10.2f) with bin %10.2f \n", eN[1],eMin[1],eMax[1],eBin[1]);
  if(!eNC)  return;
  int nmax=0, ntot=0;
  int nmin=kMaxInt;
  for(int i=0; i<eNcell; i++) {
    if( eNC[i]>nmax ) nmax=eNC[i];
    if( eNC[i]<nmin ) nmin=eNC[i];
    ntot += eNC[i];
  }
  printf("%d objects in %d cells filled as: (%d:%d) with mean= %f\n", 
     ntot, eNcell, nmin, nmax, 1.*ntot/eNcell);
}

ProjectionX()

EdbH1 * EdbH2::ProjectionX

(

)

{
  EdbH1 *h = new EdbH1(eN[0],eMin[0],eMax[0]);
  for(int i=0; i<eNcell; i++)   h->Fill( X(IX(i)), eNC[i] );
  return h;
}

ProjectionY()

EdbH1 * EdbH2::ProjectionY

(

)

{
  EdbH1 *h = new EdbH1(eN[1],eMin[1],eMax[1]);
  for(int i=0; i<eNcell; i++)    h->Fill( Y(IY(i)), eNC[i] );
  return h;
}

Set0()

void EdbH2::Set0

(

)

{
  for(int i=0; i<2; i++) { eN[i]=0; eMin[i]=0; eMax[i]=0; eBin[i]=0; }
  eNcell=0;
  eNC=0;
}

SetBin() [1/2]

void EdbH2::SetBin ( int  ix, int  iy, int  n  )

inline

{ if(Jcell(ix,iy)>-1) eNC[Jcell(ix,iy)] = n; }

SetBin() [2/2]

void EdbH2::SetBin ( int  j, int  n  )

inline

{ if(j>-1||j<eNcell) eNC[j] = n; }

X()

float EdbH2::X ( int  ix ) const

inline

{return eMin[0]+eBin[0]*(ix+0.5);}

Xbin()

float EdbH2::Xbin ( ) const

inline

{return eBin[0];}

Xj()

float EdbH2::Xj ( int  j ) const

inline

{return X(IX(j));}

Xmax()

float EdbH2::Xmax ( ) const

inline

{return eMax[0];}

XmaxA()

float EdbH2::XmaxA

(

float

level = 0

)

{
  EdbH1 *h = ProjectionX();  return h->XmaxA(level); SafeDelete(h);
}

Xmin()

float EdbH2::Xmin ( ) const

inline

{return eMin[0];}

XminA()

float EdbH2::XminA

(

float

level = 0

)

{
  EdbH1 *h = ProjectionX();  return h->XminA(level); SafeDelete(h);
}

Y()

float EdbH2::Y ( int  iy ) const

inline

{return eMin[1]+eBin[1]*(iy+0.5);}

Ybin()

float EdbH2::Ybin ( ) const

inline

{return eBin[1];}

Yj()

float EdbH2::Yj ( int  j ) const

inline

{return Y(IY(j));}

Ymax()

float EdbH2::Ymax ( ) const

inline

{return eMax[1];}

YmaxA()

float EdbH2::YmaxA

(

float

level = 0

)

{
  EdbH1 *h = ProjectionY();  return h->XmaxA(level); SafeDelete(h);
}

Ymin()

float EdbH2::Ymin ( ) const

inline

{return eMin[1];}

YminA()

float EdbH2::YminA

(

float

level = 0

)

{
  EdbH1 *h = ProjectionY();  return h->XminA(level); SafeDelete(h);
}

Member Data Documentation

eBin

Float_t EdbH2::eBin[2]

protected

bin size

eMax

Float_t EdbH2::eMax[2]

protected

max

eMin

Float_t EdbH2::eMin[2]

protected

min

eN

Int_t EdbH2::eN[2]

protected

divisions

eNC

Int_t* EdbH2::eNC

protected

[eNcell] number of objects/cell

eNcell

Int_t EdbH2::eNcell

protected

eNx*eNy

---

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

• /home/antonio/fedra_doxygen/src/libEmath/EdbCell2.h
• /home/antonio/fedra_doxygen/src/libEmath/EdbCell2.cpp