FdLightCollectionEfficiency.h

Go to the documentation of this file.

#ifndef _FdLightCollectionEfficiency_FdLightCollectionEfficiency_h_
#define _FdLightCollectionEfficiency_FdLightCollectionEfficiency_h_

#include "SubModule.h"

#include <fwk/VModule.h>
#include <map>
#include <vector>
#include <string>
#include <utl/Trace.h>
#include <fevt/FdConstants.h>
#include <atm/Atmosphere.h>


namespace evt {
  class ShowerFRecData;
  class ShowerSimData;
  class Event;
}

namespace utl {
  class TabulatedFunctionErrors;
}

namespace fevt {
  class FEvent;
  class Eye;
  class Telescope;
}

namespace FdLightCollectionEfficiencyKG {
    class PixelToApertureLightConverter;

  class FdLightCollectionEfficiency : public fwk::VModule {

  public:
    fwk::VModule::ResultFlag Init();
    fwk::VModule::ResultFlag Run(evt::Event& event);
    fwk::VModule::ResultFlag Finish();

  private:
    enum EStopCondition {
      eFixed = 0,
      eTargetUncertainty,
      eSmallEnough,
      eBootstrap
    };
  private:
    fwk::VModule::ResultFlag ProcessEvent(evt::Event& realEvent);

    fwk::VModule::ResultFlag DoInitialReconstruction(evt::Event& event, std::map<int, evt::ShowerFRecData*>& dataSets);

    std::pair<fwk::VModule::ResultFlag, unsigned int>
    RunPhotonGenerationRayTracingLoop(evt::Event& event, evt::Event& realEvent,
                                      unsigned int nRayTracingIterations,
                                      const fevt::FdConstants::LightSource lightSource);

    void FillSimEvent(evt::Event& event,
                      const evt::ShowerFRecData& recData);

    double CalculateAdditionalIterationsToMeetTarget(const fevt::FEvent& theRealFEvent,
                                                     const fevt::FEvent& theSimFEvent,
                                                     const fevt::FdConstants::LightSource& lightSource,
                                                     const double targetRelUncertainty,
                                                     const double minRelevantEfficiency);

    double CalculateTargetRelUncertainty(const fevt::FEvent& theRealFEvent,
                                         const fevt::FEvent& theSimFEvent,
                                         const fevt::FdConstants::LightSource& lightSource,
                                         const double minRelevantEfficiency,
                                         const double maxUncertaintyChangeFraction);

    bool CalculateEfficiency(const evt::Event& simEvent, evt::Event& realEvent,
                             const int eyeId, const unsigned int nRayTracingIterations,
                             const fevt::FdConstants::LightSource lightSource);

    bool CalculateTelescopeEfficiency(const fevt::Telescope& simTel, fevt::Telescope& realTel,
                                      const fevt::Eye& realEye, const unsigned int nRayTracingIterations,
                                      const fevt::FdConstants::LightSource lightSource);

    utl::TraceD CalculateTelescopeTraceSum(const fevt::Telescope& tel,
                                           const fevt::FdConstants::LightSource component,
                                           const atm::Atmosphere::EmissionMode lightType);

    utl::TabulatedFunctionErrors CalculatePixelTraceSum(const fevt::Telescope& tel,
                                                        const fevt::FdConstants::LightSource component,
                                                        const double simTimeOffset,
                                                        const std::vector<std::vector<unsigned int> >& pixelsInZeta,
                                                        const utl::TabulatedFunctionErrors& realApLight);

    utl::TabulatedFunctionErrors CalcTraceDivision(const utl::TabulatedFunctionErrors& pixelTrace,
                                                   const utl::TraceD& apertureTrace,
                                                   const utl::TraceI& nRayTracedTrace,
                                                   const double nRayTracingIterations);

    template<typename T>
    double
    CalcTraceBinContent(const utl::Trace<T>& trace, const double start, const double end)
    {
      const double binSize = trace.GetBinning();

      const double maxBin = trace.GetSize()-1;

      const double relBinStart = start / binSize;
      const double relBinEnd   = end / binSize;

      const unsigned int relBinStartInt = (unsigned int)relBinStart;
      const unsigned int relBinEndInt   = (unsigned int)relBinEnd;

      if (relBinStartInt > maxBin)
        return 0.;

      if (relBinStartInt == relBinEndInt) {
        // target bin is part of a single source trace bin
        const double traceBinFactor = relBinEnd-relBinStart;
        return trace.At(relBinStartInt) * traceBinFactor;
      }

      double binSignal = 0.;
      // signal from first, partial bin
      const double startBinFactor = 1. - (relBinStart - relBinStartInt);
      binSignal += trace.At(relBinStartInt) * startBinFactor;

      if (relBinEndInt > maxBin)
        return binSignal;

      // signal from last, partial bin
      const double endBinFactor = relBinEnd - relBinEndInt;
      binSignal += trace.At(relBinEndInt) * endBinFactor;

      // signal from all intermediate, full bins
      if (relBinEndInt > maxBin) {
        for (unsigned int iBin = relBinStartInt+1; iBin < maxBin; ++iBin)
          binSignal += trace.At(iBin);
      } else {
        for (unsigned int iBin = relBinStartInt+1; iBin < relBinEndInt; ++iBin)
          binSignal += trace.At(iBin);
      }

      return binSignal;
    }

    void WriteDebugInfo(const int eyeId, const int simTelId, const double simTimeOffset,
                        const fevt::FdConstants::LightSource component,
                        const utl::TabulatedFunctionErrors& totalPixelTrace,
                        const utl::TraceD& totalWlTrace,
                        const utl::TabulatedFunctionErrors& realApLightFlux,
                        const utl::TabulatedFunctionErrors& telEff);

    // XML configuration flags
    // Note: Let's keep the use of these globals confined to the central
    // Init/Run/Finish functions and use parameter passing elsewhere!
    // One exception for now: verbosity

    int fVerbosity;

    EStopCondition fStopCondition;

    double fMinRelevantEfficiency;
    unsigned int fMaxIterations;
    double fTargetUncertainty;

    double fTargetWorstCaseLAtApUncertaintyChange;
    double fLowerUncertaintyLimit;

    double fProfileXBinning;
    bool fUseZeta;

    int fNRayTracingIterations;
    int fMinNRayTracePerBin;
    int fMaxNRayTracePerBin;
    double fExtraRayTraceFactor;

    double fLightAtDiaBinning;

    std::map<std::string, SubModule> fSubModulesList;

    // Yes, these are officially global variables. Sue me.
    PixelToApertureLightConverter* fLightConverter;
    std::map<unsigned int, utl::TraceD>* fTimeCorrectedApertureTraces;

    std::vector<fevt::FdConstants::LightSource> fLightComponents; 

    REGISTER_MODULE("FdLightCollectionEfficiencyKG", FdLightCollectionEfficiency);
  };

 }

#endif

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