diff --git a/Modules/Core/include/mitkUIDGenerator.h b/Modules/Core/include/mitkUIDGenerator.h
index 12ee711313..0b7931f039 100644
--- a/Modules/Core/include/mitkUIDGenerator.h
+++ b/Modules/Core/include/mitkUIDGenerator.h
@@ -1,44 +1,44 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef MITK_UID_GENERATOR_INDCLUDED_FASAWE
 #define MITK_UID_GENERATOR_INDCLUDED_FASAWE
 
 #include <MitkCoreExports.h>
 #include <string>
 
 namespace mitk
 {
   /*!
     \brief Generated unique IDs
 
     Creates unique IDs.
 
     The current implementation uses the UUID specification (https://www.ietf.org/rfc/rfc4122.txt) and
     random generator.
-    One may define a prefix for the UID string. But it is not needed do guarantee uniquness. It is
-    just a human readable addition to see for which e.g. purpose the UID was generated.
+    One may define a prefix for the UID string. But it is not needed to guarantee uniquness. It is
+    just a human readable addition, e.g. to see for which purpose the UID was generated.
   */
   class MITKCORE_EXPORT UIDGenerator
   {
   public:
-    UIDGenerator(const char * prefix = "");
+    explicit UIDGenerator(const char * prefix = "");
 
     /** @return Returns a unique ID as string. You will get another unique ID each time you call GetUID. */
     std::string GetUID();
 
   private:
     std::string m_Prefix;
   };
 } // namespace mitk
 
 #endif
diff --git a/Modules/Core/src/Algorithms/mitkUIDGenerator.cpp b/Modules/Core/src/Algorithms/mitkUIDGenerator.cpp
index d80e10b9db..8cf27eacd2 100644
--- a/Modules/Core/src/Algorithms/mitkUIDGenerator.cpp
+++ b/Modules/Core/src/Algorithms/mitkUIDGenerator.cpp
@@ -1,36 +1,42 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <mitkUIDGenerator.h>
 
 #include <sstream>
 
+#include <mutex>
+
 #include <boost/uuid/uuid.hpp>
 #include <boost/uuid/uuid_io.hpp>
 #include <boost/uuid/uuid_generators.hpp>
 
+boost::uuids::random_generator uuidGen;
+std::mutex uuidGen_mutex;
 
 mitk::UIDGenerator::UIDGenerator(const char *prefix)
   : m_Prefix(prefix)
 {
 }
 
 std::string mitk::UIDGenerator::GetUID()
 {
   std::ostringstream s;
-  auto gen = boost::uuids::random_generator();
-  auto uuid = gen();
 
-  s << m_Prefix << uuid;
+  {
+    std::lock_guard<std::mutex> guard(uuidGen_mutex);
+    auto uuid = uuidGen();
+    s << m_Prefix << uuid;
+  }
 
   return s.str();
 }
