#include <SiPixelGainCalibHelper.h>

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

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

	SiPixelGainCalibrationByRegionComparisonBase ()

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)

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 >
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::SiPixelGainCalibrationByRegionComparisonBase< myType, PayloadType >

Definition at line 1350 of file SiPixelGainCalibHelper.h.

Constructor & Destructor Documentation

◆ SiPixelGainCalibrationByRegionComparisonBase()

template<gainCalibPI::type myType, class PayloadType >

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

inline

Definition at line 1353 of file SiPixelGainCalibHelper.h.

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

Member Function Documentation

◆ fill()

template<gainCalibPI::type myType, class PayloadType >

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

inlineoverride

Definition at line 1364 of file SiPixelGainCalibHelper.h.

                                                                               {
         isForHLT_ = false;
         label_ = "SiPixelGainCalibrationOffline_PayloadInspector";
       } else {
         isForHLT_ = true;
         label_ = "SiPixelGainCalibrationForHLT_PayloadInspector";
       }
     }
     bool fill(const std::vector<std::tuple<cond::Time_t, cond::Hash>>& iovs) override {
       gStyle->SetPaintTextFormat(".3f");
  
       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::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);
  
       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());
  
       const char* path_toTopologyXML = (f_GainsMap_.size() == SiPixelPI::phase0size)
                                            ? "Geometry/TrackerCommonData/data/trackerParameters.xml"
                                            : "Geometry/TrackerCommonData/data/PhaseI/trackerParameters.xml";
       TrackerTopology f_tTopo =
           StandaloneTrackerTopology::fromTrackerParametersXMLFile(edm::FileInPath(path_toTopologyXML).fullPath());
  
       bool isPhase0(false);
       if (f_GainsMap_.size() == SiPixelPI::phase0size) {
         isPhase0 = true;
       }
  
       // -------------------------------------------------------------------
       // 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, isPhase0);
  
         SiPixelPI::regions thePart = t_info_fromXML.filterThePartition();
         FirstGains_spectraByRegion[thePart]->Fill(it.second);
       }  // ends loop on the vector of error transforms
  
       path_toTopologyXML = (l_GainsMap_.size() == SiPixelPI::phase0size)
                                ? "Geometry/TrackerCommonData/data/trackerParameters.xml"
                                : "Geometry/TrackerCommonData/data/PhaseI/trackerParameters.xml";
       TrackerTopology l_tTopo =
           StandaloneTrackerTopology::fromTrackerParametersXMLFile(edm::FileInPath(path_toTopologyXML).fullPath());
  
       if (l_GainsMap_.size() == SiPixelPI::phase0size) {
         isPhase0 = true;
       }
  
       // -------------------------------------------------------------------
       // 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, isPhase0);
  
         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.AddEntry(
           summaryLast.get(),
           ("IOV: #scale[1.2]{" + std::to_string(std::get<0>(lastiov)) + "} | #color[4]{" + std::get<1>(lastiov) + "}")
               .c_str(),
           "F");
       legend.AddEntry(
           summaryFirst.get(),
           ("IOV: #scale[1.2]{" + std::to_string(std::get<0>(firstiov)) + "} | #color[2]{" + std::get<1>(firstiov) + "}")
               .c_str(),