procsave.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// @file procsave.h
///
/// A plug-in for post-processing of Morse decompositions
/// which saves the Morse decomposition and the combinatorial map.
/// This is a replacement for "procmdec.h".
///
/// @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 August 7, 2010. Last revision: July 7, 2011.
 
 
#ifndef _CMGRAPHS_PROCSAVE_H_
#define _CMGRAPHS_PROCSAVE_H_
 
// include some system header files
#include <string>
#include <sstream>
#include <fstream>
 
// include selected header files from the CHomP library
#include "chomp/system/textfile.h"
#include "chomp/struct/digraph.h"
 
// include local header files
#include "config.h"
#include "typedefs.h"
#include "conindex.h"
#include "morsedec.h"
#include "typedyns.h"
 
 
namespace custom {
 
/// Dummy version of a function for the post-processing
/// of Morse decompositions.
namespace saveMorseDec {
 
 
// --------------------------------------------------
// ------- post-process a Morse decomposition -------
// --------------------------------------------------
 
/// Dummy function for post-processing Morse decompositions.
template <class CubSetType, class MorseDecType, class GraphType,
        class CubMapType>
inline void processMorseDec (const MorseDecType &morseDec,
        const CubSetType &X, const GraphType &g,
        const CubMapType &theCubMap, const CubMapType &,
        const std::string &cubesFilePrefix,
        const std::string &procFilePrefix)
{
        using chomp::homology::sout;
 
        // don't save anything if the file name is not given
        if (cubesFilePrefix. empty ())
                return;
 
        // save the entire space to a file
        if (true)
        {
                sout << "Saving the phase space...\n";
                std::ostringstream filename;
                filename << cubesFilePrefix << ".cub";
                std::ofstream f (filename. str (). c_str ());
                f << "; The phase space X: " << X. size () << " cubes.\n";
                f << X;
        }
 
        // save the combinatorial map to a file
        if (false)
        {
                sout << "Saving the combinatorial map...\n";
                std::ostringstream filename;
                filename << cubesFilePrefix << ".map";
                std::ofstream f (filename. str (). c_str ());
                f << "; The combinatorial map: " << X. size () <<
                        " assignments.\n";
                for (int i = 0; i < X. size (); ++ i)
                {
                        f << X [i] << " -> {";
                        spcCubes img;
                        theCubMap (X [i], &img, 0, 0, 0, false);
                        for (int j = 0; j < img. size (); ++ j)
                        {
                                if (j)
                                        f << ",";
                                f << img [j];
                        }
                        f << "}\n";
                }
        }
 
        // save the graph to a file
        if (false)
        {
                sout << "Saving the graph...\n";
                std::ostringstream filename;
                filename << cubesFilePrefix << ".grp";
                std::ofstream f (filename. str (). c_str ());
                f << "; The graph: " << g. countVertices () <<
                        " vertices, " << g. countEdges () << " edges.\n";
                f << g;
        }
 
        // save the Morse sets and the exit sets to files
/*      sout << "Saving the index pairs for the Morse sets...\n";
        for (int m = 0; m < morseDec. count (); ++ m)
        {
                // extract the Morse set
                const spcCubes &mSet = morseDec [m];
 
                // save the Morse set
                {
                        std::ostringstream filename;
                        filename << cubesFilePrefix << m << "q.cub";
                        std::ofstream f (filename. str (). c_str ());
                        f << "; The Morse set no. " << m << ": " <<
                                mSet. size () << " cubes.\n";
                        f << mSet;
                }
 
                // compute the exit set for the Morse set
                spcCubes mExit;
                for (int i = 0; i < mSet. size (); ++ i)
                        theCubMap (mSet [i], &mExit, 0, 0, false);
                mExit. remove (mSet);
 
                // save the exit set
                {
                        std::ostringstream filename;
                        filename << cubesFilePrefix << m << "r.cub";
                        std::ofstream f (filename. str (). c_str ());
                        f << "; The exit set no. " << m << ": " <<
                                mExit. size () << " cubes.\n";
                        f << mExit;
                }
        }
*/
        return;
} /* processMorseDec */
 
 
} // namespace saveMorseDec
} // namespace custom
 
 
#endif // _CMGRAPHS_PROCSAVE_H_