EdbSegmentsBox Class Reference

#include <EdbPattern.h>

Inheritance diagram for EdbSegmentsBox:

Collaboration diagram for EdbSegmentsBox:

Public Member Functions
EdbSegP *	AddSegment (EdbSegP &s)
EdbSegP *	AddSegment (EdbSegP &s1, EdbSegP &s2)
EdbSegP *	AddSegment (int i, EdbSegP &s)
EdbSegP *	AddSegment (int id, float x, float y, float tx, float ty, float w=0, int flag=0)
EdbSegP *	AddSegmentNoDuplicate (EdbSegP &s)
EdbPoint *	At (int i) const
Int_t	CalculateAXAY (EdbSegmentsBox *p, EdbAffine2D *affA)
Int_t	CalculateXY (EdbSegmentsBox *p, EdbAffine2D *aff)
Float_t	Diff (EdbSegmentsBox &p)
Float_t	DiffAff (EdbAffine2D *aff)
Float_t	DZ () const
	EdbSegmentsBox (EdbSegmentsBox &box)
	EdbSegmentsBox (float x0, float y0, float z0, int nseg=0)
	EdbSegmentsBox (int nseg=0)
void	Expand (int n)
Int_t	GetN () const
EdbSegP *	GetSegment (int i) const
EdbSegP *	GetSegmentLast () const
TClonesArray *	GetSegments () const
void *	GetSegmentsAddr ()
Float_t	GetSize (Int_t XorY)
Float_t	GetSizeX ()
Float_t	GetSizeXY ()
Float_t	GetSizeY ()
Float_t	GetTrackDensity ()
Float_t	GetTrackDensitymm2 ()
Int_t	N () const
void	Print (Option_t *opt="") const
void	ProjectTo (const float dz)
void	RemoveAngMargins (float tx0, float ty0, float dtx, float dty)
void	RemovePosMargins (float x0, float y0, float dx, float dy)
void	Reset ()
void	Set0 ()
void	SetSegmentsDZ (float dz)
void	SetSegmentsFlag (int flag)
void	SetSegmentsPlate (int plate)
void	SetSegmentsW (float w)
void	SetSegmentsZ ()
void	SetX (float x)
void	SetY (float y)
void	SetZ (float z)
void	TransformA (const EdbAffine2D *affA)
void	TransformARot (const EdbAffine2D *affA)
void	TransformShr (const float shr)
Float_t	X () const
Float_t	Y () const
Float_t	Z () const
virtual	~EdbSegmentsBox ()
Public Member Functions inherited from EdbPointsBox2D
virtual Float_t	DeltaX ()
virtual Float_t	DeltaY ()
virtual void	DrawPoints (int style=23, int col=4, float size=1., bool same=false)
	EdbPointsBox2D ()
	EdbPointsBox2D (const EdbPointsBox2D &pb)
virtual const EdbAffine2D *	GetKeep () const
virtual void	GetKeep (EdbAffine2D &aff)
virtual void	Retransform ()
virtual void	Rotate (float angle)
virtual void	ScaleX (float scaleFactor)
virtual void	ScaleY (float scaleFactor)
virtual void	SetKeep (float a11, float a12, float a21, float a22, float b1, float b2)
virtual void	ShiftX (float offset)
virtual void	ShiftY (float offset)
virtual void	SmearXY (float sigmax, float sigmay)
virtual void	Substruct (EdbPointsBox2D *b)
virtual void	Transform (const EdbAffine2D *a)
virtual TH1F *	Xhist ()
virtual Float_t	Xmax () const
virtual Float_t	Xmin () const
virtual TH2F *	XYhist ()
virtual TH1F *	Yhist ()
virtual Float_t	Ymax () const
virtual Float_t	Ymin () const
virtual	~EdbPointsBox2D ()
Public Member Functions inherited from EdbPoint3D
virtual void	Substruct (EdbPoint *p)
virtual void	Test () const
virtual void	TestPoint3D () const
virtual void	Transform (const EdbAffine3D *a)
virtual	~EdbPoint3D ()
Public Member Functions inherited from EdbPoint2D
virtual void	TestPoint2D () const
virtual	~EdbPoint2D ()
Public Member Functions inherited from EdbPoint
virtual	~EdbPoint ()

