/dbfs1/fh22/linux/src/FMMLIB/Grating2D.h

Go to the documentation of this file.

#pragma once

//   Copyright (C) 2007 by Florian Hudelist
//  fh22@.hw.ac.uk
//
//References: 
//===========
// [1] Li, JOSA A, Vol.13, No.5, 1996 - Formulation and comparison of two recursive matrix algorithms for modeling diffraction gratings
// [2] Li, JOSA A, Vol.20, No.4, 2003 - Note on the S-matrix algorithm
// [3] Li, JOSA A, Vol.14, No.10, 1997 - New formulation of the Fourier modal method for crossed surface-relief gratings 
#ifndef GRATING2D_H
#define GRATING2D_H

#include "GratingLayer2D.h"
#include <vector>

using std::complex;
using std::string;
using std::vector;
using TBCI::F_BandMatrix;
using TBCI::Vector;
using TBCI::lu_invert;


class Grating2D{

private:

        bool memorysave;
        // matrices used to calculate the S matrix
        // defined in [2] equations 11, 13, 14
        // R = R_ud, T=T_dd
        // W2 is used for the last boundary as it has to be treated as a homogeneous layer
        // and so the calculation gets much easier and less time consuming
        Matrix< complex<double> > R, T, Q12, Q2, tau, T_tilde, R_tilde, G, W21, W23;
        // number of spatial Fourier orders for each dimension, nOrdsSq=nOrds^2
        // the index goes from -(nOrds-1)/2 -> +(nOrds-1)/2 for x and y
        int nOrds, nOrdsSq;
        int nLayers;
        // pixel sizes in x and y, grating size in x and y (period = nPixels*pixelSize)
        double periodX, periodY;
        // parameters for the incident light
        double lambda;
        double theta;
        double phi;
        double k1;
        double k3;
        // n1= refractive index of halfspace of incident light
        complex<double>  n1;
        // n3= refractive index of halfspace behind the element
        complex<double>  n3;
        
        // spatial frequencies for the transmitted and reflected light
        Vector< complex<double> > alpha_1, alpha_3, beta_1, beta_3, gamma_1, gamma_3;
        
        // I = 0 + 1*i; mu is the permeability (usually=1)
        complex<double> mu;
        // the eigenvalues of the region one and three, needed for calculating the last step
        // of the S-matrix approach

protected:
        // Fourier orders of the incident, transmitted and reflected light
        Vector< complex<double> > incid; // = d_(n+1) 
        Vector< complex<double> > trans; // = d_(0)
        Vector< complex<double> > ref;    // = u_(n+1)
        Matrix< complex<double> > efficiencyR, efficiencyT;
public:
        vector <GratingLayer2D> layer;


        Grating2D(int);
        ~Grating2D();
        const Grating2D &operator=(Grating2D &);
        void setParameters(int, double, double, Vector<double>, double, double, double, complex<double>, complex<double>);
        void setTransPt(Vector<double>, Vector<double>);
        void setTransPt(void);
        void setRefInd(vector< Matrix< complex<double> > >);
        void setIncid(Matrix< complex<double> >, Matrix< complex<double> >);
        Matrix< complex<double> > getIncid(string);
        void solve(void);
        void setSMatrix(void);
        complex<double> getReflection(string, int, int);
        complex<double> getTransmission(string, int, int);
        complex<double> getIncid(string, int, int);
        complex<double> calcTransField(double, double, double, string);
        void calcEfficiencyR(void);
        void calcEfficiencyT(void);     
        void writeField(string, string, string, double , int, int);
        
        void writeParameters(string);
        bool getMemsave(void);
        void setMemsave(bool);
        void minimiseMemory(void);
        // set and get various variables used in the calculations
        // grating size in x/y-direction [my m]
        double getSizeX(void);          void setSizeX(double);
        double getSizeY(void);          void setSizeY(double);
        int getnLayers(void);
        void setnLayers(int);
        double getLambda(void);         void setLambda(double);
        double getTheta(void);          void setTheta(double);
        double getPhi(void);            void setPhi(double);
        complex<double>getN1(void);     void setN1(complex<double>);
        complex<double>getN3(void);     void setN3(complex<double>);
        int getnOrds(void);
        void setnOrds(int);
        complex<double> getR(int, int);
        complex<double> getT(int, int);
        complex<double> getAlphaT(int);
        complex<double> getBetaT(int);
        complex<double> getAlphaR(int);
        complex<double> getBetaR(int);


        void calcAlphaBetaGamma(void);

        void calcBoundaryW(void);
        
        double delta(int, int);
};

#endif

---