EdbSEQ Class Reference

#include <EdbSEQ.h>

Inheritance diagram for EdbSEQ:

Collaboration diagram for EdbSEQ:

Public Member Functions
void	AddExcludeThetaRange (EdbSegP &s)
void	CalculateDensityMT (EdbH1 &hEq)
double	DNbt (double t)
double	DNmt (double t)
void	Draw ()
	EdbSEQ ()
void	EqualizeMT (TObjArray &mti, TObjArray &mto, Double_t area)
void	ExcludeThetaRange (TObjArray &mti, TObjArray &mto)
double	FDNbt (double *x, double *par)
double	FDNmt (double *x, double *par)
bool	IsInsideThetaRange (EdbSegP *s)
void	PreSelection (EdbPattern &pi, TObjArray &po)
void	PrintLimits ()
void	ResetExcludeThetaRange ()
void	Set0 ()
void	SetChiLimits (float cmin, float cmax)
void	SetThetaLimits (float tmin, float tmax)
void	SetWLimits (float wmin, float wmax)
void	SetXLimits (float xmin, float xmax)
void	SetYLimits (float ymin, float ymax)
TH1F *	ThetaPlot (EdbPattern &p, const char *name="theta", const char *title="EdbSEQ theta distribution normalised to area")
TH1F *	ThetaPlot (TObjArray &arr, const char *name="theta", const char *title="EdbSEQ theta distribution normalised to area")
float	Wmt (EdbSegP &s)
virtual	~EdbSEQ ()
Public Member Functions inherited from EdbSigma
double	DAL (double t, double sxy, double sz, double dz)
double	DALbt (double t)
double	DALmt (double t)
double	DAT (double t, double sxy, double dz)
double	DATbt (double t)
double	DATmt (double t)
double	DP (double t, double sxy, double da, double dz)
double	DPLbt (double t)
double	DPLmt (double t)
double	DPTbt (double t)
double	DPTmt (double t)
void	Draw ()
	EdbSigma ()
double	FDAL (double *x, double *par)
double	FDALbt (double *x, double *par)
double	FDAT (double *x, double *par)
double	FDPLmt (double *x, double *par)
void	Set0 ()
double	SqSum (double a, double b)
virtual	~EdbSigma ()

Public Attributes
Double_t	eArea
TObjArray	eExcludeThetaRange
EdbH1	eHEq
int	eNP
Double_t	eNsigma
Double_t	eS0mt
Public Attributes inherited from EdbSigma
double	eDZbase
double	eDZcell
double	eDZem
double	eSaPlate
double	eSaZone
double	eSxy
double	eSxyPlate
double	eSxyZone
double	eSz

Private Attributes
TVector2 *	eChiLimits
TVector2 *	eThetaLimits
TVector2 *	eWLimits
TVector2 *	eXLimits
TVector2 *	eYLimits

Constructor & Destructor Documentation

EdbSEQ()

EdbSEQ::EdbSEQ ( )

inline

{ ((EdbSigma*)this)->Set0(); Set0();}

~EdbSEQ()

EdbSEQ::~EdbSEQ ( )

virtual

{
  SafeDelete(eXLimits);
  SafeDelete(eYLimits);
  SafeDelete(eWLimits);
  SafeDelete(eThetaLimits);
  SafeDelete(eChiLimits);
}

Member Function Documentation

AddExcludeThetaRange()

void EdbSEQ::AddExcludeThetaRange

(

EdbSegP &

s

)

{
  eExcludeThetaRange.Add( new EdbSegP(s) );
}

CalculateDensityMT()

void EdbSEQ::CalculateDensityMT

(

EdbH1 &

hEq

)

