EdbPatCouple Class Reference

#include <EdbPVRec.h>

Inheritance diagram for EdbPatCouple:

Collaboration diagram for EdbPatCouple:

Public Member Functions
EdbSegCouple *	AddSegCouple (int id1, int id2)
int	Align (int alignFlag)
void	CalculateAffXY (int alignFlag)
void	CalculateAffXYZ (float z, int alignFlag)
int	CheckSegmentsDuplication (EdbPattern *pat)
float	Chi2A (EdbSegCouple *scp, int iprob=1)
float	Chi2A (EdbSegP *s1, EdbSegP *s2, int iprob=1)
float	Chi2KF (EdbSegCouple *scp)
int	CHI2mode () const
float	Chi2Pz0 (EdbSegCouple *scp)
void	ClearSegCouples ()
EdbScanCond *	Cond ()
int	CutCHI2P (float chimax)
int	DiffPat (EdbPattern *pat1, EdbPattern *pat2, Long_t vdiff[4])
int	DiffPatCell (TIndexCell *cel1, TIndexCell *cel2, Long_t vdiff[4])
	EdbPatCouple ()
void	FillCell_XYaXaY (EdbPattern *pat, EdbScanCond *cond, float dz, float stepx, float stepy)
void	FillCell_XYaXaY (EdbScanCond *cond, float zlink, int id=0)
int	FillCHI2 ()
int	FillCHI2P ()
int	FindOffset (EdbPattern *pat1, EdbPattern *pat2, Long_t vdiff[4])
int	FindOffset0 (float xmax, float ymax)
int	FindOffset01 (float xmax, float ymax)
int	FindOffset1 (float xmax, float ymax)
EdbAffine2D *	GetAff ()
EdbSegCouple *	GetSegCouple (int i) const
int	ID1 () const
int	ID2 () const
int	LinkFast ()
int	LinkSlow (float chi2max)
int	Ncouples () const
float	OffsetTX () const
float	OffsetTY () const
float	OffsetX () const
float	OffsetY () const
EdbPattern *	Pat1 ()
EdbPattern *	Pat2 ()
void	PrintCouples ()
void	RemoveSegCouple (EdbSegCouple *sc)
int	SelectIsolated ()
void	SetCHI2mode (int m)
void	SetCond (EdbScanCond *cond)
void	SetID (int id1, int id2)
void	SetOffset (float o1, float o2, float o3, float o4)
void	SetOffsetsMax (float ox, float oy)
void	SetPat1 (EdbPattern *pat1)
void	SetPat2 (EdbPattern *pat2)
void	SetSigma (float s1, float s2, float s3, float s4)
void	SetZlink (float z)
float	SigmaTX () const
float	SigmaTY () const
float	SigmaX () const
float	SigmaY () const
int	SortByCHI2P ()
float	Zlink () const
	~EdbPatCouple ()

Private Attributes
EdbAffine2D *	eAff
	affine transformation as: pat2 = pat1->Transform(aff) More...
float	eChi2Max
int	eCHI2mode
	algorithm used for chi2 calculation More...
EdbScanCond *	eCond
int	eCoupleType
	1 - up/down link; 0 - plate-to-plate More...
Int_t	eID [2]
	id-s of patterns in volume More...
Float_t	eOffset [4]
EdbPattern *	ePat1
EdbPattern *	ePat2
TObjArray *	eSegCouples
Float_t	eSigma [4]
	expected pat<->pat sigma after alignment More...
float	eXoffsetMax
float	eYoffsetMax
float	eZlink
	at this z patterns should be linked (aligned) More...

Constructor & Destructor Documentation

EdbPatCouple()

EdbPatCouple::EdbPatCouple

(

)

~EdbPatCouple()

EdbPatCouple::~EdbPatCouple

(

)

---

{
  if(eSegCouples) {
    eSegCouples->Delete();
    SafeDelete(eSegCouples);
  }
}

Member Function Documentation

AddSegCouple()

EdbSegCouple * EdbPatCouple::AddSegCouple	(	int	id1,
		int	id2
	)

---

{
  if(!eSegCouples)   eSegCouples = new TObjArray(1000);
  EdbSegCouple *sc = new EdbSegCouple(id1,id2);
  eSegCouples->Add(sc);
  return sc;
}

Align()

int EdbPatCouple::Align

(

int

alignFlag

)

---

