AlignPCLThresholdPlotHelper::AlignPCLThresholds_CompareBase< PayloadType, nIOVs, ntags > Class Template Reference

#include <SiPixelAliPCLThresholdsPayloadInspectorHelper.h>

Inheritance diagram for AlignPCLThresholdPlotHelper::AlignPCLThresholds_CompareBase< PayloadType, nIOVs, ntags >:

Public Member Functions
	AlignPCLThresholds_CompareBase ()
bool	fill () override
Public Member Functions inherited from cond::payloadInspector::PlotImage< PayloadType, nIOVs, ntags >
std::shared_ptr< PayloadType >	fetchPayload (const cond::Hash &payloadHash)
	PlotImage (const std::string &title)
std::string	serializeData () override
Public Member Functions inherited from cond::payloadInspector::PlotImpl< IOV_M, NTAGS >
	PlotImpl (const std::string &type, const std::string &title)
std::string	processData () override
	~PlotImpl () override=default
Public Member Functions inherited from cond::payloadInspector::PlotBase
void	addInputParam (const std::string &paramName)
cond::persistency::Session	dbSession ()
template<typename PayloadType >
std::shared_ptr< PayloadType >	fetchPayload (const cond::Hash &payloadHash)
template<int index>
TagReference	getTag ()
cond::Tag_t	getTagInfo (const std::string &tag)
virtual void	init ()
const std::map< std::string, std::string > &	inputParamValues () const
bool	isSingleIov () const
bool	isTwoTags () const
unsigned int	ntags () const
std::string	payloadType () const
	PlotBase ()
std::string	title () const
std::string	type () const
virtual	~PlotBase ()=default

Private Member Functions
template<typename T >
bool	isEqual (std::vector< T > const &v1, std::vector< T > const &v2)

Private Attributes
bool	isHighGranularity_
std::string	label_

Additional Inherited Members
Public Types inherited from cond::payloadInspector::PlotImage< PayloadType, nIOVs, ntags >
typedef PlotImpl< IOV_M, NTAGS >	Base
Protected Attributes inherited from cond::payloadInspector::PlotImage< PayloadType, nIOVs, ntags >
std::string	m_imageFileName
Protected Attributes inherited from cond::payloadInspector::PlotBase
std::set< std::string >	m_inputParams
std::map< std::string, std::string >	m_inputParamValues
PlotAnnotations	m_plotAnnotations
std::vector< std::pair< cond::Time_t, cond::Time_t > >	m_tagBoundaries
std::vector< std::vector< std::tuple< cond::Time_t, cond::Hash > > >	m_tagIovs
std::vector< std::string >	m_tagNames

Detailed Description

template<class PayloadType, cond::payloadInspector::IOVMultiplicity nIOVs, int ntags>
class AlignPCLThresholdPlotHelper::AlignPCLThresholds_CompareBase< PayloadType, nIOVs, ntags >

Definition at line 209 of file SiPixelAliPCLThresholdsPayloadInspectorHelper.h.

Constructor & Destructor Documentation

AlignPCLThresholds_CompareBase()

template<class PayloadType , cond::payloadInspector::IOVMultiplicity nIOVs, int ntags>

AlignPCLThresholdPlotHelper::AlignPCLThresholds_CompareBase< PayloadType, nIOVs, ntags >::AlignPCLThresholds_CompareBase ( )

inline

Definition at line 211 of file SiPixelAliPCLThresholdsPayloadInspectorHelper.h.

References AlignPCLThresholdPlotHelper::AlignPCLThresholds_CompareBase< PayloadType, nIOVs, ntags >::isHighGranularity_, and AlignPCLThresholdPlotHelper::AlignPCLThresholds_CompareBase< PayloadType, nIOVs, ntags >::label_.

        : cond::payloadInspector::PlotImage<PayloadType, nIOVs, ntags>("Table of AlignPCLThresholdsHG comparison") {
      if constexpr (std::is_same_v<PayloadType, AlignPCLThresholdsHG>) {
        isHighGranularity_ = true;
        label_ = "AlignPCLThresholdsHG_PayloadInspector";
      } else {
        isHighGranularity_ = false;
        label_ = "AlignPCLThresholds_PayloadInspector";
      }
    }

Member Function Documentation

fill()

template<class PayloadType , cond::payloadInspector::IOVMultiplicity nIOVs, int ntags>

bool AlignPCLThresholdPlotHelper::AlignPCLThresholds_CompareBase< PayloadType, nIOVs, ntags >::fill ( )

