diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxAddArtifactsToDwiTest.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxAddArtifactsToDwiTest.cpp
index 91af9d4829..b0afe6cc25 100644
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxAddArtifactsToDwiTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxAddArtifactsToDwiTest.cpp
@@ -1,216 +1,216 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <mitkTestingMacros.h>
 #include <mitkIOUtil.h>
 #include <mitkFiberTrackingObjectFactory.h>
 #include <mitkDiffusionCoreObjectFactory.h>
 #include <mitkFiberBundleX.h>
 #include <itkAddArtifactsToDwiImageFilter.h>
 #include <mitkFiberfoxParameters.h>
 #include <mitkFiberBundleXReader.h>
 #include <mitkStickModel.h>
 #include <mitkTensorModel.h>
 #include <mitkBallModel.h>
 #include <mitkDotModel.h>
 #include <mitkAstroStickModel.h>
 #include <mitkDiffusionImage.h>
 #include <mitkNrrdDiffusionImageWriter.h>
 #include <itkTestingComparisonImageFilter.h>
 #include <itkImageRegionConstIterator.h>
 #include <mitkRicianNoiseModel.h>
 #include <mitkChiSquareNoiseModel.h>
 #include <mitkTestFixture.h>
 
 /**Documentation
- *
+ * Test the Fiberfox simulation functions (diffusion weighted image -> diffusion weighted image)
  */
 class mitkFiberfoxAddArtifactsToDwiTestSuite : public mitk::TestFixture
 {
 
     CPPUNIT_TEST_SUITE(mitkFiberfoxAddArtifactsToDwiTestSuite);
     MITK_TEST(Spikes);
     MITK_TEST(GibbsRinging);
     MITK_TEST(Ghost);
     MITK_TEST(Aliasing);
     MITK_TEST(Eddy);
     MITK_TEST(RicianNoise);
     MITK_TEST(ChiSquareNoise);
     MITK_TEST(Distortions);
     CPPUNIT_TEST_SUITE_END();
 
 private:
 
     mitk::DiffusionImage<short>::Pointer m_InputDwi;
     FiberfoxParameters m_Parameters;
 
 public:
 
     void setUp()
     {
         RegisterDiffusionCoreObjectFactory();
 
         // reference files
         m_InputDwi = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(GetTestDataFilePath("DiffusionImaging/Fiberfox/StickBall_RELAX.dwi"))->GetData());
 
         // parameter setup
         m_Parameters = FiberfoxParameters();
         m_Parameters.m_ImageRegion = m_InputDwi->GetVectorImage()->GetLargestPossibleRegion();
         m_Parameters.m_ImageSpacing = m_InputDwi->GetVectorImage()->GetSpacing();
         m_Parameters.m_ImageOrigin = m_InputDwi->GetVectorImage()->GetOrigin();
         m_Parameters.m_ImageDirection = m_InputDwi->GetVectorImage()->GetDirection();
         m_Parameters.m_Bvalue = m_InputDwi->GetB_Value();
         mitk::DiffusionImage<short>::GradientDirectionContainerType::Pointer dirs = m_InputDwi->GetDirections();
         m_Parameters.m_NumGradients = 0;
         for (unsigned int i=0; i<dirs->Size(); i++)
         {
             DiffusionSignalModel<double>::GradientType g;
             g[0] = dirs->at(i)[0];
             g[1] = dirs->at(i)[1];
             g[2] = dirs->at(i)[2];
             m_Parameters.m_GradientDirections.push_back(g);
             if (dirs->at(i).magnitude()>0.0001)
                 m_Parameters.m_NumGradients++;
         }
     }
 
     bool CompareDwi(itk::VectorImage< short, 3 >* dwi1, itk::VectorImage< short, 3 >* dwi2)
     {
         typedef itk::VectorImage< short, 3 > DwiImageType;
         try{
             itk::ImageRegionIterator< DwiImageType > it1(dwi1, dwi1->GetLargestPossibleRegion());
             itk::ImageRegionIterator< DwiImageType > it2(dwi2, dwi2->GetLargestPossibleRegion());
             while(!it1.IsAtEnd())
             {
                 if (it1.Get()!=it2.Get())
                     return false;
                 ++it1;
                 ++it2;
             }
         }
         catch(...)
         {
             return false;
         }
         return true;
     }
 
     void StartSimulation(string testFileName)
     {
         mitk::DiffusionImage<short>::Pointer refImage = NULL;
         if (!testFileName.empty())
             CPPUNIT_ASSERT(refImage = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(testFileName)->GetData()));
 
         itk::AddArtifactsToDwiImageFilter< short >::Pointer artifactsToDwiFilter = itk::AddArtifactsToDwiImageFilter< short >::New();
         artifactsToDwiFilter->SetUseConstantRandSeed(true);
         artifactsToDwiFilter->SetInput(m_InputDwi->GetVectorImage());
         artifactsToDwiFilter->SettLine(m_Parameters.m_tLine);
         artifactsToDwiFilter->SetkOffset(m_Parameters.m_KspaceLineOffset);
         artifactsToDwiFilter->SetNoiseModel(m_Parameters.m_NoiseModelShort);
         artifactsToDwiFilter->SetGradientList(m_Parameters.m_GradientDirections);
         artifactsToDwiFilter->SetTE(m_Parameters.m_tEcho);
         artifactsToDwiFilter->SetSimulateEddyCurrents(m_Parameters.m_DoSimulateEddyCurrents);
         artifactsToDwiFilter->SetEddyGradientStrength(m_Parameters.m_EddyStrength);
         artifactsToDwiFilter->SetAddGibbsRinging(m_Parameters.m_AddGibbsRinging);
         artifactsToDwiFilter->SetFrequencyMap(m_Parameters.m_FrequencyMap);
         artifactsToDwiFilter->SetSpikeAmplitude(m_Parameters.m_SpikeAmplitude);
         artifactsToDwiFilter->SetSpikes(m_Parameters.m_Spikes);
         artifactsToDwiFilter->SetWrap(m_Parameters.m_Wrap);
         CPPUNIT_ASSERT_NO_THROW(artifactsToDwiFilter->Update());
 
         mitk::DiffusionImage<short>::Pointer testImage = mitk::DiffusionImage<short>::New();
         testImage->SetVectorImage( artifactsToDwiFilter->GetOutput() );
         testImage->SetB_Value(m_Parameters.m_Bvalue);
         testImage->SetDirections(m_Parameters.m_GradientDirections);
         testImage->InitializeFromVectorImage();
 
         if (refImage.IsNotNull())
         {
             CPPUNIT_ASSERT_MESSAGE(testFileName, CompareDwi(testImage->GetVectorImage(), refImage->GetVectorImage()));
         }
         else
         {
             NrrdDiffusionImageWriter<short>::Pointer writer = NrrdDiffusionImageWriter<short>::New();
             writer->SetFileName("/local/distortions2.dwi");
             writer->SetInput(testImage);
             writer->Update();
         }
     }
 
     void Spikes()
     {
         m_Parameters.m_Spikes = 5;
         m_Parameters.m_SpikeAmplitude = 1;
         StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/spikes2.dwi") );
     }
 
     void GibbsRinging()
     {
         m_Parameters.m_AddGibbsRinging = true;
         StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/gibbsringing2.dwi") );
     }
 
     void Ghost()
     {
         m_Parameters.m_KspaceLineOffset = 0.25;
         StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/ghost2.dwi") );
     }
 
     void Aliasing()
     {
         m_Parameters.m_Wrap = 0.4;
         StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/aliasing2.dwi") );
     }
 
     void Eddy()
     {
         m_Parameters.m_DoSimulateEddyCurrents = true;
         m_Parameters.m_EddyStrength = 0.05;
         StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/eddy2.dwi") );
     }
 
     void RicianNoise()
     {
         mitk::RicianNoiseModel<double>* ricianNoiseModel = new mitk::RicianNoiseModel<double>();
         ricianNoiseModel->SetNoiseVariance(1000000);
         ricianNoiseModel->SetSeed(0);
         m_Parameters.m_NoiseModel = ricianNoiseModel;
         StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/riciannoise2.dwi") );
         delete m_Parameters.m_NoiseModel;
     }
 
     void ChiSquareNoise()
     {
         mitk::ChiSquareNoiseModel<double>* chiSquareNoiseModel = new mitk::ChiSquareNoiseModel<double>();
         chiSquareNoiseModel->SetDOF(500000);
         chiSquareNoiseModel->SetSeed(0);
         m_Parameters.m_NoiseModel = chiSquareNoiseModel;
         StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/chisquarenoise2.dwi") );
         delete m_Parameters.m_NoiseModel;
     }
 
     void Distortions()
     {
         mitk::Image::Pointer mitkFMap = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode( GetTestDataFilePath("DiffusionImaging/Fiberfox/Fieldmap.nrrd") )->GetData());
         typedef itk::Image<double, 3> ItkDoubleImgType;
         ItkDoubleImgType::Pointer fMap = ItkDoubleImgType::New();
         mitk::CastToItkImage<ItkDoubleImgType>(mitkFMap, fMap);
         m_Parameters.m_FrequencyMap = fMap;
         StartSimulation( GetTestDataFilePath("DiffusionImaging/Fiberfox/distortions2.dwi") );
     }
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkFiberfoxAddArtifactsToDwi)
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxSignalGenerationTest.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxSignalGenerationTest.cpp
index 68305c8537..a6628b1bf8 100644
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxSignalGenerationTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberfoxSignalGenerationTest.cpp
@@ -1,327 +1,325 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <mitkTestingMacros.h>
 #include <mitkIOUtil.h>
 #include <mitkFiberTrackingObjectFactory.h>
 #include <mitkDiffusionCoreObjectFactory.h>
 #include <mitkFiberBundleX.h>
 #include <itkTractsToDWIImageFilter.h>
 #include <mitkFiberfoxParameters.h>
 #include <mitkFiberBundleXReader.h>
 #include <mitkStickModel.h>
 #include <mitkTensorModel.h>
 #include <mitkBallModel.h>
 #include <mitkDotModel.h>
 #include <mitkAstroStickModel.h>
 #include <mitkDiffusionImage.h>
 #include <mitkNrrdDiffusionImageWriter.h>
 #include <itkTestingComparisonImageFilter.h>
 #include <itkImageRegionConstIterator.h>
 #include <mitkRicianNoiseModel.h>
 #include <mitkChiSquareNoiseModel.h>
 
 /**Documentation
- *
+ * Test the Fiberfox simulation functions (fiberBundle -> diffusion weighted image)
  */
