EdbAlignmentV Class Reference

universal basic alignment class More...

#include <EdbAlignmentV.h>

Inheritance diagram for EdbAlignmentV:

Collaboration diagram for EdbAlignmentV:

Public Member Functions
void	AddSegCouple (EdbSegP *s1, EdbSegP *s2)
void	ApplyLimitsOffset (float &xmin1, float &xmax1, float &xmin2, float &xmax2, float offsetMax)
Int_t	CalcAffFull ()
Int_t	CalcApplyFractMeanDiff ()
Int_t	CalcApplyMeanDiff ()
Float_t	CalcFractMeanDiff (int ivar, float fraction)
Float_t	CalcMeanDiff (int ivar)
Float_t	CalcMeanDZ (float tmin=0.1, float tmax=2.)
Float_t	CalcMeanShr (float tmin=0.1, float tmax=2.)
Int_t	CalculateAffTXTY (EdbAffine2D &aff)
Int_t	CalculateAffTXTY (TObjArray &arr1, TObjArray &arr2, EdbAffine2D &aff)
Int_t	CalculateAffTXTYTurn (TObjArray &arr1, TObjArray &arr2, EdbAffine2D &aff)
Int_t	CalculateAffXY (EdbAffine2D &aff)
Int_t	CalculateAffXY (TObjArray &arr1, TObjArray &arr2, EdbAffine2D &aff)
Int_t	CalculateAffXYTurn (EdbAffine2D &aff)
Int_t	CalculateAffXYTurn (TObjArray &arr1, TObjArray &arr2, EdbAffine2D &aff)
void	CloseOutputFile ()
void	Corr2Aff (EdbLayer &layer)
void	Corr2Aff (EdbSegCorr &corr, EdbLayer &layer)
void	CorrToCoG (int side, EdbPattern &p)
	functions alpplied to the individual patterns More...
void	CorrToCoG (int side, TObjArray &p)
float	CoupleQuality (EdbSegP &s1, EdbSegP &s2)
void	DefineGuessCell (float xmin1, float xmax1, float ymin1, float ymax1, float xmin2, float xmax2, float ymin2, float ymax2, int np1, int np2, float binOK)
	Selector functions. More...
int	DoubletsFilterOut (int checkview, TH2F *hxy=0, TH2F *htxty=0)
	EdbAlignmentV ()
void	FillCell (int side, EdbPattern &pat)
void	FillCell (int side, TObjArray &pat)
int	FillCombinations ()
int	FillCombinations (float dv[4], float dxMax, float dyMax, bool doFill)
void	FillGuessCell (EdbPattern &p1, EdbPattern &p2, float binOK=1., float offsetMax=2000.)
void	FillGuessCell (TObjArray &p1, TObjArray &p2, float binOK=1., float offsetMax=2000.)
void	FillThetaHist (int side, EdbH2 &htxy)
Int_t	FindCorrDiff (float dvsame[4], int side=0, int nlim=10)
Float_t	FindDensityPeak (TArrayF &arr, float fraction)
Int_t	FindDiff (TObjArray &arr1, TObjArray &arr2, float dvlim[4], float dvfound[4])
float	FineCorrPhi (TObjArray &sel1, TObjArray &sel2)
float	FineCorrZ ()
float	FineCorrZ (TObjArray &sel1, TObjArray &sel2)
void	HDistance (EdbPattern &p1, EdbPattern &p2, float dxMax, float dyMax)
void	InitHphi (int n, float min, float max)
void	InitHshr0 (int n, float min, float max)
void	InitHshr1 (int n, float min, float max)
void	InitHx (int n, float min, float max)
void	InitHy (int n, float min, float max)
void	InitHz (int n, float min, float max)
void	InitOutputFile (const char *file="report_al.root", const char *option="RECREATE")
	IO, initialization and finalization functions. More...
void	InitPatCellBin (int side, EdbPattern &pat, float binx, float biny)
void	InitPatCellN (EdbCell2 &cell, EdbPattern &pat, int nx, int ny)
Bool_t	IsInsideDVsame (EdbSegP &s1, EdbSegP &s2)
Int_t	Ncoins (float dvlim[4], EdbH2 *hdxy=0, EdbH2 *hdtxty=0, TObjArray *sel1=0, TObjArray *sel2=0)
Int_t	Ncp ()
	Functions applied to the selected parallel arrays. More...
int	OptimiseVar1 (int side, int ivar, EdbH2 *hdxy=0, EdbH2 *hdtxy=0)
void	OptimiseVar2 (int side1, int ivar1, int side2, int ivar2, EdbH2 &h12, EdbH2 *hdxy=0, EdbH2 *hdtxty=0)
int	SelectBestCouple ()
int	SelectIsolated ()
Bool_t	SideOK (int side)
char *	StrDVsame () const
float	TX (int side, EdbSegP &s)
float	TY (int side, EdbSegP &s)
Bool_t	ValidCoinsidence (EdbSegP &s1, EdbSegP &s2, float dvlim[4], float dvfound[4])
float	Var (int side, EdbSegP &s, int ivar)
float	Var (int side, int iseg, int ivar)
float	X (int side, EdbSegP &s)
	Correction parameters handling. More...
float	Xmax (int side, EdbPattern &p)
float	Xmax (int side, TObjArray &p)
float	Xmin (int side, EdbPattern &p)
float	Xmin (int side, TObjArray &p)
float	Y (int side, EdbSegP &s)
float	Ymax (int side, EdbPattern &p)
float	Ymax (int side, TObjArray &p)
float	Ymin (int side, EdbPattern &p)
float	Ymin (int side, TObjArray &p)
virtual	~EdbAlignmentV ()

Static Public Member Functions
static Int_t	CheckEqualArr (TObjArray &arr1, TObjArray &arr2)

Public Attributes
EdbSegCorr	eCorr [2]
	corrections for side 1 and 2 (v[7]) - the result of the alignment More...
EdbLayer	eCorrL [2]
	corrections in form of affine transformations - the final output More...
TH1I *	eDoubletsRate
	can be filled in FillCombinations() More...
Float_t	eDVsame [4]
	(dx,dy,dtx,dty) condition for the coinsidence More...
EdbH1	eH [2][7]
EdbH2	eHxy
	position 2d histo to be used in OptimiseVar2 More...
TFile *	eOutputFile
EdbCell2	ePC [2]
	2-d position cells with patterns segments More...
TObjArray	eS [2]
	"parallel" arrays with the selected combinations of segments More...
Bool_t	eUseAffCorr
	if "true" - use eCorrL for corrections More...
Float_t	eXmarg
Float_t	eYmarg
	margins for the cell definition More...

Detailed Description

universal basic alignment class

Constructor & Destructor Documentation

EdbAlignmentV()

EdbAlignmentV::EdbAlignmentV

(

)

margins for the cell definition

by default use eCorr (separated corrections)

{
  eXmarg = eYmarg = 0.0001;        
  eDoubletsRate=0;
  eUseAffCorr = false;   
  eOutputFile=0;
}

~EdbAlignmentV()

EdbAlignmentV::~EdbAlignmentV ( )

virtual

{
  eS[0].Clear();
  eS[1].Clear();
  SafeDelete(eDoubletsRate);
}

Member Function Documentation

AddSegCouple()

void EdbAlignmentV::AddSegCouple ( EdbSegP *  s1, EdbSegP *  s2  )

inline

{ eS[0].Add(s1); eS[1].Add(s2); }

ApplyLimitsOffset()

void EdbAlignmentV::ApplyLimitsOffset	(	float &	xmin1,
		float &	xmax1,
		float &	xmin2,
		float &	xmax2,
		float	offsetMax
	)