{
  int npat =0;
 
  SetZlink( (Pat1()->Z()+Pat2()->Z())/2. );  // link at central z
 
  Log(2,"/nEdbPatCouple::Align","patterns: %d (%d)  and  %d (%d) at Zlink = %f",
     Pat1()->ID(), Pat1()->N(), Pat2()->ID(),Pat2()->N(), Zlink() );
 
  npat = FindOffset01(eXoffsetMax,eYoffsetMax);   if(npat<2) return npat;
 
  Long_t vdiff[4]={0,0,0,0};
  int nitr=5;
 
  FillCell_XYaXaY(Cond(), Zlink(), 2 );    Pat2()->Cell()->DropCouples(4);
 
  for(int i=0; i<nitr; i++) {
    FillCell_XYaXaY(Cond(), Zlink(), 1 );   Pat1()->Cell()->DropCouples(4);
    npat = DiffPat(Pat1(),Pat2(),vdiff);
 
    CalculateAffXYZ(Zlink(), alignFlag);
 
    Pat1()->Transform(GetAff());
    if( Pat1()->DiffAff(GetAff()) < Cond()->SigmaX(0)/20. ) break;  // stop iterations
  }
 
  vdiff[0]=vdiff[1]=vdiff[2]=vdiff[3]=1;
 
  npat = DiffPat( Pat1(), Pat2(), vdiff );
  FillCHI2P();
  SortByCHI2P();
  CutCHI2P(1.5);
  SelectIsolated();
  npat = Ncouples();                     // the selected couples for the final transformation
  CalculateAffXYZ(Zlink(),alignFlag);
  Pat1()->Transform(GetAff());
  Pat1()->SetNAff(npat);
  EdbAffine2D affA;
  affA.Set( GetAff()->A11(), GetAff()->A12(), GetAff()->A21(), GetAff()->A22(),0,0 );
 
  //psel1->CalculateAXAY(psel2,affA);
  Pat1()->TransformA(&affA);
  GetAff()->Reset();
 
 
  //psel2->CalculateAXAY(psel1,affA);
  //pat2->TransformA(affA);
 
  return npat;
}

CalculateAffXY()

void EdbPatCouple::CalculateAffXY

(

int

alignFlag

)

calculate affine transformation for SELECTED couples at Z in the center

{
  float z = (Pat2()->Z()-Pat1()->Z())/2.;
  CalculateAffXYZ(z,flag);
  Pat1()->Transform(GetAff());
  GetAff()->Reset();
}

CalculateAffXYZ()

void EdbPatCouple::CalculateAffXYZ	(	float	z,
		int	alignFlag
	)

calculate affine transformation for SELECTED couples at given z if flag==0 (default) - permit patterns deformation

{
 
  if(!eAff) eAff = new EdbAffine2D();
  else eAff->Reset();
 
  EdbSegCouple *scp=0;
  EdbSegP *s1, *s2;
  int   ncp=Ncouples();
  
  TArrayF x1(ncp);
  TArrayF y1(ncp);
  TArrayF x2(ncp);
  TArrayF y2(ncp);
 
  Float_t dz1,dz2;
 
  for( int i=0; i<ncp; i++ ) {
    scp=GetSegCouple(i);
    s1 = Pat1()->GetSegment(scp->ID1());
    s2 = Pat2()->GetSegment(scp->ID2());
    dz1 = z - s1->Z();
    dz2 = z - s2->Z();
    x1[i] = s1->X() + dz1*s1->TX();
    y1[i] = s1->Y() + dz1*s1->TY();
    x2[i] = s2->X() + dz2*s2->TX();
    y2[i] = s2->Y() + dz2*s2->TY();
  }
  eAff->Calculate( ncp,x1.fArray,y1.fArray,x2.fArray,y2.fArray, flag);
}

CheckSegmentsDuplication()

int EdbPatCouple::CheckSegmentsDuplication

(

EdbPattern *

pat

)

---

{
  TIndexCell   *cell=pat->Cell();
  int n1 = cell->GetEntries();
  TIndexCell   *c1,*c2,*c3,*c4;
  EdbSegP *s1=0,*s2=0;
  for( int i1=0; i1<n1; i1++) {
    c1 = cell->At(i1);
    int n2 = c1->GetEntries();
    for( int i2=0; i2<n2; i2++) {
      c2 = c1->At(i2);
      int n3 = c2->GetEntries();
      for( int i3=0; i3<n3; i3++) {
    c3 = c2->At(i3);
    int n4 = c3->GetEntries();
    for( int i4=0; i4<n4; i4++) {
      c4 = c3->At(i4);
      int N=c4->N();
      if(N>1) {
        for(int j1=0; j1<N-1; j1++) {
          s1=pat->GetSegment(c4->At(j1)->Value());
          for(int j2=j1+1; j2<N; j2++) {
        s2=pat->GetSegment(c4->At(j2)->Value());
        
        if(gDIFF) gDIFF->Fill( s1->X(),s1->Y(),s1->TX(),s1->TY(),s1->W(),
                       s2->X(),s2->Y(),s2->TX(),s2->TY(),s2->W(),
                       s1->Z(),
                       s1->Aid(0), s1->Aid(1), s2->Aid(0), s2->Aid(1)
                       );
        if( s1->Flag()<0 ) continue;
        if( s2->Flag()<0 ) continue;
        if( s1->Aid(0) == s2->Aid(0)&& s1->Aid(1) == s2->Aid(1) && s1->Side()==s2->Side() ) continue;
        if( TMath::Abs(s2->X()-s1->X()) > 3.) continue;
        if( TMath::Abs(s2->Y()-s1->Y()) > 3.) continue;
        s2->W()>s1->W() ? s1->SetFlag(-1):s2->SetFlag(-1);
          }
        }
      }
    }
      }
    }
  }
  return 0;
}

Chi2A() [1/2]

float EdbPatCouple::Chi2A	(	EdbSegCouple *	scp,
		int	iprob = 1
	)

---

{
  EdbSegP *s1 = Pat1()->GetSegment(scp->ID1());
  EdbSegP *s2 = Pat2()->GetSegment(scp->ID2());
  float chi2 = Chi2A(s1,s2, iprob);
 
  SafeDelete(scp->eS);
  EdbSegP *s = scp->eS=new EdbSegP();
  s->Set( 0,                              // id will be assigned on writing into the tree
      (s1->X()+s2->X())/2.,
      (s1->Y()+s2->Y())/2.,
      (s1->X()-s2->X())/(s1->Z()-s2->Z()),
      (s1->Y()-s2->Y())/(s1->Z()-s2->Z()),
      s1->W()+s2->W(),0
      );
  s->SetZ( (s2->Z()+s1->Z())/2 );
  s->SetChi2( chi2 );
  s->SetDZ( s2->Z()-s1->Z() );
  s->SetVolume( s1->Volume()+s2->Volume() );
  s->SetMC(s1->MCEvt(),s1->MCTrack());
 
  if(s1->EMULDigitArray()) 
    for(int i=0; i<s1->EMULDigitArray()->GetEntries(); i++) s->addEMULDigit(s1->EMULDigitArray()->At(i));
  if(s2->EMULDigitArray()) 
    for(int i=0; i<s2->EMULDigitArray()->GetEntries(); i++) s->addEMULDigit(s2->EMULDigitArray()->At(i));
 
  return chi2;
}

Chi2A() [2/2]

float EdbPatCouple::Chi2A	(	EdbSegP *	s1,
		EdbSegP *	s2,
		int	iprob = 1
	)

---

fast estimation of chi2 in the special case when the position errors of segments are negligible in respect to angular errors: sigmaXY/dz << sigmaTXY application: up/down linking, alignment (offset search)

All calculation are done in the track plane which remove the dependency of the polar angle (phi)

{
 
  TVector3 v1,v2,v;
  v1.SetXYZ( s1->TX(), s1->TY() , -1. );
  v2.SetXYZ( s2->TX(), s2->TY() , -1. );
  v.SetXYZ(  -( s2->X() - s1->X() ),
         -( s2->Y() - s1->Y() ),
         -( s2->Z() - s1->Z() ) );
 
  float phi = v.Phi();
  v.RotateZ(  -phi );
  v1.RotateZ( -phi );
  v2.RotateZ( -phi );
 
  float dz  = v.Z();
  float tx  = v.X()/dz;
  float ty  = v.Y()/dz;
  float stx   = eCond->SigmaTX(tx);
  float sty   = eCond->SigmaTY(ty);
 
  float prob1=1., prob2=1.;
  if(iprob) {
    prob1 = eCond->ProbSeg(tx,ty,s1->W());
    prob2 = eCond->ProbSeg(tx,ty,s2->W());
  }
  float dtx1 = (v1.X()-tx)*(v1.X()-tx)/stx/stx/prob1;
  float dty1 = (v1.Y()-ty)*(v1.Y()-ty)/sty/sty/prob1;
  float dtx2 = (v2.X()-tx)*(v2.X()-tx)/stx/stx/prob2;
  float dty2 = (v2.Y()-ty)*(v2.Y()-ty)/sty/sty/prob2;
 
  float chi2a=TMath::Sqrt(dtx1+dty1+dtx2+dty2)/2.;
  return chi2a;
}

Chi2KF()

float EdbPatCouple::Chi2KF

(

EdbSegCouple *

scp

)

---

exact estimation of chi2 with full fitting procedure Applications: up/down linking, alignment (offset search)

All calculation are done with full corellation matrix for both segments (dependency on the polar angle (phi) is taken into account)

{
 
  EdbSegP *s1 = Pat1()->GetSegment(scp->ID1());
  EdbSegP *s2 = Pat2()->GetSegment(scp->ID2());
  s1->SetErrors();
  s2->SetErrors();
  eCond->FillErrorsCov( s1->TX(), s1->TY(), s1->COV() );
  eCond->FillErrorsCov( s2->TX(), s2->TY(), s2->COV() );
 
  SafeDelete(scp->eS);
  scp->eS=new EdbSegP(*s2);
  float chi2 = EdbTrackFitter::Chi2Seg(scp->eS, s1);
  scp->eS->PropagateToCOV( 0.5*(s1->Z()+s2->Z()) );
 
  if(s1->EMULDigitArray()) 
    for(int i=0; i<s1->EMULDigitArray()->GetEntries(); i++) scp->eS->addEMULDigit(s1->EMULDigitArray()->At(i));
 
  return chi2;
}

