Merge pull request ComputationalRadiationPhysics#60 from slizzered/is…

…sue40-boost_filesystem

Nice work! ...it was a bad idea to use plain strings for filenames and paths.

CMakeLists.txt

@@ -64,7 +64,7 @@ set(CUDA_NVCC_LINKER_FLAGS ${CUDA_NVCC_FLAGS})
 ###############################################################################
 # Boost
 ###############################################################################
-find_package(Boost 1.48.0 REQUIRED COMPONENTS program_options filesystem)
+find_package(Boost 1.48.0 COMPONENTS system program_options filesystem REQUIRED)
 include_directories(SYSTEM ${Boost_INCLUDE_DIRS})
 set(LIBS ${LIBS} ${Boost_LIBRARIES})
 

include/parser.hpp

@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Erik Zenker, Carlchristian Eckert, Marius Melzer
+ * Copyright 2015 Erik Zenker, Carlchristian Eckert, Marius Melzer
  *
  * This file is part of HASEonGPU
  *
@@ -29,15 +29,16 @@
 
 #pragma once
 #include <string>  /* string */
-#include <iostream>
-#include <fstream> /* ifstream */
-#include <cstdlib> /* atof */
-#include <vector> 
+#include <vector>
 
 #include <logging.hpp>
 #include <mesh.hpp>
 #include <nan_fix.hpp>
 
+#include <boost/filesystem.hpp> /* fs::path */
+#include <boost/filesystem/fstream.hpp> /* fs::fstream */
+namespace fs = boost::filesystem;
+
 enum DeviceMode { NO_DEVICE_MODE, GPU_DEVICE_MODE, CPU_DEVICE_MODE};
 enum ParallelMode { NO_PARALLEL_MODE, THREADED_PARALLEL_MODE, MPI_PARALLEL_MODE };
 
@@ -49,25 +50,24 @@ enum ParallelMode { NO_PARALLEL_MODE, THREADED_PARALLEL_MODE, MPI_PARALLEL_MODE
  *        int, float, double).
  *
  * @param filename file to parse
- * @param vector contains the parsed values 
+ * @param vector contains the parsed values
  *
  * @return 1 if parsing was succesful (file can be opened)
  * @return 0 otherwise
  **/
 template <class T>
