EdbDistortionMap Class Reference

#include <EdbDistortion.h>

Inheritance diagram for EdbDistortionMap:

Collaboration diagram for EdbDistortionMap:

Public Member Functions
void	Add (const EdbDistortionMap &map, float k=1.)
void	AddDX (int j, double dx)
void	AddDY (int j, double dy)
void	ApplyCorr (EdbClDist &c)
int	Bin (int j) const
void	DrawCorrMap (TFile *file=0, const char *name=0)
double	DX (int j) const
double	DY (int j) const
	EdbDistortionMap ()
void	Fill (float x, float y, float dx, float dy)
void	GenerateCorrectionMatrix (const char *file)
TH2F *	GetH2dX (const char *name="hdx")
TH2F *	GetH2dY (const char *name="hdy")
void	InitMap (int nxpix, int nypix, float xpix, float ypix, float stepX, float stepY)
int	Jcell (float x, float y) const
void	Norm ()
void	PutH2dX (const TH2F &h2)
void	PutH2dY (const TH2F &h2)
void	ReadMatrix2Map (const char *file)
void	Save (TFile *f, const char *suffix="")
void	Scale (const float k)
void	SetDX (int j, double dx)
void	SetDY (int j, double dy)
void	Smooth (int n=1, Option_t *opt="k5a")
float	StepX ()
float	StepY ()
void	Substract (const EdbDistortionMap &map)
virtual	~EdbDistortionMap ()

Private Attributes
EdbCell2	eMap
int	eNXpix
int	eNYpix
float	eXpix
float	eYpix

Constructor & Destructor Documentation

EdbDistortionMap()

EdbDistortionMap::EdbDistortionMap ( )

inline

{}

~EdbDistortionMap()

virtual EdbDistortionMap::~EdbDistortionMap ( )

inlinevirtual

{}

Member Function Documentation

Add()

void EdbDistortionMap::Add	(	const EdbDistortionMap &	map,
		float	k = 1.
	)

{
  int nc=eMap.Ncell();
  for( int j=0; j<nc; j++ ) {
    int jm = map.Jcell( eMap.Xj(j), eMap.Yj(j) );
    TArrayD *dxy = (TArrayD *)eMap.GetObject(j,0);
    (*dxy)[0] += k*map.DX(jm);
    (*dxy)[1] += k*map.DY(jm);
    eMap.Fill(j);
  }
}

AddDX()

void EdbDistortionMap::AddDX	(	int	j,
		double	dx
	)

{
  TArrayD *dxy = (TArrayD*)( eMap.GetObject(j, 0 ) );    
  if(dxy) (*dxy)[0] += dx;
}

AddDY()

void EdbDistortionMap::AddDY	(	int	j,
		double	dy
	)

{
  TArrayD *dxy = (TArrayD*)( eMap.GetObject(j, 0 ) );    
  if(dxy) (*dxy)[1] += dy;
}

ApplyCorr()

void EdbDistortionMap::ApplyCorr

(

EdbClDist &

c

)

{
  int j=Jcell(c.eX,c.eY);
  if(j>-1) {
    TArrayD *dxy = (TArrayD*)( eMap.GetObject(j, 0 ) );
    if(dxy) {
      c.eX -= (*dxy)[0];
      c.eY -= (*dxy)[1];
    }
  }
}

Bin()

int EdbDistortionMap::Bin ( int  j ) const

inline

{return eMap.Bin(j);}

DrawCorrMap()

void EdbDistortionMap::DrawCorrMap	(	TFile *	file = 0,
		const char *	name = 0
	)