inlineoverridevirtual

Implements cond::payloadInspector::PlotImpl< IOV_M, NTAGS >.

Definition at line 222 of file SiPixelAliPCLThresholdsPayloadInspectorHelper.h.

References cms::cuda::assert(), svgfig::canvas(), AlignPCLThresholdPlotHelper::DELTA, AlignPCLThresholdPlotHelper::END_OF_TYPES, AlignPCLThresholds::extra_DOF, cond::payloadInspector::PlotImage< PayloadType, nIOVs, ntags >::fetchPayload(), MillePedeFileConverter_cfg::fileName, custom_jme_cff::foo, AlignPCLThresholdPlotHelper::FRACTION_CUT, AlignPCLThresholdPlotHelper::getStringFromCoordEnum(), AlignPCLThresholdPlotHelper::getStringFromTypeEnum(), AlignPCLThresholdPlotHelper::AlignPCLThresholds_CompareBase< PayloadType, nIOVs, ntags >::isEqual(), AlignPCLThresholdPlotHelper::AlignPCLThresholds_CompareBase< PayloadType, nIOVs, ntags >::isHighGranularity_, submitPVResolutionJobs::key, AlignPCLThresholdPlotHelper::AlignPCLThresholds_CompareBase< PayloadType, nIOVs, ntags >::label_, cond::payloadInspector::PlotImage< PayloadType, nIOVs, ntags >::m_imageFileName, cond::payloadInspector::PlotBase::m_plotAnnotations, AlignPCLThresholdPlotHelper::MAXERR, AlignPCLThresholdPlotHelper::MAXMOVE, Skims_PA_cff::name, cond::payloadInspector::PlotAnnotations::ntags, AlignPCLThresholdPlotHelper::replaceAll(), runTheMatrix::ret, DBoxMetadataHelper::set_difference(), DBoxMetadataHelper::set_intersection(), AlignPCLThresholdPlotHelper::SIG, contentValuesCheck::ss, AlCaHLTBitMon_QueryRunRegistry::string, HLT_2023v12_cff::Thresholds, to_string(), X, photonAnalyzer_cfi::xBin, and photonAnalyzer_cfi::yBin.

                         {
      gStyle->SetPalette(kTemperatureMap);

      // to be able to see zeros
      gStyle->SetHistMinimumZero(kTRUE);

      // trick to deal with the multi-ioved tag and two tag case at the same time
      auto theIOVs = cond::payloadInspector::PlotBase::getTag<0>().iovs;
      auto f_tagname = cond::payloadInspector::PlotBase::getTag<0>().name;
      std::string l_tagname = "";
      auto firstiov = theIOVs.front();
      std::tuple<cond::Time_t, cond::Hash> lastiov;

      // we don't support (yet) comparison with more than 2 tags
      assert(this->m_plotAnnotations.ntags < 3);

      if (this->m_plotAnnotations.ntags == 2) {
        auto tag2iovs = cond::payloadInspector::PlotBase::getTag<1>().iovs;
        l_tagname = cond::payloadInspector::PlotBase::getTag<1>().name;
        lastiov = tag2iovs.front();
      } else {
        lastiov = theIOVs.back();
      }

      std::shared_ptr<PayloadType> l_payload = this->fetchPayload(std::get<1>(lastiov));
      std::shared_ptr<PayloadType> f_payload = this->fetchPayload(std::get<1>(firstiov));

      std::string lastIOVsince = std::to_string(std::get<0>(lastiov));
      std::string firstIOVsince = std::to_string(std::get<0>(firstiov));

      const auto& alignables = l_payload->getAlignableList();
      const auto& alignables2 = f_payload->getAlignableList();

      std::vector<std::string> v_intersection;

      if (!isEqual(alignables, alignables2)) {
        edm::LogWarning(label_)
            << "Cannot compare directly the two AlignPCLThresholds objects, as the list of alignables differs";
        std::set_intersection(alignables.begin(),
                              alignables.end(),
                              alignables2.begin(),
                              alignables2.end(),
                              std::back_inserter(v_intersection));

        std::vector<std::string> not_in_first_keys, not_in_last_keys;

        // find the elements not in common
        std::set_difference(alignables.begin(),
                            alignables.end(),
                            alignables2.begin(),
                            alignables2.end(),
                            std::inserter(not_in_last_keys, not_in_last_keys.begin()));

        std::stringstream ss;
        ss << "the following keys are not in the last IoV: ";
        for (const auto& key : not_in_last_keys) {
          ss << key << ",";
        }
        ss << std::endl;
        edm::LogWarning(label_) << ss.str();
        ss.str(std::string()); /* clear the stream */

        std::set_difference(alignables2.begin(),
                            alignables2.end(),
                            alignables.begin(),
                            alignables.end(),
                            std::inserter(not_in_first_keys, not_in_first_keys.begin()));

        ss << "the following keys are not in the first IoV: ";
        for (const auto& key : not_in_first_keys) {
          ss << key << ",";
        }
        ss << std::endl;
        edm::LogWarning(label_) << ss.str();
      } else {
        // vectors are the same, just copy one
        v_intersection = alignables;
      }

      TCanvas canvas("Alignment PCL thresholds summary", "Alignment PCL thresholds summary", 1500, 800);
      canvas.cd();

      canvas.SetTopMargin(0.07);
      canvas.SetBottomMargin(isHighGranularity_ ? 0.20 : 0.06);
      canvas.SetLeftMargin(0.11);
      canvas.SetRightMargin(0.12);
      canvas.Modified();
      canvas.SetGrid();

      // needed for the internal loop
      const auto& local_end_of_types = isHighGranularity_ ? END_OF_TYPES : FRACTION_CUT;
      const int N_Y_BINS = AlignPCLThresholds::extra_DOF * local_end_of_types;

      auto Thresholds = std::make_unique<TH2F>(
          "Thresholds", "", v_intersection.size(), 0, v_intersection.size(), N_Y_BINS, 0, N_Y_BINS);
      Thresholds->SetStats(false);
      Thresholds->GetXaxis()->SetLabelSize(0.028);

      auto ThresholdsColor = std::make_unique<TH2F>(
          "ThresholdsC", "", v_intersection.size(), 0, v_intersection.size(), N_Y_BINS, 0, N_Y_BINS);
      ThresholdsColor->SetStats(false);
      ThresholdsColor->GetXaxis()->SetLabelSize(0.028);

      std::function<float(types, std::string, AlignPCLThresholds::coordType)> cutFunctor =
          [&f_payload, &l_payload](types my_type, std::string alignable, AlignPCLThresholds::coordType coord) {
            float ret(-999.);
            switch (my_type) {
              case DELTA:
                return l_payload->getCut(alignable, coord) - f_payload->getCut(alignable, coord);
              case SIG:
                return l_payload->getSigCut(alignable, coord) - f_payload->getSigCut(alignable, coord);
              case MAXMOVE:
                return l_payload->getMaxMoveCut(alignable, coord) - f_payload->getMaxMoveCut(alignable, coord);
              case MAXERR:
                return l_payload->getMaxErrorCut(alignable, coord) - f_payload->getMaxErrorCut(alignable, coord);
              case FRACTION_CUT: {
                if constexpr (std::is_same_v<PayloadType, AlignPCLThresholdsHG>) {
                  const AlignPCLThresholdsHG::param_map& f_floatMap = f_payload->getFloatMap();
                  const AlignPCLThresholdsHG::param_map& l_floatMap = l_payload->getFloatMap();
                  if (f_floatMap.find(alignable) != f_floatMap.end() &&
                      l_floatMap.find(alignable) != l_floatMap.end()) {
                    return l_payload->getFractionCut(alignable, coord) - f_payload->getFractionCut(alignable, coord);
                  } else {
                    return +999.f;
                  }
                } else {
                  assert(false); /* cannot be here */
                }
              }
              case END_OF_TYPES:
                return ret;
              default:
                return ret;
            }
          };

      unsigned int xBin = 0;
      for (const auto& alignable : v_intersection) {
        xBin++;
        auto xLabel = replaceAll(replaceAll(alignable, "minus", "(-)"), "plus", "(+)");
        Thresholds->GetXaxis()->SetBinLabel(xBin, (xLabel).c_str());
        ThresholdsColor->GetXaxis()->SetBinLabel(xBin, (xLabel).c_str());
        unsigned int yBin = N_Y_BINS;
        for (int foo = PayloadType::X; foo != PayloadType::extra_DOF; foo++) {
          AlignPCLThresholds::coordType coord = static_cast<AlignPCLThresholds::coordType>(foo);
          for (int bar = DELTA; bar != local_end_of_types; bar++) {
            types type = static_cast<types>(bar);
            std::string theLabel = getStringFromTypeEnum(type) + getStringFromCoordEnum(coord);
            if (xBin == 1) {
              Thresholds->GetYaxis()->SetBinLabel(yBin, theLabel.c_str());
              ThresholdsColor->GetYaxis()->SetBinLabel(yBin, theLabel.c_str());
            }

            const auto& value = cutFunctor(type, alignable, coord);
            Thresholds->SetBinContent(xBin, yBin, value);
            ThresholdsColor->SetBinContent(xBin, yBin, value);

            yBin--;
          }  // loop on types
        }    // loop on coordinates
      }      // loop on alignables

      ThresholdsColor->Draw("COLZ0");
      ThresholdsColor->GetXaxis()->LabelsOption(isHighGranularity_ ? "v" : "h");
      Thresholds->Draw("TEXTsame");
      Thresholds->GetXaxis()->LabelsOption(isHighGranularity_ ? "v" : "h");

      auto ltx = TLatex();
      ltx.SetTextFont(62);
      //ltx.SetTextColor(kBlue);
      ltx.SetTextSize(0.047);
      ltx.SetTextAlign(11);
      std::string ltxText;
      if (this->m_plotAnnotations.ntags == 2) {
        ltxText = fmt::sprintf("#color[2]{%s, %s} vs #color[4]{%s, %s}",
                               f_tagname,
                               std::to_string(std::get<0>(firstiov)),
                               l_tagname,
                               std::to_string(std::get<0>(lastiov)));
      } else {
        ltxText = fmt::sprintf("%s IOV: #color[2]{%s} vs IOV: #color[4]{%s}",
                               f_tagname,
                               std::to_string(std::get<0>(firstiov)),
                               std::to_string(std::get<0>(lastiov)));
      }
      ltx.DrawLatexNDC(gPad->GetLeftMargin(), 1 - gPad->GetTopMargin() + 0.01, ltxText.c_str());

      std::string fileName(this->m_imageFileName);
      canvas.SaveAs(fileName.c_str());

      return true;
    }

