SnowpackInterface.h

Go to the documentation of this file.

/***********************************************************************************/
/*  Copyright 2009-2015 WSL Institute for Snow and Avalanche Research    SLF-DAVOS      */
/***********************************************************************************/
/* This file is part of Alpine3D.
    Alpine3D 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.
 
    Alpine3D 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 Alpine3D.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef SNOWPACKINTERFACE_H
#define SNOWPACKINTERFACE_H
 
#include <meteoio/MeteoIO.h>
#include <snowpack/libsnowpack.h>
#include <alpine3d/MeteoObj.h>
 
class SnowpackInterfaceWorker;
class SnowDriftA3D;
 
#include <alpine3d/DataAssimilation.h>
#include <alpine3d/snowdrift/SnowDrift.h>
#include <alpine3d/SnowpackInterfaceWorker.h>
#include <alpine3d/Glaciers.h>
#include <alpine3d/TechSnowA3D.h>
 
 class SnowpackInterface
  {
        public:
                // Methods for accessing Snowpack Interface Manager
                SnowpackInterface(const mio::Config &io_cfg, const size_t& nbworkers,
                                  const mio::DEMObject& dem_in,
                                  const mio::Grid2DObject& landuse_in, const std::vector<mio::Coords>& vec_pts,
                      const mio::Date& startTime, const std::string& grids_requirements, const bool is_restart_in);
                SnowpackInterface(const SnowpackInterface&);
                ~SnowpackInterface();
 
                SnowpackInterface& operator=(const SnowpackInterface&); 
 
                double getTiming() const;
                void writeOutput(const mio::Date& julian);
                void writeOutputSNO(const mio::Date& julian);
 
                // Methods to set other modules
                void setSnowDrift(SnowDriftA3D& drift);
                void setEnergyBalance(EnergyBalance& myeb);
                void setDataAssimilation(DataAssimilation& init_da);
 
                // Methods to communicate with other modules
                void setSnowDrift();
                void setEnergyBalance();
                void assimilate(const mio::Grid2DObject& daData, const mio::Date& timestamp);
                void setSnowMassChange(const mio::Grid2DObject& new_mns, const mio::Date& timestamp);
                void setMeteo(const mio::Grid2DObject& new_psum,
                              const mio::Grid2DObject& new_psum_ph,
                              const mio::Grid2DObject& new_vw,
                              const mio::Grid2DObject& new_dw,
                              const mio::Grid2DObject& new_rh,
                              const mio::Grid2DObject& new_ta,
                              const mio::Date& timestamp);
                void setRadiationComponents(const mio::Array2D<double>& shortw,
                                            const mio::Array2D<double>& longwave,
                                            const mio::Array2D<double>& diff,
                                            const mio::Array2D<double>& terrain_shortwave_in,
                                            const mio::Array2D<double>& terrain_longwave_in,
                                            const double& solarElevation,
                                            const mio::Date& timestamp);
 
                mio::Grid2DObject getGrid(const SnGrids::Parameters& param) const;
                void calcNextStep();
 
        private:
                static const std::vector<std::string> grids_not_computed_in_worker;
                std::string getGridsRequirements() const;
                mio::Config readAndTweakConfig(const mio::Config& io_cfg,const bool have_pts);
                bool do_grid_output(const mio::Date &date) const;
                void setInitGlacierThickness();
                SN_SNOWSOIL_DATA getIcePixel(const double glacier_thickness, const std::stringstream& GRID_sno, const bool seaIce);
                void readInitalSnowCover(std::vector<SnowStation*>& snow_stations,
                             std::vector<std::pair<size_t,size_t> >& snow_stations_coord);
                void readSnowCover(const std::string& GRID_sno, const std::string& LUS_sno, const bool& is_special_point,
                             SN_SNOWSOIL_DATA &sno, ZwischenData &zwischenData, const bool& read_seaice);
                void writeSnowCover(const mio::Date& date, const std::vector<SnowStation*>& snow_station);
 
                void write_SMET_header(const mio::StationData& meta, const double& landuse_code) const;
                void write_SMET(const CurrentMeteo& met, const mio::StationData& meta, const SurfaceFluxes& surf) const;
                void writeOutputSpecialPoints(const mio::Date& date, const std::vector<SnowStation*>& snow_pixel, const std::vector<CurrentMeteo*>& meteo_pixel,
                                              const std::vector<SurfaceFluxes*>& surface_flux);
                void write_special_points();
                void calcLateralFlow();
                void redistributeLateralWaterFlux(int ixd, int iyd, const std::vector<std::pair<size_t, size_t>>& coords, const std::vector<SnowStation*>& snow_pixel, SnowStation* sp, double tmp_dist, double f);
 
                RunInfo run_info;
 
                // MeteoIO, used to output grids
                mio::IOManager io;
 
                std::vector< std::pair<size_t,size_t> > pts; //special points
 
                const mio::DEMObject dem;       // full DEM
                mio::DEMObject omp_dem;         // DEM shared by OMP workers (after MPI slicing)
 
                // Config dependent information
                bool is_restart, useCanopy, enable_lateral_flow, a3d_view;
                bool do_io_locally; // if false all I/O will only be done on the master process
                std::string station_name; // value for the key OUTPUT::EXPERIMENT
                bool glacier_katabatic_flow, snow_production, snow_grooming;
                // Output
                std::vector<std::string> Tsoil_idx; //TSOIL names in order to build the "field" header of the smet output
                std::vector<std::string> soil_runoff_idx; // Runoff depths names in order to build the "field" header of the smet output
                double grids_start, grids_days_between; //gridded outputs
                double ts_start, ts_days_between; //time series outputs
                double prof_start, prof_days_between; //profiles outputs
                bool grids_write, ts_write, prof_write, snow_write, write_poi_meteo, snow_poi_written, glacier_from_grid;
                std::string meteo_outpath;
                std::string outpath;
                bool mask_glaciers; //mask glaciers in outputs?
                bool mask_dynamic; //mask glaciers in outputs changes over time?
                mio::Grid2DObject maskGlacier; // save the mask
                double tz_out;
 
                SnowpackConfig sn_cfg;
                // SnowpackIO, used to output non grids data
                SnowpackIO snowpackIO;
 
                size_t dimx, dimy;
                size_t mpi_offset, mpi_nx;
                mio::Grid2DObject landuse, omp_landuse; // full land use map, and land use map shared by OMP workers (after MPI slicing)
                // meteo forcing variables
                mio::Grid2DObject mns, shortwave, longwave, diffuse, terrain_shortwave, terrain_longwave;
                mio::Grid2DObject psum, psum_ph, psum_tech, grooming, vw, dw, rh, ta, init_glaciers_thickness;
                double solarElevation;
 
                std::vector<std::string> output_grids; //which grids should be written out
                std::vector<SnowpackInterfaceWorker*> workers;
                std::vector<size_t> worker_startx; // stores offset for each workers slice
                std::vector<size_t> worker_deltax; // stores size for each workers slize
                std::vector<std::vector<std::pair<size_t,size_t> > > worker_stations_coord; // stores the grid coordinates of each worker
                // time relevant
                mio::Timer timer; // used to measure calc time of one step
                mio::Date nextStepTimestamp;
                double timeStep; // size of timestep
 
                bool dataMeteo2D, dataDa, dataSnowDrift, dataRadiation; // say, if data are present for the actual step
 
                // ==== other Modules ====
                SnowDriftA3D *drift;
                EnergyBalance *eb;
                DataAssimilation *da;
 
                Glaciers *glaciers;
                TechSnowA3D *techSnow;
};
 
#endif