{
  bool batch = gROOT->IsBatch();
  if(file) {
    Log(2,"EdbDistortionMap::DrawCorrMap","Save to file %s", file->GetName());
    gROOT->SetBatch();
  }
  
  TCanvas *cc = new TCanvas(Form("c_%s",name),"Corrections map",1200,900);
  
  gStyle->SetPalette(1);
  gStyle->SetOptStat(0);
  gPad->SetGridx(1);
  gPad->SetGridy(1);
  
  float margin=10;
  double minXborder = eMap.Xmin() - margin;
  double maxXborder = eMap.Xmax() + margin;
  double minYborder = eMap.Ymin() - margin;
  double maxYborder = eMap.Ymax() + margin;
  
  TH2F *hh = new TH2F(Form("hh_%s",name),"Corrections map",100,minXborder,maxXborder,100,minYborder,maxYborder);
  hh->GetXaxis()->SetTitle("X (#mum)");
  hh->GetYaxis()->SetTitle("Y (#mum)");
  hh->Draw();
  
  TBox *plate = new TBox(eMap.Xmin(),eMap.Ymin(),eMap.Xmax(),eMap.Ymax());
  plate->SetFillColor(16);
  plate->SetFillStyle(3001);
  plate->Draw();
  
  Double_t meanx=0, meany=0, meanr=0, wtot=0;
  float scale = 15.;
  int nc=eMap.Ncell();
  for( int i=0; i<nc; i++ ) {
    int w = eMap.Bin(i);    if(!w) continue;
    TArrayD *dxy = (TArrayD*)( eMap.GetObject(i, 0 ) );
    float x = eMap.Xj(i);
    float y = eMap.Yj(i);
    float dx = (*dxy)[0];
    float dy = (*dxy)[1];
    
    TArrow *arrow = new TArrow(x,y,x+scale*dx,y+scale*dy,0.01);
    arrow->SetLineWidth(1);
    arrow->Draw();
    
    meanx += dx;
    meany += dy;
    meanr += sqrt(dx*dx+dy*dy);
    wtot  += w;
  }
  
  meanx /= wtot;
  meany /= wtot;
  meanr /= wtot;
  printf("\nmeanR = %g   meanx = %g   meany = %g  wtot = %f\n", meanr, meanx, meany, wtot);
 
  if(file) {
   const char *mapname = "corr_map";
   if(name) mapname = name;
   eMap.DrawH2(Form("eMap_%s",name),"entries/bin")->Write();
   cc->Write(name);
  }
  gROOT->SetBatch(batch);
}

DX()

double EdbDistortionMap::DX

(

int

j

)

const

{
  TArrayD *dxy = (TArrayD*)( eMap.GetObject(j, 0 ) );
  if(dxy) return (*dxy)[0]; else return 0;
}

DY()

double EdbDistortionMap::DY

(

int

j

)

const

{
  TArrayD *dxy = (TArrayD*)( eMap.GetObject(j, 0 ) );
  if(dxy) return (*dxy)[1]; else return 0;
}

Fill()

void EdbDistortionMap::Fill	(	float	x,
		float	y,
		float	dx,
		float	dy
	)

{
  TArrayD *dxy = (TArrayD *)eMap.GetObject(x,y,0);
  if(dxy) {
    (*dxy)[0]+=dx;
    (*dxy)[1]+=dy;
    eMap.Fill(x, y);
  }
}

GenerateCorrectionMatrix()

void EdbDistortionMap::GenerateCorrectionMatrix

(

const char *

file

)

{
  int nentries = eMap.Ncell();
  Double_t *vx   = new Double_t[nentries];
  Double_t *vy   = new Double_t[nentries];
  Double_t *vdx  = new Double_t[nentries];
  Double_t *vdy  = new Double_t[nentries];
  
  for(int i=0; i<nentries; i++) {
    int w = eMap.Bin(i);    if(!w) continue;
    TArrayD *arr = (TArrayD*)eMap.GetObject(i,0);
    if(!arr) { Log(1,"EdbDistortionMap::GenerateCorrectionMatrix","ERROR: missed bin");  break; }
    vx[i]   = eMap.Xj(i);
    vy[i]   = eMap.Yj(i);
    vdx[i]  = arr->At(0);
    vdy[i]  = arr->At(1);
  }
  
  TGraph2D *gdx  = new TGraph2D("graphDX","graphDX",nentries,vx,vy,vdx);
  TGraph2D *gdy  = new TGraph2D("graphDY","graphDY",nentries,vx,vy,vdy);
  
  FILE *fmatr = fopen(file,"w");
  fprintf(fmatr,"%d %d  %f %f\n", eNXpix, eNYpix, eXpix, eYpix);
  
  for(int i=0; i<eNXpix; i++) {
    for(int j=0; j<eNYpix; j++) {
      float x = (i - 0.5*(eNXpix-1))*eXpix;
      float y = (j - 0.5*(eNYpix-1))*eYpix;
      //float dx = gdx->Interpolate(x,y);
      //float dy = gdy->Interpolate(x,y);
      float dx = ((TArrayD *)eMap.GetObject(x,y,0))->At(0);
      float dy = ((TArrayD *)eMap.GetObject(x,y,0))->At(1);
      fprintf(fmatr,"%5d %5d %12.6f %12.6f  %11.6f %11.6f\n", i, j, x,y,dx,dy);
    }
  }
  fclose(fmatr);
}

