boundary_conditions.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__BOUNDARY_CONDITIONS_H
#define PLASK__BOUNDARY_CONDITIONS_H
 
#include <list>
#include "../exceptions.hpp"
#include "boundary.hpp"
 
namespace plask {
 
template <typename BoundaryT, typename ValueT>
struct BoundaryCondition {
    typedef BoundaryT Boundary;   
    typedef typename Boundary::MeshType MeshType;    
    typedef ValueT ValueType;  
 
    Boundary place;     
    ValueType value;    
 
    template <typename... ConditionArgumentsTypes>
    BoundaryCondition(const Boundary& place, ConditionArgumentsTypes&&... value_args)
        : place(place),
          value(std::forward<ConditionArgumentsTypes>(value_args)...) {}
 
    template <typename... ConditionArgumentsTypes>
    BoundaryCondition(Boundary&& place, ConditionArgumentsTypes&&... value_args)
        : place(std::forward<Boundary>(place)),
          value(std::forward<ConditionArgumentsTypes>(value_args)...) {}
};
 
 
template <typename BoundaryT, typename ValueT>
struct BoundaryConditionWithMesh {
    typedef BoundaryT Boundary;   
    typedef typename Boundary::MeshType MeshType;    
    typedef ValueT ValueType;  
 
    BoundaryNodeSet place;     
    ValueType value;           
 
    template <typename... ConditionArgumentsTypes>
    BoundaryConditionWithMesh(const BoundaryNodeSet& place, ConditionArgumentsTypes&&... value_args)
        : place(place),
          value(std::forward<ConditionArgumentsTypes>(value_args)...) {}
 
    template <typename... ConditionArgumentsTypes>
    BoundaryConditionWithMesh(BoundaryNodeSet&& place, ConditionArgumentsTypes&&... value_args)
        : place(std::move(place)),
          value(std::forward<ConditionArgumentsTypes>(value_args)...) {}
};
 
template <typename BoundaryT, typename ValueT> struct BoundaryConditions;
 
template <typename BoundaryT, typename ValueT>
struct BoundaryConditionsWithMesh
{
    typedef BoundaryT Boundary;
    typedef typename Boundary::MeshType MeshType;    
    typedef ValueT ValueType;  
 
    typedef BoundaryConditionWithMesh<Boundary, ValueType> Element;
 
private:
    typedef std::vector<Element> elements_container_t;
    elements_container_t container;
    friend struct BoundaryConditions<BoundaryT,ValueType>;
 
public:
    typedef typename elements_container_t::iterator iterator;
    typedef typename elements_container_t::const_iterator const_iterator;
 
    iterator begin() { return container.begin(); }
    const_iterator begin() const { return container.begin(); }
 
    iterator end() { return container.end(); }
    const_iterator end() const { return container.end(); }
 
    template <typename... ArgsTypes>
    BoundaryConditionsWithMesh(ArgsTypes&&... args): container(std::forward<ArgsTypes>(args)...) {}
 
    Element& operator[](std::size_t index) {
        return container[index];
    }
 
    const Element& operator[](std::size_t index) const {
        return container[index];
    }
 
    std::size_t size() const {
        return container.size();
    }
 
    bool empty() const {
        return container.empty();
    }
 
    const_iterator find(std::size_t mesh_index) const {
        auto i = begin();
        while (i != end() && !i->place.contains(mesh_index)) ++i;
        return i;
    }
 
    plask::optional<ValueType> getValue(std::size_t mesh_index) const {
        for (auto i: container)
            if (i.place.contains(mesh_index)) return plask::optional<ValueType>(i.value);
        return plask::optional<ValueType>();
    }
};
 
 
template <typename BoundaryT, typename ValueT>
struct BoundaryConditions
{
    typedef BoundaryT Boundary;   
    typedef typename Boundary::MeshType MeshType;    
    typedef ValueT ValueType;  
 
    typedef BoundaryCondition<Boundary, ValueType> Element;
 
private:
    typedef std::list<Element> elements_container_t;    // std::list does not invalidate iterators on add/erase
    elements_container_t container;
 
public:
    typedef typename elements_container_t::iterator iterator;
    typedef typename elements_container_t::const_iterator const_iterator;
 
