pulsecalculation.h

Go to the documentation of this file.

//#pragma once
 
#include "superarray.h"
#include "fft.h"
#include "raytrace_usp.h"
#include <vector>
#include "superarray.h"
#include "raytrace_field_usp.h"
 
 
 
namespace GOAT
{
    namespace raytracing
    {
 
template <class T>  class pulseCalculation
        {
            public:
                pulseCalculation();
                pulseCalculation(Scene S);
                double findHitTime(int ObjNo); 
                void fieldCalculation(); 
                void fieldCalculation(double omega); 
                void setPulseWidth(double dt); 
                void setSpatialResolution(double dx); 
                void setRefractiveIndexFunctions(std::vector<std::function<std::complex<double>(double) > > nList); 
                void setNumReflex(int numReflex);
                void setSpectralRanges(int n); 
                void setNumWavelengthsPerRange(int nS);
                void setCenterWavelength(double wvl); 
                void setBandwidth(double dWvl); 
                void setRepetitionRate(double rep);
 
                void field(double t); 
                void reset(); 
                void setReferenceTime(double tref);
                Trafo trafo;
                SuperArray<GOAT::maths::Vector<std::complex<double> > > SAres;
                    std::vector<SuperArray<std::vector<gridEntry> > >  SA; 
                    T rt;
 
        
                
 
            // protected:   
                /* In this function the default values (trafoparms) for the calculations are set as follows:
                * dt  : 1E-14s
                * wvl : 1.0µm
                * nI  : 1
                * 
                */
                void setDefaults();              
                void calcTrafoParms();
                // std::vector< std::vector<SuperArray<std::vector<gridEntry> > > > SA;
                double domega; 
                double dWvl=0.02;  
                double dRWvl;      
                INDEX_TYPE  nn;    // number of cells over the whole width of the calculation space (i.e. 2*r0)
                Scene S;
                
                bool raytracingDone = false; 
 
                TrafoParms trafoparms;
                double tref = 0.0; 
                int numReflex = INEL_MAX_NREFLEX;                  
        };
 
// ------- some specializations ------------
                class pulseCalculation_field : public pulseCalculation<Raytrace_field_usp>
                {
                public:                     
                    pulseCalculation_field(Scene& S) : pulseCalculation<Raytrace_field_usp>(S) {}
                    void addBoxDetector(Box* box) { rt.addBoxDetector(box); }; 
                    void field(double t);                  
                };
 
 
                void pulseCalculation_field::field(double t)
                {
                    double omega0 = 2.0 * M_PI * C_LIGHT_MU_FS / trafoparms.wvl;
                    double Domega = 8.0 * 4.0 * M_LN2 / trafoparms.dt;
                    std::cout << "Domega=" << Domega << std::endl;
 
 
                    //          double Domega = 8 * M_PI * C_LIGHT_MU_FS * dWvl / (4.0 * trafoparms.wvl * trafoparms.wvl - dWvl * dWvl);
                    //                        double Domega = 2.0 * M_PI * C_LIGHT_MU_FS dWvl / (trafoparms.wvl * trafoparms.wvl);
                    double domega = Domega / (double)trafoparms.nI;
                    double omegaStart = omega0 - Domega / 2.0;
                    double omega;
                    double wvl1, wvl2;
                    rt = Raytrace_field_usp(S);
                    double wvl;
                    trafo.initResult(S.r0, rt.SE.nges[0], rt.SE.nges[1], rt.SE.nges[2], S.Obj, S.nObj);
                    // loop over the frequency ranges
                    for (int iOmega = 0; iOmega < trafoparms.nI; iOmega++)
                    {
                        omega = omegaStart + (double)iOmega * domega;
                        wvl = 2.0 * M_PI * C_LIGHT_MU_FS / omega; // center wavelength of the current range
 
                        // ------ for output only ------
                        wvl1 = 2.0 * M_PI * C_LIGHT_MU_FS / (omega - 0.5 * domega);
                        wvl2 = 2.0 * M_PI * C_LIGHT_MU_FS / (omega + 0.5 * domega);
                        std::cout << "%  " << iOmega << ":start FFT (" << wvl << "µm)" << "\twvl1=" << wvl1 << "\twvl2=" << wvl2 << "\tomega=" << omega << std::endl << std::flush;
 
                        fieldCalculation(omega); // do the raytracing                           
                        trafo.calc(static_cast<std::vector<SuperArray<std::vector<gridEntry> > > >(rt.SA), omega - domega * 0.5, omega + domega * 0.5, t); // do the Fourier transform
                    }
                }
                
    }
}
 
#include "pulsecalculation.hpp"