minor

Author: aghaeifar

README.md

@@ -37,7 +37,7 @@ You can either use the supplied Dockerfile for a consistent build that includes
 We suggest utilizing the provided Dockerfile, which automates the installation of all dependencies, as well as the cloning and building of the program. Download the [Dockerfile](./Dockerfile) to your current directory and then execute the following commands:
 
 ```
-docker build -t spinwalk .
+docker build --no-cache -t spinwalk .
 docker run --gpus all --rm -it --runtime=nvidia spinwalk bash
 ```
 ### CMake

src/file_utils.cpp

@@ -38,7 +38,13 @@ bool file_utils::read_config(std::string config_filename, simulation_parameters
     std::string cf_name = std::filesystem::path(config_filename).filename().string();
     BOOST_LOG_TRIVIAL(info) << "Reading config: " << config_filename;
     boost::property_tree::ptree pt;
-    boost::property_tree::ini_parser::read_ini(config_filename, pt);
+
+    try{ 
+        boost::property_tree::ini_parser::read_ini(config_filename, pt);
+    }catch (std::exception& e) {
+        std::cout << ERR_MSG << e.what() << "\n";
+        return false;
+    } 
 
     if(pt.get_child_optional("PARENT.PARENT_CONFIG"))
     {

src/shapes/cylinder.cu

@@ -26,8 +26,8 @@ cylinder::cylinder()
     m_orientation = 0;
 }
 
-cylinder::cylinder(float fov_um, size_t resolution, float dChi, float Y, float radius_um, float BVF, float orientation, bool is_seed_fixed, std::string filename)
-: shape(fov_um, resolution, dChi, Y, BVF, is_seed_fixed, filename)
+cylinder::cylinder(float fov_um, size_t resolution, float dChi, float Y, float radius_um, float BVF, float orientation, int32_t seed, std::string filename)
+: shape(fov_um, resolution, dChi, Y, BVF, seed, filename)
 {
     set_cylinder_parameters(radius_um, orientation);
 }
@@ -60,7 +60,7 @@ void cylinder::generate_shapes()
     float cyl_pnt[3], cyl_rad ;
     float curr_BVF = 0;
     // srandom engine
-    std::mt19937 gen(m_random_seed); // Mersenne Twister generator
+    std::mt19937 gen(m_seed); // Mersenne Twister generator
     std::uniform_real_distribution<float> dist(0.f, 1.f); 
 
     float distance, vol_cyl = 0, vol_cyl_total = 0, vol_tol = m_fov*m_fov*m_fov;

src/shapes/cylinder.cuh

@@ -17,7 +17,7 @@ class cylinder : public shape
 {
     public:
     cylinder();
-    cylinder(float fov_um, size_t resolution, float dChi, float Y, float radius_um = 50, float BVF = 10., float orientation = -1.0f, bool is_seed_fixed=false, std::string filename = "shape.h5");
+    cylinder(float fov_um, size_t resolution, float dChi, float Y, float radius_um = 50, float BVF = 10., float orientation = -1.0f, int32_t seed=-1, std::string filename = "shape.h5");
     ~cylinder();
 
     virtual bool run();

src/shapes/shape_base.cu

@@ -17,19 +17,19 @@ shape::shape()
 {
     m_fov = 0;
     m_resolution = 0;
-    m_random_seed = std::random_device{}();
+    m_seed = std::random_device{}();
     set_blood_parameters(0.273e-6 * 0.4, 0, 10.0);
     set_filename(); 
 }
 
-shape::shape(float fov_um, size_t resolution, float dChi, float Y, float BVF, bool is_seed_fixed, std::string filename)
+shape::shape(float fov_um, size_t resolution, float dChi, float Y, float BVF, int32_t seed, std::string filename)
 :shape()
 {
     set_space(fov_um, resolution);
     set_blood_parameters(dChi, Y, BVF);
     set_filename(filename);
-    if(is_seed_fixed)
-        m_random_seed = 0;
+    if(seed >= 0)
+        m_seed = seed;
 }
 
 shape::~shape()
@@ -135,5 +135,5 @@ void shape::print_info()
     std::cout << "  Resolution: " << m_resolution << "\n";
     std::cout << "  Blood parameters: dChi=" << m_dChi << ", Y=" << m_Y <<  "\n";
     std::cout << "  Filename: " << m_filename <<  "\n";
-    std::cout << "  Seed: " << m_random_seed <<  "\n";
+    std::cout << "  Seed: " << m_seed <<  "\n";
 }

src/shapes/shape_base.cuh

@@ -17,7 +17,7 @@ class shape
 {
     public:
         shape();
-        shape(float fov_um, size_t resolution, float dChi, float Y, float BVF, bool is_seed_fixed, std::string filename);
+        shape(float fov_um, size_t resolution, float dChi, float Y, float BVF, int32_t seed, std::string filename);
         ~shape();
         void set_space(float fov_um, size_t resolution);
         void set_blood_parameters(float dChi, float Y, float BVF = 10.0); 
@@ -39,7 +39,7 @@ class shape
         std::string m_filename;
         float B0[3] = {0.f, 0.f, 1.f};
         bool m_calc_fieldmap;
-        size_t m_random_seed;
+        size_t m_seed;
 
     private: 
 };

src/shapes/sphere.cu

@@ -25,8 +25,8 @@ sphere::sphere()
     m_radius = 0;
 }
 
