This addresses the 2D part of issue 168: the ability to specify which meteo parameter and time step to read/write from/to a 2D grid. This should be the prefered reading method in the future, since it leaves to the plugin the task of building the file name, extension, database table, etc This also provides added metadata and more control over the writing process.

More size_t related issues have been found (thanks to the new snowpack server) and fixed. Basically, please remember that any variable used with/for the return value of a call to size() MUST be of type size_t (this becomes specially relevant in 64 bits).

The water triple point pressure has been updated to a better value.

A new group of classes has been created, under the meteolaws subdirectory. This contains various general meteorological laws, such as a sun radiation model, standard atmosphere, etc

The first implementation (not tested yet) of a non-linear least square fit algorithm has been implemented in the libfit1D. 

Several documentation issues have been fixed (obsolete code examples, etc) and classes grouped by modules. This should help the user to quickly locate the classes of interest. 

The changes to the IOInterface (no more vec<vec<StationData>>) have been propagated into all plugins.

In order to solve compilation problems with VC++, we need to rename all publicly accessible variables whose name start with a "_". This is the begining of this effort...

BUGFIX: When adding a key on the fly to the ConfigReader object it disappeared when accessing it in a plugin. Reason: The dynamic instantiation used the filename parameter in the constructor of the plugins instead of the ConfigReader object itself. Architectural change inside DynamicLibrary was necessary.

Overall all include statements within in the library have been replaced by angle brackets, the default install path for the include file is $CMAKE_INSTALL_DIR/include/meteoio, the meteoio libraries (static and shared) will be installed in $CMAKE_INSTALL_DIR/lib per default.

The plugins will be installed in the subdirectory $CMAKE_INSTALL_DIR/lib/meteoio/plugins

Added a function that seeks for a given date within a vector of MeteoData. There are two modes of operation, depending on a boolean argument (true per default value): 
1) the date must exactly match one within the vector
2) the date doesn't have to exactly match up, in that case the vector must "contain" the date given an the index returned is for the first element of the vector with the a date greater than the one sought for.

In case of failure, the function returns IOUtils::npos

Added a missing include in ARPSIO.h

The support for true ARPS ascii grids (as coming out of ARPS) has been implemented. Now the plugin can transparently identify if the grid has been modified by ARPSGRID or not and curreclty load it is any case.

The ARPSIO plugin's documentation is now correclty linked to the rest of the documentation. The reading of DEMs has been validated (with some bug fixes). It currently only works for APRSGRID modified data files (but supporting original ARPS ascii files should be easier). More explicit error messages have been added to Array2D

The first version of an ARPSIO plugin has been written, largely based on the code of LegacyIO. This plugin is mostly non-fonctional (besides reading DEM) because most of the concepts of ARPS files are foreign to MeteoIO... Finishing it will require carreful thinking and brilliant ideas! (the biggest issues have to do with the irregular grids that are a usual feature of ARPS files).

A warning has been silenced until we finish the implementation of the USER interpolation algorithm (reading user provided grids).

Some commented out code has been removed. The check for the projection of the stations compared to the projection used for the DEM has been re-activated (it MUST be active!). The first implementation of a custom grid "interpolation" method has been done (issue 50) but can not be used: we need access to an IOHandler in order to properly read grids provided by the user. Otherwise, the rest of the code for it has been written and tested.

Then, the remaining namespace issues with doxygen have been fixed, by enclosing the full class implementation in the namespace (as seen for the libstdc++). This removes all these irritating issues. But the popc version has been broken by the change (as seen in LegacyIO).

METEO = SNOWPACK
NROFSTATIONS = 1
METAFILE = input/IMIS_Extracted_Info.txt
STATION1   = DAV1
METEOFILE1 = /home/thoems/Desktop/snowpack_ref/validation/trunk/snowpack/mst2006/MST06_RR.inp

The parameters NROFSTATIONS, METAFILE, STATION# and METEOFILE# are obligatory.

A little bug in GEOtopIO lead to the copying of the tss value to tsg.
The MeteoData::HS snow height is internally represented in meters.

Most of the doxygen issues have been fixed. A few are still left (and we lost the inheritance structure in doxygen).

The POPC compilation issue has been fixed (work around a POPC bug). These work arounds have been tagged as "HACK for POPC" in DEMObject, Date, Grid2/3DObject, IOHandler.ph, LegacyIO.ph and marshall_meteoio.cc.

The SNIO plugin that was forgotten at the last commit is now here and has been improved so that it correctly formats its output (it does not read yet).

Cosmetic changes: documentation in MeteoData, comment in ARCIO. Plus more variables are read by BormaIO.

Changed the name of the Date_IO class to Date. In case of namespace conflicts, just use mio::Date to reference the MeteoIO Date class.

changed the way we deal with the projection parameters within the io.ini. COORDSYS must be declared in the [Input] section and is optional for the [Output] section (it becomes mandatory if a function is to be used, that creates output)

The parsing of the ConfigReader object is done in IOUtils, this is not the final solution on that.

a new function called: readStationData has been added. It expects a date and a vector<StationData> as parameters and returns the meta data for the required date (often this date is irrelevant, because stations are fixed, then just pass any date).

A new function is introduced into the IOInterface: writeMeteoData. It expects one vector<vector<MeteoData>> and one vector<vector<StationData>> as well as an optional string (for database info, file name, etc). The relevant io.ini tag is:
METEODEST = GEOTOP

Only GeotopIO has this method fully implemented thus enabling to convert all meteo data captured from any other source to a GEOtop compliant meteo files. The relevant tags are:
METEODESTPATH = /tmp
METEODESTSEQ	= WindS WindDir RelHum AirT SWglobal Iprec

