Page MenuHomePhorge
Files F360851

No OneTemporary
Actions

Size
42 KB
Referenced Files
None
Subscribers
None

View Options

diff --git a/Version_Max_07_05_2018_CMake/src/StateHandler.cpp b/Version_Max_07_05_2018_CMake/src/StateHandler.cpp
index aa88186..04c4137 100755
--- a/Version_Max_07_05_2018_CMake/src/StateHandler.cpp
+++ b/Version_Max_07_05_2018_CMake/src/StateHandler.cpp
@@ -1,1206 +1,1206 @@
#include "StateHandler.h"
#include "config.h"
#include "printError.h"
#include "rlutil.h"
#include <algorithm>
#include "relationChecker.h"
#include "file_util.h"
#include "minmaxzeug.h"
#include <ctime>
#include <iostream>
//#define PRINT
-#define WRITE_MORE_INFORMATION_IN_CSV
+//#define WRITE_MORE_INFORMATION_IN_CSV
#ifdef PRINT
//#define STOP_WHEN_BROKEN
//#define STOP_AFTER_BROKEN
//#define STOP_WHEN_DRIFT
//#define STOP_WHEN_STATE_VALID
//#define STOP_WHEN_CHANGING_IN_OLD_STATE
//#define STOP_EVERY_TIME
//#define STOP_EVERY_TIME_AFTER_SAMPLENR 500000
#endif
// STANDARD_STATE_HISTORY_LENGTH is used for the history length of the number of
// values which will be compared to the current value
// NOTE: Fuzzy Functions FuncBlockConfSim2StateTime, FuncBlockConfDif2StateTime,
// FuncBlockConfValStateTime, and FuncBlockConfInvStateTime should have the same
// length NOTE: You can set the History Length with the function
// setMaxStateHistoryLength()
#define STANDARD_STATE_HISTORY_LENGTH 10 // 10
#define INJECTIONPARTITIONING 5
// three different status are for the system possible
#define STATUS_BROKEN 1
#define STATUS_DRIFT 2
#define STATUS_OKAY 3
using namespace rlutil;
void StateHandler::initStateHandler() {
csv_writer = NULL;
discreteAveragePartitionSize = INJECTIONPARTITIONING;
activeState = NULL;
// TODO: Question from Maxi: Do we need following (outcommented block)? I
// (maxi) commented it out.
/*
time_t rawtime;
struct tm timeinfo;
// char output_file_name[200];
char datetime[80];
const std::string output_directory_name =
"../data/out/"; // "./output_data_csv/Opel/2018-08-09/"; there is no
// impact if we change it!
std::string output_file_name_str;
time(&rawtime);
// timeinfo = localtime(&rawtime);
#ifdef _WIN32
localtime_s(&timeinfo, &rawtime);
#else
localtime_r(&rawtime, &timeinfo);
#endif
strftime(datetime, sizeof(datetime), "%Y-%m-%d_%I-%M-%S", &timeinfo);
#ifndef INPUT_FILE_NAME
output_file_name_str = output_directory_name + "output" + datetime + ".csv";
#else
output_file_name_str =
output_directory_name + INPUT_FILE_NAME + datetime + ".csv";
#endif // INPUT_FILE_NAME
#ifdef PRINT
cout << output_file_name_str << endl;
#endif // PRINT
*/
}
StateHandler::StateHandler() {
set_name(NO_NAME);
initStateHandler();
}
StateHandler::StateHandler(std::string name) {
set_name(name);
initStateHandler();
}
StateHandler::StateHandler(std::string name, std::string csvWriterPath) {
set_name(name);
initStateHandler();
csv_writer = new CSV_Writer("CSV Writer", csvWriterPath);
}
bool StateHandler::setDiscreteAveragePartitionSize(
unsigned int discreteAveragePartitionSize) {
if (discreteAveragePartitionSize > 0) {
this->discreteAveragePartitionSize = discreteAveragePartitionSize;
return true;
}
return false;
}
unsigned int StateHandler::getDiscreteAveragePartitionSize() {
return discreteAveragePartitionSize;
}
bool StateHandler::addVariable(vector<SlaveAgentSlotOfAgent *> *vVariables,
SlaveAgentSlotOfAgent *slot) {
if (vVariables != NULL && slot != NULL) {
if (find((*vVariables).begin(), (*vVariables).end(), slot) ==
(*vVariables).end()) {
try {
(*vVariables).push_back(slot);
return true;
} catch (bad_alloc &error) {
printError("bad_alloc caught: ", error.what());
}
}
}
return false;
}
bool StateHandler::addInputVariable(SlaveAgentSlotOfAgent *slot) {
return addVariable(&vInputVariables, slot);
}
bool StateHandler::addOutputVariable(SlaveAgentSlotOfAgent *slot) {
return addVariable(&vOutputVariables, slot);
}
bool StateHandler::delete_all_OuputVariables() {
SlaveAgentSlotOfAgent *cur_sl_ag_sl_ag;
unsigned int index_v_OutVar;
unsigned int size_v_OutVar = vOutputVariables.size();
for (index_v_OutVar = 0; index_v_OutVar < size_v_OutVar; index_v_OutVar++) {
cur_sl_ag_sl_ag = vOutputVariables[index_v_OutVar];
delete cur_sl_ag_sl_ag;
}
vOutputVariables.clear();
return true; // added by Ali, it is an error in VS.
}
bool StateHandler::delete_all_InputVariables() {
SlaveAgentSlotOfAgent *cur_sl_ag_sl_ag;
unsigned int index_v_InpVar;
unsigned int size_v_InpVar = vInputVariables.size();
for (index_v_InpVar = 0; index_v_InpVar < size_v_InpVar; index_v_InpVar++) {
cur_sl_ag_sl_ag = vInputVariables[index_v_InpVar];
delete cur_sl_ag_sl_ag;
}
vInputVariables.clear();
return true; // added by Ali, it is an error in VS.
}
bool StateHandler::delete_allStates() {
State *cur_state;
unsigned int index_v_State;
unsigned int size_v_State = vStates.size();
for (index_v_State = 0; index_v_State < size_v_State; index_v_State++) {
cur_state = vStates[index_v_State];
delete cur_state;
}
vStates.clear();
return true; // added by Ali, it is an error in VS.
}
// Sorting with bigger Value in Front
struct descending {
template <class T> bool operator()(T const &a, T const &b) const {
return a > b;
}
};
State *StateHandler::makeNewState() {
State *state = new (nothrow) State();
if (state != NULL) {
bool flagLoadVariablesWorked = true;
for (auto &slot : vInputVariables) {
if (!state->addInputSubState(slot))
flagLoadVariablesWorked = false;
}
for (auto &slot : vOutputVariables) {
if (!state->addOutputSubState(slot))
flagLoadVariablesWorked = false;
}
if (!flagLoadVariablesWorked) {
delete state;
return NULL;
}
} else {
return NULL;
}
return state;
}
bool StateHandler::addActiveStateToStateVector() {
#ifdef PRINT
printf(" >> Save Active State\n");
#endif // PRINT
if (activeState != NULL) {
for (auto &state : vStates) {
if (state == activeState)
return true;
}
#ifdef STOP_WHEN_STATE_VALID
getchar();
#endif // STOP_WHEN_STATE_VALID
try {
vStates.push_back(activeState);
return true;
} catch (bad_alloc &error) {
printError("bad_alloc caught: ", error.what());
delete activeState;
}
}
return false;
}
bool StateHandler::makeNewActiveState() {
State *state = makeNewState();
if (state != NULL) {
activeState = state;
return true;
}
return false;
}
void StateHandler ::reset_States() {
this->delete_allStates();
this->activeState = NULL;
}
void StateHandler ::reset_States_and_Slave_Agents() {
reset_States();
this->delete_all_InputVariables();
this->delete_all_OuputVariables();
}
void StateHandler::setMaxStateHistoryLength(
unsigned int maxStateHistoryLength) {
this->maxStateHistoryLength = maxStateHistoryLength;
}
void StateHandler::setSimilarToStateDeviationFuzzyFunction(
LinearFunctionBlock *FuncBlockConfSim2StateDev) {
this->FuncBlockConfSim2StateDev = FuncBlockConfSim2StateDev;
}
LinearFunctionBlock *StateHandler::getSimilarToStateDeviationFuzzyFunction() {
return this->FuncBlockConfSim2StateDev;
}
void StateHandler::setSimilarToStateTimeFuzzyFunction(
LinearFunctionBlock *FuncBlockConfSim2StateTime) {
this->FuncBlockConfSim2StateTime = FuncBlockConfSim2StateTime;
}
LinearFunctionBlock *StateHandler::getSimilarToStateTimeFuzzyFunction() {
return this->FuncBlockConfSim2StateTime;
}
void StateHandler::setDifferentToStateFuzzyFunction(
LinearFunctionBlock *FuncBlockConfDif2StateDev) {
this->FuncBlockConfDif2StateDev = FuncBlockConfDif2StateDev;
}
LinearFunctionBlock *StateHandler::getDifferentToStateDeviationFuzzyFunction() {
return this->FuncBlockConfDif2StateDev;
}
void StateHandler::setDifferentToStateTimeFuzzyFunction(
LinearFunctionBlock *FuncBlockConfDif2StateTime) {
this->FuncBlockConfDif2StateTime = FuncBlockConfDif2StateTime;
}
LinearFunctionBlock *StateHandler::getDifferentToStateTimeFuzzyFunction() {
return this->FuncBlockConfDif2StateTime;
}
void StateHandler::setSimilarityInStateDeviationFuzzyFunction(
LinearFunctionBlock *FuncBlockConfValStateDev) {
this->FuncBlockConfValStateDev = FuncBlockConfValStateDev;
}
LinearFunctionBlock *
StateHandler::getSimilarityInStateDeviationFuzzyFunction() {
return this->FuncBlockConfValStateDev;
}
void StateHandler::setSimilarityInStateTimeFuzzyFunction(
LinearFunctionBlock *FuncBlockConfValStateTime) {
this->FuncBlockConfValStateTime = FuncBlockConfValStateTime;
}
LinearFunctionBlock *StateHandler::getSimilarityInStateTimeFuzzyFunction() {
return this->FuncBlockConfValStateTime;
}
void StateHandler::setUnsimilarityInStateDeviationFuzzyFunction(
LinearFunctionBlock *FuncBlockConfInvStateDev) {
this->FuncBlockConfInvStateDev = FuncBlockConfInvStateDev;
}
LinearFunctionBlock *
StateHandler::getUnsimilarityInStateDeviationFuzzyFunction() {
return this->FuncBlockConfInvStateDev;
}
void StateHandler::setUnsimilarityInStateTimeFuzzyFunction(
LinearFunctionBlock *FuncBlockConfInvStateTime) {
this->FuncBlockConfInvStateTime = FuncBlockConfInvStateTime;
}
LinearFunctionBlock *StateHandler::getUnsimilarityInStateTimeFuzzyFunction() {
return this->FuncBlockConfInvStateTime;
}
void StateHandler::setDriftFuzzyFunction(
LinearFunctionBlock *FuncBlockDriftDeviation) {
this->FuncBlockDriftDeviation = FuncBlockDriftDeviation;
}
LinearFunctionBlock *StateHandler::getDriftFuzzyFunction() {
return this->FuncBlockDriftDeviation;
}
void StateHandler::setBrokenFuzzyFunction(
LinearFunctionBlock *FuncBlockConfBrokenSamples) {
this->FuncBlockConfBrokenSamples = FuncBlockConfBrokenSamples;
}
LinearFunctionBlock *StateHandler::getBrokenFuzzyFunction() {
return this->FuncBlockConfBrokenSamples;
}
void StateHandler::setSimilarToStateFuzzyFunctions(
LinearFunctionBlock *FuncBlockConfSim2StateDev,
LinearFunctionBlock *FuncBlockConfSim2StateTime) {
this->FuncBlockConfSim2StateDev = FuncBlockConfSim2StateDev;
this->FuncBlockConfSim2StateTime = FuncBlockConfSim2StateTime;
}
void StateHandler::setDifferentToStateFuzzyFunctions(
LinearFunctionBlock *FuncBlockConfDif2StateDev,
LinearFunctionBlock *FuncBlockConfDif2StateTime) {
this->FuncBlockConfDif2StateDev = FuncBlockConfDif2StateDev;
this->FuncBlockConfDif2StateTime = FuncBlockConfDif2StateTime;
}
void StateHandler::setSimilarityInStateFuzzyFunctions(
LinearFunctionBlock *FuncBlockConfValStateDev,
LinearFunctionBlock *FuncBlockConfValStateTime) {
this->FuncBlockConfValStateDev = FuncBlockConfValStateDev;
this->FuncBlockConfValStateTime = FuncBlockConfValStateTime;
}
void StateHandler::setUnsimilarityInStateFuzzyFunctions(
LinearFunctionBlock *FuncBlockConfInvStateDev,
LinearFunctionBlock *FuncBlockConfInvStateTime) {
this->FuncBlockConfInvStateDev = FuncBlockConfInvStateDev;
this->FuncBlockConfInvStateTime = FuncBlockConfInvStateTime;
}
void StateHandler::setDriftAndBrokenFuzzyFunctions(
LinearFunctionBlock *FuncBlockDriftDeviation,
LinearFunctionBlock *FuncBlockConfBrokenSamples) {
this->FuncBlockDriftDeviation = FuncBlockDriftDeviation;
this->FuncBlockConfBrokenSamples = FuncBlockConfBrokenSamples;
}
StateHandler ::~StateHandler() {
delete_all_OuputVariables();
delete_all_InputVariables();
delete_allStates();
// delete csv_writer;
}
void StateHandler::printOK() {
setColor(TXTCOLOR_LIGHTGREEN);
printf("OK\n");
setColor(TXTCOLOR_GREY);
}
void StateHandler::printDrift() {
setColor(TXTCOLOR_YELLOW);
printf(" >> DRIFT\n");
setColor(TXTCOLOR_GREY);
}
void StateHandler::printBroken() {
setColor(TXTCOLOR_LIGHTRED);
printf(" >> BROKEN\n");
setColor(TXTCOLOR_GREY);
}
// XXX - only for now
unsigned int old_cycle = 1;
int brokentest = 0;
bool flagPrintHeader = false;
/*
* makes a new state and reports if there is a anomaly = hearth piece of CAM :-)
*/
void StateHandler::trigger(unsigned int cycle) {
#ifdef PRINT
printf("cycle: %u\n", cycle);
#endif // PRINT
bool flagGotValues = true;
#ifdef PRINT
printf("Input Sample Values:\n");
#endif // PRINT
for (auto &slot : vInputVariables) {
float sampleValue;
if (!(slot->get_slaveAgentValue(&sampleValue)))
flagGotValues = false;
#ifdef PRINT
printf("In, %s: %f\n", slot->get_comPort()->get_name().c_str(),
sampleValue);
#endif // PRINT
}
#ifdef PRINT
printf("Output Sample Values:\n");
#endif // PRINT
for (auto &slot : vOutputVariables) {
float sampleValue;
if (!(slot->get_slaveAgentValue(&sampleValue)))
flagGotValues = false;
#ifdef PRINT
printf("Out, %s: %f\n", slot->get_comPort()->get_name().c_str(),
sampleValue);
#endif // PRINT
}
if (flagPrintHeader == false) {
csv_writer->write_field("Nr of States");
csv_writer->make_new_field();
csv_writer->write_field("State Nr");
csv_writer->make_new_field();
#ifdef WRITE_MORE_INFORMATION_IN_CSV
csv_writer->write_field("Conf State Valid");
csv_writer->make_new_field();
csv_writer->write_field("Conf State Invalid");
csv_writer->make_new_field();
csv_writer->write_field("Conf Input unchanged");
csv_writer->make_new_field();
csv_writer->write_field("Conf Input changed");
csv_writer->make_new_field();
csv_writer->write_field("Conf Output unchanged");
csv_writer->make_new_field();
csv_writer->write_field("Conf Output changed");
csv_writer->make_new_field();
#endif // WRITE_MORE_INFORMATION_IN_CSV
csv_writer->write_field("Status");
csv_writer->make_new_field();
csv_writer->write_field("Conf Status");
// csv_writer->make_new_field();
if (flagGotValues == true)
csv_writer->make_new_line();
flagPrintHeader = true;
}
if (!flagGotValues) {
} else {
// printf("neu\n");
// in the beginning, a active state has to be created
if (activeState == NULL && vStates.empty()) {
brokenCounter = 0;
#ifdef PRINT
printf(" > new active state\n");
#endif // PRINT
makeNewActiveState();
if (activeState->insertValueInState(
FuncBlockConfValStateDev, FuncBlockConfInvStateDev,
FuncBlockConfValStateTime, FuncBlockConfInvStateTime,
maxStateHistoryLength, discreteAveragePartitionSize))
addActiveStateToStateVector();
// NEW - Adjust FuncBlockConfSim2StateTime and FuncBlockConfDif2StateTime
float newBoundary = (float)activeState->getLengthOfHistory();
FuncBlockConfSim2StateTime->changeFunctionBlockIncr(newBoundary);
FuncBlockConfDif2StateTime->changeFunctionBlockDecr(newBoundary);
csv_writer->write_field((int)vStates.size());
csv_writer->make_new_field();
ptrdiff_t stateNr = find(vStates.begin(), vStates.end(), activeState) -
vStates.begin() + 1;
csv_writer->write_field((int)stateNr);
csv_writer->make_new_field();
#ifdef WRITE_MORE_INFORMATION_IN_CSV
csv_writer->write_field(activeState->getConfStateValid());
csv_writer->make_new_field();
csv_writer->write_field(activeState->getConfStateInvalid());
csv_writer->make_new_field();
csv_writer->write_field(0); // confInputVarAreSim2ActiveState
csv_writer->make_new_field();
csv_writer->write_field(0); // confInputVarAreDif2ActiveState
csv_writer->make_new_field();
csv_writer->write_field(0); // confOutputVarAreSim2ActiveState
csv_writer->make_new_field();
csv_writer->write_field(0); // confOutputVarAreDif2ActiveState
csv_writer->make_new_field();
#endif // WRITE_MORE_INFORMATION_IN_CSV
csv_writer->write_field(STATUS_OKAY); // OK
csv_writer->make_new_field();
// NOTE: Status Conf = 0 because conf valid = 0
csv_writer->write_field(0); // Status Conf
// csv_writer->make_new_field();
}
// there is an active state and/or other states
// XXXX - There is no if regarding an active state?!?!?
else {
float confInputVarAreSim2ActiveState =
activeState->getConfInputVarAreSim2State(FuncBlockConfSim2StateDev,
FuncBlockConfSim2StateTime);
float confInputVarAreDif2ActiveState =
activeState->getConfInputVarAreDif2State(FuncBlockConfDif2StateDev,
FuncBlockConfDif2StateTime);
float confOutputVarAreSim2ActiveState =
activeState->getConfOutputVarAreSim2State(FuncBlockConfSim2StateDev,
FuncBlockConfSim2StateTime);
float confOutputVarAreDif2ActiveState =
activeState->getConfOutputVarAreDif2State(FuncBlockConfDif2StateDev,
FuncBlockConfDif2StateTime);
// printf("input (sim/dif) %f/%f\noutput (sim/dif) %f/%f\n",
// confInputVarAreSim2ActiveState, confInputVarAreDif2ActiveState,
// confOutputVarAreSim2ActiveState, confOutputVarAreDif2ActiveState);
// bool flagActiveStateWasValid = false;
// if no change has detected -> same state
if ((confInputVarAreSim2ActiveState > confInputVarAreDif2ActiveState) &&
(confOutputVarAreSim2ActiveState > confOutputVarAreDif2ActiveState)) {
brokenCounter = 0;
#ifdef PRINT
printf(" > same state\n");
// printf("\nPROOF:\nconfInputVarAreSim2ActiveState =
// %f\nconfInputVarAreDif2ActiveState =
// %f\nconfOutputVarAreSim2ActiveState =
// %f\nconfOutputVarAreDif2ActiveState = %f\n",
// confInputVarAreSim2ActiveState, confInputVarAreDif2ActiveState,
// confOutputVarAreSim2ActiveState, confOutputVarAreDif2ActiveState);
#endif // PRINT
if (activeState->insertValueInState(
FuncBlockConfValStateDev, FuncBlockConfInvStateDev,
FuncBlockConfValStateTime, FuncBlockConfInvStateTime,
maxStateHistoryLength, discreteAveragePartitionSize))
addActiveStateToStateVector();
// NEW - Adjust FuncBlockConfSim2StateTime and
// FuncBlockConfDif2StateTime
float newBoundary = (float)activeState->getLengthOfHistory();
FuncBlockConfSim2StateTime->changeFunctionBlockIncr(newBoundary);
FuncBlockConfDif2StateTime->changeFunctionBlockDecr(newBoundary);
csv_writer->write_field((int)vStates.size());
csv_writer->make_new_field();
ptrdiff_t stateNr = find(vStates.begin(), vStates.end(), activeState) -
vStates.begin() + 1;
csv_writer->write_field((int)stateNr);
csv_writer->make_new_field();
#ifdef WRITE_MORE_INFORMATION_IN_CSV
// write conf valid
csv_writer->write_field(activeState->getConfStateValid());
csv_writer->make_new_field();
csv_writer->write_field(activeState->getConfStateInvalid());
csv_writer->make_new_field();
// write conf statechange
csv_writer->write_field(confInputVarAreSim2ActiveState);
csv_writer->make_new_field();
csv_writer->write_field(confInputVarAreDif2ActiveState);
csv_writer->make_new_field();
csv_writer->write_field(confOutputVarAreSim2ActiveState);
csv_writer->make_new_field();
csv_writer->write_field(confOutputVarAreDif2ActiveState);
csv_writer->make_new_field();
#endif // WRITE_MORE_INFORMATION_IN_CSV
confidenceDrift = activeState->checkAllVariablesForDriftingFuzzy(
discreteAveragePartitionSize, FuncBlockDriftDeviation);
float confidenceNoDrift = 1 - confidenceDrift;
//AAAAAAAAA (New: "&& activeState->isStateValidAfterReentrance()")
if (confidenceDrift > 0.5 && activeState->isStateValidAfterReentrance()) {
#ifdef PRINT
printDrift();
#endif // PRINT
#ifdef STOP_WHEN_DRIFT
getchar();
#endif // STOP_WHEN_DRIFT
// print drift
csv_writer->write_field(STATUS_DRIFT);
csv_writer->make_new_field();
// calc and print conf
// AAAAAAAAAAAAAAAA
float conf = fuzzyAND(
fuzzyAND(confInputVarAreSim2ActiveState,
confOutputVarAreSim2ActiveState),
fuzzyAND(confidenceDrift, activeState->getConfStateValid()));
csv_writer->write_field(conf);
// printf("drift bei (same state): %i\n", cycle);
} else {
#ifdef PRINT
printOK();
#endif // PRINT
// print ok
csv_writer->write_field(STATUS_OKAY);
csv_writer->make_new_field();
// calc and print conf
//AAAAAAAAAAA
//NOTE: next equation is without confOK because confOK = 1 anyway (because broken timer = 0)
float conf =
fuzzyAND(fuzzyOR(fuzzyAND(confInputVarAreSim2ActiveState,
confOutputVarAreSim2ActiveState),
fuzzyAND(confInputVarAreDif2ActiveState,
confOutputVarAreDif2ActiveState)),
fuzzyAND(activeState->getConfStateValid(),
confidenceNoDrift));
csv_writer->write_field(conf);
}
// csv_writer->make_new_field();
} // same state
// state change
else {
// search in vector for matching state //TODO in future: look for the
// best matching, Not for the first matching
bool flagFoundMatchingState = false;
bool flagFoundHalfMatchingState = false;
bool flagHalfMatchingStateIsActiveState = false;
bool flagHalfMatchingStateIsAnotherState = false;
float confInputVarAreSim2State;
float confInputVarAreDif2State;
float confOutputVarAreSim2State;
float confOutputVarAreDif2State;
State *activeStateBackup = activeState;
bool flagActiveStateWasValid = activeState->isStateValid();
float backupConfInputVarAreSim2ActiveState;
float backupConfInputVarAreDif2ActiveState;
float backupConfOutputVarAreSim2ActiveState;
float backupConfOutputVarAreDif2ActiveState;
float backupConfInputVarAreSim2State;
float backupConfInputVarAreDif2State;
float backupConfOutputVarAreSim2State;
float backupConfOutputVarAreDif2State;
float highestConfidenceDifferenceMatch = 0;
// compare with all states
for (auto &state : vStates) {
confInputVarAreSim2State = state->getConfInputVarAreSim2State(
FuncBlockConfSim2StateDev, FuncBlockConfSim2StateTime);
confInputVarAreDif2State = state->getConfInputVarAreDif2State(
FuncBlockConfDif2StateDev, FuncBlockConfDif2StateTime);
confOutputVarAreSim2State = state->getConfOutputVarAreSim2State(
FuncBlockConfSim2StateDev, FuncBlockConfSim2StateTime);
confOutputVarAreDif2State = state->getConfOutputVarAreDif2State(
FuncBlockConfDif2StateDev, FuncBlockConfDif2StateTime);
// state matches full with another state
if ((confInputVarAreSim2State > confInputVarAreDif2State) &&
(confOutputVarAreSim2State > confOutputVarAreDif2State)) {
// lastActiveState == activeState;
activeState = state;
flagFoundMatchingState = true;
backupConfInputVarAreSim2State = confInputVarAreSim2State;
backupConfInputVarAreDif2State = confInputVarAreDif2State;
backupConfOutputVarAreSim2State = confOutputVarAreSim2State;
backupConfOutputVarAreDif2State = confOutputVarAreDif2State;
#ifdef PRINT
ptrdiff_t stateNr = find(vStates.begin(), vStates.end(), state) -
vStates.begin() + 1;
setColor(TXTCOLOR_LIGHTGREEN);
printf("- Passt voll zu: %i\n", stateNr);
setColor(TXTCOLOR_GREY);
#endif // PRINT
break;
}
// state matches half with another state
else if ((confInputVarAreSim2State > confInputVarAreDif2State) ||
(confOutputVarAreSim2State > confOutputVarAreDif2State)) {
flagFoundHalfMatchingState = true;
// half matchin state is the active state
if (state == activeStateBackup) {
#ifdef PRINT
ptrdiff_t stateNr = find(vStates.begin(), vStates.end(), state) -
vStates.begin() + 1;
setColor(TXTCOLOR_YELLOW);
printf("- Passt halb zu: %i (active State)\n", stateNr);
setColor(TXTCOLOR_GREY);
#endif // PRINT
flagHalfMatchingStateIsActiveState = true;
backupConfInputVarAreSim2ActiveState = confInputVarAreSim2State;
backupConfInputVarAreDif2ActiveState = confInputVarAreDif2State;
backupConfOutputVarAreSim2ActiveState = confOutputVarAreSim2State;
backupConfOutputVarAreDif2ActiveState = confOutputVarAreDif2State;
}
// half matchin state is the another state
else {
#ifdef PRINT
ptrdiff_t stateNr = find(vStates.begin(), vStates.end(), state) -
vStates.begin() + 1;
setColor(TXTCOLOR_YELLOW);
printf("- Passt halb zu: %i (another State)\n", stateNr);
setColor(TXTCOLOR_GREY);
#endif // PRINT
flagHalfMatchingStateIsAnotherState = true;
float diffConfInputVarAreSim2State =
confInputVarAreSim2State - confInputVarAreDif2State;
float diffConfOutputVarAreSim2State =
confOutputVarAreSim2State - confOutputVarAreDif2State;
if (diffConfInputVarAreSim2State >
highestConfidenceDifferenceMatch) {
activeState = state;
highestConfidenceDifferenceMatch = diffConfInputVarAreSim2State;
backupConfInputVarAreSim2State = confInputVarAreSim2State;
backupConfInputVarAreDif2State = confInputVarAreDif2State;
backupConfOutputVarAreSim2State = confOutputVarAreSim2State;
backupConfOutputVarAreDif2State = confOutputVarAreDif2State;
}
if (diffConfOutputVarAreSim2State >
highestConfidenceDifferenceMatch) {
activeState = state;
highestConfidenceDifferenceMatch =
diffConfOutputVarAreSim2State;
backupConfInputVarAreSim2State = confInputVarAreSim2State;
backupConfInputVarAreDif2State = confInputVarAreDif2State;
backupConfOutputVarAreSim2State = confOutputVarAreSim2State;
backupConfOutputVarAreDif2State = confOutputVarAreDif2State;
}
}
}
}
// another state matches In- AND Outputs
if (flagFoundMatchingState == true) {
// new revision cam
activeState->resetNumOfInsertedSamples();
if (flagActiveStateWasValid == false) {
delete activeStateBackup;
// activeState = NULL;
#ifdef PRINT
printf(" > delete active state\n");
#endif // PRINT
}
// Found a matching state
brokenCounter = 0;
#ifdef PRINT
printf(" > change to existing state\n");
#endif // PRINT
#ifdef STOP_WHEN_CHANGING_IN_OLD_STATE
getchar();
#endif // STOP_WHEN_CHANGING_IN_OLD_STATE
// update state
// insert in activeState
if (activeState->insertValueInState(
FuncBlockConfValStateDev, FuncBlockConfInvStateDev,
FuncBlockConfValStateTime, FuncBlockConfInvStateTime,
maxStateHistoryLength, discreteAveragePartitionSize))
addActiveStateToStateVector();
// NEW - Adjust FuncBlockConfSim2StateTime and
// FuncBlockConfDif2StateTime
float newBoundary = (float)activeState->getLengthOfHistory();
FuncBlockConfSim2StateTime->changeFunctionBlockIncr(newBoundary);
FuncBlockConfDif2StateTime->changeFunctionBlockDecr(newBoundary);
// printf("HIER3\n");
csv_writer->write_field((int)vStates.size());
csv_writer->make_new_field();
ptrdiff_t stateNr =
find(vStates.begin(), vStates.end(), activeState) -
vStates.begin() + 1;
csv_writer->write_field((int)stateNr);
csv_writer->make_new_field();
#ifdef WRITE_MORE_INFORMATION_IN_CSV
csv_writer->write_field(activeState->getConfStateValid());
csv_writer->make_new_field();
csv_writer->write_field(activeState->getConfStateInvalid());
csv_writer->make_new_field();
csv_writer->write_field(backupConfInputVarAreSim2State);
csv_writer->make_new_field();
csv_writer->write_field(backupConfInputVarAreDif2State);
csv_writer->make_new_field();
csv_writer->write_field(backupConfOutputVarAreSim2State);
csv_writer->make_new_field();
csv_writer->write_field(backupConfOutputVarAreDif2State);
csv_writer->make_new_field();
#endif // WRITE_MORE_INFORMATION_IN_CSV
confidenceDrift = activeState->checkAllVariablesForDriftingFuzzy(
discreteAveragePartitionSize, FuncBlockDriftDeviation);
float confidenceNoDrift = 1 - confidenceDrift;
// AAAAAAAAA (New: "&& activeState->isStateValidAfterReentrance()")
if (confidenceDrift > 0.5 &&
activeState->isStateValidAfterReentrance()) {
#ifdef PRINT
printDrift();
#endif // PRINT
#ifdef STOP_WHEN_DRIFT
getchar();
#endif // STOP_WHEN_DRIFT
// print drift
csv_writer->write_field(STATUS_DRIFT);
csv_writer->make_new_field();
// calc and print conf
//AAAAAAAAAAAAAAAA
float conf = fuzzyAND(
fuzzyAND(backupConfInputVarAreSim2State,
backupConfOutputVarAreSim2State),
fuzzyAND(confidenceDrift, activeState->getConfStateValid()));
csv_writer->write_field(conf);
// printf("drift bei (flagFoundMatchingState): %i\n", cycle);
} else {
#ifdef PRINT
printOK();
#endif // PRINT
// print ok
csv_writer->write_field(STATUS_OKAY);
csv_writer->make_new_field();
// calc and print conf
//AAAAA1
//NOTE: next equation is without confOK because confOK = 1 anyway (because broken timer = 0)
float conf =
fuzzyAND(fuzzyOR(fuzzyAND(backupConfInputVarAreSim2State,
backupConfOutputVarAreSim2State),
fuzzyAND(backupConfInputVarAreDif2State,
backupConfOutputVarAreDif2State)),
fuzzyAND(activeState->getConfStateValid(),
confidenceNoDrift));
csv_writer->write_field(conf);
}
// csv_writer->make_new_field();
}
// ONLY In- OR Outputs match one state
else if (flagFoundHalfMatchingState == true) {
// active state is half matching
if (flagHalfMatchingStateIsActiveState == true) {
activeState = activeStateBackup;
brokenCounter++;
backupConfInputVarAreSim2State =
backupConfInputVarAreSim2ActiveState;
backupConfInputVarAreDif2State =
backupConfInputVarAreDif2ActiveState;
backupConfOutputVarAreSim2State =
backupConfOutputVarAreSim2ActiveState;
backupConfOutputVarAreDif2State =
backupConfOutputVarAreDif2ActiveState;
}
// only other state(s) is half matching
else if (flagHalfMatchingStateIsAnotherState == true) {
// printf("IS ER HIER?\n");
activeState->resetNumOfInsertedSamples();
if (flagActiveStateWasValid == false) {
delete activeStateBackup;
// activeState = NULL;
#ifdef PRINT
printf(" > delete active state\n");
#endif // PRINT
}
} else {
printf("Error in halfmatching\n");
getchar();
}
// new revision cam
if (activeState->isStateValid() == false ||
activeState->isStateValidAfterReentrance() == false) {
brokenCounter = 0;
}
csv_writer->write_field((int)vStates.size());
csv_writer->make_new_field();
ptrdiff_t stateNr =
find(vStates.begin(), vStates.end(), activeState) -
vStates.begin() + 1;
csv_writer->write_field((int)stateNr);
csv_writer->make_new_field();
#ifdef WRITE_MORE_INFORMATION_IN_CSV
csv_writer->write_field(activeState->getConfStateValid());
csv_writer->make_new_field();
csv_writer->write_field(activeState->getConfStateInvalid());
csv_writer->make_new_field();
csv_writer->write_field(backupConfInputVarAreSim2State);
csv_writer->make_new_field();
csv_writer->write_field(backupConfInputVarAreDif2State);
csv_writer->make_new_field();
csv_writer->write_field(backupConfOutputVarAreSim2State);
csv_writer->make_new_field();
csv_writer->write_field(backupConfOutputVarAreDif2State);
csv_writer->make_new_field();
#endif // WRITE_MORE_INFORMATION_IN_CSV
// check broken counter
#ifdef PRINT
printf("brokenCounter: %u\n", brokenCounter);
#endif // PRINT
confidenceBroken =
FuncBlockConfBrokenSamples->getY((float)brokenCounter);
float confidenceOK = 1 - confidenceBroken;
if (confidenceBroken > 0.5) {
#ifdef PRINT
setColor(TXTCOLOR_LIGHTRED);
printf("BROKEN\n");
setColor(TXTCOLOR_GREY);
#endif // PRINT
#ifdef STOP_AFTER_BROKEN
brokentest = 1;
#endif // STOP_AFTER_BROKEN
#ifdef STOP_WHEN_BROKEN
getchar();
#endif // STOP_WHEN_BROKEN
// print broken
csv_writer->write_field(STATUS_BROKEN);
csv_writer->make_new_field();
// calculate and print conf
float conf = fuzzyAND(
fuzzyOR(confInputVarAreDif2ActiveState,
confOutputVarAreDif2ActiveState),
fuzzyAND(confidenceBroken, activeState->getConfStateValid()));
csv_writer->write_field(conf);
// csv_writer->make_new_field();
} else {
confidenceDrift = activeState->checkAllVariablesForDriftingFuzzy(
discreteAveragePartitionSize, FuncBlockDriftDeviation);
float confidenceNoDrift = 1 - confidenceDrift;
// AAAAAAAAA (New: "&& activeState->isStateValidAfterReentrance()")
if (confidenceDrift > 0.5 &&
activeState->isStateValidAfterReentrance()) {
#ifdef PRINT
printDrift();
#endif // PRINT
#ifdef STOP_WHEN_DRIFT
getchar();
#endif // STOP_WHEN_DRIFT
// print drift
csv_writer->write_field(STATUS_DRIFT);
csv_writer->make_new_field();
// calc and print conf
//AAAAAAAAAAAAA
float conf = fuzzyAND(
fuzzyAND(backupConfInputVarAreSim2State,
backupConfOutputVarAreSim2State),
fuzzyAND(confidenceDrift, activeState->getConfStateValid()));
csv_writer->write_field(conf);
} else {
#ifdef PRINT
printOK();
#endif // PRINT
// print ok
csv_writer->write_field(STATUS_OKAY);
csv_writer->make_new_field();
// calc and print conf
//AAAAAAAAAA
float conf =
fuzzyAND(fuzzyOR(fuzzyAND(backupConfInputVarAreSim2State,
backupConfOutputVarAreSim2State),
fuzzyAND(backupConfInputVarAreDif2State,
backupConfOutputVarAreDif2State)),
fuzzyAND(activeState->getConfStateValid(),
fuzzyAND(confidenceNoDrift, confidenceOK)));
csv_writer->write_field(conf);
}
}
// csv_writer->make_new_field();
}
// No State matches -> make new state
else {
// was active state valid? -> If not -> delete it
if (flagActiveStateWasValid == false) {
delete activeStateBackup;
// activeState = NULL;
#ifdef PRINT
printf(" > delete active state\n");
#endif // PRINT
}
brokenCounter = 0;
// create new state and update it
makeNewActiveState();
confInputVarAreSim2ActiveState = 0;
confInputVarAreDif2ActiveState = 0;
confOutputVarAreSim2ActiveState = 0;
confOutputVarAreDif2ActiveState = 0;
#ifdef PRINT
printf(" > new active state\n");
#endif // PRINT
// insert in activeState
if (activeState->insertValueInState(
FuncBlockConfValStateDev, FuncBlockConfInvStateDev,
FuncBlockConfValStateTime, FuncBlockConfInvStateTime,
maxStateHistoryLength, discreteAveragePartitionSize))
addActiveStateToStateVector();
// NEW - Adjust FuncBlockConfSim2StateTime and
// FuncBlockConfDif2StateTime
float newBoundary = (float)activeState->getLengthOfHistory();
FuncBlockConfSim2StateTime->changeFunctionBlockIncr(newBoundary);
FuncBlockConfDif2StateTime->changeFunctionBlockDecr(newBoundary);
csv_writer->write_field((int)vStates.size());
csv_writer->make_new_field();
ptrdiff_t stateNr =
find(vStates.begin(), vStates.end(), activeState) -
vStates.begin() + 1;
csv_writer->write_field((int)stateNr);
csv_writer->make_new_field();
#ifdef WRITE_MORE_INFORMATION_IN_CSV
csv_writer->write_field(activeState->getConfStateValid());
csv_writer->make_new_field();
csv_writer->write_field(activeState->getConfStateInvalid());
csv_writer->make_new_field();
csv_writer->write_field(confInputVarAreSim2ActiveState);
csv_writer->make_new_field();
csv_writer->write_field(confInputVarAreDif2ActiveState);
csv_writer->make_new_field();
csv_writer->write_field(confOutputVarAreSim2ActiveState);
csv_writer->make_new_field();
csv_writer->write_field(confOutputVarAreDif2ActiveState);
csv_writer->make_new_field();
#endif // WRITE_MORE_INFORMATION_IN_CSV
csv_writer->write_field(STATUS_OKAY); // OK
csv_writer->make_new_field();
// NOTE: Status Conf = 0 because conf valid = 0
csv_writer->write_field(0);
// csv_writer->make_new_field();
}
}
#ifdef PRINT
printf("isStateValid = %i\nValidAfterReentrance = %i\n",
activeState->isStateValid(),
activeState->isStateValidAfterReentrance());
ptrdiff_t pos = find(vStates.begin(), vStates.end(), activeState) -
vStates.begin() + 1;
printf("cycle: %u, \n STATES: %u\n ActualState: %u\n", cycle,
vStates.size(), pos);
#endif // PRINT
}
}
csv_writer->make_new_line();
if (brokentest)
getchar();
#ifdef STOP_EVERY_TIME
getchar();
#endif // STOP_EVERY_TIME
#ifdef STOP_EVERY_TIME_AFTER_SAMPLENR
if (cycle >= STOP_EVERY_TIME_AFTER_SAMPLENR)
getchar();
#endif // STOP_EVERY_TIME_AFTER_SAMPLENR
}
void StateHandler::closeCsvFile() {
if (csv_writer != NULL)
csv_writer->close_file();
}
string StateHandler::create_Output_File_Name(string cfg_parameter) {
time_t rawtime;
struct tm *timeinfo;
// char output_file_name[200];
char datetime[80];
std::string output_file_name_str;
time(&rawtime);
timeinfo = localtime(&rawtime);
strftime(datetime, sizeof(datetime), "%Y-%m-%d_%I-%M-%S", timeinfo);
#ifndef INPUT_FILE_NAME
output_file_name_str =
output_directory_name + "output" + datetime + cfg_parameter + ".csv";
#else
string out_dir = "../data/out/";
output_file_name_str =
out_dir + INPUT_FILE_NAME + datetime + cfg_parameter + ".csv";
#endif // INPUT_FILE_NAME
return output_file_name_str;
}
void StateHandler::set_CSV_Writer_parameter(string cfg_parameter) {
string cur_Output_File_Name = this->create_Output_File_Name(cfg_parameter);
csv_writer->reset_fpointer(cur_Output_File_Name);
}

File Metadata

Mime Type
text/x-diff
Expires
Sat, May 17, 5:33 PM (1 d, 17 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
141565
Default Alt Text
(42 KB)

Event Timeline