ARIMAResampling.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-3.0-or-later
/***********************************************************************************/
/*  Copyright 2013 WSL Institute for Snow and Avalanche Research    SLF-DAVOS      */
/***********************************************************************************/
/* This file is part of MeteoIO.
    MeteoIO is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    MeteoIO 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 Lesser General Public License for more details.
 
    You should have received a copy of the GNU Lesser General Public License
    along with MeteoIO.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef ARIMARESAMPLING_H
#define ARIMARESAMPLING_H
 
#include <meteoio/meteoResampling/ARIMAutils.h>
#include <meteoio/meteoResampling/InterpolARIMA.h>
#include <meteoio/meteoResampling/ResamplingAlgorithms.h>
#include <vector>
 
namespace mio {
 
    using namespace ARIMAutils;
    class ARIMAResampling : public ResamplingAlgorithms {
    public:
        ARIMAResampling(const std::string &i_algoname, const std::string &i_parname, const double &dflt_window_size,
                        const std::vector<std::pair<std::string, std::string>> &vecArgs);
 
        // Performs ARIMA interpolation the first time it is called, as this is also the first time the data is available
        void resample(const std::string &stationHash, const size_t &index, const ResamplingPosition &position, const size_t &paramindex,
                      const std::vector<MeteoData> &vecM, MeteoData &md);
        std::string toString() const;
 
    private:
        bool verbose;
        // ARIMA related data
        std::vector<ARIMA_GAP> gap_data;
        std::vector<std::vector<double>> filled_data;
        std::vector<std::vector<Date>> all_dates;
 
        // Window parameters
        double before_window, after_window;
 
        // User defined Metadata
        int max_p = 8, max_d = 3, max_q = 8;
        int start_p = 2, start_q = 2;
        int max_P = 2, max_D = 1, max_Q = 2;
        int start_P = 1, start_Q = 1;
        double period = 0;
        ObjectiveFunction method = CSS_MLE;
        OptimizationMethod opt_method = BFGS;
        bool stepwise = true, approximation = true;
        int num_models = 94;
        bool seasonal = true, stationary = false;
        Normalization::Mode normalize = Normalization::Mode::MinMax;
 
        bool set_arima_manual = false;
        bool fill_backward_manual = false;
        int p = 0, d = 0, q = 0;
        int P = 0, D = 0, Q = 0;
 
        // Flags
        bool is_zero_possible = false;
        bool checked_vecM = false;
        bool gave_warning_end = false;
        bool gave_warning_start = false;
        bool gave_warning_interpol = false;
        std::vector<bool> is_valid_gap_data;
        std::vector<bool> warned_about_gap;
 
        ARIMA_GAP newest_gap;
        // Private methods
        void setMetaData(InterpolARIMA &arima);
        std::vector<double> predictData(std::vector<double> &data, const std::string &direction, size_t startIdx_interpol,
                                        size_t length_gap_interpol, int sr_period);
 
        // Helper methods for resample
        void checkZeroPossibility(const std::vector<MeteoData> &vecM, size_t paramindex);
        bool processKnownGaps(const Date &resampling_date, const size_t paramindex,
                              const ResamplingAlgorithms::ResamplingPosition &position, const std::vector<MeteoData> &vecM, MeteoData &md);
        void setEndGap(ARIMA_GAP &new_gap, Date &data_start_date, Date &data_end_date, const std::vector<MeteoData> &vecM,
                       const Date &resampling_date);
        double interpolVecAt(const std::vector<MeteoData> &vecM, const size_t &idx, const Date &date, const size_t &paramindex);
        double interpolVecAt(const std::vector<double> &data, const std::vector<Date> &dates, const size_t &pos, const Date &date);
        void resampleInterpolationData(size_t &length_gap_interpol, size_t &endIdx_interpol, size_t &startIdx_interpol,
                                       const ARIMA_GAP &new_gap, const Date &data_start_date, const Date &data_end_date,
                                       const std::vector<MeteoData> &data_vec_before, const std::vector<MeteoData> &data_vec_after,
                                       bool has_data_before, bool has_data_after, size_t paramindex, std::vector<double> &data,
                                       std::vector<Date> &dates, size_t length);
        std::vector<double> getInterpolatedData(std::vector<double> &data, size_t size_before, size_t size_after, size_t startIdx_interpol,
                                                size_t length_gap_interpol, int period);
        void cacheGap(const std::vector<double> &interpolated_data, const std::vector<Date> &interpolated_dates, const ARIMA_GAP &new_gap);
 
        // info
        void infoARIMA(InterpolARIMA arima);
    };
} // end namespace mio
 
#endif