network.h

Go to the documentation of this file.

#ifndef NeTrainSim_Network_h
#define NeTrainSim_Network_h
 
 
// Get all required libraries and files
#include <cmath>
#include <fstream>
#include <sstream>
#include <regex>
#include <cstdlib>
#include "../util/vector.h"
#include <unordered_set>
#include <set>
#include "netnode.h"
#include "netlink.h"
#include "netsignal.h"
#include "../traindefinition/train.h"
#include "../util/utils.h"
#include "../util/error.h"
#include "readwritenetwork.h"
 
class Network {
private:
    Vector<std::shared_ptr<NetNode>> theFileNodes;
public:
    std::string networkName;
    std::map<int, std::shared_ptr<NetNode>> nodes;
    Vector<std::shared_ptr<NetLink>> links;
    Vector<std::shared_ptr<NetSignal>> networkSignals;
 
    Network(){}
 
    Network(const string& nodesFile, const string& linksFile,
            std::string netName = "") {
        if (netName == "") {
            this->networkName = Utils::getPrefix(Utils::trim(
                Utils::getFilenameWithoutExtension(linksFile)));
        }
        else {
            this->networkName = netName;
        }
        auto nodesRecords = ReadWriteNetwork::readNodesFile(nodesFile);
        this->theFileNodes = ReadWriteNetwork::generateNodes(nodesRecords);
        auto linksRecords = ReadWriteNetwork::readLinksFile(linksFile);
        this->links = ReadWriteNetwork::generateLinks(this->theFileNodes,
                                                      linksRecords);
        updateLinksLength();
        defineNodesLinks();
        this->nodes = defineNodes();
        //this->AdjMatrix = defineAdjMatrix();
        this->networkSignals = generateSignals();
 
    }
 
    Network(Vector<tuple<int, double, double,
                         std::string, double, double>> nodesRecords,
            Vector<tuple<int, int, int, double,
                         int, double, double, int, double,
                         bool, std::string, std::string,
                         double>> linksRecords,
            std::string netName = "") {
 
        if (netName == "") {
            this->networkName = "Unnamed Network";
        }
        else {
            this->networkName = netName;
        }
        this->theFileNodes = ReadWriteNetwork::generateNodes(nodesRecords);
        this->links = ReadWriteNetwork::generateLinks(this->theFileNodes,
                                                      linksRecords);
        updateLinksLength();
        defineNodesLinks();
        this->nodes = defineNodes();
        //this->AdjMatrix = defineAdjMatrix();
        this->networkSignals = generateSignals();
    }
 
    Network(Vector<std::shared_ptr<NetNode>> theNodes,
            Vector<std::shared_ptr<NetLink>> theLinks,
            std::string netName = "") {
        if (netName == "") {
            this->networkName = "Unnamed Network";
        }
        else {
            this->networkName = netName;
        }
        this->theFileNodes = theNodes;
        this->links = theLinks;
        updateLinksLength();
        defineNodesLinks();
        this->nodes = defineNodes();
        //this->AdjMatrix = defineAdjMatrix();
        this->networkSignals = generateSignals();
    }
 
 
    std::map<int, std::shared_ptr<NetNode>> defineNodes() {
        std::map<int, std::shared_ptr<NetNode>> nodesMap;
        for (std::shared_ptr<NetNode> &n : (this->theFileNodes)) {
            nodesMap[n->id] = n;
        }
        return nodesMap;
    }
 
    Vector<int> getSimulatorTrainPath(Vector<int> userDefinedTrainPath) {
        Vector<int> simulatorTrainPath;
        for (int i = 0; i < userDefinedTrainPath.size(); i++) {
            simulatorTrainPath.push_back(getSimulatorNodeIDByUserID((
                userDefinedTrainPath)[i]));
        }
        return simulatorTrainPath;
    }
 
