mesh.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__MESH_H
#define PLASK__MESH_H
 
#include <map>
 
#include <plask/config.hpp>
#include "plask/memory.hpp"
 
#include "../vec.hpp"
#include "../geometry/object.hpp"
#include "../utils/iterators.hpp"
#include "../utils/cache.hpp"
#include "../utils/xml.hpp"
 
#include <boost/signals2.hpp>
#include "../utils/event.hpp"
 
namespace plask {
 
struct PLASK_API MeshBase {
    virtual ~MeshBase() {}
};
 
struct PLASK_API Mesh: public Printable, MeshBase {
 
    struct Event: public EventWithSourceAndFlags<Mesh> {
 
        enum Flags {
            EVENT_DELETE = 1,             
            EVENT_RESIZE = 1<<1,          
            EVENT_USER_DEFINED = 1<<2     
        };
 
        bool hasFlag(Flags flag) const { return hasAnyFlag(flag); }
 
        bool isDelete() const { return hasFlag(EVENT_DELETE); }
 
        bool isResize() const { return hasFlag(EVENT_RESIZE); }
 
        explicit Event(Mesh* source, unsigned char flags = 0): EventWithSourceAndFlags<Mesh>(source, flags) {}
    };
 
    boost::signals2::signal<void(Event&)> changed;
 
    template <typename ClassT, typename methodT>
    boost::signals2::connection changedConnectMethod(ClassT* obj, methodT method, boost::signals2::connect_position at = boost::signals2::at_back) {
        return changed.connect(boost::bind(method, obj, _1), at);
    }
 
    template <typename ClassT, typename methodT>
    void changedDisconnectMethod(ClassT* obj, methodT method) {
        changed.disconnect(boost::bind(method, obj, _1));
    }
 
    template<typename EventT = Event, typename ...Args>
    void fireChanged(Args&&... event_constructor_params_without_source) {
        EventT evt(this, std::forward<Args>(event_constructor_params_without_source)...);
        onChange(evt);
        changed(evt);
    }
 
    void fireResized() { fireChanged(Event::EVENT_RESIZE); }
 
    virtual std::size_t size() const = 0;
 
    virtual bool empty() const { return size() == 0; }
 
    virtual void writeXML(XMLElement& object) const;
 
    virtual ~Mesh() { fireChanged(Event::EVENT_DELETE); }
 
  protected:
 
    virtual void onChange(const Event& evt);
 
};
 
template <int dimension>
struct PLASK_API MeshD: public Mesh {
 
    enum { DIM = dimension };
 
    typedef typename Primitive<DIM>::DVec LocalCoords;
 
    virtual LocalCoords at(std::size_t index) const = 0;
 
    LocalCoords operator[](std::size_t index) const { return at(index); }
 
    typedef IndexedIterator< const MeshD<dimension>, LocalCoords > const_iterator;
    typedef const_iterator iterator;
    typedef const_iterator Iterator;
 
    const_iterator begin() const { return const_iterator(this, 0); }
 
    const_iterator end() const { return const_iterator(this, this->size()); }
 
    MeshD(const MeshD& PLASK_UNUSED(to_copy)) {}
 
    MeshD() {}
 
    MeshD& operator=(const MeshD& PLASK_UNUSED(to_copy)) { return *this; }
 
    bool operator==(const MeshD& to_compare) const {
        if (this == &to_compare) return true;
        return hasSameNodes(to_compare);
    }
 
    bool operator!=(const MeshD& to_compare) const { return ! (*this == to_compare); }
 
    void print(std::ostream& out) const override;
 
protected:
 
    virtual bool hasSameNodes(const MeshD<dimension>& to_compare) const;
 
};
 
PLASK_API_EXTERN_TEMPLATE_STRUCT(MeshD<1>)
PLASK_API_EXTERN_TEMPLATE_STRUCT(MeshD<2>)
PLASK_API_EXTERN_TEMPLATE_STRUCT(MeshD<3>)
 
 
class PLASK_API MeshGenerator: public MeshBase {
  public:
 
    typedef EventWithSourceAndFlags<MeshGenerator> Event;
 
    boost::signals2::signal<void(Event&)> changed;
 
    template <typename ClassT, typename methodT>
    void changedConnectMethod(ClassT* obj, methodT method, boost::signals2::connect_position at = boost::signals2::at_back) {
        changed.connect(boost::bind(method, obj, _1), at);
    }
 
    template <typename ClassT, typename methodT>
    void changedDisconnectMethod(ClassT* obj, methodT method) {
        changed.disconnect(boost::bind(method, obj, _1));
    }
 
    template<typename EventT = Event, typename ...Args>
    void fireChanged(Args&&... event_constructor_params_without_source) {
        EventT evt(this, std::forward<Args>(event_constructor_params_without_source)...);
        onChange(evt);
        changed(evt);
    }
 
    virtual ~MeshGenerator() {}
 
  protected:
 
    virtual void onChange(const Event& evt);
 
};
 
template <int MESH_DIM>
class PLASK_API MeshGeneratorD: public MeshGenerator
{
  public:
      typedef MeshD<MESH_DIM> MeshType;
 
      enum { DIM = (MESH_DIM < 2) ? 2 : MESH_DIM };
 
  protected:
    WeakCache<GeometryObject, MeshType, CacheRemoveOnEachChange> cache;
 
    void onChange(const Event&) override { clearCache(); }
 
    template <typename RequiredType>
    static shared_ptr<RequiredType> cast(const shared_ptr<MeshType>& res) {
        auto finall_res = dynamic_pointer_cast<RequiredType>(res);
        if (res && !finall_res) throw Exception("wrong type of generated {0}D mesh.", MESH_DIM);
        return finall_res;
    }
 
  public:
 
    typedef shared_ptr<GeometryObjectD<DIM>> GeometryPtr;
 
    virtual shared_ptr<MeshType> generate(const GeometryPtr& geometry) = 0;
 
    inline void clearCache() {
        cache.clear();
    }
 
    shared_ptr<MeshType> operator()(const GeometryPtr& geometry);
 
    template <typename RequiredType>
    shared_ptr<RequiredType> get(const shared_ptr<GeometryObjectD<DIM>>& geometry) {
        return cast<RequiredType> ( this->operator ()(geometry) );
    }
 
    template <typename RequiredType>
    shared_ptr<RequiredType> generate_t(const shared_ptr<GeometryObjectD<DIM>>& geometry) {
        return cast<RequiredType> ( this->generate(geometry) );
    }
 
};
 
PLASK_API_EXTERN_TEMPLATE_CLASS(MeshGeneratorD<1>)
PLASK_API_EXTERN_TEMPLATE_CLASS(MeshGeneratorD<2>)
PLASK_API_EXTERN_TEMPLATE_CLASS(MeshGeneratorD<3>)
 
 
struct PLASK_API RegisterMeshReader {
    typedef std::function<shared_ptr<Mesh>(XMLReader&)> ReadingFunction;
    RegisterMeshReader(const std::string& tag_name, ReadingFunction fun);
    static std::map<std::string, ReadingFunction>& getReaders();
    static ReadingFunction getReader(const std::string& name);
};
 
struct Manager;
 
struct PLASK_API RegisterMeshGeneratorReader {
    typedef std::function<shared_ptr<MeshGenerator>(XMLReader&, Manager&)> ReadingFunction;
    RegisterMeshGeneratorReader(const std::string& tag_name, ReadingFunction fun);
    static std::map<std::string, ReadingFunction>& getReaders();
    static ReadingFunction getReader(const std::string& name);
};
 
 
} // namespace plask
 
#endif  //PLASK__MESH_H