cmsingle.cpp

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// @file cmsingle.cpp
///
/// Computing a single Conley-Morse graph.
/// This program constitutes an interface to computing a Conley-Morse graph
/// for a single parameter box the same way it would be computed by the
/// program "cmgraphs". Its purpose is to extract specific data
/// for a single parameter box after having located it with the aid
/// of the results obtained by the program "cmgraphs", in particular,
/// by having analyzed the continuation diagram.
/// Please, use the program "cmgraphs" to run computations for a range
/// of parameters and to do continuation matching
/// between the Morse decompositions.
///
/// @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 26, 2008. Last revision: April 10, 2008.


// include some standard C++ header files
#include <exception>
#include <sstream>
#include <fstream>
#include <algorithm>
#include <new>

// 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/system/arg.h"

// include local header files
#include "config.h"
#include "confinfo.h"
#include "typedefs.h"
#include "utils.h"
#include "compmdec.h"
#include "plotmdec.h"
#include "eigenval.h"
#include "dotgraph.h"


// --------------------------------------------------
// -------------------- OVERTURE --------------------
// --------------------------------------------------

/// The title of the program which is displayed every time
/// the program is launcued.
const char *title = "\
This is a program which computes a single Conley-Morse graph.\n\
Ver. 0.01, April 19, 2008. Copyright (C) 2005-2008 by Pawel Pilarczyk.\n\
This is free software. No warranty. Consult 'license.txt' for details.";

/// The help information about the program which is displayed
/// if the program is launched without command-line arguments
/// or with incorrect arguments.
const char *helpinfo = "\
This is the front-end program for the computation of a Conley-Morse graph\n\
for a single parameter box. It is a supplementary program to 'cmgraphs',\n\
and it capable of saving the results of all its computations to files.\n\
The parameter box is identified by the integer coordinates of its minimal\n\
vertex and corresponds to a box in the subdivision of the parameter area,\n\
for example, if the entire parameter range [-1,1]x[-1,1] is divided into\n\
20x20 boxes then '-b 0,19' corresponds to [-1.0,-0.9]x[0.9,1.0].\n\
Command line arguments (the argument '-b' is mandatory):\n\
-b x1,x2,...,xN - the integer coordinates of a parameter box to process,\n\
-g file.txt - file name to save the text code for the Conley-Morse graph,\n\
-s file.ind - file name to save/load cached Conley index information,\n\
-p file.png - file name to save a PNG picture of the Morse decomposition,\n\
-c prefix - prefix for file names to save Morse sets to as lists of boxes,\n\
--conn - compute connecting orbits between Morse sets (memory-consuming),\n\
--full - use the full range of the phase space to plot Morse sets,\n\
--log filename - file name to save all the text output of the program to,\n\
--quiet - suppress any output written to the terminal,\n\
--debug - display additional information useful for debugging,\n\
--help - make the program show this brief help information and exit.\n\
For more information ask the author at http://www.pawelpilarczyk.com/.";


// --------------------------------------------------
// --------------- Single Computation ---------------
// --------------------------------------------------

int runSingeComp (const char *boxCoordinates,
        const char *graphName, const char *shareName,
        const char *phaseSpaceName, bool fullPhaseSpace,
        const char *cubesName, bool connOrbits, int skipIndices)
{
        using chomp::homology::sout;

        // show the global configuration information
        std::ostringstream info;
        showConfigInfo (info, 0, 0);
        sout << "\n" << info. str () << "\n";

        // reset the variables for computing max image diameter and volume
        theCubMapType::maxImgDiam = 0;
        theCubMapType::maxImgVol = 0;

        // decode the parameter box
        parCube paramBox;
        std::string boxCoordStr ("(" + std::string (boxCoordinates) + ")");
        std::istringstream boxCoordStream (boxCoordStr);
        boxCoordStream >> paramBox;
        sout << "Computing Morse decomposition for " << paramBox << ".\n";

        // prepare the offset and the width of the phase space region
        double offset [spaceDim];
        for (int i = 0; i < spaceDim; ++ i)
                offset [i] = spaceOffset [i];
        double width [spaceDim];
        for (int i = 0; i < spaceDim; ++ i)
                width [i] = spaceWidth [i];

        // set up an array of coordinates of the box
        parCoord curCoord [paramDim];
        paramBox. coord (curCoord);

        // prepare the actual parameters for the map
        double leftMapParam [paramCount];
        double rightMapParam [paramCount];
        computeParam (curCoord, leftMapParam, rightMapParam);
        sout << "Parameter values:";
        for (int i = 0; i < paramCount; ++ i)
        {
                sout << " [" << leftMapParam [i] << "," <<
                        rightMapParam [i] << "]";
        }
        sout << "\n";

        // create the map object and set its parameters
        theMapType theMap;
        theMap. setParam (leftMapParam, rightMapParam, paramCount);

        // prepare an object of the cubical map
        // at the highest subdivision level to be used
        // in the definition of the Morse decomposition
        theCubMapType theCubMap0 (offset, width, 1 << finalDepth, theMap);
        theCubMap0. cache = true;
        theCubMapType theCubMap1 (offset, width, 1 << (finalDepth + 1),
                theMap);
        theCubMap1. cache = true;

        // prepare a boolean value to store the information on whether
        // the Conley indices in the Morse decomposition were computed
        // or read from cache
        bool morseDecComputed (false);

        // prepare an array in which wrong Conley indices will be recorded
        std::vector<int> wrongIndices;

        // prepare an array in which skipped Conley indices will be recorded
        std::vector<int> skippedIndices;

        // prepare an array in which attractors will be recorded
        std::vector<int> attractors;

        // compute the Morse decomposition
        theMorseDecompositionType *morseDec = computeMorseDecomposition
                (theMap, theCubMap0, theCubMap1, offset, width, skipIndices,
                shareName ? shareName : "", morseDecComputed, wrongIndices,
                skippedIndices, attractors, connOrbits,
                leftMapParam, rightMapParam, paramCount);

        // show computed max image diameter and volume
        sout << "Max img diam = " << theCubMapType::maxImgDiam <<
                ", max img vol = " << theCubMapType::maxImgVol << ".\n";

        // compute the min and max coordinates of Morse sets
        spcCoord coordLeftMin [spaceDim];
        spcCoord coordRightMax [spaceDim];
        for (int i = 0; i < spaceDim; ++ i)
        {
                coordLeftMin [i] = 1 << finalDepth;
                coordRightMax [i] = 0;
        }
        coordMinMax (*morseDec, coordLeftMin, coordRightMax);

        // save a picture of the computed Morse decomposition
        if ((spaceDim == 2) && phaseSpaceName && *phaseSpaceName)
        {
                sout << "Saving a picture of Morse sets to '" <<
                        phaseSpaceName << "'...\n";
                plotMorseDecompositionPNG (*morseDec, phaseSpaceName,
                        fullPhaseSpace ? (1 << finalDepth) : 0);
        }

        // save the computed Conley-Morse graph for the "dot" program
        if (graphName && *graphName)
        {
                // create the Morse graph from the Morse decomposition
                chomp::homology::diGraph<> connGraph;
                morseDec -> makegraph (connGraph);
                chomp::homology::diGraph<> morseGraph;
                transitiveReduction (connGraph, morseGraph);

                // gather the sizes of each Morse set into a vector
                int nSets = morseGraph. countVertices ();
                std::vector<int> sizes (nSets);
                for (int n = 0; n < nSets; ++ n)
                        sizes [n] = (*morseDec) [n]. size ();

                // gather the Conley indices and the eigenvalues
                std::vector<theConleyIndexType> indices (nSets);
                std::vector<IndexEigenValues> eigenValues (nSets);
                for (int n = 0; n < nSets; ++ n)
                {
                        indices [n] = morseDec -> index (n);
                        eigenValues [n] = IndexEigenValues (indices [n]);
                }

                sout << "Saving the Conley-Morse graph to '" <<
                        graphName << "'...\n";
                std::ofstream graphFile (graphName);
                writeDotGraph (graphFile, morseGraph, sizes,
                        indices, eigenValues,
                        wrongIndices, skippedIndices, attractors);
                graphFile << "\n";
        }

        // save the computed Morse sets to separate text files
        if (cubesName && *cubesName)
        {
                sout << "Saving the Morse decomposition to '" <<
                        cubesName << "*'...\n";
                morseDec -> savetofiles (cubesName);
        }

        delete morseDec;
        return 0;
} /* runSingleComp */


// --------------------------------------------------
// ---------------------- MAIN ----------------------
// --------------------------------------------------

/// The main procedure of the program.
/// Returns: 0 = Ok, -1 = Error, 1 = Help displayed, 2 = Wrong arguments.
int main (int argc, char *argv [])
{
        using namespace chomp::homology;

        // prepare user-configurable data
        int skipIndices = 0;
        char *boxCoordinates = 0;
        char *graphName = 0;
        char *shareName = 0;
        char *phaseSpaceName = 0;
        char *cubesName = 0;
        bool fullPhaseSpace = false;
        bool connOrbits = false;

        // interprete the command-line arguments
        arguments a;
        arg (a, "b", boxCoordinates);
        arg (a, "g", graphName);
        arg (a, "s", shareName);
        arg (a, "p", phaseSpaceName);
        arg (a, "c", cubesName);
        arg (a, "-skip-indices", skipIndices, 1);
        argswitch (a, "-full", fullPhaseSpace, true);
        argswitch (a, "-conn", connOrbits, true);
        arghelp (a);

        argstreamprepare (a);
        int argresult = a. analyze (argc, argv);
        argstreamset ();

        // if no box coordinates defined then show the help message
        if (!boxCoordinates)
                argresult = 1;

        // show the program's main title
        if (argresult >= 0)
                sout << title << '\n';

        // if something was incorrect, show an additional message and exit
        if (argresult < 0)
        {
                sout << "Call with '--help' for help.\n";
                return 2;
        }

        // if help requested, show help information
        if (argresult > 0)
        {
                sout << helpinfo << '\n';
                return 1;
        }

        // try running the main function and catch an error message if thrown
        try
        {
                // set an appropriate program time message
                program_time = "Aborted after:";
                program_time = 1;

                // run the computations for a single parameter box
                runSingeComp (boxCoordinates, graphName, shareName,
                        phaseSpaceName, fullPhaseSpace, cubesName,
                        connOrbits, skipIndices);

                // set an appropriate program time message
                program_time = "Total time used:";

                // finalize
                return 0;
        }
        catch (const char *msg)
        {
                sout << "ERROR: " << msg << '\n';
                return -1;
        }
        catch (const std::exception &e)
        {
                sout << "ERROR: " << e. what () << '\n';
                return -1;
        }
        catch (...)
        {
                sout << "ABORT: An unknown error occurred.\n";
                return -1;
        }
} /* main */

---