separator.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__GEOMETRY_SEPARATOR_H
#define PLASK__GEOMETRY_SEPARATOR_H
 
#include "object.hpp"
 
namespace plask {
 
template <int dim> struct PLASK_API GeometryObjectSeparator : public GeometryObjectD<dim> {
    typedef typename GeometryObjectD<dim>::DVec DVec;
    typedef typename GeometryObjectD<dim>::Box Box;
    using GeometryObjectD<dim>::getBoundingBox;
    using GeometryObjectD<dim>::shared_from_this;
 
    GeometryObject::Type getType() const override;
 
    static const char* NAME;
 
    std::string getTypeName() const override;
 
    shared_ptr<Material> getMaterial(const DVec& p) const override;
 
    // void getLeafsInfoToVec(std::vector<std::tuple<shared_ptr<const GeometryObject>, Box, DVec>>& dest, const
    // PathHints* path = 0) const override;
 
    void getBoundingBoxesToVec(const GeometryObject::Predicate& predicate,
                               std::vector<Box>& dest,
                               const PathHints* path = 0) const override;
 
    void getObjectsToVec(const GeometryObject::Predicate& predicate,
                         std::vector<shared_ptr<const GeometryObject>>& dest,
                         const PathHints* path = 0) const override;
 
    void getPositionsToVec(const GeometryObject::Predicate& predicate,
                           std::vector<DVec>& dest,
                           const PathHints* = 0) const override;
 
    /*    inline void getLeafsToVec(std::vector< shared_ptr<const GeometryObject> >& dest) const override {
            dest.push_back(this->shared_from_this());
        }
 
        inline std::vector< shared_ptr<const GeometryObject> > getLeafs() const override {
            return { this->shared_from_this() };
        }*/
 
    bool hasInSubtree(const GeometryObject& el) const override;
 
    GeometryObject::Subtree getPathsTo(const GeometryObject& el, const PathHints* path = 0) const override;
 
    GeometryObject::Subtree getPathsAt(const DVec& point, bool = false) const override;
 
    std::size_t getChildrenCount() const override { return 0; }
 
    shared_ptr<GeometryObject> getChildNo(std::size_t child_no) const override;
 
    shared_ptr<const GeometryObject> changedVersion(const GeometryObject::Changer& changer,
                                                    Vec<3, double>* translation = 0) const override;
 
    // void extractToVec(const GeometryObject::Predicate& predicate, std::vector< shared_ptr<const GeometryObjectD<dim>
    // > >& dest, const PathHints* = 0) const {
    //     if (predicate(*this)) dest.push_back(static_pointer_cast< const GeometryObjectD<dim>
    //     >(this->shared_from_this()));
    // }
 
    shared_ptr<GeometryObject> deepCopy(
        std::map<const GeometryObject*, shared_ptr<GeometryObject>>& copied) const override;
 
    bool contains(const DVec& p) const override;
 
    void addPointsAlongToSet(std::set<double>& points,
                             Primitive<3>::Direction direction,
                             unsigned max_steps,
                             double min_step_size) const override {}
 
    void addLineSegmentsToSet(std::set<typename GeometryObjectD<dim>::LineSegment>& segments,
                              unsigned max_steps,
                              double min_step_size) const override {}
 
    /*bool intersects(const Box& area) const override {
        return this->getBoundingBox().intersects(area); //TODO ?? maybe set area to empty
    }*/
};
 
PLASK_API_EXTERN_TEMPLATE_STRUCT(GeometryObjectSeparator<2>)
PLASK_API_EXTERN_TEMPLATE_STRUCT(GeometryObjectSeparator<3>)
 
 
template <int dim, int direction> struct Gap1D : public GeometryObjectSeparator<dim> {
    static_assert(direction < dim, "direction must be from 0 to dim-1");
 
    typedef GeometryObjectSeparator<dim> BaseClass;
 
    typedef typename BaseClass::DVec DVec;
    typedef typename BaseClass::Box Box;
 
    static constexpr const char* NAME = "gap";            
    static constexpr const char* XML_SIZE_ATTR = "size";  
 
    std::string getTypeName() const override { return NAME; }
 
    double size;
 
    Gap1D(double size = 0.0) : size(size) {}
 
    Box getBoundingBox() const override {
        auto size_vec = Primitive<dim>::ZERO_VEC;
        size_vec[direction] = size;
        return Box(Primitive<dim>::ZERO_VEC, size_vec);
    }
 
    void setSize(double new_size) {
        size = new_size;
        this->fireChanged(GeometryObject::Event::EVENT_RESIZE);
    }
 
    void writeXMLAttr(XMLWriter::Element& dest_xml_object, const AxisNames& axes) const override {
        BaseClass::writeXMLAttr(dest_xml_object, axes);
        dest_xml_object.attr(XML_SIZE_ATTR, size);
    }
 
    shared_ptr<GeometryObject> shallowCopy() const override { return make_shared<Gap1D>(size); }
};
 
}  // namespace plask
 
#endif  // PLASK__GEOMETRY_SEPARATOR_H