#include <SiPixelGainCalibHelper.h>

Inheritance diagram for gainCalibHelper::SiPixelGainCalibrationValuesPerRegion< isBarrel, myType, PayloadType >:

Public Member Functions
bool	fill () override

	SiPixelGainCalibrationValuesPerRegion ()

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)

std::string	data () const

cond::persistency::Session	dbSession ()

bool	exec_process (const std::string &connectionString, const std::vector< std::tuple< std::string, cond::Time_t, cond::Time_t >> &tagsWithTimeBoundaries)

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 ()

boost::python::list	inputParams () const

const std::map< std::string, std::string > &	inputParamValues () const

bool	isSingleIov () const

bool	isTwoTags () const

unsigned int	ntags () const

std::string	payloadType () const

	PlotBase ()

bool	process (const std::string &connectionString, const boost::python::list &tagsWithTimeBoundaries)

void	setInputParamValues (const boost::python::dict &values)

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, 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

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

Detailed Description

template<bool isBarrel, gainCalibPI::type myType, class PayloadType>
class gainCalibHelper::SiPixelGainCalibrationValuesPerRegion< isBarrel, myType, PayloadType >

Definition at line 311 of file SiPixelGainCalibHelper.h.

Constructor & Destructor Documentation

◆ SiPixelGainCalibrationValuesPerRegion()

template<bool isBarrel, gainCalibPI::type myType, class PayloadType >

gainCalibHelper::SiPixelGainCalibrationValuesPerRegion< isBarrel, myType, PayloadType >::SiPixelGainCalibrationValuesPerRegion ( )

inline

