mapopt.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// @file mapopt.h
///
/// Map optimization data saving, retrieving, and sending.
///
/// @author Pawel Pilarczyk
///
/////////////////////////////////////////////////////////////////////////////
 
// Copyright (C) 1997-2014 by Pawel Pilarczyk.
//
// This file is part of my research software package. This 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.
//
// This software 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 this software; see the file "license.txt". If not,
// please, see <https://www.gnu.org/licenses/>.
 
// Started on March 25, 2013. Last revision: November 17, 2013.
 
 
#ifndef _CMGRAPHS_MAPOPT_H_
#define _CMGRAPHS_MAPOPT_H_
 
 
// include some standard C++ header files
#include <string>
#include <sstream>
#include <vector>
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <memory>
#include <utility>
 
// include all the necessary header files from the CHomP library
#include "chomp/system/config.h"
#include "chomp/system/textfile.h"
 
// include local header files
#include "mapparam.h"
 
 
// --------------------------------------------------
// ------------- map optimization data --------------
// --------------------------------------------------
 
/// A class whose objects are responsible for adjusting the integration
/// parameters such as step size and the number of steps for an ODE.
class MapOptimization
{
public:
        /// The default constructor.
        MapOptimization ();
 
        /// The destructor.
        ~MapOptimization ();
 
        /// Returns the number of map optimization information lines.
        size_t size () const;
 
        /// Reads all the optimization data from a stream.
        void loadData (std::istream &in);
 
        /// Saves all the optimization data to a stream.
        /// If requested, saves new information only
        /// (without that loaded previously or saved earlier).
        void saveData (std::ostream &out, bool incremental);
 
        /// Adds a line of optimization data obtained from computation
        /// or read from a file to the collection.
        /// If the data does not add any new knowledge to the database
        /// then this line is ignored.
        /// The beginning of the line should contain the definition
        /// of the parameters for which the information was computed.
        void addData (const std::string &line, bool computed);
 
        /// Prepares a collection of lines to consider while processing
        /// a map with the given parameters.
        void prepareData (std::vector<std::string> &data,
                const double *leftParam, const double *rightParam,
                int nParam);
 
private:
        /// The copy constructor should not be used.
        MapOptimization (const MapOptimization &);
 
        /// The assignment operator should not be used.
        MapOptimization &operator = (const MapOptimization &);
 
        /// Collected data lines
        std::vector<std::string> dataLines;
 
        /// Decoded parameter aggregates for each data line.
        std::vector<MapParam> dataParam;
 
        /// The number of data lines loaded previously or already saved.
        size_t oldData;
 
}; /* class MapOptimization */
 
// --------------------------------------------------
 
inline MapOptimization::MapOptimization (): oldData (0)
{
        return;
} /* MapOptimization::MapOptimization */
 
inline MapOptimization::~MapOptimization ()
{
        return;
} /* MapOptimization::~MapOptimization */
 
inline MapOptimization::MapOptimization (const MapOptimization &)
{
        throw "Trying to use the copy constructor of MapOptimization.";
        return;
} /* MapOptimization::MapOptimization */
 
inline MapOptimization &MapOptimization::operator = (const MapOptimization &)
{
        throw "Trying to use the assignment operator of MapOptimization.";
        return *this;
} /* MapOptimization::MapOptimization */
 
inline size_t MapOptimization::size () const
{
        return dataLines. size ();
} /* MapOptimization::size */
 
inline void MapOptimization::loadData (std::istream &in)
{
        if (oldData != dataLines. size ())
        {
                throw "Trying to load map optimization data "
                        "on top of new data.";
        }
        chomp::homology::ignorecomments (in);
        while (!in. eof ())
        {
                // read a line from the 
                std::string line;
                std::getline (in, line);
                if (in. bad ())
                        break;
                chomp::homology::ignorecomments (in);
                
                // TODO: check if this line adds essential information
 
                // add this data line to the collection
                addData (line, false);
        }
        oldData = dataLines. size ();
 
        return;
} /* MapOptimization::loadData */
 
void MapOptimization::saveData (std::ostream &out, bool incremental)
{
        for (size_t n = incremental ? oldData : 0;
                n < dataLines. size (); ++ n)
        {
                out << dataLines [n] << '\n';
        }
        oldData = dataLines. size ();
 
        return;
} /* MapOptimization::saveData */
 
void MapOptimization::addData (const std::string &line, bool computed)
{
        // if the line is empty then ignore it
        if (line. empty ())
                return;
 
        // TODO: check if this line adds essential information
 
        // add the data line to the collection
        dataLines. push_back (line);
 
        // decode the parameters for faster access
        MapParam par;
        std::istringstream in (line);
        par. read (in);
        dataParam. push_back (par);
 
        return;
} /* MapOptimization::addData */
 
void MapOptimization::prepareData (std::vector<std::string> &data,
        const double *leftParam, const double *rightParam, int nParam)
{
        // TODO: make this procedure much smarter
 
        // make sure that all the relevant data lines are pre-decoded
        if (dataLines. size () != dataParam. size ())
                throw "Map optimization lines-parameters mismatch.";
 
        // create a data strurcutre with the requested parameters
        MapParam parRequested;
        parRequested. define (leftParam, rightParam, nParam);
 
        // find all the lines that are relevant for these parameters
        for (size_t n = 0; n < dataLines. size (); ++ n)
        {
                if (intersect (parRequested, dataParam [n]) &&
                        shareInteriors (parRequested, dataParam [n]))
                {
                        data. push_back (dataLines [n]);
                }
        }
 
        return;
} /* MapOptimization::prepareData */
 
 
#endif // _CMGRAPHS_MAPOPT_H_