rebase

src/core/detector/Detector.cpp

@@ -168,159 +168,3 @@ Configuration Detector::GetConfiguration() const {
 
     return config;
 }
-
-// Function to get global intercept with a track
-PositionVector3D<Cartesian3D<double>> Detector::getIntercept(const Track* track) const {
-
-    // FIXME: this is else statement can only be temporary
-    if(track->getType() == "gbl") {
-        return track->state(name());
-    } else {
-        // Get the distance from the plane to the track initial state
-        double distance = (m_origin.X() - track->state(m_detectorName).X()) * m_normal.X();
-        distance += (m_origin.Y() - track->state(m_detectorName).Y()) * m_normal.Y();
-        distance += (m_origin.Z() - track->state(m_detectorName).Z()) * m_normal.Z();
-        distance /=
-            (track->direction(m_detectorName).X() * m_normal.X() + track->direction(m_detectorName).Y() * m_normal.Y() +
-             track->direction(m_detectorName).Z() * m_normal.Z());
-
-        // Propagate the track
-        PositionVector3D<Cartesian3D<double>> globalIntercept(
-            track->state(m_detectorName).X() + distance * track->direction(m_detectorName).X(),
-            track->state(m_detectorName).Y() + distance * track->direction(m_detectorName).Y(),
-            track->state(m_detectorName).Z() + distance * track->direction(m_detectorName).Z());
-        return globalIntercept;
-    }
-}
-
-PositionVector3D<Cartesian3D<double>> Detector::getLocalIntercept(const Track* track) const {
-    return globalToLocal(getIntercept(track));
-}
-
-// Function to check if a track intercepts with a plane
-bool Detector::hasIntercept(const Track* track, double pixelTolerance) const {
-
-    // First, get the track intercept in global co-ordinates with the plane
-    PositionVector3D<Cartesian3D<double>> globalIntercept = this->getIntercept(track);
-
-    // Convert to local co-ordinates
-    PositionVector3D<Cartesian3D<double>> localIntercept = this->m_globalToLocal * globalIntercept;
-
-    // Get the row and column numbers
-    double row = this->getRow(localIntercept);
-    double column = this->getColumn(localIntercept);
-
-    // Check if the row and column are outside of the chip
-    // Chip reaches from -0.5 to nPixels-0.5
-    bool intercept = true;
-    if(row < pixelTolerance - 0.5 || row > (this->m_nPixels.Y() - pixelTolerance - 0.5) || column < pixelTolerance - 0.5 ||
-       column > (this->m_nPixels.X() - pixelTolerance - 0.5))
-        intercept = false;
-
-    return intercept;
-}
-
-// Function to check if a track goes through/near a masked pixel
-bool Detector::hitMasked(Track* track, int tolerance) const {
-
-    // First, get the track intercept in global co-ordinates with the plane
-    PositionVector3D<Cartesian3D<double>> globalIntercept = this->getIntercept(track);
-
-    // Convert to local co-ordinates
-    PositionVector3D<Cartesian3D<double>> localIntercept = this->m_globalToLocal * globalIntercept;
-
-    // Get the row and column numbers
-    int row = static_cast<int>(floor(this->getRow(localIntercept) + 0.5));
-    int column = static_cast<int>(floor(this->getColumn(localIntercept) + 0.5));
-
-    // Check if the pixels around this pixel are masked
-    bool hitmasked = false;
-    for(int r = (row - tolerance); r <= (row + tolerance); r++) {
-        for(int c = (column - tolerance); c <= (column + tolerance); c++) {
-            if(this->masked(c, r))
-                hitmasked = true;
-        }
-    }
-
-    return hitmasked;
-}
-
-// Functions to get row and column from local position
-double Detector::getRow(const PositionVector3D<Cartesian3D<double>> localPosition) const {
-
-    double row = localPosition.Y() / m_pitch.Y() + static_cast<double>(m_nPixels.Y() - 1) / 2.;
-    return row;
-}
-
-double Detector::getColumn(const PositionVector3D<Cartesian3D<double>> localPosition) const {
-
-    double column = localPosition.X() / m_pitch.X() + static_cast<double>(m_nPixels.X() - 1) / 2.;
-    return column;
-}
-
-// Function to get local position from row and column
-PositionVector3D<Cartesian3D<double>> Detector::getLocalPosition(double column, double row) const {
-
-    return PositionVector3D<Cartesian3D<double>>(
-        m_pitch.X() * (column - (m_nPixels.X() - 1) / 2.), m_pitch.Y() * (row - (m_nPixels.Y() - 1) / 2.), 0.);
-}
-
-// Function to get in-pixel position
-ROOT::Math::XYVector Detector::inPixel(const double column, const double row) const {
-    // a pixel ranges from (col-0.5) to (col+0.5)
-    return XYVector(m_pitch.X() * (column - floor(column) - 0.5), m_pitch.Y() * (row - floor(row) - 0.5));
-}
-
-ROOT::Math::XYVector Detector::inPixel(const PositionVector3D<Cartesian3D<double>> localPosition) const {
-    double column = getColumn(localPosition);
-    double row = getRow(localPosition);
-    return inPixel(column, row);
-}
-
-// Check if track position is within ROI:
-bool Detector::isWithinROI(const Track* track) const {
-
-    // Empty region of interest:
-    if(m_roi.empty()) {
-        return true;
-    }
-
-    // Check that track is within region of interest using winding number algorithm
-    auto localIntercept = this->getLocalIntercept(track);
-    auto coordinates = std::make_pair(this->getColumn(localIntercept), this->getRow(localIntercept));
-    if(winding_number(coordinates, m_roi) != 0) {
-        return true;
-    }
-
-    // Outside ROI:
-    return false;
-}
-
-// Check if cluster is within ROI and/or touches ROI border:
-bool Detector::isWithinROI(Cluster* cluster) const {
-
-    // Empty region of interest:
-    if(m_roi.empty()) {
-        return true;
-    }
-
-    // Loop over all pixels of the cluster
-    for(auto& pixel : cluster->pixels()) {
-        if(winding_number(pixel->coordinates(), m_roi) == 0) {
-            return false;
-        }
-    }
-    return true;
-}
-
-/* isLeft(): tests if a point is Left|On|Right of an infinite line.
- * via: http://geomalgorithms.com/a03-_inclusion.html
- *    Input:  three points P0, P1, and P2
- *    Return: >0 for P2 left of the line through P0 and P1
- *            =0 for P2  on the line
- *            <0 for P2  right of the line
- *    See: Algorithm 1 "Area of Triangles and Polygons"
- */
-int Detector::isLeft(std::pair<int, int> pt0, std::pair<int, int> pt1, std::pair<int, int> pt2) {
-    return ((pt1.first - pt0.first) * (pt2.second - pt0.second) - (pt2.first - pt0.first) * (pt1.second - pt0.second));
-}

