bisection.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__OPTICAL_EFFECTIVE_BISECTION_H
#define PLASK__OPTICAL_EFFECTIVE_BISECTION_H
 
#include <plask/plask.hpp>
 
namespace plask { namespace optical { namespace effective {
 
struct Contour {
 
    const Solver* solver;           
 
    const std::function<dcomplex(dcomplex)>& fun; 
 
    double re0,                     
           im0,                     
           re1,                     
           im1;                     
 
    DataVector<dcomplex> bottom,    
                         right,     
                         top,       
                         left;      
 
    Contour(const Solver* solver, const std::function<dcomplex(dcomplex)>& fun): solver(solver), fun(fun) {};
 
    Contour(const Contour& src): solver(src.solver), fun(src.fun), re0(src.re0), im0(src.im0), re1(src.re1), im1(src.im1),
                                 bottom(src.bottom), right(src.right), top(src.top), left(src.left) {}
 
    Contour(Contour&& src): solver(src.solver), fun(src.fun), re0(src.re0), im0(src.im0), re1(src.re1), im1(src.im1),
                            bottom(std::move(src.bottom)), right(std::move(src.right)), top(std::move(src.top)), left(std::move(src.left)) {}
 
    Contour(const Solver* solver, const std::function<dcomplex(dcomplex)>& fun, dcomplex corner0, dcomplex corner1, size_t ren, size_t imn);
 
    int winding() const {
        return   crossings(bottom, re0,im0, re1,im0)
               + crossings(right,  re1,im0, re1,im1)
               - crossings(top,    re1,im1, re0,im1)
               - crossings(left,   re0,im1, re0,im0);
    }
 
    std::pair<Contour,Contour> divide(double reps, double ieps) const;
 
  private:
 
    int crossings(const DataVector<dcomplex>& line, double r0, double i0, double r1, double i1) const;
 
};
 
std::vector<std::pair<dcomplex,dcomplex>> findZeros(const Solver* solver, const std::function<dcomplex(dcomplex)>& fun,
                                                    dcomplex corner0, dcomplex corner1, size_t resteps, size_t imsteps, dcomplex eps);
 
}}} // namespace plask::optical::effective
 
#endif // PLASK__OPTICAL_EFFECTIVE_BISECTION_H