removed alternative contructor for parameters - not working

Author: Andrea Hornakova

solverILP/LifT_py/solveFromFiles.py

@@ -15,11 +15,13 @@
 
 import disjointPathsPy as ldpPy
 
+#Create a parser for parameters
 paramsParser=ldpPy.ParametersParser()
 
+#Initializes parameters from file
 paramsParser.init_from_file("../data/exampleSolverILP/params_sequence_py.ini")
 
-#Initializes structure for holding solver parameters. It expects the path to the solver parameter file.
+#Initializes structure for holding solver parameters. It expects either a ParameterParser or a string to string dictionary as an input
 params=ldpPy.DisjointParams(paramsParser)
 
 #Constructor of structure for holding the mapping between time frames and graph vertices

solverILP/LifT_py/solveFromMatrix.py

@@ -46,7 +46,7 @@
 paramsMap["OUTPUT_PATH"]="../data/exampleSolverILP/"
 
 
-#Initializes structure for holding solver parameters. It expects the path to the solver parameter file.
+#Initializes structure for holding solver parameters. It expects either a ParameterParser or a string to string dictionary as an input
 params=ldpPy.DisjointParams(paramsMap)
 
 #Constructor of structure for holding the mapping between time frames and graph vertices

solverILP/include/disjoint-paths/disjointParams.hxx

@@ -55,7 +55,7 @@ public:
 
 
    // DisjointParams(const std::string& fileName);
-     DisjointParams(ParametersParser& paramsConstructor);
+    // DisjointParams(ParametersParser& paramsConstructor);
      DisjointParams(std::map<std::string,std::string>& parsedParams);
     //DisjointParamsDisjointParamsDisjointParams(const std::stringstream& stream);
 
@@ -247,7 +247,7 @@ public:
 
 private:
     DisjointParams<T>(const DisjointParams<T>&);
