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

#include <SiPixelGainCalibHelper.h>

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

Public Member Functions
bool	fill () override
	SiPixelGainCalibrationByRegionComparisonBase ()
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<gainCalibPI::type myType, class PayloadType, cond::payloadInspector::IOVMultiplicity nIOVs, int ntags>
class gainCalibHelper::SiPixelGainCalibrationByRegionComparisonBase< myType, PayloadType, nIOVs, ntags >

Definition at line 1486 of file SiPixelGainCalibHelper.h.

Constructor & Destructor Documentation

SiPixelGainCalibrationByRegionComparisonBase()

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

gainCalibHelper::SiPixelGainCalibrationByRegionComparisonBase< myType, PayloadType, nIOVs, ntags >::SiPixelGainCalibrationByRegionComparisonBase ( )

inline

Definition at line 1490 of file SiPixelGainCalibHelper.h.

      : public cond::payloadInspector::PlotImage<PayloadType, nIOVs, ntags> {
  public:
    SiPixelGainCalibrationByRegionComparisonBase()
        : cond::payloadInspector::PlotImage<PayloadType, nIOVs, ntags>(
              Form("SiPixelGainCalibration %s Comparison by Region", TypeName[myType])) {

References gainCalibHelper::TypeName.

Member Function Documentation

fill()

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

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

inlineoverridevirtual

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

Definition at line 1502 of file SiPixelGainCalibHelper.h.

             {
        isForHLT_ = true;
        label_ = "SiPixelGainCalibrationForHLT_PayloadInspector";
      }
    }
 
    bool fill() override {
      gStyle->SetPaintTextFormat(".3f");
 
      // 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> last_payload = this->fetchPayload(std::get<1>(lastiov));
      std::shared_ptr<PayloadType> first_payload = this->fetchPayload(std::get<1>(firstiov));
 
      std::map<uint32_t, float> f_GainsMap_;
      gainCalibPI::fillThePerModuleMap(first_payload, f_GainsMap_, myType);
 
      std::map<uint32_t, float> l_GainsMap_;
      gainCalibPI::fillThePerModuleMap(last_payload, l_GainsMap_, myType);
 
      std::string lastIOVsince = std::to_string(std::get<0>(lastiov));
      std::string firstIOVsince = std::to_string(std::get<0>(firstiov));
 
      TCanvas canvas("Comparison", "Comparison", 1600, 800);
 
      SiPixelPI::PhaseInfo f_phaseInfo(f_GainsMap_.size());
      SiPixelPI::PhaseInfo l_phaseInfo(l_GainsMap_.size());
 
      std::map<SiPixelPI::regions, std::shared_ptr<TH1F>> FirstGains_spectraByRegion;
      std::map<SiPixelPI::regions, std::shared_ptr<TH1F>> LastGains_spectraByRegion;
      std::shared_ptr<TH1F> summaryFirst;
      std::shared_ptr<TH1F> summaryLast;
 
      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;
      }
 
      // book the intermediate histograms
      for (int r = SiPixelPI::BPixL1o; r != SiPixelPI::NUM_OF_REGIONS; r++) {
        SiPixelPI::regions part = static_cast<SiPixelPI::regions>(r);
        std::string s_part = SiPixelPI::getStringFromRegionEnum(part);
 
        FirstGains_spectraByRegion[part] =
            std::make_shared<TH1F>(Form("hfirstGains_%s", s_part.c_str()),
                                   Form(";%s #LT %s #GT;n. of modules", s_part.c_str(), TypeName[myType]),
                                   200,
                                   minimum,
                                   maximum);
 
        LastGains_spectraByRegion[part] =
            std::make_shared<TH1F>(Form("hlastGains_%s", s_part.c_str()),
                                   Form(";%s #LT %s #GT;n. of modules", s_part.c_str(), TypeName[myType]),
                                   200,
                                   minimum,
                                   maximum);
      }
 
      summaryFirst = std::make_shared<TH1F>("first Summary",
                                            Form("Summary of #LT per %s %s #GT;;average %s",
                                                 (isForHLT_ ? "Column" : "Pixel"),
                                                 TypeName[myType],
                                                 TypeName[myType]),
                                            FirstGains_spectraByRegion.size(),
                                            0,
                                            FirstGains_spectraByRegion.size());
 
      summaryLast = std::make_shared<TH1F>("last Summary",
                                           Form("Summary of #LT per %s %s #GT;;average %s",
                                                (isForHLT_ ? "Column" : "Pixel"),
                                                TypeName[myType],
                                                TypeName[myType]),
                                           LastGains_spectraByRegion.size(),
                                           0,
                                           LastGains_spectraByRegion.size());
 
      // deal with first IOV
      const char* path_toTopologyXML = f_phaseInfo.pathToTopoXML();
 
      auto f_tTopo =
          StandaloneTrackerTopology::fromTrackerParametersXMLFile(edm::FileInPath(path_toTopologyXML).fullPath());
 
      // -------------------------------------------------------------------
      // loop on the first Gains Map
      // -------------------------------------------------------------------
      for (const auto& it : f_GainsMap_) {
        if (DetId(it.first).det() != DetId::Tracker) {
          edm::LogWarning(label_) << "Encountered invalid Tracker DetId:" << it.first << " - terminating ";
          return false;
        }
 
        SiPixelPI::topolInfo t_info_fromXML;
        t_info_fromXML.init();
        DetId detid(it.first);
        t_info_fromXML.fillGeometryInfo(detid, f_tTopo, f_phaseInfo.phase());
 
        SiPixelPI::regions thePart = t_info_fromXML.filterThePartition();
        FirstGains_spectraByRegion[thePart]->Fill(it.second);
      }  // ends loop on the vector of error transforms
 
      // deal with last IOV
      path_toTopologyXML = l_phaseInfo.pathToTopoXML();
 
      auto l_tTopo =
          StandaloneTrackerTopology::fromTrackerParametersXMLFile(edm::FileInPath(path_toTopologyXML).fullPath());
 
      // -------------------------------------------------------------------
      // loop on the second Gains Map
      // -------------------------------------------------------------------
      for (const auto& it : l_GainsMap_) {
        if (DetId(it.first).det() != DetId::Tracker) {
          edm::LogWarning(label_) << "Encountered invalid Tracker DetId:" << it.first << " - terminating ";
          return false;
        }
 
        SiPixelPI::topolInfo t_info_fromXML;
        t_info_fromXML.init();
        DetId detid(it.first);
        t_info_fromXML.fillGeometryInfo(detid, l_tTopo, l_phaseInfo.phase());
 
        SiPixelPI::regions thePart = t_info_fromXML.filterThePartition();
        LastGains_spectraByRegion[thePart]->Fill(it.second);
      }  // ends loop on the vector of error transforms
 
      // fill the summary plots
      int bin = 1;
      for (int r = SiPixelPI::BPixL1o; r != SiPixelPI::NUM_OF_REGIONS; r++) {
        SiPixelPI::regions part = static_cast<SiPixelPI::regions>(r);
 
        summaryFirst->GetXaxis()->SetBinLabel(bin, SiPixelPI::getStringFromRegionEnum(part).c_str());
        // avoid filling the histogram with numerical noise
        float f_mean =
            FirstGains_spectraByRegion[part]->GetMean() > 10.e-6 ? FirstGains_spectraByRegion[part]->GetMean() : 0.;
        summaryFirst->SetBinContent(bin, f_mean);
        //summaryFirst->SetBinError(bin,Gains_spectraByRegion[hash]->GetRMS());
 
        summaryLast->GetXaxis()->SetBinLabel(bin, SiPixelPI::getStringFromRegionEnum(part).c_str());
        // avoid filling the histogram with numerical noise
        float l_mean =
            LastGains_spectraByRegion[part]->GetMean() > 10.e-6 ? LastGains_spectraByRegion[part]->GetMean() : 0.;
        summaryLast->SetBinContent(bin, l_mean);
        //summaryLast->SetBinError(bin,Gains_spectraByRegion[hash]->GetRMS());
        bin++;
      }
 
      SiPixelPI::makeNicePlotStyle(summaryFirst.get());  //, kBlue);
      summaryFirst->SetMarkerColor(kRed);
      summaryFirst->GetXaxis()->LabelsOption("v");
      summaryFirst->GetXaxis()->SetLabelSize(0.05);
      summaryFirst->GetYaxis()->SetTitleOffset(0.9);
 
      SiPixelPI::makeNicePlotStyle(summaryLast.get());  //, kRed);
      summaryLast->SetMarkerColor(kBlue);
      summaryLast->GetYaxis()->SetTitleOffset(0.9);
      summaryLast->GetXaxis()->LabelsOption("v");
      summaryLast->GetXaxis()->SetLabelSize(0.05);
 
      canvas.cd()->SetGridy();
 
      SiPixelPI::adjustCanvasMargins(canvas.cd(), -1, 0.18, 0.11, 0.02);
      canvas.Modified();
 
      summaryFirst->SetFillColor(kRed);
      summaryLast->SetFillColor(kBlue);
 
      summaryFirst->SetBarWidth(0.45);
      summaryFirst->SetBarOffset(0.1);
 
      summaryLast->SetBarWidth(0.4);
      summaryLast->SetBarOffset(0.55);
 
      summaryLast->SetMarkerSize(1.2);
      summaryFirst->SetMarkerSize(1.2);
 
      float max = (summaryFirst->GetMaximum() > summaryLast->GetMaximum()) ? summaryFirst->GetMaximum()
                                                                           : summaryLast->GetMaximum();
 
      summaryFirst->GetYaxis()->SetRangeUser(0., std::max(0., max * 1.40));
 
      summaryFirst->Draw("b text0");
      summaryLast->Draw("b text0 same");
 
      TLegend legend = TLegend(0.52, 0.80, 0.98, 0.9);
      legend.SetHeader(Form("#LT %s #GT value comparison", TypeName[myType]),
                       "C");  // option "C" allows to center the header
 
      legend.SetHeader("#mu_{H} value comparison", "C");  // option "C" allows to center the header
      std::string l_tagOrHash, f_tagOrHash;
      if (this->m_plotAnnotations.ntags == 2) {
        l_tagOrHash = l_tagname;
        f_tagOrHash = f_tagname;
      } else {
        l_tagOrHash = std::get<1>(lastiov);
        f_tagOrHash = std::get<1>(firstiov);
      }
 
      legend.AddEntry(
          summaryLast.get(),
          ("IOV: #scale[1.2]{" + std::to_string(std::get<0>(lastiov)) + "} | #color[4]{" + l_tagOrHash + "}").c_str(),
          "F");
      legend.AddEntry(
          summaryFirst.get(),
          ("IOV: #scale[1.2]{" + std::to_string(std::get<0>(firstiov)) + "} | #color[2]{" + f_tagOrHash + "}").c_str(),
          "F");

Member Data Documentation

isForHLT_

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

bool gainCalibHelper::SiPixelGainCalibrationByRegionComparisonBase< myType, PayloadType, nIOVs, ntags >::isForHLT_

protected

Definition at line 1738 of file SiPixelGainCalibHelper.h.

label_

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

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

protected

Definition at line 1739 of file SiPixelGainCalibHelper.h.

Referenced by SequenceTypes.DummyModule::__repr__(), Mixins._Labelable::_findDependencies(), and Mixins._Labelable::setLabel().