Hazard.h

Go to the documentation of this file.

/* **********************************************************************************************/
/*                                        stand-alone                                          */
/*                               Derived from RESEARCH VERSION 9.0                             */
/* **********************************************************************************************/
/* **********************************************************************************/
/*  Copyright WSL Institute for Snow and Avalanche Research    SLF-DAVOS           */
/* **********************************************************************************/
/* This file is part of Snowpack.
    Snowpack is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    Snowpack 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 General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with Snowpack.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#ifndef HAZARD_H
#define HAZARD_H
 
#include <meteoio/MeteoIO.h>
#include <snowpack/DataClasses.h>
#include <vector>
 
struct ProcessDat {
        ProcessDat() : date(), nHz(0), stat_abbrev(), loc_for_snow(0), loc_for_wind(0),
                       ch(0.), swe(0.), tot_lwc(0.), runoff(0.), dewpt_def(0.), hoar_size(0.), hoar_ind6(0.), hoar_ind24(0.),
                       wind_trans(0.), wind_trans24(0.),
                       hn_half_hour(0.), hn3(0.), hn6(0.), hn12(0.), hn24(0.), hn72(0.), hn72_24(0.),
                       psum_half_hour(0.), psum3(0.), psum6(0.), psum12(0.), psum24(0.), psum72(0.),
                       stab_class1(0), stab_class2(0),
                       stab_index1(0.), stab_height1(0.), stab_index2(0.), stab_height2(0.), stab_index3(0.), stab_height3(0.), stab_index4(0.),stab_height4(0.), stab_index5(0.), stab_height5(0.),
                       crust(0.), en_bal(0.), sw_net(0.), t_top1(0.), t_top2(0.), lwi_N(0.), lwi_S(0.),
                       dhs_corr(0.), mass_corr(0.)
        {}
 
        mio::Date date;        
        unsigned int nHz;               
        std::string stat_abbrev;
        unsigned char loc_for_snow;
        unsigned char loc_for_wind;
        // Data
        double ch;             
        double swe;            
        double tot_lwc;        
        double runoff;         
        double dewpt_def;      
        double hoar_size;      
        double hoar_ind6;      
        double hoar_ind24;     
        double wind_trans;     
        double wind_trans24;   
        double hn_half_hour;   
        double hn3;            
        double hn6;            
        double hn12;           
        double hn24;           
        double hn72;           
        double hn72_24;        
        double psum_half_hour;  
        double psum3;           
        double psum6;           
        double psum12;          
        double psum24;          
        double psum72;          
        signed char stab_class1;       
        signed char stab_class2;       
        double stab_index1;    
        double stab_height1;   
        double stab_index2;    
        double stab_height2;   
        double stab_index3;    
        double stab_height3;   
        double stab_index4;    
        double stab_height4;   
        double stab_index5;    
        double stab_height5;   
        // Special parameters
        double crust;          
        double en_bal;         
        double sw_net;         
        double t_top1, t_top2; 
        double lwi_N, lwi_S;   
        // Control parameters
        double dhs_corr;  
        double mass_corr; 
};
 
struct ProcessInd {
        ProcessInd() : stat_abbrev(true), loc_for_snow(true), loc_for_wind(true),
                       ch(true), swe(true), tot_lwc(true), runoff(true), dewpt_def(true),
                       hoar_size(true), hoar_ind6(true), hoar_ind24(true),
                       wind_trans(true), wind_trans24(true),
                       hn3(true), hn6(true), hn12(true), hn24(true), hn72(true), hn72_24(true), psum3(true), psum6(true), psum12(true), psum24(true), psum72(true),
                       stab_class1(true), stab_class2(true),
                       stab_index1(true), stab_height1(true), stab_index2(true), stab_height2(true), stab_index3(true), stab_height3(true), stab_index4(true), stab_height4(true), stab_index5(true), stab_height5(true),
                       crust(true), en_bal(true), sw_net(true), t_top1(true), t_top2(true), lwi_N(true), lwi_S(true)
        {}
 
        bool stat_abbrev;
        bool loc_for_snow;
        bool loc_for_wind;
        // Data
        bool ch;
        bool swe;
        bool tot_lwc;
        bool runoff;
        bool dewpt_def;
        bool hoar_size;
        bool hoar_ind6, hoar_ind24;
        bool wind_trans, wind_trans24;
        bool hn3, hn6, hn12, hn24, hn72;
        bool hn72_24;
        bool psum3, psum6, psum12, psum24, psum72;
        bool stab_class1, stab_class2;
        bool stab_index1, stab_height1;
        bool stab_index2, stab_height2;
        bool stab_index3, stab_height3;
        bool stab_index4, stab_height4;
        bool stab_index5, stab_height5;
        bool crust;
        bool en_bal;
        bool sw_net;
        bool t_top1, t_top2;
        bool lwi_N, lwi_S;
};
 
class Hazard {
        public:
                Hazard(const SnowpackConfig& cfg, const double duration);
 
                void initializeHazard(std::vector<double>& vecDrift, double slope_angle,
                                      std::vector<ProcessDat>& Hdata, std::vector<ProcessInd>& Hdata_ind);
 
                void getHazardDataMainStation(ProcessDat& Hdata, ProcessInd& Hdata_ind,
                                      ZwischenData& Zdata, const double& newDrift, const bool stationDriftIndex,
                                      const SnowStation& Xdata, const CurrentMeteo& Mdata, const SurfaceFluxes& Sdata);
 
                void getHazardDataSlope(ProcessDat& Hdata, ProcessInd& Hdata_ind,
                                        std::vector<double>& drift24, const double& newDrift, const SnowStation& Xdata,
                                        const bool luvDriftIndex, const bool north, const bool south);
 
                static const double typical_slope_length, wind_slab_density;
                static const double minimum_drift, maximum_drift;
 
        private:
                enum ActVec {
                        noAction=0,     // neither shift nor overwite index values
                        overwrite,      // overwrite <index>[0] w/o shifting
                        pushOverwrite   // push vector values and overwrite <index>[0]
                };
 
                void actOnVector(std::vector<double>& oldVector, const double& newValue, const ActVec& action);
 
                double compDriftIndex(std::vector<double>& vecDrift, const double& drift, const double& rho,
                                      const unsigned int& nHours, const double& slope_angle, const ActVec& action);
 
                void getDriftIndex(ProcessDat& Hdata, ProcessInd& Hdata_ind,
                                   std::vector<double>& vecDrift, const double& newDriftValue, const double slope_angle);
 
                double compHoarIndex(std::vector<double> &oldHoar, const double& newHoar,
                             const unsigned int& nHours, const ActVec& action);
 
                double compDewPointDeficit(double TA, double TSS, double RH);
 
                void compMeltFreezeCrust(const SnowStation& Xdata, ProcessDat& Hdata, ProcessInd& Hdata_ind);
 
                bool research_mode, enforce_measured_snow_heights, force_rh_water;
                unsigned int nHz, hazard_steps_between;
                double sn_dt;
                double hoar_density_surf, hoar_min_size_surf;
};
 
#endif