    tuple<double, double, double, double, double> getNetworkStats() {
        double catenaryCumConsumed = 0.0;
        double catenaryCumRegenerated = 0.0;
        int nuOfCatenaryLinks = 0;
        double totalLength = 0.0;
        double totalLinkLengthsWithCatenary = 0.0;
        for (auto& link: this->links) {
            if (link->hasCatenary) {
                nuOfCatenaryLinks += 1;
                totalLinkLengthsWithCatenary += link->length;
            }
            catenaryCumConsumed += link->catenaryCumConsumedEnergy;
            catenaryCumRegenerated += link->catenaryCumRegeneratedEnergy;
            totalLength += link->length;
        }
        double percOfCatenaryLinks = (nuOfCatenaryLinks / this->links.size()) *
                                                    100.0;
        return std::make_tuple(percOfCatenaryLinks, catenaryCumConsumed,
                               catenaryCumRegenerated, totalLength,
                               totalLinkLengthsWithCatenary);
    }
 
    std::shared_ptr<NetNode> getNodeByID(int& id) {
        if (this->nodes.count(id)) {
            return this->nodes[id];
        }
        throw std::runtime_error(std::string("Error: ") +
                                     std::to_string(static_cast<int>(
                                                Error::cannotFindNode)) +
                                 "\nCould not find the simulator node ID: " +
                                 std::to_string(id) + "\n");
    }
 
    double getDistanceBetweenTwoNodes(std::shared_ptr <Train> train,
                                      std::shared_ptr<NetNode> node1,
                                      std::shared_ptr<NetNode> node2) {
        if (node1 == node2) { return 0.0; }
        int i1 = train->trainPathNodes.index(node1);
        int i2 = train->trainPathNodes.index(node2);
        if (i1 > i2) { swap(i1, i2); }
        double l = 0;
        for (int i = i1; i < i2; i++) {
            int nextI = i + 1;
            l += getLinkByStartandEndNodeID(train,
                                            train->trainPathNodes.at(i)->id,
                                            train->trainPathNodes.at(nextI)->id,
                                            true)->length;
        }
        return l;
    }
 
    bool isConflictZone(std::shared_ptr<Train> train,
                        std::shared_ptr<NetNode> node1,
                        std::shared_ptr<NetNode> node2) {
        // Get indices of nodes in train path
        int n1 = train->trainPathNodes.index(node1);
        int n2 = train->trainPathNodes.index(node2);
 
        // Ensure n1 is less than n2
        if (n1 > n2) { swap(n1, n2); }
 
        for (int i = n1; i < n2; i++) {
            // Get links between consecutive nodes
            int nextI = i + 1;
            Vector<std::shared_ptr<NetLink>> l1 =
                train->trainPathNodes.at(
                       i)->linkTo[train->trainPathNodes.at(nextI)];
            Vector<std::shared_ptr<NetLink>> l2 =
                train->trainPathNodes.at(
                       nextI)->linkTo[train->trainPathNodes.at(i)];
 
            // Add links to a set
            std::set<std::shared_ptr<NetLink>> temp;
            if (l1.size() > 0) { temp.insert(l1.begin(), l1.end()); }
            if (l2.size() > 0){ temp.insert(l2.begin(), l2.end()); }
 
            // Check if only one link exists
            if (temp.size() <= 1) { return true; }
        }
 
        // If more than one link exists between any pair of nodes, return false
        return false;
    }
 
 
 
