gainCalibHelper::SiPixelGainCalibrationValuesComparisonPerRegion< isBarrel, myType, nIOVs, ntags, PayloadType > Class Template Reference

#include <SiPixelGainCalibHelper.h>

Inheritance diagram for gainCalibHelper::SiPixelGainCalibrationValuesComparisonPerRegion< isBarrel, myType, nIOVs, ntags, PayloadType >:

Public Member Functions
bool	fill () override
	SiPixelGainCalibrationValuesComparisonPerRegion ()
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)
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, 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

Additional Inherited Members
Public Types inherited from cond::payloadInspector::PlotImage< PayloadType, nIOVs, ntags >
typedef PlotImpl< IOV_M, NTAGS >	Base

Detailed Description

template<bool isBarrel, gainCalibPI::type myType, cond::payloadInspector::IOVMultiplicity nIOVs, int ntags, class PayloadType>
class gainCalibHelper::SiPixelGainCalibrationValuesComparisonPerRegion< isBarrel, myType, nIOVs, ntags, PayloadType >

Definition at line 458 of file SiPixelGainCalibHelper.h.

Constructor & Destructor Documentation

SiPixelGainCalibrationValuesComparisonPerRegion()

template<bool isBarrel, gainCalibPI::type myType, cond::payloadInspector::IOVMultiplicity nIOVs, int ntags, class PayloadType >

gainCalibHelper::SiPixelGainCalibrationValuesComparisonPerRegion< isBarrel, myType, nIOVs, ntags, PayloadType >::SiPixelGainCalibrationValuesComparisonPerRegion ( )

inline

Definition at line 462 of file SiPixelGainCalibHelper.h.

      : public cond::payloadInspector::PlotImage<PayloadType, nIOVs, ntags> {
  public:
    SiPixelGainCalibrationValuesComparisonPerRegion()
        : cond::payloadInspector::PlotImage<PayloadType, nIOVs, ntags>(
              Form("SiPixelGainCalibration %s Values Per Region %i tag(s)", TypeName[myType], ntags)) {
      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::SiPixelGainCalibrationValuesComparisonPerRegion< isBarrel, myType, nIOVs, ntags, PayloadType >::isForHLT_, gainCalibHelper::SiPixelGainCalibrationValuesComparisonPerRegion< isBarrel, myType, nIOVs, ntags, PayloadType >::label_, cond::payloadInspector::PlotBase::ntags(), and gainCalibHelper::TypeName.

Member Function Documentation

fill()

template<bool isBarrel, gainCalibPI::type myType, cond::payloadInspector::IOVMultiplicity nIOVs, int ntags, class PayloadType >

bool gainCalibHelper::SiPixelGainCalibrationValuesComparisonPerRegion< isBarrel, myType, nIOVs, ntags, PayloadType >::fill ( )

inlineoverridevirtual

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

Definition at line 476 of file SiPixelGainCalibHelper.h.

                         {
      gStyle->SetOptStat("mr");
 
      COUT << "ntags: " << ntags << " this->m_plotAnnotations.ntags: " << this->m_plotAnnotations.ntags << std::endl;
 
      // 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 tagname1 = cond::payloadInspector::PlotBase::getTag<0>().name;
      std::string tagname2 = "";
      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;
        tagname2 = cond::payloadInspector::PlotBase::getTag<1>().name;
        lastiov = tag2iovs.front();
      } else {
        lastiov = theIOVs.back();
      }
 
      // 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> 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));
 
      std::vector<uint32_t> f_detids, l_detids;
      last_payload->getDetIds(l_detids);
      first_payload->getDetIds(f_detids);
 
      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", isBarrel ? 1400 : 1800, 1200);
      if (std::max(l_detids.size(), f_detids.size()) > SiPixelPI::phase1size) {
        SiPixelPI::displayNotSupported(canvas, std::max(f_detids.size(), l_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();
 
      bool is_l_phase0 = (l_detids.size() == SiPixelPI::phase0size);
      bool is_f_phase0 = (f_detids.size() == SiPixelPI::phase0size);
 
      const char* path_toTopologyXML = is_l_phase0 ? "Geometry/TrackerCommonData/data/trackerParameters.xml"
                                                   : "Geometry/TrackerCommonData/data/PhaseI/trackerParameters.xml";
      auto l_tTopo =
          StandaloneTrackerTopology::fromTrackerParametersXMLFile(edm::FileInPath(path_toTopologyXML).fullPath());
 
      auto l_myPlots = PixelRegions::PixelRegionContainers(&l_tTopo, !is_l_phase0);
      l_myPlots.bookAll(
          Form("Last 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);
 
      path_toTopologyXML = is_f_phase0 ? "Geometry/TrackerCommonData/data/trackerParameters.xml"
                                       : "Geometry/TrackerCommonData/data/PhaseI/trackerParameters.xml";
      auto f_tTopo =
          StandaloneTrackerTopology::fromTrackerParametersXMLFile(edm::FileInPath(path_toTopologyXML).fullPath());
 
      auto f_myPlots = PixelRegions::PixelRegionContainers(&f_tTopo, !is_f_phase0);
      f_myPlots.bookAll(
          Form("First 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);
 
      // fill the histograms
      for (const auto& pixelId : PixelRegions::PixelIDs) {
        auto f_wantedDets = PixelRegions::attachedDets(pixelId, &f_tTopo, !is_f_phase0);
        auto l_wantedDets = PixelRegions::attachedDets(pixelId, &l_tTopo, !is_l_phase0);
        gainCalibPI::fillTheHisto(first_payload, f_myPlots.getHistoFromMap(pixelId), myType, f_wantedDets);
        gainCalibPI::fillTheHisto(last_payload, l_myPlots.getHistoFromMap(pixelId), myType, l_wantedDets);
      }
 
      if (setLog) {
        f_myPlots.setLogScale();
        l_myPlots.setLogScale();
      }
 
      l_myPlots.beautify(kRed, -1);
      f_myPlots.beautify(kAzure, -1);
 
      l_myPlots.draw(canvas, isBarrel, "HIST", (!is_f_phase0 || !is_l_phase0));
      f_myPlots.draw(canvas, isBarrel, "HISTsames", (!is_f_phase0 || !is_l_phase0));
 
      // rescale the y-axis ranges in order to fit the canvas
      l_myPlots.rescaleMax(f_myPlots);
 
      // done dealing with IOVs
      auto colorTag = isBarrel ? PixelRegions::L1 : PixelRegions::Rm1l;
      std::unique_ptr<TLegend> legend;
      if (this->m_plotAnnotations.ntags == 2) {
        legend = std::make_unique<TLegend>(0.36, 0.86, 0.94, 0.92);
        legend->AddEntry(l_myPlots.getHistoFromMap(colorTag).get(), ("#color[2]{" + tagname2 + "}").c_str(), "F");
        legend->AddEntry(f_myPlots.getHistoFromMap(colorTag).get(), ("#color[4]{" + tagname1 + "}").c_str(), "F");
        legend->SetTextSize(0.024);
      } else {
        legend = std::make_unique<TLegend>(0.58, 0.80, 0.90, 0.92);
        legend->AddEntry(l_myPlots.getHistoFromMap(colorTag).get(), ("#color[2]{" + lastIOVsince + "}").c_str(), "F");
        legend->AddEntry(f_myPlots.getHistoFromMap(colorTag).get(), ("#color[4]{" + firstIOVsince + "}").c_str(), "F");
        legend->SetTextSize(0.040);
      }
      legend->SetLineColor(10);
 
      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();
      }
 
      f_myPlots.stats(0);
      l_myPlots.stats(1);
 
      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) + " : #color[4]{" + std::to_string(std::get<0>(firstiov)) +
                          "} vs #color[2]{" + std::to_string(std::get<0>(lastiov)) + "}")
                             .c_str());
      }
 
      std::string fileName(this->m_imageFileName);
      canvas.SaveAs(fileName.c_str());
 

Member Data Documentation

isForHLT_

template<bool isBarrel, gainCalibPI::type myType, cond::payloadInspector::IOVMultiplicity nIOVs, int ntags, class PayloadType >

bool gainCalibHelper::SiPixelGainCalibrationValuesComparisonPerRegion< isBarrel, myType, nIOVs, ntags, PayloadType >::isForHLT_

protected

Definition at line 653 of file SiPixelGainCalibHelper.h.

Referenced by gainCalibHelper::SiPixelGainCalibrationValuesComparisonPerRegion< isBarrel, myType, nIOVs, ntags, PayloadType >::SiPixelGainCalibrationValuesComparisonPerRegion().

label_

template<bool isBarrel, gainCalibPI::type myType, cond::payloadInspector::IOVMultiplicity nIOVs, int ntags, class PayloadType >

std::string gainCalibHelper::SiPixelGainCalibrationValuesComparisonPerRegion< isBarrel, myType, nIOVs, ntags, PayloadType >::label_

protected

Definition at line 654 of file SiPixelGainCalibHelper.h.

Referenced by SequenceTypes.DummyModule::__repr__(), Mixins._Labelable::_findDependencies(), Mixins._Labelable::setLabel(), and gainCalibHelper::SiPixelGainCalibrationValuesComparisonPerRegion< isBarrel, myType, nIOVs, ntags, PayloadType >::SiPixelGainCalibrationValuesComparisonPerRegion().