manager.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.
 */
#include "solver.hpp"
 
#ifndef PLASK__GEOMETRY_MANAGER_H
#define PLASK__GEOMETRY_MANAGER_H
 
#include <string>
#include <map>
#include <set>
#include <deque>
#include <boost/filesystem.hpp>
 
#include "utils/xml/reader.hpp"
 
#include "math.hpp"
#include "mesh/mesh.hpp"
#include "material/db.hpp"
#include "geometry/path.hpp"
#include "geometry/space.hpp"
 
namespace plask {
 
class Solver;
 
class GeometryReader;
 
struct PLASK_API Manager {
 
    template <typename T>
    struct Map: std::map<std::string, T> {
        typename std::map<std::string, T>::iterator find(const std::string& key) {
            std::string name = key;
            std::replace(name.begin(), name.end(), '-', '_');
            return std::map<std::string, T>::find(name);
        }
 
        typename std::map<std::string, T>::const_iterator find(const std::string& key) const {
            std::string name = key;
            std::replace(name.begin(), name.end(), '-', '_');
            return std::map<std::string, T>::find(name);
        }
    };
 
    static void disallowExternalSources(Manager& PLASK_UNUSED(manager), const std::string& url, const std::string& section) {
        throw Exception("can't load section \"{0}\" from \"{1}\". Loading from external sources is not supported or disallowed.", section, url); }
 
    struct PLASK_API ExternalSourcesFromFile {
 
        boost::filesystem::path originalFileName;
 
        std::string currentSection;
 
        ExternalSourcesFromFile* prev;
 
        bool hasCircularRef(boost::filesystem::path& fileName, const std::string& section) {
            if (!currentSection.empty() || currentSection != section) return false;
            if (fileName == originalFileName) return true;
            return prev != 0 && prev->hasCircularRef(fileName, section);
        }
 
        ExternalSourcesFromFile(): prev(nullptr) {}
 
        ExternalSourcesFromFile(const boost::filesystem::path& originalFileName,
                                const std::string& currentSection = std::string(),
                                ExternalSourcesFromFile* prev = nullptr)
            : originalFileName(originalFileName), currentSection(currentSection), prev(prev) {}
 
        void operator()(Manager& manager, const std::string& url, const std::string& section);
 
    };
 
private:
 
    std::map<std::string, std::map<std::string, std::string>> global_solver_names;
 
    static bool acceptAllSections(const std::string&) { return true; }
 
    /*struct LoadFunCallbackT {
        std::pair< XMLReader, std::unique_ptr<LoadFunCallbackT> > get(const std::string& url) const {
            throw Exception("can't load section from \"{0}\". Loading from external sources is not supported or disallowed.", url);
        }
    };*/
 
    typedef std::function<void(Manager&, const std::string&, const std::string&)> LoadFunCallbackT;
 
    bool tryLoadFromExternal(XMLReader& reader, const LoadFunCallbackT& load_from);
 
  protected:
 
    virtual shared_ptr<Solver> loadSolver(const std::string& category, const std::string& lib, const std::string& solver_name, const std::string& name);
 
 
    void loadMaterialLib(XMLReader& reader);
 
    virtual void loadMaterial(XMLReader& reader);
 
  public:
 
    static constexpr const char* TAG_NAME_ROOT = "plask";           
    static constexpr const char* TAG_NAME_DEFINES = "defines";      
    static constexpr const char* TAG_NAME_MATERIALS = "materials";  
    static constexpr const char* TAG_NAME_GEOMETRY = "geometry";    
    static constexpr const char* TAG_NAME_GRIDS = "grids";          
    static constexpr const char* TAG_NAME_SOLVERS = "solvers";      
    static constexpr const char* TAG_NAME_CONNECTS = "connects";    
    static constexpr const char* TAG_NAME_SCRIPT = "script";        
 
    static constexpr const char* XML_AXES_ATTR = "axes";            
 
    Map<PathHints> pathHints;
 
    std::vector<shared_ptr<Geometry>> roots;
 
    Map<shared_ptr<GeometryObject>> geometrics;
 
    Map<shared_ptr<MeshBase>> meshes;
 
    Map<shared_ptr<Solver>> solvers;
 
    //TODO? move to special modules reader class to have more local scope?
    Map<boost::any> boundaries;
 
    std::string script;
 
    unsigned scriptline;
 
    const AxisNames* axisNames;
 
    bool draft;
 
    std::deque<std::pair<int,std::string>> errors;
 
    void pushError(const std::string& mesg, int line=-1) {
        errors.push_back(std::make_pair(line, mesg));
    }
 
    void pushError(const std::runtime_error& error, int line=-1) {
        pushError(error.what(), line);
    }
 
    void pushError(const XMLException& error, int line=-1) {
        if (line == -1) line = error.line;
        pushError(error.what(), line);
    }
 
    template <typename ErrorType>
    void throwErrorIfNotDraft(ErrorType error, int line=-1) {
        if (!draft) throw error;
        else pushError(error, line);
    }
 
    std::string getAxisName(std::size_t axis_index) { return axisNames->operator [](axis_index); }
 
    std::string getAxisLongName() { return getAxisName(axis::lon_index); }
 
    std::string getAxisTranName() { return getAxisName(axis::tran_index); }
 
    std::string getAxisVertName() { return getAxisName(axis::up_index); }
 
    class PLASK_API SetAxisNames {
        Manager& manager;
        const AxisNames* old;
 
      public:
 
        SetAxisNames(Manager& manager, const AxisNames* names);
 
        SetAxisNames(Manager& manager, XMLReader& source);
 
        SetAxisNames(GeometryReader& reader);
 
        ~SetAxisNames() { manager.axisNames = old; }
    };
 
    explicit Manager(bool draft = false): scriptline(0), axisNames(&AxisNames::axisNamesRegister.get("long, tran, vert")), draft(draft) {}
 
    virtual ~Manager() {}
 
    PathHints* getPathHints(const std::string& path_hints_name);
 
    const PathHints* getPathHints(const std::string& path_hints_name) const;
 
    PathHints& requirePathHints(const std::string& path_hints_name);
 
    const PathHints& requirePathHints(const std::string& path_hints_name) const;
 
    shared_ptr<GeometryObject> getGeometryObject(const std::string& name) const;
 
    template <typename RequiredObjectType>
    shared_ptr<RequiredObjectType> getGeometryObject(const std::string& name) const;
 
    shared_ptr<GeometryObject> requireGeometryObject(const std::string& name);
 
    template <typename RequiredObjectType>
    shared_ptr<RequiredObjectType> requireGeometryObject(const std::string& name);
 
    shared_ptr<Geometry> getGeometry(const std::string& name) const;
 
    shared_ptr<MeshBase> getMesh(const std::string& name) const;
 
    template <typename RequiredCalcSpaceType>
    shared_ptr<RequiredCalcSpaceType> getGeometry(const std::string& name) const;
 
    template <typename RequiredCalcSpaceType>
    shared_ptr<RequiredCalcSpaceType> requireGeometry(const std::string& name) const {
        auto geometry = getGeometry<RequiredCalcSpaceType>(name);
        if (!geometry) throw NoSuchGeometry(name);
        return geometry;
    }
 
    virtual void loadDefines(XMLReader& reader);
 
    virtual void loadGeometry(GeometryReader& reader);
 
    virtual void loadMaterials(XMLReader& reader);
 
    virtual void loadGrids(XMLReader& reader);
 
    virtual void loadSolvers(XMLReader& reader);
 
    virtual void loadConnects(XMLReader& reader);
 
    virtual void loadScript(XMLReader& reader);
 
    void loadFromReader(XMLReader& XMLreader, const LoadFunCallbackT& load_from_cb = &disallowExternalSources);
 
    void loadFromStream(std::unique_ptr<std::istream>&& input, const LoadFunCallbackT& load_from_cb = &disallowExternalSources);
 
    void loadFromXMLString(const std::string &input_XML_str, const LoadFunCallbackT& load_from_cb = &disallowExternalSources);
 
    /*
     * Read all objects up to end of XML tag and call functor(object) for each object which was read.
     * @param source
     * @param functor
     * @tparam FunctorType unary functor which can take RequiredObjectType& as argument
     * @tparam RequiredObjectType required type of object
     */
    /*template <typename FunctorType, typename RequiredObjectType = GeometryObject>
    void readAllObjects(XMLReader& source, FunctorType functor);*/
 
    void loadFromFile(const std::string& fileName);
 
    void loadFromFILE(FILE* file, const LoadFunCallbackT& load_from_cb = &disallowExternalSources);
 
private:
    template <typename Boundary>
    Boundary getBoundaryByName(XMLReader& reader, const std::string& name) {
        auto p = this->boundaries.find(name);
        if (p == this->boundaries.end())
            throw XMLException(reader, format("can't find boundary (place) with given name \"{0}\".", name));
        return boost::any_cast<Boundary>(p->second);
    }
 
    void storeBoundary(const std::string& name, boost::any&& boundary) {
        if (!this->boundaries.insert(std::make_pair(name, std::move(boundary))).second)
            throw NamesConflictException("place (boundary)", name);
    }
 
public:
    template <typename Boundary>
    Boundary readBoundary(XMLReader& reader);
 
    //TODO moves to modules reader (with names map)
    //@param geometry (optional) geometry used by solver which reads boundary conditions
    template <typename Boundary, typename ConditionT>
    void readBoundaryConditions(XMLReader& reader, BoundaryConditions<Boundary, ConditionT>& dest/*, shared_ptr<Geometry> geometry = shared_ptr<Geometry>()*/);
 
    void load(XMLReader& XMLreader,
              const LoadFunCallbackT& load_from_cb = &disallowExternalSources,
              const std::function<bool(const std::string& section_name)>& section_filter = &acceptAllSections);
 
    void loadSection(XMLReader& XMLreader, const std::string& section_to_load,
              const LoadFunCallbackT& load_from_cb = &disallowExternalSources) {
        load(XMLreader, load_from_cb, [&](const std::string& section_name) -> bool { return section_name == section_to_load; });
    }
 
    void validatePositions(const std::function<void(const Geometry*, const Geometry*, std::vector<const GeometryObject*>&&, const std::map<const GeometryObject*, const char*>&)>& callback) const;
 
    void validatePositions() const;
 
