DirectedGraph.hpp

Go to the documentation of this file.

// Classes to assist with mesh handling and coarsening
 
#include <iostream>
#include <iomanip>
#include <vector>
#include <algorithm>
#include <functional>
#include <random>
#include <fstream>
#include <Eigen/Dense>
#include <assert.h>
 
#ifndef _DIRECTEDGRAPH_HPP
#define _DIRECTEDGRAPH_HPP
 
// ----------------------------------------------------------------------------
//                            Free functions
// ----------------------------------------------------------------------------
 
typedef std::vector<std::vector<std::size_t>> Array;
 
// ----------------------------------------------------------------------------
//                            DirectedFace class definition
// ----------------------------------------------------------------------------
 
class DirectedFace
{
public:
    std::vector<std::size_t> V;
    
    DirectedFace();
    
    ~DirectedFace();
    
    DirectedFace(std::vector<std::size_t>);
 
    void add_vertex(
        size_t 
    );
};
 
bool operator==(const DirectedFace &, const DirectedFace &);
 
// ----------------------------------------------------------------------------
//                            DirectedCell class definition
// ----------------------------------------------------------------------------
 
class DirectedCell
{
public:
    std::vector<DirectedFace> T;
    
    std::vector<std::size_t> part;
    
    DirectedCell();
    
    DirectedCell(std::size_t);
    
    ~DirectedCell();
    
    DirectedCell(
        std::vector<DirectedFace> &, 
        std::size_t 
    );
    
    void add_face(
        DirectedFace & 
    );
    
    void remove_face(
        std::size_t 
    );
    
    void append_cell(
        DirectedCell & 
    );
 
    bool check_cell();
    
    bool has_face(
        DirectedFace 
    );
    
    void print(); // Useful for debugging
};
 
// ----------------------------------------------------------------------------
//                            NodeArray class definition
// ----------------------------------------------------------------------------
 
class CellNodeArray
{
public:
    Array A;
    
    CellNodeArray();
    
    ~CellNodeArray();
    
    CellNodeArray(
        Array & 
    );
    
    bool node_exists(
        std::size_t 
    );
    
    void renum_nodes(
        std::size_t 
    );
    
    void print(
        std::ofstream *, 
        std::size_t
    );
};
 
class GraphNodeArray
{
public:
    std::vector<CellNodeArray> GA;
    
    GraphNodeArray();
    
    ~GraphNodeArray();
    
    GraphNodeArray(
        std::vector<CellNodeArray> & 
    );
    
    bool node_exists(
        std::size_t 
    );
    
    void renum_nodes(
        std::size_t 
    );
    
    void print(
        std::ofstream * 
    );
};
 
class DirectedGraph
{
public:
    std::vector<DirectedCell> G;
    
    DirectedGraph();
    
    ~DirectedGraph();
    
    DirectedGraph(
        std::vector<DirectedCell> & 
    );
    
    void add_cell(
        DirectedCell & 
    );
 
    void remove_cell(
        std::size_t 
    );
    
    bool test_graph();    
    
    void randomise();
    
    void order();
    
    void coarsen();
    
    GraphNodeArray graph_to_array();
    
    std::string get_partition();
    
    void plotfile(
        std::ofstream *, 
        std::vector<Eigen::VectorXd> & 
    );
 
private:
    /* Checks is there exists a shared face, and checks if there exists
       a shared node at a non-face interface i.e. they touch at a corner.
       Must be true, false to return true. Also stores a vector of shared 
       faces to pass to merge_cells - which deletes them.
     */
    bool can_merge(std::size_t, std::size_t, std::vector<size_t> &);
    
    /* Appends second cell to the first. Removes second cell. Removes 
       duplicate faces of first cell then orders faces. Handles
       non-simply connected case.
     */
    void merge_cells(std::size_t, std::size_t, std::vector<size_t> &);    
    
    // Random boolean generator for coarsen()
    std::knuth_b rand_engine;
    bool random_bool(double);
};
 
 
#endif