Track.cxx

Go to the documentation of this file.

#include "DDTMonopole/Track.h"

#include "SlowMonopoleTrigger/Constants.h"



mono::Track::Track(novaddt::DAQHit const& start, novaddt::DAQHit const& end) :
  is_ddt_(true), start_ddt_(start), end_ddt_(end), goodness_("not set")
{
  dp_ = static_cast<double>(end.Plane().val) -
        static_cast<double>(start.Plane().val);
  dc_ = static_cast<double>(end.Cell().val) -
        static_cast<double>(start.Cell().val);
  
  dt_ = static_cast<int64_t>(end.TDC().val) -
        static_cast<int64_t>(start.TDC().val);

  distance_ = calculate_distance();
  velocity_ = calculate_velocity();
  beta_     = velocity_ / novaddt::smt::Constants::SPEED_OF_LIGHT;

  calculate_slopes();

  min_plane_ = std::min(start.Plane().val, end.Plane().val);
  max_plane_ = std::max(start.Plane().val, end.Plane().val);
  min_cell_ = std::min(start.Cell().val, end.Cell().val);
  max_cell_ = std::max(start.Cell().val, end.Cell().val);
}



mono::Track::Track(art::Ptr<rb::CellHit> const& start,
                   art::Ptr<rb::CellHit> const& end) :
  is_ddt_(false), start_rb_(start), end_rb_(end), goodness_("not set")
{
  dp_ = static_cast<double>(end->Plane()) -
        static_cast<double>(start->Plane());
  dc_ = static_cast<double>(end->Cell()) -
        static_cast<double>(start->Cell());
  
  dt_ = static_cast<int64_t>(end->TDC()) -
        static_cast<int64_t>(start->TDC());

  distance_ = calculate_distance();
  velocity_ = calculate_velocity();
  beta_     = velocity_ / novaddt::smt::Constants::SPEED_OF_LIGHT;

  calculate_slopes();

  min_plane_ = std::min(start->Plane(), end->Plane());
  max_plane_ = std::max(start->Plane(), end->Plane());
  min_cell_ = std::min(start->Cell(), end->Cell());
  max_cell_ = std::max(start->Cell(), end->Cell());
}



double mono::Track::calculate_distance() const
{
  double dx = novaddt::smt::Constants::CELL_WIDTH  * dc_;
  double dz = novaddt::smt::Constants::PLANE_WIDTH * dp_;

  return sqrt(dx*dx + dz*dz);
}



double mono::Track::calculate_velocity() const
{
  double dt_in_nanoseconds = novaddt::smt::Constants::TDC_TICK * dt_;
  
  return distance_ / dt_in_nanoseconds;
}



void mono::Track::calculate_slopes()
{
  if (dp_ == 0)
  {
    slope_plane_is_valid_ = false;
  } else {
    slope_plane_is_valid_ = true;
    slope_cell_plane_ = dc_ / dp_;
    slope_time_plane_ = dt_ / dp_;
  }

  if (dt_ == 0)
  {
    slope_time_is_valid_ = false;
  } else {
    slope_time_is_valid_ = true;
    slope_cell_time_  = dc_ / dt_;
    slope_plane_time_ = dp_ / dt_;
  }

  if (dc_ == 0)
  {
    slope_cell_is_valid_ = false;
  } else {
    slope_cell_is_valid_ = true;
    slope_time_cell_ = dt_ / dc_;
  }
}



double mono::Track::distance() const
{
  return distance_;
}



double mono::Track::time() const
{
  return dt_;
}



double mono::Track::velocity() const
{
  return velocity_;
}



double mono::Track::beta() const
{
  return beta_;
}



bool mono::Track::slope_plane_is_valid() const
{
  return slope_plane_is_valid_;
}



bool mono::Track::slope_time_is_valid() const
{
  return slope_time_is_valid_;
}



bool mono::Track::slope_cell_is_valid() const
{
  return slope_cell_is_valid_;
}



