WSL/SLF GitLab Repository

Commit 764a3ec9 authored by Mathias Bavay's avatar Mathias Bavay
Browse files

Now the dataCreators are defined in the [Input] section with a...

Now the dataCreators are defined in the [Input] section with a {parameter}::create = {algorithm} statement. They behave the same as the dataGenerators but are called *before* the filtering takes place and always work with the whole vector of data (ie whole dataset). In order to make life easier for the devs, a new structure will be devised...
parent 0564cf99
......@@ -44,6 +44,7 @@ SET(meteoio_sources
ResamplingAlgorithms2D.cc
Meteo1DInterpolator.cc
Meteo2DInterpolator.cc
DataCreator.cc
DataGenerator.cc
plugins/libsmet.cc
IOInterface.cc
......
/***********************************************************************************/
/* Copyright 2013 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/>.
*/
#include <meteoio/DataCreator.h>
using namespace std;
namespace mio {
DataCreator::DataCreator(const Config& cfg)
: mapCreators()
{
const std::string key_pattern( "::create" );
std::set<std::string> set_of_used_parameters;
getParameters(cfg, key_pattern, set_of_used_parameters);
std::set<std::string>::const_iterator it;
for (it = set_of_used_parameters.begin(); it != set_of_used_parameters.end(); ++it) {
std::vector<std::string> tmpAlgorithms;
const std::string parname( *it );
const size_t nrOfAlgorithms = getAlgorithmsForParameter(cfg, key_pattern, parname, tmpAlgorithms);
std::vector<GeneratorAlgorithm*> vecGenerators(nrOfAlgorithms);
for (size_t jj=0; jj<nrOfAlgorithms; jj++) {
std::vector<std::string> vecArgs;
getArgumentsForAlgorithm(cfg, parname, tmpAlgorithms[jj], vecArgs);
vecGenerators[jj] = GeneratorAlgorithmFactory::getAlgorithm( cfg, tmpAlgorithms[jj], vecArgs);
}
if (nrOfAlgorithms>0) {
mapCreators[parname] = vecGenerators;
}
}
}
DataCreator::~DataCreator()
{ //we have to deallocate the memory allocated by "new GeneratorAlgorithm()"
std::map< std::string, std::vector<GeneratorAlgorithm*> >::iterator it;
for (it=mapCreators.begin(); it!=mapCreators.end(); ++it) {
std::vector<GeneratorAlgorithm*> &vec( it->second );
for (size_t ii=0; ii<vec.size(); ii++)
delete vec[ii];
}
}
DataCreator& DataCreator::operator=(const DataCreator& source)
{
if (this != &source) {
mapCreators = source.mapCreators;
}
return *this;
}
/**
* @brief create new parameters from parametrizations
* This relies on data creators defined by the user for each meteo parameters.
* This loops over the defined generators and stops as soon as all points
* have been successfully created.
* @param vecVecMeteo vector containing a timeserie for each station
*/
void DataCreator::createParameters(std::vector<METEO_SET>& vecVecMeteo) const
{
if (mapCreators.empty()) return; //no creators defined by the end user
std::map< std::string, std::vector<GeneratorAlgorithm*> >::const_iterator it;
for (it=mapCreators.begin(); it!=mapCreators.end(); ++it) {
const std::vector<GeneratorAlgorithm*> vecGenerators( it->second );
for (size_t station=0; station<vecVecMeteo.size(); ++station) { //process this parameter on all stations
//create the new parameter
for (size_t ii=0; ii<vecVecMeteo[station].size(); ++ii) {
vecVecMeteo[station][ii].addParameter( it->first );
}
const size_t param = vecVecMeteo[station][0].getParameterIndex(it->first);
//fill the new parameter
size_t jj=0;
while (jj<vecGenerators.size() && vecGenerators[jj]->generate(param, vecVecMeteo[station]) != true) jj++;
}
}
}
void DataCreator::getParameters(const Config& cfg, const std::string& key_pattern, std::set<std::string>& set_parameters)
{
set_parameters.clear();
std::vector<std::string> vec_keys;
cfg.findKeys(vec_keys, key_pattern, "Input", true); //search anywhere in key
for (size_t ii=0; ii<vec_keys.size(); ii++) {
const size_t found = vec_keys[ii].find_first_of(":");
if (found != std::string::npos){
const string tmp( vec_keys[ii].substr(0,found) );
set_parameters.insert( IOUtils::strToUpper(tmp) );
}
}
}
// This function retrieves the user defined generator algorithms for
// parameter 'parname' by querying the Config object
size_t DataCreator::getAlgorithmsForParameter(const Config& cfg, const std::string& key_pattern, const std::string& parname, std::vector<std::string>& vecAlgorithms)
{
vecAlgorithms.clear();
std::vector<std::string> vecKeys;
cfg.findKeys(vecKeys, parname+key_pattern, "Input");
if (vecKeys.size() > 1)
throw IOException("Multiple definitions of " + parname + "::generators in config file", AT);;
if (vecKeys.empty())
return 0;
cfg.getValue(vecKeys.at(0), "Input", vecAlgorithms, IOUtils::nothrow);
return vecAlgorithms.size();
}
size_t DataCreator::getArgumentsForAlgorithm(const Config& cfg,
const std::string& parname,
const std::string& algorithm,
std::vector<std::string>& vecArgs)
{
vecArgs.clear();
cfg.getValue(parname+"::"+algorithm, "Input", vecArgs, IOUtils::nothrow);
return vecArgs.size();
}
const std::string DataCreator::toString() const {
std::ostringstream os;
os << "<DataCreator>\n";
os << "Creators defined: " << std::boolalpha << !mapCreators.empty() << std::noboolalpha << "\n";
if (!mapCreators.empty()) {
os << "User list of creators:\n";
for (std::map< std::string, std::vector<GeneratorAlgorithm*> >::const_iterator iter = mapCreators.begin(); iter != mapCreators.end(); ++iter) {
os << setw(10) << iter->first << " :: ";
for (size_t jj=0; jj<iter->second.size(); jj++) {
os << iter->second[jj]->getAlgo() << " ";
}
os << "\n";
}
}
os << "</DataCreator>\n";
return os.str();
}
} //namespace
/***********************************************************************************/
/* Copyright 2013 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 DATACREATOR_H
#define DATACREATOR_H
#include <meteoio/Config.h>
#include <meteoio/dataClasses/MeteoData.h>
#include <meteoio/dataGenerators/GeneratorAlgorithms.h>
#include <vector>
#include <map>
#include <set>
namespace mio {
/**
* @class DataCreator
* @brief A class to create new meteo data parameters from user-selected models or parametrizations.
* This class sits in between the actual implementation of the various methods and the IOManager in
* order to offer some high level interface. It basically reads the arguments and creates the objects for
* the various data generators in its constructor and loop through the parameters and stations when called.
*
* @ingroup meteoLaws
* @author Mathias Bavay
*/
class DataCreator {
public:
DataCreator(const Config& cfg);
DataCreator(const DataCreator& c) : mapCreators(c.mapCreators) {}
~DataCreator();
void createParameters(std::vector<METEO_SET>& vecVecMeteo) const;
DataCreator& operator=(const DataCreator& source);
const std::string toString() const;
private:
static void getParameters(const Config& cfg, const std::string& key_pattern, std::set<std::string>& set_parameters);
static size_t getAlgorithmsForParameter(const Config& cfg, const std::string& key_pattern, const std::string& parname, std::vector<std::string>& vecAlgorithms);
static size_t getArgumentsForAlgorithm(const Config& cfg, const std::string& parname,
const std::string& algorithm,
std::vector<std::string>& vecArgs);
std::map< std::string, std::vector<GeneratorAlgorithm*> > mapCreators; //per parameter data creators algorithms
};
} //end namespace
#endif
......@@ -22,18 +22,30 @@ using namespace std;
namespace mio {
/**
*
*/ //explain how to use the generators for the end user
DataGenerator::DataGenerator(const Config& cfg)
: mapGenerators(), mapCreators(), generators_defined(false), creators_defined(false)
: mapGenerators()
{
setAlgorithms(cfg, "::generators", mapGenerators);
generators_defined = !mapGenerators.empty();
const std::string key_pattern( "::generators" );
std::set<std::string> set_of_used_parameters;
getParameters(cfg, key_pattern, set_of_used_parameters);
set<string>::const_iterator it;
for (it = set_of_used_parameters.begin(); it != set_of_used_parameters.end(); ++it) {
std::vector<std::string> tmpAlgorithms;
const std::string parname( *it );
const size_t nrOfAlgorithms = getAlgorithmsForParameter(cfg, key_pattern, parname, tmpAlgorithms);
std::vector<GeneratorAlgorithm*> vecGenerators(nrOfAlgorithms);
for (size_t jj=0; jj<nrOfAlgorithms; jj++) {
std::vector<std::string> vecArgs;
getArgumentsForAlgorithm(cfg, parname, tmpAlgorithms[jj], vecArgs);
vecGenerators[jj] = GeneratorAlgorithmFactory::getAlgorithm( cfg, tmpAlgorithms[jj], vecArgs);
}
setAlgorithms(cfg, "::create", mapCreators);
creators_defined = !mapCreators.empty();
if (nrOfAlgorithms>0) {
mapGenerators[parname] = vecGenerators;
}
}
}
DataGenerator::~DataGenerator()
......@@ -45,21 +57,12 @@ DataGenerator::~DataGenerator()
for (size_t ii=0; ii<vec.size(); ii++)
delete vec[ii];
}
for (it=mapCreators.begin(); it!=mapCreators.end(); ++it) {
std::vector<GeneratorAlgorithm*> &vec( it->second );
for (size_t ii=0; ii<vec.size(); ii++)
delete vec[ii];
}
}
DataGenerator& DataGenerator::operator=(const DataGenerator& source)
{
if (this != &source) {
mapGenerators = source.mapGenerators;
mapCreators = source.mapCreators;
generators_defined = source.generators_defined;
creators_defined = source.creators_defined;
}
return *this;
}
......@@ -73,7 +76,7 @@ DataGenerator& DataGenerator::operator=(const DataGenerator& source)
*/
void DataGenerator::fillMissing(METEO_SET& vecMeteo) const
{
if (!generators_defined) return; //no generators defined by the end user
if (mapGenerators.empty()) return; //no generators defined by the end user
std::map< std::string, std::vector<GeneratorAlgorithm*> >::const_iterator it;
for (it=mapGenerators.begin(); it!=mapGenerators.end(); ++it) {
......@@ -85,9 +88,9 @@ void DataGenerator::fillMissing(METEO_SET& vecMeteo) const
#ifdef DATA_QA
double old_val = vecMeteo[station](param);
const string statName = vecMeteo[station].meta.getStationName();
const string statID = vecMeteo[station].meta.getStationID();
const string stat = (!statID.empty())? statID : statName;
const std::string statName( vecMeteo[station].meta.getStationName() );
const std::string statID( vecMeteo[station].meta.getStationID() );
const std::string stat = (!statID.empty())? statID : statName;
#endif
bool status = false;
......@@ -97,8 +100,8 @@ void DataGenerator::fillMissing(METEO_SET& vecMeteo) const
jj++;
#ifdef DATA_QA
if (vecMeteo[station](param) != old_val) {
const string parname = it->first;
const string algo_name = vecGenerators[jj-1]->getAlgo();
const std::string parname( it->first );
const std::string algo_name( vecGenerators[jj-1]->getAlgo() );
const Date date( vecMeteo[station].date );
cout << "[DATA_QA] Generating " << stat << "::" << parname << "::" << algo_name << " " << date.toString(Date::ISO_TZ) << " [" << date.toString(Date::ISO_WEEK) << "]\n";
}
......@@ -117,7 +120,7 @@ void DataGenerator::fillMissing(METEO_SET& vecMeteo) const
*/
void DataGenerator::fillMissing(std::vector<METEO_SET>& vecVecMeteo) const
{
if (!generators_defined) return; //no generators defined by the end user
if (mapGenerators.empty()) return; //no generators defined by the end user
std::map< std::string, std::vector<GeneratorAlgorithm*> >::const_iterator it;
for (it=mapGenerators.begin(); it!=mapGenerators.end(); ++it) {
......@@ -129,9 +132,9 @@ void DataGenerator::fillMissing(std::vector<METEO_SET>& vecVecMeteo) const
#ifdef DATA_QA
METEO_SET old_val = vecVecMeteo[station];
const string statName = old_val[0].meta.getStationName();
const string statID = old_val[0].meta.getStationID();
const string stat = (!statID.empty())? statID : statName;
const std::string statName( old_val[0].meta.getStationName() );
const std::string statID( old_val[0].meta.getStationID() );
const std::string stat = (!statID.empty())? statID : statName;
#endif
bool status = false;
......@@ -140,8 +143,8 @@ void DataGenerator::fillMissing(std::vector<METEO_SET>& vecVecMeteo) const
status = vecGenerators[jj]->generate(param, vecVecMeteo[station]);
jj++;
#ifdef DATA_QA
const string parname = it->first;
const string algo_name = vecGenerators[jj-1]->getAlgo();
const std::string parname( it->first );
const std::string algo_name( vecGenerators[jj-1]->getAlgo() );
for (size_t kk=0; kk<old_val.size(); kk++) {
if (old_val[kk](param) != vecVecMeteo[station][kk](param)) {
cout << "[DATA_QA] Generating " << stat << "::" << parname << "::" << algo_name << " " << old_val[kk].date.toString(Date::ISO_TZ) << "\n";
......@@ -153,92 +156,6 @@ void DataGenerator::fillMissing(std::vector<METEO_SET>& vecVecMeteo) const
}
}
/**
* @brief create new parameters from parametrizations
* This relies on data creators defined by the user for each meteo parameters.
* This loops over the defined generators and stops as soon as all points
* have been successfully created.
* @param vecMeteo vector containing one point for each station
*/
void DataGenerator::createParameters(METEO_SET& vecMeteo) const
{
if (!creators_defined) return; //no creators defined by the end user
std::map< std::string, std::vector<GeneratorAlgorithm*> >::const_iterator it;
for (it=mapCreators.begin(); it!=mapCreators.end(); ++it) {
const std::vector<GeneratorAlgorithm*> vecGenerators( it->second );
for (size_t station=0; station<vecMeteo.size(); ++station) { //process this parameter on all stations
const size_t param = vecMeteo[station].addParameter( it->first );
size_t jj=0;
while (jj<vecGenerators.size() && vecGenerators[jj]->generate(param, vecMeteo[station]) != true) jj++;
}
}
}
/**
* @brief create new parameters from parametrizations
* This relies on data creators defined by the user for each meteo parameters.
* This loops over the defined generators and stops as soon as all points
* have been successfully created.
* @param vecVecMeteo vector containing a timeserie for each station
*/
void DataGenerator::createParameters(std::vector<METEO_SET>& vecVecMeteo) const
{
if (!creators_defined) return; //no creators defined by the end user
std::map< std::string, std::vector<GeneratorAlgorithm*> >::const_iterator it;
for (it=mapCreators.begin(); it!=mapCreators.end(); ++it) {
const std::vector<GeneratorAlgorithm*> vecGenerators( it->second );
for (size_t station=0; station<vecVecMeteo.size(); ++station) { //process this parameter on all stations
//create the new parameter
for (size_t ii=0; ii<vecVecMeteo[station].size(); ++ii) {
vecVecMeteo[station][ii].addParameter( it->first );
}
const size_t param = vecVecMeteo[station][0].getParameterIndex(it->first);
//fill the new parameter
size_t jj=0;
while (jj<vecGenerators.size() && vecGenerators[jj]->generate(param, vecVecMeteo[station]) != true) jj++;
}
}
}
/** @brief build the generators for each meteo parameter
* By reading the Config object build up a list of user configured algorithms
* for each MeteoData::Parameters parameter (i.e. each member variable of MeteoData like ta, p, psum, ...)
* Concept of this constructor: loop over all MeteoData::Parameters and then look
* for configuration of interpolation algorithms within the Config object.
* @param[in] cfg configuration object to use for getting the algorithms configuration
* @param[in] key_pattern pattern used to match the keys defining DataGenerators algorithms (for example "::generators")
* @param[out] mapAlgorithms map storing the DataGenerators for each meteorological parameter (as string)
*/
void DataGenerator::setAlgorithms(const Config& cfg, const std::string& key_pattern, std::map< std::string, std::vector<GeneratorAlgorithm*> > &mapAlgorithms)
{
set<string> set_of_used_parameters;
getParameters(cfg, key_pattern, set_of_used_parameters);
set<string>::const_iterator it;
for (it = set_of_used_parameters.begin(); it != set_of_used_parameters.end(); ++it) {
std::vector<std::string> tmpAlgorithms;
const std::string parname( *it );
const size_t nrOfAlgorithms = getAlgorithmsForParameter(cfg, key_pattern, parname, tmpAlgorithms);
std::vector<GeneratorAlgorithm*> vecGenerators(nrOfAlgorithms);
for (size_t jj=0; jj<nrOfAlgorithms; jj++) {
std::vector<std::string> vecArgs;
getArgumentsForAlgorithm(cfg, parname, tmpAlgorithms[jj], vecArgs);
vecGenerators[jj] = GeneratorAlgorithmFactory::getAlgorithm( cfg, tmpAlgorithms[jj], vecArgs);
}
if (nrOfAlgorithms>0) {
mapAlgorithms[parname] = vecGenerators;
}
}
}
void DataGenerator::getParameters(const Config& cfg, const std::string& key_pattern, std::set<std::string>& set_parameters)
{
set_parameters.clear();
......@@ -254,10 +171,10 @@ void DataGenerator::getParameters(const Config& cfg, const std::string& key_patt
}
}
// This function retrieves the user defined generator algorithms for
// parameter 'parname' by querying the Config object
size_t DataGenerator::getAlgorithmsForParameter(const Config& cfg, const std::string& key_pattern, const std::string& parname, std::vector<std::string>& vecAlgorithms)
{
// This function retrieves the user defined generator algorithms for
// parameter 'parname' by querying the Config object
vecAlgorithms.clear();
std::vector<std::string> vecKeys;
......@@ -288,8 +205,8 @@ size_t DataGenerator::getArgumentsForAlgorithm(const Config& cfg,
const std::string DataGenerator::toString() const {
std::ostringstream os;
os << "<DataGenerator>\n";
os << "Generators defined: " << std::boolalpha << generators_defined << std::noboolalpha << "\n";
if (generators_defined) {
os << "Generators defined: " << std::boolalpha << !mapGenerators.empty() << std::noboolalpha << "\n";
if (!mapGenerators.empty()) {
os << "User list of generators:\n";
for (std::map< std::string, std::vector<GeneratorAlgorithm*> >::const_iterator iter = mapGenerators.begin(); iter != mapGenerators.end(); ++iter) {
os << setw(10) << iter->first << " :: ";
......@@ -300,18 +217,6 @@ const std::string DataGenerator::toString() const {
}
}
os << "Creators defined: " << std::boolalpha << creators_defined << std::noboolalpha << "\n";
if (creators_defined) {
os << "User list of creators:\n";
for (std::map< std::string, std::vector<GeneratorAlgorithm*> >::const_iterator iter = mapCreators.begin(); iter != mapCreators.end(); ++iter) {
os << setw(10) << iter->first << " :: ";
for (size_t jj=0; jj<iter->second.size(); jj++) {
os << iter->second[jj]->getAlgo() << " ";
}
os << "\n";
}
}
os << "</DataGenerator>\n";
return os.str();
}
......
......@@ -38,22 +38,17 @@ namespace mio {
*
* @ingroup meteoLaws
* @author Mathias Bavay
* @date 2013-03-20
*/
class DataGenerator {
public:
DataGenerator(const Config& cfg);
DataGenerator(const DataGenerator& c) : mapGenerators(c.mapGenerators), mapCreators(c.mapCreators),
generators_defined(c.generators_defined), creators_defined(c.creators_defined) {}
DataGenerator(const DataGenerator& c) : mapGenerators(c.mapGenerators) {}
~DataGenerator();
void fillMissing(METEO_SET& vecMeteo) const;
void fillMissing(std::vector<METEO_SET>& vecVecMeteo) const;
void createParameters(METEO_SET& vecMeteo) const;
void createParameters(std::vector<METEO_SET>& vecVecMeteo) const;
DataGenerator& operator=(const DataGenerator& source);
const std::string toString() const;
......@@ -64,11 +59,8 @@ class DataGenerator {
static size_t getArgumentsForAlgorithm(const Config& cfg, const std::string& parname,
const std::string& algorithm,
std::vector<std::string>& vecArgs);
static void setAlgorithms(const Config& cfg, const std::string& key_pattern, std::map< std::string, std::vector<GeneratorAlgorithm*> > &mapAlgorithms);
std::map< std::string, std::vector<GeneratorAlgorithm*> > mapGenerators; //per parameter data generators algorithms
std::map< std::string, std::vector<GeneratorAlgorithm*> > mapCreators; //per parameter data creators algorithms
bool generators_defined, creators_defined; //if true, there are some generators to run. if false, nothing to do
};
} //end namespace
......
......@@ -329,14 +329,14 @@ IOInterface* IOHandler::getPlugin(const std::string& cfgkey, const std::string&
//Copy constructor
IOHandler::IOHandler(const IOHandler& aio)
: IOInterface(), cfg(aio.cfg), mapPlugins(aio.mapPlugins), excluded_params(aio.excluded_params), kept_params(aio.kept_params),
: IOInterface(), cfg(aio.cfg), dataCreator(aio.cfg), mapPlugins(aio.mapPlugins), excluded_params(aio.excluded_params), kept_params(aio.kept_params),
merge_commands(aio.merge_commands), copy_commands(aio.copy_commands), move_commands(aio.move_commands),
merged_stations(aio.merged_stations), merge_strategy(aio.merge_strategy),
copy_ready(aio.copy_ready), move_ready(aio.move_ready), excludes_ready(aio.excludes_ready), keeps_ready(aio.keeps_ready), merge_ready(aio.merge_ready)
{}
IOHandler::IOHandler(const Config& cfgreader)
: IOInterface(), cfg(cfgreader), mapPlugins(), excluded_params(), kept_params(),
: IOInterface(), cfg(cfgreader), dataCreator(cfgreader), mapPlugins(), excluded_params(), kept_params(),
merge_commands(), copy_commands(), move_commands(),
merged_stations(), merge_strategy(MeteoData::STRICT_MERGE),
copy_ready(false), move_ready(false), excludes_ready(false), keeps_ready(false), merge_ready(false)
......@@ -357,6 +357,7 @@ IOHandler::~IOHandler() throw()
IOHandler& IOHandler::operator=(const IOHandler& source) {
if (this != &source) {
dataCreator = source.dataCreator;
mapPlugins = source.mapPlugins;
excluded_params = source.excluded_params;
kept_params = source.kept_params;
......@@ -443,6 +444,8 @@ void IOHandler::readMeteoData(const Date& dateStart, const Date& dateEnd,
if (!copy_ready) create_copy_map();
copy_params(vecMeteo);
dataCreator.createParameters(vecMeteo);
}
void IOHandler::writeMeteoData(const std::vector<METEO_SET>& vecMeteo,
......@@ -1003,6 +1006,8 @@ const std::string IOHandler::toString() const
os << "</merge_commands>\n";
}
os << dataCreator.toString();
os << "</IOHandler>\n";
return os.str();
}
......
......@@ -20,6 +20,7 @@
#include <meteoio/IOInterface.h>
#include <meteoio/IOExceptions.h>
#include <meteoio/DataCreator.h>
#include <map>
#include <set>
......@@ -86,6 +87,7 @@ class IOHandler : public IOInterface {
void merge_stations(STATIONS_SET& vecStation) const;
const Config& cfg;
DataCreator dataCreator;
std::map<std::string, IOInterface*> mapPlugins;
std::map< std::string, std::set<std::string> > excluded_params;
std::map< std::string, std::set<std::string> > kept_params;
......
......@@ -48,10 +48,10 @@ void TimeSeriesManager::setDfltBufferProperties()
if ((buff_centering != -1.) && (buff_start != -1.))