EventHitTab.cxx

Go to the documentation of this file.

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

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

// ROOT
#include "TDirectory.h"
#include "TCanvas.h"
#include "TH1F.h"
#include "TH2F.h"
#include "TGraph.h"

// Local
#include "DrawUtil.h"
#include "PhysicsNtuple/Factory.h"
#include "EventHitTab.h"

REGISTER_ANP_OBJECT(EventTab,EventHitTab)

using namespace std;

//----------------------------------------------------------------------
Anp::EventHitTab::EventHitTab()
   :fInit(false),
    fDraw(true),
    fCanvas(0),
    fPadU(0),
    fPadV(0),
    f2hU(0),
    f2hV(0),
    fgShwU(0),
    fgShwV(0),
    fgTrk1U(0),
    fgTrk1V(0),
    fgTrk2U(0),
    fgTrk2V(0)
{
}

//----------------------------------------------------------------------
Anp::EventHitTab::~EventHitTab()
{
   for(std::vector<TObject *>::iterator it = fObjVec.begin(); it != fObjVec.begin(); ++it)
   {
      TObject *obj = *it;
      delete obj;
   }
}

//----------------------------------------------------------------------
void Anp::EventHitTab::Set(const Event& event, const Record& record)
{  
   if(!fInit)
   {
      Init(record);
   }
   else
   {
      Reset();
   }

   fSpan.FindSpan(event, record);

   SetShowers(event, record);

   const TrackVec tvec = GetTrack(event, record);
   for(TrackVec::const_iterator it = tvec.begin(); it != tvec.end(); ++it)
   {
      SetTrack(*(*it), record, std::distance(tvec.begin(), it));
   }
}

//------------------------------------------------------------------------------------------
void Anp::EventHitTab::SetTrack(const Track &track, const Record &record, const short index)
{
   TGraph *ug = 0;
   TGraph *vg = 0;

   if(index == 0)
   {
      ug = fgTrk1U;
      vg = fgTrk1V;
   }
   else if(index == 1)
   {
      ug = fgTrk2U;
      vg = fgTrk2V;
   }

   if(!ug || !vg)
   {
      return;
   }

   const StripVec uvec = GetStrip(track, record, "U");
   const StripVec vvec = GetStrip(track, record, "V");
   
   if(uvec.empty() || vvec.empty())
   {
      cerr << "EventHitTab::SetTrack() - no strips matching a track" << endl;
      return;
   }
   
   ug -> Set(uvec.size());
   vg -> Set(vvec.size());

   for(Draw::SIter sit = uvec.begin(); sit != uvec.end(); ++sit)
   {
      ug -> SetPoint(std::distance(uvec.begin(), sit), (*sit) -> ZPos(), (*sit) -> TPos());
   }

   for(Draw::SIter sit = vvec.begin(); sit != vvec.end(); ++sit)
   {
      vg -> SetPoint(std::distance(vvec.begin(), sit), (*sit) -> ZPos(), (*sit) -> TPos());
   }
}   


//------------------------------------------------------------------------------------------
void Anp::EventHitTab::SetShowers(const Event &event, const Record &record)
{
   if(!fgShwU || !fgShwV)
   {
      return;
   }

   if(event.GetNShowers() < 1)
   {
      return;
   }

   const ShowerVec shw_vec = GetShower(event, record);

   StripVec uvec, vvec;

   for(ShowerVec::const_iterator it = shw_vec.begin(); it != shw_vec.end(); ++it)
   {           
      const Shower &shower = *(*it);

      const StripVec suvec = GetStrip(shower, record, "U");
      const StripVec svvec = GetStrip(shower, record, "V");

      uvec.insert(uvec.end(), suvec.begin(), suvec.end());
      vvec.insert(vvec.end(), svvec.begin(), svvec.end());
   }
   
   if(uvec.empty() || vvec.empty())
   {
      cerr << "EventHitTab::SetShower() - no strips matching a shower" << endl;
      return;
   }  
   
   fgShwU -> Set(uvec.size());
   fgShwV -> Set(vvec.size());

   for(Draw::SIterator sit = uvec.begin(); sit != uvec.end(); ++sit)
   {
      fgShwU -> SetPoint(std::distance(uvec.begin(), sit), (*sit) -> ZPos(), (*sit) -> TPos());
   }

   for(Draw::SIterator sit = vvec.begin(); sit != vvec.end(); ++sit)
   {
      fgShwV -> SetPoint(std::distance(vvec.begin(), sit), (*sit) -> ZPos(), (*sit) -> TPos());
   }
}   

//------------------------------------------------------------------------------------------
void Anp::EventHitTab::Init(TCanvas *canvas)
{
   if(!canvas)
   {
      cerr << "EventHitTab::Expose(): null TCanvas pointer" << endl;
      return;
   }
   if(fPadU || fPadV || fCanvas)
   {
      cerr << "EventHitTab::Expose(): pads have been already initialized" << endl;
      return;
   }

   fCanvas = canvas;

   fCanvas -> Divide(0, 2);

   fPadU = dynamic_cast<TPad *> (canvas -> cd(1));
   fPadV = dynamic_cast<TPad *> (canvas -> cd(2));
   
   if(!fPadU || !fPadV)
   {
      cerr << "EventHitTab::Expose(): failed to create new pads" << endl;
      fCanvas = 0;
      fPadU = 0;
      fPadV = 0;
      return;
   }

   Draw::Config(fPadU, "", fConfig);
   Draw::Config(fPadV, "", fConfig);
}

//------------------------------------------------------------------------------------------
void Anp::EventHitTab::Expose()
{
   if(!fInit)
   {
      return;
   }

   if(!fPadU || !fPadV)
   {
      return;
   }

   if(fDraw)
   {
      fPadU -> cd();   
      f2hU -> Draw("");
      if(fgShwU -> GetN() > 0) fgShwU -> Draw("p");
      if(fgTrk1U -> GetN() > 0) fgTrk1U -> Draw("p");
      if(fgTrk2U -> GetN() > 0) fgTrk2U -> Draw("p");
      
      
      fPadV -> cd();
      f2hV -> Draw("");
      if(fgShwV -> GetN() > 0) fgShwV -> Draw("p");
      if(fgTrk1V -> GetN() > 0) fgTrk1V -> Draw("p");
      if(fgTrk2V -> GetN() > 0) fgTrk2V -> Draw("p");

      fDraw = false;
   }

   fCanvas -> cd();
   fCanvas -> Modified();
   fCanvas -> Update();
}

//----------------------------------------------------------------------
void Anp::EventHitTab::Config(const Registry &reg)
{
   fConfig.UnLockValues();
   fConfig.Merge(reg); 
   fConfig.LockValues();
}

//----------------------------------------------------------------------
bool Anp::EventHitTab::Init(const Record &record)
{
   if(fInit)
   {
      cerr << "EventHitTab is already initialized" << endl;
      return false;
   }

   fInit = true;  

   f2hU = Draw::CreateTH2("Uview", fConfig, record.GetHeader());
   f2hV = Draw::CreateTH2("Vview", fConfig, record.GetHeader());

   fgShwU = Draw::CreateTGraph("Shower", fConfig);
   fgShwV = Draw::CreateTGraph("Shower", fConfig);

   fgTrk1U = Draw::CreateTGraph("Track1", fConfig);
   fgTrk1V = Draw::CreateTGraph("Track1", fConfig);
   
   fgTrk2U = Draw::CreateTGraph("Track2", fConfig);
   fgTrk2V = Draw::CreateTGraph("Track2", fConfig);      

   fObjVec.push_back(f2hU);
   fObjVec.push_back(f2hV);
   fObjVec.push_back(fgTrk1U);
   fObjVec.push_back(fgTrk1V);
   fObjVec.push_back(fgTrk2U);
   fObjVec.push_back(fgTrk2V);

   return true;
}

//----------------------------------------------------------------------
void Anp::EventHitTab::Reset()
{
   fDraw = true;

   fSpan.Reset();

   if(fgShwU)
   {
      fgShwU -> Set(0);
   }
   if(fgShwV)
   {
      fgShwV -> Set(0);
   }
   if(fgTrk1U)
   {
      fgTrk1U -> Set(0);
   }
   if(fgTrk1V)
   {
      fgTrk1V -> Set(0);
   }
   if(fgTrk2U)
   {
      fgTrk2U -> Set(0);
   }
   if(fgTrk2V)
   {
      fgTrk2V -> Set(0);
   }
}


//----------------------------------------------------------------------
void Anp::EventHitTab::ZoomIn()
{
   fDraw = true;

   static double ZoomBorderScale = 1.2;
   static double ZoomBorderWidth = 0.1;

   static bool init = false;
   if(!init)
   {
      init = true;
      ZoomBorderScale = Draw::Read("ZoomBorderScale", ZoomBorderScale, fConfig);
      ZoomBorderWidth = Draw::Read("ZoomBorderWidth", ZoomBorderWidth, fConfig);

      if(ZoomBorderScale < 1.0) ZoomBorderScale = 1.2;
      if(ZoomBorderWidth < 0.0) ZoomBorderWidth = 0.1;
   }

   if(fSpan.InitU())
   {
      fSpan.SetRangeU(f2hU -> GetYaxis(), ZoomBorderScale, ZoomBorderWidth);
   }
   if(fSpan.InitZ())
   {
      fSpan.SetRangeZ(f2hU -> GetXaxis(), ZoomBorderScale, ZoomBorderWidth);
   }
   if(fSpan.InitV())
   {
      fSpan.SetRangeV(f2hV -> GetYaxis(), ZoomBorderScale, ZoomBorderWidth);
   }
   if(fSpan.InitZ())
   {
      fSpan.SetRangeZ(f2hV -> GetXaxis(), ZoomBorderScale, ZoomBorderWidth);
   }
}

//----------------------------------------------------------------------
void Anp::EventHitTab::ZoomOut()
{
   fDraw = true;

   f2hU -> GetXaxis() -> UnZoom();
   f2hU -> GetYaxis() -> UnZoom();

   f2hV -> GetXaxis() -> UnZoom();
   f2hV -> GetYaxis() -> UnZoom();
}

---