diff --git a/apps/ccam/ccam.cpp b/apps/ccam/ccam.cpp
index f177e5b..4b99535 100644
--- a/apps/ccam/ccam.cpp
+++ b/apps/ccam/ccam.cpp
@@ -1,309 +1,326 @@
 //===-- apps/ccam/ccam.cpp --------------------------------------*- C++ -*-===//
 //
 //                 The RoSA Framework -- Application CCAM
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file apps/ccam/ccam.cpp
 ///
 /// \author Maximilian Goetzinger (maximilian.goetzinger@tuwien.ac.at)
 /// \author Benedikt Tutzer (benedikt.tutzer@tuwien.ac.at)
 ///
 /// \date 2019
 ///
 /// \brief The application CCAM implements the case study from the paper:
 /// M. Goetzinger, N. TaheriNejad, H. A. Kholerdi, A. Jantsch, E. Willegger,
 /// T. Glatzl, A.M. Rahmani, T.Sauter, P. Liljeberg: Model - Free Condition
 /// Monitoring with Confidence
 //===----------------------------------------------------------------------===//
 #include "rosa/agent/Abstraction.hpp"
 #include "rosa/agent/Confidence.hpp"
 #include "rosa/agent/FunctionAbstractions.hpp"
 #include <iostream>
 
 #include "rosa/config/version.h"
 
 #include "rosa/agent/SignalStateDetector.hpp"
 #include "rosa/agent/SystemStateDetector.hpp"
 #include "rosa/deluxe/DeluxeContext.hpp"
 
 #include "rosa/support/csv/CSVReader.hpp"
 #include "rosa/support/csv/CSVWriter.hpp"
 
 #include <fstream>
 #include <limits>
 #include <memory>
 #include <streambuf>
 
 #include "configuration.h"
 #include "statehandlerutils.h"
 
 using namespace rosa;
 using namespace rosa::agent;
 using namespace rosa::deluxe;
 using namespace rosa::terminal;
 
 const std::string AppName = "CCAM";
 
 int main(int argc, char **argv) {
 
   // START MAXI TESTING
 
   std::shared_ptr<PartialFunction<float, float>> TestPartFunc(
       new PartialFunction<float, float>(
           {
               {{0.f, 3.f},
                std::make_shared<LinearFunction<float, float>>(0.f, 1.f / 3)},
               {{3.f, 6.f},
                std::make_shared<LinearFunction<float, float>>(1.f, 0.f)},
               {{6.f, 9.f},
                std::make_shared<LinearFunction<float, float>>(3.f, -1.f / 3)},
           },
           0));
 
   std::shared_ptr<StepFunction<float, float>> TestStepFunc(
       new StepFunction<float, float>(1 / 10));
 
   SystemStateDetector<float, float, float, HistoryPolicy::SRWF>
       TestSystemStateDetector(1000, 5, TestPartFunc, TestPartFunc);
   /*
     SignalStateInformation<float> TestSigStateInfo(
         0, SignalProperties::INPUT, 5, 5, 5, TestPartFunc, TestPartFunc,
         TestStepFunc, TestStepFunc, TestPartFunc, TestPartFunc);
   */
   std::vector<SignalStateInformation<float>> testVector;
 
   TestSystemStateDetector.detectSystemState(testVector);
 
   // END MAXI TESTING
 
   LOG_INFO_STREAM << '\n'
                   << library_string() << " -- " << Color::Red << AppName
                   << "app" << Color::Default << '\n';
 
   if (argc < 2) {
     LOG_ERROR("Specify config File!\nUsage:\n\tccam config.json");
     return 1;
   }
   std::string ConfigPath = argv[1];
 
   if (!readConfigFile(ConfigPath)) {
     LOG_ERROR_STREAM << "Could not read config from \"" << ConfigPath << "\"\n";
     return 2;
   }
 
   std::string InputFilePath, OutputFilePath;
 
   LOG_INFO("Creating Context");
   std::unique_ptr<DeluxeContext> C = DeluxeContext::create(AppName);
 
   std::shared_ptr<PartialFunction<uint32_t, float>> BrokenDelayFunction(
       new PartialFunction<uint32_t, float>(
           {{{0, AppConfig.BrokenCounter},
             std::make_shared<LinearFunction<uint32_t, float>>(
                 0, 0.f, AppConfig.BrokenCounter, 1.f)},
            {{AppConfig.BrokenCounter, std::numeric_limits<uint32_t>::max()},
             std::make_shared<LinearFunction<uint32_t, float>>(1.f, 0.f)}},
           0.f));
 
   std::shared_ptr<PartialFunction<uint32_t, float>> OkDelayFunction(
       new PartialFunction<uint32_t, float>(
           {{{0, AppConfig.BrokenCounter},
             std::make_shared<LinearFunction<uint32_t, float>>(
                 0, 1.f, AppConfig.BrokenCounter, 0.f)},
            {{AppConfig.BrokenCounter, std::numeric_limits<uint32_t>::max()},
             std::make_shared<LinearFunction<uint32_t, float>>(0.f, 0.f)}},
           1.f));
 
   //
   // Create a DeluxeAgent with SystemStateDetector functionality.
   //
   LOG_INFO("Create SystemStateDetector agent.");
   AgentHandle SystemStateDetectorAgent = createSystemStateDetectorAgent(
       C, "SystemStateDetector", AppConfig.SignalConfigurations.size(),
       BrokenDelayFunction, OkDelayFunction);
+  C->setExecutionPolicy(SystemStateDetectorAgent,
+                        DeluxeExecutionPolicy::awaitAll({}));
 
   LOG_INFO("Creating sensors, SignalStateDetector functionalities and their "
            "Abstractions.");
   std::vector<AgentHandle> Sensors;
   std::vector<std::shared_ptr<PartialFunction<float, float>>>
       SampleMatchesFunctions;
   std::vector<std::shared_ptr<PartialFunction<float, float>>>
       SampleMismatchesFunctions;
   std::vector<std::shared_ptr<PartialFunction<float, float>>>
       SignalIsStableFunctions;
   std::vector<std::shared_ptr<PartialFunction<float, float>>>
       SignalIsDriftingFunctions;
   std::vector<std::shared_ptr<StepFunction<float, float>>>
       NumOfSamplesMatchFunctions;
   std::vector<std::shared_ptr<StepFunction<float, float>>>
       NumOfSamplesMismatchFunctions;
   std::vector<std::shared_ptr<
       SignalStateDetector<float, float, float, HistoryPolicy::FIFO>>>
       SignalStateDetectors;
   std::vector<AgentHandle> SignalStateDetectorAgents;
 
   for (auto SignalConfiguration : AppConfig.SignalConfigurations) {
     //
     // Create deluxe sensors.
     //
     Sensors.emplace_back(C->createSensor<float>(SignalConfiguration.Name));
+    C->setExecutionPolicy(Sensors.back(), DeluxeExecutionPolicy::decimation(1));
 
     //
     // Create functionalities for SignalStateDetector.
     //
     SampleMatchesFunctions.emplace_back(new PartialFunction<float, float>(
         {
             {{-SignalConfiguration.OuterBound, -SignalConfiguration.InnerBound},
              std::make_shared<LinearFunction<float, float>>(
                  -SignalConfiguration.OuterBound, 0.f,
                  -SignalConfiguration.InnerBound, 1.f)},
             {{-SignalConfiguration.InnerBound, SignalConfiguration.InnerBound},
              std::make_shared<LinearFunction<float, float>>(1.f, 0.f)},
             {{SignalConfiguration.InnerBound, SignalConfiguration.OuterBound},
              std::make_shared<LinearFunction<float, float>>(
                  SignalConfiguration.InnerBound, 1.f,
                  SignalConfiguration.OuterBound, 0.f)},
         },
         0));
 
     SampleMismatchesFunctions.emplace_back(new PartialFunction<float, float>(
         {
             {{-SignalConfiguration.OuterBound, -SignalConfiguration.InnerBound},
              std::make_shared<LinearFunction<float, float>>(
                  -SignalConfiguration.OuterBound, 1.f,
                  -SignalConfiguration.InnerBound, 0.f)},
             {{-SignalConfiguration.InnerBound, SignalConfiguration.InnerBound},
              std::make_shared<LinearFunction<float, float>>(0.f, 0.f)},
             {{SignalConfiguration.InnerBound, SignalConfiguration.OuterBound},
              std::make_shared<LinearFunction<float, float>>(
                  SignalConfiguration.InnerBound, 0.f,
                  SignalConfiguration.OuterBound, 1.f)},
         },
         1));
 
     SignalIsStableFunctions.emplace_back(new PartialFunction<float, float>(
         {
             {{-SignalConfiguration.OuterBoundDrift,
               -SignalConfiguration.InnerBoundDrift},
              std::make_shared<LinearFunction<float, float>>(
                  -SignalConfiguration.OuterBoundDrift, 0.f,
                  -SignalConfiguration.InnerBoundDrift, 1.f)},
             {{-SignalConfiguration.InnerBoundDrift,
               SignalConfiguration.InnerBoundDrift},
              std::make_shared<LinearFunction<float, float>>(1.f, 0.f)},
             {{SignalConfiguration.InnerBoundDrift,
               SignalConfiguration.OuterBoundDrift},
              std::make_shared<LinearFunction<float, float>>(
                  SignalConfiguration.InnerBoundDrift, 1.f,
                  SignalConfiguration.OuterBoundDrift, 0.f)},
         },
         0));
 
     SignalIsDriftingFunctions.emplace_back(new PartialFunction<float, float>(
         {
             {{-SignalConfiguration.OuterBoundDrift,
               -SignalConfiguration.InnerBoundDrift},
              std::make_shared<LinearFunction<float, float>>(
                  -SignalConfiguration.OuterBoundDrift, 1.f,
                  -SignalConfiguration.InnerBoundDrift, 0.f)},
             {{-SignalConfiguration.InnerBoundDrift,
               SignalConfiguration.InnerBoundDrift},
              std::make_shared<LinearFunction<float, float>>(0.f, 0.f)},
             {{SignalConfiguration.InnerBoundDrift,
               SignalConfiguration.OuterBoundDrift},
              std::make_shared<LinearFunction<float, float>>(
                  SignalConfiguration.InnerBoundDrift, 0.f,
                  SignalConfiguration.OuterBoundDrift, 1.f)},
         },
         1));
 
     NumOfSamplesMatchFunctions.emplace_back(new StepFunction<float, float>(
         1.0f / SignalConfiguration.SampleHistorySize, StepDirection::StepUp));
 
     NumOfSamplesMismatchFunctions.emplace_back(new StepFunction<float, float>(
         1.0f / SignalConfiguration.SampleHistorySize, StepDirection::StepDown));
 
     //
     // Create SignalStateDetector functionality
     //
     SignalStateDetectors.emplace_back(
         new SignalStateDetector<float, float, float, HistoryPolicy::FIFO>(
             SignalConfiguration.Output ? SignalProperties::OUTPUT
                                        : SignalProperties::INPUT,
             std::numeric_limits<int>::max(), SampleMatchesFunctions.back(),
             SampleMismatchesFunctions.back(), NumOfSamplesMatchFunctions.back(),
             NumOfSamplesMismatchFunctions.back(),
             SignalIsDriftingFunctions.back(), SignalIsStableFunctions.back(),
             SignalConfiguration.SampleHistorySize, SignalConfiguration.DABSize,
             SignalConfiguration.DABHistorySize));
 
     //
     // Create low-level deluxe agents
     //
     SignalStateDetectorAgents.push_back(createSignalStateDetectorAgent(
         C, SignalConfiguration.Name, SignalStateDetectors.back()));
+    C->setExecutionPolicy(SignalStateDetectorAgents.back(),
+                          DeluxeExecutionPolicy::awaitAny({}));
 
     //
     // Connect sensors to low-level agents.
     //
     LOG_INFO("Connect sensors to their corresponding low-level agents.");
 
     C->connectSensor(SignalStateDetectorAgents.back(), 0, Sensors.back(),
                      SignalConfiguration.Name);
 
     C->connectAgents(SystemStateDetectorAgent, SignalStateDetectors.size() - 1,
                      SignalStateDetectorAgents.back(),
                      SignalConfiguration.Name);
+
+    std::ifstream SensorData(SignalConfiguration.InputPath);
+    if (!SensorData) {
+      LOG_ERROR_STREAM << "Cannot open Input File \""
+                       << SignalConfiguration.InputPath << "\" for Signal \""
+                       << SignalConfiguration.Name << "\"" << std::endl;
+      return 3;
+    }
+
+    C->registerSensorValues(Sensors.back(), csv::CSVIterator<float>(SensorData),
+                            csv::CSVIterator<float>());
   }
 
   //
   // For simulation output, create a logger agent writing the output of the
   // high-level agent into a CSV file.
   //
   LOG_INFO("Create a logger agent.");
 
   // Create CSV writer.
   std::ofstream OutputCSV(AppConfig.OutputFilePath);
 
   // The agent writes each new input value into a CSV file and produces nothing.
   using Input = std::pair<SystemStateTuple, bool>;
   using Result = Optional<DeluxeTuple<unit_t>>;
   using Handler = std::function<Result(Input)>;
   std::string Name = "Logger Agent";
 
   AgentHandle LoggerAgent =
       C->createAgent("Logger Agent", Handler([&OutputCSV](Input I) -> Result {
                        OutputCSV << std::get<0>(I.first) << std::endl;
                        return Result();
                      }));
+  C->setExecutionPolicy(LoggerAgent, DeluxeExecutionPolicy::awaitAny({}));
   //
   // Connect the high-level agent to the logger agent.
   //
   LOG_INFO("Connect the high-level agent to the logger agent.");
 
   C->connectAgents(LoggerAgent, 0, SystemStateDetectorAgent,
                    "SystemStateDetector Channel");
 
   //
   // Do simulation.
   //
   LOG_INFO("Setting up and performing simulation.");
 
   //
   // Initialize deluxe context for simulation.
   //
   C->initializeSimulation();
 
   //
   // Open CSV files and register them for their corresponding sensors.
   //
 
   //
   // Simulate.
   //
 
   C->simulate(AppConfig.NumberOfSimulationCycles);
 
   return 0;
 }
