#include <SiPixelGainCalibHelper.h>

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

Public Member Functions
bool	fill () override

	SiPixelGainCalibrationBPIXMap ()

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

Private Attributes
TrackerTopology	m_trackerTopo

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

Detailed Description

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

Definition at line 1098 of file SiPixelGainCalibHelper.h.

Constructor & Destructor Documentation

◆ SiPixelGainCalibrationBPIXMap()

template<gainCalibPI::type myType, class PayloadType >

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

inline

Definition at line 1102 of file SiPixelGainCalibHelper.h.

       : public cond::payloadInspector::PlotImage<PayloadType, cond::payloadInspector::SINGLE_IOV> {
   public:
     SiPixelGainCalibrationBPIXMap()
         : cond::payloadInspector::PlotImage<PayloadType, cond::payloadInspector::SINGLE_IOV>(
               Form("SiPixelGainCalibration %s Barrel Pixel Map", TypeName[myType])),
           m_trackerTopo{StandaloneTrackerTopology::fromTrackerParametersXMLFile(
               edm::FileInPath("Geometry/TrackerCommonData/data/PhaseI/trackerParameters.xml").fullPath())} {
       if constexpr (std::is_same_v<PayloadType, SiPixelGainCalibrationOffline>) {
         isForHLT_ = false;

References StandaloneTrackerTopology::fromTrackerParametersXMLFile(), contentValuesFiles::fullPath, gainCalibHelper::SiPixelGainCalibrationBPIXMap< myType, PayloadType >::isForHLT_, gainCalibHelper::SiPixelGainCalibrationBPIXMap< myType, PayloadType >::label_, gainCalibHelper::SiPixelGainCalibrationBPIXMap< myType, PayloadType >::m_trackerTopo, and gainCalibHelper::TypeName.

Member Function Documentation

◆ fill()

template<gainCalibPI::type myType, class PayloadType >

bool gainCalibHelper::SiPixelGainCalibrationBPIXMap< myType, PayloadType >::fill ( )

inlineoverridevirtual

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

Definition at line 1116 of file SiPixelGainCalibHelper.h.

              {
         isForHLT_ = true;
         label_ = "SiPixelGainCalibrationForHLT_PayloadInspector";
       }
     };
  
     bool fill() override {
       auto tag = cond::payloadInspector::PlotBase::getTag<0>();
       auto iov = tag.iovs.front();
  
       std::shared_ptr<PayloadType> payload = this->fetchPayload(std::get<1>(iov));
  
       static const int n_layers = 4;
       int nlad_list[n_layers] = {6, 14, 22, 32};
       int divide_roc = 1;
  
       // ---------------------    BOOK HISTOGRAMS
       std::array<TH2D*, n_layers> h_bpix_Gains;
  
       for (unsigned int lay = 1; lay <= 4; lay++) {
         int nlad = nlad_list[lay - 1];
  
         std::string name = "occ_Gain_Layer_" + std::to_string(lay);
         std::string title = "; Module # ; Ladder #";
         h_bpix_Gains[lay - 1] = new TH2D(name.c_str(),
                                          title.c_str(),
                                          72 * divide_roc,
                                          -4.5,
                                          4.5,
                                          (nlad * 4 + 2) * divide_roc,
                                          -nlad - 0.5,
                                          nlad + 0.5);
       }
  
       std::map<uint32_t, float> GainCalibMap_;
       gainCalibPI::fillThePerModuleMap(payload, GainCalibMap_, myType);
       if (GainCalibMap_.size() != SiPixelPI::phase1size) {
         edm::LogError(label_) << "SiPixelGainCalibration maps are not supported for non-Phase1 Pixel geometries !";
         TCanvas canvas("Canv", "Canv", 1200, 1000);
         SiPixelPI::displayNotSupported(canvas, GainCalibMap_.size());
         std::string fileName(this->m_imageFileName);
         canvas.SaveAs(fileName.c_str());
         return false;
       }
  
       // hard-coded phase-I
       std::array<double, 4> minima = {{999., 999., 999., 999.}};
  
       for (const auto& element : GainCalibMap_) {
         int subid = DetId(element.first).subdetId();
         if (subid == PixelSubdetector::PixelBarrel) {
           auto layer = m_trackerTopo.pxbLayer(DetId(element.first));
           auto s_ladder = SiPixelPI::signed_ladder(DetId(element.first), m_trackerTopo, true);
           auto s_module = SiPixelPI::signed_module(DetId(element.first), m_trackerTopo, true);
  
           auto ladder = m_trackerTopo.pxbLadder(DetId(element.first));
           auto module = m_trackerTopo.pxbModule(DetId(element.first));
           COUT << "layer:" << layer << " ladder:" << ladder << " module:" << module << " signed ladder: " << s_ladder
                << " signed module: " << s_module << std::endl;
  
           if (element.second < minima.at(layer - 1))
             minima.at(layer - 1) = element.second;
  
           auto rocsToMask = SiPixelPI::maskedBarrelRocsToBins(layer, s_ladder, s_module);
           for (const auto& bin : rocsToMask) {
             h_bpix_Gains[layer - 1]->SetBinContent(bin.first, bin.second, element.second);
           }
         }
       }
  
       gStyle->SetOptStat(0);
       //=========================
       TCanvas canvas("Summary", "Summary", 1200, 1200);
       canvas.Divide(2, 2);
  
       for (unsigned int lay = 1; lay <= 4; lay++) {
         SiPixelPI::adjustCanvasMargins(canvas.cd(lay), -1, 0.08, 0.1, 0.13);
  
         COUT << " layer:" << lay << " max:" << h_bpix_Gains[lay - 1]->GetMaximum() << " min: " << minima.at(lay - 1)
              << std::endl;
  
         SiPixelPI::dress_occup_plot(canvas, h_bpix_Gains[lay - 1], lay, 0, 1, true, true, false);
         h_bpix_Gains[lay - 1]->GetZaxis()->SetRangeUser(minima.at(lay - 1) - 0.001,
                                                         h_bpix_Gains[lay - 1]->GetMaximum() + 0.001);
       }
  
       auto unpacked = SiPixelPI::unpack(std::get<0>(iov));
  
       for (unsigned int lay = 1; lay <= 4; lay++) {
         canvas.cd(lay);
         auto ltx = TLatex();
         ltx.SetTextFont(62);
         ltx.SetTextColor(kBlue);
         ltx.SetTextSize(0.055);
         ltx.SetTextAlign(11);
         ltx.DrawLatexNDC(gPad->GetLeftMargin(),
                          1 - gPad->GetTopMargin() + 0.01,
                          unpacked.first == 0
                              ? ("IOV:" + std::to_string(unpacked.second)).c_str()
                              : (std::to_string(unpacked.first) + "," + std::to_string(unpacked.second)).c_str());
       }