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 #include //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 +#include +#include +#include +#include +#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 vec_of_Agents; +static vector vec_of_Sensors; +static vector vec_of_Channels_for_Sensors; +static vector vec_of_Channels_for_Agents; +static vector vec_of_linear_Function_Blocks; +static vector vec_of_test_benches; +static vector 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 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 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(); +} +