CHI2mode()

int EdbPatCouple::CHI2mode ( ) const

inline

{ return eCHI2mode; }

Chi2Pz0()

float EdbPatCouple::Chi2Pz0

(

EdbSegCouple *

scp

)

---

{
  float sx=.5, sy=.5, sz=3., dz=44.;
  float sa;
  float a1,a2;
  float tx,ty;
 
  TVector3 v1,v2,v;
 
  EdbSegP *s1 = Pat1()->GetSegment(scp->ID1());
  EdbSegP *s2 = Pat2()->GetSegment(scp->ID2());
 
  tx = (s1->TX()+s2->TX())/2.;
  ty = (s1->TY()+s2->TY())/2.;
 
  v1.SetXYZ( s1->TX()/sx, s1->TY()/sy , 1./sz );
  v2.SetXYZ( s2->TX()/sx, s2->TY()/sy , 1./sz );
 
  v = v1+v2;
  v *= .5;
 
  a1 = v.Angle(v1);
  a2 = v.Angle(v2);
 
  sa = sz/dz*TMath::Cos(v.Theta());
 
  float chi2 =  TMath::Sqrt( (a1*a1 + a2*a2)/2. ) / 
    eCond->ProbSeg( tx, ty, (s1->W()+s2->W())/2. ) / sa;
 
  SafeDelete(scp->eS);
  EdbSegP *s = scp->eS=new EdbSegP();
  s->Set( 0,                              // id will be assigned on writing into the tree
      (s1->X()+s2->X())/2.,
      (s1->Y()+s2->Y())/2.,
      tx,
      ty,
      s1->W()+s2->W(),0
      );
  s->SetZ( (s2->Z()+s1->Z())/2 );
  s->SetDZ( (s2->DZ()+s1->DZ())/2. );
  s->SetChi2( chi2 );
  s->SetVolume( s1->Volume()+s2->Volume() );
  s->SetMC(s1->MCEvt(),s1->MCTrack());
 
  return chi2;
}

ClearSegCouples()

void EdbPatCouple::ClearSegCouples ( )

inline

{ if(eSegCouples) eSegCouples->Clear(); }

Cond()

EdbScanCond * EdbPatCouple::Cond ( )

inline

{return eCond;}

CutCHI2P()

int EdbPatCouple::CutCHI2P

(

float

chi2max

)

---

{
  TObjArray *sCouples = new TObjArray();
  EdbSegCouple *sc = 0;
  int ncp = Ncouples();
 
  if(gEDBDEBUGLEVEL>1) printf("CutCHI2P (%4.1f):  %d -> ", chi2max,ncp );
 
  for( int i=ncp-1; i>=0; i-- ) {
    sc = GetSegCouple(i);
    if(sc->CHI2P()<=chi2max)      sCouples->Add(sc);
    else SafeDelete(sc);
  }
  SafeDelete(eSegCouples);
  eSegCouples=sCouples;
  if(gEDBDEBUGLEVEL>1) printf("%d\n", Ncouples() );
  return Ncouples();
}

DiffPat()

int EdbPatCouple::DiffPat	(	EdbPattern *	pat1,
		EdbPattern *	pat2,
		Long_t	vdiff[4]
	)

{
  if(!pat1) return 0;
  if(!pat2) return 0;
  TIndexCell   *c1=pat1->Cell();
  TIndexCell   *c2=pat2->Cell();
  int ncouples = 0; 
 
  ncouples = DiffPatCell(c1,c2,vdiff);
 
  return ncouples;
}

DiffPatCell()

int EdbPatCouple::DiffPatCell	(	TIndexCell *	cel1,
		TIndexCell *	cel2,
		Long_t	vdiff[4]
	)

Input: 2 cells as "x:y:ax:ay:entry" where entry is local id vdiff - vector of differences

Output: 1 patterns as: "entry1:entry2"

Action: all entries from both patterns satisfied to current vdiff for each cell are selected. Entries could be taken more than once

tTODO: move this algorithm to TIndexCell (n-dim)

