DrawUtil.cxx

Go to the documentation of this file.

// $Id: DrawUtil.cxx,v 1.2 2008/09/05 15:42:33 rustem Exp $

// C++
#include <cmath>
#include <iostream>

// MINOS
#include "UgliGeometry/UgliGeomHandle.h"

// ROOT
#include "TPad.h"
#include "TH1.h"
#include "TH2.h"
#include "TGraph.h"

// Local
#include "PhysicsNtuple/Default.h"

// Local
#include "DrawUtil.h"

using namespace std;

//------------------------------------------------------------------------------------------
void Anp::Draw::Config(TPad *pad, const string &prefix, const Registry &reg)
{
   if(!pad)
   {
      return;
   }

   double PadRightMargin = 0.15;
   double PadLeftMargin = 0.12;
   double PadTopMargin = 0.02;
   double PadBottomMargin = 0.12;   

   PadRightMargin = Read(prefix + "PadRightMargin", PadRightMargin, reg);
   PadLeftMargin = Read(prefix + "PadLeftMargin", PadLeftMargin, reg);
   PadTopMargin = Read(prefix + "PadTopMargin", PadTopMargin, reg);
   PadBottomMargin = Read(prefix + "PadBottomMargin", PadBottomMargin, reg);

   pad -> SetRightMargin(PadRightMargin);
   pad -> SetLeftMargin(PadLeftMargin);
   pad -> SetTopMargin(PadTopMargin);
   pad -> SetBottomMargin(PadBottomMargin);
}

//------------------------------------------------------------------------------------------
void Anp::Draw::Config(TH1 *h, const string &prefix, const Registry &reg)
{
   if(!h)
   {
      return;
   }

   double YAxisTitleOffset = 0.7;
   double XAxisTitleOffset = 0.7;

   string YAxisTitle = "";
   string XAxisTitle = "";

   double YAxisTitleSize = 0.065;
   double XAxisTitleSize = 0.065;

   string ShowStats = "no";

   string CenterXTitle = "yes";
   string CenterYTitle = "yes";

   int LineStyle = 1;
   int LineColor = 1;
   int LineWidth = 1;

   int FillStyle = -1;
   int FillColor = 1;

   YAxisTitleOffset = Read(prefix + "YAxisTitleOffset", YAxisTitleOffset, reg);
   XAxisTitleOffset = Read(prefix + "XAxisTitleOffset", XAxisTitleOffset, reg);

   YAxisTitle = Read(prefix + "YAxisTitle", YAxisTitle, reg);
   XAxisTitle = Read(prefix + "XAxisTitle", XAxisTitle, reg); 

   YAxisTitleSize = Read(prefix + "YAxisTitleSize", YAxisTitleSize, reg);
   XAxisTitleSize = Read(prefix + "XAxisTitleSize", XAxisTitleSize, reg);

   ShowStats = Read(prefix + "ShowStats", ShowStats, reg);

   CenterXTitle = Read(prefix + "CenterXTitle", CenterXTitle, reg);
   CenterYTitle = Read(prefix + "CenterYTitle", CenterYTitle, reg);

   LineStyle = Read(prefix + "LineStyle", LineStyle, reg);
   LineColor = Read(prefix + "LineColor", LineColor, reg);
   LineWidth = Read(prefix + "LineWidth", LineWidth, reg);

   FillStyle = Read(prefix + "FillStyle", FillStyle, reg);
   FillColor = Read(prefix + "FillColor", FillColor, reg);

   h -> GetXaxis() -> SetTitleOffset(XAxisTitleOffset);
   h -> GetYaxis() -> SetTitleOffset(YAxisTitleOffset);

   h -> GetXaxis() -> SetTitle(XAxisTitle.c_str());
   h -> GetYaxis() -> SetTitle(YAxisTitle.c_str()); 

   h -> GetXaxis() -> SetTitleSize(XAxisTitleSize);
   h -> GetYaxis() -> SetTitleSize(YAxisTitleSize);

   if(LineStyle > 0)
   {
      h -> SetLineStyle(LineStyle);
      h -> SetLineColor(LineColor);
      h -> SetLineWidth(LineWidth);
   }
   if(FillStyle > 0)
   {
      h -> SetFillStyle(FillStyle);
      h -> SetFillColor(FillColor);
   }   

   if(ShowStats == "yes")
   {
      h -> SetStats(kTRUE);
   }
   else if(ShowStats == "no")
   {
      h -> SetStats(kFALSE);
   }

   if(CenterXTitle == "yes")
   {
      h -> GetXaxis() -> CenterTitle();
   }
   if(CenterYTitle == "yes")
   {
      h -> GetYaxis() -> CenterTitle();
   }
}

//----------------------------------------------------------------------
TH2* Anp::Draw::CreateTH2(const string &prefix, const Registry &reg, const Header &header)
{
   float MinT = -4.0;
   float MaxT = +4.0;

   float MinZ = 0.0;
   float MaxZ = 16.0;

   float WidthT = 0.0410;
   float WidthZ = 0.0571;

   MinT = Read(prefix + "MinT", MinT, reg);
   MaxT = Read(prefix + "MaxT", MaxT, reg);
   
   MinZ = Read(prefix + "MinZ", MinZ, reg);
   MaxZ = Read(prefix + "MaxZ", MaxZ, reg);   
   
   //
   // Get detector range using geomtry database
   //
   bool use_ugli = true, only_cal = true;
   Anp::Read(reg, "UseUgli", use_ugli);
   Anp::Read(reg, "OnlyCal", only_cal);

   if(use_ugli)
   {
      vector<float> Uvec, Vvec, Zvec;

      UgliGeomHandle uhand(Draw::GetValidity(header));
      
      //
      // Get all scint planes
      //
      vector<UgliScintPlnHandle> pvec = uhand.GetScintPlnHandleVector();

      for(unsigned int iplane = 0; iplane < pvec.size(); ++iplane)
      {
         UgliScintPlnHandle phand = pvec[iplane];
         const PlexPlaneId planeid = phand.GetPlexPlaneId();

         //
         // Get Z range
         //
         if(only_cal && planeid.IsNearSpect())
         {
            continue;
         }

         Zvec.push_back(phand.GetZ0());

         //
         // Get all strips
         //
         vector<UgliStripHandle> svec = phand.GetStripHandleVector();

         for(unsigned int istrip = 0; istrip < svec.size(); ++istrip)
         {
            UgliStripHandle pstrip = svec[istrip];
            
            //
            // Get strip position
            //
            const float tpos = pstrip.GetTPos();

            if(phand.GetPlaneView() == PlaneView::kU)
            {
               Uvec.push_back(tpos);
            }
            else if(phand.GetPlaneView() == PlaneView::kV)
            {
               Vvec.push_back(tpos);
            }
         }
      }

      if(prefix.find("U") != string::npos && !Uvec.empty())
      {
         MinT = *std::min_element(Uvec.begin(), Uvec.end());
         MaxT = *std::max_element(Uvec.begin(), Uvec.end());
      }
      if(prefix.find("V") != string::npos && !Vvec.empty())
      {
         MinT = *std::min_element(Vvec.begin(), Vvec.end());
         MaxT = *std::max_element(Vvec.begin(), Vvec.end());
      }

      if(!Zvec.empty())
      {
         MinZ = *std::min_element(Zvec.begin(), Zvec.end());
         MaxZ = *std::max_element(Zvec.begin(), Zvec.end());
      }
   }

   WidthT = Read(prefix + "WidthT", WidthT, reg);
   WidthZ = Read(prefix + "WidthZ", WidthZ, reg);

   if(!(WidthT > 0.0)) WidthT = 0.0410;
   if(!(WidthZ > 0.0)) WidthZ = 0.0410;

   string Name = "TView";
   string Title = "T view";
   string XTitle = "Z position (m)";
   string YTitle = "T position (m)";

   //
   // Read strings
   //
   Anp::Read(reg, prefix+"XTitle", XTitle);
   Anp::Read(reg, prefix+"YTitle", YTitle);

   TH2 *h = new TH2F(Name.c_str(), Title.c_str(), 
                     static_cast<int>((MaxZ-MinZ)/WidthZ), MinZ, MaxZ,
                     static_cast<int>((MaxT-MinT)/WidthT), MinT, MaxT);

   h -> SetDirectory(0);
   h -> SetStats(kFALSE);

   h -> GetXaxis() -> SetTitle(XTitle.c_str());
   h -> GetXaxis() -> CenterTitle();
   h -> GetYaxis() -> SetTitle(YTitle.c_str());
   h -> GetYaxis() -> CenterTitle();

   double XAxisTitleOffset = 0.7;
   double YAxisTitleOffset = 0.7;

   double XAxisTitleSize = 0.065;
   double YAxisTitleSize = 0.065;   

   XAxisTitleOffset = Read("XAxisTitleOffset", XAxisTitleOffset, reg);
   YAxisTitleOffset = Read("YAxisTitleOffset", YAxisTitleOffset, reg);

   XAxisTitleSize = Read("XAxisTitleSize", XAxisTitleSize, reg);
   YAxisTitleSize = Read("YAxisTitleSize", YAxisTitleSize, reg);

   h -> GetXaxis() -> SetTitleOffset(XAxisTitleOffset);
   h -> GetYaxis() -> SetTitleOffset(YAxisTitleOffset);

   h -> GetXaxis() -> SetTitleSize(XAxisTitleSize);
   h -> GetYaxis() -> SetTitleSize(YAxisTitleSize);

   return h;
}

