Page MenuHomePhorge
Files F360773

No OneTemporary
Actions

Size
15 KB
Referenced Files
None
Subscribers
None

View Options

diff --git a/include/rosa/agent/Reliability.h b/include/rosa/agent/Reliability.h
index ec68be6..debe35d 100644
--- a/include/rosa/agent/Reliability.h
+++ b/include/rosa/agent/Reliability.h
@@ -1,257 +1,369 @@
//===-- rosa/agent/Reliability.h --------------------------------*- C++ -*-===//
//
// The RoSA Framework
//
//===----------------------------------------------------------------------===//
///
/// \file rosa/agent/Reliability.h
///
/// \author Daniel Schnoell (danielschnoell@tuwien.ac.at)
///
/// \date 2019
///
-/// \brief Declaration of `rosa::Reliability` base-class.
+/// \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;
- Abstraction<SensorValueType, ReliabilityType>* Reliability;
- Abstraction<SensorValueType, ReliabilityType>* ReliabilitySlope;
- Abstraction<std::size_t, ReliabilityType>* TimeConfidence;
+ 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);
- ReliabilityType relSlo = ReliabilitySlope->operator()((lastValue - actualValue) / (SensorValueType)valueSetCounter);
+ 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;
+ // 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);
+ 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();
}
}
}
-
- 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);
-
- }
};
+
+ /// 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;
};
- CrossReliability<StateType, ReliabilityType>* CrossReliability = nullptr;
- CrossConfidence <StateType, ReliabilityType>* CrossConfidence = nullptr;
-
-
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-diff
Expires
Sat, May 17, 5:06 AM (1 d, 3 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
141506
Default Alt Text
(15 KB)

Event Timeline