{
  Log(3,"EdbSEQ::CalculateDensityMT","eHEq.N(): %d", eHEq.N());
  TF1 *fnmt = new TF1("fnmt",this,&EdbSEQ::FDNmt,eHEq.Xmin(),eHEq.Xmax(),0,"EdbSEQ","FDNmt");
  fnmt->SetTitle("dNmt/dTheta in 1 view density function");
  fnmt->SetNpx(eNP);
  double *x=new double[eNP];
  double *w=new double[eNP];
  fnmt->CalcGaussLegendreSamplingPoints(eNP,x,w,1e-15);
  int n = eHEq.N();
  for(int i=0; i<n; i++) {
    float tmi=i*eHEq.Xbin();
    float tma=(i+1)*eHEq.Xbin();
    double sbin = fnmt->IntegralFast(eNP,x,w,tmi,tma);
    Log(3,"EdbSEQ::CalculateDensityMT","i,eNP,x,w,tmi,tma: %d %d %f %f %f %f   %lf", i,eNP,x,w,tmi,tma, sbin );
    if(sbin>0 && sbin<kMaxInt-2) eHEq.SetBin(i, int(sbin)+1 );
    //Log(3,"EdbSEQ::CalculateDensityMT","Integral(%f,%f) = %f", tmi, tma, float(sbin) );
  }
  Log(3,"EdbSEQ::CalculateDensityMT","Integral(0,0.6) = %f", float(fnmt->IntegralFast(eNP,x,w,0,0.6)) );
}

DNbt()

double EdbSEQ::DNbt

(

double

t

)

{
  // return dN/dTheta : the critical number of microtracks for the given
  //     theta range for a view area
  //printf("t=%f\n",t);
  double dal0 = SqSum(DALbt(0),eSaPlate);
  double dal  = SqSum(DALbt(t),eSaPlate);
  double dat  = SqSum(DATbt(t),eSaPlate);
  double dpl  = DP( t, SqSum( DPLbt(t),eSxyPlate ), dal, eDZcell );
  double dpt  = DP( t, SqSum( DPTbt(t),eSxyPlate ), dat, eDZcell );
  double nang = Sin(t)/dat * dal0/dal;
  return nang * eArea/dpl/dpt /eNsigma/eNsigma/eNsigma/eNsigma;
}

DNmt()

double EdbSEQ::DNmt

(

double

t

)

{
  // return dN/dTheta : the critical number of microtracks for the given
  //     theta range for a view*nviews area
 
  double dpl = DP(t,DPLmt(t),DALmt(t),eDZbase);
  double dpt = DP(t,DPTmt(t),DATmt(t),eDZbase);
  double nang = Sin(t)/DATmt(t) * DALmt(0)/DALmt(t);
  //return nang * eNviews*eS0mt/dpl/dpt /eNsigma/eNsigma/eNsigma/eNsigma;
  return nang * eArea/dpl/dpt /eNsigma/eNsigma/eNsigma/eNsigma;
}

Draw()

void EdbSEQ::Draw

(

)

{
  TCanvas *cn = new TCanvas("cn","Critical density",800,600);
  cn->Divide(2,2);
 
  TF1 *fnmt = new TF1("fnmt",this,&EdbSEQ::FDNmt,0.,1.,0,"EdbSEQ","FDNmt");
  fnmt->SetTitle("dNmt/dTheta in 1 view density function");
  fnmt->SetNpx(eNP);
 
  cn->cd(1);
  fnmt->Draw();
  cn->cd(2);
  fnmt->DrawIntegral();
 
  TF1 *fnbt = new TF1("fnbt",this,&EdbSEQ::FDNbt,0.,1.,0,"EdbSEQ","FDNbt");
  fnbt->SetTitle("dNbt/dTheta in 1 view density function");
  fnbt->SetNpx(eNP);
 
  cn->cd(3);
  fnbt->Draw();
  cn->cd(4);
  fnbt->DrawIntegral();
}

EqualizeMT()

void EdbSEQ::EqualizeMT	(	TObjArray &	mti,
		TObjArray &	mto,
		Double_t	area
	)

