EventAdcTab.cxx

Go to the documentation of this file.

// $Id: EventAdcTab.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 "EventAdcTab.h"

REGISTER_ANP_OBJECT(EventTab,EventAdcTab)

using namespace std;

//----------------------------------------------------------------------
Anp::EventAdcTab::EventAdcTab()
   :fInit(false),
    fDraw(true),
    fCanvas(0),
    fPadU(0),
    fPadV(0),
    f2hU(0),
    f2hV(0)
{
}

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

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

   if(!f2hU || !f2hV)
   {
      return;
   }

   fSpan.FindSpan(event, record);

   const StripVec uvec = GetStrip(event, record, "U");
   const StripVec vvec = GetStrip(event, record, "V");

   if(uvec.empty() || vvec.empty())
   {
      cerr << "EventAdcTab::SetEvent() - no strips matching a track" << endl;
      return;
   }    

   for(Draw::SIter sit = uvec.begin(); sit != uvec.end(); ++sit)
   {
      f2hU -> Fill((*sit) -> ZPos(), (*sit) -> TPos(), (*sit) -> SigCor());
   }

   for(Draw::SIter sit = vvec.begin(); sit != vvec.end(); ++sit)
   {
      f2hV -> Fill((*sit) -> ZPos(), (*sit) -> TPos(), (*sit) -> SigCor());
   }
}   

//------------------------------------------------------------------------------------------
void Anp::EventAdcTab::Init(TCanvas *canvas)
{
   if(!canvas)
   {
      cerr << "EventAdcTab::Expose(): null TCanvas pointer" << endl;
      return;
   }
   if(fPadU || fPadV || fCanvas)
   {
      cerr << "EventAdcTab::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 << "EventAdcTab::Expose(): failed to create new pads" << endl;
      fCanvas = 0;
      fPadU = 0;
      fPadV = 0;
      return;
   }

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

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

   if(!fPadU || !fPadV)
   {
      return;
   }
   
   if(fDraw)
   {
      fPadU -> cd();   
      f2hU -> Draw("colz");
      
      fPadV -> cd();   
      f2hV -> Draw("colz");

      fDraw = false;
   }

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

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

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

   fInit = true;

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

   fObjVec.push_back(f2hU);
   fObjVec.push_back(f2hV);

   return true;
}

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

   fSpan.Reset();

   if(f2hU)
   {
      f2hU -> Reset();
   }
   if(f2hV)
   {
      f2hV -> Reset();
   }
}

//----------------------------------------------------------------------
void Anp::EventAdcTab::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::EventAdcTab::ZoomOut()
{
   fDraw = true;

   if(f2hU)
   {
      f2hU -> GetXaxis() -> UnZoom();
      f2hU -> GetYaxis() -> UnZoom();
   }

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

---