diff --git a/Version_Max_07_05_2018_CMake/src/CMakeLists.txt b/Version_Max_07_05_2018_CMake/src/CMakeLists.txt
index cc6f9f3..2cd86e3 100755
--- a/Version_Max_07_05_2018_CMake/src/CMakeLists.txt
+++ b/Version_Max_07_05_2018_CMake/src/CMakeLists.txt
@@ -1,50 +1,50 @@
 cmake_minimum_required (VERSION 2.6 FATAL_ERROR)
 project("CAH-Project")
 
 if(	"${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" OR
 	"${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
 	set(warnings "-Wall -Wextra -Werror")
 elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
 	set(warnings "/W4 /WX /EHsc")
 endif()
 
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c11")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14")
 set(CMAKE_BUILD_TYPE Debug)
 
-add_executable(CAH main.cpp						
+add_executable(CAH main_configurable.cpp
 abstraction_functions.cpp       MasterAgentSlotOfAgent.cpp
 abstraction_interface.cpp       MaximumValue.cpp
 AbstractionModule.cpp           Message.cpp
 Agent.cpp                       minmaxzeug.cpp
 AgentSlotOfTestbench.cpp        MinumumValue.cpp
 attach_modules.cpp              Module.cpp
 attach_modulesToTestbench.cpp   mount_nodes.cpp
 AverageValue.cpp                Node.cpp
 boundary_check.cpp              printError.cpp
 Bunch_Module.cpp                Range.cpp
 Channel.cpp                     register_in_testbench.cpp
 ChannelSlotOfTestbench.cpp      relationChecker.cpp
 clock.cpp                       Sensor.cpp
 ConfidenceModule.cpp            SensorHandlerOfAgent.cpp
 Continuous_Average.cpp          SensorSlotOfAgent.cpp
 create_unit.cpp                 SensorSlotOfTestbench.cpp
 Cross_Confidence_Validator.cpp  setup_agent.cpp
 CSVreaderModule.cpp             setup_lookuptable.cpp
 CSV_Writer.cpp                  setupNode.cpp
 Discrete_Average.cpp            SlaveAgentHandlerOfAgent.cpp
 Domain.cpp                      SlaveAgentSlotOfAgent.cpp
 Evaluation.cpp                  Slot.cpp
 extremaValues.cpp               SlotOfAgent.cpp
 ExtremeValue.cpp                State.cpp
 HandlerOfAgent.cpp              StateHandler.cpp
 HistoryEntry.cpp                StateModule.cpp
 HistoryModule.cpp               StateVariable.cpp
 inAgentsRegistrations.cpp       StatisticValue.cpp
 LinearFunctionBlock.cpp         SubState.cpp
 LinearFunction.cpp              Testbench.cpp
 Lookuptable.cpp                 Unit.cpp
 user_method_abstraction.cpp		Testbench_Config.cpp
-MasterAgentHandlerOfAgent.cpp)
+MasterAgentHandlerOfAgent.cpp	config.h)
 
 
diff --git a/Version_Max_07_05_2018_CMake/src/StateHandler.cpp b/Version_Max_07_05_2018_CMake/src/StateHandler.cpp
index ee76269..61793f0 100755
--- a/Version_Max_07_05_2018_CMake/src/StateHandler.cpp
+++ b/Version_Max_07_05_2018_CMake/src/StateHandler.cpp
@@ -1,1820 +1,1832 @@
 #include "StateHandler.h"
+#include "config.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
 
 #define PRINT
 
 
 
 //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() {
 	
 	csv_writer = NULL;
 
 	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/";  there is no impact if we change it!
+	const std::string output_directory_name = "../data/out/"; //  "./output_data_csv/Opel/2018-08-09/";  there is no impact if we change it!
 	std::string output_file_name_str;
 
 	time(&rawtime);
 	timeinfo = localtime(&rawtime);
 
 	strftime(datetime, sizeof(datetime), "%Y-%m-%d_%I-%M-%S", timeinfo);
-	output_file_name_str = output_directory_name + "output" + datetime + ".csv";
+    
+#ifndef INPUT_FILE_NAME
+    	output_file_name_str = output_directory_name + "output" + datetime + ".csv";
+#else
+    	output_file_name_str = output_directory_name + INPUT_FILE_NAME + datetime + ".csv";
+#endif //INPUT_FILE_NAME
+    
 	cout << output_file_name_str << endl;
 	
 	//XXX - only for now:
 
 	//Ali printf("\n csv_Writer is not NULL, but it is not initialized!!   \n");
 	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();
 	return true; //added by Ali, it is an error in VS.
 }
 
 bool StateHandler::delete_all_InputVariables()
 {
 	SlaveAgentSlotOfAgent* cur_sl_ag_sl_ag;
 	unsigned int index_v_InpVar;
 	unsigned int size_v_InpVar = vInputVariables.size();
 	for(index_v_InpVar = 0; index_v_InpVar < size_v_InpVar; index_v_InpVar++) {
 		cur_sl_ag_sl_ag = vInputVariables[index_v_InpVar];
 		delete cur_sl_ag_sl_ag;
 	}
 	vInputVariables.clear();
 	return true; //added by Ali, it is an error in VS.
 }
 
 bool StateHandler::delete_allStates()
 {
 	State* 			cur_state;
 	unsigned int 	index_v_State;
 	unsigned int 	size_v_State = vStates.size();
 	for(index_v_State = 0; index_v_State < size_v_State; index_v_State++) {
 		cur_state = vStates[index_v_State];
 		delete cur_state;
 	}
 	vStates.clear();
 	return true; //added by Ali, it is an error in VS.
 }
 
 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() {
 #ifdef PRINT
 	printf(" >> Save Active State\n");
 #endif //PRINT
 	if (activeState != NULL) {
 		for (auto &state : vStates) {
 			if (state == activeState)
 				return true;
 		}
 
 #ifdef STOP_WHEN_STATE_VALID
 		getchar();
 #endif // STOP_WHEN_STATE_VALID
 		
 		try {
 			vStates.push_back(activeState);
 			return true;
 		}
 		catch (bad_alloc& error) {
 			printError("bad_alloc caught: ", error.what());
 			delete activeState;
 		}
 	}
 	return false;
 }
 
 /*
 bool StateHandler::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) {
 
 #ifdef PRINT
 	printf("cycle: %u\n", cycle);
 #endif // PRINT
 
 
 	bool flagGotValues = true;
 #ifdef PRINT
 	printf("Input Sample Values:\n");
 #endif // PRINT
 	for (auto &slot : vInputVariables) {
 		float sampleValue;
 		if (!(slot->get_slaveAgentValue(&sampleValue)))
 			flagGotValues = false;	//program never executes this line of code
 #ifdef PRINT
 		printf("In, %s: %f\n", slot->get_comPort()->get_name(), sampleValue);
 #endif // PRINT
 		
 		if (cycle == 1)
 			csv_writer->write_field(slot->get_comPort()->get_name());
 		else
 			csv_writer->write_field(sampleValue);
 		csv_writer->make_new_field();
 	}
 #ifdef PRINT
 	printf("Output Sample Values:\n");
 #endif // PRINT
 	for (auto &slot : vOutputVariables) {
 		float sampleValue;
 		if (!(slot->get_slaveAgentValue(&sampleValue)))
 			flagGotValues = false;	//program never executes this line of code
 #ifdef PRINT
 		printf("Out, %s: %f\n", slot->get_comPort()->get_name(), sampleValue);
 #endif // PRINT
 			
 		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;
 #ifdef PRINT
 			printf(" > new active state\n");
 #endif // PRINT
 			makeNewActiveState();
 			if (activeState->insertValueInState(FuncBlockConfValStateDev, FuncBlockConfInvStateDev, FuncBlockConfValStateTime, FuncBlockConfInvStateTime, maxStateHistoryLength, discreteAveragePartitionSize))
 				addActiveStateToStateVector();
 			//NEW - Adjust FuncBlockConfSim2StateTime and FuncBlockConfDif2StateTime
 			float newBoundary = (float)activeState->getLengthOfHistory();
 			FuncBlockConfSim2StateTime->changeFunctionBlockIncr(newBoundary);
 			FuncBlockConfDif2StateTime->changeFunctionBlockDecr(newBoundary);
 
 			csv_writer->write_field((int)vStates.size() + 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;
 #ifdef PRINT
 				printf(" > same state\n");
 
 				//printf("\nPROOF:\nconfInputVarAreSim2ActiveState = %f\nconfInputVarAreDif2ActiveState = %f\nconfOutputVarAreSim2ActiveState = %f\nconfOutputVarAreDif2ActiveState = %f\n", confInputVarAreSim2ActiveState, confInputVarAreDif2ActiveState, confOutputVarAreSim2ActiveState, confOutputVarAreDif2ActiveState);
 #endif // PRINT
 				if (activeState->insertValueInState(FuncBlockConfValStateDev, FuncBlockConfInvStateDev, FuncBlockConfValStateTime, FuncBlockConfInvStateTime, maxStateHistoryLength, discreteAveragePartitionSize))
 					addActiveStateToStateVector();
 				//NEW - Adjust FuncBlockConfSim2StateTime and FuncBlockConfDif2StateTime
 				float newBoundary = (float)activeState->getLengthOfHistory();
 				FuncBlockConfSim2StateTime->changeFunctionBlockIncr(newBoundary);
 				FuncBlockConfDif2StateTime->changeFunctionBlockDecr(newBoundary);
 
 				//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) {
 #ifdef PRINT
 					setColor(TXTCOLOR_YELLOW);
 					printf("DRIFT\n");
 					setColor(TXTCOLOR_GREY);
 #endif // PRINT
 #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 {
 #ifdef PRINT
 					setColor(TXTCOLOR_LIGHTGREEN);
 					printf("OK\n");
 					setColor(TXTCOLOR_GREY);
 #endif // PRINT
 
 					//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) {
 #ifdef PRINT
 							setColor(TXTCOLOR_LIGHTRED);
 							printf("BROKEN\n");
 							setColor(TXTCOLOR_GREY);
 #endif // PRINT
 #ifdef STOP_AFTER_BROKEN
 							brokentest = 1;
 #endif // STOP_AFTER_BROKEN			
 #ifdef STOP_WHEN_BROKEN
 							getchar();
 #endif // STOP_WHEN_BROKEN
 
 							//print broken
 							csv_writer->write_field(STATUS_BROKEN);
 							csv_writer->make_new_field();
 
 							//calculate and print conf
 							float conf = fuzzyAND(fuzzyOR(confInputVarAreDif2ActiveState, confOutputVarAreDif2ActiveState), fuzzyAND(confidenceBroken, activeState->getConfStateValid()));
 							csv_writer->write_field(conf);
 							//csv_writer->make_new_field();
 						}
 						else {
 							//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();
 
 
 
 				}
 
 			}
 
 #ifdef PRINT
 			printf("STATES: %u\n", vStates.size());
 #endif // PRINT
 		}
 	}
 
 	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;
-
+    
+#ifndef INPUT_FILE_NAME
+    	output_file_name_str = output_directory_name + "output" + datetime + cfg_parameter + ".csv";
+#else
+    	string out_dir = "../data/out/";
+    	output_file_name_str = out_dir + INPUT_FILE_NAME + datetime + cfg_parameter + ".csv";
+#endif // INPUT_FILE_NAME
+    
 	return output_file_name_str;
 }
 
 void StateHandler::set_CSV_Writer_parameter(string cfg_parameter)
 {
 	string cur_Output_File_Name = this->create_Output_File_Name(cfg_parameter);
 	csv_writer->reset_fpointer(cur_Output_File_Name);
 }
 
 
 
 /*
 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/config.h b/Version_Max_07_05_2018_CMake/src/config.h
new file mode 100644
index 0000000..76ab559
--- /dev/null
+++ b/Version_Max_07_05_2018_CMake/src/config.h
@@ -0,0 +1,13 @@
+#ifndef CONFIG_H
+#define CONFIG_H
+#define NUM_DATA_POINTS 4
+#define DATA_NAMES "a096FC6204", "a096FC6204_Y", "a096FC6204_SP", "a096PI6284"
+#define OUTTER_BOUND_SIM_DIF 0.2
+#define INNER_BOUND_SIM_DIF 0.01
+#define BOUND_BROKEN 2
+#define LENGTH 20
+#define INPUT_FILE_NAME "export_2018-03-21_170700-2018-03-22_030000.csv"
+#define INPUT_FILE_PATH "../data"
+#define INPUT_FILE_LENGTH 593
+#define PRINT
+#endif //CONFIG_H
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 accc255..bfac45d 100755
--- a/Version_Max_07_05_2018_CMake/src/file_util.h
+++ b/Version_Max_07_05_2018_CMake/src/file_util.h
@@ -1,81 +1,100 @@
 /*
  * 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 "config.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
+//#define CASE_OPEL 1
 
-#define WINDOWS_OS 1
+//define WINDOWS_OS 1
+
+#define CASE_OMV_20170107 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 		= "../../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/";
+#elif CASE_OMV_20170107
+
+#ifndef INPUT_FILE_PATH
+const std::string PATH_TO_CSV_DATA_FILES 		= "../../tests";
+const std::string PATH_TO_DATE_OF_MEASUREMENT	= "/2017_01_07";
+#else
+const std::string PATH_TO_CSV_DATA_FILES 		= INPUT_FILE_PATH;
+const std::string PATH_TO_DATE_OF_MEASUREMENT	= "";
+#endif
+//settings for file 2017_01_07__05_46_fc6504.csv
+const std::string PATH_TO_AN_MEASURMENT			= "/";
+#ifndef INPUT_FILE_NAME
+    const std::string FILE_NAME_OF_ENTIRE_DATA		= "2017_01_07__05_46_fc6504.csv";
+#else
+    const std::string FILE_NAME_OF_ENTIRE_DATA		= INPUT_FILE_NAME;
+#endif
+const std::string output_directory_name = "../../tests/out/";
 
 
 //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";
 const std::string output_directory_name = "../../init me correctly/";
 #endif
 
 
 #endif /* FILE_UTIL_H_ */
