#include <SimpleEpEnergyManagement.h>

Inheritance diagram for inet::power::SimpleEpEnergyManagement:

Public Member Functions
virtual	~SimpleEpEnergyManagement ()

virtual IEnergyStorage *	getEnergyStorage () const override
	Returns the energy storage that is managed by this energy management. More...

virtual J	getEstimatedEnergyCapacity () const override
	Returns the estimated energy capacity in the range [0, +infinity). More...

virtual void	receiveSignal (cComponent source, simsignal_t signal, double value, cObject details) override

Public Member Functions inherited from inet::power::IEnergyManagement
virtual	~IEnergyManagement ()

Protected Member Functions
virtual void	initialize (int stage) override

virtual void	handleMessage (cMessage *message) override

virtual void	executeNodeOperation (J estimatedEnergyCapacity)

virtual void	scheduleLifecycleOperationTimer ()

Protected Attributes
J	nodeShutdownCapacity = J(NaN)

J	nodeStartCapacity = J(NaN)

IEpEnergyStorage *	energyStorage = nullptr

LifecycleController *	lifecycleController = nullptr

cModule *	networkNode = nullptr

NodeStatus *	nodeStatus = nullptr

cMessage *	lifecycleOperationTimer = nullptr

Constructor & Destructor Documentation

inet::power::SimpleEpEnergyManagement::~SimpleEpEnergyManagement ( )

virtual

 {
     cancelAndDelete(lifecycleOperationTimer);
 }

Member Function Documentation

void inet::power::SimpleEpEnergyManagement::executeNodeOperation ( J estimatedEnergyCapacity )

protectedvirtual

Referenced by handleMessage(), and receiveSignal().

 {
     if (!std::isnan(nodeShutdownCapacity.get()) && estimatedEnergyCapacity <= nodeShutdownCapacity && nodeStatus->getState() == NodeStatus::UP) {
         EV_WARN << "Capacity reached node shutdown threshold" << endl;
         LifecycleOperation::StringMap params;
         NodeShutdownOperation *operation = new NodeShutdownOperation();
         operation->initialize(networkNode, params);
         lifecycleController->initiateOperation(operation);
     }
     else if (!std::isnan(nodeStartCapacity.get()) && estimatedEnergyCapacity >= nodeStartCapacity && nodeStatus->getState() == NodeStatus::DOWN) {
         EV_INFO << "Capacity reached node start threshold" << endl;
         LifecycleOperation::StringMap params;
         NodeStartOperation *operation = new NodeStartOperation();
         operation->initialize(networkNode, params);
         lifecycleController->initiateOperation(operation);
     }
 }

virtual IEnergyStorage* inet::power::SimpleEpEnergyManagement::getEnergyStorage ( ) const

inlineoverridevirtual

Returns the energy storage that is managed by this energy management.

This function never returns nullptr.

Implements inet::power::IEnergyManagement.

54 { return energyStorage; }

inet::power::SimpleEpEnergyManagement::energyStorage

IEpEnergyStorage * energyStorage

Definition: SimpleEpEnergyManagement.h:36

J inet::power::SimpleEpEnergyManagement::getEstimatedEnergyCapacity ( ) const

overridevirtual

Returns the estimated energy capacity in the range [0, +infinity).

It specifies the amount of energy that the energy storage contains at the moment according to the estimation of the management.

Implements inet::power::IEpEnergyManagement.

Referenced by handleMessage(), receiveSignal(), and scheduleLifecycleOperationTimer().

 {
     // NOTE: cheat with estimation and return the actual energy capacity known by the energy storage
     return energyStorage->getResidualEnergyCapacity();
 }

void inet::power::SimpleEpEnergyManagement::handleMessage ( cMessage * message )

overrideprotectedvirtual

 {
     if (message == lifecycleOperationTimer) {
         executeNodeOperation(getEstimatedEnergyCapacity());
         scheduleLifecycleOperationTimer();
     }
     else
         throw cRuntimeError("Unknown message");
 }

void inet::power::SimpleEpEnergyManagement::initialize ( int stage )

overrideprotectedvirtual

 {
     if (stage == INITSTAGE_LOCAL) {
         nodeShutdownCapacity = J(par("nodeShutdownCapacity"));
         nodeStartCapacity = J(par("nodeStartCapacity"));
         networkNode = findContainingNode(this);
         energyStorage = check_and_cast<IEpEnergyStorage *>(networkNode->getSubmodule("energyStorage"));
         auto energyStorageModule = check_and_cast<cModule *>(energyStorage);
         energyStorageModule->subscribe(IEpEnergySource::powerConsumptionChangedSignal, this);
         energyStorageModule->subscribe(IEpEnergySink::powerGenerationChangedSignal, this);
         nodeStatus = dynamic_cast<NodeStatus *>(networkNode->getSubmodule("status"));
         if (!nodeStatus)
             throw cRuntimeError("Cannot find node status");
         lifecycleController = dynamic_cast<LifecycleController *>(getModuleByPath("lifecycleController"));
         if (!lifecycleController)
             throw cRuntimeError("Cannot find lifecycle controller");
         lifecycleOperationTimer = new cMessage("lifecycleOperation");
     }
 }

void inet::power::SimpleEpEnergyManagement::receiveSignal	(	cComponent *	source,
		simsignal_t	signal,
		double	value,
		cObject *	details
	)

overridevirtual

 {
     Enter_Method("receiveSignal");
     if (signal == IEpEnergySource::powerConsumptionChangedSignal || signal == IEpEnergySink::powerGenerationChangedSignal) {
         executeNodeOperation(getEstimatedEnergyCapacity());
         scheduleLifecycleOperationTimer();
     }
 }

void inet::power::SimpleEpEnergyManagement::scheduleLifecycleOperationTimer ( )

protectedvirtual

Referenced by handleMessage(), and receiveSignal().

 {
     J targetCapacity = J(NaN);
     J estimatedResidualCapacity = getEstimatedEnergyCapacity();
     W totalPower = energyStorage->getTotalPowerGeneration() - energyStorage->getTotalPowerConsumption();
     if (totalPower > W(0)) {
         // override target capacity if start is needed
         if (!std::isnan(nodeStartCapacity.get()) && nodeStatus->getState() == NodeStatus::DOWN && estimatedResidualCapacity < nodeStartCapacity)
             targetCapacity = nodeStartCapacity;
     }
     else if (totalPower < W(0)) {
         // override target capacity if shutdown is needed
         if (!std::isnan(nodeShutdownCapacity.get()) && nodeStatus->getState() == NodeStatus::UP && estimatedResidualCapacity > nodeShutdownCapacity)
             targetCapacity = nodeShutdownCapacity;
     }
     // enforce target capacity to be in range
     simtime_t remainingTime = unit((targetCapacity - estimatedResidualCapacity) / totalPower / s(1)).get();
     if (lifecycleOperationTimer->isScheduled())
         cancelEvent(lifecycleOperationTimer);
     // don't schedule if there's no progress
     if (remainingTime > 0)
         scheduleAt(simTime() + remainingTime, lifecycleOperationTimer);
 }