No OneTemporary
Actions

Size

33 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/apps/ccam/ccam.cpp b/apps/ccam/ccam.cpp
	index 983a106..07623fb 100644
	--- a/apps/ccam/ccam.cpp
	+++ b/apps/ccam/ccam.cpp
	@@ -1,386 +1,387 @@
	//===-- 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"

	using namespace rosa;
	using namespace rosa::agent;
	using namespace rosa::deluxe;
	using namespace rosa::terminal;

	const std::string AppName = "CCAM";

	//@maxi I don't know what you want to do but if you want to have the agent be a
	//"lowlevel" agent which gives its master a tuple with all of that info you have
	// to do it as it is done in the #else. To be fair I don't know if the return
	// SignalStateTuple(); is allowed
	/*
	#if false
	using SignalStateTuple =
	std::tuple<Optional<float>, Optional<unsigned int>, Optional<float>,
	Optional<uint8_t>, Optional<unsigned int>, Optional<bool>,
	Optional<bool>, Optional<bool>, Optional<bool>>;

	AgentHandle createSignalStateDetectorAgent(
	std::unique_ptr<DeluxeContext> &C, const std::string &Name,
	std::shared_ptr<
	SignalStateDetector<float, float, float, HistoryPolicy::FIFO>>
	SigSD) {
	(void)SigSD;

	using Handler = std::function<SignalStateTuple(std::pair<float, bool>)>;

	return C->createAgent(
	Name,
	Handler([&Name, &SigSD](std::pair<float, bool> I) -> SignalStateTuple {
	LOG_INFO_STREAM << "\n******\n"
	<< Name << " " << (I.second ? "<New>" : "<Old>")
	<< " value: " << I.first << "\n******\n";
	auto StateInfo = SigSD->detectSignalState(I.first);

	if (I.second)
	return std::make_tuple(
	Optional<float>(I.first),
	Optional<unsigned int>(StateInfo.SignalStateID),
	Optional<float>(StateInfo.SignalStateConfidence),
	Optional<uint8_t>(StateInfo.SignalStateCondition),
	Optional<unsigned int>(
	StateInfo.NumberOfInsertedSamplesAfterEntrance),
	Optional<bool>(StateInfo.SignalStateIsValid),
	Optional<bool>(StateInfo.SignalStateJustGotValid),
	Optional<bool>(StateInfo.SignalStateIsValidAfterReentrance),
	Optional<bool>(StateInfo.SignalIsStable));
	return SignalStateTuple();
	}));
	}
	#else

	using tup = DeluxeTuple<float, unsigned int, float, uint8_t, unsigned int, bool,
	bool, bool, bool>;
	using SignalStateTuple = Optional<tup>;

	AgentHandle createSignalStateDetectorAgent(
	std::unique_ptr<DeluxeContext> &C, const std::string &Name,
	std::shared_ptr<
	SignalStateDetector<float, float, float, HistoryPolicy::FIFO>>
	SigSD) {
	(void)SigSD;
	using Handler =
	std::function<SignalStateTuple(std::pair<DeluxeTuple<float>, bool>)>;
	return C->createAgent(
	Name,
	Handler([&Name, &SigSD](
	std::pair<DeluxeTuple<float>, bool> I) -> SignalStateTuple {
	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)

	return {tup(
	std::get<0>(I.first), StateInfo.SignalStateID,
	StateInfo.SignalStateConfidence, StateInfo.SignalStateCondition,
	StateInfo.NumberOfInsertedSamplesAfterEntrance,
	StateInfo.SignalStateIsValid, StateInfo.SignalStateJustGotValid,
	StateInfo.SignalStateIsValidAfterReentrance,
	StateInfo.SignalIsStable)};
	return SignalStateTuple();
	}));
	}

	#endif
	*/

	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<DeluxeContext> C = DeluxeContext::create(AppName);

	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<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));

	//
	// 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(
	+ SignalStateDetectors.emplace_back(// es fehlt SignaProperties
	+ SignalProperties(),
	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()));

	//
	// Connect sensors to low-level agents.
	//
	LOG_INFO("Connect sensors to their corresponding low-level agents.");

	C->connectSensor(SignalStateDetectorAgents.back(), 0, Sensors.back(),
	"HR Sensor Channel");
	}

	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));

	std::shared_ptr<
	SystemStateDetector<uint32_t, float, float, HistoryPolicy::FIFO>>
	SystemStateDetectorF(
	new SystemStateDetector<uint32_t, float, float, HistoryPolicy::FIFO>(
	std::numeric_limits<uint32_t>::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<uint32_t, uint32_t, uint32_t, uint32_t, uint32_t,
	uint32_t>(
	[](std::pair<uint32_t, bool> HR, std::pair<uint32_t, bool> BR,
	std::pair<uint32_t, bool> SpO2, std::pair<uint32_t, bool> BPSys,
	std::pair<uint32_t, bool> BodyTemp) -> Optional<uint32_t> {
	LOG_INFO_STREAM << "\n*******\nBody Agent trigged with values:\n"
	<< (HR.second ? "<New>" : "<Old>")
	<< " HR warning score: " << HR.first << "\n"
	<< (BR.second ? "<New>" : "<Old>")
	<< " BR warning score: " << BR.first << "\n"
	<< (SpO2.second ? "<New>" : "<Old>")
	<< " SpO2 warning score: " << SpO2.first << "\n"
	<< (BPSys.second ? "<New>" : "<Old>")
	<< " BPSys warning score: " << BPSys.first << "\n"
	<< (BodyTemp.second ? "<New>" : "<Old>")
	<< " 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<uint32_t> ScoreWriter(ScoreCSV);

	// The agent writes each new input value into a CSV file and produces nothing.
	/** AgentHandle LoggerAgent = C->createAgent(
	"Logger Agent",
	DeluxeAgent::D<unit_t, uint32_t>(
	[&ScoreWriter](std::pair<uint32_t, bool> Score) -> Optional<unit_t> {
	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/include/rosa/agent/SignalStateDetector.hpp b/include/rosa/agent/SignalStateDetector.hpp
	index 2e580cd..2dbcdf3 100644
	--- a/include/rosa/agent/SignalStateDetector.hpp
	+++ b/include/rosa/agent/SignalStateDetector.hpp
	@@ -1,283 +1,284 @@
	//===-- rosa/agent/SignalStateDetector.hpp ----------------------- C++ --===//
	//
	// The RoSA Framework
	//
	//===----------------------------------------------------------------------===//
	///
	/// \file rosa/agent/SignalStateDetector.hpp
	///
	/// \author Maximilian Götzinger (maximilian.goetzinger@tuwien.ac.at)
	///
	/// \date 2019
	///
	/// \brief Definition of signal state detector functionality.
	///
	//===----------------------------------------------------------------------===//

	#ifndef ROSA_AGENT_SIGNALSTATEDETECTOR_HPP
	#define ROSA_AGENT_SIGNALSTATEDETECTOR_HPP

	#include "rosa/agent/Functionality.h"
	#include "rosa/agent/SignalState.hpp"
	#include "rosa/agent/StateDetector.hpp"

	#include <vector>

	namespace rosa {
	namespace agent {

	/// Implements \c rosa::agent::SignalStateDetector as a functionality that
	/// detects signal states given on input samples.
	///
	/// \note This implementation is supposed to be used for samples of an
	/// arithmetic type.
	///
	/// \tparam INDATATYPE type of input data, \tparam CONFDATATYPE type of
	/// data in that the confidence values are given, \tparam PROCDATATYPE type of
	/// the relative distance and the type of data in which DABs are saved.
	template <typename INDATATYPE, typename CONFDATATYPE, typename PROCDATATYPE,
	HistoryPolicy HP>
	class SignalStateDetector
	: public StateDetector<INDATATYPE, CONFDATATYPE, PROCDATATYPE, HP> {

	// @maxi added them so it is compilable is this what you intended?
	using StateDetector =
	StateDetector<INDATATYPE, CONFDATATYPE, PROCDATATYPE, HP>;
	using PartFuncPointer = typename StateDetector::PartFuncPointer;
	using StepFuncPointer = typename StateDetector::StepFuncPointer;

	private:
	// For the convinience to write a shorter data type name
	using SignalStatePtr =
	std::shared_ptr<SignalState<INDATATYPE, CONFDATATYPE, PROCDATATYPE>>;

	/// The SignalProperty saves whether the monitored signal is an input our
	/// output signal.
	SignalProperties SignalProperty;

	/// The NextSignalStateID is a counter variable which stores the ID which the
	/// next signal state shall have.
	uint32_t NextSignalStateID;

	/// The SignalStateHasChanged is a flag that show whether a signal has changed
	/// its state.
	bool SignalStateHasChanged;

	/// The CurrentSignalState is a pointer to the (saved) signal state in which
	/// the actual variable (signal) of the observed system is.
	SignalStatePtr CurrentSignalState;

	/// The DetectedSignalStates is a history in that all detected signal states
	/// are saved.
	DynamicLengthHistory<SignalStatePtr, HP> DetectedSignalStates;

	/// The FuzzyFunctionSampleMatches is the fuzzy function that gives the
	/// confidence how good the new sample matches another sample in the sample
	/// history.
	PartFuncPointer FuzzyFunctionSampleMatches;

	/// The FuzzyFunctionSampleMismatches is the fuzzy function that gives the
	/// confidence how bad the new sample matches another sample in the sample
	/// history.
	PartFuncPointer FuzzyFunctionSampleMismatches;

	/// The FuzzyFunctionNumOfSamplesMatches is the fuzzy function that gives the
	/// confidence how many samples from the sampe history match the new sample.
	StepFuncPointer FuzzyFunctionNumOfSamplesMatches;

	/// The FuzzyFunctionNumOfSamplesMismatches is the fuzzy function that gives
	/// the confidence how many samples from the sampe history mismatch the new
	/// sample.
	StepFuncPointer FuzzyFunctionNumOfSamplesMismatches;

	/// The FuzzyFunctionSignalIsDrifting is the fuzzy function that gives the
	/// confidence how likely it is that the signal is drifting.
	PartFuncPointer FuzzyFunctionSignalIsDrifting;

	/// The FuzzyFunctionSignalIsStable is the fuzzy function that gives the
	/// confidence how likely it is that the signal is stable (not drifting).
	PartFuncPointer FuzzyFunctionSignalIsStable;

	/// SampleHistorySize is the (maximum) size of the sample history.
	uint32_t SampleHistorySize;
	/// DABSize the size of a DAB (Discrete Average Block).
	uint32_t DABSize;
	/// DABHistorySize is the (maximum) size of the DAB history.
	uint32_t DABHistorySize;

	public:
	/// Creates an instance by setting all parameters
	/// \param FuzzyFunctionSampleMatches The FuzzyFunctionSampleMatches is the
	/// fuzzy function that gives the confidence how good the new sample matches
	/// another sample in the sample history.
	///
	/// \param FuzzyFunctionSampleMismatches The FuzzyFunctionSampleMismatches is
	/// the fuzzy function that gives the confidence how bad the new sample
	/// matches another sample in the sample history.
	///
	/// \param FuzzyFunctionNumOfSamplesMatches The
	/// FuzzyFunctionNumOfSamplesMatches is the fuzzy function that gives the
	/// confidence how many samples from the sampe history match the new sample.
	///
	/// \param FuzzyFunctionNumOfSamplesMismatches The
	/// FuzzyFunctionNumOfSamplesMismatches is the fuzzy function that gives the
	/// confidence how many samples from the sampe history mismatch the new
	/// sample.
	///
	/// \param FuzzyFunctionSignalIsDrifting The FuzzyFunctionSignalIsDrifting is
	/// the fuzzy function that gives the confidence how likely it is that the
	/// signal (resp. the state of a signal) is drifting.
	///
	/// \param FuzzyFunctionSignalIsStable The FuzzyFunctionSignalIsStable is the
	/// fuzzy function that gives the confidence how likely it is that the signal
	/// (resp. the state of a signal) is stable (not drifting).
	///
	/// \param SampleHistorySize Sets the History size which will be used by \c
	/// SignalState.
	///
	/// \param DABSize Sets the DAB size which will be used by \c SignalState.
	///
	/// \param DABHistorySize Sets the size which will be used by \c SignalState.
	///
	SignalStateDetector(SignalProperties SignalProperty,
	uint32_t MaximumNumberOfSignalStates,
	PartFuncPointer FuzzyFunctionSampleMatches,
	PartFuncPointer FuzzyFunctionSampleMismatches,
	StepFuncPointer FuzzyFunctionNumOfSamplesMatches,
	StepFuncPointer FuzzyFunctionNumOfSamplesMismatches,
	PartFuncPointer FuzzyFunctionSignalIsDrifting,
	PartFuncPointer FuzzyFunctionSignalIsStable,
	uint32_t SampleHistorySize, uint32_t DABSize,
	uint32_t DABHistorySize) noexcept
	- : NextSignalStateID(1), SignalStateHasChanged(false),
	- CurrentSignalState(nullptr), SignalProperty(SignalProperty),
	+ : // needed to be reorderd
	+ SignalProperty(SignalProperty), NextSignalStateID(1),
	+ SignalStateHasChanged(false), CurrentSignalState(nullptr),
	DetectedSignalStates(MaximumNumberOfSignalStates),
	FuzzyFunctionSampleMatches(FuzzyFunctionSampleMatches),
	FuzzyFunctionSampleMismatches(FuzzyFunctionSampleMismatches),
	FuzzyFunctionNumOfSamplesMatches(FuzzyFunctionNumOfSamplesMatches),
	FuzzyFunctionNumOfSamplesMismatches(
	FuzzyFunctionNumOfSamplesMismatches),
	FuzzyFunctionSignalIsDrifting(FuzzyFunctionSignalIsDrifting),
	FuzzyFunctionSignalIsStable(FuzzyFunctionSignalIsStable),
	SampleHistorySize(SampleHistorySize), DABSize(DABSize),
	DABHistorySize(DABHistorySize) {}

	/// Destroys \p this object.
	~SignalStateDetector(void) = default;

	/// Detects the signal state to which the new sample belongs or create a new
	/// signal state if the new sample does not match to any of the saved states.
	///
	/// \param Sample is the actual sample of the observed signal.
	///
	/// \return the information of the current signal state (signal state ID and
	/// other parameters).
	// TODO (future): change to operator()
	SignalStateInformation<CONFDATATYPE>
	detectSignalState(INDATATYPE Sample) noexcept {

	if (!CurrentSignalState) {
	ASSERT(DetectedSignalStates.empty());

	SignalStatePtr S = createNewSignalState();
	CurrentSignalState = S;
	} else {
	CONFDATATYPE ConfidenceSampleMatchesSignalState =
	CurrentSignalState->confidenceSampleMatchesSignalState(Sample);
	CONFDATATYPE ConfidenceSampleMismatchesSignalState =
	CurrentSignalState->confidenceSampleMismatchesSignalState(Sample);

	if (ConfidenceSampleMatchesSignalState >
	ConfidenceSampleMismatchesSignalState) {
	SignalStateHasChanged = false;
	} else {
	SignalStateHasChanged = true;

	if (CurrentSignalState->signalStateInformation().SignalStateIsValid) {
	CurrentSignalState->leaveSignalState();
	} else {
	DetectedSignalStates.deleteEntry(CurrentSignalState);
	}

	// TODO (future): additionally save averages to enable fast iteration
	// through recorded signl state history (maybe sort vector based on
	// these average values)
	CurrentSignalState = nullptr;

	//@benedikt: same question
	for (auto &SavedSignalState : DetectedSignalStates) {
	if (SavedSignalState != CurrentSignalState) {
	ConfidenceSampleMatchesSignalState =
	SavedSignalState->confidenceSampleMatchesSignalState(Sample);
	ConfidenceSampleMismatchesSignalState =
	SavedSignalState->confidenceSampleMismatchesSignalState(Sample);

	if (ConfidenceSampleMatchesSignalState >
	ConfidenceSampleMismatchesSignalState) {
	// TODO (future): maybe it would be better to compare
	// ConfidenceSampleMatchesSignalState of all signal states in the
	// vector in order to find the best matching signal state.
	CurrentSignalState = SavedSignalState;
	break;
	}
	}
	}

	if (!CurrentSignalState) {
	SignalStatePtr S = createNewSignalState();
	CurrentSignalState = S;
	}
	}
	}

	SignalStateInformation<CONFDATATYPE> SignalStateInfo =
	CurrentSignalState->insertSample(Sample);

	if (SignalStateInfo.SignalStateJustGotValid) {
	NextSignalStateID++;
	}

	return SignalStateInfo;
	}

	/// Gives information about the current signal state.
	///
	/// \return a struct SignalStateInformation that contains information about
	/// the current signal state or NULL if no current signal state exists.
	SignalStateInformation<CONFDATATYPE>
	currentSignalStateInformation(void) noexcept {
	if (CurrentSignalState) {
	return CurrentSignalState->signalStateInformation();
	} else {
	return NULL;
	}
	}

	/// Gives information whether a signal state change has happened or not.
	///
	/// \return true if a signal state change has happened, and false if not.
	bool signalStateHasChanged(void) noexcept { return SignalStateHasChanged; }

	private:
	/// Creates a new signal state and adds it to the signal 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.
	SignalStatePtr createNewSignalState(void) noexcept {
	SignalStatePtr S(new SignalState<INDATATYPE, CONFDATATYPE, PROCDATATYPE>(
	NextSignalStateID, SampleHistorySize, DABSize, DABHistorySize,
	FuzzyFunctionSampleMatches, FuzzyFunctionSampleMismatches,
	FuzzyFunctionNumOfSamplesMatches, FuzzyFunctionNumOfSamplesMismatches,
	FuzzyFunctionSignalIsDrifting, FuzzyFunctionSignalIsStable));

	DetectedSignalStates.addEntry(S);

	return S;
	}
	};

	} // End namespace agent
	} // End namespace rosa

	#endif // ROSA_AGENT_SIGNALSTATEDETECTOR_HPP
	diff --git a/include/rosa/agent/SystemState.hpp b/include/rosa/agent/SystemState.hpp
	index e73c62a..808c7c0 100644
	--- a/include/rosa/agent/SystemState.hpp
	+++ b/include/rosa/agent/SystemState.hpp
	@@ -1,146 +1,131 @@
	//===-- rosa/agent/SystemState.hpp ------------------------------- C++ --===//
	//
	// The RoSA Framework
	//
	//===----------------------------------------------------------------------===//
	///
	/// \file rosa/agent/SystemState.hpp
	///
	/// \author Maximilian Götzinger (maximilian.goetzinger@tuwien.ac.at)
	///
	/// \date 2019
	///
	/// \brief Definition of system state functionality.
	///
	//===----------------------------------------------------------------------===//

	#ifndef ROSA_AGENT_SYSTEMSTATE_HPP
	#define ROSA_AGENT_SYSTEMSTATE_HPP

	#include "rosa/agent/Functionality.h"
	#include "rosa/agent/SignalState.hpp"

	#include "rosa/support/debug.hpp"

	#include <vector>

	namespace rosa {
	namespace agent {

	// System state conditions defining how the condition of a \c
	/// rosa::agent::SystemState is saved in \c rosa::agent::SystemStateInformation.
	enum class SystemStateCondition {
	STABLE, ///< The system state is stable
	DRIFTING, ///< The system state is drifting
	MALFUNCTIONING, ///< The system state is malfunctioning
	UNKNOWN ///< The system state is unknown
	};

	/// TODO: write description
	template <typename CONFDATATYPE> struct SystemStateInformation {
	// Make sure the actual type arguments are matching our expectations.
	STATIC_ASSERT((std::is_arithmetic<CONFDATATYPE>::value),
	"confidence type is not to arithmetic");

	/// The system state ID saved as an uint32_teger number
	uint32_t SystemStateID;
	/// The SystemStateConfidence shows the overall confidence value of the system
	/// state.
	CONFDATATYPE OverallDetectionConfidence;
	/// The SystemStateCondition shows the condition of a system state (stable,
	/// drifting, malfunctioning, or unknown)
	SystemStateCondition SystemStateCondition;
	/// The SystemStateIsValid saves the number of samples which have been
	/// inserted into the state after entering it.
	uint32_t NumberOfInsertedSamplesAfterEntrance;
	/// The SystemStateIsValid shows whether a state is valid or invalid.
	/// In this context, valid means that enough samples which are in close
	/// proximitry have been inserted into the state.
	bool SystemStateIsValid;
	/// The SystemStateJustGotValid shows whether a system state got valid
	/// (toggled from invalid to valid) during the current inserted sample.
	bool SystemStateJustGotValid;
	/// The SystemStateIsValidAfterReentrance shows whether a system state is
	/// valid after the variable changed back to it again.
	bool SystemStateIsValidAfterReentrance;
	};

	// todo: do we need PROCDATATYPE?
	/// TODO TEXT
	template <typename INDATATYPE, typename CONFDATATYPE, typename PROCDATATYPE>
	class SystemState : public Functionality {

	// Make sure the actual type arguments are matching our expectations.
	STATIC_ASSERT(std::is_arithmetic<INDATATYPE>::value,
	"input data type is not to arithmetic");
	STATIC_ASSERT(std::is_arithmetic<CONFDATATYPE>::value,
	"confidence abstraction type is not to arithmetic");
	STATIC_ASSERT(std::is_arithmetic<PROCDATATYPE>::value,
	"process data type is not to arithmetic");

	private:
	SystemStateInformation<CONFDATATYPE> SystemStateInfo;

	std::vector<SignalStateInformation<CONFDATATYPE>> Signals;

	+ uint32_t NumberOfSignals;
	+
	public:
	/// TODO write
	SystemState(uint32_t SignalStateID, uint32_t NumberOfSignals) noexcept
	- : SystemStateInfo{
	- SignalStateID, 0, SystemStateCondition::UNKNOWN, 0, false,
	- false, false} {
	+ : SystemStateInfo{SignalStateID,
	+ 0,
	+ SystemStateCondition::UNKNOWN,
	+ 0,
	+ false,
	+ false,
	+ false},
	+ NumberOfSignals(NumberOfSignals) {
	Signals.resize(NumberOfSignals);
	}

	/// Destroys \p this object.
	~SystemState(void) = default;

	-#if false
	- //@Daniel: I try to insert system state infos with these two functions (copied
	- //from fuzzyOR) into the vector Signals. However, I do not know how to do
	- //that.
	- /// TODO: describe
	- template <typename CONFDATATYPE, std::size_t size>
	- CONFDATATYPE
	- insertSignalStateInfos(const std::array<CONFDATATYPE, size> &Data) noexcept {
	- STATIC_ASSERT(std::is_arithmetic<CONFDATATYPE>::value,
	- "Type of FuzzyAnd is not arithmetic");
	- STATIC_ASSERT(size > 1, "Number of Arguments is to little");
	- ASSERT(std::all_of(Data.begin(), Data.end(),
	- [](const auto &v) { return v <= 1 && v >= 0; }));
	- return *std::max_element(Data.begin(), Data.end());
	- }
	- /// TODO: describe
	- template <typename CONFDATATYPE, typename... _CONFDATATYPE>
	- std::enable_if_t<
	- std::conjunction_v<std::is_same<CONFDATATYPE, _CONFDATATYPE>...>,
	- CONFDATATYPE>
	- insertSignalStateInfos(const CONFDATATYPE Data,
	- const _CONFDATATYPE... Datan) noexcept {
	- return insertSignalStateInfos(
	- std::array<CONFDATATYPE, sizeof...(Datan) + 1>{Data, Datan...});
	- }
	-#endif
	-
	template <std::size_t size>
	void
	insertSignalStateInfos(const std::array<SystemStateInformation<CONFDATATYPE>,
	size> &Data) noexcept {
	- Signals.insert(Signals.end(), Data.begin(), Data.end());
	+ ASSERT(size <= NumberOfSignals);
	+ std::size_t counter = 0;
	+ for (auto tmp : Data) {
	+ Signals.at(counter) = tmp;
	+ counter++;
	+ }
	}

	template <typename... Types>
	std::enable_if_t<std::conjunction_v<std::is_same<
	Types, SystemStateInformation<CONFDATATYPE>>...>,
	- void>
	+ void>
	insertSignalStateInfos(Types... Data) {
	insertSignalStateInfos(
	std::array<SystemStateInformation<CONFDATATYPE>, sizeof...(Data)>(
	{Data...}));
	}
	};

	} // End namespace agent
	} // End namespace rosa

	#endif // ROSA_AGENT_SYSTEMSTATE_HPP

File Metadata

Mime Type: text/x-diff
Expires: Fri, Jul 4, 6:42 AM (6 h, 51 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 157410
Default Alt Text: (33 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions