#include <BeamSpotPayloadInspectorHelper.h>

Inheritance diagram for BeamSpotPI::DisplayParameters< PayloadType >:

Public Member Functions
	DisplayParameters ()

bool	fill () override

virtual std::shared_ptr< TH2F >	fillTheExtraHistogram () const

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 Member Functions
virtual std::string	getStringFromTypeEnum (const parameters &parameter) const

Protected Attributes
bool	isOnline_

std::shared_ptr< PayloadType >	m_payload

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<class PayloadType>
class BeamSpotPI::DisplayParameters< PayloadType >

Definition at line 201 of file BeamSpotPayloadInspectorHelper.h.

Constructor & Destructor Documentation

◆ DisplayParameters()

template<class PayloadType >

BeamSpotPI::DisplayParameters< PayloadType >::DisplayParameters ( )

inline

Definition at line 204 of file BeamSpotPayloadInspectorHelper.h.

                           : public cond::payloadInspector::PlotImage<PayloadType, cond::payloadInspector::SINGLE_IOV> {
   public:
     DisplayParameters()
         : cond::payloadInspector::PlotImage<PayloadType, cond::payloadInspector::SINGLE_IOV>(
               "Display of BeamSpot parameters") {
       if constexpr (std::is_same_v<PayloadType, BeamSpotOnlineObjects>) {
         isOnline_ = true;

References BeamSpotPI::DisplayParameters< PayloadType >::isOnline_.

Member Function Documentation

◆ fill()

template<class PayloadType >

bool BeamSpotPI::DisplayParameters< PayloadType >::fill ( )

inlineoverridevirtual

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

Definition at line 214 of file BeamSpotPayloadInspectorHelper.h.

                          {
       auto tag = cond::payloadInspector::PlotBase::getTag<0>();
       auto tagname = tag.name;
       auto iov = tag.iovs.front();
  
       gStyle->SetHistMinimumZero(kTRUE);
  
       m_payload = this->fetchPayload(std::get<1>(iov));
  
       TCanvas canvas("Beam Spot Parameters Summary", "BeamSpot Parameters summary", isOnline_ ? 1500 : 1000, 1000);
       if (isOnline_) {
         canvas.Divide(2, 1);
       }
       canvas.cd(1);
  
       canvas.cd(1)->SetTopMargin(0.05);
       canvas.cd(1)->SetBottomMargin(0.06);
       canvas.cd(1)->SetLeftMargin(0.15);
       canvas.cd(1)->SetRightMargin(0.03);
       canvas.cd(1)->Modified();
       canvas.cd(1)->SetGrid();
  
       auto h2_BSParameters = std::unique_ptr<TH2F>(new TH2F("Parameters", "", 2, 0.0, 2.0, 8, 0, 8.));
       h2_BSParameters->SetStats(false);
  
       std::function<double(parameters, bool)> cutFunctor = [this](parameters my_param, bool isError) {
         double ret(-999.);
         if (!isError) {
           switch (my_param) {
             case X:
               return m_payload->GetX();
             case Y:
               return m_payload->GetY();
             case Z:
               return m_payload->GetZ();
             case sigmaX:
               return m_payload->GetBeamWidthX();
             case sigmaY:
               return m_payload->GetBeamWidthY();
             case sigmaZ:
               return m_payload->GetSigmaZ();
             case dxdz:
               return m_payload->Getdxdz();
             case dydz:
               return m_payload->Getdydz();
             case END_OF_TYPES:
               return ret;
             default:
               return ret;
           }
         } else {
           switch (my_param) {
             case X:
               return m_payload->GetXError();
             case Y:
               return m_payload->GetYError();
             case Z:
               return m_payload->GetZError();
             case sigmaX:
               return m_payload->GetBeamWidthXError();
             case sigmaY:
               return m_payload->GetBeamWidthYError();
             case sigmaZ:
               return m_payload->GetSigmaZError();
             case dxdz:
               return m_payload->GetdxdzError();
             case dydz:
               return m_payload->GetdydzError();
             case END_OF_TYPES:
               return ret;
             default:
               return ret;
           }
         }
       };
  
       h2_BSParameters->GetXaxis()->SetBinLabel(1, "Value");
       h2_BSParameters->GetXaxis()->SetBinLabel(2, "Error");
  
       unsigned int yBin = 8;
       for (int foo = parameters::X; foo <= parameters::dydz; foo++) {
         parameters param = static_cast<parameters>(foo);
         std::string theLabel = getStringFromTypeEnum(param);
         h2_BSParameters->GetYaxis()->SetBinLabel(yBin, theLabel.c_str());
         h2_BSParameters->SetBinContent(1, yBin, cutFunctor(param, false));
         h2_BSParameters->SetBinContent(2, yBin, cutFunctor(param, true));
         yBin--;
       }
  
       h2_BSParameters->GetXaxis()->LabelsOption("h");
       h2_BSParameters->GetYaxis()->SetLabelSize(0.05);
       h2_BSParameters->GetXaxis()->SetLabelSize(0.05);
       h2_BSParameters->SetMarkerSize(1.5);
       h2_BSParameters->Draw("TEXT");
  
       auto ltx = TLatex();
       ltx.SetTextFont(62);
       if (isOnline_) {
         ltx.SetTextSize(0.030);
       } else {
         ltx.SetTextSize(0.025);
       }
       ltx.SetTextAlign(11);
  
       auto runLS = BeamSpotPI::unpack(std::get<0>(iov));
  
       ltx.DrawLatexNDC(
           gPad->GetLeftMargin(),
           1 - gPad->GetTopMargin() + 0.01,
           (tagname + " IOV: #color[4]{" + std::to_string(runLS.first) + "," + std::to_string(runLS.second) + "}")
               .c_str());
  
       if (isOnline_) {
         canvas.cd(2);
         canvas.cd(2)->SetTopMargin(0.05);
         canvas.cd(2)->SetBottomMargin(0.06);
         canvas.cd(2)->SetLeftMargin(0.15);
         canvas.cd(2)->SetRightMargin(0.03);
         canvas.cd(2)->Modified();
         canvas.cd(2)->SetGrid();
  
         auto extras = fillTheExtraHistogram();
         if (extras) {
           for (int bin = 1; bin <= extras->GetNbinsY(); bin++) {
             edm::LogVerbatim("BeamSpotPayloadInspectorHelper")
                 << extras->GetYaxis()->GetBinLabel(bin) << ": " << extras->GetBinContent(1, bin) << "\n";
           }
         }
         extras->Draw("TEXT");
  
         ltx.DrawLatexNDC(
             gPad->GetLeftMargin(),
             1 - gPad->GetTopMargin() + 0.01,
             (tagname + " IOV: #color[4]{" + std::to_string(runLS.first) + "," + std::to_string(runLS.second) + "}")
                 .c_str());
  
         std::string fileName(this->m_imageFileName);
         canvas.SaveAs(fileName.c_str());
  
         return true;
       } else {
         std::string fileName(this->m_imageFileName);
         canvas.SaveAs(fileName.c_str());

◆ fillTheExtraHistogram()

template<class PayloadType >

virtual std::shared_ptr<TH2F> BeamSpotPI::DisplayParameters< PayloadType >::fillTheExtraHistogram ( ) const

inlinevirtual

Definition at line 363 of file BeamSpotPayloadInspectorHelper.h.

366 :

367 virtual std::shared_ptr<TH2F> fillTheExtraHistogram() const { return nullptr; }

◆ getStringFromTypeEnum()

template<class PayloadType >

virtual std::string BeamSpotPI::DisplayParameters< PayloadType >::getStringFromTypeEnum ( const parameters & parameter ) const

inlineprotectedvirtual

Definition at line 370 of file BeamSpotPayloadInspectorHelper.h.

                                                                                {
       switch (parameter) {
         case X:
           return "X [cm]";
         case Y:
           return "Y [cm]";
         case Z:
           return "Z [cm]";
         case sigmaX:
           return "#sigma_{X} [cm]";
         case sigmaY:
           return "#sigma_{Y} [cm]";
         case sigmaZ:
           return "#sigma_{Z} [cm]";
         case dxdz:
           return "#frac{dX}{dZ} [rad]";
         case dydz:
           return "#frac{dY}{dZ} [rad]";