{
  if(Abs(xmin2-xmin1)>offsetMax)                                                // cut useless patterns margins
    if(xmin2>xmin1) xmin1=xmin2-offsetMax; 
    else  xmin2=xmin1-offsetMax;
  if(Abs(xmax2-xmax1)>offsetMax) 
    if(xmax2>xmax1) xmax2=xmax1+offsetMax; 
    else  xmax1=xmax2+offsetMax;
}

CalcAffFull()

Int_t EdbAlignmentV::CalcAffFull

(

)

{
  eUseAffCorr=true;
  eCorrL[0].SetZcorr( FineCorrZ( eS[0], eS[1] ) );
  EdbAffine2D aff1to2XY;
  CalculateAffXY( eS[0], eS[1], aff1to2XY);
  eCorrL[0].GetAffineXY()->Transform(&aff1to2XY);
  EdbAffine2D aff2to1TXTY;
  CalculateAffTXTY( eS[1], eS[0], aff2to1TXTY);
  eCorrL[1].GetAffineTXTY()->Transform(&aff2to1TXTY);
}

CalcApplyFractMeanDiff()

Int_t EdbAlignmentV::CalcApplyFractMeanDiff

(

)

by default apply it to side 0

{
  int side=0;
  int n = CheckEqualArr(eS[0],eS[1]);
 
//  if(n<nlim) return 0;           //TODO
  
  eCorr[side].AddV( 3, CalcFractMeanDiff( 2, 0.4 ) );                    // calc and  apply angles
  eCorr[side].AddV( 4, CalcFractMeanDiff( 3, 0.4 ) );
  
  //eCorr[side].SetV( 2, CalcMeanDZ()  );                      // calc and apply DZ
  
  //eCorr[side].SetV( 5, eCorr[side].V(5) * CalcMeanShr() );   // calc and apply shrinkage
  
  
  eCorr[side].AddV( 0, CalcFractMeanDiff( 0, 0.4 ) );                    // then apply coord
  eCorr[side].AddV( 1, CalcFractMeanDiff( 1, 0.4 ) );
  
  return n;
}

CalcApplyMeanDiff()

Int_t EdbAlignmentV::CalcApplyMeanDiff

(

)

by default apply it to side 0

{
  int side=0;
  int n = CheckEqualArr(eS[0],eS[1]);
 
//  if(n<nlim) return 0;           //TODO
  
  eCorr[side].AddV( 3, CalcMeanDiff(2) );                    // then apply angles
  eCorr[side].AddV( 4, CalcMeanDiff(3) );
  
  eCorr[side].SetV( 2, CalcMeanDZ()  );                      // at first calc and apply DZ
  
  eCorr[side].SetV( 5, eCorr[side].V(5) * CalcMeanShr() );   // second calc and apply shrinkage
  
  
  eCorr[side].AddV( 0, CalcMeanDiff(0) );                    // then apply coord
  eCorr[side].AddV( 1, CalcMeanDiff(1) );
  
  return n;
}

CalcFractMeanDiff()

Float_t EdbAlignmentV::CalcFractMeanDiff	(	int	ivar,
		float	fraction
	)

Calculate mean difference for the highest density region

{
  int n = CheckEqualArr(eS[0],eS[1]);
  TArrayF arr(n);
  for(int i=0; i<n; i++) {
    arr[i] = ( Var( 1, i, ivar ) - Var( 0, i, ivar) );
  }
  return FindDensityPeak( arr, fraction);
}

CalcMeanDiff()

Float_t EdbAlignmentV::CalcMeanDiff

(

int

ivar

)

Calculate mean difference for the given variable taking into account corrections

{
  int n = CheckEqualArr(eS[0],eS[1]);
  int ic=0;
  Double_t sd=0;
  for(int i=0; i<n; i++) {
    sd   += ( Var( 1, i, ivar ) - Var( 0, i, ivar) );
    ic++;
  }
  sd /= ic;
  return sd;
}

CalcMeanDZ()

Float_t EdbAlignmentV::CalcMeanDZ	(	float	tmin = 0.1,
		float	tmax = 2.
	)

Calculate mean shrinkage (to be applied to side 0 to get side 1)

{
  int n = CheckEqualArr(eS[0],eS[1]);
  int ic=0;
  float dz = eCorr[0].V(2); if(Abs(dz)<0.000001) return 0;
  eCorr[0].SetV(2,0.);
  Double_t dzn=0;
  for(int i=0; i<n; i++) {
    EdbSegP *s1=(EdbSegP*)eS[0].UncheckedAt(i);
    float t1  = eCorr[0].T(*s1);
    if(t1<tmin)   continue;
    if(t1>tmax)   continue;
    EdbSegP *s2=(EdbSegP*)eS[1].UncheckedAt(i);
    float tx = ( X(1,*s2) - X(0,*s1) ) / dz;
    float ty = ( Y(1,*s2) - Y(0,*s1) ) / dz;
    float t = TMath::Sqrt(tx*tx+ty*ty);
    dzn += dz*t/t1;
    ic++;
  }
  dzn /= ic;
  eCorr[0].SetV(2,dz);
  Log(3,"CalcMeanDZ","dz = %f dzn = %f n=%d",dz,dzn,ic);
  return dzn;
}

CalcMeanShr()

Float_t EdbAlignmentV::CalcMeanShr	(	float	tmin = 0.1,
		float	tmax = 2.
	)

Calculate mean shrinkage (to be applied to side 0 to get side 1)

{
  int n = CheckEqualArr(eS[0],eS[1]);
  int ic=0;
  Double_t shr=0;
  for(int i=0; i<n; i++) {
    float t1  = eCorr[0].T(*((EdbSegP*)eS[0].UncheckedAt(i)));
    //float t1  = ((EdbSegP*)eS[0].UncheckedAt(i))->Theta();
    if(t1<tmin)   continue;
    if(t1>tmax)   continue;
    float t2  = eCorr[1].T(*((EdbSegP*)eS[1].UncheckedAt(i)));
    //float t2  = ((EdbSegP*)eS[1].UncheckedAt(i))->Theta();
    shr   += (t1/t2);                // the angle is divided by shr - that's why it is inverse
    ic++;
  }
  shr /= ic;
  return shr;
}

CalculateAffTXTY() [1/2]

Int_t EdbAlignmentV::CalculateAffTXTY ( EdbAffine2D &  aff )

inline

{return CalculateAffTXTY( eS[0], eS[1], aff);}

CalculateAffTXTY() [2/2]

Int_t EdbAlignmentV::CalculateAffTXTY	(	TObjArray &	arr1,
		TObjArray &	arr2,
		EdbAffine2D &	aff
	)

{
  int n = CheckEqualArr(arr1,arr2);
  TArrayF x1(n), x2(n), y1(n), y2(n);
  for(int i=0; i<n; i++ ) {
    EdbSegP *s1 = (EdbSegP*)arr1.UncheckedAt(i);
    EdbSegP *s2 = (EdbSegP*)arr2.UncheckedAt(i);
    x1[i] = TX(0, *s1);    y1[i] = TY(0, *s1);
    x2[i] = TX(1, *s2);    y2[i] = TY(1, *s2);
  }
  aff.Calculate(n,x1.GetArray(),y1.GetArray(),x2.GetArray(),y2.GetArray(),0);
  return n;
}

CalculateAffTXTYTurn()

Int_t EdbAlignmentV::CalculateAffTXTYTurn	(	TObjArray &	arr1,
		TObjArray &	arr2,
		EdbAffine2D &	aff
	)

{
  int n = CheckEqualArr(arr1,arr2);
  TArrayF x1(n), x2(n), y1(n), y2(n);
  for(int i=0; i<n; i++ ) {
    EdbSegP *s1 = (EdbSegP*)arr1.UncheckedAt(i);
    EdbSegP *s2 = (EdbSegP*)arr2.UncheckedAt(i);
    x1[i] = TX(0, *s1);    y1[i] = TY(0, *s1);
    x2[i] = TX(1, *s2);    y2[i] = TY(1, *s2);
  }
  aff.Calculate(n,x1.GetArray(),y1.GetArray(),x2.GetArray(),y2.GetArray(),2);
  return n;
}