diff --git a/Version_Max_07_05_2018_CMake/src/main_configurable.cpp b/Version_Max_07_05_2018_CMake/src/main_configurable.cpp
new file mode 100755
index 0000000..7983c13
--- /dev/null
+++ b/Version_Max_07_05_2018_CMake/src/main_configurable.cpp
@@ -0,0 +1,1144 @@
+/*
+ * main.cpp
+ *
+ *  Created on: 25.05.2018
+ *      Author: edwin willegger, edwin.willegger@tuwien.ac.at
+ *      This file is used to generate output data from measurements
+ *      from OMV for SAVE project.
+ *      In this case the data of the 18.12.2017 is analyzed.
+ *      Based on the implementation of Maximilian Götzinger.
+ */
+
+#include "config.h"
+#include "Agent.h"
+#include "Channel.h"
+#include "create_unit.h"
+#include "CSVreaderModule.h"
+#include "inAgentsRegistrations.h"
+#include "mount_nodes.h"
+#include "register_in_testbench.h"
+#include "Sensor.h"
+#include "setupNode.h"
+#include <stdio.h>
+#include <iostream>
+#include <vector>
+#include <string>
+#include <cstring>
+#include "Testbench.h"
+#include "file_util.h"
+
+#include "LinearFunction.h"
+#include "LinearFunctionBlock.h"
+
+#include "Testbench_Config.h"
+
+using namespace std;
+
+/**********************************************************************************************************************
+ ************************************************begin of global definitions of variables and constants ***************
+ **********************************************************************************************************************/
+
+//every n-th SAMBLING value will be read in from the CSV-Data-Input-Files.
+#define SAMPLING	1
+
+//global vectors for the different elements
+static vector<Agent*> 				vec_of_Agents;
+static vector<Sensor*> 				vec_of_Sensors;
+static vector<Channel*>				vec_of_Channels_for_Sensors;
+static vector<Channel*> 			vec_of_Channels_for_Agents;
+static vector<LinearFunctionBlock*> vec_of_linear_Function_Blocks;
+static vector<Testbench*>			vec_of_test_benches;
+static vector<CSVreaderModule*>		vec_of_csv_readers;
+
+#ifndef NUM_DATA_POINTS
+	int num_data_points = 7;
+#   define NUM_DATA_POINTS 7
+#else
+	int num_data_points = NUM_DATA_POINTS;
+#endif
+
+//names of the measured data
+
+const string measured_data_names[]= {
+#ifndef DATA_NAMES    
+	"PI6174",   //INPUT
+	"PI6184",   //INPUT
+	"FC6104",   //OUTPUT
+	"FC6104_SP",//INPUT
+	"FC6104_Y", //INPUT
+	"FC6114CO", //INPUT
+	"QI6154"	//INPUT
+#else
+    DATA_NAMES
+#endif
+};
+
+//viability monitor
+const string VIABILITY_MONITOR			= "ViabilityMonitor";
+//index number of output
+const int INDEX_OUTPUT					= 0;
+
+//name for the channels of the sensors and agents
+#define APPENDIX_FOR_CHANNEL_SENSOR_NAME "(SA)";
+#define APPENDIX_FOR_CHANNEL_AGENT_NAME "(AA-UP)";
+
+static string measured_channel_sensor_names[NUM_DATA_POINTS];
+static string measured_channel_agent_names[NUM_DATA_POINTS];
+
+void init_channel_names(){
+	for(int i = 0; i < NUM_DATA_POINTS; i++)
+	{
+		measured_channel_sensor_names[i] = measured_data_names[i] + APPENDIX_FOR_CHANNEL_SENSOR_NAME;
+		measured_channel_agent_names[i] = measured_data_names[i] + APPENDIX_FOR_CHANNEL_AGENT_NAME;
+	}
+}
+
+#define TRANSFER_RATE_CHANNEL_SENSOR	0
+#define TRANSFER_RATE_CHANNEL_AGENT		MAX_BUFFER_LENGTH
+
+
+//////////////////////////////////////////////
+/*
+//out of the outer_bound the function is 0 or 1 and within 1 or 0 depending on function or complementery.
+	   inner_bound_xxx = /----------=1----|------=1---------\ = inner_bound_xxxx
+	  outer_bound_xxx = /				  |				     \
+	  	  	  	  	   /				  |					  \
+		  0=__________/					  |				       \ = outer_bound_xxxx	______ = 0
+--------------------------------------------------------------------------
+*/
+
+//parameters of boundary for similar function
+#ifndef OUTTER_BOUND_SIM_DIF
+#   define OUTTER_BOUND_SIM_DIF 	0.20 	//outer bound e. g. 0.14 = 14 percent; testested with 0.20, 0.14, 0.06,
+#endif
+
+#ifndef INNER_BOUND_SIM_DIF
+#   define INNER_BOUND_SIM_DIF 	0.01	//inner bound e. g. 0.01 = 1 percent
+#endif
+
+//same way as above but shows drift.
+#define OUTTER_BOUND_DRIFT 		OUTTER_BOUND_SIM_DIF * 3
+#define INNER_BOUND_DRIFT		OUTTER_BOUND_SIM_DIF
+
+//timer sagt, dass nach dem DOWNSAMPLING der Ausgang bis zu
+//n Werte später sich ändern darf, nachdem Sich der Eingang geändert hat.
+#ifndef BOUND_BROKEN
+#   define BOUND_BROKEN			2
+#endif
+
+//length where fuzzy function raises from 0 to 1 or 1 to 0 for the complementery.
+//history of the data depends of it, and should change, if it changes.
+#ifndef LENGTH
+#   define LENGTH					10
+#endif
+
+//definitions for the testbench
+const string TEST_BENCH = "testbench";
+
+//defintions for the csv-reader-modules
+#define APPENDIX_CSV_MODULES " CSV-Reader"
+
+const string measured_data_csv_names[] = {
+	FILE_NAME_OF_ENTIRE_DATA + APPENDIX_CSV_MODULES,
+	FILE_NAME_OF_ENTIRE_DATA + APPENDIX_CSV_MODULES,
+	FILE_NAME_OF_ENTIRE_DATA + APPENDIX_CSV_MODULES,
+	FILE_NAME_OF_ENTIRE_DATA + APPENDIX_CSV_MODULES,
+	FILE_NAME_OF_ENTIRE_DATA + APPENDIX_CSV_MODULES,
+	FILE_NAME_OF_ENTIRE_DATA + APPENDIX_CSV_MODULES,
+	FILE_NAME_OF_ENTIRE_DATA + APPENDIX_CSV_MODULES
+ };
+
+/*
+const string FIRST_MEASURED_DATA_CSV_NAME 	= FILE_NAME_OF_ENTIRE_DATA + APPENDIX_CSV_MODULES;
+const string SECOND_MEASURED_DATA_CSV_NAME 	= FILE_NAME_OF_ENTIRE_DATA + APPENDIX_CSV_MODULES;
+const string THIRD_MEASURED_DATA_CSV_NAME 	= FILE_NAME_OF_ENTIRE_DATA + APPENDIX_CSV_MODULES;
+const string FOURTH_MEASURED_DATA_CSV_NAME 	= FILE_NAME_OF_ENTIRE_DATA + APPENDIX_CSV_MODULES;
+const string FIFTH_MEASURED_DATA_CSV_NAME 	= FILE_NAME_OF_ENTIRE_DATA + APPENDIX_CSV_MODULES;
+const string SIXTH_MEASURED_DATA_CSV_NAME 	= FILE_NAME_OF_ENTIRE_DATA + APPENDIX_CSV_MODULES;
+const string SEVENTH_MEASURED_DATA_CSV_NAME = FILE_NAME_OF_ENTIRE_DATA + APPENDIX_CSV_MODULES;
+*/
+
+//to switch between different file configurations change the
+//DEFINES in file_util.h
+
+/**********************************************************************************************************************
+ ************************************************end of global definitions of variables and constants *****************
+ **********************************************************************************************************************/
+
+/**********************************************************************************************************************
+ ************************************************begin of function prototypes *****************************************
+ **********************************************************************************************************************/
+void create_and_register_all_Testbench_Configs(Testbench* current_tb);
+
+void create_and_register_All_Agents();
+void set_working_cycle_of_All_Agents();
+
+void create_and_register_All_Sensors();
+void set_working_cycle_of_All_Sensors();
+
+void create_and_register_channels();
+void create_and_register_channels_for_sensors();
+void create_and_register_channels_for_agents();
+
+void mount_sensors_in_agents();
+void mount_agents_in_agents();
+
+void register_data_agents_in_agent_state_Handler();
+
+void create_linear_function_blocks();
+void create_same_state_deviation_function_block();
+void create_another_state_deviation_function_block();
+void create_state_time_function_block();
+void create_another_state_time_function_block();
+void create_valid_state_deviation_function_block();
+void create_invalid_state_deviation_function_block();
+void create_valid_state_time_function_block();
+void create_invalid_state_time_function_block();
+void create_confidence_state_drift_function_block();
+void create_confidence_broken_function_block();
+void mount_function_blocks_to_viability_monitor();
+
+void create_all_testbenches();
+
+void create_csvr_modules();
+
+void register_agents_in_testbenches();
+
+void register_sensors_in_testbenches();
+
+void register_channels_in_testbenches();
+void register_channels_of_sensors_in_testbenches();
+void register_channels_of_actors_in_testbenches();
+
+void set_config_values_in_linear_functions(Testbench* current_tb);
+void set_parameters_LinearFunctionBlock(LinearFunctionBlock* cur_lin_func_block);
+void set_parameters_LinearFunction(vector<LinearFunction*> vec_Lin_Func);
+
+void set_CSV_Writer_parameter(Testbench* current_tb);
+
+void run_simulation_of_all_testbenches();
+
+void close_file_pointers();
+
+void empty_static_vectors();
+void empty_vec_Agent();
+void empty_vec_Channel_Agent();
+void empty_vec_Channel_Sensor();
+void empty_vec_Sensors();
+void empty_vec_csv_raders();
+void empty_vec_linear_func_Blocks();
+void empty_vec_TestBench();
+
+
+/**********************************************************************************************************************
+ ************************************************end of function prototypes *******************************************
+ **********************************************************************************************************************/
+
+int main()
+{
+	/*
+	"PI6174",   //INPUT
+	"PI6184",   //INPUT
+	"FC6104",   //OUTPUT
+	"FC6104_SP",//INPUT
+	"FC6104_Y", //INPUT
+	"FC6114CO", //INPUT
+	"QI6154"	//INPUT*/
+	cout << "This program processes test data from OMV Steam Cracker furnaces." << endl;
+
+	init_channel_names();
+
+	create_and_register_All_Agents();
+	set_working_cycle_of_All_Agents();
+
+
+	create_and_register_All_Sensors();
+	set_working_cycle_of_All_Sensors();
+
+	create_and_register_channels();
+
+	mount_sensors_in_agents();
+
+	mount_agents_in_agents();
+
+	register_data_agents_in_agent_state_Handler();
+
+	create_linear_function_blocks();
+
+	mount_function_blocks_to_viability_monitor();
+
+	create_all_testbenches();
+
+	create_csvr_modules();
+
+	register_agents_in_testbenches();
+
+	register_sensors_in_testbenches();
+
+	register_channels_in_testbenches();
+
+
+
+	run_simulation_of_all_testbenches();
+
+	//close_file_pointers();
+	//TODO memory free of all objects.
+	//empty_static_vectors();
+
+	cout << "Program finished successfully" << endl;
+	return 0;
+}
+
+void create_and_register_all_Testbench_Configs(Testbench* current_tb)
+{
+
+	One_Config_t one;
+	one.bound_broken 			= 2;
+	one.inner_bound_sim_dif 	= INNER_BOUND_SIM_DIF;
+	one.outter_bound_sim_dif 	= OUTTER_BOUND_SIM_DIF;
+	one.outter_bound_drift		= 3 * one.outter_bound_sim_dif;
+	one.inner_bound_drift		= one.outter_bound_sim_dif;
+	one.length					= LENGTH;
+	Testbench_Config* cfg 	= new Testbench_Config(one);
+	cfg->print();
+	current_tb->register_testbench_config(cfg);
+}
+
+
+
+/*
+ * creates all the agents used in the measurement
+ * and stores them into the global vector
+ */
+void create_and_register_All_Agents()
+{
+	cout << "Creating Agents" << endl;
+
+	char* c_name_of_current_agent = new char[MAX_LENGTH_NAME];
+	for(int i = 0; i < NUM_DATA_POINTS; i++)
+	{
+		strcpy(c_name_of_current_agent, measured_data_names[i].c_str());
+		Agent* a = create_agent(c_name_of_current_agent);
+		vec_of_Agents.push_back(a);
+	}
+	cout << vec_of_Agents.size() << " agents were created" << endl;
+
+	strcpy(c_name_of_current_agent, VIABILITY_MONITOR.c_str());
+	Agent* a_viabilityMonitor 	= create_agent(c_name_of_current_agent);
+	vec_of_Agents.push_back(a_viabilityMonitor);
+	cout << vec_of_Agents.size() << " agents were created" << endl;
+	delete c_name_of_current_agent;
+}
+
+/*
+ * the working_cycle for all registered agents is set
+ */
+void set_working_cycle_of_All_Agents()
+{
+	unsigned int working_Cyle = SAMPLING;
+	unsigned int size_of_vec_of_Agents = 0;
+	unsigned int index = 0;
+	Agent* current_Agent;
+	size_of_vec_of_Agents = vec_of_Agents.size();
+	for(index = 0; index < size_of_vec_of_Agents; index++) {
+		current_Agent = vec_of_Agents[index];
+		setWorkingCycleOfAgent(current_Agent, working_Cyle);
+	}
+}
+
+/*
+ * all necessary sensors are created and registered
+ */
+void create_and_register_All_Sensors()
+{
+	cout << "Creating Sensors" << endl;
+	char* c_name_of_current_sensor = new char[MAX_LENGTH_NAME];
+	for(int i = 0; i < NUM_DATA_POINTS; i++)
+	{
+		strcpy(c_name_of_current_sensor, measured_data_names[i].c_str());
+		Sensor* s 		= create_sensor(c_name_of_current_sensor);
+		vec_of_Sensors.push_back(s);
+	}
+	cout << vec_of_Sensors.size() << " sensors were created." << endl;
+	delete c_name_of_current_sensor;
+}
+
+/*
+ * working cycle of all registered sensors is set
+ */
+void set_working_cycle_of_All_Sensors()
+{
+	unsigned int working_Cyle = SAMPLING;
+	unsigned int size_of_vec_of_Sensors = 0;
+	unsigned int index = 0;
+	Sensor* current_Sensor;
+
+	size_of_vec_of_Sensors = vec_of_Sensors.size();
+	for(index = 0; index < size_of_vec_of_Sensors; index++) {
+		current_Sensor = vec_of_Sensors[index];
+		setWorkingCycleOfSensor(current_Sensor, working_Cyle);
+	}
+}
+
+/*
+ * creating and registering all channels
+ */
+void create_and_register_channels()
+{
+	create_and_register_channels_for_sensors();
+	create_and_register_channels_for_agents();
+}
+
+/*
+ * creating and registering the channels for the sensors.
+ */
+void create_and_register_channels_for_sensors()
+{
+	cout << "Creating and registering channels for sensors" << endl;
+	char* c_name_of_current_channel = new char[MAX_LENGTH_NAME];
+	for(int i = 0; i < NUM_DATA_POINTS; i++)
+	{
+		strcpy(c_name_of_current_channel, measured_channel_sensor_names[i].c_str());
+		Channel* c 	= create_channel(c_name_of_current_channel, 0);
+		vec_of_Channels_for_Sensors.push_back(c);
+	}
+	cout << vec_of_Channels_for_Sensors.size() << " channels for sensors were created" << endl;
+
+	delete c_name_of_current_channel;
+}
+
+/*
+ * creating and registering the channels for the agents
+ */
+void create_and_register_channels_for_agents()
+{
+	cout << "Creating and registering channels for agents" << endl;
+		char* c_name_of_current_channel = new char[MAX_LENGTH_NAME];
+		for(int i = 0; i < NUM_DATA_POINTS; i++)
+		{
+			strcpy(c_name_of_current_channel, measured_channel_agent_names[i].c_str());
+			Channel* c 	= create_channel(c_name_of_current_channel, 0);
+			vec_of_Channels_for_Agents.push_back(c);
+		}
+		cout << vec_of_Channels_for_Agents.size() << " channels for agents were created" << endl;
+
+		delete c_name_of_current_channel;
+}
+
+void mount_sensors_in_agents()
+{
+	Agent* 			current_agent;
+	Sensor* 		current_sensor;
+	Channel* 		current_sensor_channel;
+	unsigned int 	size_of_vec_sensor = 0;
+	unsigned int	index 	= 0;
+
+	size_of_vec_sensor = vec_of_Sensors.size();
+	cout << "mounting sensors in agents." << endl;
+	//it is assumed that the corresponding sensors and agents and channels are always at the same
+	//position in the different vectors, if not then you have to add an search algorithm for it.
+	for(index = 0; index < size_of_vec_sensor; index++)
+	{
+		current_agent 			= vec_of_Agents[index];
+		current_sensor 			= vec_of_Sensors[index];
+		current_sensor_channel 	= vec_of_Channels_for_Sensors[index];
+		mount_sensorInAgent(current_agent, current_sensor, current_sensor_channel);
+	}
+	cout << size_of_vec_sensor << " sensors in agents were mounted" << endl;
+}
+
+void mount_agents_in_agents()
+{
+	Agent* 			current_agent;
+	Agent* 			viability_Monitor;
+	Channel*	 	current_agent_channel;
+	unsigned int 	size_of_vec_agents = 0;
+	unsigned int 	index 				= 0;
+
+	size_of_vec_agents = vec_of_Agents.size();
+	//it is assumed that the viability agent is at the last position in the vector
+	viability_Monitor = vec_of_Agents[size_of_vec_agents-1];
+	//all agents and channels are registered to the viabilityMonitor agent
+	//so you have to subtract the viabilityMonitor from the number of elements to register
+	//it is assumed that all the corresponding channels and agents are placed at the same index
+	for(index = 0; index < size_of_vec_agents -1; index++)
+	{
+		current_agent 			= vec_of_Agents[index];
+		current_agent_channel 	= vec_of_Channels_for_Agents[index];
+		//only register if the agent is not the viability_monitor, otherwise you would register the viability monitor to itself.
+		if(current_agent != viability_Monitor) {
+			mount_agentInAgent(viability_Monitor, current_agent, current_agent_channel);
+		}
+	}
+	cout << size_of_vec_agents -1 << "agents were registered to the viability monitor" << endl;
+}
+
+/*
+ * registers the channels for the data agents to the viability monitor
+ */
+void register_data_agents_in_agent_state_Handler()
+
+{
+	Agent* 			viability_Monitor;
+	Channel* 		current_agent_channel;
+	unsigned int 	size_of_vec_channel_agents 	= 0;
+	unsigned int 	index 						= 0;
+
+	size_of_vec_channel_agents = vec_of_Channels_for_Agents.size();
+	//get the agent for the viabilityMonitor, it is assumed that it is at the last position
+	viability_Monitor = vec_of_Agents[vec_of_Agents.size()-1];
+	//register all the channels to the viability monitor
+	for(index = 0; index < size_of_vec_channel_agents; index++) {
+		current_agent_channel = vec_of_Channels_for_Agents[index];
+		if(index != INDEX_OUTPUT) {
+			registerSlaveAgentAsInputVariableInStateHandler(viability_Monitor, current_agent_channel);
+		}
+		else{
+			registerSlaveAgentAsOutputVariableInStateHandler(viability_Monitor, current_agent_channel);
+		}
+	}
+}
+
+/*
+ * creates and register all the different linear function blocks
+ */
+void create_linear_function_blocks()
+{
+	//don't change the sequence, because later it is assumed that the functions are
+	//registered int the vector in this sequence
+	//if you change it you have also to change the sequence in the function mount_function_blocks_to_viability_monitor
+	create_same_state_deviation_function_block();
+	create_another_state_deviation_function_block();
+	create_state_time_function_block();
+	create_another_state_time_function_block();
+	create_valid_state_deviation_function_block();
+	create_invalid_state_deviation_function_block();
+	create_valid_state_time_function_block();
+	create_invalid_state_time_function_block();
+	create_confidence_state_drift_function_block();
+	create_confidence_broken_function_block();
+}
+
+/*
+ * creates and register the linear function block for same state deviation
+ */
+void create_same_state_deviation_function_block()
+{
+	char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME];
+	strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_SAME_STATE_DEV.c_str());
+	LinearFunctionBlock* confSim2StateDev = new LinearFunctionBlock(c_name_of_current_func_block);
+	LinearFunction* funcConfSim2StateDev1 = new LinearFunction(CONF_SIM2_STATE_DEV_1);
+	funcConfSim2StateDev1->setDomain(false, true, (float)-OUTTER_BOUND_SIM_DIF);
+	funcConfSim2StateDev1->setKandD((float)0, (float)0);
+	confSim2StateDev->addLinearFunction(funcConfSim2StateDev1);
+	LinearFunction* funcConfSim2StateDev2 = new LinearFunction(CONF_SIM2_STATE_DEV_2);
+	funcConfSim2StateDev2->setDomain(true, (float)-OUTTER_BOUND_SIM_DIF, true, (float)-INNER_BOUND_SIM_DIF);
+	funcConfSim2StateDev2->setKandD((float)-OUTTER_BOUND_SIM_DIF, (float)0, (float)-INNER_BOUND_SIM_DIF, (float)1);
+	confSim2StateDev->addLinearFunction(funcConfSim2StateDev2);
+	LinearFunction* funcConfSim2StateDev3 = new LinearFunction(CONF_SIM2_STATE_DEV_3);
+	funcConfSim2StateDev3->setDomain(true, (float)-INNER_BOUND_SIM_DIF, true, (float)INNER_BOUND_SIM_DIF);
+	funcConfSim2StateDev3->setKandD((float)0, (float)1);
+	confSim2StateDev->addLinearFunction(funcConfSim2StateDev3);
+	LinearFunction* funcConfSim2StateDev4 = new LinearFunction(CONF_SIM2_STATE_DEV_4);
+	funcConfSim2StateDev4->setDomain(true, (float)INNER_BOUND_SIM_DIF, true, (float)OUTTER_BOUND_SIM_DIF);
+	funcConfSim2StateDev4->setKandD((float)INNER_BOUND_SIM_DIF, (float)1, (float)OUTTER_BOUND_SIM_DIF, (float)0);
+	confSim2StateDev->addLinearFunction(funcConfSim2StateDev4);
+	LinearFunction* funcConfSim2StateDev5 = new LinearFunction(CONF_SIM2_STATE_DEV_5);
+	funcConfSim2StateDev5->setDomain(true, (float)OUTTER_BOUND_SIM_DIF, false);
+	funcConfSim2StateDev5->setKandD((float)0, (float)0);
+	confSim2StateDev->addLinearFunction(funcConfSim2StateDev5);
+
+	vec_of_linear_Function_Blocks.push_back(confSim2StateDev);
+
+	delete c_name_of_current_func_block;
+}
+
+/*
+ * creates and register another state deviation function block
+ */
+void create_another_state_deviation_function_block()
+{
+	char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME];
+	strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_ANOTHER_STATE_DEV.c_str());
+	LinearFunctionBlock*  confDif2StateDev = new LinearFunctionBlock(c_name_of_current_func_block);
+	LinearFunction* funcConfDif2StateDev1 = new LinearFunction(CONF_DIF2_STATE_DEV_1);
+	funcConfDif2StateDev1->setDomain(false, true, (float)-OUTTER_BOUND_SIM_DIF);
+	funcConfDif2StateDev1->setKandD((float)0, (float)1);
+	confDif2StateDev->addLinearFunction(funcConfDif2StateDev1);
+	LinearFunction* funcConfDif2StateDev2 = new LinearFunction(CONF_DIF2_STATE_DEV_2);
+	funcConfDif2StateDev2->setDomain(true, (float)-OUTTER_BOUND_SIM_DIF, true, (float)-INNER_BOUND_SIM_DIF);
+	funcConfDif2StateDev2->setKandD((float)-OUTTER_BOUND_SIM_DIF, (float)1, (float)-INNER_BOUND_SIM_DIF, (float)0);
+	confDif2StateDev->addLinearFunction(funcConfDif2StateDev2);
+	LinearFunction* funcConfDif2StateDev3 = new LinearFunction(CONF_DIF2_STATE_DEV_3);
+	funcConfDif2StateDev3->setDomain(true, (float)-INNER_BOUND_SIM_DIF, true, (float)INNER_BOUND_SIM_DIF);
+	funcConfDif2StateDev3->setKandD((float)0, (float)0);
+	confDif2StateDev->addLinearFunction(funcConfDif2StateDev3);
+	LinearFunction* funcConfDif2StateDev4 = new LinearFunction(CONF_DIF2_STATE_DEV_4);
+	funcConfDif2StateDev4->setDomain(true, (float)INNER_BOUND_SIM_DIF, true, (float)OUTTER_BOUND_SIM_DIF);
+	funcConfDif2StateDev4->setKandD((float)INNER_BOUND_SIM_DIF, (float)0, (float)OUTTER_BOUND_SIM_DIF, (float)1);
+	confDif2StateDev->addLinearFunction(funcConfDif2StateDev4);
+	LinearFunction* funcConfDif2StateDev5 = new LinearFunction(CONF_DIF2_STATE_DEV_5);
+	funcConfDif2StateDev5->setDomain(true, (float)OUTTER_BOUND_SIM_DIF, false);
+	funcConfDif2StateDev5->setKandD((float)0, (float)1);
+	confDif2StateDev->addLinearFunction(funcConfDif2StateDev5);
+
+	vec_of_linear_Function_Blocks.push_back(confDif2StateDev);
+
+	delete c_name_of_current_func_block;
+}
+
+void create_state_time_function_block()
+{
+	char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME];
+	strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_SAME_TIME.c_str());
+	LinearFunctionBlock* confSim2StateTime = new LinearFunctionBlock(c_name_of_current_func_block);
+	LinearFunction* funcConfSim2StateTime1 = new LinearFunction(CONF_SIM2_STATE_TIME_1);
+	funcConfSim2StateTime1->setDomain(false, true, (float)0);
+	funcConfSim2StateTime1->setKandD((float)0, (float)0);
+	confSim2StateTime->addLinearFunction(funcConfSim2StateTime1);
+	LinearFunction* funcConfSim2StateTime2 = new LinearFunction(CONF_SIM2_STATE_TIME_2);
+	funcConfSim2StateTime2->setDomain(true, (float)0, true, (float)LENGTH);
+	funcConfSim2StateTime2->setKandD((float)0, (float)0, (float)LENGTH, (float)1);
+	confSim2StateTime->addLinearFunction(funcConfSim2StateTime2);
+	LinearFunction* funcConfSim2StateTime3 = new LinearFunction(CONF_SIM2_STATE_TIME_3);
+	funcConfSim2StateTime3->setDomain(true, (float)LENGTH, false);
+	funcConfSim2StateTime3->setKandD((float)0, (float)1);
+	confSim2StateTime->addLinearFunction(funcConfSim2StateTime3);
+
+	vec_of_linear_Function_Blocks.push_back(confSim2StateTime);
+
+	delete c_name_of_current_func_block;
+}
+
+void create_another_state_time_function_block()
+{
+	char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME];
+	strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_ANOTHER_STATE_TIME.c_str());
+	LinearFunctionBlock* confDif2StateTime = new LinearFunctionBlock(c_name_of_current_func_block);
+	LinearFunction* funcConfDif2StateTime1 = new LinearFunction(CONF_DIF2_STATE_TIME_1);
+	funcConfDif2StateTime1->setDomain(false, true, (float)0);
+	funcConfDif2StateTime1->setKandD((float)0, (float)1);
+	confDif2StateTime->addLinearFunction(funcConfDif2StateTime1);
+	LinearFunction* funcConfDif2StateTime2 = new LinearFunction(CONF_DIF2_STATE_TIME_2);
+	funcConfDif2StateTime2->setDomain(true, (float)0, true, (float)LENGTH);
+	funcConfDif2StateTime2->setKandD((float)0, (float)1, (float)LENGTH, (float)0);
+	confDif2StateTime->addLinearFunction(funcConfDif2StateTime2);
+	LinearFunction* funcConfDif2StateTime3 = new LinearFunction(CONF_DIF2_STATE_TIME_3);
+	funcConfDif2StateTime3->setDomain(true, (float)LENGTH, false);
+	funcConfDif2StateTime3->setKandD((float)0, (float)0);
+	confDif2StateTime->addLinearFunction(funcConfDif2StateTime3);
+
+	vec_of_linear_Function_Blocks.push_back(confDif2StateTime);
+
+	delete c_name_of_current_func_block;
+}
+
+void create_valid_state_deviation_function_block()
+{
+	char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME];
+	strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_VAILD_STATE_DEV.c_str());
+	LinearFunctionBlock* confValidStateDev = new LinearFunctionBlock(c_name_of_current_func_block);
+	LinearFunction* funcConfValidStateDev1 = new LinearFunction(CONF_VALID_STATE_DEV_1);
+	funcConfValidStateDev1->setDomain(false, true, (float)-OUTTER_BOUND_SIM_DIF);
+	funcConfValidStateDev1->setKandD((float)0, (float)0);
+	confValidStateDev->addLinearFunction(funcConfValidStateDev1);
+	LinearFunction* funcConfValidStateDev2 = new LinearFunction(CONF_VALID_STATE_DEV_2);
+	funcConfValidStateDev2->setDomain(true, (float)-OUTTER_BOUND_SIM_DIF, true, (float)-INNER_BOUND_SIM_DIF);
+	funcConfValidStateDev2->setKandD((float)-OUTTER_BOUND_SIM_DIF, (float)0, (float)-INNER_BOUND_SIM_DIF, (float)1);
+	confValidStateDev->addLinearFunction(funcConfValidStateDev2);
+	LinearFunction* funcConfValidStateDev3 = new LinearFunction(CONF_VALID_STATE_DEV_3);
+	funcConfValidStateDev3->setDomain(true, (float)-INNER_BOUND_SIM_DIF, true, (float)INNER_BOUND_SIM_DIF);
+	funcConfValidStateDev3->setKandD((float)0, (float)1);
+	confValidStateDev->addLinearFunction(funcConfValidStateDev3);
+	LinearFunction* funcConfValidStateDev4 = new LinearFunction(CONF_VALID_STATE_DEV_4);
+	funcConfValidStateDev4->setDomain(true, (float)INNER_BOUND_SIM_DIF, true, (float)OUTTER_BOUND_SIM_DIF);
+	funcConfValidStateDev4->setKandD((float)INNER_BOUND_SIM_DIF, (float)1, (float)OUTTER_BOUND_SIM_DIF, (float)0);
+	confValidStateDev->addLinearFunction(funcConfValidStateDev4);
+	LinearFunction* funcConfValidStateDev5 = new LinearFunction(CONF_VALID_STATE_DEV_5);
+	funcConfValidStateDev5->setDomain(true, (float)OUTTER_BOUND_SIM_DIF, false);
+	funcConfValidStateDev5->setKandD((float)0, (float)0);
+	confValidStateDev->addLinearFunction(funcConfValidStateDev5);
+
+	vec_of_linear_Function_Blocks.push_back(confValidStateDev);
+
+	delete c_name_of_current_func_block;
+}
+
+void create_invalid_state_deviation_function_block()
+{
+	char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME];
+	strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_INVALID_STATE_DEV.c_str());
+	LinearFunctionBlock* confInvalidStateDev = new LinearFunctionBlock(c_name_of_current_func_block);
+	LinearFunction* funcConfInvalidStateDev1 = new LinearFunction(CONF_INVALID_STATE_DEV_1);
+	funcConfInvalidStateDev1->setDomain(false, true, (float)-OUTTER_BOUND_SIM_DIF);
+	funcConfInvalidStateDev1->setKandD((float)0, (float)1);
+	confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev1);
+	LinearFunction* funcConfInvalidStateDev2 = new LinearFunction(CONF_INVALID_STATE_DEV_2);
+	funcConfInvalidStateDev2->setDomain(true, (float)-OUTTER_BOUND_SIM_DIF, true, (float)-INNER_BOUND_SIM_DIF);
+	funcConfInvalidStateDev2->setKandD((float)-OUTTER_BOUND_SIM_DIF, (float)1, (float)-INNER_BOUND_SIM_DIF, (float)0);
+	confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev2);
+	LinearFunction* funcConfInvalidStateDev3 = new LinearFunction(CONF_INVALID_STATE_DEV_3);
+	funcConfInvalidStateDev3->setDomain(true, (float)-INNER_BOUND_SIM_DIF, true, (float)INNER_BOUND_SIM_DIF);
+	funcConfInvalidStateDev3->setKandD((float)0, (float)0);
+	confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev3);
+	LinearFunction* funcConfInvalidStateDev4 = new LinearFunction(CONF_INVALID_STATE_DEV_4);
+	funcConfInvalidStateDev4->setDomain(true, (float)INNER_BOUND_SIM_DIF, true, (float)OUTTER_BOUND_SIM_DIF);
+	funcConfInvalidStateDev4->setKandD((float)INNER_BOUND_SIM_DIF, (float)0, (float)OUTTER_BOUND_SIM_DIF, (float)1);
+	confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev4);
+	LinearFunction* funcConfInvalidStateDev5 = new LinearFunction(CONF_INVALID_STATE_DEV_5);
+	funcConfInvalidStateDev5->setDomain(true, (float)OUTTER_BOUND_SIM_DIF, false);
+	funcConfInvalidStateDev5->setKandD((float)0, (float)1);
+	confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev5);
+
+	vec_of_linear_Function_Blocks.push_back(confInvalidStateDev);
+
+	delete c_name_of_current_func_block;
+}
+
+void create_valid_state_time_function_block()
+{
+	char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME];
+	strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_VALID_STATE_TIME.c_str());
+	LinearFunctionBlock* confValidStateTime = new LinearFunctionBlock(c_name_of_current_func_block);
+	LinearFunction* funcConfValidStateTime1 = new LinearFunction(VALID_STATE_TIME_1);
+	funcConfValidStateTime1->setDomain(false, true, (float)0);
+	funcConfValidStateTime1->setKandD((float)0, (float)0);
+	confValidStateTime->addLinearFunction(funcConfValidStateTime1);
+	LinearFunction* funcConfValidStateTime2 = new LinearFunction(VALID_STATE_TIME_2);
+	funcConfValidStateTime2->setDomain(true, (float)0, true, (float)LENGTH);				//10
+	funcConfValidStateTime2->setKandD((float)0, (float)0, (float)LENGTH, (float)1);
+	confValidStateTime->addLinearFunction(funcConfValidStateTime2);
+	LinearFunction* funcConfValidStateTime3 = new LinearFunction(VALID_STATE_TIME_3);
+	funcConfValidStateTime3->setDomain(true, (float)LENGTH, false);
+	funcConfValidStateTime3->setKandD((float)0, (float)1);
+	confValidStateTime->addLinearFunction(funcConfValidStateTime3);
+
+	vec_of_linear_Function_Blocks.push_back(confValidStateTime);
+
+	delete c_name_of_current_func_block;
+}
+void create_invalid_state_time_function_block()
+{
+	char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME];
+	strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_INVALID_STATE_TIME.c_str());
+	LinearFunctionBlock* confInvalidStateTime = new LinearFunctionBlock(c_name_of_current_func_block);
+	LinearFunction* funcConfInvalidStateTime1 = new LinearFunction(INVALID_STATE_TIME_1);
+	funcConfInvalidStateTime1->setDomain(false, true, (float)0);
+	funcConfInvalidStateTime1->setKandD((float)0, (float)1);
+	confInvalidStateTime->addLinearFunction(funcConfInvalidStateTime1);
+	LinearFunction* funcConfInvalidStateTime2 = new LinearFunction(INVALID_STATE_TIME_2);
+	funcConfInvalidStateTime2->setDomain(true, (float)0, true, (float)LENGTH);
+	funcConfInvalidStateTime2->setKandD((float)0, (float)1, (float)LENGTH, (float)0);
+	confInvalidStateTime->addLinearFunction(funcConfInvalidStateTime2);
+	LinearFunction* funcConfInvalidStateTime3 = new LinearFunction(INVALID_STATE_TIME_3);
+	funcConfInvalidStateTime3->setDomain(true, (float)LENGTH, false);
+	funcConfInvalidStateTime3->setKandD((float)0, (float)0);
+	confInvalidStateTime->addLinearFunction(funcConfInvalidStateTime3);
+
+	vec_of_linear_Function_Blocks.push_back(confInvalidStateTime);
+
+	delete c_name_of_current_func_block;
+}
+
+void create_confidence_state_drift_function_block()
+{
+	char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME];
+	strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_CONFIDENCE_STATE_DRIFTS.c_str());
+	LinearFunctionBlock* confStateDrifts = new LinearFunctionBlock(c_name_of_current_func_block);
+	LinearFunction* functionConfidenceDriftDeviation1 = new LinearFunction(CONFIDENCE_DRIFT_DEVIATION_1);
+	functionConfidenceDriftDeviation1->setDomain(false, true, (float)-OUTTER_BOUND_DRIFT);
+	functionConfidenceDriftDeviation1->setKandD((float)0, (float)1);
+	confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation1);
+	LinearFunction* functionConfidenceDriftDeviation2 = new LinearFunction(CONFIDENCE_DRIFT_DEVIATION_2);
+	functionConfidenceDriftDeviation2->setDomain(true, (float)-OUTTER_BOUND_DRIFT, true, (float)-INNER_BOUND_DRIFT);
+	functionConfidenceDriftDeviation2->setKandD((float)-INNER_BOUND_DRIFT, (float)1, (float)-INNER_BOUND_DRIFT, (float)0);
+	confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation2);
+	LinearFunction* functionConfidenceDriftDeviation3 = new LinearFunction(CONFIDENCE_DRIFT_DEVIATION_3);
+	functionConfidenceDriftDeviation3->setDomain(true, (float)-INNER_BOUND_DRIFT, true, (float)INNER_BOUND_DRIFT);
+	functionConfidenceDriftDeviation3->setKandD((float)0, (float)0);
+	confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation3);
+	LinearFunction* functionConfidenceDriftDeviation4 = new LinearFunction(CONFIDENCE_DRIFT_DEVIATION_4);
+	functionConfidenceDriftDeviation4->setDomain(true, (float)INNER_BOUND_DRIFT, true, (float)OUTTER_BOUND_DRIFT);
+	functionConfidenceDriftDeviation4->setKandD((float)INNER_BOUND_DRIFT, (float)0, (float)OUTTER_BOUND_DRIFT, (float)1);
+	confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation4);
+	LinearFunction* functionConfidenceDriftDeviation5 = new LinearFunction(CONFIDENCE_DRIFT_DEVIATION_5);
+	functionConfidenceDriftDeviation5->setDomain(true, (float)OUTTER_BOUND_DRIFT, false);
+	functionConfidenceDriftDeviation5->setKandD((float)0, (float)1);
+	confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation5);
+
+	vec_of_linear_Function_Blocks.push_back(confStateDrifts);
+
+	delete c_name_of_current_func_block;
+}
+
+void create_confidence_broken_function_block()
+{
+	char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME];
+	strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_CONFIDENCE_BROKEN.c_str());
+	LinearFunctionBlock* confBroken	= new LinearFunctionBlock(c_name_of_current_func_block);
+	LinearFunction* functionConfidenceBroken1 = new LinearFunction(CONFIDENCE_BROKEN_1);
+	functionConfidenceBroken1->setDomain(false, true, (float)0);
+	functionConfidenceBroken1->setKandD((float)0, (float)0);
+	confBroken->addLinearFunction(functionConfidenceBroken1);
+	LinearFunction* functionConfidenceBroken2 = new LinearFunction(CONFIDENCE_BROKEN_2);
+	functionConfidenceBroken2->setDomain(true, (float)0, true, (float)BOUND_BROKEN);
+	functionConfidenceBroken2->setKandD((float)0, (float)0, (float)BOUND_BROKEN, (float)1);
+	confBroken->addLinearFunction(functionConfidenceBroken2);
+	LinearFunction* functionConfidenceBroken3 = new LinearFunction(CONFIDENCE_BROKEN_3);
+	functionConfidenceBroken3->setDomain(true, (float)BOUND_BROKEN, false);
+	functionConfidenceBroken3->setKandD((float)0, (float)1);
+	confBroken->addLinearFunction(functionConfidenceBroken3);
+
+	vec_of_linear_Function_Blocks.push_back(confBroken);
+
+	delete c_name_of_current_func_block;
+}
+
+/*
+ * mount the different function blocks to the viability monitor agent
+ */
+void mount_function_blocks_to_viability_monitor()
+{
+	Agent* 					viability_Monitor;
+	LinearFunctionBlock*	current_Linear_Function_Bock;
+	unsigned int 			size_of_vec_lin_func_block 	= vec_of_linear_Function_Blocks.size();
+	unsigned int 			index 						= 0;
+
+	//it is assumed that the viability monitor is at the last position of the vector of agents
+	viability_Monitor = vec_of_Agents[vec_of_Agents.size()-1];
+	for(index = 0; index < size_of_vec_lin_func_block; index++) {
+		current_Linear_Function_Bock = vec_of_linear_Function_Blocks[index];
+		//it is assumed that the function blocks are added into the vector in the following sequence
+		switch(index) {
+			case 0:
+				viability_Monitor->get_stateHandler()->FuncBlockConfSim2StateDev 	= current_Linear_Function_Bock;
+				break;
+			case 1:
+				viability_Monitor->get_stateHandler()->FuncBlockConfDif2StateDev 	= current_Linear_Function_Bock;
+				break;
+			case 2:
+				viability_Monitor->get_stateHandler()->FuncBlockConfSim2StateTime	= current_Linear_Function_Bock;
+				break;
+			case 3:
+				viability_Monitor->get_stateHandler()->FuncBlockConfDif2StateTime	= current_Linear_Function_Bock;
+				break;
+			case 4:
+				viability_Monitor->get_stateHandler()->FuncBlockConfValStateDev 	= current_Linear_Function_Bock;
+				break;
+			case 5:
+				viability_Monitor->get_stateHandler()->FuncBlockConfInvStateDev 	= current_Linear_Function_Bock;
+				break;
+			case 6:
+				viability_Monitor->get_stateHandler()->FuncBlockConfValStateTime 	= current_Linear_Function_Bock;
+				break;
+			case 7:
+				viability_Monitor->get_stateHandler()->FuncBlockConfInvStateTime 	= current_Linear_Function_Bock;
+				break;
+			case 8:
+				viability_Monitor->get_stateHandler()->DriftDeviation 				= current_Linear_Function_Bock;
+				break;
+			case 9:
+				viability_Monitor->get_stateHandler()->FuncBlockConfBrokenSamples 	= current_Linear_Function_Bock;
+				break;
+		}
+	}
+}
+
+
+void create_all_testbenches() {
+	char* c_name_of_current_testbench = new char[MAX_LENGTH_NAME];
+	strcpy(c_name_of_current_testbench, TEST_BENCH.c_str());
+	cout << "Creating test bench" << endl;
+	Testbench* tb = create_testbench(c_name_of_current_testbench);
+	create_and_register_all_Testbench_Configs(tb);
+	vec_of_test_benches.push_back(tb);
+
+	delete c_name_of_current_testbench;
+}
+
+void create_csvr_modules()
+{
+	//sets the row in which the data starts, maybe row one contains the headers
+	unsigned int row = 2;
+	char* c_name_of_current_csv_module = new char[MAX_LENGTH_NAME];
+	string current_reader_path_and_file_name;
+	cout << "Creating CSV Reader Modules" << endl;
+
+	for(unsigned int i = 0; i < NUM_DATA_POINTS; i++)
+	{
+		current_reader_path_and_file_name 	= PATH_TO_CSV_DATA_FILES + PATH_TO_DATE_OF_MEASUREMENT + PATH_TO_AN_MEASURMENT + FILE_NAME_OF_ENTIRE_DATA;
+		strcpy(c_name_of_current_csv_module, measured_data_csv_names[i].c_str());
+		CSVreaderModule* csvr				= create_CSVreaderModule(c_name_of_current_csv_module,current_reader_path_and_file_name.c_str(),3+i,row);
+		vec_of_csv_readers.push_back(csvr);
+	}
+	delete c_name_of_current_csv_module;
+}
+
+/*
+ * all agents would be registered to all testbenches
+ */
+void register_agents_in_testbenches()
+{
+	Testbench* 		current_tb;
+	unsigned int 	size_of_vec_test_benches 	= vec_of_test_benches.size();
+	unsigned int 	index_tb 					= 0;
+	Agent* 			current_ag;
+	unsigned int 	size_of_vec_agents 	= vec_of_Agents.size();
+	unsigned int 	index_agents 		= 0;
+
+	cout << "registering agents in testbenches" << endl;
+	for(index_tb = 0; index_tb < size_of_vec_test_benches; index_tb++) {
+		current_tb = vec_of_test_benches[index_tb];
+		for(index_agents = 0; index_agents < size_of_vec_agents; index_agents++) {
+			current_ag = vec_of_Agents[index_agents];
+			register_agentInTestbench(current_tb, current_ag);
+		}
+	}
+	cout << size_of_vec_agents << " agents were registered in every of the " << size_of_vec_test_benches << " testbenches" << endl;
+}
+
+/*
+ * registering the sensors and the corresponding csv-readers in the testbenches
+ * it is assumed that the csv readers and the sensors are at the same index position
+ * in the vectors.
+ */
+void register_sensors_in_testbenches()
+{
+	Testbench* 			current_tb;
+	unsigned int 		size_of_vec_test_benches 	= vec_of_test_benches.size();
+	unsigned int 		index_tb 					= 0;
+	Sensor* 			current_se;
+	unsigned int 		size_of_vec_sensors 		= vec_of_Sensors.size();
+	unsigned int 		index_sensors 				= 0;
+	CSVreaderModule*	current_csv_reader;
+	unsigned int 		size_of_vec_csv_reader 		= vec_of_csv_readers.size();
+
+	if(size_of_vec_csv_reader != size_of_vec_sensors) {
+		cout << "Error, in sequence of data processing";
+		cout << "Number of csv-readers should be equal to number of sensors" << endl;
+	}
+	else {
+		cout << "Registering sensors and their csv-readers in testbenches " << endl;
+		for(index_tb = 0; index_tb < size_of_vec_test_benches; index_tb++) {
+			current_tb = vec_of_test_benches[index_tb];
+			for(index_sensors = 0; index_sensors < size_of_vec_sensors; index_sensors++) {
+				current_se 			= vec_of_Sensors[index_sensors];
+				//it is assumed that the sensor and the corresponding csv-reader is stored
+				//at the same position in the two different vectors
+				current_csv_reader 	= vec_of_csv_readers[index_sensors];
+				register_sensorInTestbench(current_tb, current_se, current_csv_reader);
+			}
+		}
+		cout << size_of_vec_sensors << " Sensors and their csv-readers were registered to ";
+		cout << "every of the " << size_of_vec_test_benches << " testbenches" << endl;
+	}
+}
+
+void register_channels_in_testbenches()
+{
+	register_channels_of_sensors_in_testbenches();
+
+	register_channels_of_actors_in_testbenches();
+}
+
+void register_channels_of_sensors_in_testbenches()
+{
+	Testbench* 		current_tb;
+	unsigned int 	size_of_vec_test_benches 	= vec_of_test_benches.size();
+	unsigned int 	index_tb 					= 0;
+	Channel*	 	current_se_ch;
+	unsigned int 	size_of_vec_se_channel 		= vec_of_Channels_for_Sensors.size();
+	unsigned int 	index_se_ch 				= 0;
+
+	cout << "Registering channels of sensors in testbench" << endl;
+	for(index_tb = 0; index_tb < size_of_vec_test_benches; index_tb++) {
+		current_tb = vec_of_test_benches[index_tb];
+		for(index_se_ch = 0; index_se_ch < size_of_vec_se_channel; index_se_ch++) {
+			current_se_ch = vec_of_Channels_for_Sensors[index_se_ch];
+			register_channelInTestbench(current_tb, current_se_ch);
+		}
+	}
+	cout << size_of_vec_se_channel << " channels of sensors were registered in ";
+	cout << size_of_vec_test_benches << " testbenches." << endl;
+
+}
+
+void register_channels_of_actors_in_testbenches()
+{
+	Testbench* 		current_tb;
+	unsigned int 	size_of_vec_test_benches 	= vec_of_test_benches.size();
+	unsigned int 	index_tb 					= 0;
+	Channel* 		current_se_ch;
+	unsigned int 	size_of_vec_ag_channel 		= vec_of_Channels_for_Agents.size();
+	unsigned int 	index_se_ch 				= 0;
+
+	cout << "Registering channels of agents in testbench" << endl;
+	for(index_tb = 0; index_tb < size_of_vec_test_benches; index_tb++) {
+		current_tb = vec_of_test_benches[index_tb];
+		for(index_se_ch = 0; index_se_ch < size_of_vec_ag_channel; index_se_ch++) {
+			current_se_ch = vec_of_Channels_for_Agents[index_se_ch];
+			register_channelInTestbench(current_tb, current_se_ch);
+		}
+	}
+	cout << size_of_vec_ag_channel << " channels of agents were registered in ";
+	cout << size_of_vec_test_benches << " testbenches." << endl;
+}
+
+void run_simulation_of_all_testbenches()
+{
+
+	string 						pressed_key;
+	Testbench* 					current_tb;
+	vector<Testbench_Config*> 	vec_tb_configs;
+	Testbench_Config* 			current_tb_config;
+	unsigned int 				size_of_vec_test_benches = vec_of_test_benches.size();
+	unsigned int 				index_tb = 0;
+	unsigned int 				size_of_vec_test_bench_config;
+	unsigned int				index_tb_cfg = 0;
+#ifndef INPUT_FILE_LENGTH
+    unsigned int 				sim_rounds = 131;
+#else
+    unsigned int 				sim_rounds = INPUT_FILE_LENGTH;
+#endif
+	const int					start_row = 1;
+
+	//cout << "Press any key to start the simulation of all testbenches." << endl;
+	//getline(cin, pressed_key);
+
+	for(index_tb = 0; index_tb < size_of_vec_test_benches; index_tb++){
+		current_tb = vec_of_test_benches[index_tb];
+		index_tb_cfg = 0;
+		vec_tb_configs = current_tb->get_all_registered_testbench_configs();
+		size_of_vec_test_bench_config = vec_tb_configs.size();
+		for(index_tb_cfg = 0; index_tb_cfg < size_of_vec_test_bench_config; index_tb_cfg++){
+			current_tb_config = vec_tb_configs[index_tb_cfg];
+			current_tb->set_current_tb_config_index(index_tb_cfg);
+			current_tb->set_CSV_Writer_parameter();
+			current_tb->set_config_values_in_linear_functions();
+			//have to open new file first! with the CSV-Writer, for every round > 0
+			current_tb->simulate(sim_rounds);
+			if(index_tb_cfg < size_of_vec_test_bench_config - 1) {
+				current_tb->set_CSV_Reader_row(start_row);
+				current_tb->set_CSV_Reader_to_beginning();
+				current_tb->reset_States();
+			}
+		}
+	}
+	cout << "Simulation of " << size_of_vec_test_benches << " testbenches successfully finished" << endl;
+}
+
+void close_file_pointers()
+{
+	CSVreaderModule*	current_csv_reader;
+	unsigned int 		size_of_vec_csv_reader 		= vec_of_csv_readers.size();
+	unsigned int 		index_csv_reader;
+	for(index_csv_reader = 0; index_csv_reader < size_of_vec_csv_reader; index_csv_reader++) {
+		current_csv_reader = vec_of_csv_readers[index_csv_reader];
+		current_csv_reader->close_file();
+	}
+}
+
+void empty_static_vectors()
+{
+
+	empty_vec_Agent();
+	empty_vec_Channel_Agent();
+	empty_vec_Channel_Sensor();
+	empty_vec_Sensors();
+	empty_vec_csv_raders();
+	empty_vec_linear_func_Blocks();
+	empty_vec_TestBench();
+
+	vec_of_Channels_for_Agents.clear();
+	vec_of_Channels_for_Sensors.clear();
+	vec_of_Sensors.clear();
+	vec_of_csv_readers.clear();
+	vec_of_linear_Function_Blocks.clear();
+}
+
+void empty_vec_Agent()
+{
+	Agent* 			cur_Agent;
+	unsigned int 	size_of_vec_Agent = vec_of_Agents.size();
+	unsigned int 	index_Agent;
+	for(index_Agent = 0; index_Agent < size_of_vec_Agent; index_Agent++){
+		cur_Agent = vec_of_Agents[index_Agent];
+		delete cur_Agent;
+	}
+	vec_of_Agents.clear();
+}
+
+void empty_vec_Channel_Agent()
+{
+	Channel* 		cur_Channel;
+	unsigned int 	size_of_vec_Chan_Agent = vec_of_Channels_for_Agents.size();
+	unsigned int 	index_Channel;
+	for(index_Channel = 0; index_Channel < size_of_vec_Chan_Agent; index_Channel++){
+		cur_Channel = vec_of_Channels_for_Agents[index_Channel];
+		//delete cur_Channel;
+	}
+	vec_of_Channels_for_Agents.clear();
+}
+
+void empty_vec_Channel_Sensor()
+{
+	Channel* 		cur_Channel;
+	unsigned int 	size_of_vec_Chan_Sensor = vec_of_Channels_for_Sensors.size();
+	unsigned int 	index_Channel;
+	for(index_Channel = 0; index_Channel < size_of_vec_Chan_Sensor; index_Channel++){
+		cur_Channel = vec_of_Channels_for_Sensors[index_Channel];
+		delete cur_Channel;
+	}
+	vec_of_Channels_for_Sensors.clear();
+}
+
+void empty_vec_Sensors()
+{
+	Sensor* 		cur_Sensor;
+	unsigned int 	size_of_vec_Chan_Sensor = vec_of_Sensors.size();
+	unsigned int 	index_Sensor;
+	for(index_Sensor = 0; index_Sensor < size_of_vec_Chan_Sensor; index_Sensor++){
+		cur_Sensor = vec_of_Sensors[index_Sensor];
+		delete cur_Sensor;
+	}
+	vec_of_Sensors.clear();
+}
+
+void empty_vec_csv_raders()
+{
+	CSVreaderModule* 	cur_csv_reader;
+	unsigned int 		size_of_vec_csv_reader = vec_of_csv_readers.size();
+	unsigned int 		index_csv_reader;
+	for(index_csv_reader = 0; index_csv_reader < size_of_vec_csv_reader; index_csv_reader++){
+		cur_csv_reader = vec_of_csv_readers[index_csv_reader];
+		delete cur_csv_reader;
+	}
+	vec_of_csv_readers.clear();
+}
+
+void empty_vec_linear_func_Blocks()
+{
+	LinearFunctionBlock* 	cur_lin_fun_block;
+	unsigned int 			size_of_vec_lin_fun_block= vec_of_linear_Function_Blocks.size();
+	unsigned int 			index_lin_fun_block;
+	for(index_lin_fun_block = 0; index_lin_fun_block < size_of_vec_lin_fun_block; index_lin_fun_block++){
+		cur_lin_fun_block = vec_of_linear_Function_Blocks[index_lin_fun_block];
+		delete cur_lin_fun_block;
+	}
+	vec_of_linear_Function_Blocks.clear();
+}
+
+void empty_vec_TestBench()
+{
+	Testbench* 	 current_tb;
+	unsigned int size_of_vec_test_benches = vec_of_test_benches.size();
+	unsigned int index_tb = 0;
+
+		for(index_tb = 0; index_tb < size_of_vec_test_benches; index_tb++){
+			current_tb = vec_of_test_benches[index_tb];
+			current_tb->free_resources();
+			delete current_tb;
+		}
+	vec_of_test_benches.clear();
+}
+