BeamSpot_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"

#include "CondFormats/BeamSpotObjects/interface/BeamSpotObjects.h"

#include <memory>
#include <sstream>
#include "TCanvas.h"
#include "TH2F.h"

namespace {

  enum parameters {X,
           Y,
           Z,
           sigmaX,
           sigmaY,
           sigmaZ,
           dxdz,
           dydz,    
           END_OF_TYPES};

  /************************************************/
  std::string getStringFromParamEnum (const parameters &parameter){
    switch(parameter){
    case X      : return "X";
    case Y      : return "Y";       
    case Z      : return "Z";       
    case sigmaX : return "sigmaX"; 
    case sigmaY : return "sigmaY"; 
    case sigmaZ : return "sigmaZ"; 
    case dxdz   : return "dx/dz";   
    case dydz   : return "dy/dz";  
    default: return "should never be here";
    }
  }


  class BeamSpot_hx : public cond::payloadInspector::HistoryPlot<BeamSpotObjects,std::pair<double,double> > {
  public:
    BeamSpot_hx(): cond::payloadInspector::HistoryPlot<BeamSpotObjects,std::pair<double,double> >( "x vs run number", "x"){
    }

    std::pair<double,double> getFromPayload( BeamSpotObjects& payload ) override{
      return std::make_pair(payload.GetX(),payload.GetXError());
    }
  };

  class BeamSpot_rhx : public cond::payloadInspector::RunHistoryPlot<BeamSpotObjects,std::pair<double,double> > {
  public:
    BeamSpot_rhx(): cond::payloadInspector::RunHistoryPlot<BeamSpotObjects,std::pair<double,double> >( "x vs run number", "x"){
    }

    std::pair<double,double> getFromPayload( BeamSpotObjects& payload ) override{
      return std::make_pair(payload.GetX(),payload.GetXError());
    }
  };
  class BeamSpot_x : public cond::payloadInspector::TimeHistoryPlot<BeamSpotObjects,std::pair<double,double> > {
  public:
    BeamSpot_x(): cond::payloadInspector::TimeHistoryPlot<BeamSpotObjects,std::pair<double,double> >( "x vs time", "x"){
    }

    std::pair<double,double> getFromPayload( BeamSpotObjects& payload ) override{
      return std::make_pair(payload.GetX(),payload.GetXError());
    }
  };

  class BeamSpot_y : public cond::payloadInspector::TimeHistoryPlot<BeamSpotObjects,std::pair<double,double> >{
  public:
    BeamSpot_y(): cond::payloadInspector::TimeHistoryPlot<BeamSpotObjects,std::pair<double,double> >( "y vs time", "y"){
    }

    std::pair<double,double> getFromPayload( BeamSpotObjects& payload ) override{
      return std::make_pair(payload.GetY(),payload.GetYError());
    }
  };

  /************************************************
    template classes (history)
  *************************************************/

  template<parameters my_param> class BeamSpot_history : public cond::payloadInspector::HistoryPlot<BeamSpotObjects,std::pair<double,double> > {
  public:
    BeamSpot_history (): cond::payloadInspector::HistoryPlot<BeamSpotObjects,std::pair<double,double> >(getStringFromParamEnum(my_param)+" vs run number",getStringFromParamEnum(my_param)){
    }

    std::pair<double,double> getFromPayload( BeamSpotObjects& payload ) override{
      
      auto ret = std::make_pair<double,double>(-9999.,-9999.);

      switch(my_param){
      case X      : return std::make_pair<double,double>(payload.GetX(),     payload.GetXError());
      case Y      : return std::make_pair<double,double>(payload.GetY(),     payload.GetYError());      
      case Z      : return std::make_pair<double,double>(payload.GetZ(),     payload.GetZError());      
      case sigmaX : return std::make_pair<double,double>(payload.GetBeamWidthX(),payload.GetBeamWidthXError()); 
      case sigmaY : return std::make_pair<double,double>(payload.GetBeamWidthY(),payload.GetBeamWidthYError()); 
      case sigmaZ : return std::make_pair<double,double>(payload.GetSigmaZ(),    payload.GetSigmaZError()); 
      case dxdz   : return std::make_pair<double,double>(payload.Getdxdz(),      payload.GetdxdzError());   
      case dydz   : return std::make_pair<double,double>(payload.Getdydz(),      payload.GetdydzError());   
      case END_OF_TYPES : return ret;
      default : return ret;
      }
    }
  };

