#include <SiPixelAliPCLThresholdsPayloadInspectorHelper.h>

Inheritance diagram for AlignPCLThresholdPlotHelper::AlignPCLThresholds_DisplayBase< PayloadType >:

Public Member Functions
	AlignPCLThresholds_DisplayBase ()

bool	fill () override

Public Member Functions inherited from cond::payloadInspector::PlotImage< PayloadType, cond::payloadInspector::SINGLE_IOV >
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, 0 >
	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 Attributes
bool	isHighGranularity_

std::string	label_

Additional Inherited Members
Public Types inherited from cond::payloadInspector::PlotImage< PayloadType, cond::payloadInspector::SINGLE_IOV >
typedef PlotImpl< IOV_M, 0 >	Base

Protected Attributes inherited from cond::payloadInspector::PlotImage< PayloadType, cond::payloadInspector::SINGLE_IOV >
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>
class AlignPCLThresholdPlotHelper::AlignPCLThresholds_DisplayBase< PayloadType >

Definition at line 86 of file SiPixelAliPCLThresholdsPayloadInspectorHelper.h.

Constructor & Destructor Documentation

◆ AlignPCLThresholds_DisplayBase()

template<class PayloadType >

AlignPCLThresholdPlotHelper::AlignPCLThresholds_DisplayBase< PayloadType >::AlignPCLThresholds_DisplayBase ( )

inline

Definition at line 89 of file SiPixelAliPCLThresholdsPayloadInspectorHelper.h.

References AlignPCLThresholdPlotHelper::AlignPCLThresholds_DisplayBase< PayloadType >::isHighGranularity_, and AlignPCLThresholdPlotHelper::AlignPCLThresholds_DisplayBase< PayloadType >::label_.

         : cond::payloadInspector::PlotImage<PayloadType, cond::payloadInspector::SINGLE_IOV>(
               "Display of threshold parameters for SiPixelAli PCL") {
       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 >

bool AlignPCLThresholdPlotHelper::AlignPCLThresholds_DisplayBase< PayloadType >::fill ( )

inlineoverridevirtual

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

Definition at line 101 of file SiPixelAliPCLThresholdsPayloadInspectorHelper.h.

                          {
       // to be able to see zeros
       gStyle->SetHistMinimumZero(kTRUE);
 
       auto tag = cond::payloadInspector::PlotBase::getTag<0>();
       auto iov = tag.iovs.front();
       std::shared_ptr<PayloadType> payload = this->fetchPayload(std::get<1>(iov));
       auto alignables = payload->getAlignableList();
 
       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.05);
       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", "", alignables.size(), 0, alignables.size(), N_Y_BINS, 0, N_Y_BINS);
       Thresholds->SetStats(false);
       Thresholds->GetXaxis()->SetLabelSize(0.028);
 
       std::function<float(types, std::string, AlignPCLThresholds::coordType)> cutFunctor =
           [&payload](types my_type, std::string alignable, AlignPCLThresholds::coordType coord) {
             float ret(-999.);
             switch (my_type) {
               case DELTA:
                 return payload->getCut(alignable, coord);
               case SIG:
                 return payload->getSigCut(alignable, coord);
               case MAXMOVE:
                 return payload->getMaxMoveCut(alignable, coord);
               case MAXERR:
                 return payload->getMaxErrorCut(alignable, coord);
               case FRACTION_CUT: {
                 if constexpr (std::is_same_v<PayloadType, AlignPCLThresholdsHG>) {
                   const AlignPCLThresholdsHG::param_map& floatMap = payload->getFloatMap();
                   if (floatMap.find(alignable) != floatMap.end()) {
                     return payload->getFractionCut(alignable, coord);
                   } else {
                     return 0.f;
                   }
                 } else {
                   assert(false); /* cannot be here */
                 }
               }
               case END_OF_TYPES:
                 return ret;
               default:
                 return ret;
             }
           };
 
       unsigned int xBin = 0;
       for (const auto& alignable : alignables) {
         xBin++;
         auto xLabel = replaceAll(replaceAll(alignable, "minus", "(-)"), "plus", "(+)");
         Thresholds->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());
             }
 
             Thresholds->SetBinContent(xBin, yBin, cutFunctor(type, alignable, coord));
 
             yBin--;
           }  // loop on types
         }    // loop on coordinates
       }      // loop on alignables
 
       Thresholds->GetXaxis()->LabelsOption(isHighGranularity_ ? "v" : "h");
       Thresholds->Draw("TEXT");
 
       auto ltx = TLatex();
       ltx.SetTextFont(62);
       //ltx.SetTextColor(kBlue);
       ltx.SetTextSize(0.047);
       ltx.SetTextAlign(11);
       std::string ltxText =
           fmt::sprintf("#color[4]{%s} IOV: #color[4]{%s}", tag.name, std::to_string(std::get<0>(iov)));
       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;
     }