Reliability.h
No OneTemporary
Actions

Size

12 KB

Referenced Files

None

Subscribers

None

Reliability.h
View Options

	//===-- rosa/agent/Reliability.h --------------------------------- C++ --===//
	//
	// The RoSA Framework
	//
	//===----------------------------------------------------------------------===//
	///
	/// \file rosa/agent/Reliability.h
	///
	/// \author Daniel Schnoell (danielschnoell@tuwien.ac.at)
	///
	/// \date 2019
	///
	/// \brief Definition of reliability functionality.
	///
	//===----------------------------------------------------------------------===//

	#ifndef ROSA_AGENT_RELIABILITY_H
	#define ROSA_AGENT_RELIABILITY_H

	#include "rosa/agent/FunctionAbstractions.hpp"
	#include "rosa/agent/Functionality.h"
	#include "rosa/agent/RangeConfidence.hpp"
	#include "rosa/agent/CrossReliability.h"

	#include <vector>

	namespace rosa {
	namespace agent {

	/// This is the Reliability Functionality for a low level Agent
	/// \tparam SensorValueType Datatype of the Sensor value ( Typically double or float)
	/// \tparam StateType Datatype of the State ( Typically long or int)
	/// \tparam ReliabilityType Datatype of the Reliability ( Typically double or float)
	///
	/// use the () operator to get the reliability and feed the information from the master back to this
	/// \note all pointer for the functionalities will be deleted when this is object ist destroyed
	template <typename SensorValueType, typename StateType, typename ReliabilityType>
	class LowLevel {
	struct ConfOrRel {
	StateType score;
	ReliabilityType Reliability;
	};
	public:

	/// Calculates the Conf/ Reliability
	/// \param SensorValue The current Values of the Sensor
	///
	/// \return Reliability of the current Value
	ConfOrRel operator()(SensorValueType SensorValue) {
	std::map<StateType, ReliabilityType> ActuallPosibleScores_tmp = Confidence(SensorValue);

	std::vector<ConfOrRel> ActuallPossibleScores;
	for (auto state : States)
	ActuallPossibleScores.push_back({ state, ActuallPosibleScores_tmp.find(state) });

	ReliabilityType inputReliability;

	if (PreviousSensorValueExists)
	inputReliability = getRelibility(SensorValue, previousSensorValue, valueSetCounter);
	else
	inputReliability = Reliability(SensorValue);

	for (std::size_t at = 0; at < ActuallPossibleScores.size(); at++)
	ActuallPossibleScores.at(at) = std::min(ActuallPossibleScores.at(at), inputReliability);

	for (std::size_t APS_at = 0; APS_at < ActuallPossibleScores.size(); APS_at++)
	for (std::size_t VFM_at = 0; VFM_at < ValuesFromMaster.size(); VFM_at++) {
	if (ActuallPossibleScores.at(APS_at).score == ValuesFromMaster.at(VFM_at).score) {
	ActuallPossibleScores.at(APS_at).Reliability = ActuallPossibleScores.at(APS_at).Reliability + ValuesFromMaster.at(VFM_at).Reliability;
	}
	}

	saveInHistory(ActuallPossibleScores);

	std::vector<ConfOrRel> possibleScores;

	getAllPossibleScoresBasedOnHistory(&possibleScores);


	std::sort(possibleScores.begin(), possibleScores.end(), [](ReliabilityType A, ReliabilityType B)-> bool {return A > B; });


	previousSensorValue = SensorValue;
	PreviousSensorValueExists = true;
	return possibleScores.at(0);

	}

	/// Needed feedback from the Master
	/// \param ValuesFromMaster The Scores + Reliability from the Master for this Agent
	void feedback(std::vector<ConfOrRel> ValuesFromMaster)
	{
	this->ValuesFromMaster = ValuesFromMaster;
	}


	/// This is the setter for Confidence Function
	/// \param Confidence A pointer to the Functional for the Confidence
	void setConfidenceFunction(RangeConfidence<ReliabilityType, StateType, SensorValueType>* Confidence)
	{
	this->Confidence = Confidence;
	}

	/// This is the setter for Reliability Function
	/// \param Reliability A pointer to the Functional for the Reliability
	void setReliabilityFunction(Abstraction<SensorValueType, ReliabilityType>* Reliability)
	{
	this->Reliability = Reliability;
	}

	/// This is the setter for ReliabilitySlope Function
	/// \param ReliabilitySlope A pointer to the Functional for the ReliabilitySlope
	void setReliabilitySlopeFunction(Abstraction<SensorValueType, ReliabilityType>* ReliabilitySlope)
	{
	this->ReliabilitySlope = ReliabilitySlope;
	}

	/// This is the setter for TimeConfidence Function
	/// \param TimeConfidence A pointer to the Functional for the TimeConfidence
	void setTimeConfidenceFunction(Abstraction<std::size_t, ReliabilityType>* TimeConfidence)
	{
	this->TimeConfidence = TimeConfidence;
	}

	/// deletes all given pointers
	void ~LowLevel()
	{
	delete Confidence;
	Confidence = nullptr;

	delete Reliability;
	Reliability = nullptr;

	delete ReliabilitySlop;
	ReliabilitySlope = nullptr;

	delete TimeConfidence;
	TimeConfidence = nullptr;
	}

	private:
	std::vector<std::vector<ConfOrRel>> History;
	std::size_t HistoryMaxSize;
	std::vector<ConfOrRel> ValuesFromMaster;

	SensorValueType previousSensorValue;
	unsigned int valueSetCounter;
	std::vector<StateType> States;
	bool PreviousSensorValueExists = false;

	RangeConfidence<ReliabilityType, StateType, SensorValueType>* Confidence = nullptr;
	Abstraction<SensorValueType, ReliabilityType>* Reliability = nullptr;
	Abstraction<SensorValueType, ReliabilityType>* ReliabilitySlope = nullptr;
	Abstraction<std::size_t, ReliabilityType>* TimeConfidence = nullptr;

	/--------------------------------- needed Funktions -----------------------------------------------------/

	/// returns the Reliability
	/// \param actualValue The Value of the Sensor
	/// \param lastValue of the Sensor this is stored in the class
	/// \param valueSetCounter
	ReliabilityType getRelibility(SensorValueType actualValue, SensorValueType lastValue, unsigned int valueSetCounter) {

	ReliabilityType relAbs = Reliability->operator()(actualValue);
	if (PreviousSensorValueExists)
	{
	ReliabilityType relSlo = ReliabilitySlope->operator()((lastValue - actualValue) / (SensorValueType)valueSetCounter);

	// calculate signal input reliability
	// NOTE: options would be multiply, average, AND (best to worst:
	// average = AND > multiply) rel = relAbs * relSlo; rel = (relAbs +
	// relSlo)/2;

	return std::min(relAbs, relSlo);
	}
	else
	return relAbs;
	}

	/// adabts the possible Scores by checking the History and combines those values currently with max
	/// \param possibleScores This is returned from the Master
	std::vector<ConfOrRel> getAllPossibleScoresBasedOnHistory(std::vector<ConfOrRel> possibleScores) {
	//iterate through all history entries
	std::size_t posInHistory = 0;
	typedef typename std::vector<std::vector<ConfOrRel>>::iterator iter;
	for (iter pShE = History.begin(); pShE < History.end(); pShE++, posInHistory++) {


	//iterate through all possible scores of each history entry
	for (typename std::vector<ConfOrRel>::iterator pSh : *pShE) {

	//printf("a3\n");

	int historyScore = pSh->score;
	float historyConf = pSh->Reliability;

	//combine each history score with the confidence of time
	//NOTE: multiplication, AND, or average would be alternatives (best to worst: multiplication = AND = average)
	historyConf = historyConf * TimeConfidence(posInHistory);
	//historyConf = (historyConf + TimeConfidence(posInHistory)) / 2;
	//historyConf = std::min(historyConf, TimeConfidence(posInHistory));

	//printf("a4\n");

	bool foundScore = false;
	for (ConfOrRel& pS : possibleScores) {

	if (pS->score == historyScore) {

	//calculate confidence for score
	//NOTE: multiplication, AND, or average would be alternatives (best to worst: AND >> average = multiplication )
	//pS->confOrRel = pS->confOrRel * historyConf;
	//pS->confOrRel = (pS->confOrRel + historyConf) / 2;
	pS->confOrRel = std::max(pS->confOrRel, historyConf);

	foundScore = true;
	}
	}

	if (foundScore == false) {

	ConfOrRel possibleScore;
	possibleScore.score = historyScore;
	possibleScore.Reliability = historyConf;

	possibleScores->push_back(possibleScore);

	}
	}
	}

	return possibleScores;
	}

	/// saves the Scores in the History
	/// \param actualPossibleScores The Scores which should be saved
	void saveInHistory(std::vector<ConfOrRel> actualPossibleScores) {

	//check if the reliability of at least one possible score is high enough
	bool atLeastOneRelIsHigh = false;
	for (ConfOrRel pS : actualPossibleScores) {
	if (pS.Reliability > 0.5) {
	atLeastOneRelIsHigh = true;
	}
	}
	//save possible scores if at least one possible score is high enough (or if the history is empty)
	if (History.size() < 1 \|\| atLeastOneRelIsHigh == true) {

	History.push_front(actualPossibleScores);

	//if history size is higher than allowed, savo oldest element
	while (History.size() > HistoryMaxSize) {
	//delete possibleScoreHistory.back();
	History.pop_back();
	}
	}
	}

	};



	/// This is the Reliability Functionality for the Highlevel Agent
	/// \tparam StateType Datatype of the State ( Typically double or float)
	/// \tparam ReliabilityType Datatype of the Reliability ( Typically long or int)
	///
	/// use the () operator to calculate the Reliability and all cross confidences for all slaves
	/// \note all pouinter to Funcionalities get deleted upon termitation of the object
	template<typename StateType, typename ReliabilityType>
	class HighLevel
	{
	public:

	struct ConfOrRel {
	StateType score;
	ReliabilityType Reliability;
	};

	struct returnType {
	ReliabilityType CrossReliability;
	std::vector<std::pair<id_t, std::vector<ConfOrRel>>> CrossConfidence;
	};

	returnType operator()(std::vector<std::tuple<id_t, StateType, ReliabilityType>> Values)
	{

	StateType EWS = 0;
	ReliabilityType combinedInputRel = 1;
	ReliabilityType combinedCrossRel = 1;
	ReliabilityType outputReliability;

	std::vector<std::pair<id_t, StateType>> Agents;
	std::vector<std::pair<id_t, std::vector<ConfOrRel>>> output;
	std::vector<ConfOrRel> output_temporary;

	for (auto tmp : Values)
	{
	std::pair<id_t, StateType> tmp2;
	tmp.first = std::get<0>(tmp);
	tmp.second = std::get<1>(tmp);
	Agents.push_back(tmp);
	}


	for (auto Value : Values) {
	StateType sc = std::get<1>(Value);
	ReliabilityType rel = std::get<2>(Value);

	EWS = EWS + sc;

	combinedInputRel = std::min(combinedInputRel, rel);


	//calculate the cross reliability for this slave agent
	ReliabilityType realCrossReliabilityOfSlaveAgent = CrossReliability({ std::get<0>(Value),std::get<1>(Value) }, Agents); //AVERAGE, MULTIPLICATION, CONJUNCTION (best to worst: AVERAGE = CONJUNCTION > MULTIPLICATION >> )

	output_temporary.clear();
	for (int theoreticalScore = 0; theoreticalScore <= 3; theoreticalScore++) {
	//calculate the cross reliability for this slave agent
	ConfOrRel data;
	data.score = theoreticalScore;
	data.Reliability = CrossConfidence(std::get<0>(Value), theoreticalScore, Agents);
	output_temporary.push_back(data);
	}

	output.push_back({ std::get<0>(Value),output_temporary });
	combinedCrossRel = std::min(combinedCrossRel, realCrossReliabilityOfSlaveAgent);

	}

	//combine cross reliabilites and input reliabilites of all slave agents
	//NOTE: options would be multiply, average, AND (best to worst: )
	//outputReliability = combinedInputRel * combinedCrossRel;
	//outputReliability = (combinedInputRel + combinedCrossRel) / 2;
	outputReliability = std::min(combinedInputRel, combinedCrossRel);
	return { outputReliability,output };
	}

	/// This is the setter for CrossReliability Function
	/// param A pointer to the Functional for the CrossReliability
	void setFunction(CrossReliability<StateType, ReliabilityType>* CrossReliability)
	{
	this->CrossReliability = CrossReliability;
	}

	/// This is the setter for CrossConfidence Function
	/// param A pointer to the Functional for the CrossConfidence
	void setFunction(CrossConfidence <StateType, ReliabilityType>* CrossConfidence)
	{
	this->CrossConfidence = CrossConfidence;
	}

	/// deletes all given pointers
	void ~HighLevel()
	{
	delete CrossReliability;
	CrossConfidence = nullptr;
	delete CrossConfidence;
	CrossConfidence = nullptr;
	}

	private:

	CrossReliability<StateType, ReliabilityType>* CrossReliability = nullptr;
	CrossConfidence <StateType, ReliabilityType>* CrossConfidence = nullptr;
	};
	} // namespace agent
	}// namespace rosa
	#endif // !ROSA_AGENT_RELIABILITY_H

File Metadata

Mime Type: text/x-c++
Expires: Sun, Apr 12, 11:44 AM (11 h, 58 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 306398
Default Alt Text: Reliability.h (12 KB)

Reliability.hNo OneTemporaryActions

Reliability.hView Options

File Metadata

Event Timeline

Reliability.h
No OneTemporary
Actions

Reliability.h
View Options