diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..481cd36 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +/Version_Max_07_05_2018_CMake/QtProject/build-QtCAM-Desktop_Qt_5_11_2_GCC_64bit-Debug diff --git a/Version_Max_07_05_2018_CMake/QtProject/QtCAM/.gitignore b/Version_Max_07_05_2018_CMake/QtProject/QtCAM/.gitignore new file mode 100644 index 0000000..fab7372 --- /dev/null +++ b/Version_Max_07_05_2018_CMake/QtProject/QtCAM/.gitignore @@ -0,0 +1,73 @@ +# This file is used to ignore files which are generated +# ---------------------------------------------------------------------------- + +*~ +*.autosave +*.a +*.core +*.moc +*.o +*.obj +*.orig +*.rej +*.so +*.so.* +*_pch.h.cpp +*_resource.rc +*.qm +.#* +*.*# +core +!core/ +tags +.DS_Store +.directory +*.debug +Makefile* +*.prl +*.app +moc_*.cpp +ui_*.h +qrc_*.cpp +Thumbs.db +*.res +*.rc +/.qmake.cache +/.qmake.stash + +# qtcreator generated files +*.pro.user* + +# xemacs temporary files +*.flc + +# Vim temporary files +.*.swp + +# Visual Studio generated files +*.ib_pdb_index +*.idb +*.ilk +*.pdb +*.sln +*.suo +*.vcproj +*vcproj.*.*.user +*.ncb +*.sdf +*.opensdf +*.vcxproj +*vcxproj.* + +# MinGW generated files +*.Debug +*.Release + +# Python byte code +*.pyc + +# Binaries +# -------- +*.dll +*.exe + diff --git a/Version_Max_07_05_2018_CMake/QtProject/QtCAM/QtCAM.pro b/Version_Max_07_05_2018_CMake/QtProject/QtCAM/QtCAM.pro new file mode 100644 index 0000000..ed5fa96 --- /dev/null +++ b/Version_Max_07_05_2018_CMake/QtProject/QtCAM/QtCAM.pro @@ -0,0 +1,175 @@ +QT -= gui + +CONFIG += c++11 console +CONFIG -= app_bundle + +# The following define makes your compiler emit warnings if you use +# any feature of Qt which as been marked deprecated (the exact warnings +# depend on your compiler). Please consult the documentation of the +# deprecated API in order to know how to port your code away from it. +DEFINES += QT_DEPRECATED_WARNINGS + +# You can also make your code fail to compile if you use deprecated APIs. +# In order to do so, uncomment the following line. +# You can also select to disable deprecated APIs only up to a certain version of Qt. +#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000 # disables all the APIs deprecated before Qt 6.0.0 + +SOURCES += \ + main.cpp \ + ../../src/abstraction_functions.cpp \ + ../../src/abstraction_interface.cpp \ + ../../src/AbstractionModule.cpp \ + ../../src/Agent.cpp \ + ../../src/AgentSlotOfTestbench.cpp \ + ../../src/attach_modules.cpp \ + ../../src/attach_modulesToTestbench.cpp \ + ../../src/AverageValue.cpp \ + ../../src/boundary_check.cpp \ + ../../src/Bunch_Module.cpp \ + ../../src/Channel.cpp \ + ../../src/ChannelSlotOfTestbench.cpp \ + ../../src/clock.cpp \ + ../../src/ConfidenceModule.cpp \ + ../../src/Continuous_Average.cpp \ + ../../src/create_unit.cpp \ + ../../src/Cross_Confidence_Validator.cpp \ + ../../src/CSVreaderModule.cpp \ + ../../src/CSV_Writer.cpp \ + ../../src/Discrete_Average.cpp \ + ../../src/Domain.cpp \ + ../../src/Evaluation.cpp \ + ../../src/extremaValues.cpp \ + ../../src/ExtremeValue.cpp \ + ../../src/HandlerOfAgent.cpp \ + ../../src/HistoryEntry.cpp \ + ../../src/HistoryModule.cpp \ + ../../src/inAgentsRegistrations.cpp \ + ../../src/LinearFunction.cpp \ + ../../src/LinearFunctionBlock.cpp \ + ../../src/Lookuptable.cpp \ + # ../../src/main.cpp \ + # ../../src/main_motor_old.cpp \ + # ../../src/main_OMV.cpp \ + # ../../src/main_OPEL_GA_Data.cpp \ + # ../../src/main_Opel_GA_Data_Symmetrie.cpp \ + # ../../src/main_Wr_Neustadt.cpp \ + ../../src/MasterAgentHandlerOfAgent.cpp \ + ../../src/MasterAgentSlotOfAgent.cpp \ + ../../src/MaximumValue.cpp \ + ../../src/Message.cpp \ + ../../src/minmaxzeug.cpp \ + ../../src/MinumumValue.cpp \ + ../../src/Module.cpp \ + ../../src/mount_nodes.cpp \ + ../../src/Node.cpp \ + ../../src/printError.cpp \ + ../../src/Range.cpp \ + ../../src/register_in_testbench.cpp \ + ../../src/relationChecker.cpp \ + ../../src/Sensor.cpp \ + ../../src/SensorHandlerOfAgent.cpp \ + ../../src/SensorSlotOfAgent.cpp \ + ../../src/SensorSlotOfTestbench.cpp \ + ../../src/setup_agent.cpp \ + ../../src/setup_lookuptable.cpp \ + ../../src/setupNode.cpp \ + ../../src/SlaveAgentHandlerOfAgent.cpp \ + ../../src/SlaveAgentSlotOfAgent.cpp \ + ../../src/Slot.cpp \ + ../../src/SlotOfAgent.cpp \ + ../../src/State.cpp \ + ../../src/StateHandler.cpp \ + ../../src/StateModule.cpp \ + ../../src/StateVariable.cpp \ + ../../src/StatisticValue.cpp \ + ../../src/SubState.cpp \ + ../../src/Testbench.cpp \ + ../../src/Testbench_Config.cpp \ + ../../src/Unit.cpp \ + ../../src/user_method_abstraction.cpp \ + ../../src/csvparser.c + +# Default rules for deployment. +qnx: target.path = /tmp/$${TARGET}/bin +else: unix:!android: target.path = /opt/$${TARGET}/bin +!isEmpty(target.path): INSTALLS += target + +DISTFILES += \ + ../../src/Readme_Änderungen.txt \ + ../../src/CMakeLists.txt + +HEADERS += \ + ../../src/abstraction_functions.h \ + ../../src/abstraction_interface.h \ + ../../src/AbstractionModule.h \ + ../../src/Agent.h \ + ../../src/AgentSlotOfTestbench.h \ + ../../src/attach_modules.h \ + ../../src/attach_modulesToTestbench.h \ + ../../src/AverageValue.h \ + ../../src/boundary_check.h \ + ../../src/Bunch_Module.h \ + ../../src/Channel.h \ + ../../src/ChannelSlotOfTestbench.h \ + ../../src/clock.h \ + ../../src/ConfidenceModule.h \ + ../../src/Continuous_Average.h \ + ../../src/create_unit.h \ + ../../src/Cross_Confidence_Validator.h \ + ../../src/csvparser.h \ + ../../src/CSVreaderModule.h \ + ../../src/CSV_Writer.h \ + ../../src/Discrete_Average.h \ + ../../src/Domain.h \ + ../../src/Evaluation.h \ + ../../src/extremaValues.h \ + ../../src/ExtremeValue.h \ + ../../src/file_util.h \ + ../../src/HandlerOfAgent.h \ + ../../src/Header.h \ + ../../src/HistoryEntry.h \ + ../../src/HistoryModule.h \ + ../../src/inAgentsRegistrations.h \ + ../../src/instruction_set_architecture.h \ + ../../src/LinearFunction.h \ + ../../src/LinearFunctionBlock.h \ + ../../src/Lookuptable.h \ + ../../src/MasterAgentHandlerOfAgent.h \ + ../../src/MasterAgentSlotOfAgent.h \ + ../../src/MaximumValue.h \ + ../../src/Message.h \ + ../../src/minmaxzeug.h \ + ../../src/MinumumValue.h \ + ../../src/Module.h \ + ../../src/mount_nodes.h \ + ../../src/Node.h \ + ../../src/printError.h \ + ../../src/project_settings.h \ + ../../src/Range.h \ + ../../src/register_in_testbench.h \ + ../../src/relationChecker.h \ + ../../src/rlutil.h \ + ../../src/Sensor.h \ + ../../src/SensorHandlerOfAgent.h \ + ../../src/SensorSlotOfAgent.h \ + ../../src/SensorSlotOfTestbench.h \ + ../../src/settings.h \ + ../../src/setup_agent.h \ + ../../src/setup_lookuptable.h \ + ../../src/setupNode.h \ + ../../src/SlaveAgentHandlerOfAgent.h \ + ../../src/SlaveAgentSlotOfAgent.h \ + ../../src/Slot.h \ + ../../src/SlotOfAgent.h \ + ../../src/State.h \ + ../../src/StateHandler.h \ + ../../src/StateModule.h \ + ../../src/StateVariable.h \ + ../../src/StatisticValue.h \ + ../../src/SubState.h \ + ../../src/Testbench.h \ + ../../src/Testbench_Config.h \ + ../../src/Unit.h \ + ../../src/user_method_abstraction.h + +INCLUDEPATH += ../../src diff --git a/Version_Max_07_05_2018_CMake/QtProject/QtCAM/main.cpp b/Version_Max_07_05_2018_CMake/QtProject/QtCAM/main.cpp new file mode 100644 index 0000000..d130ba2 --- /dev/null +++ b/Version_Max_07_05_2018_CMake/QtProject/QtCAM/main.cpp @@ -0,0 +1,1132 @@ +/* + * 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 +#include +#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(int argc, char **argv) +{ + bool status = false; + QCoreApplication app(argc, argv); + QString app_path = app.applicationDirPath(); + cout << "This program processes test data from OMV Steam Cracker furnaces." << endl; + + create_and_register_All_Agents(); + set_working_cycle_of_All_Agents(); + + + create_and_register_All_Sensors(); + set_working_cycle_of_All_Sensors(); + + create_and_register_channels(); + + mount_sensors_in_agents(); + + mount_agents_in_agents(); + + register_data_agents_in_agent_state_Handler(); + + create_linear_function_blocks(); + + mount_function_blocks_to_viability_monitor(); + + create_all_testbenches(); + + create_csvr_modules(); + + register_agents_in_testbenches(); + + register_sensors_in_testbenches(); + + register_channels_in_testbenches(); + + + + run_simulation_of_all_testbenches(); + + //close_file_pointers(); + //TODO memory free of all objects. + empty_static_vectors(); + + cout << "Program finished successfully" << endl; + return 0; +} + +void create_and_register_all_Testbench_Configs(Testbench* current_tb) +{ + + One_Config_t one; + one.bound_broken = 2; + one.inner_bound_sim_dif = 0.02; + one.outter_bound_sim_dif = 0.08; + one.inner_bound_drift = 3 * one.outter_bound_sim_dif; + one.inner_bound_drift = one.outter_bound_sim_dif; + one.length = 10; + Testbench_Config* cfg = new Testbench_Config(one); + cfg->print(); + current_tb->register_testbench_config(cfg); +} + + + +/* + * creates all the agents used in the measurement + * and stores them into the global vector + */ +void create_and_register_All_Agents() +{ + cout << "Creating Agents" << endl; + char* c_name_of_current_agent = new char[MAX_LENGTH_NAME]; + strcpy(c_name_of_current_agent, FIRST_MEASURED_DATA_NAME.c_str()); + Agent* a_FC6504_Y = create_agent(c_name_of_current_agent); + strcpy(c_name_of_current_agent, SECOND_MEASURED_DATA_NAME.c_str()); + Agent* a_FC6504 = create_agent(c_name_of_current_agent); + strcpy(c_name_of_current_agent, THIRD_MEASURED_DATA_NAME.c_str()); + Agent* a_FC6504_SP = create_agent(c_name_of_current_agent); + strcpy(c_name_of_current_agent, FOURTH_MEASURED_DATA_NAME.c_str()); + Agent* a_PI6584 = create_agent(c_name_of_current_agent); + strcpy(c_name_of_current_agent, VIABILITY_MONITOR.c_str()); + Agent* a_viabilityMonitor = create_agent(c_name_of_current_agent); + vec_of_Agents.push_back(a_FC6504_Y); + vec_of_Agents.push_back(a_FC6504); + vec_of_Agents.push_back(a_FC6504_SP); + vec_of_Agents.push_back(a_PI6584); + vec_of_Agents.push_back(a_viabilityMonitor); + cout << vec_of_Agents.size() << " agents were created" << endl; + delete c_name_of_current_agent; +} + +/* + * the working_cycle for all registered agents is set + */ +void set_working_cycle_of_All_Agents() +{ + unsigned int working_Cyle = SAMPLING; + unsigned int size_of_vec_of_Agents = 0; + unsigned int index = 0; + Agent* current_Agent; + size_of_vec_of_Agents = vec_of_Agents.size(); + for(index = 0; index < size_of_vec_of_Agents; index++) { + current_Agent = vec_of_Agents[index]; + setWorkingCycleOfAgent(current_Agent, working_Cyle); + } +} + +/* + * all necessary sensors are created and registered + */ +void create_and_register_All_Sensors() +{ + cout << "Creating Sensors" << endl; + char* c_name_of_current_sensor = new char[MAX_LENGTH_NAME]; + strcpy(c_name_of_current_sensor, FIRST_MEASURED_DATA_NAME.c_str()); + Sensor* s_FC6504_Y = create_sensor(c_name_of_current_sensor); + strcpy(c_name_of_current_sensor, SECOND_MEASURED_DATA_NAME.c_str()); + Sensor* s_FC6504 = create_sensor(c_name_of_current_sensor); + strcpy(c_name_of_current_sensor, THIRD_MEASURED_DATA_NAME.c_str()); + Sensor* s_FC6504_SP = create_sensor(c_name_of_current_sensor); + strcpy(c_name_of_current_sensor, FOURTH_MEASURED_DATA_NAME.c_str()); + Sensor* s_PI6584 = create_sensor(c_name_of_current_sensor); + vec_of_Sensors.push_back(s_FC6504_Y); + vec_of_Sensors.push_back(s_FC6504); + vec_of_Sensors.push_back(s_FC6504_SP); + vec_of_Sensors.push_back(s_PI6584); + cout << vec_of_Sensors.size() << " sensors were created." << endl; + delete c_name_of_current_sensor; +} + +/* + * working cycle of all registered sensors is set + */ +void set_working_cycle_of_All_Sensors() +{ + unsigned int working_Cyle = SAMPLING; + unsigned int size_of_vec_of_Sensors = 0; + unsigned int index = 0; + Sensor* current_Sensor; + + size_of_vec_of_Sensors = vec_of_Sensors.size(); + for(index = 0; index < size_of_vec_of_Sensors; index++) { + current_Sensor = vec_of_Sensors[index]; + setWorkingCycleOfSensor(current_Sensor, working_Cyle); + } +} + +/* + * creating and registering all channels + */ +void create_and_register_channels() +{ + create_and_register_channels_for_sensors(); + create_and_register_channels_for_agents(); +} + +/* + * creating and registering the channels for the sensors. + */ +void create_and_register_channels_for_sensors() +{ + cout << "Creating and registering channels for sensors" << endl; + char* c_name_of_current_channel = new char[MAX_LENGTH_NAME]; + strcpy(c_name_of_current_channel, FIRST_MEASURED_CHANNEL_SENSOR_NAME.c_str()); + Channel* c_sa_FC6504_Y = create_channel(c_name_of_current_channel, 0); + strcpy(c_name_of_current_channel, SECOND_MEASURED_CHANNEL_SENSOR_NAME.c_str()); + Channel* c_sa_FC6504 = create_channel(c_name_of_current_channel, 0); + strcpy(c_name_of_current_channel, THIRD_MEASURED_CHANNEL_SENSOR_NAME.c_str()); + Channel* c_sa_FC6504_SP = create_channel(c_name_of_current_channel, 0); + strcpy(c_name_of_current_channel, FOURTH_MEASURED_CHANNEL_SENSOR_NAME.c_str()); + Channel* c_sa_PI6584 = create_channel(c_name_of_current_channel, 0); + + vec_of_Channels_for_Sensors.push_back(c_sa_FC6504_Y); + vec_of_Channels_for_Sensors.push_back(c_sa_FC6504); + vec_of_Channels_for_Sensors.push_back(c_sa_FC6504_SP); + vec_of_Channels_for_Sensors.push_back(c_sa_PI6584); + cout << vec_of_Channels_for_Sensors.size() << " channels for sensors were created" << endl; + + delete c_name_of_current_channel; +} + +/* + * creating and registering the channels for the agents + */ +void create_and_register_channels_for_agents() +{ + cout << "Creating and registering channels for agents" << endl; + char* c_name_of_current_channel = new char[MAX_LENGTH_NAME]; + strcpy(c_name_of_current_channel, FIRST_MEASURED_CHANNEL_AGENT_NAME.c_str()); + Channel* c_aa_FC6504_Y = create_channel(c_name_of_current_channel, 0); + strcpy(c_name_of_current_channel, SECOND_MEASURED_CHANNEL_AGENT_NAME.c_str()); + Channel* c_aa_FC6504 = create_channel(c_name_of_current_channel, 0); + strcpy(c_name_of_current_channel, THIRD_MEASURED_CHANNEL_AGENT_NAME.c_str()); + Channel* c_aa_FC6504_SP = create_channel(c_name_of_current_channel, 0); + strcpy(c_name_of_current_channel, FOURTH_MEASURED_CHANNEL_AGENT_NAME.c_str()); + Channel* c_aa_PI6584 = create_channel(c_name_of_current_channel, 0); + + vec_of_Channels_for_Agents.push_back(c_aa_FC6504_Y); + vec_of_Channels_for_Agents.push_back(c_aa_FC6504); + vec_of_Channels_for_Agents.push_back(c_aa_FC6504_SP); + vec_of_Channels_for_Agents.push_back(c_aa_PI6584); + + cout << vec_of_Channels_for_Agents.size() << " channels for agents were created" << endl; + + delete c_name_of_current_channel; +} + +void mount_sensors_in_agents() +{ + Agent* current_agent; + Sensor* current_sensor; + Channel* current_sensor_channel; + unsigned int size_of_vec_sensor = 0; + unsigned int index = 0; + + size_of_vec_sensor = vec_of_Sensors.size(); + cout << "mounting sensors in agents." << endl; + //it is assumed that the corresponding sensors and agents and channels are always at the same + //position in the different vectors, if not then you have to add an search algorithm for it. + for(index = 0; index < size_of_vec_sensor; index++) + { + current_agent = vec_of_Agents[index]; + current_sensor = vec_of_Sensors[index]; + current_sensor_channel = vec_of_Channels_for_Sensors[index]; + mount_sensorInAgent(current_agent, current_sensor, current_sensor_channel); + } + cout << size_of_vec_sensor << " sensors in agents were mounted" << endl; +} + +void mount_agents_in_agents() +{ + Agent* current_agent; + Agent* viability_Monitor; + Channel* current_agent_channel; + unsigned int size_of_vec_agents = 0; + unsigned int index = 0; + + size_of_vec_agents = vec_of_Agents.size(); + //it is assumed that the viability agent is at the last position in the vector + viability_Monitor = vec_of_Agents[size_of_vec_agents-1]; + //all agents and channels are registered to the viabilityMonitor agent + //so you have to subtract the viabilityMonitor from the number of elements to register + //it is assumed that all the corresponding channels and agents are placed at the same index + for(index = 0; index < size_of_vec_agents -1; index++) + { + current_agent = vec_of_Agents[index]; + current_agent_channel = vec_of_Channels_for_Agents[index]; + //only register if the agent is not the viability_monitor, otherwise you would register the viability monitor to itself. + if(current_agent != viability_Monitor) { + mount_agentInAgent(viability_Monitor, current_agent, current_agent_channel); + } + } + cout << size_of_vec_agents -1 << "agents were registered to the viability monitor" << endl; +} + +/* + * registers the channels for the data agents to the viability monitor + */ +void register_data_agents_in_agent_state_Handler() + +{ + Agent* viability_Monitor; + Channel* current_agent_channel; + unsigned int size_of_vec_channel_agents = 0; + unsigned int index = 0; + + size_of_vec_channel_agents = vec_of_Channels_for_Agents.size(); + //get the agent for the viabilityMonitor, it is assumed that it is at the last position + viability_Monitor = vec_of_Agents[vec_of_Agents.size()-1]; + //register all the channels to the viability monitor + for(index = 0; index < size_of_vec_channel_agents; index++) { + current_agent_channel = vec_of_Channels_for_Agents[index]; + if(index != INDEX_OUTPUT) { + registerSlaveAgentAsInputVariableInStateHandler(viability_Monitor, current_agent_channel); + } + else{ + registerSlaveAgentAsOutputVariableInStateHandler(viability_Monitor, current_agent_channel); + } + } +} + +/* + * creates and register all the different linear function blocks + */ +void create_linear_function_blocks() +{ + //don't change the sequence, because later it is assumed that the functions are + //registered int the vector in this sequence + //if you change it you have also to change the sequence in the function mount_function_blocks_to_viability_monitor + create_same_state_deviation_function_block(); + create_another_state_deviation_function_block(); + create_state_time_function_block(); + create_another_state_time_function_block(); + create_valid_state_deviation_function_block(); + create_invalid_state_deviation_function_block(); + create_valid_state_time_function_block(); + create_invalid_state_time_function_block(); + create_confidence_state_drift_function_block(); + create_confidence_broken_function_block(); +} + +/* + * creates and register the linear function block for same state deviation + */ +void create_same_state_deviation_function_block() +{ + char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; + strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_SAME_STATE_DEV.c_str()); + LinearFunctionBlock* confSim2StateDev = new LinearFunctionBlock(c_name_of_current_func_block); + LinearFunction* funcConfSim2StateDev1 = new LinearFunction(CONF_SIM2_STATE_DEV_1); + funcConfSim2StateDev1->setDomain(false, true, (float)-OUTTER_BOUND_SIM_DIF); + funcConfSim2StateDev1->setKandD((float)0, (float)0); + confSim2StateDev->addLinearFunction(funcConfSim2StateDev1); + LinearFunction* funcConfSim2StateDev2 = new LinearFunction(CONF_SIM2_STATE_DEV_2); + funcConfSim2StateDev2->setDomain(true, (float)-OUTTER_BOUND_SIM_DIF, true, (float)-INNER_BOUND_SIM_DIF); + funcConfSim2StateDev2->setKandD((float)-OUTTER_BOUND_SIM_DIF, (float)0, (float)-INNER_BOUND_SIM_DIF, (float)1); + confSim2StateDev->addLinearFunction(funcConfSim2StateDev2); + LinearFunction* funcConfSim2StateDev3 = new LinearFunction(CONF_SIM2_STATE_DEV_3); + funcConfSim2StateDev3->setDomain(true, (float)-INNER_BOUND_SIM_DIF, true, (float)INNER_BOUND_SIM_DIF); + funcConfSim2StateDev3->setKandD((float)0, (float)1); + confSim2StateDev->addLinearFunction(funcConfSim2StateDev3); + LinearFunction* funcConfSim2StateDev4 = new LinearFunction(CONF_SIM2_STATE_DEV_4); + funcConfSim2StateDev4->setDomain(true, (float)INNER_BOUND_SIM_DIF, true, (float)OUTTER_BOUND_SIM_DIF); + funcConfSim2StateDev4->setKandD((float)INNER_BOUND_SIM_DIF, (float)1, (float)OUTTER_BOUND_SIM_DIF, (float)0); + confSim2StateDev->addLinearFunction(funcConfSim2StateDev4); + LinearFunction* funcConfSim2StateDev5 = new LinearFunction(CONF_SIM2_STATE_DEV_5); + funcConfSim2StateDev5->setDomain(true, (float)OUTTER_BOUND_SIM_DIF, false); + funcConfSim2StateDev5->setKandD((float)0, (float)0); + confSim2StateDev->addLinearFunction(funcConfSim2StateDev5); + + vec_of_linear_Function_Blocks.push_back(confSim2StateDev); + + delete c_name_of_current_func_block; +} + +/* + * creates and register another state deviation function block + */ +void create_another_state_deviation_function_block() +{ + char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; + strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_ANOTHER_STATE_DEV.c_str()); + LinearFunctionBlock* confDif2StateDev = new LinearFunctionBlock(c_name_of_current_func_block); + LinearFunction* funcConfDif2StateDev1 = new LinearFunction(CONF_DIF2_STATE_DEV_1); + funcConfDif2StateDev1->setDomain(false, true, (float)-OUTTER_BOUND_SIM_DIF); + funcConfDif2StateDev1->setKandD((float)0, (float)1); + confDif2StateDev->addLinearFunction(funcConfDif2StateDev1); + LinearFunction* funcConfDif2StateDev2 = new LinearFunction(CONF_DIF2_STATE_DEV_2); + funcConfDif2StateDev2->setDomain(true, (float)-OUTTER_BOUND_SIM_DIF, true, (float)-INNER_BOUND_SIM_DIF); + funcConfDif2StateDev2->setKandD((float)-OUTTER_BOUND_SIM_DIF, (float)1, (float)-INNER_BOUND_SIM_DIF, (float)0); + confDif2StateDev->addLinearFunction(funcConfDif2StateDev2); + LinearFunction* funcConfDif2StateDev3 = new LinearFunction(CONF_DIF2_STATE_DEV_3); + funcConfDif2StateDev3->setDomain(true, (float)-INNER_BOUND_SIM_DIF, true, (float)INNER_BOUND_SIM_DIF); + funcConfDif2StateDev3->setKandD((float)0, (float)0); + confDif2StateDev->addLinearFunction(funcConfDif2StateDev3); + LinearFunction* funcConfDif2StateDev4 = new LinearFunction(CONF_DIF2_STATE_DEV_4); + funcConfDif2StateDev4->setDomain(true, (float)INNER_BOUND_SIM_DIF, true, (float)OUTTER_BOUND_SIM_DIF); + funcConfDif2StateDev4->setKandD((float)INNER_BOUND_SIM_DIF, (float)0, (float)OUTTER_BOUND_SIM_DIF, (float)1); + confDif2StateDev->addLinearFunction(funcConfDif2StateDev4); + LinearFunction* funcConfDif2StateDev5 = new LinearFunction(CONF_DIF2_STATE_DEV_5); + funcConfDif2StateDev5->setDomain(true, (float)OUTTER_BOUND_SIM_DIF, false); + funcConfDif2StateDev5->setKandD((float)0, (float)1); + confDif2StateDev->addLinearFunction(funcConfDif2StateDev5); + + vec_of_linear_Function_Blocks.push_back(confDif2StateDev); + + delete c_name_of_current_func_block; +} + +void create_state_time_function_block() +{ + char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; + strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_SAME_TIME.c_str()); + LinearFunctionBlock* confSim2StateTime = new LinearFunctionBlock(c_name_of_current_func_block); + LinearFunction* funcConfSim2StateTime1 = new LinearFunction(CONF_SIM2_STATE_TIME_1); + funcConfSim2StateTime1->setDomain(false, true, (float)0); + funcConfSim2StateTime1->setKandD((float)0, (float)0); + confSim2StateTime->addLinearFunction(funcConfSim2StateTime1); + LinearFunction* funcConfSim2StateTime2 = new LinearFunction(CONF_SIM2_STATE_TIME_2); + funcConfSim2StateTime2->setDomain(true, (float)0, true, (float)LENGTH); + funcConfSim2StateTime2->setKandD((float)0, (float)0, (float)LENGTH, (float)1); + confSim2StateTime->addLinearFunction(funcConfSim2StateTime2); + LinearFunction* funcConfSim2StateTime3 = new LinearFunction(CONF_SIM2_STATE_TIME_3); + funcConfSim2StateTime3->setDomain(true, (float)LENGTH, false); + funcConfSim2StateTime3->setKandD((float)0, (float)1); + confSim2StateTime->addLinearFunction(funcConfSim2StateTime3); + + vec_of_linear_Function_Blocks.push_back(confSim2StateTime); + + delete c_name_of_current_func_block; +} + +void create_another_state_time_function_block() +{ + char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; + strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_ANOTHER_STATE_TIME.c_str()); + LinearFunctionBlock* confDif2StateTime = new LinearFunctionBlock(c_name_of_current_func_block); + LinearFunction* funcConfDif2StateTime1 = new LinearFunction(CONF_DIF2_STATE_TIME_1); + funcConfDif2StateTime1->setDomain(false, true, (float)0); + funcConfDif2StateTime1->setKandD((float)0, (float)1); + confDif2StateTime->addLinearFunction(funcConfDif2StateTime1); + LinearFunction* funcConfDif2StateTime2 = new LinearFunction(CONF_DIF2_STATE_TIME_2); + funcConfDif2StateTime2->setDomain(true, (float)0, true, (float)LENGTH); + funcConfDif2StateTime2->setKandD((float)0, (float)1, (float)LENGTH, (float)0); + confDif2StateTime->addLinearFunction(funcConfDif2StateTime2); + LinearFunction* funcConfDif2StateTime3 = new LinearFunction(CONF_DIF2_STATE_TIME_3); + funcConfDif2StateTime3->setDomain(true, (float)LENGTH, false); + funcConfDif2StateTime3->setKandD((float)0, (float)0); + confDif2StateTime->addLinearFunction(funcConfDif2StateTime3); + + vec_of_linear_Function_Blocks.push_back(confDif2StateTime); + + delete c_name_of_current_func_block; +} + +void create_valid_state_deviation_function_block() +{ + char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; + strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_VAILD_STATE_DEV.c_str()); + LinearFunctionBlock* confValidStateDev = new LinearFunctionBlock(c_name_of_current_func_block); + LinearFunction* funcConfValidStateDev1 = new LinearFunction(CONF_VALID_STATE_DEV_1); + funcConfValidStateDev1->setDomain(false, true, (float)-OUTTER_BOUND_SIM_DIF); + funcConfValidStateDev1->setKandD((float)0, (float)0); + confValidStateDev->addLinearFunction(funcConfValidStateDev1); + LinearFunction* funcConfValidStateDev2 = new LinearFunction(CONF_VALID_STATE_DEV_2); + funcConfValidStateDev2->setDomain(true, (float)-OUTTER_BOUND_SIM_DIF, true, (float)-INNER_BOUND_SIM_DIF); + funcConfValidStateDev2->setKandD((float)-OUTTER_BOUND_SIM_DIF, (float)0, (float)-INNER_BOUND_SIM_DIF, (float)1); + confValidStateDev->addLinearFunction(funcConfValidStateDev2); + LinearFunction* funcConfValidStateDev3 = new LinearFunction(CONF_VALID_STATE_DEV_3); + funcConfValidStateDev3->setDomain(true, (float)-INNER_BOUND_SIM_DIF, true, (float)INNER_BOUND_SIM_DIF); + funcConfValidStateDev3->setKandD((float)0, (float)1); + confValidStateDev->addLinearFunction(funcConfValidStateDev3); + LinearFunction* funcConfValidStateDev4 = new LinearFunction(CONF_VALID_STATE_DEV_4); + funcConfValidStateDev4->setDomain(true, (float)INNER_BOUND_SIM_DIF, true, (float)OUTTER_BOUND_SIM_DIF); + funcConfValidStateDev4->setKandD((float)INNER_BOUND_SIM_DIF, (float)1, (float)OUTTER_BOUND_SIM_DIF, (float)0); + confValidStateDev->addLinearFunction(funcConfValidStateDev4); + LinearFunction* funcConfValidStateDev5 = new LinearFunction(CONF_VALID_STATE_DEV_5); + funcConfValidStateDev5->setDomain(true, (float)OUTTER_BOUND_SIM_DIF, false); + funcConfValidStateDev5->setKandD((float)0, (float)0); + confValidStateDev->addLinearFunction(funcConfValidStateDev5); + + vec_of_linear_Function_Blocks.push_back(confValidStateDev); + + delete c_name_of_current_func_block; +} + +void create_invalid_state_deviation_function_block() +{ + char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; + strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_INVALID_STATE_DEV.c_str()); + LinearFunctionBlock* confInvalidStateDev = new LinearFunctionBlock(c_name_of_current_func_block); + LinearFunction* funcConfInvalidStateDev1 = new LinearFunction(CONF_INVALID_STATE_DEV_1); + funcConfInvalidStateDev1->setDomain(false, true, (float)-OUTTER_BOUND_SIM_DIF); + funcConfInvalidStateDev1->setKandD((float)0, (float)1); + confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev1); + LinearFunction* funcConfInvalidStateDev2 = new LinearFunction(CONF_INVALID_STATE_DEV_2); + funcConfInvalidStateDev2->setDomain(true, (float)-OUTTER_BOUND_SIM_DIF, true, (float)-INNER_BOUND_SIM_DIF); + funcConfInvalidStateDev2->setKandD((float)-OUTTER_BOUND_SIM_DIF, (float)1, (float)-INNER_BOUND_SIM_DIF, (float)0); + confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev2); + LinearFunction* funcConfInvalidStateDev3 = new LinearFunction(CONF_INVALID_STATE_DEV_3); + funcConfInvalidStateDev3->setDomain(true, (float)-INNER_BOUND_SIM_DIF, true, (float)INNER_BOUND_SIM_DIF); + funcConfInvalidStateDev3->setKandD((float)0, (float)0); + confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev3); + LinearFunction* funcConfInvalidStateDev4 = new LinearFunction(CONF_INVALID_STATE_DEV_4); + funcConfInvalidStateDev4->setDomain(true, (float)INNER_BOUND_SIM_DIF, true, (float)OUTTER_BOUND_SIM_DIF); + funcConfInvalidStateDev4->setKandD((float)INNER_BOUND_SIM_DIF, (float)0, (float)OUTTER_BOUND_SIM_DIF, (float)1); + confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev4); + LinearFunction* funcConfInvalidStateDev5 = new LinearFunction(CONF_INVALID_STATE_DEV_5); + funcConfInvalidStateDev5->setDomain(true, (float)OUTTER_BOUND_SIM_DIF, false); + funcConfInvalidStateDev5->setKandD((float)0, (float)1); + confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev5); + + vec_of_linear_Function_Blocks.push_back(confInvalidStateDev); + + delete c_name_of_current_func_block; +} + +void create_valid_state_time_function_block() +{ + char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; + strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_VALID_STATE_TIME.c_str()); + LinearFunctionBlock* confValidStateTime = new LinearFunctionBlock(c_name_of_current_func_block); + LinearFunction* funcConfValidStateTime1 = new LinearFunction(VALID_STATE_TIME_1); + funcConfValidStateTime1->setDomain(false, true, (float)0); + funcConfValidStateTime1->setKandD((float)0, (float)0); + confValidStateTime->addLinearFunction(funcConfValidStateTime1); + LinearFunction* funcConfValidStateTime2 = new LinearFunction(VALID_STATE_TIME_2); + funcConfValidStateTime2->setDomain(true, (float)0, true, (float)LENGTH); //10 + funcConfValidStateTime2->setKandD((float)0, (float)0, (float)LENGTH, (float)1); + confValidStateTime->addLinearFunction(funcConfValidStateTime2); + LinearFunction* funcConfValidStateTime3 = new LinearFunction(VALID_STATE_TIME_3); + funcConfValidStateTime3->setDomain(true, (float)LENGTH, false); + funcConfValidStateTime3->setKandD((float)0, (float)1); + confValidStateTime->addLinearFunction(funcConfValidStateTime3); + + vec_of_linear_Function_Blocks.push_back(confValidStateTime); + + delete c_name_of_current_func_block; +} +void create_invalid_state_time_function_block() +{ + char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; + strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_INVALID_STATE_TIME.c_str()); + LinearFunctionBlock* confInvalidStateTime = new LinearFunctionBlock(c_name_of_current_func_block); + LinearFunction* funcConfInvalidStateTime1 = new LinearFunction(INVALID_STATE_TIME_1); + funcConfInvalidStateTime1->setDomain(false, true, (float)0); + funcConfInvalidStateTime1->setKandD((float)0, (float)1); + confInvalidStateTime->addLinearFunction(funcConfInvalidStateTime1); + LinearFunction* funcConfInvalidStateTime2 = new LinearFunction(INVALID_STATE_TIME_2); + funcConfInvalidStateTime2->setDomain(true, (float)0, true, (float)LENGTH); + funcConfInvalidStateTime2->setKandD((float)0, (float)1, (float)LENGTH, (float)0); + confInvalidStateTime->addLinearFunction(funcConfInvalidStateTime2); + LinearFunction* funcConfInvalidStateTime3 = new LinearFunction(INVALID_STATE_TIME_3); + funcConfInvalidStateTime3->setDomain(true, (float)LENGTH, false); + funcConfInvalidStateTime3->setKandD((float)0, (float)0); + confInvalidStateTime->addLinearFunction(funcConfInvalidStateTime3); + + vec_of_linear_Function_Blocks.push_back(confInvalidStateTime); + + delete c_name_of_current_func_block; +} + +void create_confidence_state_drift_function_block() +{ + char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; + strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_CONFIDENCE_STATE_DRIFTS.c_str()); + LinearFunctionBlock* confStateDrifts = new LinearFunctionBlock(c_name_of_current_func_block); + LinearFunction* functionConfidenceDriftDeviation1 = new LinearFunction(CONFIDENCE_DRIFT_DEVIATION_1); + functionConfidenceDriftDeviation1->setDomain(false, true, (float)-OUTTER_BOUND_DRIFT); + functionConfidenceDriftDeviation1->setKandD((float)0, (float)1); + confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation1); + LinearFunction* functionConfidenceDriftDeviation2 = new LinearFunction(CONFIDENCE_DRIFT_DEVIATION_2); + functionConfidenceDriftDeviation2->setDomain(true, (float)-OUTTER_BOUND_DRIFT, true, (float)-INNER_BOUND_DRIFT); + functionConfidenceDriftDeviation2->setKandD((float)-INNER_BOUND_DRIFT, (float)1, (float)-INNER_BOUND_DRIFT, (float)0); + confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation2); + LinearFunction* functionConfidenceDriftDeviation3 = new LinearFunction(CONFIDENCE_DRIFT_DEVIATION_3); + functionConfidenceDriftDeviation3->setDomain(true, (float)-INNER_BOUND_DRIFT, true, (float)INNER_BOUND_DRIFT); + functionConfidenceDriftDeviation3->setKandD((float)0, (float)0); + confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation3); + LinearFunction* functionConfidenceDriftDeviation4 = new LinearFunction(CONFIDENCE_DRIFT_DEVIATION_4); + functionConfidenceDriftDeviation4->setDomain(true, (float)INNER_BOUND_DRIFT, true, (float)OUTTER_BOUND_DRIFT); + functionConfidenceDriftDeviation4->setKandD((float)INNER_BOUND_DRIFT, (float)0, (float)OUTTER_BOUND_DRIFT, (float)1); + confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation4); + LinearFunction* functionConfidenceDriftDeviation5 = new LinearFunction(CONFIDENCE_DRIFT_DEVIATION_5); + functionConfidenceDriftDeviation5->setDomain(true, (float)OUTTER_BOUND_DRIFT, false); + functionConfidenceDriftDeviation5->setKandD((float)0, (float)1); + confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation5); + + vec_of_linear_Function_Blocks.push_back(confStateDrifts); + + delete c_name_of_current_func_block; +} + +void create_confidence_broken_function_block() +{ + char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; + strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_CONFIDENCE_BROKEN.c_str()); + LinearFunctionBlock* confBroken = new LinearFunctionBlock(c_name_of_current_func_block); + LinearFunction* functionConfidenceBroken1 = new LinearFunction(CONFIDENCE_BROKEN_1); + functionConfidenceBroken1->setDomain(false, true, (float)0); + functionConfidenceBroken1->setKandD((float)0, (float)0); + confBroken->addLinearFunction(functionConfidenceBroken1); + LinearFunction* functionConfidenceBroken2 = new LinearFunction(CONFIDENCE_BROKEN_2); + functionConfidenceBroken2->setDomain(true, (float)0, true, (float)BOUND_BROKEN); + functionConfidenceBroken2->setKandD((float)0, (float)0, (float)BOUND_BROKEN, (float)1); + confBroken->addLinearFunction(functionConfidenceBroken2); + LinearFunction* functionConfidenceBroken3 = new LinearFunction(CONFIDENCE_BROKEN_3); + functionConfidenceBroken3->setDomain(true, (float)BOUND_BROKEN, false); + functionConfidenceBroken3->setKandD((float)0, (float)1); + confBroken->addLinearFunction(functionConfidenceBroken3); + + vec_of_linear_Function_Blocks.push_back(confBroken); + + delete c_name_of_current_func_block; +} + +/* + * mount the different function blocks to the viability monitor agent + */ +void mount_function_blocks_to_viability_monitor() +{ + Agent* viability_Monitor; + LinearFunctionBlock* current_Linear_Function_Bock; + unsigned int size_of_vec_lin_func_block = vec_of_linear_Function_Blocks.size(); + unsigned int index = 0; + + //it is assumed that the viability monitor is at the last position of the vector of agents + viability_Monitor = vec_of_Agents[vec_of_Agents.size()-1]; + for(index = 0; index < size_of_vec_lin_func_block; index++) { + current_Linear_Function_Bock = vec_of_linear_Function_Blocks[index]; + //it is assumed that the function blocks are added into the vector in the following sequence + switch(index) { + case 0: + viability_Monitor->get_stateHandler()->FuncBlockConfSim2StateDev = current_Linear_Function_Bock; + break; + case 1: + viability_Monitor->get_stateHandler()->FuncBlockConfDif2StateDev = current_Linear_Function_Bock; + break; + case 2: + viability_Monitor->get_stateHandler()->FuncBlockConfSim2StateTime = current_Linear_Function_Bock; + break; + case 3: + viability_Monitor->get_stateHandler()->FuncBlockConfDif2StateTime = current_Linear_Function_Bock; + break; + case 4: + viability_Monitor->get_stateHandler()->FuncBlockConfValStateDev = current_Linear_Function_Bock; + break; + case 5: + viability_Monitor->get_stateHandler()->FuncBlockConfInvStateDev = current_Linear_Function_Bock; + break; + case 6: + viability_Monitor->get_stateHandler()->FuncBlockConfValStateTime = current_Linear_Function_Bock; + break; + case 7: + viability_Monitor->get_stateHandler()->FuncBlockConfInvStateTime = current_Linear_Function_Bock; + break; + case 8: + viability_Monitor->get_stateHandler()->DriftDeviation = current_Linear_Function_Bock; + break; + case 9: + viability_Monitor->get_stateHandler()->FuncBlockConfBrokenSamples = current_Linear_Function_Bock; + break; + } + } +} + + +void create_all_testbenches() { + char* c_name_of_current_testbench = new char[MAX_LENGTH_NAME]; + strcpy(c_name_of_current_testbench, TEST_BENCH.c_str()); + cout << "Creating test bench" << endl; + Testbench* tb = create_testbench(c_name_of_current_testbench); + create_and_register_all_Testbench_Configs(tb); + vec_of_test_benches.push_back(tb); + + delete c_name_of_current_testbench; +} + +void create_csvr_modules() +{ + //sets the row in which the data starts, maybe row one contains the headers + unsigned int row = 2; + char* c_name_of_current_csv_module = new char[MAX_LENGTH_NAME]; + string current_reader_path_and_file_name; + cout << "Creating CSV Reader Modules" << endl; + + current_reader_path_and_file_name = PATH_TO_CSV_DATA_FILES + PATH_TO_DATE_OF_MEASUREMENT + PATH_TO_AN_MEASURMENT + FILE_NAME_OF_ENTIRE_DATA; + strcpy(c_name_of_current_csv_module, FIRST_MEASURED_DATA_CSV_NAME.c_str()); + CSVreaderModule* csvr_FC6504_Y = create_CSVreaderModule(c_name_of_current_csv_module,current_reader_path_and_file_name.c_str(),3,row); + + current_reader_path_and_file_name = PATH_TO_CSV_DATA_FILES + PATH_TO_DATE_OF_MEASUREMENT + PATH_TO_AN_MEASURMENT + FILE_NAME_OF_ENTIRE_DATA; + strcpy(c_name_of_current_csv_module, SECOND_MEASURED_DATA_CSV_NAME.c_str()); + CSVreaderModule* csvr_FC6504 = create_CSVreaderModule(c_name_of_current_csv_module,current_reader_path_and_file_name.c_str(),4,row); + + current_reader_path_and_file_name = PATH_TO_CSV_DATA_FILES + PATH_TO_DATE_OF_MEASUREMENT + PATH_TO_AN_MEASURMENT + FILE_NAME_OF_ENTIRE_DATA; + strcpy(c_name_of_current_csv_module, THIRD_MEASURED_DATA_CSV_NAME.c_str()); + CSVreaderModule* csvr_FC6504_SP = create_CSVreaderModule(c_name_of_current_csv_module,current_reader_path_and_file_name.c_str(),5,row); + + current_reader_path_and_file_name = PATH_TO_CSV_DATA_FILES + PATH_TO_DATE_OF_MEASUREMENT + PATH_TO_AN_MEASURMENT + FILE_NAME_OF_ENTIRE_DATA; + strcpy(c_name_of_current_csv_module, FOURTH_MEASURED_DATA_CSV_NAME.c_str()); + CSVreaderModule* csvr_PI6584 = create_CSVreaderModule(c_name_of_current_csv_module,current_reader_path_and_file_name.c_str(),6,row); + + vec_of_csv_readers.push_back(csvr_FC6504_Y); + vec_of_csv_readers.push_back(csvr_FC6504); + vec_of_csv_readers.push_back(csvr_FC6504_SP); + vec_of_csv_readers.push_back(csvr_PI6584); + + delete c_name_of_current_csv_module; +} + +/* + * all agents would be registered to all testbenches + */ +void register_agents_in_testbenches() +{ + Testbench* current_tb; + unsigned int size_of_vec_test_benches = vec_of_test_benches.size(); + unsigned int index_tb = 0; + Agent* current_ag; + unsigned int size_of_vec_agents = vec_of_Agents.size(); + unsigned int index_agents = 0; + + cout << "registering agents in testbenches" << endl; + for(index_tb = 0; index_tb < size_of_vec_test_benches; index_tb++) { + current_tb = vec_of_test_benches[index_tb]; + for(index_agents = 0; index_agents < size_of_vec_agents; index_agents++) { + current_ag = vec_of_Agents[index_agents]; + register_agentInTestbench(current_tb, current_ag); + } + } + cout << size_of_vec_agents << " agents were registered in every of the " << size_of_vec_test_benches << " testbenches" << endl; +} + +/* + * registering the sensors and the corresponding csv-readers in the testbenches + * it is assumed that the csv readers and the sensors are at the same index position + * in the vectors. + */ +void register_sensors_in_testbenches() +{ + Testbench* current_tb; + unsigned int size_of_vec_test_benches = vec_of_test_benches.size(); + unsigned int index_tb = 0; + Sensor* current_se; + unsigned int size_of_vec_sensors = vec_of_Sensors.size(); + unsigned int index_sensors = 0; + CSVreaderModule* current_csv_reader; + unsigned int size_of_vec_csv_reader = vec_of_csv_readers.size(); + + if(size_of_vec_csv_reader != size_of_vec_sensors) { + cout << "Error, in sequence of data processing"; + cout << "Number of csv-readers should be equal to number of sensors" << endl; + } + else { + cout << "Registering sensors and their csv-readers in testbenches " << endl; + for(index_tb = 0; index_tb < size_of_vec_test_benches; index_tb++) { + current_tb = vec_of_test_benches[index_tb]; + for(index_sensors = 0; index_sensors < size_of_vec_sensors; index_sensors++) { + current_se = vec_of_Sensors[index_sensors]; + //it is assumed that the sensor and the corresponding csv-reader is stored + //at the same position in the two different vectors + current_csv_reader = vec_of_csv_readers[index_sensors]; + register_sensorInTestbench(current_tb, current_se, current_csv_reader); + } + } + cout << size_of_vec_sensors << " Sensors and their csv-readers were registered to "; + cout << "every of the " << size_of_vec_test_benches << " testbenches" << endl; + } +} + +void register_channels_in_testbenches() +{ + register_channels_of_sensors_in_testbenches(); + + register_channels_of_actors_in_testbenches(); +} + +void register_channels_of_sensors_in_testbenches() +{ + Testbench* current_tb; + unsigned int size_of_vec_test_benches = vec_of_test_benches.size(); + unsigned int index_tb = 0; + Channel* current_se_ch; + unsigned int size_of_vec_se_channel = vec_of_Channels_for_Sensors.size(); + unsigned int index_se_ch = 0; + + cout << "Registering channels of sensors in testbench" << endl; + for(index_tb = 0; index_tb < size_of_vec_test_benches; index_tb++) { + current_tb = vec_of_test_benches[index_tb]; + for(index_se_ch = 0; index_se_ch < size_of_vec_se_channel; index_se_ch++) { + current_se_ch = vec_of_Channels_for_Sensors[index_se_ch]; + register_channelInTestbench(current_tb, current_se_ch); + } + } + cout << size_of_vec_se_channel << " channels of sensors were registered in "; + cout << size_of_vec_test_benches << " testbenches." << endl; + +} + +void register_channels_of_actors_in_testbenches() +{ + Testbench* current_tb; + unsigned int size_of_vec_test_benches = vec_of_test_benches.size(); + unsigned int index_tb = 0; + Channel* current_se_ch; + unsigned int size_of_vec_ag_channel = vec_of_Channels_for_Agents.size(); + unsigned int index_se_ch = 0; + + cout << "Registering channels of agents in testbench" << endl; + for(index_tb = 0; index_tb < size_of_vec_test_benches; index_tb++) { + current_tb = vec_of_test_benches[index_tb]; + for(index_se_ch = 0; index_se_ch < size_of_vec_ag_channel; index_se_ch++) { + current_se_ch = vec_of_Channels_for_Agents[index_se_ch]; + register_channelInTestbench(current_tb, current_se_ch); + } + } + cout << size_of_vec_ag_channel << " channels of agents were registered in "; + cout << size_of_vec_test_benches << " testbenches." << endl; +} + +void run_simulation_of_all_testbenches() +{ + + string pressed_key; + Testbench* current_tb; + vector 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(); +} +