    bool DistanceToEndOfAllLinkTrainsIsLarge(
        const std::shared_ptr <NetLink> link,
        const std::shared_ptr <Train> train)
    {
        // Store distances to other trains on the same link
        std::set<double> distanceToOtherTrains;
 
        // Compute distances for each train on the link
        for (std::shared_ptr <Train>& t : link->currentTrains) {
            if (t != train) {
                distanceToOtherTrains.insert(
                    Utils::getDistanceByTwoCoordinates(
                        t->startEndPoints[1],
                        train->currentCoordinates));
            }
        }
        // Check if any distance is less than 2
        return std::find_if(distanceToOtherTrains.begin(),
                            distanceToOtherTrains.end(),
                            [](int v) {
                                return v < 2;
                            }) == distanceToOtherTrains.end();
    }
 
 
    pair<double, double> getPositionbyTravelledDistance(
                std::shared_ptr <Train> train,
                double &travelledDistance) {
 
        // If the train has not moved, its position is the coordinates of the
        // first node in its path.
        if (travelledDistance <= 0.0) {
            return train->trainPathNodes[0]->coordinates();
        }
 
        // If the train has moved more than or equal to its total path length,
        // its position is the coordinates of the last node in its path.
        if (travelledDistance >= train->trainTotalPathLength) {
            return train->trainPathNodes.back()->coordinates();
        }
 
        // Traverse the train path
        for (int i = 0; i < train->trainPath.size() - 1; i++) {
            // Check if travelled distance is between the cumulative
            // lengths of consecutive links
            if (travelledDistance > train->linksCumLengths[i] &&
                (i == train->trainPath.size() - 2 ||
                      travelledDistance <= train->linksCumLengths[i+1])) {
                int nextI = i + 1;
 
                // Get the start node and the link on which the train is
                // currently on
                std::shared_ptr<NetNode> startNode = train->trainPathNodes[i];
                std::shared_ptr<NetLink> link =
                    getLinkByStartandEndNodeID(train, train->trainPath[i],
                                                train->trainPath[nextI], true);
 
                // Calculate the distance travelled on the current link
                double travelledDistanceOnLink =
                    travelledDistance - train->linksCumLengths[i];
 
                // Calculate and return the position on the current vector
                // based on the distance travelled on the link
                return link->findPositionOnLink(travelledDistanceOnLink,
                                                startNode);
            }
        }
        // If travelledDistance does not fall within any link's cumulative
        // lengths, return (0.0, 0.0)
        return std::make_pair(0.0, 0.0);
    }
 
    std::pair<double, double> normalize(std::pair<double, double> vec) {
        double length = sqrt(vec.first * vec.first + vec.second * vec.second);
        if(length == 0)
            return vec;
        return {vec.first / length, vec.second / length};
    }
 
 
    Vector< std::shared_ptr<NetSignal>> getSignalsByCurrentNodeList(
                        const std::vector<std::shared_ptr<NetNode>> nodeList) {
        Vector<std::shared_ptr<NetSignal>> sgnls;
        for (const auto& node : nodeList) {
            for (const auto& s : this->networkSignals) {
                if (s->currentNode.lock() == node) {
                    sgnls.push_back(s);
                }
            }
        }
        return sgnls;
    }
 
    std::shared_ptr<NetLink> getLinkByStartandEndNodeID(
                                const std::shared_ptr<Train> train,
                                int startID,
        int endID, bool calcExact = true) {
        Vector<std::shared_ptr<NetLink>> betweenNodesLinks =
            this->getNodeByID(startID)->linkTo.at(this->getNodeByID(endID));
        if (betweenNodesLinks.size() == 1) {
            return betweenNodesLinks.at(0);
        }
 
        // If there is more than one link, find the one that currently contains
        // the train
        for (std::shared_ptr<NetLink> l : betweenNodesLinks) {
            if (l->currentTrains.exist(train)) {
                return l;
            }
        }
 
        // If the train is not on any of the links, sort the links by cost and
        // potentially return the one with the lowest cost
        Vector<std::shared_ptr<NetLink>> betweenNLinks(
            betweenNodesLinks.begin(),
            betweenNodesLinks.end());
        std::sort(betweenNLinks.begin(), betweenNLinks.end(),
                  [](std::shared_ptr<NetLink> a, std::shared_ptr<NetLink> b) {
                        return a->cost < b->cost; });
        if (!calcExact) {
            return betweenNLinks[0];
        }
 
        // If calcExact is true, find a link where the train can travel without
        // colliding with other trains
        for (std::shared_ptr <NetLink> l : betweenNLinks) {
            if (l->currentTrains.empty() || (isSameDirection(l, train) &&
                           DistanceToEndOfAllLinkTrainsIsLarge(l, train))) {
                return l;
            }
        }
        return betweenNLinks[0];
 
    }
 
    Vector<std::shared_ptr<NetLink>> getLinksByStartandEndNode(
                                            std::shared_ptr<NetNode> startNode,
                                            std::shared_ptr<NetNode> endNode) {
        return startNode->linkTo.at(endNode);
    }
 
    double getFullPathLength(std::shared_ptr <Train> train) {
        double l = 0.0;
        int prevI = 0;
        for (int i = 1; i < train->trainPath.size(); i++) {
            prevI = i - 1;
            l += getLinkByStartandEndNodeID(train, train->trainPath.at(prevI),
                                            train->trainPath.at(i),
                                            false)->length;
        }
        return l;
    }
 
