/RTFunctions.h

Go to the documentation of this file.

#ifndef _RTFunctions_
#define _RTFunctions_

namespace utl {
  class Point;
  class RandomEngine;
}

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

#include <vector>
#include <utility>

namespace TelescopeSimulatorKG2 {

  namespace RTFunctions {
    
    void Reflection (const utl::Photon& photonIn,
                     const utl::Vector& normal,
                     utl::Photon& photonOut);

    void Absorption(const utl::Photon& photonIn,
                    const double filterAbsorptionFactor,
                    utl::Photon& photonOut);

    void Absorption(const utl::Photon& photonIn,
                    const double mirrorAbsorptionFactorTop,
                    const double mirrorAbsorptionFactorBot,
                    const double verticalPosOnMirror,
                    utl::Photon& photonOut,
                    const double mirrorSize); 
    
    typedef std::vector<utl::Photon> PhotonList;
    int Refraction(const double n12,
                   const utl::Photon& photonIn,
                   const utl::Vector& normal,
                   PhotonList& photonsOut);
    
    double Plane (const utl::Point& point,
                  const utl::Vector& normal,
                  const utl::Photon& photonIn,
                  utl::Photon& photonOut);
    
    typedef std::pair<utl::Photon, utl::Vector> PhotonNormalPair;
    typedef std::vector<PhotonNormalPair> IntersectionList;
    bool Sphere (const utl::Point& origin,
                 const double radius,
                 const utl::Photon& photonIn, 
                 IntersectionList& intersections);
    
    utl::Vector TorusNormal(const utl::Point& origin,
                            const utl::Vector& inwards,
                            const utl::Point& point,
                            const double torusRadius,
                            const double tubeRadius);

    void Cubic(const double a0,
               const double a1,
               const double a2,
               const double a3,
               std::vector<double>& roots);

    void Quartic(const double a0,
                 const double a1,
                 const double a2,
                 const double a3,
                 const double a4,
                 std::vector<double>& roots);

    void  Torus (const utl::Point& origin,
                 const utl::Vector& inwards,
                 const double torusRadius,
                 const double tubeRadius,
                 const utl::Photon& photonIn, 
                 IntersectionList& intersections);
    
    int CurvedLensSurface (const utl::Point& origin,
                           const utl::Vector& inwards,
                           const double torusRadius,
                           const double tubeRadius,
                           const utl::Photon& photonIn, 
                           const utl::Photon& photonLens);
    
    utl::Vector RandomNormal (utl::RandomEngine& rndm,
                              const utl::Vector& normalIn,
                              const double sigma_alpha);    

    utl::Vector RandomFacet(utl::RandomEngine& rndm,
                            const utl::Vector& normalIn, 
                            const double sigma_alpha,
                            const utl::Vector& rayIn);

    utl::Vector LambertDiffusion(utl::RandomEngine& rndm,
                                 const utl::Vector& rayIn,
                                 const utl::Vector& normal,
                                 const double amountOfStrayLight,
                                 const double MaxTheta);

    utl::Vector MirrorDiffusion(utl::RandomEngine& rndm,
                                const utl::Vector& rayIn,
                                const utl::TabulatedFunction* mirrorDiffusionTop,
                                const utl::TabulatedFunction* mirrorDiffusionBot,
                                const double verticalPosOnMirror);
  }
  
}

#endif