graph_coloring_process.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Pooyan Dadvand
//
 
#if !defined(KRATOS_GRAPH_COLORING_PROCESS_H_INCLUDED )
#define  KRATOS_GRAPH_COLORING_PROCESS_H_INCLUDED
 
// System includes
#include <string>
#include <iostream>
 
// External includes
 
// Project includes
#include "includes/define.h"
#include "processes/process.h"
#include "includes/ublas_interface.h"
 
namespace Kratos
{
 
 
class GraphColoringProcess : public Process
{
public:
 
    KRATOS_CLASS_POINTER_DEFINITION(GraphColoringProcess);
    typedef std::size_t SizeType;
    typedef std::size_t IndexType;
 
    typedef DenseMatrix<int> GraphType;
 
 
 
    GraphColoringProcess(int NumberOfPartitions, const GraphType& rDomainsGraph, GraphType& rDomainsColoredGraph, int& rMaxColor):
        mNumberOfPartitions(NumberOfPartitions), mrMaxColor(rMaxColor), mrDomainsGraph(rDomainsGraph), mrDomainsColoredGraph(rDomainsColoredGraph)
    {}
 
    virtual ~GraphColoringProcess() {}
 
 
 
    void operator()()
    {
        Execute();
    }
 
 
 
    void Execute() override
    {
  //      // Start coloring...
  //      for(SizeType i = 0 ; i < mrDomainsGraph.size1() ; i++) // for each domain
  //          for(SizeType j = i + 1 ; j < mrDomainsGraph.size2() ; j++) // finding neighbor domains
  //              if(mrDomainsGraph(i,j) != 0.00) // domain i has interface with domain j
  // I should continue the implementation. Pooyan.
 
        mrMaxColor = 0;
        // Initializing the coloered graph. -1 means no connection
        // TODO: I have to change this part and create this matrix using max color number
        mrDomainsColoredGraph.resize(mNumberOfPartitions, 2*mNumberOfPartitions,false);
        mrDomainsColoredGraph = ScalarMatrix(mNumberOfPartitions, 2*mNumberOfPartitions, -1.00);
 
        // Start coloring...
        for(SizeType i = 0 ; i < mrDomainsGraph.size1() ; i++) // for each domain
            for(SizeType j = i + 1 ; j < mrDomainsGraph.size2() ; j++) // finding neighbor domains
                if(mrDomainsGraph(i,j) != 0.00) // domain i has interface with domain j
                    for(SizeType color = 0 ; color < mrDomainsColoredGraph.size2() ; color++) // finding color
                        if((mrDomainsColoredGraph(i,color) == -1.00) && (mrDomainsColoredGraph(j,color) == -1.00)) // the first unused color
                        {
                            mrDomainsColoredGraph(i,color) = j;
                            mrDomainsColoredGraph(j,color) = i;
                            if(mrMaxColor < static_cast<int>(color + 1))
                                mrMaxColor = color + 1;
                            break;
                        }
    }
 
 
 
 
    std::string Info() const override
    {
        return "GraphColoringProcess";
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << "GraphColoringProcess";
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
    }
 
 
 
 
 
 
private:
 
 
 
    int mNumberOfPartitions;
    int& mrMaxColor;
    const GraphType& mrDomainsGraph;
    GraphType& mrDomainsColoredGraph;
 
 
    GraphColoringProcess& operator=(GraphColoringProcess const& rOther);
 
    //GraphColoringProcess(GraphColoringProcess const& rOther);
 
 
 
}; // Class GraphColoringProcess
 
 
 
 
 
 
inline std::istream& operator >> (std::istream& rIStream,
                                  GraphColoringProcess& rThis);
 
inline std::ostream& operator << (std::ostream& rOStream,
                                  const GraphColoringProcess& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
 
}  // namespace Kratos.
 
#endif // KRATOS_GRAPH_COLORING_PROCESS_H_INCLUDED  defined