METEODESTPATH determines where the files will be written to and METEODESTSEQ determines the order in which the meteo parameters will be written into the CSV file

A problem was found during the intialization of the plugins (as well as A3DIO): the parameters that were passed to initialize the local copies were not always initialized with the raw parameters passed to the constructor but usually with the copy of the previous element. This lead to some copies not to be up to date when calling their constructor (see A3DIO.cc for a clearer view!!).

The write2DGrid members of the plugins now use the features of the Coords object to output the grid in the input coordinate system (as specified in the io.ini file). A copy of the Coords object is made, so that it does not change the given grid. This is fixing issue 3

The plugin's interface (IOInterface) has been slightly modified: readSpecialPoints now returns a vector of Coords. This means that a plugin can provide coordinates as (lat,long) or (easting, northing) or (grid_i, grid_j). All the plugins have been modified accordingly and POINTS and POINTSArray have been removed from Array.h

The class Stationdata now properly uses the new Coords class. All usual dependencies have been fixed (A3DIO.cc) but not (yet) the optional plugins. The Coords class has been modified so that it computes the matching coordinates as soon as possible instead of the previous implementation that was delaying it as much as possible (thus making "const Coords..." impossible).

The includes have been cleaned up (compilation was failing because of multiple "using namespace" in header files) and all "using namespace" have been removed from header files (please don't put any of these back!!). The doxygen comments has been updated.

The MapProj class has been renamed in Coords. It now contains the coordinates (lat,long) and (xcoord, ycoord) and should therefore be used as a storage and conversion class. The necessary changes have been made to the rest of the code so it uses this class, but it still does NOT use it as a storage of coordinates (which will have to be done in the future). This addressed partially issue 35.

The Special_PTS and CSpecialPointsArray structures have been renamed in "POINT" and "POINTSArray" (there was no reason to call them "special points"). 

A few new methods have been added to DEMObject: getPointsBetween that returns a vector containing the indices of all points located on the line between two points (given by their real world (x,y) coordinates), horizontalDistance that returns the horizontal distance between two points and terrainDistance that returns the distance between two point accros the terrain as described by the DEM (ie: going up and down the terrain).

The license information has been added: LPGLv3 headers in all header files, license texts as well as a Linux Software Map entry file.

The installation procedure has been added to cmake configuration files (similar to the autotools)

2. ConfigReader has a new function called getValue(key, vector<T>) that can deal with multiple white space separated values for one key.
e.g. MYNUMBERS = 19.99 -27.89 777.0007

can be read by:

vector<double> myVec;
ConfigReader cfg("test.ini");
getValue("mynumbers", myVec);

	* Changed method call to readDEM so that polymorphism is not used anymore.

* MapProj is a new class that deals with all kinds of map projections (some can be implemented directly, like CH1903, others can be based on the Proj.4 library)
* changes in map projections made it necessary to adapt the children of IOInterface that have an implementation of readMeteoData or read2DGrid

* this functionality has previously subsided in A3DIO, where it has been deleted and moved to ARCIO
* to reference this plugin in io.ini use "ARC"
* to reference A3DIO in io.ini use "A3D" instead of "FILE"
	e.g. METEOSRC = A3D
* edited Makefile.in and configure.ac to deal with the new plugin

* Complete rewrite of IOHandler: Now it is very easy to add new plugins (adding one line), all the internals (allocation, loading, deleting, loading the right plugin for each IOInterface function) are transparently done.

* changed one parameter in readMeteoData to const unsigned int& from unsigned int. Therefore all children of IOInterface needed to undergo that change

* GeotopIO plugin, to read GeoTOP formatted files
* IOHandler: code reduction for the loading and unloading of plugins
* MeteoData: added one files "p"
* IOUtils: added one more readLineToVec for different delimiters (comma, column, ...) - there was only one for whitespaces 

* had to propagate changes into all children of IOInterface

* function readMeteoData is there to read an interval of data
	readMeteoData(fromDate, toDate, vector< vector<MeteoData> >, vector< vector<MeteoData> >)
* BufferedIOHandler is constructed with another child of IOInterface (e.g. IOHandler) as parameter and deals with all intrinsic issues of buffering, resampling, filtering: so if you have an IOHandler and you want to add buffering:
	BufferedIOHandler(iohandler, configreader)
and then you can access all IOInterface functions, plus a few convenient ones that only BufferedIOHandler exposes:
	getNextMeteoData(date, vector<MeteoData>, vector<StationData>)
	readMeteoData(date, vector<MeteoData>, vector<StationData>)
you can enable and disable buffering:
	bufferediohandler.enableResampling(true);

* A3DIO and IOHandler had to be adapted to the changes in IOInterface 
* added a getYear() function to Date_IO
* MeteoData has a new member variable "resampled" to indicate whether data has been resampled or not

Ok, this is the correct implementation of what I tried to do in the previous commit... Now, the Meteo2DInterpolator can take either Array2D<double> or Grid2DObjects as tables to fill. The overloading of the Write2DGrid has therefore been suppressed: since Grid2DObjects are geography-friendly, they should be used in our applications instead of Array2D (that should be reserved for internal implementation of objects).

So, this is mostly reverting to the code before the last commit, with a few extra lines of code to do the magic...

In order to make using the spatial interpolations easier to use, there is a need to be able to write to files objects of type Array2D. This has been added to IOInterface and implemented in the different plugins.

meteoio_demo has been modified accordingly and is now much simpler.

More fundamentally, we need to think about the way to handle in a nice and elegant way the different type accross the plugins (typically as seen for Write2DGrid): where should we handle what in order to let the user seemlessly write objects to the available mediums?