{
  // Input:  mti  - microtracks array
  // Output: mto  - selected microtracks array
 
  eArea=area;
  float tbin=0.02;
  int nbin= (int)(eThetaLimits->Y()/tbin) + 1;
  eHEq.InitH1( nbin, 0, (nbin-1)*tbin );
  CalculateDensityMT(eHEq);         // define critical theta density
  if(gEDBDEBUGLEVEL>2) eHEq.Print();
 
  TClonesArray  hw("EdbH1",eHEq.N());    // create W-hist per each theta bin
  TArrayF thres(eHEq.N());               // W-thresholds to be defined
  for(int i=0; i<eHEq.N(); i++) {
    new(hw[i]) EdbH1();
    ((EdbH1*)hw[i])->InitH1( 500, 5.*50, 17.*50. );
  }
 
  int nseg = mti.GetEntriesFast();
  for(int i=0; i<nseg; i++) {
    EdbSegP *s = (EdbSegP*)(mti.UncheckedAt(i));
    int jtheta = eHEq.IX(s->Theta());
    if(jtheta>eHEq.N()-1)  continue;
    float w = Wmt(*s);
    ((EdbH1*)hw[jtheta])->Fill(w);
  }
 
  for(int i=0; i<eHEq.N(); i++) {
    int eccess = ((EdbH1*)hw[i])->Integral() - eHEq.Bin(i);
    if( eccess <= 0 ) continue;  // the threshold remains 0
 
    int nsum=0;
    for(int j=0; j<((EdbH1*)hw[i])->N(); j++) {
      nsum+=((EdbH1*)hw[i])->Bin(j);
      if( nsum >= eccess ) { thres[i] = ((EdbH1*)hw[i])->X(j)-((EdbH1*)hw[i])->Xbin(); break; }
    }    
  }
 
  for(int i=0; i<nseg; i++) {
    EdbSegP *s = (EdbSegP*)(mti.UncheckedAt(i));
    int jtheta = eHEq.IX(s->Theta());
    if(jtheta>eHEq.N()-1)  continue;
    float w = Wmt(*s);
    if( w > thres[jtheta] ) 
      if(!IsInsideThetaRange(s)) 
        mto.Add(s);
  }
  
  Log(2,"EdbSEQ::EqualizeMT","selected %3.1f\%  (%d of %d) segments in area of %7.1f cm²", 100.*mto.GetEntriesFast()/nseg, mto.GetEntriesFast(), nseg, (float)(eArea/1000./1000./10./10.) );
}

ExcludeThetaRange()

void EdbSEQ::ExcludeThetaRange	(	TObjArray &	mti,
		TObjArray &	mto
	)

{
   // exclude 1 sigma in theta around all requested segments
  int nseg   = mti.GetEntriesFast();
  for(int i=0; i<nseg; i++) {
    EdbSegP *s = (EdbSegP*)(mti.UncheckedAt(i));
    if(!IsInsideThetaRange(s)) mto.Add(s);
  }
}

FDNbt()

double EdbSEQ::FDNbt ( double *  x, double *  par  )

inline

{return DNbt(*x);}

FDNmt()

double EdbSEQ::FDNmt ( double *  x, double *  par  )

inline

{return DNmt(*x);}

IsInsideThetaRange()

bool EdbSEQ::IsInsideThetaRange

(

EdbSegP *

s

)

{
   // exclude 1 sigma in theta around all requested segments
   int nrange = eExcludeThetaRange.GetEntriesFast();
   for(int j=0; j<nrange; j++) {
     EdbSegP *sex = (EdbSegP*)(eExcludeThetaRange.UncheckedAt(j));
     float dtx = s->TX() - sex->TX();
     float dty = s->TY() - sex->TY();
     if( (dtx*dtx/sex->STX()/sex->STX()+dty*dty/sex->STY()/sex->STY())<1. ) return 1;
  }
  return 0;
}

PreSelection()

void EdbSEQ::PreSelection	(	EdbPattern &	pi,
		TObjArray &	po
	)

{
  int nseg = pi.N();
  for(int i=0; i<nseg; i++) {
    EdbSegP *s = pi.GetSegment(i);
    if(eChiLimits) {
      if( s->Chi2() < eChiLimits->X() )  continue;
      if( s->Chi2() > eChiLimits->Y() )  continue;
    }
    if(eXLimits) {
      if( s->X() < eXLimits->X() )  continue;
      if( s->X() > eXLimits->Y() )  continue;
    }
    if(eYLimits) {
      if( s->Y() < eYLimits->X() )  continue;
      if( s->Y() > eYLimits->Y() )  continue;
    }
    if(eWLimits) {
      if( s->W() < eWLimits->X() )  continue;
      if( s->W() > eWLimits->Y() )  continue;
    }
    if(eThetaLimits) {
      if( s->Theta() < eThetaLimits->X() )  continue;
      if( s->Theta() > eThetaLimits->Y() )  continue;
    }
    po.Add(s);
  }
}

PrintLimits()

void EdbSEQ::PrintLimits

(

)

{
  if(eXLimits)     printf("XLimits:     %f %f\n",eXLimits->X(),eXLimits->Y());
  if(eYLimits)     printf("YLimits:     %f %f\n",eYLimits->X(),eYLimits->Y());
  if(eWLimits)     printf("WLimits:     %f %f\n",eWLimits->X(),eWLimits->Y());
  if(eChiLimits)   printf("ChiLimits:   %f %f\n",eChiLimits->X(),eChiLimits->Y());
  if(eThetaLimits) printf("ThetaLimits: %f %f\n",eThetaLimits->X(),eThetaLimits->Y());
}

ResetExcludeThetaRange()

void EdbSEQ::ResetExcludeThetaRange ( )

inline

{eExcludeThetaRange.Delete();}

Set0()

void EdbSEQ::Set0

(

)

{
  eS0mt   = 270.*340.;   // area unit for Nseg calculation in microns
  //eNviews = 1;         // number of views used for total area calculation
  eArea   = eS0mt;       // effective area of the pattern to be equalize
  eNsigma=4;
  eNP = 100;
  eExcludeThetaRange.SetOwner(1);
  eXLimits    =0;
  eYLimits    =0;
  eThetaLimits=0;
  eWLimits    =0;
  eChiLimits  =0;
}

SetChiLimits()

void EdbSEQ::SetChiLimits ( float  cmin, float  cmax  )

inline

{SafeDelete(eChiLimits); eChiLimits=new TVector2(cmin,cmax);}

SetThetaLimits()

void EdbSEQ::SetThetaLimits ( float  tmin, float  tmax  )

inline

{SafeDelete(eThetaLimits); eThetaLimits=new TVector2(tmin,tmax);}

SetWLimits()

void EdbSEQ::SetWLimits ( float  wmin, float  wmax  )

inline

{SafeDelete(eWLimits); eWLimits=new TVector2(wmin,wmax);}

SetXLimits()

void EdbSEQ::SetXLimits ( float  xmin, float  xmax  )

inline

{SafeDelete(eXLimits); eXLimits=new TVector2(xmin,xmax);}

SetYLimits()

void EdbSEQ::SetYLimits ( float  ymin, float  ymax  )

inline

{SafeDelete(eYLimits); eYLimits=new TVector2(ymin,ymax);}

ThetaPlot() [1/2]

TH1F * EdbSEQ::ThetaPlot	(	EdbPattern &	p,
		const char *	name = "theta",
		const char *	title = "EdbSEQ theta distribution normalised to area"
	)

{
  int n = arr.N();  if(!n) return 0;
  TObjArray a(n);
  for(int i=0; i<n; i++) a.Add(arr.GetSegment(i));
  return ThetaPlot(a, name, title);
}

ThetaPlot() [2/2]

TH1F * EdbSEQ::ThetaPlot	(	TObjArray &	arr,
		const char *	name = "theta",
		const char *	title = "EdbSEQ theta distribution normalised to area"
	)

{
  int n = arr.GetEntries();  if(!n) return 0;
  float tbin=0.01;
  int nbin= (int)(eThetaLimits->Y()/tbin) + 1;
  TH1F *h = new TH1F( name, Form("%s normalised to area of %8.1f mm²",title,eArea/1000./1000.),  nbin, 0., (nbin-1)*tbin );
  for(int i=0; i<n; i++) {
    EdbSegP *s = (EdbSegP*)(arr.At(i));
    h->Fill(s->Theta());
  }
  h->GetXaxis()->SetTitle("theta");
  if(eArea>0) h->Scale(1000000./eArea);
  return h;
}

Wmt()

float EdbSEQ::Wmt ( EdbSegP &  s )

inline

{ return s.W()*50. + s.DZ(); }

Member Data Documentation

eArea

Double_t EdbSEQ::eArea

eChiLimits

TVector2* EdbSEQ::eChiLimits

private

eExcludeThetaRange

TObjArray EdbSEQ::eExcludeThetaRange

eHEq

EdbH1 EdbSEQ::eHEq

eNP

int EdbSEQ::eNP

eNsigma

Double_t EdbSEQ::eNsigma

eS0mt

Double_t EdbSEQ::eS0mt

eThetaLimits

TVector2* EdbSEQ::eThetaLimits

private

eWLimits

TVector2* EdbSEQ::eWLimits

private

eXLimits

TVector2* EdbSEQ::eXLimits

private

eYLimits

TVector2* EdbSEQ::eYLimits

private

---

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

• src/libEbase/EdbSEQ.h
• src/libEbase/EdbSEQ.cxx