diff --git a/Version_Max_07_05_2018_CMake/src/CSV_Writer.cpp b/Version_Max_07_05_2018_CMake/src/CSV_Writer.cpp
index c9e4cd2..8b9bc3d 100755
--- a/Version_Max_07_05_2018_CMake/src/CSV_Writer.cpp
+++ b/Version_Max_07_05_2018_CMake/src/CSV_Writer.cpp
@@ -1,100 +1,102 @@
 #include "CSV_Writer.h"
 //#include <string>
 //#include <iostream>
 
 #define STRINGLENGTH 5000
 
 void CSV_Writer :: initialize_csv_writer(const char* filepath_write) {
 	if(!this->valid_fp) {
-		fpointer_write = fopen(filepath_write, "w");
+        this->fpointer_write = fopen(filepath_write, "w");
 		//fopen_s(&fpointer_write, filepath_write, "w");
 
 	}else {
 		close_file();
-		fpointer_write = fopen(filepath_write, "w");
+        this->fpointer_write = fopen(filepath_write, "w");
 	}
-	this->valid_fp = true;
+    if(this->fpointer_write != nullptr){
+       this->valid_fp = true;
+    }
 }
 
 CSV_Writer :: CSV_Writer(char* filepath_write) {
 	CSV_Writer(NO_NAME, filepath_write);
 }
 
 CSV_Writer :: CSV_Writer(char* name, char* filepath_write) {
 	this->valid_fp = false;
 	set_name(name);
 	initialize_csv_writer(filepath_write);
 }
 
 
 
 bool CSV_Writer :: write_field(int dataset) {
 	if(fpointer_write) {
 		fprintf(fpointer_write, "%i", dataset);		
 		return true;
 	}
 	return false;
 }
 
 bool CSV_Writer :: write_field(float dataset) {
 	if(fpointer_write) {
 		fprintf(fpointer_write, "%f", dataset);		
 		return true;
 	}
 	return false;
 }
 
 bool CSV_Writer :: write_field(char* dataset) {
 	if(fpointer_write) {
 		fprintf(fpointer_write, "%s", dataset);		
 		return true;
 	}
 	return false;
 }
 
 bool CSV_Writer :: make_new_field() {
 	if(fpointer_write) {
 		fprintf(fpointer_write, ",");		
 		return true;
 	}
 	return false;
 }
 
 bool CSV_Writer :: make_new_line() {
 	if(fpointer_write) {
 		fprintf(fpointer_write, "\n");	
 		return true;
 	}
 	return false;
 }
 
 
 bool CSV_Writer :: write_row_data(unsigned int num_of_datasets, float* datasets) {
 	
 	if(fpointer_write) {
 		for(unsigned int d_ix=0; d_ix<num_of_datasets; d_ix++) {
 			fprintf(fpointer_write, "%f", datasets[d_ix]);
 			if(d_ix < num_of_datasets-1)
 				fprintf(fpointer_write, ",");
 		}
 		fprintf(fpointer_write, "\n");		
 		return true;
 	}
 	return false;
 }
 
 void CSV_Writer :: reset_fpointer(std::string filepath_write) {
 	initialize_csv_writer(filepath_write.c_str());
 }
 
 void CSV_Writer :: close_file() {
 	if(fpointer_write) {
 		fclose(fpointer_write); 
 		this->valid_fp = false;
 	}
 }
 
 CSV_Writer :: ~CSV_Writer()
 {
 
 }
diff --git a/Version_Max_07_05_2018_CMake/src/StateHandler.cpp b/Version_Max_07_05_2018_CMake/src/StateHandler.cpp
index 70c93e9..3787862 100755
--- a/Version_Max_07_05_2018_CMake/src/StateHandler.cpp
+++ b/Version_Max_07_05_2018_CMake/src/StateHandler.cpp
@@ -1,1785 +1,1785 @@
 #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];
-	const std::string output_directory_name = "./output_data_csv/OMV/";
 	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;
 }
 */