    std::shared_ptr <NetLink> getLinkByStartNodeID(
                const std::shared_ptr <Train> train,
                int startNodeID) {
        int i = train->trainPath.index(startNodeID);
        if (i < train->trainPath.size() - 1) {
            int indx = i + 1;
            int EndNodeID = train->trainPath.at(indx);
            return getLinkByStartandEndNodeID(train, startNodeID, EndNodeID);
        }
        return nullptr;
    }
 
    std::shared_ptr<NetLink> getFirstTrainLink(
                                const std::shared_ptr <Train> train) {
        if (train->trainPath.size() == 0) {
            throw std::runtime_error("Error: " +
                                     std::to_string(
                                            static_cast<int>(
                                                Error::trainPathCannotBeNull)) +
                                     "\n Train" +
                                     std::to_string(train->id) +
                                     " path cannot be null!\n");
        }
        else {
            int strartID = train->trainPath.at(0);
            return getLinkByStartNodeID(train, strartID);
        }
    }
 
    Vector<double> generateCumLinksLengths(std::shared_ptr<Train> train) {
        int n = train->trainPath.size();
        Vector<double> linksCumLengths(n, 0);
        for (int i = 1; i < n; i++) {
            linksCumLengths[i] =
                getDistanceToSpecificNodeFromStart(train,
                                                   train->trainPath.at(i));
        }
        return linksCumLengths;
    }
 
    std::shared_ptr <NetNode> getPreviousNodeByDistance(
                                    std::shared_ptr<Train> train,
                                    double travelledDistance,
                                    int &previousNodeID) {
        int nextI = -1;
        for (int i = train->trainPath.index(previousNodeID);
                                    train->trainPath.size(); i++) {
            if (train->linksCumLengths.at(i) > travelledDistance) {
                nextI = i;
                break;
            }
        }
        if (nextI == -1) { nextI = train->trainPath.size(); }
        int prevI = nextI - 1;
        return train->trainPathNodes.at(prevI);
    }
 
    std::shared_ptr <NetLink> getLinkFromDistance(std::shared_ptr <Train> train,
                                                 double &travelledDistance,
                                                 int &previousNodeID) {
        int nextI = -1;
        for (int i = train->trainPath.index(previousNodeID);
                                            train->trainPath.size(); i++) {
            if (train->linksCumLengths.at(i) > travelledDistance) {
                nextI = i;
                break;
            }
        }
        if (nextI == -1) { nextI = train->trainPath.size(); }
        int prevI = nextI - 1;
        return this->getLinkByStartandEndNodeID(train,
                                                train->trainPath.at(prevI),
                                                train->trainPath.at(nextI),
                                                true);
    }
 
    int getSimulatorNodeIDByUserID(int oldID) {
        for (const std::shared_ptr<NetNode>& n : this->theFileNodes) {
            if (n->userID == oldID) {
                return n->id;
            }
        }
        throw std::runtime_error(std::string("Error: ") +
                                     std::to_string(static_cast<int>(
                                                       Error::cannotFindNode)) +
                                     "\nCould not find the node ID: " +
                                 std::to_string(oldID) + "\n");
    }
 
 
    double getDistanceToSpecificNodeByTravelledDistance(
                    std::shared_ptr<Train> train,
                    double& travelledDistance,
                    int& nodeID) {
        int endNodeIndex = train->trainPath.index(nodeID);
        return train->linksCumLengths[endNodeIndex] - travelledDistance;
    }
 
    bool ccw(const std::pair<double, double>& A,
             const std::pair<double, double>& B,
        const std::pair<double, double>& C) {
        return (C.second - A.second) *
                   (B.first - A.first) > (B.second - A.second) *
                                                        (C.first - A.first);
    }
 
    bool twoLinesIntersect(const std::pair<double, double>& A,
                           const std::pair<double, double>& B,
        const std::pair<double, double>& C,
                           const std::pair<double, double>& D) {
        return (ccw(A, C, D) != ccw(B, C, D)) && (ccw(A, B, C) != ccw(A, B, D));
    }
 
