awdiag2dmain.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// \file
///
/// The main procedure of a generic program for the computation
/// of the Alexander-Whitney diagonal.
///
/////////////////////////////////////////////////////////////////////////////

// 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: January 12, 2013.


#ifndef _AWDIAG2DMAIN_H_
#define _AWDIAG2DMAIN_H_


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

// 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/cellnames.h"
#include "chaincon/filtcomplex.h"
#ifdef SPACE_WRAPPING
#include "chaincon/wrapping.h"
#endif
#include "atmodcomp.h"
#include "awdiag2dcomp.h"


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

/// The main procedure of a program for the computation
/// of the Alexander-Whitney diagonal.
/// Returns: 0 = Ok, -1 = Error, 1 = Help displayed, 2 = Wrong arguments.
template <class CellT>
inline int awdiag2dMain (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;
        bool reduced = false;
        bool addBoundariesX = true;
        bool addBoundariesA = true;
        bool addNoBoundaries = false;
        bool displayDiag = 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, "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, "ddiag", displayDiag, 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)
        {
                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

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

                // prepare the data for storing the result of computation
                chomp::homology::hashedset<CellT> H;
                tCombLinMap<CellT, CellT> pi, incl, phi;
                tCellNames<CellT> cellNames;
        //      cellNames. setPrefix ("g");

                // compute the homology groups and generators
                bool displayPi = false;
                bool displayIncl = false;
                bool displayPhi = false;
                bool displayRepr = false;
                computeAlgTopModel (K, relativeComplex, H, pi, incl, phi,
                        cellNames, displayPi, displayIncl, displayPhi,
                        displayRepr, verify, algorithmVersion);

                // compute the A-W diagonal
                computeAWdiagonal2d (H, pi, incl, cellNames, displayDiag,
                        verify, K);

                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;
        }
} /* awdiag2dMain */


#endif // _AWDIAG2D_H_