Private Attributes
Float_t	eDZkeep
TClonesArray *	eSegments
Float_t	eX
Float_t	eY
Float_t	eZ

Constructor & Destructor Documentation

EdbSegmentsBox() [1/3]

EdbSegmentsBox::EdbSegmentsBox

(

int

nseg = 0

)

{
  if(nseg>0) eSegments = new TClonesArray("EdbSegP",nseg);
  else       eSegments = new TClonesArray("EdbSegP");
  Set0();
}

EdbSegmentsBox() [2/3]

EdbSegmentsBox::EdbSegmentsBox ( EdbSegmentsBox &  box )

inline

    {
      eX=box.X();
      eY=box.Y();
      eZ=box.Z();
      int n=box.N();
      eSegments = new TClonesArray("EdbSegP",n);
      for(int i=0; i<n; i++) 
    AddSegment( *(box.GetSegment(i)) );
    }

EdbSegmentsBox() [3/3]

EdbSegmentsBox::EdbSegmentsBox	(	float	x0,
		float	y0,
		float	z0,
		int	nseg = 0
	)

{
  if(nseg>0) eSegments = new TClonesArray("EdbSegP",nseg);
  else       eSegments = new TClonesArray("EdbSegP");
  eX=x0;  eY=y0;  eZ=z0;
  eDZkeep=0;
}

~EdbSegmentsBox()

EdbSegmentsBox::~EdbSegmentsBox ( )

virtual

{
  if(eSegments) {
    eSegments->Delete();
    delete eSegments;
    eSegments=0;
  }
}

Member Function Documentation

AddSegment() [1/4]

EdbSegP * EdbSegmentsBox::AddSegment

(

EdbSegP &

s

)

{
  return new((*eSegments)[N()])  EdbSegP( s );
}

AddSegment() [2/4]

EdbSegP * EdbSegmentsBox::AddSegment	(	EdbSegP &	s1,
		EdbSegP &	s2
	)

{
  EdbSegP *s = new((*eSegments)[N()])  EdbSegP( s1 );
  s->MergeTo(s2);
  return s;
}

AddSegment() [3/4]

EdbSegP * EdbSegmentsBox::AddSegment	(	int	i,
		EdbSegP &	s
	)

{
  return new((*eSegments)[i])  EdbSegP( s );
}

AddSegment() [4/4]

EdbSegP * EdbSegmentsBox::AddSegment	(	int	id,
		float	x,
		float	y,
		float	tx,
		float	ty,
		float	w = 0,
		int	flag = 0
	)

{
  return new((*eSegments)[N()])  EdbSegP( id,x,y,tx,ty,w,flag );
}

AddSegmentNoDuplicate()

EdbSegP * EdbSegmentsBox::AddSegmentNoDuplicate

(

EdbSegP &

s

)

{
  // This function will add the segment s to the current list of
  // segments checking for duplicates. If any segment in the list is found,
  // that is compatible to this, the segment will _not_ be added,
  // instead a warning message will be printed (according to    
  // verbosity level)
  // This function might be slow. 
  
  //cout << endl  << endl;
  //cout <<"EdbSegmentsBox::AddSegmentNoDuplicate( EdbSegP &s )" << endl;
  //s.PrintNice();
  Int_t eSegmentsN = GetN();
  //cout << "Segments already in the eSegments list: " << eSegmentsN << endl;
  //cout << "Check now if segment s is already in the list..." << endl;
  
  EdbSegP* sComparison; 
  
  for (int i=0; i<eSegmentsN; ++i) {
    
    sComparison=(EdbSegP* )eSegments->At(i);
    //sComparison->PrintNice();
    //Bool_t EdbSegP::IsEqual(const TObject *obj) const
    //cout << "Evaluating   s.IsEqual(sComparison) = " << s.IsEqual(sComparison) << endl;
    if (s.IsEqual(sComparison)==kTRUE) {
      //cout << "Tested Segment is witin one sigma equal with one already in the list. DO NOT ADD THIS Segment..." << endl;
      return NULL;
    } 
    
    //bool EdbSegP::IsCompatible( EdbSegP &s, float nsigx, float nsigt ) const
    /*
     cout << "Evaluating   s.IsCompatible(*sComparison,1,1) = " << s.IsCompatible(*sComparison,1,1) << endl;
     if (s.IsCompatible(*sComparison,1,1)==kTRUE) {
      cout << "Tested Segment is witin one sigma compatible with one already in the list. DO NOT ADD THIS Segment..." << endl;
       return NULL;
     }
     */
    
  }
 
  //cout <<" EdbSegmentsBox::AddSegmentNoDuplicate( EdbSegP &s )   Segment s added." << endl;
  return new((*eSegments)[N()])  EdbSegP( s );
}

