#include <EdbPlateAlignment.h>

Inheritance diagram for EdbPlateAlignment:

Collaboration diagram for EdbPlateAlignment:

[legend]

Public Member Functions
void	Align (EdbPattern &p1, EdbPattern &p2, float dz, int flag=0)

void	CoarseAl (EdbPattern &p1, EdbPattern &p2)

void	DoubletsFilterOut (EdbPattern &p1, EdbPattern &p2)

	EdbPlateAlignment ()

void	FineAl (EdbPattern &p1, EdbPattern &p2)

void	FineAlAff (EdbPattern &p1, EdbPattern &p2, EdbLayer &la1)

void	ProduceReport ()

void	RankCouples (TObjArray &arr1, TObjArray &arr2)

void	SaveCouplesTree ()

void	SetDoublets (float dx, float dy, float dtx, float dty)

void	SetParCoarseAl (float zcorr, float dpos=300, float dang=0.015, float dz=122, float dphi=0.01)

void	SetParFineAl ()

void	SetParTestAl (float zcorr, float dz=500, float dphi=0.03)

void	SetSigma (float spos, float sang)

void	SlowAlignXY (EdbPattern &p1, EdbPattern &p2, EdbH2 &hxy, EdbH1 &hphi, const char *name="slowal")

void	TestAl (EdbPattern &p1, EdbPattern &p2)

virtual	~EdbPlateAlignment ()

Public Member Functions inherited from EdbAlignmentV
void	AddSegCouple (EdbSegP s1, EdbSegP s2)

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

void	AssignFlagToS (int flag)

Int_t	CalcAffFull ()

Int_t	CalcApplyFractMeanDiff ()

Int_t	CalcApplyMeanDiff ()

Float_t	CalcFractMeanDiff (int ivar, float fraction)

Float_t	CalcMeanDiff (int ivar)

Float_t	CalcMeanDiff2Const (int ivar, int side, float mean)

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	CalculateAffTXTYShift (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	CalculateAffXYShift (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)

void	CorrToCoG (int side, TObjArray &p)

float	CoupleQuality (EdbSegP &s1, EdbSegP &s2)

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

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")

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 ()

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)

void	PrintCorr ()

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)

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 ()

Public Attributes
Int_t	eCoarseMin

Bool_t	eCoarseOK

Bool_t	eDoCoarse

Bool_t	eDoCorrectAngle

Bool_t	eDoCorrectBeforeSaving

Bool_t	eDoFine

Bool_t	eDoTestAl

Float_t	eDoublets [4]

Float_t	eDPHI

Float_t	eDZ

Int_t	eFineMin

Bool_t	eFineOK

EdbPeak2	eH_xy_coarse

EdbPeak2	eH_xy_final

EdbPeak2	eH_zphi_coarse

Int_t	eNcoins

Int_t	eNiter

Bool_t	eNoScale

Bool_t	eNoScaleRot

Float_t	eOffsetMax

Bool_t	eRankCouples

Bool_t	eSaveCouples

TObjArray	eSegCouples

Float_t	eSigma [2]

Bool_t	eStatus

Bool_t	eTestAlOK

Public Attributes inherited from EdbAlignmentV
EdbSegCorr	eCorr [2]

EdbLayer	eCorrL [2]

TH1I *	eDoubletsRate

Float_t	eDVsame [4]

EdbH1	eH [2][7]

EdbH2	eHxy

TFile *	eOutputFile

EdbCell2	ePC [2]

TObjArray	eS [2]

Bool_t	eUseAffCorr

Float_t	eXmarg

Float_t	eYmarg

Additional Inherited Members
Static Public Member Functions inherited from EdbAlignmentV
static Int_t	CheckEqualArr (TObjArray &arr1, TObjArray &arr2)

Constructor & Destructor Documentation

◆ EdbPlateAlignment()

EdbPlateAlignment::EdbPlateAlignment ( )

 {
   SetSigma( 10, 0.005 );
   eOffsetMax = 500.;
   eDZ        = 120;
   eDPHI      = 0.009;
   eDoublets[0]=eDoublets[1]=5;
   eDoublets[2]=eDoublets[3]=0.003;
  
   eStatus   =false;
   eDoTestAl =false; eTestAlOK =true;
   eDoCoarse =true;  eCoarseOK =false;
   eDoFine   =true;  eFineOK   =false;
   eSaveCouples=false;
   eRankCouples=false;
   eDoCorrectBeforeSaving=false;
   eDoCorrectAngle=true;               // keep true for compatibility 
   eNoScale=0;
   
   eNcoins    = 0;
   eCoarseMin = 5;
   eFineMin   = 5;
   eNiter     = 3;
 }

◆ ~EdbPlateAlignment()

EdbPlateAlignment::~EdbPlateAlignment ( )

virtual

 {
   CloseOutputFile();
 }

Member Function Documentation

◆ Align()

