EdbCorrectionMapper Class Reference

to calculate correction map More...

#include <EdbCorrectionMapper.h>

Inheritance diagram for EdbCorrectionMapper:

Collaboration diagram for EdbCorrectionMapper:

Public Member Functions
void	AddSegCouple (EdbSegP *s1, EdbSegP *s2)
void	CalculateCorrections ()
TCanvas *	DrawMap (EdbCorrectionMap &map, const char *suffix="")
TCanvas *	DrawSum (const char *suffix)
	EdbCorrectionMapper ()
void	Fill (EdbSegP &s1, EdbSegP &s2)
void	FillS (EdbSegP *s1, EdbSegP *s2)
EdbCorrectionBin *	GetBin (float x, float y)
EdbCorrectionBin *	GetBin (int i)
int	InitMap (int nx, float minx, float maxx, int ny, float miny, float maxy)
void	MakeCorrectionsTable ()
EdbH2 *	MapDV (int ivar)
EdbH2 *	MapDZ ()
void	SetCorrDZ ()
void	SmoothCorrections ()
void	UpdateLayerWithLocalCorr (EdbLayer &la)
void	Write (const char *suffix="")
virtual	~EdbCorrectionMapper ()
Public Member Functions inherited from EdbCorrectionBin
void	AddBin (EdbCorrectionBin &bin)
virtual void	AddSegCouple (EdbSegP *s1, EdbSegP *s2)
virtual void	CalculateCorrections ()
	EdbCorrectionBin ()
virtual	~EdbCorrectionBin ()

Public Attributes
EdbH2	eHdtxy
	dtxdty More...
EdbH2	eHdty_ty
EdbH2	eHdxy
	dxdy More...
EdbH1	eHdz
	dz More...
EdbH1	eHshr
EdbH2	eHtxty1
EdbH2	eHtxty2
EdbH2	eHxy1
EdbH2	eHxy2
EdbID	eID1
EdbID	eID2
EdbCorrectionMap	eMap
	result: corrections map More...
EdbCell2	eMapAl
	working object with local alignments More...
int	eNcpMin
	min number of coincidences to accept correction More...
float	eZ1
float	eZ2
Public Attributes inherited from EdbCorrectionBin
EdbAlignmentV	eAl
EdbLayer	eLayer

Detailed Description

to calculate correction map

Constructor & Destructor Documentation

EdbCorrectionMapper()

EdbCorrectionMapper::EdbCorrectionMapper

(

)

{
  eNcpMin = 100;
}

~EdbCorrectionMapper()

EdbCorrectionMapper::~EdbCorrectionMapper ( )

virtual

{
}

Member Function Documentation

AddSegCouple()

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

virtual

Reimplemented from EdbCorrectionBin.

{
  EdbCorrectionBin::AddSegCouple(s1,s2);
  EdbCorrectionBin *bin = GetBin(s1->X(),s1->Y());
  if(bin) bin->AddSegCouple(s1,s2);
}

CalculateCorrections()

void EdbCorrectionMapper::CalculateCorrections ( )

virtual

Reimplemented from EdbCorrectionBin.

{
   EdbCorrectionBin::CalculateCorrections();
   int n=eMapAl.Ncell();
   for(int i=0;i<n; i++) {
      EdbCorrectionBin *bin = GetBin(i);
      bin->CalculateCorrections();
  }
}

DrawMap()

TCanvas * EdbCorrectionMapper::DrawMap	(	EdbCorrectionMap &	map,
		const char *	suffix = ""
	)