At()

EdbPoint* EdbSegmentsBox::At ( int  i ) const

inlinevirtual

Implements EdbPointsBox2D.

{return (EdbPoint*)GetSegment(i);}

CalculateAXAY()

int EdbSegmentsBox::CalculateAXAY	(	EdbSegmentsBox *	p,
		EdbAffine2D *	affA
	)

{
  int n=N();
  if( n>pat->N() )  n=pat->N();
  if(n<2) return 0;
 
  float *ax1 = new float[n];
  float *ay1 = new float[n];
  float *ax2 = new float[n];
  float *ay2 = new float[n];
 
  EdbSegP *p1,*p2;
  for(int i=0; i<n; i++ ) {
    p1 = GetSegment(i);
    p2 = pat->GetSegment(i);
    ax1[i] = p1->TX();
    ay1[i] = p1->TY();
    ax2[i] = p2->TX();
    ay2[i] = p2->TY();
  }
  aff->Calculate(n,ax1,ay1,ax2,ay2);
 
  delete ax1;
  delete ay1;
  delete ax2;
  delete ay2;
 
  return 1;
}

CalculateXY()

int EdbSegmentsBox::CalculateXY	(	EdbSegmentsBox *	p,
		EdbAffine2D *	aff
	)

{
  int n=N();
  if( n>pat->N() )  n=pat->N();
  if(n<2) return 0;
 
  aff->Calculate(this,pat);
  return 1;
}

Diff()

float EdbSegmentsBox::Diff

(

EdbSegmentsBox &

p

)

{
  // return the mean difference beteween pattern elements
  int nseg = TMath::Min( N(), p.N() );
 
  if(nseg<1) return 0;
 
  EdbSegP *s1=0, *s2=0;
 
  float dx=0, dy=0;
  double sdx=0;
  for(int i=0; i<nseg; i++ ) {
    s1 =   GetSegment(i);
    s2 = p.GetSegment(i);
    dx = s2->X() - s1->X();
    dy = s2->Y() - s1->Y();
    sdx += TMath::Sqrt( dx*dx + dy*dy);
  }
  return sdx/nseg;
}

DiffAff()

float EdbSegmentsBox::DiffAff

(

EdbAffine2D *

aff

)

{
  EdbSegmentsBox p,p1;
  p.AddSegment(0,Xmin(),Ymin(),0.,0.);
  p.AddSegment(0,Xmax(),Ymin(),0.,0.);
  p.AddSegment(0,Xmin(),Ymax(),0.,0.);
  p.AddSegment(0,Xmax(),Ymax(),0.,0.);
 
  p1.AddSegment(0,Xmin(),Ymin(),0.,0.);
  p1.AddSegment(0,Xmax(),Ymin(),0.,0.);
  p1.AddSegment(0,Xmin(),Ymax(),0.,0.);
  p1.AddSegment(0,Xmax(),Ymax(),0.,0.);
 
  p1.Transform(aff);
  return p.Diff(p1);
}

DZ()

Float_t EdbSegmentsBox::DZ ( ) const

inline

{return eDZkeep;}

Expand()

void EdbSegmentsBox::Expand ( int  n )

inline

{eSegments->Expand(n);}

GetN()

Int_t EdbSegmentsBox::GetN ( ) const

inline

{return eSegments ? eSegments->GetEntriesFast() : 0;}

GetSegment()

EdbSegP* EdbSegmentsBox::GetSegment ( int  i ) const

inline

{return (EdbSegP*)eSegments->At(i); }

GetSegmentLast()

EdbSegP* EdbSegmentsBox::GetSegmentLast ( ) const

inline

{return GetN() ? (EdbSegP*)eSegments->Last() : 0;}

GetSegments()

TClonesArray* EdbSegmentsBox::GetSegments ( ) const

inline

{ return eSegments; }

GetSegmentsAddr()

void* EdbSegmentsBox::GetSegmentsAddr ( )

inline

{ return &eSegments; }