CalculateAffXY() [1/2]

Int_t EdbAlignmentV::CalculateAffXY ( EdbAffine2D &  aff )

inline

{return CalculateAffXY( eS[0], eS[1], aff);}

CalculateAffXY() [2/2]

Int_t EdbAlignmentV::CalculateAffXY	(	TObjArray &	arr1,
		TObjArray &	arr2,
		EdbAffine2D &	aff
	)

{
  int n = CheckEqualArr(arr1,arr2);
  TArrayF x1(n), x2(n), y1(n), y2(n);
  for(int i=0; i<n; i++ ) {
    EdbSegP *s1 = (EdbSegP*)arr1.UncheckedAt(i);
    EdbSegP *s2 = (EdbSegP*)arr2.UncheckedAt(i);
    x1[i] = X(0,*s1);    y1[i] = Y(0,*s1);
    x2[i] = X(1,*s2);    y2[i] = Y(1,*s2);
  }
  aff.Calculate(n,x1.GetArray(),y1.GetArray(),x2.GetArray(),y2.GetArray(),0);
  return n;
}

CalculateAffXYTurn() [1/2]

Int_t EdbAlignmentV::CalculateAffXYTurn ( EdbAffine2D &  aff )

inline

{return CalculateAffXYTurn( eS[0], eS[1], aff);}

CalculateAffXYTurn() [2/2]

Int_t EdbAlignmentV::CalculateAffXYTurn	(	TObjArray &	arr1,
		TObjArray &	arr2,
		EdbAffine2D &	aff
	)

{
  int n = CheckEqualArr(arr1,arr2);
  TArrayF x1(n), x2(n), y1(n), y2(n);
  for(int i=0; i<n; i++ ) {
    EdbSegP *s1 = (EdbSegP*)arr1.UncheckedAt(i);
    EdbSegP *s2 = (EdbSegP*)arr2.UncheckedAt(i);
    x1[i] = X(0,*s1);    y1[i] = Y(0,*s1);
    x2[i] = X(1,*s2);    y2[i] = Y(1,*s2);
  }
  aff.Calculate(n,x1.GetArray(),y1.GetArray(),x2.GetArray(),y2.GetArray(),2);
  return n;
}

CheckEqualArr()

Int_t EdbAlignmentV::CheckEqualArr ( TObjArray &  arr1, TObjArray &  arr2  )

static

{
  int n1 = arr1.GetEntries();
  int n2 = arr2.GetEntries();
  int n = Min(n1,n2);
  if(n1!=n2) Log(1,"CheckEqualArr","WARNING: arrays are not equal: %d %d, take first %d segs", n1,n2,n );
  return n;
}

CloseOutputFile()

void EdbAlignmentV::CloseOutputFile

(

)

{
  if(eOutputFile) {
    eOutputFile->Close();
    SafeDelete(eOutputFile);
  }
}

Corr2Aff() [1/2]

void EdbAlignmentV::Corr2Aff

(

EdbLayer &

layer

)

{
/*  EdbAffine2D &a0 = *(layer.GetAffineXY());
  a0.Reset();
  a0.ShiftX(  eCorr[0].V(0) );  a0.ShiftY( eCorr[0].V(1) );
  a0.Rotate(  eCorr[0].V(6) );
  a0.ShiftX( -eCorr[1].V(0) );  a0.ShiftY( -eCorr[1].V(1) );
  layer.SetShrinkage( eCorr[0].V(5) );
  layer.SetZcorr(     eCorr[0].V(2) );*/
  
  Corr2Aff(eCorr[0],layer);
  layer.GetAffineXY()->ShiftX( -eCorr[1].V(0) );
  layer.GetAffineXY()->ShiftY( -eCorr[1].V(1) );
}

Corr2Aff() [2/2]

void EdbAlignmentV::Corr2Aff	(	EdbSegCorr &	corr,
		EdbLayer &	layer
	)

{
  EdbAffine2D &a0 = *(layer.GetAffineXY());
  a0.Reset();
  a0.ShiftX(  corr.V(0) );  a0.ShiftY( corr.V(1) );
  a0.Rotate(  corr.V(6) );
  EdbAffine2D &atxty = *(layer.GetAffineTXTY());
  atxty.Reset();
  atxty.ShiftX(corr.V(3)); atxty.ShiftY(corr.V(4));
  layer.SetShrinkage( corr.V(5) );
  layer.SetZcorr(     corr.V(2) );
}

CorrToCoG() [1/2]

void EdbAlignmentV::CorrToCoG	(	int	side,
		EdbPattern &	p
	)

functions alpplied to the individual patterns

{
  int n=p.N();
  Double_t x0=0, y0=0;
  for(int i=0; i<n; i++) {
    EdbSegP *s = p.GetSegment(i);
    x0 += X(side, *s);
    y0 += Y(side, *s);
  }
  x0/=n;   y0/=n;
  eCorr[0].AddV(0, -x0);
  eCorr[0].AddV(1, -y0);
  eCorr[1].AddV(0, -x0);
  eCorr[1].AddV(1, -y0);
}

CorrToCoG() [2/2]

void EdbAlignmentV::CorrToCoG	(	int	side,
		TObjArray &	p
	)

{
  int n=p.GetEntries();
  Double_t x0=0, y0=0;
  for(int i=0; i<n; i++) {
    EdbSegP *s = (EdbSegP*)p.UncheckedAt(i);
    x0 += X(side,*s);
    y0 += Y(side,*s);
  }
  x0/=n;   y0/=n;
  eCorr[0].AddV(0, -x0);
  eCorr[0].AddV(1, -y0);
  eCorr[1].AddV(0, -x0);
  eCorr[1].AddV(1, -y0);
}

CoupleQuality()

float EdbAlignmentV::CoupleQuality	(	EdbSegP &	s1,
		EdbSegP &	s2
	)

{
  // TODO
  return s1.W()+s2.W();
}

DefineGuessCell()

void EdbAlignmentV::DefineGuessCell	(	float	xmin1,
		float	xmax1,
		float	ymin1,
		float	ymax1,
		float	xmin2,
		float	xmax2,
		float	ymin2,
		float	ymax2,
		int	np1,
		int	np2,
		float	binOK
	)

Selector functions.

{
  float s1 = (xmax1-xmin1)*(ymax1-ymin1);
  float xbin1 = Sqrt( s1/(np1/binOK)  );
  
  float s2 = (xmax2-xmin2)*(ymax2-ymin2);
  float xbin2 = Sqrt( s2/(np2/binOK)  );
  
  float xbin = Min(xbin1,xbin2);
 
  float min[2] = { Min(xmin1,xmin2)-eXmarg, Min(ymin1,ymin2)-eYmarg };
  float max[2] = { Max(xmax1,xmax2)+eXmarg, Max(ymax1,ymax2)+eYmarg };
  int   n[2]   = { (int)((max[0]-min[0])/xbin+1), (int)((max[1]-min[1])/xbin+1) };
  
  int maxcell1 = np1/n[0]/n[1]+10;   maxcell1 += (int)(5*Sqrt(maxcell1));
  ePC[0].InitCell(maxcell1,n,min,max);
  int maxcell2 = np2/n[0]/n[1]+10;    maxcell2 += (int)(5*Sqrt(maxcell2));
  ePC[1].InitCell(maxcell2,n,min,max);
}

DoubletsFilterOut()

int EdbAlignmentV::DoubletsFilterOut	(	int	checkview,
		TH2F *	hxy = 0,
		TH2F *	htxty = 0
	)

