SnarlAdcTab.cxx

Go to the documentation of this file.

//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 "SnarlAdcTab.h"

REGISTER_ANP_OBJECT(EventTab,SnarlAdcTab)

using namespace std;

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

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

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

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

   fSpan.FindSpan(event, record);

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

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

   Add(uvec, record, "U");
   Add(vvec, record, "V");

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

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

//------------------------------------------------------------------------------------------
void Anp::SnarlAdcTab::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::SnarlAdcTab::Config(const Registry &reg)
{
   fConfig.UnLockValues();
   fConfig.Merge(reg); 
   fConfig.LockValues();
}

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

   fInit = true;

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

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

   return true;
}

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

   fSpan.Reset();

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

//----------------------------------------------------------------------
void Anp::SnarlAdcTab::Add(StripVec &svec, const Record &record, const string &view)
{
   static double TimeWindow = 20.0e-9;
   static bool init = false;
   if(!init)
   {
      TimeWindow = Draw::Read("TimeWindow", TimeWindow, fConfig);
      init = true;
   }

   const double min = fSpan.GetMinTime(TimeWindow); 
   const double max = fSpan.GetMaxTime(TimeWindow); 

   for(StripIter strip = record.StripBeg(); strip != record.StripEnd(); ++strip)
   {
      if(strip -> Time() < min || strip -> Time() > max)
      {
         continue;
      }
      
      if(view == "U" && strip -> IsUview())
      {
         svec.push_back(strip);
      }
      if(view == "V" && strip -> IsVview())
      {
         svec.push_back(strip);
      }
   }
}

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

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

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

---