Modules/FdSimulation/TelescopeSimulatorKG2/Camera.h

Go to the documentation of this file.

#ifndef _TelescopeSimulatorKG2_Camera_h_
#define _TelescopeSimulatorKG2_Camera_h_

#include "RTResult.h"
#include "RayTracer.h"

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


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

namespace fdet {
  class Telescope;
}

class TObjArray;


namespace TelescopeSimulatorKG2 {

  class Camera {

  public:
    Camera(utl::RandomEngine& rndm,
           const fdet::Telescope& tel, 
           const bool plotPhotonTracksAtMercedes,
           const bool simulateMercedesStars,
           const bool simulateHaloEffects,
           const bool simulateGhostEffects,
           const double nPmts);

    // Shadow of camera simulation
    RTNext TraceShadow(const utl::Photon& photonIn, utl::Photon& photonOut,
                       const bool doSupport = true);

    // Simulate Camera
    RTNext Trace(const utl::Photon& photonIn, utl::Photon& photonOut,
                 int& nreflections, int& nbackscattered,
                 int& col, int& row);

    TObjArray* Draw(const bool do3D = true);

    // Compute the hit position of a ray on the camera surface
    bool TraceSurf(const utl::Photon& photonIn, utl::Photon& photonOut);

    // Simulate the ray of light with direction n and point p in the
    // mercedes and PMT system
    RTResult TraceMerc(const utl::CoordinateSystemPtr& pxlCS,
                       const utl::Photon& photonIn,
                       utl::Photon& photonOut,
                       int& nreflections);

    // Give the position pf over the focal surface identify the pixel (nx,ny)
    //int PixelId(const utl::Point& p, int* nx, int* ny);
    //int PixelId_new(const utl::Vector& pFocal, int& nx, int& ny);

    enum HexagonDirection {
      eInside      = 0, // cathode
      eTopRight    = 1,
      eTopLeft     = 2,
      eLeft        = 3,
      eBottomLeft  = 4,
      eBottomRight = 5,
      eRight       = 6,
      eOutside     = 7  // focal plane
    };

    HexagonDirection Hexagon(const double x, const double y, const double r);

    void ConstructPlane(const int id, utl::Vector& n, utl::Point& p, const utl::CoordinateSystemPtr& pxlCS);

    // this is just needed for photon plotting
    void SetPhotonTrack(RayTracer::Track* const track) { fPhotonTrack = track; }

  private:
    Camera(const Camera&);
    Camera& operator=(const Camera&);

    void SetMercedesParameter(const double height, const double width);
    void CalculateCameraSupportCoordinateSystem();
    bool FindPixelId(const utl::Vector& incidentDir, int& row, int& col) const;

    utl::RandomEngine& fRandom;
    const fdet::Telescope& fTel;
    const bool fPlotPhotonTracksAtMercedes;
    const bool fSimulateMercedesStars;
    const bool fSimulateHaloEffects;
    const bool fSimulateGhostEffects;
    
    const double fPMT_n;
    const double fAir_n = 1.000277;  // at STP

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

    const double fRFocal;  // curvature radius of focal surface
    const double fMercedesEff;

    // Warning: the values of SIN_?? may need some changes to simulate
    // correctly the camera (shadow and trace_surf).
    // side, top and down limits
    //const double fSinAx = 0.2491262;
    //const double fSinBx = 0.25646528973;
    //const double fSinAy = 0.27966724;
    //const double fSinBy = 0.26704475;

    // Mercedes parameters
    double fD1 = 0;
    double fD2 = 0;
    double fR1 = 0;
    double fR2 = 0;
    double fHMerc = 0;

    // mercedes size parameters (see picture)
    double fNz = 0;
    double fNt = 0;  // z and tangent components of the plane normal.

    // Variables to control the precision of the normal of the mercedes surface
    const double fSigma;

    // camera support
    utl::CoordinateSystemPtr fCameraSupportCoordinateSystem;

    // to check for photons to be inside camera bays
    double fRCurv2 = 0;

    // for visual plotting of ray tracing details
    RayTracer::Track* fPhotonTrack = nullptr;

  };

}


#endif