rootdigger.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_ROOTDIGGER_H
#define PLASK__OPTICAL_EFFECTIVE_ROOTDIGGER_H
 
#include <functional>
#include <plask/plask.hpp>
 
namespace plask { namespace optical { namespace effective {
 
struct RootDigger {
 
    typedef std::function<dcomplex(dcomplex)> function_type;
 
    enum Method {
        ROOT_MULLER,
        ROOT_BROYDEN,
        ROOT_BRENT,
    };
 
    struct Params {
        Method method;          
        double tolx,            
            tolf_min,           
            tolf_max,           
            maxstep;            
        int maxiter;            
        double alpha,           
            lambda_min;         
        dcomplex initial_dist;  
        int stairs;             
 
        Params():
            method(ROOT_BROYDEN),
            tolx(1e-6),
            tolf_min(1e-7),
            tolf_max(1e-5),
            maxstep(0.1),
            maxiter(500),
            alpha(1e-7),
            lambda_min(1e-8),
            initial_dist(1e-3),
            stairs(3)
            {}
    };
 
  protected:
 
    // Solver
    Solver& solver;
 
    // Solver method computing the value to zero
    function_type val_function;
 
    // Value writelog
    DataLog<dcomplex,dcomplex>& log_value;
 
    inline dcomplex valFunction(dcomplex x) const {
        try {
            return val_function(x);
        } catch (...) {
            log_value.throwError(x);
        }
        return NAN;
    }
 
  public:
 
    // Rootdigger parameters
    Params params;
 
    // Constructor
    RootDigger(Solver& solver, const function_type& val_fun, DataLog<dcomplex,dcomplex>& log_value,
               const Params& pars) :
        solver(solver),
        val_function(val_fun),
        log_value(log_value),
        params(pars)
    {};
 
    virtual ~RootDigger() {}
 
    virtual dcomplex find(dcomplex start) const = 0;
 
    static std::unique_ptr<RootDigger> get(Solver* solver, const function_type& func, DataLog<dcomplex,dcomplex>& detlog, const Params& params);
 
    static void readRootDiggerConfig(XMLReader& reader, Params& params);
};
 
}}} // namespace plask::optical::effective
 
#endif // PLASK__OPTICAL_EFFECTIVE_ROOTDIGGER_H