{
 
 
  int ncouples = 0;
  int npat = 0;
  ClearSegCouples();
 
  TIndexCell   *c1[4],*c2[4];
 
  Long_t v[2]={0,0};
  Long_t val0[6]={0,0,0,0,0,0};
  Long_t val[5]={0,0,0,0,0};
  int    vind[5]={-1,-1,-1,-1,-1};
  
  //EdbSegP *s1,*s2;
 
  int ncel1, nc10, nc11, nc12, nc13, nc23; 
 
  ncel1 = cel1->GetEntries();
  for( vind[0]=0; vind[0]<ncel1; vind[0]++) {                              //x1
    c1[0] = cel1->At(vind[0]);
    val0[0] = c1[0]->Value();
    for( val[0] = val0[0]-vdiff[0]; val[0]<=val0[0]+vdiff[0]; val[0]++ ) {              //x2
      c2[0] = cel2->Find(val[0]);
      if(!c2[0])                      continue;
 
      nc10 = c1[0]->GetEntries();
      for( vind[1]=0; vind[1]<nc10; vind[1]++) {                         //y1
    c1[1] = c1[0]->At(vind[1]);
    val0[1] = c1[1]->Value();
    for( val[1] = val0[1]-vdiff[1]; val[1]<=val0[1]+vdiff[1]; val[1]++ ) {          //y2
      c2[1] = c2[0]->Find(val[1]);
      if(!c2[1])                 continue;
 
      nc11 = c1[1]->GetEntries();
      for( vind[2]=0; vind[2]<nc11; vind[2]++) {                     //ax1
        c1[2] = c1[1]->At(vind[2]);
        val0[2] = c1[2]->Value();
        for( val[2] = val0[2]-vdiff[2]; val[2]<=val0[2]+vdiff[2]; val[2]++ ) {      //ax2
          c2[2] = c2[1]->Find(val[2]);
          if(!c2[2])                      continue;
          
          nc12 = c1[2]->GetEntries();
          for( vind[3]=0; vind[3]<nc12; vind[3]++) {                 //ay1
        c1[3] = c1[2]->At(vind[3]);
        val0[3] = c1[3]->Value();
        for( val[3] = val0[3]-vdiff[3]; val[3]<=val0[3]+vdiff[3]; val[3]++ ) {  //ay2
          c2[3] = c2[2]->Find(val[3]);
          if(!c2[3])                 continue;
 
          npat++;
 
          nc13 = c1[3]->GetEntries();
          for(int ie1=0; ie1<nc13; ie1++) {
            nc23 = c2[3]->GetEntries();
            for(int ie2=0; ie2<nc23; ie2++) {
 
              ncouples++;
 
              v[0] = c1[3]->At(ie1)->Value();
              v[1] = c2[3]->At(ie2)->Value();
 
//                s1 = Pat1()->GetSegment(v[0]);
//                s2 = Pat2()->GetSegment(v[1]);
//                if(IsCompatible(s1,s2,eCond)        //TODO
 
              AddSegCouple((int)v[0],(int)v[1]);
 
            }
          }
 
        }
          }
        }
      }
    }
      }
    }
  }
 
  return npat;
}

FillCell_XYaXaY() [1/2]

void EdbPatCouple::FillCell_XYaXaY	(	EdbPattern *	pat,
		EdbScanCond *	cond,
		float	dz,
		float	stepx,
		float	stepy
	)

fill cells according to Sigma(angle) functions here cells size do not depends on dz!

{
 
  TIndexCell *cell = pat->Cell();
  if(cell) cell->Drop();
  pat->SetStep(stepx,stepy,0,0);
 
  float x,y,tx,ty;
  Long_t  val[5];  // x,y,ax,ay,i
  EdbSegP *p;
  int npat = pat->N();
  Log(3,"EdbPatCouple::FillCell_XYaXaY","npat = %d",npat);
  for(int i=0; i<npat; i++ ) {
    p = pat->GetSegment(i);
    if( p->Track() >-1 )      continue;       //to check side effects!!!
    tx = p->TX();
    ty = p->TY();
    x  = p->X() + tx*dz;
    y  = p->Y() + ty*dz;
    val[0]= (Long_t)(x / stepx  );
    val[1]= (Long_t)(y / stepy  );
    val[2]= (Long_t)(tx/ cond->StepTX(tx) );
    val[3]= (Long_t)(ty/ cond->StepTY(ty) );
    val[4]= (Long_t)(i);
    cell->Add(5,val);
  }
  cell->Sort();
  //cell->PrintStat();
  //cell->SetName("x:y:tx:ty:entry");
}

FillCell_XYaXaY() [2/2]

void EdbPatCouple::FillCell_XYaXaY	(	EdbScanCond *	cond,
		float	zlink,
		int	id = 0
	)

fill cells according to Sigma(angle) functions at z=zlink

{
 
  float dz1 = zlink - Pat1()->Z();
  float dz2 = zlink - Pat2()->Z();
  float dz  = TMath::Max( TMath::Abs(dz1), TMath::Abs(dz2) );
  float stepx = cond->StepX(dz);
  float stepy = cond->StepY(dz);
 
  if(id==0||id==1) FillCell_XYaXaY( Pat1(), cond, dz1, stepx, stepy );
  if(id==0||id==2) FillCell_XYaXaY( Pat2(), cond, dz2, stepx, stepy );
}

