How to record results in omnet++

Question

I try to record the values of electricityConsumption. For that I build the NED file like this:

simple EConsumerRSF
{
    parameters:
        volatile xml ElectricityConsumptionRSFLoadProfile;
        volatile double sendIaTime @unit(s);
        @signal[electricityConsumption](type="double");
        @statistics[electricityConsumption](title="Electricity Consumption RSF Unit 1";source="electricityConsumption"; record=vector,stats; interpolationmode=none);
        
        
    gates:
        output outElectricityConsumptionRSF;
}

My c++ class and header file looks like this:

#ifndef __VISIONSIMULATIONOFPED_ECONSUMERRSF_H_
#define __VISIONSIMULATIONOFPED_ECONSUMERRSF_H_

#include <omnetpp.h>
#include <stdio.h>
#include <string.h>
//#include "EConsumptionRSFMessage_m.h"

using namespace omnetpp;

namespace network {

/**
 * Network EConsumerRSF; see NED file for more info.
 */
//class EConsumerRSF : public EConsumptionRSFMessage
class EConsumerRSF : public cSimpleModule
{
    public:
        EConsumerRSF();
        virtual ~EConsumerRSF();

    protected:
      virtual void initialize() override;
      virtual void handleMessage(cMessage *msg) override;
     // virtual void setValEConsumption(double valEConsumption);

    private:
      int counterSend = 1;
      int counterMessage = 1;

      double valEConsumption1;
      double valEConsumption2;
      double valEConsumption3;
      double valEConsumption4;

      simsignal_t electricityConsumptionSingnalId;
      //double electricityConsumption;

      double valEConsumption;
      double aggregationOfElectricityConsumptionRSF = 0;

      cMessage *endTxEvent;
      cMessage *EConsumptionRSFMessage;

};
}; //namespace
#endif

#include "EConsumerRSF.h"
#include <stdio.h>
#include <string.h>
//#include "EConsumptionRSFMessage_m.h"

using namespace omnetpp;

namespace network {

Define_Module(EConsumerRSF);

EConsumerRSF::EConsumerRSF()
{
    endTxEvent = nullptr;
}

EConsumerRSF::~EConsumerRSF()
{
    cancelAndDelete(endTxEvent);
}

void EConsumerRSF::initialize()
{
    electricityConsumptionSingnalId = registerSignal("electricityConsumption");
    //Get param XMLElectricity file from simple module
    cXMLElement *rootelementEConsumption = par("ElectricityConsumptionRSFLoadProfile");
    cXMLElementList paramsEConsumption = rootelementEConsumption->getChildrenByTagName("param");
    //Loop to iterate through all elements called param
    for (const auto & element : paramsEConsumption) {
        const char* valueEConsumption = element->getNodeValue();
        valEConsumption = atof(valueEConsumption);
        EV << "Read value: " << valEConsumption << std::endl;
        if (valEConsumption > 0.0) {
            //Calculation of electricity supply through utility
            aggregationOfElectricityConsumptionRSF = aggregationOfElectricityConsumptionRSF + valEConsumption;
        }
        switch(counterMessage)
        {
        case 1:
            valEConsumption1 = valEConsumption;
            counterMessage++;
            break;
        case 2:
            valEConsumption2 = valEConsumption;
            counterMessage++;
            break;
        case 3:
            valEConsumption3 = valEConsumption;
            counterMessage++;
            break;
        case 4:
            valEConsumption4 = valEConsumption;
            counterMessage++;
            break;
        }
    }
    EConsumptionRSFMessage = new cMessage("valEConsumption");
    endTxEvent = new cMessage("send/endTx");
    scheduleAt(simTime(), endTxEvent);

}

void EConsumerRSF::handleMessage(cMessage *msg)
{
    // Check if self message is received
    if(endTxEvent->isSelfMessage()){
        if(counterSend <= 4){
        switch(counterSend)
        {
        case 1:
            if(valEConsumption1 > 0.0){
                double electricityConsumption = valEConsumption1;
                emit(electricityConsumptionSingnalId, electricityConsumption);
            send(EConsumptionRSFMessage->dup(), "outElectricityConsumptionRSF");
            }else{
                double electricityConsumption = 0.0000000;
                emit(electricityConsumptionSingnalId, electricityConsumption);
            }
            counterSend++;
            scheduleAt(simTime()+par("sendIaTime").doubleValue(), endTxEvent);
            break;
        case 2:
            if(valEConsumption2 > 0.0){
                double electricityConsumption = valEConsumption2;
                emit(electricityConsumptionSingnalId, electricityConsumption);
            send(EConsumptionRSFMessage->dup(), "outElectricityConsumptionRSF");
            }else{
                 double electricityConsumption = 0.0000000;
                 emit(electricityConsumptionSingnalId, electricityConsumption);
            }
            counterSend++;
            scheduleAt(simTime()+par("sendIaTime").doubleValue(), endTxEvent);
            break;
        case 3:
            if(valEConsumption3 > 0.0){
                double electricityConsumption = valEConsumption3;
                emit(electricityConsumptionSingnalId, electricityConsumption);
            send(EConsumptionRSFMessage->dup(), "outElectricityConsumptionRSF");
            }else{
                double electricityConsumption = 0.0000000;
                emit(electricityConsumptionSingnalId, electricityConsumption);
           }
            counterSend++;
            scheduleAt(simTime()+par("sendIaTime").doubleValue(), endTxEvent);
            break;
        case 4:
            if(valEConsumption4 > 0.0){
                double electricityConsumption = valEConsumption4;
                emit(electricityConsumptionSingnalId, electricityConsumption);
            send(EConsumptionRSFMessage->dup(), "outElectricityConsumptionRSF");
            }else{
                double electricityConsumption = 0.0000000;
                emit(electricityConsumptionSingnalId, electricityConsumption);
           }
            counterSend++;
            //cancelEvent(endTxEvent);
            scheduleAt(simTime()+par("sendIaTime").doubleValue(), endTxEvent);
            break;
        default:
            cancelEvent(endTxEvent);
            break;
        }
    }else {
        throw cRuntimeError("self-message not delivered");
        cancelEvent(endTxEvent);
}
}
}
}; //namespace

and I enabled the recording in the .ini file like this:

[Config EConsumerRSF]
**.serviceTime = 1s
**.electricityConsumption.result-recording-modes = -vector

It does not even build the .vec file when I run the simulation. What am I doing wrong? Is it not possible to record results in handleMessage()? Or do I miss something?

Could please someone help me with this issue?

Thanks in advance!

Answer 1

There are two mistakes in the presented code:

1. In NED should be @statistic (instead of @statistics).

2. Actually in omnetpp.ini in the line:

   **.electricityConsumption.result-recording-modes = -vector
   

   you have turned off recording of vectors (a minus sign means disabling). To turn on recording of vector change it to +vector or simply remove this line.