MeteoData.h

Go to the documentation of this file.

/***********************************************************************************/
/*  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, 
                                HS, 
                                PSUM, 
                                PSUM_PH, 
                                PSUM_L, 
                                PSUM_S, 
                                TSG, 
                                TSS, 
                                TSOIL, 
                                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, 
                        COMPACT 
                } FORMATS;
                
                typedef enum MERGE_TYPE {
                                STRICT_MERGE=0, 
                                EXPAND_MERGE=1, 
                                FULL_MERGE=2 
                } Merge_Type;

                enum Parameters {firstparam=0,
                                 P=firstparam, 
                                 TA, 
                                 RH, 
                                 TSG, 
                                 TSS, 
                                 HS, 
                                 VW, 
                                 DW, 
                                 VW_MAX, 
                                 RSWR, 
                                 ISWR, 
                                 ILWR, 
                                 TAU_CLD, 
                                 PSUM, 
                                 PSUM_PH, 
                                 lastparam=PSUM_PH};

                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 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;}

                static void mergeTimeSeries(std::vector<MeteoData>& vec1, const std::vector<MeteoData>& vec2, const Merge_Type& strategy=STRICT_MERGE);

                static void merge(std::vector<MeteoData>& vec1, const std::vector<MeteoData>& vec2, const bool& simple_merge=false);

                static void merge(std::vector<MeteoData>& vec, const MeteoData& meteo2, const bool& simple_merge=false);

                static void merge(std::vector<MeteoData>& vec);

                static MeteoData merge(MeteoData meteo1, const MeteoData& meteo2);

                void merge(const MeteoData& meteo2);

                static MeteoData::Merge_Type getMergeType(std::string merge_type);

                static std::set<std::string> listAvailableParameters(const std::vector<MeteoData>& 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