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-2014 by Pawel Pilarczyk.
//
// This file is part of my research software package. This is free software:
// you can redistribute it and/or modify it under the terms of the GNU
// General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
//
// This software is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this software; see the file "license.txt". If not,
// please, see <https://www.gnu.org/licenses/>.
 
// Started on February 12, 2007. Last revision: July 11, 2014.
 
 
#ifndef _CMGRAPHS_INDCACHE_H_
#define _CMGRAPHS_INDCACHE_H_
 
 
// include some standard C++ header files
#include <fstream>
#include <string>
#include <sstream>
 
// 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"
#include "typedyns.h"
#include "bytecompr.h"
#include "byteutil.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 and read the cached index information from
        std::ifstream inFile (fileName. c_str ());
        if (!inFile)
                return -1;
        std::string str;
        // if this is a bzip2-compressed file then decompress it
        if (inFile. peek () == 'B')
        {
                ByteDecompressor inDecompr (inFile);
                inDecompr >> str;
                inDecompr. close ();
        }
        // otherwise read the contents of the file directly
        else
        {
                std::getline (inFile, str, '\0');
        }
        inFile. close ();
 
        // create a string stream to decode the index information from
        std::istringstream in (str);
        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 a string stream to write the cached index information to
        std::ostringstream out;
 
        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";
        }
 
        // write the string to the output file
        std::ofstream outFile (fileName. c_str ());
        if (!outFile)
                return -1;
#ifdef CONFIG_NOINDEXCACHECOMPRESSION
        outFile << out. str ();
#else
        ByteCompressor outCompr (outFile);
        outCompr << out. str ();
        outCompr. close ();
#endif
        outFile. close ();
 
        return 0;
} /* IndexCache::write */
 
 
#endif // _CMGRAPHS_INDCACHE_H_