#include <EdbSegP.h>

Inheritance diagram for EdbSegP:

[legend]

Collaboration diagram for EdbSegP:

[legend]

Public Member Functions
void	addEMULDigit (TObject *a)

Int_t	Aid (int i) const

bool	CheckCOV () const

Float_t	Chi2 () const

void	Clear ()

Int_t	Compare (const TObject *obj) const

void	Copy (const EdbSegP &s)

TMatrixD &	COV () const

Float_t	DeltaR (EdbSegP *seg1) const

Float_t	DeltaTheta (EdbSegP *seg1) const

Float_t	DZ () const

Float_t	DZem () const

	EdbSegP ()

	EdbSegP (const EdbSegP &s)

	EdbSegP (int id, float x, float y, float tx, float ty, float w=0, int flag=0)

TRefArray *	EMULDigitArray () const

Int_t	Flag () const

void	ForceCOV (TMatrixD &cov)

Int_t	ID () const

bool	IsCompatible (EdbSegP &s, float nsigx, float nsigt) const

Bool_t	IsEqual (const TObject *obj) const

bool	IsInside (float xmin, float xmax, float ymin, float ymax) const

bool	IsInside (float xmin, float xmax, float ymin, float ymax, float zmin, float zmax) const

Bool_t	IsSortable () const

Int_t	MCEvt () const

Int_t	MCTrack () const

void	MergeTo (EdbSegP &s)

Float_t	P () const

Float_t	Phi () const

Int_t	PID () const

Int_t	Plate () const

void	Print (Option_t *opt="") const

void	PrintNice () const

Float_t	Prob () const

Float_t	ProbLink (EdbSegP &s1, EdbSegP &s2)

void	PropagateTo (float z)

void	PropagateToCOV (float z)

void	PropagateToDZ (float dz)

EdbID	ScanID () const

void	Set (int id, float x, float y, float tx, float ty, float w, int flag)

void	Set0 ()

void	SetAid (int a, int v, int side=0)

void	SetChi2 (float chi2)

void	SetCOV (double *array, int dim=5)

void	SetCOV (TMatrixD &cov)

void	SetDZ (float dz)

void	SetDZem (float dz)

void	SetErrorP (float sp2)

void	SetErrors ()

void	SetErrors (float sx2, float sy2, float sz2, float stx2, float sty2, float sp2=1.)

void	SetErrors0 ()

void	SetErrorsCOV (float sx2, float sy2, float sz2, float stx2, float sty2, float sp2=1.)

void	SetFlag (int flag)

void	SetID (int id)

void	SetMC (int mEvt, int mTrack)

void	SetP (float p)

void	SetPID (int pid)

void	SetPlate (int plateid)

void	SetProb (float prob)

void	SetProbability (float p)

void	SetScanID (EdbID id)

void	SetSide (int side=0)

void	SetSZ (float sz)

void	SetTrack (int trid)

void	SetTX (Float_t tx)

void	SetTY (Float_t ty)

void	SetVid (int vid, int sid)

void	SetVolume (float w)

void	SetW (float w)

void	SetX (Float_t x)

void	SetY (Float_t y)

void	SetZ (float z)

Int_t	Side () const

Float_t	SP () const

Float_t	STX () const

Float_t	STY () const

Float_t	SX () const

Float_t	SY () const

Float_t	SZ () const

Float_t	Theta () const

Int_t	Track () const

Float_t	TX () const

Float_t	TY () const

Int_t	Vid (int i) const

Float_t	Volume () const

Float_t	W () const

Float_t	X () const

Float_t	Y () const

Float_t	Z () const

virtual	~EdbSegP ()

Public Member Functions inherited from EdbTrack2D
virtual void	Substruct (EdbTrack2D *t)

virtual void	Test () const

virtual void	Transform (const EdbAffine2D *a)

virtual	~EdbTrack2D ()

Public Member Functions inherited from EdbPoint2D
virtual void	SetX (float x)=0

virtual void	SetY (float y)=0

virtual void	Substruct (EdbPoint *p)

virtual void	TestPoint2D () const

virtual	~EdbPoint2D ()

Public Member Functions inherited from EdbPoint
virtual void	Transform (const EdbAffine3D *a)

virtual	~EdbPoint ()

Public Member Functions inherited from EdbAngle2D
virtual void	SetTX (float x)=0

virtual void	SetTY (float y)=0

virtual void	Substruct (const EdbAngle2D *a)

virtual	~EdbAngle2D ()

Static Public Member Functions
static Float_t	Angle (const EdbSegP &s1, const EdbSegP &s2)

static Float_t	Distance (const EdbSegP &s1, const EdbSegP &s2)

static void	LinkMT (const EdbSegP s1, const EdbSegP s2, EdbSegP *s)

Public Attributes
Float_t	eTX

Float_t	eTY

Float_t	eX

Float_t	eY

Float_t	eZ

Protected Attributes
TMatrixD *	eCOV

Private Attributes
Int_t	eAid [2]

Float_t	eChi2

Float_t	eDZ

Float_t	eDZem

TRefArray *	eEMULDigitArray

Int_t	eFlag

Int_t	eID

Int_t	eMCEvt

Int_t	eMCTrack

Float_t	eP

Int_t	ePID

Float_t	eProb

EdbID	eScanID
	AM+AC 27/07/07. More...

Float_t	eSZ

Int_t	eTrack

Int_t	eVid [2]

Float_t	eVolume

Float_t	eW

Constructor & Destructor Documentation

◆ EdbSegP() [1/3]

EdbSegP::EdbSegP ( )

inline

             {
     eEMULDigitArray =0;
     Set0();
   }

◆ EdbSegP() [2/3]

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

 {
   eEMULDigitArray =0;
   Set0();
   Set(id,x,y,tx,ty,w,flag);
 }

◆ EdbSegP() [3/3]

EdbSegP::EdbSegP ( const EdbSegP & s )

inline

                             {  
     eEMULDigitArray = 0;
     Set0(); Copy(s); 
   }

◆ ~EdbSegP()

virtual EdbSegP::~EdbSegP ( )

inlinevirtual

                      { 
     SafeDelete(eCOV);
     SafeDelete(eEMULDigitArray);
   }

Member Function Documentation

◆ addEMULDigit()

void EdbSegP::addEMULDigit ( TObject * a )

inline

                                    {
     if(!eEMULDigitArray) eEMULDigitArray = new TRefArray();
     eEMULDigitArray->Add(a);
   }

◆ Aid()

Int_t EdbSegP::Aid ( int i ) const

inline

166 {if(i==0) return eAid[i]; else if(i==1) return eAid[i]%100000; else return -1;}

EdbSegP::eAid

Int_t eAid[2]

Definition: EdbSegP.h:24

◆ Angle()

Float_t EdbSegP::Angle	(	const EdbSegP &	s1,
		const EdbSegP &	s2
	)

static

 {
   return EdbMath::Angle3(s1.TX(),s1.TY(),s2.TX(),s2.TY());
 }

◆ CheckCOV()

bool EdbSegP::CheckCOV ( ) const

inline

                        { //Check Covariance Matrix, is there?
     if (eCOV) return true;
     else return false;
   }

◆ Chi2()

Float_t EdbSegP::Chi2 ( ) const

inline

154 {return eChi2;}

EdbSegP::eChi2

Float_t eChi2

Definition: EdbSegP.h:32

◆ Clear()

void EdbSegP::Clear ( )

inline

85 { eCOV->Clear(); }

◆ Compare()

int EdbSegP::Compare ( const TObject * obj ) const

 {
   const EdbSegP *s=(EdbSegP*)obj;
   double f1=0, f2=0;
  
   if     ( Abs(s->Z()- Z())  >0.000001 )   {  f1 = Z();   f2 = s->Z();  }  // usual case for tracks
   else if( Abs(s->X()- X())  >0.000001 )   {  f1 = X();   f2 = s->X();  }
   else if( Abs(s->Y()- Y())  >0.000001 )   {  f1 = Y();   f2 = s->Y();  }
   else if( Abs(s->TX()- TX())>0.000001 )   {  f1 = TX();  f2 = s->TX(); }
   else if( Abs(s->TY()- TY())>0.000001 )   {  f1 = TY();  f2 = s->TY(); }
   else if( Abs(s->W()- W())  >0.000001 )   {  f1 = W();   f2 = W();     }
  
   if      (f1>f2)    return  1;
   else if (f1<f2)    return -1;
   else               return  0;
 }

◆ Copy()

void EdbSegP::Copy ( const EdbSegP & s )

 {
   SetPID(s.PID());
   Set(s.ID(),s.X(),s.Y(),s.TX(),s.TY(),s.W(),s.Flag());
   SetZ(s.Z());
   if(s.CheckCOV()) SetCOV(s.COV());
   SetSZ(s.SZ());
   SetVid(s.Vid(0),s.Vid(1));
   SetAid(s.Aid(0),s.Aid(1),s.Side());
   SetProb(s.Prob());
   SetVolume(s.Volume());
   SetDZ(s.DZ());
   SetDZem(s.DZem());
   SetP(s.P());
   SetChi2(s.Chi2());
   SetTrack(s.Track());
   SetMC( s.MCEvt(), s.MCTrack() );
   SetScanID(s.ScanID());
   if(s.eEMULDigitArray) {
     eEMULDigitArray = new TRefArray(*s.eEMULDigitArray);
     printf("copy: %d %d\n",s.eEMULDigitArray->GetEntries(),eEMULDigitArray->GetEntries());
   }
 }

◆ COV()

TMatrixD& EdbSegP::COV ( ) const

inline

120 {return *eCOV;}

◆ DeltaR()

Float_t EdbSegP::DeltaR ( EdbSegP * seg1 ) const

inline

                                          {
                     return TMath::Sqrt( TMath::Power(X()-seg1->X(),2)+TMath::Power(Y()-seg1->Y(),2) );
   }

◆ DeltaTheta()

Float_t EdbSegP::DeltaTheta ( EdbSegP * seg1 ) const

inline

                                              {
                     return TMath::Sqrt( TMath::Power(TX()-seg1->TX(),2)+TMath::Power(TY()-seg1->TY(),2) );
   }

◆ Distance()

Float_t EdbSegP::Distance	(	const EdbSegP &	s1,
		const EdbSegP &	s2
	)

static

                                                             {
   double dx=s1.X()-s2.X();
   double dy=s1.Y()-s2.Y();
   double dz=s1.Z()-s2.Z();
   return TMath::Sqrt(dx*dx+dy*dy+dz*dz);
 }

◆ DZ()

Float_t EdbSegP::DZ ( ) const

inline

151 {return eDZ;}

EdbSegP::eDZ

Float_t eDZ

Definition: EdbSegP.h:36

◆ DZem()

Float_t EdbSegP::DZem ( ) const

inline

152 {return eDZem;}

EdbSegP::eDZem

Float_t eDZem

Definition: EdbSegP.h:37

◆ EMULDigitArray()

TRefArray* EdbSegP::EMULDigitArray ( ) const

inline

81 { return eEMULDigitArray;}

◆ Flag()

Int_t EdbSegP::Flag ( ) const

inline

146 {return eFlag;}

EdbSegP::eFlag

Int_t eFlag

Definition: EdbSegP.h:25

◆ ForceCOV()

void EdbSegP::ForceCOV ( TMatrixD & cov )

inline

                                    { //to correctly copy COV matrices in MakeTracksTree
     if(eCOV) *eCOV = cov;
     else eCOV = new TMatrixD(cov);
   }

◆ ID()

Int_t EdbSegP::ID ( ) const

inline

144 {return eID;}

EdbSegP::eID

Int_t eID

Definition: EdbSegP.h:22

◆ IsCompatible()

bool EdbSegP::IsCompatible	(	EdbSegP &	s,
		float	nsigx,
		float	nsigt
	)		const

 {
   // return true if segments are closer then nsig sigma in all coordinates
   // assumed that z is the same
   float dtx=TX()-s.TX();
   if( dtx*dtx > STX()*nsigt*nsigt )    return false;
   float dty=TY()-s.TY();
   if( dty*dty > STY()*nsigt*nsigt )    return false;
   float dz=s.Z()-Z();
   float dx=X()+TX()*dz-s.X();
   if( dx*dx > SX()*nsigx*nsigx )       return false;
   float dy=Y()+TY()*dz-s.Y();
   if( dy*dy > SY()*nsigx*nsigx )       return false;
   return true;
 }

◆ IsEqual()

Bool_t EdbSegP::IsEqual ( const TObject * obj ) const

 {
   const EdbSegP *s=(EdbSegP*)obj;
   if(s->ID()  != ID())               return false;
   if(s->PID() != PID())              return false;
   if(s->Vid(0) != Vid(0))            return false;
   if(s->Vid(1) != Vid(1))            return false;
   if(s->Aid(0) != Aid(0))            return false;
   if(s->Aid(1) != Aid(1))            return false;
   if(s->Side() != Side())            return false;
   if( Abs(s->Z()- Z())  >0.000001 )  return false;
   if( Abs(s->X()- X())  >0.000001 )  return false;
   if( Abs(s->Y()- Y())  >0.000001 )  return false;
   if( Abs(s->TX()- TX())>0.000001 )  return false;
   if( Abs(s->TY()- TY())>0.000001 )  return false;
   if( Abs(s->W()- W())  >0.000001 )  return false;
   if(s->Plate() != Plate())          return false;
   return true;
 }

◆ IsInside() [1/2]

bool EdbSegP::IsInside	(	float	xmin,
		float	xmax,
		float	ymin,
		float	ymax
	)		const

 {
   if(xmax<xmin) return false;
   if(ymax<ymin) return false;
   if(eX<xmin)   return false;
   if(eX>xmax)   return false;
   if(eY<ymin)   return false;
   if(eY>ymax)   return false;
   return true;
 }

◆ IsInside() [2/2]

bool EdbSegP::IsInside	(	float	xmin,
		float	xmax,
		float	ymin,
		float	ymax,
		float	zmin,
		float	zmax
	)		const

 {
   if(xmax<xmin) return false;
   if(ymax<ymin) return false;
   if(zmax<zmin) return false;
   if(eX<xmin)   return false;
   if(eX>xmax)   return false;
   if(eY<ymin)   return false;
   if(eY>ymax)   return false;
   if(eZ<zmin)   return false;
   if(eZ>zmax)   return false;
   return true;
 }

◆ IsSortable()

Bool_t EdbSegP::IsSortable ( ) const

inline

195 { return kTRUE; }

◆ LinkMT()

void EdbSegP::LinkMT	(	const EdbSegP *	s1,
		const EdbSegP *	s2,
		EdbSegP *	s
	)

static

Segments fit by Andrey Aleksandrov (Jul-2003)

 {
  
   Double_t dz = s2->Z() - s1->Z();
   Double_t dz2 = dz*dz;
  
   Double_t q1,q2,w1,w2;
   Double_t d1,d2,dxx11,dxx22;
   Double_t dtt01,dtt02,dtx01,dtx02;
   Double_t dxx01,dxx02,dxt01,dxt02;
   Double_t xm1,xm2,sx0,sy0,stx0,sty0;
  
   Double_t q;
  
   if(dz==0.0) {
     s->SetZ(s1->Z());
     s->SetID(s1->ID());
       
     q1 = s1->SX();
     q2 = s2->SX();
     w1 = s1->STX();
     w2 = s2->STX();
     
     sx0 = q1*q2/(q1+q2);
     q = (s1->X()/q1+s2->X()/q2)*sx0;
     s->SetX(q);
     stx0 = w1*w2/(w1+w2);
     q = (s1->TX()/w1+s2->TX()/w2)*stx0;
     s->SetTX(q);
  
     q1 = s1->SY();
     q2 = s2->SY();
     w1 = s1->STY();
     w2 = s2->STY();
  
     sy0 = q1*q2/(q1+q2);
     q = (s1->Y()/q1+s2->Y()/q2)*sy0;
     s->SetY(q);
     sty0 = w1*w2/(w1+w2);
     q = (s1->TY()/w1+s2->TY()/w2)*sty0;
     s->SetTY(q);
  
     s->SetErrors(sx0,sy0,0.0,stx0,sty0);
     s->SetW( s1->W()+s2->W() );
     return;
   }
  
   q = 0.5*(s1->Z()+s2->Z());
   Double_t dzr = 1.0/dz;
  
   s->SetZ(q);
   s->SetID(s1->ID());
  
   q1 = s1->SX();
   q2 = s2->SX();
   w1 = s1->STX();
   w2 = s2->STX();
  
   q = dz2*w2+q2;
   d1 = 1.0/(q+q1);
   xm1 = (q*s1->X()+(s2->X()-dz*s2->TX())*q1)*d1;
  
   q = dz2*w1+q1;
   d2 = 1.0/(q+q2);
   xm2 = (q*s2->X()+(s1->X()+dz*s1->TX())*q2)*d2;
  
  
   dtt01 = q2*d2;
   dtt02 = q1*d1;
   dxx11 = 1.0-dtt02;
   dxx22 = 1.0-dtt01;
   dxx01 = 0.5*(dxx11+dtt01);
   dxx02 = 0.5*(dxx22+dtt02);
   dxt01 = 0.5*dz*dtt01;
   dxt02 = -0.5*dz*dtt02;
   dtx01 = dzr*(dtt01-dxx11);
   dtx02 = dzr*(dxx22-dtt02);
  
   q = (xm1+xm2)*0.5;
   s->SetX(q);
   q = (xm2-xm1)*dzr;
   s->SetTX(q);
   sx0  = dxx01*dxx01*q1+dxx02*dxx02*q2+dxt01*dxt01*w1+dxt02*dxt02*w2;
   stx0 = dtx01*dtx01*q1+dtx02*dtx02*q2+dtt01*dtt01*w1+dtt02*dtt02*w2;
  
   q1 = s1->SY();
   q2 = s2->SY();
   w1 = s1->STY();
   w2 = s2->STY();
  
   q = dz2*w2+q2;
   d1 = 1.0/(q+q1);
   xm1 = (q*s1->Y()+(s2->Y()-dz*s2->TY())*q1)*d1;
  
   q = dz2*w1+q1;
   d2 = 1.0/(q+q2);
   xm2 = (q*s2->Y()+(s1->Y()+dz*s1->TY())*q2)*d2;
  
   dtt01 = q2*d2;
   dtt02 = q1*d1;
   dxx11 = 1.0-dtt02;
   dxx22 = 1.0-dtt01;
   dxx01 = 0.5*(dxx11+dtt01);
   dxx02 = 0.5*(dxx22+dtt02);
   dxt01 = 0.5*dz*dtt01;
   dxt02 = -0.5*dz*dtt02;
   dtx01 = dzr*(dtt01-dxx11);
   dtx02 = dzr*(dxx22-dtt02);
  
   q = (xm1+xm2)*0.5;
   s->SetY(q);
   q = (xm2-xm1)*dzr;
   s->SetTY(q);
   sy0  = dxx01*dxx01*q1+dxx02*dxx02*q2+dxt01*dxt01*w1+dxt02*dxt02*w2;
   sty0 = dtx01*dtx01*q1+dtx02*dtx02*q2+dtt01*dtt01*w1+dtt02*dtt02*w2;
  
   s->SetErrors(sx0,sy0,0.0,stx0,sty0);
   s->SetW( s1->W()+s2->W() );
   s->SetDZ(dz);
 }

◆ MCEvt()

Int_t EdbSegP::MCEvt ( ) const

inline

142 {return eMCEvt;}

EdbSegP::eMCEvt

Int_t eMCEvt

Definition: EdbSegP.h:40

◆ MCTrack()

Int_t EdbSegP::MCTrack ( ) const

inline

143 {return eMCTrack;}

EdbSegP::eMCTrack

Int_t eMCTrack

Definition: EdbSegP.h:39

◆ MergeTo()

void EdbSegP::MergeTo ( EdbSegP & s )

 {
   // create linked segment at Z of s2 
   // TODO - navesti nauku covariantnuiu 
   
   PropagateTo( s.Z() );
  
   float wx1,wx2, wy1,wy2;
   float wtx1,wtx2, wty1,wty2;
  
   wx1 = 1/SX();
   wx2 = 1/s.SX();
   wy1 = 1/SY();
   wy2 = 1/s.SY();
   wtx1 = 1/STX();
   wtx2 = 1/s.STX();
   wty1 = 1/STY();
   wty2 = 1/s.STY();
  
   eX = (X()*wx1 + s.X()*wx2)/(wx1+wx2);
   eY = (Y()*wy1 + s.Y()*wy2)/(wy1+wy2);
   (*eCOV)(0,0)=  1./(wx1+wx2);
   (*eCOV)(1,1)=  1./(wy1+wy2);
  
   eTX = (TX()*wtx1 + s.TX()*wtx2)/(wtx1+wtx2);
   eTY = (TY()*wty1 + s.TY()*wty2)/(wty1+wty2);
   (*eCOV)(2,2)= 1./(wtx1+wtx2);
   (*eCOV)(3,3)= 1./(wty1+wty2);
  
   eZ = s.Z();
   eSZ = TMath::Sqrt(( SZ() + s.SZ())/2);
  
   eW = W()+s.W();
  
   eID   = s.ID();
   ePID  = s.PID();
   eFlag = s.Flag();
 }

◆ P()

Float_t EdbSegP::P ( ) const

inline

149 {return eP;}

EdbSegP::eP

Float_t eP

Definition: EdbSegP.h:38

◆ Phi()

Float_t EdbSegP::Phi ( ) const

inline

180 {return TMath::ATan2(eTY,eTX);}

◆ PID()

Int_t EdbSegP::PID ( ) const

inline

145 {return ePID;}

◆ Plate()

Int_t EdbSegP::Plate ( ) const

inline

156 {return eScanID.ePlate;}

EdbID::ePlate

Int_t ePlate

Definition: EdbID.h:11

EdbSegP::eScanID

EdbID eScanID

AM+AC 27/07/07.

Definition: EdbSegP.h:42

◆ Print()

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

virtual

Reimplemented from EdbTrack2D.

 {
   printf("EdbSegP: ID= %d  PID = %d  Vid = %d  %d \t Aid = %d %d  Flag = %d\n", 
      ID(),PID(),eVid[0],eVid[1],eAid[0],eAid[1], Flag() );
   printf("x,y,z,dz,tx,ty,w,flag = %f %f %f   %f    %f %f\n", 
      X(),Y(),Z(),DZ(),TX(),TY() );
   printf("W = %f    P= %f \t Prob = %f \t Chi2 = %f \t Track = %d \n", 
      W(),P(),Prob(),Chi2(), Track() );
     
   if(eCOV) eCOV->Print();
 }

◆ PrintNice()

void EdbSegP::PrintNice ( ) const

 {
   printf( "EdbSegP: ID= %8d  PID = %8d, x= %14.3f, y= %14.3f, z= %14.3f, tx= %7.4f, ty= %7.4f, w= %7.4f, chi2= %7.4f Flag= %6d P= %6.1f MCEvt= %6d \n", ID(),PID(),X(),Y(),Z(),TX(),TY(),W(),Chi2(), Flag(), P(), MCEvt() );
   return;
 }

◆ Prob()

Float_t EdbSegP::Prob ( ) const

inline

153 {return eProb;}

EdbSegP::eProb

Float_t eProb

Definition: EdbSegP.h:33

◆ ProbLink()

float EdbSegP::ProbLink	(	EdbSegP &	s1,
		EdbSegP &	s2
	)

 {
   // return probability of the correct link in case Up/Down - specifics is 
   // that the position errors are neglected)
  
   double dz = s2.Z() - s1.Z();
  
   double tx = (s2.X() - s1.X()) / dz;
   double ty = (s2.Y() - s1.Y()) / dz;
  
   double dtx1 = (s1.TX()-tx)*(s1.TX()-tx)/s1.STX();
   double dty1 = (s1.TY()-ty)*(s1.TY()-ty)/s1.STY();
   double dtx2 = (s2.TX()-tx)*(s2.TX()-tx)/s2.STX();
   double dty2 = (s2.TY()-ty)*(s2.TY()-ty)/s2.STY();
  
   double chi2 = TMath::Sqrt(dtx1 + dty1 + dtx2 + dty2);
   double p3   = TMath::Prob(chi2*chi2,4);
  
   return s1.Prob()*s2.Prob()*p3;
 }

◆ PropagateTo()

void EdbSegP::PropagateTo ( float z )

 {
   float dz = z-Z();
   PropagateToDZ(dz);
 }

◆ PropagateToCOV()

void EdbSegP::PropagateToCOV ( float z )

 {
   float dz = z-Z();
   eX  = X() + TX()*dz;
   eY  = Y() + TY()*dz;
   eZ  = z;
  
   VtSqMatrix pred(4);        //propagation matrix for track parameters (x,y,tx,ty)
   pred.clear();
   pred(0,0) = 1.;
   pred(1,1) = 1.;
   pred(2,2) = 1.;
   pred(3,3) = 1.;
   pred(0,2) = dz;
   pred(1,3) = dz;
   
   VtSymMatrix cov(4);             // covariance matrix for seg0
   for(int k=0; k<4; k++) 
     for(int l=0; l<4; l++) cov(k,l) = (COV())(k,l);
   
   VtSymMatrix covpred(4);         // covariation matrix for prediction
   covpred = pred*(cov*(pred.T()));
   
   for(int k=0; k<4; k++) 
     for(int l=0; l<4; l++) (COV())(k,l) = covpred(k,l);
 }

◆ PropagateToDZ()

void EdbSegP::PropagateToDZ ( float dz )

 {
   eX  = eX + eTX*dz;
   eY  = eY + eTY*dz;
   eZ  += dz;
   if(eCOV) {
     (*eCOV)(0,0) = SX() + STX()*dz*dz;
     (*eCOV)(1,1) = SY() + STY()*dz*dz;
   }
 }

◆ ScanID()

EdbID EdbSegP::ScanID ( ) const

inline

157 {return eScanID;}

◆ Set()

void EdbSegP::Set	(	int	id,
		float	x,
		float	y,
		float	tx,
		float	ty,
		float	w,
		int	flag
	)

inline

87 { eID=id; eX=x; eY=y; eTX=tx; eTY=ty; eW=w; eFlag=flag; }

MIPBaseTrack::id

UInt_t id

Definition: tlg2pattern.C:118

◆ Set0()

void EdbSegP::Set0 ( )

 {
   ePID=0;
   eID=0;
   eVid[0]=eVid[1]=0;
   eAid[0]=eAid[1]=0;
   eFlag=0;
   eTrack=-1;
   eX=eY=eZ=eTX=eTY=eSZ=0;
   eProb=0;
   eW=0;
   eVolume=0;
   eDZ=0;
   eP=-999.;
   eChi2=0;
   eCOV=0;
   eMCTrack=-999;
   eMCEvt=-999;
 }

◆ SetAid()

void EdbSegP::SetAid	(	int	a,
		int	v,
		int	side = `0`
	)

inline

135 { eAid[0]=a; eAid[1]=100000*side+v; }

◆ SetChi2()

void EdbSegP::SetChi2 ( float chi2 )

inline

132 { eChi2=chi2; }

◆ SetCOV() [1/2]

void EdbSegP::SetCOV	(	double *	array,
		int	dim = `5`
	)

inline

                                          { 
     if(!array) return;
     if(!eCOV)  eCOV = new TMatrixD(5,5);
     for(int k=0; k<dim; k++) 
       for(int l=0; l<dim; l++) (*eCOV)(k,l) = array[k*dim + l];
   }

◆ SetCOV() [2/2]

void EdbSegP::SetCOV ( TMatrixD & cov )

inline

                                  { 
     if(eCOV) eCOV->Copy(cov);
     else eCOV = new TMatrixD(cov);
   }

◆ SetDZ()

void EdbSegP::SetDZ ( float dz )

inline

123 { eDZ=dz; }

◆ SetDZem()

void EdbSegP::SetDZem ( float dz )

inline

124 { eDZem=dz; }

◆ SetErrorP()

void EdbSegP::SetErrorP ( float sp2 )

inline

                                  {
     if(!eCOV) eCOV = new TMatrixD(5,5);
     (*eCOV)(4,4) = (double)sp2;
   }

◆ SetErrors() [1/2]

void EdbSegP::SetErrors ( )

inline

89 {SetErrors( 1.,1.,0.,.0001,.0001,1.);}

◆ SetErrors() [2/2]

void EdbSegP::SetErrors	(	float	sx2,
		float	sy2,
		float	sz2,
		float	stx2,
		float	sty2,
		float	sp2 = `1.`
	)

 { 
   // setting the diagonal elements of covariance matrix
   SetErrors0();
   (*eCOV)(0,0) = (double)sx2; 
   (*eCOV)(1,1) = (double)sy2; 
   (*eCOV)(2,2) = (double)stx2;
   (*eCOV)(3,3) = (double)sty2;
   (*eCOV)(4,4) = (double)sp2;
   eSZ = sz2;
 }

◆ SetErrors0()

void EdbSegP::SetErrors0 ( )

 { 
   // just init covariance matrix
   if(!eCOV) eCOV = new TMatrixD(5,5);
   else eCOV->Zero();
 }

◆ SetErrorsCOV()

