slsDetectorPackage/slsDetectorCalibration/interpolations/linearInterpolation.h

// SPDX-License-Identifier: LGPL-3.0-or-other
// Copyright (C) 2021 Contributors to the SLS Detector Package
#ifndef LINEAR_INTERPOLATION_H
#define LINEAR_INTERPOLATION_H

//#include <TObject.h>
//#include <TTree.h>
//#include <TH2F.h>

#include "slsInterpolation.h"

class linearInterpolation : public slsInterpolation {

  public:
    linearInterpolation(int nx = 400, int ny = 400, int ns = 25)
        : slsInterpolation(nx, ny, ns){};
    linearInterpolation(linearInterpolation *orig) : slsInterpolation(orig){};

    virtual void prepareInterpolation(int &ok) { ok = 1; };

    virtual linearInterpolation *Clone() {

        return new linearInterpolation(this);
    };

    //////////////////////////////////////////////////////////////////////////////
    //////////// /*It return position hit for the event in input */
    /////////////////
    virtual void getInterpolatedPosition(int x, int y, double *data,
                                         double &int_x, double &int_y) {
        double sDum[2][2];
        double tot, totquad;
        double etax, etay;

        int corner;
        corner = calcQuad(data, tot, totquad, sDum);
        if (nSubPixels > 2) {
            calcEta(totquad, sDum, etax, etay);
        }
        getInterpolatedPosition(x, y, etax, etay, corner, int_x, int_y);

        return;
    };

    virtual void getInterpolatedPosition(int x, int y, int *data, double &int_x,
                                         double &int_y) {
        double sDum[2][2];
        double tot, totquad;
        double etax, etay;

        int corner;
        corner = calcQuad(data, tot, totquad, sDum);
        if (nSubPixels > 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 eta_x, eta_y;
        if (nSubPixels > 2) {
            double cc[2][2];
            double *cluster[3];
            cluster[0] = cl;
            cluster[1] = cl + 3;
            cluster[2] = cl + 6;
            int xoff, yoff;

            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] = cluster[yoff][xoff];
            cc[1][0] = cluster[yoff + 1][xoff];
            cc[0][1] = cluster[yoff][xoff + 1];
            cc[1][1] = cluster[yoff + 1][xoff + 1];
            calcEta(totquad, cc, eta_x, eta_y);
        }
        // cout << x << " " << y << " " << eta_x << " " << eta_y << " " << int_x
        // << " " << int_y << endl;
        return getInterpolatedPosition(x, y, eta_x, eta_y, 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 *cluster[3];
        int xoff, yoff;
        cluster[0] = cl;
        cluster[1] = cl + 3;
        cluster[2] = cl + 6;

        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, etay;
        if (nSubPixels > 2) {
            cc[0][0] = cluster[yoff][xoff];
            cc[1][0] = cluster[yoff + 1][xoff];
            cc[0][1] = cluster[yoff][xoff + 1];
            cc[1][1] = cluster[yoff + 1][xoff + 1];
            calcEta(totquad, cc, etax, etay);
        }
        //   cout << x << " " << y << " " << etax << " " << etay << " " << int_x
        //   << " " << int_y << endl;
        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, ypos_eta;
        double dX, dY;
        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 (nSubPixels > 2) {
            xpos_eta = (etax) + dX;
            ypos_eta = (etay) + dY;
        } else {
            xpos_eta = 0.5 * dX + 0.25;
            ypos_eta = 0.5 * dY + 0.25;
        }
        int_x = ((double)x) + xpos_eta;
        int_y = ((double)y) + ypos_eta;
        //  cout <<"**"<< x << " " << y << " " << xpos_eta << " " << ypos_eta <<
        //  " " << corner << endl;
        return;
    };

    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual void getPositionETA3(int x, int y, double *data, double &int_x,
                                 double &int_y) {
        double sDum[2][2];
        double tot, totquad;
        double eta3x, eta3y;

        calcQuad(data, tot, totquad, sDum);
        calcEta3(data, eta3x, eta3y, tot);

        double xpos_eta, ypos_eta;

        xpos_eta = eta3x;
        ypos_eta = eta3y;

        int_x = ((double)x) + xpos_eta;
        int_y = ((double)y) + ypos_eta;

        return;
    };
    ////////////////////////////////////////////////////////////////////////////////////////////////////////

    virtual int addToFlatField(double *cluster, double &etax, double &etay){};
    virtual int addToFlatField(int *cluster, double &etax, double &etay){};
    virtual int addToFlatField(double etax, double etay){};
    virtual int addToFlatField(double totquad, int quad, double *cl,
                               double &etax, double &etay){};
    virtual int addToFlatField(double totquad, int quad, int *cl, double &etax,
                               double &etay){};

  protected:
    ;
};

#endif