readfcompl.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// \file
///
/// A generic procedure for reading a filtered cell complex or a pair
/// of filtered cell complexes from text files.
///
/////////////////////////////////////////////////////////////////////////////

// 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: September 24, 2015.


#ifndef _CHAINCON_READFCOMPL_H_
#define _CHAINCON_READFCOMPL_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 relevant local header files
#include "chaincon/filtcomplex.h"
#include "chaincon/boundary.h"
#include "chaincon/remordered.h"


// --------------------------------------------------
// ------------ read filtered complexes -------------
// --------------------------------------------------

/// Reads a filtered cell complex or a pair of filtered cell complexes
/// from text files.
/// Shows appropriate messages and throws an error message in case of failure.
template <class CellT>
inline void readFilteredComplexes (const char *Xname, const char *Aname,
        tFilteredComplex<CellT> &K, tFilteredComplex<CellT> &L,
        bool addBoundariesX, bool addBoundariesA)
{
        using chomp::homology::sout;

        // read the first filtered cell complex
        {
                sout << "Reading '" << Xname << "'... ";
                std::ifstream in (Xname);
                if (!in)
                        chomp::homology::fileerror (Xname);
                in >> K;
                in. close ();
                sout << K. size () << " cells read.\n";
        }
//      sout << "Cells read from the input:\n" << K << "\n";

        // read the second filtered cell complex
        if (Aname && *Aname)
        {
                sout << "Reading '" << Aname << "'... ";
                std::ifstream in (Aname);
                if (!in)
                        chomp::homology::fileerror (Aname);
                in >> L;
                in. close ();
                sout << L. size () << " cells read.\n";
        }
//      sout << "Cells read from the input:\n" << L << "\n";

        // add boundaries to the second filtered cell complex
        if (Aname && *Aname)
        {
                if (addBoundariesA)
                {
                        sout << "Adding boundaries to '" << Aname << "'... ";
                        addBoundaries (L, Unrestricted ());
                        sout << L. size () << " cells total.\n";
                }
                else
                {
                        sout << "NOT adding boundaries to '" << Aname <<
                                "'.\n";
                        sout << "Note: All the relevant boundaries of cells "
                                "are assumed to be present already.\n";
                }
        }

        // remove from K all the cells that appear in L
        if (Aname && *Aname)
        {
                int_t prev_size = K. size ();
                sout << "Making the filters disjoint... ";
                removeOrdered (K, L);
                sout << (K. size () - prev_size) << " cells removed.\n";
        }

        // make sure that the filtered cell complex is complete
        if (addBoundariesX)
        {
                sout << "Adding boundaries to '" << Xname << "'... ";
                if (Aname && *Aname)
                {
                        addBoundaries (K,
                                NegateRestr<tFilteredComplex<CellT> > (L));
                }
                else
                {
                        addBoundaries (K, Unrestricted ());
                }
                sout << K. size () << " cells total.\n";
        }
        else
        {
                sout << "NOT adding boundaries to '" << Xname << "'.\n";
                sout << "Note: All the relevant boundaries of cells "
                                "are assumed to be present already.\n";
        }

//      sout << "Filtered complex:\n" << K << "==========\n";

        return;
} /* readFilteredComplexes */


#endif // _CHAINCON_READFCOMPL_H_