-
-
 bool CompareDwi(itk::VectorImage< short, 3 >* dwi1, itk::VectorImage< short, 3 >* dwi2)
 {
     typedef itk::VectorImage< short, 3 > DwiImageType;
     try{
         itk::ImageRegionIterator< DwiImageType > it1(dwi1, dwi1->GetLargestPossibleRegion());
         itk::ImageRegionIterator< DwiImageType > it2(dwi2, dwi2->GetLargestPossibleRegion());
         while(!it1.IsAtEnd())
         {
             if (it1.Get()!=it2.Get())
                 return false;
             ++it1;
             ++it2;
         }
     }
     catch(...)
     {
         return false;
     }
     return true;
 }
 
 void StartSimulation(FiberfoxParameters parameters, FiberBundleX::Pointer fiberBundle, mitk::DiffusionImage<short>::Pointer refImage, string message)
 {
     itk::TractsToDWIImageFilter< short >::Pointer tractsToDwiFilter = itk::TractsToDWIImageFilter< short >::New();
     tractsToDwiFilter->SetUseConstantRandSeed(true);
     tractsToDwiFilter->SetSimulateEddyCurrents(parameters.m_DoSimulateEddyCurrents);
     tractsToDwiFilter->SetEddyGradientStrength(parameters.m_EddyStrength);
     tractsToDwiFilter->SetAddGibbsRinging(parameters.m_AddGibbsRinging);
     tractsToDwiFilter->SetSimulateRelaxation(parameters.m_DoSimulateRelaxation);
     tractsToDwiFilter->SetImageRegion(parameters.m_ImageRegion);
     tractsToDwiFilter->SetSpacing(parameters.m_ImageSpacing);
     tractsToDwiFilter->SetOrigin(parameters.m_ImageOrigin);
     tractsToDwiFilter->SetDirectionMatrix(parameters.m_ImageDirection);
     tractsToDwiFilter->SetFiberBundle(fiberBundle);
     tractsToDwiFilter->SetFiberModels(parameters.m_FiberModelList);
     tractsToDwiFilter->SetNonFiberModels(parameters.m_NonFiberModelList);
     tractsToDwiFilter->SetNoiseModel(parameters.m_NoiseModel);
     tractsToDwiFilter->SetkOffset(parameters.m_KspaceLineOffset);
     tractsToDwiFilter->SettLine(parameters.m_tLine);
     tractsToDwiFilter->SettInhom(parameters.m_tInhom);
     tractsToDwiFilter->SetTE(parameters.m_tEcho);
     tractsToDwiFilter->SetNumberOfRepetitions(parameters.m_Repetitions);
     tractsToDwiFilter->SetEnforcePureFiberVoxels(parameters.m_DoDisablePartialVolume);
     tractsToDwiFilter->SetInterpolationShrink(parameters.m_InterpolationShrink);
     tractsToDwiFilter->SetFiberRadius(parameters.m_AxonRadius);
     tractsToDwiFilter->SetSignalScale(parameters.m_SignalScale);
     if (parameters.m_InterpolationShrink>0)
         tractsToDwiFilter->SetUseInterpolation(true);
     tractsToDwiFilter->SetTissueMask(parameters.m_MaskImage);
     tractsToDwiFilter->SetFrequencyMap(parameters.m_FrequencyMap);
     tractsToDwiFilter->SetSpikeAmplitude(parameters.m_SpikeAmplitude);
     tractsToDwiFilter->SetSpikes(parameters.m_Spikes);
     tractsToDwiFilter->SetWrap(parameters.m_Wrap);
     tractsToDwiFilter->SetAddMotionArtifact(parameters.m_DoAddMotion);
     tractsToDwiFilter->SetMaxTranslation(parameters.m_Translation);
     tractsToDwiFilter->SetMaxRotation(parameters.m_Rotation);
     tractsToDwiFilter->SetRandomMotion(parameters.m_RandomMotion);
     tractsToDwiFilter->Update();
 
     mitk::DiffusionImage<short>::Pointer testImage = mitk::DiffusionImage<short>::New();
     testImage->SetVectorImage( tractsToDwiFilter->GetOutput() );
     testImage->SetB_Value(parameters.m_Bvalue);
     testImage->SetDirections(parameters.m_GradientDirections);
     testImage->InitializeFromVectorImage();
 
     if (refImage.IsNotNull())
     {
         MITK_TEST_CONDITION_REQUIRED(CompareDwi(testImage->GetVectorImage(), refImage->GetVectorImage()), message);
     }
     else
     {
         MITK_INFO << "Saving test image to " << message;
         NrrdDiffusionImageWriter<short>::Pointer writer = NrrdDiffusionImageWriter<short>::New();
         writer->SetFileName(message);
         writer->SetInput(testImage);
         writer->Update();
     }
 }
 
 int mitkFiberfoxSignalGenerationTest(int argc, char* argv[])
 {
     RegisterDiffusionCoreObjectFactory();
 
     MITK_TEST_BEGIN("mitkFiberfoxSignalGenerationTest");
 
     MITK_TEST_CONDITION_REQUIRED(argc>=19,"check for input data");
 
     // input fiber bundle
     FiberBundleXReader::Pointer fibReader = FiberBundleXReader::New();
     fibReader->SetFileName(argv[1]);
     fibReader->Update();
     FiberBundleX::Pointer fiberBundle = dynamic_cast<FiberBundleX*>(fibReader->GetOutput());
 
     // reference diffusion weighted images
     mitk::DiffusionImage<short>::Pointer stickBall = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[2])->GetData());
     mitk::DiffusionImage<short>::Pointer stickAstrosticks = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[3])->GetData());
     mitk::DiffusionImage<short>::Pointer stickDot = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[4])->GetData());
     mitk::DiffusionImage<short>::Pointer tensorBall = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[5])->GetData());
     mitk::DiffusionImage<short>::Pointer stickTensorBall = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[6])->GetData());
     mitk::DiffusionImage<short>::Pointer stickTensorBallAstrosticks = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[7])->GetData());
     mitk::DiffusionImage<short>::Pointer gibbsringing = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[8])->GetData());
     mitk::DiffusionImage<short>::Pointer ghost = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[9])->GetData());
     mitk::DiffusionImage<short>::Pointer aliasing = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[10])->GetData());
     mitk::DiffusionImage<short>::Pointer eddy = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[11])->GetData());
     mitk::DiffusionImage<short>::Pointer linearmotion = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[12])->GetData());
     mitk::DiffusionImage<short>::Pointer randommotion = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[13])->GetData());
     mitk::DiffusionImage<short>::Pointer spikes = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[14])->GetData());
     mitk::DiffusionImage<short>::Pointer riciannoise = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[15])->GetData());
     mitk::DiffusionImage<short>::Pointer chisquarenoise = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[16])->GetData());
     mitk::DiffusionImage<short>::Pointer distortions = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[17])->GetData());
     mitk::Image::Pointer mitkFMap = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(argv[18])->GetData());
     typedef itk::Image<double, 3> ItkDoubleImgType;
     ItkDoubleImgType::Pointer fMap = ItkDoubleImgType::New();
     mitk::CastToItkImage<ItkDoubleImgType>(mitkFMap, fMap);
 
     FiberfoxParameters parameters;
     parameters.m_DoSimulateRelaxation = true;
     parameters.m_SignalScale = 10000;
     parameters.m_ImageRegion = stickBall->GetVectorImage()->GetLargestPossibleRegion();
     parameters.m_ImageSpacing = stickBall->GetVectorImage()->GetSpacing();
     parameters.m_ImageOrigin = stickBall->GetVectorImage()->GetOrigin();
     parameters.m_ImageDirection = stickBall->GetVectorImage()->GetDirection();
     parameters.m_Bvalue = stickBall->GetB_Value();
     mitk::DiffusionImage<short>::GradientDirectionContainerType::Pointer dirs = stickBall->GetDirections();
     parameters.m_NumGradients = 0;
     for (unsigned int i=0; i<dirs->Size(); i++)
     {
         DiffusionSignalModel<double>::GradientType g;
         g[0] = dirs->at(i)[0];
         g[1] = dirs->at(i)[1];
         g[2] = dirs->at(i)[2];
         parameters.m_GradientDirections.push_back(g);
         if (dirs->at(i).magnitude()>0.0001)
             parameters.m_NumGradients++;
     }
 
     // intra and inter axonal compartments
     mitk::StickModel<double> stickModel;
     stickModel.SetBvalue(parameters.m_Bvalue);
     stickModel.SetT2(110);
     stickModel.SetDiffusivity(0.001);
     stickModel.SetGradientList(parameters.m_GradientDirections);
 
     mitk::TensorModel<double> tensorModel;
     tensorModel.SetT2(110);
     stickModel.SetBvalue(parameters.m_Bvalue);
     tensorModel.SetDiffusivity1(0.001);
     tensorModel.SetDiffusivity2(0.00025);
     tensorModel.SetDiffusivity3(0.00025);
     tensorModel.SetGradientList(parameters.m_GradientDirections);
 
     // extra axonal compartment models
     mitk::BallModel<double> ballModel;
     ballModel.SetT2(80);
     ballModel.SetBvalue(parameters.m_Bvalue);
     ballModel.SetDiffusivity(0.001);
     ballModel.SetGradientList(parameters.m_GradientDirections);
 
     mitk::AstroStickModel<double> astrosticksModel;
     astrosticksModel.SetT2(80);
     astrosticksModel.SetBvalue(parameters.m_Bvalue);
     astrosticksModel.SetDiffusivity(0.001);
     astrosticksModel.SetRandomizeSticks(true);
     astrosticksModel.SetSeed(0);
     astrosticksModel.SetGradientList(parameters.m_GradientDirections);
 
     mitk::DotModel<double> dotModel;
     dotModel.SetT2(80);
     dotModel.SetGradientList(parameters.m_GradientDirections);
 
     // noise models
     mitk::RicianNoiseModel<double>* ricianNoiseModel = new mitk::RicianNoiseModel<double>();
     ricianNoiseModel->SetNoiseVariance(1000000);
     ricianNoiseModel->SetSeed(0);
 
     // Rician noise
     mitk::ChiSquareNoiseModel<double>* chiSquareNoiseModel = new mitk::ChiSquareNoiseModel<double>();
     chiSquareNoiseModel->SetDOF(500000);
     chiSquareNoiseModel->SetSeed(0);
 
     try{
         // Stick-Ball
         parameters.m_FiberModelList.push_back(&stickModel);
         parameters.m_NonFiberModelList.push_back(&ballModel);
         StartSimulation(parameters, fiberBundle, stickBall, argv[2]);
 
         // Srick-Astrosticks
         parameters.m_NonFiberModelList.clear();
         parameters.m_NonFiberModelList.push_back(&astrosticksModel);
         StartSimulation(parameters, fiberBundle, stickAstrosticks, argv[3]);
 
         // Stick-Dot
         parameters.m_NonFiberModelList.clear();
         parameters.m_NonFiberModelList.push_back(&dotModel);
         StartSimulation(parameters, fiberBundle, stickDot, argv[4]);
 
         // Tensor-Ball
         parameters.m_FiberModelList.clear();
         parameters.m_FiberModelList.push_back(&tensorModel);
         parameters.m_NonFiberModelList.clear();
         parameters.m_NonFiberModelList.push_back(&ballModel);
         StartSimulation(parameters, fiberBundle, tensorBall, argv[5]);
 
         // Stick-Tensor-Ball
         parameters.m_FiberModelList.clear();
         parameters.m_FiberModelList.push_back(&stickModel);
         parameters.m_FiberModelList.push_back(&tensorModel);
         parameters.m_NonFiberModelList.clear();
         parameters.m_NonFiberModelList.push_back(&ballModel);
         StartSimulation(parameters, fiberBundle, stickTensorBall, argv[6]);
 
         // Stick-Tensor-Ball-Astrosticks
         parameters.m_NonFiberModelList.push_back(&astrosticksModel);
         StartSimulation(parameters, fiberBundle, stickTensorBallAstrosticks, argv[7]);
 
         // Gibbs ringing
         parameters.m_FiberModelList.clear();
         parameters.m_FiberModelList.push_back(&stickModel);
         parameters.m_NonFiberModelList.clear();
         parameters.m_NonFiberModelList.push_back(&ballModel);
         parameters.m_AddGibbsRinging = true;
         StartSimulation(parameters, fiberBundle, gibbsringing, argv[8]);
 
         // Ghost
         parameters.m_AddGibbsRinging = false;
         parameters.m_KspaceLineOffset = 0.25;
         StartSimulation(parameters, fiberBundle, ghost, argv[9]);
 
         // Aliasing
         parameters.m_KspaceLineOffset = 0;
         parameters.m_Wrap = 0.4;
         parameters.m_SignalScale = 1000;
         StartSimulation(parameters, fiberBundle, aliasing, argv[10]);
 
         // Eddy currents
         parameters.m_Wrap = 1;
         parameters.m_SignalScale = 10000;
         parameters.m_DoSimulateEddyCurrents = true;
         parameters.m_EddyStrength = 0.05;
         StartSimulation(parameters, fiberBundle, eddy, argv[11]);
 
         // Motion (linear)
         parameters.m_DoSimulateEddyCurrents = false;
         parameters.m_EddyStrength = 0.0;
         parameters.m_DoAddMotion = true;
         parameters.m_RandomMotion = false;
         parameters.m_Translation[1] = 10;
         parameters.m_Rotation[2] = 90;
         StartSimulation(parameters, fiberBundle, linearmotion, argv[12]);
 
         // Motion (random)
         parameters.m_RandomMotion = true;
         parameters.m_Translation[1] = 5;
         parameters.m_Rotation[2] = 45;
         StartSimulation(parameters, fiberBundle, randommotion, argv[13]);
 
         // Spikes
         parameters.m_DoAddMotion = false;
         parameters.m_Spikes = 5;
         parameters.m_SpikeAmplitude = 1;
         StartSimulation(parameters, fiberBundle, spikes, argv[14]);
 
         // Rician noise
         parameters.m_Spikes = 0;
         parameters.m_NoiseModel = ricianNoiseModel;
         StartSimulation(parameters, fiberBundle, riciannoise, argv[15]);
         delete parameters.m_NoiseModel;
 
         // Chi-square noise
         parameters.m_NoiseModel = chiSquareNoiseModel;
         StartSimulation(parameters, fiberBundle, chisquarenoise, argv[16]);
         delete parameters.m_NoiseModel;
 
         // Distortions
         parameters.m_NoiseModel = NULL;
         parameters.m_FrequencyMap = fMap;
         StartSimulation(parameters, fiberBundle, distortions, argv[17]);
     }
     catch (std::exception &e)
     {
         MITK_TEST_CONDITION_REQUIRED(false, e.what());
     }
 
     // always end with this!
     MITK_TEST_END();
 }