-    void initParameters(std::map<std::string,std::string>& parameters);
+   // void initParameters(std::map<std::string,std::string>& parameters);
     DisjointParams();
 
     std::ofstream& infoFile(){
@@ -343,10 +343,10 @@ private:
 
 //}
 
-template<class T>
-inline DisjointParams<T>::DisjointParams(ParametersParser& paramsConstructor){
-    DisjointParams(paramsConstructor.getParsedStrings());
-}
+//template<class T>
+//inline DisjointParams<T>::DisjointParams(ParametersParser& paramsConstructor){
+//    DisjointParams(paramsConstructor.getParsedStrings());
+//}
 
 template<class T>
 inline DisjointParams<T>::DisjointParams(std::map<std::string,std::string>& parameters){

solverILP/include/disjoint-paths/disjointPathsData.hxx

@@ -555,7 +555,7 @@ inline void Data<T>::readCompleteGraph(){
             data.open(parameters.getGraphFileName());
             if(!data){
 
-                throw std::system_error(errno, std::system_category(), "failed to open "+parameters.getGraphFileName());
+                throw std::system_error(errno, std::system_category(), "failed to open graph file "+parameters.getGraphFileName());
 
             }
             char delim=',';

solverILP/include/disjoint-paths/disjointPathsMethods.hxx

@@ -71,7 +71,7 @@ std::vector<std::vector<T>> readLines(std::string inputFileName, char delim) {
 
 		inputFile.open(inputFileName);
 		if (!inputFile){
-			throw std::system_error(errno, std::system_category(), "failed to open "+inputFileName);
+            throw std::system_error(errno, std::system_category(), "failed to open file with interval solution "+inputFileName);
 		}
 
 		std::string line;
@@ -167,6 +167,7 @@ public:
     template<class PAR> VertexGroups(PAR& parameters){
 		//std::vector<std::vector<size_t>> groups;
 
+        std::cout<<"time file name check 2 "<<parameters.getTimeFileName()<<std::endl;
         initFromFile(parameters.getTimeFileName(),parameters);
 //		std::string line;
 //		std::vector<std::string> strings;
@@ -309,11 +310,12 @@ inline void VertexGroups<T>::initFromFile(const std::string& fileName, const PAR
     size_t maxTimeToRead=parameters.getMaxTimeFrame();
 
 
+    std::cout<<"time file name check 3 "<<fileName<<std::endl;
     std::ifstream timeData;
     try{
         timeData.open(fileName);
         if(!timeData){
-            throw std::system_error(errno, std::system_category(), "failed to open "+fileName);
+            throw std::system_error(errno, std::system_category(), "failed to open file with vertices in time layers "+fileName);
         }
 
     unsigned int previousTime=1;
@@ -689,6 +691,7 @@ public:
     template<class PAR>
     CompleteStructure(PAR & configParameters)
 {
+        std::cout<<"time file name check 1 "<<configParameters.getTimeFileName()<<std::endl;
         pVertexGroups=new VertexGroups<>(configParameters);
         VertexGroups<>& vg=*pVertexGroups;
 		maxTime=vg.getMaxTime();
@@ -725,6 +728,8 @@ public:
     template<class PAR>
     void addEdgesFromFile(const std::string& fileName,PAR& params);
     void addEdgesFromMatrix(size_t time1,size_t time2,const py::array_t<double> inputMatrix);
+    template<class PAR>
+    void addEdgesFromVectors(const py::array_t<size_t>edges,const py::array_t<double> costs,PAR& params);
     const VertexGroups<>& getVertexGroups(){
         return *pVertexGroups;
     }
@@ -742,6 +747,49 @@ private:
 
 };
 
+template<class T>
+template<class PAR>
+inline void CompleteStructure<T>::addEdgesFromVectors(const py::array_t<size_t> edges,const py::array_t<double> costs,PAR& params){
+    char delim=',';
+    VertexGroups<>& vg=*pVertexGroups;
+
+    const auto edgeVector=edges.unchecked<2>();
+    const std::size_t dim1=edgeVector.shape(0);
+    const std::size_t dim2=edgeVector.shape(1);
+    const auto costVector=costs.unchecked<1>();
+    const size_t dimOfCosts=costVector.shape(0);
+
+
+    if(dim2!=2){
+        std::string message="Wrong dimension of edge array, second dimension 2 expected";
+        throw std::invalid_argument(message);
+    }
+    if(dim1!=dimOfCosts){
+        std::string message="Dimension of edge array and edge costs do not match.";
+        throw std::invalid_argument(message);
+    }
+
+    params.getControlOutput()<<"Reading base edges from vector. "<<std::endl;
+    params.writeControlOutput();
+    for (size_t i=0;i<dim1;i++) {
+        size_t v=edgeVector(i,0);
+        size_t w=edgeVector(i,1);
+        double edgeCost=costVector(i);
+
+        size_t l0=vg.getGroupIndex(v);
+        size_t l1=vg.getGroupIndex(w);
+        //std::cout<<std::to_string(l0)<<", "<<std::to_string(l1)<<std::endl;
+        if(v>vg.getMaxVertex()||w>vg.getMaxVertex()) continue;
+        //std::cout<<"edge "<<v<<" "<<w<<std::endl;
+
+        if(l1-l0<=params.getMaxTimeGapComplete()){
+            completeGraph.insertEdge(v,w);
+            completeScore.push_back(edgeCost);
+        }
+    }
+}
+
+
 template<class T>
 inline void CompleteStructure<T>::addEdgesFromMatrix(size_t time1,size_t time2,const py::array_t<double> inputMatrix){
 
@@ -823,7 +871,7 @@ inline void CompleteStructure<T>::addEdgesFromFile(const std::string& fileName,P
 	try{
         data.open(fileName);
 		if(!data){
-            throw std::system_error(errno, std::system_category(), "failed to open "+fileName);
+            throw std::system_error(errno, std::system_category(), "failed to open graph file "+fileName);
 		}
 
 		std::getline(data, line);

solverILP/include/disjoint-paths/disjointStructure.hxx

@@ -207,7 +207,7 @@ parameters(configParameters)
 		try{
 			graphFile.open(parameters.getGraphFileName());
 			if(!graphFile){
-				throw std::system_error(errno, std::system_category(), "failed to open "+parameters.getGraphFileName());
+                throw std::system_error(errno, std::system_category(), "failed to open graph file "+parameters.getGraphFileName());
 			}
 			readGraph(graphFile,maxVertex,delim);
 			if(!parameters.isAutomaticLifted()){

solverILP/include/disjoint-paths/parametersconstructor.hxx

@@ -21,7 +21,7 @@ class ParametersParser{
         try{
             data.open(fileName);
             if (!data){
-                throw std::system_error(errno, std::system_category(), "failed to open "+fileName);
+                throw std::system_error(errno, std::system_category(), "failed to open parameter file "+fileName);
             }
             bool solverPart=false;
             std::string line;
@@ -38,6 +38,7 @@ class ParametersParser{
                 throw std::runtime_error("Config file does not contain \"[SOLVER]\".  ");
             }
             initFromStream(data);
+            data.close();
 
         }
 

solverILP/src/disjoint-paths/disjointPathsPython.cxx

@@ -19,12 +19,11 @@ PYBIND11_MODULE(disjointPathsPy, m) {
 
     py::class_<disjointPaths::ParametersParser>(m,"ParametersParser")
             .def(py::init<>())
-            .def("init_from_file",&disjointPaths::ParametersParser::initFromFile,"Parses parameters from a file")
-            .def("init_from_stream",&disjointPaths::ParametersParser::initFromStream<std::stringstream>,"Parses parameters from a stream");
+            .def("init_from_file",&disjointPaths::ParametersParser::initFromFile,"Parses parameters from a file");
+           // .def("init_from_stream",&disjointPaths::ParametersParser::initFromStream<std::stringstream>,"Parses parameters from a stream");
 
 
      py::class_<disjointPaths::DisjointParams<>>(m, "DisjointParams")
-        .def(py::init<disjointPaths::ParametersParser&>())
         .def(py::init<std::map<std::string,std::string>&>());
 
      py::class_<disjointPaths::VertexGroups<>>(m, "TimeFramesToVertices")
@@ -35,6 +34,7 @@ PYBIND11_MODULE(disjointPathsPy, m) {
      py::class_<disjointPaths::CompleteStructure<>>(m, "GraphStructure")
         .def(py::init<disjointPaths::VertexGroups<> &>())
         .def("add_edges_from_array", &disjointPaths::CompleteStructure<>::addEdgesFromMatrix, "Initializes edges of the graph between two time frames from a matrix.")
+        .def("add_edges_from_vectors", &disjointPaths::CompleteStructure<>::addEdgesFromVectors<disjointPaths::DisjointParams<>>, "Initializes edges of the graph from an Nx2 array of size_t with edge vertices and an Nx1 array of doubles with costs.")
         .def("add_edges_from_file", &disjointPaths::CompleteStructure<>::addEdgesFromFile<disjointPaths::DisjointParams<>>, "Initializes all edges of the graph from a file.");
 
     // m.def("solve_ilp", py::overload_cast<disjointPaths::DisjointParams<>&, disjointPaths::CompleteStructure<>&>(&disjointPaths::solver_ilp_intervals<>), "Solve lifted disjoint paths");

solverILP/src/disjoint-paths/runDisjointPaths.cxx

@@ -107,14 +107,15 @@ try
     disjointPaths::ParametersParser parametersParser;
     parametersParser.initFromFile(parameters.configFile);
 
-    disjointPaths::DisjointParams<size_t> disjointParameters(parametersParser);
+    disjointPaths::DisjointParams<size_t> disjointParameters(parametersParser.getParsedStrings());
     if(disjointParameters.isParametersSet()){
         if(disjointParameters.getMaxTimeLifted()==0){
             std::vector<std::vector<size_t>> paths=disjointPaths::solver_flow_only(disjointParameters);
             disjointPaths::writeOutputToFile(paths,disjointParameters.getOutputFileName() + "-all-paths-FINAL.txt");
 
 		}
 		else{
+            std::cout<<"time file name check 0 "<<disjointParameters.getTimeFileName()<<std::endl;
 
             disjointPaths::CompleteStructure<> cs(disjointParameters);
             std::vector<std::vector<size_t>> paths=disjointPaths::solver_ilp<size_t>(disjointParameters,cs);