No OneTemporary
Actions

Size

152 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/Version_Max_07_05_2018_CMake/src/configCAMforFluid.cpp b/Version_Max_07_05_2018_CMake/src/configCAMforFluid.cpp
	new file mode 100644
	index 0000000..57a10a1
	--- /dev/null
	+++ b/Version_Max_07_05_2018_CMake/src/configCAMforFluid.cpp
	@@ -0,0 +1,502 @@
	+#include "configCAMforFluid.h"
	+
	+#include "Agent.h"
	+#include "CSVreaderModule.h"
	+#include "Channel.h"
	+#include "Sensor.h"
	+#include "Testbench.h"
	+#include "create_unit.h"
	+#include "file_util.h"
	+#include "inAgentsRegistrations.h"
	+#include "mount_nodes.h"
	+#include "register_in_testbench.h"
	+#include "setupNode.h"
	+
	+#include "LinearFunction.h"
	+#include "LinearFunctionBlock.h"
	+
	+//#define PRINT
	+//#define STOP_BEFORE_SIMULATING
	+
	+void configAndStartFluidExperiment(
	+ char destinationPath, char datasetPath, char *datasetName,
	+ unsigned int datasetLength, float innerBoundSimDif, float outerBoundSimDif,
	+ int boundTimeInSamples, unsigned int discreteAveragePartitionSize,
	+ float innerBoundDrift, float outerBoundDrift, int boundBrokenTime,
	+ int downSamplingFactor) {
	+
	+ // config starts here
	+ // create agents
	+ // low level agents - inputs
	+ Agent *a_voltage = create_agent("A:Voltage");
	+ setWorkingCycleOfAgent(a_voltage, downSamplingFactor);
	+ // low level agents - outputs
	+ Agent *a_temp1 = create_agent("A:Temp1");
	+ setWorkingCycleOfAgent(a_temp1, downSamplingFactor);
	+ Agent *a_temp2 = create_agent("A:Temp2");
	+ setWorkingCycleOfAgent(a_temp2, downSamplingFactor);
	+ Agent *a_sharkyS = create_agent("A:SharkyS");
	+ setWorkingCycleOfAgent(a_sharkyS, downSamplingFactor);
	+ Agent *a_sharkyB = create_agent("A:SharkyS");
	+ setWorkingCycleOfAgent(a_sharkyB, downSamplingFactor);
	+ Agent *a_dyna = create_agent("A:Dyna");
	+ setWorkingCycleOfAgent(a_dyna, downSamplingFactor);
	+ Agent *a_riels = create_agent("A:Riels");
	+ setWorkingCycleOfAgent(a_riels, downSamplingFactor);
	+ Agent *a_viabilityMonitor = create_agent("ViabilityMonitor");
	+ setWorkingCycleOfAgent(a_viabilityMonitor, downSamplingFactor);
	+
	+ // create sensors
	+ // inputs
	+ Sensor *s_voltage = create_sensor("S:Voltage");
	+ setWorkingCycleOfSensor(s_voltage, downSamplingFactor);
	+ // outputs
	+ Sensor *s_temp1 = create_sensor("S:Temp1");
	+ setWorkingCycleOfSensor(s_temp1, downSamplingFactor);
	+ Sensor *s_temp2 = create_sensor("S:Temp2");
	+ setWorkingCycleOfSensor(s_temp2, downSamplingFactor);
	+ Sensor *s_sharkyS = create_sensor("S:SharkyS");
	+ setWorkingCycleOfSensor(s_sharkyS, downSamplingFactor);
	+ Sensor *s_sharkyB = create_sensor("S:SharkyB");
	+ setWorkingCycleOfSensor(s_sharkyB, downSamplingFactor);
	+ Sensor *s_dyna = create_sensor("S:Dyna");
	+ setWorkingCycleOfSensor(s_dyna, downSamplingFactor);
	+ Sensor *s_riels = create_sensor("S:Riels");
	+ setWorkingCycleOfSensor(s_riels, downSamplingFactor);
	+
	+ // create channels for sensors
	+ // inputs
	+ Channel *c_sa_voltage = create_channel("C:SA:Voltage", 0);
	+ // outputs
	+ Channel *c_sa_temp1 = create_channel("C:SA:Temp1", 0);
	+ Channel *c_sa_temp2 = create_channel("C:SA:Temp2", 0);
	+ Channel *c_sa_sharkyS = create_channel("C:SA:SharkyS", 0);
	+ Channel *c_sa_sharkyB = create_channel("C:SA:SharkyB", 0);
	+ Channel *c_sa_dyna = create_channel("C:SA:Dyna", 0);
	+ Channel *c_sa_riels = create_channel("C:SA:Riels", 0);
	+
	+ // create channels for sensors
	+ // inputs
	+ Channel *c_aa_voltage = create_channel("C:AA:Voltage", MAX_BUFFER_LENGTH);
	+ // outputs
	+ Channel *c_aa_temp1 = create_channel("C:AA:Temp1", MAX_BUFFER_LENGTH);
	+ Channel *c_aa_temp2 = create_channel("C:AA:Temp2", MAX_BUFFER_LENGTH);
	+ Channel *c_aa_sharkyS = create_channel("C:AA:SharkyS", MAX_BUFFER_LENGTH);
	+ Channel *c_aa_sharkyB = create_channel("C:AA:SharkyB", MAX_BUFFER_LENGTH);
	+ Channel *c_aa_dyna = create_channel("C:AA:Dyna", MAX_BUFFER_LENGTH);
	+ Channel *c_aa_riels = create_channel("C:AA:Riels", MAX_BUFFER_LENGTH);
	+
	+ // mount sensors in agents
	+ // inputs
	+ mount_sensorInAgent(a_voltage, s_voltage, c_sa_voltage);
	+ // outputs
	+ mount_sensorInAgent(a_voltage, s_voltage, c_sa_voltage);
	+ mount_sensorInAgent(a_temp1, s_temp1, c_sa_temp1);
	+ mount_sensorInAgent(a_temp2, s_temp2, c_sa_temp2);
	+ mount_sensorInAgent(a_sharkyS, s_sharkyS, c_sa_sharkyS);
	+ mount_sensorInAgent(a_sharkyB, s_sharkyB, c_sa_sharkyB);
	+ mount_sensorInAgent(a_dyna, s_dyna, c_sa_dyna);
	+ mount_sensorInAgent(a_riels, s_riels, c_sa_riels);
	+
	+ // mount agents in agent(s)
	+ // inputs
	+ mount_agentInAgent(a_viabilityMonitor, a_voltage, c_aa_voltage);
	+ // outputs
	+ mount_agentInAgent(a_viabilityMonitor, a_temp1, c_aa_temp1);
	+ mount_agentInAgent(a_viabilityMonitor, a_temp2, c_aa_temp2);
	+ mount_agentInAgent(a_viabilityMonitor, a_sharkyS, c_aa_sharkyS);
	+ mount_agentInAgent(a_viabilityMonitor, a_sharkyB, c_aa_sharkyB);
	+ mount_agentInAgent(a_viabilityMonitor, a_dyna, c_aa_dyna);
	+ mount_agentInAgent(a_viabilityMonitor, a_riels, c_aa_riels);
	+
	+
	+ // set State Handler in Master Agent and Initialize an CSVWriter for the CAM
	+ // output
	+ a_viabilityMonitor->set_stateHandler("CSVW:CAMoutput", destinationPath);
	+
	+
	+ // register agents in agents' stateHandler
	+ // inputs
	+ registerSlaveAgentAsInputVariableInStateHandler(a_viabilityMonitor,
	+ c_aa_voltage);
	+ // outputs
	+ registerSlaveAgentAsOutputVariableInStateHandler(a_viabilityMonitor,
	+ c_aa_temp1);
	+ registerSlaveAgentAsOutputVariableInStateHandler(a_viabilityMonitor,
	+ c_aa_temp2);
	+ registerSlaveAgentAsOutputVariableInStateHandler(a_viabilityMonitor,
	+ c_aa_sharkyS);
	+ registerSlaveAgentAsOutputVariableInStateHandler(a_viabilityMonitor,
	+ c_aa_sharkyB);
	+ registerSlaveAgentAsOutputVariableInStateHandler(a_viabilityMonitor,
	+ c_aa_dyna);
	+ registerSlaveAgentAsOutputVariableInStateHandler(a_viabilityMonitor,
	+ c_aa_riels);
	+
	+
	+ // SAME STATE DEVIATION
	+ LinearFunctionBlock *confSim2StateDev =
	+ new LinearFunctionBlock("funcBlock:confSim2StateDev");
	+ LinearFunction *funcConfSim2StateDev1 = new LinearFunction();
	+ funcConfSim2StateDev1->setDomain(false, true, -1 * outerBoundSimDif);
	+ funcConfSim2StateDev1->setKandD((float)0, (float)0);
	+ confSim2StateDev->addLinearFunction(funcConfSim2StateDev1);
	+ LinearFunction *funcConfSim2StateDev2 = new LinearFunction();
	+ funcConfSim2StateDev2->setDomain(true, -1 * outerBoundSimDif, true,
	+ -1 * innerBoundSimDif);
	+ funcConfSim2StateDev2->setKandD(-1 * outerBoundSimDif, (float)0,
	+ -1 * innerBoundSimDif, (float)1);
	+ confSim2StateDev->addLinearFunction(funcConfSim2StateDev2);
	+ LinearFunction *funcConfSim2StateDev3 = new LinearFunction();
	+ funcConfSim2StateDev3->setDomain(true, -1 * innerBoundSimDif, true,
	+ innerBoundSimDif);
	+ funcConfSim2StateDev3->setKandD((float)0, (float)1);
	+ confSim2StateDev->addLinearFunction(funcConfSim2StateDev3);
	+ LinearFunction *funcConfSim2StateDev4 = new LinearFunction();
	+ funcConfSim2StateDev4->setDomain(true, innerBoundSimDif, true,
	+ outerBoundSimDif);
	+ funcConfSim2StateDev4->setKandD(innerBoundSimDif, (float)1, outerBoundSimDif,
	+ (float)0);
	+ confSim2StateDev->addLinearFunction(funcConfSim2StateDev4);
	+ LinearFunction *funcConfSim2StateDev5 = new LinearFunction();
	+ funcConfSim2StateDev5->setDomain(true, outerBoundSimDif, false);
	+ funcConfSim2StateDev5->setKandD((float)0, (float)0);
	+ confSim2StateDev->addLinearFunction(funcConfSim2StateDev5);
	+#ifdef PRINT
	+ confSim2StateDev->printFunctionBlock("funcBlock:confSim2StateDev");
	+#endif // PRINT
	+
	+ // ANOTHER STATE DEVIATION
	+ LinearFunctionBlock *confDif2StateDev =
	+ new LinearFunctionBlock("funcBlock:confDif2StateDev");
	+ LinearFunction *funcConfDif2StateDev1 = new LinearFunction();
	+ funcConfDif2StateDev1->setDomain(false, true, -1 * outerBoundSimDif);
	+ funcConfDif2StateDev1->setKandD((float)0, (float)1);
	+ confDif2StateDev->addLinearFunction(funcConfDif2StateDev1);
	+ LinearFunction *funcConfDif2StateDev2 = new LinearFunction();
	+ funcConfDif2StateDev2->setDomain(true, -1 * outerBoundSimDif, true,
	+ -1 * innerBoundSimDif);
	+ funcConfDif2StateDev2->setKandD(-1 * outerBoundSimDif, (float)1,
	+ -1 * innerBoundSimDif, (float)0);
	+ confDif2StateDev->addLinearFunction(funcConfDif2StateDev2);
	+ LinearFunction *funcConfDif2StateDev3 = new LinearFunction();
	+ funcConfDif2StateDev3->setDomain(true, -1 * innerBoundSimDif, true,
	+ innerBoundSimDif);
	+ funcConfDif2StateDev3->setKandD((float)0, (float)0);
	+ confDif2StateDev->addLinearFunction(funcConfDif2StateDev3);
	+ LinearFunction *funcConfDif2StateDev4 = new LinearFunction();
	+ funcConfDif2StateDev4->setDomain(true, innerBoundSimDif, true,
	+ outerBoundSimDif);
	+ funcConfDif2StateDev4->setKandD(innerBoundSimDif, (float)0, outerBoundSimDif,
	+ (float)1);
	+ confDif2StateDev->addLinearFunction(funcConfDif2StateDev4);
	+ LinearFunction *funcConfDif2StateDev5 = new LinearFunction();
	+ funcConfDif2StateDev5->setDomain(true, outerBoundSimDif, false);
	+ funcConfDif2StateDev5->setKandD((float)0, (float)1);
	+ confDif2StateDev->addLinearFunction(funcConfDif2StateDev5);
	+#ifdef PRINT
	+ confDif2StateDev->printFunctionBlock("funcBlock:confDif2StateDev");
	+#endif // PRINT
	+
	+ // SAME STATE TIME
	+ LinearFunctionBlock *confSim2StateTime =
	+ new LinearFunctionBlock("funcBlock:confSim2StateTime");
	+ LinearFunction *funcConfSim2StateTime1 = new LinearFunction();
	+ funcConfSim2StateTime1->setDomain(false, true, (float)0);
	+ funcConfSim2StateTime1->setKandD((float)0, (float)0);
	+ confSim2StateTime->addLinearFunction(funcConfSim2StateTime1);
	+ LinearFunction *funcConfSim2StateTime2 = new LinearFunction();
	+ funcConfSim2StateTime2->setDomain(true, (float)0, true,
	+ (float)boundTimeInSamples);
	+ funcConfSim2StateTime2->setKandD((float)0, (float)0,
	+ (float)boundTimeInSamples, (float)1);
	+ confSim2StateTime->addLinearFunction(funcConfSim2StateTime2);
	+ LinearFunction *funcConfSim2StateTime3 = new LinearFunction();
	+ funcConfSim2StateTime3->setDomain(true, (float)boundTimeInSamples, false);
	+ funcConfSim2StateTime3->setKandD((float)0, (float)1);
	+ confSim2StateTime->addLinearFunction(funcConfSim2StateTime3);
	+#ifdef PRINT
	+ confSim2StateTime->printFunctionBlock("funcBlock:confSim2StateTime");
	+#endif // PRINT
	+
	+ // ANOTHER STATE TIME
	+ LinearFunctionBlock *confDif2StateTime =
	+ new LinearFunctionBlock("funcBlock:confDif2StateTime");
	+ LinearFunction *funcConfDif2StateTime1 = new LinearFunction();
	+ funcConfDif2StateTime1->setDomain(false, true, (float)0);
	+ funcConfDif2StateTime1->setKandD((float)0, (float)1);
	+ confDif2StateTime->addLinearFunction(funcConfDif2StateTime1);
	+ LinearFunction *funcConfDif2StateTime2 = new LinearFunction();
	+ funcConfDif2StateTime2->setDomain(true, (float)0, true,
	+ (float)boundTimeInSamples);
	+ funcConfDif2StateTime2->setKandD((float)0, (float)1,
	+ (float)boundTimeInSamples, (float)0);
	+ confDif2StateTime->addLinearFunction(funcConfDif2StateTime2);
	+ LinearFunction *funcConfDif2StateTime3 = new LinearFunction();
	+ funcConfDif2StateTime3->setDomain(true, (float)boundTimeInSamples, false);
	+ funcConfDif2StateTime3->setKandD((float)0, (float)0);
	+ confDif2StateTime->addLinearFunction(funcConfDif2StateTime3);
	+#ifdef PRINT
	+ confDif2StateTime->printFunctionBlock("funcBlock:confDif2StateTime");
	+#endif // PRINT
	+
	+ /************************ FunctionBlocks Val/Inv State (NEU)
	+ * ************************/
	+
	+ // VALID STATE DEVIATION
	+ LinearFunctionBlock *confValidStateDev =
	+ new LinearFunctionBlock("funcBlock:confValidStateDev");
	+ LinearFunction *funcConfValidStateDev1 = new LinearFunction();
	+ funcConfValidStateDev1->setDomain(false, true, -1 * outerBoundSimDif);
	+ funcConfValidStateDev1->setKandD((float)0, (float)0);
	+ confValidStateDev->addLinearFunction(funcConfValidStateDev1);
	+ LinearFunction *funcConfValidStateDev2 = new LinearFunction();
	+ funcConfValidStateDev2->setDomain(true, -1 * outerBoundSimDif, true,
	+ -1 * innerBoundSimDif);
	+ funcConfValidStateDev2->setKandD(-1 * outerBoundSimDif, (float)0,
	+ -1 * innerBoundSimDif, (float)1);
	+ confValidStateDev->addLinearFunction(funcConfValidStateDev2);
	+ LinearFunction *funcConfValidStateDev3 = new LinearFunction();
	+ funcConfValidStateDev3->setDomain(true, -1 * innerBoundSimDif, true,
	+ innerBoundSimDif);
	+ funcConfValidStateDev3->setKandD((float)0, (float)1);
	+ confValidStateDev->addLinearFunction(funcConfValidStateDev3);
	+ LinearFunction *funcConfValidStateDev4 = new LinearFunction();
	+ funcConfValidStateDev4->setDomain(true, innerBoundSimDif, true,
	+ outerBoundSimDif);
	+ funcConfValidStateDev4->setKandD(innerBoundSimDif, (float)1, outerBoundSimDif,
	+ (float)0);
	+ confValidStateDev->addLinearFunction(funcConfValidStateDev4);
	+ LinearFunction *funcConfValidStateDev5 = new LinearFunction();
	+ funcConfValidStateDev5->setDomain(true, outerBoundSimDif, false);
	+ funcConfValidStateDev5->setKandD((float)0, (float)0);
	+ confValidStateDev->addLinearFunction(funcConfValidStateDev5);
	+#ifdef PRINT
	+ confValidStateDev->printFunctionBlock("funcBlock:confValidStateDev");
	+#endif // PRINT
	+
	+ // INVALID STATE DEVIATION
	+ LinearFunctionBlock *confInvalidStateDev =
	+ new LinearFunctionBlock("funcBlock:confInvalidStateDev");
	+ LinearFunction *funcConfInvalidStateDev1 = new LinearFunction();
	+ funcConfInvalidStateDev1->setDomain(false, true, -1 * outerBoundSimDif);
	+ funcConfInvalidStateDev1->setKandD((float)0, (float)1);
	+ confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev1);
	+ LinearFunction *funcConfInvalidStateDev2 = new LinearFunction();
	+ funcConfInvalidStateDev2->setDomain(true, -1 * outerBoundSimDif, true,
	+ -1 * innerBoundSimDif);
	+ funcConfInvalidStateDev2->setKandD(-1 * outerBoundSimDif, (float)1,
	+ -1 * innerBoundSimDif, (float)0);
	+ confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev2);
	+ LinearFunction *funcConfInvalidStateDev3 = new LinearFunction();
	+ funcConfInvalidStateDev3->setDomain(true, -1 * innerBoundSimDif, true,
	+ innerBoundSimDif);
	+ funcConfInvalidStateDev3->setKandD((float)0, (float)0);
	+ confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev3);
	+ LinearFunction *funcConfInvalidStateDev4 = new LinearFunction();
	+ funcConfInvalidStateDev4->setDomain(true, innerBoundSimDif, true,
	+ outerBoundSimDif);
	+ funcConfInvalidStateDev4->setKandD(innerBoundSimDif, (float)0,
	+ outerBoundSimDif, (float)1);
	+ confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev4);
	+ LinearFunction *funcConfInvalidStateDev5 = new LinearFunction();
	+ funcConfInvalidStateDev5->setDomain(true, outerBoundSimDif, false);
	+ funcConfInvalidStateDev5->setKandD((float)0, (float)1);
	+ confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev5);
	+#ifdef PRINT
	+ confInvalidStateDev->printFunctionBlock("funcBlock:confInvalidStateDev");
	+#endif // PRINT
	+
	+ // VALID STATE TIME
	+ LinearFunctionBlock *confValidStateTime =
	+ new LinearFunctionBlock("funcBlock:confValidStateTime");
	+ LinearFunction *funcConfValidStateTime1 = new LinearFunction();
	+ funcConfValidStateTime1->setDomain(false, true, (float)0);
	+ funcConfValidStateTime1->setKandD((float)0, (float)0);
	+ confValidStateTime->addLinearFunction(funcConfValidStateTime1);
	+ LinearFunction *funcConfValidStateTime2 = new LinearFunction();
	+ funcConfValidStateTime2->setDomain(true, (float)0, true,
	+ (float)boundTimeInSamples); // 10
	+ funcConfValidStateTime2->setKandD((float)0, (float)0,
	+ (float)boundTimeInSamples, (float)1);
	+ confValidStateTime->addLinearFunction(funcConfValidStateTime2);
	+ LinearFunction *funcConfValidStateTime3 = new LinearFunction();
	+ funcConfValidStateTime3->setDomain(true, (float)boundTimeInSamples, false);
	+ funcConfValidStateTime3->setKandD((float)0, (float)1);
	+ confValidStateTime->addLinearFunction(funcConfValidStateTime3);
	+#ifdef PRINT
	+ confValidStateTime->printFunctionBlock("funcBlock:confValidStateTime");
	+#endif // PRINT
	+
	+ // INVALID STATE TIME
	+ LinearFunctionBlock *confInvalidStateTime =
	+ new LinearFunctionBlock("funcBlock:confInvalidStateTime");
	+ LinearFunction *funcConfInvalidStateTime1 = new LinearFunction();
	+ funcConfInvalidStateTime1->setDomain(false, true, (float)0);
	+ funcConfInvalidStateTime1->setKandD((float)0, (float)1);
	+ confInvalidStateTime->addLinearFunction(funcConfInvalidStateTime1);
	+ LinearFunction *funcConfInvalidStateTime2 = new LinearFunction();
	+ funcConfInvalidStateTime2->setDomain(true, (float)0, true,
	+ (float)boundTimeInSamples);
	+ funcConfInvalidStateTime2->setKandD((float)0, (float)1,
	+ (float)boundTimeInSamples, (float)0);
	+ confInvalidStateTime->addLinearFunction(funcConfInvalidStateTime2);
	+ LinearFunction *funcConfInvalidStateTime3 = new LinearFunction();
	+ funcConfInvalidStateTime3->setDomain(true, (float)boundTimeInSamples, false);
	+ funcConfInvalidStateTime3->setKandD((float)0, (float)0);
	+ confInvalidStateTime->addLinearFunction(funcConfInvalidStateTime3);
	+#ifdef PRINT
	+ confInvalidStateTime->printFunctionBlock("funcBlock:confInvalidStateTime");
	+#endif // PRINT
	+
	+ /********************************** Functions NOT OK
	+ * **********************************/
	+
	+ LinearFunctionBlock *confStateDrifts =
	+ new LinearFunctionBlock("confidence:confStateDrifts");
	+ LinearFunction *functionConfidenceDriftDeviation1 = new LinearFunction();
	+ functionConfidenceDriftDeviation1->setDomain(false, true,
	+ -1 * outerBoundDrift);
	+ functionConfidenceDriftDeviation1->setKandD((float)0, (float)1);
	+ confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation1);
	+ LinearFunction *functionConfidenceDriftDeviation2 = new LinearFunction();
	+ functionConfidenceDriftDeviation2->setDomain(true, -1 * outerBoundDrift, true,
	+ -1 * innerBoundDrift);
	+ functionConfidenceDriftDeviation2->setKandD(-1 * outerBoundDrift, (float)1,
	+ -1 * innerBoundDrift, (float)0);
	+ confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation2);
	+ LinearFunction *functionConfidenceDriftDeviation3 = new LinearFunction();
	+ functionConfidenceDriftDeviation3->setDomain(true, -1 * innerBoundDrift, true,
	+ innerBoundDrift);
	+ functionConfidenceDriftDeviation3->setKandD((float)0, (float)0);
	+ confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation3);
	+ LinearFunction *functionConfidenceDriftDeviation4 = new LinearFunction();
	+ functionConfidenceDriftDeviation4->setDomain(true, innerBoundDrift, true,
	+ outerBoundDrift);
	+ functionConfidenceDriftDeviation4->setKandD(innerBoundDrift, (float)0,
	+ outerBoundDrift, (float)1);
	+ confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation4);
	+ LinearFunction *functionConfidenceDriftDeviation5 = new LinearFunction();
	+ functionConfidenceDriftDeviation5->setDomain(true, outerBoundDrift, false);
	+ functionConfidenceDriftDeviation5->setKandD((float)0, (float)1);
	+ confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation5);
	+#ifdef PRINT
	+ confStateDrifts.printFunctionBlock("confidence:confStateDrifts");
	+#endif
	+
	+ LinearFunctionBlock *confBroken =
	+ new LinearFunctionBlock("confidence:broken");
	+ LinearFunction *functionConfidenceBroken1 = new LinearFunction();
	+ functionConfidenceBroken1->setDomain(false, true, (float)0);
	+ functionConfidenceBroken1->setKandD((float)0, (float)0);
	+ confBroken->addLinearFunction(functionConfidenceBroken1);
	+ LinearFunction *functionConfidenceBroken2 = new LinearFunction();
	+ functionConfidenceBroken2->setDomain(true, (float)0, true,
	+ (float)boundBrokenTime);
	+ functionConfidenceBroken2->setKandD((float)0, (float)0,
	+ (float)boundBrokenTime, (float)1);
	+ confBroken->addLinearFunction(functionConfidenceBroken2);
	+ LinearFunction *functionConfidenceBroken3 = new LinearFunction();
	+ functionConfidenceBroken3->setDomain(true, (float)boundBrokenTime, false);
	+ functionConfidenceBroken3->setKandD((float)0, (float)1);
	+ confBroken->addLinearFunction(functionConfidenceBroken3);
	+#ifdef PRINT
	+ confBroken->printFunctionBlock("confidence:broken");
	+#endif // PRINT
	+
	+ /********************************** Mount Functions
	+ * **********************************/
	+ a_viabilityMonitor->get_stateHandler()->setMaxStateHistoryLength(
	+ boundTimeInSamples);
	+ a_viabilityMonitor->get_stateHandler()->setSimilarToStateFuzzyFunctions(
	+ confSim2StateDev, confSim2StateTime);
	+ a_viabilityMonitor->get_stateHandler()->setDifferentToStateFuzzyFunctions(
	+ confDif2StateDev, confDif2StateTime);
	+ a_viabilityMonitor->get_stateHandler()->setSimilarityInStateFuzzyFunctions(
	+ confValidStateDev, confValidStateTime);
	+ a_viabilityMonitor->get_stateHandler()->setUnsimilarityInStateFuzzyFunctions(
	+ confInvalidStateDev, confInvalidStateTime);
	+ a_viabilityMonitor->get_stateHandler()->setDriftFuzzyFunction(
	+ confStateDrifts);
	+ a_viabilityMonitor->get_stateHandler()->setBrokenFuzzyFunction(confBroken);
	+
	+
	+ // create testbench
	+ Testbench *tb = create_testbench("testbench");
	+
	+ // create CSV reader modules
	+ unsigned int ROW = 2;
	+ // inputs
	+ CSVreaderModule *csvr_voltage =
	+ create_CSVreaderModule("CSVR:Voltage", datasetPath, 4, ROW);
	+ // outputs
	+ CSVreaderModule *csvr_Temp1 =
	+ create_CSVreaderModule("CSVR:Temp1", datasetPath, 5, ROW);
	+ CSVreaderModule *csvr_Temp2 =
	+ create_CSVreaderModule("CSVR:Temp2", datasetPath, 6, ROW);
	+ CSVreaderModule *csvr_sharkyS =
	+ create_CSVreaderModule("CSVR:SharkyS", datasetPath, 7, ROW);
	+ CSVreaderModule *csvr_sharkyB =
	+ create_CSVreaderModule("CSVR:SharkyB", datasetPath, 8, ROW);
	+ CSVreaderModule *csvr_dyna =
	+ create_CSVreaderModule("CSVR:Dyna", datasetPath, 9, ROW);
	+ CSVreaderModule *csvr_riels =
	+ create_CSVreaderModule("CSVR:Riels", datasetPath, 10, ROW);
	+
	+
	+
	+
	+
	+ // register agents
	+ // low level agents - inputs
	+ register_agentInTestbench(tb, a_voltage);
	+ // low level agents - outputs
	+ register_agentInTestbench(tb, a_temp1);
	+ register_agentInTestbench(tb, a_temp2);
	+ register_agentInTestbench(tb, a_sharkyS);
	+ register_agentInTestbench(tb, a_sharkyB);
	+ register_agentInTestbench(tb, a_dyna);
	+ register_agentInTestbench(tb, a_riels);
	+ // high level agent
	+ register_agentInTestbench(tb, a_viabilityMonitor);
	+
	+ // register sensors with their csv-readers
	+ // inputs
	+ register_sensorInTestbench(tb, s_voltage, csvr_voltage);
	+ // outputs
	+ register_sensorInTestbench(tb, s_temp1, csvr_Temp1);
	+ register_sensorInTestbench(tb, s_temp2, csvr_Temp2);
	+ register_sensorInTestbench(tb, s_sharkyS, csvr_sharkyS);
	+ register_sensorInTestbench(tb, s_sharkyB, csvr_sharkyB);
	+ register_sensorInTestbench(tb, s_dyna, csvr_dyna);
	+ register_sensorInTestbench(tb, s_riels, csvr_riels);
	+
	+ // register sensor channels
	+ // sensor-agent channels
	+ // inputs
	+ register_channelInTestbench(tb, c_sa_voltage);
	+ // outputs
	+ register_channelInTestbench(tb, c_sa_temp1);
	+ register_channelInTestbench(tb, c_sa_temp2);
	+ register_channelInTestbench(tb, c_sa_sharkyS);
	+ register_channelInTestbench(tb, c_sa_sharkyB);
	+ register_channelInTestbench(tb, c_sa_dyna);
	+ register_channelInTestbench(tb, c_sa_riels);
	+
	+ // agent-agent channels
	+ // inputs
	+ register_channelInTestbench(tb, c_aa_voltage);
	+ // ouputs
	+ register_channelInTestbench(tb, c_aa_temp1);
	+ register_channelInTestbench(tb, c_aa_temp2);
	+ register_channelInTestbench(tb, c_aa_sharkyS);
	+ register_channelInTestbench(tb, c_aa_sharkyB);
	+ register_channelInTestbench(tb, c_aa_dyna);
	+ register_channelInTestbench(tb, c_aa_riels);
	+
	+#ifdef STOP_BEFORE_SIMULATING
	+ getchar();
	+#endif
	+
	+ tb->simulate(datasetLength);
	+}
	diff --git a/Version_Max_07_05_2018_CMake/src/configCAMforFluid.h b/Version_Max_07_05_2018_CMake/src/configCAMforFluid.h
	new file mode 100644
	index 0000000..5f694cd
	--- /dev/null
	+++ b/Version_Max_07_05_2018_CMake/src/configCAMforFluid.h
	@@ -0,0 +1,11 @@
	+#ifndef HEADER_FLUID_CONFIG
	+#define HEADER_FLUID_CONFIG
	+
	+void configAndStartFluidExperiment(
	+ char destinationPath, char datasetPath, char *datasetName,
	+ unsigned int datasetLength, float innerBoundSimDif, float outerBoundSimDif,
	+ int boundTimeInSamples, unsigned int discreteAveragePartitionSize,
	+ float innerBoundDrift, float outerBoundDrift, int boundBrokenTime,
	+ int downSamplingFactor);
	+
	+#endif
	\ No newline at end of file
	diff --git a/Version_Max_07_05_2018_CMake/src/configCAMforNewMotor.cpp b/Version_Max_07_05_2018_CMake/src/configCAMforNewMotor.cpp
	index 177f483..e5f6c8c 100644
	--- a/Version_Max_07_05_2018_CMake/src/configCAMforNewMotor.cpp
	+++ b/Version_Max_07_05_2018_CMake/src/configCAMforNewMotor.cpp
	@@ -1,517 +1,490 @@
	-#include "Agent.h"
	+#include "configCAMforNewMotor.h"
	+
	+#include "Agent.h"
	#include "CSVreaderModule.h"
	#include "Channel.h"
	#include "Sensor.h"
	#include "Testbench.h"
	#include "create_unit.h"
	#include "file_util.h"
	#include "inAgentsRegistrations.h"
	#include "mount_nodes.h"
	#include "register_in_testbench.h"
	#include "setupNode.h"

	#include "LinearFunction.h"
	#include "LinearFunctionBlock.h"

	-
	-#define PRINT
	-#define STOP_BEFORE_SIMULATING
	-
	+//#define PRINT
	+//#define STOP_BEFORE_SIMULATING

	void configAndStartNewMotorExperiment(
	- char destinationPath, char datasetPath, char *datasetName,
	- unsigned int datasetLength, float innerBoundSimDif, float outerBoundSimDif,
	- int boundTimeInSamples, float innerBoundDrift, float outerBoundDrift,
	- int boundBrokenTime, int downSamplingFactor) {
	+ char destinationPath, char datasetPath, char *datasetName,
	+ unsigned int datasetLength, float innerBoundSimDif, float outerBoundSimDif,
	+ int boundTimeInSamples, unsigned int discreteAveragePartitionSize,
	+ float innerBoundDrift, float outerBoundDrift, int boundBrokenTime,
	+ int downSamplingFactor) {

	- //config starts here
	+ // config starts here
	// create agents
	// low level agents - inputs
	- Agent* a_statorVoltage = create_agent("Stator Voltage");
	+ Agent *a_statorVoltage = create_agent("Stator Voltage");
	setWorkingCycleOfAgent(a_statorVoltage, downSamplingFactor);
	- Agent* a_inputFrequency = create_agent("Input Frequency");
	+ Agent *a_inputFrequency = create_agent("Input Frequency");
	setWorkingCycleOfAgent(a_inputFrequency, downSamplingFactor);
	- Agent* a_mechanicalTorque = create_agent("Mechanical Torque");
	+ Agent *a_mechanicalTorque = create_agent("Mechanical Torque");
	setWorkingCycleOfAgent(a_mechanicalTorque, downSamplingFactor);
	// low level agents - outputs
	- Agent* a_statorCurrent = create_agent("Stator Current");
	+ Agent *a_statorCurrent = create_agent("Stator Current");
	setWorkingCycleOfAgent(a_statorCurrent, downSamplingFactor);
	- Agent* a_electromagneticTorque = create_agent("Electromagnetic Torque");
	+ Agent *a_electromagneticTorque = create_agent("Electromagnetic Torque");
	setWorkingCycleOfAgent(a_electromagneticTorque, downSamplingFactor);
	- Agent* a_speed = create_agent("Speed");
	+ Agent *a_speed = create_agent("Speed");
	setWorkingCycleOfAgent(a_speed, downSamplingFactor);
	// high level agent
	- Agent* a_viabilityMonitor = create_agent("Viability Monitor");
	+ Agent *a_viabilityMonitor = create_agent("Viability Monitor");
	setWorkingCycleOfAgent(a_viabilityMonitor, downSamplingFactor);

	// create sensors
	// inputs
	- Sensor* s_statorVoltage = create_sensor("Stator Voltage");
	+ Sensor *s_statorVoltage = create_sensor("Stator Voltage");
	setWorkingCycleOfSensor(s_statorVoltage, downSamplingFactor);
	- Sensor* s_inputFrequency = create_sensor("Input Frequency");
	+ Sensor *s_inputFrequency = create_sensor("Input Frequency");
	setWorkingCycleOfSensor(s_inputFrequency, downSamplingFactor);
	- Sensor* s_mechanicalTorque = create_sensor("Mechanical Torque");
	+ Sensor *s_mechanicalTorque = create_sensor("Mechanical Torque");
	setWorkingCycleOfSensor(s_mechanicalTorque, downSamplingFactor);
	// outputs
	- Sensor* s_statorCurrent = create_sensor("Stator Current");
	+ Sensor *s_statorCurrent = create_sensor("Stator Current");
	setWorkingCycleOfSensor(s_statorCurrent, downSamplingFactor);
	- Sensor* s_electromagneticTorque = create_sensor("Electromagnetic Torque");
	+ Sensor *s_electromagneticTorque = create_sensor("Electromagnetic Torque");
	setWorkingCycleOfSensor(s_electromagneticTorque, downSamplingFactor);
	- Sensor* s_speed = create_sensor("Speed");
	+ Sensor *s_speed = create_sensor("Speed");
	setWorkingCycleOfSensor(s_speed, downSamplingFactor);

	// create channels for sensors
	// inputs
	- Channel* c_sa_statorVoltage = create_channel("Stator Voltage (SA)", 0);
	- Channel* c_sa_inputFrequency = create_channel("Input Frequency (SA)", 0);
	- Channel* c_sa_mechanicalTorque = create_channel("Mechanical Torque (SA)", 0);
	+ Channel *c_sa_statorVoltage = create_channel("Stator Voltage (SA)", 0);
	+ Channel *c_sa_inputFrequency = create_channel("Input Frequency (SA)", 0);
	+ Channel *c_sa_mechanicalTorque = create_channel("Mechanical Torque (SA)", 0);
	// outputs
	- Channel* c_sa_statorCurrent = create_channel("Stator Current (SA)", 0);
	- Channel* c_sa_electromagneticTorque =
	+ Channel *c_sa_statorCurrent = create_channel("Stator Current (SA)", 0);
	+ Channel *c_sa_electromagneticTorque =
	create_channel("Electromagnetic Torque (SA)", 0);
	- Channel* c_sa_speed = create_channel("Speed Sensor (SA)", 0);
	+ Channel *c_sa_speed = create_channel("Speed Sensor (SA)", 0);

	// create channels for sensors
	// inputs
	- Channel* c_aa_statorVoltage =
	+ Channel *c_aa_statorVoltage =
	create_channel("Stator Voltage (AA-UP)", MAX_BUFFER_LENGTH);
	- Channel* c_aa_inputFrequency =
	+ Channel *c_aa_inputFrequency =
	create_channel("Input Frequency (AA-UP)", MAX_BUFFER_LENGTH);
	- Channel* c_aa_mechanicalTorque =
	+ Channel *c_aa_mechanicalTorque =
	create_channel("Mechanical Torque (AA-UP)", MAX_BUFFER_LENGTH);
	// outputs
	- Channel* c_aa_statorCurrent =
	+ Channel *c_aa_statorCurrent =
	create_channel("Stator Current (AA-UP)", MAX_BUFFER_LENGTH);
	- Channel* c_aa_electromagneticTorque =
	+ Channel *c_aa_electromagneticTorque =
	create_channel("Electromagnetic Torque (AA-UP)", MAX_BUFFER_LENGTH);
	- Channel* c_aa_speed =
	+ Channel *c_aa_speed =
	create_channel("Speed Sensor (AA-UP)", MAX_BUFFER_LENGTH);

	-
	-
	-
	-
	-
	-
	-
	-
	// mount sensors in agents
	// inputs
	mount_sensorInAgent(a_statorVoltage, s_statorVoltage, c_sa_statorVoltage);
	- mount_sensorInAgent(a_inputFrequency, s_inputFrequency,
	- c_sa_inputFrequency);
	+ mount_sensorInAgent(a_inputFrequency, s_inputFrequency, c_sa_inputFrequency);
	mount_sensorInAgent(a_mechanicalTorque, s_mechanicalTorque,
	c_sa_mechanicalTorque);
	// outputs
	mount_sensorInAgent(a_statorCurrent, s_statorCurrent, c_sa_statorCurrent);
	mount_sensorInAgent(a_electromagneticTorque, s_electromagneticTorque,
	c_sa_electromagneticTorque);
	mount_sensorInAgent(a_speed, s_speed, c_sa_speed);

	// mount agents in agent(s)
	// inputs
	- mount_agentInAgent(a_viabilityMonitor, a_statorVoltage,
	- c_aa_statorVoltage);
	- mount_agentInAgent(a_viabilityMonitor, a_inputFrequency,
	- c_aa_inputFrequency);
	+ mount_agentInAgent(a_viabilityMonitor, a_statorVoltage, c_aa_statorVoltage);
	+ mount_agentInAgent(a_viabilityMonitor, a_inputFrequency, c_aa_inputFrequency);
	mount_agentInAgent(a_viabilityMonitor, a_mechanicalTorque,
	c_aa_mechanicalTorque);
	// outputs
	- mount_agentInAgent(a_viabilityMonitor, a_statorCurrent,
	- c_aa_statorCurrent);
	+ mount_agentInAgent(a_viabilityMonitor, a_statorCurrent, c_aa_statorCurrent);
	mount_agentInAgent(a_viabilityMonitor, a_electromagneticTorque,
	c_aa_electromagneticTorque);
	mount_agentInAgent(a_viabilityMonitor, a_speed, c_aa_speed);

	+ // set State Handler in Master Agent and Initialize an CSVWriter for the CAM
	+ // output
	+ a_viabilityMonitor->set_stateHandler("CSVW:CAMoutput", destinationPath);
	+
	// register agents in agents' stateHandler
	// inputs
	registerSlaveAgentAsInputVariableInStateHandler(a_viabilityMonitor,
	c_aa_statorVoltage);
	registerSlaveAgentAsInputVariableInStateHandler(a_viabilityMonitor,
	c_aa_inputFrequency);
	registerSlaveAgentAsInputVariableInStateHandler(a_viabilityMonitor,
	c_aa_mechanicalTorque);
	// outputs
	registerSlaveAgentAsOutputVariableInStateHandler(a_viabilityMonitor,
	c_aa_statorCurrent);
	registerSlaveAgentAsOutputVariableInStateHandler(a_viabilityMonitor,
	c_aa_electromagneticTorque);
	registerSlaveAgentAsOutputVariableInStateHandler(a_viabilityMonitor,
	c_aa_speed);

	// SAME STATE DEVIATION
	- LinearFunctionBlock confSim2StateDev("funcBlock:confSim2StateDev");
	- LinearFunction funcConfSim2StateDev1;
	- funcConfSim2StateDev1.setDomain(false, true, -1 * outerBoundSimDif);
	- funcConfSim2StateDev1.setKandD((float)0, (float)0);
	- confSim2StateDev.addLinearFunction(&funcConfSim2StateDev1);
	- LinearFunction funcConfSim2StateDev2;
	- funcConfSim2StateDev2.setDomain(true, -1 * outerBoundSimDif, true,
	- -1 * innerBoundSimDif);
	- funcConfSim2StateDev2.setKandD(-1 * outerBoundSimDif, (float)0,
	- -1 * innerBoundSimDif, (float)1);
	- confSim2StateDev.addLinearFunction(&funcConfSim2StateDev2);
	- LinearFunction funcConfSim2StateDev3;
	- funcConfSim2StateDev3.setDomain(true, -1 * innerBoundSimDif, true,
	- innerBoundSimDif);
	- funcConfSim2StateDev3.setKandD((float)0, (float)1);
	- confSim2StateDev.addLinearFunction(&funcConfSim2StateDev3);
	- LinearFunction funcConfSim2StateDev4;
	- funcConfSim2StateDev4.setDomain(true, innerBoundSimDif, true,
	- outerBoundSimDif);
	- funcConfSim2StateDev4.setKandD(innerBoundSimDif, (float)1, outerBoundSimDif,
	- (float)0);
	- confSim2StateDev.addLinearFunction(&funcConfSim2StateDev4);
	- LinearFunction funcConfSim2StateDev5;
	- funcConfSim2StateDev5.setDomain(true, outerBoundSimDif, false);
	- funcConfSim2StateDev5.setKandD((float)0, (float)0);
	- confSim2StateDev.addLinearFunction(&funcConfSim2StateDev5);
	+ LinearFunctionBlock *confSim2StateDev =
	+ new LinearFunctionBlock("funcBlock:confSim2StateDev");
	+ LinearFunction *funcConfSim2StateDev1 = new LinearFunction();
	+ funcConfSim2StateDev1->setDomain(false, true, -1 * outerBoundSimDif);
	+ funcConfSim2StateDev1->setKandD((float)0, (float)0);
	+ confSim2StateDev->addLinearFunction(funcConfSim2StateDev1);
	+ LinearFunction *funcConfSim2StateDev2 = new LinearFunction();
	+ funcConfSim2StateDev2->setDomain(true, -1 * outerBoundSimDif, true,
	+ -1 * innerBoundSimDif);
	+ funcConfSim2StateDev2->setKandD(-1 * outerBoundSimDif, (float)0,
	+ -1 * innerBoundSimDif, (float)1);
	+ confSim2StateDev->addLinearFunction(funcConfSim2StateDev2);
	+ LinearFunction *funcConfSim2StateDev3 = new LinearFunction();
	+ funcConfSim2StateDev3->setDomain(true, -1 * innerBoundSimDif, true,
	+ innerBoundSimDif);
	+ funcConfSim2StateDev3->setKandD((float)0, (float)1);
	+ confSim2StateDev->addLinearFunction(funcConfSim2StateDev3);
	+ LinearFunction *funcConfSim2StateDev4 = new LinearFunction();
	+ funcConfSim2StateDev4->setDomain(true, innerBoundSimDif, true,
	+ outerBoundSimDif);
	+ funcConfSim2StateDev4->setKandD(innerBoundSimDif, (float)1, outerBoundSimDif,
	+ (float)0);
	+ confSim2StateDev->addLinearFunction(funcConfSim2StateDev4);
	+ LinearFunction *funcConfSim2StateDev5 = new LinearFunction();
	+ funcConfSim2StateDev5->setDomain(true, outerBoundSimDif, false);
	+ funcConfSim2StateDev5->setKandD((float)0, (float)0);
	+ confSim2StateDev->addLinearFunction(funcConfSim2StateDev5);
	#ifdef PRINT
	- confSim2StateDev.printFunctionBlock("funcBlock:confSim2StateDev");
	+ confSim2StateDev->printFunctionBlock("funcBlock:confSim2StateDev");
	#endif // PRINT

	// ANOTHER STATE DEVIATION
	- LinearFunctionBlock confDif2StateDev("funcBlock:confDif2StateDev");
	- LinearFunction funcConfDif2StateDev1;
	- funcConfDif2StateDev1.setDomain(false, true, -1 * outerBoundSimDif);
	- funcConfDif2StateDev1.setKandD((float)0, (float)1);
	- confDif2StateDev.addLinearFunction(&funcConfDif2StateDev1);
	- LinearFunction funcConfDif2StateDev2;
	- funcConfDif2StateDev2.setDomain(true, -1 * outerBoundSimDif, true,
	- -1 * innerBoundSimDif);
	- funcConfDif2StateDev2.setKandD(-1 * outerBoundSimDif, (float)1,
	- -1 * innerBoundSimDif, (float)0);
	- confDif2StateDev.addLinearFunction(&funcConfDif2StateDev2);
	- LinearFunction funcConfDif2StateDev3;
	- funcConfDif2StateDev3.setDomain(true, -1 * innerBoundSimDif, true,
	- innerBoundSimDif);
	- funcConfDif2StateDev3.setKandD((float)0, (float)0);
	- confDif2StateDev.addLinearFunction(&funcConfDif2StateDev3);
	- LinearFunction funcConfDif2StateDev4;
	- funcConfDif2StateDev4.setDomain(true, innerBoundSimDif, true,
	- outerBoundSimDif);
	- funcConfDif2StateDev4.setKandD(innerBoundSimDif, (float)0, outerBoundSimDif,
	- (float)1);
	- confDif2StateDev.addLinearFunction(&funcConfDif2StateDev4);
	- LinearFunction funcConfDif2StateDev5;
	- funcConfDif2StateDev5.setDomain(true, outerBoundSimDif, false);
	- funcConfDif2StateDev5.setKandD((float)0, (float)1);
	- confDif2StateDev.addLinearFunction(&funcConfDif2StateDev5);
	+ LinearFunctionBlock *confDif2StateDev =
	+ new LinearFunctionBlock("funcBlock:confDif2StateDev");
	+ LinearFunction *funcConfDif2StateDev1 = new LinearFunction();
	+ funcConfDif2StateDev1->setDomain(false, true, -1 * outerBoundSimDif);
	+ funcConfDif2StateDev1->setKandD((float)0, (float)1);
	+ confDif2StateDev->addLinearFunction(funcConfDif2StateDev1);
	+ LinearFunction *funcConfDif2StateDev2 = new LinearFunction();
	+ funcConfDif2StateDev2->setDomain(true, -1 * outerBoundSimDif, true,
	+ -1 * innerBoundSimDif);
	+ funcConfDif2StateDev2->setKandD(-1 * outerBoundSimDif, (float)1,
	+ -1 * innerBoundSimDif, (float)0);
	+ confDif2StateDev->addLinearFunction(funcConfDif2StateDev2);
	+ LinearFunction *funcConfDif2StateDev3 = new LinearFunction();
	+ funcConfDif2StateDev3->setDomain(true, -1 * innerBoundSimDif, true,
	+ innerBoundSimDif);
	+ funcConfDif2StateDev3->setKandD((float)0, (float)0);
	+ confDif2StateDev->addLinearFunction(funcConfDif2StateDev3);
	+ LinearFunction *funcConfDif2StateDev4 = new LinearFunction();
	+ funcConfDif2StateDev4->setDomain(true, innerBoundSimDif, true,
	+ outerBoundSimDif);
	+ funcConfDif2StateDev4->setKandD(innerBoundSimDif, (float)0, outerBoundSimDif,
	+ (float)1);
	+ confDif2StateDev->addLinearFunction(funcConfDif2StateDev4);
	+ LinearFunction *funcConfDif2StateDev5 = new LinearFunction();
	+ funcConfDif2StateDev5->setDomain(true, outerBoundSimDif, false);
	+ funcConfDif2StateDev5->setKandD((float)0, (float)1);
	+ confDif2StateDev->addLinearFunction(funcConfDif2StateDev5);
	#ifdef PRINT
	- confDif2StateDev.printFunctionBlock("funcBlock:confDif2StateDev");
	+ confDif2StateDev->printFunctionBlock("funcBlock:confDif2StateDev");
	#endif // PRINT

	// SAME STATE TIME
	- LinearFunctionBlock confSim2StateTime("funcBlock:confSim2StateTime");
	- LinearFunction funcConfSim2StateTime1;
	- funcConfSim2StateTime1.setDomain(false, true, (float)0);
	- funcConfSim2StateTime1.setKandD((float)0, (float)0);
	- confSim2StateTime.addLinearFunction(&funcConfSim2StateTime1);
	- LinearFunction funcConfSim2StateTime2;
	- funcConfSim2StateTime2.setDomain(true, (float)0, true,
	- (float)boundTimeInSamples);
	- funcConfSim2StateTime2.setKandD((float)0, (float)0, (float)boundTimeInSamples,
	- (float)1);
	- confSim2StateTime.addLinearFunction(&funcConfSim2StateTime2);
	- LinearFunction funcConfSim2StateTime3;
	- funcConfSim2StateTime3.setDomain(true, (float)boundTimeInSamples, false);
	- funcConfSim2StateTime3.setKandD((float)0, (float)1);
	- confSim2StateTime.addLinearFunction(&funcConfSim2StateTime3);
	+ LinearFunctionBlock *confSim2StateTime =
	+ new LinearFunctionBlock("funcBlock:confSim2StateTime");
	+ LinearFunction *funcConfSim2StateTime1 = new LinearFunction();
	+ funcConfSim2StateTime1->setDomain(false, true, (float)0);
	+ funcConfSim2StateTime1->setKandD((float)0, (float)0);
	+ confSim2StateTime->addLinearFunction(funcConfSim2StateTime1);
	+ LinearFunction *funcConfSim2StateTime2 = new LinearFunction();
	+ funcConfSim2StateTime2->setDomain(true, (float)0, true,
	+ (float)boundTimeInSamples);
	+ funcConfSim2StateTime2->setKandD((float)0, (float)0,
	+ (float)boundTimeInSamples, (float)1);
	+ confSim2StateTime->addLinearFunction(funcConfSim2StateTime2);
	+ LinearFunction *funcConfSim2StateTime3 = new LinearFunction();
	+ funcConfSim2StateTime3->setDomain(true, (float)boundTimeInSamples, false);
	+ funcConfSim2StateTime3->setKandD((float)0, (float)1);
	+ confSim2StateTime->addLinearFunction(funcConfSim2StateTime3);
	#ifdef PRINT
	- confSim2StateTime.printFunctionBlock("funcBlock:confSim2StateTime");
	+ confSim2StateTime->printFunctionBlock("funcBlock:confSim2StateTime");
	#endif // PRINT

	// ANOTHER STATE TIME
	- LinearFunctionBlock confDif2StateTime("funcBlock:confDif2StateTime");
	- LinearFunction funcConfDif2StateTime1;
	- funcConfDif2StateTime1.setDomain(false, true, (float)0);
	- funcConfDif2StateTime1.setKandD((float)0, (float)1);
	- confDif2StateTime.addLinearFunction(&funcConfDif2StateTime1);
	- LinearFunction funcConfDif2StateTime2;
	- funcConfDif2StateTime2.setDomain(true, (float)0, true,
	- (float)boundTimeInSamples);
	- funcConfDif2StateTime2.setKandD((float)0, (float)1, (float)boundTimeInSamples,
	- (float)0);
	- confDif2StateTime.addLinearFunction(&funcConfDif2StateTime2);
	- LinearFunction funcConfDif2StateTime3;
	- funcConfDif2StateTime3.setDomain(true, (float)boundTimeInSamples, false);
	- funcConfDif2StateTime3.setKandD((float)0, (float)0);
	- confDif2StateTime.addLinearFunction(&funcConfDif2StateTime3);
	+ LinearFunctionBlock *confDif2StateTime =
	+ new LinearFunctionBlock("funcBlock:confDif2StateTime");
	+ LinearFunction *funcConfDif2StateTime1 = new LinearFunction();
	+ funcConfDif2StateTime1->setDomain(false, true, (float)0);
	+ funcConfDif2StateTime1->setKandD((float)0, (float)1);
	+ confDif2StateTime->addLinearFunction(funcConfDif2StateTime1);
	+ LinearFunction *funcConfDif2StateTime2 = new LinearFunction();
	+ funcConfDif2StateTime2->setDomain(true, (float)0, true,
	+ (float)boundTimeInSamples);
	+ funcConfDif2StateTime2->setKandD((float)0, (float)1,
	+ (float)boundTimeInSamples, (float)0);
	+ confDif2StateTime->addLinearFunction(funcConfDif2StateTime2);
	+ LinearFunction *funcConfDif2StateTime3 = new LinearFunction();
	+ funcConfDif2StateTime3->setDomain(true, (float)boundTimeInSamples, false);
	+ funcConfDif2StateTime3->setKandD((float)0, (float)0);
	+ confDif2StateTime->addLinearFunction(funcConfDif2StateTime3);
	#ifdef PRINT
	- confDif2StateTime.printFunctionBlock("funcBlock:confDif2StateTime");
	+ confDif2StateTime->printFunctionBlock("funcBlock:confDif2StateTime");
	#endif // PRINT

	/************************ FunctionBlocks Val/Inv State (NEU)
	* ************************/

	// VALID STATE DEVIATION
	- LinearFunctionBlock confValidStateDev("funcBlock:confValidStateDev");
	- LinearFunction funcConfValidStateDev1;
	- funcConfValidStateDev1.setDomain(false, true, -1 * outerBoundSimDif);
	- funcConfValidStateDev1.setKandD((float)0, (float)0);
	- confValidStateDev.addLinearFunction(&funcConfValidStateDev1);
	- LinearFunction funcConfValidStateDev2;
	- funcConfValidStateDev2.setDomain(true, -1 * outerBoundSimDif, true,
	- -1 * innerBoundSimDif);
	- funcConfValidStateDev2.setKandD(-1 * outerBoundSimDif, (float)0,
	- -1 * innerBoundSimDif, (float)1);
	- confValidStateDev.addLinearFunction(&funcConfValidStateDev2);
	- LinearFunction funcConfValidStateDev3;
	- funcConfValidStateDev3.setDomain(true, -1 * innerBoundSimDif, true,
	- innerBoundSimDif);
	- funcConfValidStateDev3.setKandD((float)0, (float)1);
	- confValidStateDev.addLinearFunction(&funcConfValidStateDev3);
	- LinearFunction funcConfValidStateDev4;
	- funcConfValidStateDev4.setDomain(true, innerBoundSimDif, true,
	- outerBoundSimDif);
	- funcConfValidStateDev4.setKandD(innerBoundSimDif, (float)1, outerBoundSimDif,
	- (float)0);
	- confValidStateDev.addLinearFunction(&funcConfValidStateDev4);
	- LinearFunction funcConfValidStateDev5;
	- funcConfValidStateDev5.setDomain(true, outerBoundSimDif, false);
	- funcConfValidStateDev5.setKandD((float)0, (float)0);
	- confValidStateDev.addLinearFunction(&funcConfValidStateDev5);
	+ LinearFunctionBlock *confValidStateDev =
	+ new LinearFunctionBlock("funcBlock:confValidStateDev");
	+ LinearFunction *funcConfValidStateDev1 = new LinearFunction();
	+ funcConfValidStateDev1->setDomain(false, true, -1 * outerBoundSimDif);
	+ funcConfValidStateDev1->setKandD((float)0, (float)0);
	+ confValidStateDev->addLinearFunction(funcConfValidStateDev1);
	+ LinearFunction *funcConfValidStateDev2 = new LinearFunction();
	+ funcConfValidStateDev2->setDomain(true, -1 * outerBoundSimDif, true,
	+ -1 * innerBoundSimDif);
	+ funcConfValidStateDev2->setKandD(-1 * outerBoundSimDif, (float)0,
	+ -1 * innerBoundSimDif, (float)1);
	+ confValidStateDev->addLinearFunction(funcConfValidStateDev2);
	+ LinearFunction *funcConfValidStateDev3 = new LinearFunction();
	+ funcConfValidStateDev3->setDomain(true, -1 * innerBoundSimDif, true,
	+ innerBoundSimDif);
	+ funcConfValidStateDev3->setKandD((float)0, (float)1);
	+ confValidStateDev->addLinearFunction(funcConfValidStateDev3);
	+ LinearFunction *funcConfValidStateDev4 = new LinearFunction();
	+ funcConfValidStateDev4->setDomain(true, innerBoundSimDif, true,
	+ outerBoundSimDif);
	+ funcConfValidStateDev4->setKandD(innerBoundSimDif, (float)1, outerBoundSimDif,
	+ (float)0);
	+ confValidStateDev->addLinearFunction(funcConfValidStateDev4);
	+ LinearFunction *funcConfValidStateDev5 = new LinearFunction();
	+ funcConfValidStateDev5->setDomain(true, outerBoundSimDif, false);
	+ funcConfValidStateDev5->setKandD((float)0, (float)0);
	+ confValidStateDev->addLinearFunction(funcConfValidStateDev5);
	#ifdef PRINT
	- confValidStateDev.printFunctionBlock("funcBlock:confValidStateDev");
	+ confValidStateDev->printFunctionBlock("funcBlock:confValidStateDev");
	#endif // PRINT

	// INVALID STATE DEVIATION
	- LinearFunctionBlock confInvalidStateDev("funcBlock:confInvalidStateDev");
	- LinearFunction funcConfInvalidStateDev1;
	- funcConfInvalidStateDev1.setDomain(false, true, -1 * outerBoundSimDif);
	- funcConfInvalidStateDev1.setKandD((float)0, (float)1);
	- confInvalidStateDev.addLinearFunction(&funcConfInvalidStateDev1);
	- LinearFunction funcConfInvalidStateDev2;
	- funcConfInvalidStateDev2.setDomain(true, -1 * outerBoundSimDif, true,
	- -1 * innerBoundSimDif);
	- funcConfInvalidStateDev2.setKandD(-1 * outerBoundSimDif, (float)1,
	- -1 * innerBoundSimDif, (float)0);
	- confInvalidStateDev.addLinearFunction(&funcConfInvalidStateDev2);
	- LinearFunction funcConfInvalidStateDev3;
	- funcConfInvalidStateDev3.setDomain(true, -1 * innerBoundSimDif, true,
	- innerBoundSimDif);
	- funcConfInvalidStateDev3.setKandD((float)0, (float)0);
	- confInvalidStateDev.addLinearFunction(&funcConfInvalidStateDev3);
	- LinearFunction funcConfInvalidStateDev4;
	- funcConfInvalidStateDev4.setDomain(true, innerBoundSimDif, true,
	- outerBoundSimDif);
	- funcConfInvalidStateDev4.setKandD(innerBoundSimDif, (float)0,
	- outerBoundSimDif, (float)1);
	- confInvalidStateDev.addLinearFunction(&funcConfInvalidStateDev4);
	- LinearFunction funcConfInvalidStateDev5;
	- funcConfInvalidStateDev5.setDomain(true, outerBoundSimDif, false);
	- funcConfInvalidStateDev5.setKandD((float)0, (float)1);
	- confInvalidStateDev.addLinearFunction(&funcConfInvalidStateDev5);
	+ LinearFunctionBlock *confInvalidStateDev =
	+ new LinearFunctionBlock("funcBlock:confInvalidStateDev");
	+ LinearFunction *funcConfInvalidStateDev1 = new LinearFunction();
	+ funcConfInvalidStateDev1->setDomain(false, true, -1 * outerBoundSimDif);
	+ funcConfInvalidStateDev1->setKandD((float)0, (float)1);
	+ confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev1);
	+ LinearFunction *funcConfInvalidStateDev2 = new LinearFunction();
	+ funcConfInvalidStateDev2->setDomain(true, -1 * outerBoundSimDif, true,
	+ -1 * innerBoundSimDif);
	+ funcConfInvalidStateDev2->setKandD(-1 * outerBoundSimDif, (float)1,
	+ -1 * innerBoundSimDif, (float)0);
	+ confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev2);
	+ LinearFunction *funcConfInvalidStateDev3 = new LinearFunction();
	+ funcConfInvalidStateDev3->setDomain(true, -1 * innerBoundSimDif, true,
	+ innerBoundSimDif);
	+ funcConfInvalidStateDev3->setKandD((float)0, (float)0);
	+ confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev3);
	+ LinearFunction *funcConfInvalidStateDev4 = new LinearFunction();
	+ funcConfInvalidStateDev4->setDomain(true, innerBoundSimDif, true,
	+ outerBoundSimDif);
	+ funcConfInvalidStateDev4->setKandD(innerBoundSimDif, (float)0,
	+ outerBoundSimDif, (float)1);
	+ confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev4);
	+ LinearFunction *funcConfInvalidStateDev5 = new LinearFunction();
	+ funcConfInvalidStateDev5->setDomain(true, outerBoundSimDif, false);
	+ funcConfInvalidStateDev5->setKandD((float)0, (float)1);
	+ confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev5);
	#ifdef PRINT
	- confInvalidStateDev.printFunctionBlock("funcBlock:confInvalidStateDev");
	+ confInvalidStateDev->printFunctionBlock("funcBlock:confInvalidStateDev");
	#endif // PRINT

	// VALID STATE TIME
	- LinearFunctionBlock confValidStateTime("funcBlock:confValidStateTime");
	- LinearFunction funcConfValidStateTime1;
	- funcConfValidStateTime1.setDomain(false, true, (float)0);
	- funcConfValidStateTime1.setKandD((float)0, (float)0);
	- confValidStateTime.addLinearFunction(&funcConfValidStateTime1);
	- LinearFunction funcConfValidStateTime2;
	- funcConfValidStateTime2.setDomain(true, (float)0, true,
	- (float)boundTimeInSamples); // 10
	- funcConfValidStateTime2.setKandD((float)0, (float)0,
	- (float)boundTimeInSamples, (float)1);
	- confValidStateTime.addLinearFunction(&funcConfValidStateTime2);
	- LinearFunction funcConfValidStateTime3;
	- funcConfValidStateTime3.setDomain(true, (float)boundTimeInSamples, false);
	- funcConfValidStateTime3.setKandD((float)0, (float)1);
	- confValidStateTime.addLinearFunction(&funcConfValidStateTime3);
	+ LinearFunctionBlock *confValidStateTime =
	+ new LinearFunctionBlock("funcBlock:confValidStateTime");
	+ LinearFunction *funcConfValidStateTime1 = new LinearFunction();
	+ funcConfValidStateTime1->setDomain(false, true, (float)0);
	+ funcConfValidStateTime1->setKandD((float)0, (float)0);
	+ confValidStateTime->addLinearFunction(funcConfValidStateTime1);
	+ LinearFunction *funcConfValidStateTime2 = new LinearFunction();
	+ funcConfValidStateTime2->setDomain(true, (float)0, true,
	+ (float)boundTimeInSamples); // 10
	+ funcConfValidStateTime2->setKandD((float)0, (float)0,
	+ (float)boundTimeInSamples, (float)1);
	+ confValidStateTime->addLinearFunction(funcConfValidStateTime2);
	+ LinearFunction *funcConfValidStateTime3 = new LinearFunction();
	+ funcConfValidStateTime3->setDomain(true, (float)boundTimeInSamples, false);
	+ funcConfValidStateTime3->setKandD((float)0, (float)1);
	+ confValidStateTime->addLinearFunction(funcConfValidStateTime3);
	#ifdef PRINT
	- confValidStateTime.printFunctionBlock("funcBlock:confValidStateTime");
	+ confValidStateTime->printFunctionBlock("funcBlock:confValidStateTime");
	#endif // PRINT

	// INVALID STATE TIME
	- LinearFunctionBlock confInvalidStateTime("funcBlock:confInvalidStateTime");
	- LinearFunction funcConfInvalidStateTime1;
	- funcConfInvalidStateTime1.setDomain(false, true, (float)0);
	- funcConfInvalidStateTime1.setKandD((float)0, (float)1);
	- confInvalidStateTime.addLinearFunction(&funcConfInvalidStateTime1);
	- LinearFunction funcConfInvalidStateTime2;
	- funcConfInvalidStateTime2.setDomain(true, (float)0, true,
	- (float)boundTimeInSamples);
	- funcConfInvalidStateTime2.setKandD((float)0, (float)1,
	- (float)boundTimeInSamples,
	- (float)0);
	- confInvalidStateTime.addLinearFunction(&funcConfInvalidStateTime2);
	- LinearFunction funcConfInvalidStateTime3;
	- funcConfInvalidStateTime3.setDomain(true, (float)boundTimeInSamples, false);
	- funcConfInvalidStateTime3.setKandD((float)0, (float)0);
	- confInvalidStateTime.addLinearFunction(&funcConfInvalidStateTime3);
	+ LinearFunctionBlock *confInvalidStateTime =
	+ new LinearFunctionBlock("funcBlock:confInvalidStateTime");
	+ LinearFunction *funcConfInvalidStateTime1 = new LinearFunction();
	+ funcConfInvalidStateTime1->setDomain(false, true, (float)0);
	+ funcConfInvalidStateTime1->setKandD((float)0, (float)1);
	+ confInvalidStateTime->addLinearFunction(funcConfInvalidStateTime1);
	+ LinearFunction *funcConfInvalidStateTime2 = new LinearFunction();
	+ funcConfInvalidStateTime2->setDomain(true, (float)0, true,
	+ (float)boundTimeInSamples);
	+ funcConfInvalidStateTime2->setKandD((float)0, (float)1,
	+ (float)boundTimeInSamples, (float)0);
	+ confInvalidStateTime->addLinearFunction(funcConfInvalidStateTime2);
	+ LinearFunction *funcConfInvalidStateTime3 = new LinearFunction();
	+ funcConfInvalidStateTime3->setDomain(true, (float)boundTimeInSamples, false);
	+ funcConfInvalidStateTime3->setKandD((float)0, (float)0);
	+ confInvalidStateTime->addLinearFunction(funcConfInvalidStateTime3);
	#ifdef PRINT
	- confInvalidStateTime.printFunctionBlock("funcBlock:confInvalidStateTime");
	+ confInvalidStateTime->printFunctionBlock("funcBlock:confInvalidStateTime");
	#endif // PRINT

	/********************************** Functions NOT OK
	* **********************************/

	- LinearFunctionBlock confStateDrifts("confidence:confStateDrifts");
	- LinearFunction functionConfidenceDriftDeviation1;
	- functionConfidenceDriftDeviation1.setDomain(false, true,
	- -1 * outerBoundDrift);
	- functionConfidenceDriftDeviation1.setKandD((float)0, (float)1);
	- confStateDrifts.addLinearFunction(&functionConfidenceDriftDeviation1);
	- LinearFunction functionConfidenceDriftDeviation2;
	- functionConfidenceDriftDeviation2.setDomain(true, -1 * outerBoundDrift, true,
	- -1 * outerBoundDrift);
	- functionConfidenceDriftDeviation2.setKandD(-1 * outerBoundDrift, (float)1,
	- -1 * outerBoundDrift, (float)0);
	- confStateDrifts.addLinearFunction(&functionConfidenceDriftDeviation2);
	- LinearFunction functionConfidenceDriftDeviation3;
	- functionConfidenceDriftDeviation3.setDomain(true, -1 * outerBoundDrift, true,
	- outerBoundDrift);
	- functionConfidenceDriftDeviation3.setKandD((float)0, (float)0);
	- confStateDrifts.addLinearFunction(&functionConfidenceDriftDeviation3);
	- LinearFunction functionConfidenceDriftDeviation4;
	- functionConfidenceDriftDeviation4.setDomain(true, outerBoundDrift, true,
	- outerBoundDrift);
	- functionConfidenceDriftDeviation4.setKandD(outerBoundDrift, (float)0,
	- outerBoundDrift, (float)1);
	- confStateDrifts.addLinearFunction(&functionConfidenceDriftDeviation4);
	- LinearFunction functionConfidenceDriftDeviation5;
	- functionConfidenceDriftDeviation5.setDomain(true, outerBoundDrift, false);
	- functionConfidenceDriftDeviation5.setKandD((float)0, (float)1);
	- confStateDrifts.addLinearFunction(&functionConfidenceDriftDeviation5);
	+ LinearFunctionBlock *confStateDrifts =
	+ new LinearFunctionBlock("confidence:confStateDrifts");
	+ LinearFunction *functionConfidenceDriftDeviation1 = new LinearFunction();
	+ functionConfidenceDriftDeviation1->setDomain(false, true,
	+ -1 * outerBoundDrift);
	+ functionConfidenceDriftDeviation1->setKandD((float)0, (float)1);
	+ confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation1);
	+ LinearFunction *functionConfidenceDriftDeviation2 = new LinearFunction();
	+ functionConfidenceDriftDeviation2->setDomain(true, -1 * outerBoundDrift, true,
	+ -1 * innerBoundDrift);
	+ functionConfidenceDriftDeviation2->setKandD(-1 * outerBoundDrift, (float)1,
	+ -1 * innerBoundDrift, (float)0);
	+ confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation2);
	+ LinearFunction *functionConfidenceDriftDeviation3 = new LinearFunction();
	+ functionConfidenceDriftDeviation3->setDomain(true, -1 * innerBoundDrift, true,
	+ innerBoundDrift);
	+ functionConfidenceDriftDeviation3->setKandD((float)0, (float)0);
	+ confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation3);
	+ LinearFunction *functionConfidenceDriftDeviation4 = new LinearFunction();
	+ functionConfidenceDriftDeviation4->setDomain(true, innerBoundDrift, true,
	+ outerBoundDrift);
	+ functionConfidenceDriftDeviation4->setKandD(innerBoundDrift, (float)0,
	+ outerBoundDrift, (float)1);
	+ confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation4);
	+ LinearFunction *functionConfidenceDriftDeviation5 = new LinearFunction();
	+ functionConfidenceDriftDeviation5->setDomain(true, outerBoundDrift, false);
	+ functionConfidenceDriftDeviation5->setKandD((float)0, (float)1);
	+ confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation5);
	#ifdef PRINT
	confStateDrifts.printFunctionBlock("confidence:confStateDrifts");
	-#endif // PRINT
	+#endif

	- LinearFunctionBlock confBroken("confidence:broken");
	- LinearFunction functionConfidenceBroken1;
	- functionConfidenceBroken1.setDomain(false, true, (float)0);
	- functionConfidenceBroken1.setKandD((float)0, (float)0);
	- confBroken.addLinearFunction(&functionConfidenceBroken1);
	- LinearFunction functionConfidenceBroken2;
	- functionConfidenceBroken2.setDomain(true, (float)0, true,
	- (float)boundBrokenTime);
	- functionConfidenceBroken2.setKandD((float)0, (float)0, (float)boundBrokenTime,
	- (float)1);
	- confBroken.addLinearFunction(&functionConfidenceBroken2);
	- LinearFunction functionConfidenceBroken3;
	- functionConfidenceBroken3.setDomain(true, (float)boundBrokenTime, false);
	- functionConfidenceBroken3.setKandD((float)0, (float)1);
	- confBroken.addLinearFunction(&functionConfidenceBroken3);
	+ LinearFunctionBlock *confBroken =
	+ new LinearFunctionBlock("confidence:broken");
	+ LinearFunction *functionConfidenceBroken1 = new LinearFunction();
	+ functionConfidenceBroken1->setDomain(false, true, (float)0);
	+ functionConfidenceBroken1->setKandD((float)0, (float)0);
	+ confBroken->addLinearFunction(functionConfidenceBroken1);
	+ LinearFunction *functionConfidenceBroken2 = new LinearFunction();
	+ functionConfidenceBroken2->setDomain(true, (float)0, true,
	+ (float)boundBrokenTime);
	+ functionConfidenceBroken2->setKandD((float)0, (float)0,
	+ (float)boundBrokenTime, (float)1);
	+ confBroken->addLinearFunction(functionConfidenceBroken2);
	+ LinearFunction *functionConfidenceBroken3 = new LinearFunction();
	+ functionConfidenceBroken3->setDomain(true, (float)boundBrokenTime, false);
	+ functionConfidenceBroken3->setKandD((float)0, (float)1);
	+ confBroken->addLinearFunction(functionConfidenceBroken3);
	#ifdef PRINT
	- confBroken.printFunctionBlock("confidence:broken");
	+ confBroken->printFunctionBlock("confidence:broken");
	#endif // PRINT

	-
	-
	-
	-
	-/********************************** Mount Functions
	+ /********************************** Mount Functions
	* **********************************/
	-//TODO: make FuncBlockConfSim2StateDev etc. private and write a setFunction!
	-
	- //aaaaaaaaaa
	- a_viabilityMonitor->set_stateHandler("CSVW:CAMoutput", destinationPath);
	-
	- a_viabilityMonitor->get_stateHandler()->FuncBlockConfSim2StateDev =
	- &confSim2StateDev;
	- a_viabilityMonitor->get_stateHandler()->FuncBlockConfDif2StateDev =
	- &confDif2StateDev;
	- a_viabilityMonitor->get_stateHandler()->FuncBlockConfSim2StateTime =
	- &confSim2StateTime;
	- a_viabilityMonitor->get_stateHandler()->FuncBlockConfDif2StateTime =
	- &confDif2StateTime;
	-
	- a_viabilityMonitor->get_stateHandler()->FuncBlockConfValStateDev =
	- &confValidStateDev;
	- a_viabilityMonitor->get_stateHandler()->FuncBlockConfInvStateDev =
	- &confInvalidStateDev;
	- a_viabilityMonitor->get_stateHandler()->FuncBlockConfValStateTime =
	- &confValidStateTime;
	- a_viabilityMonitor->get_stateHandler()->FuncBlockConfInvStateTime =
	- &confInvalidStateTime;
	-
	- // HIIIIIIIIIIIIIIERRRRRRRRRRRR SCH种种种种种种种种种諲ER MACHEN
	- a_viabilityMonitor->get_stateHandler()->DriftDeviation = &confStateDrifts;
	- a_viabilityMonitor->get_stateHandler()->FuncBlockConfBrokenSamples =
	- &confBroken;
	-
	a_viabilityMonitor->get_stateHandler()->setMaxStateHistoryLength(
	boundTimeInSamples);
	-
	- //a_viabilityMonitor->get_stateHandler()->setCSVwriter(destinationPath);
	-
	- // New for Revision CAM
	- // a_viabilityMonitor.get_stateHandler()->FuncBlockConfBrokenSamplesChangeInOldState
	- // = &confBrokenChangeInOldState;
	+ a_viabilityMonitor->get_stateHandler()->setSimilarToStateFuzzyFunctions(
	+ confSim2StateDev, confSim2StateTime);
	+ a_viabilityMonitor->get_stateHandler()->setDifferentToStateFuzzyFunctions(
	+ confDif2StateDev, confDif2StateTime);
	+ a_viabilityMonitor->get_stateHandler()->setSimilarityInStateFuzzyFunctions(
	+ confValidStateDev, confValidStateTime);
	+ a_viabilityMonitor->get_stateHandler()->setUnsimilarityInStateFuzzyFunctions(
	+ confInvalidStateDev, confInvalidStateTime);
	+ a_viabilityMonitor->get_stateHandler()->setDriftFuzzyFunction(
	+ confStateDrifts);
	+ a_viabilityMonitor->get_stateHandler()->setBrokenFuzzyFunction(confBroken);

	// create testbench
	- Testbench* tb = create_testbench("testbench");
	+ Testbench *tb = create_testbench("testbench");

	// create CSV reader modules
	unsigned int ROW = 2;
	// inputs
	- CSVreaderModule* csvr_statorVoltage =
	+ CSVreaderModule *csvr_statorVoltage =
	create_CSVreaderModule("CSVR:StatorVoltage", datasetPath, 3, ROW);
	- CSVreaderModule* csvr_inputFrequency =
	+ CSVreaderModule *csvr_inputFrequency =
	create_CSVreaderModule("CSVR:InputFrequency", datasetPath, 6, ROW);
	- CSVreaderModule* csvr_mechanicalTorque =
	+ CSVreaderModule *csvr_mechanicalTorque =
	create_CSVreaderModule("CSVR:mTorque", datasetPath, 7, ROW);
	// outputs
	- CSVreaderModule* csvr_statorCurrent =
	+ CSVreaderModule *csvr_statorCurrent =
	create_CSVreaderModule("CSVR:StatorCurrent", datasetPath, 8, ROW);
	- CSVreaderModule* csvr_electromagneticTorque =
	+ CSVreaderModule *csvr_electromagneticTorque =
	create_CSVreaderModule("CSVR:eTorque", datasetPath, 11, ROW);
	- CSVreaderModule* csvr_speed =
	+ CSVreaderModule *csvr_speed =
	create_CSVreaderModule("CSVR:Speed", datasetPath, 12, ROW);

	// register agents
	// low level agents - inputs
	register_agentInTestbench(tb, a_statorVoltage);
	register_agentInTestbench(tb, a_inputFrequency);
	register_agentInTestbench(tb, a_mechanicalTorque);
	// low level agents - outputs
	register_agentInTestbench(tb, a_statorCurrent);
	register_agentInTestbench(tb, a_electromagneticTorque);
	register_agentInTestbench(tb, a_speed);
	// high level agent
	register_agentInTestbench(tb, a_viabilityMonitor);

	// register sensors with their csv-readers
	// inputs
	register_sensorInTestbench(tb, s_statorVoltage, csvr_statorVoltage);
	register_sensorInTestbench(tb, s_inputFrequency, csvr_inputFrequency);
	register_sensorInTestbench(tb, s_mechanicalTorque, csvr_mechanicalTorque);
	// outputs
	register_sensorInTestbench(tb, s_statorCurrent, csvr_statorCurrent);
	register_sensorInTestbench(tb, s_electromagneticTorque,
	csvr_electromagneticTorque);
	register_sensorInTestbench(tb, s_speed, csvr_speed);

	// register sensor channels
	// sensor-agent channels
	// inputs
	register_channelInTestbench(tb, c_sa_statorVoltage);
	register_channelInTestbench(tb, c_sa_inputFrequency);
	register_channelInTestbench(tb, c_sa_mechanicalTorque);
	// outputs
	register_channelInTestbench(tb, c_sa_statorCurrent);
	register_channelInTestbench(tb, c_sa_electromagneticTorque);
	register_channelInTestbench(tb, c_sa_speed);

	// agent-agent channels
	// inputs
	register_channelInTestbench(tb, c_aa_statorVoltage);
	register_channelInTestbench(tb, c_aa_inputFrequency);
	register_channelInTestbench(tb, c_aa_mechanicalTorque);
	// ouputs
	register_channelInTestbench(tb, c_aa_statorCurrent);
	register_channelInTestbench(tb, c_aa_speed);
	register_channelInTestbench(tb, c_aa_electromagneticTorque);

	#ifdef STOP_BEFORE_SIMULATING
	getchar();
	#endif

	-
	tb->simulate(datasetLength);
	-
	}
	diff --git a/Version_Max_07_05_2018_CMake/src/configCAMforNewMotor.h b/Version_Max_07_05_2018_CMake/src/configCAMforNewMotor.h
	index 7902c5d..9f99ac1 100644
	--- a/Version_Max_07_05_2018_CMake/src/configCAMforNewMotor.h
	+++ b/Version_Max_07_05_2018_CMake/src/configCAMforNewMotor.h
	@@ -1,10 +1,11 @@
	#ifndef HEADER_NEWMOTOR_CONFIG
	#define HEADER_NEWMOTOR_CONFIG

	void configAndStartNewMotorExperiment(
	char destinationPath, char datasetPath, char *datasetName,
	unsigned int datasetLength, float innerBoundSimDif, float outerBoundSimDif,
	- int boundTimeInSamples, float innerBoundDrift, float outerBoundDrift,
	- int boundBrokenTime, int downSamplingFactor);
	+ int boundTimeInSamples, unsigned int discreteAveragePartitionSize,
	+ float innerBoundDrift, float outerBoundDrift, int boundBrokenTime,
	+ int downSamplingFactor);

	#endif
	\ No newline at end of file
	diff --git a/Version_Max_07_05_2018_CMake/src/configCAMforOldMotor.cpp b/Version_Max_07_05_2018_CMake/src/configCAMforOldMotor.cpp
	new file mode 100644
	index 0000000..4473920
	--- /dev/null
	+++ b/Version_Max_07_05_2018_CMake/src/configCAMforOldMotor.cpp
	@@ -0,0 +1,40 @@
	+#include "configCAMforOldMotor.h"
	+
	+#include <string.h>
	+#include <stdio.h>
	+
	+#include "configCAMforOldMotorAnomaly.h"
	+#include "configCAMforOldMotorNormal.h"
	+#include "configCAMforOldMotorSpeedChange.h"
	+
	+void configAndStartOldMotorExperiment(
	+ char destinationPath, char datasetPath, char *datasetName,
	+ unsigned int datasetLength, float innerBoundSimDif, float outerBoundSimDif,
	+ int boundTimeInSamples, unsigned int discreteAveragePartitionSize,
	+ float innerBoundDrift, float outerBoundDrift, int boundBrokenTime,
	+ int downSamplingFactor) {
	+
	+ if (strcmp(datasetName, "Anomaly-bearing_defect-OR_0nm_2") == 0) {
	+ configAndStartOldMotorAnomalyExperiment(
	+ destinationPath, datasetPath, datasetName, datasetLength,
	+ innerBoundSimDif, outerBoundSimDif, boundTimeInSamples,
	+ discreteAveragePartitionSize, innerBoundDrift, outerBoundDrift,
	+ boundBrokenTime, downSamplingFactor);
	+ } else if (strcmp(datasetName, "Wear-out") == 0 \|\|
	+ strcmp(datasetName, "Normal_operation-Tm0") == 0 \|\|
	+ strcmp(datasetName, "Normal_operation-changing_load") == 0) {
	+ configAndStartOldMotorNormalExperiment(
	+ destinationPath, datasetPath, datasetName, datasetLength,
	+ innerBoundSimDif, outerBoundSimDif, boundTimeInSamples,
	+ discreteAveragePartitionSize, innerBoundDrift, outerBoundDrift,
	+ boundBrokenTime, downSamplingFactor);
	+ } else if (strcmp(datasetName, "Change_of_speed") == 0) {
	+ configAndStartOldMotorSpeedChangeExperiment(
	+ destinationPath, datasetPath, datasetName, datasetLength,
	+ innerBoundSimDif, outerBoundSimDif, boundTimeInSamples,
	+ discreteAveragePartitionSize, innerBoundDrift,
	+ outerBoundDrift, boundBrokenTime, downSamplingFactor);
	+ } else {
	+ printf("Chosen (old Motor) config does not exist. Check Arguments that were passed!\n");
	+ }
	+}
	\ No newline at end of file
	diff --git a/Version_Max_07_05_2018_CMake/src/configCAMforOldMotor.h b/Version_Max_07_05_2018_CMake/src/configCAMforOldMotor.h
	new file mode 100644
	index 0000000..18ae6d3
	--- /dev/null
	+++ b/Version_Max_07_05_2018_CMake/src/configCAMforOldMotor.h
	@@ -0,0 +1,11 @@
	+#ifndef HEADER_OLDMOTOR_CONFIG
	+#define HEADER_OLDMOTOR_CONFIG
	+
	+void configAndStartOldMotorExperiment(
	+ char destinationPath, char datasetPath, char *datasetName,
	+ unsigned int datasetLength, float innerBoundSimDif, float outerBoundSimDif,
	+ int boundTimeInSamples, unsigned int discreteAveragePartitionSize,
	+ float innerBoundDrift, float outerBoundDrift, int boundBrokenTime,
	+ int downSamplingFactor);
	+
	+#endif
	\ No newline at end of file
	diff --git a/Version_Max_07_05_2018_CMake/src/configCAMforOldMotorAnomaly.cpp b/Version_Max_07_05_2018_CMake/src/configCAMforOldMotorAnomaly.cpp
	new file mode 100644
	index 0000000..3757519
	--- /dev/null
	+++ b/Version_Max_07_05_2018_CMake/src/configCAMforOldMotorAnomaly.cpp
	@@ -0,0 +1,563 @@
	+#include "configCAMforOldMotorAnomaly.h"
	+
	+#include "Agent.h"
	+#include "CSVreaderModule.h"
	+#include "Channel.h"
	+#include "Sensor.h"
	+#include "Testbench.h"
	+#include "create_unit.h"
	+#include "file_util.h"
	+#include "inAgentsRegistrations.h"
	+#include "mount_nodes.h"
	+#include "register_in_testbench.h"
	+#include "setupNode.h"
	+
	+#include "LinearFunction.h"
	+#include "LinearFunctionBlock.h"
	+
	+//#define PRINT
	+//#define STOP_BEFORE_SIMULATING
	+
	+
	+void configAndStartOldMotorAnomalyExperiment(
	+ char destinationPath, char datasetPath, char *datasetName,
	+ unsigned int datasetLength, float innerBoundSimDif, float outerBoundSimDif,
	+ int boundTimeInSamples, unsigned int discreteAveragePartitionSize,
	+ float innerBoundDrift, float outerBoundDrift, int boundBrokenTime,
	+ int downSamplingFactor) {
	+
	+ // config starts here
	+ // create agents
	+ // low level agents - inputs
	+ Agent *a_statorVoltage = create_agent("StatorVoltage");
	+ setWorkingCycleOfAgent(a_statorVoltage, downSamplingFactor);
	+ // low level agents - outputs
	+ Agent *a_statorCurrent_1 = create_agent("StatorCurrent1");
	+ setWorkingCycleOfAgent(a_statorCurrent_1, downSamplingFactor);
	+ Agent *a_statorCurrent_2 = create_agent("StatorCurrent2");
	+ setWorkingCycleOfAgent(a_statorCurrent_2, downSamplingFactor);
	+ Agent *a_statorCurrent_3 = create_agent("StatorCurrent3");
	+ setWorkingCycleOfAgent(a_statorCurrent_3, downSamplingFactor);
	+ Agent *a_electromagneticTorque = create_agent("ElectromagneticTorque");
	+ setWorkingCycleOfAgent(a_electromagneticTorque, downSamplingFactor);
	+ Agent *a_vibration_1 = create_agent("Vibration1");
	+ setWorkingCycleOfAgent(a_vibration_1, downSamplingFactor);
	+ Agent *a_vibration_2 = create_agent("Vibration2");
	+ setWorkingCycleOfAgent(a_vibration_2, downSamplingFactor);
	+ Agent *a_vibration_3 = create_agent("Vibration3");
	+ setWorkingCycleOfAgent(a_vibration_3, downSamplingFactor);
	+ Agent *a_viabilityMonitor = create_agent("ViabilityMonitor");
	+ setWorkingCycleOfAgent(a_viabilityMonitor, downSamplingFactor);
	+
	+ // create sensors
	+ // inputs
	+ Sensor *s_statorVoltage = create_sensor("Stator Voltage");
	+ setWorkingCycleOfSensor(s_statorVoltage, downSamplingFactor);
	+ // outputs
	+ Sensor *s_statorCurrent_1 = create_sensor("Stator Current1");
	+ setWorkingCycleOfSensor(s_statorCurrent_1, downSamplingFactor);
	+ Sensor *s_statorCurrent_2 = create_sensor("Stator Current2");
	+ setWorkingCycleOfSensor(s_statorCurrent_2, downSamplingFactor);
	+ Sensor *s_statorCurrent_3 = create_sensor("Stator Current3");
	+ setWorkingCycleOfSensor(s_statorCurrent_3, downSamplingFactor);
	+ Sensor *s_electromagneticTorque = create_sensor("Electromagnetic Torque");
	+ setWorkingCycleOfSensor(s_electromagneticTorque, downSamplingFactor);
	+ Sensor *s_vibration_1 = create_sensor("Vibration1");
	+ setWorkingCycleOfSensor(s_vibration_1, downSamplingFactor);
	+ Sensor *s_vibration_2 = create_sensor("Vibration2");
	+ setWorkingCycleOfSensor(s_vibration_2, downSamplingFactor);
	+ Sensor *s_vibration_3 = create_sensor("Vibration3");
	+ setWorkingCycleOfSensor(s_vibration_3, downSamplingFactor);
	+
	+ // create channels for sensors
	+ // inputs
	+ Channel *c_sa_statorVoltage = create_channel("Stator Voltage (SA)", 0);
	+ // outputs
	+ Channel *c_sa_statorCurrent_1 = create_channel("Stator Current 1 (SA)", 0);
	+ Channel *c_sa_statorCurrent_2 = create_channel("Stator Current 2 (SA)", 0);
	+ Channel *c_sa_statorCurrent_3 = create_channel("Stator Current 3 (SA)", 0);
	+ Channel *c_sa_electromagneticTorque =
	+ create_channel("Electromagnetic Torque (SA)", 0);
	+ Channel *c_sa_vibration_1 = create_channel("Vibration 1 (SA)", 0);
	+ Channel *c_sa_vibration_2 = create_channel("Vibration 2 (SA)", 0);
	+ Channel *c_sa_vibration_3 = create_channel("Vibration 3 (SA)", 0);
	+
	+ // create channels for sensors
	+ // inputs
	+ Channel *c_aa_statorVoltage = create_channel("Stator Voltage (AA)", 0);
	+ // outputs
	+ Channel *c_aa_statorCurrent_1 = create_channel("Stator Current 1 (AA)", 0);
	+ Channel *c_aa_statorCurrent_2 = create_channel("Stator Current 2 (AA)", 0);
	+ Channel *c_aa_statorCurrent_3 = create_channel("Stator Current 3 (AA)", 0);
	+ Channel *c_aa_electromagneticTorque =
	+ create_channel("Electromagnetic Torque (AA)", 0);
	+ Channel *c_aa_vibration_1 = create_channel("Vibration 1 (AA)", 0);
	+ Channel *c_aa_vibration_2 = create_channel("Vibration 2 (AA)", 0);
	+ Channel *c_aa_vibration_3 = create_channel("Vibration 3 (AA)", 0);
	+
	+ // mount sensors in agents
	+ // inputs
	+ mount_sensorInAgent(a_statorVoltage, s_statorVoltage, c_sa_statorVoltage);
	+ // outputs
	+ mount_sensorInAgent(a_statorCurrent_1, s_statorCurrent_1,
	+ c_sa_statorCurrent_1);
	+ mount_sensorInAgent(a_statorCurrent_2, s_statorCurrent_2,
	+ c_sa_statorCurrent_2);
	+ mount_sensorInAgent(a_statorCurrent_3, s_statorCurrent_3,
	+ c_sa_statorCurrent_3);
	+ mount_sensorInAgent(a_electromagneticTorque, s_electromagneticTorque,
	+ c_sa_electromagneticTorque);
	+ mount_sensorInAgent(a_vibration_1, s_vibration_1, c_sa_vibration_1);
	+ mount_sensorInAgent(a_vibration_2, s_vibration_2, c_sa_vibration_2);
	+ mount_sensorInAgent(a_vibration_3, s_vibration_3, c_sa_vibration_3);
	+
	+ // mount agents in agent(s)
	+ // inputs
	+ mount_agentInAgent(a_viabilityMonitor, a_statorVoltage,
	+ c_aa_statorVoltage);
	+ // outputs
	+ mount_agentInAgent(a_viabilityMonitor, a_statorCurrent_1,
	+ c_aa_statorCurrent_1);
	+ mount_agentInAgent(a_viabilityMonitor, a_statorCurrent_2,
	+ c_aa_statorCurrent_2);
	+ mount_agentInAgent(a_viabilityMonitor, a_statorCurrent_3,
	+ c_aa_statorCurrent_3);
	+ mount_agentInAgent(a_viabilityMonitor, a_electromagneticTorque,
	+ c_aa_electromagneticTorque);
	+ mount_agentInAgent(a_viabilityMonitor, a_vibration_1, c_aa_vibration_1);
	+ mount_agentInAgent(a_viabilityMonitor, a_vibration_2, c_aa_vibration_2);
	+ mount_agentInAgent(a_viabilityMonitor, a_vibration_3, c_aa_vibration_3);
	+
	+
	+ // set State Handler in Master Agent and Initialize an CSVWriter for the CAM
	+ // output
	+ a_viabilityMonitor->set_stateHandler("CSVW:CAMoutput", destinationPath);
	+
	+
	+ // register agents in agents' stateHandler
	+ // inputs
	+ registerSlaveAgentAsInputVariableInStateHandler(a_viabilityMonitor,
	+ c_aa_statorVoltage);
	+ // outputs
	+ registerSlaveAgentAsOutputVariableInStateHandler(a_viabilityMonitor,
	+ c_aa_statorCurrent_1);
	+ registerSlaveAgentAsOutputVariableInStateHandler(a_viabilityMonitor,
	+ c_aa_statorCurrent_2);
	+ registerSlaveAgentAsOutputVariableInStateHandler(a_viabilityMonitor,
	+ c_aa_statorCurrent_3);
	+ registerSlaveAgentAsOutputVariableInStateHandler(a_viabilityMonitor,
	+ c_aa_electromagneticTorque);
	+ registerSlaveAgentAsOutputVariableInStateHandler(a_viabilityMonitor,
	+ c_aa_vibration_1);
	+ registerSlaveAgentAsOutputVariableInStateHandler(a_viabilityMonitor,
	+ c_aa_vibration_2);
	+ registerSlaveAgentAsOutputVariableInStateHandler(a_viabilityMonitor,
	+ c_aa_vibration_3);
	+
	+
	+
	+
	+ // SAME STATE DEVIATION
	+ LinearFunctionBlock *confSim2StateDev =
	+ new LinearFunctionBlock("funcBlock:confSim2StateDev");
	+ LinearFunction *funcConfSim2StateDev1 = new LinearFunction();
	+ funcConfSim2StateDev1->setDomain(false, true, -1 * outerBoundSimDif);
	+ funcConfSim2StateDev1->setKandD((float)0, (float)0);
	+ confSim2StateDev->addLinearFunction(funcConfSim2StateDev1);
	+ LinearFunction *funcConfSim2StateDev2 = new LinearFunction();
	+ funcConfSim2StateDev2->setDomain(true, -1 * outerBoundSimDif, true,
	+ -1 * innerBoundSimDif);
	+ funcConfSim2StateDev2->setKandD(-1 * outerBoundSimDif, (float)0,
	+ -1 * innerBoundSimDif, (float)1);
	+ confSim2StateDev->addLinearFunction(funcConfSim2StateDev2);
	+ LinearFunction *funcConfSim2StateDev3 = new LinearFunction();
	+ funcConfSim2StateDev3->setDomain(true, -1 * innerBoundSimDif, true,
	+ innerBoundSimDif);
	+ funcConfSim2StateDev3->setKandD((float)0, (float)1);
	+ confSim2StateDev->addLinearFunction(funcConfSim2StateDev3);
	+ LinearFunction *funcConfSim2StateDev4 = new LinearFunction();
	+ funcConfSim2StateDev4->setDomain(true, innerBoundSimDif, true,
	+ outerBoundSimDif);
	+ funcConfSim2StateDev4->setKandD(innerBoundSimDif, (float)1, outerBoundSimDif,
	+ (float)0);
	+ confSim2StateDev->addLinearFunction(funcConfSim2StateDev4);
	+ LinearFunction *funcConfSim2StateDev5 = new LinearFunction();
	+ funcConfSim2StateDev5->setDomain(true, outerBoundSimDif, false);
	+ funcConfSim2StateDev5->setKandD((float)0, (float)0);
	+ confSim2StateDev->addLinearFunction(funcConfSim2StateDev5);
	+#ifdef PRINT
	+ confSim2StateDev->printFunctionBlock("funcBlock:confSim2StateDev");
	+#endif // PRINT
	+
	+ // ANOTHER STATE DEVIATION
	+ LinearFunctionBlock *confDif2StateDev =
	+ new LinearFunctionBlock("funcBlock:confDif2StateDev");
	+ LinearFunction *funcConfDif2StateDev1 = new LinearFunction();
	+ funcConfDif2StateDev1->setDomain(false, true, -1 * outerBoundSimDif);
	+ funcConfDif2StateDev1->setKandD((float)0, (float)1);
	+ confDif2StateDev->addLinearFunction(funcConfDif2StateDev1);
	+ LinearFunction *funcConfDif2StateDev2 = new LinearFunction();
	+ funcConfDif2StateDev2->setDomain(true, -1 * outerBoundSimDif, true,
	+ -1 * innerBoundSimDif);
	+ funcConfDif2StateDev2->setKandD(-1 * outerBoundSimDif, (float)1,
	+ -1 * innerBoundSimDif, (float)0);
	+ confDif2StateDev->addLinearFunction(funcConfDif2StateDev2);
	+ LinearFunction *funcConfDif2StateDev3 = new LinearFunction();
	+ funcConfDif2StateDev3->setDomain(true, -1 * innerBoundSimDif, true,
	+ innerBoundSimDif);
	+ funcConfDif2StateDev3->setKandD((float)0, (float)0);
	+ confDif2StateDev->addLinearFunction(funcConfDif2StateDev3);
	+ LinearFunction *funcConfDif2StateDev4 = new LinearFunction();
	+ funcConfDif2StateDev4->setDomain(true, innerBoundSimDif, true,
	+ outerBoundSimDif);
	+ funcConfDif2StateDev4->setKandD(innerBoundSimDif, (float)0, outerBoundSimDif,
	+ (float)1);
	+ confDif2StateDev->addLinearFunction(funcConfDif2StateDev4);
	+ LinearFunction *funcConfDif2StateDev5 = new LinearFunction();
	+ funcConfDif2StateDev5->setDomain(true, outerBoundSimDif, false);
	+ funcConfDif2StateDev5->setKandD((float)0, (float)1);
	+ confDif2StateDev->addLinearFunction(funcConfDif2StateDev5);
	+#ifdef PRINT
	+ confDif2StateDev->printFunctionBlock("funcBlock:confDif2StateDev");
	+#endif // PRINT
	+
	+ // SAME STATE TIME
	+ LinearFunctionBlock *confSim2StateTime =
	+ new LinearFunctionBlock("funcBlock:confSim2StateTime");
	+ LinearFunction *funcConfSim2StateTime1 = new LinearFunction();
	+ funcConfSim2StateTime1->setDomain(false, true, (float)0);
	+ funcConfSim2StateTime1->setKandD((float)0, (float)0);
	+ confSim2StateTime->addLinearFunction(funcConfSim2StateTime1);
	+ LinearFunction *funcConfSim2StateTime2 = new LinearFunction();
	+ funcConfSim2StateTime2->setDomain(true, (float)0, true,
	+ (float)boundTimeInSamples);
	+ funcConfSim2StateTime2->setKandD((float)0, (float)0,
	+ (float)boundTimeInSamples, (float)1);
	+ confSim2StateTime->addLinearFunction(funcConfSim2StateTime2);
	+ LinearFunction *funcConfSim2StateTime3 = new LinearFunction();
	+ funcConfSim2StateTime3->setDomain(true, (float)boundTimeInSamples, false);
	+ funcConfSim2StateTime3->setKandD((float)0, (float)1);
	+ confSim2StateTime->addLinearFunction(funcConfSim2StateTime3);
	+#ifdef PRINT
	+ confSim2StateTime->printFunctionBlock("funcBlock:confSim2StateTime");
	+#endif // PRINT
	+
	+ // ANOTHER STATE TIME
	+ LinearFunctionBlock *confDif2StateTime =
	+ new LinearFunctionBlock("funcBlock:confDif2StateTime");
	+ LinearFunction *funcConfDif2StateTime1 = new LinearFunction();
	+ funcConfDif2StateTime1->setDomain(false, true, (float)0);
	+ funcConfDif2StateTime1->setKandD((float)0, (float)1);
	+ confDif2StateTime->addLinearFunction(funcConfDif2StateTime1);
	+ LinearFunction *funcConfDif2StateTime2 = new LinearFunction();
	+ funcConfDif2StateTime2->setDomain(true, (float)0, true,
	+ (float)boundTimeInSamples);
	+ funcConfDif2StateTime2->setKandD((float)0, (float)1,
	+ (float)boundTimeInSamples, (float)0);
	+ confDif2StateTime->addLinearFunction(funcConfDif2StateTime2);
	+ LinearFunction *funcConfDif2StateTime3 = new LinearFunction();
	+ funcConfDif2StateTime3->setDomain(true, (float)boundTimeInSamples, false);
	+ funcConfDif2StateTime3->setKandD((float)0, (float)0);
	+ confDif2StateTime->addLinearFunction(funcConfDif2StateTime3);
	+#ifdef PRINT
	+ confDif2StateTime->printFunctionBlock("funcBlock:confDif2StateTime");
	+#endif // PRINT
	+
	+ /************************ FunctionBlocks Val/Inv State (NEU)
	+ * ************************/
	+
	+ // VALID STATE DEVIATION
	+ LinearFunctionBlock *confValidStateDev =
	+ new LinearFunctionBlock("funcBlock:confValidStateDev");
	+ LinearFunction *funcConfValidStateDev1 = new LinearFunction();
	+ funcConfValidStateDev1->setDomain(false, true, -1 * outerBoundSimDif);
	+ funcConfValidStateDev1->setKandD((float)0, (float)0);
	+ confValidStateDev->addLinearFunction(funcConfValidStateDev1);
	+ LinearFunction *funcConfValidStateDev2 = new LinearFunction();
	+ funcConfValidStateDev2->setDomain(true, -1 * outerBoundSimDif, true,
	+ -1 * innerBoundSimDif);
	+ funcConfValidStateDev2->setKandD(-1 * outerBoundSimDif, (float)0,
	+ -1 * innerBoundSimDif, (float)1);
	+ confValidStateDev->addLinearFunction(funcConfValidStateDev2);
	+ LinearFunction *funcConfValidStateDev3 = new LinearFunction();
	+ funcConfValidStateDev3->setDomain(true, -1 * innerBoundSimDif, true,
	+ innerBoundSimDif);
	+ funcConfValidStateDev3->setKandD((float)0, (float)1);
	+ confValidStateDev->addLinearFunction(funcConfValidStateDev3);
	+ LinearFunction *funcConfValidStateDev4 = new LinearFunction();
	+ funcConfValidStateDev4->setDomain(true, innerBoundSimDif, true,
	+ outerBoundSimDif);
	+ funcConfValidStateDev4->setKandD(innerBoundSimDif, (float)1, outerBoundSimDif,
	+ (float)0);
	+ confValidStateDev->addLinearFunction(funcConfValidStateDev4);
	+ LinearFunction *funcConfValidStateDev5 = new LinearFunction();
	+ funcConfValidStateDev5->setDomain(true, outerBoundSimDif, false);
	+ funcConfValidStateDev5->setKandD((float)0, (float)0);
	+ confValidStateDev->addLinearFunction(funcConfValidStateDev5);
	+#ifdef PRINT
	+ confValidStateDev->printFunctionBlock("funcBlock:confValidStateDev");
	+#endif // PRINT
	+
	+ // INVALID STATE DEVIATION
	+ LinearFunctionBlock *confInvalidStateDev =
	+ new LinearFunctionBlock("funcBlock:confInvalidStateDev");
	+ LinearFunction *funcConfInvalidStateDev1 = new LinearFunction();
	+ funcConfInvalidStateDev1->setDomain(false, true, -1 * outerBoundSimDif);
	+ funcConfInvalidStateDev1->setKandD((float)0, (float)1);
	+ confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev1);
	+ LinearFunction *funcConfInvalidStateDev2 = new LinearFunction();
	+ funcConfInvalidStateDev2->setDomain(true, -1 * outerBoundSimDif, true,
	+ -1 * innerBoundSimDif);
	+ funcConfInvalidStateDev2->setKandD(-1 * outerBoundSimDif, (float)1,
	+ -1 * innerBoundSimDif, (float)0);
	+ confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev2);
	+ LinearFunction *funcConfInvalidStateDev3 = new LinearFunction();
	+ funcConfInvalidStateDev3->setDomain(true, -1 * innerBoundSimDif, true,
	+ innerBoundSimDif);
	+ funcConfInvalidStateDev3->setKandD((float)0, (float)0);
	+ confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev3);
	+ LinearFunction *funcConfInvalidStateDev4 = new LinearFunction();
	+ funcConfInvalidStateDev4->setDomain(true, innerBoundSimDif, true,
	+ outerBoundSimDif);
	+ funcConfInvalidStateDev4->setKandD(innerBoundSimDif, (float)0,
	+ outerBoundSimDif, (float)1);
	+ confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev4);
	+ LinearFunction *funcConfInvalidStateDev5 = new LinearFunction();
	+ funcConfInvalidStateDev5->setDomain(true, outerBoundSimDif, false);
	+ funcConfInvalidStateDev5->setKandD((float)0, (float)1);
	+ confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev5);
	+#ifdef PRINT
	+ confInvalidStateDev->printFunctionBlock("funcBlock:confInvalidStateDev");
	+#endif // PRINT
	+
	+ // VALID STATE TIME
	+ LinearFunctionBlock *confValidStateTime =
	+ new LinearFunctionBlock("funcBlock:confValidStateTime");
	+ LinearFunction *funcConfValidStateTime1 = new LinearFunction();
	+ funcConfValidStateTime1->setDomain(false, true, (float)0);
	+ funcConfValidStateTime1->setKandD((float)0, (float)0);
	+ confValidStateTime->addLinearFunction(funcConfValidStateTime1);
	+ LinearFunction *funcConfValidStateTime2 = new LinearFunction();
	+ funcConfValidStateTime2->setDomain(true, (float)0, true,
	+ (float)boundTimeInSamples); // 10
	+ funcConfValidStateTime2->setKandD((float)0, (float)0,
	+ (float)boundTimeInSamples, (float)1);
	+ confValidStateTime->addLinearFunction(funcConfValidStateTime2);
	+ LinearFunction *funcConfValidStateTime3 = new LinearFunction();
	+ funcConfValidStateTime3->setDomain(true, (float)boundTimeInSamples, false);
	+ funcConfValidStateTime3->setKandD((float)0, (float)1);
	+ confValidStateTime->addLinearFunction(funcConfValidStateTime3);
	+#ifdef PRINT
	+ confValidStateTime->printFunctionBlock("funcBlock:confValidStateTime");
	+#endif // PRINT
	+
	+ // INVALID STATE TIME
	+ LinearFunctionBlock *confInvalidStateTime =
	+ new LinearFunctionBlock("funcBlock:confInvalidStateTime");
	+ LinearFunction *funcConfInvalidStateTime1 = new LinearFunction();
	+ funcConfInvalidStateTime1->setDomain(false, true, (float)0);
	+ funcConfInvalidStateTime1->setKandD((float)0, (float)1);
	+ confInvalidStateTime->addLinearFunction(funcConfInvalidStateTime1);
	+ LinearFunction *funcConfInvalidStateTime2 = new LinearFunction();
	+ funcConfInvalidStateTime2->setDomain(true, (float)0, true,
	+ (float)boundTimeInSamples);
	+ funcConfInvalidStateTime2->setKandD((float)0, (float)1,
	+ (float)boundTimeInSamples, (float)0);
	+ confInvalidStateTime->addLinearFunction(funcConfInvalidStateTime2);
	+ LinearFunction *funcConfInvalidStateTime3 = new LinearFunction();
	+ funcConfInvalidStateTime3->setDomain(true, (float)boundTimeInSamples, false);
	+ funcConfInvalidStateTime3->setKandD((float)0, (float)0);
	+ confInvalidStateTime->addLinearFunction(funcConfInvalidStateTime3);
	+#ifdef PRINT
	+ confInvalidStateTime->printFunctionBlock("funcBlock:confInvalidStateTime");
	+#endif // PRINT
	+
	+ /********************************** Functions NOT OK
	+ * **********************************/
	+
	+ LinearFunctionBlock *confStateDrifts =
	+ new LinearFunctionBlock("confidence:confStateDrifts");
	+ LinearFunction *functionConfidenceDriftDeviation1 = new LinearFunction();
	+ functionConfidenceDriftDeviation1->setDomain(false, true,
	+ -1 * outerBoundDrift);
	+ functionConfidenceDriftDeviation1->setKandD((float)0, (float)1);
	+ confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation1);
	+ LinearFunction *functionConfidenceDriftDeviation2 = new LinearFunction();
	+ functionConfidenceDriftDeviation2->setDomain(true, -1 * outerBoundDrift, true,
	+ -1 * innerBoundDrift);
	+ functionConfidenceDriftDeviation2->setKandD(-1 * outerBoundDrift, (float)1,
	+ -1 * innerBoundDrift, (float)0);
	+ confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation2);
	+ LinearFunction *functionConfidenceDriftDeviation3 = new LinearFunction();
	+ functionConfidenceDriftDeviation3->setDomain(true, -1 * innerBoundDrift, true,
	+ innerBoundDrift);
	+ functionConfidenceDriftDeviation3->setKandD((float)0, (float)0);
	+ confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation3);
	+ LinearFunction *functionConfidenceDriftDeviation4 = new LinearFunction();
	+ functionConfidenceDriftDeviation4->setDomain(true, innerBoundDrift, true,
	+ outerBoundDrift);
	+ functionConfidenceDriftDeviation4->setKandD(innerBoundDrift, (float)0,
	+ outerBoundDrift, (float)1);
	+ confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation4);
	+ LinearFunction *functionConfidenceDriftDeviation5 = new LinearFunction();
	+ functionConfidenceDriftDeviation5->setDomain(true, outerBoundDrift, false);
	+ functionConfidenceDriftDeviation5->setKandD((float)0, (float)1);
	+ confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation5);
	+#ifdef PRINT
	+ confStateDrifts.printFunctionBlock("confidence:confStateDrifts");
	+#endif
	+
	+ LinearFunctionBlock *confBroken =
	+ new LinearFunctionBlock("confidence:broken");
	+ LinearFunction *functionConfidenceBroken1 = new LinearFunction();
	+ functionConfidenceBroken1->setDomain(false, true, (float)0);
	+ functionConfidenceBroken1->setKandD((float)0, (float)0);
	+ confBroken->addLinearFunction(functionConfidenceBroken1);
	+ LinearFunction *functionConfidenceBroken2 = new LinearFunction();
	+ functionConfidenceBroken2->setDomain(true, (float)0, true,
	+ (float)boundBrokenTime);
	+ functionConfidenceBroken2->setKandD((float)0, (float)0,
	+ (float)boundBrokenTime, (float)1);
	+ confBroken->addLinearFunction(functionConfidenceBroken2);
	+ LinearFunction *functionConfidenceBroken3 = new LinearFunction();
	+ functionConfidenceBroken3->setDomain(true, (float)boundBrokenTime, false);
	+ functionConfidenceBroken3->setKandD((float)0, (float)1);
	+ confBroken->addLinearFunction(functionConfidenceBroken3);
	+#ifdef PRINT
	+ confBroken->printFunctionBlock("confidence:broken");
	+#endif // PRINT
	+
	+ /********************************** Mount Functions
	+ * **********************************/
	+ a_viabilityMonitor->get_stateHandler()->setMaxStateHistoryLength(
	+ boundTimeInSamples);
	+ a_viabilityMonitor->get_stateHandler()->setSimilarToStateFuzzyFunctions(
	+ confSim2StateDev, confSim2StateTime);
	+ a_viabilityMonitor->get_stateHandler()->setDifferentToStateFuzzyFunctions(
	+ confDif2StateDev, confDif2StateTime);
	+ a_viabilityMonitor->get_stateHandler()->setSimilarityInStateFuzzyFunctions(
	+ confValidStateDev, confValidStateTime);
	+ a_viabilityMonitor->get_stateHandler()->setUnsimilarityInStateFuzzyFunctions(
	+ confInvalidStateDev, confInvalidStateTime);
	+ a_viabilityMonitor->get_stateHandler()->setDriftFuzzyFunction(
	+ confStateDrifts);
	+ a_viabilityMonitor->get_stateHandler()->setBrokenFuzzyFunction(confBroken);
	+
	+ // create testbench
	+ Testbench *tb = create_testbench("testbench");
	+
	+ // create CSV reader modules
	+ unsigned int ROW = 2;
	+ char csvPath[600];
	+ // inputs
	+#ifdef _WIN32
	+ sprintf_s(csvPath, "%s\\statorVoltage_abstracted.csv", datasetPath);
	+#else
	+ sprintf(csvPath, "%s/statorVoltage_abstracted.csv", datasetPath);
	+#endif // _WIN32
	+ CSVreaderModule *csvr_statorVoltage =
	+ create_CSVreaderModule("Stator Voltage CSV-Reader", csvPath, 2, ROW);
	+ // outputs
	+#ifdef _WIN32
	+ sprintf_s(csvPath, "%s\\statorCurrent_abs_fil.csv", datasetPath);
	+#else
	+ sprintf(csvPath, "%s/statorCurrent_abs_fil.csv", datasetPath);
	+#endif // _WIN32
	+ CSVreaderModule *csvr_statorCurrent_1 =
	+ create_CSVreaderModule("Stator Current 1 CSV-Reader", csvPath, 2, ROW);
	+ CSVreaderModule *csvr_statorCurrent_2 =
	+ create_CSVreaderModule("Stator Current 2 CSV-Reader", csvPath, 3, ROW);
	+ CSVreaderModule *csvr_statorCurrent_3 =
	+ create_CSVreaderModule("Stator Current 3 CSV-Reader", csvPath, 4, ROW);
	+#ifdef _WIN32
	+ sprintf_s(csvPath, "%s\\te_filtered.csv", datasetPath);
	+#else
	+ sprintf(csvPath, "%s/te_filtered.csv", datasetPath);
	+#endif // _WIN32
	+ CSVreaderModule *csvr_electromagneticTorque = create_CSVreaderModule(
	+ "Electromagnetic Torque CSV-Reader", csvPath, 2, ROW);
	+#ifdef _WIN32
	+ sprintf_s(csvPath, "%s\\vib1_filtered.csv", datasetPath);
	+#else
	+ sprintf(csvPath, "%s/vib1_filtered.csv", datasetPath);
	+#endif // _WIN32
	+ CSVreaderModule *csvr_vibration_1 =
	+ create_CSVreaderModule("Vibration 1 CSV-Reader", csvPath, 2, ROW);
	+#ifdef _WIN32
	+ sprintf_s(csvPath, "%s\\vib2_filtered.csv", datasetPath);
	+#else
	+ sprintf(csvPath, "%s/vib2_filtered.csv", datasetPath);
	+#endif // _WIN32
	+ CSVreaderModule *csvr_vibration_2 =
	+ create_CSVreaderModule("Vibration 2 CSV-Reader", csvPath, 2, ROW);
	+#ifdef _WIN32
	+ sprintf_s(csvPath, "%s\\vib3_filtered.csv", datasetPath);
	+#else
	+ sprintf(csvPath, "%s/vib3_filtered.csv", datasetPath);
	+#endif // _WIN32
	+ CSVreaderModule *csvr_vibration_3 =
	+ create_CSVreaderModule("Vibration 3 CSV-Reader", csvPath, 2, ROW);
	+
	+ // register agents
	+ // low level agents - inputs
	+ register_agentInTestbench(tb, a_statorVoltage);
	+ // low level agents - outputs
	+ register_agentInTestbench(tb, a_statorCurrent_1);
	+ register_agentInTestbench(tb, a_statorCurrent_2);
	+ register_agentInTestbench(tb, a_statorCurrent_3);
	+ register_agentInTestbench(tb, a_electromagneticTorque);
	+ register_agentInTestbench(tb, a_vibration_1);
	+ register_agentInTestbench(tb, a_vibration_2);
	+ register_agentInTestbench(tb, a_vibration_3);
	+ // high level agent
	+ register_agentInTestbench(tb, a_viabilityMonitor);
	+
	+
	+ // register sensors with their csv-readers
	+ // inputs
	+ register_sensorInTestbench(tb, s_statorVoltage, csvr_statorVoltage);
	+ // outputs
	+ register_sensorInTestbench(tb, s_statorCurrent_1, csvr_statorCurrent_1);
	+ register_sensorInTestbench(tb, s_statorCurrent_2, csvr_statorCurrent_2);
	+ register_sensorInTestbench(tb, s_statorCurrent_3, csvr_statorCurrent_3);
	+ register_sensorInTestbench(tb, s_electromagneticTorque,
	+ csvr_electromagneticTorque);
	+ register_sensorInTestbench(tb, s_vibration_1, csvr_vibration_1);
	+ register_sensorInTestbench(tb, s_vibration_2, csvr_vibration_2);
	+ register_sensorInTestbench(tb, s_vibration_3, csvr_vibration_3);
	+
	+
	+ // register sensor channels
	+ // sensor-agent channels
	+ // inputs
	+ register_channelInTestbench(tb, c_sa_statorVoltage);
	+ // outputs
	+ register_channelInTestbench(tb, c_sa_statorCurrent_1);
	+ register_channelInTestbench(tb, c_sa_statorCurrent_2);
	+ register_channelInTestbench(tb, c_sa_statorCurrent_3);
	+ register_channelInTestbench(tb, c_sa_electromagneticTorque);
	+ register_channelInTestbench(tb, c_sa_vibration_1);
	+ register_channelInTestbench(tb, c_sa_vibration_2);
	+ register_channelInTestbench(tb, c_sa_vibration_3);
	+
	+ // agent-agent channels
	+ // inputs
	+ register_channelInTestbench(tb, c_aa_statorVoltage);
	+ // ouputs
	+ register_channelInTestbench(tb, c_aa_statorCurrent_1);
	+ register_channelInTestbench(tb, c_aa_statorCurrent_2);
	+ register_channelInTestbench(tb, c_aa_statorCurrent_3);
	+ register_channelInTestbench(tb, c_aa_electromagneticTorque);
	+ register_channelInTestbench(tb, c_aa_vibration_1);
	+ register_channelInTestbench(tb, c_aa_vibration_2);
	+ register_channelInTestbench(tb, c_aa_vibration_3);
	+
	+
	+
	+
	+#ifdef STOP_BEFORE_SIMULATING
	+ getchar();
	+#endif
	+
	+ tb->simulate(datasetLength);
	+}
	diff --git a/Version_Max_07_05_2018_CMake/src/configCAMforOldMotorAnomaly.h b/Version_Max_07_05_2018_CMake/src/configCAMforOldMotorAnomaly.h
	new file mode 100644
	index 0000000..847d0c5
	--- /dev/null
	+++ b/Version_Max_07_05_2018_CMake/src/configCAMforOldMotorAnomaly.h
	@@ -0,0 +1,11 @@
	+#ifndef HEADER_OLDMOTOR_ANOMALY_CONFIG
	+#define HEADER_OLDMOTOR_ANOMALY_CONFIG
	+
	+void configAndStartOldMotorAnomalyExperiment(
	+ char destinationPath, char datasetPath, char *datasetName,
	+ unsigned int datasetLength, float innerBoundSimDif, float outerBoundSimDif,
	+ int boundTimeInSamples, unsigned int discreteAveragePartitionSize,
	+ float innerBoundDrift, float outerBoundDrift, int boundBrokenTime,
	+ int downSamplingFactor);
	+
	+#endif
	\ No newline at end of file
	diff --git a/Version_Max_07_05_2018_CMake/src/configCAMforOldMotorNormal.cpp b/Version_Max_07_05_2018_CMake/src/configCAMforOldMotorNormal.cpp
	new file mode 100644
	index 0000000..35f5e59
	--- /dev/null
	+++ b/Version_Max_07_05_2018_CMake/src/configCAMforOldMotorNormal.cpp
	@@ -0,0 +1,504 @@
	+#include "configCAMforOldMotorNormal.h"
	+
	+#include "Agent.h"
	+#include "CSVreaderModule.h"
	+#include "Channel.h"
	+#include "Sensor.h"
	+#include "Testbench.h"
	+#include "create_unit.h"
	+#include "file_util.h"
	+#include "inAgentsRegistrations.h"
	+#include "mount_nodes.h"
	+#include "register_in_testbench.h"
	+#include "setupNode.h"
	+
	+#include "LinearFunction.h"
	+#include "LinearFunctionBlock.h"
	+
	+//#define PRINT
	+//#define STOP_BEFORE_SIMULATING
	+
	+void configAndStartOldMotorNormalExperiment(
	+ char destinationPath, char datasetPath, char *datasetName,
	+ unsigned int datasetLength, float innerBoundSimDif, float outerBoundSimDif,
	+ int boundTimeInSamples, unsigned int discreteAveragePartitionSize,
	+ float innerBoundDrift, float outerBoundDrift, int boundBrokenTime,
	+ int downSamplingFactor) {
	+
	+ // config starts here
	+ // create agents
	+ // low level agents - inputs
	+ Agent *a_statorVoltage = create_agent("Stator Voltage");
	+ setWorkingCycleOfAgent(a_statorVoltage, downSamplingFactor);
	+ Agent *a_mechanicalTorque = create_agent("Mechanical Torque");
	+ setWorkingCycleOfAgent(a_mechanicalTorque, downSamplingFactor);
	+ // low level agents - outputs
	+ Agent *a_statorCurrent = create_agent("Stator Current");
	+ setWorkingCycleOfAgent(a_statorCurrent, downSamplingFactor);
	+ Agent *a_electromagneticTorque = create_agent("Electromagnetic Torque");
	+ setWorkingCycleOfAgent(a_electromagneticTorque, downSamplingFactor);
	+ Agent *a_speed = create_agent("Speed");
	+ setWorkingCycleOfAgent(a_speed, downSamplingFactor);
	+ // high level agent
	+ Agent *a_viabilityMonitor = create_agent("Viability Monitor");
	+ setWorkingCycleOfAgent(a_viabilityMonitor, downSamplingFactor);
	+
	+ // create sensors
	+ // inputs
	+ Sensor *s_statorVoltage = create_sensor("Stator Voltage");
	+ setWorkingCycleOfSensor(s_statorVoltage, downSamplingFactor);
	+ Sensor *s_mechanicalTorque = create_sensor("Mechanical Torque");
	+ setWorkingCycleOfSensor(s_mechanicalTorque, downSamplingFactor);
	+ // outputs
	+ Sensor *s_statorCurrent = create_sensor("Stator Current");
	+ setWorkingCycleOfSensor(s_statorCurrent, downSamplingFactor);
	+ Sensor *s_electromagneticTorque = create_sensor("Electromagnetic Torque");
	+ setWorkingCycleOfSensor(s_electromagneticTorque, downSamplingFactor);
	+ Sensor *s_speed = create_sensor("Speed");
	+ setWorkingCycleOfSensor(s_speed, downSamplingFactor);
	+
	+ // create channels for sensors
	+ // inputs
	+ Channel *c_sa_statorVoltage = create_channel("Stator Voltage (SA)", 0);
	+ Channel *c_sa_mechanicalTorque = create_channel("Mechanical Torque (SA)", 0);
	+ // outputs
	+ Channel *c_sa_statorCurrent = create_channel("Stator Current (SA)", 0);
	+ Channel *c_sa_electromagneticTorque =
	+ create_channel("Electromagnetic Torque (SA)", 0);
	+ Channel *c_sa_speed = create_channel("Speed Sensor (SA)", 0);
	+
	+ // create channels for sensors
	+ // inputs
	+ Channel *c_aa_statorVoltage =
	+ create_channel("Stator Voltage (AA-UP)", MAX_BUFFER_LENGTH);
	+ Channel *c_aa_mechanicalTorque =
	+ create_channel("Mechanical Torque (AA-UP)", MAX_BUFFER_LENGTH);
	+ // outputs
	+ Channel *c_aa_statorCurrent =
	+ create_channel("Stator Current (AA-UP)", MAX_BUFFER_LENGTH);
	+ Channel *c_aa_electromagneticTorque =
	+ create_channel("Electromagnetic Torque (AA-UP)", MAX_BUFFER_LENGTH);
	+ Channel *c_aa_speed =
	+ create_channel("Speed Sensor (AA-UP)", MAX_BUFFER_LENGTH);
	+
	+ // mount sensors in agents
	+ // inputs
	+ mount_sensorInAgent(a_statorVoltage, s_statorVoltage, c_sa_statorVoltage);
	+ mount_sensorInAgent(a_mechanicalTorque, s_mechanicalTorque,
	+ c_sa_mechanicalTorque);
	+ // outputs
	+ mount_sensorInAgent(a_statorCurrent, s_statorCurrent, c_sa_statorCurrent);
	+ mount_sensorInAgent(a_electromagneticTorque, s_electromagneticTorque,
	+ c_sa_electromagneticTorque);
	+ mount_sensorInAgent(a_speed, s_speed, c_sa_speed);
	+
	+ // mount agents in agent(s)
	+ // inputs
	+ mount_agentInAgent(a_viabilityMonitor, a_statorVoltage, c_aa_statorVoltage);
	+ mount_agentInAgent(a_viabilityMonitor, a_mechanicalTorque,
	+ c_aa_mechanicalTorque);
	+ // outputs
	+ mount_agentInAgent(a_viabilityMonitor, a_statorCurrent, c_aa_statorCurrent);
	+ mount_agentInAgent(a_viabilityMonitor, a_electromagneticTorque,
	+ c_aa_electromagneticTorque);
	+ mount_agentInAgent(a_viabilityMonitor, a_speed, c_aa_speed);
	+
	+
	+ // set State Handler in Master Agent and Initialize an CSVWriter for the CAM
	+ // output
	+ a_viabilityMonitor->set_stateHandler("CSVW:CAMoutput", destinationPath);
	+
	+
	+ // register agents in agents' stateHandler
	+ // inputs
	+ registerSlaveAgentAsInputVariableInStateHandler(a_viabilityMonitor,
	+ c_aa_statorVoltage);
	+ registerSlaveAgentAsInputVariableInStateHandler(a_viabilityMonitor,
	+ c_aa_mechanicalTorque);
	+ // outputs
	+ registerSlaveAgentAsOutputVariableInStateHandler(a_viabilityMonitor,
	+ c_aa_statorCurrent);
	+ registerSlaveAgentAsOutputVariableInStateHandler(a_viabilityMonitor,
	+ c_aa_electromagneticTorque);
	+ registerSlaveAgentAsOutputVariableInStateHandler(a_viabilityMonitor,
	+ c_aa_speed);
	+
	+ // SAME STATE DEVIATION
	+ LinearFunctionBlock *confSim2StateDev =
	+ new LinearFunctionBlock("funcBlock:confSim2StateDev");
	+ LinearFunction *funcConfSim2StateDev1 = new LinearFunction();
	+ funcConfSim2StateDev1->setDomain(false, true, -1 * outerBoundSimDif);
	+ funcConfSim2StateDev1->setKandD((float)0, (float)0);
	+ confSim2StateDev->addLinearFunction(funcConfSim2StateDev1);
	+ LinearFunction *funcConfSim2StateDev2 = new LinearFunction();
	+ funcConfSim2StateDev2->setDomain(true, -1 * outerBoundSimDif, true,
	+ -1 * innerBoundSimDif);
	+ funcConfSim2StateDev2->setKandD(-1 * outerBoundSimDif, (float)0,
	+ -1 * innerBoundSimDif, (float)1);
	+ confSim2StateDev->addLinearFunction(funcConfSim2StateDev2);
	+ LinearFunction *funcConfSim2StateDev3 = new LinearFunction();
	+ funcConfSim2StateDev3->setDomain(true, -1 * innerBoundSimDif, true,
	+ innerBoundSimDif);
	+ funcConfSim2StateDev3->setKandD((float)0, (float)1);
	+ confSim2StateDev->addLinearFunction(funcConfSim2StateDev3);
	+ LinearFunction *funcConfSim2StateDev4 = new LinearFunction();
	+ funcConfSim2StateDev4->setDomain(true, innerBoundSimDif, true,
	+ outerBoundSimDif);
	+ funcConfSim2StateDev4->setKandD(innerBoundSimDif, (float)1, outerBoundSimDif,
	+ (float)0);
	+ confSim2StateDev->addLinearFunction(funcConfSim2StateDev4);
	+ LinearFunction *funcConfSim2StateDev5 = new LinearFunction();
	+ funcConfSim2StateDev5->setDomain(true, outerBoundSimDif, false);
	+ funcConfSim2StateDev5->setKandD((float)0, (float)0);
	+ confSim2StateDev->addLinearFunction(funcConfSim2StateDev5);
	+#ifdef PRINT
	+ confSim2StateDev->printFunctionBlock("funcBlock:confSim2StateDev");
	+#endif // PRINT
	+
	+ // ANOTHER STATE DEVIATION
	+ LinearFunctionBlock *confDif2StateDev =
	+ new LinearFunctionBlock("funcBlock:confDif2StateDev");
	+ LinearFunction *funcConfDif2StateDev1 = new LinearFunction();
	+ funcConfDif2StateDev1->setDomain(false, true, -1 * outerBoundSimDif);
	+ funcConfDif2StateDev1->setKandD((float)0, (float)1);
	+ confDif2StateDev->addLinearFunction(funcConfDif2StateDev1);
	+ LinearFunction *funcConfDif2StateDev2 = new LinearFunction();
	+ funcConfDif2StateDev2->setDomain(true, -1 * outerBoundSimDif, true,
	+ -1 * innerBoundSimDif);
	+ funcConfDif2StateDev2->setKandD(-1 * outerBoundSimDif, (float)1,
	+ -1 * innerBoundSimDif, (float)0);
	+ confDif2StateDev->addLinearFunction(funcConfDif2StateDev2);
	+ LinearFunction *funcConfDif2StateDev3 = new LinearFunction();
	+ funcConfDif2StateDev3->setDomain(true, -1 * innerBoundSimDif, true,
	+ innerBoundSimDif);
	+ funcConfDif2StateDev3->setKandD((float)0, (float)0);
	+ confDif2StateDev->addLinearFunction(funcConfDif2StateDev3);
	+ LinearFunction *funcConfDif2StateDev4 = new LinearFunction();
	+ funcConfDif2StateDev4->setDomain(true, innerBoundSimDif, true,
	+ outerBoundSimDif);
	+ funcConfDif2StateDev4->setKandD(innerBoundSimDif, (float)0, outerBoundSimDif,
	+ (float)1);
	+ confDif2StateDev->addLinearFunction(funcConfDif2StateDev4);
	+ LinearFunction *funcConfDif2StateDev5 = new LinearFunction();
	+ funcConfDif2StateDev5->setDomain(true, outerBoundSimDif, false);
	+ funcConfDif2StateDev5->setKandD((float)0, (float)1);
	+ confDif2StateDev->addLinearFunction(funcConfDif2StateDev5);
	+#ifdef PRINT
	+ confDif2StateDev->printFunctionBlock("funcBlock:confDif2StateDev");
	+#endif // PRINT
	+
	+ // SAME STATE TIME
	+ LinearFunctionBlock *confSim2StateTime =
	+ new LinearFunctionBlock("funcBlock:confSim2StateTime");
	+ LinearFunction *funcConfSim2StateTime1 = new LinearFunction();
	+ funcConfSim2StateTime1->setDomain(false, true, (float)0);
	+ funcConfSim2StateTime1->setKandD((float)0, (float)0);
	+ confSim2StateTime->addLinearFunction(funcConfSim2StateTime1);
	+ LinearFunction *funcConfSim2StateTime2 = new LinearFunction();
	+ funcConfSim2StateTime2->setDomain(true, (float)0, true,
	+ (float)boundTimeInSamples);
	+ funcConfSim2StateTime2->setKandD((float)0, (float)0,
	+ (float)boundTimeInSamples, (float)1);
	+ confSim2StateTime->addLinearFunction(funcConfSim2StateTime2);
	+ LinearFunction *funcConfSim2StateTime3 = new LinearFunction();
	+ funcConfSim2StateTime3->setDomain(true, (float)boundTimeInSamples, false);
	+ funcConfSim2StateTime3->setKandD((float)0, (float)1);
	+ confSim2StateTime->addLinearFunction(funcConfSim2StateTime3);
	+#ifdef PRINT
	+ confSim2StateTime->printFunctionBlock("funcBlock:confSim2StateTime");
	+#endif // PRINT
	+
	+ // ANOTHER STATE TIME
	+ LinearFunctionBlock *confDif2StateTime =
	+ new LinearFunctionBlock("funcBlock:confDif2StateTime");
	+ LinearFunction *funcConfDif2StateTime1 = new LinearFunction();
	+ funcConfDif2StateTime1->setDomain(false, true, (float)0);
	+ funcConfDif2StateTime1->setKandD((float)0, (float)1);
	+ confDif2StateTime->addLinearFunction(funcConfDif2StateTime1);
	+ LinearFunction *funcConfDif2StateTime2 = new LinearFunction();
	+ funcConfDif2StateTime2->setDomain(true, (float)0, true,
	+ (float)boundTimeInSamples);
	+ funcConfDif2StateTime2->setKandD((float)0, (float)1,
	+ (float)boundTimeInSamples, (float)0);
	+ confDif2StateTime->addLinearFunction(funcConfDif2StateTime2);
	+ LinearFunction *funcConfDif2StateTime3 = new LinearFunction();
	+ funcConfDif2StateTime3->setDomain(true, (float)boundTimeInSamples, false);
	+ funcConfDif2StateTime3->setKandD((float)0, (float)0);
	+ confDif2StateTime->addLinearFunction(funcConfDif2StateTime3);
	+#ifdef PRINT
	+ confDif2StateTime->printFunctionBlock("funcBlock:confDif2StateTime");
	+#endif // PRINT
	+
	+ /************************ FunctionBlocks Val/Inv State (NEU)
	+ * ************************/
	+
	+ // VALID STATE DEVIATION
	+ LinearFunctionBlock *confValidStateDev =
	+ new LinearFunctionBlock("funcBlock:confValidStateDev");
	+ LinearFunction *funcConfValidStateDev1 = new LinearFunction();
	+ funcConfValidStateDev1->setDomain(false, true, -1 * outerBoundSimDif);
	+ funcConfValidStateDev1->setKandD((float)0, (float)0);
	+ confValidStateDev->addLinearFunction(funcConfValidStateDev1);
	+ LinearFunction *funcConfValidStateDev2 = new LinearFunction();
	+ funcConfValidStateDev2->setDomain(true, -1 * outerBoundSimDif, true,
	+ -1 * innerBoundSimDif);
	+ funcConfValidStateDev2->setKandD(-1 * outerBoundSimDif, (float)0,
	+ -1 * innerBoundSimDif, (float)1);
	+ confValidStateDev->addLinearFunction(funcConfValidStateDev2);
	+ LinearFunction *funcConfValidStateDev3 = new LinearFunction();
	+ funcConfValidStateDev3->setDomain(true, -1 * innerBoundSimDif, true,
	+ innerBoundSimDif);
	+ funcConfValidStateDev3->setKandD((float)0, (float)1);
	+ confValidStateDev->addLinearFunction(funcConfValidStateDev3);
	+ LinearFunction *funcConfValidStateDev4 = new LinearFunction();
	+ funcConfValidStateDev4->setDomain(true, innerBoundSimDif, true,
	+ outerBoundSimDif);
	+ funcConfValidStateDev4->setKandD(innerBoundSimDif, (float)1, outerBoundSimDif,
	+ (float)0);
	+ confValidStateDev->addLinearFunction(funcConfValidStateDev4);
	+ LinearFunction *funcConfValidStateDev5 = new LinearFunction();
	+ funcConfValidStateDev5->setDomain(true, outerBoundSimDif, false);
	+ funcConfValidStateDev5->setKandD((float)0, (float)0);
	+ confValidStateDev->addLinearFunction(funcConfValidStateDev5);
	+#ifdef PRINT
	+ confValidStateDev->printFunctionBlock("funcBlock:confValidStateDev");
	+#endif // PRINT
	+
	+ // INVALID STATE DEVIATION
	+ LinearFunctionBlock *confInvalidStateDev =
	+ new LinearFunctionBlock("funcBlock:confInvalidStateDev");
	+ LinearFunction *funcConfInvalidStateDev1 = new LinearFunction();
	+ funcConfInvalidStateDev1->setDomain(false, true, -1 * outerBoundSimDif);
	+ funcConfInvalidStateDev1->setKandD((float)0, (float)1);
	+ confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev1);
	+ LinearFunction *funcConfInvalidStateDev2 = new LinearFunction();
	+ funcConfInvalidStateDev2->setDomain(true, -1 * outerBoundSimDif, true,
	+ -1 * innerBoundSimDif);
	+ funcConfInvalidStateDev2->setKandD(-1 * outerBoundSimDif, (float)1,
	+ -1 * innerBoundSimDif, (float)0);
	+ confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev2);
	+ LinearFunction *funcConfInvalidStateDev3 = new LinearFunction();
	+ funcConfInvalidStateDev3->setDomain(true, -1 * innerBoundSimDif, true,
	+ innerBoundSimDif);
	+ funcConfInvalidStateDev3->setKandD((float)0, (float)0);
	+ confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev3);
	+ LinearFunction *funcConfInvalidStateDev4 = new LinearFunction();
	+ funcConfInvalidStateDev4->setDomain(true, innerBoundSimDif, true,
	+ outerBoundSimDif);
	+ funcConfInvalidStateDev4->setKandD(innerBoundSimDif, (float)0,
	+ outerBoundSimDif, (float)1);
	+ confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev4);
	+ LinearFunction *funcConfInvalidStateDev5 = new LinearFunction();
	+ funcConfInvalidStateDev5->setDomain(true, outerBoundSimDif, false);
	+ funcConfInvalidStateDev5->setKandD((float)0, (float)1);
	+ confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev5);
	+#ifdef PRINT
	+ confInvalidStateDev->printFunctionBlock("funcBlock:confInvalidStateDev");
	+#endif // PRINT
	+
	+ // VALID STATE TIME
	+ LinearFunctionBlock *confValidStateTime =
	+ new LinearFunctionBlock("funcBlock:confValidStateTime");
	+ LinearFunction *funcConfValidStateTime1 = new LinearFunction();
	+ funcConfValidStateTime1->setDomain(false, true, (float)0);
	+ funcConfValidStateTime1->setKandD((float)0, (float)0);
	+ confValidStateTime->addLinearFunction(funcConfValidStateTime1);
	+ LinearFunction *funcConfValidStateTime2 = new LinearFunction();
	+ funcConfValidStateTime2->setDomain(true, (float)0, true,
	+ (float)boundTimeInSamples); // 10
	+ funcConfValidStateTime2->setKandD((float)0, (float)0,
	+ (float)boundTimeInSamples, (float)1);
	+ confValidStateTime->addLinearFunction(funcConfValidStateTime2);
	+ LinearFunction *funcConfValidStateTime3 = new LinearFunction();
	+ funcConfValidStateTime3->setDomain(true, (float)boundTimeInSamples, false);
	+ funcConfValidStateTime3->setKandD((float)0, (float)1);
	+ confValidStateTime->addLinearFunction(funcConfValidStateTime3);
	+#ifdef PRINT
	+ confValidStateTime->printFunctionBlock("funcBlock:confValidStateTime");
	+#endif // PRINT
	+
	+ // INVALID STATE TIME
	+ LinearFunctionBlock *confInvalidStateTime =
	+ new LinearFunctionBlock("funcBlock:confInvalidStateTime");
	+ LinearFunction *funcConfInvalidStateTime1 = new LinearFunction();
	+ funcConfInvalidStateTime1->setDomain(false, true, (float)0);
	+ funcConfInvalidStateTime1->setKandD((float)0, (float)1);
	+ confInvalidStateTime->addLinearFunction(funcConfInvalidStateTime1);
	+ LinearFunction *funcConfInvalidStateTime2 = new LinearFunction();
	+ funcConfInvalidStateTime2->setDomain(true, (float)0, true,
	+ (float)boundTimeInSamples);
	+ funcConfInvalidStateTime2->setKandD((float)0, (float)1,
	+ (float)boundTimeInSamples, (float)0);
	+ confInvalidStateTime->addLinearFunction(funcConfInvalidStateTime2);
	+ LinearFunction *funcConfInvalidStateTime3 = new LinearFunction();
	+ funcConfInvalidStateTime3->setDomain(true, (float)boundTimeInSamples, false);
	+ funcConfInvalidStateTime3->setKandD((float)0, (float)0);
	+ confInvalidStateTime->addLinearFunction(funcConfInvalidStateTime3);
	+#ifdef PRINT
	+ confInvalidStateTime->printFunctionBlock("funcBlock:confInvalidStateTime");
	+#endif // PRINT
	+
	+ /********************************** Functions NOT OK
	+ * **********************************/
	+
	+ LinearFunctionBlock *confStateDrifts =
	+ new LinearFunctionBlock("confidence:confStateDrifts");
	+ LinearFunction *functionConfidenceDriftDeviation1 = new LinearFunction();
	+ functionConfidenceDriftDeviation1->setDomain(false, true,
	+ -1 * outerBoundDrift);
	+ functionConfidenceDriftDeviation1->setKandD((float)0, (float)1);
	+ confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation1);
	+ LinearFunction *functionConfidenceDriftDeviation2 = new LinearFunction();
	+ functionConfidenceDriftDeviation2->setDomain(true, -1 * outerBoundDrift, true,
	+ -1 * innerBoundDrift);
	+ functionConfidenceDriftDeviation2->setKandD(-1 * outerBoundDrift, (float)1,
	+ -1 * innerBoundDrift, (float)0);
	+ confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation2);
	+ LinearFunction *functionConfidenceDriftDeviation3 = new LinearFunction();
	+ functionConfidenceDriftDeviation3->setDomain(true, -1 * innerBoundDrift, true,
	+ innerBoundDrift);
	+ functionConfidenceDriftDeviation3->setKandD((float)0, (float)0);
	+ confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation3);
	+ LinearFunction *functionConfidenceDriftDeviation4 = new LinearFunction();
	+ functionConfidenceDriftDeviation4->setDomain(true, innerBoundDrift, true,
	+ outerBoundDrift);
	+ functionConfidenceDriftDeviation4->setKandD(innerBoundDrift, (float)0,
	+ outerBoundDrift, (float)1);
	+ confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation4);
	+ LinearFunction *functionConfidenceDriftDeviation5 = new LinearFunction();
	+ functionConfidenceDriftDeviation5->setDomain(true, outerBoundDrift, false);
	+ functionConfidenceDriftDeviation5->setKandD((float)0, (float)1);
	+ confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation5);
	+#ifdef PRINT
	+ confStateDrifts.printFunctionBlock("confidence:confStateDrifts");
	+#endif
	+
	+ LinearFunctionBlock *confBroken =
	+ new LinearFunctionBlock("confidence:broken");
	+ LinearFunction *functionConfidenceBroken1 = new LinearFunction();
	+ functionConfidenceBroken1->setDomain(false, true, (float)0);
	+ functionConfidenceBroken1->setKandD((float)0, (float)0);
	+ confBroken->addLinearFunction(functionConfidenceBroken1);
	+ LinearFunction *functionConfidenceBroken2 = new LinearFunction();
	+ functionConfidenceBroken2->setDomain(true, (float)0, true,
	+ (float)boundBrokenTime);
	+ functionConfidenceBroken2->setKandD((float)0, (float)0,
	+ (float)boundBrokenTime, (float)1);
	+ confBroken->addLinearFunction(functionConfidenceBroken2);
	+ LinearFunction *functionConfidenceBroken3 = new LinearFunction();
	+ functionConfidenceBroken3->setDomain(true, (float)boundBrokenTime, false);
	+ functionConfidenceBroken3->setKandD((float)0, (float)1);
	+ confBroken->addLinearFunction(functionConfidenceBroken3);
	+#ifdef PRINT
	+ confBroken->printFunctionBlock("confidence:broken");
	+#endif // PRINT
	+
	+ /********************************** Mount Functions
	+ * **********************************/
	+ a_viabilityMonitor->get_stateHandler()->setMaxStateHistoryLength(
	+ boundTimeInSamples);
	+ a_viabilityMonitor->get_stateHandler()->setSimilarToStateFuzzyFunctions(
	+ confSim2StateDev, confSim2StateTime);
	+ a_viabilityMonitor->get_stateHandler()->setDifferentToStateFuzzyFunctions(
	+ confDif2StateDev, confDif2StateTime);
	+ a_viabilityMonitor->get_stateHandler()->setSimilarityInStateFuzzyFunctions(
	+ confValidStateDev, confValidStateTime);
	+ a_viabilityMonitor->get_stateHandler()->setUnsimilarityInStateFuzzyFunctions(
	+ confInvalidStateDev, confInvalidStateTime);
	+ a_viabilityMonitor->get_stateHandler()->setDriftFuzzyFunction(
	+ confStateDrifts);
	+ a_viabilityMonitor->get_stateHandler()->setBrokenFuzzyFunction(confBroken);
	+
	+
	+ // create testbench
	+ Testbench *tb = create_testbench("testbench");
	+
	+ // create CSV reader modules
	+ unsigned int ROW = 2;
	+ char csvPath[600];
	+ // inputs
	+#ifdef _WIN32
	+ sprintf_s(csvPath, "%s\\statorVoltage_abstracted.csv", datasetPath);
	+#else
	+ sprintf(csvPath, "%s/statorVoltage_abstracted.csv", datasetPath);
	+#endif // _WIN32
	+ CSVreaderModule *csvr_statorVoltage =
	+ create_CSVreaderModule("Stator Voltage CSV-Reader", csvPath, 2, ROW);
	+#ifdef _WIN32
	+ sprintf_s(csvPath, "%s\\mechanicalTorque.csv", datasetPath);
	+#else
	+ sprintf(csvPath, "%s/mechanicalTorque.csv", datasetPath);
	+#endif // _WIN32
	+ CSVreaderModule *csvr_mechanicalTorque =
	+ create_CSVreaderModule("Mechanical Torque CSV-Reader", csvPath, 2, ROW);
	+ // outputs
	+#ifdef _WIN32
	+ sprintf_s(csvPath, "%s\\statorCurrent_abstracted.csv", datasetPath);
	+#else
	+ sprintf(csvPath, "%s/statorCurrent_abstracted.csv", datasetPath);
	+#endif // _WIN32
	+ CSVreaderModule *csvr_statorCurrent =
	+ create_CSVreaderModule("Stator Current CSV-Reader", csvPath, 2, ROW);
	+#ifdef _WIN32
	+ sprintf_s(csvPath, "%s\\electromagneticTorque.csv", datasetPath);
	+#else
	+ sprintf(csvPath, "%s/electromagneticTorque.csv", datasetPath);
	+#endif // _WIN32
	+ CSVreaderModule *csvr_electromagneticTorque = create_CSVreaderModule(
	+ "Electromagnetic Torque CSV-Reader", csvPath, 2, ROW);
	+#ifdef _WIN32
	+ sprintf_s(csvPath, "%s\\speed.csv", datasetPath);
	+#else
	+ sprintf(csvPath, "%s/speed.csv", datasetPath);
	+#endif // _WIN32
	+ CSVreaderModule *csvr_speed =
	+ create_CSVreaderModule("Speed CSV-Reader", csvPath, 2, ROW);
	+
	+
	+
	+ // register agents
	+ // low level agents - inputs
	+ register_agentInTestbench(tb, a_statorVoltage);
	+ register_agentInTestbench(tb, a_mechanicalTorque);
	+ // low level agents - outputs
	+ register_agentInTestbench(tb, a_statorCurrent);
	+ register_agentInTestbench(tb, a_electromagneticTorque);
	+ register_agentInTestbench(tb, a_speed);
	+ // high level agent
	+ register_agentInTestbench(tb, a_viabilityMonitor);
	+
	+ // register sensors with their csv-readers
	+ // inputs
	+ register_sensorInTestbench(tb, s_statorVoltage, csvr_statorVoltage);
	+ register_sensorInTestbench(tb, s_mechanicalTorque, csvr_mechanicalTorque);
	+ // outputs
	+ register_sensorInTestbench(tb, s_statorCurrent, csvr_statorCurrent);
	+ register_sensorInTestbench(tb, s_electromagneticTorque,
	+ csvr_electromagneticTorque);
	+ register_sensorInTestbench(tb, s_speed, csvr_speed);
	+
	+ // register sensor channels
	+ // sensor-agent channels
	+ // inputs
	+ register_channelInTestbench(tb, c_sa_statorVoltage);
	+ register_channelInTestbench(tb, c_sa_mechanicalTorque);
	+ // outputs
	+ register_channelInTestbench(tb, c_sa_statorCurrent);
	+ register_channelInTestbench(tb, c_sa_electromagneticTorque);
	+ register_channelInTestbench(tb, c_sa_speed);
	+
	+ // agent-agent channels
	+ // inputs
	+ register_channelInTestbench(tb, c_aa_statorVoltage);
	+ register_channelInTestbench(tb, c_aa_mechanicalTorque);
	+ // ouputs
	+ register_channelInTestbench(tb, c_aa_statorCurrent);
	+ register_channelInTestbench(tb, c_aa_speed);
	+ register_channelInTestbench(tb, c_aa_electromagneticTorque);
	+
	+#ifdef STOP_BEFORE_SIMULATING
	+ getchar();
	+#endif
	+
	+ tb->simulate(datasetLength);
	+}
	diff --git a/Version_Max_07_05_2018_CMake/src/configCAMforOldMotorNormal.h b/Version_Max_07_05_2018_CMake/src/configCAMforOldMotorNormal.h
	new file mode 100644
	index 0000000..06fa4b0
	--- /dev/null
	+++ b/Version_Max_07_05_2018_CMake/src/configCAMforOldMotorNormal.h
	@@ -0,0 +1,11 @@
	+#ifndef HEADER_NEWMOTOR_NORMAL_CONFIG
	+#define HEADER_NEWMOTOR_NORMAL_CONFIG
	+
	+void configAndStartOldMotorNormalExperiment(
	+ char destinationPath, char datasetPath, char *datasetName,
	+ unsigned int datasetLength, float innerBoundSimDif, float outerBoundSimDif,
	+ int boundTimeInSamples, unsigned int discreteAveragePartitionSize,
	+ float innerBoundDrift, float outerBoundDrift, int boundBrokenTime,
	+ int downSamplingFactor);
	+
	+#endif
	\ No newline at end of file
	diff --git a/Version_Max_07_05_2018_CMake/src/configCAMforOldMotorSpeedChange.cpp b/Version_Max_07_05_2018_CMake/src/configCAMforOldMotorSpeedChange.cpp
	new file mode 100644
	index 0000000..c7ddf53
	--- /dev/null
	+++ b/Version_Max_07_05_2018_CMake/src/configCAMforOldMotorSpeedChange.cpp
	@@ -0,0 +1,527 @@
	+#include "configCAMforOldMotorSpeedChange.h"
	+
	+#include "Agent.h"
	+#include "CSVreaderModule.h"
	+#include "Channel.h"
	+#include "Sensor.h"
	+#include "Testbench.h"
	+#include "create_unit.h"
	+#include "file_util.h"
	+#include "inAgentsRegistrations.h"
	+#include "mount_nodes.h"
	+#include "register_in_testbench.h"
	+#include "setupNode.h"
	+
	+#include "LinearFunction.h"
	+#include "LinearFunctionBlock.h"
	+
	+//#define PRINT
	+//#define STOP_BEFORE_SIMULATING
	+
	+void configAndStartOldMotorSpeedChangeExperiment(
	+ char destinationPath, char datasetPath, char *datasetName,
	+ unsigned int datasetLength, float innerBoundSimDif, float outerBoundSimDif,
	+ int boundTimeInSamples, unsigned int discreteAveragePartitionSize,
	+ float innerBoundDrift, float outerBoundDrift, int boundBrokenTime,
	+ int downSamplingFactor) {
	+
	+ // config starts here
	+ // create agents
	+ // low level agents - inputs
	+ Agent *a_statorVoltage = create_agent("Stator Voltage");
	+ setWorkingCycleOfAgent(a_statorVoltage, downSamplingFactor);
	+ Agent *a_inputFrequency = create_agent("Input Frequency");
	+ setWorkingCycleOfAgent(a_inputFrequency, downSamplingFactor);
	+ Agent *a_mechanicalTorque = create_agent("Mechanical Torque");
	+ setWorkingCycleOfAgent(a_mechanicalTorque, downSamplingFactor);
	+ // low level agents - outputs
	+ Agent *a_statorCurrent = create_agent("Stator Current");
	+ setWorkingCycleOfAgent(a_statorCurrent, downSamplingFactor);
	+ Agent *a_electromagneticTorque = create_agent("Electromagnetic Torque");
	+ setWorkingCycleOfAgent(a_electromagneticTorque, downSamplingFactor);
	+ Agent *a_speed = create_agent("Speed");
	+ setWorkingCycleOfAgent(a_speed, downSamplingFactor);
	+ // high level agent
	+ Agent *a_viabilityMonitor = create_agent("Viability Monitor");
	+ setWorkingCycleOfAgent(a_viabilityMonitor, downSamplingFactor);
	+
	+ // create sensors
	+ // inputs
	+ Sensor *s_statorVoltage = create_sensor("Stator Voltage");
	+ setWorkingCycleOfSensor(s_statorVoltage, downSamplingFactor);
	+ Sensor *s_inputFrequency = create_sensor("Input Frequency");
	+ setWorkingCycleOfSensor(s_inputFrequency, downSamplingFactor);
	+ Sensor *s_mechanicalTorque = create_sensor("Mechanical Torque");
	+ setWorkingCycleOfSensor(s_mechanicalTorque, downSamplingFactor);
	+ // outputs
	+ Sensor *s_statorCurrent = create_sensor("Stator Current");
	+ setWorkingCycleOfSensor(s_statorCurrent, downSamplingFactor);
	+ Sensor *s_electromagneticTorque = create_sensor("Electromagnetic Torque");
	+ setWorkingCycleOfSensor(s_electromagneticTorque, downSamplingFactor);
	+ Sensor *s_speed = create_sensor("Speed");
	+ setWorkingCycleOfSensor(s_speed, downSamplingFactor);
	+
	+ // create channels for sensors
	+ // inputs
	+ Channel *c_sa_statorVoltage = create_channel("Stator Voltage (SA)", 0);
	+ Channel *c_sa_inputFrequency = create_channel("Input Frequency (SA)", 0);
	+ Channel *c_sa_mechanicalTorque = create_channel("Mechanical Torque (SA)", 0);
	+ // outputs
	+ Channel *c_sa_statorCurrent = create_channel("Stator Current (SA)", 0);
	+ Channel *c_sa_electromagneticTorque =
	+ create_channel("Electromagnetic Torque (SA)", 0);
	+ Channel *c_sa_speed = create_channel("Speed Sensor (SA)", 0);
	+
	+ // create channels for sensors
	+ // inputs
	+ Channel *c_aa_statorVoltage =
	+ create_channel("Stator Voltage (AA-UP)", MAX_BUFFER_LENGTH);
	+ Channel *c_aa_inputFrequency =
	+ create_channel("Input Frequency (AA-UP)", MAX_BUFFER_LENGTH);
	+ Channel *c_aa_mechanicalTorque =
	+ create_channel("Mechanical Torque (AA-UP)", MAX_BUFFER_LENGTH);
	+ // outputs
	+ Channel *c_aa_statorCurrent =
	+ create_channel("Stator Current (AA-UP)", MAX_BUFFER_LENGTH);
	+ Channel *c_aa_electromagneticTorque =
	+ create_channel("Electromagnetic Torque (AA-UP)", MAX_BUFFER_LENGTH);
	+ Channel *c_aa_speed =
	+ create_channel("Speed Sensor (AA-UP)", MAX_BUFFER_LENGTH);
	+
	+ // mount sensors in agents
	+ // inputs
	+ mount_sensorInAgent(a_statorVoltage, s_statorVoltage, c_sa_statorVoltage);
	+ mount_sensorInAgent(a_inputFrequency, s_inputFrequency, c_sa_inputFrequency);
	+ mount_sensorInAgent(a_mechanicalTorque, s_mechanicalTorque,
	+ c_sa_mechanicalTorque);
	+ // outputs
	+ mount_sensorInAgent(a_statorCurrent, s_statorCurrent, c_sa_statorCurrent);
	+ mount_sensorInAgent(a_electromagneticTorque, s_electromagneticTorque,
	+ c_sa_electromagneticTorque);
	+ mount_sensorInAgent(a_speed, s_speed, c_sa_speed);
	+
	+ // mount agents in agent(s)
	+ // inputs
	+ mount_agentInAgent(a_viabilityMonitor, a_statorVoltage, c_aa_statorVoltage);
	+ mount_agentInAgent(a_viabilityMonitor, a_inputFrequency, c_aa_inputFrequency);
	+ mount_agentInAgent(a_viabilityMonitor, a_mechanicalTorque,
	+ c_aa_mechanicalTorque);
	+ // outputs
	+ mount_agentInAgent(a_viabilityMonitor, a_statorCurrent, c_aa_statorCurrent);
	+ mount_agentInAgent(a_viabilityMonitor, a_electromagneticTorque,
	+ c_aa_electromagneticTorque);
	+ mount_agentInAgent(a_viabilityMonitor, a_speed, c_aa_speed);
	+
	+
	+ // set State Handler in Master Agent and Initialize an CSVWriter for the CAM
	+ // output
	+ a_viabilityMonitor->set_stateHandler("CSVW:CAMoutput", destinationPath);
	+
	+
	+ // register agents in agents' stateHandler
	+ // inputs
	+ registerSlaveAgentAsInputVariableInStateHandler(a_viabilityMonitor,
	+ c_aa_statorVoltage);
	+ registerSlaveAgentAsInputVariableInStateHandler(a_viabilityMonitor,
	+ c_aa_inputFrequency);
	+ registerSlaveAgentAsInputVariableInStateHandler(a_viabilityMonitor,
	+ c_aa_mechanicalTorque);
	+ // outputs
	+ registerSlaveAgentAsOutputVariableInStateHandler(a_viabilityMonitor,
	+ c_aa_statorCurrent);
	+ registerSlaveAgentAsOutputVariableInStateHandler(a_viabilityMonitor,
	+ c_aa_electromagneticTorque);
	+ registerSlaveAgentAsOutputVariableInStateHandler(a_viabilityMonitor,
	+ c_aa_speed);
	+
	+ // SAME STATE DEVIATION
	+ LinearFunctionBlock *confSim2StateDev =
	+ new LinearFunctionBlock("funcBlock:confSim2StateDev");
	+ LinearFunction *funcConfSim2StateDev1 = new LinearFunction();
	+ funcConfSim2StateDev1->setDomain(false, true, -1 * outerBoundSimDif);
	+ funcConfSim2StateDev1->setKandD((float)0, (float)0);
	+ confSim2StateDev->addLinearFunction(funcConfSim2StateDev1);
	+ LinearFunction *funcConfSim2StateDev2 = new LinearFunction();
	+ funcConfSim2StateDev2->setDomain(true, -1 * outerBoundSimDif, true,
	+ -1 * innerBoundSimDif);
	+ funcConfSim2StateDev2->setKandD(-1 * outerBoundSimDif, (float)0,
	+ -1 * innerBoundSimDif, (float)1);
	+ confSim2StateDev->addLinearFunction(funcConfSim2StateDev2);
	+ LinearFunction *funcConfSim2StateDev3 = new LinearFunction();
	+ funcConfSim2StateDev3->setDomain(true, -1 * innerBoundSimDif, true,
	+ innerBoundSimDif);
	+ funcConfSim2StateDev3->setKandD((float)0, (float)1);
	+ confSim2StateDev->addLinearFunction(funcConfSim2StateDev3);
	+ LinearFunction *funcConfSim2StateDev4 = new LinearFunction();
	+ funcConfSim2StateDev4->setDomain(true, innerBoundSimDif, true,
	+ outerBoundSimDif);
	+ funcConfSim2StateDev4->setKandD(innerBoundSimDif, (float)1, outerBoundSimDif,
	+ (float)0);
	+ confSim2StateDev->addLinearFunction(funcConfSim2StateDev4);
	+ LinearFunction *funcConfSim2StateDev5 = new LinearFunction();
	+ funcConfSim2StateDev5->setDomain(true, outerBoundSimDif, false);
	+ funcConfSim2StateDev5->setKandD((float)0, (float)0);
	+ confSim2StateDev->addLinearFunction(funcConfSim2StateDev5);
	+#ifdef PRINT
	+ confSim2StateDev->printFunctionBlock("funcBlock:confSim2StateDev");
	+#endif // PRINT
	+
	+ // ANOTHER STATE DEVIATION
	+ LinearFunctionBlock *confDif2StateDev =
	+ new LinearFunctionBlock("funcBlock:confDif2StateDev");
	+ LinearFunction *funcConfDif2StateDev1 = new LinearFunction();
	+ funcConfDif2StateDev1->setDomain(false, true, -1 * outerBoundSimDif);
	+ funcConfDif2StateDev1->setKandD((float)0, (float)1);
	+ confDif2StateDev->addLinearFunction(funcConfDif2StateDev1);
	+ LinearFunction *funcConfDif2StateDev2 = new LinearFunction();
	+ funcConfDif2StateDev2->setDomain(true, -1 * outerBoundSimDif, true,
	+ -1 * innerBoundSimDif);
	+ funcConfDif2StateDev2->setKandD(-1 * outerBoundSimDif, (float)1,
	+ -1 * innerBoundSimDif, (float)0);
	+ confDif2StateDev->addLinearFunction(funcConfDif2StateDev2);
	+ LinearFunction *funcConfDif2StateDev3 = new LinearFunction();
	+ funcConfDif2StateDev3->setDomain(true, -1 * innerBoundSimDif, true,
	+ innerBoundSimDif);
	+ funcConfDif2StateDev3->setKandD((float)0, (float)0);
	+ confDif2StateDev->addLinearFunction(funcConfDif2StateDev3);
	+ LinearFunction *funcConfDif2StateDev4 = new LinearFunction();
	+ funcConfDif2StateDev4->setDomain(true, innerBoundSimDif, true,
	+ outerBoundSimDif);
	+ funcConfDif2StateDev4->setKandD(innerBoundSimDif, (float)0, outerBoundSimDif,
	+ (float)1);
	+ confDif2StateDev->addLinearFunction(funcConfDif2StateDev4);
	+ LinearFunction *funcConfDif2StateDev5 = new LinearFunction();
	+ funcConfDif2StateDev5->setDomain(true, outerBoundSimDif, false);
	+ funcConfDif2StateDev5->setKandD((float)0, (float)1);
	+ confDif2StateDev->addLinearFunction(funcConfDif2StateDev5);
	+#ifdef PRINT
	+ confDif2StateDev->printFunctionBlock("funcBlock:confDif2StateDev");
	+#endif // PRINT
	+
	+ // SAME STATE TIME
	+ LinearFunctionBlock *confSim2StateTime =
	+ new LinearFunctionBlock("funcBlock:confSim2StateTime");
	+ LinearFunction *funcConfSim2StateTime1 = new LinearFunction();
	+ funcConfSim2StateTime1->setDomain(false, true, (float)0);
	+ funcConfSim2StateTime1->setKandD((float)0, (float)0);
	+ confSim2StateTime->addLinearFunction(funcConfSim2StateTime1);
	+ LinearFunction *funcConfSim2StateTime2 = new LinearFunction();
	+ funcConfSim2StateTime2->setDomain(true, (float)0, true,
	+ (float)boundTimeInSamples);
	+ funcConfSim2StateTime2->setKandD((float)0, (float)0,
	+ (float)boundTimeInSamples, (float)1);
	+ confSim2StateTime->addLinearFunction(funcConfSim2StateTime2);
	+ LinearFunction *funcConfSim2StateTime3 = new LinearFunction();
	+ funcConfSim2StateTime3->setDomain(true, (float)boundTimeInSamples, false);
	+ funcConfSim2StateTime3->setKandD((float)0, (float)1);
	+ confSim2StateTime->addLinearFunction(funcConfSim2StateTime3);
	+#ifdef PRINT
	+ confSim2StateTime->printFunctionBlock("funcBlock:confSim2StateTime");
	+#endif // PRINT
	+
	+ // ANOTHER STATE TIME
	+ LinearFunctionBlock *confDif2StateTime =
	+ new LinearFunctionBlock("funcBlock:confDif2StateTime");
	+ LinearFunction *funcConfDif2StateTime1 = new LinearFunction();
	+ funcConfDif2StateTime1->setDomain(false, true, (float)0);
	+ funcConfDif2StateTime1->setKandD((float)0, (float)1);
	+ confDif2StateTime->addLinearFunction(funcConfDif2StateTime1);
	+ LinearFunction *funcConfDif2StateTime2 = new LinearFunction();
	+ funcConfDif2StateTime2->setDomain(true, (float)0, true,
	+ (float)boundTimeInSamples);
	+ funcConfDif2StateTime2->setKandD((float)0, (float)1,
	+ (float)boundTimeInSamples, (float)0);
	+ confDif2StateTime->addLinearFunction(funcConfDif2StateTime2);
	+ LinearFunction *funcConfDif2StateTime3 = new LinearFunction();
	+ funcConfDif2StateTime3->setDomain(true, (float)boundTimeInSamples, false);
	+ funcConfDif2StateTime3->setKandD((float)0, (float)0);
	+ confDif2StateTime->addLinearFunction(funcConfDif2StateTime3);
	+#ifdef PRINT
	+ confDif2StateTime->printFunctionBlock("funcBlock:confDif2StateTime");
	+#endif // PRINT
	+
	+ /************************ FunctionBlocks Val/Inv State (NEU)
	+ * ************************/
	+
	+ // VALID STATE DEVIATION
	+ LinearFunctionBlock *confValidStateDev =
	+ new LinearFunctionBlock("funcBlock:confValidStateDev");
	+ LinearFunction *funcConfValidStateDev1 = new LinearFunction();
	+ funcConfValidStateDev1->setDomain(false, true, -1 * outerBoundSimDif);
	+ funcConfValidStateDev1->setKandD((float)0, (float)0);
	+ confValidStateDev->addLinearFunction(funcConfValidStateDev1);
	+ LinearFunction *funcConfValidStateDev2 = new LinearFunction();
	+ funcConfValidStateDev2->setDomain(true, -1 * outerBoundSimDif, true,
	+ -1 * innerBoundSimDif);
	+ funcConfValidStateDev2->setKandD(-1 * outerBoundSimDif, (float)0,
	+ -1 * innerBoundSimDif, (float)1);
	+ confValidStateDev->addLinearFunction(funcConfValidStateDev2);
	+ LinearFunction *funcConfValidStateDev3 = new LinearFunction();
	+ funcConfValidStateDev3->setDomain(true, -1 * innerBoundSimDif, true,
	+ innerBoundSimDif);
	+ funcConfValidStateDev3->setKandD((float)0, (float)1);
	+ confValidStateDev->addLinearFunction(funcConfValidStateDev3);
	+ LinearFunction *funcConfValidStateDev4 = new LinearFunction();
	+ funcConfValidStateDev4->setDomain(true, innerBoundSimDif, true,
	+ outerBoundSimDif);
	+ funcConfValidStateDev4->setKandD(innerBoundSimDif, (float)1, outerBoundSimDif,
	+ (float)0);
	+ confValidStateDev->addLinearFunction(funcConfValidStateDev4);
	+ LinearFunction *funcConfValidStateDev5 = new LinearFunction();
	+ funcConfValidStateDev5->setDomain(true, outerBoundSimDif, false);
	+ funcConfValidStateDev5->setKandD((float)0, (float)0);
	+ confValidStateDev->addLinearFunction(funcConfValidStateDev5);
	+#ifdef PRINT
	+ confValidStateDev->printFunctionBlock("funcBlock:confValidStateDev");
	+#endif // PRINT
	+
	+ // INVALID STATE DEVIATION
	+ LinearFunctionBlock *confInvalidStateDev =
	+ new LinearFunctionBlock("funcBlock:confInvalidStateDev");
	+ LinearFunction *funcConfInvalidStateDev1 = new LinearFunction();
	+ funcConfInvalidStateDev1->setDomain(false, true, -1 * outerBoundSimDif);
	+ funcConfInvalidStateDev1->setKandD((float)0, (float)1);
	+ confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev1);
	+ LinearFunction *funcConfInvalidStateDev2 = new LinearFunction();
	+ funcConfInvalidStateDev2->setDomain(true, -1 * outerBoundSimDif, true,
	+ -1 * innerBoundSimDif);
	+ funcConfInvalidStateDev2->setKandD(-1 * outerBoundSimDif, (float)1,
	+ -1 * innerBoundSimDif, (float)0);
	+ confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev2);
	+ LinearFunction *funcConfInvalidStateDev3 = new LinearFunction();
	+ funcConfInvalidStateDev3->setDomain(true, -1 * innerBoundSimDif, true,
	+ innerBoundSimDif);
	+ funcConfInvalidStateDev3->setKandD((float)0, (float)0);
	+ confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev3);
	+ LinearFunction *funcConfInvalidStateDev4 = new LinearFunction();
	+ funcConfInvalidStateDev4->setDomain(true, innerBoundSimDif, true,
	+ outerBoundSimDif);
	+ funcConfInvalidStateDev4->setKandD(innerBoundSimDif, (float)0,
	+ outerBoundSimDif, (float)1);
	+ confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev4);
	+ LinearFunction *funcConfInvalidStateDev5 = new LinearFunction();
	+ funcConfInvalidStateDev5->setDomain(true, outerBoundSimDif, false);
	+ funcConfInvalidStateDev5->setKandD((float)0, (float)1);
	+ confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev5);
	+#ifdef PRINT
	+ confInvalidStateDev->printFunctionBlock("funcBlock:confInvalidStateDev");
	+#endif // PRINT
	+
	+ // VALID STATE TIME
	+ LinearFunctionBlock *confValidStateTime =
	+ new LinearFunctionBlock("funcBlock:confValidStateTime");
	+ LinearFunction *funcConfValidStateTime1 = new LinearFunction();
	+ funcConfValidStateTime1->setDomain(false, true, (float)0);
	+ funcConfValidStateTime1->setKandD((float)0, (float)0);
	+ confValidStateTime->addLinearFunction(funcConfValidStateTime1);
	+ LinearFunction *funcConfValidStateTime2 = new LinearFunction();
	+ funcConfValidStateTime2->setDomain(true, (float)0, true,
	+ (float)boundTimeInSamples); // 10
	+ funcConfValidStateTime2->setKandD((float)0, (float)0,
	+ (float)boundTimeInSamples, (float)1);
	+ confValidStateTime->addLinearFunction(funcConfValidStateTime2);
	+ LinearFunction *funcConfValidStateTime3 = new LinearFunction();
	+ funcConfValidStateTime3->setDomain(true, (float)boundTimeInSamples, false);
	+ funcConfValidStateTime3->setKandD((float)0, (float)1);
	+ confValidStateTime->addLinearFunction(funcConfValidStateTime3);
	+#ifdef PRINT
	+ confValidStateTime->printFunctionBlock("funcBlock:confValidStateTime");
	+#endif // PRINT
	+
	+ // INVALID STATE TIME
	+ LinearFunctionBlock *confInvalidStateTime =
	+ new LinearFunctionBlock("funcBlock:confInvalidStateTime");
	+ LinearFunction *funcConfInvalidStateTime1 = new LinearFunction();
	+ funcConfInvalidStateTime1->setDomain(false, true, (float)0);
	+ funcConfInvalidStateTime1->setKandD((float)0, (float)1);
	+ confInvalidStateTime->addLinearFunction(funcConfInvalidStateTime1);
	+ LinearFunction *funcConfInvalidStateTime2 = new LinearFunction();
	+ funcConfInvalidStateTime2->setDomain(true, (float)0, true,
	+ (float)boundTimeInSamples);
	+ funcConfInvalidStateTime2->setKandD((float)0, (float)1,
	+ (float)boundTimeInSamples, (float)0);
	+ confInvalidStateTime->addLinearFunction(funcConfInvalidStateTime2);
	+ LinearFunction *funcConfInvalidStateTime3 = new LinearFunction();
	+ funcConfInvalidStateTime3->setDomain(true, (float)boundTimeInSamples, false);
	+ funcConfInvalidStateTime3->setKandD((float)0, (float)0);
	+ confInvalidStateTime->addLinearFunction(funcConfInvalidStateTime3);
	+#ifdef PRINT
	+ confInvalidStateTime->printFunctionBlock("funcBlock:confInvalidStateTime");
	+#endif // PRINT
	+
	+ /********************************** Functions NOT OK
	+ * **********************************/
	+
	+ LinearFunctionBlock *confStateDrifts =
	+ new LinearFunctionBlock("confidence:confStateDrifts");
	+ LinearFunction *functionConfidenceDriftDeviation1 = new LinearFunction();
	+ functionConfidenceDriftDeviation1->setDomain(false, true,
	+ -1 * outerBoundDrift);
	+ functionConfidenceDriftDeviation1->setKandD((float)0, (float)1);
	+ confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation1);
	+ LinearFunction *functionConfidenceDriftDeviation2 = new LinearFunction();
	+ functionConfidenceDriftDeviation2->setDomain(true, -1 * outerBoundDrift, true,
	+ -1 * innerBoundDrift);
	+ functionConfidenceDriftDeviation2->setKandD(-1 * outerBoundDrift, (float)1,
	+ -1 * innerBoundDrift, (float)0);
	+ confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation2);
	+ LinearFunction *functionConfidenceDriftDeviation3 = new LinearFunction();
	+ functionConfidenceDriftDeviation3->setDomain(true, -1 * innerBoundDrift, true,
	+ innerBoundDrift);
	+ functionConfidenceDriftDeviation3->setKandD((float)0, (float)0);
	+ confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation3);
	+ LinearFunction *functionConfidenceDriftDeviation4 = new LinearFunction();
	+ functionConfidenceDriftDeviation4->setDomain(true, innerBoundDrift, true,
	+ outerBoundDrift);
	+ functionConfidenceDriftDeviation4->setKandD(innerBoundDrift, (float)0,
	+ outerBoundDrift, (float)1);
	+ confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation4);
	+ LinearFunction *functionConfidenceDriftDeviation5 = new LinearFunction();
	+ functionConfidenceDriftDeviation5->setDomain(true, outerBoundDrift, false);
	+ functionConfidenceDriftDeviation5->setKandD((float)0, (float)1);
	+ confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation5);
	+#ifdef PRINT
	+ confStateDrifts.printFunctionBlock("confidence:confStateDrifts");
	+#endif
	+
	+ LinearFunctionBlock *confBroken =
	+ new LinearFunctionBlock("confidence:broken");
	+ LinearFunction *functionConfidenceBroken1 = new LinearFunction();
	+ functionConfidenceBroken1->setDomain(false, true, (float)0);
	+ functionConfidenceBroken1->setKandD((float)0, (float)0);
	+ confBroken->addLinearFunction(functionConfidenceBroken1);
	+ LinearFunction *functionConfidenceBroken2 = new LinearFunction();
	+ functionConfidenceBroken2->setDomain(true, (float)0, true,
	+ (float)boundBrokenTime);
	+ functionConfidenceBroken2->setKandD((float)0, (float)0,
	+ (float)boundBrokenTime, (float)1);
	+ confBroken->addLinearFunction(functionConfidenceBroken2);
	+ LinearFunction *functionConfidenceBroken3 = new LinearFunction();
	+ functionConfidenceBroken3->setDomain(true, (float)boundBrokenTime, false);
	+ functionConfidenceBroken3->setKandD((float)0, (float)1);
	+ confBroken->addLinearFunction(functionConfidenceBroken3);
	+#ifdef PRINT
	+ confBroken->printFunctionBlock("confidence:broken");
	+#endif // PRINT
	+
	+ /********************************** Mount Functions
	+ * **********************************/
	+ a_viabilityMonitor->get_stateHandler()->setMaxStateHistoryLength(
	+ boundTimeInSamples);
	+ a_viabilityMonitor->get_stateHandler()->setSimilarToStateFuzzyFunctions(
	+ confSim2StateDev, confSim2StateTime);
	+ a_viabilityMonitor->get_stateHandler()->setDifferentToStateFuzzyFunctions(
	+ confDif2StateDev, confDif2StateTime);
	+ a_viabilityMonitor->get_stateHandler()->setSimilarityInStateFuzzyFunctions(
	+ confValidStateDev, confValidStateTime);
	+ a_viabilityMonitor->get_stateHandler()->setUnsimilarityInStateFuzzyFunctions(
	+ confInvalidStateDev, confInvalidStateTime);
	+ a_viabilityMonitor->get_stateHandler()->setDriftFuzzyFunction(
	+ confStateDrifts);
	+ a_viabilityMonitor->get_stateHandler()->setBrokenFuzzyFunction(confBroken);
	+
	+
	+ // create testbench
	+ Testbench *tb = create_testbench("testbench");
	+
	+ // create CSV reader modules
	+ unsigned int ROW = 2;
	+ char csvPath[600];
	+ // inputs
	+#ifdef _WIN32
	+ sprintf_s(csvPath, "%s\\statorVoltage_abstracted.csv", datasetPath);
	+#else
	+ sprintf(csvPath, "%s/statorVoltage_abstracted.csv", datasetPath);
	+#endif // _WIN32
	+ CSVreaderModule *csvr_statorVoltage =
	+ create_CSVreaderModule("Stator Voltage CSV-Reader", csvPath, 2, ROW);
	+#ifdef _WIN32
	+ sprintf_s(csvPath, "%s\\frequency.csv", datasetPath);
	+#else
	+ sprintf(csvPath, "%s/frequency.csv", datasetPath);
	+#endif // _WIN32
	+ CSVreaderModule *csvr_inputFrequency =
	+ create_CSVreaderModule("Frequency CSV-Reader", csvPath, 2, ROW);
	+#ifdef _WIN32
	+ sprintf_s(csvPath, "%s\\mechanicalTorque.csv", datasetPath);
	+#else
	+ sprintf(csvPath, "%s/mechanicalTorque.csv", datasetPath);
	+#endif // _WIN32
	+ CSVreaderModule *csvr_mechanicalTorque =
	+ create_CSVreaderModule("Mechanical Torque CSV-Reader", csvPath, 2, ROW);
	+ // outputs
	+#ifdef _WIN32
	+ sprintf_s(csvPath, "%s\\statorCurrent_abstracted.csv", datasetPath);
	+#else
	+ sprintf(csvPath, "%s/statorCurrent_abstracted.csv", datasetPath);
	+#endif // _WIN32
	+ CSVreaderModule *csvr_statorCurrent =
	+ create_CSVreaderModule("Stator Current CSV-Reader", csvPath, 2, ROW);
	+#ifdef _WIN32
	+ sprintf_s(csvPath, "%s\\electromagneticTorque.csv", datasetPath);
	+#else
	+ sprintf(csvPath, "%s/electromagneticTorque.csv", datasetPath);
	+#endif // _WIN32
	+ CSVreaderModule *csvr_electromagneticTorque = create_CSVreaderModule(
	+ "Electromagnetic Torque CSV-Reader", csvPath, 2, ROW);
	+#ifdef _WIN32
	+ sprintf_s(csvPath, "%s\\speed.csv", datasetPath);
	+#else
	+ sprintf(csvPath, "%s/speed.csv", datasetPath);
	+#endif // _WIN32
	+ CSVreaderModule *csvr_speed =
	+ create_CSVreaderModule("Speed CSV-Reader", csvPath, 2, ROW);
	+
	+
	+
	+
	+ // register agents
	+ // low level agents - inputs
	+ register_agentInTestbench(tb, a_statorVoltage);
	+ register_agentInTestbench(tb, a_inputFrequency);
	+ register_agentInTestbench(tb, a_mechanicalTorque);
	+ // low level agents - outputs
	+ register_agentInTestbench(tb, a_statorCurrent);
	+ register_agentInTestbench(tb, a_electromagneticTorque);
	+ register_agentInTestbench(tb, a_speed);
	+ // high level agent
	+ register_agentInTestbench(tb, a_viabilityMonitor);
	+
	+ // register sensors with their csv-readers
	+ // inputs
	+ register_sensorInTestbench(tb, s_statorVoltage, csvr_statorVoltage);
	+ register_sensorInTestbench(tb, s_inputFrequency, csvr_inputFrequency);
	+ register_sensorInTestbench(tb, s_mechanicalTorque, csvr_mechanicalTorque);
	+ // outputs
	+ register_sensorInTestbench(tb, s_statorCurrent, csvr_statorCurrent);
	+ register_sensorInTestbench(tb, s_electromagneticTorque,
	+ csvr_electromagneticTorque);
	+ register_sensorInTestbench(tb, s_speed, csvr_speed);
	+
	+ // register sensor channels
	+ // sensor-agent channels
	+ // inputs
	+ register_channelInTestbench(tb, c_sa_statorVoltage);
	+ register_channelInTestbench(tb, c_sa_inputFrequency);
	+ register_channelInTestbench(tb, c_sa_mechanicalTorque);
	+ // outputs
	+ register_channelInTestbench(tb, c_sa_statorCurrent);
	+ register_channelInTestbench(tb, c_sa_electromagneticTorque);
	+ register_channelInTestbench(tb, c_sa_speed);
	+
	+ // agent-agent channels
	+ // inputs
	+ register_channelInTestbench(tb, c_aa_statorVoltage);
	+ register_channelInTestbench(tb, c_aa_inputFrequency);
	+ register_channelInTestbench(tb, c_aa_mechanicalTorque);
	+ // ouputs
	+ register_channelInTestbench(tb, c_aa_statorCurrent);
	+ register_channelInTestbench(tb, c_aa_speed);
	+ register_channelInTestbench(tb, c_aa_electromagneticTorque);
	+
	+#ifdef STOP_BEFORE_SIMULATING
	+ getchar();
	+#endif
	+
	+ tb->simulate(datasetLength);
	+}
	diff --git a/Version_Max_07_05_2018_CMake/src/configCAMforOldMotorSpeedChange.h b/Version_Max_07_05_2018_CMake/src/configCAMforOldMotorSpeedChange.h
	new file mode 100644
	index 0000000..4bc6d09
	--- /dev/null
	+++ b/Version_Max_07_05_2018_CMake/src/configCAMforOldMotorSpeedChange.h
	@@ -0,0 +1,11 @@
	+#ifndef HEADER_OLDMOTOR_SPEEDCHANGE_CONFIG
	+#define HEADER_OLDMOTOR_SPEEDCHANGE_CONFIG
	+
	+void configAndStartOldMotorSpeedChangeExperiment(
	+ char destinationPath, char datasetPath, char *datasetName,
	+ unsigned int datasetLength, float innerBoundSimDif, float outerBoundSimDif,
	+ int boundTimeInSamples, unsigned int discreteAveragePartitionSize,
	+ float innerBoundDrift, float outerBoundDrift, int boundBrokenTime,
	+ int downSamplingFactor);
	+
	+#endif
	\ No newline at end of file

File Metadata

Mime Type: text/x-diff
Expires: Sat, May 17, 7:55 PM (1 d, 19 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 141590
Default Alt Text: (152 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions