AlignPCLThresholds_PayloadInspector.cc

Go to the documentation of this file.

#include "CondCore/Utilities/interface/PayloadInspectorModule.h"
#include "CondCore/Utilities/interface/PayloadInspector.h"
#include "CondCore/CondDB/interface/Time.h"

// the data format of the condition to be inspected
#include "CondFormats/PCLConfig/interface/AlignPCLThresholds.h"

#include <memory>
#include <sstream>
#include <iostream>
#include <functional>

// include ROOT 
#include "TH2F.h"
#include "TLegend.h"
#include "TCanvas.h"
#include "TLine.h"
#include "TStyle.h"

namespace {

  enum types {DELTA,
          SIG,
          MAXMOVE,
          MAXERR,
          END_OF_TYPES};
  
  /************************************************
    Display of AlignPCLThresholds
  *************************************************/
  class AlignPCLThresholds_Display : public cond::payloadInspector::PlotImage<AlignPCLThresholds> {
  public:
    AlignPCLThresholds_Display() : cond::payloadInspector::PlotImage<AlignPCLThresholds>( "Display of threshold parameters for SiPixelAli PCL" ){
    setSingleIov( true );
    }
  
    bool fill( const std::vector<std::tuple<cond::Time_t,cond::Hash> >& iovs ) override{
      auto iov = iovs.front();
      std::shared_ptr<AlignPCLThresholds> payload = fetchPayload( std::get<1>(iov) );
      auto alignables = payload->getAlignableList();
      
      TCanvas canvas("Alignment PCL thresholds summary","Alignment PCL thresholds summary",1500,800); 
      canvas.cd();

      canvas.SetTopMargin(0.07);
      canvas.SetBottomMargin(0.06);
      canvas.SetLeftMargin(0.11);
      canvas.SetRightMargin(0.05);
      canvas.Modified();
      canvas.SetGrid();

      auto Thresholds = std::unique_ptr<TH2F>(new TH2F("Thresholds","Alignment parameter thresholds",alignables.size(),0,alignables.size(),24,0,24));
      Thresholds->SetStats(false);
      
      std::function<float(types,std::string,AlignPCLThresholds::coordType)> cutFunctor = [&payload](types my_type,std::string alignable,AlignPCLThresholds::coordType coord) {  
    float ret(-999.);
    switch(my_type){
    case DELTA   : return payload->getCut(alignable,coord);
    case SIG     : return payload->getSigCut(alignable,coord);
    case MAXMOVE : return payload->getMaxMoveCut(alignable,coord);
    case MAXERR  : return payload->getMaxErrorCut(alignable,coord);
    case END_OF_TYPES : return ret;
    default : return ret;
    }
      };

      unsigned int xBin=0;      
      for(const auto &alignable : alignables){
    xBin++;

    auto xLabel = replaceAll(replaceAll(alignable,"minus","(-)"),"plus","(+)");
    Thresholds->GetXaxis()->SetBinLabel(xBin,(xLabel).c_str());
    unsigned int yBin=24;
    for(int foo = AlignPCLThresholds::X; foo != AlignPCLThresholds::extra_DOF; foo++ ){
      AlignPCLThresholds::coordType coord = static_cast<AlignPCLThresholds::coordType>(foo);  
      for(int bar = types::DELTA; bar != types::END_OF_TYPES; bar++ ){
        types type = static_cast<types>(bar);
        std::string theLabel = getStringFromTypeEnum(type)+getStringFromCoordEnum(coord);
        if(xBin==1){
          Thresholds->GetYaxis()->SetBinLabel(yBin,theLabel.c_str());
        }
 
        Thresholds->SetBinContent(xBin,yBin,cutFunctor(type,alignable,coord)); 

        yBin--;
      }// loop on types
    }// loop on coordinates
      } // loop on alignables


      Thresholds->GetXaxis()->LabelsOption("h");
      Thresholds->Draw("TEXT");
      
      std::string fileName(m_imageFileName);
      canvas.SaveAs(fileName.c_str());

      return true;
    }
    
    /************************************************/
    std::string getStringFromCoordEnum (const AlignPCLThresholds::coordType &coord){
      switch(coord){
      case AlignPCLThresholds::X : return "X";
      case AlignPCLThresholds::Y : return "Y";
      case AlignPCLThresholds::Z : return "Z";
      case AlignPCLThresholds::theta_X : return "#theta_{X}";
      case AlignPCLThresholds::theta_Y : return "#theta_{Y}";
      case AlignPCLThresholds::theta_Z : return "#theta_{Z}";
      default : return "should never be here";
      }
    }

    /************************************************/
    std::string getStringFromTypeEnum (const types &type){
      switch(type){
      case types::DELTA   : return "#Delta";
      case types::SIG     : return "#Delta/#sigma ";
      case types::MAXMOVE : return "max. move ";
      case types::MAXERR  : return "max. err ";
      default: return "should never be here";
      }
    }

    /************************************************/
    std::string replaceAll(const std::string& str, const std::string& from, const std::string& to) {
      std::string out(str);
  
      if(from.empty())
        return out;
      size_t start_pos = 0;
      while((start_pos = out.find(from, start_pos)) != std::string::npos) {
        out.replace(start_pos, from.length(), to);
        start_pos += to.length(); // In case 'to' contains 'from', like replacing 'x' with 'yx'
      }
      return out;
    }
   
  };
} // close namespace

// Register the classes as boost python plugin
PAYLOAD_INSPECTOR_MODULE(AlignPCLThresholds){
  PAYLOAD_INSPECTOR_CLASS(AlignPCLThresholds_Display);
}