atmodmain.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// \file
///
/// The main procedure for a program for the computation of
/// an algebraic topological model.
///
/////////////////////////////////////////////////////////////////////////////

// Copyright (C) 2009-2016 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 <http://www.gnu.org/licenses/>.

// Started on March 24, 2009. Last revision: October 21, 2013.


#ifndef _ATMODMAIN_H_
#define _ATMODMAIN_H_


// include some standard C++ header files
#include <istream>
#include <ostream>
#include <string>

// 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/struct/hashsets.h"

// include relevant local header files
#include "chaincon/linmap.h"
#include "chaincon/comblinmap.h"
#include "chaincon/ringzp.h"
#include "chaincon/cellnames.h"
#ifdef SPACE_WRAPPING
#include "chaincon/wrapping.h"
#endif
#include "atmodcomp.h"


// --------------------------------------------------
// ---------------------- main ----------------------
// --------------------------------------------------

/// The main procedure for a program for the computation of a homology
/// gradient vector field.
/// Returns: 0 = Ok, -1 = Error, 1 = Help displayed, 2 = Wrong arguments.
template <class CellT>
inline int atModelMain (int argc, char *argv [],
        const char *title, const char *helpinfo)
{
        using namespace chomp::homology;

        // turn on a message that will appear if the program does not finish
        program_time = "Aborted after";

        // prepare user-configurable data
        char *Xname = 0;
        char *Aname = 0;
        int p = 1;
        bool reduced = false;
        bool addBoundariesX = true;
        bool addBoundariesA = true;
        bool addNoBoundaries = false;
        bool displayPi = false;
        bool displayIncl = false;
        bool displayPhi = false;
        bool displayRepr = false;
        bool verify = false;
        int algorithmVersion = 2;
#ifdef SPACE_WRAPPING
        const int maxWrapping = 100;
        char *wrapping [maxWrapping];
        int nWrapping = 0;
#endif

        // analyze the command line
        arguments a;
        arg (a, NULL, Xname);
        arg (a, NULL, Aname);
        arg (a, "p", p);
        arg (a, "a", algorithmVersion);
#ifdef SPACE_WRAPPING
        arg (a, "w", wrapping, nWrapping, maxWrapping);
#endif
        argswitch (a, "r", reduced, true);
        argswitch (a, "bx", addBoundariesX, false);
        argswitch (a, "ba", addBoundariesA, false);
        argswitch (a, "b", addNoBoundaries, true);
        argswitch (a, "dpi", displayPi, true);
        argswitch (a, "dincl", displayIncl, true);
        argswitch (a, "dphi", displayPhi, true);
        argswitch (a, "drepr", displayRepr, true);
        argswitch (a, "-verify", verify, true);
        arghelp (a);

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

        // show the program's 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 or no filename present, show help information
        if ((argresult > 0) || !Xname || (p < 0))
        {
                sout << helpinfo << '\n';
                return 1;
        }

        // try running the main function and catch an error message if thrown
        try
        {
                // set the existence of the empty cell if desired
                if (reduced)
                        CellT::EmptyType::setExistence (true);

#ifdef SPACE_WRAPPING
                // set wrapping as desired
                for (int i = 0; i < nWrapping; ++ i)
                {
                        setWrapping<typename CellT::WrapType>
                                (std::string (wrapping [i]));
                }
#endif

                // prepare the data for storing the result of computation
                chomp::homology::hashedset<CellT> H;

                // read the filtered cell complexes
                tFilteredComplex<CellT> K;
                tFilteredComplex<CellT> L;
                readFilteredComplexes (Xname, Aname, K, L,
                        addBoundariesX && !addNoBoundaries,
                        addBoundariesA && !addNoBoundaries);
                bool relativeComplex = !L. empty ();

                // compute the homology groups and generators
                tCellNames<CellT> cellNames;
        //      cellNames. setPrefix ("g");
                if (p == 1)
                {
                        sout << "Carrying out computations "
                                "in a combinatorial way (ring Z_2).\n";
                        tCombLinMap<CellT,CellT> pi, incl, phi;
                        computeAlgTopModel (K, relativeComplex, 
                                H, pi, incl, phi, cellNames,
                                displayPi, displayIncl, displayPhi,
                                displayRepr, verify, algorithmVersion);
                }
                else
                {
                        typedef tZp<short> CoefT;
                        CoefT::setp (p);
                        p = CoefT::getp ();
                        sout << "Carrying out computations in the ring " <<
                                CoefT::ringsymbol () << ".\n";
                        tLinMap<CellT,CellT,CoefT> pi, incl, phi;
                        computeAlgTopModel (K, relativeComplex, 
                                H, pi, incl, phi, cellNames,
                                displayPi, displayIncl, displayPhi,
                                displayRepr, verify, algorithmVersion);
                }

                program_time = "Total time used:";
                program_time = 1;
                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;
        }
} /* atModelMain */


#endif // _ATMODMAIN_H_