assumed the same pattern's segments in eS[0] and eS[1]
checkview = 0 do not check if close tracks belongs to different views
checkview = 1 check views, select best and cancel the worst candidate
checkview = 2 check views but do not cancell worst candidate (debug option)

{
  
  int nout=0;
  int n = CheckEqualArr(eS[0], eS[1]);
  for(int i=0; i<n; i++) {
    EdbSegP *s1 = (EdbSegP*)eS[0].UncheckedAt(i);
    EdbSegP *s2 = (EdbSegP*)eS[1].UncheckedAt(i);
    if( s1->Flag()==-10 && s2->Flag()==-10) continue;
    if(checkview>0) if( s2->Aid(0)==s1->Aid(0) && s2->Aid(1)==s1->Aid(1) && s2->Side()==s1->Side() )    continue;
    if( !IsInsideDVsame(*s1,*s2) )                                                                      continue;
    if(s1->Flag()>-10 && s2->Flag()>-10) {
      if(hxy)   hxy->Fill( s1->X()-s2->X() , s1->Y()-s2->Y());
      if(htxty) htxty->Fill(s1->TX()-s2->TX(),s1->TY()-s2->TY());
    }
    if(checkview==1||checkview==0) {
      if( s2->W()>s1->W() )                                        s1->SetFlag(-10);
      else if( s2->W() == s1->W() &&  s2->Chi2() <  s1->Chi2() )   s1->SetFlag(-10);
      else if( s2->W() == s1->W() &&  s2->Chi2() >= s1->Chi2() )   s2->SetFlag(-10);
      else if( s2->W()<s1->W() )                                   s2->SetFlag(-10);
      nout++;
    }
  }
  
  //check 
  int miss=0, wrong=0;
  for(int i=0; i<n; i++) {
    EdbSegP *s1 = (EdbSegP*)eS[0].UncheckedAt(i);
    EdbSegP *s2 = (EdbSegP*)eS[1].UncheckedAt(i);
    if( s1->Flag()==-10 && s2->Flag()==-10 )                  continue;
    if( s1->Flag()!=-10 && s2->Flag()!=-10 )        { miss++; continue;}
    if( s1->Flag()==-10 && (s1->W() > s2->W()) )    {
      wrong++;
      s1->SetFlag(0);
      s2->SetFlag(-10);
    }
  }
  Log(2,"DubletsFilterOut","miss: %d wrong: %d",miss,wrong);
  
  Log(2,"DubletsFilterOut","%d segments discarded with DX,DY,DTX,DTY: (%8.4f %8.4f %7.5f %7.5f) checkview =%d", 
      nout,eDVsame[0],eDVsame[1],eDVsame[2],eDVsame[3], checkview );
  return nout;
}

FillCell() [1/2]

void EdbAlignmentV::FillCell	(	int	side,
		EdbPattern &	pat
	)

assume that the cell is already initialized

{
  if(!SideOK(side)) return;
  EdbSegP *s=0;
  int n = pat.N();
  for(int i=0; i<n; i++) {
    s = pat.GetSegment(i);
    ePC[side].AddObject( X(side,*s), Y(side,*s), (TObject*)s );
  }
}

FillCell() [2/2]

void EdbAlignmentV::FillCell	(	int	side,
		TObjArray &	pat
	)

assume that the cell is already initialized

{
  if(!SideOK(side)) return;
  EdbSegP *s=0;
  int n = pat.GetEntriesFast();
  for(int i=0; i<n; i++) {
    s = (EdbSegP*)pat.UncheckedAt(i);
    ePC[side].AddObject( X(side,*s), Y(side,*s), (TObject*)s );
  }
}

FillCombinations() [1/2]

int EdbAlignmentV::FillCombinations

(

)

{
  float dxMax = 2*Max( ePC[0].Xbin(), ePC[1].Xbin() );
  float dyMax = 2*Max( ePC[0].Ybin(), ePC[1].Ybin() );
  return FillCombinations( eDVsame, dxMax, dyMax, 1);
}

FillCombinations() [2/2]

int EdbAlignmentV::FillCombinations	(	float	dv[4],
		float	dxMax,
		float	dyMax,
		bool	doFill
	)

input: dv = coinsidence condition (dx,dy,dtx,dty)
dxMax, dyMax - the area around each segment for the combinations
selection, it can be selected bigger then coinsidence condition due to
corrections displacements
the cells must be already filled

{
 
  eS[0].Clear();
  eS[1].Clear();
  int ir2[2] = { int((dxMax-0.0001)/ePC[0].Xbin())+1, int((dyMax-0.0001)/ePC[0].Ybin())+1 };
 
  int nout=0;
 
  TObjArray arr1(10000);
  TObjArray arr2(100);
  float v[2];
  EdbSegP *s1,*s2;
 
  int ncomb;                      // combinations rate counter
  int n1 = ePC[0].SelectObjects(arr1);
  for(int i=0; i<n1; i++) {
    ncomb=0;
    s1 = (EdbSegP*)arr1.UncheckedAt(i);
    if(s1->Flag()==-10)                                   continue;
    arr2.Clear();
    v[0] = X( 0, *s1);
    v[1] = Y( 0, *s1);
    int n2 = ePC[1].SelectObjectsC(v,ir2,arr2);
 
    if(n2<1)                                              continue;
    float tx1 = TX(0, *s1);
    float ty1 = TY(0, *s1);
    for(int i2=0; i2<n2; i2++) {
      s2 = (EdbSegP*)arr2.UncheckedAt(i2);
      if(s2->Flag()==-10)                                 continue;
      if( s2==s1 )                                        continue;
      if( Abs(X(1, *s2) - v[0]) > dv[0] )                 continue;
      if( Abs(Y(1, *s2) - v[1]) > dv[1] )                 continue;
      if( Abs(TX(1, *s2)- tx1)  > dv[2] )                 continue;
      if( Abs(TY(1, *s2)- ty1)  > dv[3] )                 continue;
 
      if(doFill) {
        eS[0].Add(s1);
        eS[1].Add(s2);
      }
      ncomb++;
    }
    nout+=ncomb;
    if(eDoubletsRate) eDoubletsRate->Fill(ncomb);
  }
 
  arr1.Clear();
  arr2.Clear();
 
  Log(3,"FillCombinations","%d selected with the acceptance: %7.2f %7.2f (%d,%d) and tolerance (%7.2f %7.2f %7.4f %7.4f)",
      nout, dxMax,dyMax, ir2[0], ir2[1], dv[0], dv[1], dv[2], dv[3] );
  return nout;
}

FillGuessCell() [1/2]

void EdbAlignmentV::FillGuessCell	(	EdbPattern &	p1,
		EdbPattern &	p2,
		float	binOK = 1.,
		float	offsetMax = 2000.
	)

binOK - is the mean number of entries requested per bin

{
 
  float xmin1=Xmin(0,p1), ymin1=Ymin(0,p1), xmax1=Xmax(0,p1), ymax1=Ymax(0,p1);
  float xmin2=Xmin(1,p2), ymin2=Ymin(1,p2), xmax2=Xmax(1,p2), ymax2=Ymax(1,p2);
  Log(3, "FillGuessCell", "x1:(%f %f) y1:(%f %f)",xmin1,xmax1, ymin1, ymax1);
  Log(3, "FillGuessCell", "x2:(%f %f) y2:(%f %f)",xmin2,xmax2, ymin2, ymax2);
  ApplyLimitsOffset( xmin1, xmax1, xmin2, xmax2, offsetMax);
  ApplyLimitsOffset( ymin1, ymax1, ymin2, ymax2, offsetMax);
  int np1 = p1.N(), np2 = p2.N();
 
  DefineGuessCell( xmin1, xmax1, ymin1, ymax1, xmin2, xmax2, ymin2, ymax2, np1, np2, binOK);
 
  FillCell( 0, p1 );
  FillCell( 1, p2 );
 
  if( Log(3, "FillGuessCell", "with patterns of %d %d  statistics:",np1,np2) ) {
    ePC[0].PrintStat();
    ePC[1].PrintStat();
  }
}

