awdiag2dcomp.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// \file
///
/// A generic procedure for the Alexander-Whithey diagonal computation
/// for 2-dimensional homology generators.
/// This is a complete procedure good for simplicial, cubical,
/// or other complexes.
///
/////////////////////////////////////////////////////////////////////////////

// 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 6, 2013.


#ifndef _AWDIAG2DCOMP_H_
#define _AWDIAG2DCOMP_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/struct/hashsets.h"

// include relevant local header files
#include "chaincon/awdiag.h"
#include "chaincon/combchain.h"
#include "chaincon/combtensor.h"
#include "chaincon/comblinmap.h"


// --------------------------------------------------
// ---------------- compute homology ----------------
// --------------------------------------------------

/// Computes the Alexander-Whithey diagonal for 2-dimensional
/// homology generators.
/// Uses the projection and inclusion maps computed previously
/// as parts of a chain contraction of a cell complex.
template <class CellT, class LinMap, class CellNames, class CellRestrT>
void computeAWdiagonal2d (const chomp::homology::hashedset<CellT> &H,
        const LinMap &pi, const LinMap &incl, CellNames &cellNames,
        bool displayDiag, bool verify, const CellRestrT &restr)
{
        using chomp::homology::sout;

        typedef typename LinMap::ChainDomType ChainType;
        typedef typename LinMap::TensorDomType TensorType;

        // compute the AW decomposition of each 2D homology generator
        int_t Hsize = H. size ();
        for (int_t i = 0; i < Hsize; ++ i)
        {
                if (H [i]. dim () != 2)
                        continue;
                ChainType homGen = incl (H [i]);
                TensorType diag;
                AWdiagonal (homGen, diag);
                if (displayDiag)
                {
                        sout << "A-W diagonal of " << cellNames (H [i]) <<
                                ":\n";
                        int_t size = homGen. size ();
                        for (int_t j = 0; j < size; ++ j)
                        {
                                ChainType chain;
                                chain. add (homGen. getCell (j));
                                TensorType diagGen;
                                AWdiagonal (chain, diagGen);
                                sout << homGen. getCell (j) << " -> " <<
                                        diagGen << "\n";
                        }
                //      sout << "which reduces to:\n" << diag << "\n";
                }
                int_t n = diag. size ();
                TensorType diag1dim;
                for (int_t j = 0; j < n; ++ j)
                {
                        if (diag. left (j). dim () != 1)
                                continue;
                        if (diag. right (j). dim () != 1)
                                continue;
                        diag1dim. add (diag. left (j), diag. right (j));
                }
                TensorType diagBoundary;
                if (verify)
                        computeBoundary (diag1dim, diagBoundary, restr);
                if (displayDiag)
                {
                        sout << "restricted to 1-dim:\n" << diag1dim << "\n";
                        if (verify)
                        {
                                sout << "its boundary: " <<
                                        diagBoundary << "\n";
                        }
                }
                if (verify)
                {
                        if (diagBoundary. empty ())
                                sout << "Verified: bd AW " <<
                                        cellNames (H [i]) << " = 0.\n";
                        else
                                sout << "Failed to verify that bd AW " <<
                                        cellNames (H [i]) << " = 0.\n";
                }
                TensorType diagHom (pi (diag1dim));
                sout << "A-W decomp of " << cellNames (H [i]) << ": " <<
                        cells2names (diagHom, cellNames, cellNames) << "\n";
        }

        return;
} /* computeAWdiagonal */


#endif // _AWDIAG2DCOMP_H_