GetH2dX()

TH2F * EdbDistortionMap::GetH2dX

(

const char *

name = "hdx"

)

{
  TH2F *hd = eMap.DrawH2(name,"CorrectionMatrix dX");
  hd->Reset();
  int nc=eMap.Ncell();
  for( int j=0; j<nc; j++ )
    hd->Fill( eMap.Xj(j), eMap.Yj(j), DX(j) );
  return hd;
}

GetH2dY()

TH2F * EdbDistortionMap::GetH2dY

(

const char *

name = "hdy"

)

{
  TH2F *hd = eMap.DrawH2(name,"CorrectionMatrix dY");
  hd->Reset();
  int nc=eMap.Ncell();
  for( int j=0; j<nc; j++ )
    hd->Fill( eMap.Xj(j), eMap.Yj(j), DY(j) );
  return hd;
}

InitMap()

void EdbDistortionMap::InitMap	(	int	nxpix,
		int	nypix,
		float	xpix,
		float	ypix,
		float	stepX,
		float	stepY
	)

{
  // matrix of the corrections in each entry is TArrayD with 2 entries:(dx,dy)
  eNXpix = nxpix;
  eNYpix = nypix;
  eXpix  = xpix;
  eYpix  = ypix;
  
  float  mi[2] = { -eNXpix*Abs(eXpix)/2., -eNYpix*Abs(eYpix)/2. };
  float  ma[2] = {  eNXpix*Abs(eXpix)/2.,  eNYpix*Abs(eYpix)/2. };
  int    n[2] = { int((ma[0]-mi[0])/stepX), int((ma[1]-mi[1])/stepY) };
  
  stepX = (ma[0]-mi[0])/n[0];
  stepY = (ma[1]-mi[1])/n[1];
  n[0] = int((ma[0]-mi[0]+1.)/stepX);
  n[1] = int((ma[1]-mi[1]+1.)/stepY);
  
  eMap.InitCell(2, n, mi, ma);
  //eMap.PrintStat();
  
  int nc=eMap.Ncell();
  for( int i=0; i<nc; i++ ) {
    TArrayD *a = new TArrayD(2);
    eMap.AddObject(i, (TObject*)a );
    eMap.SetBin(i,0);
  }
}

Jcell()

int EdbDistortionMap::Jcell ( float  x, float  y  ) const

inline

{return eMap.Jcell(x,y);}

Norm()

void EdbDistortionMap::Norm

(

)

{
  int nc=eMap.Ncell();
  for( int i=0; i<nc; i++ ) {
    TArrayD *dxy = (TArrayD*)( eMap.GetObject(i, 0 ) );    if(!dxy) continue;
    int w = eMap.Bin(i);                                   if(!w) continue;
    (*dxy)[0] /= w;
    (*dxy)[1] /= w;
  }
}

PutH2dX()

void EdbDistortionMap::PutH2dX

(

const TH2F &

h2

)

{
  // TODO: no any checks yet
  int nc = h2.GetNcells();
  int ix,iy,iz;
  for( int j=0; j<nc; j++ ) {
    double dx = h2.GetBinContent(j);
    h2.GetBinXYZ(j,ix,iy,iz);
    float x = ((TAxis*)h2.GetXaxis())->GetBinCenter(ix);
    float y = ((TAxis*)h2.GetYaxis())->GetBinCenter(iy);
    int jm = eMap.Jcell(x,y);
    SetDX( jm, dx );
  }
}

PutH2dY()

void EdbDistortionMap::PutH2dY

(

const TH2F &

h2

)

{
  // TODO: no any checks yet
  int nc = h2.GetNcells();
  int ix,iy,iz;
  for( int j=0; j<nc; j++ ) {
    double dy = h2.GetBinContent(j);
    h2.GetBinXYZ(j,ix,iy,iz);
    float x = ((TAxis*)h2.GetXaxis())->GetBinCenter(ix);
    float y = ((TAxis*)h2.GetYaxis())->GetBinCenter(iy);
    int jm = eMap.Jcell(x,y);
    SetDY( jm, dy );
  }
}

ReadMatrix2Map()

void EdbDistortionMap::ReadMatrix2Map

