EdbLayer Class Reference

#include <EdbLayer.h>

Inheritance diagram for EdbLayer:

Collaboration diagram for EdbLayer:

Public Member Functions
const EdbAffine2D *	AffineTXTY () const
const EdbAffine2D *	AffineXY () const
void	ApplyCorrections (EdbLayer &la)
void	ApplyCorrections (float shr, float zcorr, const EdbAffine2D &affxy, const EdbAffine2D &afftxty)
void	ApplyCorrectionsLocal (EdbCorrectionMap &map)
void	Copy (const EdbLayer &l)
void	CopyCorr (const EdbLayer &l)
void	CorrectSeg (EdbSegP &s)
void	CorrectSegLocal (EdbSegP &s)
float	DX () const
float	DY () const
float	DZ () const
	EdbLayer ()
	============================================================================== More...
	EdbLayer (const EdbLayer &l)
	============================================================================== More...
EdbAffine2D *	GetAffineTXTY ()
EdbAffine2D *	GetAffineXY ()
int	ID () const
void	Invert ()
bool	IsInside (float x, float y)
bool	IsInside (float x, float y, float z)
EdbCorrectionMap &	Map ()
int	Ncp () const
void	Print ()
void	ResetAffTXTY ()
void	ResetAffXY ()
void	ResetCorr ()
void	Set0 ()
	============================================================================== More...
void	SetAffTXTY (float a11, float a12, float a21, float a22, float b1, float b2)
void	SetAffXY (float a11, float a12, float a21, float a22, float b1, float b2)
void	SetDXDY (float dx, float dy)
void	SetID (int id)
void	SetNcp (int n)
void	SetShrinkage (float shr)
void	SetTXTY (float tx, float ty)
void	SetXY (float x, float y)
void	SetZ (float z)
void	SetZcorr (float zcorr)
void	SetZlayer (float z, float zmin, float zmax)
void	ShiftZ (float dz)
float	Shr () const
void	SubstructCorrections (EdbLayer &la)
float	TX () const
float	TX (EdbSegP &s)
float	TXp (EdbSegP &s)
float	TY () const
float	TY (EdbSegP &s)
float	TYp (EdbSegP &s)
float	X () const
float	X (EdbSegP &s)
float	Xmax () const
float	Xmin () const
float	Xp (EdbSegP &s)
float	Y () const
float	Y (EdbSegP &s)
float	Ymax () const
float	Ymin () const
float	Yp (EdbSegP &s)
float	Z () const
float	Zcorr () const
float	Zmax () const
float	Zmin () const
float	Zxy ()
virtual	~EdbLayer ()

Private Attributes
EdbAffine2D	eAffTXTY
EdbAffine2D	eAffXY
Float_t	eDX
Float_t	eDY
Int_t	eID
EdbCorrectionMap	eMap
Int_t	eNcp
Float_t	eShr
Float_t	eTX
Float_t	eTY
Float_t	eX
Float_t	eY
Float_t	eZ
Float_t	eZcorr
Float_t	eZmax
Float_t	eZmin

Constructor & Destructor Documentation

EdbLayer() [1/2]

EdbLayer::EdbLayer

(

)

==============================================================================

{
  Set0();
}

EdbLayer() [2/2]

EdbLayer::EdbLayer

(

const EdbLayer &

l

)

==============================================================================

{
  Set0();
  Copy(l);
}

~EdbLayer()

virtual EdbLayer::~EdbLayer ( )

inlinevirtual

{}

Member Function Documentation

AffineTXTY()

const EdbAffine2D * EdbLayer::AffineTXTY ( ) const

inline

{return &eAffTXTY;}

AffineXY()

const EdbAffine2D * EdbLayer::AffineXY ( ) const

inline

{return &eAffXY;}

ApplyCorrections() [1/2]

void EdbLayer::ApplyCorrections

(

EdbLayer &

la

)

---

{
  ApplyCorrections( la.Shr(), la.Zcorr(), *(la.GetAffineXY()), *(la.GetAffineTXTY()) );
  SetNcp(la.Ncp());
}

ApplyCorrections() [2/2]

void EdbLayer::ApplyCorrections	(	float	shr,
		float	zcorr,
		const EdbAffine2D &	affxy,
		const EdbAffine2D &	afftxty
	)

---

{
  eShr *= shr;
  eZcorr += zcorr;
  Log(3,"EdbLayer::ApplyCorrections","eShr: %f eZcorr: %f ", eShr, eZcorr );
  Log(3,"EdbLayer::ApplyCorrections","aff before: %s", eAffXY.AsString());
  Log(3,"EdbLayer::ApplyCorrections","corr      : %s", affxy.AsString());
  eAffXY.Transform(affxy);
  Log(3,"EdbLayer::ApplyCorrections","aff after: %s", eAffXY.AsString());
  Log(3,"EdbLayer::ApplyCorrections","afftxty  : %s", afftxty.AsString());
  eAffTXTY.Transform(afftxty);
}

ApplyCorrectionsLocal()

void EdbLayer::ApplyCorrectionsLocal ( EdbCorrectionMap &  map )