//----------------------------------------------------------------------
TGraph* Anp::Draw::CreateTGraph(const string &prefix, const Registry &reg)
{
   double MarkerSize = 1.0;
   int MarkerStyle = 8;
   int MarkerColor = 3;

   MarkerSize = Read(prefix + "MarkerSize", MarkerSize, reg);
   MarkerStyle = Read(prefix + "MarkerStyle", MarkerStyle, reg);
   MarkerColor = Read(prefix + "MarkerColor", MarkerColor, reg);

   TGraph *g = new TGraph(0);
   
   g -> SetMarkerSize(MarkerSize);
   g -> SetMarkerStyle(MarkerStyle);
   g -> SetMarkerColor(MarkerColor);

   return g;
}

//----------------------------------------------------------------------
double Anp::Draw::Read(const string &key, const double pvalue, const Registry &reg)
{
   double value = 0.0;
   if(reg.KeyExists(key.c_str()) && reg.Get(key.c_str(), value))
   {
      return value;
   }
   
   return pvalue;
}

//----------------------------------------------------------------------
int Anp::Draw::Read(const string &key, const int pvalue, const Registry &reg)
{
   int value = 0;
   if(reg.KeyExists(key.c_str()) && reg.Get(key.c_str(), value))
   {
      return value;
   }
   
   return pvalue;
}

//----------------------------------------------------------------------
const string Anp::Draw::Read(const string &key, const string &pvalue, const Registry &reg)
{
   const char *value = 0;
   if(reg.KeyExists(key.c_str()) && reg.Get(key.c_str(), value))
   {
      return value;
   }
   
   return pvalue;
}

//----------------------------------------------------------------------
int Anp::Draw::Read(const Record &record, HepVec &hvec, const int beg, const int end)
{
   if(beg > end)
   {
      cerr << "Draw::ReadStdHep - invalid StdHep index range" << endl;
      return 0;
   }

   int count = 0;

   for(StdHepIter it = record.StdHepBeg(); it != record.StdHepEnd(); ++it)
   {
      if(it -> StdHepIndex() < beg || it -> StdHepIndex() > end)
      {
         continue;
      }

      ++count;
      
      hvec.push_back(it);

      count += Anp::Draw::Read(record, hvec, it -> ChildBeg(), it -> ChildEnd());
   }
   
   return count;
}

//---------------------------------------------------------------------------------------------
const VldContext Anp::Draw::GetValidity(const Header &header)
{
   //
   // Convert Anp::Header to VldContext
   //

   const VldTimeStamp time(header.Sec(), header.NSec());
   if(header.IsData())
   {
      if     (header.IsNear()) return VldContext(Detector::kNear, SimFlag::kData, time);
      else if(header.IsFar())  return VldContext(Detector::kFar, SimFlag::kData, time);
   }
   else
   {
      if     (header.IsNear()) return VldContext(Detector::kNear, SimFlag::kMC, time);
      else if(header.IsFar())  return VldContext(Detector::kFar, SimFlag::kMC, time);
   }

   return VldContext(Detector::kUnknown, SimFlag::kUnknown, time);  
}

---