{
  TCanvas   *corrmap = new TCanvas( Form("corrmap_%s",suffix), Form("corrmap_%s %s -> %s: %d",suffix, eID1.AsString(), eID2.AsString(), map.Ncp() ), 800,800 );
  corrmap->SetRightMargin(0.14);
  corrmap->SetLeftMargin(0.08);
  corrmap->SetFillColor(3);
  TH2F *h2f = map.DrawH2( Form("mapDZ_%s" ,suffix), corrmap->GetTitle() );
  h2f->GetXaxis()->SetLabelSize(0.025);
  h2f->GetYaxis()->SetLabelSize(0.025);
  h2f->GetZaxis()->SetLabelSize(0.025);
 
  int n=map.Ncell();
  for( int i=0; i<n; i++ ) {
    EdbSegCorr scorr = map.CorrLoc(i);
    h2f->Fill(map.Xj(i), map.Yj(i), scorr.V(2)-1);
  }
  h2f->Draw("colz");
    
  float xbin = map.Xbin();
  float ybin = map.Ybin();
  float scalexy = 300.;
  float scaletxty = 100000.;
  for( int i=0; i<n; i++ ) {
    EdbSegCorr scorr = map.CorrLoc(i);
    if(map.GetLayer(i)->Ncp()>0) {
      float dx   = scorr.V(0);
      float dy   = scorr.V(1);
      float dtx  = scorr.V(3);
      float dty  = scorr.V(4);
       
      float x = map.Xj(i);
      float y = map.Yj(i);
 
      TArrow *arrowxy = new TArrow(x,y,x+scalexy*dx,y+scalexy*dy,0.005);
      arrowxy->SetLineWidth(2);
      arrowxy->SetLineColor(1);
      arrowxy->Draw();
       
      TArrow *arrowtxty = new TArrow(x,y,x+scaletxty*dtx,y+scaletxty*dty,0.005);
      arrowtxty->SetLineWidth(2);
      arrowtxty->SetLineColor(0);
      arrowtxty->Draw();
       
      TText *t = new TText(x-xbin/3,y-ybin/2.5,Form("%d",map.GetLayer(i)->Ncp()));
      t->SetTextSize(0.02);
      t->Draw();
    }
  }
 
    // Draw scale
  float x= map.Xj(0)+xbin/6;
  float y= map.Yj(0)+ybin/6;
  TArrow *arrowxy = new TArrow(x,y,x+scalexy*10,y,0.005);
  arrowxy->SetLineWidth(3);
  arrowxy->SetLineColor(1);
  arrowxy->Draw();
  TText *text = new TText(x,y+ybin/10,"10 microns");
  text->SetTextSize(0.02);
  text->Draw();
    
    //x= map.Xj(0)+xbin/6 + scalexy*10 + xbin/6;
  x= map.Xj(0)+xbin/6;
  y= map.Yj(0)+ybin/6 + ybin;
  TArrow *arrowtxty = new TArrow(x,y,x+scaletxty*0.01,y,0.005);
  arrowtxty->SetLineWidth(3);
  arrowtxty->SetLineColor(0);
  arrowtxty->Draw();
  TText *textt = new TText(x,y+ybin/10,"10 mrad");
  textt->SetTextSize(0.02);
  textt->Draw();
 
  return corrmap;
}

DrawSum()

TCanvas * EdbCorrectionMapper::DrawSum

(

const char *

suffix

)

{
    gStyle->SetPalette(1);
    gStyle->SetOptStat(0);
    gStyle->SetOptDate(1);
 
    TCanvas   *csum = new TCanvas( Form("csum_%s",suffix), Form("csum_%s",suffix), 800,960 );
    TPaveText *tsum = new TPaveText(0.01,0.943,0.99,0.998);
    tsum->AddText( Form("%s -> %s", eID1.AsString(), eID2.AsString() ) );
    tsum->AddText( Form("z2-z1 = %12.1f -  %12.1f  = %12.1f", eZ2,eZ1, eZ2-eZ1 ) );
    tsum->Draw();
    
    TPad *sum = new TPad("sum","plots",0.01,0.03,0.99,0.94);
    sum->Divide(2,4);    sum->Draw();
 
    sum->cd(1);    eHxy1.DrawH2(    Form("Hxy1_%s"    ,suffix),"Pattern X vs Y" )->Draw("colz");
    sum->cd(2);    eHtxty1.DrawH2(  Form("Htxty1_%s"  ,suffix),"Pattern TX vs TY" )->Draw("colz");
    
    sum->cd(3);    eHdxy.DrawH2(    Form("Hdxy_%s"    ,suffix),"Map DX vs DY" )->Draw("colz");
    sum->cd(4);    eHdtxy.DrawH2(   Form("Hdtxy_%s"   ,suffix),"Map DTX vs DTY" )->Draw("colz");
    
    gStyle->SetOptStat(1);
    sum->cd(5);    
    TH1F *hdz = eHdz.DrawH1(     Form("Hdz_%s"     ,suffix),"Map DZ" );
    hdz->Draw();
    sum->cd(6);    
    TH1F *hshr = eHshr.DrawH1(    Form("Hshr_%s"    ,suffix),"Map Shr" );
    hshr->Draw();
    //printf("meanZ = %f meanShr= %f \n",hdz->GetMean(), hshr->GetMean());
    gStyle->SetOptStat(0);
    
    sum->cd(7);    eHdty_ty.DrawH2( Form("Hdty_ty_%s" ,suffix),"Map DTY vs TY" )->Draw("colz");
    sum->cd(8);
    
    return csum;
}