FillGuessCell() [2/2]

void EdbAlignmentV::FillGuessCell	(	TObjArray &	p1,
		TObjArray &	p2,
		float	binOK = 1.,
		float	offsetMax = 2000.
	)

binOK - is the mean number of entries requested per bin

{
 
  float xmin1=Xmin(0,p1), ymin1=Ymin(0,p1), xmax1=Xmax(0,p1), ymax1=Ymax(0,p1);
  float xmin2=Xmin(1,p2), ymin2=Ymin(1,p2), xmax2=Xmax(1,p2), ymax2=Ymax(1,p2);
  ApplyLimitsOffset( xmin1, xmax1, xmin2, xmax2, offsetMax);
  ApplyLimitsOffset( ymin1, ymax1, ymin2, ymax2, offsetMax);
  int np1 = p1.GetEntries(), np2 = p2.GetEntries();
 
  Log(3, "FillGuessCell", "xmin1, xmax1, ymin1, ymax1, xmin2, xmax2, ymin2, ymax2, np1, np2, binOK: %f %f %f %f   %f %f %f %f   %d %d   %f",xmin1, xmax1, ymin1, ymax1, xmin2, xmax2, ymin2, ymax2, np1, np2, binOK);
  DefineGuessCell( xmin1, xmax1, ymin1, ymax1, xmin2, xmax2, ymin2, ymax2, np1, np2, binOK);
 
  FillCell( 0, p1 );
  FillCell( 1, p2 );
 
  if( Log(3, "FillGuessCell", "with arrays of %d %d  statistics:",np1,np2) ) {
    ePC[0].PrintStat();
    ePC[1].PrintStat();
  }
}

FillThetaHist()

void EdbAlignmentV::FillThetaHist	(	int	side,
		EdbH2 &	htxy
	)

{
  if( side<0 || side>1 ) return;
  TObjArray arr(10000);
  int n = ePC[side].SelectObjects(arr);
  for(int i=0; i<n; i++) {
    EdbSegP *s = (EdbSegP*)arr.UncheckedAt(i);
    htxy.Fill( s->TY(), s->TX() );
  }
}

FindCorrDiff()

Int_t EdbAlignmentV::FindCorrDiff	(	float	dvsame[4],
		int	side = 0,
		int	nlim = 10
	)

find diffs with the default settings and correct requested side

{
  if(!SideOK(side)) return 0;
  float dvf[4];
  int n = FindDiff(eS[0], eS[1], dvsame, dvf );
  if(n<nlim) return n;
  eCorr[side].AddV(0,dvf[0]);
  eCorr[side].AddV(1,dvf[1]);
  //eCorr[side].AddV(3,dvf[2]);
  //eCorr[side].AddV(4,dvf[3]);
  Log(3,"FindCorrDiff","correct side %d  with %11.7f %11.7f %10.7f %10.7f using %5d coinsidences",
      side, dvf[0] ,dvf[1] ,dvf[2] ,dvf[3],n);
  return n;
}

FindDensityPeak()

Float_t EdbAlignmentV::FindDensityPeak	(	TArrayF &	arr,
		float	fraction
	)

{
  if(fraction<=0||fraction>1) Log(1,"EdbAlignmentV::FindDensityPeak","ERROR! fraction out of limits: %f",fraction);
  TArrayI ind(arr.fN);
  Sort( arr.fN, arr.GetArray(), ind.GetArray(), 0 );
  int nfra = (int)(fraction*arr.fN);
  float dxmin = arr[ ind[nfra] ] - arr[ ind[0] ];
  int   ibest=0;
 for(int i=1; i<arr.fN-nfra; i++)   {
    float dx = arr[ ind[nfra+i] ] - arr[ind[i]];
    if( dx < dxmin) {
      dxmin = dx;
      ibest=i;
    }
  }
 
  Double_t sd=0;
  int ic=0;
  for(int i=ibest; i<ibest+nfra-1; i++) {
    sd   += arr[ ind[i] ];
    ic++;
  }
  sd /= ic;
  Log(2,"EdbAlignmentV::FindDensityPeak", "nfra/n: %d/%d     dxmin = %g   sd = %g",nfra,arr.fN,dxmin,sd);
  return (Float_t)sd;
}

FindDiff()

Int_t EdbAlignmentV::FindDiff	(	TObjArray &	arr1,
		TObjArray &	arr2,
		float	dvlim[4],
		float	dvfound[4]
	)

{
  int n = CheckEqualArr(arr1,arr2);
  int ic=0;
  EdbSegP *s1,*s2;
  Double_t sdx=0, sdy=0, sdtx=0, sdty=0;
  float dvf[4];
  for(int i=0; i<n; i++) {
    s1 = (EdbSegP*)arr1.UncheckedAt(i);
    s2 = (EdbSegP*)arr2.UncheckedAt(i);
    if( ValidCoinsidence(*s1, *s2, dvlim, dvf) ) {
      sdx   += dvf[0];
      sdy   += dvf[1];
      sdtx  += dvf[2];
      sdty  += dvf[3];
      ic++;
    }
  }
  dvfound[0]  = sdx/ic;
  dvfound[1]  = sdy/ic;
  dvfound[2]  = sdtx/ic;
  dvfound[3]  = sdty/ic;
  return ic;
}

FineCorrPhi()

Float_t EdbAlignmentV::FineCorrPhi	(	TObjArray &	sel1,
		TObjArray &	sel2
	)

for the correct answer the O,O should be in the CoG of the second pattern

{
  int n = CheckEqualArr(arr1,arr2);
  if(n<3) return 0;
  double x1=0, y1=0, x2=0,y2=0;
  Double_t R=0, r=0, dPhi=0;
  for(int i=0; i<n; i++) {
    EdbSegP *s1 = (EdbSegP*)arr1.UncheckedAt(i);
    EdbSegP *s2 = (EdbSegP*)arr2.UncheckedAt(i);
    x1 =  X(0,*s1);
    y1 =  Y(0,*s1);
    x2 =  X(1,*s2);
    y2 =  Y(1,*s2);
    r = Sqrt(x1*x1+y1*y1);
    dPhi += (ATan2(-y2,-x2) - ATan2(-y1,-x1)) * r;
    R += r;
  }
  dPhi /= R;
  Log(3,"FineCorrPhi","dPhi =%f with %d segments",      (float)dPhi, n );
  return (float)dPhi;
}

FineCorrZ() [1/2]

float EdbAlignmentV::FineCorrZ ( )

inline

{ return FineCorrZ(eS[0], eS[1]); }

FineCorrZ() [2/2]

Float_t EdbAlignmentV::FineCorrZ	(	TObjArray &	sel1,
		TObjArray &	sel2
	)

{
  double dzz=0, dzx=0, dzy=0;
  int n = CheckEqualArr(arr1,arr2);
  int icx=0, icy=0;
  for(int i=0; i<n; i++) {
    EdbSegP *s1 = (EdbSegP*)arr1.UncheckedAt(i);
    EdbSegP *s2 = (EdbSegP*)arr2.UncheckedAt(i);
    float tx1 =  TX(0, *s1), ty1 =  TY(0, *s1);
    float x1  =  X(0,*s1),  y1 =  Y(0,*s1);
    float x2  =  X(1,*s2),  y2 =  Y(1,*s2);
 
    if(tx1>0.1) {
      dzx += (x2-x1)/tx1;
      icx++;
    }
    if(ty1>0.1) {
      dzy += (y2-y1)/ty1;
      icy++;
    }
  }
 
  if(icx+icy>3)   dzz = (dzx+dzy)/(icx+icy);
 
  Log(3,"FineCorrZ","dzz =%f with icx=%d and icy=%d (of %d) segments",
      (float)dzz, icx,icy, n );
 
  return (float)dzz;
}