diff --git a/apps/ccam/configuration.h b/apps/ccam/configuration.h
index 4db55b4..cec43ad 100644
--- a/apps/ccam/configuration.h
+++ b/apps/ccam/configuration.h
@@ -1,85 +1,85 @@
 #ifndef CONFIGURATION_H
 #define CONFIGURATION_H
 
 // clang-tidy off
 // clang-format off
 #include "json.hpp"
 // clang-format on
 // clang-tidy on
 #include "rosa/config/version.h"
 #include "rosa/deluxe/DeluxeContext.hpp"
 #include <fstream>
 
 using namespace rosa;
 using nlohmann::json;
 
 struct SignalConfiguration {
   std::string Name;
+  std::string InputPath;
   bool Output;
   float InnerBound;
   float OuterBound;
   float InnerBoundDrift;
   float OuterBoundDrift;
   uint32_t SampleHistorySize;
   uint32_t DABSize;
   uint32_t DABHistorySize;
 };
 
 struct AppConfiguration {
-  std::string InputFilePath;
   std::string OutputFilePath;
   uint32_t BrokenCounter;
   uint32_t NumberOfSimulationCycles;
   std::vector<SignalConfiguration> SignalConfigurations;
 };
 
 void from_json(const json &J, SignalConfiguration &SC) {
   J.at("Name").get_to(SC.Name);
+  J.at("InputPath").get_to(SC.InputPath);
   J.at("Output").get_to(SC.Output);
   J.at("InnerBound").get_to(SC.InnerBound);
   J.at("OuterBound").get_to(SC.OuterBound);
   J.at("InnerBoundDrift").get_to(SC.InnerBoundDrift);
   J.at("OuterBoundDrift").get_to(SC.OuterBoundDrift);
   J.at("SampleHistorySize").get_to(SC.SampleHistorySize);
   J.at("DABSize").get_to(SC.DABSize);
   J.at("DABHistorySize").get_to(SC.DABHistorySize);
 }
 
 void from_json(const json &J, AppConfiguration &AC) {
-  J.at("InputFilePath").get_to(AC.InputFilePath);
   J.at("OutputFilePath").get_to(AC.OutputFilePath);
   J.at("BrokenCounter").get_to(AC.BrokenCounter);
   J.at("NumberOfSimulationCycles").get_to(AC.NumberOfSimulationCycles);
   J.at("SignalConfigurations").get_to(AC.SignalConfigurations);
 }
 
 AppConfiguration AppConfig;
 
 bool readConfigFile(std::string ConfigPath) {
 
   LOG_INFO("READING CONFIG FILE");
   LOG_INFO_STREAM << "Looking for config file at \"" << ConfigPath << "\"\n";
 
   std::ifstream ConfigFile;
   ConfigFile.open(ConfigPath);
 
   if (!ConfigFile) {
     LOG_ERROR("Unable to open config file");
     return false;
   }
 
   json ConfigObj;
   ConfigFile >> ConfigObj;
   LOG_INFO_STREAM << "Read JSON file as \"" << ConfigObj << "\"\n";
 
   try {
     ConfigObj.get_to(AppConfig);
   } catch (nlohmann::detail::type_error ex) {
     LOG_ERROR("Misformatted Config File");
     return false;
   }
 
   return true;
 }
 
 #endif // CONFIGURATION_H