Fill()

void EdbCorrectionMapper::Fill	(	EdbSegP &	s1,
		EdbSegP &	s2
	)

{
  eHxy1.Fill( s1.X(),s1.Y() );
  eHtxty1.Fill( s1.TX(),s1.TY() );
  eHxy2.Fill( s2.X(),s2.Y() );
  eHtxty2.Fill( s2.TX(),s2.TY() );
  eHdxy.Fill( s2.X()-(s1.X()+s1.TX()*(s2.Z()-s1.Z())), s2.Y()-(s1.Y()+s1.TY()*(s2.Z()-s1.Z())) );
  eHdtxy.Fill( s2.TX()-s1.TX(), s2.TY()-s1.TY() );
  eHdty_ty.Fill( s1.TY(), s2.TY()-s1.TY() );
      
  float t1  = s1.Theta();
  if(t1>.1) {
      float dz = s2.Z()-s1.Z();
      float tx = (s2.X()-s1.X())/dz;
      float ty = (s2.Y()-s1.Y())/dz;
      float t = TMath::Sqrt(tx*tx+ty*ty);
      float dzn = dz*t/t1;
      eHdz.Fill(dzn-dz);
  }
  
  if(t1>.1) {
    float t2  = s2.Theta();
    float shr = t2/t1;
    eHshr.Fill(shr);
  }
 
}

FillS()

void EdbCorrectionMapper::FillS ( EdbSegP *  s1, EdbSegP *  s2  )

inline

{ eAl.AddSegCouple(s1,s2); }

GetBin() [1/2]

EdbCorrectionBin * EdbCorrectionMapper::GetBin ( float  x, float  y  )

inline

{ return (EdbCorrectionBin*)(eMapAl.GetObject(x, y, 0)); }

GetBin() [2/2]

EdbCorrectionBin * EdbCorrectionMapper::GetBin ( int  i )

inline

{ return (EdbCorrectionBin*)(eMapAl.GetObject( i, 0)); }

InitMap()

int EdbCorrectionMapper::InitMap	(	int	nx,
		float	minx,
		float	maxx,
		int	ny,
		float	miny,
		float	maxy
	)

assumed that the own histograms of EdbCorrectionMapper are correctly defined

{
  int n = eMapAl.InitCell(nx, minx, maxx, ny, miny, maxy, 1);
  for(int i=0; i<n; i++) {
    EdbCorrectionBin *bin = new EdbCorrectionBin();
    eMapAl.AddObject(i, bin );
  }
  eMap.Init(eMapAl);
  
  return n;
}

MakeCorrectionsTable()

void EdbCorrectionMapper::MakeCorrectionsTable

(

)

assuming that all corrections are calculated produce the output eMap object

{
  int n = eMapAl.Ncell();
  for(int i=0; i<n; i++) {
       EdbCorrectionBin *bin = GetBin(i);
       EdbLayer *l = eMap.GetLayer(i);
       l->ApplyCorrections( bin->eLayer );
       l->SetNcp(bin->eAl.Ncp());
       l->SubstructCorrections(eLayer);
  }
}

MapDV()

EdbH2 * EdbCorrectionMapper::MapDV

(

int

ivar

)

