iray.h

Go to the documentation of this file.

/***************************************************************************
                          iray.h  -  description                              
                             -------------------                                         
    begin                : Fri Oct 15 1999                                           
    copyright            : (C) 1999 by Thomas Weigel                         
    email                : weigel@lat.ruhr-uni-bochum.de                                     
 ***************************************************************************/
 
 
#pragma once
#include <complex>
#include "vector.h"
#include "matrix.h"
#include "plane.h"
#include "objectshape.h"
#include "tubedray.h"
#include "misc.h"
#include "raybase.h"
 
 
 
namespace GOAT
{
    namespace raytracing
    {
 
        class IRay : public RayBase {
        public:
            IRay();
            IRay(const maths::Vector<double>& p,
                const maths::Vector<std::complex<double> >& Pol, const maths::Vector<double>& K,
                std::complex<double>  n0, double r0, double k0,
                const int numObj = 0, std::vector<ObjectShape*> obj = std::vector<ObjectShape*>() );
            IRay(const IRay& r)
            {
                this->E1 = r.E1;
                this->E2 = r.E2;
 
                this->numObj = r.numObj;
                this->Obj = r.Obj;
                this->objIndex = r.objIndex;
                this->inObject = r.inObject;
                this->iR = r.iR;
                this->isValid = r.isValid;
                this->k = r.k;
                this->k0 = r.k0;
                this->KORR = r.KORR;
                this->n = r.n;
                this->OK = r.OK;
                this->P = r.P;
                this->r0 = r.r0;
                this->status = r.status;
                this->suppress_phase_progress = r.suppress_phase_progress;
            }
 
 
            bool next();
 
            maths::Vector<std::complex<double> > getE() { return E1; }
            IRay reflect(maths::Vector<double> n, std::complex<double>  n1, std::complex<double>  n2);
            void refract(maths::Vector<double> N, std::complex<double>  n1, std::complex<double>  n2);
            void setRefract(std::complex<double>  n) { this->n = n; }  
            std::complex<double>  getRefract() { return n; } 
            void setk(const maths::Vector<double>& K) { k = K; } 
            void setP(const maths::Vector<double>& p) { P = p; } 
            void setiR(int i) { iR = i; } 
            // void setGetunnelt (bool v) { getunnelt=v; } 
            maths::Vector<double> getk() { return k; } 
            maths::Vector<double> getP() { return P; } 
            int objectIndex() { return objIndex; } 
            void reflectRay(RayBase*& tray, maths::Vector<double> n, std::complex<double> n1, std::complex<double> n2);
            ObjectShape* getObject(int i) { return Obj[i]; } 
            ~IRay();
            bool isInObject() { return inObject; } 
            bool checkObjectIntersection(int& Index, maths::Vector<double>& Pmin);
            int currentObjectIndex() { return objIndex; } 
            friend std::ostream& operator << (std::ostream& os, IRay S);
            int reflections() { return iR; } 
 
        public:
            maths::Vector<std::complex<double> > Pol1() { return E1 / abs(E1); } 
            maths::Vector<std::complex<double> > Pol2() { return E2 / abs(E2); } 
 
            maths::Matrix<std::complex<double> > Fresnel_reflect(double alpha, std::complex<double>  n1, std::complex<double>  n2); 
            maths::Matrix<std::complex<double> > Fresnel_trans(double alpha, std::complex<double>  beta, std::complex<double>  n1, std::complex<double>  n2); 
            void initElectricField(const Plane& Eb, const maths::Vector<std::complex<double> >& Pol, const int numOfRays = 1); 
            void initElectricField(const maths::Vector<std::complex<double> >& PolS, const maths::Vector<std::complex<double> >& PolP, const int AnzRays); 
            void initElectricField(const Plane& Eb, const maths::Vector<std::complex<double> >& Pol1, const maths::Vector<std::complex<double> >& Pol2, const int AnzRays);
            void initElectricFieldGauss(double sigma2, maths::Vector<double> focuspos, maths::Vector<std::complex<double> > Pol);
            void initElectricFieldGauss(const Plane& Eb,
                const maths::Vector<std::complex<double> >& PolS,
                const maths::Vector<std::complex<double> >& PolP,
                Gauss g); 
 
            void initElectricFieldGauss(maths::Vector<std::complex<double> >& Pol, Gauss g); 
            double cross(const maths::Vector<double> P10, const maths::Vector<double> P11, const maths::Vector<double> P20, const maths::Vector<double> P21);
 
            maths::Vector<double> crossPlane(const maths::Vector<double> Pe, const maths::Vector<double> n); 
            maths::Vector<double> intersectRect(const maths::Vector<double> P, const maths::Vector<double> e1, const maths::Vector<double> e2);
 
 
 
            maths::Vector<double> P; 
            maths::Vector<double> k; 
            maths::Vector<std::complex<double> > E1, E2; 
 
        protected:
            maths::Vector<double> OK;
            double KORR;
            bool isValid;
        };
    }
}