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 <iostream>
#include <meteoio/MeteoIO.h>
#include <snowpack/libsnowpack.h>
#include <alpine3d/MeteoObj.h>

class SnowpackInterfaceWorker;
class SnowDriftA3D;
class Runoff; // forward declaration, cyclic header include

#include <alpine3d/DataAssimilation.h>
#include <alpine3d/runoff/Runoff.h>
#include <alpine3d/snowdrift/SnowDrift.h>
#include <alpine3d/SnowpackInterfaceWorker.h>
#include <alpine3d/Glaciers.h>
#include <alpine3d/TechSnowA3D.h>

 class SnowpackInterface
  {
        public:
                // Methods for accessing Snopack 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);
                void setRunoff(Runoff& init_runoff);

                // Methods to communicate with other modules
                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 double& solarElevation,
                                            const mio::Date& timestamp);

                mio::Grid2DObject getGrid(const SnGrids::Parameters& param) const;

        private:
                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 calcNextStep();
                void setInitGlacierHeight();
                SN_SNOWSOIL_DATA getIcePixel(const double glacier_height, 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();

                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;

                // 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
                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, 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;
                // meteo forcing variables
                mio::Grid2DObject mns, shortwave, longwave, diffuse;
                mio::Grid2DObject psum, psum_ph, psum_tech, grooming, vw, dw, rh, ta, init_glaciers_height;
                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; // ttores te grid coordiante of each worker
                // time relevant
                mio::Timer timer; // used to mesure 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 actuall step

                // ==== other Modules ====
                SnowDriftA3D *drift;
                EnergyBalance *eb;
                DataAssimilation *da;
                Runoff *runoff;

                Glaciers *glaciers;
                TechSnowA3D *techSnow;
};

#endif