No OneTemporary
Actions

Size

53 KB

Referenced Files

None

Subscribers

None

View Options

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

File Metadata

Mime Type: text/x-diff
Expires: Fri, Jul 4, 5:50 AM (5 h, 35 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 157479
Default Alt Text: (53 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions