FEvent/Telescope.cc

Go to the documentation of this file.

#include <det/Detector.h>
#include <fdet/FDetector.h>
#include <fdet/Eye.h>
#include <fdet/Telescope.h>
#include <fdet/Pixel.h>
#include <fevt/Telescope.h>
#include <fevt/EyeRecData.h>
#include <fevt/Channel.h>
#include <fevt/Pixel.h>
#include <fevt/TelescopeSimData.h>
#include <fevt/TelescopeRecData.h>
#include <fevt/TelescopeTriggerData.h>
#include <utl/ErrorLogger.h>
#include <utl/AugerException.h>
#include <utl/IteratorDeprecator.h>
#include <utl/PointerContainer.h>
#include <sstream>

using namespace std;
using namespace utl;
using namespace fevt;


Telescope::Telescope(const unsigned int eyeId, const unsigned int telescopeId,
                     const ComponentSelector::Status status) :
  fTelescopeId(telescopeId),
  fEyeId(eyeId),
  fRawTelPointing("unknown"),
  fStatus(status)
{ }


Telescope::~Telescope()
{
  for (const auto cp : fChannels)
    delete cp;
  for (const auto pp : fPixels)
    delete pp;
}


Telescope&
Telescope::operator=(const Telescope& telescope)
{
  if (this != &telescope) {
    fTelescopeId = telescope.fTelescopeId;
    fEyeId = telescope.fEyeId;
    fSimData = telescope.fSimData;
    fRecData = telescope.fRecData;
    fTriggerData = telescope.fTriggerData;
    fTracesStartTime = telescope.fTracesStartTime;

    for (const auto cp : fChannels)
      delete cp;
    fChannels.clear();
    for (const auto cp : telescope.fChannels)
      fChannels.push_back(new Channel(*cp));

    for (const auto pp : fPixels)
      delete pp;
    fPixels.clear();
    for (const auto pp : telescope.fPixels)
      fPixels.push_back(new Pixel(*pp));

    fTimeOffset = telescope.fTimeOffset;
    fRawTelPointing = telescope.fRawTelPointing;
    fStatus = telescope.fStatus;
    fMirrorEventBorderPixelsDir = telescope.fMirrorEventBorderPixelsDir;
  }
  return *this;
}


void
Telescope::Assign(const Telescope& t)
{
  const auto tId = fTelescopeId;
  const auto eId = fEyeId;
  *this = t;
  CorrectIds(eId, tId);
}


Channel&
Telescope::GetChannel(const unsigned int channelId)
{
  for (auto& c : ChannelsRange())
    if (c.GetId() == channelId)
      return c;

  ostringstream err;
  err << "Non existent channel requested, Eye: " << fEyeId
      << " Tel: "<< fTelescopeId << " pix: " << channelId;
  ERROR(err);

  throw utl::NonExistentComponentException(err.str());
}


const Channel&
Telescope::GetChannel(const unsigned int channelId)
  const
{
  for (const auto& c : ChannelsRange())
    if (c.GetId() == channelId)
      return c;

  ostringstream err;
  err << "Non existent channel requested, Eye: " << fEyeId
      << " Tel: "<< fTelescopeId << " pix: " << channelId;
  ERROR(err);

  throw utl::NonExistentComponentException(err.str());
}


void
Telescope::MakeChannel(const unsigned int channelId)
{
  for (const auto& c : ChannelsRange())
    if (c.GetId() == channelId) {
      ostringstream err;
      err << "Channel already exists, Eye: " << fEyeId
          << " Tel: " << fTelescopeId << " pix: " << channelId
          << " - Not replacing";
      ERROR(err);
      return;
    }

  fChannels.push_back(new Channel(fEyeId, fTelescopeId, channelId));
}


bool
Telescope::HasChannel(const unsigned int channelId)
  const
{
  for (const auto& c : ChannelsRange())
    if (c.GetId() == channelId)
      return true;

  return false;
}


Pixel&
Telescope::GetPixel(const unsigned int pixelId,
                    const ComponentSelector::Status status)
{
  for (auto& p : PixelsRange(status))
    if (p.GetId() == pixelId)
      return p;

  ostringstream err;
  err << "Non existent pixel (status: " << int(status) << ") requested, Eye: " << fEyeId
      << " Tel: " << fTelescopeId << " pix: " << pixelId << ".";

  if (HasPixel(pixelId, ComponentSelector::eUnknown))
    err << " Pixel has status: " << GetPixel(pixelId, ComponentSelector::eUnknown).GetStatus() << "! ";
  else
    err << " Pixel not defined! ";

  ERROR(err);
  throw utl::NonExistentComponentException(err.str());
}


const Pixel&
Telescope::GetPixel(const unsigned int pixelId,
                    const ComponentSelector::Status status)
  const
{
  for (const auto& p : PixelsRange(status))
    if (p.GetId() == pixelId)
      return p;

  ostringstream err;
  err << "Non existent pixel (status: " << int(status) << ") requested, Eye: " << fEyeId
      << " Tel: " << fTelescopeId << " pix: " << pixelId << ".";

  if (HasPixel(pixelId, ComponentSelector::eUnknown))
    err << " Pixel has status: " << GetPixel(pixelId, ComponentSelector::eUnknown).GetStatus() << "! ";
  else
    err << " Pixel not defined! ";

  ERROR(err);
  throw utl::NonExistentComponentException(err.str());
}


void
Telescope::MakePixel(const unsigned int pixelId, const ComponentSelector::Status status)
{
  for (const auto& p : PixelsRange(status))
    if (p.GetId() == pixelId) {
      ostringstream err;
      err << "pixel " << pixelId << " already exists for eye " << fEyeId
          << " tel " << fTelescopeId << "; not replacing";
      ERROR(err);
      return;
    }

  fPixels.push_back(new Pixel(fEyeId, fTelescopeId, pixelId, status));
}


