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-2008 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 2 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, write to the
// Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
// MA 02111-1307, USA.

// Started on February 11, 2008. Last revision: April 16, 2008.


#ifndef _CMGRAPHS_COORD_H_
#define _CMGRAPHS_COORD_H_


// include some standard C++ header files
#include <string>
#include <iostream>
#include <fstream>
#include <cctype>

// include selected header files from the CHomP library
#include "chomp/system/config.h"
#include "chomp/system/textfile.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 "utils.h"
#include "dataconv.h"
#include "matcharr.h"
#include "dotgraph.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 *_graphsFileName,
                const char *_finalPrefix, const char *_sharePrefix,
                const char *_phaseSpacePrefix, bool _fullPhaseSpace,
                int _skipIndices, int _nWorkers);

        /// 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 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 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 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;

        /// 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;

}; /* class Coordinator */

// --------------------------------------------------

inline Coordinator::Coordinator (const char *_interFileName,
        const char *_graphsFileName,
        const char *_finalPrefix, const char *_sharePrefix,
        const char *_phaseSpacePrefix, bool _fullPhaseSpace,
        int _skipIndices, int _nWorkers):
        currentCache (0), maxCache (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 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;

        // 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)
        {
                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);

        // prepare a rectangle for iterating the rectangular regions
        rectIterator = subRectangles (zeroIter, maxIter,
                subCoords, _nWorkers);

        // 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;
        }

        // 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;
        }

        // 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
        if (!sharePrefix. empty ())
        {
                for (int i = 0; i < paramDim; ++ i)
                        cacheCoord [i] = 0;
                maxCache = 1;
                for (int i = 0; i < paramDim; ++ i)
                        maxCache *= paramSubdiv [i];
        }

        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 ()
{
        if (rectIterator)
                delete rectIterator;
        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;

        // 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" and "png" files already exist
        while (currentCache < maxCache)
        {
                // if the cached indices file does not exist then send it
                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 (!phaseSpacePrefix. empty ())
                {
                        std::string pictureFileName = phaseSpacePrefix +
                                coord2str (cacheCoord, paramDim) + ".png";
                        if (!fileExists (pictureFileName. c_str ()))
                                break;
                }

                // 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";
                }
        }

        // 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;
        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;
        }

        // save the final results if this is the end of computations.
        if (allSent && !sentlen && !finalPrefix. empty ())
        {
                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";
                        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
                if (coordLeftMin [0] < coordRightMax [0])
                {
                        sout << "The computed Morse sets are in ";
                        for (int i = 0; i < spaceDim; ++ i)
                        {
                                sout << (i ? " x [" : "[") <<
                                        coordLeftMin [i] << "," <<
                                        coordRightMax [i] << "]";
                        }
                        sout << ".\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)
                return chomp::multiwork::mwNoData;

        // 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], 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;
                }
        }

        // 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 << sharePrefix;
        data << phaseSpacePrefix;
        data << fullPhaseSpace;
        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;
        }

        return chomp::multiwork::mwOk;
} /* Coordinator::Prepare */

inline int Coordinator::Accept (chomp::multiwork::mwData &data)
{
        using chomp::homology::sout;
        using chomp::homology::sbug;

        // 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";

        // 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> 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 (!graphsWritten. check (paramBox))
                {
                        graphsFile << paramBox << " ";
                        writeDotGraph (graphsFile, morseGraph, sizes,
                                indices, eigenValues,
                                localWrongIndices [curNumber],
                                skippedIndices [curNumber],
                                attractors [curNumber]);
                        graphsFile << "\n";
                        graphsWritten. add (paramBox);
                        graphsOutput = true;
                }
        }
        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;

        // 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 and say how many results have been accepted
        if (dataNumber >= 0)
                interFile << std::flush;
        if (graphsOutput)
                graphsFile << std::flush;
        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_

---