main.cpp
No OneTemporary
Actions

Size

50 KB

Referenced Files

None

Subscribers

None

main.cpp
View Options

	/*
	* 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 <QCoreApplication>
	#include <QFile>
	#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;

	//names of the measured data
	const string FIRST_MEASURED_DATA_NAME = "FC6504_Y"; //Input
	const string SECOND_MEASURED_DATA_NAME = "FC6504"; //Output
	const string THIRD_MEASURED_DATA_NAME = "FC6504_SP"; //Input
	const string FOURTH_MEASURED_DATA_NAME = "PI6584"; //Input


	//viability monitor
	const string VIABILITY_MONITOR = "ViabilityMonitor";
	//index number of output
	const int INDEX_OUTPUT = 1;

	//name for the channels of the sensors and agents
	const string APPENDIX_FOR_CHANNEL_SENSOR_NAME = "(SA)";
	const string FIRST_MEASURED_CHANNEL_SENSOR_NAME = FIRST_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_SENSOR_NAME;
	const string SECOND_MEASURED_CHANNEL_SENSOR_NAME = SECOND_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_SENSOR_NAME;
	const string THIRD_MEASURED_CHANNEL_SENSOR_NAME = THIRD_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_SENSOR_NAME;
	const string FOURTH_MEASURED_CHANNEL_SENSOR_NAME = FOURTH_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_SENSOR_NAME;
	const string APPENDIX_FOR_CHANNEL_AGENT_NAME = "(AA-UP)";
	const string FIRST_MEASURED_CHANNEL_AGENT_NAME = FIRST_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_AGENT_NAME;
	const string SECOND_MEASURED_CHANNEL_AGENT_NAME = SECOND_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_AGENT_NAME;
	const string THIRD_MEASURED_CHANNEL_AGENT_NAME = THIRD_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_AGENT_NAME;
	const string FOURTH_MEASURED_CHANNEL_AGENT_NAME = FOURTH_MEASURED_DATA_NAME + 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
	#define OUTTER_BOUND_SIM_DIF 0.20 //outer bound e. g. 0.14 = 14 percent; testested with 0.20, 0.14, 0.06,
	#define INNER_BOUND_SIM_DIF 0.01 //inner bound e. g. 0.01 = 1 percent

	//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.
	#define BOUND_BROKEN 2

	//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.
	#define LENGTH 10


	//definitions for the testbench
	const string TEST_BENCH = "testbench";

	//defintions for the csv-reader-modules
	const string APPENDIX_CSV_MODULES = " CSV-Reader";
	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;


	//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(int argc, char **argv)
	{
	bool status = false;
	QCoreApplication app(argc, argv);
	QString app_path = app.applicationDirPath();
	cout << "This program processes test data from OMV Steam Cracker furnaces." << endl;

	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 = 0.02;
	one.outter_bound_sim_dif = 0.08;
	one.inner_bound_drift = 3 * one.outter_bound_sim_dif;
	one.inner_bound_drift = one.outter_bound_sim_dif;
	one.length = 10;
	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];
	strcpy(c_name_of_current_agent, FIRST_MEASURED_DATA_NAME.c_str());
	Agent* a_FC6504_Y = create_agent(c_name_of_current_agent);
	strcpy(c_name_of_current_agent, SECOND_MEASURED_DATA_NAME.c_str());
	Agent* a_FC6504 = create_agent(c_name_of_current_agent);
	strcpy(c_name_of_current_agent, THIRD_MEASURED_DATA_NAME.c_str());
	Agent* a_FC6504_SP = create_agent(c_name_of_current_agent);
	strcpy(c_name_of_current_agent, FOURTH_MEASURED_DATA_NAME.c_str());
	Agent* a_PI6584 = create_agent(c_name_of_current_agent);
	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_FC6504_Y);
	vec_of_Agents.push_back(a_FC6504);
	vec_of_Agents.push_back(a_FC6504_SP);
	vec_of_Agents.push_back(a_PI6584);
	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];
	strcpy(c_name_of_current_sensor, FIRST_MEASURED_DATA_NAME.c_str());
	Sensor* s_FC6504_Y = create_sensor(c_name_of_current_sensor);
	strcpy(c_name_of_current_sensor, SECOND_MEASURED_DATA_NAME.c_str());
	Sensor* s_FC6504 = create_sensor(c_name_of_current_sensor);
	strcpy(c_name_of_current_sensor, THIRD_MEASURED_DATA_NAME.c_str());
	Sensor* s_FC6504_SP = create_sensor(c_name_of_current_sensor);
	strcpy(c_name_of_current_sensor, FOURTH_MEASURED_DATA_NAME.c_str());
	Sensor* s_PI6584 = create_sensor(c_name_of_current_sensor);
	vec_of_Sensors.push_back(s_FC6504_Y);
	vec_of_Sensors.push_back(s_FC6504);
	vec_of_Sensors.push_back(s_FC6504_SP);
	vec_of_Sensors.push_back(s_PI6584);
	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];
	strcpy(c_name_of_current_channel, FIRST_MEASURED_CHANNEL_SENSOR_NAME.c_str());
	Channel* c_sa_FC6504_Y = create_channel(c_name_of_current_channel, 0);
	strcpy(c_name_of_current_channel, SECOND_MEASURED_CHANNEL_SENSOR_NAME.c_str());
	Channel* c_sa_FC6504 = create_channel(c_name_of_current_channel, 0);
	strcpy(c_name_of_current_channel, THIRD_MEASURED_CHANNEL_SENSOR_NAME.c_str());
	Channel* c_sa_FC6504_SP = create_channel(c_name_of_current_channel, 0);
	strcpy(c_name_of_current_channel, FOURTH_MEASURED_CHANNEL_SENSOR_NAME.c_str());
	Channel* c_sa_PI6584 = create_channel(c_name_of_current_channel, 0);

	vec_of_Channels_for_Sensors.push_back(c_sa_FC6504_Y);
	vec_of_Channels_for_Sensors.push_back(c_sa_FC6504);
	vec_of_Channels_for_Sensors.push_back(c_sa_FC6504_SP);
	vec_of_Channels_for_Sensors.push_back(c_sa_PI6584);
	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];
	strcpy(c_name_of_current_channel, FIRST_MEASURED_CHANNEL_AGENT_NAME.c_str());
	Channel* c_aa_FC6504_Y = create_channel(c_name_of_current_channel, 0);
	strcpy(c_name_of_current_channel, SECOND_MEASURED_CHANNEL_AGENT_NAME.c_str());
	Channel* c_aa_FC6504 = create_channel(c_name_of_current_channel, 0);
	strcpy(c_name_of_current_channel, THIRD_MEASURED_CHANNEL_AGENT_NAME.c_str());
	Channel* c_aa_FC6504_SP = create_channel(c_name_of_current_channel, 0);
	strcpy(c_name_of_current_channel, FOURTH_MEASURED_CHANNEL_AGENT_NAME.c_str());
	Channel* c_aa_PI6584 = create_channel(c_name_of_current_channel, 0);

	vec_of_Channels_for_Agents.push_back(c_aa_FC6504_Y);
	vec_of_Channels_for_Agents.push_back(c_aa_FC6504);
	vec_of_Channels_for_Agents.push_back(c_aa_FC6504_SP);
	vec_of_Channels_for_Agents.push_back(c_aa_PI6584);

	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;

	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, FIRST_MEASURED_DATA_CSV_NAME.c_str());
	CSVreaderModule* csvr_FC6504_Y = create_CSVreaderModule(c_name_of_current_csv_module,current_reader_path_and_file_name.c_str(),3,row);

	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, SECOND_MEASURED_DATA_CSV_NAME.c_str());
	CSVreaderModule* csvr_FC6504 = create_CSVreaderModule(c_name_of_current_csv_module,current_reader_path_and_file_name.c_str(),4,row);

	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, THIRD_MEASURED_DATA_CSV_NAME.c_str());
	CSVreaderModule* csvr_FC6504_SP = create_CSVreaderModule(c_name_of_current_csv_module,current_reader_path_and_file_name.c_str(),5,row);

	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, FOURTH_MEASURED_DATA_CSV_NAME.c_str());
	CSVreaderModule* csvr_PI6584 = create_CSVreaderModule(c_name_of_current_csv_module,current_reader_path_and_file_name.c_str(),6,row);

	vec_of_csv_readers.push_back(csvr_FC6504_Y);
	vec_of_csv_readers.push_back(csvr_FC6504);
	vec_of_csv_readers.push_back(csvr_FC6504_SP);
	vec_of_csv_readers.push_back(csvr_PI6584);

	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;
	unsigned int sim_rounds = -1;
	const int start_row = 1;
	if (FILE_NAME_OF_ENTIRE_DATA == "2017_01_07__05_46_fc6504.csv") {
	sim_rounds = 720;
	}

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

File Metadata

Mime Type: text/x-c++
Expires: Thu, Jul 3, 6:28 AM (1 d, 14 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 157191
Default Alt Text: main.cpp (50 KB)

main.cppNo OneTemporaryActions

main.cppView Options

File Metadata

Event Timeline

main.cpp
No OneTemporary
Actions

main.cpp
View Options