Modules/FdSimulation/TelescopeSimulatorKG/Camera.h

Go to the documentation of this file.

#ifndef _TelescopeSimulatorKG_Camera_h_
#define _TelescopeSimulatorKG_Camera_h_


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

namespace fdet {
  class Pixel;
  class Telescope;
}

#include "RTResult.h"

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

#include <string>

class TObjArray;

namespace TelescopeSimulatorKG {

  class Camera {

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

  public:

    Camera(utl::RandomEngine& rndm, const fdet::Telescope& tel);

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


    // Simulate Camera
    RTResult Trace(const utl::Photon& photonIn,
                   utl::Photon& photonOut,
                   int& nreflections,
                   int& col, int& row,
                   double& cosTheta,
                   bool doMercedes=true);


    TObjArray* Draw(const bool do3D=true);

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


    // 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,
      eTopRight    = 1,
      eTopLeft     = 2,
      eLeft        = 3,
      eBottomLeft  = 4,
      eBottomRight = 5,
      eRight       = 6
    };
    HexagonDirection Hexagon(double x, double y, double r);
    int ConstructPlane(const int id, utl::Vector& n, utl::Point& p, const utl::CoordinateSystemPtr& pxlCS);

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

  private:

    utl::RandomEngine& fRandom;
    const fdet::Telescope& fTel;
    
    utl::CoordinateSystemPtr fTelCS;
    utl::Point fOrigin;

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

    double fSinAx, fSinBx, fSinAy, fSinBy; // side, top and down limits

    // Mercedes parameters
    double fD1, fD2, fR1, fR2, fHMerc;

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

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


    // camera support
    utl::CoordinateSystemPtr fCameraSupportCoordinateSystem;

  };

} // TelescopeSimulatorKG


#endif // _TelescopeSimulatorKG_Camera_h_

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