NPtGainDisplayer.cpp

#include "NPtGainDisplayer.h"
#include "DisplayManager.h"
#include "DisplayInfo.h"

#include "SctData/NPtGainTestResult.h"
#include "SctData/FitScanResult.h"
#include "SctData/ResponseCurve.h"
#include "Sct/SctParameters.h"

#include <TGraph.h>
#include <TCanvas.h>
#include <TF1.h>
#include <TPolyLine.h>
#include <TLine.h>

#include <algorithm>

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

namespace SctDataDisplay {

class NPtGainDisplayData : public DisplayData {
public:
    vector<shared_ptr<TCanvas> > canvas;
    shared_ptr<const NPtGainTestResult> test;
    vector<shared_ptr<TF1> > funcs;
    vector<shared_ptr<TGraph> > graphs;
    vector<shared_ptr<TPolyLine> > lines;
};        
    
bool NPtGainDisplayer::inMap = DisplayManager::addToMap("SctData::NPtGainTestResult", shared_ptr<Displayer>(new NPtGainDisplayer()));
    
    
shared_ptr<DisplayData> NPtGainDisplayer::display(shared_ptr<const Sct::Serializable> serial, const DisplayInfo& info, std::ostream& os) {
    shared_ptr<NPtGainDisplayData> data (new NPtGainDisplayData());
    data->test = dynamic_pointer_cast<const NPtGainTestResult>(serial);
        
    //Construct gain, noise and offset graphs
    shared_ptr<TGraph> noise  = data->test->getNoiseGraph();
    shared_ptr<TGraph> gain   = data->test->getGainGraph();
    shared_ptr<TGraph> offset = data->test->getOffsetGraph();

    data->graphs.push_back(noise);
    data->graphs.push_back(gain);
    data->graphs.push_back(offset);
    
    plotData("Gain", 0, 80, *data, *gain, data->test->gainSlope);
    plotData("Offset", 0, 200, *data, *offset, data->test->offsetSlope);
    plotData("Noise", 0, 2500, *data, *noise, data->test->noiseSlope);

    if (info.displayChips.size() > 0)
    displayChips(*data, info, os);
    
    if (info.displayChannels.size() > 0)
    displayChannels(*data, info, os);
    
    os << "Defects:" << std::endl;
    printDefectList(data->test->getDefects(), os);
    
    return data;
}

void NPtGainDisplayer::plotData(string name, double min, double max, NPtGainDisplayData& data, TGraph& graph, RangedVector<float> slope) {
  std::string canvasname=(string)data.test->getHeader().getUniqueID() + "_" + name;
  if (DisplayManager::rootMode()){
    shared_ptr<TDirectory> file=DisplayManager::getTDirectory();
    if (file) {
      file->cd();
      graph.Write(canvasname.c_str());
    }
  }else{
    std::string canvasname=(string)data.test->getHeader().getUniqueID() + "_" + name;
    shared_ptr<TCanvas> c = createCanvas(canvasname, canvasname);
    data.canvas.push_back(c);
    graph.SetMaximum(max);
    graph.SetMinimum(min);
    graph.SetTitle(name.c_str());
    graph.GetXaxis()->SetLimits(0, nChannelModule);
    graph.GetXaxis()->SetTitle("Channel Number");
    graph.Draw("alp");
    for (unsigned int ichip=0; ichip<nChipModule; ++ichip) {
        shared_ptr<TPolyLine> p (new TPolyLine(2));
        data.lines.push_back(p);
        p->SetLineStyle(2);
        p->SetPoint(0, nChannelChip*ichip-0.5, min);
        p->SetPoint(1, nChannelChip*ichip-0.5, max);
        p->Draw();
    //--------------------------------------
    if (ichip<slope.size()){
      ModuleElement e=SctData::ModuleElement::Chip(ichip);
      double mean=0;
      for (unsigned ichan=e.getFirst(); ichan<e.getLast(); ++ichan){
        Double_t x, y;
        graph.GetPoint(ichan, x,y);
        mean+=y;
      }
      mean /= e.getNChannels();
      TLine*l = new TLine(e.getFirst(), mean-slope[ichip]* nChannelChip/2, 
                  e.getLast(),  mean+slope[ichip]*nChannelChip/2);
      std::cout << "line: (" << e.getFirst() << "," << mean-slope[ichip]*nChannelChip/2
            << ") -> (" << e.getLast()   << "," << mean+slope[ichip]*nChannelChip/2 << ")" << endl;

      l->SetLineWidth(1);
      l->SetLineColor(kBlue);
      l->Draw();
    }
    }
  }
}

void NPtGainDisplayer::displayChips(NPtGainDisplayData& data, const DisplayInfo& info, std::ostream& os) {
    shared_ptr<TCanvas> c = createCanvas((string)data.test->getHeader().getUniqueID() + "_chipRC", data.test->getModuleName() + " Chip Fits");
    data.canvas.push_back(c);
    divideCanvas(info.displayChips.size(), *c);
    for (unsigned int i = 0; i < info.displayChips.size(); ++i) {
        c->cd(i + 1);
    displayData(data, data.test->getChipData(info.displayChips[i]));
    }
    
    //Print out chip fit parameters
    os << "Chip parameters" << endl;
    for (unsigned int i = 0; i < 12; ++i) {
        shared_ptr<TF1> f = data.test->getChipData(i).rc->getFunction();
        os << f->GetParameter(0) << "  " << f->GetParameter(1) << "  " << f->GetParameter(2) << endl;
    }    
}

void NPtGainDisplayer::displayChannels(NPtGainDisplayData& data, const DisplayInfo& info, std::ostream& os) {
    shared_ptr<TCanvas> c;
    unsigned int nMax = min((unsigned int)25, info.displayChannels.size());
    int j=0;
    
    for (unsigned int i=0; i<info.displayChannels.size(); ++i, ++j) {   
        if (j%nMax == 0) {
        c = createCanvas((string)data.test->getUniqueID() + "_channelRC", "Channel Response Curves for module " + data.test->getModuleName());
        data.canvas.push_back(c);
        divideCanvas(nMax, *c);
            j=0;
        }   
        c->cd(i%nMax + 1);
    displayData(data, data.test->getChannelData(info.displayChannels[i]));
    }
}

void NPtGainDisplayer::displayData(NPtGainDisplayData& data, const NPtGainTestResultData& testData) {
  gPad->SetLeftMargin(0.17);
  gPad->SetBottomMargin(0.15);
  gPad->SetTopMargin(0.03);
  gPad->SetRightMargin(0.03);
    TGraph & g = *testData.graph;
    g.SetMarkerStyle(20);
    g.Draw("ap");
    g.GetHistogram()->SetXTitle("Q_th / fC");
    g.GetHistogram()->SetYTitle("V_th / mV");
    g.GetHistogram()->GetYaxis()->SetTitleOffset(1.2);
    g.GetHistogram()->GetXaxis()->SetLabelSize(0.06);
    g.GetHistogram()->GetYaxis()->SetLabelSize(0.06);
    g.GetHistogram()->GetXaxis()->SetTitleSize(0.06);
    g.GetHistogram()->GetYaxis()->SetTitleSize(0.06);
    shared_ptr<TF1> f = testData.rc->getFunction();
    f->SetRange(0, 8);
    f->SetFillStyle(0);
    f->Draw("same");
    data.funcs.push_back(f);
}


}

---