FMTParallelWriter.h

Go to the documentation of this file.

#ifndef FMTparallelwriter_Hm_included
#define FMTparallelwriter_Hm_included
#include "FMTModelParser.h"
#include <vector>
#include <string>
#include <memory>
#include <boost/thread/recursive_mutex.hpp>
#include "FMTutility.h"
 
#ifdef FMTWITHGDAL
class GDALDataset;
class OGRLayer;
#endif
 
namespace Models {
    class FMTModel;
}
 
 
namespace Parallel
{
    // DocString: FMTParallelWriter
    class FMTEXPORT FMTParallelWriter : public Parser::FMTModelParser
    {
    public:
        // DocString: FMTParallelWriter::FMTParallelWriter()
        FMTParallelWriter() = default;
        // DocString: ~FMTparallelwrite()
        virtual ~FMTParallelWriter();
        // DocString: FMTParallelWriter::FMTParallelWriter(const FMTParallelWriter&)
        FMTParallelWriter(const FMTParallelWriter& rhs) = default;
        // DocString: FMTParallelWriter::operator=()
        FMTParallelWriter& operator = (const FMTParallelWriter& rhs) = default;
        // DocString: FMTParallelWriter::FMTParallelWriter(const std::string&,const std::string&,const std::vector<Core::FMTOutput>&,const Models::FMTModel&)
        FMTParallelWriter(const std::string& location,
            const std::string& driver,
            const std::vector<Core::FMTOutput>& outputs,
            const std::vector<Models::FMTModel*>& allmodels,
            std::vector<std::string>layersoptions = std::vector<std::string>(),
            double minimaldrift = 0.5,
            Core::FMToutputlevel outputlevel = Core::FMToutputlevel::totalonly);
        // DocString: FMTParallelWriter::FMTParallelWriter(const std::string&,const std::string&,std::vector<std::string>,Core::FMToutputlevel)
        FMTParallelWriter(const std::string& location,
            const std::string& driver,
            Core::FMToutputlevel outputlevel = Core::FMToutputlevel::totalonly,
            std::vector<std::string>layersoptions = std::vector<std::string>(),
            int firstPeriod=1,
            int lastPeriod=1,
            std::string primaryfilelocation = std::string());
        // DocString: FMTParallelWriter::setLayer
        void setLayer(const std::string& p_name);
        // DocString: FMTParallelWriter::write()
        void write(const std::string& modelname,
            const std::map<std::string, std::vector<std::vector<double>>>& results,
            const int& firstPeriod, const int& lastPeriod, const int& iteration) const;
        // DocString: FMTParallelWriter::writeSchedules
        void writeSchedules(const std::string seqName, const std::vector<Core::FMTSchedule> scheduleList, bool append) const;
        // DocString: FMTParallelWriter::getResults()
        std::map<std::string, std::vector<std::vector<double>>> getResults(const std::unique_ptr<Models::FMTModel>& modelptr, const int& firstPeriod, const int& lastPeriod) const;
        // DocString: FMTParallelWriter::setDriftProbability()
        void setDriftProbability(const std::string& globalmodel, const std::string& localmodel) const;
        // DocString: FMTParallelWriter::getAndWrite()
        void getAndWrite(const std::unique_ptr<Models::FMTModel>& modelptr, const std::vector<Core::FMTOutput>& loutputs);
        // DocString: FMTParallelWriter::close()
        void close() noexcept;
        protected:
            // DocString: FMTParallelWriter::_getDriftProbability()
            const std::map<std::string, std::map<double, std::vector<double>>>_getDriftProbability(
                const std::map<std::string, std::vector<std::vector<double>>>& globalvalues,
                const std::map<std::string, std::vector<std::vector<double>>>& localvalues,
                const bool lower = true) const;
        private:
            // DocString: FMTParallelWriter::m_outputstowrite
            std::vector<Core::FMTOutput>m_outputstowrite;
            #ifdef FMTWITHGDAL
                    // DocString: FMTParallelWriter::m_resultsdataset
                    GDALDataset* m_resultsdataset;
                    // DocString: FMTParallelWriter::m_resultslayer
                    std::map<std::string, OGRLayer*> m_resultslayer;
                    // DocString: FMTParallelWriter::m_driftlayer
                    OGRLayer* m_driftlayer;
            #endif
            // DocString: FMTParallelWriter::m_mtx
            mutable boost::recursive_mutex m_mtx;
            // DocString: FMTParallelWriter::m_resultsminimaldrift;
            double m_resultsminimaldrift;
            // DocString: FMTParallelWriter::m_outputslevel
            Core::FMToutputlevel m_outputslevel;
            // DocString: FMTParallelWriter::m_alllayeroptions
            std::vector<std::string> m_alllayeroptions;
            // DocString: FMTParallelWriter::m_outputfirstperiod
            int m_outputfirstperiod;
            // DocString: FMTParallelWriter::m_outputlastperiod;
            int m_outputlastperiod;
            // DocString: FMTParallelWriter::m_projectdirectory;
            std::string m_projectdirectory;
            // DocString: FMTParallelWriter::m_projectname;
            std::string m_projectname;
            // DocString: FMTParallelWriter::m_projectname;
            std::string m_outputLocationPath;
        };
}
#endif