void EdbPlateAlignment::Align	(	EdbPattern &	p1,
		EdbPattern &	p2,
		float	dz,
		int	flag = `0`
	)

 {
   // if flag is different from 0 assign it to the selected segments
   //
   eStatus = false;
   eHxy.Delete();
   eH_zphi_coarse.Delete();
   eH_xy_coarse.Delete();
   eH_xy_final.Delete();
  
   Log(2,"EdbPlateAlignment::Align","pattern 1 with %d in limits x:(%12.2f %12.2f) y:(%12.2f %12.2f)",
         p1.N(), p1.Xmin(),p1.Xmax(),p1.Ymin(),p1.Ymax() );
   Log(2,"EdbPlateAlignment::Align","pattern 2 with %d in limits x:(%12.2f %12.2f) y:(%12.2f %12.2f)",
         p2.N(), p2.Xmin(),p2.Xmax(),p2.Ymin(),p2.Ymax() );
   
   if(p1.N()<1||p2.N()<1) return;
   DoubletsFilterOut(p1,p2);
  
   SetParTestAl(dz);
   if(eDoTestAl)     {
     TestAl(p1,p2);
     if(!eTestAlOK)    goto END;
   }
  
   CorrToCoG(1,p2);
  
   if(eDoCoarse) {
     SetParCoarseAl( eCorr[0].V(2) , eOffsetMax, 3*eSigma[1], eDZ, eDPHI );
     CoarseAl(p1,p2);
     if(!eCoarseOK)    goto END;
   }
  
  if(eDoFine) {
     SetParFineAl();
     for(int i=0; i<eNiter; i++)   FineAl(p1,p2);
  
     eUseAffCorr=true;
     Corr2Aff( eCorrL[0] );
  
     for(int i=0; i<eNiter; i++)   FineAlAff(p1,p2,eCorrL[0] );
     eH_xy_final.Init(eHxy);
     if(!eFineOK)    goto END;
   }
   
  END:
  
   if(eRankCouples) {
 //    eCorr[0].SetV(2,0);  eCorr[1].SetV(2, 0); ??
     RankCouples( eS[0], eS[1] );
   }
   ProduceReport();
   if(flag) AssignFlagToS(flag);           // assign particular flag to the selected segments
   if(eSaveCouples) SaveCouplesTree();
 }

◆ CoarseAl()

void EdbPlateAlignment::CoarseAl	(	EdbPattern &	p1,
		EdbPattern &	p2
	)

 {
   // all pars should be already defined
   
   if( Log(3, "CoarseAl","with patterns %d %d", p1.N(), p2.N() ) ) {
     eCorr[0].Print();    eCorr[1].Print();
   }
   FillGuessCell(p1,p2,1.,eOffsetMax);
   FillCombinations( eDVsame, eDVsame[0], eDVsame[1], 1);
   int      n[2] = { eH[0][0].N()   , eH[0][1].N()    };
   float  min[2] = { eH[0][0].Xmin(), eH[0][1].Xmin() };
   float  max[2] = { eH[0][0].Xmax(), eH[0][1].Xmax() };
   eHxy.InitH2(n, min, max);
  
   //OptimiseVar1(0, 6, &eHxy);
   //OptimiseVar1(0, 2, &eHxy);
  
   EdbH2  h_z_phi;
   OptimiseVar2( 0, 6,  0, 2, h_z_phi, &eHxy );  // variate rotation and z of the p1
  
   eH_zphi_coarse.Init(h_z_phi);
  
   EdbPeak2 pk2z(h_z_phi);
   float  dphi, dz;
   pk2z.FindPeak( dphi, dz );
   pk2z.ProbPeak();
   eCorr[0].SetV(2, dz  );
   eCorr[0].SetV(6, dphi);
  
   Ncoins(eDVsame, &eHxy);
   Log(2,"CoarseAl","DVsame: %s",StrDVsame()); 
   eH_xy_coarse.Init(eHxy);
  
   EdbPeak2 pk2(eHxy);
   float  dx, dy;
   int npk = (int)pk2.FindPeak9( dx, dy );
   eCorr[0].AddV(0,dx);   eCorr[0].AddV(1,dy);
   pk2.ProbPeak();
   //pk2.Print();
  
   Log(2,"CoarseAl","%d coins with peak of %d/%6.3f with offsets (dx:dy:dz:dphi): %7.2f %7.2f %8.2f %7.3f  with patterns of: %d %d", 
       npk, (int)pk2.ePeak[0], pk2.eMean[0],
       eCorr[0].V(0)-eCorr[1].V(0), eCorr[0].V(1)-eCorr[1].V(1), eCorr[0].V(2), eCorr[0].V(6), 
       p1.N(),p2.N() );
  
   if(npk>3)  eCoarseOK = true;
   else       eCoarseOK = false;
 }

◆ DoubletsFilterOut()

