StateHandler.cpp
No OneTemporary
Actions

Size

50 KB

Referenced Files

None

Subscribers

None

StateHandler.cpp
View Options

	#include "StateHandler.h"

	#include <algorithm>
	#include "printError.h"
	#include "rlutil.h"

	#include "relationChecker.h"

	#include "minmaxzeug.h"
	#include "file_util.h"


	#include <iostream>
	#include <ctime>

	//CHANGE ALSO BOTH FUZZY FUNCTION!!!
	// is used for the history length of the number of values which will be compared
	//to the current value
	#define MAX_STATE_HISTORY_LENGTH 10 //10

	#define STOP_WHEN_BROKEN
	//#define STOP_AFTER_BROKEN
	//#define STOP_WHEN_DRIFT
	//#define STOP_WHEN_STATE_VALID

	//TODO: also change also hardcoded value in "SlaveAgentHandlerOfAgent.cpp"
	#define SLIDINGWINDOWSIZE 3 //3 //10
	#define STABLENUMBER 2 //2 //8
	#define STABLETHRESHOLD (float)0.04 //0.4 //0.03
	#define RELATEDTHRESHOLD (float)0.08 //0.08

	#define INJECTIONPARTITIONING 5
	#define CMPDISTANCE 3
	#define THDRIFT (float)0.08 //0.8

	#define MINNUMTOBEVALIDSTATE 11 //11 //8 //10

	//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() {

	flagVariablesWereStable = false;

	slidingWindowBufferSize = SLIDINGWINDOWSIZE;
	minNumOfRelatedValuesToBeStable = STABLENUMBER;
	thresholdToBeStable = STABLETHRESHOLD;

	thresholdToBeRelated = RELATEDTHRESHOLD;

	discreteAveragePartitionSize = INJECTIONPARTITIONING;
	compareDistanceDiscreteAveragePartition = CMPDISTANCE;
	thresholdNotDrift = THDRIFT;

	minNumToBeValidState = MINNUMTOBEVALIDSTATE;

	activeState = NULL;

	maxStateHistoryLength = MAX_STATE_HISTORY_LENGTH;


	time_t rawtime;
	struct tm * timeinfo;
	char output_file_name[200];
	char datetime[80];
	const std::string output_directory_name = "./output_data_csv/Opel/2018-08-09/";
	std::string output_file_name_str;

	time(&rawtime);
	timeinfo = localtime(&rawtime);

	strftime(datetime, sizeof(datetime), "%Y-%m-%d_%I-%M-%S", timeinfo);
	output_file_name_str = output_directory_name + "output" + datetime + ".csv";
	cout << output_file_name_str << endl;

	//XXX - only for now:
	if(csv_writer == NULL) {
	csv_writer = new CSV_Writer("CSV Writer", (char*) output_file_name_str.c_str());
	}




	//DATE18
	confidenceStableInput = 0;
	confidenceStableOutput = 0;
	confidenceStable = 0;
	confStableAdjustableThreshold = 0.5;

	confidenceUnstableInput = 0;
	confidenceUnstableOutput = 0;
	confidenceUnstable = 0;
	confidenceUnstableAdjustableThreshold = 0.5;


	confidenceSameStateInput = 0;
	confSameStateInputAdjustableThreshold = 0.5;
	confidenceSameStateOutput = 0;
	confSameStateOutputAdjustableThreshold = 0.5;

	confidenceValidState = 0;
	confValidStateAdjustableThreshold = 0.5;

	brokenCounter = 0;
	confidenceBroken = 0;
	confidenceBrokenAdjustableThreshold = 0.5;

	driftCounter = 0;
	confidenceDrift = 0;
	confidenceDriftAdjustableThreshold = 0.5;


	}

	StateHandler::StateHandler() {
	set_name(NO_NAME);
	initStateHandler();
	}

	StateHandler::StateHandler(char* name) {
	set_name(name);
	initStateHandler();
	}

	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();
	}

	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();
	}

	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();
	}

	bool StateHandler::setSlidingWindowBufferSize(unsigned int slidingWindowBufferSize) {
	if (slidingWindowBufferSize >= minNumOfRelatedValuesToBeStable) {
	this->slidingWindowBufferSize = slidingWindowBufferSize;
	return true;
	}
	return false;
	}

	bool StateHandler::setMinNumOfRelatedValuesToBeStable(unsigned int minNumOfRelatedValuesToBeStable) {
	if (minNumOfRelatedValuesToBeStable <= slidingWindowBufferSize) {
	this->minNumOfRelatedValuesToBeStable = minNumOfRelatedValuesToBeStable;
	return true;
	}
	return false;
	}

	bool StateHandler::setThresholdToBeStable(float thresholdToBeStable) {
	if (thresholdToBeStable >= 0 && thresholdToBeStable <= 1) {
	this->thresholdToBeStable = thresholdToBeStable;
	return true;
	}
	return false;
	}

	bool StateHandler::setThresholdToBeRelated(float thresholdToBeRelated) {
	if (thresholdToBeRelated >= 0 && thresholdToBeRelated <= 1) {
	this->thresholdToBeRelated = thresholdToBeRelated;
	return true;
	}
	return false;
	}




	bool StateHandler::variablesAreStable(vector<SlaveAgentSlotOfAgent> vVariables) {
	bool flagAllVariablesAreStable = true;
	for (auto &slot : *vVariables) {
	if (slot->getHistoryLength() >= slidingWindowBufferSize - 1) { //-1 because actual value is not in the history
	if (slot->getNumberOfRelativesToActualValue(thresholdToBeStable) < minNumOfRelatedValuesToBeStable) { //-1 because actual value is also on of minNumOfRelatedValuesToBeStable
	flagAllVariablesAreStable = false;
	}
	}
	else {
	return false;
	}
	}

	return flagAllVariablesAreStable;
	}

	//Sorting with bigger Value in Front
	struct descending
	{
	template<class T>
	bool operator()(T const &a, T const &b) const { return a > b; }
	};

	//DATE18
	float StateHandler::getConfVariableIsStable(SlaveAgentSlotOfAgent* variable) {
	float bestConfOf1Var = 0;
	float sample;
	if (variable->get_slaveAgentValue(&sample)) {

	list<float> lHistoryTemporary = variable->getHistory();
	vector<float> vDeviations;

	for (auto &h : lHistoryTemporary)
	vDeviations.push_back(deviationValueReferenceValue(sample, h));

	std::sort(std::begin(vDeviations), std::end(vDeviations));

	//all adaptabilities within the history of one variable
	for (unsigned int numOfHistSamplesIncluded = 1; numOfHistSamplesIncluded <= vDeviations.size(); numOfHistSamplesIncluded++) {

	float worstConfOfHistSampleSet = 1;
	unsigned int histSampleCounter = 0;

	for (auto &deviation : vDeviations) {
	if (histSampleCounter >= numOfHistSamplesIncluded)
	break;

	worstConfOfHistSampleSet = minValueOf2Values(worstConfOfHistSampleSet, StabDeviation->getY(deviation));

	histSampleCounter++;
	}

	bestConfOf1Var = maxValueOf2Values(bestConfOf1Var, minValueOf2Values(worstConfOfHistSampleSet, StabSamples->getY((float)histSampleCounter)));
	}
	}

	return bestConfOf1Var;
	}

	//DATE18
	float StateHandler::getConfVariablesAreStable(vector<SlaveAgentSlotOfAgent> vVariables) {
	float worstConfOfAllVariables = 1;

	for (auto &slot : *vVariables)
	worstConfOfAllVariables = minValueOf2Values(worstConfOfAllVariables, getConfVariableIsStable(slot));

	return worstConfOfAllVariables;
	}

	//DATE18
	float StateHandler::getConfVariableIsUnstable(SlaveAgentSlotOfAgent* variable) {
	float bestConfOf1Var = 0;
	float sample;
	if (variable->get_slaveAgentValue(&sample)) {

	list<float> lHistoryTemporary = variable->getHistory();
	vector<float> vDeviations;

	for (auto &h : lHistoryTemporary)
	vDeviations.push_back(deviationValueReferenceValue(sample, h));

	sort(begin(vDeviations), end(vDeviations), descending());

	//all adaptabilities within the history of one variable
	for (unsigned int numOfHistSamplesIncluded = 1; numOfHistSamplesIncluded <= vDeviations.size(); numOfHistSamplesIncluded++) {

	//float bestConfOfHistSampleSet = 1;
	float bestConfOfHistSampleSet = 0;
	unsigned int histSampleCounter = 0;

	for (auto &deviation : vDeviations) {
	if (histSampleCounter >= numOfHistSamplesIncluded)
	break;

	//bestConfOfHistSampleSet = minValueOf2Values(bestConfOfHistSampleSet, UnstabDeviation->getY(deviation));
	bestConfOfHistSampleSet = maxValueOf2Values(bestConfOfHistSampleSet, UnstabDeviation->getY(deviation));

	histSampleCounter++;
	}

	bestConfOf1Var = maxValueOf2Values(bestConfOf1Var, minValueOf2Values(bestConfOfHistSampleSet, StabSamples->getY((float)histSampleCounter)));
	}
	}

	return bestConfOf1Var;
	}

	//DATE18 - Is there one unstable variable?
	float StateHandler::getConfVariablesAreUnstable(vector<SlaveAgentSlotOfAgent> vVariables) {
	float bestConfOfAllVariables = 0;

	for (auto &slot : *vVariables)
	bestConfOfAllVariables = maxValueOf2Values(bestConfOfAllVariables, getConfVariableIsUnstable(slot));

	return bestConfOfAllVariables;
	}




	bool StateHandler::getConfAndUnconfVariableIsMatching(State* state, LinearFunctionBlock* confDeviation, LinearFunctionBlock* confTime, float* conf, float* unconf) {
	float bestUnconfOf1Var = 0;
	float worstConfOf1Var = 1;

	if (state != NULL) {


	}

	/*
	float sample;
	if (variable->get_slaveAgentValue(&sample)) {

	list<float> lHistoryTemporary = variable->getHistory();
	vector<float> vDeviations;

	for (auto &h : lHistoryTemporary)
	vDeviations.push_back(deviationValueReferenceValue(sample, h));

	sort(begin(vDeviations), end(vDeviations), descending());

	//all adaptabilities within the history of one variable
	for (unsigned int numOfHistSamplesIncluded = 1; numOfHistSamplesIncluded <= vDeviations.size(); numOfHistSamplesIncluded++) {

	//float bestConfOfHistSampleSet = 1;
	float bestConfOfHistSampleSet = 0;
	unsigned int histSampleCounter = 0;

	for (auto &deviation : vDeviations) {
	if (histSampleCounter >= numOfHistSamplesIncluded)
	break;

	//bestConfOfHistSampleSet = minValueOf2Values(bestConfOfHistSampleSet, UnstabDeviation->getY(deviation));
	bestConfOfHistSampleSet = maxValueOf2Values(bestConfOfHistSampleSet, UnstabDeviation->getY(deviation));

	histSampleCounter++;
	}

	bestConfOf1Var = maxValueOf2Values(bestConfOf1Var, minValueOf2Values(bestConfOfHistSampleSet, StabSamples->getY((float)histSampleCounter)));
	}
	}

	return bestConfOf1Var;
	*/

	return 0;
	}

	/*
	bool StateHandler::getConfAndUnconfVariablesAreMatching(vector<SlaveAgentSlotOfAgent> vVariables, LinearFunctionBlock* confDeviation, LinearFunctionBlock* confTime, float* conf, float* unconf) {

	float bestUnconfOfAllVariables = 0;
	float worstConfOfAllVariables = 1;

	for (auto &variable :* vVariables) {
	bestUnconfOfAllVariables = maxValueOf2Values(bestUnconfOfAllVariables, getConfAndUnconfVariableIsMatching(variable, confDeviation, confTime, conf, unconf));
	worstConfOfAllVariables = minValueOf2Values(worstConfOfAllVariables, getConfAndUnconfVariableIsMatching(variable, confDeviation, confTime, conf, unconf));
	}

	*conf = worstConfOfAllVariables;
	*unconf = bestUnconfOfAllVariables;

	return true;
	}
	*/





	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() {

	printf(" >> Save Active State\n");

	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::addStateAndMakeItActive() {
	State* state = addState();
	if (state != NULL) {
	activeState = state;
	return true;
	}
	return false;
	}
	*/

	bool StateHandler::makeNewActiveState() {
	State* state = makeNewState();
	if (state != NULL) {
	activeState = state;
	return true;
	}
	return false;
	}


	State* StateHandler::findRelatedState() {
	for (auto &state : vStates) {
	if (state->inputVariablesAreRelated(thresholdToBeRelated) && state->outputVariablesAreRelated(thresholdToBeRelated)) {
	return state;
	}
	}
	return NULL;
	}

	bool StateHandler::findRelatedStateAndMakeItActive() {
	State* state = findRelatedState();
	if (state != NULL) {
	activeState = state;
	return true;
	}
	return false;
	}

	void StateHandler::eraseStatesWithLessInjections() {
	if (activeState != NULL) {
	if (activeState->getNumOfInjections() < minNumToBeValidState) {
	activeState = NULL;
	}
	}

	for (vector<State*>::iterator state = vStates.begin(); state < vStates.end(); state++) {
	if ((*state)->getNumOfInjections() < minNumToBeValidState) {
	//TODO: also delete all subStates (etc.) of the State? Because: Memory Leakage.
	vStates.erase(state);
	state--;
	}
	}








	/*
	for (auto &state : vStates) {
	//TODO: also delete all subStates (etc.) of the State? Because: Memory Leakage.
	if (state->getNumOfInjections() < minNumToBeValidState) {
	vStates.erase(state);
	}
	}
	*/

	}

	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();
	}


	StateHandler :: ~StateHandler()
	{
	delete_all_OuputVariables();
	delete_all_InputVariables();
	delete_allStates();

	//delete csv_writer;
	}


	//XXX - only for now
	bool test = true;
	unsigned int brokenCounter = 0, driftCounter = 0;

	void printDrift() {
	driftCounter++;
	setColor(TXTCOLOR_YELLOW);
	printf(" >> DRIFT\n");
	setColor(TXTCOLOR_GREY);
	test = true;
	}

	void printBroken() {
	brokenCounter++;
	setColor(TXTCOLOR_LIGHTRED);
	printf(" >> BROKEN\n");
	setColor(TXTCOLOR_GREY);
	test = true;
	}

	//XXX - only for now
	unsigned int old_cycle = 1;

	int brokentest = 0;

	/*
	* makes a new state and reports if there is a anomaly = hearth piece of CAM :-)
	*/
	void StateHandler::trigger(unsigned int cycle) {
	printf("cycle: %u\n", cycle);


	bool flagGotValues = true;
	printf("Input Sample Values:\n");
	for (auto &slot : vInputVariables) {
	float sampleValue;
	if (!(slot->get_slaveAgentValue(&sampleValue)))
	flagGotValues = false; //program never executes this line of code
	printf("In, %s: %f\n", slot->get_comPort()->get_name(), sampleValue);

	if (cycle == 1)
	csv_writer->write_field(slot->get_comPort()->get_name());
	else
	csv_writer->write_field(sampleValue);
	csv_writer->make_new_field();
	}
	printf("Output Sample Values:\n");
	for (auto &slot : vOutputVariables) {
	float sampleValue;
	if (!(slot->get_slaveAgentValue(&sampleValue)))
	flagGotValues = false; //program never executes this line of code
	printf("Out, %s: %f\n", slot->get_comPort()->get_name(), sampleValue);

	if (cycle == 1)
	csv_writer->write_field(slot->get_comPort()->get_name());
	else
	csv_writer->write_field(sampleValue);
	csv_writer->make_new_field();
	}

	if (cycle == 1){
	csv_writer->write_field("State Nr");
	csv_writer->make_new_field();

	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();

	csv_writer->write_field("Status");
	csv_writer->make_new_field();

	csv_writer->write_field("Conf Status");
	csv_writer->make_new_field();
	}
	else {
	//in the beginning, a active state has to be created
	if (activeState == NULL && vStates.empty()) {
	brokenCounter = 0;

	printf(" > new active state\n");
	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() + 1);
	csv_writer->make_new_field();

	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();


	csv_writer->write_field(STATUS_OKAY);
	csv_writer->make_new_field();

	csv_writer->write_field(0); //Status Conf
	csv_writer->make_new_field();


	}
	//there is an active state and/or other states
	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);

	float confInputIsSteady = confInputVarAreSim2ActiveState - confInputVarAreDif2ActiveState;
	float confOutputIsSteady = confOutputVarAreSim2ActiveState - confOutputVarAreDif2ActiveState;

	printf("input (sim/dif) %f/%f\noutput (sim/dif) %f/%f\n", confInputVarAreSim2ActiveState, confInputVarAreDif2ActiveState, confOutputVarAreSim2ActiveState, confOutputVarAreDif2ActiveState);


	//same state
	if ((confInputVarAreSim2ActiveState > confInputVarAreDif2ActiveState) && (confOutputVarAreSim2ActiveState > confOutputVarAreDif2ActiveState)) {
	brokenCounter = 0;

	printf(" > same state\n");
	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);

	//print state number
	if(activeState->isStateValid())
	csv_writer->write_field((int)vStates.size());
	else
	csv_writer->write_field((int)vStates.size()+1);
	csv_writer->make_new_field();

	//print conf valid
	csv_writer->write_field(activeState->getConfStateValid());
	csv_writer->make_new_field();
	csv_writer->write_field(activeState->getConfStateInvalid());
	csv_writer->make_new_field();

	//print 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();


	confidenceDrift = activeState->checkAllVariablesForDriftingFuzzy(discreteAveragePartitionSize, DriftDeviation);
	float confidenceNoDrift = 1 - confidenceDrift;

	/*
	//print conf drift
	csv_writer->write_field(confidenceNoDrift);
	csv_writer->make_new_field();
	csv_writer->write_field(confidenceDrift);
	csv_writer->make_new_field();
	*/

	if (confidenceDrift > 0.5) {
	setColor(TXTCOLOR_YELLOW);
	printf("DRIFT\n");
	#ifdef STOP_WHEN_DRIFT
	getchar();
	#endif // STOP_WHEN_DRIFT
	setColor(TXTCOLOR_GREY);

	//print drift
	csv_writer->write_field(STATUS_DRIFT);
	csv_writer->make_new_field();

	//calc and print conf
	float conf = fuzzyAND(fuzzyAND(confidenceDrift, activeState->getConfStateValid()), fuzzyAND(confInputVarAreSim2ActiveState, confOutputVarAreSim2ActiveState));
	csv_writer->write_field(conf);

	}
	else {
	setColor(TXTCOLOR_LIGHTGREEN);
	printf("OK\n");
	setColor(TXTCOLOR_GREY);

	//print ok
	csv_writer->write_field(STATUS_OKAY);
	csv_writer->make_new_field();

	//calc and print conf
	float conf = fuzzyAND(fuzzyAND(confInputVarAreSim2ActiveState, confOutputVarAreSim2ActiveState), fuzzyAND(activeState->getConfStateValid(), confidenceNoDrift));
	csv_writer->write_field(conf);
	}
	csv_writer->make_new_field();



	}
	//state change
	else {
	//was Valid
	if (activeState->isStateValid()) {

	//only one sub set changed
	if (((confInputVarAreSim2ActiveState > confInputVarAreDif2ActiveState) && (confOutputVarAreSim2ActiveState <= confOutputVarAreDif2ActiveState)) \|\| ((confInputVarAreSim2ActiveState <= confInputVarAreDif2ActiveState) && (confOutputVarAreSim2ActiveState > confOutputVarAreDif2ActiveState))) {


	//print state number
	if (activeState->isStateValid())
	csv_writer->write_field((int)vStates.size());
	else
	csv_writer->write_field((int)vStates.size() + 1);
	csv_writer->make_new_field();

	//print conf valid
	csv_writer->write_field(activeState->getConfStateValid());
	csv_writer->make_new_field();
	csv_writer->write_field(activeState->getConfStateInvalid());
	csv_writer->make_new_field();

	//print 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();







	brokenCounter++;
	printf("brokenCounter: %u\n", brokenCounter);

	confidenceBroken = FuncBlockConfBrokenSamples->getY((float) brokenCounter);
	float confidenceOK = 1 - confidenceBroken;

	if (confidenceBroken > 0.5) {
	setColor(TXTCOLOR_LIGHTRED);
	printf("BROKEN\n");
	setColor(TXTCOLOR_GREY);
	#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 {
	//print ok
	csv_writer->write_field(STATUS_OKAY);
	csv_writer->make_new_field();

	//calculate and print conf
	float conf = fuzzyAND(fuzzyOR(fuzzyAND(confInputVarAreSim2ActiveState, confOutputVarAreSim2ActiveState), fuzzyAND(confInputVarAreDif2ActiveState, confOutputVarAreDif2ActiveState)), fuzzyAND(confidenceOK, activeState->getConfStateValid()));
	csv_writer->write_field(conf);
	}






	}
	//In- and output changed
	else {
	brokenCounter = 0;

	printf(" > delete active state\n");
	activeState = NULL;
	printf(" > new active state\n");

	// search in vector for matching state //TODO in future: look for the best matching, Not for the first matching
	bool flagFoundMatchingState = false;
	float confInputVarAreSim2ActiveState;
	float confInputVarAreDif2ActiveState;
	float confOutputVarAreSim2ActiveState;
	float confOutputVarAreDif2ActiveState;
	for (auto &state : vStates) {
	confInputVarAreSim2ActiveState = state->getConfInputVarAreSim2State(FuncBlockConfSim2StateDev, FuncBlockConfSim2StateTime);
	confInputVarAreDif2ActiveState = state->getConfInputVarAreDif2State(FuncBlockConfDif2StateDev, FuncBlockConfDif2StateTime);
	confOutputVarAreSim2ActiveState = state->getConfOutputVarAreSim2State(FuncBlockConfSim2StateDev, FuncBlockConfSim2StateTime);
	confOutputVarAreDif2ActiveState = state->getConfOutputVarAreDif2State(FuncBlockConfDif2StateDev, FuncBlockConfDif2StateTime);

	if ((confInputVarAreSim2ActiveState > confInputVarAreDif2ActiveState) && (confOutputVarAreSim2ActiveState > confOutputVarAreDif2ActiveState)) {
	activeState = state;
	flagFoundMatchingState = true;
	}
	}

	if (flagFoundMatchingState == false) {
	makeNewActiveState();
	confInputVarAreSim2ActiveState = 0;
	confInputVarAreDif2ActiveState = 0;
	confOutputVarAreSim2ActiveState = 0;
	confOutputVarAreDif2ActiveState = 0;
	}

	//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);


	//print state number
	if (activeState->isStateValid())
	csv_writer->write_field((int)vStates.size());
	else
	csv_writer->write_field((int)vStates.size() + 1);
	csv_writer->make_new_field();

	//print conf valid
	csv_writer->write_field(activeState->getConfStateValid());
	csv_writer->make_new_field();
	csv_writer->write_field(activeState->getConfStateInvalid());
	csv_writer->make_new_field();

	//print 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();




	confidenceDrift = activeState->checkAllVariablesForDriftingFuzzy(discreteAveragePartitionSize, DriftDeviation);
	float confidenceNoDrift = 1 - confidenceDrift;

	if (confidenceDrift > 0.5) {
	setColor(TXTCOLOR_YELLOW);
	printf("DRIFT\n");
	#ifdef STOP_WHEN_DRIFT
	getchar();
	#endif // STOP_WHEN_DRIFT
	setColor(TXTCOLOR_GREY);

	//print drift
	csv_writer->write_field(STATUS_DRIFT);
	csv_writer->make_new_field();

	//calc and print conf
	float conf = fuzzyAND(confidenceDrift, activeState->getConfStateValid());
	csv_writer->write_field(conf);

	}
	else {
	setColor(TXTCOLOR_LIGHTGREEN);
	printf("OK\n");
	setColor(TXTCOLOR_GREY);

	//print ok
	csv_writer->write_field(STATUS_OKAY);
	csv_writer->make_new_field();

	//calc and print conf
	float conf = fuzzyAND(fuzzyAND(confInputVarAreDif2ActiveState, confOutputVarAreDif2ActiveState), fuzzyAND(activeState->getConfStateValid(), confidenceNoDrift));
	csv_writer->write_field(conf);
	}
	csv_writer->make_new_field();
	}


	}
	//was NOT Valid
	else {

	brokenCounter = 0;

	printf(" > delete active state\n");
	delete activeState;
	activeState = NULL;
	printf(" > new active state\n");


	// search in vector for matching state //TODO in future: look for the best matching, Not for the first matching
	bool flagFoundMatchingState = false;
	float confInputVarAreSim2ActiveState;
	float confInputVarAreDif2ActiveState;
	float confOutputVarAreSim2ActiveState;
	float confOutputVarAreDif2ActiveState;
	for (auto &state : vStates) {
	confInputVarAreSim2ActiveState = state->getConfInputVarAreSim2State(FuncBlockConfSim2StateDev, FuncBlockConfSim2StateTime);
	confInputVarAreDif2ActiveState = state->getConfInputVarAreDif2State(FuncBlockConfDif2StateDev, FuncBlockConfDif2StateTime);
	confOutputVarAreSim2ActiveState = state->getConfOutputVarAreSim2State(FuncBlockConfSim2StateDev, FuncBlockConfSim2StateTime);
	confOutputVarAreDif2ActiveState = state->getConfOutputVarAreDif2State(FuncBlockConfDif2StateDev, FuncBlockConfDif2StateTime);

	if ((confInputVarAreSim2ActiveState > confInputVarAreDif2ActiveState) && (confOutputVarAreSim2ActiveState > confOutputVarAreDif2ActiveState)) {
	activeState = state;
	flagFoundMatchingState = true;
	}
	}

	if (flagFoundMatchingState == false) {
	makeNewActiveState();
	confInputVarAreSim2ActiveState = 0;
	confInputVarAreDif2ActiveState = 0;
	confOutputVarAreSim2ActiveState = 0;
	confOutputVarAreDif2ActiveState = 0;
	}

	//insert in active state
	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);


	//print state number
	if (activeState->isStateValid())
	csv_writer->write_field((int)vStates.size());
	else
	csv_writer->write_field((int)vStates.size() + 1);
	csv_writer->make_new_field();

	//print conf valid
	csv_writer->write_field(activeState->getConfStateValid());
	csv_writer->make_new_field();
	csv_writer->write_field(activeState->getConfStateInvalid());
	csv_writer->make_new_field();

	//print 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();




	confidenceDrift = activeState->checkAllVariablesForDriftingFuzzy(discreteAveragePartitionSize, DriftDeviation);
	float confidenceNoDrift = 1 - confidenceDrift;

	if (confidenceDrift > 0.5) {
	setColor(TXTCOLOR_YELLOW);
	printf("DRIFT\n");
	#ifdef STOP_WHEN_DRIFT
	getchar();
	#endif // STOP_WHEN_DRIFT
	setColor(TXTCOLOR_GREY);

	//print drift
	csv_writer->write_field(2);
	csv_writer->make_new_field();

	//calc and print conf
	float conf = fuzzyAND(confidenceDrift, activeState->getConfStateValid());
	csv_writer->write_field(conf);

	}
	else {
	setColor(TXTCOLOR_LIGHTGREEN);
	printf("OK\n");
	setColor(TXTCOLOR_GREY);

	//print ok
	csv_writer->write_field(STATUS_OKAY);
	csv_writer->make_new_field();

	//calc and print conf
	float conf = fuzzyAND(fuzzyAND(confInputVarAreDif2ActiveState, confOutputVarAreDif2ActiveState), fuzzyAND(activeState->getConfStateValid(), confidenceNoDrift));
	csv_writer->write_field(conf);
	}
	csv_writer->make_new_field();



	}

	}

	printf("STATES: %u\n", vStates.size());
	}
	}

	csv_writer->make_new_line();

	if (brokentest)
	getchar();




















	/*
	//XXX - only for now
	for (unsigned int i = 1; i < (cycle - old_cycle); i++) {
	csv_writer->make_new_field();
	csv_writer->make_new_field();
	csv_writer->make_new_field();
	csv_writer->make_new_line();
	//printf("%u\n", i);
	}
	old_cycle = cycle;

	confidenceStableInput = getConfVariablesAreStable(&vInputVariables);
	confidenceStableOutput = getConfVariablesAreStable(&vOutputVariables);
	confidenceStable = minValueOf2Values(confidenceStableInput, confidenceStableOutput);
	printf("confidence stable: %f\n", confidenceStable);


	confidenceUnstableInput = getConfVariablesAreUnstable(&vInputVariables);
	confidenceUnstableOutput = getConfVariablesAreUnstable(&vOutputVariables);
	printf("unstable In: %f, Out: %f\n", confidenceUnstableInput, confidenceUnstableOutput);
	confidenceUnstable = maxValueOf2Values(confidenceUnstableInput, confidenceUnstableOutput);
	printf("confidence unstable: %f\n", confidenceUnstable);

	if (confidenceUnstableInput > 0) {
	printf("jetzt\n");
	getchar();
	}


	//TEST
	if (confidenceStable > confidenceUnstable) {
	setColor(TXTCOLOR_LIGHTBLUE);
	printf("jetzt\n");
	setColor(TXTCOLOR_GREY);

	getchar();
	}

	//getchar();


	if (confidenceStable > confidenceUnstable) {
	//if (false) {
	printf(" > stable\n");

	//for the beginning (there is no state available/created) -> create state
	if (activeState == NULL && vStates.empty()) {
	printf(" > new state\n");
	makeNewActiveState();
	activeState->injectValues(discreteAveragePartitionSize);
	confidenceValidState = ValidState->getY((float)activeState->getNumOfInjections());
	}
	//there is an active state
	else if (activeState != NULL) {

	//caclulate confidences of deciding for same state
	float confidenceSameStateInput = activeState->inputVariablesAreRelatedFuzzy(SameState);
	float confidenceSameStateOutput = activeState->outputVariablesAreRelatedFuzzy(SameState);
	printf("ConfSameState\nIn: %f\nout: %f\n", confidenceSameStateInput, confidenceSameStateOutput);


	//In- and Outputs are unchanged
	if ((confidenceSameStateInput > confSameStateInputAdjustableThreshold) && (confidenceSameStateOutput > confSameStateOutputAdjustableThreshold)) {

	printf(" > same state\n");

	//inject values
	activeState->injectValues(discreteAveragePartitionSize);
	//calculate the confidence to have a validState
	confidenceValidState = ValidState->getY((float)activeState->getNumOfInjections());

	//TODO DATE
	//check for drifting!!!
	//printDrift();


	}
	//In- and Outputs have changed
	else if ((confidenceSameStateInput <= confSameStateInputAdjustableThreshold) && (confidenceSameStateOutput <= confSameStateOutputAdjustableThreshold)) {

	printf(" > change state\n");
	getchar();
	//active state is/was valid
	if (confidenceValidState > confValidStateAdjustableThreshold) {

	printf("speicher\n");
	getchar();


	addActiveStateToStateVector();

	//TODO DATE
	//search for matching state
	//or
	printf(" > new state\n");
	//create an new active state
	makeNewActiveState();

	//inject values
	activeState->injectValues(discreteAveragePartitionSize);
	//calculate the confidence to have a validState
	confidenceValidState = ValidState->getY((float)activeState->getNumOfInjections());

	//TODO DATE
	//check for drifting!!!
	//printDrift();

	}
	}
	//Only in- or outputs have changed
	else {
	//active state is/was valid
	if (confidenceValidState > confValidStateAdjustableThreshold) {

	addActiveStateToStateVector();

	printf(" > broken\n");
	brokenCounter++;
	confidenceBroken = BrokenCounterSamples->getY(brokenCounter);

	//getchar();

	//TODO DATE??
	//Save State
	}
	}
	}
	//there is no active state, but there is/are state(s)
	else {

	printf(" > old or new state\n");

	//getchar();
	//TODO DATE
	//search for matching state
	//or
	printf(" > new state\n");
	makeNewActiveState();
	activeState->injectValues(discreteAveragePartitionSize);
	confidenceValidState = ValidState->getY((float)activeState->getNumOfInjections());

	//TODO DATE
	//check for drifting!!!
	//printDrift();
	}


	if (activeState != NULL) {
	confidenceDrift = activeState->checkAllVariablesForDriftingFuzzy(discreteAveragePartitionSize, DriftDeviation);
	}

	//getchar();
	}
	//unstable
	else {

	printf(" > unstable\n");

	//there is/was an active state
	if (activeState != NULL) {
	//delete activeState;

	if (confidenceValidState > confValidStateAdjustableThreshold)
	addActiveStateToStateVector();

	activeState = NULL;
	}
	}

	//DATE TODO
	//STABLE CONFIDENCE MITEINBEZIEHEN
	if ((confidenceBroken >= confidenceBroken) && (confidenceBroken > confidenceBrokenAdjustableThreshold)) {
	setColor(TXTCOLOR_LIGHTRED);
	printf(" >> BROKEN - confidence %f\n", confidenceBroken);
	setColor(TXTCOLOR_GREY);

	getchar();
	}
	else if (confidenceDrift > confidenceDriftAdjustableThreshold) {
	setColor(TXTCOLOR_YELLOW);
	printf(" >> DRIFT - confidence %f\n", confidenceDrift);
	setColor(TXTCOLOR_GREY);

	//XXXXXXXXXX ????????????????????????????????????
	if (brokenCounter > 0)
	brokenCounter--;

	getchar();
	}
	else {
	setColor(TXTCOLOR_LIGHTGREEN);

	float confidenceOK;
	if (confidenceDrift > confidenceBroken)
	confidenceOK = 1 - confidenceDrift;
	else
	confidenceOK = 1 - confidenceBroken;

	printf(" >> SYSTEM OK - confidence %f\n", confidenceOK);
	setColor(TXTCOLOR_GREY);
	}



	printf("brokenCounter %u\n", brokenCounter);
	printf("number of states: %i\n", vStates.size());
	*/








	/*
	if (variablesAreStable(&vInputVariables) && variablesAreStable(&vOutputVariables)) {
	printf(" > stable\n");

	//XXX - only for now
	csv_writer->write_field(2); //stable
	csv_writer->make_new_field();

	//getchar();

	if (activeState == NULL && vStates.empty()) {
	makeNewActiveState();
	activeState->injectValues(discreteAveragePartitionSize);

	//XXX - only for now
	csv_writer->write_field(1); //new active state
	csv_writer->make_new_field();
	csv_writer->make_new_field();
	}
	else {
	if (activeState != NULL) {

	printf("\nbeginning here:\n");

	bool flagInputUnchanged = activeState->inputVariablesAreRelated(thresholdToBeRelated);
	bool flagOutputUnchanged = activeState->outputVariablesAreRelated(thresholdToBeRelated);

	//input and/or output unchanged?
	if (flagInputUnchanged && flagOutputUnchanged) {
	activeState->injectValues(discreteAveragePartitionSize);
	if (!activeState->checkAllVariablesForNotDrifting(discreteAveragePartitionSize, compareDistanceDiscreteAveragePartition, thresholdNotDrift)) {
	printDrift();

	//XXX - only for now
	csv_writer->make_new_field();
	csv_writer->write_field(1); //drift
	csv_writer->make_new_field();
	}
	//XXX - only for now
	else {
	csv_writer->make_new_field();
	csv_writer->make_new_field();
	}
	}
	else {
	if (activeState->getNumOfInjections() >= minNumToBeValidState) {
	if ((!flagInputUnchanged && flagOutputUnchanged) \|\| (flagInputUnchanged && !flagOutputUnchanged)) {
	printBroken();
	getchar();

	//XXX - only for now
	csv_writer->make_new_field();
	csv_writer->write_field(2); //broken
	csv_writer->make_new_field();
	}
	else {
	addActiveStateToStateVector();
	if (!findRelatedStateAndMakeItActive()) {
	makeNewActiveState();
	activeState->injectValues(discreteAveragePartitionSize);

	//XXX - only for now
	csv_writer->write_field(1); //new active state
	csv_writer->make_new_field();
	csv_writer->make_new_field();
	}
	else {
	//next line is new
	activeState->resetDiscreteAveragePartitionCounter();

	//XXX - only for now
	csv_writer->write_field(2); //change to existing state
	csv_writer->make_new_field();


	activeState->injectValues(discreteAveragePartitionSize);
	if (!activeState->checkAllVariablesForNotDrifting(discreteAveragePartitionSize, compareDistanceDiscreteAveragePartition, thresholdNotDrift)) {
	printDrift();

	//XXX - only for now
	csv_writer->write_field(1); //drift
	csv_writer->make_new_field();
	}
	//XXX - only for now
	else {
	csv_writer->make_new_field();
	}
	}
	}
	}
	else {
	delete activeState;
	if (!findRelatedStateAndMakeItActive()) {
	makeNewActiveState();
	activeState->injectValues(discreteAveragePartitionSize);

	//XXX - only for now
	csv_writer->write_field(1); //new active state
	csv_writer->make_new_field();
	csv_writer->make_new_field();
	}
	else {
	//next line is new
	activeState->resetDiscreteAveragePartitionCounter();

	//XXX - only for now
	csv_writer->write_field(2); //change to existing state
	csv_writer->make_new_field();

	activeState->injectValues(discreteAveragePartitionSize);
	if (!activeState->checkAllVariablesForNotDrifting(discreteAveragePartitionSize, compareDistanceDiscreteAveragePartition, thresholdNotDrift)) {
	printDrift();

	//XXX - only for now
	csv_writer->write_field(1); //drift
	csv_writer->make_new_field();
	}
	//XXX - only for now
	else {
	csv_writer->make_new_field();
	}
	}
	}
	}
	}
	else {
	if (!findRelatedStateAndMakeItActive()) {
	makeNewActiveState();
	activeState->injectValues(discreteAveragePartitionSize);

	//XXX - only for now
	csv_writer->write_field(1); //new active state
	csv_writer->make_new_field();
	csv_writer->make_new_field();
	}
	else {
	//next line is new
	activeState->resetDiscreteAveragePartitionCounter();

	//XXX - only for now
	csv_writer->write_field(2); //change to existing state
	csv_writer->make_new_field();

	activeState->injectValues(discreteAveragePartitionSize);
	if (!activeState->checkAllVariablesForNotDrifting(discreteAveragePartitionSize, compareDistanceDiscreteAveragePartition, thresholdNotDrift)) {
	printDrift();

	//XXX - only for now
	csv_writer->write_field(1); //drift
	csv_writer->make_new_field();
	}
	//XXX - only for now
	else {
	csv_writer->make_new_field();
	}
	}
	}
	}





	if (activeState != NULL) {
	printf(" -- an activeState exist: \n");
	printf(" --- injections: %u\n", activeState->getNumOfInjections());

	//XXX - only for now
	csv_writer->write_field((int)activeState->getNumOfInjections()); //number of injections
	csv_writer->make_new_line();
	}
	//XXX - only for now
	else {
	csv_writer->make_new_field();
	}


	printf(" -- Number of States (excl. activeState): %u\n", vStates.size());
	for (auto &s : vStates) {
	printf(" --- injections: %u\n", s->getNumOfInjections());
	}
	printf(" ... BrokenCounter: %u\n", brokenCounter);
	printf(" ... driftCounter: %u\n", driftCounter);
	printf("cycle: %u\n", cycle);


	if (test) {
	test = false;
	//getchar();
	}

	flagVariablesWereStable = true;
	}

	else {

	printf(" > unstable\n");
	//XXX - only for now
	csv_writer->write_field(1); //unstable
	csv_writer->make_new_field();
	csv_writer->make_new_field();
	csv_writer->make_new_field();
	csv_writer->make_new_line();


	if (flagVariablesWereStable)
	test = true;

	//search for states with less injections in all states
	if (flagVariablesWereStable) {
	if (activeState != NULL) {

	if (activeState->getNumOfInjections() >= minNumToBeValidState) {
	addActiveStateToStateVector();

	}
	else {
	delete activeState;
	}
	activeState = NULL;


	//getchar();

	}
	}

	flagVariablesWereStable = false;
	}



	//xxx - only for now
	//csv_writer->make_new_line();
	*/
	}


	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);
	output_file_name_str = output_directory_name + "output" + datetime + cfg_parameter + ".csv";
	//cout << output_file_name_str << endl;

	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);
	}



	/*
	void StateHandler :: initStateHandler() {
	//activeState = NULL;
	thresholdToAverage = THRESHOLDTOAVG;
	minNumOfChangedForValidStateChange = MINNUMCHANGEDFORVALIDSTATECHANGE;

	minimumInjectionsForBeingState = MININJFORBEINGSTATE;
	}

	StateHandler :: StateHandler() {
	set_name(NO_NAME);
	initStateHandler();
	}

	StateHandler :: StateHandler(char* name) {
	set_name(name);
	initStateHandler();
	}

	bool StateHandler :: setMinimumInjectionsForBeingState(unsigned int minimumInjectionsForBeingState) {
	if (minimumInjectionsForBeingState > 0) {
	this->minimumInjectionsForBeingState = minimumInjectionsForBeingState;
	return true;
	}
	return false;
	}

	unsigned int StateHandler :: getMinimumInjectionsForBeingState() {
	return minimumInjectionsForBeingState;
	}

	bool StateHandler :: add_slot(SlaveAgentSlotOfAgent* slot) {
	if(slot != NULL) {
	try {
	vSlots.push_back(slot);
	return true;
	}
	catch(bad_alloc& error) {
	printError("bad_alloc caught: ", error.what());
	delete slot;
	}
	}
	return false;
	}

	void StateHandler :: setThresholdToAverage(float thresholdToAverage) {
	this->thresholdToAverage = thresholdToAverage;
	}

	float StateHandler :: getThresholdToAverage() {
	return thresholdToAverage;
	}

	void StateHandler::set_minNumOfChangedForValidStateChange(unsigned int minNumOfChangedForValidStateChange) {
	this->minNumOfChangedForValidStateChange = minNumOfChangedForValidStateChange;
	}

	unsigned int StateHandler::get_minNumOfChangedForValidStateChange() {
	return minNumOfChangedForValidStateChange;
	}


	bool StateHandler :: trigger() {

	bool flagWorked = true;

	printf("NumOfStates: ");
	for (auto &slot : vSlots) {
	printf("%u, ", slot->getNumberOfStates());
	}
	printf("\n");


	//Check all input values if they have changed more than threshold ...and count how many changed
	unsigned int numberOfChanges = 0;
	for (auto &slot : vSlots) {
	float value;
	if (slot->get_slaveAgentValue(&value)) {

	State* activeState = slot->getActiveState();
	if (activeState != NULL) {
	printf("act - ");
	if (activeState->isNew()) {
	printf("new - ");
	//numberOfChanges++;
	}
	else if (activeState->valueIsRelated(value, thresholdToAverage)) {
	printf("rel - ");
	}
	else {
	printf("nrel - ");
	numberOfChanges++;
	}
	}

	else {
	printf("nact - ");
	}
	}
	}
	printf("\n");









	printf(" >> Number of Changes: %u\n", numberOfChanges);
	//nothing has changes more than threshold

	if (numberOfChanges == 0) {
	printf("\n\n >>> inject in active state\n");
	for (auto &slot : vSlots) {
	slot->injectValueInActiveState();
	}
	}
	else if(numberOfChanges >= minNumOfChangedForValidStateChange) {
	printf("\n\n >>> new (or another) state\n");

	for (auto &slot : vSlots) {
	State* activeState = slot->getActiveState();
	if (activeState != NULL) {
	if (activeState->getNumberOfInjections() < minimumInjectionsForBeingState) {
	slot->deleteActiveState();
	printf(" >> delete State\n");
	}
	}
	}

	//search for existing state
	bool flagRelated = false;
	if (vSlots.empty() == false) {
	int ix = vSlots.front()->getIndexOfRelatedState(0, thresholdToAverage);
	while (ix > -2) {
	if (ix >= 0) {
	//TODO: maybe another state fits a bit better.. approach -> euklidean distance?
	flagRelated = true;
	for (vector<SlaveAgentSlotOfAgent*>::iterator slot = vSlots.begin() + 1; slot < vSlots.end(); slot++) {
	if ((*slot)->valueIsRelated(ix, thresholdToAverage) == false) {
	flagRelated = false;
	}
	}
	if (flagRelated == true) {
	for (auto &slot : vSlots) {
	slot->setActiveState(ix);
	}
	break;
	}
	ix = vSlots.front()->getIndexOfRelatedState(ix+1, thresholdToAverage);
	}
	}
	}

	if (flagRelated == false) {
	printf(" >> No related state found\n");

	printf("\n\n >>> inject in active state\n");
	for (auto &slot : vSlots) {
	slot->injectValueInActiveState();
	}
	}


	}


	printf("ende\n");

	return false;
	}
	*/

File Metadata

Mime Type: text/x-c++
Expires: Thu, Jan 15, 8:06 PM (1 d, 5 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 261186
Default Alt Text: StateHandler.cpp (50 KB)

StateHandler.cppNo OneTemporaryActions

StateHandler.cppView Options

File Metadata

Event Timeline

StateHandler.cpp
No OneTemporary
Actions

StateHandler.cpp
View Options