    std::size_t getRootIndex(const Geometry* geom) const;
};
 
// Specialization for most types
template <typename RequiredObjectType>
shared_ptr<RequiredObjectType> Manager::getGeometryObject(const std::string& name) const {
    return dynamic_pointer_cast<RequiredObjectType>(getGeometryObject(name));
}
 
// Specialization for GeometryObject which doesn't require dynamic_cast
template <>
inline shared_ptr<GeometryObject> Manager::getGeometryObject<GeometryObject>(const std::string& name) const {
    return getGeometryObject(name);
}
 
// Specialization for most types
template <typename RequiredObjectType>
inline shared_ptr<RequiredObjectType> Manager::requireGeometryObject(const std::string& name) {
    shared_ptr<RequiredObjectType> result = dynamic_pointer_cast<RequiredObjectType>(requireGeometryObject(name));
    if (!result) throwErrorIfNotDraft(UnexpectedGeometryObjectTypeException());
    return result;
}
 
// Specialization for GeometryObject which doesn't require dynamic_cast
template <>
inline shared_ptr<GeometryObject> Manager::requireGeometryObject<GeometryObject>(const std::string& name) {
    return requireGeometryObject(name);
}
 
//specialization for most types
template <typename RequiredCalcSpaceType>
inline shared_ptr<RequiredCalcSpaceType> Manager::getGeometry(const std::string& name) const {
    return dynamic_pointer_cast<RequiredCalcSpaceType>(getGeometry(name));
}
 
// Specialization for Geometry which doesn't require dynamic_cast
template <>
inline shared_ptr<Geometry> Manager::getGeometry<Geometry>(const std::string& name) const {
    return getGeometry(name);
}
 
template <typename ConditionT>
inline ConditionT parseBoundaryValue(const XMLReader& tag_with_value) {
    return tag_with_value.requireAttribute<ConditionT>("value");
}
 
template <typename Boundary>
Boundary Manager::readBoundary(XMLReader& reader) {
    Boundary boundary;
    std::string op_name = reader.getTagName();
    plask::optional<std::string> placename = reader.getAttribute("name");
    if (op_name == "union") {
        reader.requireTag(); Boundary A = this->readBoundary<Boundary>(reader);
        reader.requireTag(); Boundary B = this->readBoundary<Boundary>(reader);
        reader.requireTagEnd();
        boundary = A + B;
    } else
    if (op_name == "intersection") {
        reader.requireTag(); Boundary A = this->readBoundary<Boundary>(reader);
        reader.requireTag(); Boundary B = this->readBoundary<Boundary>(reader);
        reader.requireTagEnd();
        boundary = A * B;
    } else
    if (op_name == "difference") {
        reader.requireTag(); Boundary A = this->readBoundary<Boundary>(reader);
        reader.requireTag(); Boundary B = this->readBoundary<Boundary>(reader);
        reader.requireTagEnd();
        boundary = A - B;
    } else
    if (op_name == "place") {
        reader.ensureNodeTypeIs(XMLReader::NODE_ELEMENT, "place");
        plask::optional<std::string> refname = reader.getAttribute("ref");
        boundary = refname ? this->getBoundaryByName<Boundary>(reader, *refname)
                           : parseBoundary<Boundary>(reader, *this);
    } else
        reader.throwUnexpectedElementException("place, union, intersection, or difference tag");
    if (boundary.isNull()) throwErrorIfNotDraft(XMLException(reader, "Can't parse boundary place from XML."));
    if (placename) {
        std::replace(placename->begin(), placename->end(), '-', '_');
        this->storeBoundary(*placename, boundary);
    }
    return boundary;
}
 
template <typename Boundary, typename ConditionT>
inline void Manager::readBoundaryConditions(XMLReader& reader, BoundaryConditions<Boundary, ConditionT>& dest) {
    while (reader.requireTagOrEnd("condition")) {
        Boundary boundary;
        plask::optional<std::string> place = reader.getAttribute("place");
        plask::optional<std::string> placename = reader.getAttribute("placename");
        ConditionT value;
        try {
            value = parseBoundaryValue<ConditionT>(reader);
        } catch (std::runtime_error err) {
            throwErrorIfNotDraft(err);
        }
        if (place) {
            boundary = parseBoundary<Boundary>(*place, *this);
            if (boundary.isNull()) throwErrorIfNotDraft(XMLException(reader, format("Can't parse boundary place from string \"{0}\".", *place)));
        } else {
            place = reader.getAttribute("placeref");
            if (place)
                boundary = this->getBoundaryByName<Boundary>(reader, *place);
            else {
                reader.requireTag();
                boundary = this->readBoundary<Boundary>(reader);
                //placename.reset(); // accept "placename" or only "name" in place tag?
            }
        }
        /*if (!value) {   // value still not known, must be read from tag <value>...</value>
            reader.requireTag("value");
            *value = reader.requireText<ConditionT>();
            reader.requireTagEnd();
        }*/ //now we read only from XML tags
        if (placename) this->storeBoundary(*placename, boundary);
        dest.add(std::move(boundary), std::move(value));
        reader.requireTagEnd(); // </condition>
    }
}
 
 
} // namespace plask
 
#endif // PLASK__GEOMETRY_MANAGER_H