void EdbPlateAlignment::DoubletsFilterOut	(	EdbPattern &	p1,
		EdbPattern &	p2
	)

 {
   EdbAlignmentV adup;
   for(int i=0; i<4; i++) adup.eDVsame[i]=eDoublets[i];
   
   adup.FillGuessCell(p1,p1,1.,eOffsetMax);
   adup.FillCombinations();
   adup.DoubletsFilterOut(0);   // assign flag -10 to the duplicated segments
  
   adup.FillGuessCell(p2,p2,1.,eOffsetMax);
   adup.FillCombinations();
   adup.DoubletsFilterOut(0);   // assign flag -10 to the duplicated segments
 }

◆ FineAl()

void EdbPlateAlignment::FineAl	(	EdbPattern &	p1,
		EdbPattern &	p2
	)

 {
   Log(3, "FineAl","with patterns %d %d", p1.N(), p2.N() );
   FillGuessCell(p1,p2,1.,eOffsetMax);
   float dxlim = eH[0][0].Xmax()-eH[0][0].Xmin();
   float dylim = eH[0][1].Xmax()-eH[0][1].Xmin();
  
   eDVsame[0] = dxlim/2.;  eDVsame[1] = dylim/2.;
   //eDVsame[0] = dxlim;  eDVsame[1] = dylim;
  
   //eDVsame[2]=eDVsame[3]=0.01;
   eDVsame[2]=eDVsame[3]=3.*eSigma[1];
   FillCombinations( eDVsame, dxlim, dylim, 1);
  
   int      n[2] = { 9,9 };
   float  min[2] = { eH[0][0].Xmin(), eH[0][1].Xmin() };
   float  max[2] = { eH[0][0].Xmax(), eH[0][1].Xmax() };
   eHxy.InitH2(n, min, max);
  
   for(int i=0; i<3; i++) FindCorrDiff(eDVsame);
  
   TObjArray sel1,sel2;
   Ncoins(eDVsame, &eHxy, 0, &sel1, &sel2);
  
   if( eDZ>0.0001 ) {
     for(int i=0; i<3; i++) {
       float dz = FineCorrZ(sel1,sel2);
       eCorr[0].AddV(2,dz);
     }
   }
   
 //   for(int i=0; i<3; i++) {
 //     float dphi = FineCorrPhi(sel1,sel2);
 //     eCorr[0].AddV(6,dphi);
 //   }
  
   int npk=Ncoins(eDVsame, &eHxy);
  
   Log(2,"FineAl","peak of %d with offsets (dx:dy:dz:dphi): %7.2f %7.2f %8.2f %7.3f  with patterns of: %d %d", 
       npk, 
       eCorr[0].V(0)-eCorr[1].V(0), eCorr[0].V(1)-eCorr[1].V(1), eCorr[0].V(2), eCorr[0].V(6), 
       p1.N(),p2.N() );
  
  
   if(npk>3)  eFineOK = true;
   else       eFineOK = false;
 }

◆ FineAlAff()

void EdbPlateAlignment::FineAlAff	(	EdbPattern &	p1,
		EdbPattern &	p2,
		EdbLayer &	la1
	)

 {
   // assuming that the patterns are already aligned with the accuracy of a few 
   // microns or the corrections are setted.
   // find affine transfornations
   Log(3, "FineAlAff","with patterns %d %d", p1.N(), p2.N() );
   FillGuessCell(p1,p2,1.,eOffsetMax);
   float dxlim = eH[0][0].Xmax()-eH[0][0].Xmin();
   float dylim = eH[0][1].Xmax()-eH[0][1].Xmin();
  
   eDVsame[0] = dxlim/2.;  eDVsame[1] = dylim/2.;
   //eDVsame[0] = dxlim;  eDVsame[1] = dylim;
   eDVsame[2]=eDVsame[3]=3.*eSigma[1];
   FillCombinations( eDVsame, dxlim, dylim, 1);
  
   int      n[2] = { 9,9 };
   float  min[2] = { eH[0][0].Xmin(), eH[0][1].Xmin() };
   float  max[2] = { eH[0][0].Xmax(), eH[0][1].Xmax() };
   eHxy.InitH2(n, min, max);
  
   TObjArray sel1, sel2;
   int npk= Ncoins(eDVsame, &eHxy, 0, &sel1, &sel2);
   EdbAffine2D aff;
   if(eNoScale)         CalculateAffXYTurn(sel1,sel2,aff);
   else if(eNoScaleRot) CalculateAffXYShift(sel1,sel2,aff);
   else                 CalculateAffXY(sel1,sel2,aff);
   la1.GetAffineXY()->Transform(&aff);
   
   if(eDoCorrectAngle) {
     EdbAffine2D afftxty;
     CalculateAffTXTYTurn(sel1,sel2,afftxty);
     la1.GetAffineTXTY()->Transform(&afftxty);
   }
   
   Log(2,"FineAlAff","peak of %d  with patterns of: %d %d",  npk, p1.N(),p2.N() );
   if(gEDBDEBUGLEVEL>2)  la1.GetAffineXY()->Print();
  
   if(npk>3)  eFineOK = true;
   else       eFineOK = false;
 }

◆ ProduceReport()

void EdbPlateAlignment::ProduceReport ( )

 {
   TH2F *zphiCoarse=0, *xyCoarse=0;
   TH2F *xyFine=0;
   gStyle->SetPalette(1);
   if( eDoTestAl&&eTestAlOK ) {
     Log(1,"Alignment Report","TestAl OK");
   }
   if( eDoCoarse&&eCoarseOK ) {
     zphiCoarse = eH_zphi_coarse.DrawH2("zphi_coarse", "Z vs Phi after coarse align");
     xyCoarse   = eH_xy_coarse.DrawH2("xy_coarse", "dY vs dX after coarse align");
     float dx,dy;
     int npk = (int)eH_xy_coarse.FindPeak9( dx, dy );
     eH_xy_coarse.ProbPeak();
  
     if     (npk<eCoarseMin)                       eStatus = false;   // too few coinsidences
     else if(npk < 3*Sqrt(eH_xy_coarse.eMean[0]) ) eStatus = false;   // too small signal/noise
     else                                          eStatus = true;    // good alignment
  
     if(eStatus) 
       Log(2,"Alignment Report","Coarse %s: %d coins with peak of %d/%6.3f","OK",
       npk, (int)eH_xy_coarse.ePeak[0], eH_xy_coarse.eMean[0]);    
     else {
       Log(1,"Alignment Report","Coarse %s: %d coins with peak of %d/%6.3f","FAILED!",
       npk, (int)eH_xy_coarse.ePeak[0], eH_xy_coarse.eMean[0]);
       return;
     }
   }
  
  
   if( eDoFine&&eFineOK ) {
     xyFine = eH_xy_final.DrawH2("xy_final","dY vs dX after final alignment");
     eNcoins = eH_xy_final.Integral();
     if( eNcoins < eFineMin )               eStatus = false;   // too few coinsidences
     else                                   eStatus = true;    // good alignment
  
      if(eStatus) 
        Log(2,"Alignment Report","Fine   %s: %d coins inside (%6.1f %6.1f) with angular acc: (%6.3f %6.3f)", "OK",
     (int)(eH_xy_final.Integral()), 
     eH_xy_final.Xmax()-eH_xy_final.Xmin(),eH_xy_final.Ymax()-eH_xy_final.Ymin(),
     eDVsame[2], eDVsame[3] );
      else {
        Log(2,"Alignment Report","Fine   %s: %d coins inside (%6.1f %6.1f) with angular acc: (%6.3f %6.3f)", "FAILED!",
     (int)(eH_xy_final.Integral()), 
     eH_xy_final.Xmax()-eH_xy_final.Xmin(),eH_xy_final.Ymax()-eH_xy_final.Ymin(),
     eDVsame[2], eDVsame[3] );
     return;
      }
   }
  
     EdbAffine2D *aXY = eCorrL[0].GetAffineXY();
     float xcenter1 = (ePC[0].Xmin()+ePC[0].Xmax())/2.;
     float ycenter1 = (ePC[0].Ymin()+ePC[0].Ymax())/2.;
     float xoffset= aXY->A11()*xcenter1 + aXY->A12()*ycenter1 + aXY->B1() - xcenter1;
     float yoffset= aXY->A21()*xcenter1 + aXY->A22()*ycenter1 + aXY->B2() - ycenter1;
     
     eCorrL[0].SetXY( xcenter1, ycenter1 );
     
     const char *str = Form( "Nfinal= %5d    Peak: %5d/%6.3f    dx,dy,dz = %7.3f  %7.3f %7.3f",
                 eS[0].GetEntries(),(int)eH_xy_coarse.ePeak[0], eH_xy_coarse.eMean[0], 
                 xoffset, yoffset, eCorrL[0].Zcorr() );
     Log(1,"Alignment Report","%s", str);
  
   if(eOutputFile) {
     Log(2,"Alignment Report","Save to file %s", eOutputFile->GetName());
     gStyle->SetPalette(1);
     bool batch = gROOT->IsBatch();
     gROOT->SetBatch();
     
     TCanvas *cc = new TCanvas("cc","Alignment report",800,800);
     
     
     TPaveText *ctit = new TPaveText(0.01,0.943,0.99,0.998);
     ctit->AddText( Form("Alignment of  %s",eOutputFile->GetName()) );
     ctit->AddText( str );
     ctit->Draw();
     
     TPad *c = new TPad("c","plots",0.01,0.05,0.99,0.94);
     c->Divide(3,3);
     c->Draw();
     TH2F *hp1 = ePC[0].DrawH2("hp1","Pattern1"); c->cd(1); hp1->SetStats(0); hp1->Draw("colz");
     TH2F *hp2 = ePC[1].DrawH2("hp2","Pattern2"); c->cd(2); hp2->SetStats(0); hp2->Draw("colz");
     if(zphiCoarse)  { c->cd(3); zphiCoarse->SetStats(0); zphiCoarse->Draw("colz"); }
     if(xyCoarse)    { c->cd(4); xyCoarse->SetStats(0);   xyCoarse->Draw("colz");   }
     if(xyFine)      { c->cd(5); xyFine->SetStats(0);     xyFine->Draw("colz");     }
  
  
     float xmin = Min( ePC[0].Xmin(), ePC[1].Xmin() );
     float xmax = Max( ePC[0].Xmax(), ePC[1].Xmax() );
     float ymin = Min( ePC[0].Ymin(), ePC[1].Ymin() );
     float ymax = Max( ePC[0].Ymax(), ePC[1].Ymax() );
  
     Log(2,"Alignment Report","xmax-xmin: %f (%f-%f) ymax-ymin: %f (%f-%f)", 
     (xmax-xmin),xmax,xmin, (ymax-ymin),ymax,ymin);
  
  
     int n = CheckEqualArr(eS[0],eS[1]);
  
     c->cd(6);
  
     TH2I *hdtxy  = new TH2I("dTXdTY","dTY vs dTX after final alignment",25,-3*eSigma[1], 3*eSigma[1], 25, -3*eSigma[1], 3*eSigma[1]);
     for(int i=0; i<n; i++) {
       EdbSegP *s1 = (EdbSegP*)eS[0].UncheckedAt(i);
       EdbSegP *s2 = (EdbSegP*)eS[1].UncheckedAt(i);
       float dtx  =   TX(1,*s2) - TX(0,*s1);
       float dty  =   TY(1,*s2) - TY(0,*s1);
       hdtxy->Fill(dtx,dty);
     }
     hdtxy->SetStats(0); hdtxy->Draw("colz");
  
     c->cd(8);
  
     TH2I *h2  = new TH2I("plateXY","plateXY",100,xmin-10, xmax+10, 100, ymin-10,ymax+10);
     h2->SetStats(0);
     h2->Draw();
  
     if(n<1000) {
       for(int i=0; i<n; i++) {
         EdbSegP *s1 = (EdbSegP*)eS[0].UncheckedAt(i);
         EdbSegP *s2 = (EdbSegP*)eS[1].UncheckedAt(i);
         float x1  =  X(0,*s1),  y1 =  Y(0,*s1);
         float x2  =  X(1,*s2),  y2 =  Y(1,*s2);
         TMarker *m1 = new TMarker(x1,y1,22);
         m1->SetMarkerColor(kRed);
         m1->SetMarkerSize(0.6);
         m1->Draw();
         TMarker *m2 = new TMarker(x2,y2,23);
         m2->SetMarkerColor(kBlue);
         m2->SetMarkerSize(0.6);
         m2->Draw();
       }
     }
  
     c->cd(9);
     TH2I *h2t = new TH2I("plateTXTY","plateTXTY",100,-1, 1, 100, -1,1 );
     h2t->SetStats(0);
     h2t->Draw();
     if(n<1000) {
       for(int i=0; i<n; i++) {
         EdbSegP *s1 = (EdbSegP*)eS[0].UncheckedAt(i);
         EdbSegP *s2 = (EdbSegP*)eS[1].UncheckedAt(i);
         float tx1 =  TX(0, *s1), ty1 =  TY(0, *s1);
         float tx2 =  TX(1, *s2), ty2 =  TY(1, *s2);
         TMarker *m1 = new TMarker(tx1,ty1,22);
         m1->SetMarkerColor(kRed);
         m1->SetMarkerSize(0.6);
         m1->Draw();
         TMarker *m2 = new TMarker(tx2,ty2,23);
         m2->SetMarkerColor(kBlue);
         m2->SetMarkerSize(0.6);
         m2->Draw();
       }
     }
     
  
     c->cd(7);
     int nbin=25;
     TArrayF xbins(nbin+1);
     xbins[0]= 0.15;
     float s0 = xbins[0]*xbins[0];
     for(int i=1; i<nbin+1; i++) xbins[i] = Sqrt( xbins[i-1]*xbins[i-1] + s0 );
  
     TH1F *thetadens = new TH1F("thetadens","theta density",nbin,xbins.GetArray() );
     for(int i=0; i<n; i++) {
       //EdbSegP *s1 = (EdbSegP*)eS[0].UncheckedAt(i);
       EdbSegP *s2 = (EdbSegP*)eS[1].UncheckedAt(i);
       float tx  =   TX(1,*s2), ty  =   TY(1,*s2);
       float theta = Sqrt(tx*tx+ty*ty);
       thetadens->Fill(theta);
     }
     thetadens->Draw();
  
     eH_xy_coarse.Write("peak2c");
     cc->Write("report_al");
     eCorrL[0].Write("corr_layer1");
     eCorrL[1].Write("corr_layer2");
     SafeDelete(c);
     
     SafeDelete(cc);
     
     gROOT->SetBatch(batch);
   }
  
   SafeDelete(zphiCoarse);
   SafeDelete(xyCoarse);
   SafeDelete(xyFine);
 }