GetSize()

float EdbSegmentsBox::GetSize

(

Int_t

XorY

)

{
  // return the size of the segments box in X//Y
  // simple approach using max/min values of segments
  // works only if 2 or more segemts are in it.
  int nseg = N();
  if(nseg<2) return 0;
  EdbSegP *s1=0;
 
  float minX=0; float maxX=0;
  float minY=0; float maxY=0;
  for(int i=0; i<nseg; i++ ) {
    s1 =   GetSegment(i);
    if (i==0) { 
      minX=s1->X(); maxX=s1->X(); 
      minY=s1->Y(); maxY=s1->Y();
    }
    maxX=TMath::Max(maxX,s1->X());
    minX=TMath::Min(minX,s1->X());
    maxY=TMath::Max(maxY,s1->Y());
    minY=TMath::Min(minY,s1->Y());
  }
  float sizeX=TMath::Abs(maxX-minX);
  float sizeY=TMath::Abs(maxY-minY);
  
  if (XorY==1) { return sizeY; }
  else { return sizeX; }
}

GetSizeX()

Float_t EdbSegmentsBox::GetSizeX ( )

inline

{ return GetSize(0); }

GetSizeXY()

float EdbSegmentsBox::GetSizeXY

(

)

{
  return (GetSize(0)*GetSize(1));
}

GetSizeY()

Float_t EdbSegmentsBox::GetSizeY ( )

inline

{ return GetSize(1); }

GetTrackDensity()

float EdbSegmentsBox::GetTrackDensity

(

)

{
  // Returns number of tracks per area (in microns usually)
  int nseg = N();
  if(nseg<2) return 0;
  float size=GetSizeXY();
  return float(nseg)/size;
}

GetTrackDensitymm2()

float EdbSegmentsBox::GetTrackDensitymm2

(

)

{
  // Returns number of tracks per area in millimeter squared
  // Original area is in microns x microns
  return GetTrackDensity()*1e6;
}

N()

Int_t EdbSegmentsBox::N ( ) const

inlinevirtual

Implements EdbPointsBox2D.

{return GetN();}

Print()

void EdbSegmentsBox::Print ( Option_t *  opt = "" ) const

virtual

Reimplemented from EdbPointsBox2D.

{
  int nseg=GetN();
  printf("EdbSegmentsBox: %d segments\n", nseg );
  for(int i=0; i<nseg; i++) GetSegment(i)->Print();
} 

ProjectTo()

void EdbSegmentsBox::ProjectTo

(

const float

dz

)

{
  eZ += dz;  eDZkeep += dz;
  int nseg = N();
  for(int i=0; i<nseg; i++ ) GetSegment(i)->PropagateToDZ(dz);
/*  for(int i=0; i<nseg; i++ ) {
    p = GetSegment(i);
    p->SetX( p->X() + p->TX()*dz );
    p->SetY( p->Y() + p->TY()*dz );
    p->SetZ( Z() );
  }*/
}

RemoveAngMargins()

void EdbSegmentsBox::RemoveAngMargins	(	float	tx0,
		float	ty0,
		float	dtx,
		float	dty
	)

{
  int nseg = N();
  for(int i=nseg-1; i>=0; i-- )    {
    EdbSegP *s = GetSegment(i);
    if( s->eTX > tx0+dtx || s->eTX < tx0-dtx || s->eTY > ty0+dty || s->eTY < ty0-dty ) eSegments->RemoveAt(i);
  }
  eSegments->Compress();
  Log(2,"EdbSegmentsBox::RemoveAngMargins","%d out of %d segments left", N(), nseg );
}

RemovePosMargins()

void EdbSegmentsBox::RemovePosMargins	(	float	x0,
		float	y0,
		float	dx,
		float	dy
	)

{
  int nseg = N();
  for(int i=nseg-1; i>=0; i-- )    {
    EdbSegP *s = GetSegment(i);
    if( s->eX > x0+dx || s->eX < x0-dx || s->eY > y0+dy || s->eY < y0-dy ) {
      eSegments->RemoveAt(i);
    }
  }
  eSegments->Compress();
  Log(2,"EdbSegmentsBox::RemovePosMargins","%d out of %d segments left", N(), nseg );
}

Reset()

void EdbSegmentsBox::Reset

(

)

