No OneTemporary
Actions

Size

36 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/examples/agent-functionalities/Reliability-functionality.cpp b/examples/agent-functionalities/Reliability-functionality.cpp
	index 4991b92..860b303 100644
	--- a/examples/agent-functionalities/Reliability-functionality.cpp
	+++ b/examples/agent-functionalities/Reliability-functionality.cpp
	@@ -1,106 +1,238 @@
	//===- examples/agent-functionalities/Reliability-functionality.cpp C++--===//
	//
	// The RoSA Framework
	//
	//===----------------------------------------------------------------------===//
	///
	/// \file examples/agent-functionalities/Reliability-functionality.cpp
	///
	/// \author Daniel Schnoell (daniel.schnoell@tuwien.ac.at )
	///
	/// \date 2019
	///
	/// \brief A simple example on defining \c rosa::Agent instances using
	/// Relianility Functionalities.
	///
	//===----------------------------------------------------------------------===//



	#include "rosa/config/version.h"

	#include "rosa/core/Agent.hpp"
	#include "rosa/core/MessagingSystem.hpp"

	#include "rosa/support/log.h"
	#include "rosa/support/terminal_colors.h"

	#include "rosa/agent/Reliability.h"
	#include "rosa/agent/RangeConfidence.hpp"
	+#include "rosa/agent/CrossReliability.h"

	#include <vector>
	#include <map>

	using namespace rosa::agent;

	int main(void)
	{
	typedef double SensorValueType;
	typedef long StateType;
	typedef double ReliabilityType;

	// defining Range confidence



	auto Confidence = new RangeConfidence<ReliabilityType, StateType, SensorValueType>({
	{0, PartialFunction<double, double>({
	{{0, 3}, std::make_shared<LinearFunction<double, double>>
	(0, 1.0/3)},
	{{3, 6}, std::make_shared<LinearFunction<double, double>>
	(1, 0)},
	{{6, 9}, std::make_shared<LinearFunction<double, double>>
	(3.0, -1.0/3)},
	},0)},
	{1, PartialFunction<double, double>({
	{{6, 9}, std::make_shared<LinearFunction<double, double>>
	(-2, 1.0/3)},
	{{9, 12}, std::make_shared<LinearFunction<double, double>>
	(1, 0)},
	{{12, 15}, std::make_shared<LinearFunction<double, double>>
	(5, -1.0/3)},
	},0)},
	{2, PartialFunction<double, double>({
	{{12, 15}, std::make_shared<LinearFunction<double, double>>
	(-4, 1.0/3)},
	{{15, 18}, std::make_shared<LinearFunction<double, double>>
	(1, 0)},
	{{18, 21}, std::make_shared<LinearFunction<double, double>>
	(7, -1.0/3)},
	},0)}
	});


	Abstraction<SensorValueType, ReliabilityType>* Reliability = new LinearFunction<SensorValueType, ReliabilityType>(1,-1.0/9);


	auto ReliabilitySlope = new LinearFunction<SensorValueType, ReliabilityType>(1, -1.0/9);


	auto TimeConfidence = new LinearFunction<std::size_t, ReliabilityType>(1, -1.0/9);

	auto lowlevel = new LowLevel <SensorValueType, StateType, ReliabilityType>();

	std::vector<long> states;
	states.push_back(0);
	states.push_back(1);
	states.push_back(2);


	lowlevel->setConfidenceFunction(Confidence);
	lowlevel->setReliabilityFunction(Reliability);
	lowlevel->setReliabilitySlopeFunction(ReliabilitySlope);
	lowlevel->setTimeConfidenceFunction(TimeConfidence);
	lowlevel->setStates(states);
	- lowlevel->setHistoryLength(1);
	+ lowlevel->setHistoryLength(2);
	+ lowlevel->setValueSetCounter(1);

	/* ----------------------------- Do Something ---------------------------------------------------------------- */

	for ( int a= 0 ; a <10 ; a++)
	std::cout <<"a: " << a << "\n" << (lowlevel->feedback({{0,0},{1,0.3},{2,0.5}}),lowlevel->operator()(a)) << "\n";

	/* ----------------------------- Cleanup --------------------------------------------------------------------- */

	+ std::cout << "------------------------------------------------------------------------------------------------\n";
	+ std::cout << "------------------------------------High level Test---------------------------------------------\n";
	+
	+
	+
	+
	+ auto Confidence2 = new RangeConfidence<ReliabilityType, StateType, SensorValueType>({
	+ {0, PartialFunction<double, double>({
	+ {{0, 3}, std::make_shared<LinearFunction<double, double>>
	+ (0, 1.0/3)},
	+ {{3, 6}, std::make_shared<LinearFunction<double, double>>
	+ (1, 0)},
	+ {{6, 9}, std::make_shared<LinearFunction<double, double>>
	+ (3.0, -1.0/3)},
	+ },0)},
	+ {1, PartialFunction<double, double>({
	+ {{6, 9}, std::make_shared<LinearFunction<double, double>>
	+ (-2, 1.0/3)},
	+ {{9, 12}, std::make_shared<LinearFunction<double, double>>
	+ (1, 0)},
	+ {{12, 15}, std::make_shared<LinearFunction<double, double>>
	+ (5, -1.0/3)},
	+ },0)},
	+ {2, PartialFunction<double, double>({
	+ {{12, 15}, std::make_shared<LinearFunction<double, double>>
	+ (-4, 1.0/3)},
	+ {{15, 18}, std::make_shared<LinearFunction<double, double>>
	+ (1, 0)},
	+ {{18, 21}, std::make_shared<LinearFunction<double, double>>
	+ (7, -1.0/3)},
	+ },0)}
	+ });
	+
	+
	+ Abstraction<SensorValueType, ReliabilityType>* Reliability2 = new LinearFunction<SensorValueType, ReliabilityType>(1,-1.0/9);
	+
	+
	+ auto ReliabilitySlope2 = new LinearFunction<SensorValueType, ReliabilityType>(1, -1.0/9);
	+
	+
	+ auto TimeConfidence2 = new LinearFunction<std::size_t, ReliabilityType>(1, -1.0/9);
	+
	+ auto lowlevel2 = new LowLevel <SensorValueType, StateType, ReliabilityType>();
	+
	+ std::vector<long> states2;
	+ states2.push_back(0);
	+ states2.push_back(1);
	+ states2.push_back(2);
	+
	+
	+ lowlevel2->setConfidenceFunction(Confidence2);
	+ lowlevel2->setReliabilityFunction(Reliability2);
	+ lowlevel2->setReliabilitySlopeFunction(ReliabilitySlope2);
	+ lowlevel2->setTimeConfidenceFunction(TimeConfidence2);
	+ lowlevel2->setStates(states2);
	+ lowlevel2->setHistoryLength(2);
	+ lowlevel2->setValueSetCounter(1);
	+
	+
	+ HighLevel<StateType,ReliabilityType>* highlevel=new HighLevel<StateType,ReliabilityType>();
	+
	+ CrossReliability<StateType,ReliabilityType>* CrossReliability1= new CrossReliability<StateType,ReliabilityType>();
	+
	+ Abstraction<long,double>* func1=new PartialFunction<long, double>({
	+ {{0, 1}, std::make_shared<LinearFunction<long, double>>
	+ (1, 0)},
	+ {{1,2}, std::make_shared<LinearFunction<long, double>>
	+ (2, -1.0)},
	+ },0);
	+
	+ CrossReliability1->addCrossReliabilityProfile(0,1,func1);
	+ CrossReliability1->setCrossReliabilityMethod(CrossReliability<StateType,ReliabilityType>::AVERAGE);
	+ CrossReliability1->setCrossReliabilityParameter(1);
	+
	+
	+
	+ CrossConfidence<StateType,ReliabilityType>* CrossConfidence1= new CrossConfidence<StateType,ReliabilityType>();
	+
	+ Abstraction<long,double>* func2=new PartialFunction<long, double>({
	+ {{0, 1}, std::make_shared<LinearFunction<long, double>>
	+ (1, 0)},
	+ {{1,2}, std::make_shared<LinearFunction<long, double>>
	+ (2, -1.0)},
	+ },0);
	+
	+ CrossConfidence1->addCrossReliabilityProfile(0,1,func2);
	+ CrossConfidence1->setCrossReliabilityMethod(CrossConfidence<StateType,ReliabilityType>::AVERAGE);
	+ CrossConfidence1->setCrossReliabilityParameter(1);
	+
	+
	+ highlevel->setFunction(CrossConfidence1);
	+ highlevel->setFunction(CrossReliability1);
	+ highlevel->MaximumState=2;
	+
	+
	+for ( int a= 0 ; a <21 ; a++)
	+{
	+ auto out1=lowlevel->operator()(a),out2=lowlevel2->operator()(21-a);
	+ std::cout << "s1: " << out1 << "\ns2:" << out2 << "\n";
	+ std::vector<std::tuple<rosa::id_t, StateType, ReliabilityType>> tmp2;
	+ tmp2.push_back({0,out1.score,out1.Reliability});
	+ tmp2.push_back({1,out2.score,out2.Reliability});
	+
	+ auto out_o=highlevel->operator()(tmp2);
	+ std::cout << "it: " << a << "\t rel: " << out_o.CrossReliability << "\n";
	+ std::cout << "\t subs:\n";
	+ for (auto q:out_o.CrossConfidence)
	+ {
	+ std::cout<< "\t\t id:" << q.first << "\n";
	+ std::vector<LowLevel<SensorValueType, StateType, ReliabilityType>::ConfOrRel> tmp;
	+ for(auto z: q.second)
	+ {
	+ std::cout << "\t\t\t score: " << z.score << "\tRel: " << z.Reliability << "\n";
	+ tmp.push_back({z.score,z.Reliability});
	+ }
	+
	+ if(q.first==0)
	+ lowlevel->feedback(tmp);
	+ else
	+ lowlevel2->feedback(tmp);
	+
	+ }
	+
	+}
	+
	+
	+
	+
	+
	delete lowlevel;
	+ delete lowlevel2;

	}
	\ No newline at end of file
	diff --git a/include/rosa/agent/CrossReliability.h b/include/rosa/agent/CrossReliability.h
	index d3a1f16..af67744 100644
	--- a/include/rosa/agent/CrossReliability.h
	+++ b/include/rosa/agent/CrossReliability.h
	@@ -1,344 +1,347 @@
	//===-- rosa/delux/CrossReliability.h ---------------------------- C++ --===//
	//
	// The RoSA Framework
	//
	//===----------------------------------------------------------------------===//
	///
	/// \file rosa/delux/CrossReliability.h
	///
	/// \author Daniel Schnoell
	///
	/// \date 2019
	///
	/// \brief
	///
	/// \todo there is 1 exception that needs to be handled correctly.
	/// \note the default search function is extremely slow maby this could be done
	/// via template for storage class and the functions/methods to efficiently find
	/// the correct LinearFunction
	//===----------------------------------------------------------------------===//
	#ifndef ROSA_AGENT_CROSSRELIABILITY_H
	#define ROSA_AGENT_CROSSRELIABILITY_H


	#include "rosa/agent/Abstraction.hpp"
	#include "rosa/agent/Functionality.h"
	#include "rosa/core/forward_declarations.h" // needed for id_t
	#include "rosa/support/log.h" // needed for error "handling"

	// nedded headers

	#include <string>
	#include <type_traits> //assert
	#include <vector>
	// for static methods
	#include <algorithm>
	#include <numeric>

	namespace rosa {
	namespace agent {

	/// Calculates the Cross Reliability
	/// \brief it uses the state represented by a numerical value and calculates the
	/// Reliability of a given agent( represented by there id ) in connection to all
	/// other given agents
	///
	/// \note all combination of agents and there coresponding Cross Reliability
	/// function have to be specified
	template <typename StateType, typename Type>
	class CrossReliability : public Abstraction<StateType, Type> {
	using Abstraction = typename rosa::agent::Abstraction<StateType, Type>;

	struct Functionblock {
	bool exists = false;
	id_t A;
	id_t B;
	Abstraction *Funct;
	};

	/// From Maxi in his code defined as 1 can be changed by set
	Type crossReliabilityParameter = 1;

	/// Stored Cross Reliability Functions
	std::vector<Functionblock> Functions;

	/// Method which is used to combine the generated values
	Type (*Method)(std::vector<Type> values) = AVERAGE;

	//--------------------------------------------------------------------------------
	// helper function
	/// evalues the absolute distance between two values
	/// \note this is actually the absolute distance but to ceep it somewhat
	/// conform with maxis code
	template <typename Type_t> Type_t AbsuluteValue(Type_t A, Type_t B) {
	static_assert(std::is_arithmetic<Type_t>::value);
	return ((A - B) < 0) ? B - A : A - B;
	}

	/// verry inefficient searchFunction
	Functionblock (*searchFunction)(std::vector<Functionblock> vect,
	const id_t nameA, const id_t nameB) =
	[](std::vector<Functionblock> vect, const id_t nameA,
	const id_t nameB) -> Functionblock {
	for (Functionblock tmp : vect) {
	if (tmp.A == nameA && tmp.B == nameB)
	return tmp;
	if (tmp.A == nameB && tmp.B == nameA)
	return tmp;
	}
	return Functionblock();
	};

	/// evaluest the corisponding LinearFunction thith the score difference
	/// \param nameA these two parameters are the unique identifiers
	/// \param nameB these two parameters are the unique identifiers
	/// for the LinerFunction
	///
	/// \note If the block nameA nameB doesn't exist it logs the error and returns
	/// 0
	/// \note it doesn't matter if they are swapped
	Type getCrossReliabilityFromProfile(id_t nameA, id_t nameB,
	StateType scoreDifference) {
	Functionblock block = searchFunction(Functions, nameA, nameB);
	if (!block.exists) {
	LOG_ERROR(("CrossReliability: Block:" + std::to_string(nameA) + "," +
	std::to_string(nameB) + "doesn't exist returning 0"));
	return 0;
	}
	return block.Funct->operator()(scoreDifference);
	}

	public:
	/// adds a Cross Reliability Profile used to get the Reliability of the state
	/// difference
	void addCrossReliabilityProfile(id_t idA, id_t idB, Abstraction *Function) {
	Functions.push_back({true, idA, idB, Function});
	}

	/// sets the cross reliability parameter
	void setCrossReliabilityParameter(Type val) {
	crossReliabilityParameter = val;
	}
	/// sets the used method to combine the values
	void setCrossReliabilityMethod(Type (*Meth)(std::vector<Type> values)) {
	Method = Meth;
	}

	+ CrossReliability():Abstraction(0) {}
	+
	+
	~CrossReliability() {
	for (auto tmp : Functions)
	delete tmp.Funct;
	Functions.clear();
	}

	/// Calculets the CrossReliability
	/// \note both Main and Slaveagents are represented by there data and an
	/// unique identifier
	///
	/// \param MainAgent defines the value pair around which the Cross Reliability
	/// is calculated
	/// \param SlaveAgents defines all value pairs of the connected Agents it
	/// doesn't matter if Main agent exists inside this vector
	- Type operator()(std::pair<id_t, StateType> &MainAgent,
	- std::vector<std::pair<id_t, StateType>> &SlaveAgents);
	+ Type operator()(std::pair<id_t, StateType> &&MainAgent,
	+ std::vector<std::pair<id_t, StateType>> &&SlaveAgents);

	/// predefined combination method
	static Type CONJUNCTION(std::vector<Type> values) {
	static_assert(std::is_arithmetic<Type>::value); // sanitny check
	return *std::min_element(values.begin(), values.end());
	}

	/// predefined combination method
	static Type AVERAGE(std::vector<Type> values) {
	static_assert(std::is_arithmetic<Type>::value); // sanitny check
	return std::accumulate(values.begin(), values.end(), 0.0) / values.size();
	}

	/// predefined combination method
	static Type DISJUNCTION(std::vector<Type> values) {
	static_assert(std::is_arithmetic<Type>::value); // sanitny check
	return *std::max_element(values.begin(), values.end());
	}
	};

	template <typename StateType, typename Type>
	inline Type CrossReliability<StateType, Type>::
	-operator()(std::pair<id_t, StateType> &MainAgent,
	- std::vector<std::pair<id_t, StateType>> &SlaveAgents) {
	+operator()(std::pair<id_t, StateType> &&MainAgent,
	+ std::vector<std::pair<id_t, StateType>> &&SlaveAgents) {
	static_assert(std::is_arithmetic<Type>::value); // sanitny check
	static_assert(std::is_arithmetic<StateType>::value); // sanitny check

	Type crossReliabiability;
	std::vector<Type> values;

	for (std::pair<id_t, StateType> SlaveAgent : SlaveAgents) {

	if (SlaveAgent.first == MainAgent.first)
	continue;

	if (MainAgent.second == SlaveAgent.second)
	crossReliabiability = 1;
	else
	crossReliabiability =
	1 / (crossReliabilityParameter *
	AbsuluteValue(MainAgent.second, SlaveAgent.second));

	// profile reliability
	Type crossReliabilityFromProfile = getCrossReliabilityFromProfile(
	MainAgent.first, SlaveAgent.first,
	AbsuluteValue(MainAgent.second, SlaveAgent.second));
	values.push_back(
	std::max(crossReliabiability, crossReliabilityFromProfile));
	}
	return Method(values);
	}

	/// Calculates the Cross Confidence
	/// \brief It uses the a theoretical state represented by a numerical value and
	/// calculates the Reliability of a given agent( represented by there id ) in
	/// connection to all other given agents this can be used to get a Confidence of
	/// the current state
	///
	/// \note all combination of agents and there coresponding Cross Reliability
	/// function have to be specified
	template <typename StateType, typename Type>
	class CrossConfidence : public Abstraction<StateType, Type> {
	using Abstraction = typename rosa::agent::Abstraction<StateType, Type>;

	struct Functionblock {
	bool exists = false;
	id_t A;
	id_t B;
	Abstraction *Funct;
	};

	/// From Maxi in his code defined as 1 can be changed by set
	Type crossReliabilityParameter = 1;

	/// Stored Cross Reliability Functions
	std::vector<Functionblock> Functions;

	/// Method which is used to combine the generated values
	Type (*Method)(std::vector<Type> values) = AVERAGE;

	//--------------------------------------------------------------------------------
	// helper function
	/// evalues the absolute distance between two values
	/// \note this is actually the absolute distance but to ceep it somewhat
	/// conform with maxis code
	template <typename Type_t> Type_t AbsuluteValue(Type_t A, Type_t B) {
	static_assert(std::is_arithmetic<Type_t>::value);
	return ((A - B) < 0) ? B - A : A - B;
	}

	/// verry inefficient searchFunction
	Functionblock (*searchFunction)(std::vector<Functionblock> vect,
	const id_t nameA, const id_t nameB) =
	[](std::vector<Functionblock> vect, const id_t nameA,
	const id_t nameB) -> Functionblock {
	for (Functionblock tmp : vect) {
	if (tmp.A == nameA && tmp.B == nameB)
	return tmp;
	if (tmp.A == nameB && tmp.B == nameA)
	return tmp;
	}
	return Functionblock();
	};

	/// evaluest the corisponding LinearFunction thith the score difference
	/// \param nameA these two parameters are the unique identifiers
	/// \param nameB these two parameters are the unique identifiers
	/// for the LinerFunction
	///
	/// \note it doesn't matter if they are swapped
	Type getCrossReliabilityFromProfile(id_t nameA, id_t nameB,
	StateType scoreDifference) {
	Functionblock block = searchFunction(Functions, nameA, nameB);
	if (!block.exists) {
	LOG_ERROR(("CrossReliability: Block:" + std::to_string(nameA) + "," +
	std::to_string(nameB) + "doesn't exist returning 0"));
	return 0;
	}
	return block.Funct->operator()(scoreDifference);
	}

	public:
	/// adds a Cross Reliability Profile used to get the Reliability of the state
	/// difference
	void addCrossReliabilityProfile(id_t idA, id_t idB, Abstraction *Function) {
	Functions.push_back({true, idA, idB, Function});
	}

	/// sets the cross reliability parameter
	void setCrossReliabilityParameter(Type val) {
	crossReliabilityParameter = val;
	}
	/// sets the used method to combine the values
	void setCrossReliabilityMethod(Type (*Meth)(std::vector<Type> values)) {
	Method = Meth;
	}

	~CrossConfidence() {
	for (auto tmp : Functions)
	delete tmp.Funct;
	Functions.clear();
	}

	Type operator()(id_t MainAgent, StateType TheoreticalValue,
	std::vector<std::pair<id_t, StateType>> &SlaveAgents);

	/// predefined combination method
	static Type CONJUNCTION(std::vector<Type> values) {
	static_assert(std::is_arithmetic<Type>::value); // sanitny check
	return *std::min_element(values.begin(), values.end());
	}

	/// predefined combination method
	static Type AVERAGE(std::vector<Type> values) {
	static_assert(std::is_arithmetic<Type>::value); // sanitny check
	return std::accumulate(values.begin(), values.end(), 0.0) / values.size();
	}

	/// predefined combination method
	static Type DISJUNCTION(std::vector<Type> values) {
	static_assert(std::is_arithmetic<Type>::value); // sanitny check
	return *std::max_element(values.begin(), values.end());
	}
	};

	template <typename StateType, typename Type>
	inline Type CrossConfidence<StateType, Type>::
	operator()(id_t MainAgent, StateType TheoreticalValue,
	std::vector<std::pair<id_t, StateType>> &SlaveAgents) {
	static_assert(std::is_arithmetic<Type>::value); // sanitny check
	static_assert(std::is_arithmetic<StateType>::value); // sanitny check

	Type crossReliabiability;

	std::vector<Type> values;

	for (std::pair<id_t, StateType> SlaveAgent : SlaveAgents) {

	if (SlaveAgent.first == MainAgent)
	continue;

	if (TheoreticalValue == SlaveAgent.second)
	crossReliabiability = 1;
	else
	crossReliabiability =
	1 / (crossReliabilityParameter *
	AbsuluteValue(TheoreticalValue, SlaveAgent.second));

	// profile reliability
	Type crossReliabilityFromProfile = getCrossReliabilityFromProfile(
	MainAgent, SlaveAgent.first,
	AbsuluteValue(TheoreticalValue, SlaveAgent.second));
	values.push_back(
	std::max(crossReliabiability, crossReliabilityFromProfile));
	}
	return Method(values);
	}

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

	#endif // ROSA_AGENT_CROSSRELIABILITY_H
	\ No newline at end of file
	diff --git a/include/rosa/agent/Reliability.h b/include/rosa/agent/Reliability.h
	index 70290d5..18998fd 100644
	--- a/include/rosa/agent/Reliability.h
	+++ b/include/rosa/agent/Reliability.h
	@@ -1,413 +1,433 @@
	//===-- 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.
	///
	/// \note All classes throw runtime errors if not all things are set
	///
	//===----------------------------------------------------------------------===//

	#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>
	#include <algorithm>

	#define __ostream_output true

	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 {
	+ public:
	struct ConfOrRel {
	StateType score;
	ReliabilityType Reliability;

	ConfOrRel(StateType _score,ReliabilityType _Reliability):score(_score),Reliability(_Reliability){};
	ConfOrRel() {};
	#if __ostream_output
	friend std::ostream & operator << (std::ostream &out, const ConfOrRel &c)
	{
	out << "Score: " << c.score << "\t Reliability: " << c.Reliability << " " ;
	return out;
	}
	#endif
	};
	- 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->operator()(SensorValue);
	-
	+
	std::vector<ConfOrRel> ActuallPossibleScores;
	for (StateType state : States)
	{
	if(ActuallPosibleScores_tmp.find(state)!=ActuallPosibleScores_tmp.end())
	{
	ConfOrRel val;
	val.score=state;
	val.Reliability=ActuallPosibleScores_tmp.find(state)->second;
	ActuallPossibleScores.push_back(val);
	}

	}
	ReliabilityType inputReliability;

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

	+ std::cout << "input Rel: " << inputReliability << "\n";
	+
	for (std::size_t at = 0; at < ActuallPossibleScores.size(); at++)
	ActuallPossibleScores.at(at).Reliability = std::min(ActuallPossibleScores.at(at).Reliability, 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;

	possibleScores=getAllPossibleScoresBasedOnHistory(possibleScores);

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


	previousSensorValue = SensorValue;
	PreviousSensorValueExists = true;
	+
	for(auto val:ActuallPossibleScores)
	std::cout <<"inside APS:" << val << "\n";
	for(auto val:possibleScores)
	std::cout <<"inside PS:" << val << "\n";
	-
	+
	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;
	}

	/// This is the setter for all possible States
	/// \param states A vertor for all states
	void setStates(std::vector<StateType> states)
	{
	this->States=states;
	}

	/// This sets the Maximum length of the Histpry
	/// \param length The length
	void setHistoryLength(std::size_t length)
	{
	this->HistoryMaxSize=length;
	}

	+ /// This sets the Value set Counter
	+ /// \param ValueSetCounter the new Value
	+ void setValueSetCounter(unsigned int ValueSetCounter)
	+ {
	+ this->valueSetCounter=ValueSetCounter;
	+ }

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

	delete Reliability;
	Reliability = nullptr;

	delete ReliabilitySlope;
	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 Todo
	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;
	for (auto pShE = History.begin(); pShE < History.end(); pShE++, posInHistory++) {


	//iterate through all possible scores of each history entry
	for (ConfOrRel& pSh : *pShE) {

	//printf("a3\n");

	StateType historyScore = pSh.score;
	ReliabilityType 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->operator()(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.Reliability = std::max(pS.Reliability, 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.insert(History.begin(),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;
	+
	+ ConfOrRel(StateType _score,ReliabilityType _Reliability):score(_score),Reliability(_Reliability){};
	+ ConfOrRel() {};
	+ #if __ostream_output
	+ friend std::ostream & operator << (std::ostream &out, const ConfOrRel &c)
	+ {
	+ out << "Score: " << c.score << "\t Reliability: " << c.Reliability << " " ;
	+ return out;
	+ }
	+ #endif
	};

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

	StateType MaximumState;

	- returnType operator()(std::vector<std::tuple<id_t, StateType, ReliabilityType>> Values)
	+ 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);
	+ tmp2.first = std::get<0>(tmp);
	+ tmp2.second = std::get<1>(tmp);
	+ Agents.push_back(tmp2);
	}


	for (auto Value : Values) {
	+ id_t id = std::get<0>(Value);
	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 >> )
	+ ReliabilityType realCrossReliabilityOfSlaveAgent = CrossReliability->operator()({id,sc }, Agents); //AVERAGE, MULTIPLICATION, CONJUNCTION (best to worst: AVERAGE = CONJUNCTION > MULTIPLICATION >> )

	output_temporary.clear();
	for (StateType theoreticalScore = 0; theoreticalScore <= MaximumState; theoreticalScore++) {
	//calculate the cross reliability for this slave agent
	ConfOrRel data;
	data.score = theoreticalScore;
	- data.Reliability = CrossConfidence(std::get<0>(Value), theoreticalScore, Agents);
	+ data.Reliability = CrossConfidence->operator()(id, 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
	~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-diff
Expires: Fri, Jul 4, 5:36 AM (5 h, 43 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 157474
Default Alt Text: (36 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions