---

io_dinic.cpp

#include "dinic.hpp"

#include <fstream>

#include "PG_ostream.hpp"

void print()
{
  if( _libbase.rank() == 0 ) std::cout << "Der Graph: " << std::endl;
  std::cout << *g;
}

AllToAllBuffer dummy_buf;

void read_graph( std::istream & istr )
{
  char c;
  bool has_pline = false;
  size_t vsize=0;
  while( istr.get(c) )
  {
    switch(c)
    {
    case 'p':
        istr >> vsize;
        for( size_t i = 0 ; i < vsize ; i++ )
        {
          vertex_property_type v_prop(0);
          g->insert( i, v_prop );
        }
        has_pline = true;
    case 'c':
    case '#':
        do {
            istr.get(c);
        } while( c != '\n' );
        break;
    case 'n':
    case 'v':
        {
        VertexID_t v;
        proc_t p;
        istr >> v;
        istr >> p;
        int size = -1;
        do {
            size++;
            istr.get(c);
        } while( c != '\n' );
        char * name = new char[size];
        for(int i = 0 ; i < size ; i++ ) istr.unget();
        istr.get( name, size ); istr.get(c);
        if( has_pline )
        {
            //put( VertexPropertyMap< vertex_name_tag, Graph >(), v,*g, name );
        }
        else
        {
            std::cout<<"error"<<std::endl;exit(0);
            //vertex_property_type v_prop( name, vertex_property_type::next_type( p ));
            g->insert( v );//, v_prop );
        }
        if( strcmp( name, "s" ) == 0 ) (*set_s_vertex).insert( v );
        if( strcmp( name, "t" ) == 0 ) (*set_t_vertex).insert( v );
        }
        break;
    case 'a':
    case 'e':
        VertexID_t v1, v2;
        EdgeID_t e;
        unsigned int cap;
        istr >> e;
        istr >> v1;
        istr >> v2;
        istr >> cap;
        do {
            istr.get(c);
        } while( c != '\n' );
        network_edges_property_type e_prop( cap,
        network_edges_property_type::next_type( 0 ));
        add_edge_with_id( network_edges, e, v1, v2, e_prop, *g, dummy_buf );
    }
  }
}

void random_graph( VertexID_t vsize, EdgeID_t esize, unsigned int maxcap, unsigned int seed, std::ostream & ostr )
{
  ostr << "p " << vsize << " " << esize << std::endl;
  srand( seed );
  VertexID_t v = 0, s = rand() % vsize, t = rand() % vsize;
  if( s == t ) t = (t + 1) % vsize;
  for(; v < vsize ; v++ )
  {
    if( v == s )
        ostr << "v " << v << " 0 s" << std::endl;
    if( v == t )
        ostr << "v " << v << " 0 t" << std::endl;

    vertex_property_type v_prop;
    g->insert( v, v_prop );
  }
  (*set_s_vertex).insert( s );
  (*set_t_vertex).insert( t );
  for( EdgeID_t e = 0 ; e < esize ; e++ )
  {
    VertexID_t v1 = rand() % vsize, v2 = rand() % vsize;
    if( v1 == v2 ) v2 = (v2 + 1) % vsize;
    unsigned int cap = (rand() % maxcap) + 1;
    network_edges_property_type e_prop( cap,
    network_edges_property_type::next_type( 0 ));
    add_edge_with_id( network_edges, e, v1, v2, e_prop, *g, dummy_buf );
    ostr << "e " << e << " " << v1 << " " << v2 << " " << cap <<std::endl;
  }
}

void rect_graph_add_edge( VertexID_t v1, VertexID_t v2, EdgeID_t * e, unsigned int maxcap, std::ostream & ostr )
{
  unsigned int cap = (rand() % maxcap) + 1;
  network_edges_property_type e_prop( cap,
  network_edges_property_type::next_type( 0 ));
  add_edge_with_id( network_edges, *e, v1, v2, e_prop, *g, dummy_buf );
  ostr << "e " << *e << " " << v1 << " " << v2 << " " << cap <<std::endl;
  (*e)++;
}

void rectangular_graph( size_t breadth, size_t length, unsigned int maxcap, unsigned int seed, std::ostream & ostr )
{
  size_t vsize = breadth * length + 2;
  size_t esize = 4 * breadth * length - breadth - 3 * length + 2;
  ostr << "p " << vsize << " " << esize << std::endl;
  srand( seed );

  VertexID_t v = 0, s = vsize - 2, t = vsize - 1;
  for(; v < vsize ; v++ )
  {
    vertex_property_type v_prop;
    g->insert( v, v_prop );
  }
  (*set_s_vertex).insert( s );
  (*set_t_vertex).insert( t );
  ostr << "v " << s << " 0 s" << std::endl;
  ostr << "v " << t << " 0 t" << std::endl;

  EdgeID_t e = 0;
  for( size_t i = 0 ; i < breadth ; i++ )
  {
    for( size_t j = 0 ; j < length ; j++ )
    {
      VertexID_t v1 = i + j * breadth;
      if( j < length - 1 )
        rect_graph_add_edge( v1, i + (j + 1) * breadth,
                             &e, maxcap, ostr );
      if( j < length - 1 && i < breadth - 1 )
        rect_graph_add_edge( v1, i + 1 + (j + 1) * breadth,
                             &e, maxcap, ostr );
      if( j < length - 1 && i > 0 )
        rect_graph_add_edge( v1, i - 1 + (j + 1) * breadth,
                             &e, maxcap, ostr );
      if( i < breadth - 1 )
        rect_graph_add_edge( v1, i + 1 + j * breadth,
                             &e, maxcap, ostr );
      if( i > 0 )
        rect_graph_add_edge( v1, i - 1 + j * breadth,
        &e, maxcap, ostr );
    }
    rect_graph_add_edge( s, i, &e, maxcap, ostr );
    rect_graph_add_edge( i + breadth * ( length - 1 ), t,
                         &e, maxcap, ostr );
  }
}

void dinic_read_graph( int argc, char **argv )
{
  if( argc != 2 && argc != 7 )
  {
    if( rank() == 0 )
    {
      std::cout << "USAGE: dinic <Datafile>\n"
                << "       dinic r <VertiexSize> <EdgeSize> <MaxCapacity> <Seed> <Datafile>\n"
                << "       dinic q <Breadth> <Length> <MaxCapacity> <Seed> <Datafile>\n"
                << "Calculates the maximum flow of a graph.\n"
                << "The first variant reads the graph from <Datafile>.\n"
                << "The second one creates a random graph out of four parameters and stores it in <Datafile>."
                << std::endl;
    }
    ParGraph_finalize();
    exit(0);
  }

  if( rank() == 0 )
  {
    if( argc == 2 )
    {
      std::ifstream istr( argv[1] );
      read_graph( istr );
      std::cout<<"Graph eingelesen"<<std::endl;
    }
    else
    {
      VertexID_t v = atoi( argv[2] );
      EdgeID_t e = atoi( argv[3] );
      unsigned int c = atoi( argv[4] );
      unsigned int s = atoi( argv[5] );
      std::ofstream ostr( argv[6] );
      if( argv[1][0] == 'r' )
          random_graph( v, e, c, s, ostr );
      if( argv[1][0] == 'q' )
          rectangular_graph( v, e, c, s, ostr );
      std::cout<<"Graph zufällig erzeugt"<<std::endl;
    }
  }
}

---