DrawSpan.cxx

Go to the documentation of this file.

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

//ROOT
#include "TAxis.h"

//Local
#include "DrawSpan.h"

using namespace std;

//----------------------------------------------------------------------
Anp::DrawSpan::DrawSpan()
   :fInitU(false),
    fInitV(false),
    fInitZ(false),
    fInitTime(false),
    fMinU(0.0),
    fMaxU(0.0),
    fMinV(0.0),
    fMaxV(0.0),
    fMinZ(0.0),
    fMaxZ(0.0),
    fMinTime(0.0),
    fMaxTime(0.0)
{
}

//----------------------------------------------------------------------
void Anp::DrawSpan::Reset()
{
   fInitU = false;
   fInitV = false;
   fInitZ = false;
   fInitTime = false;
   
   fMinU = 0.0;
   fMaxU = 0.0;
   
   fMinV = 0.0;
   fMaxV = 0.0;
   
   fMinZ = 0.0;
   fMaxZ = 0.0;

   fMinTime = 0.0;
   fMaxTime = 0.0; 
}

//----------------------------------------------------------------------
float Anp::DrawSpan::GetMinU(const float scale, const float border) const
{
   return Min(fMinU, scale) - border;
}

//----------------------------------------------------------------------
float Anp::DrawSpan::GetMaxU(const float scale, const float border) const
{
   return Max(fMaxU, scale) + border;
}

//----------------------------------------------------------------------
float Anp::DrawSpan::GetMinV(const float scale, const float border) const
{
   return Min(fMinV, scale) - border;
}

//----------------------------------------------------------------------
float Anp::DrawSpan::GetMaxV(const float scale, const float border) const
{
   return Max(fMaxV, scale) + border;
}

//----------------------------------------------------------------------
float Anp::DrawSpan::GetMinZ(const float scale, const float border) const
{
   return Min(fMinZ, scale) - border;
}

//----------------------------------------------------------------------
float Anp::DrawSpan::GetMaxZ(const float scale, const float border) const
{
   return Max(fMaxZ, scale) + border;
}

//----------------------------------------------------------------------
double Anp::DrawSpan::GetMinTime(const double window) const
{
   if(window < 0.0)
   {
      return fMinTime;
   }
   
   return fMinTime - window;
}

//----------------------------------------------------------------------
double Anp::DrawSpan::GetMaxTime(const double window) const
{
   if(window < 0.0)
   {
      return fMaxTime;
   }
   
   return fMaxTime + window;
}

//----------------------------------------------------------------------
float Anp::DrawSpan::Min(const float pos, const float scale) const
{
   if(scale < 1.0)
   {
      return pos;
   }

   if(pos < 0.0)
   {
      return pos * scale;
   }

   return pos / scale;
}

//----------------------------------------------------------------------
float Anp::DrawSpan::Max(const float pos, const float scale) const
{
   if(scale < 1.0)
   {
      return pos;
   }

   if(pos < 0.0)
   {
      return pos / scale;
   }

   return pos * scale;
}

//----------------------------------------------------------------------
void Anp::DrawSpan::SetRangeU(TAxis *axis, const float scale, const float border) const
{
   Set(axis, GetMinU(scale, border), GetMaxU(scale, border));
}

//----------------------------------------------------------------------
void Anp::DrawSpan::SetRangeV(TAxis *axis, const float scale, const float border) const
{
   Set(axis, GetMinV(scale, border), GetMaxV(scale, border));
}

//----------------------------------------------------------------------
void Anp::DrawSpan::SetRangeZ(TAxis *axis, const float scale, const float border) const
{
   Set(axis, GetMinZ(scale, border), GetMaxZ(scale, border));
}

//----------------------------------------------------------------------
bool Anp::DrawSpan::InitU() const
{
   return fInitU;
}

//----------------------------------------------------------------------
bool Anp::DrawSpan::InitV() const
{
   return fInitV;
}

