maxflow_sap.h

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file maxflow_sap.h

/* This software is distributed under the GNU Lesser General Public License */
//==========================================================================
//
//   maxflow_sap.h
//
//==========================================================================
// $Id: maxflow_sap.h,v 1.4 2003/01/31 08:15:05 chris Exp $

#ifndef GTL_MAXFLOW_SAP_H
#define GTL_MAXFLOW_SAP_H

#include <GTL/GTL.h>
#include <GTL/graph.h>
#include <GTL/node_map.h>
#include <GTL/edge_map.h>
#include <GTL/algorithm.h>

#include <queue>

__GTL_BEGIN_NAMESPACE

class GTL_EXTERN maxflow_sap : public algorithm
{
public:
    maxflow_sap();

    virtual ~maxflow_sap();

    void set_vars(const edge_map<double>& edge_capacity);

    void set_vars(const edge_map<double>& edge_capacity, 
                                  const node& net_source, 
                                  const node& net_target);

    virtual int check(graph& G);
            
    int run(graph& G);
                
    double get_max_flow(const edge& e) const;

    double get_max_flow() const;
        
    double get_rem_cap(const edge& e) const;

    virtual void reset();
protected:
    enum {AP_FOUND = 2, NO_AP_FOUND = 3};

    bool artif_source_target;

    bool set_vars_executed;

    double max_graph_flow;

    node net_source;

    node net_target;

    list<edge> edges_not_org;

    node_map<int> dist_label;
        
    edge_map<bool> edge_org;

    edge_map<bool> back_edge_exists;

    edge_map<edge> back_edge;

    edge_map<double> edge_capacity;

    edge_map<double> edge_max_flow;

    void create_artif_source_target(graph& G);

    void prepare_run(const graph& G);

        void comp_dist_labels(const graph& G, vector<int>& numb);

        bool has_an_admissible_arc(const node cur_node);

        void advance(node& cur_node, node_map<edge>& last_edge);

        void augment(graph& G, const node_map<edge>& last_edge);

        bool retreat(const int number_of_nodes,
                                 node& cur_node,
                                 const node_map<edge>& last_edge,
                                 vector<int>& numb);

        int min_neighbour_label(const int number_of_nodes,
                                                        const node cur_node) const;

    double free_capacity(const node_map<edge>& last_edge) const;

    void create_back_edge(graph& G, const edge& org_edge);

    void comp_max_flow(const graph& G);

    void restore_graph(graph& G);
};

__GTL_END_NAMESPACE

#endif // GTL_MAXFLOW_SAP_H

//--------------------------------------------------------------------------
//   end of file
//--------------------------------------------------------------------------