MeteoData.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-3.0-or-later
/***********************************************************************************/
/*  Copyright 2009 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 METEODATA_H
#define METEODATA_H
 
#include <meteoio/dataClasses/Date.h>
#include <meteoio/dataClasses/StationData.h>
 
#include <string>
#include <vector>
#include <set>
 
namespace mio {
 
class MeteoData; //forward declaration
typedef std::vector<MeteoData> METEO_SET;
 
class MeteoGrids {
        public:
                enum Parameters {firstparam=0,
                                TA=firstparam, 
                                RH, 
                                QI, 
                                TD, 
                                VW, 
                                DW, 
                                VW_MAX, 
                                ISWR, 
                                RSWR, 
                                ISWR_DIFF, 
                                ISWR_DIR, 
                                ILWR, 
                                OLWR, 
                                TAU_CLD, 
                                CLD, 
                                HS, 
                                PSUM, 
                                PSUM_PH, 
                                PSUM_L, 
                                PSUM_S, 
                                TSG, 
                                TSS, 
                                TSOIL, 
                                TSNOW, 
                                P, 
                                P_SEA, 
                                U, 
                                V, 
                                W, 
                                SWE, 
                                RSNO, 
                                ROT, 
                                ALB, 
                                DEM, 
                                SHADE, 
                                SLOPE, 
                                AZI, 
                                lastparam=AZI};
 
                static const size_t nrOfParameters; 
                static size_t getParameterIndex(const std::string& parname);
                static const std::string getParameterName(const size_t& parindex);
                static const std::string getParameterDescription(const size_t& parindex, const bool& allow_ws=true);
                static const std::string getParameterUnits(const size_t& parindex);
 
        private:
                //static methods
                static std::vector<std::string> paramname, description, units;
                static const bool __init;    
                static bool initStaticData();
};
 
class MeteoData {
        public:
                typedef enum {
                        DFLT, 
                        FULL, 
                        COMPACT 
                } FORMATS;
                
                typedef enum MERGE_TYPE {
                                STRICT_MERGE=0, 
                                EXPAND_MERGE=1, 
                                FULL_MERGE=2, 
                                WINDOW_MERGE=3 
                } Merge_Type;
                
                typedef enum MERGE_CONFLICTS {
                                CONFLICTS_PRIORITY_FIRST=0, 
                                CONFLICTS_PRIORITY_LAST=1, 
                                CONFLICTS_AVERAGE=2 
                } Merge_Conflicts;
 
                enum Parameters {firstparam=0,
                                 P=firstparam, 
                                 TA, 
                                 RH, 
                                 TSG, 
                                 TSS, 
                                 TSOIL, 
                                 TSNOW, 
                                 HS, 
                                 VW, 
                                 DW, 
                                 VW_MAX, 
                                 RSWR, 
                                 ISWR, 
                                 ILWR, 
                                 TAU_CLD, 
                                 PSUM, 
                                 PSUM_PH, 
                                 lastparam=PSUM_PH};
                
                static Parameters toParameter(const std::string& paramStr);
                static std::string parToString(const Parameters& param);
 
                static const std::string& getParameterName(const size_t& parindex);
 
                static size_t getStaticParameterIndex(const std::string& parname);
 
                MeteoData(void);
 
                MeteoData(const Date& in_date);
 
                MeteoData(const StationData& meta_in);
                
                MeteoData(const Date& date_in, const StationData& meta_in);
 
                void setDate(const Date& in_date) {date = in_date;}
 
                size_t addParameter(const std::string& i_paramname);
 
                bool param_exists(const std::string& parname) const;
 
                void reset();
                
                bool isNodata() const;
 
                bool isResampled() const {return resampled;}
                void setResampled(const bool& in_resampled) {resampled = in_resampled;}
 
                bool isFiltered(const size_t& param) const;
                void setFiltered(const size_t& param, const bool& in_filtered = true);
                bool isGenerated(const size_t& param) const;
                void setGenerated(const size_t& param, const bool& in_generated = true);
                bool isResampledParam(const size_t& param) const;
                void setResampledParam(const size_t& param, const bool& in_resampled = true);
 
                void standardizeNodata(const double& plugin_nodata);
 
                double& operator()(const size_t& parindex);
                const double& operator()(const size_t& parindex) const;
                double& operator()(const std::string& parname);
                const double& operator()(const std::string& parname) const;
 
                const std::string& getNameForParameter(const size_t& parindex) const;
                size_t getParameterIndex(const std::string& parname) const;
                size_t getNrOfParameters() const {return nrOfAllParameters;}
                size_t getOccurencesOfParameter(const Parameters& par, const std::set<std::string>& additional_parameters = std::set<std::string>()) const;
                std::vector<double> getHeightsForParameter(const std::string& in_parname, bool include_default = true, const std::set<std::string>& additional_parameters = std::set<std::string>()) const;
                size_t listUnknownParameters(const std::set<std::string>& additional_params = std::set<std::string>()) const;
                static std::string convertHeightToString(const double& height);
 
 
                static bool getTypeAndNo(const std::string& parname, std::string& par, double& number, const std::set<std::string>& additional_parameters = std::set<std::string>());
                static bool sameParameterType(const std::string& par1, const std::string& par2, const std::set<std::string>& additional_parameters = std::set<std::string>());
                static std::vector<std::string> retrieveAllHeightsForParam(const std::set<std::string>& available_parameters, const std::string& parname, const std::set<std::string>& additional_parameters = std::set<std::string>());
                static std::vector<std::string> retrieveAllParametersAtHeight(const std::set<std::string>& available_parameters, const double& height, const std::set<std::string>& additional_parameters = std::set<std::string>());
                static std::set<double> retrieveAllHeights(const std::set<std::string>& available_parameters, const std::set<std::string>& additional_parameters = std::set<std::string>());
                static std::set<std::string> retriveUniqueParameters(const std::set<std::string>& available_parameters, const std::set<std::string>& additional_parameters=std::set<std::string>());
                static std::vector<std::string> sortListByParams(const std::vector<std::string>& param_list, const std::set<std::string>& available_parameters = std::set<std::string>());
 
 
                static MeteoGrids::Parameters findGridParam(const Parameters& mpar);
                static Parameters findMeteoParam(const MeteoGrids::Parameters& gpar);
 
                static size_t mergeTimeSeries(std::vector<MeteoData>& vec1, const std::vector<MeteoData>& vec2, const Merge_Type& strategy=STRICT_MERGE, const Merge_Conflicts& conflicts_strategy=CONFLICTS_PRIORITY_FIRST);
 
                static void merge(std::vector<MeteoData>& vec1, const std::vector<MeteoData>& vec2, const bool& simple_merge=false, const Merge_Conflicts& conflicts_strategy=CONFLICTS_PRIORITY_FIRST);
 
                static void merge(std::vector<MeteoData>& vec, const MeteoData& meteo2, const bool& simple_merge=false, const Merge_Conflicts& conflicts_strategy=CONFLICTS_PRIORITY_FIRST);
 
                static void merge(std::vector<MeteoData>& vec, const Merge_Conflicts& conflicts_strategy=CONFLICTS_PRIORITY_FIRST);
 
                static MeteoData merge(MeteoData meteo1, const MeteoData& meteo2, const Merge_Conflicts& conflicts_strategy=CONFLICTS_PRIORITY_FIRST);
 
                bool merge(const MeteoData& meteo2, const Merge_Conflicts& conflicts_strategy=CONFLICTS_PRIORITY_FIRST);
 
                bool hasConflicts(const MeteoData& meteo2) const;
                
                static MeteoData::Merge_Type getMergeType(std::string merge_type);
                
                static MeteoData::Merge_Conflicts getMergeConflicts(std::string merge_conflicts);
 
                static std::set<std::string> listAvailableParameters(const std::vector<MeteoData>& vecMeteo);
                
 
                static void unifyMeteoData(METEO_SET &vecMeteo);
 
                const std::string toString(const FORMATS format=DFLT) const;
                friend std::ostream& operator<<(std::ostream& os, const MeteoData& data);
                friend std::istream& operator>>(std::istream& is, MeteoData& data);
 
                //Comparison operators
                bool operator==(const MeteoData&) const; 
                inline bool operator!=(const MeteoData& in) const {return !(*this==in);} 
                inline bool operator<(const MeteoData& in) const {return (this->date < in.date);} 
                inline bool operator>(const MeteoData& in) const {return (this->date > in.date);} 
 
                //direct access allowed
                Date date; 
                StationData meta; 
 
                static const size_t nrOfParameters; 
 
                const std::string getStationID() const {return meta.stationID;}
 
        private:
 
                struct flag_field { //object to hold all data quality / datapoint meta flags
                        bool filtered : 1;
                        bool resampled : 1;
                        bool generated : 1;
                        bool created : 1; //TODO: not yet filled in the creators!
                        bool : 1; //leave one empty for future flag
                        unsigned int extra_flag : 3; //rest of byte space could be any 3-bit-value
                        float offset; //an offset that has been applied to the data at this time step
                };
 
                //static methods
                static std::vector<std::string> s_default_paramname; 
                static const double epsilon; 
                static const bool __init;    
                static bool initStaticData();
 
                //private data members, please keep the order consistent with declaration lists and logic!
                std::vector<std::string> extra_param_name;
                std::vector<double> data;
 
                size_t nrOfAllParameters;
 
                //data qa containers:
                bool resampled; 
                std::vector<flag_field> flags; 
                static flag_field zero_flag; //TODO: is there a way to make this const?
};
 
} //end namespace
 
#endif