FillCHI2()

int EdbPatCouple::FillCHI2

(

)

---

final chi2 calculation based on the linked track

{
 
  EdbSegCouple *scp=0;
  float       chi2;
  int ncp = Ncouples();
  for( int i=0; i<ncp; i++ ) {
    scp=GetSegCouple(i);
    chi2 = Chi2A(scp,0);
    scp->SetCHI2(chi2);
  }
  return Ncouples();
}

FillCHI2P()

int EdbPatCouple::FillCHI2P

(

)

---

fast chi2 calculation used for couples selection

{
 
  EdbSegCouple *scp=0;
  float       chi2;
  int ncp = Ncouples();
 
  Log(3,"EdbPatCouple::FillCHI2P","eCHI2mode = %d\n",eCHI2mode);
  for( int i=0; i<ncp; i++ ) {
    scp=GetSegCouple(i);
 
    if(eCHI2mode==2) chi2 = Chi2Pz0(scp);
    else if(eCHI2mode==3) chi2 = Chi2KF(scp);
    else                  chi2 = Chi2A(scp);
 
    scp->SetCHI2P(chi2);
  }
  return Ncouples();
}

FindOffset()

int EdbPatCouple::FindOffset	(	EdbPattern *	pat1,
		EdbPattern *	pat2,
		Long_t	vdiff[4]
	)

{
  float dz=pat2->Z()-pat1->Z();
 
  float  voff[2]={0,0};
  float stepx = Cond()->StepX(dz/2);
  float stepy = Cond()->StepY(dz/2);
  int      nx = (int)( eXoffsetMax/stepx );
  int      ny = (int)( eYoffsetMax/stepy );
 
  if(nx==0&&ny==0) return 2;
  Log(2,"EdbPatCouple::FindOffset","( %d x %d ) with steps %8.3f %8.3f \t%f %f",
     2*nx+1,2*ny+1,stepx,stepy,Cond()->StepTX(0),Cond()->StepTY(0) );
 
  FillCell_XYaXaY(pat1,Cond(),dz/2.,stepx,stepy);
  Log(3,"EdbPatCouple::FindOffset"," drop couples: %d",pat1->Cell()->DropCouples(4) );
  FillCell_XYaXaY(pat2,Cond(),-dz/2.,stepx,stepy);
  Log(3,"EdbPatCouple::FindOffset"," drop couples: %d",pat2->Cell()->DropCouples(4) );
 
  Long_t vshift[4] = {0,0,0,0};
  TIndexCell *c1=pat1->Cell();
  TIndexCell *c2=pat2->Cell();
 
  int npat0 = 0;
  int npat  = 0;
 
  for(int iy=-ny; iy<=ny; iy++ ) {
    for(int ix=-nx; ix<=nx; ix++ ) {
      vshift[0] = ix;
      vshift[1] = iy;
      c1->Shift(2,vshift);
 
      npat = c1->ComparePatterns(4,vdiff,c2);
      if(gEDBDEBUGLEVEL>1) printf("%5d",npat);
 
      if(npat>npat0) {
    npat0 = npat;
    voff[0] = ix*stepx;
    voff[1] = iy*stepy;
      }
 
      vshift[0] = -ix;
      vshift[1] = -iy;
      c1->Shift(2,vshift);
    }
    if(gEDBDEBUGLEVEL>1) printf("\n");
  }
 
  Log(2,"EdbPatCouple::FindOffset","Offset: %f %f   npat = %d", voff[0], voff[1], npat0 );
 
  EdbAffine2D aff;
  aff.ShiftX(voff[0]);
  aff.ShiftY(voff[1]);
  pat1->Transform(&aff);
 
  return npat0;
}

FindOffset0()

int EdbPatCouple::FindOffset0	(	float	xmax,
		float	ymax
	)

{
  Long_t vdiff[4]={0,0,0,0};
  SetOffsetsMax(xmax,ymax);
  return FindOffset( Pat1(),Pat2(),vdiff);
}

FindOffset01()

int EdbPatCouple::FindOffset01	(	float	xmax,
		float	ymax
	)

{
  Long_t vdiff[4]={0,0,1,1};
  SetOffsetsMax(xmax,ymax);
  return FindOffset( Pat1(),Pat2(),vdiff);
}

FindOffset1()

int EdbPatCouple::FindOffset1	(	float	xmax,
		float	ymax
	)

{
  Long_t vdiff[4]={1,1,1,1};
  SetOffsetsMax(xmax,ymax);
  return FindOffset( Pat1(),Pat2(),vdiff);
}

GetAff()

EdbAffine2D * EdbPatCouple::GetAff ( )

inline

{return eAff;}

GetSegCouple()

EdbSegCouple * EdbPatCouple::GetSegCouple ( int  i ) const

