FMTmodelparser.hpp

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 FMTmodelparser_H_INCLUDED
#define FMTmodelparser_H_INCLUDED
 
 
#include <map>
#include <string>
#include <vector>
#include "FMTparser.hpp"
//#include "FMToutput.hpp"
#include "FMToutputnode.hpp"
#include "FMTconstants.hpp"
 
 
namespace Models {
    class FMTmodel;
}
 
 
namespace Core {
    class FMTschedule;
    class FMTconstraint;
    class FMToutput;
}
 
 
namespace Parser
{
class FMTconstantparser;
class FMTlandscapeparser;
class FMTareaparser;
class FMTyieldparser;
class FMTactionparser;
class FMTlifespanparser;
class FMToutputparser;
class FMToptimizationparser;
class FMTscheduleparser;
// DocString: FMTmodelparser
class FMTEXPORT FMTmodelparser : public FMTparser
    {
    // DocString: FMTmodelparser::referenceread
    Models::FMTmodel referenceread(std::map<std::string, std::vector<int>>& common_sections,
                    std::vector<Models::FMTmodel>& models,
                    const std::string& con, const std::string& lan,
                    const std::string& lif, const std::string& are, const std::string& yld,
                    const std::string& act, const std::string& tr, const std::string& out,
                    std::string opt = std::string(),bool allow_mapping=false);
    // DocString: FMTmodelparser::readfromfolder
    std::vector<Models::FMTmodel>readfromfolder(const std::string& primary_location,
                                    const std::string& folder,
                                    std::vector<std::string>scenarios,
                                    bool validatescenarioname,
                                    bool readarea=true, bool readoutputs=true, bool readoptimize=true);
    protected:
    #ifdef FMTWITHGDAL
    // DocString: FMTmodelparser::getiterationsvalues()
    std::map<std::string,std::vector<std::vector<double>>>getiterationsvalues(OGRLayer* layer) const;
    // DocString: FMTmodelparser::createdriftlayer()
    OGRLayer* createdriftlayer(GDALDataset* dataset, std::vector<std::string> creationoptions = std::vector<std::string>()) const;
    // DocString: FMTmodelparser::writedriftr()
    void writedrift(OGRLayer* layer,const std::map<std::string,std::map<double,std::vector<double>>>& lowervalues,
                                const std::map<std::string, std::map<double, std::vector<double>>>& uppervalues) const;
    #endif
    // DocString: FMTmodelparser::writeprimary()
    void writeprimary(
        const std::string& location,
        const std::string& lanfile,
        const std::string& arefile,
        const std::string& yldfile,
        const std::string& actfile,
        const std::string& trnfile,
        const std::string& outfile,
        const std::string& optfile,
        const std::string& liffile,
        std::string seqfile=std::string()) const;
    // DocString: FMTmodelparser::writemodel
    void writemodel(const Models::FMTmodel& model, 
        const std::string& lanfile,
        const std::string& arefile,
        const std::string& yldfile,
        const std::string& actfile,
        const std::string& trnfile,
        const std::string& outfile,
        const std::string& optfile,
        const std::string& liffile,
        const std::string& seqfile) const;
    public:
        // DocString: FMTmodelparser()
        FMTmodelparser();
        // DocString: ~FMTmodelparser()
        virtual ~FMTmodelparser() = default;
        // DocString: FMTmodelparser(const FMTmodelparser&)
        FMTmodelparser(const FMTmodelparser& rhs);
        // DocString: FMTmodelparser::operator=
        FMTmodelparser& operator = (const FMTmodelparser& rhs);
        // DocString: FMTmodelparser::read
        Models::FMTmodel read(const std::string& con,const std::string& lan,
                      const std::string& lif,const std::string& are,const std::string& yld,
                      const std::string& act,const std::string& tr,const std::string& out,
                        std::string opt = std::string());
        // DocString: FMTmodelparser::readtemplate
        std::vector<Models::FMTmodel>readtemplates(const std::string& primary_location,const std::string& templatefolder);
        // DocString: FMTmodelparser::readproject
        std::vector<Models::FMTmodel>readproject(const std::string& primary_location,
            std::vector<std::string>scenarios = std::vector<std::string>(),
            bool readarea = true,bool readoutputs = true, bool readoptimize = true);
        // DocString: FMTmodelparser::writetoproject
        void writetoproject(const std::string& primary_location,
            const Models::FMTmodel& model);
        // DocString: FMTmodelparser::readschedules
        std::vector<std::vector<Core::FMTschedule>>readschedules(const std::string& primary_location,
            const std::vector<Models::FMTmodel>& models);
        // DocString: FMTmodelparser::getconstraintsfromstring
        std::vector<Core::FMTconstraint>getconstraintsfromstring(std::string constraintstr,
            const Models::FMTmodel& model,Core::FMTconstants constants = Core::FMTconstants());
        // DocString: FMTmodelparser::write
        void write(const Models::FMTmodel& model,const std::string& folder) const;
        #ifdef FMTWITHGDAL
        // DocString: FMTmodelparser::createresultslayer
        OGRLayer* createresultslayer(const Models::FMTmodel& model,
            GDALDataset* dataset, std::vector<std::string> creationoptions=std::vector<std::string>())const;
        // DocString: FMTmodelparser::fillupinfeasibles
        void fillupinfeasibles(OGRLayer* layer,
            const std::vector<Core::FMToutput>&theoutputs,
            const int& iteration,const int& firstperiod, const int&lastperiod) const;
        // DocString: FMTmodelparser::writefeatures
        void writefeatures(OGRLayer* layer,const int& firstperiod, const int& iteration,
            const std::vector<Core::FMToutput>&theoutputs,
            const std::map<std::string,std::vector<std::vector<double>>>& values, bool writeNaN = false)const;
        // DocString: FMTmodelparser::writeresults
        void writeresults(const Models::FMTmodel& model,
            const std::vector<Core::FMToutput>&theoutputs,
            const int& firstperiod, const int& lastperiod,
            const std::string& location,
            Core::FMToutputlevel level = Core::FMToutputlevel::standard,
            std::string gdaldrivername= "CSV") const;
        #endif 
    };
}
 
#endif // FMTmodelparser_H_INCLUDED