coord.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// @file coord.h
///
/// The coordinator class for the Conley-Morse graphs computation program.
/// This file contains the definition of the coordinator class which prepares
/// data for workers (chunks of the parameter range) and collects results
/// of their computations.
///
/// @author Pawel Pilarczyk
///
/////////////////////////////////////////////////////////////////////////////
 
// Copyright (C) 1997-2022 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 February 11, 2008. Last revision: March 29, 2022.
 
 
#ifndef _CMGRAPHS_COORD_H_
#define _CMGRAPHS_COORD_H_
 
 
// include some standard C++ header files
#include <string>
#include <iostream>
#include <fstream>
#include <sstream>
#include <cctype>
#include <vector>
 
// include selected header files from the CHomP library
#include "chomp/system/config.h"
#include "chomp/system/textfile.h"
#include "chomp/system/timeused.h"
#include "chomp/cubes/cube.h"
#include "chomp/multiwork/mw.h"
 
// include local header files
#include "config.h"
#include "confinfo.h"
#include "typedefs.h"
#include "typedyns.h"
#include "utils.h"
#include "dataconv.h"
#include "datavector.h"
#include "matcharr.h"
#include "dotgraph.h"
#include "mapopt.h"
 
 
// --------------------------------------------------
// ------------- the coordinator class --------------
// --------------------------------------------------
 
/// The coordinator class which prepares chunks of parameter space
/// to be processed by workers, and then incorporates the results
/// of the computations into the final picture, and also saves the results
/// to a log file.
class Coordinator: public chomp::multiwork::mwCoordinator
{
public:
        /// The complete constructor of a coordinator.
        Coordinator (const char *_interFileName,
                const char *_mapOptFileName, const char *_mapOptPrefix,
                const char *_graphsFileName, const char *_graphsPrefix,
                const char *_finalPrefix, const char *_sharePrefix,
                const char *_phaseSpacePrefix, const char *_cubesPrefix,
                const char *_morseDecPrefix,
                const char *_procPrefix, bool _fullPhaseSpace,
                int _skipIndices, int _nPatches);
 
        /// The destructor.
        ~Coordinator ();
 
private:
        /// A function for preparing data by the coordinator.
        int Prepare (chomp::multiwork::mwData &data);
 
        /// A function for accepting results by the coordinator.
        int Accept (chomp::multiwork::mwData &data);
 
        /// A function for taking rejected data by the coordinator.
        int Reject (chomp::multiwork::mwData &data);
 
        // The copy constructor is not allowed.
//      Coordinator (const Coordinator &) {return;}
 
        // The assignment operator is not allowed.
//      Coordinator &operator = (const Coordinator &) {return *this;}
 
private:
        /// This is an auxiliary class whose objects store the information
        /// on the data chunks sent to workers.
        struct datapack
        {
                /// The default constructor of an uninitialized data pack.
                datapack () {}
 
                /// A nice constructor which initializes all the data.
                datapack (int _num, const parCube &_box):
                        num (_num), box (_box) {}
 
                // the default copy constructor and operator = are good
 
                // no destructor is necessary
 
                /// The number of the data pack.
                int num;
 
                /// The cube (with respect to the iterator) sent to a worker.
                parCube box;
        
        }; /* struct datapack */
 
 
private:
        /// A procedure for reading the previously computed results.
        void readPreviousResults (const char *filename);
 
        /// A file to append the results to.
        std::ofstream interFile;
 
        /// A file to append the optimization results to.
        std::string mapOptFileName;
 
        /// A file name prefix for optimization data for each parameter.
        std::string mapOptPrefix;
 
        /// Is the graphs file in use?
        bool usingGraphsFile;
 
        /// A file to append the computed Conley-Morse graphs to.
        std::ofstream graphsFile;
 
        /// The current number of data pack sent for pre-caching indices.
        int currentCache;
 
        /// The number of indices to pre-cache.
        int maxCache;
 
        /// The number of pre-cached indices waiting to complete.
        int waitingCache;
 
        /// The coordinates of a box to send for pre-caching indices.
        parCoord cacheCoord [paramDim];
 
        /// The current number of data pack to prepare by the coordinator.
        int current;
 
        /// The number of parameter regions which are to be processed
        /// in this run of the program.
        int maxCurrent;
 
        /// The data packs sent for processing to workers.
        chomp::homology::multitable<datapack> sent;
 
        /// The number of data packs currently being processed by workers.
        int sentlen;
 
        /// The minimal size of a Morse set for which the indices should not
        /// be computed. Zero to compute all the Conley indices.
        int skipIndices;
 
        /// The file name prefix for saving the text Conley-Morse graphs.
        std::string graphsPrefix;
 
        /// The file name prefix for saving the final result.
        std::string finalPrefix;
 
        /// The file name prefix for saving Morse sets by workers.
        std::string sharePrefix;
 
        /// The file name prefix for saving the phase space pictures
        /// of Morse decompositions.
        std::string phaseSpacePrefix;
 
        /// The file name prefix for saving the actual cubes of Morse sets
        /// and possibly also additional sets (while post-processing).
        std::string cubesPrefix;
 
        /// The file name prefix for cached compressed Morse decompositions.
        std::string morseDecPrefix;
 
        /// The file name prefix for saving post-processing information.
        std::string procPrefix;
 
        /// Should the full phase space be taken for plotting the pictures
        /// of Morse sets?
        bool fullPhaseSpace;
 
        /// The coordinates for lower (and upper) ends of rectangular regions
        /// in each direction.
        std::vector<parCoord> subCoords [paramDim];
 
        /// The minimal corner of the rectangle to iterate (zero coords).
        parCoord zeroIter [paramDim];
 
        /// The numbers of rectangular regions in each direction to iterate.
        parCoord maxIter [paramDim];
 
        /// A rectangle which iterates the rectangular sets to send.
        parRect *rectIterator;
 
        /// Parity bits of which rectangles are to be sent to workers.
        parCoord parityBits [paramDim];
 
        /// Have all the rectangular regions already been sent?
        bool allSent;
 
        /// The array of matching between parameter boxes.
        MatchArray<parCoord,int> matchArray;
 
        /// The total number of computed Morse decopositions.
        int morseDecComputed;
 
        /// The total number of re-used Morse decompositions.
        int morseDecReused;
 
        /// The parameter boxes for which wrong Conley indices
        /// were computed by workers.
        parCubes wrongIndexBoxes;
 
        /// The parameter boxes for which the Conley-Morse graph
        /// has already been written to the corresponding file.
        parCubes graphsWritten;
 
        /// The boxes representing parameter ranges which have already been
        /// processed in the previous run of the coordinator.
        parCubes previousBoxes;
 
        /// The lists of Morse set numbers for which the wrong Conley indices
        /// appeared.
        chomp::homology::multitable<std::vector<int> > wrongIndices;
 
        /// The left coordinates of a box that contains all the Morse sets.
        spcCoord coordLeftMin [spaceDim];
 
        /// The right coordinates of a box that contains all the Morse sets.
        spcCoord coordRightMax [spaceDim];
 
        /// The maximal image diameter encountered by the workers.
        int maxImgDiam;
 
        /// The maximal image volume encountered by the workers.
        int maxImgVol;
 
        /// Map optimization data for all the parameters.
        MapOptimization mapOptimization;
 
}; /* class Coordinator */
 
// --------------------------------------------------
 
inline Coordinator::Coordinator (const char *_interFileName,
        const char *_mapOptFileName, const char *_mapOptPrefix,
        const char *_graphsFileName, const char *_graphsPrefix,
        const char *_finalPrefix, const char *_sharePrefix,
        const char *_phaseSpacePrefix, const char *_cubesPrefix,
        const char *_morseDecPrefix,
        const char *_procPrefix, bool _fullPhaseSpace,
        int _skipIndices, int _nPatches):
        usingGraphsFile (false),
        currentCache (0), maxCache (0), waitingCache (0),
        current (0), maxCurrent (0), sentlen (0),
        skipIndices (_skipIndices), fullPhaseSpace (_fullPhaseSpace),
        rectIterator (0), allSent (false),
        matchArray (paramDim, paramSubdiv),
        morseDecComputed (0), morseDecReused (0),
        maxImgDiam (0), maxImgVol (0)
{
        using chomp::homology::sout;
 
        // remember a file name prefix for optimization data for each parameter
        if (_mapOptPrefix && *_mapOptPrefix)
                mapOptPrefix = _mapOptPrefix;
 
        // remember the prefix for saving Morse sets
        if (_sharePrefix && *_sharePrefix)
                sharePrefix = _sharePrefix;
 
        // remember the prefix for saving pictures of Morse decompositions
        if (_phaseSpacePrefix && *_phaseSpacePrefix)
                phaseSpacePrefix = _phaseSpacePrefix;
 
        // remember the prefix for saving Morse sets as list of cubes
        if (_cubesPrefix && *_cubesPrefix)
                cubesPrefix = _cubesPrefix;
 
        // remember the prefix for saving Morse sets as list of cubes
        if (_morseDecPrefix && *_morseDecPrefix)
                morseDecPrefix = _morseDecPrefix;
 
        // remember the prefix for saving post-processing information
        if (_procPrefix && *_procPrefix)
                procPrefix = _procPrefix;
 
        // display a warning if no intermediate file name is provided
        if (!_interFileName || !*_interFileName)
        {
                sout << "WARNING: No file name for intermediate results "
                        "has been provided.\n"
                        "         It will not be possible to restart "
                        "the computations if they are interrupted.\n";
        }
 
        // display a warning if no file name for saving graphs was given
        if ((!_graphsFileName || !*_graphsFileName) &&
                (!_graphsPrefix || !*_graphsPrefix))
        {
                sout << "WARNING: No file name for saving the Conley-Morse "
                        "graphs has been provided.\n"
                        "         The computed Conley-Morse graphs "
                        "Will be discarded.\n";
        }
 
        // remember the prefix for file names to which the final result
        // will be saved
        if (_finalPrefix && *_finalPrefix)
                finalPrefix = _finalPrefix;
        else
                throw "No file name prefix provided for the results.";
 
        // read the previously computed results of the computations
        if (_interFileName && *_interFileName)
                this -> readPreviousResults (_interFileName);
 
        // read the previously computed results of the computations
        if (_mapOptFileName && *_mapOptFileName)
        {
                mapOptFileName = std::string (_mapOptFileName);
                std::ifstream in (_mapOptFileName);
                size_t prevSize (mapOptimization. size ());
                if (in)
                {
                        sout << "Reading map optimization data... ";
                        mapOptimization. loadData (in);
                        sout << (mapOptimization. size () - prevSize) <<
                                " items added.\n";
                }
        }
 
        // prepare a rectangle for iterating the rectangular regions
        rectIterator = subRectangles (zeroIter, maxIter,
                subCoords, _nPatches);
 
        // prepare the parity bits
        for (int i = 0; i < paramDim; ++ i)
                parityBits [i] = 0;
 
        // compute the number of regions which will be sent for processing
        maxCurrent = 1;
        for (int i = 0; i < paramDim; ++ i)
                maxCurrent *= maxIter [i];
 
        // open the graphs file for appending
        if (_graphsFileName && *_graphsFileName)
        {
                graphsFile. open (_graphsFileName,
                        std::ios::out | std::ios::app);
                graphsFile << "; --- Conley-Morse graphs ---\n";
                graphsFile << std::flush;
                usingGraphsFile = true;
        }
 
        // remember the prefix for graph file names
        if (_graphsPrefix && *_graphsPrefix)
                graphsPrefix = _graphsPrefix;
 
        // open the results file for appending
        if (_interFileName && *_interFileName)
        {
                interFile. open (_interFileName,
                        std::ios::out | std::ios::app);
                interFile << "; Started on " <<
                        chomp::homology::currenttime () << ";\n";
                showConfigInfo (interFile, "; ", maxIter);
                interFile << std::flush;
        }
 
        // make sure that the range of spce coordinates will not be exhausted
        if (finalDepth + refineDepth + 2 > 8 * sizeof(spcCoord))
        {
                sout << "Serious problem: finalDepth (" <<
                        finalDepth << ") + refineDepth (" << refineDepth <<
                        ") = " << (finalDepth + refineDepth) << ".\n";
                sout << "However, the space coordinates are " <<
                        (8 * sizeof(spcCoord)) << "-bit integers.\n";
                sout << "Please, modify 'typespace.h': the 'spcCoord' type "
                        "must have at least " <<
                        (finalDepth + refineDepth + 2) << " bits.\n";
                throw "Not enough bits available in spcCoord.";
        }
 
        // initialize the coordinate ranges
        for (int i = 0; i < spaceDim; ++ i)
        {
                coordLeftMin [i] = 1 << finalDepth;
                coordRightMax [i] = 0;
        }
 
        // initialize the data for pre-computation of cached Conley indices
#ifndef CONFIG_ONLYPREPROCESSING
        if (!sharePrefix. empty ())
#endif
        {
                for (int i = 0; i < paramDim; ++ i)
                        cacheCoord [i] = 0;
#ifndef CONFIG_NOPREPROCESSING
                maxCache = 1;
                for (int i = 0; i < paramDim; ++ i)
                        maxCache *= paramSubdiv [i];
                waitingCache = maxCache;
#endif
        }
 
        return;
} /* Coordinator::Coordinator */
 
