indcache.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// @file indcache.h
///
/// Cached Conley indices for a Morse decomposition.
/// This file contains the definition of a class for caching computed
/// Conley indices for a Morse decomposition. The Conley indices can be
/// saved to a file or retrieved from a file, including the information
/// on a nontrivial invariant part for Morse sets with the trivial index.
///
/// @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 12, 2007. Last revision: March 8, 2008.


#ifndef _CMGRAPHS_INDCACHE_H_
#define _CMGRAPHS_INDCACHE_H_


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

// include selected header files from the CHomP library
#include "chomp/system/textfile.h"
#include "chomp/cubes/pointset.h"

// include local header files
#include "config.h"
#include "typedefs.h"
#include "conindex.h"
#include "morsedec.h"


// --------------------------------------------------
// ------------- cached Conley indices --------------
// --------------------------------------------------

/// Cached information on the Conley-Morse decompositions
/// which contains information on computed Conley indices
/// for Morse sets and also the information on whether the invariant part
/// was proved to be empty for the sets with the trivial index.
class IndexCache
{
public:
        /// The constructor of an empty cached information structure
        /// for the given number of Morse sets.
        IndexCache (int nSets);

        /// Reads the cached information from a file, matches it
        /// with the given Morse decomposition and sets the Conley indices.
        /// Returns 0 if succeeded, or -1 if failed.
        int read (const std::string &fileName,
                theMorseDecompositionType &morseDec);

        /// Writes the cached information for the given Morse decomposition
        /// to a file.
        /// Returns 0 if succeeded, 1 if the file already exists,
        /// or -1 in the case of failure.
        int write (const std::string &fileName,
                const theMorseDecompositionType &morseDec) const;

        /// The destructor of a cached information structure.
        ~IndexCache ();

        /// The information on whether the invariant part of the given set
        /// has been proven to be empty.
        std::vector<bool> emptyInv;

        /// The information on whether the given Morse set is an attractor
        /// in the sense that its image is contained in itself.
        std::vector<bool> attractor;

        /// The information on whether the given index could not be computed
        /// because of a problem with isolation.
        std::vector<bool> wrongIndex;

        /// The information on whether the computation of the given index
        /// was skipped due to the limit on the size of the set.
        std::vector<bool> skipped;

}; /* class IndexCache */

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

inline IndexCache::IndexCache (int nSets): emptyInv (nSets, false),
        attractor (nSets, false), wrongIndex (nSets, false),
        skipped (nSets, false)
{
        return;
} /* IndexCache::IndexCache */

inline IndexCache::~IndexCache ()
{
        return;
} /* IndexCache::IndexCache */

