cringmain.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// \file
///
/// The main function of a program for computing the cubical cohomology ring
/// of a cellular complex of a given type.
///
/////////////////////////////////////////////////////////////////////////////

// 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: June 10, 2015.


#ifndef _CRINGMAIN_H_
#define _CRINGMAIN_H_


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

// 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/ringzp.h"
#include "chaincon/cellnames.h"
#ifdef SPACE_WRAPPING
#include "chaincon/wrapping.h"
#endif
#include "ammodcomp.h"
#include "cringcomp.h"


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

/// The main procedure of a program for the computation of a cohomology ring.
/// Returns: 0 = Ok, -1 = Error, 1 = Help displayed, 2 = Wrong arguments.
template <class CellT>
inline int cohomRingMain (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 = 0;
        bool reduced = false;
        bool addBoundariesX = true;
        bool addBoundariesA = true;
        bool addNoBoundaries = false;
        bool displayPi = false;
        bool displayIncl = false;
        bool displayPhi = false;
        bool displayD = false;
        bool verify = false;
#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);
#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, "dd", displayD, 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 ring of coefficients
                typedef tZp<short> CoefT;
                CoefT::setp (p);
                p = CoefT::getp ();

                // prepare the data for storing the result of computations
                chomp::homology::hashedset<CellT> H, A, B;
                std::vector<CoefT> Q;

                // compute the homology groups and generators
                sout << "Carrying out computations in the ring " <<
                        CoefT::ringsymbol () << ".\n";
                tLinMap<CellT,CellT,CoefT> pi, incl, phi;
                tCellNames<CellT> dummyCellNames;
                tCellNames<CellT> cellNames;
        //      cellNames. setPrefix ("g");

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

                sout << "=== Computing the minimal model ===\n";
                computeAlgMinModel (K, !L. empty (), H, A, B, Q,
                        pi, incl, phi, dummyCellNames, cellNames,
                        displayPi, displayIncl, displayPhi, displayD,
                        verify);

                sout << "=== Computing the cohomology ring ===\n";
                computeCohomRing (H, A, B, Q, pi, incl, cellNames, verify);

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


#endif // _CRINGMAIN_H_