isEqual()

template<class PayloadType , cond::payloadInspector::IOVMultiplicity nIOVs, int ntags>

template<typename T >

bool AlignPCLThresholdPlotHelper::AlignPCLThresholds_CompareBase< PayloadType, nIOVs, ntags >::isEqual ( std::vector< T > const &  v1, std::vector< T > const &  v2  )

inlineprivate

Definition at line 417 of file SiPixelAliPCLThresholdsPayloadInspectorHelper.h.

References cond::serialization::equal().

Referenced by AlignPCLThresholdPlotHelper::AlignPCLThresholds_CompareBase< PayloadType, nIOVs, ntags >::fill().

                                                                 {
      return (v1.size() == v2.size() && std::equal(v1.begin(), v1.end(), v2.begin()));
    }

Member Data Documentation

isHighGranularity_

template<class PayloadType , cond::payloadInspector::IOVMultiplicity nIOVs, int ntags>

bool AlignPCLThresholdPlotHelper::AlignPCLThresholds_CompareBase< PayloadType, nIOVs, ntags >::isHighGranularity_

private

Definition at line 420 of file SiPixelAliPCLThresholdsPayloadInspectorHelper.h.

Referenced by AlignPCLThresholdPlotHelper::AlignPCLThresholds_CompareBase< PayloadType, nIOVs, ntags >::AlignPCLThresholds_CompareBase(), and AlignPCLThresholdPlotHelper::AlignPCLThresholds_CompareBase< PayloadType, nIOVs, ntags >::fill().

label_

template<class PayloadType , cond::payloadInspector::IOVMultiplicity nIOVs, int ntags>

std::string AlignPCLThresholdPlotHelper::AlignPCLThresholds_CompareBase< PayloadType, nIOVs, ntags >::label_

private

Definition at line 421 of file SiPixelAliPCLThresholdsPayloadInspectorHelper.h.

Referenced by Modules.SwitchProducer::__addParameter(), SequenceTypes.DummyModule::__repr__(), Modules.SwitchProducer::__setattr__(), Mixins._Labelable::_findDependencies(), AlignPCLThresholdPlotHelper::AlignPCLThresholds_CompareBase< PayloadType, nIOVs, ntags >::AlignPCLThresholds_CompareBase(), AlignPCLThresholdPlotHelper::AlignPCLThresholds_CompareBase< PayloadType, nIOVs, ntags >::fill(), and Mixins._Labelable::setLabel().