//----------------------------------------------------------------------
bool Anp::DrawSpan::InitZ() const
{
   return fInitZ;
}

//----------------------------------------------------------------------
void Anp::DrawSpan::Set(TAxis *axis, float min, float max) const
{
   if(!axis)
   {
      return;
   }
   
   const float xmax = axis -> GetXmax();
   const float xmin = axis -> GetXmin();

   if(min < xmin)
   {
      min = xmin;
   }
   if(max > xmax)
   {
      max = xmax;
   }

   axis -> SetRangeUser(min, max);
}

//----------------------------------------------------------------------
void Anp::DrawSpan::FindSpan(const Event &event, const Record &record)
{ 
   Draw::SVec uvec, vvec;
   
   for(Anp::StripIter sit = record.StripBeg(); sit != record.StripEnd(); ++sit)
   {
      if(!sit -> MatchEvt(event.EventIndex()))
      {
         continue;
      }

      if(sit -> GetPlane() % 2 == 1)
      {
         uvec.push_back(sit);
      }
      else
      {
         vvec.push_back(sit);
      }
   }
   
   FindSpan(uvec, vvec);
}

//----------------------------------------------------------------------
void Anp::DrawSpan::FindSpan(const Draw::SVec &uvec, const Draw::SVec &vvec)
{
   if(!uvec.empty())
   {   
      if(!fInitTime)
      {
         const Strip &strip = *(*uvec.begin());
         fMinTime = strip.Time();
         fMaxTime = strip.Time();
         fInitTime = true;
      }
      if(!fInitU)
      {
         const Strip &strip = *(*uvec.begin());
         fMinU = strip.TPos();
         fMaxU = strip.TPos();
         fInitU = true;
      }
      if(!fInitZ)
      {
         const Strip &strip = *(*uvec.begin());
         fMinZ = strip.ZPos();
         fMaxZ = strip.ZPos();
         fInitZ = true;
      }

      for(Draw::SIter sit = uvec.begin(); sit != uvec.end(); ++sit)
      {
         const float upos  = (*sit) -> TPos();
         const float zpos  = (*sit) -> ZPos();
         const double time = (*sit) -> Time();
         
         if(fMinU > upos)
         {
            fMinU = upos;
         }
         if(fMaxU < upos)
         {
            fMaxU = upos;
         }
         if(fMinZ > zpos)
         {
            fMinZ = zpos;
         }
         if(fMaxZ < zpos)
         {
            fMaxZ = zpos;
         }
         if(fMinTime > time)
         {
            fMinTime = time;
         }
         if(fMaxTime < time)
         {
            fMaxTime = time;
         }
      }
   }

   if(!vvec.empty())
   { 
      if(!fInitTime)
      {
         const Strip &strip = *(*vvec.begin());
         fMinTime = strip.Time();
         fMaxTime = strip.Time();
         fInitTime = true;
      }
      if(!fInitV)
      {
         const Strip &strip = *(*vvec.begin());
         fMinV = strip.TPos();
         fMaxV = strip.TPos();
         fInitV = true;
      }
      if(!fInitZ)
      {
         const Strip &strip = *(*vvec.begin());
         fMinZ = strip.ZPos();
         fMaxZ = strip.ZPos();
         fInitZ = true;
      }

      for(Draw::SIter sit = vvec.begin(); sit != vvec.end(); ++sit)
      {
         const float vpos  = (*sit) -> TPos();
         const float zpos  = (*sit) -> ZPos();
         const double time = (*sit) -> Time();

         if(fMinV > vpos)
         {
            fMinV = vpos;
         }
         if(fMaxV < vpos)
         {
            fMaxV = vpos;
         }
         if(fMinZ > zpos)
         {
            fMinZ = zpos;
         }
         if(fMaxZ < zpos)
         {
            fMaxZ = zpos;
         }      
         if(fMinTime > time)
         {
            fMinTime = time;
         }
         if(fMaxTime < time)
         {
            fMaxTime = time;
         }
      }
   }
}

---