Page MenuHomePhorge
Files F332201

No OneTemporary
Actions

Size
59 KB
Referenced Files
None
Subscribers
None

View Options

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 <QCoreApplication>
+#include <QFile>
+#include "Agent.h"
+#include "Channel.h"
+#include "create_unit.h"
+#include "CSVreaderModule.h"
+#include "inAgentsRegistrations.h"
+#include "mount_nodes.h"
+#include "register_in_testbench.h"
+#include "Sensor.h"
+#include "setupNode.h"
+#include <stdio.h>
+#include <iostream>
+#include <vector>
+#include <string>
+#include <cstring>
+#include "Testbench.h"
+#include "file_util.h"
+
+#include "LinearFunction.h"
+#include "LinearFunctionBlock.h"
+
+#include "Testbench_Config.h"
+
+using namespace std;
+
+/**********************************************************************************************************************
+ ************************************************begin of global definitions of variables and constants ***************
+ **********************************************************************************************************************/
+
+//every n-th SAMBLING value will be read in from the CSV-Data-Input-Files.
+#define SAMPLING 1
+
+//global vectors for the different elements
+static vector<Agent*> vec_of_Agents;
+static vector<Sensor*> vec_of_Sensors;
+static vector<Channel*> vec_of_Channels_for_Sensors;
+static vector<Channel*> vec_of_Channels_for_Agents;
+static vector<LinearFunctionBlock*> vec_of_linear_Function_Blocks;
+static vector<Testbench*> vec_of_test_benches;
+static vector<CSVreaderModule*> vec_of_csv_readers;
+
+//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<LinearFunction*> vec_Lin_Func);
+
+void set_CSV_Writer_parameter(Testbench* current_tb);
+
+void run_simulation_of_all_testbenches();
+
+void close_file_pointers();
+
+void empty_static_vectors();
+void empty_vec_Agent();
+void empty_vec_Channel_Agent();
+void empty_vec_Channel_Sensor();
+void empty_vec_Sensors();
+void empty_vec_csv_raders();
+void empty_vec_linear_func_Blocks();
+void empty_vec_TestBench();
+
+
+/**********************************************************************************************************************
+ ************************************************end of function prototypes *******************************************
+ **********************************************************************************************************************/
+
+int main(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<Testbench_Config*> vec_tb_configs;
+ Testbench_Config* current_tb_config;
+ unsigned int size_of_vec_test_benches = vec_of_test_benches.size();
+ unsigned int index_tb = 0;
+ unsigned int size_of_vec_test_bench_config;
+ unsigned int index_tb_cfg = 0;
+ 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();
+}
+

File Metadata

Mime Type
text/x-diff
Expires
Sun, Mar 16, 10:45 AM (1 d, 20 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
129116
Default Alt Text
(59 KB)

Event Timeline