meshadapter.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__SOLVER_OPTICAL_MODAL_MESHADAPTER_H
#define PLASK__SOLVER_OPTICAL_MODAL_MESHADAPTER_H
 
#include <boost/iterator/filter_iterator.hpp>
 
#include "plask/mesh/mesh.hpp"
 
#include "matrices.hpp"
 
namespace plask { namespace optical { namespace modal {
 
 
struct PLASK_SOLVER_API LevelsAdapter
{
    struct Level {
        virtual size_t index(size_t i) const = 0;
 
        virtual double vpos() const = 0;
 
        virtual size_t size() const = 0;
 
        virtual shared_ptr<const Mesh> mesh() const = 0;
    };
 
    virtual ~LevelsAdapter() {}
 
    virtual shared_ptr<Level> yield() = 0;
};
 
 
template <int dim>
struct PLASK_SOLVER_API LevelsAdapterGeneric: public LevelsAdapter
{
    struct GenericLevel;
 
    struct Mesh: public MeshD<dim> {
      protected:
        const GenericLevel* level;
      public:
        Mesh(const GenericLevel* level): level(level) {}
        // Overrides
        std::size_t size() const override { return level->matching.size(); }
        plask::Vec<dim> at(std::size_t i) const override { return (*level->src)[level->matching[i]]; }
    };
 
    struct GenericLevel: public LevelsAdapter::Level {
      protected:
        std::vector<size_t> matching;       
        shared_ptr<const MeshD<dim>> src;   
        double vert;                        
        friend struct LevelsAdapterGeneric<dim>::Mesh;
      public:
        GenericLevel(shared_ptr<const MeshD<dim>> src, double level): src(src), vert(level) {
            for (auto it = src->begin(); it != src->end(); ++it) {
                if ((*it)[dim-1] == level) matching.push_back(it.index);
            }
        }
        // Overrides
        size_t index(size_t i) const override;
        double vpos() const override;
        std::size_t size() const override { return matching.size(); }
        shared_ptr<const plask::Mesh> mesh() const override { return plask::make_shared<const Mesh>(this); }
    };
 
    shared_ptr<const MeshD<dim>> src;
 
    std::set<double> levels;
 
    std::set<double>::iterator iter;
 
    LevelsAdapterGeneric(shared_ptr<const MeshD<dim>> src): src(src) {
        for (auto point: *src) {
            levels.insert(point[dim-1]);
        }
        iter = levels.begin();
    }
 
    shared_ptr<typename LevelsAdapter::Level> yield() override {
        if (iter == levels.end()) return shared_ptr<typename LevelsAdapter::Level>();
        return plask::make_shared<GenericLevel>(src, *(iter++));
    }
};
 
template <int dim>
struct PLASK_SOLVER_API LevelsAdapterRectangular: public LevelsAdapter
{
    struct RectangularLevel;
 
    struct Mesh: public MeshD<dim> {
      protected:
        const RectangularLevel* level;
      public:
        Mesh(const RectangularLevel* level): level(level) {}
        // Overrides
        std::size_t size() const override;
        plask::Vec<dim> at(std::size_t i) const override;
    };
 
    struct RectangularLevel: public LevelsAdapter::Level {
      protected:
        shared_ptr<const RectangularMesh<dim>> src; 
        size_t vert;                        
        friend struct LevelsAdapterRectangular<dim>::Mesh;
      public:
        RectangularLevel(shared_ptr<const RectangularMesh<dim>> src, size_t vert): src(src), vert(vert) {}
        // Overrides
        size_t index(size_t i) const override;
        double vpos() const override;
        std::size_t size() const override;
        shared_ptr<const plask::Mesh> mesh() const override { return plask::make_shared<const Mesh>(this); }
    };
 
    shared_ptr<const RectangularMesh<dim>> src;
 
    size_t idx;
 
    LevelsAdapterRectangular(shared_ptr<const RectangularMesh<dim>> src): src(src), idx(0) {}
 
    shared_ptr<typename LevelsAdapter::Level> yield() override;
};
 
 
std::unique_ptr<LevelsAdapter> PLASK_SOLVER_API makeLevelsAdapter(const shared_ptr<const Mesh>& src);
 
 
}}} // namespace plask::optical::modal
 
#endif // PLASK__SOLVER_OPTICAL_MODAL_MESHADAPTER_H