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>
 
#ifndef _DIRECTEDGRAPH_HPP
#define _DIRECTEDGRAPH_HPP
 
// ----------------------------------------------------------------------------
//                            Free functions
// ----------------------------------------------------------------------------
 
typedef std::vector<std::vector<std::size_t>> Array;
 
// ----------------------------------------------------------------------------
//                            DirectedEdge class definition
// ----------------------------------------------------------------------------
 
class DirectedEdge
{
public:
    std::size_t a;
    
    std::size_t b;
    
    DirectedEdge();
    
    ~DirectedEdge();
    
    DirectedEdge(size_t, size_t);
    
    DirectedEdge anti_edge();
};
 
bool operator==(const DirectedEdge &, const DirectedEdge &);
 
// ----------------------------------------------------------------------------
//                            DirectedCell class definition
// ----------------------------------------------------------------------------
 
class DirectedCell
{
public:
    std::vector<DirectedEdge> T;
    
    std::vector<std::size_t> part;
    
    DirectedCell();
    
    DirectedCell(std::size_t);
    
    ~DirectedCell();
    
    DirectedCell(
        std::vector<DirectedEdge> &, 
        std::size_t 
    );
    
    void add_edge(
        DirectedEdge & 
    );
    
    void remove_edge(
        std::size_t 
    );
    
    void append_cell(
        DirectedCell & 
    );
    
    bool check_nodes();
    
    bool is_ordered();
    
    void remove_duplicate_edges();
    
    std::vector<DirectedEdge> order_edges();
    
    bool has_edge(
        DirectedEdge 
    );
    
    void print(); // Useful for debugging
};
 
// ----------------------------------------------------------------------------
//                            NodeArray class definition
// ----------------------------------------------------------------------------
 
class NodeArray
{
public:
    Array A;
    
    NodeArray();
    
    ~NodeArray();
    
    NodeArray(
        Array & 
    );
    
    bool node_exists(
        std::size_t 
    );
    
    void renum_nodes(
        std::size_t 
    );
    
    void print(
        std::ofstream *, 
        std::size_t width = 6 
    );
};
 
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();
    
    NodeArray graph_to_array();
    
    std::string get_partition();
    
    void plotfile(
        std::ofstream *, 
        std::vector<Eigen::VectorXd> & 
    );
 
private:
    /* Checks if there exists a shared edge, and checks if there exists
       a shared node at a non-edge interface i.e. they touch at a corner.
       Must be true, false to return true. Also stores a vector of shared 
       edges 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 edges of first cell then orders edges. 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