    std::pair<Vector<std::shared_ptr<NetNode>>, double> shortestPathSearch(
                    int startNodeID, int targetNodeID) {
        // clear all the nodes for the new sheart path
        for (auto& n : this->nodes) {
            n.second->clearGraphSearchParams();
        }
        // get the nodes by their user id's
        std::shared_ptr<NetNode> startNode = this->getNodeByID(startNodeID);
        std::shared_ptr<NetNode> targetNode = this->getNodeByID(targetNodeID);
        // override the inf value of the start node
        startNode->graphSearchDistanceFromStart = 0.0;
 
        // keep looping until the target node is reached
        while (! targetNode->graphSearchVisited) {
            // get the min-distance-unvisited node
            std::shared_ptr<NetNode> currentNode = minimumDistance();
            // if nothing was found, break
            if (currentNode == nullptr) { break; }
            // set the node as visited
            currentNode->graphSearchVisited = true;
            // check all the connected links/nodes
            for (auto& connectedNode : currentNode->getNeighbors()) {
                // check if a new node has a lower value
                if ((currentNode->graphSearchDistanceFromStart +
                    currentNode->linkTo.at(connectedNode).at(0)->length) <
                            connectedNode->graphSearchDistanceFromStart) {
                    // set the value
                    connectedNode->graphSearchDistanceFromStart =
                        currentNode->graphSearchDistanceFromStart +
                            currentNode->linkTo.at(connectedNode).at(0)->length;
                    connectedNode->graphSearchPreviousNode = currentNode;
                }
            }
        }
 
        Vector<std::shared_ptr<NetNode>> path;
        path.push_back(targetNode);
        while (true) {
            std::shared_ptr<NetNode> node = path.back();
            if (node->graphSearchPreviousNode == nullptr) { break; }
            //if (path.exist(node->graphSearchPreviousNode)) { break; }
            path.push_back(node->graphSearchPreviousNode);
        }
        std::reverse(path.begin(), path.end());
        return std::make_pair(path, targetNode->graphSearchDistanceFromStart);
    }
 
 
 
    //************************************************************************
    // Private functions
    // ***********************************************************************
private:
 
    std::shared_ptr<NetNode> minimumDistance() {
        std::shared_ptr<NetNode> nextNode = std::shared_ptr<NetNode>();
        double minValue = INFINITY;
        for (auto& node : this->nodes) {
            if (node.second->graphSearchDistanceFromStart < minValue &&
                node.second->graphSearchVisited == false) {
                minValue = node.second->graphSearchDistanceFromStart;
                nextNode = node.second;
            }
        }
        return nextNode;
    }
// ##################################################################
// #               start: read data and organize it                 #
// ##################################################################
 
 
    Vector<std::shared_ptr<NetSignal>> generateSignals() {
        Vector<std::shared_ptr<NetSignal>> networkSignals;
        //signals.reserve(links.size());
        for (const std::shared_ptr<NetLink> &l : this->links) {
            if (l->trafficSignalNo != 0 && l->trafficSignalNo != 10001) {
                if (l->direction == 1) {
                    // if the link should have a signal at end point
                    if (l->trafficSignalAtEnd.exist(l->toLoc->userID)) {
                        NetSignal networkSignal = NetSignal(l->trafficSignalNo,
                                                            l,
                                                            l->fromLoc,
                                                            l->toLoc);
                        std::shared_ptr<NetSignal> sharedSignal =
                            std::make_shared<NetSignal>(networkSignal);
                        l->toLoc->addSignal(sharedSignal);
                        networkSignals.push_back(sharedSignal);
                    }
                    // if the link should have a signal at start point
                    if (l->trafficSignalAtEnd.exist(l->fromLoc->userID)) {
                        NetSignal networkSignal = NetSignal(l->trafficSignalNo,
                                                            l,
                                                            l->toLoc,
                                                            l->fromLoc);
                        std::shared_ptr<NetSignal> sharedSignal =
                            std::make_shared<NetSignal>(networkSignal);
                        l->fromLoc->addSignal(sharedSignal);
                        networkSignals.push_back(sharedSignal);
                    }
                }
                else {
                    // if the link should have a signal at end point
                    if (l->trafficSignalAtEnd.exist(l->toLoc->userID)) {
                        NetSignal networkSignal1 = NetSignal(l->trafficSignalNo,
                                                             l,
                                                             l->fromLoc,
                                                             l->toLoc);
                        std::shared_ptr<NetSignal> sharedSignal1 =
                            std::make_shared<NetSignal>(networkSignal1);
                        l->toLoc->addSignal(sharedSignal1);
                        networkSignals.push_back(sharedSignal1);
                    }
                    // if the link should have a signal at start point
                    if (l->trafficSignalAtEnd.exist(l->fromLoc->userID)) {
                        NetSignal networkSignal2 = NetSignal(l->trafficSignalNo,
                                                             l,
                                                             l->toLoc,
                                                             l->fromLoc);
                        std::shared_ptr<NetSignal> sharedSignal2 =
                            std::make_shared<NetSignal>(networkSignal2);
                        l->fromLoc->addSignal(sharedSignal2);
                        networkSignals.push_back(sharedSignal2);
                        //networkSignals.push_back(sharedSignal2);
                    }
                }
                
            }
            else if (l->trafficSignalNo == 10001){
                l->toLoc->isDepot = true;
            }
        }
        return networkSignals;
    }
 