{
  EdbH2 *h = new EdbH2();
  h->InitH2(eMapAl);
  int n=eMapAl.Ncell();
  for(int i=0;i<n; i++) {
      EdbCorrectionBin *bin = GetBin(i);
      h->SetBin( i, (int)(1000*bin->eAl.CalcMeanDiff(ivar)) );
  }
  return h;
}

MapDZ()

EdbH2 * EdbCorrectionMapper::MapDZ

(

)

{
  EdbH2 *h = new EdbH2();
  h->InitH2(eMapAl);
  int n=eMapAl.Ncell();
  for(int i=0;i<n; i++) {
      EdbCorrectionBin *bin = GetBin(i);
      //h->SetBin( i, (int)(1000*bin->eAl.CalcMeanDZ()) );
      h->SetBin( i, (int)(1000*bin->eAl.eCorr[0].V(2)) );  // assumed that all corrections are calculated
  }
  return h;
}

SetCorrDZ()

void EdbCorrectionMapper::SetCorrDZ

(

)

{
    eAl.eCorr[0].SetV( 2, eZ2-eZ1 );
    int n=eMapAl.Ncell();
    for(int i=0;i<n; i++) {
      EdbCorrectionBin *bin = GetBin(i);
      bin->eAl.eCorr[0].SetV( 2, eZ2-eZ1 );
    }
}

SmoothCorrections()

void EdbCorrectionMapper::SmoothCorrections

(

)

in case of low pattern: add segments from 3x3 neighbouring and calculate mean alignment

{
  int n = eMapAl.Ncell();
  int ncpGood = 0;
  for(int i=0; i<n; i++) if( GetBin(i)->eAl.Ncp() >= eNcpMin ) ncpGood++;
  Log(2,"EdbCorrectionMapper::SmoothCorrections","%d / %d = %6.4f fraction of good alignments (>%d)",
        ncpGood,n, 1.*ncpGood/n, eNcpMin);
  for(int j=0; j<n; j++) {
    EdbCorrectionBin *bin = GetBin(j);
    if(bin->eAl.Ncp() >= eNcpMin)   continue;
    TObjArray arr;
    int ne = eMapAl.SelectObjectsCJ(j,1,arr);
    for(int ie=0; ie<ne; ie++) {
      EdbCorrectionBin *bine = (EdbCorrectionBin *)(arr.At(ie));
      if(bine != bin)  bin->AddBin(*bine);
    }
  }
  
}

UpdateLayerWithLocalCorr()

void EdbCorrectionMapper::UpdateLayerWithLocalCorr

(

EdbLayer &

la

)

{
  la.Map().ApplyCorrections(eMap);
}

Write()

void EdbCorrectionMapper::Write

(

const char *

suffix = ""

)

{
    bool batch = gROOT->IsBatch();
    gROOT->SetBatch();
    TCanvas *csum = DrawSum(suffix);
    csum->Write();
    TCanvas *cdiff = DrawMap(eMap, suffix);
    cdiff->Write();
    gROOT->SetBatch(batch);
}

Member Data Documentation

eHdtxy

EdbH2 EdbCorrectionMapper::eHdtxy

dtxdty

eHdty_ty

EdbH2 EdbCorrectionMapper::eHdty_ty

eHdxy

EdbH2 EdbCorrectionMapper::eHdxy

dxdy

eHdz

EdbH1 EdbCorrectionMapper::eHdz

dz

eHshr

EdbH1 EdbCorrectionMapper::eHshr

eHtxty1

EdbH2 EdbCorrectionMapper::eHtxty1

eHtxty2

EdbH2 EdbCorrectionMapper::eHtxty2

eHxy1

EdbH2 EdbCorrectionMapper::eHxy1

eHxy2

EdbH2 EdbCorrectionMapper::eHxy2

eID1

EdbID EdbCorrectionMapper::eID1

eID2

EdbID EdbCorrectionMapper::eID2

eMap

EdbCorrectionMap EdbCorrectionMapper::eMap

result: corrections map

eMapAl

EdbCell2 EdbCorrectionMapper::eMapAl

working object with local alignments

eNcpMin

int EdbCorrectionMapper::eNcpMin

min number of coincidences to accept correction

eZ1

float EdbCorrectionMapper::eZ1

eZ2

float EdbCorrectionMapper::eZ2

---

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

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