HDistance()

void EdbAlignmentV::HDistance	(	EdbPattern &	p1,
		EdbPattern &	p2,
		float	dxMax,
		float	dyMax
	)

{
  Log(3,"HDistance","preselection for patterns with %d and %d segments",p1.N(), p2.N());
 
  int eITMAX=51;  // angular normalization (def=50) (the step is ~1./eITMAX)
  int eOCMAX=100; // occupancy (def=100)
  int nx=201, ny=201, no=eOCMAX;
 
  Long_t *ind1 = new Long_t[nx*ny*no];
  Long_t *ind2 = new Long_t[nx*ny*no];
  Int_t  *oc1  = new Int_t[nx*ny];
  Int_t  *oc2  = new Int_t[nx*ny];
  memset(ind1,0,nx*ny*no*sizeof(Long_t));
  memset(ind2,0,nx*ny*no*sizeof(Long_t));
  memset( oc1,0,nx*ny*sizeof(Int_t));
  memset( oc2,0,nx*ny*sizeof(Int_t));
 
  int itx,ity;  
 
  for(int i=0;i<eITMAX;i++) for(int j=0;j<eITMAX;j++) { oc1[i*nx+j]=0; oc2[i*nx+j]=0;} 
  for(int i=0;i<p1.N();i++){
    itx=int( (p1.GetSegment(i)->TX()+1.)*eITMAX/2. );
    ity=int( (p1.GetSegment(i)->TY()+1.)*eITMAX/2. );
    if(itx<eITMAX)
      if(ity<eITMAX)
    if(itx>=0)
      if(ity>=0)
        if(oc1[itx*nx+ity]<eOCMAX-1) 
          { ind1[itx*nx*ny+ity*ny+oc1[itx*nx+ity]]=i; (oc1[itx*nx+ity])++;}
  }
  for(int i=0;i<p2.N();i++){
    itx=int( (p2.GetSegment(i)->TX()+1.)*eITMAX/2 );
    ity=int( (p2.GetSegment(i)->TY()+1.)*eITMAX/2 );
    if(itx<eITMAX)
      if(ity<eITMAX)
    if(itx>=0)
      if(ity>=0)
        if(oc2[itx*nx+ity]<eOCMAX-1) 
          { ind2[itx*nx*ny+ity*ny+oc2[itx*nx+ity]]=i; (oc2[itx*nx+ity])++;}
  }
  
  eS[0].Clear();
  eS[1].Clear();
 
  EdbSegP *s1,*s2;
  for(int itx=0;itx<eITMAX;itx++) for(int ity=0;ity<eITMAX;ity++) 
    for(int i=0;i<oc1[itx*nx+ity];i++) {
      s1 = p1.GetSegment(ind1[itx*nx*ny+ity*ny+i]);
      for(int j=0;j<oc2[itx*nx+ity];j++)
    {
      s2 = p2.GetSegment(ind2[itx*nx*ny+ity*ny+j]);
      if(Abs(s2->eX-s1->eX)>dxMax) continue;
      if(Abs(s2->eY-s1->eY)>dyMax) continue;
      eS[0].Add( s1 );
      eS[1].Add( s2 );
    }
    }
  delete [] ind1;
  delete [] ind2;
  delete [] oc1;
  delete [] oc2;
  Log(3,"HDistance","preselection for patterns with %d and %d segments: %d comb",p1.N(), p2.N(), eS[0].GetEntries());
}

InitHphi()

void EdbAlignmentV::InitHphi ( int  n, float  min, float  max  )

inline

{ eH[0][6].InitH1(n, min, max); }

InitHshr0()

void EdbAlignmentV::InitHshr0 ( int  n, float  min, float  max  )

inline

{ eH[0][5].InitH1(n, min, max); }

InitHshr1()

void EdbAlignmentV::InitHshr1 ( int  n, float  min, float  max  )

inline

{ eH[1][5].InitH1(n, min, max); }

InitHx()

void EdbAlignmentV::InitHx ( int  n, float  min, float  max  )

inline

{ eH[0][0].InitH1(n, min, max); }

InitHy()

void EdbAlignmentV::InitHy ( int  n, float  min, float  max  )

inline

{ eH[0][1].InitH1(n, min, max); }

InitHz()

void EdbAlignmentV::InitHz ( int  n, float  min, float  max  )

inline

{ eH[0][2].InitH1(n, min, max); }

InitOutputFile()

void EdbAlignmentV::InitOutputFile	(	const char *	file = "report_al.root",
		const char *	option = "RECREATE"
	)

IO, initialization and finalization functions.

{
  CloseOutputFile();
  eOutputFile = TFile::Open(file,option);
}

InitPatCellBin()

void EdbAlignmentV::InitPatCellBin	(	int	side,
		EdbPattern &	pat,
		float	binx,
		float	biny
	)

{
  if(!SideOK(side)) return;
 
  EdbSegP s1min(0,pat.Xmin(), pat.Ymin(), 0,0 );
  EdbSegP s1max(0,pat.Xmax(), pat.Ymax(), 0,0 );
  float min[2] = { X(side,s1min)-eXmarg, X(side,s1min)-eYmarg };
  float max[2] = { X(side,s1max)+eXmarg, X(side,s1max)+eYmarg };
 
  int   n[2]   = { (int)((max[0]-min[0])/binx+1), (int)((max[1]-min[1])/biny+1) };
  int maxcell = pat.N()/n[0]/n[1]+10;
  maxcell += (int)(5*Sqrt(maxcell));
  Log(2, "InitPatCellBin", "maxcell = %d\n",maxcell);
  ePC[side].InitCell(maxcell,n,min,max);
}

InitPatCellN()

void EdbAlignmentV::InitPatCellN	(	EdbCell2 &	cell,
		EdbPattern &	pat,
		int	nx,
		int	ny
	)

note: no correction (do we need tis function?)

{
  float min[2] = {pat.Xmin()-eXmarg, pat.Ymin()-eYmarg };
  float max[2] = {pat.Xmax()+eXmarg, pat.Ymax()+eYmarg };
  int   n[2]   = {nx,ny};
  int maxcell = pat.N()/n[0]/n[1]+10;
  maxcell += (int)(5*Sqrt(maxcell));
  Log(2, "InitPatCellN", "maxcell = %d\n",maxcell);
  cell.InitCell(maxcell,n,min,max);
}

IsInsideDVsame()

Bool_t EdbAlignmentV::IsInsideDVsame	(	EdbSegP &	s1,
		EdbSegP &	s2
	)

{
  if( Abs(s1.X()-s2.X())   > eDVsame[0] )  return 0;
  if( Abs(s1.Y()-s2.Y())   > eDVsame[1] )  return 0;
  if( Abs(s1.TX()-s2.TX()) > eDVsame[2] )  return 0;
  if( Abs(s1.TY()-s2.TY()) > eDVsame[3] )  return 0;
  return 1;
}

Ncoins()

Int_t EdbAlignmentV::Ncoins	(	float	dvlim[4],
		EdbH2 *	hdxy = 0,
		EdbH2 *	hdtxty = 0,
		TObjArray *	sel1 = 0,
		TObjArray *	sel2 = 0
	)

calculate all coinsidences inside dv:(dx,dy, dtx,dty)
fill position and angular 2-d plots if requested
fill arrays with selected segments sel1, sel2 if requested

