diff --git a/apps/ccam/CMakeLists.txt b/apps/ccam/CMakeLists.txt index 004f0aa..0f634a9 100644 --- a/apps/ccam/CMakeLists.txt +++ b/apps/ccam/CMakeLists.txt @@ -1,11 +1,12 @@ if ( ROSA_COMPILER_IS_GCC_COMPATIBLE ) # Allow exceptions by removing restricting flag (needed by cxxopts) remove("-fno-exceptions" CMAKE_CXX_FLAGS) endif() set(SOURCES configuration.h) +set(SOURCES statehandlerutils.h) ROSA_add_app(ccam ccam.cpp) ROSA_add_library_dependencies(ccam ROSAConfig) ROSA_add_library_dependencies(ccam ROSADeluxe) ROSA_add_library_dependencies(ccam ROSAAgent) diff --git a/apps/ccam/ccam.cpp b/apps/ccam/ccam.cpp index bba45e6..f3d94fd 100644 --- a/apps/ccam/ccam.cpp +++ b/apps/ccam/ccam.cpp @@ -1,346 +1,309 @@ //===-- 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 #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 #include #include #include #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"; -using SignalStateTuple = DeluxeTuple; - -AgentHandle createSignalStateDetectorAgent( - std::unique_ptr &C, const std::string &Name, - std::shared_ptr< - SignalStateDetector> - SigSD) { - (void)SigSD; - - using Input = std::pair, bool>; - using Result = Optional; - using Handler = std::function; - - return C->createAgent( - Name, Handler([&Name, &SigSD](Input I) -> Result { - LOG_INFO_STREAM << "\n******\n" - << Name << " " << (I.second ? "" : "") - << " 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.SignalStateID, - StateInfo.SignalStateConfidence, - (uint8_t)StateInfo.SignalStateCondition, - StateInfo.NumberOfInsertedSamplesAfterEntrance, - StateInfo.SignalStateIsValid, - StateInfo.SignalStateJustGotValid, - StateInfo.SignalStateIsValidAfterReentrance, - StateInfo.SignalIsStable}; - return Result(res); - } - return Result(); - })); -} - int main(int argc, char **argv) { 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 C = DeluxeContext::create(AppName); LOG_INFO("Creating sensors, SignalStateDetector functionalities and their " "Abstractions."); std::vector Sensors; std::vector>> SampleMatchesFunctions; std::vector>> SampleMismatchesFunctions; std::vector>> SignalIsStableFunctions; std::vector>> SignalIsDriftingFunctions; std::vector>> NumOfSamplesMatchFunctions; std::vector>> NumOfSamplesMismatchFunctions; std::vector>> SignalStateDetectors; std::vector SignalStateDetectorAgents; for (auto SignalConfiguration : AppConfig.SignalConfigurations) { // // Create deluxe sensors. // Sensors.emplace_back(C->createSensor(SignalConfiguration.Name)); // // Create functionalities for SignalStateDetector. // SampleMatchesFunctions.emplace_back(new PartialFunction( { {{-SignalConfiguration.OuterBound, -SignalConfiguration.InnerBound}, std::make_shared>( -SignalConfiguration.OuterBound, 0.f, -SignalConfiguration.InnerBound, 1.f)}, {{-SignalConfiguration.InnerBound, SignalConfiguration.InnerBound}, std::make_shared>(1.f, 0.f)}, {{SignalConfiguration.InnerBound, SignalConfiguration.OuterBound}, std::make_shared>( SignalConfiguration.InnerBound, 1.f, SignalConfiguration.OuterBound, 0.f)}, }, 0)); SampleMismatchesFunctions.emplace_back(new PartialFunction( { {{-SignalConfiguration.OuterBound, -SignalConfiguration.InnerBound}, std::make_shared>( -SignalConfiguration.OuterBound, 1.f, -SignalConfiguration.InnerBound, 0.f)}, {{-SignalConfiguration.InnerBound, SignalConfiguration.InnerBound}, std::make_shared>(0.f, 0.f)}, {{SignalConfiguration.InnerBound, SignalConfiguration.OuterBound}, std::make_shared>( SignalConfiguration.InnerBound, 0.f, SignalConfiguration.OuterBound, 1.f)}, }, 1)); SignalIsStableFunctions.emplace_back(new PartialFunction( { {{-SignalConfiguration.OuterBoundDrift, -SignalConfiguration.InnerBoundDrift}, std::make_shared>( -SignalConfiguration.OuterBoundDrift, 0.f, -SignalConfiguration.InnerBoundDrift, 1.f)}, {{-SignalConfiguration.InnerBoundDrift, SignalConfiguration.InnerBoundDrift}, std::make_shared>(1.f, 0.f)}, {{SignalConfiguration.InnerBoundDrift, SignalConfiguration.OuterBoundDrift}, std::make_shared>( SignalConfiguration.InnerBoundDrift, 1.f, SignalConfiguration.OuterBoundDrift, 0.f)}, }, 0)); SignalIsDriftingFunctions.emplace_back(new PartialFunction( { {{-SignalConfiguration.OuterBoundDrift, -SignalConfiguration.InnerBoundDrift}, std::make_shared>( -SignalConfiguration.OuterBoundDrift, 1.f, -SignalConfiguration.InnerBoundDrift, 0.f)}, {{-SignalConfiguration.InnerBoundDrift, SignalConfiguration.InnerBoundDrift}, std::make_shared>(0.f, 0.f)}, {{SignalConfiguration.InnerBoundDrift, SignalConfiguration.OuterBoundDrift}, std::make_shared>( SignalConfiguration.InnerBoundDrift, 0.f, SignalConfiguration.OuterBoundDrift, 1.f)}, }, 1)); NumOfSamplesMatchFunctions.emplace_back(new StepFunction( 1.0f / SignalConfiguration.SampleHistorySize, StepDirection::StepUp)); NumOfSamplesMismatchFunctions.emplace_back(new StepFunction( 1.0f / SignalConfiguration.SampleHistorySize, StepDirection::StepDown)); // // Create SignalStateDetector functionality // SignalStateDetectors.emplace_back( new SignalStateDetector( std::numeric_limits::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())); // // 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); } std::shared_ptr> BrokenDelayFunction( new PartialFunction( {{{0, AppConfig.BrokenCounter}, std::make_shared>( 0, 0.f, AppConfig.BrokenCounter, 1.f)}, {{AppConfig.BrokenCounter, std::numeric_limits::max()}, std::make_shared>(1.f, 0.f)}}, 0)); std::shared_ptr> OkDelayFunction( new PartialFunction( {{{0, AppConfig.BrokenCounter}, std::make_shared>( 0, 1.f, AppConfig.BrokenCounter, 0.f)}, {{AppConfig.BrokenCounter, std::numeric_limits::max()}, std::make_shared>(0.f, 0.f)}}, 1)); std::shared_ptr< SystemStateDetector> SystemStateDetectorF( new SystemStateDetector( std::numeric_limits::max(), BrokenDelayFunction, OkDelayFunction)); // // Create a high-level deluxe agent. // LOG_INFO("Create high-level agent."); // The new agent logs its input values and results in the the sum of them. /** AgentHandle BodyAgent = C->createAgent( "Body Agent", DeluxeAgent::D( [](std::pair HR, std::pair BR, std::pair SpO2, std::pair BPSys, std::pair BodyTemp) -> Optional { LOG_INFO_STREAM << "\n*******\nBody Agent trigged with values:\n" << (HR.second ? "" : "") << " HR warning score: " << HR.first << "\n" << (BR.second ? "" : "") << " BR warning score: " << BR.first << "\n" << (SpO2.second ? "" : "") << " SpO2 warning score: " << SpO2.first << "\n" << (BPSys.second ? "" : "") << " BPSys warning score: " << BPSys.first << "\n" << (BodyTemp.second ? "" : "") << " BodyTemp warning score: " << BodyTemp.first << "\n******\n"; return {HR.first + BR.first + SpO2.first + BPSys.first + BodyTemp.first}; })); */ // // Connect low-level agents to the high-level agent. // LOG_INFO("Connect low-level agents to the high-level agent."); /// C->connectAgents(BodyAgent, 0, HRAgent, "HR Agent Channel"); // // 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 ScoreCSV(ScoreCSVPath); /// csv::CSVWriter ScoreWriter(ScoreCSV); // The agent writes each new input value into a CSV file and produces nothing. /** AgentHandle LoggerAgent = C->createAgent( "Logger Agent", DeluxeAgent::D( [&ScoreWriter](std::pair Score) -> Optional { if (Score.second) { // The state of \p ScoreWriter is not checked, expecting good. ScoreWriter << Score.first; } return {}; })); */ // // Connect the high-level agent to the logger agent. // LOG_INFO("Connect the high-level agent to the logger agent."); /// C->connectAgents(LoggerAgent, 0, BodyAgent, "Body Agent 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(NumberOfSimulationCycles); return 0; } diff --git a/apps/ccam/statehandlerutils.h b/apps/ccam/statehandlerutils.h new file mode 100644 index 0000000..641d7b4 --- /dev/null +++ b/apps/ccam/statehandlerutils.h @@ -0,0 +1,102 @@ +#ifndef STATEHANDLERUTILS_H +#define STATEHANDLERUTILS_H +#include "rosa/agent/Abstraction.hpp" +#include "rosa/agent/Confidence.hpp" +#include "rosa/agent/FunctionAbstractions.hpp" +#include + +#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 +#include +#include +#include +using namespace rosa; +using namespace rosa::agent; +using namespace rosa::deluxe; +using namespace rosa::terminal; + +#endif // STATEHANDLERUTILS_H + +using SignalStateTuple = DeluxeTuple; + +using SystemStateTuple = DeluxeTuple; + +AgentHandle createSignalStateDetectorAgent( + std::unique_ptr &C, const std::string &Name, + std::shared_ptr< + SignalStateDetector> + SigSD) { + + using Input = std::pair, bool>; + using Result = Optional; + using Handler = std::function; + + return C->createAgent( + Name, Handler([&Name, &SigSD](Input I) -> Result { + LOG_INFO_STREAM << "\n******\n" + << Name << " " << (I.second ? "" : "") + << " 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.SignalStateID, + StateInfo.SignalStateConfidence, + (uint8_t)StateInfo.SignalStateCondition, + StateInfo.NumberOfInsertedSamplesAfterEntrance, + StateInfo.SignalStateIsValid, + StateInfo.SignalStateJustGotValid, + StateInfo.SignalStateIsValidAfterReentrance, + StateInfo.SignalIsStable}; + return Result(res); + } + return Result(); + })); +} + +AgentHandle createSystemStateDetectorAgent1( + std::unique_ptr &C, const std::string &Name, + std::shared_ptr< + SystemStateDetector> + SysSD) { + + using Input = std::pair; + using Result = Optional; + using Handler = std::function; + + return C->createAgent( + Name, Handler([&Name, &SysSD](Input I) -> Result { + LOG_INFO_STREAM << "\n******\n" + << Name << " " << (I.second ? "" : "") + << " value: " << std::get<0>(I.first) << "\n******\n"; + + auto StateInfo = SysSD->detectSystemState(); + //auto StateInfo = SigSD->detectSignalState(std::get<0>(I.first)); + + if (I.second) { + SignalStateTuple res = { + std::get<0>(I.first), + StateInfo.SignalStateID, + StateInfo.SignalStateConfidence, + (uint8_t)StateInfo.SignalStateCondition, + StateInfo.NumberOfInsertedSamplesAfterEntrance, + StateInfo.SignalStateIsValid, + StateInfo.SignalStateJustGotValid, + StateInfo.SignalStateIsValidAfterReentrance, + StateInfo.SignalIsStable}; + return Result(res); + } + return Result(); + })); +}