diff --git a/apps/ccam/statehandlerutils.h b/apps/ccam/statehandlerutils.h
index 73f25b0..9bf7ee4 100644
--- a/apps/ccam/statehandlerutils.h
+++ b/apps/ccam/statehandlerutils.h
@@ -1,186 +1,184 @@
 #ifndef STATEHANDLERUTILS_H
 #define STATEHANDLERUTILS_H
 #include "rosa/agent/Abstraction.hpp"
 #include "rosa/agent/Confidence.hpp"
 #include "rosa/agent/FunctionAbstractions.hpp"
 #include <functional>
 #include <iostream>
 #include <tuple>
 #include <vector>
 
 #include "rosa/config/version.h"
 
 #include "rosa/agent/SignalStateDetector.hpp"
 #include "rosa/agent/SystemStateDetector.hpp"
 #include "rosa/deluxe/DeluxeContext.hpp"
 
 #include "rosa/support/csv/CSVReader.hpp"
 #include "rosa/support/csv/CSVWriter.hpp"
 
 #include <fstream>
 #include <limits>
 #include <memory>
 #include <streambuf>
 using namespace rosa;
 using namespace rosa::agent;
 using namespace rosa::deluxe;
 using namespace rosa::terminal;
 
 // Signal State
 
 using SignalStateTuple =
     DeluxeTuple<float, uint32_t, uint8_t, float, float, float, float, float,
-                float, uint8_t, uint32_t, bool, bool, bool>;
+                float, uint8_t, uint32_t, uint8_t>;
 
 AgentHandle createSignalStateDetectorAgent(
     std::unique_ptr<DeluxeContext> &C, const std::string &Name,
     std::shared_ptr<
         SignalStateDetector<float, float, float, HistoryPolicy::FIFO>>
         SigSD) {
 
   using Input = std::pair<DeluxeTuple<float>, bool>;
 
   using Result = Optional<SignalStateTuple>;
   using Handler = std::function<Result(Input)>;
 
   return C->createAgent(
       Name, Handler([&Name, &SigSD](Input I) -> Result {
         LOG_INFO_STREAM << "\n******\n"
                         << Name << " " << (I.second ? "<New>" : "<Old>")
                         << " value: " << std::get<0>(I.first) << "\n******\n";
         auto StateInfo = SigSD->detectSignalState(std::get<0>(I.first));
 
         if (I.second) {
           SignalStateTuple Res = {
               std::get<0>(I.first), StateInfo.StateID, StateInfo.SignalProperty,
               //@benedikt: I changed this
               // StateInfo.SignalStateConfidence,
               StateInfo.ConfidenceOfMatchingState,
               StateInfo.ConfidenceOfMismatchingState,
               StateInfo.ConfidenceStateIsValid,
               StateInfo.ConfidenceStateIsInvalid,
               StateInfo.ConfidenceStateIsStable,
               StateInfo.ConfidenceStateIsDrifting, StateInfo.StateCondition,
               StateInfo.NumberOfInsertedSamplesAfterEntrance,
-              StateInfo.StateIsValid, StateInfo.StateJustGotValid,
-              StateInfo.StateIsValidAfterReentrance};
+              (StateInfo.StateIsValid ? 4 : 0) +
+                  (StateInfo.StateJustGotValid ? 2 : 0) +
+                  (StateInfo.StateIsValidAfterReentrance ? 1 : 0)};
           return Result(Res);
         }
         return Result();
       }));
 }
 
 // System State
 
 using SystemStateTuple = DeluxeTuple<std::string, uint32_t, float, uint8_t,
                                      uint32_t, bool, bool, bool, bool>;
 
 template <std::size_t size, typename ret, typename functype, typename... A>
 struct Handler_helper;
 
 template <typename B, typename func, typename A, typename... As>
 struct function_helper {
   static_assert(std::conjunction_v<std::is_same<A, As>...>,
                 "All types need to be identical");
 
   static B function(A valA, As... valAs) {
     std::vector<A> ar({valA, valAs...});
     return func()(ar);
   }
 };
 
 template <typename ret, typename typeA, typename functype, typename... B>
 struct Handler_helper<0, ret, functype, typeA, B...> {
   using handler = function_helper<ret, functype, B...>;
 };
 
 template <std::size_t size, typename ret, typename typeA, typename functype,
           typename... B>
 struct Handler_helper<size, ret, functype, typeA, B...> {
   using handler =
       typename Handler_helper<size - 1, ret, functype, typeA,
                               std::pair<typeA, bool>, B...>::handler;
 };
 
 template <std::size_t size, typename ret, typename functype, typename typeA>
 using Handler = typename Handler_helper<size, ret, functype, typeA>::handler;
 
 // todo: state-detector durschleifen
 template <typename ret, typename A> struct function {
   ret operator()(A a) {
     // std::vector<SystemStateInformation> out;
     for (auto tmp1 : a) {
       // convert tuple to info struct out.push_back({});
       (void)tmp1;
       LOG_INFO_STREAM << "new SignalStateTuple!\n";
     }
     // feed state detector
     // return result
     return ret();
   }
 };
 
 using arr = std::vector<std::pair<SignalStateTuple, bool>>;
 
 template <size_t NumOfSlaves>
 AgentHandle createSystemStateDetectorAgent(
     std::unique_ptr<DeluxeContext> &C, const std::string &Name,
     std::shared_ptr<PartialFunction<uint32_t, float>> BrokenDelayFunction,
     std::shared_ptr<PartialFunction<uint32_t, float>> OkDelayFunction) {
   LOG_TRACE("Creating fixed SystemStateDetectorAgent");
   using Input = SignalStateTuple;
   using Result = Optional<SystemStateTuple>;
 
   auto HandlerFunction =
       Handler<NumOfSlaves, Result, function<Optional<SystemStateTuple>, arr>,
               Input>::function;
   std::shared_ptr<
       SystemStateDetector<uint32_t, float, float, HistoryPolicy::FIFO>>
-      //@benedikt: I had to insert a dummy number for NumberOfSignals (I
-      // inserted 5)
-      SysSD(
-          new SystemStateDetector<uint32_t, float, float, HistoryPolicy::FIFO>(
-              std::numeric_limits<uint32_t>::max(), 5, BrokenDelayFunction,
-              OkDelayFunction));
+  SysSD(new SystemStateDetector<uint32_t, float, float, HistoryPolicy::FIFO>(
+      std::numeric_limits<uint32_t>::max(), NumOfSlaves, BrokenDelayFunction,
+      OkDelayFunction));
 
   return C->createAgent(Name, std::function(HandlerFunction));
 }
 
 AgentHandle createSystemStateDetectorAgent(
     std::unique_ptr<DeluxeContext> &C, const std::string &Name,
     size_t NumOfSlaves,
     std::shared_ptr<PartialFunction<uint32_t, float>> BrokenDelayFunction,
     std::shared_ptr<PartialFunction<uint32_t, float>> OkDelayFunction) {
   LOG_TRACE("Creating dynamic SystemStateDetectorAgent");
   switch (NumOfSlaves) {
   // clang-format off
   case  2: return createSystemStateDetectorAgent< 2>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case  3: return createSystemStateDetectorAgent< 3>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case  4: return createSystemStateDetectorAgent< 4>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case  5: return createSystemStateDetectorAgent< 5>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case  6: return createSystemStateDetectorAgent< 6>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case  7: return createSystemStateDetectorAgent< 7>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case  8: return createSystemStateDetectorAgent< 8>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case  9: return createSystemStateDetectorAgent< 9>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case 10: return createSystemStateDetectorAgent<10>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case 11: return createSystemStateDetectorAgent<11>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case 12: return createSystemStateDetectorAgent<12>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case 13: return createSystemStateDetectorAgent<13>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case 14: return createSystemStateDetectorAgent<14>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case 15: return createSystemStateDetectorAgent<15>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case 16: return createSystemStateDetectorAgent<16>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case 17: return createSystemStateDetectorAgent<17>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case 18: return createSystemStateDetectorAgent<18>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case 19: return createSystemStateDetectorAgent<19>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case 20: return createSystemStateDetectorAgent<20>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case 21: return createSystemStateDetectorAgent<21>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case 22: return createSystemStateDetectorAgent<22>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case 23: return createSystemStateDetectorAgent<23>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case 24: return createSystemStateDetectorAgent<24>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case 25: return createSystemStateDetectorAgent<25>(C, Name, BrokenDelayFunction, OkDelayFunction);
   case 1:
   default: return createSystemStateDetectorAgent<1>(C, Name, BrokenDelayFunction, OkDelayFunction);
     // clang-format on
   }
 }
 #endif // STATEHANDLERUTILS_H
