Modules/FdSimulation/TelescopeSimulatorKG2/Mirror.h

Go to the documentation of this file.

#ifndef _TelescopeSimulatorKG2_Mirror_h_
#define _TelescopeSimulatorKG2_Mirror_h_

#include "RTResult.h"

#include <utl/CoordinateSystemPtr.h>
#include <utl/AugerUnits.h>

#include <utl/Math.h>
#include <utl/MathConstants.h>

#include <utl/Point.h>
#include <utl/Vector.h>
#include <utl/TabulatedFunction.h>

#include <string>

using namespace utl;
using namespace std;


namespace utl {
  class Photon;
  class Vector;
  class RandomEngine;
  class TabulatedFunction;
}

namespace fdet {
  class Telescope;
}

class TObjArray;

namespace TelescopeSimulatorKG2 {

  class Mirror {

  public:
    Mirror(utl::RandomEngine& rndm,
           const fdet::Telescope& tel,
           const double mirrorSize,
           const double mirrorSegmentSigma,
           const double mirrorRadiusSigma,
           const double mirrorAbsorptionTop,
           const double mirrorAbsorptionBot,
           const utl::TabulatedFunction* const mirrorDiffusionTop,
           const utl::TabulatedFunction* const mirrorDiffusionBot);

    RTNext Trace(const utl::Photon& photonIn, utl::Photon& photonOut);

    TObjArray* Draw();

  private:
    utl::RandomEngine& fRandom;

    const double fMirrorSize;
    const double fMirrorSegmentSigma;
    const double fMirrorRadiusSigma;
    const double fMirrorAbsorptionTop;
    const double fMirrorAbsorptionBot;
    const utl::TabulatedFunction* const fMirrorDiffusionTop;
    const utl::TabulatedFunction* const fMirrorDiffusionBot;

    utl::CoordinateSystemPtr fTelCS;
    const utl::Point fOrigin;

    const utl::TabulatedFunction& fReflectivity;
    const double fRCurv;
    const double fSigma;  // deviation of the normal of the mirror surface.

    struct MirrorSegment {
      MirrorSegment() { }
      MirrorSegment(const int i, const utl::Point& p, const double r, const utl::CoordinateSystemPtr& ptr)
        : index(i), origin(p), radius(r), cs(ptr) { }

      int index = 0;
      utl::Point origin;
      double radius = 0;
      utl::CoordinateSystemPtr cs;
    };

    MirrorSegment& GetMirrorSegment(const utl::Point& p);

    std::map<int, MirrorSegment> fSegments;
  };

}


#endif