pulsecalculation.h

Go to the documentation of this file.

#pragma once
 
#include "superarray.h"
#include "fft.h"
#include "raytrace_usp.h"
#include <vector>
 
 
 
 
namespace GOAT
{
    namespace raytracing
    {
        #define PULSECALCULATION_CLEAR_SA         0
        #define PULSECALCULATION_NOT_CLEAR_SA     1  
        constexpr int PULSECALCULATION_NOT_CLEAR_RESULT = 2;  

        class pulseCalculation
        {
            public:
                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 setNumberOfThreads(int n); 
                int getNumberOfThreads(); 
 
                double field(double t, int settings=PULSECALCULATION_CLEAR_SA); 
                void reset(); 
                void setReferenceTime(double tref);
                Trafo trafo;
                SuperArray<GOAT::maths::Vector<std::complex<double> > > SAres;
                    std::vector<SuperArray<std::vector<gridEntry> > >  SA; 
                    Raytrace_usp rt;
 
                double domega; 
                double dWvl=0.02;  
                TrafoParms getTrafoParms() { return trafoparms; }
                double getReferenceTime() { return tref; }
                /*
                 * Returns the number of cells per direction, nn along each axis of the calculation space.
                 * The spatial resolution is then 2*r0/nn. This number is changed by calling #setSpatialResolution
                 */
                INDEX_TYPE getNumCellsPerDirection() { return nn; }
 
            private:    
                int settings=0;
                /* In this function the default values (trafoparms) for the calculations are set as follows:
                * dt  : 1E-14s
                * wvl : 1.0&mu;m
                * nI  : 1
                * 
                */
                void setDefaults();              
                void calcTrafoParms();
                // std::vector< std::vector<SuperArray<std::vector<gridEntry> > > > SA;
 
                double dRWvl;      
                INDEX_TYPE  nn;    
                Scene S;
                
                bool raytracingDone = false; 
 
                TrafoParms trafoparms;
                double tref = 0.0; 
                int numReflex = INEL_MAX_NREFLEX;      
                int fieldCalls = 0; 
                int number_of_threads=5; 
        };
    }
}