TimeRangeCalculator.cc

Go to the documentation of this file.

#include "TimeRangeCalculator.h"

#include <vector>
#include <list>
#include <limits>

#include <evt/Event.h>

#include <fevt/FEvent.h>
#include <fevt/Eye.h>
#include <fevt/Telescope.h>
#include <fevt/EyeRecData.h>
#include <fevt/TelescopeRecData.h>
#include <fevt/FdConstants.h>

#include <utl/AugerException.h>
#include <utl/ErrorLogger.h>

#include <sstream>

using namespace FdLightCollectionEfficiencyKG;
using namespace utl;
using namespace evt;
using namespace fevt;
using namespace std;


/*************************************************************************/
TimeRangeCalculator::TimeRangeCalculator(fevt::TelescopeRecData& telRec,
                                         const int verbosity) :
  fTelRec(telRec), fVerbosity(verbosity)
{
}


/*************************************************************************/
void
TimeRangeCalculator::UpdateSpotFarFromBorderTimes(const double effThreshold)
{
  if (!fTelRec.HasLightFlux(FdConstants::eTotal)) {
    if (fVerbosity > 1)
      INFO("Skipping telescope. No telescope-aperture light trace");
    return;
  }

  const utl::TabulatedFunctionErrors& totalLAtAperture = fTelRec.GetLightFlux(FdConstants::eTotal);
  // Calculate the start/stop times of each light component and use the smallest range
  std::pair<double, double> startStop
    = std::make_pair(-std::numeric_limits<double>::max(), std::numeric_limits<double>::max());
  const utl::MultiTabulatedFunctionErrors& lcEff = fTelRec.GetLightCollectionEfficiency();
  for (utl::MultiTabulatedFunctionErrors::ConstIterator lcIt = lcEff.Begin(), end = lcEff.End();
       lcIt != end; ++lcIt)
  {
    const utl::TabulatedFunctionErrors& componentLCEff   = lcIt->GetTabulatedFunctionErrors();
    pair<double, double> thisStartStop
      = CalculateStartStopTimes(componentLCEff, totalLAtAperture, effThreshold);

    if (fVerbosity > 1) {
      ostringstream msg;
      msg << "Determined start/stop for light component " << lcIt->GetLabel()
          << ": Start=" << thisStartStop.first << " End=" << thisStartStop.second;
      INFO(msg);
    }
    if (thisStartStop.first > startStop.first)
      startStop.first = thisStartStop.first;
    if (thisStartStop.second < startStop.second)
      startStop.second = thisStartStop.second;
  }

  if (fVerbosity > 0) {
    ostringstream msg;
    msg << "Determined telescope lc-eff start/stop: Start="
        << startStop.first << " End=" << startStop.second;
    INFO(msg);
  }

  // Update the time ranges to include only the time range we deduced from the
  // light collection efficiency
  list<pair<double, double> >& timeRanges = fTelRec.GetSpotFarFromBorderTimeRanges();
  timeRanges.clear();
  timeRanges.push_back(startStop);
}


/*************************************************************************/
std::pair<double, double>
TimeRangeCalculator::CalculateStartStopTimes(const utl::TabulatedFunctionErrors& lcEff,
                                             const utl::TabulatedFunctionErrors& lAtAperture,
                                             const double effThreshold)
{
  const unsigned int nPoints = lcEff.GetNPoints();
  unsigned int iStart = 0;
  for (; iStart < nPoints; ++iStart) {
    if (lcEff.GetY(iStart) > effThreshold)
      break;
  }

  int iStop = nPoints-1;
  for (; iStop > 0; --iStop) {
    if (lcEff.GetY(iStop) > effThreshold)
      break;
  }

  // assumes similar size bins
  const double start = (iStart == 0
                        ? lAtAperture.GetX(iStart)
                        : (lAtAperture.GetX(iStart-1) + lAtAperture.GetX(iStart)) / 2.);

  // assumes similar size bins
  const double stop  = (iStop == (int)nPoints-1
                        ? lAtAperture.GetX(iStop)
                        : (lAtAperture.GetX(iStop+1) + lAtAperture.GetX(iStop)) / 2.);

  return std::make_pair(start, stop);
}


// Configure (x)emacs for this file ...
// Local Variables:
// mode: c++
// End: