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_max_gap_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
                bool resample(const std::string &stationHash, const size_t &index, const ResamplingPosition &position, const size_t &paramindex,
                                        const std::vector<MeteoData> &vecM, MeteoData &md) override;
                std::string toString() const override;
 
        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 (in Julian days)
                // Time window before and after gap to accumulate data for ARIMA model fitting
                double before_window, after_window;
 
                // ARIMA model parameters - non-seasonal component
                int max_p = 8;           
                int max_d = 3;           
                int max_q = 8;           
                int start_p = 2;         
                int start_q = 2;         
 
                // ARIMA model parameters - seasonal component
                int max_P = 2;           
                int max_D = 1;           
                int max_Q = 2;           
                int start_P = 1;         
                int start_Q = 1;         
                double period = 0;       
 
                // Model fitting parameters
                ObjectiveFunction method = CSS_MLE;      
                OptimizationMethod opt_method = BFGS;    
                bool stepwise = true;                    
                bool approximation = true;               
                int num_models = 94;                     
                bool seasonal = true;                    
                bool stationary = false;                 
                Normalization::Mode normalize = Normalization::Mode::Nothing;  
 
                // Manual ARIMA parameter settings (overrides auto-selection)
                bool set_arima_manual = false;           
                bool fill_backward_manual = false;       
                int p = 0, d = 0, q = 0;                
                int P = 0, D = 0, Q = 0;                
 
                // State and warning 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);
 
                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);
 
                double interpolVecAt(std::vector<MeteoData> &vecMet, const Date &date, const size_t &paramindex);
 
                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,
                                                                                std::vector<MeteoData> &data_vec_before, 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