ProcUndercatch_Spice.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-3.0-or-later
/***********************************************************************************/
/*      Copyright 2012 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 PROCUNDERCATCH_SPICE_H
#define PROCUNDERCATCH_SPICE_H
 
#include <meteoio/meteoFilters/ProcessingBlock.h>
#include <vector>
#include <string>
#include <map>
 
namespace mio {
 
class ProcUndercatch_Spice : public ProcessingBlock {
        public:
                ProcUndercatch_Spice(const std::vector< std::pair<std::string, std::string> >& vecArgs, const std::string& name, const Config& cfg);
 
                virtual void process(const unsigned int& param, const std::vector<MeteoData>& ivec,
                                        std::vector<MeteoData>& ovec) override;
 
        private:
                // Rain gauge models
                enum class GaugeModel {
                        Geonor,
                        Hellmann
                };
 
                // Wind speed measurement height
                enum class WindHeight {
                        Gauge,      
                        TenMeters   
                };
 
                // Correction equation types
                enum class EquationType {
                        Eq1,
                        Eq2,
                        Eq3,
                        max_eqs
                };
 
                // Configuration for a single (gauge, height, equation) triplet
                struct GaugeConfig {
                        EquationType equation;
                        double a, b, c;
                };
 
                // Setup for a (gauge, height) pair: all valid equations + fallback selection
                struct GaugeSetup {
                        GaugeConfig equations[(size_t)EquationType::max_eqs];
                        EquationType fallback_equation;  
                };
 
                // Static configuration data
                static const std::map<std::pair<GaugeModel, WindHeight>, GaugeSetup> gauge_setups;
 
                // Runtime state
                GaugeModel   active_gauge;
                WindHeight   active_height;
                EquationType primary_eq;
                EquationType fallback_eq;
                double       primary_a, primary_b, primary_c;
                double       fallback_a, fallback_b, fallback_c;
                bool         use_fallback;  
 
                // Temperature thresholds
                double Tsnow, Train;
                static const double     Tsnow_SPICE, Train_SPICE;
 
                // Correction equation implementations (from Kochendorfer et al., 2018)
                static double eq1(const double& VW, const double& TA, const double& a, const double& b, const double& c);
                static double eq2(const double& VW, const double& TA, const double& a, const double& b, const double& c);
                static double eq3(const double& VW, const double& TA, const double& a, const double& b, const double& c);
 
                void parse_args(const std::vector< std::pair<std::string, std::string> >& vecArgs);
 
                // Helper functions for parsing
                static GaugeModel parseGaugeModel(const std::string& name);
                static WindHeight parseWindHeight(const std::string& name);
                static EquationType parseEquationType(const std::string& name);
 
                // Helper to create a GaugeConfig
                static GaugeConfig makeConfig(EquationType eq, double a, double b, double c);
};
 
} //end namespace
 
#endif