TelescopeData.cc

Go to the documentation of this file.

#include "TelescopeData.h"
#include <utl/TabulatedFunction.h>
#include <utl/AugerUnits.h>
#include <cmath>
#include <algorithm>

using namespace utl;
using namespace FdEnergyDepositFinderKG;


typedef std::map<fevt::FdConstants::LightSource, double> EfficiencyMap;

TelescopeDataBin::TelescopeDataBin(const double minDepth,
                                   const double maxDepth,
                                   const double hXmean,
                                   const utl::Point& pFirst,
                                   const utl::Point& pLast,
                                   const utl::Point& pXMean,
                                   const double t, const double dt,
                                   const double sig, const double sigErr,
                                   const double vbg,
                                   const EfficiencyMap& lightEfficiencies, const int parentBin):
  fMinDepth(minDepth),
  fMaxDepth(maxDepth),
  fHeight(hXmean),
  fFirstPoint(pFirst),
  fLastPoint(pLast),
  fMeanDepthPoint(pXMean),
  fTime(t),
  fTimeBinHalfWidth(dt),
  fSignal(sig),
  fSignalErr(sigErr),
  fBackgroundVariance(vbg),
  fParentBin(parentBin),
  fLightEfficiencies(lightEfficiencies),
  fArcLengthFunction(),
  fMaxZeta(0.)
{
}

TelescopeDataBin::~TelescopeDataBin() {
}


void
TelescopeDataBin::AddZetaPixel(const ZetaPixel& pixel)
{
  for (unsigned int i=0; i<pixel.GetXCoordinates().size(); ++i) {
    const double x = pixel.GetXCoordinates()[i];
    const double y = pixel.GetYCoordinates()[i];
    const double r = std::sqrt(x*x+y*y);
    if (r > fMaxZeta)
      fMaxZeta = r;
  }
  fZetaPixels.push_back(pixel);
}

double
TelescopeDataBin::GetMaxZeta()
  const
{
  return fMaxZeta;
}

double
TelescopeDataBin::GetEfficiency(fevt::FdConstants::LightSource source)
  const
{
  EfficiencyMap::const_iterator iter = fLightEfficiencies.find(source);
  if (iter != fLightEfficiencies.end())
    return iter->second;
  else
    return 1.;
}

double
TelescopeDataBin::GetMeanDepth()
  const
{
  return (fMinDepth+fMaxDepth)/2.;
}

bool
TelescopeDataBin::HasEfficiency(fevt::FdConstants::LightSource source)
  const
{
  return (fLightEfficiencies.find(source) != fLightEfficiencies.end());
}


const std::vector<ZetaPixel>&
TelescopeDataBin::GetZetaPixels()
  const
{
  return fZetaPixels;
}

const TabulatedFunction&
TelescopeDataBin::GetArcLengthFunction()
  const {

  if (!fArcLengthFunction.GetNPoints()) {
    double zeta = 0;
    const double dZeta = 0.001 * degree;
    while (zeta < fMaxZeta + dZeta) {

      double arcLength = 0;
      for (unsigned int i=0;i<fZetaPixels.size(); ++i) {
        double arcLengthPixel = fZetaPixels[i].CalculateInsideArcLength(0.,0.,zeta);
        fZetaPixels[i].fArcLengthFunction.PushBack(zeta, arcLengthPixel);
        arcLength += arcLengthPixel;
      }
      fArcLengthFunction.PushBack(zeta, arcLength);
      zeta+=dZeta;
    }
  }

  return fArcLengthFunction;

}


//------------------------------------


TelescopeData::TelescopeData(int telId,
                             TelescopeData::ETelDataType type) :
  fTelescopeId(telId), fTelDataType(type),
  fPhotonToPhotoElectron(0.), fGainVariance(0.),
  fDiaphragmArea(0.), fZeta(0.)
{
}

void
TelescopeData::SortBins() {
  std::sort(fTelescopeDataBins.begin(), fTelescopeDataBins.end());
}


void
TelescopeData::AddTelescopeDataBin(const TelescopeDataBin& telDataBin)
{
  fTelescopeDataBins.push_back(telDataBin);
}

double
TelescopeData::GetMinDepth() const
{
  return fTelescopeDataBins.empty()?-1.:fTelescopeDataBins.front().fMinDepth;
}

double
TelescopeData::GetMaxDepth()
  const
{
  return fTelescopeDataBins.empty()?-1.:fTelescopeDataBins.back().fMaxDepth;
}

bool
TelescopeData::DepthInRange(const double depth) const
{
  return (GetMinDepth() <= depth &&
          GetMaxDepth() >= depth);
}

unsigned int
TelescopeData::GetId() const
{
  return fTelescopeId;
}

TelescopeData::ETelDataType
TelescopeData::GetType()
  const
{
  return fTelDataType;
}

const std::vector<TelescopeDataBin>&
TelescopeData::GetTelescopeDataBins()
  const
{
  return fTelescopeDataBins;
}

std::vector<TelescopeDataBin>::const_iterator
TelescopeData::TelDataBinsBegin()
  const
{
  return fTelescopeDataBins.begin();
}

std::vector<TelescopeDataBin>::const_iterator
TelescopeData::TelDataBinsEnd()
  const
{
  return fTelescopeDataBins.end();
}

void
TelescopeData::SetTelescopeParameters(double peFactor, double gainVariance,
                                      double diaArea)
{
  fPhotonToPhotoElectron=peFactor;
  fGainVariance=gainVariance;
  fDiaphragmArea = diaArea;
}