inline void Coordinator::readPreviousResults (const char *filename)
{
        using chomp::homology::sout;
        using chomp::homology::ignoreline;
        using chomp::homology::ignorecomments;
 
        std::ifstream in (filename);
        if (!in)
        {
                sout << "Note: Could not open the results file. "
                        "Any previous results will be ignored.\n";
                return;
        }
 
        int countClasses = 0;
        int countBoxes = 0;
        ignorecomments (in);
        while (!in. eof ())
        {
                // add an equivalence class to the array of connections
                if (in. peek () == 'E')
                {
                        // read the letter indicating an equivalence class
                        in. get ();
                        ignorecomments (in);
 
                        // read and ignore the number of cubes in the class
                        if (std::isdigit (in. peek ()))
                        {
                                int nCubes = 0;
                                in >> nCubes;
                                ignorecomments (in);
                        }
 
                        // read the first cube in the equivalence class
                        parCube firstCube;
                        in >> firstCube;
                        parCoord firstCoord [paramDim];
                        firstCube. coord (firstCoord);
                        ignorecomments (in);
 
                        // read all the remaining cubes
                        while (in. peek () == '(')
                        {
                                parCube otherCube;
                                in >> otherCube;
                                parCoord otherCoord [paramDim];
                                otherCube. coord (otherCoord);
                                matchArray. join (firstCoord, otherCoord);
                                ignorecomments (in);
                        }
 
                        // update the class counter
                        ++ countClasses;
                }
 
                // add a box to the list of previously processed boxes
                else if (in. peek () == '*')
                {
                        // read the asterisk
                        in. get ();
                        ignorecomments (in);
 
                        // read and ignore the datapack number
                        if (std::isdigit (in. peek ()))
                        {
                                int num = 0;
                                in >> num;
                                ignorecomments (in);
                        }
 
                        // read the cube which has already been processed
                        parCube paramBox;
                        in >> paramBox;
                        previousBoxes. add (paramBox);
                        ignorecomments (in);
 
                        // update the box counter
                        ++ countBoxes;
                }
 
                // ignore the line if it is not understood
                else
                {
                        ignoreline (in);
                        ignorecomments (in);
                }
        }
 
        chomp::homology::sout << countBoxes << " previously computed "
                "parameter ranges read from a file.\n";
        maxCurrent -= countBoxes;
        chomp::homology::sout << countClasses << " previously computed "
                "equivalence classes processed.\n";
        return;
} /* Coordinator::readPreviousResults */
 
inline Coordinator::~Coordinator ()
{
        // remove the rectangle iterator
        if (rectIterator)
                delete rectIterator;
 
        // write remaining map optimization data if any
        if (!mapOptFileName. empty ())
        {
                std::ofstream mapOptFile;
                mapOptFile. open (mapOptFileName. c_str (),
                        std::ios::out | std::ios::app);
                mapOptimization. saveData (mapOptFile, true);
        }
 
        // close the intermediate results file
        interFile << "; Finished on " << chomp::homology::currenttime ();
        interFile. close ();
 
        return;
} /* Coordinator::~Coordinator */
 
inline int Coordinator::Prepare (chomp::multiwork::mwData &data)
{
        using chomp::homology::sout;
        using chomp::homology::sbug;
        using chomp::homology::timeused;
 
        // measure working time
        timeused workingTime;
        workingTime = 0;
 
        // read a list of bad boxes which must be skipped, if available
        parCubes badBoxes;
        std::ifstream in ("_badboxes.cub");
        in >> badBoxes;
        if (!badBoxes. empty ())
                sbug << badBoxes. size () << " bad boxes will be skipped.\n";
        in. close ();
 
        // show a message about the first phase of computations
        if (!currentCache && maxCache)
                sout << "=== PHASE 1: Computation of Conley indices ===\n";
 
        // skip all single boxes whose "ind", "png" and "bz2" files
        // already exist
        while (currentCache < maxCache)
        {
                // skip the box if it is bad
                bool skip = false;
                if (!badBoxes. empty ())
                {
                        parCube p (cacheCoord, paramDim);
                        if (badBoxes. check (p))
                        {
                                skip = true;
                                sbug << "Skipping bad parameter box " << p << ".\n";
                                -- waitingCache;
                        }
                }
 
                // if the cached indices file does not exist then send it
                if (!skip && !sharePrefix. empty ())
                {
                        std::string cacheFileName (sharePrefix +
                                coord2str (cacheCoord, paramDim) + ".ind");
                        if (!fileExists (cacheFileName. c_str ()))
                                break;
                }
 
                // if the phase space picture does not exist then send it
                if (!skip && (!phaseSpacePrefix. empty () && (spaceDim == 2)))
                {
                        std::string pictureFileName = phaseSpacePrefix +
                                coord2str (cacheCoord, paramDim) + ".png";
                        if (!fileExists (pictureFileName. c_str ()))
                                break;
                }
 
                // if the cached Morse dec file does not exist then send it
                if (!skip && !morseDecPrefix. empty ())
                {
                        std::string morseDecFileName (morseDecPrefix +
                                coord2str (cacheCoord, paramDim) + ".bz2");
                        if (!fileExists (morseDecFileName. c_str ()))
                                break;
                }
 
                // if preprocessing only was requested then send the point
                // even if all the prefixes are empty
#ifdef CONFIG_ONLYPREPROCESSING
                if (!skip)
                        break;
#endif
 
                // take the next point
                for (int i = 0; i < paramDim; ++ i)
                {
                        if (++ (cacheCoord [i]) < paramSubdiv [i])
                                break;
                        cacheCoord [i] = 0;
                }
                ++ currentCache;
 
                // show a message about the second phase of computations
                if (currentCache == maxCache)
                {
                        sout << "=== PHASE 2: Continuation of Morse "
                                "decompositions ===\n";
                }
        }
 
#ifdef CONFIG_SEPARATEPHASES
        // if Phase 1 must be fully completed before Phase 2 can begin
        if ((currentCache >= maxCache) && waitingCache)
        {
                sbug << "[Note: waiting for " << waitingCache << " indices to be cached.]\n";
                return chomp::multiwork::mwNoData;
        }
#endif
 
        // decide if a single box for pre-caching of indices should be sent
        bool cacheToSend = (currentCache < maxCache);
 
        // determine the data pack to send if any
        const parCoord *coord = 0;
#ifndef CONFIG_ONLYPREPROCESSING
        while (!cacheToSend && !allSent)
        {
                // take the next available set of coordinates
                coord = rectIterator -> get ();
 
                // if no new coordinates are available...
                if (!coord)
                {
                        // increase the parity bits
                        int nBit = 0;
                        while ((nBit < paramDim) && (parityBits [nBit] == 1))
                                parityBits [nBit ++] = 0;
 
                        // quit if all the parity bits have been used
                        if (nBit == paramDim)
                        {
                                allSent = true;
                                break;
                        }
 
                        // increase the bit that was found
                        parityBits [nBit] = 1;
 
                        // rewind the iterator of box coordinates
                        coord = rectIterator -> get ();
                }
 
                // check if the coordinates satisfy the parity condition
                bool parityOk = true;
                for (int i = 0; i < paramDim; ++ i)
                {
                        if (parityBits [i] && (coord [i] & 1))
                                continue;
                        if (!parityBits [i] && !(coord [i] & 1))
                                continue;
                        parityOk = false;
                        break;
                }
 
                // if this box has already been processed before then skip it
                if (parityOk && !previousBoxes. empty () &&
                        previousBoxes. check (parCube (coord, paramDim)))
                {
                        continue;
                }
 
                // if the parity condition is satisfied then break the loop
                if (parityOk)
                        break;
        }
#endif
 
        // save the final results if this is the end of computations.
#ifndef CONFIG_ONLYPREPROCESSING
        if (allSent && !sentlen && !finalPrefix. empty ())
#else
        if (!sentlen)
#endif
        {
                sout << "================================\n";
 
                // show a warning about wrong Conley indices
                if (!wrongIndexBoxes. empty ())
                {
                        sout << "\n*** WARNING: Some Conley indices at " <<
                                wrongIndexBoxes. size () <<
                                " parameters were not computed\n"
                                "*** because of lack of isolation.\n\n";
                        if (!finalPrefix. empty ())
                        {
                                std::ofstream bad ((finalPrefix + ".bad").
                                    c_str ());
                                bad << "; Parameter boxes for which "
                                        "at least one Conley index "
                                        "could not be computed:\n";
                                bad << wrongIndexBoxes;
                        }
                }
 
                // show a summary on the number of computed Morse decomps
                int volume = 1;
                for (int i = 0; i < paramDim; ++ i)
                        volume *= paramSubdiv [i];
                int percent = static_cast<int>
                        (morseDecComputed * 100.0 / volume);
                sout << morseDecComputed << " out of " <<
                        volume << " Morse decomps computed (" <<
                        percent << "%) and " << morseDecReused <<
                        " reused.\n";
 
                // show the range of cubes in the Morse sets
                CoordMinMax coordMinMax (coordLeftMin, coordRightMax);
                sout << "The computed Morse sets are in " <<
                        coordMinMax << ".\n";
                sout << "Real coordinates: ";
                showRealCoords (sout, coordMinMax) << ".\n";
 
                // show the max image diameter and volume encountered
                sout << "Max img diam = " << maxImgDiam <<
                        ", max img vol = " << maxImgVol << ".\n";
 
                // save the continuation classes to files
                sout << "Saving the continuation classes...\n";
                matchArray. saveSets (finalPrefix. c_str ());
        }
 
        // if all data has already been sent then return no data
        if (allSent)
        {
                // show working time if the work took a lot of time
                if (static_cast<double> (workingTime) > 1.0)
                {
                        sbug << "It took " << workingTime << " to "
                                "see that there is no data to send.\n";
                }
 
                return chomp::multiwork::mwNoData;
        }
 
#ifdef CONFIG_ONLYPREPROCESSING
        // if preprocessing only was requested, no more work is necessary
        if (!cacheToSend)
                return chomp::multiwork::mwNoData;
#endif
 
        // create a data pack with the current box
        parCube dataBox (cacheToSend ? cacheCoord : coord, paramDim);
        int dataNumber = cacheToSend ? -(currentCache + 1) : current;
        sent [sentlen ++] = datapack (dataNumber, dataBox);
 
        // prepare the parameter coordinate ranges to send
        int leftCoords [paramDim];
        int rightCoords [paramDim];
        for (int i = 0; i < paramDim; ++ i)
        {
                if (cacheToSend)
                {
                        leftCoords [i] = cacheCoord [i];
                        rightCoords [i] = cacheCoord [i] + 1;
                }
                else
                {
                        // prepare the range of coordinates to process
                        // and add an overlap margin if necessary
                        int left = subCoords [i] [coord [i]];
                        int right = subCoords [i] [coord [i] + 1];
                        if (right < paramSubdiv [i])
                                ++ right;
                        leftCoords [i] = left;
                        rightCoords [i] = right;
                }
        }
 
        // prepare map optimization data
        parCoord parLeft [paramDim];
        parCoord parRight [paramDim];
        for (int i = 0; i < paramDim; ++ i)
        {
                parLeft [i] = static_cast<parCoord> (leftCoords [i]);
                parRight [i] = static_cast<parCoord> (rightCoords [i]);
        }
        std::vector<std::vector<std::string> > mapOptLines;
        parRect rect (parLeft, parRight, paramDim);
        const parCoord *curCoord;
        int curNumber = 0;
        while ((curCoord = rect. get ()) != 0)
        {
                // prepare the actual parameters for this parameter box
                double leftMapParam [paramCount];
                double rightMapParam [paramCount];
                computeParam (curCoord, leftMapParam, rightMapParam);
 
                // prepare map optimization data for these parameters
                std::vector<std::string> data;
                mapOptLines. push_back (data);
                mapOptimization. prepareData (mapOptLines [curNumber],
                        leftMapParam, rightMapParam, paramCount);
 
                // increase the counter of the current optimization data set
                ++ curNumber;
        }
 
        // encode the data to send
        data. Reset ();
        data << dataNumber;
        data << paramDim;
        for (int i = 0; i < paramDim; ++ i)
                data << leftCoords [i] << rightCoords [i];
        data << skipIndices;
        data << mapOptPrefix;
        data << sharePrefix;
        data << phaseSpacePrefix;
        data << cubesPrefix;
        data << morseDecPrefix;
        data << graphsPrefix;
        data << procPrefix;
        data << fullPhaseSpace;
        data << mapOptLines;
        data << controlNumber;
 
        // save the information on this data to the results file
        if (!cacheToSend)
        {
                interFile << "+ " << dataNumber << " " << dataBox << "\n" <<
                        std::flush;
        }
 
        // show a message on what is being sent
        // and indicate the percentage of work done
        sout << "Sending " << dataNumber << " " << dataBox;
        if (!cacheToSend)
        {
                for (int i = 0; i < paramDim; ++ i)
                {
                        sout << (i ? " x [" : ": [") << leftCoords [i] <<
                                "," << rightCoords [i] << "]";
                }
        }
        int countSent = cacheToSend ? currentCache : current;
        int maxToSend = cacheToSend ? maxCache : maxCurrent;
        sout << ", " << (100 * (countSent + 1) /
                (maxToSend ? maxToSend : 1)) << "% sent.\n";
 
        if (cacheToSend)
        {
                // increase the counter of the current box
                for (int i = 0; i < paramDim; ++ i)
                {
                        if (++ (cacheCoord [i]) < paramSubdiv [i])
                                break;
                        cacheCoord [i] = 0;
                }
                ++ currentCache;
 
                // show a message about the second phase of computations
                if (currentCache == maxCache)
                {
                        sout << "=== PHASE 2: Continuation of Morse "
                                "decompositions ===\n";
                }
        }
        else
        {
                ++ current;
        }
 
        // show working time if the work took considerable amount of time
        if (static_cast<double> (workingTime) > 1.0)
        {
                sbug << "It took " << workingTime <<
                        " to prepare new data.\n";
        }
        return chomp::multiwork::mwOk;
} /* Coordinator::Prepare */
 