    void defineNodesLinks() {
        for (std::shared_ptr<NetLink>& l : this->links) {
            if (l->direction == 1){ 
                l->fromLoc.get()->linkTo[l->toLoc].push_back(l);
                //l->fromLoc.get()->linkTo.at(l->toLoc).push_back(l);
            }
            else {
                l->fromLoc.get()->linkTo[l->toLoc].push_back(l);
                l->toLoc.get()->linkTo[l->fromLoc].push_back(l);
                //l->fromLoc.get()->linkTo.at(l->toLoc).push_back(l);
                //l->toLoc.get()->linkTo.at(l->fromLoc).push_back(l);
            }
            
        }
    }
 
 
    void updateLinksLength() {
        for (std::shared_ptr<NetLink> &l : this->links) {
            std::shared_ptr<NetNode> n1 = l->fromLoc;
            std::shared_ptr<NetNode> n2 = l->toLoc;
            double dx = n2->x - n1->x;
            double dy = n2->y - n1->y;
            double lLength = sqrt(dx * dx + dy * dy);
            if (lLength <= 0) {
                throw std::runtime_error("Error: " +
                                         std::to_string(static_cast<int>(
                                             Error::wrongLinksLength)) +
                                         "\nHorizontal distance between nodes" +
                                         " should be greater than 0!" +
                                         "\nReview the nodes file!... " +
                                         std::to_string(l->id) +
                                         "'s length is equal to zero!\n");
            }
            l->length = lLength;
        }
    }
 
// ##################################################################
// #                 end: read data and organize it                 #
// ##################################################################
 
    bool isSameDirection(std::shared_ptr<NetLink> link,
                         std::shared_ptr <Train> train) {
        std::set<bool> allTrainsAreInSameDirection;
        for (const std::shared_ptr<Train>& t : link->currentTrains) {
            if (t != train) {
                allTrainsAreInSameDirection.insert(
                    std::is_permutation(t->trainPath.begin(),
                                        t->trainPath.end(),
                                        train->trainPath.begin(),
                                        train->trainPath.end()));
            }
        }
        return !allTrainsAreInSameDirection.count(false);
    }
 
    double getDistanceToSpecificNodeFromStart(std::shared_ptr<Train> train,
                                              int nodeID) {
        double l = 0;
        for (int i = 1; i < train->trainPath.size(); i++) {
            int prevI = i - 1;
            l += getLinkByStartandEndNodeID(train,
                                            train->trainPath.at(prevI),
                                            train->trainPath.at(i),
                                            true)->length;
            if (train->trainPath.at(i) == nodeID) {
                return l;
            }
        }
        return l;
    }
 
    friend ostream& operator<<(ostream& ostr, Network& stud) {
        ostr << "the network has " << stud.nodes.size() << " nodes and " <<
            stud.links.size() << "links." << endl;
        return ostr;
    }
 
};
 
#endif // !NeTrainSim_Network_h