◆ RankCouples()

void EdbPlateAlignment::RankCouples	(	TObjArray &	arr1,
		TObjArray &	arr2
	)

 {
   int n = arr1.GetEntries();
   Log(3,"RankCouples","%d" ,n);
  
   EdbTrackFitter tf;
   EdbScanCond cond;
   cond.SetSigma0(eSigma[0],eSigma[0],eSigma[1],eSigma[1]);
   eSegCouples.Delete();
   EdbSegP seg, seg1, seg2;
   for(int i=0; i<n; i++) {
     EdbSegP *s1 = ((EdbSegP*)arr1.UncheckedAt(i));
     EdbSegP *s2 = ((EdbSegP*)arr2.UncheckedAt(i));
     
     seg.Copy(*s1);   // to set correctly vid, aid, etc
     seg1.Copy(*s1);
     seg2.Copy(*s2);
     
     eCorr[0].ApplyCorrections(seg1);
     eCorr[1].ApplyCorrections(seg2);
    
     tf.Chi2PSeg( seg1, seg2, seg, cond, cond);
     
     s1->SetFlag(0);
     s2->SetFlag(0);
     seg.SetFlag(0);
     seg.SetSide(0);
     seg.SetVolume(seg1.Volume()+seg2.Volume());
     seg.SetDZ( Abs(seg1.eZ - seg2.eZ) );
     
     seg.SetDZem( seg1.Chi2() + seg2.Chi2() );    // HACK: use eDZem variable to keep microtracking Likelihood 
     
     EdbSegCouple *sc=new EdbSegCouple();
     sc->eS1=s1;
     sc->eS2=s2;
     sc->eS = new EdbSegP(seg);
     sc->SetCHI2P( seg.Chi2() );
     eSegCouples.Add(sc);
   }
  
   EdbSegCouple::SetSortFlag(0);    // sort by CHI2P
   eSegCouples.UnSort();
   eSegCouples.Sort();
  
   int ncp = eSegCouples.GetEntries();
  
   for(int i=0; i<ncp; i++) {
     EdbSegCouple *sc = (EdbSegCouple*)(eSegCouples.UncheckedAt(i));
     sc->eS1->SetFlag( sc->eS1->Flag()+1 );
     sc->eS2->SetFlag( sc->eS2->Flag()+1 );
     sc->SetN1(sc->eS1->Flag());
     sc->SetN2(sc->eS2->Flag());
   }
  
   for(int i=0; i<ncp; i++) {
     EdbSegCouple *sc = (EdbSegCouple*)(eSegCouples.UncheckedAt(i));
     sc->SetN1tot(sc->eS1->Flag());
     sc->SetN2tot(sc->eS2->Flag());
   }
  
   Log(2,"RankCouples","%d couples ok", ncp );
 }