-int fileToVector(const std::string filename, std::vector<T> *v){
+int fileToVector(const fs::path filename, std::vector<T> *v){
   std::string line;
-  std::ifstream fileStream; 
+  fs::ifstream fileStream;
   T value = 0.0;
 
-  fileStream.open(filename.c_str());
+  fileStream.open(filename);
   if(fileStream.is_open()){
     while(fileStream.good()){
-      std::getline(fileStream, line);
-      value = (T) atof(line.c_str());
+      fileStream >> value;
       if(isNaN(value)){
-	dout(V_ERROR) << "NAN in input data: " << filename << std::endl;
-	exit(1);
+        dout(V_ERROR) << "NAN in input data: " << filename << std::endl;
+        exit(1);
       }
       v->push_back(value);
     }
@@ -81,28 +81,46 @@ int fileToVector(const std::string filename, std::vector<T> *v){
   v->pop_back();
   fileStream.close();
   return 0;
-  
+
 }
+
+
+/**
+ * @brief overload to allow distinct directory and filename
+ *
+ * @param directory directory where file is located
+ * @param filename file to parse
+ * @param vector contains the parsed values
+ *
+ * @return 1 if parsing was succesful (file can be opened)
+ * @return 0 otherwise
+ **/
+template <class T>
+int fileToVector(const fs::path directory, const fs::path filename, std::vector<T> *v){
+  fs::path tempPath(directory);
+  return(fileToVector(tempPath /= filename, v));
+}
+
+
 /**
  * @brief Parses just one line(value) of a given file(filename).
  *        The value should be a number (short, unsigned,
  *        int, float, double).
  *
  * @param filename file to parse
- * @param value is the value which was parsed 
+ * @param value is the value which was parsed
  *
  * @return 1 if parsing was succesful (file can be opened)
  * @return 0 otherwise
  **/
 template <class T>
-int fileToValue(const std::string filename, T &value){
+int fileToValue(const fs::path filename, T &value){
   std::string line;
-  std::ifstream fileStream; 
+  fs::ifstream fileStream;
 
-  fileStream.open(filename.c_str());
+  fileStream.open(filename);
   if(fileStream.is_open()){
-      std::getline(fileStream, line);
-      value = (T) atof(line.c_str());
+    fileStream >> value;
   }
   else{
     dout(V_ERROR) << "Can't open file " << filename << std::endl;
@@ -111,7 +129,24 @@ int fileToValue(const std::string filename, T &value){
   }
   fileStream.close();
   return 0;
-
+
+}
+
+
+/**
+ * @brief overload to allow distinct directory and filename
+ *
+ * @param directory directory where file is located
+ * @param filename file to parse
+ * @param value is the value which was parsed
+ *
+ * @return 1 if parsing was succesful (file can be opened)
+ * @return 0 otherwise
+ **/
+template <class T>
+int fileToValue(const fs::path directory, const fs::path filename, T &value){
+  fs::path tempPath(directory);
+  return(fileToValue(tempPath /= filename, value));
 }
 
 
@@ -120,7 +155,7 @@ void parseCommandLine(
     char** argv,
     unsigned *raysPerSample,
     unsigned *maxRaysPerSample,
-    std::string *inputPath,
+    fs::path *inputPath,
     bool *writeVtk,
     DeviceMode *deviceMode,
     ParallelMode *parallelMode,
@@ -129,41 +164,41 @@ void parseCommandLine(
     int *minSample_i,
     int *maxSample_i,
     unsigned *maxRepetitions,
-    std::string *outputPath,
+    fs::path *outputPath,
     double *mseThreshold,
     unsigned *lambdaResolution
     );
 
 void printCommandLine(
     unsigned raysPerSample,
     unsigned maxRaysPerSample,
-    std::string inputPath,
+    fs::path inputPath,
     bool writeVtk,
-    std::string compareLocation,
+    fs::path compareLocation,
     const DeviceMode deviceMode,
     const ParallelMode parallelMode,
     bool useReflections,
     unsigned maxgpus,
     int minSample_i,
     int maxSample_i,
     unsigned maxRepetitions,
-    std::string outputPath,
+    fs::path outputPath,
     double mseThreshold
     );
 
 int checkParameterValidity(
     const int argc,
     const unsigned raysPerSample,
     unsigned *maxRaysPerSample,
-    const std::string inputPath,
+    const fs::path inputPath,
     const unsigned deviceCount,
     const DeviceMode deviceMode,
     const ParallelMode parallelMode,
     unsigned *maxgpus,
     const int minSample_i,
     const int maxSample_i,
     const unsigned maxRepetitions,
-    const std::string outputPath,
+    const fs::path outputPath,
     double *mseThreshold
     );
 
@@ -173,7 +208,7 @@ void checkSampleRange(
 	const unsigned numberOfSamples
 	);
 
-std::vector<Mesh> parseMesh(std::string rootPath,
+std::vector<Mesh> parseMesh(const fs::path rootPath,
 			    std::vector<unsigned> devices,
 			    unsigned maxGpus);
 

include/progressbar.hpp

@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Erik Zenker, Carlchristian Eckert, Marius Melzer
+ * Copyright 2015 Erik Zenker, Carlchristian Eckert, Marius Melzer
  *
  * This file is part of HASEonGPU
  *
@@ -32,6 +32,8 @@
 #pragma once
 #include <string>
 
+#include <boost/filesystem.hpp> /* boost::filesystem::path */
+
 /**
  * @brief writes the progress of an operation to dout(V_PROGRESS) (see logging.h),
  *        updating the progress every time the function is called.
@@ -75,4 +77,4 @@ void fancyProgressBar(const unsigned current,const unsigned nTotal);
  * @param path the name of the file to write
  *
  */
-void fileProgressBar(const unsigned nTotal, const std::string path);
+void fileProgressBar(const unsigned nTotal, const boost::filesystem::path path);

include/write_matlab_output.hpp

@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Erik Zenker, Carlchristian Eckert, Marius Melzer
+ * Copyright 2015 Erik Zenker, Carlchristian Eckert, Marius Melzer
  *
  * This file is part of HASEonGPU
  *
@@ -23,6 +23,8 @@
 #include <vector>
 #include <string>
 
+#include <boost/filesystem.hpp> /* boost::filesystem::path */
+
 /**
  * @brief creates textfiles containing all the results as a 2D matrix
  *        (needs to be reshaped in matlab, see calcPhiASE.m)
@@ -41,7 +43,7 @@
  * @license GPLv3
  */
 void writeMatlabOutput(
-    const std::string experimentPath,
+    const boost::filesystem::path experimentPath,
     const std::vector<float> ase,
     const std::vector<unsigned> N_rays, 
     const std::vector<double> mse_values,

include/write_to_file.hpp

@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Erik Zenker, Carlchristian Eckert, Marius Melzer
+ * Copyright 2015 Erik Zenker, Carlchristian Eckert, Marius Melzer
  *
  * This file is part of HASEonGPU
  *
@@ -29,6 +29,8 @@
 #include <string>
 #include <vector>
 
+#include <boost/filesystem.hpp> /* boost::filesystem::path */
+
 /** 
  * @brief writes a value to a file, where the filename is appended with 2 longish indices
  *
@@ -41,7 +43,7 @@
  */
 int writeValueToFile(
     const float value, 
-    const std::string path, 
+    const boost::filesystem::path path,
     const std::string indexName1, 
     const int index1, 
     const std::string indexName2, 
@@ -56,4 +58,4 @@ int writeValueToFile(
  * @param pFilename the name of the output file
  *
  */
-void writeVectorToFile(std::vector<double> v, std::string pFilename);
+void writeVectorToFile(std::vector<double> v, boost::filesystem::path filename);

include/write_to_vtk.hpp

@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Erik Zenker, Carlchristian Eckert, Marius Melzer
+ * Copyright 2015 Erik Zenker, Carlchristian Eckert, Marius Melzer
  *
  * This file is part of HASEonGPU
  *
@@ -29,6 +29,8 @@
 #include <vector>
 #include <string>
 
+#include <boost/filesystem.hpp> /* boost::filesystem::path */
+
 #include <mesh.hpp>
 
 /**
@@ -48,7 +50,7 @@
  */
 int writePointsToVtk(const Mesh& mesh,
 	       const std::vector<double> ase,
-	       const std::string filename, 
+	       const boost::filesystem::path filename,
 	       const unsigned minRaysPerSample,
 	       const unsigned maxRaysPerSample,
 	       const float mseThreshold,
@@ -72,7 +74,7 @@ int writePointsToVtk(const Mesh& mesh,
  */
 int writePrismToVtk(const Mesh& mesh,
 	       const std::vector<double> prismData,
-	       const std::string filename, 
+	       const boost::filesystem::path filename,
 	       const unsigned minRaysPerSample,
 	       const unsigned maxRaysPerSample,
 	       const float mseThreshold,
@@ -87,7 +89,7 @@ int writePrismToVtk(const Mesh& mesh,
  * @return a vector containing the difference between "compare" and "data"
  *
  */
-std::vector<double> compareVtk(std::vector<double> compare, std::string filename);
+std::vector<double> compareVtk(std::vector<double> compare, const boost::filesystem::path filename);
 
 
 

src/main.cu

@@ -1,5 +1,5 @@
 /**
- * Copyright 2013 Erik Zenker, Carlchristian Eckert, Marius Melzer
+ * Copyright 2015 Erik Zenker, Carlchristian Eckert, Marius Melzer
  *
  * This file is part of HASEonGPU
  *
@@ -37,6 +37,10 @@
 #include <numeric> /* accumulate*/
 #include <stdexcept>
 
+// Boost stuff
+#include <boost/filesystem.hpp> /* fs::path */
+namespace fs = boost::filesystem;
+
 // User header files
 #include <calc_phi_ase.hpp>
 #include <calc_phi_ase_threaded.hpp>
@@ -93,8 +97,8 @@ int main(int argc, char **argv){
   time_t starttime   = time(0);
   unsigned usedGpus  = 0;
 
-  std::string inputPath;
-  std::string outputPath;
+  fs::path inputPath;
+  fs::path outputPath;
   double mseThreshold = 0;
 
   // Wavelength data
@@ -121,10 +125,10 @@ int main(int argc, char **argv){
   dout(V_INFO) << "parameter validity was checked!" << std::endl;
 
   // Parse wavelengths from files
-  if(fileToVector(inputPath + "sigmaA.txt",  &sigmaA))   return 1;
-  if(fileToVector(inputPath + "sigmaE.txt",  &sigmaE))   return 1;
-  if(fileToVector(inputPath + "lambdaA.txt", &lambdaA)) return 1;
-  if(fileToVector(inputPath + "lambdaE.txt", &lambdaE)) return 1;
+  if(fileToVector(inputPath, "sigmaA.txt",  &sigmaA))   return 1;
+  if(fileToVector(inputPath, "sigmaE.txt",  &sigmaE))   return 1;
+  if(fileToVector(inputPath, "lambdaA.txt", &lambdaA)) return 1;
+  if(fileToVector(inputPath, "lambdaE.txt", &lambdaE)) return 1;
   lambdaResolution = std::max(lambdaResolution, (unsigned) lambdaA.size());
   lambdaResolution = std::max(lambdaResolution, (unsigned) lambdaE.size());
 
@@ -274,10 +278,10 @@ int main(int argc, char **argv){
     std::vector<double> tmpPhiAse(phiAse.begin(), phiAse.end());
     std::vector<double> tmpTotalRays(totalRays.begin(), totalRays.end());
 
-    writePointsToVtk(meshs[0], dndtAse, outputPath + "vtk/dndt", minRaysPerSample, maxRaysPerSample, mseThreshold, useReflections, runtime);
-    writePointsToVtk(meshs[0], tmpPhiAse, outputPath + "vtk/phiase", minRaysPerSample, maxRaysPerSample, mseThreshold, useReflections, runtime);
-    writePointsToVtk(meshs[0], mse, outputPath + "vtk/mse", minRaysPerSample, maxRaysPerSample, mseThreshold, useReflections, runtime);
-    writePointsToVtk(meshs[0], tmpTotalRays, outputPath + "vtk/total_rays", minRaysPerSample, maxRaysPerSample, mseThreshold, useReflections, runtime);
+    writePointsToVtk(meshs[0], dndtAse, outputPath /= "vtk/dndt", minRaysPerSample, maxRaysPerSample, mseThreshold, useReflections, runtime);
+    writePointsToVtk(meshs[0], tmpPhiAse, outputPath /= "vtk/phiase", minRaysPerSample, maxRaysPerSample, mseThreshold, useReflections, runtime);
+    writePointsToVtk(meshs[0], mse, outputPath /= "vtk/mse", minRaysPerSample, maxRaysPerSample, mseThreshold, useReflections, runtime);
+    writePointsToVtk(meshs[0], tmpTotalRays, outputPath /= "vtk/total_rays", minRaysPerSample, maxRaysPerSample, mseThreshold, useReflections, runtime);
   }
 
   // Print statistics