int IndexCache::read (const std::string &fileName,
        theMorseDecompositionType &morseDec)
{
        using chomp::homology::ignoreline;
        using chomp::homology::ignorecomments;
        using chomp::homology::sbug;

        // open the file to read the cached index information from
        std::ifstream in (fileName. c_str ());
        if (!in)
                return -1;
        ignorecomments (in);

        // read the number of Morse sets and make sure that it is correct
        int nSets = -1;
        in >> nSets;
        ignorecomments (in);
        if (nSets != morseDec. count ())
        {
                sbug << "Wrong number of Morse sets: " << nSets <<
                        " instead of " << morseDec. count () << ".\n";
                return -1;
        }

        // prepare variables to read for each Morse set
        int number = -1;
        int empty = -1;
        int attr = -1;
        int wrong = -1;
        int skip = -1;
        int nCubes = -1;
        spcCube reprCube;
        theConleyIndexType ind;
        int countItems = 0;

        // prepare counters and matched bits to verify correctness
        int countSets = 0;
        std::vector<bool> matched (nSets, false);
        bool found = false;

        // read the Conley index and other information for each Morse set
        while (1)
        {
                // read the control character which determines
                // the kind of information to be read
                int character = in. get ();
                ignorecomments (in);
                if (countSets && (character == 'M'))
                        character = 0x100;

                switch (character)
                {
                // save the information previously gathered
                case EOF:
                case 0x100:
                        // make sure the number of items read is good
                        if (countItems < 7)
                        {
                                sbug << "Only " << countItems << " elements "
                                        "read, at least 7 expected.\n";
                                return -1;
                        }

                        // find the Morse set which corresponds to this one
                        // and fill in the corresponding information
                        found = false;
                        for (int setNum = 0; setNum < nSets; ++ setNum)
                        {
                                if (matched [setNum])
                                        continue;
                                if (morseDec [setNum]. size () != nCubes)
                                        continue;
                                if (!morseDec [setNum]. check (reprCube))
                                        continue;
                                matched [setNum] = true;
                                emptyInv [setNum] = (empty == 1);
                                attractor [setNum] = (attr == 1);
                                wrongIndex [setNum] = (wrong == 1);
                                skipped [setNum] = (skip == 1);
                                morseDec. setindex (setNum, ind);
                                found = true;
                                break;
                        }

                        // return error code if the Morse set was not matched
                        if (!found)
                        {
                                sbug << "Morse set no. " << number <<
                                        " could not be matched with any "
                                        "Morse set in the Morse dec.\n";
                                return -1;
                        }

                        // quit if this is the end of the data
                        if (character == EOF)
                        {
                                if (countSets == nSets)
                                        return 0;
                                sbug << "Cached information for " <<
                                        countSets << " Morse sets found, " <<
                                        nSets << " expected.\n";
                                return -1;
                        }

                        // reset the variables
                        number = -1;
                        empty = -1;
                        attr = -1;
                        wrong = -1;
                        skip = -1;
                        nCubes = -1;
                        countItems = 0;
                        // [no 'break' after this case...]

                // verify the number of the subsequent Morse set
                case 'M':
                        in >> number;
                        ignorecomments (in);
                        if (number != countSets)
                        {
                                sbug << "Wrong Morse set number: " <<
                                        number << " (" << countSets <<
                                        " expected).\n";
                                return -1;
                        }
                        ++ countSets;
                        ++ countItems;
                        break;

                // check if the invariant part of this set is empty or not
                case 'E':
                        in >> empty;
                        ignorecomments (in);
                        if ((empty != 0) && (empty != 1))
                        {
                                sbug << "The number 0 or 1 expected "
                                        "for 'emptyInv', " << empty <<
                                        " found.\n";
                                return -1;
                        }
                        ++ countItems;
                        break;

                // check if this is an attractor
                case 'A':
                        in >> attr;
                        ignorecomments (in);
                        if ((attr != 0) && (attr != 1))
                        {
                                sbug << "The number 0 or 1 expected "
                                        "for 'attractor', " << attr <<
                                        " found.\n";
                                return -1;
                        }
                        ++ countItems;
                        break;

                // check if the Morse set is wrong (no isolation)
                case 'W':
                        in >> wrong;
                        ignorecomments (in);
                        if ((wrong != 0) && (wrong != 1))
                        {
                                sbug << "The number 0 or 1 expected "
                                        "for 'wrong index', " << wrong <<
                                        " found.\n";
                                return -1;
                        }
                        ++ countItems;
                        break;

                // check if the computation for this set was skipped or not
                case 'S':
                        in >> skip;
                        ignorecomments (in);
                        if ((skip != 0) && (skip != 1))
                        {
                                sbug << "The number 0 or 1 expected "
                                        "for 'skipped index', " << skip <<
                                        " found.\n";
                                return -1;
                        }
                        ++ countItems;
                        break;

                // acquire the number of cubes in the Morse set
                case 'N':
                        in >> nCubes;
                        ignorecomments (in);
                        if (nCubes < 0)
                        {
                                sbug << "Negative number of cubes found.\n";
                                return -1;
                        }
                        ++ countItems;
                        break;

                // read a representative cube from the Morse set
                case 'Q':
                        // make sure that a cube is waiting at the input
                        if (in. peek () != '(')
                        {
                                sbug << "An opening parenthesis of a cube "
                                        "not present.\n";
                                return -1;
                        }

                        in >> reprCube;
                        ignorecomments (in);
                        ++ countItems;
                        break;

                // read the Conley index
                case 'I':
                        in >> ind;
                        ignorecomments (in);
                        ++ countItems;
                        break;

                // ignore any unsupported data (for backwards compatibility)
                default:
                        ignoreline (in);
                        ignorecomments (in);
                        break;
                }
        }

        return 0;
} /* IndexCache::read */

int IndexCache::write (const std::string &fileName,
        const theMorseDecompositionType &morseDec) const
{
        // create the file to write the cached index information to
        std::ofstream out (fileName. c_str ());
        if (!out)
                return -1;
        out << "; Cached information with Conley indices "
                "for a Morse decomposition.\n";

        // write the number of Morse sets
        int nSets = morseDec. count ();
        out << "; The number of Morse sets:\n";
        out << nSets << "\n";

        // write the description of the information
        out << "; -----------------------------------------------\n";
        out << "; M - the consecutive number of a Morse set\n";
        out << "; E - 1 if the invariant set is empty, 0 if unknown\n";
        out << "; A - 1 if this is an attractor, 0 if not or unknown\n";
        out << "; W - 1 if the index is wrong (no isolation), 0 if good\n";
        out << "; S - 1 if the index computation was skipped, 0 otherwise\n";
        out << "; N - the number of cubes in the Morse set\n";
        out << "; Q - a representative cube\n";
        out << "; I - the Conley index encoded in numbers\n";

        // write the Conley index and other information for each Morse set
        for (int n = 0; n < nSets; ++ n)
        {
                out << "; -----------------------------------------------\n";
                out << "M " << n << "\n";
                out << "E " << (emptyInv [n] ? 1 : 0) << "\n";
                out << "A " << (attractor [n] ? 1 : 0) << "\n";
                out << "W " << (wrongIndex [n] ? 1 : 0) << "\n";
                out << "S " << (skipped [n] ? 1 : 0) << "\n";
                out << "N " << morseDec [n]. size () << "\n";
                out << "Q " << morseDec [n] [0] << "\n";
                out << "I " << morseDec. index (n) << "\n";
        }

        return 0;
} /* IndexCache::write */


#endif // _CMGRAPHS_INDCACHE_H_

---