{
  Set0();
  if(eSegments) eSegments->Clear();
}

Set0()

void EdbSegmentsBox::Set0

(

)

{
  eX=0;  eY=0;  eZ=0;
  eDZkeep=0;
}

SetSegmentsDZ()

void EdbSegmentsBox::SetSegmentsDZ

(

float

dz

)

{
  int nseg = N();
  for(int i=0; i<nseg; i++ )    {
    GetSegment(i)->SetDZ( dz );
  }
}

SetSegmentsFlag()

void EdbSegmentsBox::SetSegmentsFlag

(

int

flag

)

{
  int nseg = N();
  for(int i=0; i<nseg; i++ )    {
    GetSegment(i)->SetFlag( flag );
  }
}

SetSegmentsPlate()

void EdbSegmentsBox::SetSegmentsPlate

(

int

plate

)

{
  int nseg = N();
  for(int i=0; i<nseg; i++ )    {
    GetSegment(i)->SetPlate( plate );
  }
}

SetSegmentsW()

void EdbSegmentsBox::SetSegmentsW

(

float

w

)

{
  int nseg = N();
  for(int i=0; i<nseg; i++ )    {
    GetSegment(i)->SetW( w );
  }
}

SetSegmentsZ()

void EdbSegmentsBox::SetSegmentsZ

(

)

{
  int nseg = N();
  for(int i=0; i<nseg; i++ )    {
    GetSegment(i)->SetZ( Z() );
  }
}

SetX()

void EdbSegmentsBox::SetX ( float  x )

inlinevirtual

Reimplemented from EdbPointsBox2D.

{ eX=x; }

SetY()

void EdbSegmentsBox::SetY ( float  y )

inlinevirtual

Reimplemented from EdbPointsBox2D.

{ eY=y; }

SetZ()

void EdbSegmentsBox::SetZ ( float  z )

inlinevirtual

Reimplemented from EdbPointsBox2D.

{ eZ=z; }

TransformA()

void EdbSegmentsBox::TransformA

(

const EdbAffine2D *

affA

)

{
  EdbSegP *p;
  float tx,ty;
 
  int nseg = N();
  for(int i=0; i<nseg; i++ ) {
    p = GetSegment(i);
 
    tx = aff->A11()*p->TX() + aff->A12()*p->TY() + aff->B1();
    ty = aff->A21()*p->TX() + aff->A22()*p->TY() + aff->B2();
    p->SetTX(tx);
    p->SetTY(ty);
  }
}

TransformARot()

void EdbSegmentsBox::TransformARot

(

const EdbAffine2D *

affA

)

{
  // apply to the angles only rotation members of transformation
 
  EdbSegP *p;
  float tx,ty;
 
  int nseg = N();
  for(int i=0; i<nseg; i++ ) {
    p = GetSegment(i);
 
    tx = aff->A11()*p->TX() + aff->A12()*p->TY();
    ty = aff->A21()*p->TX() + aff->A22()*p->TY();
    p->SetTX(tx);
    p->SetTY(ty);
  }
}

TransformShr()

void EdbSegmentsBox::TransformShr

(

const float

shr

)

{
  EdbSegP *p;
  float tx,ty;
 
  int nseg = N();
  for(int i=0; i<nseg; i++ ) {
    p = GetSegment(i);
 
    tx = p->TX()/shr;
    ty = p->TY()/shr;
    p->SetTX(tx);
    p->SetTY(ty);
  }
}

X()

Float_t EdbSegmentsBox::X ( ) const

inlinevirtual

Reimplemented from EdbPointsBox2D.

{return eX;}

Y()

Float_t EdbSegmentsBox::Y ( ) const

inlinevirtual

Reimplemented from EdbPointsBox2D.

{return eY;}

Z()

Float_t EdbSegmentsBox::Z ( ) const

inlinevirtual

Reimplemented from EdbPointsBox2D.

{return eZ;}

Member Data Documentation

eDZkeep

Float_t EdbSegmentsBox::eDZkeep

private

eSegments

TClonesArray* EdbSegmentsBox::eSegments

private

eX

Float_t EdbSegmentsBox::eX

private

eY

Float_t EdbSegmentsBox::eY

private

eZ

Float_t EdbSegmentsBox::eZ

private

---

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

• src/libEdr/EdbPattern.h
• src/libEdr/EdbPattern.cxx