ODMatrix.h

Go to the documentation of this file.

/****************************************************************************/
// An O/D (origin/destination) matrix
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
// Copyright (C) 2006-2017 DLR (http://www.dlr.de/) and contributors
/****************************************************************************/
//
//   This file is part of SUMO.
//   SUMO is free software: you can redistribute it and/or modify
//   it under the terms of the GNU General Public License as published by
//   the Free Software Foundation, either version 3 of the License, or
//   (at your option) any later version.
//
/****************************************************************************/
#ifndef ODMatrix_h
#define ODMatrix_h


// ===========================================================================
// included modules
// ===========================================================================
#ifdef _MSC_VER
#include <windows_config.h>
#else
#include <config.h>
#endif

#include <iostream>
#include <sstream>
#include <fstream>
#include <vector>
#include <cstdlib>
#include <ctime>
#include <algorithm>
#include <set>
#include <string>
#include <utils/common/SUMOTime.h>
#include "ODCell.h"
#include "ODDistrictCont.h"
#include <utils/distribution/Distribution_Points.h>
#include <utils/importio/LineReader.h>
#include <utils/common/SUMOTime.h>

// ===========================================================================
// class declarations
// ===========================================================================
class OutputDevice;
class SUMOSAXHandler;


// ===========================================================================
// class definitions
// ===========================================================================
class ODMatrix {
public:
    ODMatrix(const ODDistrictCont& dc);


    ~ODMatrix();


    bool add(double vehicleNumber, SUMOTime begin,
             SUMOTime end, const std::string& origin, const std::string& destination,
             const std::string& vehicleType);

    bool add(const std::string& id, const SUMOTime depart,
             const std::pair<const std::string, const std::string>& od,
             const std::string& vehicleType);

    void writeDefaultAttrs(OutputDevice& dev, const bool noVtype,
                           const ODCell* const cell);

    void write(SUMOTime begin, const SUMOTime end,
               OutputDevice& dev, const bool uniform,
               const bool differSourceSink, const bool noVtype,
               const std::string& prefix, const bool stepLog,
               bool pedestrians, bool persontrips);


    void writeFlows(const SUMOTime begin, const SUMOTime end,
                    OutputDevice& dev, const bool noVtype,
                    const std::string& prefix,
                    bool asProbability = false);


    double getNumLoaded() const;


    double getNumWritten() const;


    double getNumDiscarded() const;


    void applyCurve(const Distribution_Points& ps);


    void readO(LineReader& lr, double scale,
               std::string vehType, bool matrixHasVehType);

    void readV(LineReader& lr, double scale,
               std::string vehType, bool matrixHasVehType);

    void loadMatrix(OptionsCont& oc);

    void loadRoutes(OptionsCont& oc, SUMOSAXHandler& handler);

    Distribution_Points parseTimeLine(const std::vector<std::string>& def, bool timelineDayInHours);

    const std::vector<ODCell*>& getCells() {
        return myContainer;
    }

    void sortByBeginTime();

protected:
    struct ODVehicle {
        std::string id;
        SUMOTime depart;
        ODCell* cell;
        std::string from;
        std::string to;

    };


    double computeDeparts(ODCell* cell,
                          int& vehName, std::vector<ODVehicle>& into,
                          const bool uniform, const bool differSourceSink,
                          const std::string& prefix);


    void applyCurve(const Distribution_Points& ps, ODCell* cell,
                    std::vector<ODCell*>& newCells);


private:
    std::string getNextNonCommentLine(LineReader& lr);

    SUMOTime parseSingleTime(const std::string& time);

    std::pair<SUMOTime, SUMOTime> readTime(LineReader& lr);

    double readFactor(LineReader& lr, double scale);


private:
    std::vector<ODCell*> myContainer;

    std::map<const std::pair<const std::string, const std::string>, std::vector<ODCell*> > myShortCut;

    const ODDistrictCont& myDistricts;

    std::set<std::string> myMissingDistricts;

    double myNumLoaded;

    double myNumWritten;

    double myNumDiscarded;


    class cell_by_begin_comparator {
    public:
        explicit cell_by_begin_comparator() { }


        int operator()(ODCell* p1, ODCell* p2) const {
            if (p1->begin == p2->begin) {
                if (p1->origin == p2->origin) {
                    return p1->destination < p2->destination;
                }
                return p1->origin < p2->origin;
            }
            return p1->begin < p2->begin;
        }

    };


    class descending_departure_comperator {
    public:
        descending_departure_comperator() { }


        bool operator()(const ODVehicle& p1, const ODVehicle& p2) const {
            if (p1.depart == p2.depart) {
                return p1.id > p2.id;
            }
            return p1.depart > p2.depart;
        }

    };

private:
    ODMatrix(const ODMatrix& s);

    ODMatrix& operator=(const ODMatrix& s);

};


#endif

/****************************************************************************/