  typedef BeamSpot_history<X>      BeamSpot_HistoryX;     
  typedef BeamSpot_history<Y>      BeamSpot_HistoryY;    
  typedef BeamSpot_history<Z>      BeamSpot_HistoryZ;     
  typedef BeamSpot_history<sigmaX> BeamSpot_HistorySigmaX;
  typedef BeamSpot_history<sigmaY> BeamSpot_HistorySigmaY;
  typedef BeamSpot_history<sigmaZ> BeamSpot_HistorySigmaZ;
  typedef BeamSpot_history<dxdz>   BeamSpot_HistorydXdZ;
  typedef BeamSpot_history<dydz>   BeamSpot_HistorydYdZ;     

  /************************************************
    template classes (run history)
  *************************************************/

  template<parameters my_param> class BeamSpot_runhistory : public cond::payloadInspector::RunHistoryPlot<BeamSpotObjects,std::pair<double,double> > {
  public:
    BeamSpot_runhistory (): cond::payloadInspector::RunHistoryPlot<BeamSpotObjects,std::pair<double,double> >(getStringFromParamEnum(my_param)+" vs run number",getStringFromParamEnum(my_param)){
    }

    std::pair<double,double> getFromPayload( BeamSpotObjects& payload ) override{
      
      auto ret = std::make_pair<double,double>(-9999.,-9999.);

      switch(my_param){
      case X      : return std::make_pair<double,double>(payload.GetX(),     payload.GetXError());
      case Y      : return std::make_pair<double,double>(payload.GetY(),     payload.GetYError());      
      case Z      : return std::make_pair<double,double>(payload.GetZ(),     payload.GetZError());      
      case sigmaX : return std::make_pair<double,double>(payload.GetBeamWidthX(),payload.GetBeamWidthXError()); 
      case sigmaY : return std::make_pair<double,double>(payload.GetBeamWidthY(),payload.GetBeamWidthYError()); 
      case sigmaZ : return std::make_pair<double,double>(payload.GetSigmaZ(),    payload.GetSigmaZError()); 
      case dxdz   : return std::make_pair<double,double>(payload.Getdxdz(),      payload.GetdxdzError());   
      case dydz   : return std::make_pair<double,double>(payload.Getdydz(),      payload.GetdydzError());   
      case END_OF_TYPES : return ret;
      default : return ret;
      }
    }
  };

  typedef BeamSpot_runhistory<X>      BeamSpot_RunHistoryX;     
  typedef BeamSpot_runhistory<Y>      BeamSpot_RunHistoryY;    
  typedef BeamSpot_runhistory<Z>      BeamSpot_RunHistoryZ;     
  typedef BeamSpot_runhistory<sigmaX> BeamSpot_RunHistorySigmaX;
  typedef BeamSpot_runhistory<sigmaY> BeamSpot_RunHistorySigmaY;
  typedef BeamSpot_runhistory<sigmaZ> BeamSpot_RunHistorySigmaZ;
  typedef BeamSpot_runhistory<dxdz>   BeamSpot_RunHistorydXdZ;
  typedef BeamSpot_runhistory<dydz>   BeamSpot_RunHistorydYdZ;

  /************************************************
    template classes (time history)
  *************************************************/

