DataEditingAlgorithms.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-3.0-or-later
/***********************************************************************************/
/*  Copyright 2020 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 DATAEDITINGALGS_H
#define DATAEDITINGALGS_H
 
#include <meteoio/IOInterface.h>
#include <meteoio/meteoFilters/TimeFilters.h>
 
#include <set>
#include <string>
 
namespace mio {
 
class EditingBlock {
        public:
                EditingBlock(const std::string& i_stationID, const std::vector< std::pair<std::string, std::string> >& vecArgs, const std::string& name, const Config &cfg);
                
                virtual ~EditingBlock() {}
                
                virtual void editTimeSeries(std::vector<METEO_SET>& vecMeteo) {(void)vecMeteo;}
                
                virtual void editTimeSeries(STATIONS_SET& vecStation) {(void)vecStation;}
                
                virtual std::set<std::string> requiredIDs() const {return std::set<std::string>();}
                
                virtual std::set<std::string> providedIDs() const {return std::set<std::string>();}
                
                virtual std::set<std::string> purgeIDs() const {return requiredIDs();}
                
                const std::string toString() const;
                
        protected:
                std::string getName() const {return block_name;}
                static std::set<std::string> initStationSet(const std::vector< std::pair<std::string, std::string> >& vecArgs, const std::string& keyword);
                bool skipStation(const std::vector<MeteoData>& vecMeteo) const;
                METEO_SET timeFilterFromStation(const METEO_SET& vecMeteo) const; //merge and automerge need this method
                
                const std::set<std::string> excluded_stations, kept_stations;
                const std::vector<DateRange> time_restrictions;
                const std::string stationID, block_name;
};
 
class EditingSwap : public EditingBlock {
        public:
                EditingSwap(const std::string& i_stationID, const std::vector< std::pair<std::string, std::string> >& vecArgs, const std::string& name, const Config &cfg);
                
                virtual void editTimeSeries(std::vector<METEO_SET>& vecMeteo) override;
                
        private:
                void parse_args(const std::vector< std::pair<std::string, std::string> >& vecArgs);
                std::string dest_param, src_param;
};
 
 
class EditingRename : public EditingBlock {
        public:
                EditingRename(const std::string& i_stationID, const std::vector< std::pair<std::string, std::string> >& vecArgs, const std::string& name, const Config &cfg);
                
                virtual void editTimeSeries(std::vector<METEO_SET>& vecMeteo) override;
                
        private:
                void parse_args(const std::vector< std::pair<std::string, std::string> >& vecArgs);
                std::set< std::string > src_params;
                std::string dest_param;
};
 
class EditingExclude : public EditingBlock {
        public:
                EditingExclude(const std::string& i_stationID, const std::vector< std::pair<std::string, std::string> >& vecArgs, const std::string& name, const Config &cfg);
                
                virtual void editTimeSeries(std::vector<METEO_SET>& vecMeteo) override;
                
        private:
                void parse_args(const std::vector< std::pair<std::string, std::string> >& vecArgs);
                void processStation(METEO_SET& vecMeteo, const size_t& startIdx, const size_t& endIdx, const std::set< std::string >& params) const;
                std::set< std::string > exclude_params;
                bool wildcard;
};
 
class EditingKeep : public EditingBlock {
        public:
                EditingKeep(const std::string& i_stationID, const std::vector< std::pair<std::string, std::string> >& vecArgs, const std::string& name, const Config &cfg);
                
                virtual void editTimeSeries(std::vector<METEO_SET>& vecMeteo) override;
                static void processStation(METEO_SET& vecMeteo, const size_t& startIdx, const size_t& endIdx, const std::set< std::string >& params); //for use in DataEditingAlgorithms
                
        private:
                void parse_args(const std::vector< std::pair<std::string, std::string> >& vecArgs);
                std::set< std::string > keep_params;
};
 
class EditingCombine : public EditingBlock {
        public:
                enum CombineType {
                        FIRST,  
                        MIN,    
                        AVG,    
                        MAX             
                };
        public:
                EditingCombine(const std::string& i_stationID, const std::vector< std::pair<std::string, std::string> >& vecArgs, const std::string& name, const Config &cfg);
                
                virtual void editTimeSeries(std::vector<METEO_SET>& vecMeteo) override;
        private:
                void parse_args(const std::vector< std::pair<std::string, std::string> >& vecArgs);
                void processFIRST(METEO_SET& vecMeteo, const size_t& startIdx, const size_t& endIdx) const;
                void processMIN(METEO_SET& vecMeteo, const size_t& startIdx, const size_t& endIdx) const;
                void processAVG(METEO_SET& vecMeteo, const size_t& startIdx, const size_t& endIdx) const;
                void processMAX(METEO_SET& vecMeteo, const size_t& startIdx, const size_t& endIdx) const;
                std::vector< std::string > merged_params; //as vector since order is important
                std::string dest_param;
                CombineType type;
                bool replace;
};
 
class EditingMerge : public EditingBlock {
        public:
                EditingMerge(const std::string& i_stationID, const std::vector< std::pair<std::string, std::string> >& vecArgs, const std::string& name, const Config &cfg);
                
                virtual void editTimeSeries(std::vector<METEO_SET>& vecMeteo) override;
                virtual void editTimeSeries(STATIONS_SET& vecStation) override;
                
                std::set<std::string> requiredIDs() const override;
        private:
                void parse_args(const std::vector< std::pair<std::string, std::string> >& vecArgs);
                std::vector< std::string > merged_stations;
                std::set< std::string > merged_params;
                MeteoData::Merge_Type merge_strategy;
                MeteoData::MERGE_CONFLICTS merge_conflicts;
};
 
class EditingAutoMerge : public EditingBlock {
        public:
                EditingAutoMerge(const std::string& i_stationID, const std::vector< std::pair<std::string, std::string> >& vecArgs, const std::string& name, const Config &cfg);
                
                virtual void editTimeSeries(std::vector<METEO_SET>& vecMeteo) override;
                virtual void editTimeSeries(STATIONS_SET& vecStation) override;
                
        private:
                void parse_args(const std::vector< std::pair<std::string, std::string> >& vecArgs);
                static void mergeStations(const size_t& toStationIdx, STATIONS_SET& vecStation);
                void mergeMeteo(const size_t& toStationIdx, std::vector<METEO_SET>& vecMeteo) const;
                MeteoData::Merge_Type merge_strategy;
                MeteoData::MERGE_CONFLICTS merge_conflicts;
};
 
class EditingCopy : public EditingBlock {
        public:
                EditingCopy(const std::string& i_stationID, const std::vector< std::pair<std::string, std::string> >& vecArgs, const std::string& name, const Config &cfg);
                
                virtual void editTimeSeries(std::vector<METEO_SET>& vecMeteo) override;
                
        private:
                void parse_args(const std::vector< std::pair<std::string, std::string> >& vecArgs);
                std::string dest_param, src_param;
};
 
class EditingCreate : public EditingBlock {
        public:
                EditingCreate(const std::string& i_stationID, const std::vector< std::pair<std::string, std::string> >& vecArgs, const std::string& name, const Config &cfg);
                
                virtual void editTimeSeries(std::vector<METEO_SET>& vecMeteo) override;
                
        private:
                static const std::vector< std::pair<std::string, std::string> > cleanGeneratorArgs(const std::vector< std::pair<std::string, std::string> >& vecArgs);
                void parse_args(const std::vector< std::pair<std::string, std::string> >& vecArgs);
                
                const Config &cfg_copy;
                const std::vector< std::pair<std::string, std::string> > vecArgs_copy;
                std::string algorithm, dest_param;
};
 
class EditingMetadata : public EditingBlock {
        public:
                EditingMetadata(const std::string& i_stationID, const std::vector< std::pair<std::string, std::string> >& vecArgs, const std::string& name, const Config &cfg);
                
                virtual void editTimeSeries(std::vector<METEO_SET>& vecMeteo) override;
                virtual void editTimeSeries(STATIONS_SET& vecStation) override;
                
                std::set<std::string> providedIDs() const override;
                
        private:
                void parse_args(const std::vector< std::pair<std::string, std::string> >& vecArgs);
                void mergeMigratedData(std::vector<METEO_SET>& vecMeteo, const std::vector<METEO_SET>& vecTmp) const;
                
                std::string new_name, new_id;
                double lat, lon, alt, slope, azi;
                bool edit_in_place;
};
 
class EditingRegFill : public EditingBlock {
        public: 
                enum RegressionType {
                        LINEAR,
                        QUADRATIC,
                        CUBIC
                };
 
        public:
                EditingRegFill(const std::string& i_stationID, const std::vector< std::pair<std::string, std::string> >& vecArgs, const std::string& name, const Config &cfg);
                
                virtual void editTimeSeries(std::vector<METEO_SET>& vecMeteo) override;
                
        private:
                void parse_args(const std::vector< std::pair<std::string, std::string> >& vecArgs);
                void fillTimeseries(METEO_SET& vecMeteo1, const METEO_SET& vecMeteo2);
                std::vector< std::string > source_stations;
                std::set< std::string > params_to_merge;
                RegressionType regtype;
                bool print_regression_info;
};
 
class EditingMove : public EditingBlock {
        public: 
 
        public:
                EditingMove(const std::string& i_stationID, const std::vector< std::pair<std::string, std::string> >& vecArgs, const std::string& name, const Config &cfg);
                
                virtual void editTimeSeries(std::vector<METEO_SET>& vecMeteo) override;
                
        private:
                void parse_args(const std::vector< std::pair<std::string, std::string> >& vecArgs);
                std::set<std::string> dest_stations;
                std::set< std::string > params_to_move;
 
                std::vector<MeteoData> createFullTimeSeries(const std::vector<MeteoData>& source, const std::vector<MeteoData>& dest) const;
                bool isDestination(const std::string& stationID) const;
 
                bool param_wildcard;
                bool station_wildcard;
                bool station_glob;
};
 
class EditingSplit : public EditingBlock {
        public: 
 
        public:
                EditingSplit(const std::string& i_stationID, const std::vector< std::pair<std::string, std::string> >& vecArgs, const std::string& name, const Config &cfg);
                
                virtual void editTimeSeries(std::vector<METEO_SET>& vecMeteo) override;
                
        private:
                void parse_args(const std::vector< std::pair<std::string, std::string> >& vecArgs);
                std::string dest_station_id;
                std::set< std::string > params_to_move;
 
                std::vector<MeteoData> splitTimeSeries(std::vector<MeteoData>& source);
};
 
class EditingBlockFactory {
        public:
                static EditingBlock* getBlock(const std::string& i_stationID, const std::vector< std::pair<std::string, std::string> >& vecArgs, const std::string& name, const Config &cfg);
};
 
} //namespace
 
#endif