Changeset 187

Timestamp:

02/01/10 20:13:46 (14 years ago)

Author:

bernard

Message:

code commenté et quelques fonctions simplifiées

Location:

trunk/yao

Files:

• bin/Yao9Generator (modified) (previous)
• src/YAOObjects/Order.cpp (modified) (21 diffs)
• src/YAOObjects/Order.hpp (modified) (2 diffs)

trunk/yao/src/YAOObjects/Order.cpp

@@ -766 +766 @@
         // --------------------------------
 
-                for(int i = 0; i < outerComp.size(); i++) Read(i);
+                for(int i = 0; i < outerComp.size(); i++) Read3D(i);
 
                 break;
@@ -842 +842 @@
  
 
- 
+
 int Order::getCommonSignInner(int noFixed, int noFree, myGraphType& currentGraph) {
 
+        // Create a graph that will be fixed before to perform the sign analyzis (working graph)
+        // -------------------------------------------------------------------------------------
+
         myGraphType fixedGraph;
 
+        // Copy into the working graph the informations of the graph given as parameter
+        // ----------------------------------------------------------------------------
+
         copyGraph(currentGraph, fixedGraph);
 
-        fixGraph(fixedGraph, noFixed);
-
-        int recVal = 0;
-
-        for(tie(edgeIterOne, edgeIterTwo) = edges(fixedGraph); edgeIterOne != edgeIterTwo; ++edgeIterOne) {
-
-                int val0 = get(boost::edge_weight_d1_t(), fixedGraph, *edgeIterOne);
-                int val1 = get(boost::edge_weight_d2_t(), fixedGraph, *edgeIterOne);
-                int val2 = get(boost::edge_weight_d3_t(), fixedGraph, *edgeIterOne);
-
-                if(recVal != 2) {
-
-                        switch(noFree) {
-
-                                case 0: if(val0 != 0) { if(recVal + val0 == 0) { recVal = 2; } else { recVal = val0; } } break;
-                                case 1: if(val1 != 0) { if(recVal + val1 == 0) { recVal = 2; } else { recVal = val1; } } break;
-                                case 2: if(val2 != 0) { if(recVal + val2 == 0) { recVal = 2; } else { recVal = val2; } } break;
+        // Fix the working graph by keeping only edges with null value for the dimension "noFixed" given as parameter
+        // ----------------------------------------------------------------------------------------------------------
+
+        fixGraph(fixedGraph, noFixed);
+
+        // Perform a sign analyzis on the fixed graph for the dimension "noFree" given as paramater
+        // ----------------------------------------------------------------------------------------
+
+        return(getCommonSign(noFree, fixedGraph));
+
+};
+
+
+
+void Order::showOuter() {
+
+        cout << endl << "PROTOTYPE : outerComp[noComp3D]" << endl;
+
+        // For all 3D component embedded in the vector outerComp
+        // -----------------------------------------------------
+
+        for(int noComp3D = 0; noComp3D < outerComp.size(); noComp3D++) {
+
+                // Display all relevant informations on components : dimension and sign of the three first axis
+                // --------------------------------------------------------------------------------------------
+
+                cout << endl << "outerComp[" << noComp3D << "].cfcSign[0].first : " <<  outerComp[noComp3D].cfcSign[0].first << " , second : " << outerComp[noComp3D].cfcSign[0].second;
+                cout << endl << "outerComp[" << noComp3D << "].cfcSign[1].first : " <<  outerComp[noComp3D].cfcSign[1].first << " , second : " << outerComp[noComp3D].cfcSign[1].second;
+                cout << endl << "outerComp[" << noComp3D << "].cfcSign[2].first : " <<  outerComp[noComp3D].cfcSign[2].first << " , second : " << outerComp[noComp3D].cfcSign[2].second;
+
+                cout << endl;
+
+        }
+        };
+
+
+void Order::showInner(int noFixed1, int noFixed2, int freeDim) {
+
+        cout << endl << "PROTOTYPE : innerComp[noComp3D][noFixed1][noComp2D][noFixed2][noComp1D]" << endl;
+
+        //  For all 3D component embedded in the vector outerComp
+        // ------------------------------------------------------
+
+        for(int noComp3D = 0; noComp3D < outerComp.size(); noComp3D++) {
+
+                //  For all 2D component embedded in the vector middleComp
+                // -------------------------------------------------------
+
+                for(int noComp2D = 0; noComp2D < middleComp[noComp3D][noFixed1].size(); noComp2D++) {
+
+                        // For all 1D component embedded in the vector innerComp
+                        // -----------------------------------------------------        
+
+                        for(int noComp1D = 0; noComp1D < innerComp[noComp3D][noFixed1][noComp2D][noFixed2].size(); noComp1D++)  {
+
+                                // Display all relevant informations on components : dimension and sign of the remaining axis then embedded moduls
+                                // ---------------------------------------------------------------------------------------------------------------
+
+
+        cout    << endl << "innerComp[" << noComp3D << "][" << noFixed1 << "][" << noComp2D << "][" << noFixed2 << "][" << noComp1D << "] Dim1 : " <<
+                            innerComp[noComp3D][noFixed1][noComp2D][noFixed2][noComp1D].cfcSign[0].first << " , second : " << innerComp[noComp3D][noFixed1][noComp2D][noFixed2][noComp1D].cfcSign[0].second;
+
+        cout << endl;
+
+                                for(int noMod = 0; noMod < innerComp[noComp3D][noFixed1][noComp2D][noFixed2][noComp1D].embeddedModuls.size(); noMod++) {
+
+                                        int noModd = innerComp[noComp3D][noFixed1][noComp2D][noFixed2][noComp1D].embeddedModuls[noMod];
+
+                                        cout << endl << "NO MOD : " <<  noModd;
+
+                                        cout << endl << "innerComp[" << noComp3D << "][" << noFixed1 << "][" << noComp2D << "][" << noFixed2 << "][" << noComp1D << "].embeddedModuls[" << noMod << "] : "
+                                             << boost::get(boost::vertex_name_t(), myGraph, innerComp[noComp3D][noFixed1][noComp2D][noFixed2][noComp1D].embeddedModuls[noMod]);
+
+                                }
+
+                        cout << endl;
+
                         }
                 }
         }
-
-        return(recVal);
 };
-
-
-
-void Order::showOuter() {
-
-        for(int noComp3D = 0; noComp3D < outerComp.size(); noComp3D++) {
-
-                cout << endl << "outerComp[" << noComp3D << "].cfcSign[0].first : " <<  outerComp[noComp3D].cfcSign[0].first << " , second : " << outerComp[noComp3D].cfcSign[0].second;
-                cout << endl << "outerComp[" << noComp3D << "].cfcSign[1].first : " <<  outerComp[noComp3D].cfcSign[1].first << " , second : " << outerComp[noComp3D].cfcSign[1].second;
-                cout << endl << "outerComp[" << noComp3D << "].cfcSign[2].first : " <<  outerComp[noComp3D].cfcSign[2].first << " , second : " << outerComp[noComp3D].cfcSign[2].second;
-
-                cout << endl;  
-
-                for(int noMod = 0; noMod < outerComp[noComp3D].embeddedModuls.size(); noMod++)
-                cout << endl << "outerComp[" << noComp3D << "].embeddedModuls[" << noMod << "] : " << get(boost::vertex_name_t(), myGraph, outerComp[noComp3D].embeddedModuls[noMod]);
-                cout << endl; 
-        }
-        };
-
-
-void Order::showInner(int noFixed1, int noFixed2, int freeDim) {
-        
-        cout << endl << "showInner(" << noFixed1 << ", " << noFixed2 << ", " << freeDim << ")" << endl;
-
-        cout << endl << "PROTOTYPE : innerComp[noComp3D][noFixed1][noComp2D][noFixed2][noComp1D]" << endl;
-
-
-        for(int noComp3D = 0; noComp3D < outerComp.size(); noComp3D++) { 
-
-                for(int noComp2D = 0; noComp2D < middleComp[noComp3D][noFixed1].size(); noComp2D++) {   
-
-                        for(int noComp1D = 0; noComp1D < innerComp[noComp3D][noFixed1][noComp2D][noFixed2].size(); noComp1D++)  {       
-        
-
-        cout    << endl << "innerComp[" << noComp3D << "][" << noFixed1 << "][" << noComp2D << "][" << noFixed2 << "][" << noComp1D << "] Dim1 : " <<
-                            innerComp[noComp3D][noFixed1][noComp2D][noFixed2][noComp1D].cfcSign[0].first << " , second : " << innerComp[noComp3D][noFixed1][noComp2D][noFixed2][noComp1D].cfcSign[0].second;
-
-        cout << endl; 
-
-                                for(int noMod = 0; noMod < innerComp[noComp3D][noFixed1][noComp2D][noFixed2][noComp1D].embeddedModuls.size(); noMod++) {
-
-                                int noModd = innerComp[noComp3D][noFixed1][noComp2D][noFixed2][noComp1D].embeddedModuls[noMod];
-
-                                cout << endl << "NO MOD : " <<  noModd;
-
-                                cout << endl << "innerComp[" << noComp3D << "][" << noFixed1 << "][" << noComp2D << "][" << noFixed2 << "][" << noComp1D << "].embeddedModuls[" << noMod << "] : " 
-                                             << innerComp[noComp3D][noFixed1][noComp2D][noFixed2][noComp1D].embeddedModuls[noMod] << " ==> "
-                                             << boost::get(boost::vertex_name_t(), myGraph, innerComp[noComp3D][noFixed1][noComp2D][noFixed2][noComp1D].embeddedModuls[noMod])
-                                             << " noMod : " << innerComp[noComp3D][noFixed1][noComp2D][noFixed2][noComp1D].embeddedModuls[noMod];
-
-                                } 
-
-                        cout << endl;
-
-                        } 
-                }  
-        }
-};              
-
-
-
-
-
 
  
@@ -1089 +1090 @@
                 if(outerComp[noComponent].cfcSign[2].second == 2)       
                 if(outerComp[noComponent].cfcSign[1].second != 2)       
-                if(!isToDecompose(0, 1, 2, myGraph))                    
+                // if(!isToDecompose(0, 1, 2, myGraph))                         
+                if(!isToDecompose(2, myGraph))
                 
                 outerComp[noComponent].cfcSign[2].second = 3;                   
@@ -1109 +1111 @@
                 if(outerComp[noComponent].cfcSign[2].second == 2)
                 if(outerComp[noComponent].cfcSign[1].second != 2) 
-                if(!isToDecompose(0, 1, 2, myGraph)) 
+                // if(!isToDecompose(0, 1, 2, myGraph)) 
+                if(!isToDecompose(2, myGraph))
 
                  outerComp[noComponent].cfcSign[2].second = 3;
@@ -1127 +1130 @@
                 if(outerComp[noComponent].cfcSign[2].second == 2)
                 if(outerComp[noComponent].cfcSign[1].second != 2) 
-                if(!isToDecompose(0, 1, 2, myGraph))
+                // if(!isToDecompose(0, 1, 2, myGraph)) 
+                if(!isToDecompose(2, myGraph))
                 
                 outerComp[noComponent].cfcSign[2].second = 3;
@@ -1150 +1154 @@
                 if(outerComp[noComponent].cfcSign[1].second == 2)
                 if(outerComp[noComponent].cfcSign[2].second != 2) 
-                if(!isToDecompose(0, 2, 1, myGraph))
+                // if(!isToDecompose(0, 2, 1, myGraph))
+                if(!isToDecompose(1, myGraph))
         
                 outerComp[noComponent].cfcSign[1].second = 3;
@@ -1175 +1180 @@
                 if(outerComp[noComponent].cfcSign[0].second == 2)       
                 if(outerComp[noComponent].cfcSign[2].second != 2) 
-                if(!isToDecompose(1, 2, 0, myGraph))
+                // if(!isToDecompose(1, 2, 0, myGraph))
+                if(!isToDecompose(0, myGraph))
 
                 outerComp[noComponent].cfcSign[0].second = 3;
@@ -1200 +1206 @@
                 if(outerComp[noComponent].cfcSign[2].second == 2)
                 if(outerComp[noComponent].cfcSign[0].second != 2)
-                if(!isToDecompose(1, 0, 2, myGraph))
+                // if(!isToDecompose(1, 0, 2, myGraph))
+                if(!isToDecompose(2, myGraph))
 
                 outerComp[noComponent].cfcSign[2].second = 3;
@@ -1226 +1233 @@
                 if(outerComp[noComponent].cfcSign[1].second == 2)       
                 if(outerComp[noComponent].cfcSign[0].second != 2) 
-                if(!isToDecompose(2, 0, 1, myGraph))
+                // if(!isToDecompose(2, 0, 1, myGraph))
+                if(!isToDecompose(1, myGraph))
 
                 outerComp[noComponent].cfcSign[1].second = 3;
@@ -1416 +1424 @@
 
 
+
+
 void Order::keepComponent(int noComp, myGraphType& componentGraph) {
 
-        typedef boost::graph_traits<myGraphType>::edge_iterator edgeIterType;
+        typedef boost::graph_traits<myGraphType>::edge_iterator edgeIterType;
 
         std::vector<edgeIterType> edgeIterVector;
 
+        // Insert all edges of the graph inside a vector of edge
+        // -----------------------------------------------------
+
         for(tie(edgeIterOne, edgeIterTwo) = edges(componentGraph); edgeIterOne != edgeIterTwo; ++edgeIterOne) edgeIterVector.push_back(edgeIterOne);
 
+        // Reverse the vector to avoid a mess in the indexes when the edges are deleted
+        // ----------------------------------------------------------------------------
+
         reverse(edgeIterVector.begin(), edgeIterVector.end());
 
+        // For all edges embeded in the vector
+        // -----------------------------------
+
         for(int i = 0; i < edgeIterVector.size(); i++)
 
+                // If the edge does not connect two nodes of the component "noComp" given as parameter (ie. if the edge is not fully integrated in the comoponent)
+                // -----------------------------------------------------------------------------------------------------------------------------------------------
+
                 if( get(boost::vertex_affected_comp_t(), componentGraph, boost::source(*(edgeIterVector[i]), componentGraph)) != noComp ||
-                   
-                    get(boost::vertex_affected_comp_t(), componentGraph, boost::target(*(edgeIterVector[i]), componentGraph)) != noComp )
+
+                    get(boost::vertex_affected_comp_t(), componentGraph, boost::target(*(edgeIterVector[i]), componentGraph)) != noComp )
+
+
+                                // Remove the edge for keeping just edges of the relevant component
+                                // ----------------------------------------------------------------
 
                                 boost::remove_edge(*(edgeIterVector[i]), componentGraph);
 
-        typedef boost::graph_traits<myGraphType>::vertex_iterator vertexIterType;
-
-        std::vector<vertexIterType> vertexIterVector;
-
-        for(tie(vertexIterOne, vertexIterTwo) = vertices(componentGraph); vertexIterOne != vertexIterTwo; ++vertexIterOne) vertexIterVector.push_back(vertexIterOne);
-
-        reverse(vertexIterVector.begin(), vertexIterVector.end());
-
-        for(int i = 0; i < vertexIterVector.size(); i++)
-
-                if(get(boost::vertex_affected_comp_t(), componentGraph, *(vertexIterVector[i])) != noComp)
-
-                        boost::remove_vertex(*(vertexIterVector[i]), componentGraph);
-
-        }; 
-                
-
-
-        
-
+        typedef boost::graph_traits<myGraphType>::vertex_iterator vertexIterType;
+
+        std::vector<vertexIterType> vertexIterVector;
+
+        // Insert all vertices of the graph inside a vector of vertex
+                                                                                   // ----------------------------------------------------------
+
+        for(tie(vertexIterOne, vertexIterTwo) = vertices(componentGraph); vertexIterOne != vertexIterTwo; ++vertexIterOne) vertexIterVector.push_back(vertexIterOne);
+
+        // Reverse the vector to avoid a mess in the indexes when the vertices are deleted
+        // ----------------------------------------------------------------------------
+
+        reverse(vertexIterVector.begin(), vertexIterVector.end());
+
+        // For all vertices embeded in the vector
+        // -----------------------------------
+
+        for(int i = 0; i < vertexIterVector.size(); i++)
+
+                // If the vertex is not a part of the component "noComp" given as parameter
+                // ------------------------------------------------------------------------
+
+                if(get(boost::vertex_affected_comp_t(), componentGraph, *(vertexIterVector[i])) != noComp)
+
+                        // Remove the vertex for keeping just vertices of the relevant component
+                        // ---------------------------------------------------------------------
+
+                        boost::remove_vertex(*(vertexIterVector[i]), componentGraph);
+
+        };
 
 
@@ -1486 +1522 @@
 
 
+
+
 int Order::getCommonSign(int noAxis,  myGraphType& fixedGraph) {
 
+// Initial value set to zero (which means free sign)
+// -------------------------------------------------
+
 int recVal = 0;
 
-        for(tie(edgeIterOne, edgeIterTwo) = edges(fixedGraph); edgeIterOne != edgeIterTwo; ++edgeIterOne) {
-
-                int val0 = get(boost::edge_weight_d1_t(), fixedGraph, *edgeIterOne);
-                int val1 = get(boost::edge_weight_d2_t(), fixedGraph, *edgeIterOne);
-                int val2 = get(boost::edge_weight_d3_t(), fixedGraph, *edgeIterOne);
-
-                if(recVal != 2) {
-
-                        switch(noAxis) {
-
-                                case 0: if(val0 != 0) { if(recVal + val0 == 0) { recVal = 2; } else { recVal = val0; } } break;
-                                case 1: if(val1 != 0) { if(recVal + val1 == 0) { recVal = 2; } else { recVal = val1; } } break;
-                                case 2: if(val2 != 0) { if(recVal + val2 == 0) { recVal = 2; } else { recVal = val2; } } break;
-                        }
-
-                }
-        }
+        // For all edges of the graph 
+        // --------------------------
+
+        for(tie(edgeIterOne, edgeIterTwo) = edges(fixedGraph); edgeIterOne != edgeIterTwo; ++edgeIterOne) {
+
+                // Get informations on the sign for the dimensions i, j and k
+                // -----------------------------------------------------------
+
+                int val0 = get(boost::edge_weight_d1_t(), fixedGraph, *edgeIterOne);
+                int val1 = get(boost::edge_weight_d2_t(), fixedGraph, *edgeIterOne);
+                int val2 = get(boost::edge_weight_d3_t(), fixedGraph, *edgeIterOne);
+
+                // If the recorded value recVal is not equal to 2 (ie. if it is equal to 2, there is no need to go further in the sign analyzis)
+                // -----------------------------------------------------------------------------------------------------------------------------
+
+                if(recVal != 2) {
+
+                        // The sign analyzed is this of the dimension "noAxis" given as parameter 
+                        // ----------------------------------------------------------------------
+
+                        switch(noAxis) {
+
+                                // If the current value is not null and recVal + the current value is equal to zero, it means there is a couple -1 an +1 and then no common sign
+                                // ---------------------------------------------------------------------------------------------------------------------------------------------
+
+                                case 0: if(val0 != 0) { if(recVal + val0 == 0) { recVal = 2; } else { recVal = val0; } } break;
+                                case 1: if(val1 != 0) { if(recVal + val1 == 0) { recVal = 2; } else { recVal = val1; } } break;
+                                case 2: if(val2 != 0) { if(recVal + val2 == 0) { recVal = 2; } else { recVal = val2; } } break;
+                        }
+                }
+        }
 
 return(recVal);
@@ -1514 +1569 @@
 
 
- 
-
-void Order::copyGraph( myGraphType& upperGraph, myGraphType& outGraph) { 
-
-for(int noVertex = 0; noVertex < boost::num_vertices(upperGraph); noVertex++) add_vertex(outGraph);  
+
+void Order::copyGraph( myGraphType& upperGraph, myGraphType& outGraph) {
+
+// Create a new graph "outGraph" with one vertex for each vertex of the graph that have to be copied "upperGraph"
+// --------------------------------------------------------------------------------------------------------------
+
+for(int noVertex = 0; noVertex < boost::num_vertices(upperGraph); noVertex++) add_vertex(outGraph);
+
+// Add one edge for each edge of the graph that have to be copied (the vertices are created with the same indexes than in the original graph and then the edges connect the right vertices)
+// ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
 for(tie(edgeIterOne, edgeIterTwo) = edges(upperGraph); edgeIterOne != edgeIterTwo; ++edgeIterOne) add_edge(boost::source(*edgeIterOne, upperGraph), boost::target(*edgeIterOne, upperGraph), outGraph);
 
+// For all vertices
+// ----------------
+
 for(tie(vertexIterOne, vertexIterTwo) = vertices(upperGraph); vertexIterOne != vertexIterTwo; ++vertexIterOne) {
-        
-        put(get(boost::vertex_name_t(),          outGraph),     *vertexIterOne,         get(boost::vertex_name_t(),             upperGraph, *vertexIterOne));
-        put(get(boost::vertex_topo_order_t(),    outGraph),     *vertexIterOne,         get(boost::vertex_topo_order_t(),       upperGraph, *vertexIterOne));
-        put(get(boost::vertex_affected_comp_t(), outGraph),     *vertexIterOne,         get(boost::vertex_affected_comp_t(),    upperGraph, *vertexIterOne));
-        put(get(boost::vertex_original_id_t(),   outGraph),     *vertexIterOne,         get(boost::vertex_original_id_t(),      upperGraph, *vertexIterOne));
-
-        }
+
+        // Copy the properties from the original graph into the target graph
+        // -----------------------------------------------------------------
+
+        put(get(boost::vertex_name_t(),          outGraph),     *vertexIterOne,         get(boost::vertex_name_t(),             upperGraph, *vertexIterOne));
+        put(get(boost::vertex_topo_order_t(),    outGraph),     *vertexIterOne,         get(boost::vertex_topo_order_t(),       upperGraph, *vertexIterOne));
+        put(get(boost::vertex_affected_comp_t(), outGraph),     *vertexIterOne,         get(boost::vertex_affected_comp_t(),    upperGraph, *vertexIterOne));
+        put(get(boost::vertex_original_id_t(),   outGraph),     *vertexIterOne,         get(boost::vertex_original_id_t(),      upperGraph, *vertexIterOne));
+
+        }
 
 
@@ -1539 +1606 @@
         put(get(boost::edge_weight_d3_t(), outGraph), *edgeIterOne, get(boost::edge_weight_d3_t(), upperGraph, *edgeIterOne));
 
-        }
+        }
 */
 
-
-std::vector<int> dim_1; 
-std::vector<int> dim_2; 
-std::vector<int> dim_3; 
+// As it is not possible to populate the edges properties the same way than the vertices properties, this operation is made in two steps : data structures are populated
+// from the source graph then target graph properties are populated from the structures 
+
+// Create one vector by edge property that have to be copied in the new graph 
+// --------------------------------------------------------------------------
+
+std::vector<int> dim_1;
+std::vector<int> dim_2;
+std::vector<int> dim_3;
+
+// For all edges in the original graph
+// -----------------------------------
 
 for(tie(edgeIterOne, edgeIterTwo) = edges(upperGraph); edgeIterOne != edgeIterTwo; ++edgeIterOne) {
 
-        dim_1.push_back(get(boost::edge_weight_d1_t(), upperGraph, *edgeIterOne));
-        dim_2.push_back(get(boost::edge_weight_d2_t(), upperGraph, *edgeIterOne));
-        dim_3.push_back(get(boost::edge_weight_d3_t(), upperGraph, *edgeIterOne));
-
-        }
+        // Insert the properties into the dedicated vectors 
+        // ------------------------------------------------
+
+        dim_1.push_back(get(boost::edge_weight_d1_t(), upperGraph, *edgeIterOne));
+        dim_2.push_back(get(boost::edge_weight_d2_t(), upperGraph, *edgeIterOne));
+        dim_3.push_back(get(boost::edge_weight_d3_t(), upperGraph, *edgeIterOne));
+
+        }
 
 int cmptArc = 0;
 
