diff --git a/Version_Max_07_05_2018_CMake/src/CSVreaderModule.cpp b/Version_Max_07_05_2018_CMake/src/CSVreaderModule.cpp index 6705ac2..f652c26 100755 --- a/Version_Max_07_05_2018_CMake/src/CSVreaderModule.cpp +++ b/Version_Max_07_05_2018_CMake/src/CSVreaderModule.cpp @@ -1,217 +1,235 @@ #include "CSVreaderModule.h" +#include "file_util.h" #include #include #include #define STRINGLENGTH 5000 /* void CSV_Reader :: initialize_csvreader(char* filepath_read, unsigned int num_of_datasets, unsigned int* list_of_datasets, unsigned int start_row) { //fpointer_read = fopen(filepath_read, "r"); fopen_s(&fpointer_read, filepath_read, "r"); this->num_of_datasets = num_of_datasets; //TODO: sort.. falls es nicht in aufsteigender folge kommt for(unsigned int d_ix=0; d_ixlist_of_datasets[d_ix] = list_of_datasets[d_ix]; } row = 1; this->start_row = start_row; } */ void CSVreaderModule :: initialize_csvreader(FILE* fpointer, unsigned int column, unsigned int start_row) { //fpointer_read = fopen(filepath_read, "r"); //TODO: file ponter schon aus CSV-Reader Creator Funktion �bergeben.. dann kann man n�mlich ausgeben, wenn da was nicht erstellt werden kann //bool file_opened = fopen_s(&fpointer_read, filepath_read, "r"); //TODO: etwas mit flag this->fpointer = fpointer; this->row = 1; this->column = column; this->start_row = start_row; flag_csv_reader_configured = true; } /* CSV_Reader :: CSV_Reader(char* filepath_read, unsigned int num_of_data_sets, unsigned int* list_of_datasets, unsigned int start_row) { set_name(NO_NAME); initialize_csvreader(filepath_read, num_of_data_sets, list_of_datasets, start_row); } CSV_Reader :: CSV_Reader(char* name, char* filepath_read, unsigned int num_of_data_sets, unsigned int* list_of_datasets, unsigned int start_row) { set_name(name); initialize_csvreader(filepath_read, num_of_data_sets, list_of_datasets, start_row); } */ CSVreaderModule :: CSVreaderModule() { set_name(NO_NAME); flag_csv_reader_configured = false; } CSVreaderModule :: CSVreaderModule(char* name) { set_name(name); flag_csv_reader_configured = false; } CSVreaderModule :: CSVreaderModule(FILE* fpointer, unsigned int column, unsigned int start_row) { set_name(NO_NAME); if(fpointer) { initialize_csvreader(fpointer, column, start_row); } else { flag_csv_reader_configured = false; } } CSVreaderModule :: CSVreaderModule(char* name, FILE* fpointer, unsigned int column, unsigned int start_row) { set_name(name); if(fpointer) { initialize_csvreader(fpointer, column, start_row); } else { flag_csv_reader_configured = false; } } /* CSV_Reader :: CSV_Reader(char* name, char* filepath_read, int column, int start_row) { } */ //XXX: Wird nicht mehr benutzt //TODO: �berarbeiten nach folgendem Beispiel https://msdn.microsoft.com/en-us/library/ftsafwz3.aspx bool CSVreaderModule :: read_one_row() { if(fpointer) { char readrow[STRINGLENGTH] = "", electedfield[STRINGLENGTH] = ""; //TODO: move following for-loop to "initialize_csvreader(...) for(;rowrow = row; } void CSVreaderModule:: set_position_fpointer_to_start() { long int cur_pos; if(this->fpointer) { cur_pos = ftell(this->fpointer); rewind(this->fpointer); } } //TODO: flag_csv_reader_configured abfragen void CSVreaderModule :: close_file() { fclose(fpointer); } CSVreaderModule :: ~CSVreaderModule(){ if(fpointer) { close_file(); } } 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 8751598..accc255 100755 --- a/Version_Max_07_05_2018_CMake/src/file_util.h +++ b/Version_Max_07_05_2018_CMake/src/file_util.h @@ -1,77 +1,81 @@ /* * 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 #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_OMV 1 + +#define CASE_OPEL 1 + +#define WINDOWS_OS 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/"; //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_Opel_GA_Data_Symmetrie.cpp b/Version_Max_07_05_2018_CMake/src/main_Opel_GA_Data_Symmetrie.cpp index 41998d5..14e3f29 100755 --- a/Version_Max_07_05_2018_CMake/src/main_Opel_GA_Data_Symmetrie.cpp +++ b/Version_Max_07_05_2018_CMake/src/main_Opel_GA_Data_Symmetrie.cpp @@ -1,1204 +1,1204 @@ /* * main.cpp * * Created on: 09.08.2018 * Author: edwin willegger, edwin.willegger@tuwien.ac.at * This file is used to generate output data from measurements * from Opel for SAVE project. * In this case the data of the entire time frame is analysed. * Based on the implementation of Maximilian Götzinger. * * WITH this main you can analyse data of all four GA and the Symmetrie column. */ - + #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; /* to switch between different file configurations change the * selected DEFINE in file_util.h * because the case of data analysis is selected in file_util.h * current available, Wr. Neustsadt, OMV, Opel * * One run for the entire Opel data set needs around 5 minutes. */ /********************************************************************************************************************** ************************************************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; /* * it is not possible to have inputs and outputs, because all data are mesaruements at the end * of the conrod line. * Workaround: All parameters are as inputs and outputs used. */ //names of the measured data const string FIRST_MEASURED_DATA_NAME = "GA_open_laengs"; //Input and Output const string SECOND_MEASURED_DATA_NAME = "GA_oben_quer"; //Input and Output const string THIRD_MEASURED_DATA_NAME = "GA_unten_laengs"; //Input and Output const string FOURTH_MEASURED_DATA_NAME = "GA_unten_quer"; //Input and Output const string FIFTH_MEASURED_DATA_NAME = "Symmetrie"; //Input and Output //viability monitor const string VIABILITY_MONITOR = "ViabilityMonitor"; //index number of output, only used for data aquisition from OMV //better implementation a const list, with the index of all outputs //and another list for all input indices. //const int INDEX_OUTPUT = 3; //name for the channels of the sensors and agents const string APPENDIX_FOR_CHANNEL_SENSOR_NAME = "(SA)"; const string FIRST_MEASURED_CHANNEL_SENSOR_NAME = FIRST_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_SENSOR_NAME; const string SECOND_MEASURED_CHANNEL_SENSOR_NAME = SECOND_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_SENSOR_NAME; const string THIRD_MEASURED_CHANNEL_SENSOR_NAME = THIRD_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_SENSOR_NAME; const string FOURTH_MEASURED_CHANNEL_SENSOR_NAME = FOURTH_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_SENSOR_NAME; const string FIFTH_MEASURED_CHANNEL_SENSOR_NAME = FIFTH_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_SENSOR_NAME; const string APPENDIX_FOR_CHANNEL_AGENT_NAME = "(AA-UP)"; const string FIRST_MEASURED_CHANNEL_AGENT_NAME = FIRST_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_AGENT_NAME; const string SECOND_MEASURED_CHANNEL_AGENT_NAME = SECOND_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_AGENT_NAME; const string THIRD_MEASURED_CHANNEL_AGENT_NAME = THIRD_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_AGENT_NAME; const string FOURTH_MEASURED_CHANNEL_AGENT_NAME = FOURTH_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_AGENT_NAME; const string FIFTH_MEASURED_CHANNEL_AGENT_NAME = FIFTH_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_AGENT_NAME; #define TRANSFER_RATE_CHANNEL_SENSOR 0 #define TRANSFER_RATE_CHANNEL_AGENT MAX_BUFFER_LENGTH ////////////////////////////////////////////// /* //out of the outer_bound the function is 0 or 1 and within 1 or 0 depending on function or complementery. inner_bound_xxx = /----------=1----|------=1---------\ = inner_bound_xxxx outer_bound_xxx = / | \ / | \ 0=__________/ | \ = outer_bound_xxxx ______ = 0 -------------------------------------------------------------------------- */ //parameters of boundary for similar function #define OUTTER_BOUND_SIM_DIF 0.20 //outer bound e. g. 0.14 = 14 percent; testested with 0.20, 0.14, 0.06, #define INNER_BOUND_SIM_DIF 0.01 //inner bound e. g. 0.01 = 1 percent //same way as above but shows drift. #define OUTTER_BOUND_DRIFT OUTTER_BOUND_SIM_DIF * 3 #define INNER_BOUND_DRIFT OUTTER_BOUND_SIM_DIF //timer sagt, dass nach dem DOWNSAMPLING der Ausgang bis zu //n Werte später sich ändern darf, nachdem Sich der Eingang geändert hat. #define BOUND_BROKEN 2 //length where fuzzy function raises from 0 to 1 or 1 to 0 for the complementery. //history of the data depends of it, and should change, if it changes. #define LENGTH 10//2//10 //definitions for the testbench const string TEST_BENCH = "testbench"; //defintions for the csv-reader-modules //every agent have a own-csv-reader const string APPENDIX_CSV_MODULES = " CSV-Reader"; const string FIRST_MEASURED_DATA_CSV_NAME = FILE_NAME_OF_ENTIRE_DATA + APPENDIX_CSV_MODULES; const string SECOND_MEASURED_DATA_CSV_NAME = FILE_NAME_OF_ENTIRE_DATA + APPENDIX_CSV_MODULES; const string THIRD_MEASURED_DATA_CSV_NAME = FILE_NAME_OF_ENTIRE_DATA + APPENDIX_CSV_MODULES; const string FOURTH_MEASURED_DATA_CSV_NAME = FILE_NAME_OF_ENTIRE_DATA + APPENDIX_CSV_MODULES; const string FIFTH_MEASURED_DATA_CSV_NAME = FILE_NAME_OF_ENTIRE_DATA + APPENDIX_CSV_MODULES; /********************************************************************************************************************** ************************************************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() { cout << "This program processes test data from Opel conrod production." << endl; create_and_register_All_Agents(); set_working_cycle_of_All_Agents(); create_and_register_All_Sensors(); set_working_cycle_of_All_Sensors(); create_and_register_channels(); mount_sensors_in_agents(); mount_agents_in_agents(); register_data_agents_in_agent_state_Handler(); create_linear_function_blocks(); mount_function_blocks_to_viability_monitor(); create_all_testbenches(); create_csvr_modules(); register_agents_in_testbenches(); register_sensors_in_testbenches(); register_channels_in_testbenches(); run_simulation_of_all_testbenches(); //close_file_pointers(); //TODO memory free of all objects. empty_static_vectors(); cout << "Program finished successfully" << endl; return 0; } void create_and_register_all_Testbench_Configs(Testbench* current_tb) { One_Config_t configuration; //setting of parameters, which will the same for all configurations configuration.bound_broken = 2; configuration.length = 10;//10; //the individual settings are set before a new Testbench_Config is created. configuration.inner_bound_sim_dif = 1 * 0.906241; configuration.outter_bound_sim_dif = 2 * configuration.inner_bound_sim_dif; configuration.outter_bound_drift = float(3) * configuration.outter_bound_sim_dif; configuration.inner_bound_drift = configuration.outter_bound_sim_dif; Testbench_Config* cfg = new Testbench_Config(configuration); /*configuration.inner_bound_sim_dif = 0.0005; configuration.outter_bound_sim_dif = 0.002; configuration.outter_bound_drift = float(3) * configuration.outter_bound_sim_dif; configuration.inner_bound_drift = configuration.outter_bound_sim_dif; Testbench_Config* cfg2 = new Testbench_Config(configuration); configuration.inner_bound_sim_dif = 0.002; configuration.outter_bound_sim_dif = 0.01; configuration.outter_bound_drift = float(3) * configuration.outter_bound_sim_dif; configuration.inner_bound_drift = configuration.outter_bound_sim_dif; Testbench_Config* cfg3 = new Testbench_Config(configuration); configuration.inner_bound_sim_dif = 0.005; configuration.outter_bound_sim_dif = 0.01; configuration.outter_bound_drift = float(3) * configuration.outter_bound_sim_dif; configuration.inner_bound_drift = configuration.outter_bound_sim_dif; Testbench_Config* cfg4 = new Testbench_Config(configuration); cfg->print(); cfg2->print(); cfg3->print(); cfg4->print(); */ current_tb->register_testbench_config(cfg); /* current_tb->register_testbench_config(cfg2); current_tb->register_testbench_config(cfg3); current_tb->register_testbench_config(cfg4); */ } /* * creates all the agents used in the measurement * and stores them into the global vector */ void create_and_register_All_Agents() { cout << "Creating Agents" << endl; char* c_name_of_current_agent = new char[MAX_LENGTH_NAME]; strcpy(c_name_of_current_agent, FIRST_MEASURED_DATA_NAME.c_str()); Agent* a_GA_oben_laengs = create_agent(c_name_of_current_agent); strcpy(c_name_of_current_agent, SECOND_MEASURED_DATA_NAME.c_str()); Agent* a_GA_oben_quer = create_agent(c_name_of_current_agent); strcpy(c_name_of_current_agent, THIRD_MEASURED_DATA_NAME.c_str()); Agent* a_GA_unten_laengs = create_agent(c_name_of_current_agent); strcpy(c_name_of_current_agent, FOURTH_MEASURED_DATA_NAME.c_str()); Agent* a_GA_unten_quer = create_agent(c_name_of_current_agent); strcpy(c_name_of_current_agent, FIFTH_MEASURED_DATA_NAME.c_str()); Agent* a_Symmetrie = create_agent(c_name_of_current_agent); strcpy(c_name_of_current_agent, VIABILITY_MONITOR.c_str()); Agent* a_viabilityMonitor = create_agent(c_name_of_current_agent); vec_of_Agents.push_back(a_GA_oben_laengs); vec_of_Agents.push_back(a_GA_oben_quer); vec_of_Agents.push_back(a_GA_unten_laengs); vec_of_Agents.push_back(a_GA_unten_quer); vec_of_Agents.push_back(a_Symmetrie); vec_of_Agents.push_back(a_viabilityMonitor); cout << vec_of_Agents.size() << " agents were created" << endl; delete c_name_of_current_agent; } /* * the working_cycle for all registered agents is set */ void set_working_cycle_of_All_Agents() { unsigned int working_Cyle = SAMPLING; unsigned int size_of_vec_of_Agents = 0; unsigned int index = 0; Agent* current_Agent; size_of_vec_of_Agents = vec_of_Agents.size(); for(index = 0; index < size_of_vec_of_Agents; index++) { current_Agent = vec_of_Agents[index]; setWorkingCycleOfAgent(current_Agent, working_Cyle); } } /* * all necessary sensors are created and registered */ void create_and_register_All_Sensors() { cout << "Creating Sensors" << endl; char* c_name_of_current_sensor = new char[MAX_LENGTH_NAME]; strcpy(c_name_of_current_sensor, FIRST_MEASURED_DATA_NAME.c_str()); Sensor* s_GA_oben_laengs = create_sensor(c_name_of_current_sensor); strcpy(c_name_of_current_sensor, SECOND_MEASURED_DATA_NAME.c_str()); Sensor* s_GA_oben_quer = create_sensor(c_name_of_current_sensor); strcpy(c_name_of_current_sensor, THIRD_MEASURED_DATA_NAME.c_str()); Sensor* s_GA_unten_laengs = create_sensor(c_name_of_current_sensor); strcpy(c_name_of_current_sensor, FOURTH_MEASURED_DATA_NAME.c_str()); Sensor* s_GA_unten_quer = create_sensor(c_name_of_current_sensor); strcpy(c_name_of_current_sensor, FIFTH_MEASURED_DATA_NAME.c_str()); Sensor* s_Symmetrie = create_sensor(c_name_of_current_sensor); vec_of_Sensors.push_back(s_GA_oben_laengs); vec_of_Sensors.push_back(s_GA_oben_quer); vec_of_Sensors.push_back(s_GA_unten_laengs); vec_of_Sensors.push_back(s_GA_unten_quer); vec_of_Sensors.push_back(s_Symmetrie); cout << vec_of_Sensors.size() << " sensors were created." << endl; delete c_name_of_current_sensor; } /* * working cycle of all registered sensors is set */ void set_working_cycle_of_All_Sensors() { unsigned int working_Cyle = SAMPLING; unsigned int size_of_vec_of_Sensors = 0; unsigned int index = 0; Sensor* current_Sensor; size_of_vec_of_Sensors = vec_of_Sensors.size(); for(index = 0; index < size_of_vec_of_Sensors; index++) { current_Sensor = vec_of_Sensors[index]; setWorkingCycleOfSensor(current_Sensor, working_Cyle); } } /* * creating and registering all channels */ void create_and_register_channels() { create_and_register_channels_for_sensors(); create_and_register_channels_for_agents(); } /* * creating and registering the channels for the sensors. */ void create_and_register_channels_for_sensors() { cout << "Creating and registering channels for sensors" << endl; char* c_name_of_current_channel = new char[MAX_LENGTH_NAME]; strcpy(c_name_of_current_channel, FIRST_MEASURED_CHANNEL_SENSOR_NAME.c_str()); Channel* c_sa_GA_oben_laengs = create_channel(c_name_of_current_channel, 0); strcpy(c_name_of_current_channel, SECOND_MEASURED_CHANNEL_SENSOR_NAME.c_str()); Channel* c_sa_GA_oben_quer = create_channel(c_name_of_current_channel, 0); strcpy(c_name_of_current_channel, THIRD_MEASURED_CHANNEL_SENSOR_NAME.c_str()); Channel* c_sa_GA_unten_laengs = create_channel(c_name_of_current_channel, 0); strcpy(c_name_of_current_channel, FOURTH_MEASURED_CHANNEL_SENSOR_NAME.c_str()); Channel* c_sa_GA_unten_quer = create_channel(c_name_of_current_channel, 0); strcpy(c_name_of_current_channel, FIFTH_MEASURED_CHANNEL_SENSOR_NAME.c_str()); Channel* c_sa_Symmetrie = create_channel(c_name_of_current_channel, 0); vec_of_Channels_for_Sensors.push_back(c_sa_GA_oben_laengs); vec_of_Channels_for_Sensors.push_back(c_sa_GA_oben_quer); vec_of_Channels_for_Sensors.push_back(c_sa_GA_unten_laengs); vec_of_Channels_for_Sensors.push_back(c_sa_GA_unten_quer); vec_of_Channels_for_Sensors.push_back(c_sa_Symmetrie); cout << vec_of_Channels_for_Sensors.size() << " channels for sensors were created" << endl; delete c_name_of_current_channel; } /* * creating and registering the channels for the agents */ void create_and_register_channels_for_agents() { cout << "Creating and registering channels for agents" << endl; char* c_name_of_current_channel = new char[MAX_LENGTH_NAME]; strcpy(c_name_of_current_channel, FIRST_MEASURED_CHANNEL_AGENT_NAME.c_str()); Channel* c_aa_GA_oben_laengs = create_channel(c_name_of_current_channel, 0); strcpy(c_name_of_current_channel, SECOND_MEASURED_CHANNEL_AGENT_NAME.c_str()); Channel* c_aa_GA_oben_quer = create_channel(c_name_of_current_channel, 0); strcpy(c_name_of_current_channel, THIRD_MEASURED_CHANNEL_AGENT_NAME.c_str()); Channel* c_aa_GA_unten_laengs = create_channel(c_name_of_current_channel, 0); strcpy(c_name_of_current_channel, FOURTH_MEASURED_CHANNEL_AGENT_NAME.c_str()); Channel* c_aa_GA_unten_quer = create_channel(c_name_of_current_channel, 0); strcpy(c_name_of_current_channel, FIFTH_MEASURED_CHANNEL_AGENT_NAME.c_str()); Channel* c_aa_Symmetrie = create_channel(c_name_of_current_channel, 0); vec_of_Channels_for_Agents.push_back(c_aa_GA_oben_laengs); vec_of_Channels_for_Agents.push_back(c_aa_GA_oben_quer); vec_of_Channels_for_Agents.push_back(c_aa_GA_unten_laengs); vec_of_Channels_for_Agents.push_back(c_aa_GA_unten_quer); vec_of_Channels_for_Agents.push_back(c_aa_Symmetrie); 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 postition 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]; registerSlaveAgentAsInputVariableInStateHandler(viability_Monitor, current_agent_channel); 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; //for entire data set offset has to be 1 int data_offset = -1; if (FILE_NAME_OF_ENTIRE_DATA == "Ga_all_Symmetrie_Combined_25000_to_30000.csv"){ data_offset = 2; } cout << "Creating CSV Reader Modules" << endl; current_reader_path_and_file_name = PATH_TO_CSV_DATA_FILES + PATH_TO_DATE_OF_MEASUREMENT + PATH_TO_AN_MEASURMENT + FILE_NAME_OF_ENTIRE_DATA; strcpy(c_name_of_current_csv_module, FIRST_MEASURED_DATA_CSV_NAME.c_str()); CSVreaderModule* csvr_GA_oben_laengs = create_CSVreaderModule(c_name_of_current_csv_module,current_reader_path_and_file_name.c_str(),1 + data_offset,row); current_reader_path_and_file_name = PATH_TO_CSV_DATA_FILES + PATH_TO_DATE_OF_MEASUREMENT + PATH_TO_AN_MEASURMENT + FILE_NAME_OF_ENTIRE_DATA; strcpy(c_name_of_current_csv_module, SECOND_MEASURED_DATA_CSV_NAME.c_str()); CSVreaderModule* csvr_GA_oben_quer = create_CSVreaderModule(c_name_of_current_csv_module,current_reader_path_and_file_name.c_str(),2 + data_offset,row); current_reader_path_and_file_name = PATH_TO_CSV_DATA_FILES + PATH_TO_DATE_OF_MEASUREMENT + PATH_TO_AN_MEASURMENT + FILE_NAME_OF_ENTIRE_DATA; strcpy(c_name_of_current_csv_module, THIRD_MEASURED_DATA_CSV_NAME.c_str()); CSVreaderModule* csvr_GA_unten_laengs = create_CSVreaderModule(c_name_of_current_csv_module,current_reader_path_and_file_name.c_str(),3 + data_offset,row); current_reader_path_and_file_name = PATH_TO_CSV_DATA_FILES + PATH_TO_DATE_OF_MEASUREMENT + PATH_TO_AN_MEASURMENT + FILE_NAME_OF_ENTIRE_DATA; strcpy(c_name_of_current_csv_module, FOURTH_MEASURED_DATA_CSV_NAME.c_str()); CSVreaderModule* csvr_GA_unten_quer = create_CSVreaderModule(c_name_of_current_csv_module,current_reader_path_and_file_name.c_str(),4 + data_offset,row); current_reader_path_and_file_name = PATH_TO_CSV_DATA_FILES + PATH_TO_DATE_OF_MEASUREMENT + PATH_TO_AN_MEASURMENT + FILE_NAME_OF_ENTIRE_DATA; strcpy(c_name_of_current_csv_module, FIFTH_MEASURED_DATA_CSV_NAME.c_str()); CSVreaderModule* csvr_Symmetrie = create_CSVreaderModule(c_name_of_current_csv_module,current_reader_path_and_file_name.c_str(),5 + data_offset,row); vec_of_csv_readers.push_back(csvr_GA_oben_laengs); vec_of_csv_readers.push_back(csvr_GA_oben_quer); vec_of_csv_readers.push_back(csvr_GA_unten_laengs); vec_of_csv_readers.push_back(csvr_GA_unten_quer); vec_of_csv_readers.push_back(csvr_Symmetrie); 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; //the number of rows which will be read in from the files. unsigned int sim_rounds = 0; const int start_row = 1; if(FILE_NAME_OF_ENTIRE_DATA == "Ga_all_Symmetrie_Combined_25000_to_30000.csv"){ sim_rounds = 5000; } 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(); }