ssqmain.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// \file
///
/// The main function of a program for computing the Steenrod squares
/// of a simplicial complex or a cubical complex.
///
/////////////////////////////////////////////////////////////////////////////

// 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 July 4, 2013. Last revision: December 11, 2015.


#ifndef _SSQMAIN_H_
#define _SSQMAIN_H_


// the choice of cubes or simplices
#ifndef CUBES_NOT_SIMPLICES
#define CUBES_NOT_SIMPLICES 0
#endif

// is space wrapping relevant for the chosen type of cells?
#if CUBES_NOT_SIMPLICES
#define SPACE_WRAPPING
#endif

// should the direct formula by Marek Krcal be used for cubes?
#if CUBES_NOT_SIMPLICES
#ifndef DIRECT_CUBICAL_FORMULA
#define DIRECT_CUBICAL_FORMULA 1
#endif
#endif

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

// include the string hashing definitions (before including "hashsets.h")
#include "chaincon/stringhash.h"

// 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/cubcell.h"
#include "chaincon/cubproduct.h"
#include "chaincon/awdiagcub.h"
#include "chaincon/simplex.h"
#include "chaincon/simplset.h"
#include "chaincon/awdiagsim.h"
#include "chaincon/emptycell.h"
#include "chaincon/chain.h"
#include "chaincon/linmap.h"
#include "chaincon/comblinmap.h"
#include "chaincon/ringzp.h"
#include "chaincon/cellnames.h"
#include "chaincon/awdiag.h"
#include "chaincon/boundary.h"
#include "chaincon/ez_aw.h"
#include "chaincon/ez_eml.h"
#include "chaincon/ez_shi.h"
#include "chaincon/readfcompl.h"
#include "chaincon/setfilter.h"
#ifdef SPACE_WRAPPING
#include "chaincon/wrapping.h"
#endif
#include "atmodcomp.h"
#include "ssqcomp.h"


// --------------------------------------------------
// ----------------- mainProcedure ------------------
// --------------------------------------------------

/// Runs the experimental calculations.
//template <class SetT, class CellT, class CoefT, class CellNames>
template <class CellT, class SimCellT, class CoefT>
inline void computeSteenrodSquares (const char *Xname, const char *Aname,
        int algorithmVersion, int ssquareVersion,
        bool displayPi, bool displayIncl, bool displayPhi,
        bool displayD, bool displayRepr, bool verify)
{
        using chomp::homology::timeused;
        using chomp::homology::sout;
        using chomp::homology::sbug;
        using chomp::homology::fileerror;
        using chomp::homology::ignorecomments;
        using chomp::homology::hashedset;
        using chomp::homology::multitable;

        // prepare
        timeused compTime;
        compTime = 0;

#if CUBES_NOT_SIMPLICES
        sout << "Working with CUBICAL cells. "
                "(Please, re-compile for simplices.)\n";
#if DIRECT_CUBICAL_FORMULA
        sout << "Using a direct formula for cubical cells. "
                "(Recompile to change.)\n";
#else
        sout << "Using simplicial subdivision of cubical cells. "
                "(Recompile to change.)\n";
#endif
#else
        sout << "Working with SIMPLICIAL cells. "
                "(Please, re-compile for cubical sets.)\n";
#endif

        // compute the homology groups and generators
        sout << "Carrying out computations in the ring " <<
                CoefT::ringsymbol () << ".\n";

        // read the cubical or simplicial set
        sout << "Reading the cells from '" << Xname << "'...\n";
        hashedset<CellT> Xcells;
        std::ifstream in (Xname);
        if (!in)
                fileerror (Xname);
        in >> Xcells;
        in. close ();
        if (Xcells. empty ())
                throw "No cells read from the input file.";
        sout << Xcells. size () << " cells read.\n";

        // show a warning that relative complexes are not handled
        if (Aname && *Aname)
        {
                sout << "WARNING: Relative complexes cannot yet be handled "
                        "by this program.\nThe contents of '" <<
                        Aname << "' will be ignored.\n";
        }

#if CUBES_NOT_SIMPLICES && DIRECT_CUBICAL_FORMULA
        hashedset<SimCellT> &Xsimpl (Xcells);

        // determine the highest dimension of cubical cells in the set
        int dimension (-2);
        int_t size (Xsimpl. size ());
        for (int_t i = 0; i < size; ++ i)
        {
                int dim = Xsimpl [i]. dim ();
                if (dimension < dim)
                        dimension = dim;
        }

//      sbug << "DEBUG: The cubical set read from the file:\n" << Xsimpl;

        // transform the cubical set to a filtered complex
        sout << "Transforming the cubical set "
                "into a filtered complex...\n";
#else
        // transform the data into the structure of a simplicial set
        tSimplSet<SimCellT> Xsimpl;

#if CUBES_NOT_SIMPLICES
        // transform the cubes into products of simplices if necessary
        sout << "Transforming the cubical cells into products "
                "of simplices...\n";
        for (int_t i = 0; i < Xcells. size (); ++ i)
                cube2product (Xcells [i], Xsimpl);
        sout << Xsimpl. size () << " products created.\n";
#else
        sout << "Creating the structure of a simplicial set...\n";
        for (int_t i = 0; i < Xcells. size (); ++ i)
                Xsimpl. add (Xcells [i]);

        // add faces of all the cells in the product
        sout << "Adding faces of cells in the product...\n";
        int_t nAddedFaces = Xsimpl. addFaces ();
        sout << nAddedFaces << " faces added, the complex has " <<
                Xsimpl. size () << " elements.\n";
#endif
//      sbug << "DEBUG: Xsimpl:\n" << Xsimpl;

        // normalize the constructed simplicial set
        sout << "Normalizing the constructed simplicial set...\n";
        int_t nDegenerate = Xsimpl. normalize ();
        sout << nDegenerate << " degenerate cells removed, " <<
                Xsimpl. size () << " cells remain.\n";
//      sbug << "DEBUG: Xsimpl:\n" << Xsimpl;

        // determine the highest dimension of simplices in the simplicial set
        int dimension = Xsimpl. dim ();

        // transform the simplicial set to a filtered complex
        sout << "Transforming the simplicial set "
                "into a filtered complex...\n";
#endif
        tFilteredComplex<SimCellT> K;
        set2filter (Xsimpl, K, dimension);
//      sbug << "DEBUG: K:\n" << K;

#if CUBES_NOT_SIMPLICES && DIRECT_CUBICAL_FORMULA
        // add boundaries of cubical cells in the filtered complex
        sout << "Adding boundaries of cells in the complex...\n";
        addBoundaries (K, Unrestricted ());
        sout << "The complex has " << K. size () << " cells.\n";
#endif

//      sbug << "DEBUG: The filtered complex:\n" << K;

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

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

        // show the time used so far
        sout << "The computations up to now took " << compTime << ".\n";

        sout << "=== Computing an AT model ===\n";
//      computeAlgMinModel (K, false, H, A, B, Q, pi, incl, phi,
//              homCellNames, cohomCellNames,
//              displayPi, displayIncl, displayPhi, displayD, verify);
        computeAlgTopModel (K, false,
                H, pi, incl, phi, homCellNames,
                displayPi, displayIncl, displayPhi,
                displayRepr, verify, algorithmVersion);

        // show the time used so far
        sout << "The computations up to now took " << compTime << ".\n";

        // compute the Steenrod squares
        computeSteenrodSquares (H, A, B, Q, pi, incl, cohomCellNames,
                ssquareVersion, verify);

        return;
} /* computeSteenrodSquares */


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

