JDrawDetector2D.cc

Go to the documentation of this file.

#include <string>
#include <iostream>
#include <limits>
#include <vector>

#include "TROOT.h"
#include "TH2D.h"
#include "TApplication.h"
#include "TGraph.h"
#include "TEllipse.h"
#include "TCanvas.h"
#include "TMarker.h"
#include "TText.h"
#include "TStyle.h"
#include "TLegend.h"
#include "TError.h"

#include "JLang/JSinglePointer.hh"
#include "JROOT/JCanvas.hh"
#include "JROOT/JStyle.hh"
#include "JROOT/JMarkerAttributes.hh"
#include "JDetector/JDetector.hh"
#include "JDetector/JDetectorToolkit.hh"
#include "JDetector/JTripod.hh"
#include "JGeometry2D/JPosition2D.hh"
#include "JGeometry2D/JCircle2D.hh"

#include "Jeep/JeepToolkit.hh"
#include "Jeep/JContainer.hh"
#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"


/**
 * \file
 * Auxiliary program to draw the footprint of detector(s).
 * \author mdejong
 */
int main(int argc, char**argv)
{
  using namespace std;
  using namespace JPP;

  typedef JContainer< vector<JTripod> >      tripods_container;

  vector<string>      detectorFile;
  tripods_container   tripods;
  string              outputFile;
  JCanvas             canvas;
  bool                legend;
  double              markerSize;
  double              textSize;
  bool                batch;
  int                 debug;

  try {

    JParser<> zap("Auxiliary program to draw the footprint of detector(s).");

    zap['w'] = make_field(canvas,       "size of canvas <nx>x<ny> [pixels]")  = JCanvas(500, 500);
    zap['a'] = make_field(detectorFile, "detector file")                      = JPARSER::initialised();
    zap['T'] = make_field(tripods,      "tripod data")                        = JPARSER::initialised();
    zap['o'] = make_field(outputFile,   "graphics output")                    = "";
    zap['L'] = make_field(legend,       "optional legend");
    zap['S'] = make_field(markerSize,   "marker size")                        = 1.0;
    zap['s'] = make_field(textSize,     "text size")                          = 0.02;
    zap['B'] = make_field(batch,        "batch processing");
    zap['d'] = make_field(debug)                                              = 1;

    zap(argc, argv);
  }
  catch(const exception &error) {
    FATAL(error.what() << endl);
  }


  if (detectorFile.empty() && tripods.empty()) {
    FATAL("No detector elements." << endl);
  }


  gROOT->SetBatch(batch);

  gErrorIgnoreLevel = kWarning;

  TApplication* tp = new TApplication("user", NULL, NULL);
  TCanvas*      cv = new TCanvas("detector", "", canvas.x, canvas.y);

  JSinglePointer<TStyle> gStyle(new JStyle("gplot", cv->GetWw(), cv->GetWh()));

  gROOT->SetStyle("gplot");
  gROOT->ForceStyle();

  cv->SetFillStyle(4000);
  cv->SetFillColor(kWhite);
  cv->Divide(1, 1);
  cv->cd(1);

  JMarkerAttributes::getInstance().setMarkerSize(markerSize);


  struct alignment {
    double angle;
    int    text;
  };

  vector<alignment> align = {
    { 0.25*PI, kHAlignLeft  + kVAlignBottom },
    { 0.75*PI, kHAlignRight + kVAlignBottom },
    { 1.25*PI, kHAlignRight + kVAlignTop },
    { 1.75*PI, kHAlignLeft  + kVAlignTop }
  };


  int number_of_positions = 0;

  vector<TGraph*> data;
  vector<TText*>  text;
  
  JCircle2D    circle;
  JUTMPosition position;

  for (vector<string>::const_iterator file_name = detectorFile.begin(); file_name != detectorFile.end(); ++file_name) {

    JDetector detector;

    try {
      load(*file_name, detector);
    }
    catch(const JException& error) {
      FATAL(error);
    }

    if (detector.empty()) {
      ERROR("Empty detector." << endl);
      continue;
    }

    const JCircle2D c1(detector.begin(), detector.end());

    if (c1.getRadius() > circle.getRadius()) {
      circle = c1;
    }

    position = detector.getUTMPosition();

    const TAttMarker& marker = *JMarkerAttributes::getInstance().next();

    TGraph* graph = new TGraph(detector.size());

    graph->SetTitle(getFilename(*file_name).c_str());

    dynamic_cast<TAttMarker&>(*graph) = marker;

    int n = 0;

    for (JDetector::const_iterator module = detector.begin(); module != detector.end(); ++module, ++n) {      

      number_of_positions += 1;

      graph->GetX()[n] = module->getX();
      graph->GetY()[n] = module->getY();

      if (module->getFloor() == 1) {

        const alignment& a1 = align[distance(detectorFile.cbegin(), file_name) % align.size()];

        text.push_back(new TText(module->getX() + 3.0 * textSize * c1.getRadius()*cos(a1.angle),
                                 module->getY() + 3.0 * textSize * c1.getRadius()*sin(a1.angle),
                                 MAKE_CSTRING(module->getString())));

        (*text.rbegin())->SetTextSize (textSize);
        (*text.rbegin())->SetTextAlign(a1.text);
        (*text.rbegin())->SetTextColor(marker.GetMarkerColor());
      }
    }
    
    data.push_back(graph);
  }

  if (!tripods.empty()) {

    if (number_of_positions == 0) {

      for (tripods_container::const_iterator i = tripods.begin(); i != tripods.end(); ++i) {
        position += *i;
      }

      position /= tripods.size();
    }

    vector<JPosition3D> zbuf;

    for (tripods_container::iterator i = tripods.begin(); i != tripods.end(); ++i) {
      zbuf.push_back(*i - position);
    }

    circle = JCircle2D(zbuf.begin(), zbuf.end());

    TGraph* graph = new TGraph(zbuf.size());

    graph->SetTitle("tripod");

    for (size_t i = 0; i != zbuf.size(); ++i) {
      graph->GetX()[i] = zbuf[i].getPosition().getX();
      graph->GetY()[i] = zbuf[i].getPosition().getY();
    }

    dynamic_cast<TAttMarker&>(*graph) = *JMarkerAttributes::getInstance().next();

    data.push_back(graph);
  }

  if (number_of_positions == 0 && tripods.empty()) {
    FATAL("No detector elements." << endl);
  }


  DEBUG("Detector (x,y,R): " << FIXED(12,3) << circle.getX() << ' ' << FIXED(12,3) << circle.getY() << ' ' << FIXED(9,3) << circle.getRadius() << endl);

  for (vector<TGraph*>::iterator graph = data.begin(); graph != data.end(); ++graph) {
    for (int i = 0; i != (*graph)->GetN(); ++i) {
      (*graph)->GetX()[i] -= circle.getX();
      (*graph)->GetY()[i] -= circle.getY();
    }
  }

  for (vector<TText*>::iterator i = text.begin(); i != text.end(); ++i) {
    (*i)->SetX((*i)->GetX() - circle.getX());
    (*i)->SetY((*i)->GetY() - circle.getY());
  }

  circle.sub(circle.getPosition());

  Double_t R    = circle.getRadius();

  if (R <= 1.0) {
    R = 1.0;
  }

  Double_t xmin = circle.getX() - R;
  Double_t xmax = circle.getX() + R;
  Double_t ymin = circle.getY() - R;
  Double_t ymax = circle.getY() + R;


  const Double_t dx = (xmax - xmin);
  const Double_t dy = (ymax - ymin);

  xmin -= 0.1 * dx;
  xmax += 0.1 * dx;
  ymin -= 0.1 * dy;
  ymax += 0.1 * dy;


  cv->cd(1);

  TH2D h2("h2", "", 1, xmin, xmax, 1, ymin, ymax);

  h2.GetXaxis()->SetTitle("x [m]");
  h2.GetYaxis()->SetTitle("y [m]");
  
  h2.GetXaxis()->CenterTitle(true);
  h2.GetYaxis()->CenterTitle(true);

  h2.SetStats(kFALSE);
  h2.Draw();


  TEllipse ellipse(circle.getX(), circle.getY(), circle.getRadius());

  ellipse.Draw();

  for (vector<TGraph*>::iterator graph = data.begin(); graph != data.end(); ++graph) {
    (*graph)->Draw("P");
  }

  for (vector<TText*>::iterator i = text.begin(); i != text.end(); ++i) {
    (*i)->Draw();
  }

  
  if (legend) {

    const Double_t x2  = gPad->GetX2() - gStyle->GetPadRightMargin();
    const Double_t y2  = gPad->GetY2() - gStyle->GetPadTopMargin();
    
    size_t   length    = 10;
    Double_t font_size = 0.03; // gStyle->GetStatFontSize();
    
    for (vector<TGraph*>::iterator graph = data.begin(); graph != data.end(); ++graph) {
      length = max(length, strlen((*graph)->GetTitle()));
    }
    
    TLegend* legend = new TLegend(x2 - length      * font_size * 0.65 - 0.02, 
                                  y2 - data.size() * font_size, 
                                  x2 - 0.01, 
                                  y2 - 0.01);
    
    //legend->SetFillStyle(4000);
    legend->SetFillColor(0);
    legend->SetBorderSize(0);
    legend->SetTextSize(font_size);
    
    for (vector<TGraph*>::iterator graph = data.begin(); graph != data.end(); ++graph) {
      legend->AddEntry(*graph, (*graph)->GetTitle(), "P"); 
    }
    
    legend->Draw();
  }

  cv->Update();

  if (outputFile != "") {
    cv->SaveAs(outputFile.c_str());
  }

  if (!batch) {
    tp->Run();
  }
}