No OneTemporary
Actions

Size

14 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/include/rosa/agent/SignalStateDetector.hpp b/include/rosa/agent/SignalStateDetector.hpp
	index bd62965..aa1acfb 100644
	--- a/include/rosa/agent/SignalStateDetector.hpp
	+++ b/include/rosa/agent/SignalStateDetector.hpp
	@@ -1,285 +1,285 @@
	-//===-- rosa/agent/SignalStateDetector.hpp ----------------------------*- C++
	-//-*-===//
	+//===-- 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/FunctionAbstractions.hpp"
	#include "rosa/agent/Functionality.h"
	+#include "rosa/agent/History.hpp"
	#include "rosa/agent/SignalState.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, \param 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 Functionality {

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

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

	/// The NextSignalStateID is a counter variable which stores the ID which the
	/// next signal state shall have.
	unsigned int 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 vector 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.
	unsigned int SampleHistorySize;
	/// DABSize the size of a DAB (Discrete Average Block).
	unsigned int DABSize;
	/// DABHistorySize is the (maximum) size of the DAB history.
	unsigned int 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(unsigned int MaximumNumberOfSignalStates,
	PartFuncPointer FuzzyFunctionSampleMatches,
	PartFuncPointer FuzzyFunctionSampleMismatches,
	StepFuncPointer FuzzyFunctionNumOfSamplesMatches,
	StepFuncPointer FuzzyFunctionNumOfSamplesMismatches,
	PartFuncPointer FuzzyFunctionSignalIsDrifting,
	PartFuncPointer FuzzyFunctionSignalIsStable,
	unsigned int SampleHistorySize, unsigned int DABSize,
	unsigned int DABHistorySize) noexcept
	: NextSignalStateID(1), SignalStateHasChanged(false),
	CurrentSignalState(NULL),
	FuzzyFunctionSampleMatches(FuzzyFunctionSampleMatches),
	FuzzyFunctionSampleMismatches(FuzzyFunctionSampleMismatches),
	FuzzyFunctionNumOfSamplesMatches(FuzzyFunctionNumOfSamplesMatches),
	FuzzyFunctionNumOfSamplesMismatches(
	FuzzyFunctionNumOfSamplesMismatches),
	FuzzyFunctionSignalIsDrifting(FuzzyFunctionSignalIsDrifting),
	FuzzyFunctionSignalIsStable(FuzzyFunctionSignalIsStable),
	SampleHistorySize(SampleHistorySize), DABSize(DABSize),
	DABHistorySize(DABHistorySize),
	DetectedSignalStates(MaximumNumberOfSignalStates) {}

	/// 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).
	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 {
	//@benedikt: changed from vector to history. can i still do the next
	// line?
	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));

	// @benedikt: todo: assert in history, which checks if push_back worked
	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
	new file mode 100644
	index 0000000..207e284
	--- /dev/null
	+++ b/include/rosa/agent/SystemState.hpp
	@@ -0,0 +1,44 @@
	+//===-- 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"
	+
	+namespace rosa {
	+namespace agent {
	+
	+/// TODO TEXT
	+template <typename CONFDATATYPE> class SystemState : public Functionality {
	+
	+ /* //TODO: STATIC_ASSERT
	+// Make sure the actual type arguments are matching our expectations.
	+STATIC_ASSERT(std::is_arithmetic<CONFDATATYPE>::value,
	+ "confidence abstraction type is not to arithmetic");
	+*/
	+
	+private:
	+ unsigned int x;
	+
	+public:
	+ SystemState() {}
	+};
	+
	+} // End namespace agent
	+} // End namespace rosa
	+
	+#endif // ROSA_AGENT_SYSTEMSTATE_HPP
	diff --git a/include/rosa/agent/SystemStateDetector.hpp b/include/rosa/agent/SystemStateDetector.hpp
	new file mode 100644
	index 0000000..fe0d3fd
	--- /dev/null
	+++ b/include/rosa/agent/SystemStateDetector.hpp
	@@ -0,0 +1,47 @@
	+//===-- rosa/agent/SystemStateDetector.hpp ----------------------- C++ --===//
	+//
	+// The RoSA Framework
	+//
	+//===----------------------------------------------------------------------===//
	+///
	+/// \file rosa/agent/SystemStateDetector.hpp
	+///
	+/// \author Maximilian Götzinger (maximilian.goetzinger@tuwien.ac.at)
	+///
	+/// \date 2019
	+///
	+/// \brief Definition of system state detector functionality.
	+///
	+//===----------------------------------------------------------------------===//
	+
	+#ifndef ROSA_AGENT_SYSTEMSTATEDETECTOR_HPP
	+#define ROSA_AGENT_SYSTEMSTATEDETECTOR_HPP
	+
	+#include "rosa/agent/Functionality.h"
	+#include "rosa/agent/History.hpp"
	+#include <type_traits>
	+
	+namespace rosa {
	+namespace agent {
	+
	+/// TODO TEXT
	+template <typename CONFDATATYPE, HistoryPolicy HP>
	+class SystemStateDetector : public Functionality {
	+
	+ /* //TODO: STATIC_ASSERT
	+// Make sure the actual type arguments are matching our expectations.
	+STATIC_ASSERT(std::is_arithmetic<CONFDATATYPE>::value,
	+ "confidence abstraction type is not to arithmetic");
	+*/
	+
	+private:
	+ unsigned int NextSignalStateID;
	+
	+public:
	+ SystemStateDetector() : NextSignalStateID(1) {}
	+};
	+
	+} // End namespace agent
	+} // End namespace rosa
	+
	+#endif // ROSA_AGENT_SYSTEMSTATEDETECTOR_HPP

File Metadata

Mime Type: text/x-diff
Expires: Thu, Jul 3, 10:45 PM (17 h, 27 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 157397
Default Alt Text: (14 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions