RawDisplayer.cpp

#include "RawDisplayer.h"
#include "DisplayManager.h"
#include "DisplayInfo.h"

#include "SctData/ModuleConfiguration.h"
#include "SctData/ResultHeader.h"
#include "SctData/ConfigurationVariable.h"
#include "SctData/RawScanResult.h"
#include "SctData/OccupancyProjector.h"
#include "SctData/ModuleElement.h"
#include "SctData/DefaultVariable.h"
#include "ScanResultWriter/dataTypes.h"
#include "Sct/AbcdScans.h"
#include <TH1.h>
#include <TH2.h>
#include <TCanvas.h>
#include <TApplication.h>
#include <TStyle.h>
#include <TPaletteAxis.h>

#include <iostream>
#include <vector>
#include <boost/lexical_cast.hpp>

using namespace std;
using namespace Sct;
using namespace SctData;
using namespace boost;

namespace SctDataDisplay {
    

bool RawDisplayer::inMap = DisplayManager::addToMap("SctData::RawScanResult", shared_ptr<Displayer>(new RawDisplayer()));
    
shared_ptr<DisplayData> RawDisplayer::display(shared_ptr<const Sct::Serializable> serial, const DisplayInfo& info, std::ostream& os) {
    shared_ptr<RawDisplayData> data (new RawDisplayData());
    data->scan = dynamic_pointer_cast<const RawScanResult>(serial);

    const ConfigurationVariable& var = data->scan->getHeader().getVariable();
    
    if (data->scan->getDataType() != SR_DT_RAWHIST  && 
    var != *DefaultVariable::instance(ST_NMASK) &&
    var != *DefaultVariable::instance(ST_TOKEN) &&
    info.displayChannels.size() + info.displayChips.size() != 0) {
      displayProjs(info, *data);
    }
    
    string name = "Raw." + (string)data->scan->getUniqueID();
    shared_ptr<TCanvas> c = createCanvas(name, name);
    data->canvas.push_back(c);
    TPad* p1=new TPad("Data","Data",0.,0.,0.75,1.0);
    TPad* p2=new TPad("Info","Info",0.75,0.4,1.0,0.95);
    p1->Draw();
    p2->Draw();

    p2->cd();
    p2->SetLeftMargin(0.2);
    p2->SetRightMargin(0.3);
    //p2->SetLogz();
    const SctData::ScanPoints& pts = data->scan->getPoints();
    double* bins = pts.getEdgesAscending();
    int npoints= pts.getNPoints();
    shared_ptr<TH2> trigs (new TH2F("Triggers","Triggers",2,0,2,npoints,bins));
    for (int i=0; i<npoints; ++i){
      int ipt=pts.ascending() ? i : npoints-i-1;
      trigs->Fill(1.5, pts[ipt],data->scan->getPoints().getNEvents(ipt));
      trigs->Fill(0.5, pts[ipt],data->scan->getPoints().getNErrorEvents(ipt));
    }
    delete[] bins;
    trigs->GetYaxis()->SetTitleOffset(1.8);
    trigs->GetXaxis()->SetLabelSize(0.08);
    trigs->GetYaxis()->SetLabelSize(0.08);
    trigs->GetZaxis()->SetLabelSize(0.08);
    trigs->GetXaxis()->SetBinLabel(1,"Errors");
    trigs->GetXaxis()->SetBinLabel(2,"Events");
    
    gPad->SetLogz();
    gPad->SetTheta(10);
    data->histos.push_back(trigs);
    displayHistogram(trigs,"lego");

    const Int_t NRGBs = 5;
    Double_t Stops[NRGBs] = { 0.00, 0.10, 0.50, 0.90, 1.00 };
    Double_t Red[NRGBs]   = { 1.0, 0.0, 0.0, 1.0, 0.0 };
    Double_t Green[NRGBs] = { 1.0, 0.0, 1.0, 0.0, 0.0 };
    Double_t Blue[NRGBs]  = { 1.0, 1.0, 0.0, 0.0, 0.0 };
    gStyle->CreateGradientColorTable(NRGBs, Stops, Red, Green, Blue, 100);
    
    p1->cd();
    gPad->Divide(1,2,0.01,0.01);
    for (int ilink=0; ilink<2; ++ilink){
      p1->cd(ilink+1);
      data->scan->getScanData(ilink).SetMinimum(0.);
      string x_title;
      switch(data->scan->getDataType()) {
      case SR_DT_RAWHIST: { x_title="Time Bin"; break;}
      case SR_DT_SLICE: case SR_DT_SLICE_COMPRESSED: { x_title="Channel"; break;}
      }
      shared_ptr<TH2> datah(dynamic_cast<TH2*>(data->scan->getScanData(ilink).Clone()));
      
      for (unsigned iy=1; iy<=datah->GetNbinsY(); ++iy){
    int ipt=pts.ascending() ? iy-1 : npoints-iy;
    for (unsigned ix=1; ix<=datah->GetNbinsX(); ++ix){
      double val=datah->GetBinContent(ix,iy);
      double triggers = data->scan->getPoints().getNEvents(ipt);
      if (triggers!=0.) val/=triggers;
      datah->SetBinContent(ix,iy,val);
    }
      }
      datah->SetXTitle(x_title.c_str());
      std::string ytitle=var.getVariableName();
      datah->SetYTitle(ytitle.c_str());
      datah->SetStats(false);
      datah->GetXaxis()->CenterTitle();
      datah->GetYaxis()->CenterTitle();
      data->histos.push_back(datah);
      displayHistogram(datah,"colz");
    }

    if (info.occupancyHistograms && data->scan->nOccupancyPerEvent()!=0){
      displayOccupancyPerEvent(info, *data);
    }else if(info.occupancyHistograms){
      std::cerr << "No OPE data available" << std::endl;
    }

    return data;
}

void RawDisplayer::displayOccupancyPerEvent(const DisplayInfo& info, RawDisplayData& data){
  ostringstream oss;
  oss << "Raw." << data.scan->getHeader().getUniqueID() << "_OPE";
  const char*const name = oss.str().c_str();
  shared_ptr<TCanvas> canvas_occ = createCanvas(name, name);
  data.canvas.push_back(canvas_occ);
  const unsigned n=data.scan->nOccupancyPerEvent();
  divideCanvas(n, *canvas_occ);
  for (unsigned i=0; i<n; ++i){
    canvas_occ->cd(i+1);
    gPad->SetLogz();
    gPad->SetLeftMargin(0.17);
    gPad->SetBottomMargin(0.15);
    gPad->SetTopMargin(0.03);
    gPad->SetRightMargin(0.03);
    TH2D& hist = const_cast<TH2D&> ( data.scan->getOccupancyPerEvent(i) );
    ostringstream title;
    title << "Chip " << i;
    hist.GetYaxis()->SetTitleOffset(1.2);
    hist.GetXaxis()->SetLabelSize(0.05);
    hist.GetYaxis()->SetLabelSize(0.05);
    hist.GetXaxis()->SetTitleSize(0.05);
    hist.GetYaxis()->SetTitleSize(0.05);
    hist.GetXaxis()->CenterTitle();
    hist.GetYaxis()->CenterTitle();
    hist.SetTitle(title.str().c_str());
    displayHistogram(hist,"colz");
  }
}
    
void RawDisplayer::displayProjs(const DisplayInfo& info, RawDisplayData& data) {
  if (!info.projections) return;
    unsigned int nMax = min((unsigned int)25, info.displayChannels.size() + info.displayChips.size());
    unsigned int j=0;
    shared_ptr<TCanvas> c;
    
    //Now show some projections for channels and chips
    OccupancyProjector occ(*data.scan);

    for (unsigned int i=0; i<info.displayChips.size(); ++i, ++j) {
    if (j%nMax == 0) {
      std::string canvasname = "Raw." + (string)data.scan->getHeader().getUniqueID() + "_chipProj";
            c = createCanvas(canvasname, canvasname);
        data.canvas.push_back(c);
        divideCanvas(nMax, *c);
            j=0;
        }
    c->cd(j+1);
    string name = "chip" + lexical_cast<string>(info.displayChips[i]) + (string)data.scan->getUniqueID();
    shared_ptr<TH1> chip(occ.getOccupancy(name.c_str(), ModuleElement::Chip(info.displayChips[i])).release());
    gPad->SetLeftMargin(0.2);
    gPad->SetBottomMargin(0.15);
    gPad->SetTopMargin(0.07);
    gPad->SetRightMargin(0.03);
    chip->GetYaxis()->SetTitleOffset(1.35);
    chip->GetXaxis()->SetLabelSize(0.05);
    chip->GetYaxis()->SetLabelSize(0.05);
    chip->GetXaxis()->SetTitleSize(0.05);
    chip->GetYaxis()->SetTitleSize(0.05);
    chip->GetXaxis()->CenterTitle();
    chip->GetYaxis()->CenterTitle();
    chip->GetXaxis()->SetNdivisions(506);
    data.histos.push_back(chip);
    displayHistogram(chip);
    }
    
    
    for (unsigned int i=0; i<info.displayChannels.size(); ++i, ++j) {
    if (j%nMax == 0) {
      std::string canvasname = "Raw." + (string)data.scan->getHeader().getUniqueID() + "_chanProj";
            c = createCanvas(canvasname, canvasname);
        data.canvas.push_back(c);
        divideCanvas(nMax, *c);
            j=0;
        }
    c->cd(j+1);
    
    string name = "channel" + lexical_cast<string>(info.displayChannels[i]) + (string)data.scan->getUniqueID();
    shared_ptr<TH1> channel(occ.getOccupancy(name.c_str(), ModuleElement::Channel(info.displayChannels[i])).release());
    data.histos.push_back(channel);
    displayHistogram(channel);
    }
}   
}

---