diff --git a/include/rosa/app/Application.hpp b/include/rosa/app/Application.hpp
index e7a80ee..9943e8d 100644
--- a/include/rosa/app/Application.hpp
+++ b/include/rosa/app/Application.hpp
@@ -1,931 +1,939 @@
 //===-- rosa/app/Application.hpp --------------------------------*- C++ -*-===//
 //
 //                                 The RoSA Framework
 //
 // Distributed under the terms and conditions of the Boost Software License 1.0.
 // See accompanying file LICENSE.
 //
 // If you did not receive a copy of the license file, see
 // http://www.boost.org/LICENSE_1_0.txt.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file rosa/app/Application.hpp
 ///
 /// \author David Juhasz (david.juhasz@tuwien.ac.at)
 ///
 /// \date 2017-2020
 ///
 /// \brief Public interface for the *application interface* for working with
 /// agent
 ///        systems.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef ROSA_APP_APPLICATION_HPP
 #define ROSA_APP_APPLICATION_HPP
 
 #include "rosa/app/AppSystem.hpp"
 
 #include "rosa/support/types.hpp"
 
 #include <iterator>
 #include <memory>
 #include <set>
 
 /// Local helper macro to log and return a
 /// \c rosa::app::Application::ErrorCode value.
 ///
 /// Creates a debug message with the stringified value and returns the value.
 ///
 /// \param Err \c rosa::app::Application::ErrorCode value to log and
 /// return
 #define APPRETERROR(Err)                                                       \
   {                                                                            \
     LOG_DEBUG(#Err);                                                           \
     return Err;                                                                \
   }
 
 namespace rosa {
 namespace app {
 
 /// Defines the *application interface*.
 ///
 /// \todo The classes \c rosa::app::AppSensor and \c
 /// rosa::app::AppAgent share some common features in relation to their
 /// *slave* role in the *application interface*. But their definitions are
 /// completely independent. It could be investigated how to lift their common
 /// parts into a new *application slave* class, which would serve as base for
 /// both, to avoid code duplication.
 class Application {
 
   /// A system owned by \p this object.
   ///
   /// \note The reference is kept in a \c std::shared_ptr because of the member
   /// function \c rosa::app::Application::getSystem.
   std::shared_ptr<AppSystem> System;
 
   /// References to all *sensors* and *agents* created by \p this object.
   std::set<AgentHandle> AppUnits;
 
 public:
   /// Errors that may be resulted by some of the member functions of the class.
   enum struct ErrorCode {
     NoError,
     TypeMismatch,
     NotSensor,
     NotAgent,
     NotUnit,
     WrongPosition,
     AlreadyHasSlave,
     AlreadyHasMaster,
     AlreadyHasValueStream,
     UnsuitableExecutionPolicy
   };
 
   /// Returns a new instance of \c rosa::app::Application.
   ///
   /// \param Name name of the underlying \c rosa::AppSystem
   ///
   /// \return \c std::unique_ptr for the new instance of
   /// \c rosa::app::Application with a new, empty \c rosa::AppSystem
   static std::unique_ptr<Application> create(const std::string &Name) noexcept;
 
 private:
   /// Creates a new instance.
   ///
   /// \note Private constructor restricts instantiation to member functions of
   /// the class.
   ///
   /// \param Name name of the underlying \c rosa::MessagingSystem
   Application(const std::string &Name) noexcept;
 
 public:
   /// Destroys \p this object.
   ~Application(void) noexcept;
 
   /// Returns a reference for the underlying \c rosa::MessagingSystem.
   ///
   /// \note One cannot do much with a \c rosa::MessagingSystem currently, this
   /// is for future use.
   ///
   /// \return reference for the underlying \c rosa::MessagingSystem.
   std::weak_ptr<MessagingSystem> getSystem(void) const noexcept;
 
 private:
   /// Creates a new *sensor* in the context of \p this object.
   ///
   /// The new *sensor* handles master-input by \p MF.
   ///
   /// \tparam MT type of master-input the new *sensor* handles
   /// \tparam T type of data the new *sensor* operates on
   ///
   /// \note Instantiation fails if any of the type arguments \p MT and \p T
   /// is not an instance of \c rosa::app::AppTuple or \p T is \c
   /// rosa::app::EmptyAppTuple.
   ///
   /// \param Name name of the new *sensor*
   /// \param MF function for the new *sensors* to process master-input
   /// values with
   /// \param F function for the new *sensor* to generate the next value with
   /// during normal operation
   ///
   /// \note \p F is not used during simulation, in which case
   /// \c rosa::app::Application::registerSensorValues is used to
   /// register an alternative simulation data source with \c
   /// rosa::app::AppSensor::registerSimulationDataSource. One may
   /// safely keep relying on the default value of \p F as long as only
   /// simulation of the system is to be done.
   ///
   /// \see \c rosa::app::AppSensor::AppSensor.
   ///
   /// \return \c rosa::AgentHandle for the new *sensor*
   template <
       typename MT, typename T,
       typename = std::enable_if<TypeListAllAppTuple<TypeList<MT, T>>::Value &&
                                 !std::is_same<T, EmptyAppTuple>::value>>
   AgentHandle createSensorImpl(const std::string &Name,
                                std::function<void(std::pair<MT, bool>)> &&MF,
                                std::function<T(void)> &&F) noexcept;
 
 public:
   /// Creates a new *sensor* in the context of \p this object.
   ///
   /// The new *sensor* does not receive master-input.
   ///
   /// \tparam T type of data the new *sensor* operates on
   ///
   /// \note Instantiation fails if type argument \p T is neither a built-in type
   /// nor an instance of \c rosa::app::AppTuple with at least one element.
   ///
   /// \param Name name of the new *sensor*
   /// \param F function for the new *sensor* to generate the next value with
   /// during normal operation
   ///
   /// \note \p F is not used during simulation, in which case
   /// \c rosa::app::Application::registerSensorValues is used to register
   /// an alternative simulation data source with
   /// \c rosa::app::AppSensor::registerSimulationDataSource. One may
   /// safely keep relying on the default value of \p F as long as only
   /// simulation of the system is to be done.
   ///
   /// \see \c rosa::app::AppSensor::AppSensor.
   ///
   /// \return \c rosa::AgentHandle for the new *sensor*
   template <typename T, typename = std::enable_if_t<
                             TypeListContains<BuiltinTypes, T>::Value ||
                             (IsAppTuple<T>::Value &&
                              !std::is_same<T, EmptyAppTuple>::value)>>
   AgentHandle createSensor(
       const std::string &Name,
       std::function<T(void)> &&F = [](void) { return T(); }) noexcept;
 
   /// Creates a new *sensor* in the context of \p this object.
   ///
   /// The new *sensor* handles master-input by \p MF.
   ///
   /// \tparam MT type of master-input the new *sensor* handles
   /// \tparam T type of data the new *sensor* operates on
   ///
   /// \note The type arguments \p MT and \p T must be either all built-in types
   /// or all instances of \c rosa::app::AppTuple. Moreover, \p T cannot be
   /// \c rosa::app::EmptyAppTuple. Instantiation fails if these conditions
   /// do not hold.
   ///
   /// \param Name name of the new *sensor*
   /// \param MF function for the new *sensors* to process master-input
   /// values with \param F function for the new *sensor* to generate
   /// the next value with during normal operation
   ///
   /// \note \p F is not used during simulation, in which case
   /// \c rosa::app::Application::registerSensorValues is used to
   /// register an alternative simulation data source with \c
   /// rosa::app::AppSensor::registerSimulationDataSource. One may
   /// safely keep relying on the default value of \p F as long as only
   /// simulation of the system is to be done.
   ///
   /// \see \c rosa::app::AppSensor::AppSensor.
   ///
   /// \return \c rosa::AgentHandle for the new *sensor*
   template <typename MT, typename T,
             typename = std::enable_if<
                 TypeListSubsetOf<TypeList<MT, T>, BuiltinTypes>::Value ||
                 (TypeListAllAppTuple<TypeList<MT, T>>::Value &&
                  !std::is_same<T, EmptyAppTuple>::value)>>
   AgentHandle createSensor(
       const std::string &Name, std::function<void(std::pair<MT, bool>)> &&MF,
       std::function<T(void)> &&F = [](void) { return T(); }) noexcept;
 
 private:
   /// Creates a new *agent* in the context of \p this object.
   ///
   /// The new *agent* receives master-input by \p MF and produces
   /// master-output.
   ///
   /// \tparam MT type of master-input the new *agent* handles
   /// \tparam T type of data the new *agent* outputs
   /// \tparam Ts types of master-output the new *agent* produces
   /// \tparam As types of inputs the new *agent* takes
   ///
   /// \note Instantiation fails if any of the type arguments \p MT, \p T, \p
   /// Ts..., and \p As... is not an instance of \c rosa::app::AppTuple or
   /// any of \p T and \p As... is \c rosa::app::EmptyAppTuple.
   ///
   /// \param Name name of the new *agent*
   /// \param MF function for the new *agent* to process master-input
   /// values with \param F function for the new *agent* to process
   /// input values and generate output with
   ///
   /// \see \c rosa::app::AppAgent::AppAgent.
   ///
   /// \return \c rosa::AgentHandle for the new *agent*
   template <typename MT, typename T, typename... Ts, typename... As,
             typename = std::enable_if_t<
                 TypeListAllAppTuple<TypeList<MT, T, Ts..., As...>>::Value &&
                 !std::is_same<T, EmptyAppTuple>::value &&
                 (true && ... && (!std::is_same<As, EmptyAppTuple>::value))>>
   AgentHandle createAgentImpl(
       const std::string &Name,
       std::function<std::tuple<Optional<Ts>...>(std::pair<MT, bool>)> &&MF,
       std::function<std::tuple<Optional<T>, Optional<Ts>...>(
           std::pair<As, bool>...)> &&F) noexcept;
 
 public:
   /// Creates a new *agent* in the context of \p this object.
   ///
   /// The new *agent* neither receives master-input nor produces
   /// master-output.
   ///
   /// \tparam T type of data the new *agent* outputs
   /// \tparam As types of inputs the new *agent* takes
   ///
   /// \note The type arguments \p T and \p As... must be either all built-in
   /// types or all instances of \c rosa::app::AppTuple. Moreover, none of
   /// them can be \c rosa::app::EmptyAppTuple. Instantiation fails if
   /// these conditions do not hold.
   ///
   /// \param Name name of the new *agent*
   /// \param F function for the new *agent* to process input values and
   /// generate output with
   ///
   /// \see \c rosa::app::AppAgent::AppAgent.
   ///
   /// \return \c rosa::AgentHandle for the new *agent*
   template <typename T, typename... As,
             typename = std::enable_if_t<
                 TypeListSubsetOf<TypeList<T, As...>, BuiltinTypes>::Value ||
                 (TypeListAllAppTuple<TypeList<T, As...>>::Value &&
                  !std::is_same<T, EmptyAppTuple>::value &&
                  (true && ... && (!std::is_same<As, EmptyAppTuple>::value)))>>
   AgentHandle
   createAgent(const std::string &Name,
               std::function<Optional<T>(std::pair<As, bool>...)> &&F) noexcept;
 
   /// Creates a new *agent* in the context of \p this object.
   ///
   /// The new *agent* receives master-input by \p MF but does not
   /// produce master-output.
   ///
   /// \tparam MT type of master-input the new *agent* handles
   /// \tparam T type of data the new *agent* outputs
   /// \tparam As types of inputs the new *agent* takes
   ///
   /// \note The type arguments \p MT, \p T, and \p As... must be either all
   /// built-in types or all instances of \c rosa::app::AppTuple. Moreover,
   /// none of \p T and \p As... can be \c rosa::app::EmptyAppTuple.
   /// Instantiation fails if these conditions do not hold.
   ///
   /// \param Name name of the new *agent*
   /// \param MF function for the new *agent* to process master-input
   /// values with
   /// \param F function for the new *agent* to process input values and
   /// generate output with
   ///
   /// \see \c rosa::app::AppAgent::AppAgent.
   ///
   /// \return \c rosa::AgentHandle for the new *agent*
   template <typename MT, typename T, typename... As,
             typename = std::enable_if_t<
                 TypeListSubsetOf<TypeList<MT, T, As...>, BuiltinTypes>::Value ||
                 (TypeListAllAppTuple<TypeList<MT, T, As...>>::Value &&
                  !std::is_same<T, EmptyAppTuple>::value &&
                  (true && ... && (!std::is_same<As, EmptyAppTuple>::value)))>>
   AgentHandle
   createAgent(const std::string &Name,
               std::function<void(std::pair<MT, bool>)> &&MF,
               std::function<Optional<T>(std::pair<As, bool>...)> &&F) noexcept;
 
   /// Creates a new *agent* in the context of \p this object.
   ///
   /// The new *agent* does not receive master-input but produces
   /// master-output.
   ///
   /// \tparam T type of data the new *agent* outputs
   /// \tparam Ts types of master-output the new *agent* produces
   /// \tparam As types of inputs the new *agent* takes
   ///
   /// \note The type arguments \p T, \p Ts, and \p As... must be either all
   /// built-in types or all instances of \c rosa::app::AppTuple. Moreover,
   /// none of \p T and \p As... can be \c rosa::app::EmptyAppTuple.
   /// Instantiation fails if these conditions do not hold.
   ///
   /// \param Name name of the new *agent*
   /// \param F function for the new *agent* to process input values and
   /// generate output with
   ///
   /// \note \p F does not produce master-output for a given position if the
   /// corresponding type is \c rosa::app::EmptyAppTuple. It is not
   /// possible to disable master-output at any position by using built-in types.
   ///
   /// \see \c rosa::app::AppAgent::AppAgent.
   ///
   /// \return \c rosa::AgentHandle for the new *agent*
   template <
       typename T, typename... Ts, typename... As,
       typename = std::enable_if_t<
           TypeListSubsetOf<TypeList<T, Ts..., As...>, BuiltinTypes>::Value ||
           (TypeListAllAppTuple<TypeList<T, Ts..., As...>>::Value &&
            !std::is_same<T, EmptyAppTuple>::value &&
            (true && ... && (!std::is_same<As, EmptyAppTuple>::value)))>>
   AgentHandle
   createAgent(const std::string &Name,
               std::function<std::tuple<Optional<T>, Optional<Ts>...>(
                   std::pair<As, bool>...)> &&F) noexcept;
 
   /// Creates a new *agent* in the context of \p this object.
   ///
   /// The new *agent* receives master-input by \p MF and produces
   /// master-output.
   ///
   /// \tparam MT type of master-input the new *agent* handles
   /// \tparam T type of data the new *agent* outputs
   /// \tparam Ts types of master-output the new *agent* produces
   /// \tparam As types of inputs the new *agent* takes
   ///
   /// \note The type arguments \p MT, \p T, \p Ts, and \p As... must be either
   /// all built-in types or all instances of \c rosa::app::AppTuple.
   /// Moreover, none of \p T and \p As... can be \c
   /// rosa::app::EmptyAppTuple. Instantiation fails if these conditions
   /// do not hold.
   ///
   /// \param Name name of the new *agent*
   /// \param MF function for the new *agent* to process master-input
   /// values with
   /// \param F function for the new *agent* to process input values and
   /// generate output with
   ///
   /// \note \p F does not produce master-output for a given position if the
   /// corresponding type is \c rosa::app::EmptyAppTuple. It is not
   /// possible to disable master-output at any position by using built-in types.
   ///
   /// \see \c rosa::app::AppAgent::AppAgent.
   ///
   /// \return \c rosa::AgentHandle for the new *agent*
   template <typename MT, typename T, typename... Ts, typename... As,
             typename = std::enable_if_t<
                 TypeListSubsetOf<TypeList<MT, T, Ts..., As...>,
                                  BuiltinTypes>::Value ||
                 (TypeListAllAppTuple<TypeList<MT, T, Ts..., As...>>::Value &&
                  !std::is_same<T, EmptyAppTuple>::value &&
                  (true && ... && (!std::is_same<As, EmptyAppTuple>::value)))>>
   AgentHandle createAgent(
       const std::string &Name,
       std::function<std::tuple<Optional<Ts>...>(std::pair<MT, bool>)> &&MF,
       std::function<std::tuple<Optional<T>, Optional<Ts>...>(
           std::pair<As, bool>...)> &&F) noexcept;
 
   /// Returns the current execution policy of the referred \p Unit
   ///
   /// \see \c rosa::app::AppExecutionPolicy
   ///
   /// \note The referred \p Unit is either *sensor* or *agent*.
   ///
   /// \note The returned reference is valid only as long as \c
   /// rosa::app::Application::setExecutionPolicy() is not called with the
   /// *unit* referred by \p Unit and the *unit* is not destroyed.
   ///
   /// \param Unit the *unit* whose execution policy is to be obtained
   ///
   /// \return the \c rosa::app::AppExecutionPolicy from \p Unit if \p Unit
   /// is valid
   Optional<const AppExecutionPolicy &>
   getExecutionPolicy(AgentHandle Unit) const noexcept;
 
   /// Sets the current execution policy of the referred \p Unit to \p
   /// ExecutionPolicy.
   ///
   /// \see \c rosa::app::AppExecutionPolicy
   ///
   /// \note The referred \p Unit is either *sensor* or *agent*.
   ///
   /// \param Unit the *unit* whose execution policy is to be set
   /// \param ExecutionPolicy the new execution policy for \p Unit
   ///
   /// \return how successful setting \p ExecutionPolicy for \p Unit was
   ///
   /// \note The function may return the following
   /// \c rosa::app::Application::ErrorCode values:
   /// `ErrorCode`                 | Comment
   /// -----------                 | -------
   /// `NoError`                   | Success
   /// `NotUnit`                   | Referred \p Unit is not valid
   /// `UnsuitableExecutionPolicy` | \p ExecutionPolicy cannot handle \p Unit
   ErrorCode setExecutionPolicy(
       AgentHandle Unit,
       std::unique_ptr<AppExecutionPolicy> &&ExecutionPolicy) noexcept;
 
   /// Connects a *sensor* to an *agent* in the context of \p this object.
   ///
   /// \param Agent the *agent* to connect to
   /// \param Pos the index of slot of \p Agent to connect \p Sensor to
   /// \param Sensor the *sensor* to connect
   /// \param Description optional textual description of the connection
   ///
   /// \return how successfull connecting \p Sensor to \p Agent at slot
   /// index \p Pos was
   ///
   /// \note The function may return the following
   /// \c rosa::app::Application::ErrorCode values:
   /// `ErrorCode`        | Comment
   /// -----------        | -------
   /// `NoError`          | Success
   /// `NotAgent`         | Referred \p Agent is not \c rosa::app::AppAgent
   /// `NotSensor`        | Referred \p Sensor is not \c rosa::app::AppSensor
   /// `WrongPosition`    | \p Pos is not a valid input position of \p Agent
   /// `TypeMismatch`     | Expected input type at position \p Pos of \p Agent is
   /// other thanthe output type of \p Sensor or expected master-input of \p
   /// Sensor is other than master-output at position \p Pos of \p Agent if any
   /// `AlreadyHasSlave`  | \p Agent at position \p Pos already has a *slave*
   /// registered `AlreadyHasMaster` | \p Sensor already has a *master*
   /// registered
   ErrorCode connectSensor(AgentHandle Agent, const size_t Pos,
                           AgentHandle Sensor,
                           const std::string &Description = "") noexcept;
 
   /// Connectes two *agents* in the context of \p this object.
   ///
   /// \param Master the *agent* to connect to
   /// \param Pos the index of slot of \p Master to connect \p Slave to
   /// \param Slave the *agent* to connect
   /// \param Description optional textual description of the connection
   ///
   /// \return how succesfull connecting \p Slave to \p Master at slot
   /// index \p Pos was
   ///
   /// \note The function may return the following
   /// \c rosa::app::Application::ErrorCode values:
   /// `ErrorCode`        | Comment
   /// -----------        | -------
   /// `NoError`          | Success
   /// `NotAgent`         | Referred \p Master or \p Slave is not \c
   /// rosa::app::AppAgent `WrongPosition`    | \p Pos is not a valid input
   /// position of \p Master `TypeMismatch`     | Expected input type at position
   /// \p Pos of \p Master is other than the output type of \p Slave or expected
   /// master-input of \p Slave is other than master-output at position \p Pos of
   /// \p Master if any `AlreadyHasSlave`  | \p Master at position \p Pos already
   /// has a *slave* registered `AlreadyHasMaster` | \p Slave already has a
   /// *master* registered
   ErrorCode connectAgents(AgentHandle Master, const size_t Pos,
                           AgentHandle Slave,
                           const std::string &Description = "") noexcept;
 
   /// Initializes \c this object and others managed by \p this object
   /// for setting up and performing simulation.
   ///
   /// \see \c rosa::app::Application::registerSensorValues,
   /// \c rosa::app::Application::simulate
   ///
   /// Need to clear simulation data sources from all the *sensors*.
   void initializeSimulation(void) noexcept;
 
-public:
   /// Registers a stream providing values for a *sensor* during
   /// simulation.
   ///
   /// \tparam Iterator type of iterator providing values for \p Sensor
   /// \tparam T type that can be matched to values \p Sensor is operating on,
   /// always use default!
   ///
   /// \note Instantiation fails if type argument \p T is neither a built-in type
   /// nor a tuple (i.e., can be converted to \c rosa::app::AppTuple).
   ///
   /// \param Sensor the *sensor* to register values for
   /// \param Start provides values for \p Sensor
   /// \param End denotes the end of stream of values
   /// \param Default value to be used when input stream is depleted
   /// during simulation
   ///
   /// \return how successful registering \p Source for \p Sensor
   ///
   /// \note The function may return the following
   /// \c rosa::app::Application::ErrorCode values:
   /// `ErrorCode`             | Comment
   /// -----------             | -------
   /// `NoError`               | Success
   /// `TypeMismatch`          | \p T does not match the type of values
   /// generated by \p Sensor
   /// `NotSensor`             | Referred \p Sensor is not \c
   /// rosa::app::AppSensor
   /// `AlreadyHasValueStream` | \p Sensor already has simulation data source set
   template <typename Iterator, typename T = typename Iterator::value_type,
             typename = std::enable_if_t<
                 TypeListContains<BuiltinTypes, T>::Value || IsTuple<T>::Value>>
   ErrorCode registerSensorValues(AgentHandle Sensor, Iterator &&Start,
                                  const Iterator &End, T Default = {}) noexcept;
 
   /// Performs the system contained by \p this object.
   ///
   /// The function performs \p NumCycles cycle of simulation. In each
   /// cycle, all the *agents* and *sensors* registered in \c
   /// rosa::app::Application::AppUnits are trigged for
   /// execution.
   ///
+  /// \note Simulation data sources are cleared at the end of the simulation.
+  ///
   /// \param NumCycles number of cycles to perform
   ///
   /// \pre All the *sensors* in the system contained by \p this object
   /// generate their output from simulation data sources.
-  void simulate(const size_t NumCycles) const noexcept;
+  void simulate(const size_t NumCycles) noexcept;
+
+protected:
+  /// Clears simulation data sources from all the *sensors*.
+  ///
+  /// \see \c rosa::app::Application::initializeSimulation,
+  /// \c rosa::app::Application::simulate
+  void clearSimulationDataSources(void) noexcept;
 };
 
 /// Anonymous namespace with helper features for implementing
 /// \c rosa::app::Application, consider it private.
 namespace {
 
 /// Maps any type \p T to \c rosa::app::EmptyAppTuple.
 template <typename T> struct MapToEmptyAppTuple { using Type = EmptyAppTuple; };
 
 /// Convenience template alias for \c MapToEmptyAppTuple.
 template <typename T> using empty_app_t = typename MapToEmptyAppTuple<T>::Type;
 
 /// Converts a \c std::tuple of \c rosa::Optional built-in types into a
 /// corresponding \c std::tuple of \c rosa::Optional with each actual value
 /// wrapped in \c rosa::app::AppTuple.
 ///
 /// \tparam Ts types of the values
 /// \tparam S0 indices for accessing values in \p Values
 ///
 /// \param Values the \c std::tuple of \c rosa::Optional with built-in values
 ///
 /// \note The second argument provides indices statically as template arguments
 /// \p S0..., so its actual value is ignored.
 ///
 /// \return a \c std::tuple of \c rosa::Optional corresponding to \p Values
 /// with each actual value wrapped in \c rosa::app::AppTuple
 ///
 /// \pre Statically, all type arguments \p Ts... are built-in types and the
 /// provided indices \p S0... match the length of \p Ts...: \code
 /// TypeListSubsetOf<TypeList<Ts...>, BuiltinTypes>::Value &&
 /// sizeof...(Ts) == sizeof...(S0)
 /// \endcode
 template <typename... Ts, size_t... S0>
 std::tuple<Optional<AppTuple<Ts>>...>
 wrapBuiltinInAppTuple(const std::tuple<Optional<Ts>...> &Values,
                       Seq<S0...>) noexcept {
   STATIC_ASSERT((TypeListSubsetOf<TypeList<Ts...>, BuiltinTypes>::Value),
                 "not built-in types");
   STATIC_ASSERT(sizeof...(Ts) == sizeof...(S0), "inconsistent type arguments");
 
   return std::make_tuple(
       std::get<S0>(Values)
           ? Optional<AppTuple<Ts>>(make_app_tuple<Ts>(*std::get<S0>(Values)))
           : Optional<AppTuple<Ts>>()...);
 }
 
 } // End namespace
 
 template <typename MT, typename T, typename>
 AgentHandle
 Application::createSensorImpl(const std::string &Name,
                               std::function<void(std::pair<MT, bool>)> &&MF,
                               std::function<T(void)> &&F) noexcept {
   AgentHandle H = System->createSensor(Name, std::move(MF), std::move(F));
   AppUnits.emplace(H);
   return H;
 }
 
 template <typename T, typename>
 AgentHandle Application::createSensor(const std::string &Name,
                                       std::function<T(void)> &&F) noexcept {
   auto EmptyMF = std::function<void(std::pair<EmptyAppTuple, bool>)>(
       [](std::pair<EmptyAppTuple, bool>) {});
 
   if constexpr (TypeListContains<BuiltinTypes, T>::Value) {
     using OutputType = AppTuple<T>;
     return createSensorImpl(
         Name, std::move(EmptyMF),
         std::function<OutputType(void)>(
             [F{std::move(F)}](void) { return OutputType(F()); }));
 
   } else if constexpr (IsAppTuple<T>::Value &&
                        !std::is_same<T, EmptyAppTuple>::value) {
     return createSensorImpl(Name, std::move(EmptyMF), std::move(F));
 
   } else {
     ASSERT(false && "Unexpected type argument");
   }
 }
 
 template <typename MT, typename T, typename>
 AgentHandle
 Application::createSensor(const std::string &Name,
                           std::function<void(std::pair<MT, bool>)> &&MF,
                           std::function<T(void)> &&F) noexcept {
 
   if constexpr (TypeListSubsetOf<TypeList<MT, T>, BuiltinTypes>::Value) {
     using MasterInputType = AppTuple<MT>;
     using OutputType = AppTuple<T>;
     return createSensorImpl(
         Name,
         std::function<void(std::pair<MasterInputType, bool>)>(
             [MF{std::move(MF)}](std::pair<MasterInputType, bool> Arg) {
               MF({std::get<0>(Arg.first), Arg.second});
             }),
         std::function<OutputType(void)>(
             [F{std::move(F)}](void) { return OutputType(F()); }));
 
   } else if constexpr (TypeListAllAppTuple<TypeList<MT, T>>::Value &&
                        !std::is_same<T, EmptyAppTuple>::value) {
     return createSensorImpl(Name, std::move(MF), std::move(F));
 
   } else {
     ASSERT(false && "Unexpected type arguments");
   }
 }
 
 template <typename MT, typename T, typename... Ts, typename... As, typename>
 AgentHandle Application::createAgentImpl(
     const std::string &Name,
     std::function<std::tuple<Optional<Ts>...>(std::pair<MT, bool>)> &&MF,
     std::function<std::tuple<Optional<T>, Optional<Ts>...>(
         std::pair<As, bool>...)> &&F) noexcept {
   AgentHandle H = System->createAgent(Name, std::move(MF), std::move(F));
   AppUnits.emplace(H);
   return H;
 }
 
 template <typename T, typename... As, typename>
 AgentHandle Application::createAgent(
     const std::string &Name,
     std::function<Optional<T>(std::pair<As, bool>...)> &&F) noexcept {
 
   using NoMasterOutputType = std::tuple<Optional<empty_app_t<As>>...>;
   auto EmptyMF =
       std::function<NoMasterOutputType(std::pair<EmptyAppTuple, bool>)>(
           [](std::pair<EmptyAppTuple, bool>) { return NoMasterOutputType(); });
 
   if constexpr (TypeListSubsetOf<TypeList<T, As...>, BuiltinTypes>::Value) {
     using OutputType = AppTuple<T>;
     return createAgentImpl(
         Name, std::move(EmptyMF),
         std::function<
             std::tuple<Optional<OutputType>, Optional<empty_app_t<As>>...>(
                 std::pair<AppTuple<As>, bool>...)>(
             [F{std::move(F)}](std::pair<AppTuple<As>, bool>... Args) {
               const auto Result = F({std::get<0>(Args.first), Args.second}...);
               return std::tuple_cat(
                   wrapBuiltinInAppTuple(std::tuple(Result), seq_t<1>()),
                   NoMasterOutputType());
             }));
 
   } else if constexpr (TypeListAllAppTuple<TypeList<T, As...>>::Value &&
                        !std::is_same<T, EmptyAppTuple>::value &&
                        (true && ... &&
                         (!std::is_same<As, EmptyAppTuple>::value))) {
     return createAgentImpl(
         Name, std::move(EmptyMF),
         std::function<std::tuple<Optional<T>, Optional<empty_app_t<As>>...>(
             std::pair<As, bool>...)>(
             [F{std::move(F)}](std::pair<As, bool>... Args) {
               const auto Result = F(Args...);
               return std::tuple_cat(std::tuple(Result), NoMasterOutputType());
             }));
 
   } else {
     ASSERT(false && "Unexpected type arguments");
   }
 }
 
 template <typename MT, typename T, typename... As, typename>
 AgentHandle Application::createAgent(
     const std::string &Name, std::function<void(std::pair<MT, bool>)> &&MF,
     std::function<Optional<T>(std::pair<As, bool>...)> &&F) noexcept {
 
   using NoMasterOutputType = std::tuple<Optional<empty_app_t<As>>...>;
 
   if constexpr (TypeListSubsetOf<TypeList<MT, T, As...>, BuiltinTypes>::Value) {
     using MasterInputType = AppTuple<MT>;
     using OutputType = AppTuple<T>;
     return createAgentImpl(
         Name,
         std::function<NoMasterOutputType(std::pair<MasterInputType, bool>)>(
             [MF{std::move(MF)}](std::pair<MasterInputType, bool> Arg) {
               MF({std::get<0>(Arg.first), Arg.second});
               return NoMasterOutputType();
             }),
         std::function<
             std::tuple<Optional<OutputType>, Optional<empty_app_t<As>>...>(
                 std::pair<AppTuple<As>, bool>...)>(
             [F{std::move(F)}](std::pair<AppTuple<As>, bool>... Args) {
               const auto Result = F({std::get<0>(Args.first), Args.second}...);
               return std::tuple_cat(
                   wrapBuiltinInAppTuple(std::tuple(Result), seq_t<1>()),
                   NoMasterOutputType());
             }));
 
   } else if constexpr (TypeListAllAppTuple<TypeList<MT, T, As...>>::Value &&
                        !std::is_same<T, EmptyAppTuple>::value &&
                        (true && ... &&
                         (!std::is_same<As, EmptyAppTuple>::value))) {
     return createAgentImpl(
         Name,
         std::function<NoMasterOutputType(std::pair<MT, bool>)>(
             [MF{std::move(MF)}](std::pair<MT, bool> Arg) {
               MF(Arg);
               return NoMasterOutputType();
             }),
         std::function<std::tuple<Optional<T>, Optional<empty_app_t<As>>...>(
             std::pair<As, bool>...)>(
             [F{std::move(F)}](std::pair<As, bool>... Args) {
               const auto Result = F(Args...);
               return std::tuple_cat(std::tuple(Result), NoMasterOutputType());
             }));
 
   } else {
     ASSERT(false && "Unexpected type arguments");
   }
 }
 
 template <typename T, typename... Ts, typename... As, typename>
 AgentHandle
 Application::createAgent(const std::string &Name,
                          std::function<std::tuple<Optional<T>, Optional<Ts>...>(
                              std::pair<As, bool>...)> &&F) noexcept {
 
   if constexpr (TypeListSubsetOf<TypeList<T, Ts..., As...>,
                                  BuiltinTypes>::Value) {
     using MasterOutputType = std::tuple<Optional<AppTuple<Ts>>...>;
     using OutputType = AppTuple<T>;
     return createAgentImpl(
         Name,
         std::function<MasterOutputType(std::pair<EmptyAppTuple, bool>)>(
             [](std::pair<EmptyAppTuple, bool>) { return MasterOutputType(); }),
         std::function<
             std::tuple<Optional<OutputType>, Optional<AppTuple<Ts>>...>(
                 std::pair<AppTuple<As>, bool>...)>(
             [F{std::move(F)}](std::pair<AppTuple<As>, bool>... Args) {
               const auto Result = F({std::get<0>(Args.first), Args.second}...);
               return wrapBuiltinInAppTuple(Result, seq_t<1 + sizeof...(Ts)>());
             }));
 
   } else if constexpr (TypeListAllAppTuple<TypeList<T, Ts..., As...>>::Value &&
                        !std::is_same<T, EmptyAppTuple>::value &&
                        (true && ... &&
                         (!std::is_same<As, EmptyAppTuple>::value))) {
     using MasterOutputType = std::tuple<Optional<Ts>...>;
     return createAgentImpl(
         Name,
         std::function<MasterOutputType(std::pair<EmptyAppTuple, bool>)>(
             [](std::pair<EmptyAppTuple, bool>) { return MasterOutputType(); }),
         std::function<std::tuple<Optional<T>, Optional<Ts>...>(
             std::pair<As, bool>...)>(
             [F{std::move(F)}](std::pair<As, bool>... Args) {
               const auto Output = F(Args...);
               return Output;
             }));
 
   } else {
     ASSERT(false && "Unexpected type arguments");
   }
 }
 
 template <typename MT, typename T, typename... Ts, typename... As, typename>
 AgentHandle Application::createAgent(
     const std::string &Name,
     std::function<std::tuple<Optional<Ts>...>(std::pair<MT, bool>)> &&MF,
     std::function<std::tuple<Optional<T>, Optional<Ts>...>(
         std::pair<As, bool>...)> &&F) noexcept {
 
   if constexpr (TypeListSubsetOf<TypeList<MT, T, Ts..., As...>,
                                  BuiltinTypes>::Value) {
     using MasterInputType = AppTuple<MT>;
     using MasterOutputType = std::tuple<Optional<AppTuple<Ts>>...>;
     using OutputType = AppTuple<T>;
     return createAgentImpl(
         Name,
         std::function<MasterOutputType(std::pair<MasterInputType, bool>)>(
             [MF{std::move(MF)}](std::pair<MasterInputType, bool> Arg) {
               const auto Result = MF({std::get<0>(Arg.first), Arg.second});
               return wrapBuiltinInAppTuple(Result, seq_t<sizeof...(Ts)>());
             }),
         std::function<
             std::tuple<Optional<OutputType>, Optional<AppTuple<Ts>>...>(
                 std::pair<AppTuple<As>, bool>...)>(
             [F{std::move(F)}](std::pair<AppTuple<As>, bool>... Args) {
               const auto Result = F({std::get<0>(Args.first), Args.second}...);
               return wrapBuiltinInAppTuple(Result, seq_t<1 + sizeof...(Ts)>());
             }));
 
   } else if constexpr (TypeListAllAppTuple<
                            TypeList<MT, T, Ts..., As...>>::Value &&
                        !std::is_same<T, EmptyAppTuple>::value &&
                        (true && ... &&
                         (!std::is_same<As, EmptyAppTuple>::value))) {
     using MasterOutputType = std::tuple<Optional<Ts>...>;
     return createAgentImpl(
         Name,
         std::function<MasterOutputType(std::pair<MT, bool>)>(
             [MF{std::move(MF)}](std::pair<MT, bool> Arg) {
               const auto Output = MF(Arg);
               return Output;
             }),
         std::function<std::tuple<Optional<T>, Optional<Ts>...>(
             std::pair<As, bool>...)>(
             [F{std::move(F)}](std::pair<As, bool>... Args) {
               const auto Output = F(Args...);
               return Output;
             }));
 
   } else {
     ASSERT(false && "Unexpected type arguments");
   }
 }
 
 template <typename Iterator, typename T, typename>
 Application::ErrorCode
 Application::registerSensorValues(AgentHandle Sensor, Iterator &&Start,
                                   const Iterator &End, T Default) noexcept {
   // Get the type of values provided by \p Iterator.
   STATIC_ASSERT((std::is_same<T, typename Iterator::value_type>::value),
                 "type mismatch");
 
   // Make sure preconditions are met.
   if (!System->isAppSensor(Sensor)) {
     APPRETERROR(ErrorCode::NotSensor);
   }
   auto S = System->getAppSensor(Sensor);
   ASSERT(S); // Sanity check.
 
   if (S->simulationDataSourceIsSet()) {
     APPRETERROR(ErrorCode::AlreadyHasValueStream);
   }
 
   if constexpr (TypeListContains<BuiltinTypes, T>::Value) {
     if (S->OutputType != TypeToken<T>::Value) {
       APPRETERROR(ErrorCode::TypeMismatch);
     }
 
     // Register input stream.
     // \note Need to capture parameters by value so having local copies.
     S->registerSimulationDataSource(std::function<AppTuple<T>(void)>([=
     ](void) mutable noexcept->AppTuple<T> {
       if (Start != End) {
         LOG_TRACE_STREAM << "Reading next value for sensor '" << S->FullName
                          << "': " << PRINTABLE(*Start) << '\n';
         return make_app_tuple<T>(*Start++);
       } else {
         LOG_TRACE_STREAM << "Providing default value for sensor '"
                          << S->FullName << "': " << PRINTABLE(Default) << '\n';
         return make_app_tuple<T>(Default);
       }
     }));
 
   } else if constexpr (IsTuple<T>::Value) {
 
     using TT = matching_app_tuple_t<T>;
     if (std::is_same<T, EmptyAppTuple>::value || S->OutputType != TT::TT) {
       APPRETERROR(ErrorCode::TypeMismatch);
     }
 
     // Register input stream.
     // \note Need to capture parameters by value so having local copies.
     S->registerSimulationDataSource(
         std::function<TT(void)>([=](void) mutable noexcept->TT {
           if (Start != End) {
             const TT AV(*Start++);
             LOG_TRACE_STREAM << "Reading next value for sensor '" << S->FullName
                              << "': " << PRINTABLE(AV) << '\n';
             return AV;
           } else {
             static const TT AD(Default);
             LOG_TRACE_STREAM << "Providing default value for sensor '"
                              << S->FullName << "': " << PRINTABLE(AD) << '\n';
             return AD;
           }
         }));
 
   } else {
     ASSERT(false && "Unexpected type argument");
   }
 
   return ErrorCode::NoError;
 }
 
 } // End namespace app
 } // End namespace rosa
 
 // Undef local macro if not used in the corresponding implementation.
 #ifndef ROSA_LIB_APP_APPLICATION_CPP
 #undef APPRETERROR
 #endif
 
 #endif // ROSA_APP_APPLICATION_HPP
diff --git a/lib/app/Application.cpp b/lib/app/Application.cpp
index 38d3b8f..1bce142 100644
--- a/lib/app/Application.cpp
+++ b/lib/app/Application.cpp
@@ -1,224 +1,233 @@
 //===-- app/Application.cpp -------------------------------------*- C++ -*-===//
 //
 //                                 The RoSA Framework
 //
 // Distributed under the terms and conditions of the Boost Software License 1.0.
 // See accompanying file LICENSE.
 //
 // If you did not receive a copy of the license file, see
 // http://www.boost.org/LICENSE_1_0.txt.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file app/Application.cpp
 ///
 /// \author David Juhasz (david.juhasz@tuwien.ac.at)
 ///
 /// \date 2017-2020
 ///
 /// \brief Implementation for rosa/app/Application.hpp.
 ///
 //===----------------------------------------------------------------------===//
 
 #define ROSA_LIB_APP_APPLICATION_CPP // For including helper macros.
 
 #include "rosa/app/Application.hpp"
 
 #include <algorithm>
 #include <sstream>
 
 namespace rosa {
 namespace app {
 
 std::unique_ptr<Application>
 Application::create(const std::string &Name) noexcept {
   return std::unique_ptr<Application>(new Application(Name));
 }
 
 Application::Application(const std::string &Name) noexcept
     : System(AppSystem::createSystem(Name)) {
   LOG_TRACE("Application for '" + System->name() + "' is created.");
 }
 
 Application::~Application(void) noexcept {
   // \c rosa::app::Application::System is not used outside, just clean it.
   for (auto U : AppUnits) {
     System->destroyAgent(U);
   }
   // \note \c System will be marked clean by SystemImpl::~SystemImpl.
   LOG_TRACE("Application for '" + System->name() +
             "' prepared for destruction.");
 }
 
 Optional<const AppExecutionPolicy &>
 Application::getExecutionPolicy(AgentHandle Unit) const noexcept {
   if (System->isAppSensor(Unit)) {
     return {System->getAppSensor(Unit)->executionPolicy()};
   } else if (System->isAppAgent(Unit)) {
     return {System->getAppAgent(Unit)->executionPolicy()};
   } else {
     return {};
   }
 }
 
 Application::ErrorCode Application::setExecutionPolicy(
     AgentHandle Unit,
     std::unique_ptr<AppExecutionPolicy> &&ExecutionPolicy) noexcept {
   // Generate trace log.
   auto &Trace = LOG_TRACE_STREAM;
   Trace << "Setting execution policy of " << System->unwrapAgent(Unit).FullName
         << " to ";
   if (ExecutionPolicy) {
     Trace << "'" << ExecutionPolicy->dump() << "'\n";
   } else {
     Trace << "[]\n";
     APPRETERROR(ErrorCode::UnsuitableExecutionPolicy);
   }
 
   if (System->isAppSensor(Unit)) {
     const bool Success = System->getAppSensor(Unit)->setExecutionPolicy(
         std::move(ExecutionPolicy));
     if (!Success) {
       APPRETERROR(ErrorCode::UnsuitableExecutionPolicy);
     } else {
       return ErrorCode::NoError;
     }
   } else if (System->isAppAgent(Unit)) {
     const bool Success = System->getAppAgent(Unit)->setExecutionPolicy(
         std::move(ExecutionPolicy));
     if (!Success) {
       APPRETERROR(ErrorCode::UnsuitableExecutionPolicy);
     } else {
       return ErrorCode::NoError;
     }
   } else {
     APPRETERROR(ErrorCode::NotUnit);
   }
 }
 
 Application::ErrorCode
 Application::connectSensor(AgentHandle Agent, const size_t Pos,
                            AgentHandle Sensor,
                            const std::string &Description) noexcept {
   // Generate trace log.
   auto &Trace = LOG_TRACE_STREAM;
   Trace << "Establishing connection";
   if (!Description.empty()) {
     Trace << " '" << Description << "'";
   }
   Trace << " between '" << System->unwrapAgent(Sensor).FullName << "' and '"
         << System->unwrapAgent(Agent).FullName << "'\n";
 
   // Make sure preconditions are met.
   if (!System->isAppAgent(Agent)) {
     APPRETERROR(ErrorCode::NotAgent);
   } else if (!System->isAppSensor(Sensor)) {
     APPRETERROR(ErrorCode::NotSensor);
   }
   auto A = System->getAppAgent(Agent);
   auto S = System->getAppSensor(Sensor);
   ASSERT(A && S); // Sanity check.
   if (Pos >= A->NumberOfInputs) {
     APPRETERROR(ErrorCode::WrongPosition);
   } else if (A->inputType(Pos) != S->OutputType ||
              (!emptyToken(A->masterOutputType(Pos)) &&
               A->masterOutputType(Pos) != S->MasterInputType)) {
     APPRETERROR(ErrorCode::TypeMismatch);
   } else if (A->slave(Pos)) {
     APPRETERROR(ErrorCode::AlreadyHasSlave);
   } else if (S->master()) {
     APPRETERROR(ErrorCode::AlreadyHasMaster);
   }
 
   // Do register.
   A->registerSlave(Pos, {Sensor});
   S->registerMaster({Agent});
 
   return ErrorCode::NoError;
 }
 
 Application::ErrorCode
 Application::connectAgents(AgentHandle Master, const size_t Pos,
                            AgentHandle Slave,
                            const std::string &Description) noexcept {
   // Generate trace log.
   auto &Trace = LOG_TRACE_STREAM;
   Trace << "Establishing connection";
   if (!Description.empty()) {
     Trace << " '" << Description << "'";
   }
   Trace << " between '" << System->unwrapAgent(Slave).FullName << "' and '"
         << System->unwrapAgent(Master).FullName << "'\n";
 
   // Make sure preconditions are met.
   if (!(System->isAppAgent(Master) && System->isAppAgent(Slave))) {
     APPRETERROR(ErrorCode::NotAgent);
   }
   auto M = System->getAppAgent(Master);
   auto S = System->getAppAgent(Slave);
   ASSERT(M && S); // Sanity check.
   if (Pos >= M->NumberOfInputs) {
     APPRETERROR(ErrorCode::WrongPosition);
   } else if (M->inputType(Pos) != S->OutputType ||
              (!emptyToken(M->masterOutputType(Pos)) &&
               M->masterOutputType(Pos) != S->MasterInputType)) {
     APPRETERROR(ErrorCode::TypeMismatch);
   } else if (M->slave(Pos)) {
     APPRETERROR(ErrorCode::AlreadyHasSlave);
   } else if (S->master()) {
     APPRETERROR(ErrorCode::AlreadyHasMaster);
   }
 
   // Do register.
   M->registerSlave(Pos, {Slave});
   S->registerMaster({Master});
 
   return ErrorCode::NoError;
 }
 
 std::weak_ptr<MessagingSystem> Application::getSystem(void) const noexcept {
   return std::weak_ptr<MessagingSystem>(System);
 }
 
 void Application::initializeSimulation(void) noexcept {
-  LOG_INFO_STREAM << "Initializing simulation for " << System->name()
-                  << ". Clearing all data sources.\n";
+  LOG_INFO_STREAM << "Initializing simulation for " << System->name() << ".\n";
   // Clear simulation data sources from sensors.
-  for (auto U : AppUnits) {
-    if (auto S = System->getAppSensor(U)) {
-      S->clearSimulationDataSource();
-    }
-  }
+  clearSimulationDataSources();
 }
 
-void Application::simulate(const size_t NumCycles) const noexcept {
+void Application::simulate(const size_t NumCycles) noexcept {
+  LOG_INFO_STREAM << "Simulating " << System->name() << "...\n";
   DEBUG(for (auto H
              : AppUnits) {
     std::stringstream Message;
     Message << System->unwrapAgent(H).FullName << " is an App "
             << " " << (System->isAppSensor(H) ? "Sensor" : "Agent");
     if (System->isAppSensor(H))
       Message << " with it's data source "
               << (!System->getAppSensor(H)->simulationDataSourceIsSet()
                       ? "not "
                       : "set");
     Message << '\n';
     LOG_TRACE_STREAM << Message.str();
   });
 
   ASSERT(
       std::all_of(AppUnits.begin(), AppUnits.end(), [&](const AgentHandle &H) {
         return System->isAppAgent(H) ||
                System->isAppSensor(H) &&
                    System->getAppSensor(H)->simulationDataSourceIsSet();
       }));
   for (size_t I = 1; I <= NumCycles; ++I) {
-    LOG_TRACE("Simulation cycle: " + std::to_string(I));
+    LOG_INFO("Simulation cycle: " + std::to_string(I));
     for (auto U : AppUnits) {
       U.sendMessage(Message::create(atoms::Trigger::Value));
     }
   }
+  LOG_INFO_STREAM << "Simulation done.\n";
+
+  // Clear simulation data sources from sensors.
+  clearSimulationDataSources();
+}
+
+void Application::clearSimulationDataSources(void) noexcept {
+  LOG_INFO_STREAM << "Clearing data sources in " << System->name() << ".\n";
+  for (auto U : AppUnits) {
+    if (auto S = System->getAppSensor(U)) {
+      S->clearSimulationDataSource();
+    }
+  }
 }
 
 } // End namespace app
 } // End namespace rosa