void EdbSegP::SetErrorsCOV	(	float	sx2,
		float	sy2,
		float	sz2,
		float	stx2,
		float	sty2,
		float	sp2 = `1.`
	)

 { 
   // calculation of the non-diagonal covariance matrix considering the input 
   // sigma being in the track plane (Y - is transversal axis)
  
   SetErrors( sx2, sy2, sz2, stx2, sty2, sp2 );
  
   //double Phi = -(TMath::ATan2((double)TY(),(double)TX()));
   double Phi = (TMath::ATan2((double)TY(),(double)TX()));
   TMatrixD t(5,5);
   TMatrixD tt(5,5);
   t(0,0) =  TMath::Cos(Phi);
   t(0,1) = -(TMath::Sin(Phi));
   t(1,0) =  TMath::Sin(Phi);
   t(1,1) =  TMath::Cos(Phi);
   t(2,2) =  TMath::Cos(Phi);
   t(2,3) = -(TMath::Sin(Phi));
   t(3,2) =  TMath::Sin(Phi);
   t(3,3) =  TMath::Cos(Phi);
   t(4,4) =  1.;
   tt(0,0) =  t(0,0);
   tt(1,0) =  t(0,1);
   tt(0,1) =  t(1,0);
   tt(1,1) =  t(1,1);
   tt(2,2) =  t(2,2);
   tt(3,2) =  t(2,3);
   tt(2,3) =  t(3,2);
   tt(3,3) =  t(3,3);
   tt(4,4) =  t(4,4);
   (*eCOV) = t*((*eCOV)*tt);
 }

◆ SetFlag()

void EdbSegP::SetFlag ( int flag )

inline

127 { eFlag=flag; }

◆ SetID()

void EdbSegP::SetID ( int id )

inline

125 { eID=id; }

◆ SetMC()

void EdbSegP::SetMC	(	int	mEvt,
		int	mTrack
	)

inline

138 { eMCEvt=mEvt; eMCTrack=mTrack; }

◆ SetP()

void EdbSegP::SetP ( float p )

inline

130 { eP=p; }

p

Definition: testBGReduction_AllMethods.C:8

◆ SetPID()

void EdbSegP::SetPID ( int pid )

inline

126 { ePID=pid; }

pid

int pid[1000]

Definition: m2track.cpp:13

◆ SetPlate()

void EdbSegP::SetPlate ( int plateid )

inline

139 { eScanID.ePlate = plateid; }

◆ SetProb()

void EdbSegP::SetProb ( float prob )

inline

131 { eProb=prob; }

◆ SetProbability()

void EdbSegP::SetProbability ( float p )

inline

137 { eProb=p; }

◆ SetScanID()

void EdbSegP::SetScanID ( EdbID id )

inline

140 { eScanID = id; }

◆ SetSide()

void EdbSegP::SetSide ( int side = 0 )

inline

136 { int v=eAid[1]%100000; eAid[1]=100000*side+v; }

◆ SetSZ()

void EdbSegP::SetSZ ( float sz )

inline

121 { eSZ=sz; }

◆ SetTrack()

void EdbSegP::SetTrack ( int trid )

inline

128 { eTrack=trid; }

◆ SetTX()

void EdbSegP::SetTX ( Float_t tx )

inline

176 { eTX=tx; }

◆ SetTY()

void EdbSegP::SetTY ( Float_t ty )

inline

177 { eTY=ty; }

◆ SetVid()

void EdbSegP::SetVid	(	int	vid,
		int	sid
	)

inline

134 { eVid[0]=vid; eVid[1]=sid; }

◆ SetVolume()

void EdbSegP::SetVolume ( float w )

inline

133 { eVolume=w; }

◆ SetW()

void EdbSegP::SetW ( float w )

inline

129 { eW=w; }

◆ SetX()

void EdbSegP::SetX ( Float_t x )

inline

174 { eX=x; }

◆ SetY()

void EdbSegP::SetY ( Float_t y )

inline

175 { eY=y; }

◆ SetZ()

void EdbSegP::SetZ ( float z )

inlinevirtual

Reimplemented from EdbPoint2D.

122 { eZ=z; }

◆ Side()

Int_t EdbSegP::Side ( ) const

inline

167 {return eAid[1]/100000;}

◆ SP()

Float_t EdbSegP::SP ( ) const

inline

163 { if(!eCOV) return 0; return (Float_t)(*eCOV)(4,4); }

◆ STX()

Float_t EdbSegP::STX ( ) const

inline

161 { if(!eCOV) return 0; return (Float_t)(*eCOV)(2,2); }

◆ STY()

Float_t EdbSegP::STY ( ) const

inline

162 { if(!eCOV) return 0; return (Float_t)(*eCOV)(3,3); }

◆ SX()

Float_t EdbSegP::SX ( ) const

inline

159 { if(!eCOV) return 0; return (Float_t)(*eCOV)(0,0); }

◆ SY()

Float_t EdbSegP::SY ( ) const

inline

160 { if(!eCOV) return 0; return (Float_t)(*eCOV)(1,1); }

◆ SZ()

Float_t EdbSegP::SZ ( ) const

