lightsrc.h

Go to the documentation of this file.

#ifndef Lightsrc_H
#define Lightsrc_H
 
#include "raybase.h"
#include "vector.h"
#include "tubedray.h"
#include "iray.h"
#include "objectshape.h"
#include "ray_pow.h"
#include <vector>
 
namespace GOAT
{
    namespace raytracing
    {
#define LIGHTSRC_RAYTYPE_RAY 1    
#define LIGHTSRC_RAYTYPE_IRAY 2   
#define LIGHTSRC_RAYTYPE_PRAY 3   
constexpr int LIGHTSRC_SRCTYPE_PLANE=1;  
constexpr int LIGHTSRC_SRCTYPE_GAUSS=2;  
constexpr int LIGHTSRC_SRCTYPE_RING = 3;  
constexpr int LIGHTSRC_SRCTYPE_TOPHAT=4; 
constexpr int LIGHTSRC_SRCTYPE_LINE = 5; 
constexpr int LIGHTSRC_SRCTYPE_POINT = 6; 
 
constexpr int LIGHTSRC_SRCTYPE_PLANE_MC = 11; 
constexpr int LIGHTSRC_SRCTYPE_GAUSS_MC = 12; 
constexpr int LIGHTSRC_SRCTYPE_RING_MC =  13; 
constexpr int LIGHTSRC_SRCTYPE_LINE_MC = 14; 
constexpr int LIGHTSRC_SRCTYPE_POINT_MC = 15; 
 
 
 
#define LIGHTSRC_NOT_LAST_RAY 0  
#define LIGHTSRC_IS_LAST_RAY 1   
#define LIGHTSRC_ERROR -1        
#define Z0 376.730313461         
 
#define LIGHTSRC_POL_X 0 
#define LIGHTSRC_POL_Y 1 
#define LIGHTSRC_POL_Z 2 
#define LIGHTSRC_POL_USER_DEFINED 0 
 
 
 

        class LightSrc
 
        {
        public:
            void reset();  
            ~LightSrc(void);
            LightSrc();
            LightSrc(const LightSrc&); 
            void clearObjects(); 
            void addObject(ObjectShape* obj);  
            void removeObject(ObjectShape* obj); 
            void ObjectList(int Anz, std::vector<ObjectShape*> Obj);  

            virtual int next(RayBase* ray) = 0; // gives back next ray
            virtual int next(Ray_pow& ray) = 0; // gives back next ray
            virtual int next(IRay& ray) = 0; // gives back next ray
            virtual int next(tubedRay& ray) = 0;  // gives back next ray
            virtual double area() { return 1.0; } 
            void binRead(std::ifstream& is); 
            void binWrite(std::ofstream& os); 
            virtual void binWriteItem(std::ofstream& os) = 0; 
            virtual void binReadItem(std::ifstream& os) = 0; 
            int getNumObjs() { return numObjs; } 
            ObjectShape* getObject(int i) { if ((i < 0) || (i > numObjs)) return NULL; return Obj[i]; }  
            void setObject(ObjectShape* O, int i = -1); 
            int rayType() { return raytype; }  
            void setR0(double r0); 
            double getDensity() { return density; } 
            maths::Vector<std::complex<double>> getInitPol() { return initPol; }
            void setD(double D) 
            {
                this->density = D / ((double)N);
                this->D = D;
                D1 = D;
                D2 = D;
                reset();
            } 
 
            void setD(double D1, double D2) 
            {               
                if (D1<D2) density= D1 / ((double)N);
                else density = D2 / ((double)N);
                this->D1 = D1;
                this->D2 = D2;
                reset();
            }
 
            void setNumRaysRT (int numRaysRT)
            {
                this->numRaysRT=numRaysRT;
            }
 
            int getNumRaysRT () {return numRaysRT; }
 
 
 
            void setk(const maths::Vector<double>& k); 
            maths::Vector<double> getk() { return k; } 
            int getNumRays() { return N; } 
            void setNumRays(int N) 
            {
                this->N = N;
                density = D / ((double)N);
                reset();
            }
            void setWavelength(double wvl) { this->wvl = wvl; k0 = 2.0 * M_PI / wvl; }
            double getWavelength() { return wvl; }
            void setWavenumber(double k0) { this->k0 = k0; wvl = 2.0 * M_PI / k0; }
            double getWavenumber() { return k0; }
            
            void setPol(maths::Vector<std::complex<double> > pol); 
            void setPos(maths::Vector<double> P); 
            maths::Vector<double> getPos() { return Pos; }  
            void setN0(std::complex<double> n0) { this->n0 = n0; } 
            std::vector<ObjectShape*> Obj; 
            // protected :
            maths::Vector<double> Pos; 
            int type;           
            double P0=1.0;        
            double density;     
            maths::Vector<double> k;   
            int N=10000;  
            int i1; 
            int i2; 
            maths::Vector<std::complex<double> > Pol; 
            maths::Vector<std::complex<double> > Pol2; 
            double r0=1.0;          
            
            int numObjs;        
            std::complex<double> n0; 
 
            double D;           
            double D1, D2;      
            maths::Vector<double> e1, e2;  
            int raytype;        
            int polType;        
            maths::Vector<std::complex<double> > initPol; 
            double Pall;        
            friend class LightSrcPlane;
            friend class LightSrcGauss;
            friend std::ostream& operator << (std::ostream& os, LightSrc* ls);
            bool suppress_phase_progress = false; 
            int rayCounter=0; 
            void adjustDirection();
            double getIsum1() { return Isum1; }
            double getIsum2() { return Isum2; }
            
        protected:
            double wvl=1;         
            double k0;            
            maths::Vector<double> rotVec=maths::Vector<double>(1,0,0); 
            double Isum1, Isum2;
            int numRaysRT=20; 
            
        };
 
 
 

        class LightSrcPlane : public LightSrc
        {
        public:
            LightSrcPlane(void);
            LightSrcPlane(maths::Vector<double> Pos, int N, double wvl, double D = 100.0, maths::Vector<std::complex<double> > Pol = maths::Vector<std::complex<double> >(0.0, 1.0, 0.0), int raytype = LIGHTSRC_RAYTYPE_IRAY, double r0 = 100.0); 
            LightSrcPlane(const LightSrcPlane&); 
            ~LightSrcPlane(void) {}; 
            int next(GOAT::raytracing::RayBase* ray);  
            int next(IRay& S);
            int next(tubedRay& S);
            int next(Ray_pow& S);
            void binWriteItem(std::ofstream& os) { /* to be implemented !!! */ }
            void binReadItem(std::ifstream& os) { /* to be implemented !!! */ }
            double area() { return D * D; } 
 
            // void turnSrc // to be done !!!
        };

        class LightSrcLine : public LightSrc
        {
        public:
            LightSrcLine();
            LightSrcLine(maths::Vector<double> Pos, int N, double wvl, double size, maths::Vector<double> k=maths::ez, maths::Vector<double> direction=maths::ey);
            int next(RayBase* ray);
            int next(IRay& S);
            int next(Ray_pow& S);
            int next(tubedRay& S);
            void binWriteItem(std::ofstream& os) { /* to be implemented !!! */ }
            void binReadItem(std::ifstream& os) { /* to be implemented !!! */ }
            maths::Vector<double> direction;
            double size;
        };
 
 

        class LightSrcRing : public LightSrc
        {
        public:
            LightSrcRing();
            LightSrcRing(maths::Vector<double> Pos, int N, double wvl, double rmin=0.0, double rmax=100.0, maths::Vector<std::complex<double> > Pol = maths::Vector<std::complex<double> >(0.0, 1.0, 0.0), int raytype = LIGHTSRC_RAYTYPE_IRAY, double r0 = 100.0);
            int next(RayBase* ray);
            int next(IRay& S);
            int next(Ray_pow& S);
            int next(tubedRay& S);
            void binWriteItem(std::ofstream& os) { /* to be implemented !!! */ }
            void binReadItem(std::ifstream& os) { /* to be implemented !!! */ }
            double getRmin() {return rmin; }  
            double getRmax() {return rmax; } 
            void setRmin(double rmin); 
            void setRmax(double rmax); 
            double area() { return M_PI * (rmax * rmax - rmin * rmin); } 
        private:
            double rmin = 0.0;
            double rmax = 100.0;
        };

        class LightSrcGauss : public LightSrc
        {
        public:
            void binWriteItem(std::ofstream& os);
            void binReadItem(std::ifstream& is);
            int next(GOAT::raytracing::RayBase* ray);
            int next(Ray_pow& S);
            int next(IRay& S);
            int next(tubedRay& S);
            // void initElectricFieldGauss(GOAT::maths::Vector<double> &P, GOAT::maths::Vector<double> &k, GOAT::maths::Vector<std::complex<double> > &E); ///< Initialisierung eines Teilstrahls
            LightSrcGauss(void);
            LightSrcGauss(const LightSrcGauss&);
            LightSrcGauss(maths::Vector<double> Pos, int N, double wvl, double w0, maths::Vector<double> focuspos, double D = 1.0, maths::Vector<std::complex<double> > Pol = maths::Vector<std::complex<double> >(0.0, 1.0, 0.0), int raytype = LIGHTSRC_RAYTYPE_IRAY, double r0 = 1.0);
            double area() { return D * D; } 
            void setW0(double w0) { this->w0 = w0; calcz0(); reset(); } 
            maths::Vector<double> getFocuspos() { return focuspos; } 
            void setFocuspos(maths::Vector<double> fp) { focuspos = fp; f = abs(Pos - focuspos); reset(); } 
            void setPos(maths::Vector<double> pos) { Pos = pos; f = abs(Pos - focuspos); reset(); } 
 
            void setNA(double na); 
            void setWvl(double wvl); 
            void setk(maths::Vector<double> k);   
            double calcz0() { z0 = M_PI * w0 * w0 / wvl; return z0; } 
            std::complex<double> calcStartPhase(maths::Vector<double> P); 
            void reset()
            {           
                polType = LIGHTSRC_POL_Y; // ???               
                k = focuspos - Pos;
                k = k / abs(k);
                e1 = k % maths::ez;
                if (abs(e1) < 1E-10) e1 = maths::ex;
                e2 = k % e1;
                e1 = e1 / abs(e1);
                e2 = e2 / abs(e2);
 
                i1 = 0;
                i2 = 0;
                f = (Pos - focuspos)*k;
                z0 = M_PI * w0 * w0 / wvl;
                numObjs = 0;
                n0 = 1.0;
                double d = abs(Pos - focuspos);
                calcz0();
                calcw(d);
                double theta = atan(wvl / (M_PI * w0));
                NA = real(n0) * sin(theta);
                calcNormfak();
                zeta = atan(f / z0);
                R = f * (1 + z0 * z0 / (f * f));
                k0 = 2.0 * M_PI / wvl;
                std::cout << "Gauss: k=" << k << std::endl;
            }
 
            double calcw(double z) 
            {
                w = w0 * sqrt(1.0 + z * z / (z0 * z0));
                return w;
            }
 
            
            
            void calcNormfak() 
            {
                double l = abs(Pos - focuspos);
                calcz0();
                calcw(l);
                Normfak = Z0 * sqrt(2.0 / M_PI) / (n0 * l * M_PI) * w / w0 / w0 * exp(-2.0 * l * l / w / w);
                Normfak = Normfak / ((double)N * N) * l * l;
            }
            //protected : 
            double w0;        
            double f;         
            double getNA() { return NA; } 
 
            std::complex<double> Normfak;
            maths::Vector<double> focuspos; 
            double z0;                 
//          maths::Vector<double> k;         ///< direction of the gaussian beam
            double w;               
            double NA;                 
            double zeta;             
            double R;               
        };
 
        
        void binWriteLSList(std::ofstream& os, int nLS, LightSrc** ls);
        void binReadLSList(std::ifstream& is, int nLS, LightSrc**& ls);
        void copyLightSrcList(LightSrc**& d, LightSrc** s, int nLS);
    }
}
#endif