inline

{ eMap.ApplyCorrections(map); }

Copy()

void EdbLayer::Copy

(

const EdbLayer &

l

)

---

{
  eID = l.ID();
  eZ = l.Z(); 
  eZmin=l.Zmin(); 
  eZmax=l.Zmax();
  eX=l.X(); 
  eY=l.Y(); 
  eTX=l.TX(); 
  eTY=l.TY();
  eDX=l.DX(); 
  eDY=l.DY();
  CopyCorr(l);
  eNcp = l.eNcp;
  eMap.Copy(l.eMap);
}

CopyCorr()

void EdbLayer::CopyCorr

(

const EdbLayer &

l

)

---

{
  ResetCorr();
  ApplyCorrections( l.Shr(), l.Zcorr(), *(l.AffineXY()),  *(l.AffineTXTY()));
}

CorrectSeg()

void EdbLayer::CorrectSeg

(

EdbSegP &

s

)

---

{
  s.Set( s.ID(), X(s), Y(s), TX(s), TY(s), s.W(), s.Flag() );
}

CorrectSegLocal()

void EdbLayer::CorrectSegLocal

(

EdbSegP &

s

)

---

{
  eMap.CorrectSeg(s);
}

DX()

float EdbLayer::DX ( ) const

inline

{return eDX;}

DY()

float EdbLayer::DY ( ) const

inline

{return eDY;}

DZ()

float EdbLayer::DZ ( ) const

inline

{return eZmax-eZmin;}

GetAffineTXTY()

EdbAffine2D * EdbLayer::GetAffineTXTY ( )

inline

{return &eAffTXTY;}

GetAffineXY()

EdbAffine2D * EdbLayer::GetAffineXY ( )

inline

{return &eAffXY;}

ID()

int EdbLayer::ID ( ) const

inline

{return eID;}

Invert()

void EdbLayer::Invert

(

)

---

{
  eAffXY.Invert();
  eAffTXTY.Invert();
  eShr = 1./eShr;
  //TODO: invert also zcorr?
}

IsInside() [1/2]

bool EdbLayer::IsInside	(	float	x,
		float	y
	)

---

{
  if( x<Xmin() )  return false;
  if( x>Xmax() )  return false;
  if( y<Ymin() )  return false;
  if( y>Ymax() )  return false;
  return true;
}

IsInside() [2/2]

bool EdbLayer::IsInside	(	float	x,
		float	y,
		float	z
	)

---

{
  if( x<Xmin() )  return false;
  if( x>Xmax() )  return false;
  if( y<Ymin() )  return false;
  if( y>Ymax() )  return false;
  if( z<Zmin() )  return false;
  if( z>Zmax() )  return false;
  return true;
}

Map()

EdbCorrectionMap & EdbLayer::Map ( )

inline

{ return eMap; }

Ncp()

int EdbLayer::Ncp ( ) const

inline

{return eNcp;}

Print()

void EdbLayer::Print

(

)

---

{
  printf("Layer:\t%d\n",eID);
  printf("Ncp:\t%d\n", eNcp );
  printf("ZLAYER\t%f %f %f\n",eZ,eZmin,eZmax);
  printf("SHR\t%f\n",eShr);
  printf("Zcorr\t%f\n",eZcorr);
  printf("AFFXY\t");        eAffXY.Print();
  printf("AFFTXTY\t");      eAffTXTY.Print();
  printf("Local Corrections Table: %d x %d \n", eMap.NX(), eMap.NY() );
}

ResetAffTXTY()

void EdbLayer::ResetAffTXTY ( )

inline

{ eAffTXTY.Reset(); }

ResetAffXY()

void EdbLayer::ResetAffXY ( )

inline

{ eAffXY.Reset(); }

ResetCorr()

void EdbLayer::ResetCorr

(

)

---

{
  eShr = 1.;
  eZcorr=0;
  eAffXY.Reset();
  eAffTXTY.Reset();
}

Set0()

void EdbLayer::Set0

(

)

==============================================================================

{
  eID=0;
  eZ=0; eZmin=0; eZmax=0;
  eX=0; eY=0; eTX=0; eTY=0;
  eDX=eDY=kMaxInt;
  eShr = 1.;
  eZcorr=0;
}

SetAffTXTY()

void EdbLayer::SetAffTXTY ( float  a11, float  a12, float  a21, float  a22, float  b1, float  b2  )

inline

    {eAffTXTY.Set(a11,a12,a21,a22,b1,b2);}

SetAffXY()

void EdbLayer::SetAffXY ( float  a11, float  a12, float  a21, float  a22, float  b1, float  b2  )

inline

    {eAffXY.Set(a11,a12,a21,a22,b1,b2);}

SetDXDY()

void EdbLayer::SetDXDY ( float  dx, float  dy  )

inline

{eDX=dx; eDY=dy;}

SetID()

void EdbLayer::SetID ( int  id )

inline

{eID=id;}

SetNcp()

void EdbLayer::SetNcp ( int  n )

inline

{eNcp=n;}

SetShrinkage()

void EdbLayer::SetShrinkage ( float  shr )

inline

{eShr=shr;}

SetTXTY()

void EdbLayer::SetTXTY ( float  tx, float  ty  )

inline

{eTX=tx; eTY=ty;}

SetXY()

void EdbLayer::SetXY ( float  x, float  y  )

inline

{eX=x; eY=y;}

SetZ()

void EdbLayer::SetZ ( float  z )

inline

{eZ=z;}

SetZcorr()

void EdbLayer::SetZcorr ( float  zcorr )

inline

{eZcorr = zcorr;}

SetZlayer()

void EdbLayer::SetZlayer ( float  z, float  zmin, float  zmax  )

inline

{ eZ=z;eZmin=zmin;eZmax=zmax; }

ShiftZ()

void EdbLayer::ShiftZ

(

float

dz

)

---

{
  eZ += dz;  eZmin +=dz;  eZmax +=dz;
}

Shr()

float EdbLayer::Shr ( ) const

inline

{return eShr;}

SubstructCorrections()

void EdbLayer::SubstructCorrections

(

EdbLayer &

l

)

---

apply inverse corrections of layer l

{
  EdbAffine2D aff( *(l.GetAffineXY()) ), afftxty( *(l.GetAffineTXTY()) );
  aff.Invert();
  afftxty.Invert();
  ApplyCorrections( 1./l.Shr(), -l.Zcorr() , aff, afftxty );
}

TX() [1/2]

float EdbLayer::TX ( ) const

inline

{return eTX;}

TX() [2/2]

float EdbLayer::TX ( EdbSegP &  s )

inline

{ return eAffTXTY.A11()*TXp(s) + eAffTXTY.A12()*TYp(s) + eAffTXTY.B1(); }

TXp()

float EdbLayer::TXp ( EdbSegP &  s )

inline

{ return (eAffXY.A11()*s.eTX + eAffXY.A12()*s.eTY) / eShr; } // apply shrinkage and rotation 

TY() [1/2]

float EdbLayer::TY ( ) const

inline

{return eTY;}

TY() [2/2]

float EdbLayer::TY ( EdbSegP &  s )

inline

{ return eAffTXTY.A21()*TXp(s) + eAffTXTY.A22()*TYp(s) + eAffTXTY.B2(); }

TYp()

float EdbLayer::TYp ( EdbSegP &  s )

inline

{ return (eAffXY.A21()*s.eTX + eAffXY.A22()*s.eTY) / eShr; } // of the main transform: eAffXY

X() [1/2]

float EdbLayer::X ( ) const

inline

{return eX;}

X() [2/2]

float EdbLayer::X ( EdbSegP &  s )

inline

{ return Xp(s) + TX(s)*eZcorr; } // apply propagation

Xmax()

float EdbLayer::Xmax ( ) const

inline

{return X()+DX();}

Xmin()

float EdbLayer::Xmin ( ) const

inline

{return X()-DX();}

Xp()

float EdbLayer::Xp ( EdbSegP &  s )

inline

{ return eAffXY.A11()*s.eX + eAffXY.A12()*s.eY + eAffXY.B1(); } // only position transform

Y() [1/2]

float EdbLayer::Y ( ) const

inline

{return eY;}

Y() [2/2]

float EdbLayer::Y ( EdbSegP &  s )

inline

{ return Yp(s) + TY(s)*eZcorr; }

Ymax()

float EdbLayer::Ymax ( ) const

inline

{return Y()+DY();}

Ymin()

float EdbLayer::Ymin ( ) const

inline

{return Y()-DY();}

Yp()

float EdbLayer::Yp ( EdbSegP &  s )

inline

{ return eAffXY.A21()*s.eX + eAffXY.A22()*s.eY + eAffXY.B2(); }

Z()

float EdbLayer::Z ( ) const

inline

{return eZ;}

Zcorr()

float EdbLayer::Zcorr ( ) const

inline

{return eZcorr;}

Zmax()

float EdbLayer::Zmax ( ) const

inline

{return eZmax;}

Zmin()

float EdbLayer::Zmin ( ) const

inline

{return eZmin;}

Zxy()

float EdbLayer::Zxy ( )

inline

{ return eZ+eZcorr; }

Member Data Documentation

eAffTXTY

EdbAffine2D EdbLayer::eAffTXTY

private

eAffXY

EdbAffine2D EdbLayer::eAffXY

private

eDX

Float_t EdbLayer::eDX

private

eDY

Float_t EdbLayer::eDY

private

eID

Int_t EdbLayer::eID

private

eMap

EdbCorrectionMap EdbLayer::eMap

private

eNcp

Int_t EdbLayer::eNcp

private

eShr

Float_t EdbLayer::eShr

private

eTX

Float_t EdbLayer::eTX

private

eTY

Float_t EdbLayer::eTY

private

eX

Float_t EdbLayer::eX

private

eY

Float_t EdbLayer::eY

private

eZ

Float_t EdbLayer::eZ

private

eZcorr

Float_t EdbLayer::eZcorr

private

eZmax

Float_t EdbLayer::eZmax

private

eZmin

Float_t EdbLayer::eZmin

private

---

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

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