/// The main procedure of the program.
/// Returns: 0 = Ok, -1 = Error, 1 = Help displayed, 2 = Wrong arguments.
inline int steenrodSquaresMain (int argc, char *argv [],
        const char *title, const char *helpinfo)
{
        // prepare the types for coordinates, cells, etc.
        typedef short int CoordT;
        typedef tZp<short> CoefT;

#if CUBES_NOT_SIMPLICES
        typedef tCubCell<CoordT,SettableWrapping<CoordT>,SettableEmptyCell>
                CellT;
#if DIRECT_CUBICAL_FORMULA
        typedef CellT SimCellT;
#else
        typedef tProdCell<tSimplex<CoordT,SettableEmptyCell> > SimCellT;
#endif
#else
        typedef tSimplex<CoordT,SettableEmptyCell> CellT;
        typedef tSimplex<CoordT,SettableEmptyCell> SimCellT;
#endif

        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 = 2;
        bool reduced = false;
        bool displayPi = false;
        bool displayIncl = false;
        bool displayPhi = false;
        bool displayD = false;
        bool displayRepr = false;
        bool verify = false;
        int algorithmVersion = 2;
        int ssquareVersion = 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);
        arg (a, "s", ssquareVersion);
        arg (a, "p", p);
#ifdef SPACE_WRAPPING
        arg (a, "w", wrapping, nWrapping, maxWrapping);
#endif
        argswitch (a, "r", reduced, true);
        argswitch (a, "dpi", displayPi, true);
        argswitch (a, "dincl", displayIncl, true);
        argswitch (a, "dphi", displayPhi, true);
        argswitch (a, "dd", displayD, 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 up the ring of coefficients and make a correction to p
                CoefT::setp (p);
                p = CoefT::getp ();

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

                // verify the experimental formulas
                computeSteenrodSquares<CellT, SimCellT, CoefT> (Xname, Aname,
                        algorithmVersion, ssquareVersion,
                        displayPi, displayIncl, displayPhi,
                        displayD, displayRepr, 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;
        }

} /* steenrodSquaresMain */


#endif // _SSQMAIN_H_