◆ SaveCouplesTree()

void EdbPlateAlignment::SaveCouplesTree ( )

 {
   EdbCouplesTree ect;
   ect.InitCouplesTree("couples",0,"NEW");
   int nseg = CheckEqualArr(eS[0],eS[1]);
   for(int i=0; i<nseg; i++)
     if(eDoCorrectBeforeSaving) eCorrL[0].CorrectSeg(*(EdbSegP*)eS[0].UncheckedAt(i));
   for(int i=0; i<nseg; i++) {
     if( eRankCouples ) {
       EdbSegCouple *sc = (EdbSegCouple *)eSegCouples.At(i);
       ect.Fill( sc->eS1, sc->eS2, sc->eS, sc );
     }
     else ect.Fill( (EdbSegP*)eS[0].UncheckedAt(i), (EdbSegP*)eS[1].UncheckedAt(i) );
   }
   ect.eTree->AutoSave();
 }

◆ SetDoublets()

void EdbPlateAlignment::SetDoublets	(	float	dx,
		float	dy,
		float	dtx,
		float	dty
	)

inline

58 { eDoublets[0]=dx; eDoublets[1]=dy; eDoublets[2]=dtx; eDoublets[3]=dty; }

◆ SetParCoarseAl()

void EdbPlateAlignment::SetParCoarseAl	(	float	zcorr,
		float	dpos = `300`,
		float	dang = `0.015`,
		float	dz = `122`,
		float	dphi = `0.01`
	)

 {
   // medium-wide parameters setting for the coarse alignment
   Log(3,"EdbPlateAlignment::SetParCoarseAl","zcorr = %f  dpos = %f dang=%f  dz=%f  dphi=%f",zcorr, dpos, dang, dz, dphi);
   eDVsame[0] = eDVsame[1] = dpos;
   //eDVsame[0] = eDVsame[1] = 3*eSigma[0];
   eDVsame[2] = eDVsame[3] = dang;
   int n = (int)( 2*dpos/ (4*eSigma[0]) );
   n = n%2 ? n : n+1;              // make n - odd
   Log(3, "SetParCoarseAl"," n = %d dpos = %f ", n, dpos);
   InitHx(   n,  -dpos,   dpos   );
   InitHy(   n,  -dpos,   dpos   );
  
   float zstepmin=0.5;   // 0.5 microns is the minimum step size
   int nz = Min( (int)( 2*dz/ zstepmin ), 51);
   nz = nz%2 ? nz : nz+1;              // make n - odd
   InitHz(   nz,  zcorr-dz, zcorr+dz );
   eCorr[0].SetV(2,zcorr);
  
   float phimin=0.00001;   // minimum step size
   int nphi = Min( (int)( 2*dphi/ phimin ), 51);
   nphi = nphi%2 ? nphi : nphi+1;             // make n - odd
   InitHphi( nphi,  eCorr[0].V(6)-dphi,   eCorr[0].V(6)+dphi );
 }