bool
Telescope::HasPixel(const unsigned int pixelId, const ComponentSelector::Status status)
  const
{
  for (const auto& p : PixelsRange(status))
    if (p.GetId() == pixelId)
      return true;

  return false;
}


TelescopeSimData&
Telescope::GetSimData()
{
  return *fSimData;
}


const TelescopeSimData&
Telescope::GetSimData()
  const
{
  return *fSimData;
}


void
Telescope::MakeSimData()
{
  if (fSimData)
    ERROR("TelescopeSimData already exists - Not Replacing");
  else
    fSimData = new TelescopeSimData;
}


fevt::TelescopeRecData&
Telescope::GetRecData()
{
  return *fRecData;
}


const fevt::TelescopeRecData&
Telescope::GetRecData()
  const
{
  return *fRecData;
}


void
Telescope::MakeRecData()
{
  if (fRecData)
    ERROR("TelescopeRecData already exists - Not Replacing");
  else
    fRecData = new TelescopeRecData( GetEyeId(), GetId() );
}


TelescopeTriggerData&
Telescope::GetTriggerData()
{
  return *fTriggerData;
}


const TelescopeTriggerData&
Telescope::GetTriggerData()
  const
{
  return *fTriggerData;
}


void
Telescope::MakeTriggerData()
{
  if (fTriggerData)
    ERROR("TelescopeTriggerData already exists - Not Replacing");
  else
    fTriggerData = new TelescopeTriggerData;
}


void
Telescope::GenerateMirrorEventBorderPixels()
  const
{
  const fdet::FDetector& fDet = det::Detector::GetInstance().GetFDetector();
  const fdet::Telescope& dTel = fDet.GetTelescope(*this);

  // 1.05 is just an arbitrary extra margin against floating point issues
  const double cosNeighbourPixelAngle = cos((4./3*1.05)*dTel.GetCamera().GetEta());

  // Generate list of candidate pixel directions from detector + out of border pixels
  vector<Vector> candidatePixelDirections;

  // First, add the out of border pixels to the candidates
  for (const auto& pv : dTel.OutOfBorderPixelsRange())
    candidatePixelDirections.push_back(pv);

  for (unsigned int i = dTel.GetFirstPixelId(); i <= dTel.GetLastPixelId(); ++i) {
    // Skip event pixels
    if (HasPixel(i, ComponentSelector::eHasData) && GetPixel(i).HasRecData())
      continue;
    // Add the remaining det Pixels to the list of candidates
    candidatePixelDirections.push_back(dTel.GetCameraPixelDirection(i));
  }

  // Iterate over all candidate pixel directions
  for (const auto& cd : candidatePixelDirections) {
    // Iterate over all event pixel directions
    for (const auto& p : PixelsRange(ComponentSelector::eHasData)) {
      // If the candidate direction is within one pixel row of an event pixel direction,
      // it is an event border pixel
      if (!p.HasRecData())
        continue;
      const unsigned int id = p.GetId();
      if (CosAngle(cd, dTel.GetCameraPixelDirection(id)) > cosNeighbourPixelAngle) {
        fMirrorEventBorderPixelsDir.push_back(cd);
        break;
      }
    }
  }
}


Telescope::ConstMirrorEventBorderPixelsIterator
Telescope::MirrorEventBorderPixelsBegin()
  const
{
  if (fMirrorEventBorderPixelsDir.empty())
    GenerateMirrorEventBorderPixels();
  return fMirrorEventBorderPixelsDir.begin();
}


Telescope::ConstMirrorEventBorderPixelsIterator
Telescope::MirrorEventBorderPixelsEnd()
  const
{
  if (fMirrorEventBorderPixelsDir.empty())
    GenerateMirrorEventBorderPixels();
  return fMirrorEventBorderPixelsDir.end();
}


// This is deprecated!
Telescope::PixelIterator
Telescope::PixelsBegin()
{
  utl::IteratorDeprecator::GetInstance().Deprecated("fevt::Telescope::PixelsBegin");

  return PixelIterator(ComponentSelector(ComponentSelector::eHasData),
                       AllPixelsBegin(), AllPixelsEnd());
}


// This is deprecated!
Telescope::ConstPixelIterator
Telescope::PixelsBegin()
  const
{
  utl::IteratorDeprecator::GetInstance().Deprecated("fevt::Telescope::PixelsBegin");

  return ConstPixelIterator(ComponentSelector(ComponentSelector::eHasData),
                            AllPixelsBegin(), AllPixelsEnd());
}


// This is deprecated!
Telescope::PixelIterator
Telescope::PixelsEnd()
{
  utl::IteratorDeprecator::GetInstance().Deprecated("fevt::Telescope::PixelsEnd");

  return PixelIterator(ComponentSelector(ComponentSelector::eHasData),
                       AllPixelsEnd(), AllPixelsEnd());
}


// This is deprecated!
Telescope::ConstPixelIterator
Telescope::PixelsEnd()
  const
{
  utl::IteratorDeprecator::GetInstance().Deprecated("fevt::Telescope::PixelsEnd");

  return ConstPixelIterator(ComponentSelector(ComponentSelector::eHasData),
                            AllPixelsEnd(), AllPixelsEnd());
}


void
Telescope::CorrectIds(const unsigned int eyeId, const unsigned int telescopeId)
{
  fTelescopeId = telescopeId;
  fEyeId = eyeId;
  if (fRecData)
    fRecData->CorrectIds(eyeId, telescopeId);
  for (auto& c : ChannelsRange())
    c.CorrectIds(eyeId, telescopeId);
  for (auto& p : AllPixelsRange())
    p.CorrectIds(eyeId, telescopeId);
}