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 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 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 ActuallPosibleScores_tmp = Confidence(SensorValue); + + std::vector 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 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 ValuesFromMaster) + { + this->ValuesFromMaster = ValuesFromMaster; + } + + + /// This is the setter for Confidence Function + /// \param Confidence A pointer to the Functional for the Confidence + void setConfidenceFunction(RangeConfidence* Confidence) + { + this->Confidence = Confidence; + } + + /// This is the setter for Reliability Function + /// \param Reliability A pointer to the Functional for the Reliability + void setReliabilityFunction(Abstraction* Reliability) + { + this->Reliability = Reliability; + } + + /// This is the setter for ReliabilitySlope Function + /// \param ReliabilitySlope A pointer to the Functional for the ReliabilitySlope + void setReliabilitySlopeFunction(Abstraction* ReliabilitySlope) + { + this->ReliabilitySlope = ReliabilitySlope; + } + + /// This is the setter for TimeConfidence Function + /// \param TimeConfidence A pointer to the Functional for the TimeConfidence + void setTimeConfidenceFunction(Abstraction* 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> History; std::size_t HistoryMaxSize; std::vector ValuesFromMaster; SensorValueType previousSensorValue; unsigned int valueSetCounter; std::vector States; bool PreviousSensorValueExists = false; - RangeConfidence* Confidence; - Abstraction* Reliability; - Abstraction* ReliabilitySlope; - Abstraction* TimeConfidence; + RangeConfidence* Confidence = nullptr; + Abstraction* Reliability = nullptr; + Abstraction* ReliabilitySlope = nullptr; + Abstraction* 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 getAllPossibleScoresBasedOnHistory(std::vector possibleScores) { //iterate through all history entries std::size_t posInHistory = 0; typedef typename std::vector>::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::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 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 ActuallPosibleScores_tmp = Confidence(SensorValue); - - std::vector 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 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 class HighLevel { + public: + struct ConfOrRel { StateType score; ReliabilityType Reliability; }; struct returnType { ReliabilityType CrossReliability; std::vector>> CrossConfidence; }; - CrossReliability* CrossReliability = nullptr; - CrossConfidence * CrossConfidence = nullptr; - - returnType operator()(std::vector> Values) { StateType EWS = 0; ReliabilityType combinedInputRel = 1; ReliabilityType combinedCrossRel = 1; ReliabilityType outputReliability; std::vector> Agents; std::vector>> output; std::vector output_temporary; for (auto tmp : Values) { std::pair 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* CrossReliability) + { + this->CrossReliability = CrossReliability; + } + + /// This is the setter for CrossConfidence Function + /// param A pointer to the Functional for the CrossConfidence + void setFunction(CrossConfidence * CrossConfidence) + { + this->CrossConfidence = CrossConfidence; + } + + /// deletes all given pointers + void ~HighLevel() + { + delete CrossReliability; + CrossConfidence = nullptr; + delete CrossConfidence; + CrossConfidence = nullptr; + } + + private: + + CrossReliability* CrossReliability = nullptr; + CrossConfidence * CrossConfidence = nullptr; }; } // namespace agent }// namespace rosa #endif // !ROSA_AGENT_RELIABILITY_H