Merge branch '24.0-afp-mon-tof-sit-corr_check' into 'main'

algorithm for tof-sit correlation

See merge request atlas/athena!68701

DataQuality/DataQualityConfigurations/config/AFP/collisions_run.config

@@ -542,7 +542,13 @@ dir AFP {
 	dir ToFSiTCorr {
 		output = AFP/ToFSiTCorr
 		display = Draw=COLZ
-		hist ToFSiTCorr[XY][AC] {
+		hist ToFSiTCorrXA {
+			algorithm = AFPToFSiTCorrCheck/sideA
+		}
+		hist ToFSiTCorrXC {
+			algorithm = AFPToFSiTCorrCheck/sideC
+		}
+		hist ToFSiTCorrY[AC] {
 			regex = 1
 		}
 		hist ToFSiTCorrTight[XY][AC] {
@@ -827,6 +833,19 @@ algorithm AFPLBsOutOfRange {
 	}
 }
 
+algorithm AFPToFSiTCorrCheck {
+	libname = libdqm_algorithms.so
+	name = AFP_ToFSiTCorrCheck
+	pronounciation_level = 1.15
+	thresholds = AFPToFSiTCorrCheckThreshold
+	algorithm sideA {
+			RANGES = "13,69,73,132,137,238,241,300"
+	}
+	algorithm sideC {
+			RANGES = "13,78,83,142,147,245,250,300"
+	}
+}
+
 algorithm AFPToFEfficiency {
 	libname = libdqm_algorithms.so
 	name = AFP_ToFEfficiency
@@ -866,6 +885,17 @@ thresholds AFPLBsOutOfRangeTrackFE {
 	}
 }
 
+thresholds AFPToFSiTCorrCheckThreshold {
+	limits NbadTrains {
+		warning = 1
+		error = 2
+	}
+	limits NbadStairs {
+		warning = 1
+		error = 3
+	}
+}
+
 thresholds AFPToFEfficiencyThreshold {
 	limits NbadTrains {
 		warning = 1

DataQuality/dqm_algorithms/dqm_algorithms/AFP_ToFSiTCorrCheck.h

+/*
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef DQM_Algorithms_AFP_ToFSiTCorrCheck_H
+#define DQM_Algorithms_AFP_ToFSiTCorrCheck_H
+
+#include <dqm_core/Algorithm.h>
+#include <dqm_core/AlgorithmConfig.h>
+#include <dqm_core/Result.h>
+
+#include <TObject.h>
+
+#include <map>
+#include <ostream>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace dqm_algorithms {
+    class AFP_ToFSiTCorrCheck : public dqm_core::Algorithm {
+      public:
+        AFP_ToFSiTCorrCheck();
+
+        AFP_ToFSiTCorrCheck* clone() override;
+        dqm_core::Result* execute( const std::string& name, const TObject& object, const dqm_core::AlgorithmConfig& config ) override;
+        void printDescriptionTo( std::ostream& out ) override;
+
+    };
+} // namespace dqm_algorithms
+
+#endif // DQM_Algorithms_AFP_ToFSiTCorrCheck_H

DataQuality/dqm_algorithms/dqm_algorithms/dqm_algorithmsDict.h

 /*
-  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 
 #ifndef DQM_ALGORITHMS_DQM_ALGORITHMSDICT_H
 #define DQM_ALGORITHMS_DQM_ALGORITHMSDICT_H
 
-#include "dqm_algorithms/AFP_LBsOutOfRange.h"
 #include "dqm_algorithms/AddReference.h"
 #include "dqm_algorithms/AddReference_All_Bins_Filled.h"
 #include "dqm_algorithms/AddReference_BinContentComp.h"
@@ -17,6 +16,7 @@
 #include "dqm_algorithms/AddReference_Bins_LessThan_Threshold.h"
 #include "dqm_algorithms/AddReference_Bins_NotEqual_Threshold.h"
 #include "dqm_algorithms/AFP_LBsOutOfRange.h"
+#include "dqm_algorithms/AFP_ToFSiTCorrCheck.h"
 #include "dqm_algorithms/AFP_ToFEfficiency.h"
 #include "dqm_algorithms/All_Bins_Filled.h"
 #include "dqm_algorithms/AveragePrint.h"

DataQuality/dqm_algorithms/dqm_algorithms/selection.xml

@@ -11,6 +11,7 @@
   <class name="dqm_algorithms::AddReference_Bins_LessThan_Threshold"/>
   <class name="dqm_algorithms::AddReference_Bins_NotEqual_Threshold"/>
   <class name="dqm_algorithms::AFP_LBsOutOfRange"/>
+  <class name="dqm_algorithms::AFP_ToFSiTCorrCheck"/>
   <class name="dqm_algorithms::AFP_ToFEfficiency"/>
   <class name="dqm_algorithms::All_Bins_Filled"/>
   <class name="dqm_algorithms::AveragePrint"/>

DataQuality/dqm_algorithms/dqm_algorithms/tools/AlgorithmHelper.h

@@ -87,6 +87,13 @@ namespace dqm_algorithms
 
     double GetFirstFromMap(const std::string &paramName, const std::map<std::string, double > &params, double defaultValue);
     // optional: returns defaultValue if the parameter is not found
+
+    //string overloads
+    const std::string& GetFirstFromMap(const std::string &paramName, const std::map<std::string, std::string > &params);
+    // mandatory: throws an exception if the parameter is not found
+
+    const std::string& GetFirstFromMap(const std::string &paramName, const std::map<std::string, std::string > &params, const std::string& defaultValue);
+    // optional: returns defaultValue if the parameter is not found
     
     std::vector<int> GetBinRange(const TH1* histogram, const std::map<std::string, double > & params);
   

DataQuality/dqm_algorithms/src/AFP_ToFSiTCorrCheck.cxx

+/*
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "dqm_algorithms/AFP_ToFSiTCorrCheck.h"
+
+#include <dqm_algorithms/tools/AlgorithmHelper.h>
+#include <dqm_core/AlgorithmManager.h>
+#include "dqm_core/AlgorithmConfig.h"
+#include <dqm_core/exceptions.h>
+
+#include <TDirectory.h>
+#include <TH1.h>
+#include <TH2.h>
+#include <TFile.h>
+
+namespace {
+    static dqm_algorithms::AFP_ToFSiTCorrCheck instance;
+}
+
+dqm_algorithms::AFP_ToFSiTCorrCheck::AFP_ToFSiTCorrCheck() {
+    dqm_core::AlgorithmManager::instance().registerAlgorithm( "AFP_ToFSiTCorrCheck", this );
+}
+
+
+dqm_algorithms::AFP_ToFSiTCorrCheck*
+dqm_algorithms::AFP_ToFSiTCorrCheck::clone() {
+    return new AFP_ToFSiTCorrCheck();
+}
+
+dqm_core::Result*
+dqm_algorithms::AFP_ToFSiTCorrCheck::execute( const std::string& name,
+                                            const TObject& object,
+                                            const dqm_core::AlgorithmConfig& config ) {
+    if ( !object.IsA()->InheritsFrom( "TH2" ) ) {
+        throw dqm_core::BadConfig( ERS_HERE, name, "does not inherit from TH2" );
+    }
+
+    auto histogram = static_cast<const TH2*>( &object );
+    
+    if ( histogram->GetDimension() > 2 ) {
+        throw dqm_core::BadConfig( ERS_HERE, name, "histogram has more than 2 dimensions" );
+    }
+
+    auto gthreshold_tr = static_cast<uint32_t>( dqm_algorithms::tools::GetFromMap( "NbadTrains", config.getGreenThresholds() ) );
+    auto rthreshold_tr = static_cast<uint32_t>( dqm_algorithms::tools::GetFromMap( "NbadTrains", config.getRedThresholds() ) );
+    auto gthreshold_st = static_cast<uint32_t>( dqm_algorithms::tools::GetFromMap( "NbadStairs", config.getGreenThresholds() ) );
+    auto rthreshold_st = static_cast<uint32_t>( dqm_algorithms::tools::GetFromMap( "NbadStairs", config.getRedThresholds() ) );
+    auto pronounciation_level   = static_cast<double>( dqm_algorithms::tools::GetFirstFromMap( "pronounciation_level", config.getParameters() ) );
+    const std::string RANGES = dqm_algorithms::tools::GetFirstFromMap( "RANGES", config.getGenericParameters() );
+
+    //from string of ranges to int array
+    int y_bins[8] = {};
+    std::string s = RANGES;
+    std::string delimiter = ",";
+    uint32_t pos = 0;
+    s.erase(s.begin());
+    s.pop_back();
+    for (uint32_t i = 0; i < 8; ++i) 
+    {
+        pos = s.find(delimiter);
+        y_bins[i] = stoi(s.substr(0, pos));
+        s.erase(0, pos + delimiter.length());
+    } 
+
+    //from 2D hist to projections of each train and get bin content 
+    const std::string trains[4] = {"0", "1", "2", "3"};
+    auto projections_tr = std::vector<TH1D *>(4);
+    int max_bins[4] = {};
+    float max_bins_content[4] = {};
+    float all_bins_content[4][4] = {};
+
+    for (uint32_t i = 0; i < 4; ++i)
+    {
+        projections_tr[i] = new TH1D(("projections_tr"+trains[i]).c_str(),("projections_tr"+trains[i]).c_str(), 16, 0, 4);
+        projections_tr[i] = histogram->ProjectionX(("projections_tr"+trains[i]).c_str(), y_bins[i*2], y_bins[i*2+1], "cutg");
+        projections_tr[i]->Rebin(4);
+        max_bins[i] = (projections_tr[i]->GetMaximumBin())-2;
+        max_bins_content[i] = (projections_tr[i]->GetBinContent(max_bins[i]+2));
+        for (size_t j = 0; j < 4; j++)
+            all_bins_content[i][j] = (projections_tr[i]->GetBinContent(j+2));
+    }   
+
+    //check if any train is not max
+    uint32_t false_bins = 0;
+    for (int i = 0; i < 4; ++i)
+    {
+        if (max_bins[i] != i)
+            false_bins++;
+    }
+    uint32_t status_bins = 0;
+    if (false_bins == 0)
+        status_bins = 1; 
+    else if (false_bins == gthreshold_tr)
+        status_bins = 2;
+    else if (false_bins >= rthreshold_tr)
+        status_bins = 3;
+
+    //check on how good pronounce stairs are
+    float check_devided_bins[4][4] = {};
+    int false_bins_devided[4] = {};
+    uint32_t false_bins_devided_tr = 0;
+    for (uint32_t i = 0; i < 4; ++i)
+    {
+        for (uint32_t j = 0; j < 4; ++j)
+            if (i != j) 
+            {
+                check_devided_bins[i][j] = max_bins_content[i]/all_bins_content[i][j];
+                if ((check_devided_bins[i][j] < pronounciation_level) || (check_devided_bins[i][j] > 50))
+                    false_bins_devided[i]++;
+            }  
+        if (false_bins_devided[i] > 1)
+            false_bins_devided_tr++;        
+    }
+    uint32_t status_bins_devided = 0;
+    if (false_bins_devided_tr == 0)
+        status_bins_devided = 1;
+    else if ((false_bins_devided_tr >= gthreshold_st) && (false_bins_devided_tr < rthreshold_st))
+        status_bins_devided = 2;
+    else if (false_bins_devided_tr >= rthreshold_st)
+        status_bins_devided = 3;
+
+    //get general status
+    uint32_t status_general = 0;
+    if (status_bins_devided > status_bins) {status_general = status_bins_devided;}
+    else {status_general = status_bins;}
+
+    auto result = new dqm_core::Result();
+
+    // publish problematic bins
+    result->tags_[ "N Trains on wrong positions/not existing" ] = false_bins;
+    result->tags_[ "N Stairs not pronounced" ] = false_bins_devided_tr;
+
+    if ( status_general == 0 )
+        result->status_ = dqm_core::Result::Undefined;
+    else if ( status_general == 3 )
+        result->status_ = dqm_core::Result::Red;
+    else if ( status_general == 2 )
+        result->status_ = dqm_core::Result::Yellow;
+    else if ( status_general == 1 )
+        result->status_ = dqm_core::Result::Green;
+
+    return result;
+}
+
+void dqm_algorithms::AFP_ToFSiTCorrCheck::printDescriptionTo( std::ostream& out ) {
+    out << "AFP_ToFSiTCorrCheck: Print out how many stairs are not on their places and how many are not pronounced\n"
+        << "Required Parameter: pronounciation_level: how pronounced the stair is\n" 
+        << "Required Parameter: RANGES: ranges of SiT, corresponding to ToF trains, in bins of hist"<< std::endl;
+}

DataQuality/dqm_algorithms/tools/AlgorithmHelper.cxx

@@ -354,7 +354,28 @@ double dqm_algorithms::tools::GetFirstFromMap(const std::string &paramName, cons
     } else {
         return it->second;
     }
-}        	
+}
+
+//string overloads
+const std::string& dqm_algorithms::tools::GetFirstFromMap(const std::string &paramName, const std::map<std::string, std::string > &params)
+{
+    std::map<std::string, std::string >::const_iterator it = params.find(paramName);
+    if (it == params.end()) {
+        throw dqm_core::BadConfig(ERS_HERE, "None", paramName);	// this is the only difference between the two overloaded versions
+    } else {
+        return it->second;
+    }
+}
+
+const std::string& dqm_algorithms::tools::GetFirstFromMap(const std::string &paramName, const std::map<std::string, std::string > &params, const std::string& defaultValue)
+{
+    std::map<std::string, std::string >::const_iterator it = params.find(paramName);
+    if (it == params.end()) {
+        return defaultValue; // this is the only difference between the two overloaded versions
+    } else {
+        return it->second;
+    }
+} 
 
 std::vector<int> dqm_algorithms::tools::GetBinRange(const TH1 *h, const std::map<std::string, double > &params)
 {