inline

    { return (EdbSegCouple *)(eSegCouples->At(i)); }

ID1()

int EdbPatCouple::ID1 ( ) const

inline

{ return eID[0]; }

ID2()

int EdbPatCouple::ID2 ( ) const

inline

{ return eID[1]; }

LinkFast()

int EdbPatCouple::LinkFast

(

)

---

to link segments of already aligned patterns fast - because check couples by cells

{
 
  if(Pat1()->N()<1) return 0;
  if(Pat2()->N()<1) return 0;
  int npat =0;
  SetZlink( (Pat2()->Z()+Pat1()->Z())/2. );
 
  Log(2,"EdbPatCouple::LinkFast"," %3d (%7d)  and  %3d (%7d) at Z = %13.3f",
       Pat1()->ID(), Pat1()->N(), Pat2()->ID(),Pat2()->N(), Zlink() );
 
  FillCell_XYaXaY(Cond(), Zlink() );
  Log(3,"EdbPatCouple::LinkFast","1");
 
  //CheckSegmentsDuplication(Pat1());
  //CheckSegmentsDuplication(Pat2());
 
  Long_t vdiff[4]={1,1,1,1};
 
  npat = DiffPat( Pat1(), Pat2(), vdiff );
  Log(3,"EdbPatCouple::LinkFast","2");
 
  FillCHI2P();
  Log(3,"EdbPatCouple::LinkFast","End of linking: %3d (%7d)  and  %3d (%7d) at Z = %13.3f  npat= %d",
      Pat1()->ID(), Pat1()->N(), Pat2()->ID(),Pat2()->N(), Zlink(),npat );
 
  return npat;
}

LinkSlow()

int EdbPatCouple::LinkSlow

(

float

chi2max

)

---

to link segments of already aligned patterns slow - because check all couples

{
 
  int npat =0;
  EdbPattern const *pat1=Pat1();   if(!pat1) return npat;
  EdbPattern const *pat2=Pat2();   if(!pat2) return npat;
 
  ClearSegCouples();
 
  Log(2,"EdbPatCouple::LinkSlow","patterns: %d (%d)  and  %d (%d) \n",
       pat1->ID(), pat1->N(), pat2->ID(),pat2->N());
 
  EdbSegCouple   *c;
  float chi2;
 
  int n1,n2;
  n1 = pat1->N();
  for( int i1=0; i1<n1; i1++ ) {
    n2 = pat2->N();
    for( int i2=0; i2<n2; i2++ ) {
      chi2 = Chi2A( pat1->GetSegment(i1), pat2->GetSegment(i2) );
      if( chi2 > chi2max )        continue;
      c=AddSegCouple(i1,i2);
      c->SetCHI2P(chi2);
      npat++;
    }
  }
  return npat;
}

Ncouples()

int EdbPatCouple::Ncouples ( ) const

inline

                           { if(eSegCouples) return eSegCouples->GetEntriesFast(); 
                             else return 0; }

OffsetTX()

float EdbPatCouple::OffsetTX ( ) const

inline

{ return eOffset[2]; }

OffsetTY()

float EdbPatCouple::OffsetTY ( ) const

inline

{ return eOffset[3]; }

OffsetX()

float EdbPatCouple::OffsetX ( ) const

inline

{ return eOffset[0]; }

OffsetY()

float EdbPatCouple::OffsetY ( ) const

inline

{ return eOffset[1]; }

Pat1()

EdbPattern * EdbPatCouple::Pat1 ( )

inline

{ return ePat1; }

Pat2()

EdbPattern * EdbPatCouple::Pat2 ( )

inline

{ return ePat2; }

PrintCouples()

void EdbPatCouple::PrintCouples

(

)

---

{
  EdbSegCouple *sc=0;
  int ncp = Ncouples();
  for(int i=0; i<ncp; i++) {
    sc = GetSegCouple(i);
    sc->Print();
  }
}

RemoveSegCouple()

void EdbPatCouple::RemoveSegCouple ( EdbSegCouple *  sc )

inline

{ SafeDelete(sc); }

SelectIsolated()

int EdbPatCouple::SelectIsolated

(

)

---

{
  TObjArray *sCouples = new TObjArray();
  EdbSegCouple *sc = 0;
  int ncp = Ncouples();
  if(gEDBDEBUGLEVEL>1) printf("SelectIsolated:  %d -> ", ncp );
 
  for( int i=ncp-1; i>=0; i-- ) {
    sc = GetSegCouple(i);
    if( sc->N1tot()>1 || sc->N2tot()>1 ) {SafeDelete(sc);}
    else sCouples->Add(sc);
  }
  SafeDelete(eSegCouples);
  eSegCouples=sCouples;
  if(gEDBDEBUGLEVEL>1) printf(" %d \n", Ncouples() );
  return Ncouples();
}

SetCHI2mode()