{
 
  int ic = 0; // counter
  int n = CheckEqualArr(eS[0],eS[1]);
 
  if(hdxy)   hdxy->CleanCells();
  if(hdtxy)  hdtxy->CleanCells();
 
  float dfound[4];
  for(int i=0; i<n; i++)
    {
      EdbSegP *s1 = (EdbSegP*)eS[0].UncheckedAt(i);
      EdbSegP *s2 = (EdbSegP*)eS[1].UncheckedAt(i);
 
      if( !ValidCoinsidence(*s1, *s2, dv, dfound) )    continue;
 
      ic++;
      if(sel1)  sel1->Add(s1);
      if(sel2)  sel2->Add(s2);
      if(hdxy)  hdxy->Fill(dfound[0],dfound[1]);
      if(hdtxy) hdtxy->Fill(dfound[2],dfound[3]);
    }
  return ic;
}

Ncp()

Int_t EdbAlignmentV::Ncp ( )

inline

Functions applied to the selected parallel arrays.

{return  CheckEqualArr( eS[0], eS[1]); }

OptimiseVar1()

int EdbAlignmentV::OptimiseVar1	(	int	side,
		int	ivar,
		EdbH2 *	hdxy = 0,
		EdbH2 *	hdtxy = 0
	)

use already preselected "couples" - useful to test small variations of parameters

{
  if(!SideOK(side)) return 0;
 
  EdbH1 &h = eH[side][ivar];
  if( h.N() < 1 ) {
    Log(1,"OptimiseVar1","ERROR: var %d of side %d have %d steps - skipped", ivar,side, h.N() );
    return 0;
  }
 
  h.CleanCells();
 
  int   npk0=0;
  float dx0=0,dy0=0;  //the position of the highest peak in xy
  float var0=0;      //the position of the highest peak on var
  for(int i=0; i<h.N(); i++) 
    {
      float var= h.X(i);
      eCorr[side].SetV( ivar, var );
 
      int npk = Ncoins(eDVsame, hdxy);
 
      float dx=0, dy=0;
      if(hdxy){
    EdbPeak2 pk2(*hdxy);
    npk = (int)(pk2.ProbPeak( dx, dy ));
        //hdxy->DrawH2(Form("hdxy%d_%2.2d",side,i),Form("OptimiseVar1: ivar=%d var=%f npk=%d",ivar, var,npk) )->Write();
      }
      h.SetBin( i, npk );
      if( npk > npk0 ) { npk0=npk; dx0 = dx; dy0=dy; var0 = var; }
      Log(4,"OptimiseVar1"," %d %f %d (%f %f)", i, h.X(i), h.Bin(i), dx,dy );
    }
 
  //eCorr[side].AddV(0,dx0);      // set x-y corrections if any
  //eCorr[side].AddV(1,dy0);
  eCorr[side].SetV(ivar,var0);
  if(hdxy) Ncoins(eDVsame, hdxy);  // to keep the optimal histogram in hdxy
  
  Log(3,"OptimiseVar1"," side:var (%d:%d): found %d at var=%f  xy:(%f %f)", side, ivar, npk0, var0, dx0,dy0 );
  return npk0;
}

OptimiseVar2()

void EdbAlignmentV::OptimiseVar2	(	int	side1,
		int	ivar1,
		int	side2,
		int	ivar2,
		EdbH2 &	h12,
		EdbH2 *	hdxy = 0,
		EdbH2 *	hdtxty = 0
	)

use already preselected "couples" - useful to test small variations of parameters
especially after Hdistance preselection
Input: 2 variables defoned as side1/ivar1 and side1/ivar1
Output: h12 - filled selections histo
Optional: hdxy, hdtxy - 2d- histograms defined outside and used for the peak selection

{
  if(!SideOK(side1)) return;
  if(!SideOK(side2)) return;
  EdbH1 &h1 = eH[side1][ivar1];
  EdbH1 &h2 = eH[side2][ivar2];
  if( h1.N() < 1 || h2.N() < 1) {
    Log(1,"OptimiseVar2","ERROR: var %d of side %d have %d steps - skipped", ivar1,side1, h1.N() );
    Log(1,"OptimiseVar2","ERROR: var %d of side %d have %d steps - skipped", ivar2,side2, h2.N() );
    return;
  }
  Log(3,"OptimiseVar2","side/var: %d/%d and %d/%d with  %d x %d = %d attempts", 
      side1, ivar1, side2, ivar2, h1.N(), h2.N(), h1.N()*h2.N() );
 
    //h12.Delete();
  int    n12[2]  = { h1.N(), h2.N() };
  float  min[2]  = { h1.Xmin(), h2.Xmin() };
  float  max[2]  = { h1.Xmax(), h2.Xmax() };
  h12.InitH2(n12, min, max);
 
  h1.CleanCells();
  h2.CleanCells();
 
  int   npk0=0;
  float dx0=0,dy0=0;  //the position of the highest peak
 
  for(int i1=0; i1<h1.N(); i1++)
    {
      eCorr[side1].SetV( ivar1, h1.X(i1) );
      for(int i2=0; i2<h2.N(); i2++) 
    {
      eCorr[side2].SetV( ivar2, h2.X(i2) );
      int nc = Ncoins(eDVsame, hdxy);
      if(!hdxy) h12.SetBin( i1, i2, nc );
      else {
        EdbPeak2 pk2(*hdxy);
        float  dx, dy;
        int npk = pk2.FindPeak( dx, dy );
        //int npk = pk2.FindPeak9( dx, dy );
        if( npk > npk0 ) { npk0=npk; dx0 = dx; dy0=dy; }
        h12.SetBin( i1, i2, npk );
      }
    }
    }
 
  eCorr[side1].AddV(0,dx0);      // set x-y corrections
  eCorr[side1].AddV(1,dy0);
}

SelectBestCouple()

int EdbAlignmentV::SelectBestCouple

(

)

assume the different pattern's segments in eS[0] and eS[1]
assume that the selection method in FillCombinations - "first s1 then s2"

{
 
  int nrem=0;
  int n = CheckEqualArr(eS[0], eS[1]);
  EdbSegP *s1=0,*s2=0;
  EdbSegP *s1ok=0,*s2ok=0;
  int   iok=-1;
  for(int i=0; i<n; i++) {
    s1 = (EdbSegP*)eS[0].UncheckedAt(i);
    s2 = (EdbSegP*)eS[1].UncheckedAt(i);
    if(s1==s1ok) {
      if( CoupleQuality(*s1,*s2) >  CoupleQuality(*s1ok,*s2ok) ) {
    s1ok = s1, s2ok = s2;
    eS[0].RemoveAt(iok);
    eS[1].RemoveAt(iok);
    iok=i;
      }
      else { 
    eS[0].RemoveAt(i);
    eS[1].RemoveAt(i);
      }
      nrem++;
    } 
    else {  s1ok = s1, s2ok = s2; iok=i; }
  }
  
  eS[0].Compress();
  eS[1].Compress();
 
  Log(2,"SelectBestCouple","%d couples discarded with", nrem );
  return nrem;
}

SelectIsolated()

int EdbAlignmentV::SelectIsolated

(

)

assume the different pattern's segments in eS[0] and eS[1]
assume that the selection method in FillCombinations - "first s1 then s2"
remove all duplicated combs

{
 
  int nrem=0;
  int n = CheckEqualArr(eS[0], eS[1]);
  EdbSegP *s1=0,*s2=0;
  EdbSegP *s1ok=0,*s2ok=0;
  int   iok=-1;
  for(int i=0; i<n; i++) {
    s1 = (EdbSegP*)eS[0].UncheckedAt(i);
    s2 = (EdbSegP*)eS[1].UncheckedAt(i);
    if(s1==s1ok) {
      eS[0].RemoveAt(i);
      eS[1].RemoveAt(i);
      nrem++;
    } 
    else if(s1ok!=0) {
      eS[0].RemoveAt(iok);
      eS[1].RemoveAt(iok);
      s1ok=0;
      nrem++;
    }
    else {  s1ok = s1, s2ok = s2; iok=i; }
  }
  
  eS[0].Compress();
  eS[1].Compress();
 
  Log(2,"SelectIsolated","%d couples discarded with", nrem );
  return nrem;
}