◆ SetParFineAl()

void EdbPlateAlignment::SetParFineAl ( )

 {
   // narrow parameters setting for the fine alignment
   InitHx(   1,  -4.*eSigma[0],   4.*eSigma[0]   );
   InitHy(   1,  -4.*eSigma[0],   4.*eSigma[0]   );
 }

◆ SetParTestAl()

void EdbPlateAlignment::SetParTestAl	(	float	zcorr,
		float	dz = `500`,
		float	dphi = `0.03`
	)

 {
   // wide parameters setting for the test pre-alignment
   InitHx(   81,  -2000,   2000   );
   InitHy(   81,  -2000,   2000   );
   int nbinz = Min(101, Max(21, (int)(dz/50.) ));
   InitHz(   nbinz,   zcorr-dz, zcorr+dz );
   int nbinphi = Min(101, Max(21, (int)(dphi/0.0001) ));
   InitHphi( nbinphi,  -dphi,   dphi   );
   eCorr[0].SetV(2,zcorr);
 }

◆ SetSigma()

void EdbPlateAlignment::SetSigma	(	float	spos,
		float	sang
	)

inline

56 { eSigma[0]=spos; eSigma[1]=sang; }

◆ SlowAlignXY()

void EdbPlateAlignment::SlowAlignXY	(	EdbPattern &	p1,
		EdbPattern &	p2,
		EdbH2 &	hxy,
		EdbH1 &	hphi,
		const char *	name = `"slowal"`
	)

 {
   int n1= pat1.N();
   int n2= pat2.N();
   float x0 = (Min(pat1.Xmin(),pat2.Xmin())+Max(pat1.Xmax(),pat2.Xmax()))/2;
   float y0 = (Min(pat1.Ymin(),pat2.Ymin())+Max(pat1.Ymax(),pat2.Ymax()))/2;
   struct point{ int i; float x; float y; };
   point **p1 = new point*[n1];
   point **p2 = new point*[n2];
  
   std::unique_ptr<TFile> f(TFile::Open(name,"RECREATE"));
   if (!f || f->IsZombie())  Log(1,"EdbPlateAlignment::SlowAlignXY","ERROR! can not open file %s", name);
  
   TNtuple *ntpeak = new TNtuple("ntpeak","","phi:dx:dy:peak");  
   for(int i=0; i<n1; i++)     p1[i] = new point;
   for(int i=0; i<n2; i++)     p2[i] = new point;
   
   for(int iphi=0; iphi<hphi.N(); iphi++) {
     float phi=hphi.X(iphi);
     for(int i=0; i<n1; i++) {
       EdbSegP *s= pat1.GetSegment(i);
       p1[i]->x = (s->X()-x0)*Cos(phi) - (s->Y()-y0)*Sin(phi);
       p1[i]->y = (s->X()-x0)*Sin(phi) + (s->Y()-y0)*Cos(phi);
       p1[i]->i = i;
     }
     for(int i=0; i<n2; i++) {
       EdbSegP *s= pat2.GetSegment(i);
       p2[i]->x = (s->X()-x0); 
       p2[i]->y = (s->Y()-y0); 
       p2[i]->i = i;
     }
  
     for(int i1=0; i1<n1; i1++) {
       for(int i2=0; i2<n2; i2++) {
         float dx= p2[i2]->x-p1[i1]->x;
         float dy= p2[i2]->y-p1[i1]->y;
         hxy.Fill(dx,dy);
       }
     }
     EdbPeak2 pk2(hxy);
     float  dx, dy;
     int npk = pk2.FindPeak( dx, dy );
     printf("phi = %f  dx = %f dy = %f  npk = %d\n",phi,dx,dy,npk);
     hphi.Fill(phi,npk);
     ntpeak->Fill(phi,dx,dy,npk);
     hxy.Write(Form("hxy%d",iphi));
     hxy.CleanCells();
   }
   hphi.Write("hphi");
   ntpeak->Write();
 }

◆ TestAl()

