#include <SiPixelGainCalibHelper.h>

Inheritance diagram for gainCalibHelper::SiPixelGainCalibrationValueComparisonBase< myType, PayloadType >:

Public Member Functions
bool	fill (const std::vector< std::tuple< cond::Time_t, cond::Hash >> &iovs) override

	SiPixelGainCalibrationValueComparisonBase ()

Public Member Functions inherited from cond::payloadInspector::PlotImage< PayloadType >
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< UNSPECIFIED_IOV, 0 >
virtual bool	fill ()

virtual bool	fill (const std::vector< std::tuple< cond::Time_t, cond::Hash >> &iovs)

	PlotImpl (const std::string &type, const std::string &title)

std::string	processData () override

void	setSingleIov (bool flag)

void	setTwoTags (bool flag)

	~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

Protected Attributes
bool	isForHLT_

std::string	label_

Protected Attributes inherited from cond::payloadInspector::PlotImage< PayloadType >
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

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

Public Attributes inherited from cond::payloadInspector::PlotImpl< UNSPECIFIED_IOV, 0 >
bool	m_singleIovSet = false

Detailed Description

template<gainCalibPI::type myType, class PayloadType>
class gainCalibHelper::SiPixelGainCalibrationValueComparisonBase< myType, PayloadType >

Definition at line 1019 of file SiPixelGainCalibHelper.h.

Constructor & Destructor Documentation

◆ SiPixelGainCalibrationValueComparisonBase()

template<gainCalibPI::type myType, class PayloadType >

gainCalibHelper::SiPixelGainCalibrationValueComparisonBase< myType, PayloadType >::SiPixelGainCalibrationValueComparisonBase ( )

inline

Definition at line 1021 of file SiPixelGainCalibHelper.h.

References ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), and gainCalibHelper::SiPixelGainCalibrationValueComparisonBase< myType, PayloadType >::isForHLT_.

         : cond::payloadInspector::PlotImage<PayloadType>(
               Form("SiPixelGainCalibration %s Values Comparison", TypeName[myType])) {
       if constexpr (std::is_same_v<PayloadType, SiPixelGainCalibrationOffline>) {
         isForHLT_ = false;
       } else {
         isForHLT_ = true;
       }
     }

Member Function Documentation

◆ fill()

template<gainCalibPI::type myType, class PayloadType >

bool gainCalibHelper::SiPixelGainCalibrationValueComparisonBase< myType, PayloadType >::fill ( const std::vector< std::tuple< cond::Time_t, cond::Hash >> & iovs )

inlineoverride

Definition at line 1030 of file SiPixelGainCalibHelper.h.

References SiPixelPI::adjustCanvasMargins(), SiPixelPI::adjustStats(), svgfig::canvas(), cond::payloadInspector::PlotImage< PayloadType >::fetchPayload(), MillePedeFileConverter_cfg::fileName, gainCalibHelper::gainCalibPI::fillTheHisto(), SiPixelPI::getExtrema(), gainCalibHelper::SiPixelGainCalibrationValueComparisonBase< myType, PayloadType >::isForHLT_, gainCalibHelper::SiPixelGainCalibrationValueComparisonBase< myType, PayloadType >::label_, compareTotals::legend, cond::payloadInspector::PlotImage< PayloadType >::m_imageFileName, SiPixelPI::makeNicePlotStyle(), SiStripPI::max, SiStripPI::min, jetUpdater_cfi::sort, AlCaHLTBitMon_QueryRunRegistry::string, RandomServiceHelper::t1, RandomServiceHelper::t2, gainCalibHelper::gainCalibPI::t_gain, gainCalibHelper::gainCalibPI::t_pedestal, to_string(), and gainCalibHelper::TypeName.

                                                                               {
       gStyle->SetOptStat("emr");
       TGaxis::SetExponentOffset(-0.1, 0.01, "y");  // Y offset
       TH1F::SetDefaultSumw2(true);
 
       std::vector<std::tuple<cond::Time_t, cond::Hash>> sorted_iovs = iovs;
       // make absolute sure the IOVs are sortd by since
       std::sort(begin(sorted_iovs), end(sorted_iovs), [](auto const& t1, auto const& t2) {
         return std::get<0>(t1) < std::get<0>(t2);
       });
       auto firstiov = sorted_iovs.front();
       auto lastiov = sorted_iovs.back();
 
       std::shared_ptr<PayloadType> last_payload = this->fetchPayload(std::get<1>(lastiov));
       std::shared_ptr<PayloadType> first_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));
 
       float minimum(9999.);
       float maximum(-9999.);
 
       switch (myType) {
         case gainCalibPI::t_gain:
           maximum = std::max(last_payload->getGainHigh(), first_payload->getGainHigh());
           minimum = std::min(last_payload->getGainLow(), first_payload->getGainLow());
           break;
         case gainCalibPI::t_pedestal:
           maximum = std::max(last_payload->getPedHigh(), first_payload->getPedHigh());
           minimum = std::min(last_payload->getPedLow(), first_payload->getPedLow());
           break;
         default:
           edm::LogError(label_) << "Unrecognized type " << myType << std::endl;
           break;
       }
 
       TCanvas canvas("Canv", "Canv", 1200, 1000);
       canvas.cd();
       auto hfirst = std::make_shared<TH1F>(Form("First, IOV %s", firstIOVsince.c_str()),
                                            Form("SiPixel Gain Calibration %s - %s;per %s %s;# %ss",
                                                 (isForHLT_ ? "ForHLT" : "Offline"),
                                                 TypeName[myType],
                                                 (isForHLT_ ? "Column" : "Pixel"),
                                                 TypeName[myType],
                                                 (isForHLT_ ? "column" : "pixel")),
                                            200,
                                            minimum,
                                            maximum);
 
       auto hlast = std::make_shared<TH1F>(Form("Last, IOV %s", lastIOVsince.c_str()),
                                           Form("SiPixel Gain Calibration %s - %s;per %s %s;# %ss",
                                                (isForHLT_ ? "ForHLT" : "Offline"),
                                                TypeName[myType],
                                                (isForHLT_ ? "Column" : "Pixel"),
                                                TypeName[myType],
                                                (isForHLT_ ? "column" : "pixel")),
                                           200,
                                           minimum,
                                           maximum);
 
       SiPixelPI::adjustCanvasMargins(canvas.cd(), 0.05, 0.12, 0.12, 0.03);
       canvas.Modified();
 
       gainCalibPI::fillTheHisto(first_payload, hfirst, myType);
       gainCalibPI::fillTheHisto(last_payload, hlast, myType);
 
       canvas.cd()->SetLogy();
       auto extrema = SiPixelPI::getExtrema(hfirst.get(), hlast.get());
       //hfirst->GetYaxis()->SetRangeUser(extrema.first, extrema.second * 1.10);
       hfirst->GetYaxis()->SetRangeUser(1., extrema.second * 10);
 
       hfirst->SetTitle("");
       hfirst->SetLineColor(kRed);
       hfirst->SetBarWidth(0.95);
       hfirst->Draw("hist");
 
       hlast->SetTitle("");
       hlast->SetFillColorAlpha(kBlue, 0.20);
       hlast->SetBarWidth(0.95);
       hlast->Draw("histsames");
 
       SiPixelPI::makeNicePlotStyle(hfirst.get());
       hfirst->SetStats(true);
       SiPixelPI::makeNicePlotStyle(hlast.get());
       hlast->SetStats(true);
 
       canvas.Update();
 
       TLegend legend = TLegend(0.45, 0.86, 0.74, 0.94);
       //legend.SetHeader("#font[22]{SiPixel Offline Gain Calibration Comparison}", "C");  // option "C" allows to center the header
       //legend.AddEntry(hfirst.get(), ("IOV: " + std::to_string(std::get<0>(firstiov))).c_str(), "FL");
       //legend.AddEntry(hlast.get(),  ("IOV: " + std::to_string(std::get<0>(lastiov))).c_str(), "FL");
       legend.AddEntry(hfirst.get(), ("payload: #color[2]{" + std::get<1>(firstiov) + "}").c_str(), "F");
       legend.AddEntry(hlast.get(), ("payload: #color[4]{" + std::get<1>(lastiov) + "}").c_str(), "F");
       legend.SetTextSize(0.022);
       legend.SetLineColor(10);
       legend.Draw("same");
 
       TPaveStats* st1 = (TPaveStats*)hfirst->FindObject("stats");
       st1->SetTextSize(0.021);
       st1->SetLineColor(kRed);
       st1->SetTextColor(kRed);
       SiPixelPI::adjustStats(st1, 0.13, 0.86, 0.31, 0.94);
 
       TPaveStats* st2 = (TPaveStats*)hlast->FindObject("stats");
       st2->SetTextSize(0.021);
       st2->SetLineColor(kBlue);
       st2->SetTextColor(kBlue);
       SiPixelPI::adjustStats(st2, 0.13, 0.77, 0.31, 0.85);
 
       auto ltx = TLatex();
       ltx.SetTextFont(62);
       //ltx.SetTextColor(kBlue);
       ltx.SetTextSize(0.047);
       ltx.SetTextAlign(11);
       ltx.DrawLatexNDC(gPad->GetLeftMargin(),
                        1 - gPad->GetTopMargin() + 0.01,
                        ("SiPixel Gain Calibration IOV:#color[2]{" + std::to_string(std::get<0>(firstiov)) +
                         "} vs IOV:#color[4]{" + std::to_string(std::get<0>(lastiov)) + "}")
                            .c_str());
 
       std::string fileName(this->m_imageFileName);
       canvas.SaveAs(fileName.c_str());
 #ifdef MMDEBUG
       canvas.SaveAs("out.root");
 #endif
 
       return true;
     }