diff --git a/lib/deluxe/DeluxeContext.cpp b/lib/deluxe/DeluxeContext.cpp
index ef3434d..b3da8f7 100755
--- a/lib/deluxe/DeluxeContext.cpp
+++ b/lib/deluxe/DeluxeContext.cpp
@@ -1,151 +1,151 @@
 //===-- deluxe/DeluxeContext.cpp --------------------------------*- C++ -*-===//
 //
 //                                 The RoSA Framework
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file deluxe/DeluxeContext.cpp
 ///
 /// \author David Juhasz (david.juhasz@tuwien.ac.at)
 ///
 /// \date 2017
 ///
 /// \brief Implementation for rosa/deluxe/DeluxeContext.hpp.
 ///
 //===----------------------------------------------------------------------===//
 
 #define ROSA_LIB_DELUXE_DELUXECONTEXT_CPP // For including helper macros.
 
 #include "rosa/deluxe/DeluxeContext.hpp"
 
 #include <algorithm>
 
 namespace rosa {
 namespace deluxe {
 
 std::unique_ptr<DeluxeContext>
 DeluxeContext::create(const std::string &Name) noexcept {
   return std::unique_ptr<DeluxeContext>(new DeluxeContext(Name));
 }
 
 DeluxeContext::DeluxeContext(const std::string &Name) noexcept
     : System(DeluxeSystem::createSystem(Name)) {
   LOG_TRACE("DeluxeContext for '" + System->name() + "' is created.");
 }
 
 DeluxeContext::~DeluxeContext(void) noexcept {
   // \c rosa::deluxe::DeluxeContext::System is not used outside, just clean it.
   for(auto U : DeluxeUnits) {
     System->destroyAgent(U);
   }
   // \note \c System will be marked clean by SystemImpl::~SystemImpl.
   LOG_TRACE("DeluxeContext for '" + System->name() +
             "' prepared for destruction.");
 }
 
 DeluxeContext::ErrorCode
 DeluxeContext::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->isDeluxeAgent(Agent)) {
     DCRETERROR(ErrorCode::NotAgent);
   } else if (!System->isDeluxeSensor(Sensor)) {
     DCRETERROR(ErrorCode::NotSensor);
   }
   auto A = System->getDeluxeAgent(Agent);
   auto S = System->getDeluxeSensor(Sensor);
   ASSERT(A && S); // Sanity check.
   if (Pos >= A->NumberOfInputs) {
     DCRETERROR(ErrorCode::WrongPosition);
   } else if (A->inputType(Pos) != S->OutputType) {
     DCRETERROR(ErrorCode::TypeMismatch);
   } else if (A->slave(Pos)) {
     DCRETERROR(ErrorCode::AlreadyHasSlave);
   } else if (S->master()) {
     DCRETERROR(ErrorCode::AlreadyHasMaster);
   }
 
   // Do register.
   A->registerSlave(Pos, {Sensor});
   S->registerMaster({Agent});
 
   return ErrorCode::NoError;
 }
 
 DeluxeContext::ErrorCode
 DeluxeContext::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->isDeluxeAgent(Master) && System->isDeluxeAgent(Slave))) {
     DCRETERROR(ErrorCode::NotAgent);
   }
   auto M = System->getDeluxeAgent(Master);
-  auto S = System->getDeluxeSensor(Slave);
+  auto S = System->getDeluxeAgent(Slave);
   ASSERT(M && S); // Sanity check.
   if (Pos >= M->NumberOfInputs) {
     DCRETERROR(ErrorCode::WrongPosition);
   } else if (M->inputType(Pos) != S->OutputType) {
     DCRETERROR(ErrorCode::TypeMismatch);
   } else if (M->slave(Pos)) {
     DCRETERROR(ErrorCode::AlreadyHasSlave);
   } else if (S->master()) {
     DCRETERROR(ErrorCode::AlreadyHasMaster);
   }
 
   // Do register.
   M->registerSlave(Pos, {Slave});
   S->registerMaster({Master});
 
   return ErrorCode::NoError;
 }
 
 std::weak_ptr<MessagingSystem> DeluxeContext::getSystem(void) const noexcept {
   return std::weak_ptr<MessagingSystem>(System);
 }
 
 void DeluxeContext::initializeSimulation(void) noexcept {
   // Clear simulation data sources from sensors.
   for (auto U : DeluxeUnits) {
     if (auto S = System->getDeluxeSensor(U)) {
       S->clearSimulationDataSource();
     }
   }
 }
 
 void DeluxeContext::simulate(const size_t NumCycles) const noexcept {
   ASSERT(std::all_of(
       DeluxeUnits.begin(), DeluxeUnits.end(), [&](const AgentHandle &H) {
         return System->isDeluxeAgent(H) ||
                System->isDeluxeSensor(H) &&
                    System->getDeluxeSensor(H)->simulationDataSourceIsSet();
       }));
   for (size_t I = 1; I <= NumCycles; ++I) {
     LOG_TRACE("Simulation cycle: " + std::to_string(I));
     for (auto U : DeluxeUnits) {
       U.sendMessage(Message::create(atoms::Trigger::Value));
     }
   }
 }
 
 } // End namespace deluxe
 } // End namespace rosa