  template<parameters my_param> class BeamSpot_timehistory : public cond::payloadInspector::TimeHistoryPlot<BeamSpotObjects,std::pair<double,double> > {
  public:
    BeamSpot_timehistory (): cond::payloadInspector::TimeHistoryPlot<BeamSpotObjects,std::pair<double,double> >(getStringFromParamEnum(my_param)+" vs time",getStringFromParamEnum(my_param)){
    }

    std::pair<double,double> getFromPayload( BeamSpotObjects& payload ) override{
      
      auto ret = std::make_pair<double,double>(-9999.,-9999.);

      switch(my_param){
      case X      : return std::make_pair<double,double>(payload.GetX(),     payload.GetXError());
      case Y      : return std::make_pair<double,double>(payload.GetY(),     payload.GetYError());      
      case Z      : return std::make_pair<double,double>(payload.GetZ(),     payload.GetZError());      
      case sigmaX : return std::make_pair<double,double>(payload.GetBeamWidthX(),payload.GetBeamWidthXError()); 
      case sigmaY : return std::make_pair<double,double>(payload.GetBeamWidthY(),payload.GetBeamWidthYError()); 
      case sigmaZ : return std::make_pair<double,double>(payload.GetSigmaZ(),    payload.GetSigmaZError()); 
      case dxdz   : return std::make_pair<double,double>(payload.Getdxdz(),      payload.GetdxdzError());   
      case dydz   : return std::make_pair<double,double>(payload.Getdydz(),      payload.GetdydzError());   
      case END_OF_TYPES : return ret;
      default : return ret;
      }
    }
  };

  typedef BeamSpot_timehistory<X>      BeamSpot_TimeHistoryX;     
  typedef BeamSpot_timehistory<Y>      BeamSpot_TimeHistoryY;    
  typedef BeamSpot_timehistory<Z>      BeamSpot_TimeHistoryZ;     
  typedef BeamSpot_timehistory<sigmaX> BeamSpot_TimeHistorySigmaX;
  typedef BeamSpot_timehistory<sigmaY> BeamSpot_TimeHistorySigmaY;
  typedef BeamSpot_timehistory<sigmaZ> BeamSpot_TimeHistorySigmaZ;
  typedef BeamSpot_timehistory<dxdz>   BeamSpot_TimeHistorydXdZ;
  typedef BeamSpot_timehistory<dydz>   BeamSpot_TimeHistorydYdZ;


  /************************************************
    X-Y correlation plot
  *************************************************/
  class BeamSpot_xy : public cond::payloadInspector::ScatterPlot<BeamSpotObjects,double,double>{
  public:
    BeamSpot_xy(): cond::payloadInspector::ScatterPlot<BeamSpotObjects,double,double>("BeamSpot x vs y","x","y" ){
    }

    std::tuple<double,double> getFromPayload( BeamSpotObjects& payload ) override{
      return std::make_tuple( payload.GetX(), payload.GetY() );
    }
  };

  /************************************************
    Display of Beam Spot parameters
  *************************************************/
  class BeamSpotParameters : public cond::payloadInspector::PlotImage<BeamSpotObjects> {
  public:
    BeamSpotParameters() : cond::payloadInspector::PlotImage<BeamSpotObjects>( "Display of BeamSpot parameters" ){
    setSingleIov( true );
    }
  
