mirror of
https://github.com/slsdetectorgroup/slsDetectorPackage.git
synced 2025-04-22 22:40:02 +02:00
407 lines
8.8 KiB
C++
407 lines
8.8 KiB
C++
#ifndef ETA2_INTERPOLATION_BASE_H
|
|
#define ETA2_INTERPOLATION_BASE_H
|
|
|
|
#ifdef MYROOT1
|
|
#include <TObject.h>
|
|
#include <TTree.h>
|
|
#include <TH2D.h>
|
|
#include <TH2F.h>
|
|
#endif
|
|
|
|
#include "etaInterpolationBase.h"
|
|
|
|
class eta2InterpolationBase : public virtual etaInterpolationBase {
|
|
|
|
public:
|
|
eta2InterpolationBase(int nx=400, int ny=400, int ns=25, int nsy=25, int nb=-1, int nby=-1, double emin=1, double emax=0) : etaInterpolationBase(nx,ny, ns, nsy, nb, nby, emin, emax) {
|
|
|
|
/* if (etamin>=etamax) { */
|
|
/* etamin=-1; */
|
|
/* etamax=2; */
|
|
/* // cout << ":" <<endl; */
|
|
/* } */
|
|
/* etastep=(etamax-etamin)/nbeta; */
|
|
|
|
};
|
|
|
|
eta2InterpolationBase(eta2InterpolationBase *orig): etaInterpolationBase(orig){ };
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//////////// /*It return position hit for the event in input */ //////////////
|
|
virtual void getInterpolatedPosition(int x, int y, int *data, double &int_x, double &int_y)
|
|
{
|
|
double sDum[2][2];
|
|
double tot, totquad;
|
|
double etax=0,etay=0;
|
|
|
|
int corner;
|
|
corner=calcQuad(data, tot, totquad, sDum);
|
|
if (nSubPixelsX>2 || nSubPixelsY>2)
|
|
calcEta(totquad, sDum, etax, etay);
|
|
getInterpolatedPosition(x,y,etax,etay,corner,int_x,int_y);
|
|
|
|
return;
|
|
};
|
|
|
|
|
|
virtual void getInterpolatedPosition(int x, int y, double *data, double &int_x, double &int_y)
|
|
{
|
|
double sDum[2][2];
|
|
double tot, totquad;
|
|
double etax=0,etay=0;
|
|
|
|
int corner;
|
|
corner=calcQuad(data, tot, totquad, sDum);
|
|
if (nSubPixelsX>2 || nSubPixelsY>2 )
|
|
calcEta(totquad, sDum, etax, etay);
|
|
getInterpolatedPosition(x,y,etax,etay,corner,int_x,int_y);
|
|
|
|
return;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
virtual void getInterpolatedPosition(int x, int y, double totquad,int quad,double *cl,double &int_x, double &int_y) {
|
|
|
|
double cc[2][2];
|
|
int xoff=0, yoff=0;
|
|
switch (quad) {
|
|
case BOTTOM_LEFT:
|
|
xoff=0;
|
|
yoff=0;
|
|
break;
|
|
case BOTTOM_RIGHT:
|
|
xoff=1;
|
|
yoff=0;
|
|
break;
|
|
case TOP_LEFT:
|
|
xoff=0;
|
|
yoff=1;
|
|
break;
|
|
case TOP_RIGHT:
|
|
xoff=1;
|
|
yoff=1;
|
|
break;
|
|
default:
|
|
;
|
|
}
|
|
double etax=0, etay=0;
|
|
if (nSubPixelsX>2 || nSubPixelsY>2) {
|
|
cc[0][0]=cl[xoff+3*yoff];
|
|
cc[1][0]=cl[xoff+3*(yoff+1)];
|
|
cc[0][1]=cl[xoff+1+3*yoff];
|
|
cc[1][1]=cl[xoff+1+3*(yoff+1)];
|
|
calcEta(totquad,cc,etax,etay);
|
|
}
|
|
|
|
return getInterpolatedPosition(x,y,etax, etay,quad,int_x,int_y);
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual void getInterpolatedPosition(int x, int y, double totquad,int quad,int *cl,double &int_x, double &int_y) {
|
|
|
|
double cc[2][2];
|
|
int xoff=0, yoff=0;
|
|
|
|
switch (quad) {
|
|
case BOTTOM_LEFT:
|
|
xoff=0;
|
|
yoff=0;
|
|
break;
|
|
case BOTTOM_RIGHT:
|
|
xoff=1;
|
|
yoff=0;
|
|
break;
|
|
case TOP_LEFT:
|
|
xoff=0;
|
|
yoff=1;
|
|
break;
|
|
case TOP_RIGHT:
|
|
xoff=1;
|
|
yoff=1;
|
|
break;
|
|
default:
|
|
;
|
|
}
|
|
double etax=0, etay=0;
|
|
if (nSubPixelsX>2 || nSubPixelsY>2) {
|
|
cc[0][0]=cl[xoff+3*yoff];
|
|
cc[1][0]=cl[xoff+3*(yoff+1)];
|
|
cc[0][1]=cl[xoff+1+3*yoff];
|
|
cc[1][1]=cl[xoff+1+3*(xoff+1)];
|
|
calcEta(totquad,cc,etax,etay);
|
|
}
|
|
return getInterpolatedPosition(x,y,etax, etay,quad,int_x,int_y);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
virtual void getInterpolatedPosition(int x, int y, double etax, double etay, int corner, double &int_x, double &int_y)
|
|
{
|
|
|
|
|
|
double xpos_eta=0,ypos_eta=0;
|
|
double dX,dY;
|
|
int ex,ey;
|
|
switch (corner)
|
|
{
|
|
case TOP_LEFT:
|
|
dX=-1.;
|
|
dY=0;
|
|
break;
|
|
case TOP_RIGHT:
|
|
;
|
|
dX=0;
|
|
dY=0;
|
|
break;
|
|
case BOTTOM_LEFT:
|
|
dX=-1.;
|
|
dY=-1.;
|
|
break;
|
|
case BOTTOM_RIGHT:
|
|
dX=0;
|
|
dY=-1.;
|
|
break;
|
|
default:
|
|
cout << "bad quadrant" << endl;
|
|
dX=0.;
|
|
dY=0.;
|
|
}
|
|
|
|
|
|
if (nSubPixelsX>2 || nSubPixelsY>2 ) {
|
|
|
|
ex=(etax-etamin)/etastepX;
|
|
ey=(etay-etamin)/etastepY;
|
|
if (ex<0) {
|
|
cout << "x*"<< ex << endl;
|
|
ex=0;
|
|
}
|
|
if (ex>=nbetaX) {
|
|
cout << "x?"<< ex << endl;
|
|
ex=nbetaX-1;
|
|
}
|
|
if (ey<0) {
|
|
cout << "y*"<< ey << " " << nbetaY << endl;
|
|
ey=0;
|
|
}
|
|
if (ey>=nbetaY) {
|
|
cout << "y?"<< ey << " " << nbetaY << endl;
|
|
ey=nbetaY-1;
|
|
}
|
|
|
|
|
|
|
|
xpos_eta=(((double)hhx[(ey*nbetaX+ex)]))+dX ;///((double)nSubPixels);
|
|
ypos_eta=(((double)hhy[(ey*nbetaX+ex)]))+dY ;///((double)nSubPixels);
|
|
|
|
} else {
|
|
xpos_eta=0.5*dX+0.25;
|
|
ypos_eta=0.5*dY+0.25;
|
|
}
|
|
|
|
int_x=((double)x) + xpos_eta+0.5;
|
|
int_y=((double)y) + ypos_eta+0.5;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual int addToFlatField(double totquad,int quad,int *cl,double &etax, double &etay) {
|
|
double cc[2][2];
|
|
int xoff=0, yoff=0;
|
|
|
|
switch (quad) {
|
|
case BOTTOM_LEFT:
|
|
xoff=0;
|
|
yoff=0;
|
|
break;
|
|
case BOTTOM_RIGHT:
|
|
xoff=1;
|
|
yoff=0;
|
|
break;
|
|
case TOP_LEFT:
|
|
xoff=0;
|
|
yoff=1;
|
|
break;
|
|
case TOP_RIGHT:
|
|
xoff=1;
|
|
yoff=1;
|
|
break;
|
|
default:
|
|
;
|
|
}
|
|
cc[0][0]=cl[xoff+3*yoff];
|
|
cc[1][0]=cl[xoff+3*(yoff+1)];
|
|
cc[0][1]=cl[xoff+1+3*yoff];
|
|
cc[1][1]=cl[xoff+1+3*(yoff+1)];
|
|
|
|
//calcMyEta(totquad,quad,cl,etax, etay);
|
|
calcEta(totquad, cc,etax, etay);
|
|
|
|
// cout <<"******"<< etax << " " << etay << endl;
|
|
|
|
|
|
return addToFlatField(etax,etay);
|
|
}
|
|
|
|
virtual int addToFlatField(double totquad,int quad,double *cl,double &etax, double &etay) {
|
|
double cc[2][2];
|
|
int xoff=0, yoff=0;
|
|
|
|
switch (quad) {
|
|
case BOTTOM_LEFT:
|
|
xoff=0;
|
|
yoff=0;
|
|
break;
|
|
case BOTTOM_RIGHT:
|
|
xoff=1;
|
|
yoff=0;
|
|
break;
|
|
case TOP_LEFT:
|
|
xoff=0;
|
|
yoff=1;
|
|
break;
|
|
case TOP_RIGHT:
|
|
xoff=1;
|
|
yoff=1;
|
|
break;
|
|
default:
|
|
;
|
|
}
|
|
cc[0][0]=cl[xoff+3*yoff];
|
|
cc[1][0]=cl[(yoff+1)*3+xoff];
|
|
cc[0][1]=cl[yoff*3+xoff+1];
|
|
cc[1][1]=cl[(yoff+1)*3+xoff+1];
|
|
|
|
/* cout << cl[0] << " " << cl[1] << " " << cl[2] << endl; */
|
|
/* cout << cl[3] << " " << cl[4] << " " << cl[5] << endl; */
|
|
/* cout << cl[6] << " " << cl[7] << " " << cl[8] << endl; */
|
|
/* cout <<"******"<<totquad << " " << quad << endl; */
|
|
/* cout << cc[0][0]<< " " << cc[0][1] << endl; */
|
|
/* cout << cc[1][0]<< " " << cc[1][1] << endl; */
|
|
//calcMyEta(totquad,quad,cl,etax, etay);
|
|
calcEta(totquad, cc,etax, etay);
|
|
|
|
// cout <<"******"<< etax << " " << etay << endl;
|
|
|
|
|
|
return addToFlatField(etax,etay);
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
virtual int addToFlatField(double *cluster, double &etax, double &etay){
|
|
double sDum[2][2];
|
|
double tot, totquad;
|
|
// int corner;
|
|
//corner=
|
|
calcQuad(cluster, tot, totquad, sDum);
|
|
|
|
//double xpos_eta,ypos_eta;
|
|
//double dX,dY;
|
|
|
|
|
|
calcEta(totquad, sDum, etax, etay);
|
|
|
|
return addToFlatField(etax,etay);
|
|
|
|
};
|
|
|
|
virtual int addToFlatField(int *cluster, double &etax, double &etay){
|
|
double sDum[2][2];
|
|
double tot, totquad;
|
|
//int corner;
|
|
//corner=
|
|
calcQuad(cluster, tot, totquad, sDum);
|
|
|
|
// double xpos_eta,ypos_eta;
|
|
//double dX,dY;
|
|
|
|
|
|
calcEta(totquad, sDum, etax, etay);
|
|
|
|
return addToFlatField(etax,etay);
|
|
|
|
};
|
|
|
|
|
|
virtual int addToFlatField(double etax, double etay){
|
|
#ifdef MYROOT1
|
|
heta->Fill(etax,etay);
|
|
#endif
|
|
#ifndef MYROOT1
|
|
int ex,ey;
|
|
ex=(etax-etamin)/etastepX;
|
|
ey=(etay-etamin)/etastepY;
|
|
if (ey<nbetaY && ex<nbetaX && ex>=0 && ey>=0)
|
|
heta[ey*nbetaX+ex]++;
|
|
#endif
|
|
return 0;
|
|
};
|
|
|
|
virtual int *getInterpolatedImage(){
|
|
int ipx, ipy;
|
|
// cout << "ff" << endl;
|
|
calcDiff(1, hhx, hhy); //get flat
|
|
double avg=0;
|
|
for (ipx=0; ipx<nSubPixelsX; ipx++)
|
|
for (ipy=0; ipy<nSubPixelsY; ipy++)
|
|
avg+=flat[ipx+ipy*nSubPixelsX];
|
|
avg/=nSubPixelsY*nSubPixelsX;
|
|
|
|
for (int ibx=0 ; ibx<nSubPixelsX*nPixelsX; ibx++) {
|
|
ipx=ibx%nSubPixelsX-nSubPixelsX/2;
|
|
if (ipx<0) ipx=nSubPixelsX+ipx;
|
|
for (int iby=0 ; iby<nSubPixelsY*nPixelsY; iby++) {
|
|
ipy=iby%nSubPixelsY-nSubPixelsY/2;
|
|
if (ipy<0) ipy=nSubPixelsY+ipy;
|
|
// cout << ipx << " " << ipy << " " << ibx << " " << iby << endl;
|
|
if (flat[ipx+ipy*nSubPixelsX]>0)
|
|
hintcorr[ibx+iby*nSubPixelsX*nPixelsX]=hint[ibx+iby*nSubPixelsX*nPixelsX]*(avg/flat[ipx+ipy*nSubPixelsX]);
|
|
else
|
|
hintcorr[ibx+iby*nSubPixelsX*nPixelsX]=hint[ibx+iby*nSubPixelsX*nPixelsX];
|
|
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
return hintcorr;
|
|
};
|
|
|
|
/* protected: */
|
|
|
|
/* #ifdef MYROOT1 */
|
|
/* TH2D *heta; */
|
|
/* TH2D *hhx; */
|
|
/* TH2D *hhy; */
|
|
/* #endif */
|
|
/* #ifndef MYROOT1 */
|
|
/* int *heta; */
|
|
/* float *hhx; */
|
|
/* float *hhy; */
|
|
/* #endif */
|
|
/* int nbeta; */
|
|
/* double etamin, etamax, etastep; */
|
|
|
|
};
|
|
|
|
#endif
|