transfer.hpp

Go to the documentation of this file.

/*
 * This file is part of PLaSK (https://plask.app) by Photonics Group at TUL
 * Copyright (c) 2022 Lodz University of Technology
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 */
#ifndef PLASK__SLAB_TRANSFER_H
#define PLASK__SLAB_TRANSFER_H
 
#include "plask/solver.hpp"
 
#include "matrices.hpp"
 
namespace plask { namespace optical { namespace modal {
 
enum WhichField {
    FIELD_E,  
    FIELD_H   
};
 
enum PropagationDirection {
    PROPAGATION_TOTAL = 0,     
    PROPAGATION_UPWARDS = 1,   
    PROPAGATION_DOWNWARDS = 2  
};
 
using phys::Z0;
 
struct ModalBase;
struct Expansion;
class Diagonalizer;
 
struct PLASK_SOLVER_API Transfer {
    enum IncidentDirection {
        INCIDENCE_TOP,    
        INCIDENCE_BOTTOM  
    };
 
    enum Determined {
        DETERMINED_NOTHING = 0,  
        DETERMINED_RESONANT,     
        DETERMINED_REFLECTED     
    };
 
    enum Method {
        METHOD_AUTO,                   
        METHOD_REFLECTION_ADMITTANCE,  
        METHOD_REFLECTION_IMPEDANCE,   
        METHOD_ADMITTANCE,             
        METHOD_IMPEDANCE,              
    };
 
    enum Determinant {
        DETERMINANT_EIGENVALUE,
        DETERMINANT_FULL
    };
 
  protected:
    cmatrix interface_field_matrix;  
    dcomplex* interface_field;       
 
    cmatrix M;  
 
    cmatrix temp;  
 
    dcomplex* evals;   
    double* rwrk;      
    std::size_t lwrk;  
    dcomplex* wrk;     
 
    cvector incident_vector;            
    IncidentDirection incident_side;    
 
    ModalBase* solver;  
 
  public:
    void initDiagonalization();
 
    std::unique_ptr<Diagonalizer> diagonalizer;
 
    Determined fields_determined;
 
    Transfer(ModalBase* solver, Expansion& expansion);
 
    virtual ~Transfer();
 
    dcomplex determinant();
 
    virtual cvector getReflectionVector(const cvector& incident, IncidentDirection side) = 0;
 
    virtual cvector getTransmissionVector(const cvector& incident, IncidentDirection side) = 0;
 
  protected:
    virtual void getFinalMatrix() = 0;
 
    virtual void determineFields() = 0;
 
    virtual void determineReflectedFields(const cvector& incident, IncidentDirection side) = 0;
 
    virtual cvector getFieldVectorE(double z, std::size_t n, PropagationDirection part = PROPAGATION_TOTAL) = 0;
 
    virtual cvector getFieldVectorH(double z, std::size_t n, PropagationDirection part = PROPAGATION_TOTAL) = 0;
 
    const_cvector getInterfaceVector();
 
    LazyData<Vec<3, dcomplex>> computeFieldE(double power,
                                             const shared_ptr<const Mesh>& dst_mesh,
                                             InterpolationMethod method,
                                             bool reflected,
                                             PropagationDirection part = PROPAGATION_TOTAL);
 
    LazyData<Vec<3, dcomplex>> computeFieldH(double power,
                                             const shared_ptr<const Mesh>& dst_mesh,
                                             InterpolationMethod method,
                                             bool reflected,
                                             PropagationDirection part = PROPAGATION_TOTAL);
 
    LazyData<double> computeFieldMagnitude(double power,
                                           const shared_ptr<const Mesh>& dst_mesh,
                                           InterpolationMethod method,
                                           bool reflected) {
        auto E = computeFieldE(1., dst_mesh, method, reflected);
        power *= 0.5 / Z0;  // because <M> = ½ E conj(E) / Z0
        return LazyData<double>(E.size(), [power, E](size_t i) { return power * abs2(E[i]); });
    }
 
    virtual double integrateField(WhichField field,
                                  size_t n,
                                  double z1,
                                  double z2) = 0;
 
  public:
    LazyData<Vec<3, dcomplex>> getFieldE(double power,
                                         const shared_ptr<const Mesh>& dst_mesh,
                                         InterpolationMethod method,
                                         PropagationDirection part = PROPAGATION_TOTAL) {
        determineFields();
        return computeFieldE(power, dst_mesh, method, false, part);
    }
 
    LazyData<Vec<3, dcomplex>> getFieldH(double power,
                                         const shared_ptr<const Mesh>& dst_mesh,
                                         InterpolationMethod method,
                                         PropagationDirection part = PROPAGATION_TOTAL) {
        determineFields();
        return computeFieldH(power, dst_mesh, method, false, part);
    }
 
    LazyData<double> getFieldMagnitude(double power,
                                       const shared_ptr<const Mesh>& dst_mesh,
                                       InterpolationMethod method) {
        determineFields();
        return computeFieldMagnitude(power, dst_mesh, method, false);
    }
 
    LazyData<Vec<3, dcomplex>> getScatteredFieldE(const cvector& incident,
                                                  IncidentDirection side,
                                                  const shared_ptr<const Mesh>& dst_mesh,
                                                  InterpolationMethod method,
                                                  PropagationDirection part = PROPAGATION_TOTAL) {
        determineReflectedFields(incident, side);
        return computeFieldE(1e3 * Z0, dst_mesh, method, true, part);
    }
 
    LazyData<Vec<3, dcomplex>> getScatteredFieldH(const cvector& incident,
                                                  IncidentDirection side,
                                                  const shared_ptr<const Mesh>& dst_mesh,
                                                  InterpolationMethod method,
                                                  PropagationDirection part = PROPAGATION_TOTAL) {
        determineReflectedFields(incident, side);
        return computeFieldH(1e3 * Z0, dst_mesh, method, true, part);
    }
 
    LazyData<double> getScatteredFieldMagnitude(const cvector& incident,
                                                IncidentDirection side,
                                                const shared_ptr<const Mesh>& dst_mesh,
                                                InterpolationMethod method) {
        determineReflectedFields(incident, side);
        return computeFieldMagnitude(1e3 * Z0, dst_mesh, method, true);
    }
 
    cvector getFieldVectorE(double z, PropagationDirection part = PROPAGATION_TOTAL);
 
    cvector getFieldVectorH(double z, PropagationDirection part = PROPAGATION_TOTAL);
 
    cvector getScatteredFieldVectorE(const cvector& incident,
                                     IncidentDirection side,
                                     double z,
                                     PropagationDirection part = PROPAGATION_TOTAL);
 
    cvector getScatteredFieldVectorH(const cvector& incident,
                                     IncidentDirection side,
                                     double z,
                                     PropagationDirection part = PROPAGATION_TOTAL);
 
    double getFieldIntegral(WhichField field, double z1, double z2, double power);
 
    double getScatteredFieldIntegral(WhichField field,
                                     const cvector& incident,
                                     IncidentDirection side,
                                     double z1,
                                     double z2);
};
 
}}}  // namespace plask::optical::modal
 
#endif  // PLASK__SLAB_TRANSFER_H