diff --git a/Modules/PhotoacousticsLib/MitkPAPhantomGenerator/PAPhantomGenerator.cpp b/Modules/PhotoacousticsLib/MitkPAPhantomGenerator/PAPhantomGenerator.cpp
index bfe738fb41..1f81720dbb 100644
--- a/Modules/PhotoacousticsLib/MitkPAPhantomGenerator/PAPhantomGenerator.cpp
+++ b/Modules/PhotoacousticsLib/MitkPAPhantomGenerator/PAPhantomGenerator.cpp
@@ -1,226 +1,225 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <mitkCommon.h>
 #include <chrono>
 #include <mitkPATissueGeneratorParameters.h>
 #include <mitkPATissueGenerator.h>
 #include <mitkPAPhantomTissueGenerator.h>
 #include <mitkIOUtil.h>
 #include <mitkCommandLineParser.h>
 #include <mitkUIDGenerator.h>
 #include <mitkException.h>
 
 #include <itksys/SystemTools.hxx>
 
 using namespace mitk::pa;
 
 TissueGeneratorParameters::Pointer CreatePhantom_04_04_18_Parameters()
 {
   auto returnParameters = TissueGeneratorParameters::New();
   returnParameters->SetAirThicknessInMillimeters(12);
   returnParameters->SetMinBackgroundAbsorption(0.1);
   returnParameters->SetMaxBackgroundAbsorption(0.1);
   returnParameters->SetBackgroundAnisotropy(0.9);
   returnParameters->SetBackgroundScattering(15);
   returnParameters->SetCalculateNewVesselPositionCallback(&VesselMeanderStrategy::CalculateNewDirectionVectorInStraightLine);
   returnParameters->SetDoPartialVolume(true);
   returnParameters->SetMinNumberOfVessels(1);
   returnParameters->SetMaxNumberOfVessels(8);
   returnParameters->SetMinVesselAbsorption(1);
   returnParameters->SetMaxVesselAbsorption(10);
   returnParameters->SetMinVesselAnisotropy(0.9);
   returnParameters->SetMaxVesselAnisotropy(0.9);
   returnParameters->SetMinVesselBending(0.1);
   returnParameters->SetMaxVesselBending(0.3);
   returnParameters->SetMinVesselRadiusInMillimeters(0.25);
   returnParameters->SetMaxVesselRadiusInMillimeters(4);
   returnParameters->SetMinVesselScattering(15);
   returnParameters->SetMaxVesselScattering(15);
   returnParameters->SetMinVesselZOrigin(1.6);
   returnParameters->SetMaxVesselZOrigin(4);
   returnParameters->SetVesselBifurcationFrequency(5000);
   returnParameters->SetRandomizePhysicalProperties(false);
   returnParameters->SetSkinThicknessInMillimeters(0);
   returnParameters->SetUseRngSeed(false);
   returnParameters->SetVoxelSpacingInCentimeters(0.03);
   returnParameters->SetXDim(140);
   returnParameters->SetYDim(100);
   returnParameters->SetZDim(180);
   //returnParameters->SetVoxelSpacingInCentimeters(0.015);
   //returnParameters->SetXDim(280);
   //returnParameters->SetYDim(200);
   //returnParameters->SetZDim(360);
   returnParameters->SetForceVesselsMoveAlongYDirection(true);
   //returnParameters->SetVoxelSpacingInCentimeters(0.0075);
   //returnParameters->SetXDim(560);
   //returnParameters->SetYDim(400);
   //returnParameters->SetZDim(720);
   return returnParameters;
 }
 
 struct InputParameters
 {
   std::string saveFolderPath;
   std::string identifyer;
   std::string exePath;
   std::string probePath;
   bool empty;
   bool verbose;
 };
 
 InputParameters parseInput(int argc, char* argv[])
 {
   MITK_INFO << "Parsing arguments...";
   mitkCommandLineParser parser;
 
   parser.setCategory("MITK-Photoacoustics");
   parser.setTitle("Mitk Tissue Batch Generator");
   parser.setDescription("Creates in silico tissue in batch processing and automatically calculates fluence values for the central slice of the volume.");
   parser.setContributor("Computer Assisted Medical Interventions, DKFZ");
 
   parser.setArgumentPrefix("--", "-");
 
   parser.beginGroup("Required parameters");
   parser.addArgument(
     "savePath", "s", mitkCommandLineParser::Directory,
     "Input save folder (directory)", "input save folder",
     us::Any(), false, false, false, mitkCommandLineParser::Input);
   parser.addArgument(
     "mitkMcxyz", "m", mitkCommandLineParser::File,
     "MitkMcxyz binary (file)", "path to the MitkMcxyz binary",
     us::Any(), false, false, false, mitkCommandLineParser::Output);
   parser.endGroup();
 
   parser.beginGroup("Optional parameters");
   parser.addArgument(
     "probe", "p", mitkCommandLineParser::File,
     "xml probe file (file)", "file to the definition of the used probe (*.xml)",
     us::Any(), true, false, false, mitkCommandLineParser::Output);
   parser.addArgument(
     "verbose", "v", mitkCommandLineParser::Bool,
     "Verbose Output", "Whether to produce verbose, or rather debug output");
   parser.addArgument(
     "identifyer", "i", mitkCommandLineParser::String,
     "Generator identifyer (string)", "A unique identifyer for the calculation instance");
   parser.addArgument(
     "empty-volume", "e", mitkCommandLineParser::Bool,
     "omit vessel structures (boolean flag)", "Whether to create an empty volume with no structures inside.");
   parser.endGroup();
 
   InputParameters input;
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size() == 0)
     exit(-1);
 
   if (parsedArgs.count("empty-volume"))
   {
     input.empty = us::any_cast<bool>(parsedArgs["empty-volume"]);
   }
   else
   {
     input.empty = false;
   }
 
   if (parsedArgs.count("verbose"))
   {
     input.verbose = us::any_cast<bool>(parsedArgs["verbose"]);
   }
   else
   {
     input.verbose = false;
   }
 
   if (parsedArgs.count("savePath"))
   {
     input.saveFolderPath = us::any_cast<std::string>(parsedArgs["savePath"]);
   }
 
   if (parsedArgs.count("mitkMcxyz"))
   {
     input.exePath = us::any_cast<std::string>(parsedArgs["mitkMcxyz"]);
   }
 
   if (parsedArgs.count("probe"))
   {
     input.probePath = us::any_cast<std::string>(parsedArgs["probe"]);
   }
 
   if (parsedArgs.count("identifyer"))
   {
     input.identifyer = us::any_cast<std::string>(parsedArgs["identifyer"]);
   }
   else
   {
-    auto uid = mitk::UIDGenerator("");
-    input.identifyer = uid.GetUID();
+    input.identifyer = mitk::UIDGenerator().GetUID();
   }
   MITK_INFO << "Parsing arguments...[Done]";
   return input;
 }
 
 int main(int argc, char * argv[])
 {
   auto input = parseInput(argc, argv);
   auto parameters = CreatePhantom_04_04_18_Parameters();
   if (input.empty)
   {
     parameters->SetMaxNumberOfVessels(0);
     parameters->SetMinNumberOfVessels(0);
   }
   MITK_INFO(input.verbose) << "Generating tissue..";
   auto resultTissue = InSilicoTissueGenerator::GenerateInSilicoData(parameters);
   MITK_INFO(input.verbose) << "Generating tissue..[Done]";
 
   auto inputfolder = std::string(input.saveFolderPath + "input/");
   auto outputfolder = std::string(input.saveFolderPath + "output/");
   if (!itksys::SystemTools::FileIsDirectory(inputfolder))
   {
     itksys::SystemTools::MakeDirectory(inputfolder);
   }
   if (!itksys::SystemTools::FileIsDirectory(outputfolder))
   {
     itksys::SystemTools::MakeDirectory(outputfolder);
   }
 
   std::string savePath = input.saveFolderPath + "input/Phantom_" + input.identifyer +
     ".nrrd";
   mitk::IOUtil::Save(resultTissue->ConvertToMitkImage(), savePath);
   std::string outputPath = input.saveFolderPath + "output/Phantom_" + input.identifyer +
     "/";
 
   resultTissue = nullptr;
 
   if (!itksys::SystemTools::FileIsDirectory(outputPath))
   {
     itksys::SystemTools::MakeDirectory(outputPath);
   }
 
   outputPath = outputPath + "Fluence_Phantom_" + input.identifyer;
 
   MITK_INFO(input.verbose) << "Simulating fluence..";
 
   int result = -4;
 
   std::string cmdString = std::string(input.exePath + " -i " + savePath + " -o " +
     (outputPath + ".nrrd") +
     " -yo " + "0" + " -p " + input.probePath +
     " -n 10000000");
 
   MITK_INFO << "Executing: " << cmdString;
 
   result = std::system(cmdString.c_str());
 
   MITK_INFO << result;
   MITK_INFO(input.verbose) << "Simulating fluence..[Done]";
 }