inline int Coordinator::Accept (chomp::multiwork::mwData &data)
{
        using chomp::homology::sout;
        using chomp::homology::sbug;
        using chomp::homology::timeused;
 
        // measure working time
        timeused workingTime;
        workingTime = 0;
 
        // decode the number
        int dataNumber = 0;
        data >> dataNumber;
 
        // show a message informing about the reception of the data
        // and indicate the percentage of work done
        int countSent = sentlen;
        int countPrepared = (dataNumber >= 0) ? current : currentCache;
        int maxPrepared = (dataNumber >= 0) ? maxCurrent : maxCache;
        for (int i = 0; i < sentlen; ++ i)
        {
                if ((dataNumber >= 0) && (sent [i]. num < 0))
                        -- countSent;
                else if ((dataNumber < 0) && (sent [i]. num >= 0))
                        -- countSent;
        }
        sout << "Receiving " << dataNumber << ", " <<
                (100 * (countPrepared - countSent + 1) /
                (maxPrepared ? maxPrepared : 1)) << "% completed.\n";
 
        // if this was a result of pre-computation then count it
        if (dataNumber < 0)
                -- waitingCache;
 
        // find the data chunk that corresponds to this number
        int pos = 0;
        while ((pos < sentlen) && (sent [pos]. num != dataNumber))
                ++ pos;
        if (pos >= sentlen)
                throw "Wrong data chunk number returned by a worker.";
 
        // make a note in the log file that this result has been received
        if (dataNumber >= 0)
        {
                interFile << "* " << dataNumber << " " <<
                        sent [pos]. box << "\n";
        }
 
        // retrieve the time of processing this entire chunk of boxes
        double processingTime = 0;
        data >> processingTime;
 
        // acquire the numbers of Morse sets with wrong Conley indices
        std::vector<std::vector<int> > localWrongIndices;
        data >> localWrongIndices;
 
        // acquire the numbers of Morse sets for which the Conley index
        // computation was skipped
        std::vector<std::vector<int> > skippedIndices;
        data >> skippedIndices;
 
        // acquire the numbers of Morse sets which are attractors
        std::vector<std::vector<int> > attractors;
        data >> attractors;
 
        // acquire the ranges of coordinates
        spcCube cubeLeftMin;
        spcCube cubeRightMax;
        data >> cubeLeftMin;
        data >> cubeRightMax;
        spcCoord localLeftMin [spaceDim];
        spcCoord localRightMax [spaceDim];
        cubeLeftMin. coord (localLeftMin);
        cubeRightMax. coord (localRightMax);
        for (int i = 0; i < spaceDim; ++ i)
        {
                if (coordLeftMin [i] > localLeftMin [i])
                        coordLeftMin [i] = localLeftMin [i];
                if (coordRightMax [i] < localRightMax [i])
                        coordRightMax [i] = localRightMax [i];
        }
 
        // determine the number of processed boxes
        int countBoxes = 0;
        data >> countBoxes;
 
        // acquire data for each box
        bool graphsOutput = false;
        parCubes paramBoxes;
        for (int curNumber = 0; curNumber < countBoxes; ++ curNumber)
        {
                // determine the actual box coordinates
                parCube paramBox;
                data >> paramBox;
                paramBoxes. add (paramBox);
                if (paramBoxes. size () <= curNumber)
                        throw "Repeated box found in the results.";
 
                // retrieve the time used to process this box
                double timeUsed = 0;
                data >> timeUsed;
 
                // was this Morse decomposition computed by this worker?
                bool wasComputed = false;
                data >> wasComputed;
                if (wasComputed)
                        ++ morseDecComputed;
                else
                        ++ morseDecReused;
 
                // decode the Morse graph
                chomp::homology::diGraph<> morseGraph;
                data >> morseGraph;
 
                // decode the sizes of each Morse set
                int nSets = morseGraph. countVertices ();
                std::vector<int_t> sizes (nSets);
                for (int n = 0; n < nSets; ++ n)
                        data >> sizes [n];
 
                // make a note of wrong Conley indices if any
                if (!localWrongIndices [curNumber]. empty ())
                {
                        wrongIndices [wrongIndexBoxes. size ()] =
                                localWrongIndices [curNumber];
                        wrongIndexBoxes. add (paramBox);
                }
 
                // decode the Conley indices and the eigenvalues
                std::vector<theConleyIndexType> indices (nSets);
                std::vector<IndexEigenValues> eigenValues (nSets);
                for (int n = 0; n < nSets; ++ n)
                {
                        // decode the Morse index of the n-th Morse set
                        data >> indices [n];
 
                        // decode the sets of nonzero eigenvalues
                        data >> eigenValues [n];
                }
 
                // write the Conley-Morse graph for the given box
                if (((usingGraphsFile || !graphsPrefix. empty ())) &&
                        !graphsWritten. check (paramBox))
                {
                        // prepare a string containing the text graph
                        std::ostringstream dotGraphStream;
                        writeDotGraph (dotGraphStream, morseGraph, sizes,
                                indices, eigenValues,
                                localWrongIndices [curNumber],
                                skippedIndices [curNumber],
                                attractors [curNumber]);
                        std::string dotGraph (dotGraphStream. str ());
 
                        // write the text graph to the main graph file
                        if (usingGraphsFile)
                        {
                                graphsFile << paramBox << " " << dotGraph <<
                                        "\n";
                                graphsOutput = true;
                        }
 
                        // write the text graph to a single graph file
                        // NOTE: This is already contained in the
                        // "computeMorseDecomposition" procedure.
                        if (false && !graphsPrefix. empty ())
                        {
                                std::string graphFileName = graphsPrefix +
                                        coord2str (paramBox) + ".txt";
                                if (!fileExists (graphFileName. c_str ()))
                                {
                                        std::ofstream graphFile
                                                (graphFileName. c_str ());
                                        graphFile << dotGraph << "\n";
                                        graphFile. close ();
                                }
                        }
 
                        // remember that this graph has been written
                        graphsWritten. add (paramBox);
                }
        }
        if (paramBoxes. empty ())
        {
                sbug << "Results for no boxes accepted.\n";
        }
        else if (paramBoxes. size () == 1)
        {
                sbug << "Results for one box (processed in " <<
                        processingTime << " sec) accepted.\n";
        }
        else
        {
                sbug << "Results for " << paramBoxes. size () << " boxes "
                        "(processed in " << processingTime <<
                        " sec) accepted.\n";
        }
 
        // acquire data regarding the continuation relation between the boxes
        std::vector<std::vector<parCube> > matchClasses;
        data >> matchClasses;
        int nClasses = matchClasses. size ();
        for (int n = 0; n < nClasses; ++ n)
        {
                // determine the number of boxes in the equivalence class
                const std::vector<parCube> &theClass = matchClasses [n];
                int nBoxes = theClass. size ();
                if (nBoxes < 2)
                        continue;
                interFile << "E " << nBoxes;
 
                // prepare the coordinates of the first box in the class
                parCoord coordZero [paramDim];
                theClass [0]. coord (coordZero);
                interFile << " " << theClass [0];
 
                // make a note of all the other boxes being equivalent
                for (int i = 1; i < nBoxes; ++ i)
                {
                        interFile << " " << theClass [i];
                        parCoord coordBox [paramDim];
                        theClass [i]. coord (coordBox);
                        matchArray. join (coordZero, coordBox);
                }
                interFile << "\n";
        }
 
        // retrieve computed max image diameter and volume
        int localMaxImgDiam = 0;
        int localMaxImgVol = 0;
        data >> localMaxImgDiam;
        data >> localMaxImgVol;
        if (maxImgDiam < localMaxImgDiam)
                maxImgDiam = localMaxImgDiam;
        if (maxImgVol < localMaxImgVol)
                maxImgVol = localMaxImgVol;
 
        // retrieve map optimization data
        std::vector<std::string> mapOptLines;
        data >> mapOptLines;
        if (!mapOptLines. empty ())
        {
                // add the map optimization data to the aggregate structure
                for (size_t n = 0; n < mapOptLines. size (); ++ n)
                {
                        if (!mapOptLines [n]. empty ())
                        {
                                mapOptimization. addData (mapOptLines [n],
                                        true);
                        }
                }
 
                // save new map optimization data if any
                if (!mapOptFileName. empty ())
                {
                        std::ofstream mapOptFile;
                        mapOptFile. open (mapOptFileName. c_str (),
                                std::ios::out | std::ios::app);
                        mapOptimization. saveData (mapOptFile, true);
                }
        }
 
        // remove the data from the table containing the data that was sent
        -- sentlen;
        if (pos != sentlen)
                sent [pos] = sent [sentlen];
 
        // indicate the number of equivalence classes acquired.
//      sbug << nClasses << " equivalence class" <<
//              ((nClasses == 1) ? "" : "es") << " acquired.\n";
 
        // flush the output files
        if (dataNumber >= 0)
                interFile << std::flush;
        if (graphsOutput)
                graphsFile << std::flush;
 
        // show working time if the work took considerable amount of time
        if (static_cast<double> (workingTime) > 1.0)
        {
                sbug << "It took " << workingTime <<
                        " to accept the data.\n";
        }
 
        return chomp::multiwork::mwOk;
} /* Coordinator::Accept */
 
inline int Coordinator::Reject (chomp::multiwork::mwData &/*data*/)
{
        using chomp::homology::sout;
        sout << "WARNING: Data rejected by a worker.\n";
        return chomp::multiwork::mwError;
} /* Coordinator::Reject */
 
 
#endif // _CMGRAPHS_COORD_H_