MarkSpaceRatioDisplayer.cpp

#include "MarkSpaceRatioDisplayer.h"
#include "DisplayManager.h"
#include "DisplayInfo.h"

#include "SctData/MarkSpaceRatioTestResult.h"
#include "SctData/DefectList.h"

#include "TH2.h"
#include "TGraph.h"
#include "TCanvas.h"
#include "TLatex.h"
#include "TLine.h"
#include "TLegend.h"
#include "TStyle.h"
#include <string>
#include <boost/shared_ptr.hpp>

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

namespace SctDataDisplay {


class MarkSpaceRatioDisplayData : public DisplayData {
public:
    vector<shared_ptr<TObject> > obs;
};
    
bool MarkSpaceRatioDisplayer::inMap = DisplayManager::addToMap("SctData::MarkSpaceRatioTestResult", shared_ptr<Displayer>(new MarkSpaceRatioDisplayer()));
    
    
shared_ptr<DisplayData> MarkSpaceRatioDisplayer::display(shared_ptr<const Sct::Serializable> serial, const DisplayInfo& info, std::ostream& os) { 
    shared_ptr<MarkSpaceRatioDisplayData> data (new MarkSpaceRatioDisplayData());    
    shared_ptr<const MarkSpaceRatioTestResult> test
      = dynamic_pointer_cast<const MarkSpaceRatioTestResult>(serial);

    shared_ptr<TCanvas> canvas (createCanvas(test->getUniqueID(),test->getUniqueID())); 
    data->obs.push_back(canvas);
    canvas->Divide(1,2);

    shared_ptr<TGraph> g0     (new TGraph());
    shared_ptr<TGraph> g1     (new TGraph());
    shared_ptr<TGraph> g0flip (new TGraph());
    shared_ptr<TGraph> g1flip (new TGraph());

    shared_ptr<TGraph> g0diff (new TGraph());
    shared_ptr<TGraph> g1diff (new TGraph());

    data->obs.push_back(g0);
    data->obs.push_back(g1);

    data->obs.push_back(g0flip);
    data->obs.push_back(g1flip);

    data->obs.push_back(g0diff);
    data->obs.push_back(g1diff);

    const unsigned & n=test->getNPoints();
    g0->Set(n);
    g1->Set(n);
    g0flip->Set(n);
    g1flip->Set(n);

    g0diff->Set(n);
    g1diff->Set(n); 

    double ymin=1.E12;
    double ymax=0.;

    double xmin=0.;
    double xmax=0.;

    double diffmin=0.;
    double diffmax=0.;
    
    for (unsigned i=0 ; i<n; ++i){
      const MarkSpaceRatioTestResult::MsrPoint& p = test->getPoint(i);
      g0->SetPoint(i, p.msr, p.occ0);
      g1->SetPoint(i, p.msr, p.occ1);

      g0flip->SetPoint(i, p.msr, p.occ0flip);
      g1flip->SetPoint(i, p.msr, p.occ1flip);
      
      double diff0=p.occ0-p.occ0flip;
      double diff1=p.occ1-p.occ1flip;
      
      g0diff->SetPoint(i, p.msr, diff0);
      g1diff->SetPoint(i, p.msr, diff1);

      if (p.occ0>ymax) ymax=p.occ0;
      if (p.occ1>ymax) ymax=p.occ1;
      if (p.occ0flip>ymax) ymax=p.occ0flip;
      if (p.occ1flip>ymax) ymax=p.occ1flip;

      if (p.occ0<ymin) ymin=p.occ0;
      if (p.occ1<ymin) ymin=p.occ1;
      if (p.occ0flip<ymin) ymin=p.occ0flip;
      if (p.occ1flip<ymin) ymin=p.occ1flip;

      if (p.msr>xmax)  xmax=p.msr;
      if (p.msr<xmin)  xmin=p.msr;
      
      if (diff0>diffmax) diffmax=diff0;
      if (diff1>diffmax) diffmax=diff1;

      if (diff0<diffmin) diffmin=diff0;
      if (diff1<diffmin) diffmin=diff1;
    }

    canvas->cd(1);

    gStyle->SetTitleX(0.7);
    
    string name=test->getUniqueID();
    shared_ptr<TH2> hist1(new TH2D(name.c_str(),"Mark:Space ratio",2,xmin,xmax,2,ymin,ymax));
    hist1->SetXTitle("MSR register");
    hist1->SetYTitle("Duty Cycle");
    hist1->GetXaxis()->SetLabelSize(0.05);
    hist1->GetXaxis()->SetTitleSize(0.05);
    hist1->GetYaxis()->SetLabelSize(0.05);
    hist1->GetYaxis()->SetTitleSize(0.05);
    hist1->Draw();

    data->obs.push_back(hist1);

    g0->SetLineColor(2);
    g0->SetMarkerColor(2);
    g0->SetMarkerStyle(21);
    g0->Draw("LP");

    g0flip->SetLineColor(2);
    g0flip->SetLineStyle(2);
    g0flip->SetMarkerColor(2);
    g0flip->SetMarkerStyle(21);
    g0flip->Draw("LP");

    g1->SetLineColor(4);
    g1->SetMarkerColor(4);
    g1->SetMarkerStyle(20);
    g1->Draw("LP");

    g1flip->SetLineColor(4);
    g1flip->SetLineStyle(2);
    g1flip->SetMarkerColor(4);
    g1flip->SetMarkerStyle(20);
    g1flip->Draw("LP");

    shared_ptr<TLegend> legend0 (new TLegend(0.4, 0.75, 0.6, 0.99));
    legend0->SetBorderSize(1);
    legend0->AddEntry(g0.get(),"Link 0","lp");
    legend0->AddEntry(g1.get(),"Link 1","lp");
    legend0->AddEntry(g0flip.get(),"Link 0 (flipped)","lp");
    legend0->AddEntry(g1flip.get(),"Link 1 (flipped)","lp");
    legend0->Draw();
    data->obs.push_back(legend0);

    canvas->cd(2);
    
    name += "_2";
    shared_ptr<TH2> hist2(new TH2D(name.c_str(),"Mark:Space ratio",2,xmin,xmax,2,diffmin,diffmax));
    hist2->SetXTitle("MSR register");
    hist2->SetYTitle("Change in DutyCycle");
    hist2->GetXaxis()->SetLabelSize(0.05);
    hist2->GetXaxis()->SetTitleSize(0.05);
    hist2->GetYaxis()->SetLabelSize(0.05);
    hist2->GetYaxis()->SetTitleSize(0.05);
    hist2->Draw();

    data->obs.push_back(hist2);
    
    g0diff->SetLineColor(2);
    g0diff->SetMarkerStyle(21);
    g0diff->Draw("LP");

    g1diff->SetLineColor(4);
    g1diff->SetMarkerStyle(20);
    g1diff->Draw("LP");
    
    char label[30];
    sprintf(label,"Optimum = %5.1f", test->getOptimum());

    shared_ptr<TLatex> lat (new TLatex(test->getOptimum(), diffmin*0.8, label));
    lat->Draw();
    data->obs.push_back(lat);

    shared_ptr<TLine> line (new TLine(xmin, 0, xmax, 0));
    line->SetLineStyle(2);
    line->Draw();
    data->obs.push_back(line);

    shared_ptr<TLine> line2 (new TLine(test->getOptimum(), diffmin*0.68, test->getOptimum(), diffmax*0.68));
    line2->SetLineColor(13);
    line2->Draw();
    data->obs.push_back(line2);

    shared_ptr<TLegend> legend1 (new TLegend(0.4, 0.85, 0.6, 0.99));
    legend1->SetBorderSize(1);
    legend1->AddEntry(g0diff.get(),"Link 0","lp");
    legend1->AddEntry(g1diff.get(),"Link 1","lp");
    legend1->Draw();
    data->obs.push_back(legend1);

    return data;
}

}

---