diff --git a/include/rosa/agent/SystemStateDetector.hpp b/include/rosa/agent/SystemStateDetector.hpp
index 9152dfa..bcff7b4 100644
--- a/include/rosa/agent/SystemStateDetector.hpp
+++ b/include/rosa/agent/SystemStateDetector.hpp
@@ -1,223 +1,222 @@
 //===-- rosa/agent/SystemStateDetector.hpp ----------------------*- C++ -*-===//
 //
 //                                 The RoSA Framework
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file rosa/agent/SystemStateDetector.hpp
 ///
 /// \author Maximilian Götzinger (maximilian.goetzinger@tuwien.ac.at)
 ///
 /// \date 2019
 ///
 /// \brief Definition of *system state detector* *functionality*.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef ROSA_AGENT_SYSTEMSTATEDETECTOR_HPP
 #define ROSA_AGENT_SYSTEMSTATEDETECTOR_HPP
 
 #include "rosa/agent/Functionality.h"
 #include "rosa/agent/SignalState.hpp"
 #include "rosa/agent/StateDetector.hpp"
 #include "rosa/agent/SystemState.hpp"
 
 #include "rosa/support/debug.hpp"
 
 namespace rosa {
 namespace agent {
 
 /*
 /// System state conditions defining how the condition of a \c
 /// rosa::agent::SystemState is saved in \c rosa::agent::SystemStateInformation.
 // TODO: think about shifting this in SystemStateDetector and make a
 // StateCondition with only stable, drifting, unknown
 enum class SystemStateCondition : uint8_t {
   STABLE = 0,         ///< The system state is stable
   DRIFTING = 1,       ///< The system state is drifting
   MALFUNCTIONING = 2, ///< The system state is malfunctioning
   UNKNOWN = 3         ///< The system state is unknown
 };
 */
 
 /// TODO: write description
 template <typename INDATATYPE, typename CONFDATATYPE, typename PROCDATATYPE,
           HistoryPolicy HP>
 class SystemStateDetector
     : public StateDetector<INDATATYPE, CONFDATATYPE, PROCDATATYPE, HP> {
 
   using StateDetector =
       StateDetector<INDATATYPE, CONFDATATYPE, PROCDATATYPE, HP>;
   using PartFuncPointer = typename StateDetector::PartFuncPointer;
 
 private:
   // For the convinience to write a shorter data type name
   using SystemStatePtr =
       std::shared_ptr<SystemState<INDATATYPE, CONFDATATYPE, PROCDATATYPE>>;
 
   /// TODO: description
   uint32_t NumberOfSignals;
 
   /// The CurrentSystemState is a pointer to the (saved) system state in which
   /// the actual state of the observed system is.
   SystemStatePtr CurrentSystemState;
 
   /// The DetectedSystemStates is a history in that all detected system states
   /// are saved.
   DynamicLengthHistory<SystemStatePtr, HP> DetectedSystemStates;
 
   /// TODO: description
   unsigned int TimeOfDisparity;
 
   /// The FuzzyFunctionDelayTimeToGetBroken is the fuzzy function that gives
   /// the confidence whether the system is Broken because of an input change
   /// without an output change or vice versa. A small time gap between the two
   /// shall be allowed.
   PartFuncPointer FuzzyFunctionDelayTimeToGetBroken;
 
   /// The FuzzyFunctionDelayTimeToBeWorking is the fuzzy function that gives
   /// the
   /// confidence whether the system is still OK allthough an input change
   /// without an output change or vice versa.
   PartFuncPointer FuzzyFunctionDelayTimeToBeWorking;
 
 public:
   // todo zwei parameter für variablen anzahl
   /// TODO: write description
   SystemStateDetector(
       uint32_t MaximumNumberOfSystemStates, uint32_t NumberOfSignals,
       PartFuncPointer FuzzyFunctionDelayTimeToGetBroken,
       PartFuncPointer FuzzyFunctionDelayTimeToBeWorking) noexcept
-      : CurrentSystemState(nullptr),
-        DetectedSystemStates(MaximumNumberOfSystemStates),
-        NumberOfSignals(NumberOfSignals), TimeOfDisparity(0),
+      : NumberOfSignals(NumberOfSignals), CurrentSystemState(nullptr),
+        DetectedSystemStates(MaximumNumberOfSystemStates), TimeOfDisparity(0),
         FuzzyFunctionDelayTimeToGetBroken(FuzzyFunctionDelayTimeToGetBroken),
         FuzzyFunctionDelayTimeToBeWorking(FuzzyFunctionDelayTimeToBeWorking) {
     //@Benedikt: if I write "NextStateID(1), StateHasChanged(false)" before the
     //{}-brackets, the compiler tells me: "SystemStateDetector.hpp:72:9: error:
     // member initializer 'NextStateID'/'StateHasChanged' does not name a
     // non-static data member or base class"
     this->NextStateID = 1;
     this->StateHasChanged = false;
   }
 
   /// Destroys \p this object.
   ~SystemStateDetector(void) = default;
 
   /// TODO: write description
   SystemStateInformation<CONFDATATYPE>
   detectSystemState(std::vector<SignalStateInformation<CONFDATATYPE>>
                         SignalStateInfos) noexcept {
 
     SystemStateInformation<CONFDATATYPE> SystemStateInfo;
 
     if (!CurrentSystemState) {
       ASSERT(DetectedSystemStates.empty());
       SystemStatePtr S = createNewSystemState();
       CurrentSystemState = S;
 
       SystemStateInfo =
           CurrentSystemState->insertSignalStateInformation(SignalStateInfos);
     } else {
 
       SystemStateRelation SysStateRel =
           CurrentSystemState->compareSignalStateInformation(SignalStateInfos);
 
       if (SysStateRel == SystemStateRelation::STATEISMATCHING) {
         TimeOfDisparity = 0;
 
         SystemStateInfo =
             CurrentSystemState->insertSignalStateInformation(SignalStateInfos);
       } else { // ONLYINPUTISMATCHING, ONLYOUTPUTISMATCHING, STATEISMISMATCHING
 
         if (!CurrentSystemState->systemStateInformation().StateIsValid)
           DetectedSystemStates.deleteEntry(CurrentSystemState);
         CurrentSystemState = nullptr;
 
         SystemStatePtr potentialSystemState = nullptr;
 
         // search all saved system states
         for (auto &SavedSystemState : DetectedSystemStates) {
           SysStateRel =
               SavedSystemState->compareSignalStateInformation(SignalStateInfos);
           if (SysStateRel == SystemStateRelation::STATEISMATCHING) {
             CurrentSystemState = SavedSystemState;
             break;
           } else if (SysStateRel == SystemStateRelation::ONLYINPUTISMATCHING ||
                      SysStateRel == SystemStateRelation::ONLYOUTPUTISMATCHING) {
             potentialSystemState = SavedSystemState;
           }
         }
 
         // actions depending whether state is matchin fully or only half
         if (CurrentSystemState) {
           TimeOfDisparity = 0;
 
           SystemStateInfo = CurrentSystemState->insertSignalStateInformation(
               SignalStateInfos);
 
         } else if (potentialSystemState) {
           TimeOfDisparity++;
 
           CurrentSystemState = potentialSystemState;
 
           SystemStateInfo = CurrentSystemState->systemStateInformation();
 
         } else {
           SystemStatePtr S = createNewSystemState();
           TimeOfDisparity = 0;
 
           CurrentSystemState = S;
 
           SystemStateInfo = CurrentSystemState->insertSignalStateInformation(
               SignalStateInfos);
         }
       }
     }
 
     // TODO: is this right? if i don't insert if broke, it will never be valid?!
     // right?
     if (!SystemStateInfo.StateIsValid ||
         !SystemStateInfo.StateIsValidAfterReentrance) {
       TimeOfDisparity = 0;
     }
 
     // TODO: maybe make reference instead of pointer
     CONFDATATYPE ConfidenceSystemIsMalfunctioning =
         FuzzyFunctionDelayTimeToGetBroken->operator()(
             static_cast<INDATATYPE>(TimeOfDisparity));
     CONFDATATYPE ConfidenceSystemIsFunctioning =
         FuzzyFunctionDelayTimeToBeWorking->operator()(
             static_cast<INDATATYPE>(TimeOfDisparity));
 
     if (ConfidenceSystemIsMalfunctioning > ConfidenceSystemIsFunctioning)
       SystemStateInfo.StateCondition = StateConditions::MALFUNCTIONING;
 
     // TODO: calculate overall confidence
 
     if (SystemStateInfo.StateJustGotValid) {
       this->NextStateID++;
     }
 
     return SystemStateInfo;
   }
 
 private:
   /// Creates a new system state and adds it to the system state vector in
   /// which
   /// all known states are saved.
   ///
   /// \return a pointer to the newly created signal state or NULL if no state
   /// could be created.
   SystemStatePtr createNewSystemState(void) noexcept {
     SystemStatePtr S(new SystemState<INDATATYPE, CONFDATATYPE, PROCDATATYPE>(
         this->NextStateID, this->NumberOfSignals));
     DetectedSystemStates.addEntry(S);
     return S;
   }
 };
 
 } // End namespace agent
 } // End namespace rosa
 
 #endif // ROSA_AGENT_SYSTEMSTATEDETECTOR_HPP
diff --git a/include/rosa/support/csv/CSVReader.hpp b/include/rosa/support/csv/CSVReader.hpp
index c5678ef..3b6ed7b 100755
--- a/include/rosa/support/csv/CSVReader.hpp
+++ b/include/rosa/support/csv/CSVReader.hpp
@@ -1,484 +1,484 @@
 //===-- rosa/support/csv/CSVReader.hpp --------------------------*- C++ -*-===//
 //
 //                                 The RoSA Framework
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file rosa/support/csv/CSVReader.hpp
 ///
 /// \authors David Juhasz (david.juhasz@tuwien.ac.at), Edwin Willegger
 /// (edwin.willegger@tuwien.ac.at)
 ///
 /// \date 2017-2019
 ///
 /// \brief Facitilities to read CSV files.
 ///
 /// \note The implementation is based on the solution at
 /// https://stackoverflow.com/a/1120224
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef ROSA_SUPPORT_CSV_CSVREADER_HPP
 #define ROSA_SUPPORT_CSV_CSVREADER_HPP
 
 #include "rosa/support/debug.hpp"
 #include "rosa/support/sequence.hpp"
 
 #include <algorithm>
 #include <istream>
 #include <map>
 #include <set>
 #include <sstream>
 #include <vector>
 
 namespace rosa {
 namespace csv {
 
 /// Indicating it the CSV file contains any header or not
 enum class HeaderInformation { HasHeader, HasNoHeader };
 
 /// Anonymous namespace providing implementation details for
 /// \c rosa::csv::CSVIterator, consider it private.
 namespace {
 
 /// Provides facility for parsing one value from a string.
 ///
 /// \tparam T type of value to parse
 /// \tparam IsSignedInt if \p T is a signed integral type, always use default
 /// \tparam IsUnsignedInt if \p T is an unsigned integral type, always use
 /// default
 /// \tparam IsFloat if \p T is a floating-point type, always use default
 /// \tparam IsString if \p T is \c std::string, always use default
 ///
 /// \note Specializations of this struct are provided for arithmentic types
 /// and \c std::string.
 template <typename T,
           bool IsSignedInt =
               (std::is_integral<T>::value && std::is_signed<T>::value),
           bool IsUnsignedInt =
               (std::is_integral<T>::value && std::is_unsigned<T>::value),
           bool IsFloat = std::is_floating_point<T>::value,
           bool IsString = std::is_same<T, std::string>::value>
 struct ValueParser {
 
   ///
   ///
   /// \param Cell the \c std::string to parse
   ///
   /// \return the parsed value
   ///
   /// \note The function silently fails if cannot parse \p Cell for type \p T.
   static T parse(const std::string &Cell) noexcept;
 };
 
 template <typename T> struct ValueParser<T, true, false, false, false> {
   STATIC_ASSERT((std::is_integral<T>::value && std::is_signed<T>::value),
                 "wrong type"); // Sanity check.
   static T parse(const std::string &Cell) noexcept {
     return static_cast<T>(std::stoll(Cell));
   }
 };
 
 template <typename T> struct ValueParser<T, false, true, false, false> {
   STATIC_ASSERT((std::is_integral<T>::value && std::is_unsigned<T>::value),
                 "wrong type"); // Sanity check.
   static T parse(const std::string &Cell) noexcept {
     return static_cast<T>(std::stoull(Cell));
   }
 };
 
 template <typename T> struct ValueParser<T, false, false, true, false> {
   STATIC_ASSERT((std::is_floating_point<T>::value),
                 "wrong type"); // Sanity check.
   static T parse(const std::string &Cell) noexcept {
     return static_cast<T>(std::stold(Cell));
   }
 };
 
 template <typename T> struct ValueParser<T, false, false, false, true> {
   STATIC_ASSERT((std::is_same<T, std::string>::value),
                 "wrong type"); // Sanity check.
   static T parse(const std::string &Cell) noexcept { return Cell; }
 };
 
 /// Parses and stores entries from a row of CSV data.
 ///
 /// \tparam Ts types of values to parse and store, i.e. entries in the row
 ///
 /// \note The implementation relies on \c rosa::csv::CSVRowParser, which is
 /// implemented only for `arithmetic` types -- signed and unsigned integral
 /// and floating-point types -- and for \c std::string. Those are the valid
 /// values for \p Ts.
 template <typename... Ts> class CSVRow {
 private:
   /// Parses a given row of CSV data into \c CSVRow::Data.
   ///
   /// \ CSVRow::Data is filled with values parsed from \p LineStream. Entries
   /// in the line are to be separated by commas, the character `,`.
   ///
   /// \note Parsed values are silently converted to types \p Ts.
   ///
   /// \note Parsing silently fails if values do not match \p Ts.
   ///
   /// \tparam S0 indices to access tuple elements.
   ///
   /// \param [in,out] LineStream the line to parse
   ///
   /// \note The last argument is used only to get \p S0, the actual value of
   /// the parameter is ignored.
   template <size_t... S0>
-  void parseRow(std::stringstream &LineStream, char Delimeter, Seq<S0...>) {
+  void parseRow(std::stringstream &LineStream, char Delimiter, Seq<S0...>) {
     STATIC_ASSERT(sizeof...(Ts) == sizeof...(S0),
                   "Not matching template arguments.");
     std::string Cell;
     // Get fields and parse the values into the proper element of the tuple
     // one by one in a fold expression.
-    ((std::getline(LineStream, Cell, Delimeter),
+    ((std::getline(LineStream, Cell, Delimiter),
       std::get<S0>(Data) = ValueParser<Ts>::parse(Cell)),
      ...);
   }
 
 public:
   /// Constructor with all possible parameters
   ///
   ///  The function creates an instance of an CSVRow object and sets the
   ///  attributes of the
   ///  object to the values of the parameters.
   ///
   /// \param SkipRows the number of data rows to skip, not taking header into
   /// account.
   /// \param HeaderInfo is the first line of the file a header row or not.
-  /// \param Delimeter to seperate between the data entries within one row.
+  /// \param Delimiter to seperate between the data entries within one row.
   CSVRow(const size_t SkipRows = 0,
          const HeaderInformation HeaderInfo = HeaderInformation::HasHeader,
-         const char Delimeter = ',')
-      : SkipRows(SkipRows), HeaderInfo(HeaderInfo), Delimeter(Delimeter),
+         const char Delimiter = ',')
+      : SkipRows(SkipRows), HeaderInfo(HeaderInfo), Delimiter(Delimiter),
         RowNumber(0), IsHeaderRead(false) {}
 
   /// Parses and stores one row of CSV data.
   ///
   /// The function reads one line from \p Str and parses it into
   /// \c rosa::csv::CSVRow::Data using \c rosa::csv::CSVRowParser.
   ///
   /// \param [in,out] Str input stream of a CSV file
   void readNextRow(std::istream &Str) noexcept {
     std::string Line;
 
     std::getline(Str, Line);
 
     if (Line.size() > 0) {
       std::stringstream LineStream(Line);
-      parseRow(LineStream, Delimeter, seq_t<sizeof...(Ts)>());
+      parseRow(LineStream, Delimiter, seq_t<sizeof...(Ts)>());
 
       RowNumber = RowNumber + 1;
     }
   }
 
   /// Read header row and stores it as \p std::string.
   ///
   /// The function reads the first line of the csv file and stores the entries
   /// in a vector.
   ///
   /// \param [in,out] Str input stream of a CSV file
   void readHeader(std::istream &Str) noexcept {
     std::string Line;
     std::getline(Str, Line);
     std::stringstream LineStream(Line);
     std::string Value;
 
-    while (getline(LineStream, Value, Delimeter)) {
+    while (getline(LineStream, Value, Delimiter)) {
       Header.push_back(Value);
     }
 
     IsHeaderRead = true;
   }
 
   /// The number of rows to skip once.
   ///
   /// This function returns the number of data rows to skip
   /// at the beginning of the file.
   ///
   /// \return The number of rows to skip at the beginning of a csv file.
   inline size_t SkipNumRows() const noexcept { return this->SkipRows; }
 
   /// The current row number within the csv file.
   ///
   /// This function returns the current row number. The header
   /// row is not counted as a row.
   ///
   /// \returns the current row number within the csv file.
   inline size_t CurRow() const noexcept { return this->RowNumber; }
 
   /// Indiciates if the header was already read.
   ///
   /// This function returns true, if the header of a csv file which contains
   /// a header file is already read.
   /// The user has to pass in the attribute HeaderInfo the information if the
   /// file has in the first row the header row or not.
   ///
   /// \return if the header of a file is already read.
   inline bool IsHeaderReadDone() const noexcept { return this->IsHeaderRead; }
 
   /// Indicates if the file contains a header row in the first row.
   ///
   /// This function returns if the file contains a header row.
   /// The information if the file contains a header row or not, has to be passed
   /// by the user.
   /// The standard value is HeaderInformation::HasHeader
   ///
   /// \return if the csv file contains a header row in the first line of the
   /// file.
   inline HeaderInformation HasFileHeader() const noexcept {
     return this->HeaderInfo;
   }
 
   /// Set the number of rows to skip.
   ///
   /// This function sets the number of rows to skip at the beginning of
   /// the reading of the file.
   ///
-  /// \param SkipRows the number of rows you want to skip at the beginning of
+  /// \param _SkipRows the number of rows you want to skip at the beginning of
   /// the file.
   // NOTE (Maxi): I had to change "SkipRows" to "_SkipRows" because otherwise:
   // "warning: C4458: declaration of 'SkipRows' hides class member"
   inline void SetSkipRows(const size_t _SkipRows) noexcept {
     this->SkipRows = _SkipRows;
   }
 
   /// Is the first row a header row or not.
   ///
   /// This function sets the information, if the first row of the csv file
   /// is a header line or not.
   ///
-  /// \param HeaderInfo if the first row is a header row or not.
+  /// \param _HeaderInfo if the first row is a header row or not.
   // NOTE (Maxi): I had to change "HeaderInfo" to "_HeaderInfo", otherwise:
   // "warning: C4458: declaration of 'HeaderInfo' hides class member"
   inline void SetHeaderInfo(const HeaderInformation _HeaderInfo) noexcept {
     this->HeaderInfo = _HeaderInfo;
   }
 
   /// Set the seperator between data entries.
   ///
   /// This funcction sets the separator between the data entries of the csv
   /// file.
   ///
-  /// \param Delimeter the character that separates the data values.
-  // NOTE (Maxi): I had to change "Delimeter" to "_Delimeter" because otherwise:
-  // "warning: C4458: declaration of 'Delimeter' hides class member"
-  inline void SetDelimeter(char _Delimeter) { this->Delimeter = _Delimeter; }
+  /// \param _Delimiter the character that separates the data values.
+  // NOTE (Maxi): I had to change "Delimiter" to "_Delimiter" because otherwise:
+  // "warning: C4458: declaration of 'Delimiter' hides class member"
+  inline void SetDelimiter(char _Delimiter) { this->Delimiter = _Delimiter; }
 
   /// Gives a constant references for the \c std::tuple containing the values
   /// read by \p this object.
   ///
   /// \return \c CSVRow::Data
   const std::tuple<Ts...> &tuple(void) const noexcept { return Data; }
 
 private:
   std::tuple<Ts...> Data; ///< Stores parsed entries
   size_t SkipRows; ///< The number of rows to skip at the very beginning of the
                    /// file.
   ///< This number only applies on the number of data rows.
   ///< If your file contains a header row and data rows, the skiping
   ///< of the header row is not taken into account.
   HeaderInformation HeaderInfo; ///< If the file contains a header row or not.
-  char Delimeter;               ///< The seperator between the data entries.
+  char Delimiter;               ///< The seperator between the data entries.
   size_t RowNumber;  ///< Current row number, counts all row numbers including
                      /// the header row.
   bool IsHeaderRead; ///< Was the header read or not.
   std::vector<std::string> Header; ///< The content of the header row.
 };
 
 /// Reads a row of CSV data into \c rosa::csv::CSVRow.
 ///
 /// The next line is read from \p Str by calling
 /// \c rosa::csv::CSVRow::readNextRow on \p Data until all lines are
 /// skipped.
 ///
 /// If the function is called for the first time and the file contains
 /// a header than is the header and the first data row read in after the
 /// number of rows that the user wants to skip.
 ///
 /// \tparam Ts type of values to read from the row
 ///
 /// \note The CSV file should contain a line with fields matching \p Ts...
 ///
 /// \param [in,out] Str input stream of a CSV file
 /// \param [in,out] Data object to read the next line into
 ///
 /// \return \p Str after reading one line from it
 template <typename... Ts>
 std::istream &operator>>(std::istream &Str, CSVRow<Ts...> &Data) {
 
   if (Data.HasFileHeader() == HeaderInformation::HasHeader &&
       !Data.IsHeaderReadDone()) {
     Data.readHeader(Str);
   }
 
   while (Data.CurRow() < (Data.SkipNumRows())) {
     Data.readNextRow(Str);
   }
 
   // read the lines after you skipped the number of rows you want to skip
   Data.readNextRow(Str);
 
   return Str;
 }
 
 } // End namespace
 
 /// Provides `InputIterator` features for iterating over a CSV file.
 ///
 /// The iterator parses rows into `std::tuple` values and iterates over the
 /// file row by row.
 ///
 /// \tparam Ts types of values stored in one row of the CSV file
 ///
 /// \note The iterator expects each row to consists of fields matching \p Ts.
 ///
 /// \note The implementation relies on \c rosa::csv::CSVRow, which in turn
 /// relies on \c rosa::csv::CSVRowParser, which is implemented only for
 /// `arithmetic` types -- signed and unsigned integral types and floating-point
 /// types -- and for \c std::string. Those are the valid values for \p Ts
 template <typename... Ts> class CSVIterator {
 public:
   /// \defgroup CSVIteratorTypedefs Typedefs of rosa::csv::CSVIterator
   ///
   /// Standard `typedef`s for iterators.
   ///
   ///@{
   typedef std::input_iterator_tag
       iterator_category;                ///< Category of the iterator.
   typedef std::tuple<Ts...> value_type; ///< Type of values iterated over.
   typedef std::size_t difference_type;  ///< Type to identify distance.
   typedef std::tuple<Ts...> *pointer;   ///< Pointer to the type iterated over.
   typedef std::tuple<Ts...>
       &reference; ///< Reference to the type iterated over.
   ///@}
 
   /// Creates a new instance.
   ///
   /// \param [in,out] S input stream to iterate over
   /// \param          SkipRows the number of rows you want to skip only once at
   /// the beginning of the file.
   ///                 If you have an header in the file, it is supposed to be
   ///                 the first row, and it will be always read out.
   ///                 But after this header the next number of Rows will be
   ///                 skipped.
   /// \param          HeaderInfo is used to know wheter the file contains an
   /// header row or not.
   ///                 The header has to be in the first row.
-  /// \param          Delimeter is the separator between the differnt values of
+  /// \param          Delimiter is the separator between the differnt values of
   /// the csv file.
   CSVIterator(std::istream &S, const size_t SkipRows = 0,
               const HeaderInformation HeaderInfo = HeaderInformation::HasHeader,
-              const char Delimeter = ',')
+              const char Delimiter = ',')
       : Str(S.good() ? &S : nullptr), SkipRows(SkipRows),
-        HeaderInfo(HeaderInfo), Delimeter(Delimeter), Row() {
+        HeaderInfo(HeaderInfo), Delimiter(Delimiter), Row() {
 
     Row.SetSkipRows(SkipRows);
     Row.SetHeaderInfo(HeaderInfo);
-    Row.SetDelimeter(Delimeter);
+    Row.SetDelimiter(Delimiter);
 
     // \c rosa::csv::CSVIterator::Row is initialized empty so the first
     // incrementation here will read the first row.
     ++(*this);
   }
 
   /// Creates an empty new instance.
   CSVIterator(void) noexcept : Str(nullptr) {}
 
   /// Pre-increment operator.
   ///
   /// The implementation reads the next row. If the end of the input stream is
   /// reached, the operator becomes empty and has no further effect.
   ///
   /// \return \p this object after incrementing it.
   CSVIterator &operator++() {
     if (Str) {
       if (!((*Str) >> Row)) {
         Str = nullptr;
       }
     }
     return *this;
   }
 
   /// Post-increment operator.
   ///
   /// The implementation uses the pre-increment operator and returns a copy of
   /// the original state of \p this object.
   ///
   /// \return \p this object before incrementing it.
   CSVIterator operator++(int) {
     CSVIterator Tmp(*this);
     ++(*this);
     return Tmp;
   }
 
   /// Returns a constant reference to the current entry.
   ///
   /// \note Should not dereference the iterator when it is empty.
   ///
   /// \return constant reference to the current entry.
   const std::tuple<Ts...> &operator*(void)const noexcept { return Row.tuple(); }
 
   /// Returns a constant pointer to the current entry.
   ///
   /// \note Should not dereference the iterator when it is empty.
   ///
   /// \return constant pointer to the current entry.
   const std::tuple<Ts...> *operator->(void)const noexcept {
     return &Row.tuple();
   }
 
   /// Tells if \p this object is equal to another one.
   ///
   /// Two \c rosa::csv::CSVReader instances are equal if and only if they are
   /// the same or both are empty.
   ///
   /// \param RHS other object to compare to
   ///
   /// \return whether \p this object is equal with \p RHS
   bool operator==(const CSVIterator &RHS) const noexcept {
     return ((this == &RHS) || ((this->Str == nullptr) && (RHS.Str == nullptr)));
   }
 
   /// Tells if \p this object is not equal to another one.
   ///
   /// \see rosa::csv::CSVReader::operator==
   ///
   /// \param RHS other object to compare to
   ///
   /// \return whether \p this object is not equal with \p RHS.
   bool operator!=(const CSVIterator &RHS) const noexcept {
     return !((*this) == RHS);
   }
 
-  /// Set the delimeter used in the csv file.
-  /// \param Delimeter the character which separates the values in the csv file.
-  // NOTE (Maxi): I had to change "Delimeter" to "_Delimeter" because otherwise:
-  // "warning: C4458: declaration of 'Delimeter' hides class member"
-  inline void setDelimeter(char _Delimeter) noexcept {
-    this->Delimeter = _Delimeter;
+  /// Set the delimiter used in the csv file.
+  /// \param _Delimiter the character which separates the values in the csv file.
+  // NOTE (Maxi): I had to change "Delimiter" to "_Delimiter" because otherwise:
+  // "warning: C4458: declaration of 'Delimiter' hides class member"
+  inline void setDelimiter(char _Delimiter) noexcept {
+    this->Delimiter = _Delimiter;
   }
 
-  /// get the delimeter currently set to separate the values in the csv file.
+  /// get the delimiter currently set to separate the values in the csv file.
   /// \return the current character, which is used to separte teh values in the
   /// csv file.
-  inline char getDelimeter() const noexcept { return this->Delimeter; }
+  inline char getDelimiter() const noexcept { return this->Delimiter; }
 
 private:
   std::istream *Str; ///< Input stream of a CSV file to iterate over.
   size_t SkipRows; ///< Number of Rows to skip only once at the beginning of the
                    /// file.
   HeaderInformation HeaderInfo; ///< does the csv file contain a header or not,
                                 /// if this information is
   ///< not given correclty, the reading of the header would result in
   ///< in an error.
-  char Delimeter;    ///< Delimeter between the entries in the csv file.
+  char Delimiter;    ///< Delimiter between the entries in the csv file.
   CSVRow<Ts...> Row; ///< Content of the current row
 };
 
 } // End namespace csv
 } // End namespace rosa
 
 #endif // ROSA_SUPPORT_CSV_CSVREADER_HPP
diff --git a/include/rosa/support/csv/CSVWriter.hpp b/include/rosa/support/csv/CSVWriter.hpp
index a077e3d..f1cf2ac 100755
--- a/include/rosa/support/csv/CSVWriter.hpp
+++ b/include/rosa/support/csv/CSVWriter.hpp
@@ -1,221 +1,221 @@
 //===-- rosa/support/csv/CSVWriter.hpp --------------------------*- C++ -*-===//
 //
 //                                 The RoSA Framework
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file rosa/support/csv/CSVWriter.hpp
 ///
 /// \authors David Juhasz    (david.juhasz@tuwien.ac.at)
 ///          Edwin Willegger (edwin.willegger@tuwien.ac.at)
 ///
 /// \date 2017-2019
 ///
 /// \brief Facitilities to write CSV files.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef ROSA_SUPPORT_CSV_CSVWRITER_HPP
 #define ROSA_SUPPORT_CSV_CSVWRITER_HPP
 
 #include <iostream>
 #include <ostream>
 
 #include <tuple>
 #include <vector>
 #include <array>
 
 #include "rosa/support/log.h"
 
 namespace rosa {
 namespace csv {
 
 /// Provides facilities to write values into a CSV file.
 ///
 /// The writer emits a comma, the character `,`, between each written values.
 /// The resulted stream is a flat CSV file as it consists of onlyone row, no new
 /// line is emitted.
 ///
 /// \tparam T type of values to write
 template <typename T>
 class CSVWriter {
 public:
   /// Creates a new instance.
   ///
   /// \param [in,out] S output stream to write to
   ///
   /// \note The writer operates on non-binary outputs as long as \p S is in
   /// good state.
   CSVWriter(std::ostream &S)
       : Str(S.good() && !(S.flags() & std::ios::binary) ? &S : nullptr),
         IsFirst(true) {}
 
   /// Tells if the last operation was successful.
   ///
   /// \return if the last operation was successful
   bool good(void) const noexcept {
     return Str != nullptr;
   }
 
   /// Writes an entry to the output stream.
   ///
   /// The implementation does anything only if the last operation was
   /// successful. If so, \p V is written to \c rosa::csv::CSVWriter::Str.
   /// The emitted value is preceded with a comma if the actual call is not the
   /// first one for \p this object. Success of the operation is checked at the
   /// end.
   ///
   /// \param V value to write
   void write(const T &V) {
     if (Str) {
       if (!IsFirst) {
         *Str << ',';
       } else {
         IsFirst = false;
       }
       *Str << V;
       if (!Str->good()) {
         Str = nullptr;
       }
     }
   }
 
 private:
   std::ostream *Str; ///< Output stream to write to.
   bool IsFirst;      ///< Denotes if the next write would be the first one.
 };
 
 /// Writes a tuple of values into a CSV file
 ///
 /// \tparam Ts types of values to write
 template <typename... Ts> class CSVTupleWriter {
 
 public:
 
 //    typedef <Ts...> value_type ;  ///< Type of values written.
     typedef std::tuple<Ts...> value_type;
 
     /// Creates a new instance.
     ///
     /// \param [in,out] S output stream to write to
     ///
     /// \note The writer operates on non-binary outputs as long as \p S is in
     /// good state.
     CSVTupleWriter(std::ostream &S)
         : Str(S.good() && !(S.flags() & std::ios::binary) ? &S : nullptr), 
           IsHeaderWritten(false), IsDataWritten(false) {}
 
     /// Tells if the last operation was successful.
     ///
     /// \return if the last operation was successful
     bool good(void) const noexcept {
       return Str != nullptr;
     }
 
 
     /// Write the values of a tuple to a CSV file with \c rosa::csv::CSVTupleWriter.
     ///
     /// \see rosa::csv::CSVTupleWriter
     ///
     /// 
     /// \param [in,out] values tuple, which values are written in a recusive fashion into a stream.
     template<size_t i = 0>
     void write(const std::tuple<Ts...> &values) {
         constexpr size_t size = sizeof...(Ts);
 
         LOG_TRACE_STREAM << "Writing tuple values into file \n"; 
         LOG_TRACE_STREAM << " Tuple has " << std::to_string(size) << " elements. \n";
 
         LOG_TRACE_STREAM << " Value is " << std::get<i>(values);
 
         if(Str){
             /// Write the current element of the tuple into the stream and add a separtor after it, 
             /// and call the function for the next element in the tuple.
             if constexpr(i+1 != sizeof...(Ts)){
                 *Str << std::get<i>(values) << ", ";
                 write<i+1>(values);
             /// If the last element is written into the stream than begin a new line. 
             }else if constexpr(i + 1 == sizeof...(Ts)){
                 *Str << std::get<i>(values) << '\n';
                 /// every time the last data value of a line is written, the flag indicates that data was already written into the file.
                 IsDataWritten = true; 
             }
         }
     }
 
     /// Write the header values to a CSV file with \c rosa::csv::CSVTupleWriter.
     ///
     /// \note The function has no effect if anything has already been written
     /// to the output stream either by \c
     /// rosa::csv::CSVTupleWriter::writeHeader() or \c
     /// rosa::csv::CSVTupleWriter::write().
     ///
     /// \see rosa::csv::CSVTupleWriter
     ///
     /// \param header the content of the header line.
     void writeHeader(const std::array<std::string, sizeof...(Ts)> &header){
         size_t index = 0;
         /// write into the stream only, if it is not a nullptr, and if no data and no header was already written into it. 
         if(Str && IsDataWritten == false && IsHeaderWritten == false){
             index = 0;
             for (auto i = header.begin(); i != header.end(); ++i){
                 index = index + 1;
-                /// write into the stream every entry with a delimeter, in this case ", " until 
+                /// write into the stream every entry with a delimiter, in this case ", " until 
                 /// the last entry
                 if(index != header.size()){
                     *Str << *i << ", ";
-                /// write the last entry into the stream, without any delimeter
+                /// write the last entry into the stream, without any delimiter
                 }else {
                     *Str << *i;
                 }
             }
             /// finish the header line and start a new line.
             *Str << '\n';
             /// now it is not possible to write additional header lines. 
             IsHeaderWritten = true;
         }
     }
 
 private:
     std::ostream *Str;              ///< Output stream to write to.
     bool          IsHeaderWritten;  ///< If an header line was already written into the stream. If set than no additional header could be written.
     bool          IsDataWritten;    ///< If one line of data has already been written into the stream, than no headerline could be added. 
 };
 
 /// Writes all values of a tuple to a CSV file with \c rosa::csv::CSVTupleWriter.
 ///
 /// \see rosa::csv::CSVTupleWriter
 ///
 /// \tparam Ts types of values to write
 ///
 /// \param [in,out] W object to write with
 /// \param V values to write
 ///
 /// \return \p W after writing \p V with it
 template <typename... Ts>
 CSVTupleWriter<Ts...> &operator<<(CSVTupleWriter<Ts...> &W, const std::tuple<Ts...> &V)
 {
     W.write(V);
     return W;
 }
 
 /// Writes a value to a CSV file with \c rosa::csv::CSVWriter.
 ///
 /// \see rosa::csv::CSVWriter
 ///
 /// \tparam T type of value to write
 ///
 /// \param [in,out] W object to write with
 /// \param V value to write
 ///
 /// \return \p W after writing \p V with it
 template <typename T>
 CSVWriter<T> &operator<<(CSVWriter<T> &W, const T& V) {
   W.write(V);
   return W;
 }
 
 } // End namespace csv
 } // End namespace rosa
 
 #endif // ROSA_SUPPORT_CSV_CSVWRITER_HPP