    iterator begin() { return container.begin(); }
    const_iterator begin() const { return container.begin(); }
 
    iterator end() { return container.end(); }
    const_iterator end() const { return container.end(); }
 
private:
    iterator lastIterator() { return --end(); }
 
public:
 
    template <typename... ArgsTypes>
    BoundaryConditions(ArgsTypes&&... args): container(std::forward<ArgsTypes>(args)...) {}
 
    iterator getIteratorForIndex(std::size_t index) {
        iterator result = begin();
        while (index > 0 && result != end()) { ++result; --index; }
        return result;
    }
 
    const_iterator getIteratorForIndex(std::size_t index) const {
        const_iterator result = begin();
        while (index > 0 && result != end()) { ++result; --index; }
        return result;
    }
 
    Element& operator[](std::size_t index) {
        iterator i = getIteratorForIndex(index);
        if (i == end()) OutOfBoundsException("BoundaryConditions[]", "index");
        return *i;
    }
 
    const Element& operator[](std::size_t index) const {
        const_iterator i = getIteratorForIndex(index);
        if (i == end()) OutOfBoundsException("BoundaryConditions::at", "index");
        return *i;
    }
 
    iterator add(Element&& element) {
        container.push_back(std::forward<Element>(element));
        return lastIterator();
    }
 
    template <typename... ConditionArgumentsTypes>
    iterator add(Boundary&& place, ConditionArgumentsTypes&&... value_args) {
        container.emplace_back(std::forward<Boundary>(place), std::forward<ConditionArgumentsTypes>(value_args)...);
        return lastIterator();
    }
 
    iterator insert(std::size_t index, Element&& element) {
        iterator i = getIteratorForIndex(index);
        container.insert(i, std::forward<Element>(element));
        return lastIterator();
    }
 
    template <typename... ConditionArgumentsTypes>
    iterator insert(std::size_t index, Boundary&& place, ConditionArgumentsTypes&&... value_args) {
        iterator i = getIteratorForIndex(index);
        container.emplace(i, std::forward<Boundary>(place), std::forward<ConditionArgumentsTypes>(value_args)...);
        return lastIterator();
    }
 
    void clear() {
        container.clear();
    }
 
    void erase(iterator to_erase) {
        container.erase(to_erase);
    }
 
    void erase(iterator first, iterator last) {
        container.erase(first, last);
    }
 
    void erase(std::size_t index) {
        iterator i = getIteratorForIndex(index);
        if (i == end()) OutOfBoundsException("BoundaryConditions[]", "index");
        erase(i);
    }
 
    std::size_t size() const {
        return container.size();
    }
 
    bool empty() const {
        return container.empty();
    }
 
    BoundaryConditionsWithMesh<Boundary,ValueType> get(const typename Boundary::MeshType& mesh,
                                                       const shared_ptr<const GeometryD<MeshType::DIM>>& geometry) const {
        BoundaryConditionsWithMesh<Boundary,ValueType> impl;
        impl.container.reserve(container.size());
        for (auto& el: container) {
            auto place = el.place(mesh, geometry);
            if (place.empty())
                writelog(LOG_WARNING, "Boundary condition with value {} contains no points for given mesh", el.value);
            impl.container.push_back(
                BoundaryConditionWithMesh<Boundary,ValueType>(place, el.value)
            );
        }
        return impl;
    }
 
    BoundaryConditionsWithMesh<Boundary,ValueType> get(const shared_ptr<const typename Boundary::MeshType>& mesh,
                                                       const shared_ptr<const GeometryD<MeshType::DIM>>& geometry) const {
        return get(*mesh, geometry);
    }
 
    BoundaryConditionsWithMesh<Boundary,ValueType> operator()(const MeshType& mesh,
                                                              const shared_ptr<const GeometryD<MeshType::DIM>>& geometry) const {
        return get(mesh, geometry);
    }
 
    BoundaryConditionsWithMesh<Boundary,ValueType> operator()(const shared_ptr<const MeshType>& mesh,
                                                              const shared_ptr<const GeometryD<MeshType::DIM>>& geometry) const {
        return get(*mesh, geometry);
    }
 
};
 
}   // namespace plask
 
#endif // PLASK__BOUNDARY_CONDITIONS_H