    bool fill( const std::vector<std::tuple<cond::Time_t,cond::Hash> >& iovs ) override{
      auto iov = iovs.front();
      std::shared_ptr<BeamSpotObjects> payload = fetchPayload( std::get<1>(iov) );
      
      TCanvas canvas("Beam Spot Parameters Summary","BeamSpot Parameters summary",1000,1000); 
      canvas.cd();

      canvas.SetTopMargin(0.07);
      canvas.SetBottomMargin(0.06);
      canvas.SetLeftMargin(0.15);
      canvas.SetRightMargin(0.03);
      canvas.Modified();
      canvas.SetGrid();

      auto h2_BSParameters = std::unique_ptr<TH2F>(new TH2F("Parameters","BeamSpot parameters summary",2,0.0,2.0,8,0,8.));
      h2_BSParameters->SetStats(false);
      
      std::function<double(parameters,bool)> cutFunctor = [&payload](parameters my_param,bool isError) {    
    double ret(-999.);
    if(!isError){
      switch(my_param){
      case X      : return payload->GetX();
      case Y      : return payload->GetY();     
      case Z      : return payload->GetZ();     
      case sigmaX : return payload->GetBeamWidthX(); 
      case sigmaY : return payload->GetBeamWidthY(); 
      case sigmaZ : return payload->GetSigmaZ(); 
      case dxdz   : return payload->Getdxdz();   
      case dydz   : return payload->Getdydz();
      case END_OF_TYPES : return ret;
      default : return ret;
      }
    } else {
      switch(my_param){
      case X      : return payload->GetXError();
      case Y      : return payload->GetYError();        
      case Z      : return payload->GetZError();        
      case sigmaX : return payload->GetBeamWidthXError(); 
      case sigmaY : return payload->GetBeamWidthYError(); 
      case sigmaZ : return payload->GetSigmaZError(); 
      case dxdz   : return payload->GetdxdzError();   
      case dydz   : return 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::END_OF_TYPES; 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");
      
      std::string fileName(m_imageFileName);
      canvas.SaveAs(fileName.c_str());

      return true;
    }

    /************************************************/
    std::string getStringFromTypeEnum (const parameters &parameter){
      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]";   
      default: return "should never be here";
      }
    }
  };

} // close namespace

PAYLOAD_INSPECTOR_MODULE( BeamSpot ){
  PAYLOAD_INSPECTOR_CLASS( BeamSpot_hx );
  PAYLOAD_INSPECTOR_CLASS( BeamSpot_rhx );
  PAYLOAD_INSPECTOR_CLASS( BeamSpot_x );
  PAYLOAD_INSPECTOR_CLASS( BeamSpot_y );
  PAYLOAD_INSPECTOR_CLASS( BeamSpot_xy );
  PAYLOAD_INSPECTOR_CLASS( BeamSpotParameters );
  PAYLOAD_INSPECTOR_CLASS( BeamSpot_HistoryX );        
  PAYLOAD_INSPECTOR_CLASS( BeamSpot_HistoryY );        
  PAYLOAD_INSPECTOR_CLASS( BeamSpot_HistoryZ );        
  PAYLOAD_INSPECTOR_CLASS( BeamSpot_HistorySigmaX );   
  PAYLOAD_INSPECTOR_CLASS( BeamSpot_HistorySigmaY );    
  PAYLOAD_INSPECTOR_CLASS( BeamSpot_HistorySigmaZ );   
  PAYLOAD_INSPECTOR_CLASS( BeamSpot_HistorydXdZ );     
  PAYLOAD_INSPECTOR_CLASS( BeamSpot_HistorydYdZ );     
  PAYLOAD_INSPECTOR_CLASS( BeamSpot_RunHistoryX );        
  PAYLOAD_INSPECTOR_CLASS( BeamSpot_RunHistoryY );        
  PAYLOAD_INSPECTOR_CLASS( BeamSpot_RunHistoryZ );        
  PAYLOAD_INSPECTOR_CLASS( BeamSpot_RunHistorySigmaX );   
  PAYLOAD_INSPECTOR_CLASS( BeamSpot_RunHistorySigmaY );    
  PAYLOAD_INSPECTOR_CLASS( BeamSpot_RunHistorySigmaZ );   
  PAYLOAD_INSPECTOR_CLASS( BeamSpot_RunHistorydXdZ );     
  PAYLOAD_INSPECTOR_CLASS( BeamSpot_RunHistorydYdZ );     
  PAYLOAD_INSPECTOR_CLASS( BeamSpot_TimeHistoryX );        
  PAYLOAD_INSPECTOR_CLASS( BeamSpot_TimeHistoryY );        
  PAYLOAD_INSPECTOR_CLASS( BeamSpot_TimeHistoryZ );        
  PAYLOAD_INSPECTOR_CLASS( BeamSpot_TimeHistorySigmaX );   
  PAYLOAD_INSPECTOR_CLASS( BeamSpot_TimeHistorySigmaY );    
  PAYLOAD_INSPECTOR_CLASS( BeamSpot_TimeHistorySigmaZ );   
  PAYLOAD_INSPECTOR_CLASS( BeamSpot_TimeHistorydXdZ );     
  PAYLOAD_INSPECTOR_CLASS( BeamSpot_TimeHistorydYdZ );     
}