cmgraphs.cpp

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// @file cmgraphs.cpp
///
/// Conley-Morse graphs - the main program.
/// This program computes a set of Conley-Morse graphs
/// for a given discrete dynamical system
/// for a prescribed rectangular range of parameters,
/// and establishes the continuation relation
/// between adjacent computed graphs.
///
/// @author Pawel Pilarczyk
///
///
/// @mainpage The Conley-Morse Graphs Software
///
/// \section intro Introduction
///
/// This website contains the documentation of software designed and
/// programmed by Pawel Pilarczyk which accompanies the paper
/// <em>Databases for the Global Dynamics of Multiparameter Systems</em>
/// by Z. Arai, W. Kalies, H. Kokubu, K. Mischaikow, H. Oka,
/// and P. Pilarczyk. Please, see the
/// <a href="http://chomp.rutgers.edu/database/">website of the project</a>
/// and refer to the <a href="http://www.pawelpilarczyk.com/cmgraphs/">page
/// devoted to the software</a> for more information.
///
/// \section license License
///
/// In order to make this software freely available for wide audience,
/// it is provided here under the terms of the
/// <a href="http://www.gnu.org/copyleft/gpl.html">GNU General
/// Public License</a>, and this documentation is provided under the terms
/// of the <a href="http://www.gnu.org/copyleft/fdl.html">GNU Free
/// Documentation License</a>.
///
/// \section browsing Browsing
///
/// Although a lot of effort has been put into making this software
/// as transparent and clear as possible,
/// and to make this documentation complete,
/// I am sure that there is a lot of important information
/// which should have been included here but was omitted.
/// Therefore, this documentation was generated in such
/// a way that it contains the entire source code
/// which can be browsed and verified in case of any doubt.
///
/// So, what are you waiting for? Have a nice browsing!
///
/// 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 in November 2005. Last revision: February 24, 2008.


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

// 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 "chomp/multiwork/mw.h"

// include local header files
#include "config.h"
#include "typedefs.h"
#include "worker.h"
#include "coord.h"


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

/// The title of the program which is displayed every time
/// the program is launcued.
const char *title = "\
This is a Conley-Morse graphs computation program.\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 Conley-Morse graphs\n\
for a selected range of parameters for a given discrete dynamical system,\n\
as configured in the file 'config.h' of the source code. Please, see the\n\
documentation of the program and the source code for more information.\n\
Command line arguments (at least '-w', '-c' or '-f' must be specified):\n\
-w computer:port - run as a worker and connect to the given coordinator,\n\
-c [port] - run as a coordinator and listen to workers at the given port;\n\
\tif port=0 (default) then runs the computations locally only,\n\
-f prefix - file name prefix for saving the final continuation data & png,\n\
-i filename - intermediate results file (new results will be appended),\n\
-g filename - file name to save the text code for Conley-Morse graphs,\n\
-s prefix - file name prefix for saving shared Morse decompositions,\n\
-p prefix - file name prefix for PNG pictures of Morse decompositions,\n\
-n num - the expected number of workers (affects data chunk sizes),\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/.";


// --------------------------------------------------
// ---------------------- 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
        char *workAddress = 0;
        char *interFileName = 0;
        char *graphsFileName = 0;
        char *finalPrefix = 0;
        char *sharePrefix = 0;
        char *phaseSpacePrefix = 0;
        int coordPort = -1;
        int skipIndices = 0;
        bool fullPhaseSpace = false;
        int nWorkers = 1000000;

        // interprete the command-line arguments
        arguments a;
        arg (a, "c", coordPort, 0);
        arg (a, "w", workAddress);
        arg (a, "i", interFileName);
        arg (a, "g", graphsFileName);
        arg (a, "f", finalPrefix);
        arg (a, "s", sharePrefix);
        arg (a, "p", phaseSpacePrefix);
        arg (a, "n", nWorkers);
        arg (a, "-skip-indices", skipIndices, 1);
        argswitch (a, "-full", fullPhaseSpace, true);
        arghelp (a);

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

        // if the final results prefix is specified but no port for the
        // coordinator was specified then set it to 0 (local work)
        if (finalPrefix && (coordPort < 0))
                coordPort = 0;

        // if no worker/coordinator selected then show help information
        if (!finalPrefix && !workAddress)
                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 as a worker if requested to
                if (workAddress)
                {
                        Worker w (false);
                        w. Port (0);
                        w. Add (workAddress);
                        w. TimeOut (30);
                        sout << "Running as a worker...\n";
                        int result = w. Work ();
                        if (result == chomp::multiwork::mwOk)
                                sout << "Work completed successfully.\n";
                        else
                                sout << "Could not work - probably "
                                        "an error occurred.\n";
                }

                // run as a coordinator otherwise
                else
                {
                        Worker w (true);
                        Coordinator c (interFileName, graphsFileName,
                                finalPrefix, sharePrefix,
                                phaseSpacePrefix, fullPhaseSpace,
                                skipIndices, nWorkers);
                        c. Port (coordPort);
                        sout << "Running as a coordinator...\n";
                        int result = c. Coordinate (coordPort ? 0 : &w);
                        if (result == chomp::multiwork::mwOk)
                                sout << "The task completed successfully.\n";
                        else
                                sout << "Could not coordinate - probably "
                                        "an error occurred.\n";
                }

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

---