SideOK()

bool EdbAlignmentV::SideOK

(

int

side

)

{
  if(side==0||side==1) return 1; 
  else { 
    Log(1,"SideOK","ERROR: invalid side index %d",side); 
    return 0;
  }
}

StrDVsame()

char * EdbAlignmentV::StrDVsame ( ) const

inline

{return Form("%7.2f %7.2f %8.5f %8.5f",eDVsame[0],eDVsame[1],eDVsame[2],eDVsame[3]); }

TX()

float EdbAlignmentV::TX ( int  side, EdbSegP &  s  )

inline

{ return eUseAffCorr? eCorrL[side].TX(s) : eCorr[side].TX(s); }

TY()

float EdbAlignmentV::TY ( int  side, EdbSegP &  s  )

inline

{ return eUseAffCorr? eCorrL[side].TY(s) : eCorr[side].TY(s); }

ValidCoinsidence()

Bool_t EdbAlignmentV::ValidCoinsidence	(	EdbSegP &	s1,
		EdbSegP &	s2,
		float	dvlim[4],
		float	dvfound[4]
	)

{
  if(&s1==&s2)                                                                return 0;
  if(s1.Flag()==-10)                                                          return 0;
  if(s2.Flag()==-10)                                                          return 0;
  dfound[0] = X(1,s2)  - X(0,s1);  if(Abs(dfound[0]) > dv[0])   return 0;
  dfound[1] = Y(1,s2)  - Y(0,s1);  if(Abs(dfound[1]) > dv[1])   return 0;
  dfound[2] = TX(1,s2) - TX(0,s1); if(Abs(dfound[2]) > dv[2])   return 0;
  dfound[3] = TY(1,s2) - TY(0,s1); if(Abs(dfound[3]) > dv[3])   return 0;
  return 1;
}

Var() [1/2]

float EdbAlignmentV::Var ( int  side, EdbSegP &  s, int  ivar  )

inline

                                                     {switch(ivar) { 
                            case(0): return X(side,s); 
                            case(1): return Y(side,s); 
                            case(2): return TX(side,s); 
                            case(3): return TY(side,s); } return 0;
                            }

Var() [2/2]

float EdbAlignmentV::Var ( int  side, int  iseg, int  ivar  )

inline

{ return Var(side,*((EdbSegP*)eS[side].UncheckedAt(iseg)),ivar); }

X()

float EdbAlignmentV::X ( int  side, EdbSegP &  s  )

inline

Correction parameters handling.

{ return eUseAffCorr? eCorrL[side].X(s)  : eCorr[side].X(s);  }

Xmax() [1/2]

float EdbAlignmentV::Xmax	(	int	side,
		EdbPattern &	p
	)

{
  int n=p.N();  float xmax = 0;
  for(int i=0; i<n; i++) {
     EdbSegP *s = p.GetSegment(i);
     float x=X(side,*s);
     if(!i) xmax=x;     else if( x>xmax) xmax=x;
  }
  return xmax;
}

Xmax() [2/2]

float EdbAlignmentV::Xmax	(	int	side,
		TObjArray &	p
	)

{
  int n=p.GetEntries();  float xmax = 0;
  for(int i=0; i<n; i++) {
     EdbSegP *s = (EdbSegP*)(p.At(i));
     float x=X(side,*s);
     if(!i) xmax=x;     else if( x>xmax) xmax=x;
  }
  return xmax;
}

Xmin() [1/2]

float EdbAlignmentV::Xmin	(	int	side,
		EdbPattern &	p
	)

{
  int n=p.N();  float xmin = 0;
  for(int i=0; i<n; i++) {
     EdbSegP *s = p.GetSegment(i);
     float x=X(side,*s);
     if(!i) xmin=x;     else if( x<xmin) xmin=x;
  }
  return xmin;
}

Xmin() [2/2]

float EdbAlignmentV::Xmin	(	int	side,
		TObjArray &	p
	)

{
  int n=p.GetEntries();  float xmin = 0;
  for(int i=0; i<n; i++) {
     EdbSegP *s = (EdbSegP*)(p.At(i));
     float x=X(side,*s);
     if(!i) xmin=x;     else if( x<xmin) xmin=x;
  }
  return xmin;
}

Y()

float EdbAlignmentV::Y ( int  side, EdbSegP &  s  )

inline

{ return eUseAffCorr? eCorrL[side].Y(s)  : eCorr[side].Y(s);  }

Ymax() [1/2]

float EdbAlignmentV::Ymax	(	int	side,
		EdbPattern &	p
	)

{
  int n=p.N();  float ymax = 0;
  for(int i=0; i<n; i++) {
     EdbSegP *s = p.GetSegment(i);
     float y=Y(side,*s);
     if(!i) ymax=y;     else if( y>ymax) ymax=y;
  }
  return ymax;
}

Ymax() [2/2]

float EdbAlignmentV::Ymax	(	int	side,
		TObjArray &	p
	)

{
  int n=p.GetEntries();  float ymax = 0;
  for(int i=0; i<n; i++) {
     EdbSegP *s = (EdbSegP*)(p.At(i));
     float y=Y(side,*s);
     if(!i) ymax=y;     else if( y>ymax) ymax=y;
  }
  return ymax;
}

Ymin() [1/2]

float EdbAlignmentV::Ymin	(	int	side,
		EdbPattern &	p
	)

{
  int n=p.N();  float ymin = 0;
  for(int i=0; i<n; i++) {
     EdbSegP *s = p.GetSegment(i);
     float y=Y(side,*s);
     if(!i) ymin=y;     else if( y<ymin) ymin=y;
  }
  return ymin;
}

Ymin() [2/2]

float EdbAlignmentV::Ymin	(	int	side,
		TObjArray &	p
	)

{
  int n=p.GetEntries();  float ymin = 0;
  for(int i=0; i<n; i++) {
     EdbSegP *s = (EdbSegP*)(p.At(i));
     float y=Y(side,*s);
     if(!i) ymin=y;     else if( y<ymin) ymin=y;
  }
  return ymin;
}

Member Data Documentation

eCorr

EdbSegCorr EdbAlignmentV::eCorr[2]

corrections for side 1 and 2 (v[7]) - the result of the alignment

eCorrL

EdbLayer EdbAlignmentV::eCorrL[2]

corrections in form of affine transformations - the final output

eDoubletsRate

TH1I* EdbAlignmentV::eDoubletsRate

can be filled in FillCombinations()

eDVsame

Float_t EdbAlignmentV::eDVsame[4]

(dx,dy,dtx,dty) condition for the coinsidence

eH

EdbH1 EdbAlignmentV::eH[2][7]

conditions for the selection procedure for each var of each side variables: dx,dy,dz, dtx,dty, shr, phi 0 1 2 3 4 5 6

eHxy

EdbH2 EdbAlignmentV::eHxy

position 2d histo to be used in OptimiseVar2

eOutputFile

TFile* EdbAlignmentV::eOutputFile

ePC

EdbCell2 EdbAlignmentV::ePC[2]

2-d position cells with patterns segments

eS

TObjArray EdbAlignmentV::eS[2]

"parallel" arrays with the selected combinations of segments

eUseAffCorr

Bool_t EdbAlignmentV::eUseAffCorr

if "true" - use eCorrL for corrections

eXmarg

Float_t EdbAlignmentV::eXmarg

eYmarg

Float_t EdbAlignmentV::eYmarg

margins for the cell definition

---

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

• /home/antonio/fedra_doxygen/src/libAlignment/EdbAlignmentV.h
• /home/antonio/fedra_doxygen/src/libAlignment/EdbAlignmentV.cxx