void EdbPlateAlignment::TestAl	(	EdbPattern &	p1,
		EdbPattern &	p2
	)

 {
   // alignment of 2 plates with testal-like preselection. 
   // Application: basetracks patterns with: well defined angles, big possible offsets, 
   // big possible rotations; z-variation
   // Result: find best dz and rotation and position offset and set them as: 
   // eCorr[0].SetV(2, dz),  eCorr[0].SetV(6, dphi); eCorr[0].AddV(0, dx); eCorr[0].AddV(1, dy);
  
   float dxlim = eH[0][0].Xmax()-eH[0][0].Xmin();
   float dylim = eH[0][1].Xmax()-eH[0][1].Xmin();
   HDistance(p1,p2, dxlim, dylim );
  
   float x0 = p2.Xmean(), y0 = p2.Ymean();           // centralize patterns
   eCorr[0].SetV(0,-x0);  eCorr[0].SetV(1,-y0);
   eCorr[1].SetV(0,-x0);  eCorr[1].SetV(1,-y0);
     
   int      n[2] = { eH[0][0].N()   , eH[0][1].N()        };
   float  min[2] = { eH[0][0].Xmin(), eH[0][1].Xmin() };
   float  max[2] = { eH[0][0].Xmax(), eH[0][1].Xmax() };
   eHxy.InitH2(n, min, max);
  
   eDVsame[0] = dxlim/2.;
   eDVsame[1] = dylim/2.;
   eDVsame[2]=eDVsame[3]=eSigma[1];
  
   EdbH2  h_z_phi;
   OptimiseVar2( 0, 6,  0, 2, h_z_phi, &eHxy );  // variate rotation and z of the p1
  
   h_z_phi.DrawH2()->Draw("colz");
  
   EdbPeak2 pk2z(h_z_phi);
   float  dphi, dz;
   pk2z.FindPeak( dphi, dz );
   pk2z.ProbPeak();
  
   eCorr[0].SetV(2, dz  );
   eCorr[0].SetV(6, dphi);
  
   Ncoins(eDVsame, &eHxy);
   EdbPeak2 pk2(eHxy);
   float  dx, dy;
   pk2.FindPeak( dx, dy );
   pk2.ProbPeak();
   eCorr[0].AddV(0,dx);      // set x-y corrections
   eCorr[0].AddV(1,dy);
  
   Log(2,"TestAl","peak of %d/%6.3f with offsets (dx:dy:dz:dphi): %7.2f %7.2f %8.2f %7.3f  with patterns of: %d %d", 
       (int)pk2.ePeak[0], pk2.eMean[0], 
       eCorr[0].V(0)-eCorr[1].V(0), eCorr[0].V(1)-eCorr[1].V(1), eCorr[0].V(2), eCorr[0].V(6), 
       p1.N(),p2.N() );
 }

Member Data Documentation

◆ eCoarseMin

Int_t EdbPlateAlignment::eCoarseMin

◆ eCoarseOK

Bool_t EdbPlateAlignment::eCoarseOK

◆ eDoCoarse

Bool_t EdbPlateAlignment::eDoCoarse

◆ eDoCorrectAngle

Bool_t EdbPlateAlignment::eDoCorrectAngle

◆ eDoCorrectBeforeSaving

Bool_t EdbPlateAlignment::eDoCorrectBeforeSaving

◆ eDoFine

Bool_t EdbPlateAlignment::eDoFine

◆ eDoTestAl

Bool_t EdbPlateAlignment::eDoTestAl

◆ eDoublets

Float_t EdbPlateAlignment::eDoublets[4]

◆ eDPHI

Float_t EdbPlateAlignment::eDPHI

◆ eDZ

Float_t EdbPlateAlignment::eDZ

◆ eFineMin

Int_t EdbPlateAlignment::eFineMin

◆ eFineOK

Bool_t EdbPlateAlignment::eFineOK

◆ eH_xy_coarse

EdbPeak2 EdbPlateAlignment::eH_xy_coarse

◆ eH_xy_final

EdbPeak2 EdbPlateAlignment::eH_xy_final

◆ eH_zphi_coarse

EdbPeak2 EdbPlateAlignment::eH_zphi_coarse

◆ eNcoins

Int_t EdbPlateAlignment::eNcoins

◆ eNiter

Int_t EdbPlateAlignment::eNiter

◆ eNoScale

Bool_t EdbPlateAlignment::eNoScale

◆ eNoScaleRot

Bool_t EdbPlateAlignment::eNoScaleRot

◆ eOffsetMax

Float_t EdbPlateAlignment::eOffsetMax

◆ eRankCouples

Bool_t EdbPlateAlignment::eRankCouples

◆ eSaveCouples

Bool_t EdbPlateAlignment::eSaveCouples

◆ eSegCouples

TObjArray EdbPlateAlignment::eSegCouples

◆ eSigma

Float_t EdbPlateAlignment::eSigma[2]

◆ eStatus

Bool_t EdbPlateAlignment::eStatus

◆ eTestAlOK

Bool_t EdbPlateAlignment::eTestAlOK

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

src/libAlignment/EdbPlateAlignment.h
src/libAlignment/EdbPlateAlignment.cxx

Public Member Functions

Public Attributes

Additional Inherited Members