+// For all edges in the target graph
+// ---------------------------------
+
 for(tie(edgeIterOne, edgeIterTwo) = edges(outGraph); edgeIterOne != edgeIterTwo; ++edgeIterOne) {
 
-        put(get(boost::edge_weight_d1_t(), outGraph), *edgeIterOne, dim_1[cmptArc]);
-        put(get(boost::edge_weight_d2_t(), outGraph), *edgeIterOne, dim_2[cmptArc]);
-        put(get(boost::edge_weight_d3_t(), outGraph), *edgeIterOne, dim_3[cmptArc]);
-
-        cmptArc++;
-
-        }
+        // Populate the properties from the dedicated vector
+        // -------------------------------------------------
+
+        put(get(boost::edge_weight_d1_t(), outGraph), *edgeIterOne, dim_1[cmptArc]);
+        put(get(boost::edge_weight_d2_t(), outGraph), *edgeIterOne, dim_2[cmptArc]);
+        put(get(boost::edge_weight_d3_t(), outGraph), *edgeIterOne, dim_3[cmptArc]);
+
+        cmptArc++;
+
+        }
 
 };
 
 
-
-void Order::showGraph( myGraphType& currentGraph) { 
-
-        cout << endl << "showGraph(currentGraph) : " <<  endl << endl;
-
-        int cmptMod = 0; 
-
-        for(tie(vertexIterOne, vertexIterTwo) = vertices(currentGraph); vertexIterOne != vertexIterTwo; ++vertexIterOne) {
-
-        cout << endl << "Module " << cmptMod << ":\t"
-             << "Nom : " << get(boost::vertex_name_t(), myGraph, get(boost::vertex_original_id_t(), currentGraph, *vertexIterOne))
-             << ", No ordre : " << get(boost::vertex_topo_order_t(), currentGraph, *vertexIterOne)
-             << ", No Composante : " << get(boost::vertex_affected_comp_t(), currentGraph, *vertexIterOne)
-             << ", No Id graph original : " << get(boost::vertex_original_id_t(), currentGraph, *vertexIterOne);
-
-        cmptMod++;
-
-        }
-
-        int cmptArc = 0;
-
-        cout << endl << endl;
-
-        for(tie(edgeIterOne, edgeIterTwo) = edges(currentGraph); edgeIterOne != edgeIterTwo; ++edgeIterOne) {
-
-        cout << endl << "Arc " << cmptArc << " :\t" 
-             << get(boost::vertex_name_t(), currentGraph,  boost::source(*edgeIterOne, currentGraph))
-             << " ( " << get(boost::edge_weight_d1_t(), currentGraph, *edgeIterOne) 
-             << ", "  << get(boost::edge_weight_d2_t(), currentGraph, *edgeIterOne)
-             << ", "  << get(boost::edge_weight_d3_t(), currentGraph, *edgeIterOne)
-             <<") ==> " << get(boost::vertex_name_t(), currentGraph,  boost::target(*edgeIterOne, currentGraph));
-
-        cmptArc++;
-        
-        }
-        };
-        
-
-
+void Order::showGraph( myGraphType& currentGraph) {
+
+        cout << endl << "showGraph : " <<  endl << endl;
+
+        int cmptMod = 0;
+
+        // For all vertex embedded in the current graph 
+        // --------------------------------------------
+
+        for(tie(vertexIterOne, vertexIterTwo) = vertices(currentGraph); vertexIterOne != vertexIterTwo; ++vertexIterOne) {
+
+                // Display all relevant informations on the vertex (ie the modul) 
+                // --------------------------------------------------------------
+
+                cout    << endl << "Module " << cmptMod << ":\t"
+
+                        // Name of the modul as it appears in the description file 
+                        // -------------------------------------------------------
+
+                        << "Nom : " << get(boost::vertex_name_t(), myGraph, get(boost::vertex_original_id_t(), currentGraph, *vertexIterOne))
+
+                        // Order affected to the modul in the current graph (iformation coming from the topological sort)
+                        // ----------------------------------------------------------------------------------------------
+
+                        << ", No ordre : "      << get(boost::vertex_topo_order_t(), currentGraph, *vertexIterOne)
+
+                        // Component in which the modul is integrated (infromation coming from the strong component search) 
+                        // ------------------------------------------------------------------------------------------------
+
+                        << ", No Composante : " << get(boost::vertex_affected_comp_t(), currentGraph, *vertexIterOne)
+
+                        // Index that is affected to the modul in the main graph (as vertices are automatically indexed by boost, it is very important to keep this information inside the sub-graphs) 
+                        // ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+                        << ", No Id graph original : " << get(boost::vertex_original_id_t(), currentGraph, *vertexIterOne);
+
+                cmptMod++;
+        }
+
+
+        int cmptArc = 0;
+
+        cout << endl << endl;
+
+        // For all edge embedded in the current graph 
+        // ------------------------------------------
+
+        for(tie(edgeIterOne, edgeIterTwo) = edges(currentGraph); edgeIterOne != edgeIterTwo; ++edgeIterOne) {
+
+                // Display all relevant informations on the edge (ie connection between two moduls) 
+                // --------------------------------------------------------------------------------
+
+                cout    << endl << "Arc " << cmptArc << " :\t"
+
+                        // Name of the source modul of the connection 
+                        // ------------------------------------------
+
+                        << get(boost::vertex_name_t(), currentGraph,  boost::source(*edgeIterOne, currentGraph))
+
+                        // Sign of the dimension i of the connection 
+                        // -----------------------------------------
+
+                        << " ( " << get(boost::edge_weight_d1_t(), currentGraph, *edgeIterOne)
+
+                        // Sign of the dimension j of the connection 
+                        // -----------------------------------------
+
+                        << ", "  << get(boost::edge_weight_d2_t(), currentGraph, *edgeIterOne)
+
+                        // Sign of the dimension k of the connection 
+                        // -----------------------------------------
+
+                        << ", "  << get(boost::edge_weight_d3_t(), currentGraph, *edgeIterOne)
+
+                        // Name of the tagret modul of the connection 
+                        // ------------------------------------------
+
+                        <<") ==> " << get(boost::vertex_name_t(), currentGraph,  boost::target(*edgeIterOne, currentGraph));
+        cmptArc++;
+         
+        }
+};
+
+                     
+ 
 void Order::readParam(int noAxis, int valAxis, int noParam) {
- 
+
+// Static value that record the last parameter level that have been inserted (ie parameter position in the order statement)
+// ------------------------------------------------------------------------------------------------------------------------
+
 static int lastParam;
 
+// The function have a special behaviour if noParam have a null value
+// ------------------------------------------------------------------
+
 if(noParam > 0) {
 
-        int deltaParam = lastParam - noParam;
-
-        lastParam = noParam;
-
-        switch(deltaParam) {
-
-                        case 0:
-                                if(noParam == 3) cout << endl << endl << "\t\tforder";
-                                if(noParam == 2) cout << endl << endl << "\tforder";
-                                if(noParam == 1) cout << endl << endl << "forder";  
-                        break;
-
-                        case 1:
-                                if(noParam == 2) cout << endl << endl << "\t\tforder" << endl << "\tforder";
-                                if(noParam == 1) cout << endl << endl << "\tforder" << endl << "forder";
-                        break;
-                        
-                        case 2: cout << endl << endl << "\t\tforder" << endl << endl << "\tforder" << endl << "forder";
-                        break;
-                        }
-                         
-
-
-        switch(noParam) {
-
-                        case 1: cout << endl << endl; break;
-                        case 2: cout << endl << endl << "\t"; break;
-                        case 3: cout << endl << endl << "\t\t"; break;
-                        }
-
-        switch(valAxis) { 
-
-                        case  0: cout << "order " << "\t" << "Y." << noAxis + 1; break;
-                        case  3: cout << "order " << "\t" << "Y." << noAxis + 1; break;
-                        case -1: cout << "order " << "\t" << "YA" << noAxis + 1; break;
-                        case  1: cout << "order " << "\t" << "YB" << noAxis + 1; break;
-                        case  2: cout << "order " << "\t" << "Y." << noAxis + 1; break;         // A VOIR !!!!
-                        }
+        // Record the difference between the current parameter level and the former parameter level
+        // ----------------------------------------------------------------------------------------
+
+        int deltaParam = lastParam - noParam;
+
+        // Reset the lastParam static value with the current parameter level (for the next function call) 
+        // ----------------------------------------------------------------------------------------------
+
+        lastParam = noParam;
+
+        // Accordignly to the difference of levels, the number of "forder" tokens to close the order statement will be different 
+        // ---------------------------------------------------------------------------------------------------------------------
+
+        switch(deltaParam) {
+
+                        // If there is no difference between the last level and the current one, then one order have to be closed (those of the current level)
+                        // -----------------------------------------------------------------------------------------------------------------------------------
+
+                        case 0:
+
+                                // If the current level is the third one, it means the order have to be closed with two tabulation offsets 
+                                // -------------------------------------------------------------------------------------------------------
+
+                                if(noParam == 3) cout << endl << endl << "\t\tforder";
+
+                                // If the current level is the second one, it means the order have to be closed with one tabulation offset
+                                // -------------------------------------------------------------------------------------------------------
+
+                                if(noParam == 2) cout << endl << endl << "\tforder";
+
+                                // If the current level is the first one, it means the order have to be closed without tabulation offset 
+                                // -----------------------------------------------------------------------------------------------------
+
+                                if(noParam == 1) cout << endl << endl << "forder";
+                        break;
+
+                        // If the last parameter is one level higer than the current one, then two parameters have to be closed  (one for the current level and one for the higher)
+                        // --------------------------------------------------------------------------------------------------------------------------------------------------------
+
+                        case 1:
+
+                                // If the current parameter is the second one, the order statement have to be closed with two tabulation offset then one tabulation offset 
+                                // ---------------------------------------------------------------------------------------------------------------------------------------
+
+                                if(noParam == 2) cout << endl << endl << "\t\tforder" << endl << "\tforder";
+
+                                // If the current parameter is the first one, the order statement  have to be closed with one tabulation offset then no offset
+                                // ---------------------------------------------------------------------------------------------------------------------------
+
+                                if(noParam == 1) cout << endl << endl << "\tforder" << endl << "forder";
+                        break;
+
+                        // If the last parameter is two levels higer than the current one, then three parameters have to be closed  (one for the current level and one for each higer)
+                        // -----------------------------------------------------------------------------------------------------------------------------------------------------------
+
+                        case 2:
+
+                                // The order statement  have to be closed with two tabulations (higer level), one tabulation (middle level) and no tabulation (lower level)
+                                // ----------------------------------------------------------------------------------------------------------------------------------------
+
+                                cout << endl << endl << "\t\tforder" << endl << endl << "\tforder" << endl << "forder";
+
+                        break;
+
+                        }
+
+
+        // Set up tabulation offsets for displaying moduls after the order parameters 
+        // --------------------------------------------------------------------------
+
+        switch(noParam) {
+
+                        // If the parameter is the first, then no offset is needed 
+                        // -------------------------------------------------------
+
+                        case 1: cout << endl << endl; break;
+
+                        // If the parameter is the second, then one offset is needed
+                        // ---------------------------------------------------------
+
+                        case 2: cout << endl << endl << "\t"; break;
+
+                        // If the parameter is the third, then two offsets are needed
+                        // ----------------------------------------------------------
+
+                        case 3: cout << endl << endl << "\t\t"; break;
+                        }
+
+        // Set up the parameter sign accordignly to the axis value
+        // -------------------------------------------------------
+
+        switch(valAxis) {
+
+                        // If the axis value is set to 0 (null values on each edges), then the dimension can be crossed both way (free)
+                        // ------------------------------------------------------------------------------------------------------------
+
+                        case  0: cout << "order " << "\t" << "Y." << noAxis + 1; break;
+
+                        // If the axis value is set to 3 (no edges), then the dimension can be crossed both way (free)
+                        // -------------------------------------------------------------------------------------------
+
+                        case  3: cout << "order " << "\t" << "Y." << noAxis + 1; break;
+
+                        // If the axis value is set to -1, then the dimension must be crossed increasingly 
+                        // -------------------------------------------------------------------------------
+
+                        case -1: cout << "order " << "\t" << "YA" << noAxis + 1; break;
+
+                        // If the axis value is set to +1, then the dimension must be crossed decreasingly
+                        // -------------------------------------------------------------------------------
+
+                        case  1: cout << "order " << "\t" << "YB" << noAxis + 1; break;
+
+                        // If the axis value is set to 2 (no common value), then the dimension can be crossed both way (free)
+                        // --------------------------------------------------------------------------------------------------
+
+                        case  2: cout << "order " << "\t" << "Y." << noAxis + 1; break;         // A VOIR !!!!
+                        }
 }
 
+// If the function is called with a null value for noParam, then tho order statement must be closed 
+// ------------------------------------------------------------------------------------------------
 
 else {
 
-                if(lastParam == 3) cout << endl << endl << "\t\tforder" << endl << endl << "\tforder" << endl << "forder" << endl << endl;
-                if(lastParam == 2) cout << endl << endl << "\tforder" << endl << "forder" << endl << endl;
-                if(lastParam == 1) cout << endl << endl << "forder" << endl << endl;
-}  
+        // If the last parameter was the third in the order statement, then three parameters have to be closed (one for each open parameter)
+        // ---------------------------------------------------------------------------------------------------------------------------------
+
+        if(lastParam == 3) cout << endl << endl << "\t\tforder" << endl << endl << "\tforder" << endl << "forder" << endl << endl;
+
+        // If the last parameter was the second in the order statement, then two parameters have to be closed (one for each open parameter)
+        // --------------------------------------------------------------------------------------------------------------------------------
+
+        if(lastParam == 2) cout << endl << endl << "\tforder" << endl << "forder" << endl << endl;
+
+        // If the last parameter was the first in the order statement, then one parameter have to be closed 
+        // ------------------------------------------------------------------------------------------------
+
+        if(lastParam == 1) cout << endl << endl << "forder" << endl << endl;
+}
 
 
 };
-
 
 
@@ -1842 +2070 @@
 
 
-
 void Order::fixGraph(myGraphType& currentGraph, int noFixedDim)  {
 
-        typedef boost::graph_traits<myGraphType>::edge_iterator edgeIterType;
-
-        std::vector<edgeIterType> edgeIterVector;
-
-        for(tie(edgeIterOne, edgeIterTwo) = edges(currentGraph); edgeIterOne != edgeIterTwo; ++edgeIterOne) edgeIterVector.push_back(edgeIterOne);
-
-        reverse(edgeIterVector.begin(), edgeIterVector.end());
-
-        for(int i = 0; i < edgeIterVector.size(); i++) {
-
-                if(noFixedDim == 0) if(get(boost::edge_weight_d1_t(), currentGraph, *(edgeIterVector[i])) != 0) boost::remove_edge(*(edgeIterVector[i]), currentGraph); 
-                if(noFixedDim == 1) if(get(boost::edge_weight_d2_t(), currentGraph, *(edgeIterVector[i])) != 0) boost::remove_edge(*(edgeIterVector[i]), currentGraph);
-                if(noFixedDim == 2) if(get(boost::edge_weight_d3_t(), currentGraph, *(edgeIterVector[i])) != 0) boost::remove_edge(*(edgeIterVector[i]), currentGraph); 
-        }
-}; 
+        // Putting iterators inside a vector is more convenient , especially for deletions
+        // -------------------------------------------------------------------------------
+
+        typedef boost::graph_traits<myGraphType>::edge_iterator edgeIterType;
+
+        std::vector<edgeIterType> edgeIterVector;
+
+        // Insert all edges of the graph inside a vector of edge
+        // -----------------------------------------------------
+
+        for(tie(edgeIterOne, edgeIterTwo) = edges(currentGraph); edgeIterOne != edgeIterTwo; ++edgeIterOne) edgeIterVector.push_back(edgeIterOne);
+
+        // Reverse the vector to avoid a mess in the indexes when the edges are deleted
+        // ----------------------------------------------------------------------------
+
+        reverse(edgeIterVector.begin(), edgeIterVector.end());
+
+        // For all edges inside the vector
+        // -------------------------------
+
+        for(int i = 0; i < edgeIterVector.size(); i++) {
+
+                // If the sign value for the edge is not null for the dimension "noFixedDim" given as parameter, then delete the edge
+                // ------------------------------------------------------------------------------------------------------------------
+
+                if(noFixedDim == 0) if(get(boost::edge_weight_d1_t(), currentGraph, *(edgeIterVector[i])) != 0) boost::remove_edge(*(edgeIterVector[i]), currentGraph);
+                if(noFixedDim == 1) if(get(boost::edge_weight_d2_t(), currentGraph, *(edgeIterVector[i])) != 0) boost::remove_edge(*(edgeIterVector[i]), currentGraph);
+                if(noFixedDim == 2) if(get(boost::edge_weight_d3_t(), currentGraph, *(edgeIterVector[i])) != 0) boost::remove_edge(*(edgeIterVector[i]), currentGraph);
+        }
+};
 
 
@@ -1865 +2107 @@
 void Order::reduceGraph(myGraphType innerGraph, myGraphType& outerGraph, int nbComp) {
 
-        // Create a graph that will contain one vertex by component
-
-        for(int noComp = 0; noComp < nbComp; noComp++) add_vertex(outerGraph);
-
-        // For all edges in the currentGraph 
+        // Create a graph that will contain one vertex by component
+        // --------------------------------------------------------
+
+        for(int noComp = 0; noComp < nbComp; noComp++) add_vertex(outerGraph);
+
+        // For all edges in the graph that have to reduced 
+        // -----------------------------------------------
 
         for(tie(edgeIterOne, edgeIterTwo) = edges(innerGraph); edgeIterOne != edgeIterTwo; ++edgeIterOne) {
@@ -1878 +2122 @@
 
                 // If the target and the source modul of the edge are not in the same component, add an edge to the reduced graph 
+                // --------------------------------------------------------------------------------------------------------------
 
                 if(sourceComp != targetComp)  add_edge(sourceComp, targetComp, outerGraph);
 
-        }
+        }
 };
 
