diff --git a/Version_Max_07_05_2018_CMake/src/main.cpp b/Version_Max_07_05_2018_CMake/src/main.cpp index 9bdf415..f3045be 100755 --- a/Version_Max_07_05_2018_CMake/src/main.cpp +++ b/Version_Max_07_05_2018_CMake/src/main.cpp @@ -1,1128 +1,1128 @@ /* * 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 "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; //names of the measured data const string FIRST_MEASURED_DATA_NAME = "FC6504_Y"; //Input const string SECOND_MEASURED_DATA_NAME = "FC6504"; //Output const string THIRD_MEASURED_DATA_NAME = "FC6504_SP"; //Input const string FOURTH_MEASURED_DATA_NAME = "PI6584"; //Input //viability monitor const string VIABILITY_MONITOR = "ViabilityMonitor"; //index number of output const int INDEX_OUTPUT = 1; //name for the channels of the sensors and agents const string APPENDIX_FOR_CHANNEL_SENSOR_NAME = "(SA)"; const string FIRST_MEASURED_CHANNEL_SENSOR_NAME = FIRST_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_SENSOR_NAME; const string SECOND_MEASURED_CHANNEL_SENSOR_NAME = SECOND_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_SENSOR_NAME; const string THIRD_MEASURED_CHANNEL_SENSOR_NAME = THIRD_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_SENSOR_NAME; const string FOURTH_MEASURED_CHANNEL_SENSOR_NAME = FOURTH_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_SENSOR_NAME; const string APPENDIX_FOR_CHANNEL_AGENT_NAME = "(AA-UP)"; const string FIRST_MEASURED_CHANNEL_AGENT_NAME = FIRST_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_AGENT_NAME; const string SECOND_MEASURED_CHANNEL_AGENT_NAME = SECOND_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_AGENT_NAME; const string THIRD_MEASURED_CHANNEL_AGENT_NAME = THIRD_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_AGENT_NAME; const string FOURTH_MEASURED_CHANNEL_AGENT_NAME = FOURTH_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_AGENT_NAME; #define TRANSFER_RATE_CHANNEL_SENSOR 0 #define TRANSFER_RATE_CHANNEL_AGENT MAX_BUFFER_LENGTH ////////////////////////////////////////////// /* //out of the outer_bound the function is 0 or 1 and within 1 or 0 depending on function or complementery. inner_bound_xxx = /----------=1----|------=1---------\ = inner_bound_xxxx outer_bound_xxx = / | \ / | \ 0=__________/ | \ = outer_bound_xxxx ______ = 0 -------------------------------------------------------------------------- */ //parameters of boundary for similar function #define OUTTER_BOUND_SIM_DIF 0.20 //outer bound e. g. 0.14 = 14 percent; testested with 0.20, 0.14, 0.06, #define INNER_BOUND_SIM_DIF 0.01 //inner bound e. g. 0.01 = 1 percent //same way as above but shows drift. #define OUTTER_BOUND_DRIFT OUTTER_BOUND_SIM_DIF * 3 #define INNER_BOUND_DRIFT OUTTER_BOUND_SIM_DIF //timer sagt, dass nach dem DOWNSAMPLING der Ausgang bis zu //n Werte später sich ändern darf, nachdem Sich der Eingang geändert hat. #define BOUND_BROKEN 2 //length where fuzzy function raises from 0 to 1 or 1 to 0 for the complementery. //history of the data depends of it, and should change, if it changes. #define LENGTH 10 //definitions for the testbench const string TEST_BENCH = "testbench"; //defintions for the csv-reader-modules const string APPENDIX_CSV_MODULES = " CSV-Reader"; const string FIRST_MEASURED_DATA_CSV_NAME = FILE_NAME_OF_ENTIRE_DATA + APPENDIX_CSV_MODULES; const string SECOND_MEASURED_DATA_CSV_NAME = FILE_NAME_OF_ENTIRE_DATA + APPENDIX_CSV_MODULES; const string THIRD_MEASURED_DATA_CSV_NAME = FILE_NAME_OF_ENTIRE_DATA + APPENDIX_CSV_MODULES; const string FOURTH_MEASURED_DATA_CSV_NAME = FILE_NAME_OF_ENTIRE_DATA + APPENDIX_CSV_MODULES; //to switch between different file configurations change the //DEFINES in file_util.h /********************************************************************************************************************** ************************************************end of global definitions of variables and constants ***************** **********************************************************************************************************************/ /********************************************************************************************************************** ************************************************begin of function prototypes ***************************************** **********************************************************************************************************************/ void create_and_register_all_Testbench_Configs(Testbench* current_tb); void create_and_register_All_Agents(); void set_working_cycle_of_All_Agents(); void create_and_register_All_Sensors(); void set_working_cycle_of_All_Sensors(); void create_and_register_channels(); void create_and_register_channels_for_sensors(); void create_and_register_channels_for_agents(); void mount_sensors_in_agents(); void mount_agents_in_agents(); void register_data_agents_in_agent_state_Handler(); void create_linear_function_blocks(); void create_same_state_deviation_function_block(); void create_another_state_deviation_function_block(); void create_state_time_function_block(); void create_another_state_time_function_block(); void create_valid_state_deviation_function_block(); void create_invalid_state_deviation_function_block(); void create_valid_state_time_function_block(); void create_invalid_state_time_function_block(); void create_confidence_state_drift_function_block(); void create_confidence_broken_function_block(); void mount_function_blocks_to_viability_monitor(); void create_all_testbenches(); void create_csvr_modules(); void register_agents_in_testbenches(); void register_sensors_in_testbenches(); void register_channels_in_testbenches(); void register_channels_of_sensors_in_testbenches(); void register_channels_of_actors_in_testbenches(); void set_config_values_in_linear_functions(Testbench* current_tb); void set_parameters_LinearFunctionBlock(LinearFunctionBlock* cur_lin_func_block); void set_parameters_LinearFunction(vector 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 OMV Steam Cracker furnaces." << endl; create_and_register_All_Agents(); set_working_cycle_of_All_Agents(); create_and_register_All_Sensors(); set_working_cycle_of_All_Sensors(); create_and_register_channels(); mount_sensors_in_agents(); mount_agents_in_agents(); register_data_agents_in_agent_state_Handler(); create_linear_function_blocks(); mount_function_blocks_to_viability_monitor(); create_all_testbenches(); create_csvr_modules(); register_agents_in_testbenches(); register_sensors_in_testbenches(); register_channels_in_testbenches(); run_simulation_of_all_testbenches(); //close_file_pointers(); //TODO memory free of all objects. empty_static_vectors(); cout << "Program finished successfully" << endl; return 0; } void create_and_register_all_Testbench_Configs(Testbench* current_tb) { One_Config_t one; one.bound_broken = 2; one.inner_bound_sim_dif = 0.02; one.outter_bound_sim_dif = 0.08; one.inner_bound_drift = 3 * one.outter_bound_sim_dif; one.inner_bound_drift = one.outter_bound_sim_dif; one.length = 10; Testbench_Config* cfg = new Testbench_Config(one); cfg->print(); current_tb->register_testbench_config(cfg); } /* * creates all the agents used in the measurement * and stores them into the global vector */ void create_and_register_All_Agents() { cout << "Creating Agents" << endl; char* c_name_of_current_agent = new char[MAX_LENGTH_NAME]; strcpy(c_name_of_current_agent, FIRST_MEASURED_DATA_NAME.c_str()); Agent* a_FC6504_Y = create_agent(c_name_of_current_agent); strcpy(c_name_of_current_agent, SECOND_MEASURED_DATA_NAME.c_str()); Agent* a_FC6504 = create_agent(c_name_of_current_agent); strcpy(c_name_of_current_agent, THIRD_MEASURED_DATA_NAME.c_str()); Agent* a_FC6504_SP = create_agent(c_name_of_current_agent); strcpy(c_name_of_current_agent, FOURTH_MEASURED_DATA_NAME.c_str()); Agent* a_PI6584 = create_agent(c_name_of_current_agent); strcpy(c_name_of_current_agent, VIABILITY_MONITOR.c_str()); Agent* a_viabilityMonitor = create_agent(c_name_of_current_agent); vec_of_Agents.push_back(a_FC6504_Y); vec_of_Agents.push_back(a_FC6504); vec_of_Agents.push_back(a_FC6504_SP); vec_of_Agents.push_back(a_PI6584); vec_of_Agents.push_back(a_viabilityMonitor); cout << vec_of_Agents.size() << " agents were created" << endl; delete c_name_of_current_agent; } /* * the working_cycle for all registered agents is set */ void set_working_cycle_of_All_Agents() { unsigned int working_Cyle = SAMPLING; unsigned int size_of_vec_of_Agents = 0; unsigned int index = 0; Agent* current_Agent; size_of_vec_of_Agents = vec_of_Agents.size(); for(index = 0; index < size_of_vec_of_Agents; index++) { current_Agent = vec_of_Agents[index]; setWorkingCycleOfAgent(current_Agent, working_Cyle); } } /* * all necessary sensors are created and registered */ void create_and_register_All_Sensors() { cout << "Creating Sensors" << endl; char* c_name_of_current_sensor = new char[MAX_LENGTH_NAME]; strcpy(c_name_of_current_sensor, FIRST_MEASURED_DATA_NAME.c_str()); Sensor* s_FC6504_Y = create_sensor(c_name_of_current_sensor); strcpy(c_name_of_current_sensor, SECOND_MEASURED_DATA_NAME.c_str()); Sensor* s_FC6504 = create_sensor(c_name_of_current_sensor); strcpy(c_name_of_current_sensor, THIRD_MEASURED_DATA_NAME.c_str()); Sensor* s_FC6504_SP = create_sensor(c_name_of_current_sensor); strcpy(c_name_of_current_sensor, FOURTH_MEASURED_DATA_NAME.c_str()); Sensor* s_PI6584 = create_sensor(c_name_of_current_sensor); vec_of_Sensors.push_back(s_FC6504_Y); vec_of_Sensors.push_back(s_FC6504); vec_of_Sensors.push_back(s_FC6504_SP); vec_of_Sensors.push_back(s_PI6584); cout << vec_of_Sensors.size() << " sensors were created." << endl; delete c_name_of_current_sensor; } /* * working cycle of all registered sensors is set */ void set_working_cycle_of_All_Sensors() { unsigned int working_Cyle = SAMPLING; unsigned int size_of_vec_of_Sensors = 0; unsigned int index = 0; Sensor* current_Sensor; size_of_vec_of_Sensors = vec_of_Sensors.size(); for(index = 0; index < size_of_vec_of_Sensors; index++) { current_Sensor = vec_of_Sensors[index]; setWorkingCycleOfSensor(current_Sensor, working_Cyle); } } /* * creating and registering all channels */ void create_and_register_channels() { create_and_register_channels_for_sensors(); create_and_register_channels_for_agents(); } /* * creating and registering the channels for the sensors. */ void create_and_register_channels_for_sensors() { cout << "Creating and registering channels for sensors" << endl; char* c_name_of_current_channel = new char[MAX_LENGTH_NAME]; strcpy(c_name_of_current_channel, FIRST_MEASURED_CHANNEL_SENSOR_NAME.c_str()); Channel* c_sa_FC6504_Y = create_channel(c_name_of_current_channel, 0); strcpy(c_name_of_current_channel, SECOND_MEASURED_CHANNEL_SENSOR_NAME.c_str()); Channel* c_sa_FC6504 = create_channel(c_name_of_current_channel, 0); strcpy(c_name_of_current_channel, THIRD_MEASURED_CHANNEL_SENSOR_NAME.c_str()); Channel* c_sa_FC6504_SP = create_channel(c_name_of_current_channel, 0); strcpy(c_name_of_current_channel, FOURTH_MEASURED_CHANNEL_SENSOR_NAME.c_str()); Channel* c_sa_PI6584 = create_channel(c_name_of_current_channel, 0); vec_of_Channels_for_Sensors.push_back(c_sa_FC6504_Y); vec_of_Channels_for_Sensors.push_back(c_sa_FC6504); vec_of_Channels_for_Sensors.push_back(c_sa_FC6504_SP); vec_of_Channels_for_Sensors.push_back(c_sa_PI6584); cout << vec_of_Channels_for_Sensors.size() << " channels for sensors were created" << endl; delete c_name_of_current_channel; } /* * creating and registering the channels for the agents */ void create_and_register_channels_for_agents() { cout << "Creating and registering channels for agents" << endl; char* c_name_of_current_channel = new char[MAX_LENGTH_NAME]; strcpy(c_name_of_current_channel, FIRST_MEASURED_CHANNEL_AGENT_NAME.c_str()); - Channel* c_aa_FC6504_Y = create_channel(c_name_of_current_channel, 0); + Channel* c_aa_FC6504_Y = create_channel(c_name_of_current_channel, MAX_BUFFER_LENGTH); strcpy(c_name_of_current_channel, SECOND_MEASURED_CHANNEL_AGENT_NAME.c_str()); - Channel* c_aa_FC6504 = create_channel(c_name_of_current_channel, 0); + Channel* c_aa_FC6504 = create_channel(c_name_of_current_channel, MAX_BUFFER_LENGTH); strcpy(c_name_of_current_channel, THIRD_MEASURED_CHANNEL_AGENT_NAME.c_str()); - Channel* c_aa_FC6504_SP = create_channel(c_name_of_current_channel, 0); + Channel* c_aa_FC6504_SP = create_channel(c_name_of_current_channel, MAX_BUFFER_LENGTH); strcpy(c_name_of_current_channel, FOURTH_MEASURED_CHANNEL_AGENT_NAME.c_str()); - Channel* c_aa_PI6584 = create_channel(c_name_of_current_channel, 0); + Channel* c_aa_PI6584 = create_channel(c_name_of_current_channel, MAX_BUFFER_LENGTH); vec_of_Channels_for_Agents.push_back(c_aa_FC6504_Y); vec_of_Channels_for_Agents.push_back(c_aa_FC6504); vec_of_Channels_for_Agents.push_back(c_aa_FC6504_SP); vec_of_Channels_for_Agents.push_back(c_aa_PI6584); cout << vec_of_Channels_for_Agents.size() << " channels for agents were created" << endl; delete c_name_of_current_channel; } void mount_sensors_in_agents() { Agent* current_agent; Sensor* current_sensor; Channel* current_sensor_channel; unsigned int size_of_vec_sensor = 0; unsigned int index = 0; size_of_vec_sensor = vec_of_Sensors.size(); cout << "mounting sensors in agents." << endl; //it is assumed that the corresponding sensors and agents and channels are always at the same //position in the different vectors, if not then you have to add an search algorithm for it. for(index = 0; index < size_of_vec_sensor; index++) { current_agent = vec_of_Agents[index]; current_sensor = vec_of_Sensors[index]; current_sensor_channel = vec_of_Channels_for_Sensors[index]; mount_sensorInAgent(current_agent, current_sensor, current_sensor_channel); } cout << size_of_vec_sensor << " sensors in agents were mounted" << endl; } void mount_agents_in_agents() { Agent* current_agent; Agent* viability_Monitor; Channel* current_agent_channel; unsigned int size_of_vec_agents = 0; unsigned int index = 0; size_of_vec_agents = vec_of_Agents.size(); //it is assumed that the viability agent is at the last position in the vector viability_Monitor = vec_of_Agents[size_of_vec_agents-1]; //all agents and channels are registered to the viabilityMonitor agent //so you have to subtract the viabilityMonitor from the number of elements to register //it is assumed that all the corresponding channels and agents are placed at the same index for(index = 0; index < size_of_vec_agents -1; index++) { current_agent = vec_of_Agents[index]; current_agent_channel = vec_of_Channels_for_Agents[index]; //only register if the agent is not the viability_monitor, otherwise you would register the viability monitor to itself. if(current_agent != viability_Monitor) { mount_agentInAgent(viability_Monitor, current_agent, current_agent_channel); } } cout << size_of_vec_agents -1 << "agents were registered to the viability monitor" << endl; } /* * registers the channels for the data agents to the viability monitor */ void register_data_agents_in_agent_state_Handler() { Agent* viability_Monitor; Channel* current_agent_channel; unsigned int size_of_vec_channel_agents = 0; unsigned int index = 0; size_of_vec_channel_agents = vec_of_Channels_for_Agents.size(); //get the agent for the viabilityMonitor, it is assumed that it is at the last position viability_Monitor = vec_of_Agents[vec_of_Agents.size()-1]; //register all the channels to the viability monitor for(index = 0; index < size_of_vec_channel_agents; index++) { current_agent_channel = vec_of_Channels_for_Agents[index]; if(index != INDEX_OUTPUT) { registerSlaveAgentAsInputVariableInStateHandler(viability_Monitor, current_agent_channel); } else{ registerSlaveAgentAsOutputVariableInStateHandler(viability_Monitor, current_agent_channel); } } } /* * creates and register all the different linear function blocks */ void create_linear_function_blocks() { //don't change the sequence, because later it is assumed that the functions are //registered int the vector in this sequence //if you change it you have also to change the sequence in the function mount_function_blocks_to_viability_monitor create_same_state_deviation_function_block(); create_another_state_deviation_function_block(); create_state_time_function_block(); create_another_state_time_function_block(); create_valid_state_deviation_function_block(); create_invalid_state_deviation_function_block(); create_valid_state_time_function_block(); create_invalid_state_time_function_block(); create_confidence_state_drift_function_block(); create_confidence_broken_function_block(); } /* * creates and register the linear function block for same state deviation */ void create_same_state_deviation_function_block() { char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_SAME_STATE_DEV.c_str()); LinearFunctionBlock* confSim2StateDev = new LinearFunctionBlock(c_name_of_current_func_block); LinearFunction* funcConfSim2StateDev1 = new LinearFunction(CONF_SIM2_STATE_DEV_1); funcConfSim2StateDev1->setDomain(false, true, (float)-OUTTER_BOUND_SIM_DIF); funcConfSim2StateDev1->setKandD((float)0, (float)0); confSim2StateDev->addLinearFunction(funcConfSim2StateDev1); LinearFunction* funcConfSim2StateDev2 = new LinearFunction(CONF_SIM2_STATE_DEV_2); funcConfSim2StateDev2->setDomain(true, (float)-OUTTER_BOUND_SIM_DIF, true, (float)-INNER_BOUND_SIM_DIF); funcConfSim2StateDev2->setKandD((float)-OUTTER_BOUND_SIM_DIF, (float)0, (float)-INNER_BOUND_SIM_DIF, (float)1); confSim2StateDev->addLinearFunction(funcConfSim2StateDev2); LinearFunction* funcConfSim2StateDev3 = new LinearFunction(CONF_SIM2_STATE_DEV_3); funcConfSim2StateDev3->setDomain(true, (float)-INNER_BOUND_SIM_DIF, true, (float)INNER_BOUND_SIM_DIF); funcConfSim2StateDev3->setKandD((float)0, (float)1); confSim2StateDev->addLinearFunction(funcConfSim2StateDev3); LinearFunction* funcConfSim2StateDev4 = new LinearFunction(CONF_SIM2_STATE_DEV_4); funcConfSim2StateDev4->setDomain(true, (float)INNER_BOUND_SIM_DIF, true, (float)OUTTER_BOUND_SIM_DIF); funcConfSim2StateDev4->setKandD((float)INNER_BOUND_SIM_DIF, (float)1, (float)OUTTER_BOUND_SIM_DIF, (float)0); confSim2StateDev->addLinearFunction(funcConfSim2StateDev4); LinearFunction* funcConfSim2StateDev5 = new LinearFunction(CONF_SIM2_STATE_DEV_5); funcConfSim2StateDev5->setDomain(true, (float)OUTTER_BOUND_SIM_DIF, false); funcConfSim2StateDev5->setKandD((float)0, (float)0); confSim2StateDev->addLinearFunction(funcConfSim2StateDev5); vec_of_linear_Function_Blocks.push_back(confSim2StateDev); delete c_name_of_current_func_block; } /* * creates and register another state deviation function block */ void create_another_state_deviation_function_block() { char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_ANOTHER_STATE_DEV.c_str()); LinearFunctionBlock* confDif2StateDev = new LinearFunctionBlock(c_name_of_current_func_block); LinearFunction* funcConfDif2StateDev1 = new LinearFunction(CONF_DIF2_STATE_DEV_1); funcConfDif2StateDev1->setDomain(false, true, (float)-OUTTER_BOUND_SIM_DIF); funcConfDif2StateDev1->setKandD((float)0, (float)1); confDif2StateDev->addLinearFunction(funcConfDif2StateDev1); LinearFunction* funcConfDif2StateDev2 = new LinearFunction(CONF_DIF2_STATE_DEV_2); funcConfDif2StateDev2->setDomain(true, (float)-OUTTER_BOUND_SIM_DIF, true, (float)-INNER_BOUND_SIM_DIF); funcConfDif2StateDev2->setKandD((float)-OUTTER_BOUND_SIM_DIF, (float)1, (float)-INNER_BOUND_SIM_DIF, (float)0); confDif2StateDev->addLinearFunction(funcConfDif2StateDev2); LinearFunction* funcConfDif2StateDev3 = new LinearFunction(CONF_DIF2_STATE_DEV_3); funcConfDif2StateDev3->setDomain(true, (float)-INNER_BOUND_SIM_DIF, true, (float)INNER_BOUND_SIM_DIF); funcConfDif2StateDev3->setKandD((float)0, (float)0); confDif2StateDev->addLinearFunction(funcConfDif2StateDev3); LinearFunction* funcConfDif2StateDev4 = new LinearFunction(CONF_DIF2_STATE_DEV_4); funcConfDif2StateDev4->setDomain(true, (float)INNER_BOUND_SIM_DIF, true, (float)OUTTER_BOUND_SIM_DIF); funcConfDif2StateDev4->setKandD((float)INNER_BOUND_SIM_DIF, (float)0, (float)OUTTER_BOUND_SIM_DIF, (float)1); confDif2StateDev->addLinearFunction(funcConfDif2StateDev4); LinearFunction* funcConfDif2StateDev5 = new LinearFunction(CONF_DIF2_STATE_DEV_5); funcConfDif2StateDev5->setDomain(true, (float)OUTTER_BOUND_SIM_DIF, false); funcConfDif2StateDev5->setKandD((float)0, (float)1); confDif2StateDev->addLinearFunction(funcConfDif2StateDev5); vec_of_linear_Function_Blocks.push_back(confDif2StateDev); delete c_name_of_current_func_block; } void create_state_time_function_block() { char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_SAME_TIME.c_str()); LinearFunctionBlock* confSim2StateTime = new LinearFunctionBlock(c_name_of_current_func_block); LinearFunction* funcConfSim2StateTime1 = new LinearFunction(CONF_SIM2_STATE_TIME_1); funcConfSim2StateTime1->setDomain(false, true, (float)0); funcConfSim2StateTime1->setKandD((float)0, (float)0); confSim2StateTime->addLinearFunction(funcConfSim2StateTime1); LinearFunction* funcConfSim2StateTime2 = new LinearFunction(CONF_SIM2_STATE_TIME_2); funcConfSim2StateTime2->setDomain(true, (float)0, true, (float)LENGTH); funcConfSim2StateTime2->setKandD((float)0, (float)0, (float)LENGTH, (float)1); confSim2StateTime->addLinearFunction(funcConfSim2StateTime2); LinearFunction* funcConfSim2StateTime3 = new LinearFunction(CONF_SIM2_STATE_TIME_3); funcConfSim2StateTime3->setDomain(true, (float)LENGTH, false); funcConfSim2StateTime3->setKandD((float)0, (float)1); confSim2StateTime->addLinearFunction(funcConfSim2StateTime3); vec_of_linear_Function_Blocks.push_back(confSim2StateTime); delete c_name_of_current_func_block; } void create_another_state_time_function_block() { char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_ANOTHER_STATE_TIME.c_str()); LinearFunctionBlock* confDif2StateTime = new LinearFunctionBlock(c_name_of_current_func_block); LinearFunction* funcConfDif2StateTime1 = new LinearFunction(CONF_DIF2_STATE_TIME_1); funcConfDif2StateTime1->setDomain(false, true, (float)0); funcConfDif2StateTime1->setKandD((float)0, (float)1); confDif2StateTime->addLinearFunction(funcConfDif2StateTime1); LinearFunction* funcConfDif2StateTime2 = new LinearFunction(CONF_DIF2_STATE_TIME_2); funcConfDif2StateTime2->setDomain(true, (float)0, true, (float)LENGTH); funcConfDif2StateTime2->setKandD((float)0, (float)1, (float)LENGTH, (float)0); confDif2StateTime->addLinearFunction(funcConfDif2StateTime2); LinearFunction* funcConfDif2StateTime3 = new LinearFunction(CONF_DIF2_STATE_TIME_3); funcConfDif2StateTime3->setDomain(true, (float)LENGTH, false); funcConfDif2StateTime3->setKandD((float)0, (float)0); confDif2StateTime->addLinearFunction(funcConfDif2StateTime3); vec_of_linear_Function_Blocks.push_back(confDif2StateTime); delete c_name_of_current_func_block; } void create_valid_state_deviation_function_block() { char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_VAILD_STATE_DEV.c_str()); LinearFunctionBlock* confValidStateDev = new LinearFunctionBlock(c_name_of_current_func_block); LinearFunction* funcConfValidStateDev1 = new LinearFunction(CONF_VALID_STATE_DEV_1); funcConfValidStateDev1->setDomain(false, true, (float)-OUTTER_BOUND_SIM_DIF); funcConfValidStateDev1->setKandD((float)0, (float)0); confValidStateDev->addLinearFunction(funcConfValidStateDev1); LinearFunction* funcConfValidStateDev2 = new LinearFunction(CONF_VALID_STATE_DEV_2); funcConfValidStateDev2->setDomain(true, (float)-OUTTER_BOUND_SIM_DIF, true, (float)-INNER_BOUND_SIM_DIF); funcConfValidStateDev2->setKandD((float)-OUTTER_BOUND_SIM_DIF, (float)0, (float)-INNER_BOUND_SIM_DIF, (float)1); confValidStateDev->addLinearFunction(funcConfValidStateDev2); LinearFunction* funcConfValidStateDev3 = new LinearFunction(CONF_VALID_STATE_DEV_3); funcConfValidStateDev3->setDomain(true, (float)-INNER_BOUND_SIM_DIF, true, (float)INNER_BOUND_SIM_DIF); funcConfValidStateDev3->setKandD((float)0, (float)1); confValidStateDev->addLinearFunction(funcConfValidStateDev3); LinearFunction* funcConfValidStateDev4 = new LinearFunction(CONF_VALID_STATE_DEV_4); funcConfValidStateDev4->setDomain(true, (float)INNER_BOUND_SIM_DIF, true, (float)OUTTER_BOUND_SIM_DIF); funcConfValidStateDev4->setKandD((float)INNER_BOUND_SIM_DIF, (float)1, (float)OUTTER_BOUND_SIM_DIF, (float)0); confValidStateDev->addLinearFunction(funcConfValidStateDev4); LinearFunction* funcConfValidStateDev5 = new LinearFunction(CONF_VALID_STATE_DEV_5); funcConfValidStateDev5->setDomain(true, (float)OUTTER_BOUND_SIM_DIF, false); funcConfValidStateDev5->setKandD((float)0, (float)0); confValidStateDev->addLinearFunction(funcConfValidStateDev5); vec_of_linear_Function_Blocks.push_back(confValidStateDev); delete c_name_of_current_func_block; } void create_invalid_state_deviation_function_block() { char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_INVALID_STATE_DEV.c_str()); LinearFunctionBlock* confInvalidStateDev = new LinearFunctionBlock(c_name_of_current_func_block); LinearFunction* funcConfInvalidStateDev1 = new LinearFunction(CONF_INVALID_STATE_DEV_1); funcConfInvalidStateDev1->setDomain(false, true, (float)-OUTTER_BOUND_SIM_DIF); funcConfInvalidStateDev1->setKandD((float)0, (float)1); confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev1); LinearFunction* funcConfInvalidStateDev2 = new LinearFunction(CONF_INVALID_STATE_DEV_2); funcConfInvalidStateDev2->setDomain(true, (float)-OUTTER_BOUND_SIM_DIF, true, (float)-INNER_BOUND_SIM_DIF); funcConfInvalidStateDev2->setKandD((float)-OUTTER_BOUND_SIM_DIF, (float)1, (float)-INNER_BOUND_SIM_DIF, (float)0); confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev2); LinearFunction* funcConfInvalidStateDev3 = new LinearFunction(CONF_INVALID_STATE_DEV_3); funcConfInvalidStateDev3->setDomain(true, (float)-INNER_BOUND_SIM_DIF, true, (float)INNER_BOUND_SIM_DIF); funcConfInvalidStateDev3->setKandD((float)0, (float)0); confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev3); LinearFunction* funcConfInvalidStateDev4 = new LinearFunction(CONF_INVALID_STATE_DEV_4); funcConfInvalidStateDev4->setDomain(true, (float)INNER_BOUND_SIM_DIF, true, (float)OUTTER_BOUND_SIM_DIF); funcConfInvalidStateDev4->setKandD((float)INNER_BOUND_SIM_DIF, (float)0, (float)OUTTER_BOUND_SIM_DIF, (float)1); confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev4); LinearFunction* funcConfInvalidStateDev5 = new LinearFunction(CONF_INVALID_STATE_DEV_5); funcConfInvalidStateDev5->setDomain(true, (float)OUTTER_BOUND_SIM_DIF, false); funcConfInvalidStateDev5->setKandD((float)0, (float)1); confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev5); vec_of_linear_Function_Blocks.push_back(confInvalidStateDev); delete c_name_of_current_func_block; } void create_valid_state_time_function_block() { char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_VALID_STATE_TIME.c_str()); LinearFunctionBlock* confValidStateTime = new LinearFunctionBlock(c_name_of_current_func_block); LinearFunction* funcConfValidStateTime1 = new LinearFunction(VALID_STATE_TIME_1); funcConfValidStateTime1->setDomain(false, true, (float)0); funcConfValidStateTime1->setKandD((float)0, (float)0); confValidStateTime->addLinearFunction(funcConfValidStateTime1); LinearFunction* funcConfValidStateTime2 = new LinearFunction(VALID_STATE_TIME_2); funcConfValidStateTime2->setDomain(true, (float)0, true, (float)LENGTH); //10 funcConfValidStateTime2->setKandD((float)0, (float)0, (float)LENGTH, (float)1); confValidStateTime->addLinearFunction(funcConfValidStateTime2); LinearFunction* funcConfValidStateTime3 = new LinearFunction(VALID_STATE_TIME_3); funcConfValidStateTime3->setDomain(true, (float)LENGTH, false); funcConfValidStateTime3->setKandD((float)0, (float)1); confValidStateTime->addLinearFunction(funcConfValidStateTime3); vec_of_linear_Function_Blocks.push_back(confValidStateTime); delete c_name_of_current_func_block; } void create_invalid_state_time_function_block() { char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_INVALID_STATE_TIME.c_str()); LinearFunctionBlock* confInvalidStateTime = new LinearFunctionBlock(c_name_of_current_func_block); LinearFunction* funcConfInvalidStateTime1 = new LinearFunction(INVALID_STATE_TIME_1); funcConfInvalidStateTime1->setDomain(false, true, (float)0); funcConfInvalidStateTime1->setKandD((float)0, (float)1); confInvalidStateTime->addLinearFunction(funcConfInvalidStateTime1); LinearFunction* funcConfInvalidStateTime2 = new LinearFunction(INVALID_STATE_TIME_2); funcConfInvalidStateTime2->setDomain(true, (float)0, true, (float)LENGTH); funcConfInvalidStateTime2->setKandD((float)0, (float)1, (float)LENGTH, (float)0); confInvalidStateTime->addLinearFunction(funcConfInvalidStateTime2); LinearFunction* funcConfInvalidStateTime3 = new LinearFunction(INVALID_STATE_TIME_3); funcConfInvalidStateTime3->setDomain(true, (float)LENGTH, false); funcConfInvalidStateTime3->setKandD((float)0, (float)0); confInvalidStateTime->addLinearFunction(funcConfInvalidStateTime3); vec_of_linear_Function_Blocks.push_back(confInvalidStateTime); delete c_name_of_current_func_block; } void create_confidence_state_drift_function_block() { char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_CONFIDENCE_STATE_DRIFTS.c_str()); LinearFunctionBlock* confStateDrifts = new LinearFunctionBlock(c_name_of_current_func_block); LinearFunction* functionConfidenceDriftDeviation1 = new LinearFunction(CONFIDENCE_DRIFT_DEVIATION_1); functionConfidenceDriftDeviation1->setDomain(false, true, (float)-OUTTER_BOUND_DRIFT); functionConfidenceDriftDeviation1->setKandD((float)0, (float)1); confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation1); LinearFunction* functionConfidenceDriftDeviation2 = new LinearFunction(CONFIDENCE_DRIFT_DEVIATION_2); functionConfidenceDriftDeviation2->setDomain(true, (float)-OUTTER_BOUND_DRIFT, true, (float)-INNER_BOUND_DRIFT); functionConfidenceDriftDeviation2->setKandD((float)-INNER_BOUND_DRIFT, (float)1, (float)-INNER_BOUND_DRIFT, (float)0); confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation2); LinearFunction* functionConfidenceDriftDeviation3 = new LinearFunction(CONFIDENCE_DRIFT_DEVIATION_3); functionConfidenceDriftDeviation3->setDomain(true, (float)-INNER_BOUND_DRIFT, true, (float)INNER_BOUND_DRIFT); functionConfidenceDriftDeviation3->setKandD((float)0, (float)0); confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation3); LinearFunction* functionConfidenceDriftDeviation4 = new LinearFunction(CONFIDENCE_DRIFT_DEVIATION_4); functionConfidenceDriftDeviation4->setDomain(true, (float)INNER_BOUND_DRIFT, true, (float)OUTTER_BOUND_DRIFT); functionConfidenceDriftDeviation4->setKandD((float)INNER_BOUND_DRIFT, (float)0, (float)OUTTER_BOUND_DRIFT, (float)1); confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation4); LinearFunction* functionConfidenceDriftDeviation5 = new LinearFunction(CONFIDENCE_DRIFT_DEVIATION_5); functionConfidenceDriftDeviation5->setDomain(true, (float)OUTTER_BOUND_DRIFT, false); functionConfidenceDriftDeviation5->setKandD((float)0, (float)1); confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation5); vec_of_linear_Function_Blocks.push_back(confStateDrifts); delete c_name_of_current_func_block; } void create_confidence_broken_function_block() { char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_CONFIDENCE_BROKEN.c_str()); LinearFunctionBlock* confBroken = new LinearFunctionBlock(c_name_of_current_func_block); LinearFunction* functionConfidenceBroken1 = new LinearFunction(CONFIDENCE_BROKEN_1); functionConfidenceBroken1->setDomain(false, true, (float)0); functionConfidenceBroken1->setKandD((float)0, (float)0); confBroken->addLinearFunction(functionConfidenceBroken1); LinearFunction* functionConfidenceBroken2 = new LinearFunction(CONFIDENCE_BROKEN_2); functionConfidenceBroken2->setDomain(true, (float)0, true, (float)BOUND_BROKEN); functionConfidenceBroken2->setKandD((float)0, (float)0, (float)BOUND_BROKEN, (float)1); confBroken->addLinearFunction(functionConfidenceBroken2); LinearFunction* functionConfidenceBroken3 = new LinearFunction(CONFIDENCE_BROKEN_3); functionConfidenceBroken3->setDomain(true, (float)BOUND_BROKEN, false); functionConfidenceBroken3->setKandD((float)0, (float)1); confBroken->addLinearFunction(functionConfidenceBroken3); vec_of_linear_Function_Blocks.push_back(confBroken); delete c_name_of_current_func_block; } /* * mount the different function blocks to the viability monitor agent */ void mount_function_blocks_to_viability_monitor() { Agent* viability_Monitor; LinearFunctionBlock* current_Linear_Function_Bock; unsigned int size_of_vec_lin_func_block = vec_of_linear_Function_Blocks.size(); unsigned int index = 0; //it is assumed that the viability monitor is at the last position of the vector of agents viability_Monitor = vec_of_Agents[vec_of_Agents.size()-1]; for(index = 0; index < size_of_vec_lin_func_block; index++) { current_Linear_Function_Bock = vec_of_linear_Function_Blocks[index]; //it is assumed that the function blocks are added into the vector in the following sequence switch(index) { case 0: viability_Monitor->get_stateHandler()->FuncBlockConfSim2StateDev = current_Linear_Function_Bock; break; case 1: viability_Monitor->get_stateHandler()->FuncBlockConfDif2StateDev = current_Linear_Function_Bock; break; case 2: viability_Monitor->get_stateHandler()->FuncBlockConfSim2StateTime = current_Linear_Function_Bock; break; case 3: viability_Monitor->get_stateHandler()->FuncBlockConfDif2StateTime = current_Linear_Function_Bock; break; case 4: viability_Monitor->get_stateHandler()->FuncBlockConfValStateDev = current_Linear_Function_Bock; break; case 5: viability_Monitor->get_stateHandler()->FuncBlockConfInvStateDev = current_Linear_Function_Bock; break; case 6: viability_Monitor->get_stateHandler()->FuncBlockConfValStateTime = current_Linear_Function_Bock; break; case 7: viability_Monitor->get_stateHandler()->FuncBlockConfInvStateTime = current_Linear_Function_Bock; break; case 8: viability_Monitor->get_stateHandler()->DriftDeviation = current_Linear_Function_Bock; break; case 9: viability_Monitor->get_stateHandler()->FuncBlockConfBrokenSamples = current_Linear_Function_Bock; break; } } } void create_all_testbenches() { char* c_name_of_current_testbench = new char[MAX_LENGTH_NAME]; strcpy(c_name_of_current_testbench, TEST_BENCH.c_str()); cout << "Creating test bench" << endl; Testbench* tb = create_testbench(c_name_of_current_testbench); create_and_register_all_Testbench_Configs(tb); vec_of_test_benches.push_back(tb); delete c_name_of_current_testbench; } void create_csvr_modules() { //sets the row in which the data starts, maybe row one contains the headers unsigned int row = 2; char* c_name_of_current_csv_module = new char[MAX_LENGTH_NAME]; string current_reader_path_and_file_name; cout << "Creating CSV Reader Modules" << endl; current_reader_path_and_file_name = PATH_TO_CSV_DATA_FILES + PATH_TO_DATE_OF_MEASUREMENT + PATH_TO_AN_MEASURMENT + FILE_NAME_OF_ENTIRE_DATA; strcpy(c_name_of_current_csv_module, FIRST_MEASURED_DATA_CSV_NAME.c_str()); CSVreaderModule* csvr_FC6504_Y = create_CSVreaderModule(c_name_of_current_csv_module,current_reader_path_and_file_name.c_str(),3,row); current_reader_path_and_file_name = PATH_TO_CSV_DATA_FILES + PATH_TO_DATE_OF_MEASUREMENT + PATH_TO_AN_MEASURMENT + FILE_NAME_OF_ENTIRE_DATA; strcpy(c_name_of_current_csv_module, SECOND_MEASURED_DATA_CSV_NAME.c_str()); CSVreaderModule* csvr_FC6504 = create_CSVreaderModule(c_name_of_current_csv_module,current_reader_path_and_file_name.c_str(),4,row); current_reader_path_and_file_name = PATH_TO_CSV_DATA_FILES + PATH_TO_DATE_OF_MEASUREMENT + PATH_TO_AN_MEASURMENT + FILE_NAME_OF_ENTIRE_DATA; strcpy(c_name_of_current_csv_module, THIRD_MEASURED_DATA_CSV_NAME.c_str()); CSVreaderModule* csvr_FC6504_SP = create_CSVreaderModule(c_name_of_current_csv_module,current_reader_path_and_file_name.c_str(),5,row); current_reader_path_and_file_name = PATH_TO_CSV_DATA_FILES + PATH_TO_DATE_OF_MEASUREMENT + PATH_TO_AN_MEASURMENT + FILE_NAME_OF_ENTIRE_DATA; strcpy(c_name_of_current_csv_module, FOURTH_MEASURED_DATA_CSV_NAME.c_str()); CSVreaderModule* csvr_PI6584 = create_CSVreaderModule(c_name_of_current_csv_module,current_reader_path_and_file_name.c_str(),6,row); vec_of_csv_readers.push_back(csvr_FC6504_Y); vec_of_csv_readers.push_back(csvr_FC6504); vec_of_csv_readers.push_back(csvr_FC6504_SP); vec_of_csv_readers.push_back(csvr_PI6584); delete c_name_of_current_csv_module; } /* * all agents would be registered to all testbenches */ void register_agents_in_testbenches() { Testbench* current_tb; unsigned int size_of_vec_test_benches = vec_of_test_benches.size(); unsigned int index_tb = 0; Agent* current_ag; unsigned int size_of_vec_agents = vec_of_Agents.size(); unsigned int index_agents = 0; cout << "registering agents in testbenches" << endl; for(index_tb = 0; index_tb < size_of_vec_test_benches; index_tb++) { current_tb = vec_of_test_benches[index_tb]; for(index_agents = 0; index_agents < size_of_vec_agents; index_agents++) { current_ag = vec_of_Agents[index_agents]; register_agentInTestbench(current_tb, current_ag); } } cout << size_of_vec_agents << " agents were registered in every of the " << size_of_vec_test_benches << " testbenches" << endl; } /* * registering the sensors and the corresponding csv-readers in the testbenches * it is assumed that the csv readers and the sensors are at the same index position * in the vectors. */ void register_sensors_in_testbenches() { Testbench* current_tb; unsigned int size_of_vec_test_benches = vec_of_test_benches.size(); unsigned int index_tb = 0; Sensor* current_se; unsigned int size_of_vec_sensors = vec_of_Sensors.size(); unsigned int index_sensors = 0; CSVreaderModule* current_csv_reader; unsigned int size_of_vec_csv_reader = vec_of_csv_readers.size(); if(size_of_vec_csv_reader != size_of_vec_sensors) { cout << "Error, in sequence of data processing"; cout << "Number of csv-readers should be equal to number of sensors" << endl; } else { cout << "Registering sensors and their csv-readers in testbenches " << endl; for(index_tb = 0; index_tb < size_of_vec_test_benches; index_tb++) { current_tb = vec_of_test_benches[index_tb]; for(index_sensors = 0; index_sensors < size_of_vec_sensors; index_sensors++) { current_se = vec_of_Sensors[index_sensors]; //it is assumed that the sensor and the corresponding csv-reader is stored //at the same position in the two different vectors current_csv_reader = vec_of_csv_readers[index_sensors]; register_sensorInTestbench(current_tb, current_se, current_csv_reader); } } cout << size_of_vec_sensors << " Sensors and their csv-readers were registered to "; cout << "every of the " << size_of_vec_test_benches << " testbenches" << endl; } } void register_channels_in_testbenches() { register_channels_of_sensors_in_testbenches(); register_channels_of_actors_in_testbenches(); } void register_channels_of_sensors_in_testbenches() { Testbench* current_tb; unsigned int size_of_vec_test_benches = vec_of_test_benches.size(); unsigned int index_tb = 0; Channel* current_se_ch; unsigned int size_of_vec_se_channel = vec_of_Channels_for_Sensors.size(); unsigned int index_se_ch = 0; cout << "Registering channels of sensors in testbench" << endl; for(index_tb = 0; index_tb < size_of_vec_test_benches; index_tb++) { current_tb = vec_of_test_benches[index_tb]; for(index_se_ch = 0; index_se_ch < size_of_vec_se_channel; index_se_ch++) { current_se_ch = vec_of_Channels_for_Sensors[index_se_ch]; register_channelInTestbench(current_tb, current_se_ch); } } cout << size_of_vec_se_channel << " channels of sensors were registered in "; cout << size_of_vec_test_benches << " testbenches." << endl; } void register_channels_of_actors_in_testbenches() { Testbench* current_tb; unsigned int size_of_vec_test_benches = vec_of_test_benches.size(); unsigned int index_tb = 0; Channel* current_se_ch; unsigned int size_of_vec_ag_channel = vec_of_Channels_for_Agents.size(); unsigned int index_se_ch = 0; cout << "Registering channels of agents in testbench" << endl; for(index_tb = 0; index_tb < size_of_vec_test_benches; index_tb++) { current_tb = vec_of_test_benches[index_tb]; for(index_se_ch = 0; index_se_ch < size_of_vec_ag_channel; index_se_ch++) { current_se_ch = vec_of_Channels_for_Agents[index_se_ch]; register_channelInTestbench(current_tb, current_se_ch); } } cout << size_of_vec_ag_channel << " channels of agents were registered in "; cout << size_of_vec_test_benches << " testbenches." << endl; } void run_simulation_of_all_testbenches() { string pressed_key; Testbench* current_tb; vector vec_tb_configs; Testbench_Config* current_tb_config; unsigned int size_of_vec_test_benches = vec_of_test_benches.size(); unsigned int index_tb = 0; unsigned int size_of_vec_test_bench_config; unsigned int index_tb_cfg = 0; unsigned int sim_rounds = -1; const int start_row = 1; if (FILE_NAME_OF_ENTIRE_DATA == "2017_01_07__05_46_fc6504.csv") { sim_rounds = 720; } cout << "Press any key to start the simulation of all testbenches." << endl; getline(cin, pressed_key); for(index_tb = 0; index_tb < size_of_vec_test_benches; index_tb++){ current_tb = vec_of_test_benches[index_tb]; index_tb_cfg = 0; vec_tb_configs = current_tb->get_all_registered_testbench_configs(); size_of_vec_test_bench_config = vec_tb_configs.size(); for(index_tb_cfg = 0; index_tb_cfg < size_of_vec_test_bench_config; index_tb_cfg++){ current_tb_config = vec_tb_configs[index_tb_cfg]; current_tb->set_current_tb_config_index(index_tb_cfg); current_tb->set_CSV_Writer_parameter(); current_tb->set_config_values_in_linear_functions(); //have to open new file first! with the CSV-Writer, for every round > 0 current_tb->simulate(sim_rounds); if(index_tb_cfg < size_of_vec_test_bench_config - 1) { current_tb->set_CSV_Reader_row(start_row); current_tb->set_CSV_Reader_to_beginning(); current_tb->reset_States(); } } } cout << "Simulation of " << size_of_vec_test_benches << " testbenches successfully finished" << endl; } void close_file_pointers() { CSVreaderModule* current_csv_reader; unsigned int size_of_vec_csv_reader = vec_of_csv_readers.size(); unsigned int index_csv_reader; for(index_csv_reader = 0; index_csv_reader < size_of_vec_csv_reader; index_csv_reader++) { current_csv_reader = vec_of_csv_readers[index_csv_reader]; current_csv_reader->close_file(); } } void empty_static_vectors() { empty_vec_Agent(); empty_vec_Channel_Agent(); empty_vec_Channel_Sensor(); empty_vec_Sensors(); empty_vec_csv_raders(); empty_vec_linear_func_Blocks(); empty_vec_TestBench(); vec_of_Channels_for_Agents.clear(); vec_of_Channels_for_Sensors.clear(); vec_of_Sensors.clear(); vec_of_csv_readers.clear(); vec_of_linear_Function_Blocks.clear(); } void empty_vec_Agent() { Agent* cur_Agent; unsigned int size_of_vec_Agent = vec_of_Agents.size(); unsigned int index_Agent; for(index_Agent = 0; index_Agent < size_of_vec_Agent; index_Agent++){ cur_Agent = vec_of_Agents[index_Agent]; delete cur_Agent; } vec_of_Agents.clear(); } void empty_vec_Channel_Agent() { Channel* cur_Channel; unsigned int size_of_vec_Chan_Agent = vec_of_Channels_for_Agents.size(); unsigned int index_Channel; for(index_Channel = 0; index_Channel < size_of_vec_Chan_Agent; index_Channel++){ cur_Channel = vec_of_Channels_for_Agents[index_Channel]; //delete cur_Channel; } vec_of_Channels_for_Agents.clear(); } void empty_vec_Channel_Sensor() { Channel* cur_Channel; unsigned int size_of_vec_Chan_Sensor = vec_of_Channels_for_Sensors.size(); unsigned int index_Channel; for(index_Channel = 0; index_Channel < size_of_vec_Chan_Sensor; index_Channel++){ cur_Channel = vec_of_Channels_for_Sensors[index_Channel]; delete cur_Channel; } vec_of_Channels_for_Sensors.clear(); } void empty_vec_Sensors() { Sensor* cur_Sensor; unsigned int size_of_vec_Chan_Sensor = vec_of_Sensors.size(); unsigned int index_Sensor; for(index_Sensor = 0; index_Sensor < size_of_vec_Chan_Sensor; index_Sensor++){ cur_Sensor = vec_of_Sensors[index_Sensor]; delete cur_Sensor; } vec_of_Sensors.clear(); } void empty_vec_csv_raders() { CSVreaderModule* cur_csv_reader; unsigned int size_of_vec_csv_reader = vec_of_csv_readers.size(); unsigned int index_csv_reader; for(index_csv_reader = 0; index_csv_reader < size_of_vec_csv_reader; index_csv_reader++){ cur_csv_reader = vec_of_csv_readers[index_csv_reader]; delete cur_csv_reader; } vec_of_csv_readers.clear(); } void empty_vec_linear_func_Blocks() { LinearFunctionBlock* cur_lin_fun_block; unsigned int size_of_vec_lin_fun_block= vec_of_linear_Function_Blocks.size(); unsigned int index_lin_fun_block; for(index_lin_fun_block = 0; index_lin_fun_block < size_of_vec_lin_fun_block; index_lin_fun_block++){ cur_lin_fun_block = vec_of_linear_Function_Blocks[index_lin_fun_block]; delete cur_lin_fun_block; } vec_of_linear_Function_Blocks.clear(); } void empty_vec_TestBench() { Testbench* current_tb; unsigned int size_of_vec_test_benches = vec_of_test_benches.size(); unsigned int index_tb = 0; for(index_tb = 0; index_tb < size_of_vec_test_benches; index_tb++){ current_tb = vec_of_test_benches[index_tb]; current_tb->free_resources(); delete current_tb; } vec_of_test_benches.clear(); }