inline

164 { return eSZ; }

◆ Theta()

Float_t EdbSegP::Theta ( ) const

inline

181 {return TMath::Sqrt(eTY*eTY+eTX*eTX);}

◆ Track()

Int_t EdbSegP::Track ( ) const

inline

147 {return eTrack;}

◆ TX()

Float_t EdbSegP::TX ( ) const

inlinevirtual

Implements EdbAngle2D.

172 {return eTX;}

◆ TY()

Float_t EdbSegP::TY ( ) const

inlinevirtual

Implements EdbAngle2D.

173 {return eTY;}

◆ Vid()

Int_t EdbSegP::Vid ( int i ) const

inline

165 {return (i < 0 || i > 1) ? -1 : eVid[i];}

◆ Volume()

Float_t EdbSegP::Volume ( ) const

inline

155 {return eVolume;}

◆ W()

Float_t EdbSegP::W ( ) const

inline

148 {return eW;}

◆ X()

Float_t EdbSegP::X ( ) const

inlinevirtual

Implements EdbPoint2D.

170 {return eX;}

◆ Y()

Float_t EdbSegP::Y ( ) const

inlinevirtual

Implements EdbPoint2D.

171 {return eY;}

◆ Z()

Float_t EdbSegP::Z ( ) const

inlinevirtual

Reimplemented from EdbPoint2D.

150 {return eZ;}

Member Data Documentation

◆ eAid

Int_t EdbSegP::eAid[2]

private

◆ eChi2

Float_t EdbSegP::eChi2

private

◆ eCOV

TMatrixD* EdbSegP::eCOV

protected

◆ eDZ

Float_t EdbSegP::eDZ

private

◆ eDZem

Float_t EdbSegP::eDZem

private

◆ eEMULDigitArray

TRefArray* EdbSegP::eEMULDigitArray

private

◆ eFlag

Int_t EdbSegP::eFlag

private

◆ eID

Int_t EdbSegP::eID

private

◆ eMCEvt

Int_t EdbSegP::eMCEvt

private

◆ eMCTrack

Int_t EdbSegP::eMCTrack

private

◆ eP

Float_t EdbSegP::eP

private

◆ ePID

Int_t EdbSegP::ePID

private

◆ eProb

Float_t EdbSegP::eProb

private

◆ eScanID

EdbID EdbSegP::eScanID

private

AM+AC 27/07/07.

◆ eSZ

Float_t EdbSegP::eSZ

private

◆ eTrack

Int_t EdbSegP::eTrack

private

◆ eTX

Float_t EdbSegP::eTX

◆ eTY

Float_t EdbSegP::eTY

◆ eVid

Int_t EdbSegP::eVid[2]

private

◆ eVolume

Float_t EdbSegP::eVolume

private

◆ eW

Float_t EdbSegP::eW

private

◆ eX

Float_t EdbSegP::eX

◆ eY

Float_t EdbSegP::eY

◆ eZ

Float_t EdbSegP::eZ

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

src/libEbase/EdbSegP.h
src/libEbase/EdbSegP.cxx

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Attributes

Private Attributes

Constructor & Destructor Documentation

◆ EdbSegP() [1/3]

◆ EdbSegP() [2/3]

◆ EdbSegP() [3/3]

◆ ~EdbSegP()

Member Function Documentation

◆ addEMULDigit()

◆ Aid()

◆ Angle()

◆ CheckCOV()

◆ Chi2()

◆ Clear()

◆ Compare()

◆ Copy()

◆ COV()

◆ DeltaR()

◆ DeltaTheta()

◆ Distance()

◆ DZ()

◆ DZem()

◆ EMULDigitArray()

◆ Flag()

◆ ForceCOV()

◆ ID()

◆ IsCompatible()

◆ IsEqual()

◆ IsInside() [1/2]

◆ IsInside() [2/2]

◆ IsSortable()

◆ LinkMT()

◆ MCEvt()

◆ MCTrack()

◆ MergeTo()

◆ P()

◆ Phi()

◆ PID()

◆ Plate()

◆ Print()

◆ PrintNice()

◆ Prob()

◆ ProbLink()

◆ PropagateTo()

◆ PropagateToCOV()

◆ PropagateToDZ()

◆ ScanID()

◆ Set()

◆ Set0()

◆ SetAid()

◆ SetChi2()

◆ SetCOV() [1/2]

◆ SetCOV() [2/2]

◆ SetDZ()

◆ SetDZem()

◆ SetErrorP()

◆ SetErrors() [1/2]

◆ SetErrors() [2/2]

◆ SetErrors0()

◆ SetErrorsCOV()

◆ SetFlag()

◆ SetID()

◆ SetMC()

◆ SetP()

◆ SetPID()

◆ SetPlate()

◆ SetProb()

◆ SetProbability()

◆ SetScanID()

◆ SetSide()

◆ SetSZ()

◆ SetTrack()

◆ SetTX()

◆ SetTY()

◆ SetVid()

◆ SetVolume()

◆ SetW()