EdbH1 Class Reference

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

#include <EdbCell1.h>

Inheritance diagram for EdbH1:

Collaboration diagram for EdbH1:

Public Member Functions
void	AddBin (int jcell, int n)
int	Bin (int ix) const
void	CleanCells ()
void	Copy (const EdbH1 &h)
void	Delete ()
int	DiscardHighCells (int nmax)
TH1F *	DrawH1 (const char *name="EdbH1plot", const char *title="EdbH1plot1D")
TH1I *	DrawSpectrum (const char *name="EdbH1spectrun")
	EdbH1 ()
	EdbH1 (const EdbH1 &h)
	EdbH1 (int n, float min, float max)
int	Fill (float x)
int	Fill (float x, int n)
int	InitH1 (const EdbH1 &h)
int	InitH1 (int n, float min, float max)
Long_t	Integral ()
Long_t	Integral (int iv, int ir)
int	IX (float x) const
int	Jcell (float x) const
int	Jcell (int ix) const
int	MaxBin ()
Float_t	Mean ()
int	N () const
int	Ncell () const
void	Print ()
void	PrintStat ()
void	Set0 ()
void	SetBin (int ix, int n)
float	X (int i) const
float	Xbin () const
float	Xmax () const
float	XmaxA (float level=0)
float	Xmin () const
float	XminA (float level=0)
	~EdbH1 ()

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

Detailed Description

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

//////////////////////////////////////////////////////////////////////// // EdbCell1 // // class to group 1-dim objects for the fast access // // ////////////////////////////////////////////////////////////////////////

Constructor & Destructor Documentation

EdbH1() [1/3]

EdbH1::EdbH1

(

)

{
  Set0();
}

EdbH1() [2/3]

EdbH1::EdbH1 ( int  n, float  min, float  max  )

inline

{ Set0(); InitH1(n,min,max); }

EdbH1() [3/3]

EdbH1::EdbH1

(

const EdbH1 &

h

)

{
  eNC = 0;
  Copy(h);
}

~EdbH1()

EdbH1::~EdbH1

(

)

{ 
  Delete();
}

Member Function Documentation

AddBin()

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

inline

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

Bin()

int EdbH1::Bin ( int  ix ) const

inline

{ if(Jcell(ix)>-1) return eNC[Jcell(ix)]; else return 0; }

CleanCells()

void EdbH1::CleanCells

(

)

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

Copy()

void EdbH1::Copy

(

const EdbH1 &

h

)

{
  Delete();
  eN=h.eN;
  eMin=h.eMin;
  eMax=h.eMax;
  eBin=h.eBin;
  eNcell=h.eNcell;
  if(h.eNC) {
    eNC = new Int_t[eNcell];
    memcpy( eNC, h.eNC, sizeof(Int_t)*eNcell );
  }
}

Delete()

void EdbH1::Delete

(

)

{
  if(eNC)    { delete [] eNC;    eNC = 0;  }
}

DiscardHighCells()

int EdbH1::DiscardHighCells

(

int

nmax

)

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

DrawH1()

TH1F * EdbH1::DrawH1	(	const char *	name = "EdbH1plot",
		const char *	title = "EdbH1plot1D"
	)

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

DrawSpectrum()

TH1I * EdbH1::DrawSpectrum

(

const char *

name = "EdbH1spectrun"

)

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

Fill() [1/2]

int EdbH1::Fill ( float  x )

inline

{ return Fill(x,1); }

Fill() [2/2]

int EdbH1::Fill	(	float	x,
		int	n
	)

{ 
  int j = Jcell(x);
  if(j<0)              return 0;
  eNC[j] += n;
  return n;
}

InitH1() [1/2]

int EdbH1::InitH1 ( const EdbH1 &  h )

inline

{return InitH1( h.N(), h.Xmin(), h.Xmax() ); }

InitH1() [2/2]

int EdbH1::InitH1	(	int	n,
		float	min,
		float	max
	)

{ 
  if(n<1) return 0;
  eN=n;
  eMin = min;
  eMax = max;
  eBin = (eMax-eMin)/eN;
  eNcell = eN;
  if(eNC) delete [] eNC;
  eNC = new Int_t[eNcell];
  CleanCells();
  return eNcell;
}

Integral() [1/2]

Long_t EdbH1::Integral

(

)

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

Integral() [2/2]

Long_t EdbH1::Integral	(	int	iv,
		int	ir
	)

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

IX()

int EdbH1::IX ( float  x ) const

inline

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

Jcell() [1/2]

int EdbH1::Jcell ( float  x ) const

inline

{ return Jcell( IX(x) ); }

Jcell() [2/2]

int EdbH1::Jcell ( int  ix ) const

inline

{ if(ix>=0&&ix<eN) return ix; else return -1;}

MaxBin()

int EdbH1::MaxBin

(

)

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

Mean()

Float_t EdbH1::Mean ( )

inline

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

N()

int EdbH1::N ( ) const

inline

{return eN;}

Ncell()

int EdbH1::Ncell ( ) const

inline

{return eNcell;}

Print()

void EdbH1::Print

(

)

{
  PrintStat();
  for(int i=0; i<N(); i++) 
    printf("%d (%f) = %d\n", i, X(i), Bin(i) );
}

PrintStat()

void EdbH1::PrintStat

(

)

{
  printf("X:%5d cells in range (%10.2f %10.2f) with bin %10.2f \n", eN,eMin,eMax,eBin);
  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 entries in %d bins in the range: (%d:%d) with mean occupancy= %f\n", 
     ntot, eNcell, nmin, nmax, 1.*ntot/eNcell);
}

Set0()

void EdbH1::Set0

(

)

{
  eN=0;
  eNcell=0;
  eNC=0;
}

SetBin()

void EdbH1::SetBin ( int  ix, int  n  )

inline

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

X()

float EdbH1::X ( int  i ) const

inline

{ return eMin+eBin*(i+0.5); }

Xbin()

float EdbH1::Xbin ( ) const

inline

{ return eBin; }

Xmax()

float EdbH1::Xmax ( ) const

inline

{ return eMax; }

XmaxA()

float EdbH1::XmaxA

(

float

level = 0

)

return X of the last bin >= given ratio in respect to the maximum amplitude (level range: [0:1] )

{
  float thres = MaxBin()*level;
  for(int i=eNcell-1; i>=0; i--)    if( eNC[i] >= thres ) return X(i);
  return 0;
}

Xmin()

float EdbH1::Xmin ( ) const

inline

{ return eMin; }

XminA()

float EdbH1::XminA

(

float

level = 0

)

return X of the first bin >= given ratio in respect to the maximum amplitude (level range: [0:1] )

{
  float thres = MaxBin()*level;
  for(int i=0; i<eNcell; i++)    if( eNC[i] >= thres ) return X(i);
  return 0;
}

Member Data Documentation

eBin

Float_t EdbH1::eBin

protected

bin size

eMax

Float_t EdbH1::eMax

protected

max

eMin

Float_t EdbH1::eMin

protected

min

eN

Int_t EdbH1::eN

protected

divisions

eNC

Int_t* EdbH1::eNC

protected

[eNcell] number of objects/cell

eNcell

Int_t EdbH1::eNcell

protected

eN

---

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

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