src/core/detector/PixelDetector.cpp

@@ -271,13 +271,13 @@ bool PixelDetector::hitMasked(Track* track, int tolerance) const {
 
 // Functions to get row and column from local position
 double PixelDetector::getRow(const PositionVector3D<Cartesian3D<double>> localPosition) const {
-    // (1-m_nPixelsX%2)/2. --> add 1/2 pixel pitch if even number of rows
-    double row = localPosition.Y() / m_pitch.Y() + static_cast<double>(m_nPixels.Y()) / 2. + (1 - m_nPixels.Y() % 2) / 2.;
+
+    double row = localPosition.Y() / m_pitch.Y() + static_cast<double>(m_nPixels.Y() - 1) / 2.;
     return row;
 }
 double PixelDetector::getColumn(const PositionVector3D<Cartesian3D<double>> localPosition) const {
-    // (1-m_nPixelsX%2)/2. --> add 1/2 pixel pitch if even number of columns
-    double column = localPosition.X() / m_pitch.X() + static_cast<double>(m_nPixels.X()) / 2. + (1 - m_nPixels.X() % 2) / 2.;
+
+    double column = localPosition.X() / m_pitch.X() + static_cast<double>(m_nPixels.X() - 1) / 2.;
     return column;
 }
 
@@ -285,7 +285,7 @@ double PixelDetector::getColumn(const PositionVector3D<Cartesian3D<double>> loca
 PositionVector3D<Cartesian3D<double>> PixelDetector::getLocalPosition(double column, double row) const {
 
     return PositionVector3D<Cartesian3D<double>>(
-        m_pitch.X() * (column - m_nPixels.X() / 2), m_pitch.Y() * (row - m_nPixels.Y() / 2), 0.);
+        m_pitch.X() * (column - (m_nPixels.X() - 1) / 2.), m_pitch.Y() * (row - (m_nPixels.Y() - 1) / 2.), 0.);
 }
 
 // Function to get in-pixel position