(

const char *

file

)

{
  Log(1,"EdbDistortionMap::ReadMatrix2Map","%s ",file);
  FILE *f = fopen(file,"r");
  if(!f) { Log(1,"ReadMatrix2Map","file %s not found!",file); return; }
  char str[256]; 
  fgets(str, 256, f);
  int nxpix, nypix;
  float xpix, ypix;
  sscanf(str,"%d %d  %f %f", &nxpix, &nypix, &xpix, &ypix);
  if( nxpix!=eNXpix||nypix!=eNYpix||abs(xpix-eXpix)>0.000001||abs(ypix-eYpix)>0.000001 ) 
  { Log(1,"ReadMatrix2Map","ERROR: matrix definition is different!",file); 
    printf("%d %d  %f %f\n", nxpix, nypix, xpix, ypix);
    return; 
  }
  
  int i0,j0;
  float x0,y0,dx0,dy0;
  for(int i=0; i<eNXpix; i++) {
    for(int j=0; j<eNYpix; j++) {
      if(fgets(str, 256, f)==NULL) Log(1,"GenerateCorrectionMatrix","ERROR: input file is not correct");
      if( sscanf(str, "%d %d %f %f %f %f", &i0, &j0, &x0, &y0, &dx0, &dy0) == 6 )  
      {
    TArrayD *dxy = (TArrayD *)eMap.GetObject(x0,y0,0);
    (*dxy)[0]+=dx0;
    (*dxy)[1]+=dy0;
    eMap.Fill(x0, y0);
      }
    }    
  }
  fclose(f);
  
  int nc=eMap.Ncell();
  for( int i=0; i<nc; i++ ) {
    TArrayD *dxy = (TArrayD*)( eMap.GetObject(i, 0 ) );    if(!dxy) continue;
    int w = eMap.Bin(i);                                   if(!w) continue;
    (*dxy)[0] /= w;
    (*dxy)[1] /= w;
  }
}

Save()

void EdbDistortionMap::Save	(	TFile *	f,
		const char *	suffix = ""
	)

{
  if(file) {
    bool batch = gROOT->IsBatch();
    gROOT->SetBatch();
    DrawCorrMap( file, Form("corrmap_%s",suffix) );
    GetH2dX()->Write( Form("hdx_%s",suffix) );
    GetH2dY()->Write( Form("hdy_%s",suffix) );
    gROOT->SetBatch(batch);
  }
}

Scale()

void EdbDistortionMap::Scale

(

const float

k

)

{
  int nc=eMap.Ncell();
  for( int j=0; j<nc; j++ ) {
    SetDX( j, DX(j)*k );
    SetDY( j, DY(j)*k );
  }
}

SetDX()

void EdbDistortionMap::SetDX	(	int	j,
		double	dx
	)

{
  TArrayD *dxy = (TArrayD*)( eMap.GetObject(j, 0 ) );    
  if(dxy) (*dxy)[0] = dx;
}

SetDY()

void EdbDistortionMap::SetDY	(	int	j,
		double	dy
	)

{
  TArrayD *dxy = (TArrayD*)( eMap.GetObject(j, 0 ) );    
  if(dxy) (*dxy)[1] = dy;
}

Smooth()

void EdbDistortionMap::Smooth	(	int	n = 1,
		Option_t *	opt = "k5a"
	)

{
  TH2F *h2x = GetH2dX();
  TH2F *h2y = GetH2dY();
  for(int i=0; i<n; i++) {
    h2x->Smooth(1,opt);
    h2y->Smooth(1,opt);
  }
  PutH2dX(*h2x);
  PutH2dY(*h2y);
}

StepX()

float EdbDistortionMap::StepX ( )

inline

{return eMap.Xbin();}

StepY()

float EdbDistortionMap::StepY ( )

inline

{return eMap.Ybin();}

Substract()

void EdbDistortionMap::Substract ( const EdbDistortionMap &  map )

inline

{ Add(map,-1.); }

Member Data Documentation

eMap

EdbCell2 EdbDistortionMap::eMap

private

eNXpix

int EdbDistortionMap::eNXpix

private

eNYpix

int EdbDistortionMap::eNYpix

private

eXpix

float EdbDistortionMap::eXpix

private

eYpix

float EdbDistortionMap::eYpix

private

---

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

• src/libEMC/EdbDistortion.h
• src/libEMC/EdbDistortion.cxx