metavis/metavis/RunData.cpp

#include "pch.h"
#include "RunData.h"
#include <QDebug>
#include <QString>
#include <regex>



RunData::RunData()
{
}

RunData::RunData(std::string filePath): fileStream(filePath)
{
    if (!fileStream.is_open())
    {
        //Cant open file
        badFileFlag = true;
        return;
    }
    /* Start extracting */
    while (fileStream.peek() != EOF) {
        std::string buffer;
        getLine(buffer);
        //qDebug() << "Line[" << actualLine << "]:" << QString::fromStdString(buffer);
        SolutionPointData sol;

        std::regex regexIter("i:([\\+\\-]?\\d+)");
        std::regex regexObjectiveFunction("of:([\\+\\-]?\\d+\\.\\d+(?:E[\\+\\-]\\d+)?)");
        std::smatch match;
        if (!std::regex_search(buffer, match, regexIter)) {
            qDebug() << "Bad formatatted Line[" << actualLine << "].";
            qDebug() << "Failed to matched:";
            qDebug() << QString::fromStdString(buffer);
            return;
        }
        sol.iteration = std::stoi(match[1]);
        if (!std::regex_search(buffer, match, regexObjectiveFunction)) {
            qDebug() << "Bad formatatted Line[" << actualLine << "].";
            qDebug() << "Failed to matched:";
            qDebug() << QString::fromStdString(buffer);
            return;
        }
        sol.objectiveFunction = std::stod(match[1]);
        std::regex regexParticleNumber("pN:([\\+\\-]?\\d+)");
        if (!std::regex_search(buffer, match, regexParticleNumber)) {
            qDebug() << "Bad formatatted Line[" << actualLine << "].";
            qDebug() << "Failed to matched:";
            qDebug() << QString::fromStdString(buffer);
            return;
        }
        sol.particleNumber = std::stoi(match[1]);
        solutionVec.push_back(sol);
    }
    fileStream.close();
    calculateBestAndAverageIter();
    calculateParticleSolution();
    calculateDotsForDistribution();
}

void RunData::getLine(std::string& bufferString)
{
    //std::getline(fileStream, bufferString);
    std::getline(fileStream, bufferString);
    actualLine++;
}

void RunData::calculateBestAndAverageIter()
{
    if (solutionVec.empty()) {
        return;
    }
    double minObjectiveFunctionInIter = solutionVec[0].objectiveFunction;
    double maxObjectiveFunctionInIter = solutionVec[0].objectiveFunction;
    double bestObjectiveFunctionFound = solutionVec[0].objectiveFunction;
    double actualIterObjectiveFunctionAggregate = solutionVec[0].objectiveFunction;
    int actualIter = solutionVec[0].iteration;
    int foundSolutionInIteration = 1; 
    for(int i = 1; i < solutionVec.size(); i++) {
        SolutionPointData nextData = solutionVec[i];
        if (nextData.iteration != actualIter) {
            //save last
            bestSolutionPerIteration.push_back(QPointF((double)actualIter, bestObjectiveFunctionFound));
            averageSolutionPerItertion.push_back(QPointF((double)actualIter, actualIterObjectiveFunctionAggregate / (double)foundSolutionInIteration));
            minSolutionPerItertion.push_back(QPointF((double)actualIter, minObjectiveFunctionInIter));
            maxSolutionPerItertion.push_back(QPointF((double)actualIter, maxObjectiveFunctionInIter));
            //init new iteration
            actualIter = nextData.iteration;
            foundSolutionInIteration = 1;
            actualIterObjectiveFunctionAggregate = nextData.objectiveFunction;
            minObjectiveFunctionInIter = nextData.objectiveFunction;
            maxObjectiveFunctionInIter = nextData.objectiveFunction;
        }
        else {
            //increae aggregate
            foundSolutionInIteration++;
            actualIterObjectiveFunctionAggregate += nextData.objectiveFunction;
        }
        //update best min and max if better
        if (nextData.objectiveFunction < bestObjectiveFunctionFound) {
            bestObjectiveFunctionFound = nextData.objectiveFunction;
        }
        if (nextData.objectiveFunction < minObjectiveFunctionInIter) {
            minObjectiveFunctionInIter = nextData.objectiveFunction;
        }
        if (nextData.objectiveFunction > maxObjectiveFunctionInIter) {
            maxObjectiveFunctionInIter = nextData.objectiveFunction;
        }
    }
    //save last iteration
    bestSolutionPerIteration.push_back(QPointF((double)actualIter, bestObjectiveFunctionFound));
    averageSolutionPerItertion.push_back(QPointF((double)actualIter, actualIterObjectiveFunctionAggregate / (double)foundSolutionInIteration));
    minSolutionPerItertion.push_back(QPointF((double)actualIter, minObjectiveFunctionInIter));
    maxSolutionPerItertion.push_back(QPointF((double)actualIter, maxObjectiveFunctionInIter));


}

void RunData::calculateParticleSolution()
{
    for (SolutionPointData sol : solutionVec) {
        QPointF point(sol.iteration, sol.objectiveFunction);
        auto iter = particleMap.find(sol.particleNumber);
        if (iter == particleMap.end()) {
            //create new Entry
            std::vector<QPointF> vec;
            vec.push_back(point);
            particleMap.insert({ sol.particleNumber, vec});
        }
        else {
            //append to vector in Entry
            iter->second.push_back(point);
        }
    }
    /*for (auto iter = std::begin(particleMap); iter != std::end(particleMap); iter++) {
        qDebug() << "List with pN[" << iter->first << "]:";
        for (QPointF point : iter->second) {
                qDebug() << point;
        }
    }*/
}

void RunData::calculateDotsForDistribution()
{
    for (SolutionPointData sol : solutionVec) {
        dotsForDistribution.push_back(QPointF((double)sol.iteration, sol.objectiveFunction));
    }
}