diff --git a/Version_Max_07_05_2018_CMake/src/create_unit.cpp b/Version_Max_07_05_2018_CMake/src/create_unit.cpp
index 14f1f6d..e749f0e 100755
--- a/Version_Max_07_05_2018_CMake/src/create_unit.cpp
+++ b/Version_Max_07_05_2018_CMake/src/create_unit.cpp
@@ -1,400 +1,399 @@
 #include "create_unit.h"
 #include <stdio.h>
 #include "errno.h"
 #include "rlutil.h"
 
 using namespace rlutil;
 
 void print_agent(Agent agent) {
 	
 }
 
 Agent* create_agent() {
 	return create_agent(NO_NAME);
 }
 
 Agent* create_agent(char* name) {
 	Agent* agent = new Agent(name);
 	
 	printf(" > Agent ");
 	setColor(TXTCOLOR_LIGHTCYAN);
 	printf("%s ", agent->get_name());
 	setColor(TXTCOLOR_GREY);
 	printf("(id: %03u) ", agent->get_id());
 	setColor(TXTCOLOR_LIGHTGREEN);
 	printf("created\n");
 	setColor(TXTCOLOR_GREY);
 
 	return agent;
 }
 
 
 Sensor* create_sensor() {
 	return create_sensor(NO_NAME);
 }
 
 Sensor* create_sensor(char* name) {
 	Sensor* sensor = new Sensor(name);
 
 	printf(" > Sensor ");
 	setColor(TXTCOLOR_LIGHTCYAN);
 	printf("%s ", sensor->get_name());
 	setColor(TXTCOLOR_GREY);
 	printf("(id: %03u) ", sensor->get_id());
 	setColor(TXTCOLOR_LIGHTGREEN);
 	printf("created\n");
 	setColor(TXTCOLOR_GREY);
 
 	return sensor;
 }
 
 
 HistoryModule create_historyModule(unsigned int history_length, int delimitation_mode) {
 	return create_historyModule(NO_NAME, history_length, delimitation_mode);
 }
 
 HistoryModule create_historyModule(char* name, unsigned int history_length, int delimitation_mode) {
 	
 	HistoryModule historyModule(name);
 
 	printf(" > History ");
 	setColor(TXTCOLOR_LIGHTCYAN);
 	printf("%s ", historyModule.get_name());
 	setColor(TXTCOLOR_GREY);
 	printf("(id: %03u) ", historyModule.get_id());
 	setColor(TXTCOLOR_LIGHTGREEN);
 	printf("created\n");
 	setColor(TXTCOLOR_GREY);
 	if(historyModule.set_maxHistoryLength(history_length)) {
 		printf("   > History length ");
 		setColor(TXTCOLOR_LIGHTGREEN);
 		printf("set ");
 		setColor(TXTCOLOR_GREY);
 		printf("to %u\n", history_length);
 	}
 	else {
 		setColor(TXTCOLOR_LIGHTRED);
 		printf("   > historyLength could not set (out of allowed range).");
 		setColor(TXTCOLOR_GREY);
 	}
 	if(historyModule.set_delimitationMode(delimitation_mode)) {
 		printf("   > Delimitation Mode ");
 		setColor(TXTCOLOR_LIGHTGREEN);
 		printf("set ");
 		setColor(TXTCOLOR_GREY);
 		printf("to %u\n", delimitation_mode);
 	}
 	else {
 		setColor(TXTCOLOR_LIGHTRED);
 		printf("   > Delimitation Mode could not set (out of allowed range).");
 		setColor(TXTCOLOR_GREY);
 	}
 
 	return historyModule;
 }
 
 Channel* create_channel(unsigned int transfer_rate) {
 	return create_channel(NO_NAME, transfer_rate);
 }
 
 Channel* create_channel(char* name, unsigned int transfer_rate) {
 
 	Channel* channel = new Channel(name);
 
 	printf(" > Channel ");
 	setColor(TXTCOLOR_LIGHTCYAN);
 	printf("%s ", channel->get_name());
 	setColor(TXTCOLOR_GREY);
 	printf("(id: %03u) ", channel->get_id());
 	setColor(TXTCOLOR_LIGHTGREEN);
 	printf("created\n");
 	setColor(TXTCOLOR_GREY);
 
 	if(channel->set_transferRate(transfer_rate)) {
 		if(transfer_rate != 0) {
 			printf("   > transfer rate ");
 			setColor(TXTCOLOR_LIGHTGREEN);
 			printf("set ");
 			setColor(TXTCOLOR_GREY);
 			printf("to %i\n", transfer_rate);
 		}
 		else {
 			printf("   > transfer ");
 			setColor(TXTCOLOR_LIGHTGREEN);
 			printf("set ");
 			setColor(TXTCOLOR_GREY);
 			printf("to immediately transportation\n");
 		}
 	}
 	else {
 		setColor(TXTCOLOR_LIGHTRED);
 		printf("   > Transfer Rate out of allowed bounds!\n");
 		setColor(TXTCOLOR_GREY);
 	}
 
 	return channel;
 }
 
 
 
 
 Testbench* create_testbench() {
 	return create_testbench(NO_NAME);
 }
 
 Testbench* create_testbench(char* name) {
 	Testbench* testbench = new Testbench(name);
 	printf(" > ");
 	rlutil::setColor(TXTCOLOR_LIGHTCYAN);
 	printf("%s ", testbench->get_name());
 	rlutil::setColor(TXTCOLOR_GREY);
 	printf("(id: %03u) ", testbench->get_id());
 	rlutil::setColor(TXTCOLOR_LIGHTGREEN);
 	printf("created\n");
 	rlutil::setColor(TXTCOLOR_GREY);
 	testbench->init_testbench();
 	return testbench;
 }
 
 /*
 Lookuptable create_lookuptable() {
 	Lookuptable lut;
 
 	printf(" > ");
 	rlutil::setColor(TXTCOLOR_LIGHTCYAN);
 	printf("%s ", lut.get_name());
 	rlutil::setColor(TXTCOLOR_GREY);
 	printf("(id: %03u) ", lut.get_id());
 	rlutil::setColor(TXTCOLOR_LIGHTGREEN);
 	printf("created\n");
 	rlutil::setColor(TXTCOLOR_GREY);
 
 	return lut;
 }
 
 Lookuptable create_lookuptable(char* name) {
 	Lookuptable lut(name);
 
 	printf(" > ");
 	rlutil::setColor(TXTCOLOR_LIGHTCYAN);
 	printf("%s ", lut.get_name());
 	rlutil::setColor(TXTCOLOR_GREY);
 	printf("(id: %03u) ", lut.get_id());
 	rlutil::setColor(TXTCOLOR_LIGHTGREEN);
 	printf("created\n");
 	rlutil::setColor(TXTCOLOR_GREY);
 
 	return lut;
 }
 
 void print_confidence_validator(Confidence_Validator conf_valid) {
 	printf(" > ");
 	rlutil::setColor(TXTCOLOR_LIGHTCYAN);
 	printf("%s ", conf_valid.get_name());
 	rlutil::setColor(TXTCOLOR_GREY);
 	printf("(id: %03u) ", conf_valid.get_id());
 	rlutil::setColor(TXTCOLOR_LIGHTGREEN);
 	printf("created\n");
 	rlutil::setColor(TXTCOLOR_GREY);
 
 	printf("   - range of validity ");
 	if(conf_valid.get_flag_lower_bound_exist())
 		printf("[ %.3f, ", conf_valid.get_lower_bound());
 	else
 		printf("] -inf, ");
 	if(conf_valid.get_flag_upper_bound_exist())
 		printf("%.3f ] ", conf_valid.get_upper_bound());
 	else
 		printf("+inf [ ");
 	rlutil::setColor(TXTCOLOR_LIGHTGREEN);
 	printf("set\n");
 	rlutil::setColor(TXTCOLOR_GREY);
 
 	if(conf_valid.get_flag_rates_of_change_exist()) {
 		printf("   - validity for rates of change of ");
 		printf("%.3f ", conf_valid.get_rates_of_change());
 		rlutil::setColor(TXTCOLOR_LIGHTGREEN);
 		printf("set\n");
 		rlutil::setColor(TXTCOLOR_GREY);
 	}
 }
 
 Confidence_Validator create_confidence_validator(float lower_bound, bool flag_lower_bound_exist, float upper_bound, bool flag_upper_bound_exist, float rates_of_change, bool flag_rates_of_change_exist) {
 	Confidence_Validator conf_valid(lower_bound, flag_lower_bound_exist, upper_bound, flag_upper_bound_exist, rates_of_change, flag_rates_of_change_exist);
 	print_confidence_validator(conf_valid);
 
 	return conf_valid;
 }
 
 Confidence_Validator create_confidence_validator(char* name, float lower_bound, bool flag_lower_bound_exist, float upper_bound, bool flag_upper_bound_exist, float rates_of_change, bool flag_rates_of_change_exist) {
 	Confidence_Validator conf_valid(name, lower_bound, flag_lower_bound_exist, upper_bound, flag_upper_bound_exist, rates_of_change, flag_rates_of_change_exist);
 	print_confidence_validator(conf_valid);
 
 	return conf_valid;
 }
 
 void print_abstraction_module(Abstraction abstraction) {
 	printf(" > ");
 	rlutil::setColor(TXTCOLOR_LIGHTCYAN);
 	printf("%s ", abstraction.get_name());
 	rlutil::setColor(TXTCOLOR_GREY);
 	printf("(id: %03u) ", abstraction.get_id());
 	rlutil::setColor(TXTCOLOR_LIGHTGREEN);
 	printf("created\n");
 	rlutil::setColor(TXTCOLOR_GREY);
 
 	//TODO: abstraction method printen
 	printf("   - abstraction method %u ", abstraction.get_abstraction_method());
 	rlutil::setColor(TXTCOLOR_LIGHTGREEN);
 	printf("set\n");
 	rlutil::setColor(TXTCOLOR_GREY);
 
 	//TODO: auch das hier bissl sch�ner machen
 	if(abstraction.get_flag_lookuptable_exist(0)) {
 		printf("   - position 0 connected mit Look up Table ");
 		rlutil::setColor(TXTCOLOR_LIGHTCYAN);
 		printf("%s ", abstraction.get_lookuptable(0)->get_name());
 		rlutil::setColor(TXTCOLOR_GREY);
 		printf("(id: %03u) ", abstraction.get_lookuptable(0)->get_id());
 		rlutil::setColor(TXTCOLOR_LIGHTGREEN);
 		printf("set\n");
 		rlutil::setColor(TXTCOLOR_GREY);
 	}
 } 
 
 Abstraction create_abstraction_module(Lookuptable* lut, unsigned int abstraction_method) {
 	Abstraction abstraction(lut, abstraction_method);
 	print_abstraction_module(abstraction);
 
 	return abstraction;
 }
 
 Abstraction create_abstraction_module(char* name, Lookuptable* lut, unsigned int abstraction_method) {
 	Abstraction abstraction(name, lut, abstraction_method);
 	print_abstraction_module(abstraction);
 
 	return abstraction;
 }
 
 void print_bunch_module(Bunch_Module bunch_module) {
 	printf(" > ");
 	rlutil::setColor(TXTCOLOR_LIGHTCYAN);
 	printf("%s ", bunch_module.get_name());
 	rlutil::setColor(TXTCOLOR_GREY);
 	printf("(id: %03u) ", bunch_module.get_id());
 	rlutil::setColor(TXTCOLOR_LIGHTGREEN);
 	printf("created\n");
 	rlutil::setColor(TXTCOLOR_GREY);
 
 	//TODO: abstraction method printen
 	printf("   - abstraction method %u ", bunch_module.get_bunch_method());
 	rlutil::setColor(TXTCOLOR_LIGHTGREEN);
 	printf("set\n");
 	rlutil::setColor(TXTCOLOR_GREY);
 } 
 
 
 Bunch_Module create_bunch_module(unsigned int bunch_method) {
 	Bunch_Module bunch_module(bunch_method);
 	print_bunch_module(bunch_module);
 
 	return bunch_module;
 }
 
 Bunch_Module create_bunch_module(char* name, unsigned int bunch_method) {
 	Bunch_Module bunch_module(name, bunch_method);
 	print_bunch_module(bunch_module);
 
 	return bunch_module;
 }
 */
 
 FILE* make_file_pointer(const char* filepath, int mode) {
 	
-	FILE* fpointer;
-	bool file_opened;
+    FILE* fpointer = nullptr;
 	
 	if(mode == CSV_MODE_READ) {
 		// file_opened = fopen_s(&fpointer, filepath, "r"); //only windows compatible
-		fpointer = fopen(filepath, "r"); 
+        fpointer = fopen(filepath, "r");
 	}
 	else if(mode == CSV_MODE_WRITE) {
 		// file_opened = fopen_s(&fpointer, filepath, "w"); //only windows compatible
 		fpointer = fopen(filepath, "w"); 
 	}
 	else {
 		printf("File pointer mode for \"%s\" ", filepath);
 		rlutil::setColor(TXTCOLOR_LIGHTRED);
 		printf("is not supported!\n");
 		rlutil::setColor(TXTCOLOR_GREY);
 
 		return NULL;
 	}
 
 	//if(file_opened == 0) {
-	if(errno == 0) {
+    if(fpointer != nullptr) {
 		return fpointer;
 	}
 
 	printf("File pointer \"%s\" ", filepath);
 	rlutil::setColor(TXTCOLOR_LIGHTRED);
 	printf("could not created!\n");
 	rlutil::setColor(TXTCOLOR_GREY);
 
 	return NULL;
 }
 
 void print_csv_reader(CSVreaderModule* csvReaderModule,const char* filepath) {
 	printf(" > ");
 	rlutil::setColor(TXTCOLOR_LIGHTCYAN);
 	printf("%s ", csvReaderModule->get_name());
 	rlutil::setColor(TXTCOLOR_GREY);
 	printf("(id: %03u) for \"%s\" ", csvReaderModule->get_id(), filepath);
 	rlutil::setColor(TXTCOLOR_LIGHTGREEN);
 	printf("created\n");
 	rlutil::setColor(TXTCOLOR_GREY);
 }  
 
 CSVreaderModule* create_CSVreaderModule(const char* filepath, unsigned int column, unsigned int start_row) {
 	
 	FILE* fpointer =  make_file_pointer(filepath, CSV_MODE_READ);
 
 	if(fpointer) {
 		CSVreaderModule* csvr = new CSVreaderModule(fpointer, column, start_row);
 		print_csv_reader(csvr, filepath);
 		
 		return csvr;
 	}
 	else {
 		CSVreaderModule* csvr = new CSVreaderModule();
 
 		return csvr;
 	}
 }
 
 CSVreaderModule* create_CSVreaderModule(char* name,const char* filepath, unsigned int column, unsigned int start_row) {
 	
 	FILE* fpointer =  make_file_pointer(filepath, CSV_MODE_READ);
 
 	if(fpointer) {
 		CSVreaderModule* csvr = new CSVreaderModule(name, fpointer, column, start_row);
 		print_csv_reader(csvr, filepath);
 
 		return csvr;
 	}
 	else {
 		CSVreaderModule* csvr = new CSVreaderModule;
 
 		return csvr;
 	}
 }
 
 
 StateHandler create_stateHandler() {
 	return create_stateHandler(NO_NAME);
 }
 
 StateHandler create_stateHandler(char* name) {
 	StateHandler stateHandler(name);
 	return stateHandler;
 }
diff --git a/Version_Max_07_05_2018_CMake/src/file_util.h b/Version_Max_07_05_2018_CMake/src/file_util.h
index 04818b7..8751598 100755
--- a/Version_Max_07_05_2018_CMake/src/file_util.h
+++ b/Version_Max_07_05_2018_CMake/src/file_util.h
@@ -1,70 +1,77 @@
 /*
  * file_util.h
  *
  *  Created on: 22.05.2018
  *      Author: edwin
  *
  *      This file contains constant definitions for different file names, which are
  *      used as input files.
  */
 
 #ifndef FILE_UTIL_H_
 #define FILE_UTIL_H_
 
+#include <iostream>
+#include <string>
+
 //defines to swtich the file-configurations applied in file file_util.h
 //#define CASE_WR_NEUSTADT 1
 #define CASE_OMV 1
 
 //#define CASE_OPEL 1
 
 #ifdef CASE_WR_NEUSTADT
 //information related to the csv data files
 //definitions for measurements from Wr. Neustadt.
 const std::string PATH_TO_CSV_DATA_FILES 		= "./data_csv/Messungen_Wr_Neustadt";
 const std::string PATH_TO_DATE_OF_MEASUREMENT	= "/2018_05_23";
 const std::string PATH_TO_AN_MEASURMENT			= "/20180523_normal_SS_closed_SB_open/";
 const std::string FILE_NAME_VOLTAGE 			= "Voltage.csv";
 const std::string FILE_NAME_TEMP_1 				= "Temp1.csv";
 const std::string FILE_NAME_TEMP_2 				= "Temp2.csv";
 const std::string FILE_NAME_SHARKY_S 			= "SharkyS.csv";
 const std::string FILE_NAME_SHARKY_B 			= "SharkyB.csv";
 const std::string FILE_NAME_RIELS 				= "Riels.csv";
 const std::string FILE_NAME_DYNA 				= "Dyna.csv";
 
 #elif CASE_OMV
 //information related to the csv data files
 //definitions for measurements from Wr. Neustadt.
-const std::string PATH_TO_CSV_DATA_FILES 		= "./data_csv/OMV";
+const std::string PATH_TO_CSV_DATA_FILES 		= "../../messdaten/data_csv/OMV";
 //settings for file B960428-Jun-2018 09-15-21.csv
 //const std::string PATH_TO_DATE_OF_MEASUREMENT	= "/2017_12_18";
 //const std::string PATH_TO_AN_MEASURMENT			= "/";
 //extendend data with 30 minutes more than in file "B960425-Jun-2018 09-45-01.csv"
 //const std::string FILE_NAME_OF_ENTIRE_DATA		= "B960428-Jun-2018 09-15-21.csv";
 //const std::string FILE_NAME_OF_ENTIRE_DATA		= "B960425-Jun-2018 09-45-01.csv";
 //settings for file 2017_01_07__05_46_fc6504.csv
 const std::string PATH_TO_DATE_OF_MEASUREMENT	= "/2017_01_07";
 const std::string PATH_TO_AN_MEASURMENT			= "/";
 const std::string FILE_NAME_OF_ENTIRE_DATA		= "2017_01_07__05_46_fc6504.csv";
 
+const std::string output_directory_name = "../../messdaten/output_data_csv/OMV/";
+
+
 //definitions for motor measurements
 const std::string FOLDERNAME_NORMAL_OPERATION	= "/Normal_operation-Tm0/";
 
 #elif CASE_OPEL
 const std::string PATH_TO_CSV_DATA_FILES 		= "./data_csv/Opel";
 const std::string PATH_TO_DATE_OF_MEASUREMENT	= "";
 //for Draft Messergeb OP90_decimalPoint.csv
 //const std::string PATH_TO_AN_MEASURMENT			= "/";
 //for "GA_daten_200_samples.csv"
 //const std::string PATH_TO_AN_MEASURMENT			= "/Ga_daten/";
 //for "Ga_all_Symmetrie_Combined_25000_to_30000.csv"
 const std::string PATH_TO_AN_MEASURMENT			= "/Ga_daten_with_Symmetrie/";
 
 //entire data set
 //const std::string FILE_NAME_OF_ENTIRE_DATA		= "Draft Messergeb OP90_decimalPoint.csv";
 //only 200 data points beginning of row 8450 and only Ga data for 200 values.
 //const std::string FILE_NAME_OF_ENTIRE_DATA			= "GA_daten_200_samples.csv";
 //for data combination o all ga data with the symmetrie column and from data point 25000 to 30000
 const std::string FILE_NAME_OF_ENTIRE_DATA = "Ga_all_Symmetrie_Combined_25000_to_30000.csv";
 #endif
 
+
 #endif /* FILE_UTIL_H_ */