-
-
-        
 
 
@@ -1918 +2160 @@
         // ---------------------------------------------------------
 
-        for(tie(vertexIterOne, vertexIterTwo) = vertices(fixedGraph); vertexIterOne != vertexIterTwo; ++vertexIterOne) put(get(boost::vertex_affected_comp_t(), fixedGraph), *vertexIterOne, -1);
-
-        // Perform a strong components search on the 2D graph 
-        // --------------------------------------------------
-
-        boost::strong_components(fixedGraph, &middleComponentsList[0], boost::root_map(&verticesDiscoverList[0]));
-
-        // Update vertices properties of the 2D graph : set a component Id on each vertex
-        // ------------------------------------------------------------------------------
-
-        for(int i = 0; i < middleComponentsList.size(); i++) put(get(boost::vertex_affected_comp_t(), fixedGraph), i, middleComponentsList[i]);
-
-        // Setting the number of components that have been detected
-        // --------------------------------------------------------
-
-        int nbComponents = *max_element(middleComponentsList.begin(), middleComponentsList.end()) + 1;
-
-        // Setting the third dimension size of innerComp array
-        // ---------------------------------------------------
-
-        innerComp[noComp][fixedDim] = new cfcStructTableType*[nbComponents]; 
-
-        // Setting the fourth dimension size of the innerComp array
-        // --------------------------------------------------------
-
-        for(int noCompD2 = 0; noCompD2 < nbComponents; noCompD2++) innerComp[noComp][fixedDim][noCompD2] = new cfcStructTableType[3];
-
-
-        // *****************************************************
-        // ****                                           ******
-        // ****  ETAPE 5 DE LA PROCEDURE A DEUX DIMENSION ******
-        // ****                                           ******
-        // *****************************************************
-
-        // Resize the middleComp array with the size of 2D components that have been detected
-        // ----------------------------------------------------------------------------------
-
-        middleComp[noComp][fixedDim].resize(nbComponents);
-
-        // Set up the array that will be used to register the informations about imposed values for the axis
-        // -------------------------------------------------------------------------------------------------
-
-        int ** isImposed2D = new int*[nbComponents];
-
-        for(int i = 0; i < nbComponents; i++) isImposed2D[i] = new int[2];
-
-        // For each component, set the sign for the first and second dimensions then register this sign in the cfcSign attribute
-        // ---------------------------------------------------------------------------------------------------------------------
-
-        for(int noComponent = 0; noComponent < nbComponents; noComponent++) {
-
-                // Setting inial imposed values (0 mean no imposed)
-                // ------------------------------------------------
-
-                isImposed2D[noComponent][0] = 0;
-                isImposed2D[noComponent][1] = 0;
-
-                middleComp[noComp][fixedDim][noComponent].cfcSign.resize(2);
-
-                middleComp[noComp][fixedDim][noComponent].cfcSign[0].first = dimOne;
-                middleComp[noComp][fixedDim][noComponent].cfcSign[1].first = dimTwo;
-
-                middleComp[noComp][fixedDim][noComponent].cfcSign[0].second = 0;
-                middleComp[noComp][fixedDim][noComponent].cfcSign[1].second = 0;
-
-                middleComp[noComp][fixedDim][noComponent].cfcSign[0].second = getCommonSign(dimOne, noComponent, fixedGraph); 
-                middleComp[noComp][fixedDim][noComponent].cfcSign[1].second = getCommonSign(dimTwo, noComponent, fixedGraph);
-
-                // Detecting all possible axis combinations 
-                // ----------------------------------------
-
-                int noConf = -1;
+for(tie(vertexIterOne, vertexIterTwo) = vertices(fixedGraph); vertexIterOne != vertexIterTwo; ++vertexIterOne) put(get(boost::vertex_affected_comp_t(), fixedGraph), *vertexIterOne, -1);
+
+// Perform a strong components search on the 2D graph 
+// --------------------------------------------------
+
+boost::strong_components(fixedGraph, &middleComponentsList[0], boost::root_map(&verticesDiscoverList[0]));
+
+// Update vertices properties of the 2D graph : set a component Id on each vertex
+// ------------------------------------------------------------------------------
+
+for(int i = 0; i < middleComponentsList.size(); i++) put(get(boost::vertex_affected_comp_t(), fixedGraph), i, middleComponentsList[i]);
+
+// Setting the number of components that have been detected
+// --------------------------------------------------------
+
+int nbComponents = *max_element(middleComponentsList.begin(), middleComponentsList.end()) + 1;
+
+// Setting the third dimension size of innerComp array
+// ---------------------------------------------------
+
+innerComp[noComp][fixedDim] = new cfcStructTableType*[nbComponents]; 
+
+// Setting the fourth dimension size of the innerComp array
+// --------------------------------------------------------
+
+for(int noCompD2 = 0; noCompD2 < nbComponents; noCompD2++) innerComp[noComp][fixedDim][noCompD2] = new cfcStructTableType[3];
+
+
+// *****************************************************
+// ****                                           ******
+// ****  ETAPE 5 DE LA PROCEDURE A DEUX DIMENSION ******
+// ****                                           ******
+// *****************************************************
+
+// Resize the middleComp array with the size of 2D components that have been detected
+// ----------------------------------------------------------------------------------
+
+middleComp[noComp][fixedDim].resize(nbComponents);
+
+// Set up the array that will be used to register the informations about imposed values for the axis
+// -------------------------------------------------------------------------------------------------
+
+int ** isImposed2D = new int*[nbComponents];
+
+for(int i = 0; i < nbComponents; i++) isImposed2D[i] = new int[2];
+
+// For each component, set the sign for the first and second dimensions then register this sign in the cfcSign attribute
+// ---------------------------------------------------------------------------------------------------------------------
+
+for(int noComponent = 0; noComponent < nbComponents; noComponent++) {
+
+        // Setting inial imposed values (0 mean no imposed)
+        // ------------------------------------------------
+
+        isImposed2D[noComponent][0] = 0;
+        isImposed2D[noComponent][1] = 0;
+
+        middleComp[noComp][fixedDim][noComponent].cfcSign.resize(2);
+
+        middleComp[noComp][fixedDim][noComponent].cfcSign[0].first = dimOne;
+        middleComp[noComp][fixedDim][noComponent].cfcSign[1].first = dimTwo;
+
+        middleComp[noComp][fixedDim][noComponent].cfcSign[0].second = 0;
+        middleComp[noComp][fixedDim][noComponent].cfcSign[1].second = 0;
+
+        middleComp[noComp][fixedDim][noComponent].cfcSign[0].second = getCommonSign(dimOne, noComponent, fixedGraph); 
+        middleComp[noComp][fixedDim][noComponent].cfcSign[1].second = getCommonSign(dimTwo, noComponent, fixedGraph);
+
+        // Detecting all possible axis combinations 
+        // ----------------------------------------
+
+        int noConf = -1;
+
+        int sign0 = middleComp[noComp][fixedDim][noComponent].cfcSign[0].second;
+        int sign1 = middleComp[noComp][fixedDim][noComponent].cfcSign[1].second; 
+
+
+int axis0 = dimOne; 
+int axis1 = dimTwo;
+
+if(sign0 != 2 && sign1 != 2)  noConf = 0;       // axis0 -> axis1 (axis1 free)
+if(sign0 != 2 && sign1 == 2)  noConf = 1;       // axis0 -> axis1 
+if(sign0 == 2 && sign1 == 2)  noConf = 2;       // axis0 -> axis1
+if(sign0 == 2 && sign1 != 2)  noConf = 3;       // axis1 -> axis0 
+
+// Looking at combinations to set imposed values for the second axis 
+// -----------------------------------------------------------------
+
+if(noConf < 3) isImposed2D[noComponent][1] = getImposed(axis1, noComponent, fixedGraph);
+
+if(noConf == 3) isImposed2D[noComponent][1] = getImposed(axis0, noComponent, fixedGraph);
+
+// Sort the axis then set their values accordignly to the combination available for the current 2D component
+// ---------------------------------------------------------------------------------------------------------
+
+if(noConf == 0) { 
+
+                middleComp[noComp][fixedDim][noComponent].cfcSign[1].second = 0;
+
+                if(isImposed2D[noComponent][0] != 0) middleComp[noComp][fixedDim][noComponent].cfcSign[0].second = isImposed2D[noComponent][0];
+                if(isImposed2D[noComponent][1] != 0) middleComp[noComp][fixedDim][noComponent].cfcSign[1].second = isImposed2D[noComponent][1]; 
+}
+
+if(noConf > 0 && noConf < 3) {
+
+                if(isImposed2D[noComponent][0] != 0) middleComp[noComp][fixedDim][noComponent].cfcSign[0].second = isImposed2D[noComponent][0];
+                if(isImposed2D[noComponent][1] != 0) middleComp[noComp][fixedDim][noComponent].cfcSign[1].second = isImposed2D[noComponent][1];
+}
+
+if(noConf == 3) { 
+
+                int tmpVal = middleComp[noComp][fixedDim][noComponent].cfcSign[0].second;
+                middleComp[noComp][fixedDim][noComponent].cfcSign[0].second = middleComp[noComp][fixedDim][noComponent].cfcSign[1].second;
+                middleComp[noComp][fixedDim][noComponent].cfcSign[1].second = tmpVal;
+                middleComp[noComp][fixedDim][noComponent].cfcSign[0].first = axis1;
+                middleComp[noComp][fixedDim][noComponent].cfcSign[1].first = axis0;
+
+                if(isImposed2D[noComponent][0] != 0) middleComp[noComp][fixedDim][noComponent].cfcSign[1].second = isImposed2D[noComponent][0];
+                if(isImposed2D[noComponent][1] != 0) middleComp[noComp][fixedDim][noComponent].cfcSign[0].second = isImposed2D[noComponent][1];
+}
+
+
+} 
+
+
+
+// *****************************************************
+// ****                                           ******
+// ****  ETAPE 6 DE LA PROCEDURE A DEUX DIMENSION ******
+// ****                                           ******
+// *****************************************************
+
+myGraphType cfcGraph;
+
+reduceGraph(fixedGraph, cfcGraph, nbComponents);
+
+// *****************************************************
+// ****                                           ******
+// ****  ETAPE 7 DE LA PROCEDURE A DEUX DIMENSION ******
+// ****                                           ******
+// *****************************************************
+
+std::deque<int> topoOrder;
+
+if(boost::num_vertices(cfcGraph) > 1) {
+
+// Perform a topological sort on the graph whose vertices are the components (reduced graph)
+// -----------------------------------------------------------------------------------------
+
+boost::topological_sort(cfcGraph, std::front_inserter(topoOrder), boost::vertex_index_map(boost::identity_property_map()));
+
+// *****************************************************
+// ****                                           ******
+// ****  ETAPE 8 DE LA PROCEDURE A DEUX DIMENSION ******
+// ****                                           ******
+// *****************************************************
+
+// Sort the middle structure table elements (2D graph components) accordignly to the sorting performed on the reduced graph 
+// ------------------------------------------------------------------------------------------------------------------------
+
+vector<cfcStruct> sortedCfcStructTable;
+
+for(int noComponent = 0; noComponent < topoOrder.size(); noComponent++) sortedCfcStructTable.push_back(middleComp[noComp][fixedDim][topoOrder[noComponent]]);
+
+middleComp[noComp][fixedDim].clear();
+
+for(int noComponent = 0; noComponent < topoOrder.size(); noComponent++) middleComp[noComp][fixedDim].push_back(sortedCfcStructTable[noComponent]);
+
+}
+
+else { topoOrder[0] = 0; }
+
+
+// *****************************************************
+// ****                                           ******
+// ****  ETAPE 9 DE LA PROCEDURE A DEUX DIMENSION ******
+// ****                                           ******
+// *****************************************************
+
+
+// Create a graph that just keep the current 2D component egdes and vertices 
+// -------------------------------------------------------------------------
+
+for(int noComp2D = 0; noComp2D < nbComponents; noComp2D++) { 
+
+myGraphType outputGraph;
+
+copyGraph(fixedGraph, outputGraph); 
+
+keepComponent(topoOrder[noComp2D], outputGraph);
+
+
+// Create the two 1D component vectors corresponding to the two third dimensions availables
+// ----------------------------------------------------------------------------------------
+
+switch(fixedDim) {
+
+        case 0:
+
+                setInner(noComp, fixedDim, noComp2D, 1, 2, outputGraph);    // jk    
         
-                int sign0 = middleComp[noComp][fixedDim][noComponent].cfcSign[0].second;
-                int sign1 = middleComp[noComp][fixedDim][noComponent].cfcSign[1].second; 
-
-                int axis0 = dimOne; 
-                int axis1 = dimTwo;
-
-                if(sign0 != 2 && sign1 != 2)  noConf = 0;       // axis0 -> axis1 (axis1 free)
-                if(sign0 != 2 && sign1 == 2)  noConf = 1;       // axis0 -> axis1 
-                if(sign0 == 2 && sign1 == 2)  noConf = 2;       // axis0 -> axis1
-                if(sign0 == 2 && sign1 != 2)  noConf = 3;       // axis1 -> axis0 
- 
-                // Looking at combinations to set imposed values for the second axis 
-                // -----------------------------------------------------------------
-        
-                if(noConf < 3) isImposed2D[noComponent][1] = getImposed(axis1, noComponent, fixedGraph);
-
-                if(noConf == 3) isImposed2D[noComponent][1] = getImposed(axis0, noComponent, fixedGraph);
-
-                // Sort the axis then set their values accordignly to the combination available for the current 2D component
-                // ---------------------------------------------------------------------------------------------------------
-
-                if(noConf == 0) { 
-
-                                middleComp[noComp][fixedDim][noComponent].cfcSign[1].second = 0;
-
-                                if(isImposed2D[noComponent][0] != 0) middleComp[noComp][fixedDim][noComponent].cfcSign[0].second = isImposed2D[noComponent][0];
-                                if(isImposed2D[noComponent][1] != 0) middleComp[noComp][fixedDim][noComponent].cfcSign[1].second = isImposed2D[noComponent][1]; 
-                }
-
-                if(noConf > 0 && noConf < 3) {
-
-                                if(isImposed2D[noComponent][0] != 0) middleComp[noComp][fixedDim][noComponent].cfcSign[0].second = isImposed2D[noComponent][0];
-                                if(isImposed2D[noComponent][1] != 0) middleComp[noComp][fixedDim][noComponent].cfcSign[1].second = isImposed2D[noComponent][1];
-                }
-
-                if(noConf == 3) { 
-
-                                int tmpVal = middleComp[noComp][fixedDim][noComponent].cfcSign[0].second;
-                                middleComp[noComp][fixedDim][noComponent].cfcSign[0].second = middleComp[noComp][fixedDim][noComponent].cfcSign[1].second;
-                                middleComp[noComp][fixedDim][noComponent].cfcSign[1].second = tmpVal;
-                                middleComp[noComp][fixedDim][noComponent].cfcSign[0].first = axis1;
-                                middleComp[noComp][fixedDim][noComponent].cfcSign[1].first = axis0;
-
-                                if(isImposed2D[noComponent][0] != 0) middleComp[noComp][fixedDim][noComponent].cfcSign[1].second = isImposed2D[noComponent][0];
-                                if(isImposed2D[noComponent][1] != 0) middleComp[noComp][fixedDim][noComponent].cfcSign[0].second = isImposed2D[noComponent][1];
-                }
-
-
-        } 
-
-
-
-        // *****************************************************
-        // ****                                           ******
-        // ****  ETAPE 6 DE LA PROCEDURE A DEUX DIMENSION ******
-        // ****                                           ******
-        // *****************************************************
-
-        myGraphType cfcGraph;
-
-        reduceGraph(fixedGraph, cfcGraph, nbComponents);
-
-        // *****************************************************
-        // ****                                           ******
-        // ****  ETAPE 7 DE LA PROCEDURE A DEUX DIMENSION ******
-        // ****                                           ******
-        // *****************************************************
-
-        std::deque<int> topoOrder;
-
-        if(boost::num_vertices(cfcGraph) > 1) {
-
-        // Perform a topological sort on the graph whose vertices are the components (reduced graph)
-        // -----------------------------------------------------------------------------------------
-
-        boost::topological_sort(cfcGraph, std::front_inserter(topoOrder), boost::vertex_index_map(boost::identity_property_map()));
-
-        // *****************************************************
-        // ****                                           ******
-        // ****  ETAPE 8 DE LA PROCEDURE A DEUX DIMENSION ******
-        // ****                                           ******
-        // *****************************************************
-
-        // Sort the middle structure table elements (2D graph components) accordignly to the sorting performed on the reduced graph 
-        // ------------------------------------------------------------------------------------------------------------------------
-
-        vector<cfcStruct> sortedCfcStructTable;
-
-        for(int noComponent = 0; noComponent < topoOrder.size(); noComponent++) sortedCfcStructTable.push_back(middleComp[noComp][fixedDim][topoOrder[noComponent]]);
-
-        middleComp[noComp][fixedDim].clear();
-
-        for(int noComponent = 0; noComponent < topoOrder.size(); noComponent++) middleComp[noComp][fixedDim].push_back(sortedCfcStructTable[noComponent]);
-
-        }
-
-        else { topoOrder[0] = 0; }
-
-
-        // *****************************************************
-        // ****                                           ******
-        // ****  ETAPE 9 DE LA PROCEDURE A DEUX DIMENSION ******
-        // ****                                           ******
-        // *****************************************************
-
-
-        // Create a graph that just keep the current 2D component egdes and vertices 
+                setInner(noComp, fixedDim, noComp2D, 2, 1, outputGraph);    // kj
+
+        break;
+
+        case 1:
+
+                setInner(noComp, fixedDim, noComp2D, 0, 2, outputGraph);    // ik
+
+                setInner(noComp, fixedDim, noComp2D, 2, 0, outputGraph);    // ki
+
+                break;
+
+        case 2:
+
+                setInner(noComp, fixedDim, noComp2D, 0, 1, outputGraph);    // ij
+
+                setInner(noComp, fixedDim, noComp2D, 1, 0, outputGraph);    // ji
+
+        break;
+}
+}
+};
+
+
+
+
+
+
+
+
+
+ void Order::Read1D(int noComp1D) {
+
+
+        // Get the axis number (the component value in 3D and 2D are the same and the axis numbers are 0 (i) and 1 (j)
+        // -----------------------------------------------------------------------------------------------------------
+
+        // ******  int noAxis1  = innerComp[0][0][0][1][noComp1D].cfcSign[0].first;
+
+        // Get the axis value : the component Id in 3D and 2D is zero and the axis numbers is 2 (k)
+        // ----------------------------------------------------------------------------------------
+
+        int valAxis1 = innerComp[0][0][0][1][noComp1D].cfcSign[0].second;
+
+        // Read the order parameter for the 0 axis number (i dimension) 
+        // ------------------------------------------------------------ 
+
+        readParam(0, valAxis1, 1);
+
+        // ********* readParam(noAxis1 -2, valAxis1, 1);
+
+        cout << endl << endl << "\t\t";
+
+        // For all moduls embedded in the 1D component "noComp1D" given as parameter
         // -------------------------------------------------------------------------
 
-        for(int noComp2D = 0; noComp2D < nbComponents; noComp2D++) { 
-
-                myGraphType outputGraph;
-        
-                copyGraph(fixedGraph, outputGraph); 
-
-                keepComponent(topoOrder[noComp2D], outputGraph);
-        
-
-        // Create the two 1D component vectors corresponding to the two third dimensions availables
-        // ----------------------------------------------------------------------------------------
-
-                switch(fixedDim) {
-
-                        case 0:
-
-                                setInner(noComp, fixedDim, noComp2D, 1, 2, outputGraph);    // jk    
-                        
-                                setInner(noComp, fixedDim, noComp2D, 2, 1, outputGraph);    // kj
-
-                        break;
-
-                        case 1:
-
-                                setInner(noComp, fixedDim, noComp2D, 0, 2, outputGraph);    // ik
-
-                                setInner(noComp, fixedDim, noComp2D, 2, 0, outputGraph);    // ki
-
-                                break;
-
-                        case 2:
-
-                                setInner(noComp, fixedDim, noComp2D, 0, 1, outputGraph);    // ij
-
-                                setInner(noComp, fixedDim, noComp2D, 1, 0, outputGraph);    // ji
-
-                        break;
-                }
-        }
+        for(int noMod = 0; noMod < innerComp[0][0][0][1][noComp1D].embeddedModuls.size(); noMod++) {
+
+                // Display the modul name as they appear in the description file
+                // -------------------------------------------------------------
+
+                cout << boost::get(boost::vertex_name_t(), myGraph, innerComp[0][0][0][1][noComp1D].embeddedModuls[noMod]) << " ";
+
+        }
+
+        // Close the order statement
+        // -------------------------
+
+        readParam(0, 0, 0);
+
+        };
+
+
+void Order::Read2D(int noComp2D) {
+
+        // Get the axis number (dimension) and the axis value for the first axis crossed in the order statement (the 3D component is zero)
+        // -------------------------------------------------------------------------------------------------------------------------------
+
+        int noFixed1 = middleComp[0][0][noComp2D].cfcSign[0].first; int valFixed1 = middleComp[0][0][noComp2D].cfcSign[0].second;
+
+        //  Get the axis number (dimension) and the axis value for the second axis crossed in the order statement (the 3D component is zero)
+        // ---------------------------------------------------------------------------------------------------------------------------------
+
+        int noAxis2  = middleComp[0][0][noComp2D].cfcSign[1].first; int valAxis2 = middleComp[0][0][noComp2D].cfcSign[1].second;
+
+        // Read the order parameter for this axis dimension and this axis value
+        // ---------------------------------------------------------------------
+
+        readParam(noFixed1 -1, valFixed1, 1);
+
+        // If the second axis value is defined in the 2D component graph
+        // -------------------------------------------------------------
+
+        if(valAxis2 != 2) {
+
+                // Read the order parameter for this axis dimension and this axis value from the 2D graph component
+                // ------------------------------------------------------------------------------------------------
+
+                readParam(noAxis2 -1, valAxis2, 2);
+
+                cout << endl << endl << "\t\t";
+
+                // For all 1D graphs embedded inside the 2D graph (component)
+                // ----------------------------------------------------------
+
+                for(int noComp1D = 0; noComp1D < innerComp[0][0][noComp2D][noAxis2].size(); noComp1D++) {
+
+                        // For all moduls embedded in the 1D graph
+                        // ---------------------------------------
+
+                        for(int noMod = 0; noMod < innerComp[0][0][noComp2D][noAxis2][noComp1D].embeddedModuls.size(); noMod++) {
+
+                                // Display the modul name as it appears in the description file 
+                                // ------------------------------------------------------------
+
+                                cout << boost::get(boost::vertex_name_t(), myGraph, innerComp[0][0][noComp2D][noAxis2][noComp1D].embeddedModuls[noMod]) << " ";
+
+                        }
+                }
+        }
+
+        // If the second axis value is not defined in the 2D component graph
+        // -----------------------------------------------------------------
+
+        else {
+
+                // For all 1D graphs embedded inside the 2D graph (component)
+                // ----------------------------------------------------------
+
+                for(int noComp1D = 0; noComp1D < innerComp[0][0][noComp2D][noAxis2].size(); noComp1D++) {
+
+                        // Get the axis number (dimension) for the second axis crossed in the order statement (information readen from the 1D graph component)
+                        // -----------------------------------------------------------------------------------------------------------------------------------  
+
+                        noAxis2  = innerComp[0][0][noComp2D][noAxis2][noComp1D].cfcSign[0].first;
+
+                        // Get the axis value  for the second axis crossed in the order statement (information readen from the 1D graph component)
+                        // -----------------------------------------------------------------------------------------------------------------------              
+
+                        valAxis2 = innerComp[0][0][noComp2D][noAxis2][noComp1D].cfcSign[0].second;
+
+                                // Read the order parameter for this axis dimension and this axis value
+                                // --------------------------------------------------------------------
+
+                                readParam(noAxis2 -1, valAxis2, 2);
+
+                                // For all moduls embedded in the 1D graph
+                                // ---------------------------------------
+
+                                for(int noMod = 0; noMod < innerComp[0][0][noComp2D][noAxis2][noComp1D].embeddedModuls.size(); noMod++) {
+
+                                        // Display the modul name as it appears in the description file 
+                                        // ------------------------------------------------------------
+
+                                        cout << boost::get(boost::vertex_name_t(), myGraph, innerComp[0][0][noComp2D][noAxis2][noComp1D].embeddedModuls[noMod]) << " ";
+
+                                }
+                }
+        }
+
+        // Close the order statement
+        // -------------------------
+
+        readParam(0, 0, 0);
+
+        };
+
+
+void Order::Read3D(int noComp3D) {
+
+        // Get the axis number (dimension) and the axis value of the first axis crossed in the order statement
+        // ---------------------------------------------------------------------------------------------------
+
+        int noFixed1 = outerComp[noComp3D].cfcSign[0].first; int valFixed1 = outerComp[noComp3D].cfcSign[0].second;
+
+        // Get the axis number (dimension) and the axis value of the second axis crossed in the order statement (values with no fixed dimensions : ie 3D graphs)
+        // -----------------------------------------------------------------------------------------------------------------------------------------------------
+
+        int noAxis2  = outerComp[noComp3D].cfcSign[1].first; int valAxis2  = outerComp[noComp3D].cfcSign[1].second;
+
+        // Get the axis number (dimension) and the axis value of the third axis crossed in the order statement (values with no fixed dimensions : ie 3D graphs)
+        // ----------------------------------------------------------------------------------------------------------------------------------------------------
+
+        int noAxis3 = outerComp[noComp3D].cfcSign[2].first; int valAxis3   = outerComp[noComp3D].cfcSign[2].second;
+
+        // Read the parameter for the first axis (this one can not be undefined as it is the first axis crossed, the the reading can be performed) 
+        // ---------------------------------------------------------------------------------------------------------------------------------------
+
+        readParam(noFixed1, valFixed1, 1);
+
+        // If the second axis value is defined in the 3D graph 
+        // ---------------------------------------------------
+
+        if(valAxis2 != 2) {
+
+                // Read the parameter for the second axis directly from here (no need to get informations from any fixed graph)
+                // ------------------------------------------------------------------------------------------------------------
+
+                 readParam(noAxis2, valAxis2, 2);
+
+                // If the third axis value is defined in the 3D graph
+                // --------------------------------------------------
+
+                if(valAxis3 != 2) {
+
+                                // Read the parameter for the third axis directly from here (no need to get informations from any fixed graph)
+                                // -----------------------------------------------------------------------------------------------------------
+
+                                readParam(noAxis3, valAxis3, 3);
+
+                                cout << endl << endl << "\t\t\t";
+
+                                // For all 2D graphs embedded in the current 3D graph (ie the fixed dimension is the first crossed in the order statement)
+                                // ----------------------------------------------------------------------------------------------------------------------- 
+
+                                for(int noComp2D = 0; noComp2D < middleComp[noComp3D][noFixed1].size(); noComp2D++) {
+
+                                        // Get the number of the second axis crossed in the order statement 
+                                        // ----------------------------------------------------------------
+
+                                        noAxis2 = middleComp[noComp3D][noFixed1][noComp2D].cfcSign[0].first;
+
+                                        // For all 1D graphs embedded in the current 2D graph (ie the second dimension is the second crossed in the order statement)
+                                        // -------------------------------------------------------------------------------------------------------------------------    
+
+                                        for(int noComp1D= 0; noComp1D < innerComp[noComp3D][noFixed1][noComp2D][noAxis2].size(); noComp1D++) {
+
+                                                // For all moduls embedded in the current 1D graph component
+                                                // ---------------------------------------------------------
+
+                                                for(int noMod = 0; noMod < innerComp[noComp3D][noFixed1][noComp2D][noAxis2][noComp1D].embeddedModuls.size(); noMod++) {
+
+                                                        // Display the modul name (that will appear after the order paramaters that have been read before)
+                                                        // -----------------------------------------------------------------------------------------------      
+
+                                                        cout << boost::get(boost::vertex_name_t(), myGraph, innerComp[noComp3D][noFixed1][noComp2D][noAxis2][noComp1D].embeddedModuls[noMod]) << " ";
+                                                }
+                                        }
+                                }
+                        }
+
+                // If the third axis value is not defined in the 2D graph 
+
+                else {
+
+                        // For all 2D graphs embedded in the current 3D graph (ie the fixed dimension is the first crossed in the order statement)
+                        // -----------------------------------------------------------------------------------------------------------------------
+
+                        for(int noComp2D = 0; noComp2D < middleComp[noComp3D][noFixed1].size(); noComp2D++) {
+
+
+                                // Get the number of the second axis crossed in the order statement
+                                // ----------------------------------------------------------------
+
+                                noAxis2 = middleComp[noComp3D][noFixed1][noComp2D].cfcSign[0].first;
+
+                                // For all 1D graphs embedded in the current 2D graph (ie the second dimension is the second crossed in the order statement)
+                                // -------------------------------------------------------------------------------------------------------------------------
+
+                                for(int noComp1D = 0; noComp1D < innerComp[noComp3D][noFixed1][noComp2D][noAxis2].size(); noComp1D++) {
+
+                                        // Get the number of the third axis crossed in the order statement
+                                        // ---------------------------------------------------------------
+
+                                        noAxis3  = innerComp[noComp3D][noFixed1][noComp2D][noAxis2][noComp1D].cfcSign[0].first;
+
+                                        // Get the value of the third axis crossed in the order statement
+                                        // --------------------------------------------------------------
+
+                                        valAxis3 = innerComp[noComp3D][noFixed1][noComp2D][noAxis2][noComp1D].cfcSign[0].second;
+
+                                        // Read the parameter for the third axis from the 1D component
+                                        // -----------------------------------------------------------
+
+                                        readParam(noAxis3, valAxis3, 3);
+
+                                        cout << endl << endl << "\t\t\t";
+
+                                        // For all moduls embedded in the current 1D graph component
+                                        // ---------------------------------------------------------
+
+                                        for(int noMod = 0; noMod < innerComp[noComp3D][noFixed1][noComp2D][noAxis2][noComp1D].embeddedModuls.size(); noMod++) {
+
+                                                // Display the modul name (that will appear after the order paramaters that have been read before)
+                                                // -----------------------------------------------------------------------------------------------
+
+                                                cout << boost::get(boost::vertex_name_t(), myGraph, innerComp[noComp3D][noFixed1][noComp2D][noAxis2][noComp1D].embeddedModuls[noMod]) << " ";
+
+                                        }
+                                   }
+                             }
+                }
+
+
+        }
+
+        // If the second axis value is not defined in the 3D graph 
+        // -------------------------------------------------------
+
+        if(valAxis2 == 2) {
+
+                // For all 2D graphs embedded in the current 3D graph (ie the fixed dimension is the first crossed in the order statement)
+                // -----------------------------------------------------------------------------------------------------------------------
+
+                for(int noComp2D = 0; noComp2D < middleComp[noComp3D][noFixed1].size(); noComp2D++) {
+
+                        // Get the number of the second axis crossed in the order statement
+                        // ----------------------------------------------------------------
+
+                        noAxis2  = middleComp[noComp3D][noFixed1][noComp2D].cfcSign[0].first;
+
+                        // Get the value of the second axis crossed in the order statement
+                        // ----------------------------------------------------------------
+
+                        valAxis2 = middleComp[noComp3D][noFixed1][noComp2D].cfcSign[0].second;
+
+                        // Get the number of the third axis crossed in the order statement (values with just one fixed dimensions : ie from 2D graphs)
+                        // ---------------------------------------------------------------------------------------------------------------------------
+
+                        noAxis3  = middleComp[noComp3D][noFixed1][noComp2D].cfcSign[1].first;
+
+                        // Get the value of the third axis crossed in the order statement (values with just one fixed dimensions : ie from 2D graphs)
+                        // --------------------------------------------------------------------------------------------------------------------------
+
+                        valAxis3 = middleComp[noComp3D][noFixed1][noComp2D].cfcSign[1].second;
+
+                        // If the second axis value is defined in the 2D graph
+                        // ---------------------------------------------------
+
+                        if(valAxis2 != 2) {
+
+                                // Read the parameter for the second axis from the 2D component
+                                // ------------------------------------------------------------
+
+                                readParam(noAxis2, valAxis2, 2);
+
+                                // If the third axis value is defined in the 2D graph
+                                // --------------------------------------------------
+
+                                if(valAxis3 != 2) {
+
+                                        // Read the parameter for the third axis from the 2D component
+                                        // -----------------------------------------------------------
+
+                                        readParam(noAxis3, valAxis3, 3);
+
+                                        cout << endl << endl << "\t\t\t";
+
+                                        // For all 1D graph embedded in the current 2D graph (ie the second fixed dimension is the second crossed in the order statement)
+                                        // ------------------------------------------------------------------------------------------------------------------------------
+
+                                        for(int noComp1D= 0; noComp1D < innerComp[noComp3D][noFixed1][noComp2D][noAxis2].size(); noComp1D++) {
+
+                                                // For all moduls embedded in the current 1D graph component
+                                                // ---------------------------------------------------------
+
+                                                for(int noMod = 0; noMod < innerComp[noComp3D][noFixed1][noComp2D][noAxis2][noComp1D].embeddedModuls.size(); noMod++) {
+
+                                                        // Display the modul name (that will appear after the order paramaters that have been readen before)
+                                                        // -------------------------------------------------------------------------------------------------
+
+                                                        cout << boost::get(boost::vertex_name_t(), myGraph, innerComp[noComp3D][noFixed1][noComp2D][noAxis2][noComp1D].embeddedModuls[noMod]) << " ";
+
+                                                }
+                                        }
+                                }
+
+                                // If the third axis value is not defined in the 2D graph
+                                // ------------------------------------------------------
+
+                                else {
+
+                                        // For all 1D graph embedded in the current 2D graph (ie the second fixed dimension is the second crossed in the order statement)
+                                        // ------------------------------------------------------------------------------------------------------------------------------
+
+                                        for(int noComp1D= 0; noComp1D < innerComp[noComp3D][noFixed1][noComp2D][noAxis2].size(); noComp1D++) {
+
+                                                // Get the number of the third axis crossed in the order statement
+                                                // ---------------------------------------------------------------
+
+                                                noAxis3  = innerComp[noComp3D][noFixed1][noComp2D][noAxis2][noComp1D].cfcSign[0].first;
+
+                                                // Get the value of the third axis crossed in the order statement
+                                                // ---------------------------------------------------------------
+
+                                                valAxis3 = innerComp[noComp3D][noFixed1][noComp2D][noAxis2][noComp1D].cfcSign[0].second;
+
+                                                // Read the parameter for the third axis from the 1D component
+                                                // -----------------------------------------------------------
+
+                                                readParam(noAxis3, valAxis3, 3);
+
+                                                cout << endl << endl << "\t\t\t";
+
+                                                // For all moduls embedded in the current 1D graph component
+                                                // ---------------------------------------------------------
+
+                                                for(int noMod = 0; noMod < innerComp[noComp3D][noFixed1][noComp2D][noAxis2][noComp1D].embeddedModuls.size(); noMod++) {
+
+                                                        // Display the modul name (that will appear after the order paramaters that have been readen before)
+                                                        // -------------------------------------------------------------------------------------------------
+
+                                                        cout << boost::get(boost::vertex_name_t(), myGraph, innerComp[noComp3D][noFixed1][noComp2D][noAxis2][noComp1D].embeddedModuls[noMod]) << " ";
+
+                                                }
+                                        }
+                                }
+                        }
+                }
+        }
+
+        // Close the order statement
+        // -------------------------
+
+        readParam(0, 0, 0);
 };
 