Definition at line 315 of file SiPixelGainCalibHelper.h.

         :
     SiPixelGainCalibrationValuesPerRegion()
         : cond::payloadInspector::PlotImage<PayloadType, cond::payloadInspector::SINGLE_IOV>(
               Form("SiPixelGainCalibration %s Values Per Region", TypeName[myType])) {
       cond::payloadInspector::PlotBase::addInputParam("SetLog");
  
       if constexpr (std::is_same_v<PayloadType, SiPixelGainCalibrationOffline>) {
         isForHLT_ = false;
         label_ = "SiPixelGainCalibrationOffline_PayloadInspector";
       } else {
         isForHLT_ = true;
         label_ = "SiPixelGainCalibrationForHLT_PayloadInspector";
       }

References cond::payloadInspector::PlotBase::addInputParam(), gainCalibHelper::SiPixelGainCalibrationValuesPerRegion< isBarrel, myType, PayloadType >::isForHLT_, and gainCalibHelper::SiPixelGainCalibrationValuesPerRegion< isBarrel, myType, PayloadType >::label_.

Member Function Documentation

◆ fill()

template<bool isBarrel, gainCalibPI::type myType, class PayloadType >

bool gainCalibHelper::SiPixelGainCalibrationValuesPerRegion< isBarrel, myType, PayloadType >::fill ( )

inlineoverridevirtual

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

Definition at line 329 of file SiPixelGainCalibHelper.h.

                          {
       gStyle->SetOptStat("mr");
  
       auto tag = cond::payloadInspector::PlotBase::getTag<0>();
       auto iov = tag.iovs.front();
  
       // parse first if log
       bool setLog(true);
       auto paramValues = cond::payloadInspector::PlotBase::inputParamValues();
       auto ip = paramValues.find("SetLog");
       if (ip != paramValues.end()) {
         auto answer = boost::lexical_cast<std::string>(ip->second);
         if (!SiPixelPI::checkAnswerOK(answer, setLog)) {
           throw cms::Exception(label_)
               << "\nERROR: " << answer
               << " is not a valid setting for this parameter, please use True,False,1,0,Yes,No \n\n";
         }
       }
  
       std::shared_ptr<PayloadType> payload = this->fetchPayload(std::get<1>(iov));
  
       std::vector<uint32_t> detids;
       payload->getDetIds(detids);
  
       float minimum(9999.);
       float maximum(-9999.);
  
       switch (myType) {
         case gainCalibPI::t_gain:
           maximum = payload->getGainHigh();
           minimum = payload->getGainLow();
           break;
         case gainCalibPI::t_pedestal:
           maximum = payload->getPedHigh();
           minimum = payload->getPedLow();
           break;
         default:
           edm::LogError(label_) << "Unrecognized type " << myType << std::endl;
           break;
       }
  
       TCanvas canvas("Canv", "Canv", isBarrel ? 1400 : 1800, 1200);
       if (detids.size() > SiPixelPI::phase1size) {
         SiPixelPI::displayNotSupported(canvas, detids.size());
         std::string fileName(this->m_imageFileName);
         canvas.SaveAs(fileName.c_str());
         return false;
       }
  
       canvas.Divide(isBarrel ? 2 : 4, isBarrel ? 2 : 3);
       canvas.cd();
  
       const char* path_toTopologyXML = (detids.size() == SiPixelPI::phase0size)
                                            ? "Geometry/TrackerCommonData/data/trackerParameters.xml"
                                            : "Geometry/TrackerCommonData/data/PhaseI/trackerParameters.xml";
       TrackerTopology tTopo =
           StandaloneTrackerTopology::fromTrackerParametersXMLFile(edm::FileInPath(path_toTopologyXML).fullPath());
  
       auto myPlots = PixelRegions::PixelRegionContainers(&tTopo, (detids.size() == SiPixelPI::phase1size));
       myPlots.bookAll(Form("SiPixel Gain Calibration %s - %s", (isForHLT_ ? "ForHLT" : "Offline"), TypeName[myType]),
                       Form("per %s %s", (isForHLT_ ? "Column" : "Pixel"), TypeName[myType]),
                       Form("# %ss", (isForHLT_ ? "column" : "pixel")),
                       200,
                       minimum,
                       maximum);
  
       canvas.Modified();
  
       // fill the histograms
       for (const auto& pixelId : PixelRegions::PixelIDs) {
         auto wantedDets = PixelRegions::attachedDets(pixelId, &tTopo, (detids.size() == SiPixelPI::phase1size));
         gainCalibPI::fillTheHisto(payload, myPlots.getHistoFromMap(pixelId), myType, wantedDets);
       }
  
       if (setLog) {
         myPlots.setLogScale();
       }
       myPlots.beautify(kBlue, -1);
       myPlots.draw(canvas, isBarrel, "HIST");
  
       TLegend legend = TLegend(0.45, 0.88, 0.91, 0.92);
       legend.SetHeader(("hash: #bf{" + (std::get<1>(iov)) + "}").c_str(),
                        "C");  // option "C" allows to center the header
       //legend.AddEntry(h1.get(), ("IOV: " + std::to_string(std::get<0>(iov))).c_str(), "PL");
       legend.SetLineColor(10);
       legend.SetTextSize(0.025);
       legend.Draw("same");
  
       unsigned int maxPads = isBarrel ? 4 : 12;
       for (unsigned int c = 1; c <= maxPads; c++) {
         canvas.cd(c);
         SiPixelPI::adjustCanvasMargins(canvas.cd(c), 0.06, 0.12, 0.12, 0.05);
         legend.Draw("same");
         canvas.cd(c)->Update();
       }
  
       myPlots.stats();
  
       auto ltx = TLatex();
       ltx.SetTextFont(62);
       ltx.SetTextSize(0.05);
       ltx.SetTextAlign(11);
  
       for (unsigned int c = 1; c <= maxPads; c++) {
         auto index = isBarrel ? c - 1 : c + 3;
         canvas.cd(c);
         auto leftX = setLog ? 0. : 0.1;
         ltx.DrawLatexNDC(gPad->GetLeftMargin() + leftX,
                          1 - gPad->GetTopMargin() + 0.01,
                          (PixelRegions::IDlabels.at(index) + ", IOV:" + std::to_string(std::get<0>(iov))).c_str());
       }
  
       std::string fileName(this->m_imageFileName);
       canvas.SaveAs(fileName.c_str());
  
       return true;