prism.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_PRISM_H
#define PLASK__GEOMETRY_PRISM_H
 
#include "../vector/lateral.hpp"
 
#include "leaf.hpp"
 
namespace plask {
 
struct PLASK_API TriangularPrism : public GeometryObjectLeaf<3> {
    typedef GeometryObjectLeaf<3> BaseClass;
 
    typedef typename BaseClass::DVec DVec;
 
    typedef LateralVec<double> Vec2;
 
    typedef typename BaseClass::Box Box;
 
    static const char* NAME;
 
    std::string getTypeName() const override;
 
    explicit TriangularPrism(const Vec2& p0 = Primitive<2>::ZERO_VEC,
                   const Vec2& p1 = Primitive<2>::ZERO_VEC,
                   double height = 0.,
                   const shared_ptr<Material>& material = shared_ptr<Material>());
 
    explicit TriangularPrism(const Vec2& p0,
                   const Vec2& p1,
                   double height,
                   shared_ptr<MaterialsDB::MixedCompositionFactory> materialTopBottom);
 
    // explicit Prism(const DVec& p0, const Vec2& p1, double height,
    //                const std::unique_ptr<MaterialProvider>& materialProvider);
 
    Box3D getBoundingBox() const override;
 
    bool contains(const DVec& p) const override;
 
    shared_ptr<GeometryObject> shallowCopy() const override { return make_shared<TriangularPrism>(*this); }
 
    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;
 
    void writeXMLAttr(XMLWriter::Element& dest_xml_object, const AxisNames& axes) const override;
 
    Vec2 p0, p1;
 
    double height;
 
    void setP0(const Vec2& new_p0) {
        p0 = new_p0;
        this->fireChanged(GeometryObject::Event::EVENT_RESIZE);
    }
 
    void setP1(const Vec2& new_p1) {
        p1 = new_p1;
        this->fireChanged(GeometryObject::Event::EVENT_RESIZE);
    }
 
    void setHeight(double new_height) {
        height = new_height;
        this->fireChanged(GeometryObject::Event::EVENT_RESIZE);
    }
};
 
 
struct PLASK_API Prism : public GeometryObjectLeaf<3> {
  protected:
    double height;
 
    std::vector<LateralVec<double>> vertices;
 
    friend shared_ptr<GeometryObject> read_prism(GeometryReader& reader);
 
  public:
    typedef GeometryObjectLeaf<3> BaseClass;
 
    typedef typename BaseClass::DVec DVec;
 
    typedef typename BaseClass::Box Box;
 
    static const char* NAME;
 
    std::string getTypeName() const override;
 
    Prism() = default;
 
    explicit Prism(double height,
                       const std::vector<LateralVec<double>>& vertices,
                       const shared_ptr<Material>& material = shared_ptr<Material>());
 
    explicit Prism(double height,
                       std::vector<LateralVec<double>>&& vertices,
                       const shared_ptr<Material>&& material = shared_ptr<Material>());
 
    explicit Prism(double height,
                       std::initializer_list<LateralVec<double>> vertices,
                       const shared_ptr<Material>& material = shared_ptr<Material>());
 
    explicit Prism(double height,
                       const std::vector<LateralVec<double>>& vertices,
                       shared_ptr<MaterialsDB::MixedCompositionFactory> materialTopBottom);
 
    explicit Prism(double height,
                       std::vector<LateralVec<double>>&& vertices,
                       shared_ptr<MaterialsDB::MixedCompositionFactory> materialTopBottom);
 
    explicit Prism(double height,
                       std::initializer_list<LateralVec<double>> vertices,
                       shared_ptr<MaterialsDB::MixedCompositionFactory> materialTopBottom);
 
    explicit Prism(const Prism& src) : BaseClass(src), height(src.height), vertices(src.vertices) {}
 
    double getHeight() const { return height; }
 
    void setHeight(double height) {
        this->height = height;
        this->fireChanged(GeometryObject::Event::EVENT_RESIZE);
    }
 
    const std::vector<LateralVec<double>>& getVertices() const { return vertices; }
 
    std::vector<LateralVec<double>>& getVertices() { return vertices; }
 
    void setVertices(const std::vector<LateralVec<double>>& vertices) {
        this->vertices = vertices;
        this->fireChanged(GeometryObject::Event::EVENT_RESIZE);
    }
 
    void setVertices(std::vector<LateralVec<double>>&& vertices) {
        this->vertices = std::move(vertices);
        this->fireChanged(GeometryObject::Event::EVENT_RESIZE);
    }
 
    void setVertex(unsigned index, const LateralVec<double>& vertex) {
        vertices.at(index) = vertex;
        this->fireChanged(GeometryObject::Event::EVENT_RESIZE);
    }
 
    void insertVertex(unsigned index, const LateralVec<double>& vertex) {
        vertices.insert(vertices.begin() + index, vertex);
        this->fireChanged(GeometryObject::Event::EVENT_RESIZE);
    }
 
    void addVertex(const LateralVec<double>& vertex) {
        vertices.push_back(vertex);
        this->fireChanged(GeometryObject::Event::EVENT_RESIZE);
    }
 
    void removeVertex(unsigned index) {
        vertices.erase(vertices.begin() + index);
        this->fireChanged(GeometryObject::Event::EVENT_RESIZE);
    }
 
    void clearVertices() {
        vertices.clear();
        this->fireChanged(GeometryObject::Event::EVENT_RESIZE);
    }
 
    unsigned getVertexCount() const { return vertices.size(); }
 
    const LateralVec<double>& getVertex(unsigned index) const { return vertices.at(index); }
 
    // /// Validate the prism: check if the lines between vertices do not intersect.
    // bool checkSegments() const;
 
    void validate() const override;
 
    Box getBoundingBox() const override;
 
    bool contains(const DVec& p) const override;
 
    shared_ptr<GeometryObject> shallowCopy() const override { return make_shared<Prism>(*this); }
 
    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;
 
    void writeXMLAttr(XMLWriter::Element& dest_xml_object, const AxisNames& axes) const override;
};
 
}  // namespace plask
 
#endif  // PLASK__GEOMETRY_PRISM_H