configCAMforFluid.cpp
No OneTemporary
Actions

Size

23 KB

Referenced Files

None

Subscribers

None

configCAMforFluid.cpp
View Options

	#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);
	}

File Metadata

Mime Type: text/x-c
Expires: Sun, Mar 1, 5:52 PM (4 h, 36 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 287208
Default Alt Text: configCAMforFluid.cpp (23 KB)

configCAMforFluid.cppNo OneTemporaryActions

configCAMforFluid.cppView Options

File Metadata

Event Timeline

configCAMforFluid.cpp
No OneTemporary
Actions

configCAMforFluid.cpp
View Options