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 ()
	RS agreement: 0 - in-view (default); 1 - in-zone; 2-in-plate; 3-in-brick. More...
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
	effective area of the pattern to be equalized More...
TObjArray	eExcludeThetaRange
	can be added EdbSegP with tx,ty, sigmaTX,sigmaTY to be excluded More...
EdbH1	eHEq
int	eNP
	number of points for the functions calculation More...
Double_t	eNsigma
	=4 More...
Double_t	eS0mt
	= 270.*340.; // area unit for Nseg calculation More...
Public Attributes inherited from EdbSigma
double	eDZbase
	= 210. emulsion base More...
double	eDZcell
	=1300. plate-to plate distance More...
double	eDZem
	geometry defines the "in-view" mt/bt accuracy: More...
double	eSaPlate
	"in-plate" basetrack angular tolrance (nonplanarity) More...
double	eSaZone
	"in-zone" microtrack angular tolrance (incorrect shrinkage+offsets) More...
double	eSxy
	grains measurement accuracy defines the "in view" bt and mt errors More...
double	eSxyPlate
	additional terms defines "in-plate" resolution More...
double	eSxyZone
	additional terms defines "in-zone" resolution More...
double	eSz
	= 2. grains z-uncertainty "field depth" More...

Private Attributes
TVector2 *	eChiLimits
	[min,max] More...
TVector2 *	eThetaLimits
	[min,max] More...
TVector2 *	eWLimits
	[min,max] More...
TVector2 *	eXLimits
	[min,max] area limits for the preselection procedure More...
TVector2 *	eYLimits
	[min,max] More...

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

effective area of the pattern to be equalized

eChiLimits

TVector2* EdbSEQ::eChiLimits

private

[min,max]

eExcludeThetaRange

TObjArray EdbSEQ::eExcludeThetaRange

can be added EdbSegP with tx,ty, sigmaTX,sigmaTY to be excluded

eHEq

EdbH1 EdbSEQ::eHEq

eNP

int EdbSEQ::eNP

number of points for the functions calculation

eNsigma

Double_t EdbSEQ::eNsigma

=4

eS0mt

Double_t EdbSEQ::eS0mt

= 270.*340.; // area unit for Nseg calculation

eThetaLimits

TVector2* EdbSEQ::eThetaLimits

private

[min,max]

eWLimits

TVector2* EdbSEQ::eWLimits

private

[min,max]

eXLimits

TVector2* EdbSEQ::eXLimits

private

[min,max] area limits for the preselection procedure

eYLimits

TVector2* EdbSEQ::eYLimits

private

[min,max]

---

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

• /home/antonio/fedra_doxygen/src/libEbase/EdbSEQ.h
• /home/antonio/fedra_doxygen/src/libEbase/EdbSEQ.cxx