void EdbPatCouple::SetCHI2mode ( int  m )

inline

{ eCHI2mode=m; }

SetCond()

void EdbPatCouple::SetCond ( EdbScanCond *  cond )

inline

{ eCond=cond; }

SetID()

void EdbPatCouple::SetID ( int  id1, int  id2  )

inline

{ eID[0]=id1; eID[1]=id2; }

SetOffset()

void EdbPatCouple::SetOffset ( float  o1, float  o2, float  o3, float  o4  )

inline

    { eOffset[0]=o1; eOffset[1]=o2; eOffset[2]=o3; eOffset[3]=o4;  }

SetOffsetsMax()

void EdbPatCouple::SetOffsetsMax ( float  ox, float  oy  )

inline

    { eXoffsetMax=ox; eYoffsetMax=oy; }

SetPat1()

void EdbPatCouple::SetPat1 ( EdbPattern *  pat1 )

inline

{ ePat1=pat1; }

SetPat2()

void EdbPatCouple::SetPat2 ( EdbPattern *  pat2 )

inline

{ ePat2=pat2; }

SetSigma()

void EdbPatCouple::SetSigma ( float  s1, float  s2, float  s3, float  s4  )

inline

    { eSigma[0]=s1; eSigma[1]=s2; eSigma[2]=s3; eSigma[3]=s4; }

SetZlink()

void EdbPatCouple::SetZlink ( float  z )

inline

{eZlink=z;}

SigmaTX()

float EdbPatCouple::SigmaTX ( ) const

inline

{ return eSigma[2]; }

SigmaTY()

float EdbPatCouple::SigmaTY ( ) const

inline

{ return eSigma[3]; }

SigmaX()

float EdbPatCouple::SigmaX ( ) const

inline

{ return eSigma[0]; }

SigmaY()

float EdbPatCouple::SigmaY ( ) const

inline

{ return eSigma[1]; }

SortByCHI2P()

int EdbPatCouple::SortByCHI2P

(

)

---

{
  int   npat=0;
 
  EdbSegCouple::SetSortFlag(0);    // sort by CHI2P
  eSegCouples->UnSort();
  eSegCouples->Sort();
 
  int np1 = ePat1->N();
  int np2 = ePat2->N();
  TArrayI found1(np1);
  TArrayI found2(np2);
  int i;
  for(i=0; i<np1; i++) found1[i]=0;
  for(i=0; i<np2; i++) found2[i]=0;
 
  EdbSegCouple *sc = 0;
 
  int ncp = Ncouples();
  for( i=0; i<ncp; i++ ) {
    sc = GetSegCouple(i);
    found1[sc->ID1()]++;
    found2[sc->ID2()]++;
    sc->SetN1( found1[sc->ID1()] );
    sc->SetN2( found2[sc->ID2()] );
    npat++;
  }
 
  ncp = Ncouples();
  for( i=0; i<ncp; i++ ) {
    sc = GetSegCouple(i);
    sc->SetN1tot( found1[sc->ID1()] );
    sc->SetN2tot( found2[sc->ID2()] );
  }
 
  EdbSegCouple::SetSortFlag(1);      // sort by (numbers + CHI2P)
  eSegCouples->UnSort();
  eSegCouples->Sort();
 
  return npat;
}

Zlink()

float EdbPatCouple::Zlink ( ) const

inline

{return eZlink;}

Member Data Documentation

eAff

EdbAffine2D* EdbPatCouple::eAff

private

affine transformation as: pat2 = pat1->Transform(aff)

eChi2Max

float EdbPatCouple::eChi2Max

private

eCHI2mode

int EdbPatCouple::eCHI2mode

private

algorithm used for chi2 calculation

eCond

EdbScanCond* EdbPatCouple::eCond

private

eCoupleType

int EdbPatCouple::eCoupleType

private

1 - up/down link; 0 - plate-to-plate

eID

Int_t EdbPatCouple::eID[2]

private

id-s of patterns in volume

eOffset

Float_t EdbPatCouple::eOffset[4]

private

maximal allowed offset before alignment "x:y:tx:ty"

ePat1

EdbPattern* EdbPatCouple::ePat1

private

ePat2

EdbPattern* EdbPatCouple::ePat2

private

eSegCouples

TObjArray* EdbPatCouple::eSegCouples

private

eSigma

Float_t EdbPatCouple::eSigma[4]

private

expected pat<->pat sigma after alignment

eXoffsetMax

float EdbPatCouple::eXoffsetMax

private

eYoffsetMax

float EdbPatCouple::eYoffsetMax

private

eZlink

float EdbPatCouple::eZlink

private

at this z patterns should be linked (aligned)

---

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

• /home/antonio/fedra_doxygen/src/libEdr/EdbPVRec.h
• /home/antonio/fedra_doxygen/src/libEdr/EdbPVRec.cxx