double mono::Track::slope_cell_plane() const
{
  if (!slope_plane_is_valid())
  {
    std::cerr << "\n\tThe slope is invalid.\n\n"
              << "Please check Track::slope_is_valid() "
              << "before accessing Track::slope()." << std::endl;
    assert(false);
  }

  return slope_cell_plane_;
}



double mono::Track::slope_time_plane() const
{
  if (!slope_plane_is_valid())
  {
    std::cerr << "\n\tThe slope is invalid.\n\n"
              << "Please check Track::slope_is_valid() "
              << "before accessing Track::slope()." << std::endl;
    assert(false);
  }

  return slope_time_plane_;
}



double mono::Track::slope_cell_time() const
{
  if (!slope_time_is_valid())
  {
    std::cerr << "\n\tThe slope is invalid.\n\n"
              << "Please check Track::slope_is_valid() "
              << "before accessing Track::slope()." << std::endl;
    assert(false);
  }

  return slope_cell_time_;
}



double mono::Track::slope_plane_time() const
{
  if (!slope_time_is_valid())
  {
    std::cerr << "\n\tThe slope is invalid.\n\n"
              << "Please check Track::slope_is_valid() "
              << "before accessing Track::slope()." << std::endl;
    assert(false);
  }

  return slope_plane_time_;
}



double mono::Track::slope_time_cell() const
{
  if (!slope_cell_is_valid())
  {
    std::cerr << "\n\tThe slope is invalid.\n\n"
              << "Please check Track::slope_is_valid() "
              << "before accessing Track::slope()." << std::endl;
    assert(false);
  }

  return slope_time_cell_;
}



int mono::Track::plane_difference() const
{
  return dp_;
}


unsigned mono::Track::min_plane() const
{
  return min_plane_;
}



unsigned mono::Track::max_plane() const
{
  return max_plane_;
}



int mono::Track::cell_difference() const
{
  return dc_;
}



unsigned mono::Track::min_cell() const
{
  return min_cell_;
}



unsigned mono::Track::max_cell() const
{
  return max_cell_;
}



void mono::Track::mark_as_good()
{
  goodness_ = "marked good";
}



bool mono::Track::is_good() const
{
  if (goodness_ == "marked good")
    return true;

  return false;
}



void mono::Track::set(std::string const& name, double value)
{
  if (info_.find(name) != info_.end())
  {
    std::cerr << "\n\n\t" << name << " has already been set.\n" << std::endl;
    assert(false);
  }

  info_[name] = value;
}



double mono::Track::get(std::string const& name) const
{
  if (info_.find(name) == info_.end())
  {
    std::cerr << "\n\n\t" << name << " does not exist.\n" << std::endl;
    assert(false);
  }

  return info_.at(name);
}



novaddt::DAQHit mono::Track::start_ddt() const
{
  if (!is_ddt_)
  {
    std::cerr << "\n\tThis object only contains art::Ptr<rb::CellHit> hits, "
              << "please use start_rb()\n" << std::endl;
    assert(false);
  }
  
  return start_ddt_;
}



novaddt::DAQHit mono::Track::end_ddt() const
{
  if (!is_ddt_)
  {
    std::cerr << "\n\tThis object only contains art::Ptr<rb::CellHit> hits, "
              << "please use end_rb()\n" << std::endl;
    assert(false);
  }
  
  return end_ddt_;
}



art::Ptr<rb::CellHit> mono::Track::start_rb() const
{
  if (is_ddt_)
  {
    std::cerr << "\n\tThis object only contains novaddt::DAQHit hits, "
              << "please use start_ddt()\n" << std::endl;
    assert(false);
  }
  
  return start_rb_;
}



art::Ptr<rb::CellHit> mono::Track::end_rb() const
{
  if (is_ddt_)
  {
    std::cerr << "\n\tThis object only contains novaddt::DAQHit hits, "
              << "please use end_ddt()\n" << std::endl;
    assert(false);
  }
  
  return end_rb_;
}