FMTSpatialGraphs.h

Go to the documentation of this file.

/*
Copyright (c) 2019 Gouvernement du Québec
 
SPDX-License-Identifier: LiLiQ-R-1.1
License-Filename: LICENSES/EN/LiLiQ-R11unicode.txt
*/
#ifndef FMTSPATIALGRAPHS_H
#define FMTSPATIALGRAPHS_H
 
 
#include <map>
//#include <boost/container/flat_map.hpp>
#include <vector>
#include <string>
#include <memory>
#include <unordered_map>
#include <boost/unordered_map.hpp>
#include "FMTObject.h"
#include "FMTGraphInfo.h"
#include "FMTMask.h"
#include "FMTSolutionTracker.h"
 
namespace Graph
{
    class FMTLineGraph;
}
 
namespace Models
{
    class FMTModel;
}
 
namespace Core
{
    class FMTConstraint;
    class FMTOutputNode;
    class FMTSchedule;
    class FMTOutput;
    class FMTSchedule;
}
 
 
namespace Spatial
    {
    class FMTVirtualLineGraph;
    // DocString: FMTSpatialGraphs
    class FMTSpatialGraphs: public Core::FMTObject
        {
        public:
            using const_iterator = std::map<Graph::FMTLineGraph, 
                FMTGraphInfo>::const_iterator;
            // DocString: FMTSpatialGraphs()
            FMTSpatialGraphs() = default;
            // DocString: FMTSpatialGraphs(const FMTSpatialGraphs&)
            FMTSpatialGraphs(const FMTSpatialGraphs& p_rhs)=default;
            // DocString: FMTSpatialGraphs::operator=
            FMTSpatialGraphs& operator = (const FMTSpatialGraphs&)=default;
            // DocString: FMTSpatialGraphs(const Models::FMTModel&,double)
            FMTSpatialGraphs(const Models::FMTModel& p_model, double p_CellSize);
            // DocString: FMTSpatialGraphs::getConstraintsValue
            double getConstraintsValue(size_t NonSpatialConstraintId,
                                            const FMTSolutionTracker& p_solution) const;
            // DocString: FMTSpatialGraphs::getVirtualGraph
            FMTVirtualLineGraph getVirtualGraph(const Graph::FMTLineGraph& p_LineGraph);
            // DocString: FMTSpatialGraphs::setVirtualGraph
            FMTVirtualLineGraph setVirtualGraph(const Graph::FMTLineGraph& p_LineGraph);
            // DocString: FMTSpatialGraphs::getBaseSolution
            FMTSolutionTracker getBaseSolution() const;
            // DocString: FMTSpatialGraphs::getIterator
            const_iterator getIterator(
                                                const Graph::FMTLineGraph& p_Graph,
                                                            size_t p_family) const;
            // DocString: FMTSpatialGraphs::setIterator
            const_iterator setIterator(
                                const Graph::FMTLineGraph& p_Graph,
                                size_t p_family);
            // DocString: FMTSpatialGraphs::setNaturalGrowthIterator
            const_iterator setNaturalGrowthIterator(size_t p_family);
            // DocString: FMTSpatialGraphs::getModel
            const Models::FMTModel& getModel() const;
            // DocString: FMTSpatialGraphs::getOutput
            std::map<std::string, double> getOutput(
                const FMTSolutionTracker& p_Solution,
                const Core::FMTOutput& p_output,
                int p_period, Core::FMToutputlevel level) const;
            // DocString: FMTSpatialGraphs::setModel
            void setModel(const Models::FMTModel& p_model);
            // DocString: FMTSpatialGraphs::addToSolution
            void addToSolution(FMTSolutionTracker& p_solution,
                size_t p_family,
                const_iterator p_iterator);
            // DocString: FMTSpatialGraphs::removeToSolution
            void removeToSolution(FMTSolutionTracker& p_solution,
                size_t p_family,
                const_iterator p_iterator);
            // DocString: FMTSpatialGraphs::isNotNull
            bool isNotNull(size_t p_family,
                const_iterator p_iterator) const;
            // DocString: FMTSpatialGraphs::getSchedules
            std::vector<Core::FMTSchedule> getSchedules(const FMTSolutionTracker& p_Solution,
                                            bool WithLock = false) const;
            // DocString: FMTSpatialGraphs::getBaseIterator
            const_iterator getBaseIterator(size_t p_family) const;
            // DocString: FMTSpatialGraphs::getLastPeriodIterator
            const_iterator getLastPeriodIterator(
                size_t p_family,
                const_iterator p_iterator) const;
            // DocString: FMTSpatialGraphs::swap
            void swap(FMTSpatialGraphs& p_Other);
            // DocString: FMTSpatialGraphs::getNumberOfCategories
            size_t getNumberOfCategories(int p_themeId) const;
            // DocString: FMTSpatialGraphs::getCategoryOf
            size_t getCategoryOf(int p_themeId, size_t p_family) const;
            // DocString: FMTSpatialGraphs::deleteNonCompleteGraphs
            void deleteNonCompleteGraphs();
            // DocString: FMTSpatialGraphs::enableSolutionTracker
            void enableSolutionTracker(FMTSolutionTracker& p_tracker) const;
        private:
            using iterator = std::map<Graph::FMTLineGraph,
                FMTGraphInfo>::iterator;
            using family_iterator = std::vector<std::map<Graph::FMTLineGraph, FMTGraphInfo>>::iterator;
            std::vector<std::map<Graph::FMTLineGraph, FMTGraphInfo>>m_AllGraphs;
            size_t m_LastGraphId;
            std::vector<std::vector<size_t>>m_Constraints;
            boost::unordered_map<Core::FMTMask, size_t>m_GraphsMasks;
            FMTSolutionTracker m_BaseSolution;
            std::vector<size_t>m_ConstraintsId;
            Models::FMTModel const * m_Model;
            // Run-scoped deduplication pool for graph constraint values (replaces the former
            // process-wide boost::flyweight static factory). Keyed by value-vector hash, holding
            // weak_ptr so distinct vectors are shared while alive and released with the graphs.
            std::unordered_map<std::size_t, std::vector<std::weak_ptr<const FMTGraphValues>>> m_ValuesPool;
            // DocString: FMTSpatialGraphs::_internValues
            std::shared_ptr<const FMTGraphValues> _internValues(const std::vector<double>& p_Values);
            // DocString: FMTSpatialGraphs::_buildConstraintsLocator
            void _buildConstraintsLocator(const Models::FMTModel& p_model);
            // DocString: FMTSpatialGraphs::_buildGraphs
            std::vector<size_t> _buildGraphs(const Models::FMTModel& p_model, double p_CellSize);
            // DocString: FMTSpatialGraphs::_buildConstraintsValues(family_iterator,family_iterator)
            void _buildConstraintsValues( 
                family_iterator FirstGraphFamily,
                family_iterator GraphFamilyEnd);
            // DocString: FMTSpatialGraphs::_buildConstraintsValues(iterator,size_t)
            void _buildConstraintsValues(
                iterator p_Graph,
                size_t p_family);
            // DocString: FMTSpatialGraphs::_fillValuesFromLastPeriod
            size_t _fillValuesFromLastPeriod(
                size_t p_family,
                FMTSpatialGraphs::iterator p_Graph,
                size_t p_ConstraintId,
                std::vector<double>& p_constraintValues) const;
            // DocString: FMTSpatialGraphs::_getUseFullBits
            static Core::FMTMask _getUseFullBits(const Models::FMTModel& p_model);
            // DocString: FMTSpatialGraphs::_getFamily
            size_t _getFamily(const Graph::FMTLineGraph& p_Graph) const;
            // DocString: FMTSpatialGraphs::_getNonSpatialId
            size_t _getNonSpatialId(size_t p_Constraint) const;
            // DocString: FMTSpatialGraphs::_fillConstraintResults
            void _fillConstraintResults(size_t p_Constraint,
                const FMTGraphInfo& p_GraphInfo,
                std::vector<double>& p_results,
                const FMTSolutionTracker& p_solution) const;
            // DocString: FMTSpatialGraphs::_getGraphCells
            double _getGraphCells(const FMTSolutionTracker& p_solution, const FMTGraphInfo& p_GraphInfo) const;
            // DocString: FMTSpatialGraphs::_getMaxGraphLength
            size_t _getMaxGraphLength() const;
            // DocString: FMTSpatialGraphs::_getMinGraphLength
            size_t _getMinGraphLength() const;
            // DocString: FMTSpatialGraphs::_removeGraphsShorterThan
            void _removeGraphsShorterThan(size_t p_GraphSize);
            // DocString: FMTSpatialGraphs::_getNaturalGrowthIterator
            const_iterator _getNaturalGrowthIterator(size_t p_family) const;
            // DocString: FMTSpatialGraphs::_getConstraintsValueFromSolution
            std::vector<double> _getConstraintsValueFromSolution(size_t p_ConstraintId,
                const FMTSolutionTracker& p_solution) const;
            // DocString: FMTSpatialGraphs::_getConstraintsValueFromTracker
            std::vector<double> _getConstraintsValueFromTracker(size_t p_ConstraintId,
                const FMTSolutionTracker& p_solution) const;
            // DocString: FMTSpatialGraphs::_getConstraintsValues
            std::vector<std::vector<double>> _getConstraintsValues(const FMTSolutionTracker& p_solution) const;
            // DocString: FMTSpatialGraphs::_buildTacker
            void _buildTacker(const std::vector<size_t>& p_solution);
        };
}
 
 
#endif