@@ -2144 +2781 @@
 
 
-void Order::Read1D(int noComp1D) {
-
-        int noAxis1  = innerComp[0][0][0][1][noComp1D].cfcSign[0].first;
-
-        int valAxis1 = innerComp[0][0][0][1][noComp1D].cfcSign[0].second;
-        
-        readParam(noAxis1 -2, valAxis1, 1);
-
-        cout << endl << endl << "\t\t";
-
-        for(int noMod = 0; noMod < innerComp[0][0][0][1][noComp1D].embeddedModuls.size(); noMod++) {
-
-                cout << boost::get(boost::vertex_name_t(), myGraph, innerComp[0][0][0][1][noComp1D].embeddedModuls[noMod]) << " ";
-
-        }
-
-        readParam(0, 0, 0);     
-        
-}; 
-
-
-void Order::Read2D(int noComp2D) {
-
-
-        int noFixed1 = middleComp[0][0][noComp2D].cfcSign[0].first; int valFixed1 = middleComp[0][0][noComp2D].cfcSign[0].second;
-        
-        int noAxis2  = middleComp[0][0][noComp2D].cfcSign[1].first; int valAxis2 = middleComp[0][0][noComp2D].cfcSign[1].second;
- 
-        readParam(noFixed1 -1, valFixed1, 1); 
-                        
-        if(valAxis2 != 2) {
-
-                readParam(noAxis2 -1, valAxis2, 2);
-
-                cout << endl << endl << "\t\t";
-        
-                for(int noComp1D = 0; noComp1D < innerComp[0][0][noComp2D][noAxis2].size(); noComp1D++) {
-
-                        for(int noMod = 0; noMod < innerComp[0][0][noComp2D][noAxis2][noComp1D].embeddedModuls.size(); noMod++) {
-
-                                cout << boost::get(boost::vertex_name_t(), myGraph, innerComp[0][0][noComp2D][noAxis2][noComp1D].embeddedModuls[noMod]) << " ";
-
-                        }
-                }
-        }
-
-        else { 
-
-                for(int noComp1D = 0; noComp1D < innerComp[0][0][noComp2D][noAxis2].size(); noComp1D++) {
-
-                        noAxis2  = innerComp[0][0][noComp2D][noAxis2][noComp1D].cfcSign[0].first;
-
-                        valAxis2 = innerComp[0][0][noComp2D][noAxis2][noComp1D].cfcSign[0].second;
-        
-                                readParam(noAxis2 -1, valAxis2, 2);
-
-                                for(int noMod = 0; noMod < innerComp[0][0][noComp2D][noAxis2][noComp1D].embeddedModuls.size(); noMod++) {
-
-                                        cout << boost::get(boost::vertex_name_t(), myGraph, innerComp[0][0][noComp2D][noAxis2][noComp1D].embeddedModuls[noMod]) << " ";
-
-                                }
-                }
-        }
-
-        readParam(0, 0, 0);
-        
-        };
-
-
-void Order::Read(int noComp3D) {
-
-        int noFixed1 = outerComp[noComp3D].cfcSign[0].first; int valFixed1 = outerComp[noComp3D].cfcSign[0].second;
-
-        int noAxis2  = outerComp[noComp3D].cfcSign[1].first; int valAxis2  = outerComp[noComp3D].cfcSign[1].second;
-
-        int noAxis3 = outerComp[noComp3D].cfcSign[2].first; int valAxis3   = outerComp[noComp3D].cfcSign[2].second;
-
-        readParam(noFixed1, valFixed1, 1);
-
-        if(valAxis2 != 2) {
-
-                 readParam(noAxis2, valAxis2, 2);
-
-                if(valAxis3 != 2) {     // cout << endl << "\t\t\t\t\t\tOK - OK - OK";
-
-                                readParam(noAxis3, valAxis3, 3);
-
-                                cout << endl << endl << "\t\t\t";
-
-                                for(int noComp2D = 0; noComp2D < middleComp[noComp3D][noFixed1].size(); noComp2D++) {
-
-                                        noAxis2 = middleComp[noComp3D][noFixed1][noComp2D].cfcSign[0].first;
-
-                                        for(int noComp1D= 0; noComp1D < innerComp[noComp3D][noFixed1][noComp2D][noAxis2].size(); noComp1D++) {
-
-                                                for(int noMod = 0; noMod < innerComp[noComp3D][noFixed1][noComp2D][noAxis2][noComp1D].embeddedModuls.size(); noMod++) { 
-        
-                                                        cout << boost::get(boost::vertex_name_t(), myGraph, innerComp[noComp3D][noFixed1][noComp2D][noAxis2][noComp1D].embeddedModuls[noMod]) << " ";
-                                                }
-                                        }
-                                }
-                        }
-
-                else { 
-
-                             // cout << endl << "\t\t\t\t\t\tOK - OK - DEC";
-
-                                   for(int noComp2D = 0; noComp2D < middleComp[noComp3D][noFixed1].size(); noComp2D++) {
-
-                                                        noAxis2 = middleComp[noComp3D][noFixed1][noComp2D].cfcSign[0].first;
-
-                                                        for(int noComp1D = 0; noComp1D < innerComp[noComp3D][noFixed1][noComp2D][noAxis2].size(); noComp1D++) {
-
-                                                                noAxis3  = innerComp[noComp3D][noFixed1][noComp2D][noAxis2][noComp1D].cfcSign[0].first;
-
-                                                                valAxis3 = innerComp[noComp3D][noFixed1][noComp2D][noAxis2][noComp1D].cfcSign[0].second;
-
-                                                                readParam(noAxis3, valAxis3, 3);
-
-                                                                cout << endl << endl << "\t\t\t";
-
-                                                                for(int noMod = 0; noMod < innerComp[noComp3D][noFixed1][noComp2D][noAxis2][noComp1D].embeddedModuls.size(); noMod++) {
-
-                                                                 cout << boost::get(boost::vertex_name_t(), myGraph, innerComp[noComp3D][noFixed1][noComp2D][noAxis2][noComp1D].embeddedModuls[noMod]) << " ";
-
-                                                                }
-                                                        }
-                                      }
-                }
-
-        
-        } 
-
-        if(valAxis2 == 2) {
-
-                for(int noComp2D = 0; noComp2D < middleComp[noComp3D][noFixed1].size(); noComp2D++) {
-
-                        noAxis2  = middleComp[noComp3D][noFixed1][noComp2D].cfcSign[0].first;
-
-                        valAxis2 = middleComp[noComp3D][noFixed1][noComp2D].cfcSign[0].second;
-
-                        noAxis3  = middleComp[noComp3D][noFixed1][noComp2D].cfcSign[1].first;
-
-                        valAxis3 = middleComp[noComp3D][noFixed1][noComp2D].cfcSign[1].second;
-
-                        if(valAxis2 != 2) { 
-
-                                readParam(noAxis2, valAxis2, 2);
-
-                                if(valAxis3 != 2) {     // cout << endl << "\t\t\t\t\t\tOK - KO (OK - OK)";
-        
-                                        readParam(noAxis3, valAxis3, 3); 
-        
-                                        cout << endl << endl << "\t\t\t";
-
-                                        for(int noComp1D= 0; noComp1D < innerComp[noComp3D][noFixed1][noComp2D][noAxis2].size(); noComp1D++) {
-
-                                                for(int noMod = 0; noMod < innerComp[noComp3D][noFixed1][noComp2D][noAxis2][noComp1D].embeddedModuls.size(); noMod++) {
-
-                                                        cout << boost::get(boost::vertex_name_t(), myGraph, innerComp[noComp3D][noFixed1][noComp2D][noAxis2][noComp1D].embeddedModuls[noMod]) << " ";
-
-                                                }
-                                        }
-                                }
-
-                                else { // cout << endl << "\t\t\t\t\t\tOK - KO (OK - KO)";
-
-                                        for(int noComp1D= 0; noComp1D < innerComp[noComp3D][noFixed1][noComp2D][noAxis2].size(); noComp1D++) {
-
-                                                noAxis3  = innerComp[noComp3D][noFixed1][noComp2D][noAxis2][noComp1D].cfcSign[0].first;
-
-                                                valAxis3 = innerComp[noComp3D][noFixed1][noComp2D][noAxis2][noComp1D].cfcSign[0].second;
-
-                                                readParam(noAxis3, valAxis3, 3);
-
-                                                cout << endl << endl << "\t\t\t";
-
-                                                for(int noMod = 0; noMod < innerComp[noComp3D][noFixed1][noComp2D][noAxis2][noComp1D].embeddedModuls.size(); noMod++) {
-
-                                                        cout << boost::get(boost::vertex_name_t(), myGraph, innerComp[noComp3D][noFixed1][noComp2D][noAxis2][noComp1D].embeddedModuls[noMod]) << " ";
-        
-                                                }
-                                        }
-                                }
-                        }
-                }
-        }
-                        
-        readParam(0, 0, 0);
+
+int Order::getImposed(int fixedDim, int freeDim, int noComp, myGraphType& upperGraph) {
+
+        // Create a graph that will be fixed
+        // ---------------------------------
+
+        myGraphType fixedGraph;
+
+        // Copy the informations of the graph given as parameter in the graph that will be fixed
+        // -------------------------------------------------------------------------------------
+
+        copyGraph(upperGraph, fixedGraph);
+
+        // Fix the dimension "fixedDim" given as parameter
+        // -----------------------------------------------
+
+        fixGraph(fixedGraph, fixedDim);
+
+        // Return the sign for the free dimension and the component given as parameter 
+        // ---------------------------------------------------------------------------
+
+        return(getCommonSign(freeDim, noComp, fixedGraph));
+
 };
 
 
-int Order::getImposed(int fixedDim, int freeDim, int noComp, myGraphType& upperGraph) { 
-
-        myGraphType fixedGraph; 
-
-        copyGraph(upperGraph, fixedGraph); 
-
-        fixGraph(fixedGraph, fixedDim);
-        
-        int valDim0 = 0;
-
-        for(tie(edgeIterOne, edgeIterTwo) = edges(fixedGraph); edgeIterOne != edgeIterTwo; ++edgeIterOne) {
-
-                if(get(boost::vertex_affected_comp_t(), fixedGraph, boost::source(*edgeIterOne, fixedGraph)) == noComp)  {
-
-                        if(get(boost::vertex_affected_comp_t(), fixedGraph, boost::target(*edgeIterOne, fixedGraph)) == noComp)  {
-
-                                int val0 = get(boost::edge_weight_d1_t(), fixedGraph, *edgeIterOne);
-                                int val1 = get(boost::edge_weight_d2_t(), fixedGraph, *edgeIterOne);
-                                int val2 = get(boost::edge_weight_d3_t(), fixedGraph, *edgeIterOne);
-
-                                if(valDim0 != 2) { 
-
-                                        switch(freeDim) {
-
-                                                case 0: if(val0 != 0) { if(valDim0 + val0 == 0) { valDim0 = 2; } else { valDim0  = val0; } } break;
-                                                case 1: if(val1 != 0) { if(valDim0 + val1 == 0) { valDim0 = 2; } else { valDim0  = val1; } } break;
-                                                case 2: if(val2 != 0) { if(valDim0 + val2 == 0) { valDim0 = 2; } else { valDim0  = val2; } } break;
-                                        }
-                                }
-                        }
-                }
-        }
-
-        return(valDim0); 
+
+
+bool Order::isToDecompose(int freeDim, myGraphType& upperGraph) {
+
+
+        // A boolean value that will be set to true if the dimension have to be decomposed 
+        // -------------------------------------------------------------------------------
+
+        bool toDecompose = false;
+
+        // Create a graph that will be fixed
+        // ---------------------------------
+
+        myGraphType fixedGraph;
+
+        // Copy the informations of the graph given as parameter in the graph that will be fixed
+        // -------------------------------------------------------------------------------------
+
+        copyGraph(upperGraph, fixedGraph);
+
+        // Accordingly to the dimension sign that must be analyzed (free dimension), fix both of the two other dimensions
+        // --------------------------------------------------------------------------------------------------------------
+
+        if(freeDim == 0) { fixGraph(fixedGraph, 1); fixGraph(fixedGraph, 2); }  // j == 0, k == 0
+        if(freeDim == 1) { fixGraph(fixedGraph, 0); fixGraph(fixedGraph, 2); }  // i == 0, k == 0
+        if(freeDim == 2) { fixGraph(fixedGraph, 0); fixGraph(fixedGraph, 1); }  // i == 0, j == 0
+
+        // If the sign of the remaining edges is not defined for the free dimension given as parameter, then the dimension have to be decomposed
+        // -------------------------------------------------------------------------------------------------------------------------------------
+
+        if(getCommonSign(freeDim, fixedGraph) == 2) toDecompose = true;
+
+        // Return the boolean information about decomposition of the dimension 
+        // -------------------------------------------------------------------
+
+        return(toDecompose);
+
 };
 
 
-/*
- * Function used to know if the third axis have to be decomposed 
- * This function reduce two times the main graph then seek a common value on the remaining edges 
- * If there is no common value the axis have to be decomposed 
- * If there is a common value or if there is no remaining edges in the last fixed graph, then the axis does not have to be decomposed
- */
-
-bool Order::isToDecompose(int fixedDimOne, int fixedDimTwo, int freeDim, myGraphType& upperGraph) {
-
-        bool toDecompose = false;
-
-        myGraphType fixedGraph;
-
-        copyGraph(upperGraph, fixedGraph);
-
-        fixGraph(fixedGraph, fixedDimOne);
-
-        fixGraph(fixedGraph, fixedDimTwo);
-
-        if(getCommonSign(freeDim, fixedGraph) == 2) toDecompose = true; 
-
-        return(toDecompose);  
-
-};      
-                                        
 
 int Order::getCommonSign(int noDim, int noComp, myGraphType& currentGraph) {
@@ -2403 +2852 @@
         int valDim0 = 0;
 
-        int nbEdges = 0;
+        // For all edges in the current graph
+        // ----------------------------------
 
         for(tie(edgeIterOne, edgeIterTwo) = edges(currentGraph); edgeIterOne != edgeIterTwo; ++edgeIterOne) {
 
+                // If the source modul of the edge is in the component given as paramater
+                // ----------------------------------------------------------------------
+
                 if(get(boost::vertex_affected_comp_t(), currentGraph, boost::source(*edgeIterOne, currentGraph)) == noComp)  {
 
+                        // If the target modul of the edge is in the component given as paramater
+                        // ----------------------------------------------------------------------
+
                         if(get(boost::vertex_affected_comp_t(), currentGraph, boost::target(*edgeIterOne, currentGraph)) == noComp)  {
 
-                                nbEdges++;
+                                // Get the dimension values for axis i, j and k 
+                                // --------------------------------------------
 
                                 int val0 = get(boost::edge_weight_d1_t(), currentGraph, *edgeIterOne);
@@ -2417 +2874 @@
                                 int val2 = get(boost::edge_weight_d3_t(), currentGraph, *edgeIterOne);
 
+                                // If the recorded value valDim0 is not equal to 2 (ie. if it is equal to 2, there is no need to go further in the sign analyzis)
+                                // -----------------------------------------------------------------------------------------------------------------------------
+
                                 if(valDim0 != 2) {
 
+                                        // The sign analyzis is performed for the dimension "noDim" given as parameter 
+                                        // ---------------------------------------------------------------------------
+
                                         switch(noDim) {
+
+                                                // If the current value is not null and valDim0 + the current value is equal to zero, it means there is a couple -1 an +1 and then no common sign
+                                                // ----------------------------------------------------------------------------------------------------------------------------------------------
 
                                                 case 0: if(val0 != 0) { if(valDim0 + val0 == 0) { valDim0 = 2; } else { valDim0  = val0; } } break;
@@ -2430 +2896 @@
         }
 
-        if(nbEdges == 0) valDim0 = 3;   
-
-        return(valDim0);        
+        return(valDim0);
+
+};
+
+
+
+
+int Order::getImposed(int freeDim, int noComp, myGraphType& upperGraph) {
+
+        // Create a new graph that will be fixed
+
+        myGraphType fixedGraph;
+
+        // Copy the informations of the graph given as parameter in the graph that will be fixed
+        // -------------------------------------------------------------------------------------
+
+        copyGraph(upperGraph, fixedGraph);
+
+        // Accordingly to the dimension sign that must be analyzed (free dimension), fix both of the two other dimensions
+        // --------------------------------------------------------------------------------------------------------------
+
+        if(freeDim == 0) { fixGraph(fixedGraph, 1); fixGraph(fixedGraph, 2); }  // j == 0, k == 0
+        if(freeDim == 1) { fixGraph(fixedGraph, 0); fixGraph(fixedGraph, 2); }  // i == 0, k == 0
+        if(freeDim == 2) { fixGraph(fixedGraph, 0); fixGraph(fixedGraph, 1); }  // i == 0, j == 0
+
+        // Return the sign for the free dimension and the component given as parameter 
+        // ---------------------------------------------------------------------------
+
+        return(getCommonSign(freeDim, noComp, fixedGraph));
 
 };
         
 
-        
-
-
-
-int Order::getImposed(int freeDim, int noComp, myGraphType& upperGraph) {
-
-        myGraphType fixedGraph; 
-
-        copyGraph(upperGraph, fixedGraph);
-
-        if(freeDim == 0) { fixGraph(fixedGraph, 1); fixGraph(fixedGraph, 2); }  // j == 0, k == 0
-        if(freeDim == 1) { fixGraph(fixedGraph, 0); fixGraph(fixedGraph, 2); }  // i == 0, k == 0
-        if(freeDim == 2) { fixGraph(fixedGraph, 0); fixGraph(fixedGraph, 1); }  // i == 0, j == 0
-
-        int valDim0 = 0;
-
-        for(tie(edgeIterOne, edgeIterTwo) = edges(fixedGraph); edgeIterOne != edgeIterTwo; ++edgeIterOne) {
-
-                if(get(boost::vertex_affected_comp_t(), fixedGraph, boost::source(*edgeIterOne, fixedGraph)) == noComp)  {
-
-                        if(get(boost::vertex_affected_comp_t(), fixedGraph, boost::target(*edgeIterOne, fixedGraph)) == noComp)  {
-
-                                int val0 = get(boost::edge_weight_d1_t(), fixedGraph, *edgeIterOne);
-                                int val1 = get(boost::edge_weight_d2_t(), fixedGraph, *edgeIterOne);
-                                int val2 = get(boost::edge_weight_d3_t(), fixedGraph, *edgeIterOne);
-
-                                if(valDim0 != 2) {
-
-                                        switch(freeDim) {
-
-                                                case 0: if(val0 != 0) { if(valDim0 + val0 == 0) { valDim0 = 2; } else { valDim0  = val0; } } break;
-                                                case 1: if(val1 != 0) { if(valDim0 + val1 == 0) { valDim0 = 2; } else { valDim0  = val1; } } break;
-                                                case 2: if(val2 != 0) { if(valDim0 + val2 == 0) { valDim0 = 2; } else { valDim0  = val2; } } break;
-                                        }
-                                }
-                        }
-                }
-         }
-
-        return(valDim0);
-};
-
 
 

trunk/yao/src/YAOObjects/Order.hpp

@@ -417 +417 @@
         * If there is no common value the axis have to be decomposed 
         * If there is a common value or if there is no remaining edges in the last fixed graph, then the axis does not have to be decomposed
-        * @param fixedDimOne an interger value indicating which is the first dimension that should be fixed 
-        * @param fixedDimTwo an interger value indicating which is the second dimension that should be fixed 
         * @param freeDim an interger value indicating on which dimension the sign must be analyzed
         * @param upperGraph a reference to the graph on which the operations have to be performed
         */
-        bool isToDecompose(int fixedDimOne, int fixedDimTwo, int freeDim, myGraphType& upperGraph);
+        bool isToDecompose(int freeDim, myGraphType& upperGraph);
 
         /**
@@ -485 +483 @@
         * @param noComp3D an integer value indicating from which 3D component the order have to be read
         */
-        void Read(int noComp3D);
+        void Read3D(int noComp3D);
 
         /**