ShowerPhotonGenerator.h

Go to the documentation of this file.

#ifndef _ShowerPhotonGeneratorOG_ShowerPhotonGenerator_h_
#define _ShowerPhotonGeneratorOG_ShowerPhotonGenerator_h_

#include <fwk/VModule.h>

#include <utl/CoordinateSystemPtr.h>
#include <utl/ShadowPtr.h>
#include <fevt/FdConstants.h>

#include <map>
#include <vector>
#include <fstream>

class TH1D;
class MultipleScatterer;

namespace utl {
  class Point;
  class Vector;
  class RandomEngine;
  class VRandomSampler;
  class RandomSamplerFromPDF;
  class TabulatedFunction;
}

namespace fdet {
  class Telescope;
}

namespace evt {
  class Event;
  class ShowerSimData;
}

namespace atm {
  class ProfileResult;
}

namespace ShowerPhotonGeneratorOG {

  class RayTracer;


  class ShowerPhotonGenerator : public fwk::VModule {

    enum ELDFMode {
      eOff,       // 1D shower
      eNKG,       // NKG lateral distribution
      eGora,      // Gora et al LDF
      eCherenkov,  // full Cherenkov emission calculation
      eCherenkovAtAxis, // Cherenkov emission, for electrons at shower axis
      eCherenkovCORSIKA // use full Cherenkov option of CORSIKA
    };

    enum EPhotonSource {
      eUnkown,
      eFluorescence,
      eDirectCherenkov,
      eScatteredCherenkov,
      eLaser
    };

  public:
    ShowerPhotonGenerator();

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

    unsigned int GetMaxNRayTrace() const { return fMaxNRayTrace; }
    void SetMaxNRayTrace(unsigned int nphotons) { fMaxNRayTrace = nphotons; }

    unsigned int GetMinNRayTrace() const { return fMinNRayTrace; }
    void SetMinNRayTrace(unsigned int nphotons) { fMinNRayTrace = nphotons; }

    double GetExtraRayTraceFactor() const { return fExtraRayTraceFactor; }
    void SetExtraRayTraceFactor(double factor) { fExtraRayTraceFactor = factor; }

    bool GetUseOnlyReferenceWavelength() const { return fUseOnlyReferenceWavelength; }
    void SetUseOnlyReferenceWavelength(bool onlyRefWl)
    { fUseOnlyReferenceWavelength = onlyRefWl; }

    void ResetLightSourceSelection() { fLightSourceSelector = -2; }
    void SetLightSourceSelection(const fevt::FdConstants::LightSource source) { fLightSourceSelector = source; }
    int GetLightSourceSelection() { return fLightSourceSelector; } 

  private:
    unsigned int fMaxNRayTrace; 
    unsigned int fMinNRayTrace; 
    double fExtraRayTraceFactor; 
    bool fUseOnlyReferenceWavelength; 
    ELDFMode fFluorescenceLDF;
    ELDFMode fScatteredCherenkovLDF;
    ELDFMode fDirectCherenkovLDF;
    bool fMultipleScattering;
    int fLightSourceSelector; 

    utl::RandomEngine* fRandomEngine;
    MultipleScatterer* fMultipleScatterer;


    utl::Vector LateralDistributionNKG(const utl::CoordinateSystemPtr& shwCS,
                                       const double s_age,
                                       const double r_moliere);
    utl::Vector LateralDistributionGora(const utl::CoordinateSystemPtr& shwCS,
                                        const double s_age,
                                        const double r_moliere);

    utl::Vector LateralDistributionScatteredCherenkov(const utl::CoordinateSystemPtr& showerCX,
                                                      const utl::Point& core,
                                                      const utl::Vector& axis,
                                                      double distanceCoreToPointOnShower,
                                                      double Xmax,
                                                      double rMoliere,
                                                      double& emissionDistance,
                                                      utl::Point& pointOfEnission,
                                                      utl::Vector& directionOfEmission,
                                                      const utl::VRandomSampler& cherenkovProduction,
                                                      const atm::ProfileResult& depthProfile,
                                                      const atm::ProfileResult* slantDepthVsDistance,
                                                      const double absCosZenith,
                                                      const double coreZ,
                                                      const bool flatEarth,
                                                      const double atmDistanceMin,
                                                      const double atmDistanceMax);

    double NKGFunction(const double s, const double fMax);
    double GoraFunction(const double s);

    void PlotLDF(const evt::ShowerSimData& simShower,
                 const utl::TabulatedFunction& cherenkovProductionBeam,
                 const double age);

    TH1D* ToCumu(TH1D* h, double total);

    REGISTER_MODULE("ShowerPhotonGeneratorOG", ShowerPhotonGenerator);

  };

  class ScopeGuard {
  public:
    ScopeGuard(std::map<int, utl::RandomSamplerFromPDF*>& theMap);
    ~ScopeGuard();
  private:
    std::map<int, utl::RandomSamplerFromPDF*>& fMap;
  };
}


#endif

// Configure (x)emacs for this file ...
// Local Variables:
// mode: c++
// compile-command: "make -C .. -k"
// End: