updated pass criteria for test to match the errors associated with...

updated pass criteria for test to match the errors associated with efficiencies printed. The test still fails

src/modules/AnalysisDUT/AnalysisDUT.cpp

@@ -419,6 +419,54 @@ void AnalysisDUT::initialize() {
                           -pitch_y / 2.,
                           pitch_y / 2.);
 
+    title = "Mean cluster charge map (1-pixel);" + mod_axes + "<cluster charge> [ke]";
+    qvsxmym_1px = new TProfile2D("qvsxmym_1px",
+                                 title.c_str(),
+                                 static_cast<int>(pitch_x),
+                                 -pitch_x / 2.,
+                                 pitch_x / 2.,
+                                 static_cast<int>(pitch_y),
+                                 -pitch_y / 2.,
+                                 pitch_y / 2.,
+                                 0,
+                                 250);
+
+    title = "Mean cluster charge map (2-pixel);" + mod_axes + "<cluster charge> [ke]";
+    qvsxmym_2px = new TProfile2D("qvsxmym_2px",
+                                 title.c_str(),
+                                 static_cast<int>(pitch_x),
+                                 -pitch_x / 2.,
+                                 pitch_x / 2.,
+                                 static_cast<int>(pitch_y),
+                                 -pitch_y / 2.,
+                                 pitch_y / 2.,
+                                 0,
+                                 250);
+
+    title = "Mean cluster charge map (3-pixel);" + mod_axes + "<cluster charge> [ke]";
+    qvsxmym_3px = new TProfile2D("qvsxmym_3px",
+                                 title.c_str(),
+                                 static_cast<int>(pitch_x),
+                                 -pitch_x / 2.,
+                                 pitch_x / 2.,
+                                 static_cast<int>(pitch_y),
+                                 -pitch_y / 2.,
+                                 pitch_y / 2.,
+                                 0,
+                                 250);
+
+    title = "Mean cluster charge map (4-pixel);" + mod_axes + "<cluster charge> [ke]";
+    qvsxmym_4px = new TProfile2D("qvsxmym_4px",
+                                 title.c_str(),
+                                 static_cast<int>(pitch_x),
+                                 -pitch_x / 2.,
+                                 pitch_x / 2.,
+                                 static_cast<int>(pitch_y),
+                                 -pitch_y / 2.,
+                                 pitch_y / 2.,
+                                 0,
+                                 250);
+
     residualsTime = new TH1F("residualsTime",
                              "Time residual;time_{track}-time_{hit} [ns];#entries",
                              n_timebins_,
@@ -634,8 +682,8 @@ StatusCode AnalysisDUT::run(const std::shared_ptr<Clipboard>& clipboard) {
 
         // Calculate in-pixel position of track in microns
         auto inpixel = m_detector->inPixel(localIntercept);
-        auto xmod = inpixel.X() * 1000.; // convert mm -> um
-        auto ymod = inpixel.Y() * 1000.; // convert mm -> um
+        auto xmod_um = inpixel.X() * 1000.; // convert mm -> um
+        auto ymod_um = inpixel.Y() * 1000.; // convert mm -> um
 
         // Loop over all associated DUT clusters:
         for(auto assoc_cluster : track->getAssociatedClusters(m_detector->getName())) {
@@ -752,11 +800,11 @@ StatusCode AnalysisDUT::run(const std::shared_ptr<Clipboard>& clipboard) {
             clusterWidthColAssoc->Fill(static_cast<double>(assoc_cluster->columnWidth()));
 
             // Fill in-pixel plots: (all as function of track position within pixel cell)
-            qvsxmym->Fill(xmod, ymod, cluster_charge);                     // cluster charge profile
-            qMoyalvsxmym->Fill(xmod, ymod, exp(-normalized_charge / 3.5)); // norm. cluster charge profile
+            qvsxmym->Fill(xmod_um, ymod_um, cluster_charge);                     // cluster charge profile
+            qMoyalvsxmym->Fill(xmod_um, ymod_um, exp(-normalized_charge / 3.5)); // norm. cluster charge profile
 
             // mean charge of cluster seed
-            pxqvsxmym->Fill(xmod, ymod, assoc_cluster->getSeedPixel()->charge());
+            pxqvsxmym->Fill(xmod_um, ymod_um, assoc_cluster->getSeedPixel()->charge());
 
             if(assoc_cluster->size() > 1) {
                 for(auto& px : assoc_cluster->pixels()) {
@@ -790,20 +838,28 @@ StatusCode AnalysisDUT::run(const std::shared_ptr<Clipboard>& clipboard) {
             }
 
             // mean cluster size
-            npxvsxmym->Fill(xmod, ymod, static_cast<double>(assoc_cluster->size()));
-            if(assoc_cluster->size() == 1)
-                npx1vsxmym->Fill(xmod, ymod);
-            if(assoc_cluster->size() == 2)
-                npx2vsxmym->Fill(xmod, ymod);
-            if(assoc_cluster->size() == 3)
-                npx3vsxmym->Fill(xmod, ymod);
-            if(assoc_cluster->size() == 4)
-                npx4vsxmym->Fill(xmod, ymod);
+            npxvsxmym->Fill(xmod_um, ymod_um, static_cast<double>(assoc_cluster->size()));
+            if(assoc_cluster->size() == 1) {
+                npx1vsxmym->Fill(xmod_um, ymod_um);
+                qvsxmym_1px->Fill(xmod_um, ymod_um, cluster_charge);
+            }
+            if(assoc_cluster->size() == 2) {
+                npx2vsxmym->Fill(xmod_um, ymod_um);
+                qvsxmym_2px->Fill(xmod_um, ymod_um, cluster_charge);
+            }
+            if(assoc_cluster->size() == 3) {
+                npx3vsxmym->Fill(xmod_um, ymod_um);
+                qvsxmym_3px->Fill(xmod_um, ymod_um, cluster_charge);
+            }
+            if(assoc_cluster->size() == 4) {
+                npx4vsxmym->Fill(xmod_um, ymod_um);
+                qvsxmym_4px->Fill(xmod_um, ymod_um, cluster_charge);
+            }
 
             // residual MAD x, y, combined (sqrt(x*x + y*y))
-            rmsxvsxmym->Fill(xmod, ymod, xabsdistance);
-            rmsyvsxmym->Fill(xmod, ymod, yabsdistance);
-            rmsxyvsxmym->Fill(xmod, ymod, fabs(sqrt(xdistance * xdistance + ydistance * ydistance)));
+            rmsxvsxmym->Fill(xmod_um, ymod_um, xabsdistance);
+            rmsyvsxmym->Fill(xmod_um, ymod_um, yabsdistance);
+            rmsxyvsxmym->Fill(xmod_um, ymod_um, fabs(sqrt(xdistance * xdistance + ydistance * ydistance)));
 
             hAssociatedTracksGlobalPosition->Fill(globalIntercept.X(), globalIntercept.Y());
             hAssociatedTracksLocalPosition->Fill(m_detector->getColumn(localIntercept), m_detector->getRow(localIntercept));

src/modules/AnalysisDUT/AnalysisDUT.h

@@ -74,6 +74,7 @@ namespace corryvreckan {
 
         TProfile2D *rmsxvsxmym, *rmsyvsxmym, *rmsxyvsxmym;
         TProfile2D *qvsxmym, *qMoyalvsxmym, *pxqvsxmym;
+        TProfile2D *qvsxmym_1px, *qvsxmym_2px, *qvsxmym_3px, *qvsxmym_4px;
         TProfile2D* npxvsxmym;
         TH2F *npx1vsxmym, *npx2vsxmym, *npx3vsxmym, *npx4vsxmym;
 

src/modules/AnalysisEfficiency/AnalysisEfficiency.cpp

@@ -23,14 +23,14 @@ AnalysisEfficiency::AnalysisEfficiency(Configuration& config, std::shared_ptr<De
     config_.setDefault<double>("time_cut_frameedge", Units::get<double>(20, "ns"));
     config_.setDefault<double>("chi2ndof_cut", 3.);
     config_.setDefault<double>("inpixel_bin_size", Units::get<double>(1.0, "um"));
-    config_.setDefault<double>("inpixel_cut_edge", Units::get<double>(5., "um"));
+    config_.setDefault<XYVector>("inpixel_cut_edge", {Units::get(5.0, "um"), Units::get(5.0, "um")});
     config_.setDefault<double>("masked_pixel_distance_cut", 1.);
 
     m_timeCutFrameEdge = config_.get<double>("time_cut_frameedge");
     m_chi2ndofCut = config_.get<double>("chi2ndof_cut");
     m_inpixelBinSize = config_.get<double>("inpixel_bin_size");
     require_associated_cluster_on_ = config_.getArray<std::string>("require_associated_cluster_on", {});
-    m_inpixelEdgeCut = config_.get<double>("inpixel_cut_edge");
+    m_inpixelEdgeCut = config_.get<XYVector>("inpixel_cut_edge");
     m_maskedPixelDistanceCut = config_.get<int>("masked_pixel_distance_cut");
 }
 
@@ -74,6 +74,19 @@ void AnalysisEfficiency::initialize() {
                                                    -pitch_y / 2.,
                                                    pitch_y / 2.);
 
+    title = m_detector->getName() +
+            " Pixel efficiency map (in-pixel ROI);in-pixel x_{track} [#mum];in-pixel y_{track} #mum;#epsilon";
+    hPixelEfficiencyMap_inPixelROI_trackPos_TProfile = new TProfile2D("pixelEfficiencyMap_inPixelROI_trackPos_TProfile",
+                                                                      title.c_str(),
+                                                                      nbins_x,
+                                                                      -pitch_x / 2.,
+                                                                      pitch_x / 2.,
+                                                                      nbins_y,
+                                                                      -pitch_y / 2.,
+                                                                      pitch_y / 2.,
+                                                                      0,
+                                                                      1);
+
     title = m_detector->getName() + " Chip efficiency map;x [px];y [px];#epsilon";
     hChipEfficiencyMap_trackPos_TProfile = new TProfile2D("chipEfficiencyMap_trackPos_TProfile",
                                                           title.c_str(),
@@ -180,6 +193,8 @@ void AnalysisEfficiency::initialize() {
                                       -1.5 * m_detector->getPitch().y(),
                                       1.5 * m_detector->getPitch().y());
     eTotalEfficiency = new TEfficiency("eTotalEfficiency", "totalEfficiency;;#epsilon", 1, 0, 1);
+    eTotalEfficiency_inPixelROI = new TEfficiency(
+        "eTotalEfficiency_inPixelROI", "eTotalEfficiency_inPixelROI;;#epsilon (within in-pixel ROI)", 1, 0, 1);
 
     efficiencyColumns = new TEfficiency("efficiencyColumns",
                                         "Efficiency vs. column number; column; #epsilon",
@@ -268,8 +283,8 @@ StatusCode AnalysisEfficiency::run(const std::shared_ptr<Clipboard>& clipboard)
     // Get the telescope tracks from the clipboard
     auto tracks = clipboard->getData<Track>();
 
-    auto pitch_x = static_cast<double>(Units::convert(m_detector->getPitch().X(), "um"));
-    auto pitch_y = static_cast<double>(Units::convert(m_detector->getPitch().Y(), "um"));
+    auto pitch_x = m_detector->getPitch().X();
+    auto pitch_y = m_detector->getPitch().Y();
 
     // Loop over all tracks
     for(auto& track : tracks) {
@@ -353,8 +368,13 @@ StatusCode AnalysisEfficiency::run(const std::shared_ptr<Clipboard>& clipboard)
 
         // Calculate in-pixel position of track in microns
         auto inpixel = m_detector->inPixel(localIntercept);
-        auto xmod = static_cast<double>(Units::convert(inpixel.X(), "um"));
-        auto ymod = static_cast<double>(Units::convert(inpixel.Y(), "um"));
+        auto xmod = inpixel.X();
+        auto ymod = inpixel.Y();
+        auto xmod_um = xmod * 1000.; // mm->um (for plotting)
+        auto ymod_um = ymod * 1000.; // mm->um (for plotting)
+
+        bool isWithinInPixelROI =
+            (pitch_x - abs(xmod * 2) > m_inpixelEdgeCut.x()) && (pitch_y - abs(ymod * 2) > m_inpixelEdgeCut.y());
 
         // Get the DUT clusters from the clipboard, that are assigned to the track
         auto associated_clusters = track->getAssociatedClusters(m_detector->getName());
@@ -366,8 +386,10 @@ StatusCode AnalysisEfficiency::run(const std::shared_ptr<Clipboard>& clipboard)
             for(auto& pixel : pixels) {
                 if((pixel->column() == static_cast<int>(m_detector->getColumn(localIntercept)) &&
                     pixel->row() == static_cast<int>(m_detector->getRow(localIntercept))) &&
-                   (pitch_x - abs(xmod * 2) < m_inpixelEdgeCut || pitch_y - abs(ymod * 2) < m_inpixelEdgeCut))
+                   isWithinInPixelROI) {
                     hPixelEfficiencyMatrix_TProfile->Fill(pixel->column(), pixel->row(), 1);
+                    break; // There cannot be a second pixel within the cluster through which the track goes.
+                }
             }
 
             auto clusterLocal = m_detector->globalToLocal(cluster->global());
@@ -387,10 +409,10 @@ StatusCode AnalysisEfficiency::run(const std::shared_ptr<Clipboard>& clipboard)
                 has_associated_cluster, m_detector->getColumn(clusterLocal), m_detector->getRow(clusterLocal));
         }
 
-        if(!has_associated_cluster &&
-           (pitch_x - abs(xmod * 2) < m_inpixelEdgeCut || pitch_y - abs(ymod * 2) < m_inpixelEdgeCut))
+        if(!has_associated_cluster && isWithinInPixelROI) {
             hPixelEfficiencyMatrix_TProfile->Fill(
                 m_detector->getColumn(localIntercept), m_detector->getRow(localIntercept), 0);
+        }
 
         hGlobalEfficiencyMap_trackPos_TProfile->Fill(globalIntercept.X(), globalIntercept.Y(), has_associated_cluster);
         hGlobalEfficiencyMap_trackPos->Fill(has_associated_cluster, globalIntercept.X(), globalIntercept.Y());
@@ -402,12 +424,17 @@ StatusCode AnalysisEfficiency::run(const std::shared_ptr<Clipboard>& clipboard)
 
         // For pixels, only look at the ROI:
         if(is_within_roi) {
-            hPixelEfficiencyMap_trackPos_TProfile->Fill(xmod, ymod, has_associated_cluster);
-            hPixelEfficiencyMap_trackPos->Fill(has_associated_cluster, xmod, ymod);
+            hPixelEfficiencyMap_trackPos_TProfile->Fill(xmod_um, ymod_um, has_associated_cluster);
+            hPixelEfficiencyMap_trackPos->Fill(has_associated_cluster, xmod_um, ymod_um);
             eTotalEfficiency->Fill(has_associated_cluster, 0); // use 0th bin for total efficiency
             efficiencyColumns->Fill(has_associated_cluster, m_detector->getColumn(localIntercept));
             efficiencyRows->Fill(has_associated_cluster, m_detector->getRow(localIntercept));
             efficiencyVsTime->Fill(has_associated_cluster, track->timestamp() / 1e9); // convert nanoseconds to seconds
+
+            if(isWithinInPixelROI) {
+                hPixelEfficiencyMap_inPixelROI_trackPos_TProfile->Fill(xmod_um, ymod_um, has_associated_cluster);
+                eTotalEfficiency_inPixelROI->Fill(has_associated_cluster, 0); // use 0th bin for total efficiency
+            }
         }
 
         auto intercept_col = static_cast<size_t>(m_detector->getColumn(localIntercept));

src/modules/AnalysisEfficiency/AnalysisEfficiency.h

@@ -48,6 +48,7 @@ namespace corryvreckan {
 
         // Profile version
         TProfile2D* hPixelEfficiencyMap_trackPos_TProfile;
+        TProfile2D* hPixelEfficiencyMap_inPixelROI_trackPos_TProfile;
         TProfile2D* hChipEfficiencyMap_trackPos_TProfile;
         TProfile2D* hPixelEfficiencyMatrix_TProfile;
         TProfile2D* hGlobalEfficiencyMap_trackPos_TProfile;
@@ -61,6 +62,7 @@ namespace corryvreckan {
         TEfficiency* hGlobalEfficiencyMap_clustPos;
 
         TEfficiency* eTotalEfficiency;
+        TEfficiency* eTotalEfficiency_inPixelROI;
         TEfficiency* efficiencyColumns;
         TEfficiency* efficiencyRows;
         TEfficiency* efficiencyVsTime;
@@ -78,7 +80,8 @@ namespace corryvreckan {
         TH2D* hPosDiffPrevTrack_assocCluster;
         TH2D* hPosDiffPrevTrack_noAssocCluster;
         TH2D* hDistanceCluster_track;
-        double m_chi2ndofCut, m_timeCutFrameEdge, m_inpixelBinSize, m_inpixelEdgeCut;
+        double m_chi2ndofCut, m_timeCutFrameEdge, m_inpixelBinSize;
+        XYVector m_inpixelEdgeCut;
         int m_maskedPixelDistanceCut = 1;
         int total_tracks = 0;
         int matched_tracks = 0;

src/modules/AnalysisEfficiency/README.md

@@ -19,7 +19,7 @@ More information can be found in the ROOT `TEfficiency` class reference, section
 * `time_cut_frameedge`: Parameter to discard telescope tracks at the frame edges (start and end of the current event window). Defaults to `20ns`.
 * `chi2ndof_cut`: Acceptance criterion for telescope tracks, defaults to a value of `3`.
 * `inpixel_bin_size`: Parameter to set the bin size of the in-pixel 2D efficiency histogram. This should be given in units of distance and the same value is used in both axes. Defaults to `1.0um`.
-* `inpixel_cut_edge`: Parameter to exclude tracks going within a cut-distance to the pixel edge. Defaults to `5um`.
+* `inpixel_cut_edge`: Parameter to exclude tracks going within a cut-distance to the pixel edge. Effectively defines an in-pixel ROI. Defaults to `5um`.
 * `masked_pixel_distance_cut`: Distance (in pixels) to exclude tracks passing close to masked pixel. Defaults to `1`.
 * `require_associated_cluster_on`: Names of detectors which are required to have an associated cluster to the telescope tracks. Detectors listed here must be marked as `role = DUT` in the detector configuration file. Only tracks satisfying this requirement are accepted for the efficiency measurement. If empty, no detector is required. Default is empty.
 
@@ -28,9 +28,9 @@ More information can be found in the ROOT `TEfficiency` class reference, section
 For the DUT, the following plots are produced:
 
 * 2D histograms:
-  * 2D Map of in-pixel efficiency
+  * 2D Map of in-pixel efficiency and in-pixel efficiency within in-pixel ROI
   * 2D Maps of chip efficiency in local and global coordinates, filled at the position of the track intercept point or at the position of the associated cluster center
-  * 2D Map of pixel efficiency, for the full matrix, filled at the pixel (of the associated cluster) through which the track goes, constrained to an inpixel-ROI defined by `inpixel_cut_edge`.
+  * 2D Map of pixel efficiency, for the full matrix, filled at the pixel (of the associated cluster) through which the track goes, constrained to an in-pixel ROI defined by `inpixel_cut_edge`.
   * 2D Maps of the position difference of a track with and without associated cluster to the previous track
   * 2D Map of the distance between track intersection and associated cluster
 
@@ -42,7 +42,7 @@ For the DUT, the following plots are produced:
   * Distribution of cluster-track distances
 
 * Other:
-  * Value of total efficiency as `TEfficiency` including (asymmetric) error bars
+  * Value of total efficiency as `TEfficiency` including (asymmetric) error bars (total and restricted to in-pixel ROI)
   * Efficiency as function of column and row, and vs. time