diff --git a/Modules/PhotoacousticsLib/MitkTissueBatchGenerator/TissueBatchGenerator.cpp b/Modules/PhotoacousticsLib/MitkTissueBatchGenerator/TissueBatchGenerator.cpp
index 943441e1f0..7f2237754d 100644
--- a/Modules/PhotoacousticsLib/MitkTissueBatchGenerator/TissueBatchGenerator.cpp
+++ b/Modules/PhotoacousticsLib/MitkTissueBatchGenerator/TissueBatchGenerator.cpp
@@ -1,390 +1,389 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <mitkCommon.h>
 #include <chrono>
 #include <mitkPATissueGeneratorParameters.h>
 #include <mitkPATissueGenerator.h>
 #include <mitkIOUtil.h>
 #include <mitkCommandLineParser.h>
 #include <mitkUIDGenerator.h>
 #include <mitkException.h>
 
 #include <itksys/SystemTools.hxx>
 
 using namespace mitk::pa;
 
 TissueGeneratorParameters::Pointer CreateMultiHB_13_02_18_Parameters()
 {
   auto returnParameters = TissueGeneratorParameters::New();
   returnParameters->SetAirThicknessInMillimeters(1.8);
   returnParameters->SetMinBackgroundAbsorption(0.001);
   returnParameters->SetMaxBackgroundAbsorption(0.2);
   returnParameters->SetBackgroundAnisotropy(0.9);
   returnParameters->SetBackgroundScattering(15);
   returnParameters->SetCalculateNewVesselPositionCallback(&VesselMeanderStrategy::CalculateNewRandomlyDivergingDirectionVector);
   returnParameters->SetDoPartialVolume(true);
   returnParameters->SetMinNumberOfVessels(1);
   returnParameters->SetMaxNumberOfVessels(7);
   returnParameters->SetMinVesselAbsorption(1);
   returnParameters->SetMaxVesselAbsorption(12);
   returnParameters->SetMinVesselAnisotropy(0.9);
   returnParameters->SetMaxVesselAnisotropy(0.9);
   returnParameters->SetMinVesselBending(0);
   returnParameters->SetMaxVesselBending(0.2);
   returnParameters->SetMinVesselRadiusInMillimeters(0.5);
   returnParameters->SetMaxVesselRadiusInMillimeters(6);
   returnParameters->SetMinVesselScattering(15);
   returnParameters->SetMaxVesselScattering(15);
   returnParameters->SetMinVesselZOrigin(1);
   returnParameters->SetMaxVesselZOrigin(3);
   returnParameters->SetVesselBifurcationFrequency(5000);
   returnParameters->SetRandomizePhysicalProperties(false);
   returnParameters->SetSkinThicknessInMillimeters(0);
   returnParameters->SetUseRngSeed(false);
   returnParameters->SetVoxelSpacingInCentimeters(0.06);
   returnParameters->SetXDim(70);
   returnParameters->SetYDim(100);
   returnParameters->SetZDim(100);
   returnParameters->SetMCflag(4);
   return returnParameters;
 }
 
 TissueGeneratorParameters::Pointer CreateBaselineHB_13_02_18_Parameters()
 {
   auto returnParameters = TissueGeneratorParameters::New();
   returnParameters->SetAirThicknessInMillimeters(1.8);
   returnParameters->SetMinBackgroundAbsorption(0.001);
   returnParameters->SetMaxBackgroundAbsorption(0.2);
   returnParameters->SetBackgroundAnisotropy(0.9);
   returnParameters->SetBackgroundScattering(15);
   returnParameters->SetCalculateNewVesselPositionCallback(&VesselMeanderStrategy::CalculateNewRandomlyDivergingDirectionVector);
   returnParameters->SetDoPartialVolume(true);
   returnParameters->SetMinNumberOfVessels(1);
   returnParameters->SetMaxNumberOfVessels(1);
   returnParameters->SetMinVesselAbsorption(4.73);
   returnParameters->SetMaxVesselAbsorption(4.73);
   returnParameters->SetMinVesselAnisotropy(0.9);
   returnParameters->SetMaxVesselAnisotropy(0.9);
   returnParameters->SetMinVesselBending(0);
   returnParameters->SetMaxVesselBending(0.2);
   returnParameters->SetMinVesselRadiusInMillimeters(3);
   returnParameters->SetMaxVesselRadiusInMillimeters(3);
   returnParameters->SetMinVesselScattering(15);
   returnParameters->SetMaxVesselScattering(15);
   returnParameters->SetMinVesselZOrigin(1);
   returnParameters->SetMaxVesselZOrigin(3);
   returnParameters->SetVesselBifurcationFrequency(5000);
   returnParameters->SetRandomizePhysicalProperties(false);
   returnParameters->SetSkinThicknessInMillimeters(0);
   returnParameters->SetUseRngSeed(false);
   returnParameters->SetVoxelSpacingInCentimeters(0.06);
   returnParameters->SetXDim(70);
   returnParameters->SetYDim(100);
   returnParameters->SetZDim(100);
   returnParameters->SetMCflag(4);
   return returnParameters;
 }
 
 TissueGeneratorParameters::Pointer CreateSingleVesselHeterogeneousBackground_08_02_18_Parameters()
 {
   auto returnParameters = TissueGeneratorParameters::New();
   returnParameters->SetAirThicknessInMillimeters(1.8);
   returnParameters->SetMinBackgroundAbsorption(0.001);
   returnParameters->SetMaxBackgroundAbsorption(0.2);
   returnParameters->SetBackgroundAnisotropy(0.9);
   returnParameters->SetBackgroundScattering(15);
   returnParameters->SetCalculateNewVesselPositionCallback(&VesselMeanderStrategy::CalculateNewRandomlyDivergingDirectionVector);
   returnParameters->SetDoPartialVolume(true);
   returnParameters->SetMinNumberOfVessels(1);
   returnParameters->SetMaxNumberOfVessels(1);
   returnParameters->SetMinVesselAbsorption(1);
   returnParameters->SetMaxVesselAbsorption(12);
   returnParameters->SetMinVesselAnisotropy(0.9);
   returnParameters->SetMaxVesselAnisotropy(0.9);
   returnParameters->SetMinVesselBending(0);
   returnParameters->SetMaxVesselBending(0.2);
   returnParameters->SetMinVesselRadiusInMillimeters(0.5);
   returnParameters->SetMaxVesselRadiusInMillimeters(6);
   returnParameters->SetMinVesselScattering(15);
   returnParameters->SetMaxVesselScattering(15);
   returnParameters->SetMinVesselZOrigin(1);
   returnParameters->SetMaxVesselZOrigin(3);
   returnParameters->SetVesselBifurcationFrequency(5000);
   returnParameters->SetRandomizePhysicalProperties(false);
   returnParameters->SetSkinThicknessInMillimeters(0);
   returnParameters->SetUseRngSeed(false);
   returnParameters->SetVoxelSpacingInCentimeters(0.06);
   returnParameters->SetXDim(70);
   returnParameters->SetYDim(100);
   returnParameters->SetZDim(100);
   returnParameters->SetMCflag(4);
   return returnParameters;
 }
 
 TissueGeneratorParameters::Pointer CreateMultivessel_19_12_17_Parameters()
 {
   auto returnParameters = TissueGeneratorParameters::New();
   returnParameters->SetAirThicknessInMillimeters(12);
   returnParameters->SetMinBackgroundAbsorption(0.1);
   returnParameters->SetMaxBackgroundAbsorption(0.1);
   returnParameters->SetBackgroundAnisotropy(0.9);
   returnParameters->SetBackgroundScattering(15);
   returnParameters->SetCalculateNewVesselPositionCallback(&VesselMeanderStrategy::CalculateNewRandomlyDivergingDirectionVector);
   returnParameters->SetDoPartialVolume(true);
   returnParameters->SetMinNumberOfVessels(1);
   returnParameters->SetMaxNumberOfVessels(7);
   returnParameters->SetMinVesselAbsorption(2);
   returnParameters->SetMaxVesselAbsorption(8);
   returnParameters->SetMinVesselAnisotropy(0.9);
   returnParameters->SetMaxVesselAnisotropy(0.9);
   returnParameters->SetMinVesselBending(0.1);
   returnParameters->SetMaxVesselBending(0.3);
   returnParameters->SetMinVesselRadiusInMillimeters(0.5);
   returnParameters->SetMaxVesselRadiusInMillimeters(4);
   returnParameters->SetMinVesselScattering(15);
   returnParameters->SetMaxVesselScattering(15);
   returnParameters->SetMinVesselZOrigin(2.2);
   returnParameters->SetMaxVesselZOrigin(4);
   returnParameters->SetVesselBifurcationFrequency(5000);
   returnParameters->SetRandomizePhysicalProperties(false);
   returnParameters->SetSkinThicknessInMillimeters(0);
   returnParameters->SetUseRngSeed(false);
   returnParameters->SetVoxelSpacingInCentimeters(0.06);
   returnParameters->SetXDim(70);
   returnParameters->SetYDim(100);
   returnParameters->SetZDim(100);
   return returnParameters;
 }
 
 TissueGeneratorParameters::Pointer CreateMultivessel_19_10_17_Parameters()
 {
   auto returnParameters = TissueGeneratorParameters::New();
   returnParameters->SetAirThicknessInMillimeters(12);
   returnParameters->SetMinBackgroundAbsorption(0.1);
   returnParameters->SetMaxBackgroundAbsorption(0.1);
   returnParameters->SetBackgroundAnisotropy(0.9);
   returnParameters->SetBackgroundScattering(15);
   returnParameters->SetCalculateNewVesselPositionCallback(&VesselMeanderStrategy::CalculateNewRandomlyDivergingDirectionVector);
   returnParameters->SetDoPartialVolume(true);
   returnParameters->SetMinNumberOfVessels(1);
   returnParameters->SetMaxNumberOfVessels(7);
   returnParameters->SetMinVesselAbsorption(2);
   returnParameters->SetMaxVesselAbsorption(8);
   returnParameters->SetMinVesselAnisotropy(0.9);
   returnParameters->SetMaxVesselAnisotropy(0.9);
   returnParameters->SetMinVesselBending(0.1);
   returnParameters->SetMaxVesselBending(0.3);
   returnParameters->SetMinVesselRadiusInMillimeters(0.5);
   returnParameters->SetMaxVesselRadiusInMillimeters(4);
   returnParameters->SetMinVesselScattering(15);
   returnParameters->SetMaxVesselScattering(15);
   returnParameters->SetMinVesselZOrigin(2.2);
   returnParameters->SetMaxVesselZOrigin(4);
   returnParameters->SetVesselBifurcationFrequency(5000);
   returnParameters->SetRandomizePhysicalProperties(false);
   returnParameters->SetSkinThicknessInMillimeters(0);
   returnParameters->SetUseRngSeed(false);
   returnParameters->SetVoxelSpacingInCentimeters(0.03);
   returnParameters->SetXDim(140);
   returnParameters->SetYDim(200);
   returnParameters->SetZDim(180);
   return returnParameters;
 }
 
 TissueGeneratorParameters::Pointer CreateSinglevessel_19_10_17_Parameters()
 {
   auto returnParameters = TissueGeneratorParameters::New();
   returnParameters->SetAirThicknessInMillimeters(12);
   returnParameters->SetMinBackgroundAbsorption(0.1);
   returnParameters->SetMaxBackgroundAbsorption(0.1);
   returnParameters->SetBackgroundAnisotropy(0.9);
   returnParameters->SetBackgroundScattering(15);
   returnParameters->SetCalculateNewVesselPositionCallback(&VesselMeanderStrategy::CalculateNewRandomlyDivergingDirectionVector);
   returnParameters->SetDoPartialVolume(true);
   returnParameters->SetMinNumberOfVessels(1);
   returnParameters->SetMaxNumberOfVessels(1);
   returnParameters->SetMinVesselAbsorption(2);
   returnParameters->SetMaxVesselAbsorption(8);
   returnParameters->SetMinVesselAnisotropy(0.9);
   returnParameters->SetMaxVesselAnisotropy(0.9);
   returnParameters->SetMinVesselBending(0.1);
   returnParameters->SetMaxVesselBending(0.3);
   returnParameters->SetMinVesselRadiusInMillimeters(0.5);
   returnParameters->SetMaxVesselRadiusInMillimeters(4);
   returnParameters->SetMinVesselScattering(15);
   returnParameters->SetMaxVesselScattering(15);
   returnParameters->SetMinVesselZOrigin(2.2);
   returnParameters->SetMaxVesselZOrigin(4);
   returnParameters->SetVesselBifurcationFrequency(5000);
   returnParameters->SetRandomizePhysicalProperties(false);
   returnParameters->SetSkinThicknessInMillimeters(0);
   returnParameters->SetUseRngSeed(false);
   returnParameters->SetVoxelSpacingInCentimeters(0.03);
   returnParameters->SetXDim(140);
   returnParameters->SetYDim(200);
   returnParameters->SetZDim(180);
   return returnParameters;
 }
 
 struct InputParameters
 {
   std::string saveFolderPath;
   std::string identifyer;
   std::string exePath;
   std::string probePath;
   bool verbose;
 };
 
 InputParameters parseInput(int argc, char* argv[])
 {
   MITK_INFO << "Paring arguments...";
   mitkCommandLineParser parser;
   // set general information
   parser.setCategory("MITK-Photoacoustics");
   parser.setTitle("Mitk Tissue Batch Generator");
   parser.setDescription("Creates in silico tissue in batch processing and automatically calculates fluence values for the central slice of the volume.");
   parser.setContributor("Computer Assisted Medical Interventions, DKFZ");
 
   // how should arguments be prefixed
   parser.setArgumentPrefix("--", "-");
   // add each argument, unless specified otherwise each argument is optional
   // see mitkCommandLineParser::addArgument for more information
   parser.beginGroup("Required parameters");
   parser.addArgument(
     "savePath", "s", mitkCommandLineParser::Directory,
     "Input save folder (directory)", "input save folder",
     us::Any(), false, false, false, mitkCommandLineParser::Input);
   parser.addArgument(
     "mitkMcxyz", "m", mitkCommandLineParser::File,
     "MitkMcxyz binary (file)", "path to the MitkMcxyz binary",
     us::Any(), false, false, false, mitkCommandLineParser::Output);
   parser.endGroup();
   parser.beginGroup("Optional parameters");
   parser.addArgument(
     "probe", "p", mitkCommandLineParser::File,
     "xml probe file (file)", "file to the definition of the used probe (*.xml)",
     us::Any(), true, false, false, mitkCommandLineParser::Output);
   parser.addArgument(
     "verbose", "v", mitkCommandLineParser::Bool,
     "Verbose Output", "Whether to produce verbose, or rather debug output");
   parser.addArgument(
     "identifyer", "i", mitkCommandLineParser::String,
     "Generator identifyer (string)", "A unique identifyer for the calculation instance");
 
   InputParameters input;
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size() == 0)
     exit(-1);
 
   if (parsedArgs.count("verbose"))
   {
     MITK_INFO << "verbose";
     input.verbose = us::any_cast<bool>(parsedArgs["verbose"]);
   }
   else
   {
     input.verbose = false;
   }
 
   if (parsedArgs.count("savePath"))
   {
     MITK_INFO << "savePath";
     input.saveFolderPath = us::any_cast<std::string>(parsedArgs["savePath"]);
   }
 
   if (parsedArgs.count("mitkMcxyz"))
   {
     MITK_INFO << "mitkMcxyz";
     input.exePath = us::any_cast<std::string>(parsedArgs["mitkMcxyz"]);
   }
 
   if (parsedArgs.count("probe"))
   {
     MITK_INFO << "probe";
     input.probePath = us::any_cast<std::string>(parsedArgs["probe"]);
   }
 
   if (parsedArgs.count("identifyer"))
   {
     MITK_INFO << "identifyer";
     input.identifyer = us::any_cast<std::string>(parsedArgs["identifyer"]);
   }
   else
   {
     MITK_INFO << "generating identifyer";
-    auto uid = mitk::UIDGenerator("");
-    input.identifyer = uid.GetUID();
+    input.identifyer = mitk::UIDGenerator().GetUID();
   }
   MITK_INFO << "Paring arguments...[Done]";
   return input;
 }
 
 int main(int argc, char * argv[])
 {
   auto input = parseInput(argc, argv);
   unsigned int iterationNumber = 0;
 
   while (true)
   {
     auto parameters = CreateBaselineHB_13_02_18_Parameters();
     MITK_INFO(input.verbose) << "Generating tissue..";
     auto resultTissue = InSilicoTissueGenerator::GenerateInSilicoData(parameters);
     MITK_INFO(input.verbose) << "Generating tissue..[Done]";
 
     auto inputfolder = std::string(input.saveFolderPath + "input/");
     auto outputfolder = std::string(input.saveFolderPath + "output/");
     if (!itksys::SystemTools::FileIsDirectory(inputfolder))
     {
       itksys::SystemTools::MakeDirectory(inputfolder);
     }
     if (!itksys::SystemTools::FileIsDirectory(outputfolder))
     {
       itksys::SystemTools::MakeDirectory(outputfolder);
     }
 
     std::string savePath = input.saveFolderPath + "input/BaselineHB_" + input.identifyer +
             "_" + std::to_string(iterationNumber) + ".nrrd";
     mitk::IOUtil::Save(resultTissue->ConvertToMitkImage(), savePath);
     std::string outputPath = input.saveFolderPath + "output/BaselineHB_" + input.identifyer +
             "_" + std::to_string(iterationNumber) + "/";
 
     if (!itksys::SystemTools::FileIsDirectory(outputPath))
     {
       itksys::SystemTools::MakeDirectory(outputPath);
     }
 
     outputPath = outputPath + "Fluence_BaselineHB_" + input.identifyer + "_" + std::to_string(iterationNumber);
 
     MITK_INFO(input.verbose) << "Simulating fluence..";
     for(double yo = -1.8; yo <= 1.81; yo=yo+0.12)
     {
         std::string yo_string = std::to_string(round(yo*100)/100.0);
         int result = -4;
         if(!input.probePath.empty())
             result = std::system(std::string(input.exePath + " -i " + savePath + " -o " +
                                              (outputPath + "_yo" + yo_string + ".nrrd") +
                                              " -yo " + yo_string + " -p " + input.probePath +
                                              " -n 100000000").c_str());
         else
             result = std::system(std::string(input.exePath + " -i " + savePath + " -o " +
                                              (outputPath + "_yo" + yo_string + ".nrrd") +
                                              " -yo " + yo_string + " -n 100000000").c_str());
         MITK_INFO << "yo: " << yo_string << ": " << result;
     }
 
     MITK_INFO(input.verbose) << "Simulating fluence..[Done]";
 
     iterationNumber++;
   }
 }