lattice.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_LATTICE_H
#define PLASK__GEOMETRY_LATTICE_H
 
#include <cmath>
 
#include "../log/log.hpp"
#include "transform.hpp"
 
#include "translation_container.hpp"  // used by lattiece
 
namespace plask {
 
template <int dim> struct PLASK_API ArrangeContainer : public GeometryObjectTransform<dim> {
    typedef GeometryObjectTransform<dim> BaseClass;
 
    typedef typename BaseClass::DVec DVec;
 
    typedef typename BaseClass::Box Box;
 
    typedef typename BaseClass::ChildType ChildType;
 
    using BaseClass::getChild;
 
  protected:
    using BaseClass::_child;
 
    DVec translation;
 
    unsigned repeat_count;
 
    std::pair<int, int> bounds(const DVec& vec) const;
 
    void warmOverlaping() const;
 
  public:
    bool warn_overlapping;
 
    ArrangeContainer()
        : GeometryObjectTransform<dim>(shared_ptr<ChildType>()),
          translation(Primitive<dim>::ZERO_VEC),
          repeat_count(0),
          warn_overlapping(true) {}
 
    ArrangeContainer(const shared_ptr<ChildType>& child, const DVec& step, unsigned repeat, bool warn = true)
        : GeometryObjectTransform<dim>(child), translation(step), repeat_count(repeat), warn_overlapping(warn) {
        warmOverlaping();
    }
 
    static const char* NAME;
 
    std::string getTypeName() const override { return NAME; }
 
    Box getBoundingBox() const override;
 
    Box getRealBoundingBox() 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* path = 0) const override;
 
    bool contains(const DVec& p) const override;
 
    shared_ptr<Material> getMaterial(const DVec& p) const override;
 
    std::size_t getChildrenCount() const override;
 
    shared_ptr<GeometryObject> getChildNo(std::size_t child_no) const override;
 
    std::size_t getRealChildrenCount() const override;
 
    shared_ptr<GeometryObject> getRealChildNo(std::size_t child_no) const override;
 
    GeometryObject::Subtree getPathsAt(const DVec& point, bool all = false) const override;
 
    shared_ptr<GeometryObject> shallowCopy() const override;
 
    Box fromChildCoords(const typename ChildType::Box& child_bbox) const override;
 
    unsigned getRepeatCount() const { return repeat_count; }
 
    void setRepeatCount(unsigned new_repeat_count) {
        if (repeat_count == new_repeat_count) return;
        repeat_count = new_repeat_count;
        this->fireChildrenChanged();
    }
 
    DVec getTranslation() const { return translation; }
 
    void setTranslation(DVec new_translation) {
        if (translation == new_translation) return;
        translation = new_translation;
        warmOverlaping();
        this->fireChildrenChanged();
    }
 
    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;
 
    void writeXMLAttr(XMLWriter::Element& dest_xml_object, const AxisNames& axes) const override;
};
 
template <> void ArrangeContainer<2>::writeXMLAttr(XMLWriter::Element& dest_xml_object, const AxisNames& axes) const;
template <> void ArrangeContainer<3>::writeXMLAttr(XMLWriter::Element& dest_xml_object, const AxisNames& axes) const;
 
PLASK_API_EXTERN_TEMPLATE_STRUCT(ArrangeContainer<2>)
PLASK_API_EXTERN_TEMPLATE_STRUCT(ArrangeContainer<3>)
 
 
struct PLASK_API Lattice : public GeometryObjectTransform<3> {
    typedef typename GeometryObjectTransform<3>::DVec DVec;
 
    typedef typename GeometryObjectTransform<3>::Box Box;
 
    typedef typename GeometryObjectTransform<3>::ChildType ChildType;
 
    using GeometryObjectTransform<3>::getChild;
 
    static const char* NAME;
 
    DVec vec0, vec1;
 
    shared_ptr<TranslationContainer<3>> container;
 
    std::vector<std::vector<Vec<2, int>>> segments;  // TODO checking somewhere if sides do not cross each other
 
    std::string getTypeName() const override { return NAME; }
 
    Lattice(const shared_ptr<ChildType>& child = shared_ptr<ChildType>(),
            const DVec& vec0 = Primitive<3>::ZERO_VEC,
            const DVec& vec1 = Primitive<3>::ZERO_VEC)
        : GeometryObjectTransform<3>(child),
          vec0(vec0),
          vec1(vec1),
          container(plask::make_shared<TranslationContainer<3>>()) {}
 
    shared_ptr<Material> getMaterial(const DVec& p) const override { return container->getMaterial(p); }
 
    bool contains(const DVec& p) const override { return container->contains(p); }
 
    // some methods must be overwrite to invalidate cache:
    void onChildChanged(const GeometryObject::Event& evt) override {
        // if (evt.isResize()) invalidateCache();
        container->onChildChanged(evt);  // force early cache rebuilding
        GeometryObjectTransform<3>::onChildChanged(evt);
    }
 
    /*void rebuildCache() {
        //TODO
    }*/
 
    void writeXMLAttr(XMLWriter::Element& dest_xml_object, const AxisNames& axes) const override;
 
    void writeXMLChildren(XMLWriter::Element& dest_xml_object,
                          WriteXMLCallback& write_cb,
                          const AxisNames& axes) const override;
 
    Box getBoundingBox() const override { return container->getBoundingBox(); }
 
    Box getRealBoundingBox() const override { return container->getRealBoundingBox(); }
 
    // using GeometryObjectTransform<3>::getPathsTo;
 
    // Box fromChildCoords(const typename ChildType::Box& child_bbox) 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* path = 0) const override;
 
    GeometryObject::Subtree getPathsTo(const GeometryObject& el, const PathHints* path = 0) const override;
 
    // GeometryObject::Subtree getPathsAt(const DVec& point, bool all=false) const override;
 
    GeometryObject::Subtree getPathsAt(const DVec& point, bool all = false) const override {
        return container->ensureHasCache()->getPathsAt(this->shared_from_this(), point, all);
    }
 
    std::size_t getChildrenCount() const override { return container->getChildrenCount(); }
 
    shared_ptr<GeometryObject> getChildNo(std::size_t child_no) const override {
        return container->getChildNo(child_no);
    }
 
    std::size_t getRealChildrenCount() const override { return GeometryObjectTransform<3>::getRealChildrenCount(); }
 
    shared_ptr<GeometryObject> getRealChildNo(std::size_t child_no) const override {
        return GeometryObjectTransform<3>::getRealChildNo(child_no);
    }
 
    shared_ptr<Lattice> copyShallow() const {
        auto result = plask::make_shared<Lattice>(*this);
        result->container = plask::make_shared<TranslationContainer<3>>(*result->container);
        return result;
    }
 
    shared_ptr<GeometryObject> shallowCopy() const override { return copyShallow(); }
 
    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<3>::LineSegment>& segments,
                              unsigned max_steps,
                              double min_step_size) const override;
 
    // probably unused
    Box fromChildCoords(const typename ChildType::Box& child_bbox) const override { return child_bbox; }
 
    void setSegments(std::vector<std::vector<Vec<2, int>>> new_segments);
 
    // protected:
 
    void refillContainer();
};
 
}  // namespace plask
 
#endif  // PLASK__GEOMETRY_LATTICE_H