-sphere::sphere(float fov_um, size_t resolution, float dChi, float Y, float radius_um, float BVF, bool is_seed_fixed, std::string filename)
-: shape(fov_um, resolution, dChi, Y, BVF, is_seed_fixed, filename)
+sphere::sphere(float fov_um, size_t resolution, float dChi, float Y, float radius_um, float BVF, int32_t seed, std::string filename)
+: shape(fov_um, resolution, dChi, Y, BVF, seed, filename)
 {
     set_sphere_parameters(radius_um);
 }
@@ -55,7 +55,7 @@ void sphere::generate_shapes()
     float sph_pnt[3], radius ;
 
     // srandom engine
-    std::mt19937 gen(m_random_seed); // Mersenne Twister generator
+    std::mt19937 gen(m_seed); // Mersenne Twister generator
     std::uniform_real_distribution<float> dist(0.f, 1.f); 
 
     float distance, vol_sph = 0, vol_tol = m_fov*m_fov*m_fov;

src/shapes/sphere.cuh

@@ -17,7 +17,7 @@ class sphere : public shape
 {
     public:
     sphere();
-    sphere(float fov_um, size_t resolution, float dChi, float Y, float radius_um = 50, float BVF = 10.0, bool is_seed_fixed=false, std::string filename = "shape.h5");
+    sphere(float fov_um, size_t resolution, float dChi, float Y, float radius_um = 50, float BVF = 10.0, int32_t seed = -1, std::string filename = "shape.h5");
     ~sphere();
 
     virtual bool run();

src/spinwalk.cu

@@ -94,6 +94,7 @@ bool run(simulation_parameters param, std::map<std::string, std::vector<std::str
     for (int16_t fieldmap_no=0; fieldmap_no<param.n_fieldmaps; fieldmap_no++)
     {
         // ========== load files (field-maps, xyz0, m0) ==========
+        std::cout << "Loading phantom: " << std::filesystem::path(filenames.at("phantom")[fieldmap_no]).filename().string() << "\n";
         if(file_utils::read_fieldmap(filenames.at("phantom")[fieldmap_no], fieldmap, mask, &param) == false)
             return false;
         // convert fieldmap from T to degree per timestep
@@ -224,7 +225,7 @@ bool run(simulation_parameters param, std::map<std::string, std::vector<std::str
         checkCudaErrors(cudaEventElapsedTime(&elapsedTime, start, end));
         std::cout << "Simulation over " << device_count << " GPU(s) took " << std::fixed << std::setprecision(2) <<  elapsedTime/1000. << " second(s)" << '\n';
         // ========== save results ========== 
-        std::cout << "Saving the results to disk" << "\n";
+        std::cout << "Saving the results to disk." << "\n";
         std::string f = filenames.at("output")[fieldmap_no];
         if (std::filesystem::exists(f)) 
             std::filesystem::remove(f);
@@ -274,7 +275,7 @@ int main(int argc, char * argv[])
     bool bStatus = true;
     std::string phantom_output;
     float phantom_radius, phantom_fov, phantom_dchi, phantom_oxy_level, phantom_orientation, phantom_BVF;
-    int32_t phantom_resolution;
+    int32_t phantom_resolution, phantom_seed;
     std::vector<std::string>  config_files;
     print_logo();
     // ========== parse command line arguments ==========
@@ -287,15 +288,15 @@ int main(int argc, char * argv[])
         ("no_gpu,g", "only run on CPU(s) (default: GPU)")
 #endif
         ("cylinder,C", "generate phantom filled with cylinders")
-        ("sphere,s", "generate phantom filled with spheres")
+        ("sphere,S", "generate phantom filled with spheres")
         ("orientation,o", po::value<float>(&phantom_orientation)->default_value(90.0), "orientation of the cylinders in degree with respect to B0")
         ("radius,r", po::value<float>(&phantom_radius)->default_value(50), "radius of the cylinders/spheres in um (negative value = random radius)")
-        ("reproducible,R", "set fixed seed for random number generator (for reproducibility)")
+        ("seed,s", po::value<int32_t>(&phantom_seed)->default_value(-1), "seed for random number generator in phantom creator (negative value = random seed)")
         ("BVF,b", po::value<float>(&phantom_BVF)->default_value(10.0), "fraction of shapes to entire volume <0.0 100.0> (i.e. blood volume fraction)")
         ("fov,v", po::value<float>(&phantom_fov)->default_value(1000.0), "voxel field of view in um (isotropic)")
         ("resolution,z", po::value<int32_t>(&phantom_resolution)->default_value(500), "base resolution")
         ("dchi,d", po::value<float>(&phantom_dchi)->default_value(0.11e-6), "susceptibility difference between fully deoxygenated blood (inside cylinders/spheres) and tissue (outside cylinders/spheres) (default: 0.11e-6 in cgs units)")
-        ("oxy_level,Y", po::value<float>(&phantom_oxy_level)->default_value(0.75), "blood oxygenetation level <0.0 1.0> (negative value = exclude off-resonance effect and only generate the mask)")
+        ("oxy_level,y", po::value<float>(&phantom_oxy_level)->default_value(0.75), "blood oxygenetation level <0.0 1.0> (negative value = exclude off-resonance effect and only generate the mask)")
         ("output_file,f", po::value<std::string>(&phantom_output)->default_value("./phantom.h5"), "path to save phantom (h5 format)");
 
     po::variables_map vm;
@@ -326,12 +327,12 @@ int main(int argc, char * argv[])
     // ========== generate phantom ==========
     if (vm.count("cylinder"))
     {
-        cylinder cyl(phantom_fov, phantom_resolution, phantom_dchi, phantom_oxy_level, phantom_radius, phantom_BVF, phantom_orientation, vm.count("reproducible")>0, phantom_output);
+        cylinder cyl(phantom_fov, phantom_resolution, phantom_dchi, phantom_oxy_level, phantom_radius, phantom_BVF, phantom_orientation, phantom_seed, phantom_output);
         cyl.run();
     }
     if (vm.count("sphere"))
     {
-        sphere sph(phantom_fov, phantom_resolution, phantom_dchi, phantom_oxy_level, phantom_radius, phantom_BVF, vm.count("reproducible")>0, phantom_output);
+        sphere sph(phantom_fov, phantom_resolution, phantom_dchi, phantom_oxy_level, phantom_radius, phantom_BVF, phantom_seed, phantom_output);
         sph.run();
     }
 
@@ -343,7 +344,7 @@ int main(int argc, char * argv[])
     auto start = std::chrono::steady_clock::now();
     for(const auto& cfile : config_files)
     {
-        std::cout << "<" <<  std::filesystem::path(cfile).filename().string() << ">\n";
+        std::cout << "<" << std::filesystem::path(cfile).filename().string() << ">\n";
         std::map<std::string, std::vector<std::string> > filenames = {{"phantom", 	std::vector<std::string>()},  // input:  map of off-resonance in Tesla
                                                                       {"xyz0", 		std::vector<std::string>()},  // input:  spins starting spatial positions in meters
                                                                       {"m0", 		std::vector<std::string>()},  // input:  spins initial magnetization