TelescopeSimData.cc

Go to the documentation of this file.

#include <fevt/TelescopeSimData.h>
#include <fevt/Eye.h>

#include <utl/ErrorLogger.h>
#include <utl/Trace.h>
#include <utl/MultiTrace.h>
#include <utl/AugerException.h>
#include <utl/Md5Sum.h>

#include <sstream>

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


TelescopeSimData::TelescopeSimData() :
  fNumberOfPhotonBins(0),
  fNFltPixels(0),
  fNFltPixelsFromShower(0),
  fNFltPixelsFromBackground(0),
  fNPixelWithShowerLight(0),
  fNReadOutPixels(0),
  fSltTriggerTime(0),
  fSltTimeShift(0),
  fConfigSignatureStr(""),
  fConfigSignature("")
{ }


utl::TraceD&
TelescopeSimData::GetPhotonTrace(const fevt::FdConstants::LightSource source, const int wl)
{
  if (!fPhotonTraces.count(source)) {
    ostringstream err;
    err << "Photon trace for source=" << source << " does not exist!";
    ERROR(err);
    throw utl::NonExistentComponentException(err.str());
  }
  if (!fPhotonTraces[source].HasLabel(wl)) {
    ostringstream err;
    err << "Photon trace for source=" << source << " at wlBin=" << wl << " does not exist!";
    ERROR(err);
    throw utl::NonExistentComponentException(err.str());
  }
  return fPhotonTraces[source].GetTrace(wl);
}


const utl::TraceD&
TelescopeSimData::GetPhotonTrace(const fevt::FdConstants::LightSource source, const int wl)
  const
{
  const ConstPhotonTraceSourceIterator it = fPhotonTraces.find(source);
  if (it == fPhotonTraces.end()) {
    ostringstream err;
    err << "Photon trace for source=" << source << " does not exist!";
    ERROR(err);
    throw utl::NonExistentComponentException(err.str());
  }
  if (!it->second.HasLabel(wl)) {
    ostringstream err;
    err << "Photon trace for source=" << source << " at wlBin=" << wl << " does not exist!";
    ERROR(err);
    throw utl::NonExistentComponentException(err.str());
  }
  return it->second.GetTrace(wl);
}


bool
TelescopeSimData::HasPhotonTrace(const fevt::FdConstants::LightSource source, const int wl)
  const
{
  const ConstPhotonTraceSourceIterator it = fPhotonTraces.find(source);
  return it != fPhotonTraces.end() && it->second.HasLabel(wl);
}


bool
TelescopeSimData::HasPhotonTrace(const fevt::FdConstants::LightSource source)
  const
{
  const ConstPhotonTraceSourceIterator it = fPhotonTraces.find(source);
  return it != fPhotonTraces.end();
}


void
TelescopeSimData::MakePhotonTrace(const fevt::FdConstants::LightSource source, const int wl,
                                  const unsigned int size, const double binSize)
{
  if (HasPhotonTrace(source, wl)) {
    ERROR("Source already exists. Not Changing.");
    return;
  }
  fPhotonTraces[source].AddTrace(size, binSize, wl);
}


TelescopeSimData::PhotonTraceIterator
TelescopeSimData::PhotonTracesBegin(const fevt::FdConstants::LightSource source)
{
  const PhotonTraceSourceIterator it = fPhotonTraces.find(source);
  if (it == fPhotonTraces.end()) {
    ostringstream err;
    err << "Photon trace for source=" << source << " does not exist!";
    ERROR(err);
    throw utl::NonExistentComponentException(err.str());
  }
  return it->second.Begin();
}


TelescopeSimData::ConstPhotonTraceIterator
TelescopeSimData::PhotonTracesBegin(const fevt::FdConstants::LightSource source)
  const
{
  const ConstPhotonTraceSourceIterator it = fPhotonTraces.find(source);
  if (it == fPhotonTraces.end()) {
    ostringstream err;
    err << "Photon trace for source=" << source << " does not exist!";
    ERROR(err);
    throw utl::NonExistentComponentException(err.str());
  }
  return it->second.Begin();
}


TelescopeSimData::PhotonTraceIterator
TelescopeSimData::PhotonTracesEnd(const fevt::FdConstants::LightSource source)
{
  const PhotonTraceSourceIterator it = fPhotonTraces.find(source);
  if (it == fPhotonTraces.end()) {
    ostringstream err;
    err << "Photon trace for source=" << source << " does not exist!";
    ERROR(err);
    throw utl::NonExistentComponentException(err.str());
  }
  return it->second.End();
}


TelescopeSimData::ConstPhotonTraceIterator
TelescopeSimData::PhotonTracesEnd(fevt::FdConstants::LightSource source)
  const
{
  const ConstPhotonTraceSourceIterator it = fPhotonTraces.find(source);
  if (it == fPhotonTraces.end()) {
    ostringstream err;
    err << "Photon trace for source=" << source << " does not exist!";
    ERROR(err);
    throw utl::NonExistentComponentException(err.str());
  }
  return it->second.End();
}


void
TelescopeSimData::MakeRayTracedPhotonTrace(const unsigned int size, const double binSize)
{
  if (fRayTracedPhotonTrace) {
    ERROR("RayTracedPhotonTrace already exists");
    return;
  }
  fRayTracedPhotonTrace = new TraceI(size, binSize, 0);
}


void
TelescopeSimData::MakeDistanceTrace(const unsigned int size, const double binSize)
{
  if (fDistanceTrace) {
    ERROR("Trace already exists");
    return;
  }
  fDistanceTrace = new TraceD(size, binSize);
}


const std::string&
TelescopeSimData::GetConfigSignature()
  const
{
  if (fConfigSignature.empty())
    fConfigSignature = Md5Sum(fConfigSignatureStr).GetHexDigest();
  return fConfigSignature;
}


void
TelescopeSimData::ClearConfigSignature()
{
  fConfigSignature = "";
  fConfigSignatureStr = "";
}