PndLmdAlignStructs.h

Go to the documentation of this file.

/*
 * PndLmdAlignStructs.h
 *
 *      Header-only file to collect all structs used during SensorAlignment
 *
 *  Created on: Jul 20, 2017
 *      Author: Roman Klasen, roklasen@uni-mainz.de or klasen@kph.uni-mainz.de
 */

#ifndef LMD_LMDSENSORALIGNMENT_PNDLMDALIGNSTRUCTS_H_
#define LMD_LMDSENSORALIGNMENT_PNDLMDALIGNSTRUCTS_H_

#include "PndLmdHitPair.h"

#include <TH1D.h>
#include <TCanvas.h>

#include <cmath>
#include <iostream>
#include <string>
#include <vector>

using std::max;
using std::min;
using std::cout;
using std::vector;

//simple pixel hit, maybe not even necessary
struct pixelHit {
        int _sensorId;
        double _col;
        double _row;

        double x() const {
                return _col;
        }

        pixelHit(int idVal, double colVal, double rowVal) {
                _sensorId = idVal;
                _col = colVal;
                _row = rowVal;
        }

        pixelHit() {
                _col = -1;
                _row = -1;
                _sensorId = -1;
        }
};

/*
 * contains multiple pixelHits that form a cluster. most routines are for checking,
 * if two separate pixelHits belong to the same cluster
 */
struct pixelCluster {
        int _sensorId;
        double centerCol, centerRow;  //,centerZ;
        double clusterSize;
        vector<pixelHit> pixelHits;
        bool clusterReady;

        pixelCluster() {
                _sensorId = -1;
                centerCol = -1;
                centerRow = -1;  //centerZ=-1;
                clusterSize = -1;
                clusterReady = false;
        }

        pixelCluster(const pixelHit &hit) {
                _sensorId = hit._sensorId;
                pixelHits.push_back(hit);

                centerCol = -1;
                centerRow = -1;  //centerZ=-1;
                clusterSize = -1;
                clusterReady = false;
        }

        pixelCluster(const pixelCluster &copy) {
                _sensorId = copy._sensorId;
                for (size_t i = 0; i < copy.pixelHits.size(); i++) {
                        pixelHits.push_back(copy.pixelHits[i]);
                }

                centerCol = -1;
                centerRow = -1;  //centerZ=-1;
                clusterSize = -1;
                clusterReady = false;
        }

        //checks, if two clusters lie DIRECTLY next to each other, that means any two pixels
        //must be directly next to each other
        //TODO: inefficient code, may be improved
        bool isNeighbour(pixelCluster &other) {
                //first, they must be on same sensor
                if (_sensorId != other._sensorId) {
                        return false;
                }
                double _col1, _col2, _row1, _row2;
                for (size_t i = 0; i < this->pixelHits.size(); i++) {
                        _col1 = this->pixelHits[i]._col;
                        _row1 = this->pixelHits[i]._row;
                        for (size_t j = 0; j < other.pixelHits.size(); j++) {
                                _col2 = other.pixelHits[j]._col;
                                _row2 = other.pixelHits[j]._row;
                                //check if neighboring, that means distance of pixels is smaller than 1.5 pixels
                                if ((_col2 - _col1) * (_col2 - _col1) + (_row2 - _row1) * (_row2 - _row1) < 2.25) {
                                        return true;
                                }
                        }
                }
                return false;
        }

        //merges other to this one
        void merge(pixelCluster &other) {
                for (size_t i = 0; i < other.pixelHits.size(); i++) {
                        pixelHits.push_back(other.pixelHits[i]);
                }
        }

        void calculateCenter() {
                centerCol = 0;
                centerRow = 0;
                for (size_t i = 0; i < pixelHits.size(); i++) {
                        centerCol += pixelHits[i]._col;
                        centerRow += pixelHits[i]._row;
                }
                centerCol /= pixelHits.size();
                centerRow /= pixelHits.size();
                double tempDistance;
                //calculate size, go from corner to corner for clusters larger than 2 pixels
                if (pixelHits.size() == 1) {
                        clusterSize = 1;
                }
                else {
                        for (size_t i = 0; i < pixelHits.size(); i++) {
                                for (size_t j = i + 1; j < pixelHits.size(); j++) {
                                        double deltax = (pixelHits[i]._col - pixelHits[j]._col);
                                        if (deltax > 0) {
                                                deltax = deltax + 1;
                                        }
                                        if (deltax < 0) {
                                                deltax = deltax - 1;
                                        }
                                        double deltay = (pixelHits[i]._row - pixelHits[j]._row);
                                        if (deltay > 0) {
                                                deltay = deltay + 1;
                                        }
                                        if (deltay < 0) {
                                                deltay = deltay - 1;
                                        }
                                        tempDistance = sqrt(deltax * deltax + deltay * deltay);
                                        clusterSize = max(clusterSize, tempDistance);
                                }
                        }
                }
                clusterReady = true;
        }

        void printPixels() {
                for (size_t i = 0; i < pixelHits.size(); i++) {
                        cout << "pixelHit x:" << pixelHits[i]._col << ", y:" << pixelHits[i]._row << " on sensor "
                            << pixelHits[i]._sensorId << "\n";
                }
        }
        void printCenter() {
                cout << "clusterCenter x:" << centerCol << ", y:" << centerRow << " on sensor " << _sensorId
                    << ", contains " << pixelHits.size() << " pixels and is " << clusterSize
                    << " pixels in diameter." << "\n";
        }
};

#endif /* LMD_LMDSENSORALIGNMENT_PNDLMDALIGNSTRUCTS_H_ */